// DO NOT EDIT.
//
// Generated by the Swift generator plugin for the protocol buffer compiler.
// Source: generated_swift_names_enums.proto
//
// For information on using the generated types, please see the documenation:
//   https://github.com/apple/swift-protobuf/

/// See Makefile for the logic that generates this
/// Protoc errors imply this file is being generated incorrectly
/// Swift compile errors are probably bugs in protoc-gen-swift

import Foundation
import SwiftProtobuf

// If the compiler emits an error on this type, it is because this file
// was generated by a version of the `protoc` Swift plug-in that is
// incompatible with the version of SwiftProtobuf to which you are linking.
// Please ensure that your are building against the same version of the API
// that was used to generate this file.
fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
  struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {}
  typealias Version = _2
}

struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum adjusted: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAdjusted // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAdjusted
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAdjusted
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAdjusted: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum allCases: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAllCases // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAllCases
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAllCases
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAllCases: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum allocate: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAllocate // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAllocate
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAllocate
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAllocate: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum alwaysPrintEnumsAsInts: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAlwaysPrintEnumsAsInts // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAlwaysPrintEnumsAsInts
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAlwaysPrintEnumsAsInts
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAlwaysPrintEnumsAsInts: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum any: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAny // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAny
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAny
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAny: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum AnyExtensionField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAnyExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAnyExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAnyExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAnyExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum AnyMessageExtension: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAnyMessageExtension // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAnyMessageExtension
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAnyMessageExtension
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAnyMessageExtension: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum AnyMessageStorage: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAnyMessageStorage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAnyMessageStorage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAnyMessageStorage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAnyMessageStorage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum AnyUnpackError: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAnyUnpackError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAnyUnpackError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAnyUnpackError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAnyUnpackError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Api: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneApi // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneApi
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneApi
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneApi: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum appended: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAppended // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAppended
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAppended
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAppended: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum appendUIntHex: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAppendUintHex // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAppendUintHex
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAppendUintHex
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAppendUintHex: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum appendUnknown: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAppendUnknown // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAppendUnknown
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAppendUnknown
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAppendUnknown: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum areAllInitialized: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAreAllInitialized // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAreAllInitialized
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAreAllInitialized
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAreAllInitialized: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum array: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneArray // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneArray
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneArray
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneArray: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum arrayLiteral: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneArrayLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneArrayLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneArrayLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneArrayLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum arraySeparator: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneArraySeparator // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneArraySeparator
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneArraySeparator
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneArraySeparator: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum asEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAs // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAs
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAs
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAs: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum asciiOpenCurlyBracket: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAsciiOpenCurlyBracket // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAsciiOpenCurlyBracket
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAsciiOpenCurlyBracket
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAsciiOpenCurlyBracket: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum asciiZero: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAsciiZero // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAsciiZero
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAsciiZero
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAsciiZero: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum assumingMemoryBound: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAssumingMemoryBound // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAssumingMemoryBound
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAssumingMemoryBound
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAssumingMemoryBound: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum available: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneAvailable // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAvailable
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAvailable
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAvailable: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum b: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneB // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneB
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneB
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneB: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum base64Values: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBase64Values // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBase64Values
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBase64Values
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBase64Values: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum baseAddress: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBaseAddress // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBaseAddress
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBaseAddress
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBaseAddress: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum BaseType: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBaseType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBaseType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBaseType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBaseType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum binary: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBinary // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinary
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinary
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinary: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum BinaryDecoder: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBinaryDecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryDecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryDecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryDecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum BinaryDecodingError: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBinaryDecodingError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryDecodingError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryDecodingError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryDecodingError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum BinaryDecodingOptions: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBinaryDecodingOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryDecodingOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryDecodingOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryDecodingOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum BinaryDelimited: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBinaryDelimited // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryDelimited
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryDelimited
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryDelimited: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum BinaryEncoder: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBinaryEncoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryEncoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryEncoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryEncoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum BinaryEncodingError: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBinaryEncodingError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryEncodingError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryEncodingError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryEncodingError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum BinaryEncodingMessageSetSizeVisitor: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBinaryEncodingMessageSetSizeVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryEncodingMessageSetSizeVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryEncodingMessageSetSizeVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryEncodingMessageSetSizeVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum BinaryEncodingMessageSetVisitor: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBinaryEncodingMessageSetVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryEncodingMessageSetVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryEncodingMessageSetVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryEncodingMessageSetVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum BinaryEncodingSizeVisitor: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBinaryEncodingSizeVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryEncodingSizeVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryEncodingSizeVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryEncodingSizeVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum BinaryEncodingVisitor: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBinaryEncodingVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryEncodingVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryEncodingVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryEncodingVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum body: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBody // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBody
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBody
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBody: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum bodySize: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBodySize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBodySize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBodySize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBodySize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum BoolEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBool // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBool
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBool
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBool: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum booleanLiteral: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBooleanLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBooleanLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBooleanLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBooleanLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum BooleanLiteralType: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBooleanLiteralType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBooleanLiteralType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBooleanLiteralType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBooleanLiteralType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum boolValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBoolValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBoolValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBoolValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBoolValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum buffer: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBuffer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBuffer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBuffer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBuffer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum bytes: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum bytesInGroup: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBytesInGroup // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBytesInGroup
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBytesInGroup
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBytesInGroup: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum bytesRead: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBytesRead // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBytesRead
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBytesRead
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBytesRead: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum BytesValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneBytesValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBytesValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBytesValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBytesValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum c: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneC // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneC
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneC
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneC: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum capacity: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneCapacity // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCapacity
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCapacity
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCapacity: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum capitalizeNext: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneCapitalizeNext // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCapitalizeNext
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCapitalizeNext
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCapitalizeNext: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum cardinality: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneCardinality // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCardinality
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCardinality
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCardinality: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Character: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneCharacter // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCharacter
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCharacter
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCharacter: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum chars: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneChars // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneChars
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneChars
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneChars: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum classEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneClass // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClass
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClass
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClass: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum clearExtensionValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneClearExtensionValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearExtensionValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearExtensionValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearExtensionValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum clearSourceContext: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneClearSourceContext // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearSourceContext
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearSourceContext
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearSourceContext: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum clearValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneClearValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum codeUnits: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneCodeUnits // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCodeUnits
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCodeUnits
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCodeUnits: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Collection: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneCollection // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCollection
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCollection
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCollection: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum com: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneCom // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCom
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCom
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCom: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum comma: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneComma // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneComma
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneComma
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneComma: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum contentsOf: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneContentsOf // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneContentsOf
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneContentsOf
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneContentsOf: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum count: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneCount // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCount
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCount
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCount: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum countVarintsInBuffer: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneCountVarintsInBuffer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCountVarintsInBuffer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCountVarintsInBuffer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCountVarintsInBuffer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum customCodable: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneCustomCodable // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCustomCodable
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCustomCodable
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCustomCodable: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum CustomDebugStringConvertible: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneCustomDebugStringConvertible // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCustomDebugStringConvertible
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCustomDebugStringConvertible
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCustomDebugStringConvertible: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum d: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneD // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneD
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneD
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneD: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum DataEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneData // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneData
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneData
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneData: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum dataResult: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDataResult // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDataResult
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDataResult
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDataResult: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum dataSize: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDataSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDataSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDataSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDataSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum date: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDate // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDate
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDate
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDate: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum daySec: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDaySec // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDaySec
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDaySec
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDaySec: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum daysSinceEpoch: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDaysSinceEpoch // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDaysSinceEpoch
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDaysSinceEpoch
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDaysSinceEpoch: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum debugDescriptionEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDebugDescription // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDebugDescription
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDebugDescription
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDebugDescription: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decoded: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecoded // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecoded
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecoded
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecoded: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodedFromJSONNull: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodedFromJsonnull // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodedFromJsonnull
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodedFromJsonnull
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodedFromJsonnull: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeExtensionField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeExtensionFieldsAsMessageSet: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeExtensionFieldsAsMessageSet // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeExtensionFieldsAsMessageSet
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeExtensionFieldsAsMessageSet
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeExtensionFieldsAsMessageSet: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeJSON: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeJson // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeJson
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeJson
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeJson: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeMapField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeMapField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeMapField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeMapField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeMapField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeMessageEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeMessage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeMessage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeMessage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeMessage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decoder: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeated: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeated // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeated
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeated
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeated: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedBoolField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedBoolField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedBoolField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedBoolField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedBoolField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedBytesField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedBytesField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedBytesField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedBytesField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedBytesField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedDoubleField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedDoubleField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedDoubleField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedDoubleField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedDoubleField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedEnumField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedEnumField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedEnumField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedEnumField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedEnumField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedFixed32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedFixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedFixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedFixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedFixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedFixed64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedFixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedFixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedFixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedFixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedFloatField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedFloatField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedFloatField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedFloatField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedFloatField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedGroupField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedGroupField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedGroupField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedGroupField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedGroupField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedInt32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedInt32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedInt32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedInt32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedInt32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedInt64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedInt64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedInt64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedInt64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedInt64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedMessageField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedMessageField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedMessageField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedMessageField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedMessageField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedSFixed32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedSfixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedSfixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedSfixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedSfixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedSFixed64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedSfixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedSfixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedSfixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedSfixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedSInt32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedSint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedSint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedSint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedSint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedSInt64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedSint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedSint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedSint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedSint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedStringField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedStringField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedStringField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedStringField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedStringField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedUInt32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedUint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedUint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedUint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedUint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeRepeatedUInt64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeRepeatedUint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedUint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedUint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedUint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingular: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingular // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingular
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingular
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingular: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularBoolField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularBoolField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularBoolField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularBoolField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularBoolField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularBytesField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularBytesField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularBytesField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularBytesField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularBytesField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularDoubleField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularDoubleField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularDoubleField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularDoubleField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularDoubleField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularEnumField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularEnumField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularEnumField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularEnumField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularEnumField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularFixed32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularFixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularFixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularFixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularFixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularFixed64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularFixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularFixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularFixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularFixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularFloatField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularFloatField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularFloatField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularFloatField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularFloatField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularGroupField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularGroupField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularGroupField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularGroupField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularGroupField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularInt32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularInt32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularInt32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularInt32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularInt32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularInt64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularInt64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularInt64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularInt64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularInt64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularMessageField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularMessageField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularMessageField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularMessageField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularMessageField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularSFixed32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularSfixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularSfixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularSfixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularSfixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularSFixed64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularSfixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularSfixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularSfixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularSfixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularSInt32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularSint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularSint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularSint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularSint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularSInt64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularSint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularSint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularSint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularSint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularStringField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularStringField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularStringField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularStringField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularStringField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularUInt32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularUint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularUint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularUint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularUint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeSingularUInt64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeSingularUint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularUint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularUint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularUint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum decodeTextFormat: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDecodeTextFormat // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeTextFormat
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeTextFormat
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeTextFormat: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum defaultAnyTypeURLPrefix: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDefaultAnyTypeUrlprefix // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDefaultAnyTypeUrlprefix
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDefaultAnyTypeUrlprefix
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDefaultAnyTypeUrlprefix: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum defaultValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDefaultValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDefaultValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDefaultValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDefaultValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum descriptionEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDescription // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDescription
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDescription
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDescription: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Dictionary: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDictionary // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDictionary
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDictionary
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDictionary: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum dictionaryLiteral: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDictionaryLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDictionaryLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDictionaryLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDictionaryLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum digit: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDigit // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDigit
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDigit
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDigit: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum digit0: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDigit0 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDigit0
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDigit0
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDigit0: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum digit1: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDigit1 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDigit1
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDigit1
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDigit1: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum digitCount: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDigitCount // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDigitCount
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDigitCount
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDigitCount: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum digits: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDigits // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDigits
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDigits
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDigits: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum digitValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDigitValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDigitValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDigitValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDigitValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum discardableResult: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDiscardableResult // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDiscardableResult
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDiscardableResult
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDiscardableResult: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum discardUnknownFields: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDiscardUnknownFields // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDiscardUnknownFields
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDiscardUnknownFields
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDiscardUnknownFields: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum distance: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDistance // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDistance
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDistance
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDistance: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum double: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDouble // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDouble
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDouble
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDouble: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum doubleToUtf8: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDoubleToUtf8 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDoubleToUtf8
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDoubleToUtf8
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDoubleToUtf8: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum DoubleValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDoubleValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDoubleValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDoubleValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDoubleValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Duration: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneDuration // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDuration
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDuration
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDuration: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum E: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneE // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneE
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneE
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneE: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Element: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneElement // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneElement
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneElement
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneElement: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum elements: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneElements // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneElements
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneElements
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneElements: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum emitExtensionFieldName: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEmitExtensionFieldName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEmitExtensionFieldName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEmitExtensionFieldName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEmitExtensionFieldName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum emitFieldName: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEmitFieldName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEmitFieldName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEmitFieldName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEmitFieldName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum emitFieldNumber: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEmitFieldNumber // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEmitFieldNumber
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEmitFieldNumber
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEmitFieldNumber: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Empty: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEmpty // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEmpty
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEmpty
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEmpty: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum emptyData: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEmptyData // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEmptyData
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEmptyData
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEmptyData: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum encoded: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEncoded // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEncoded
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEncoded
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEncoded: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum encodedJSONString: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEncodedJsonstring // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEncodedJsonstring
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEncodedJsonstring
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEncodedJsonstring: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum encodedSize: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEncodedSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEncodedSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEncodedSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEncodedSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum encodeField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEncodeField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEncodeField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEncodeField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEncodeField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum encoder: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEncoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEncoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEncoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEncoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum end: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEnd // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEnd
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEnd
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEnd: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum endArray: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEndArray // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEndArray
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEndArray
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEndArray: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum endMessageField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEndMessageField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEndMessageField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEndMessageField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEndMessageField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum endObject: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEndObject // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEndObject
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEndObject
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEndObject: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum endRegularField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEndRegularField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEndRegularField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEndRegularField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEndRegularField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum enumEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEnum // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEnum
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEnum
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEnum: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum enumvalue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEnumvalue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEnumvalue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEnumvalue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEnumvalue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Equatable: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneEquatable // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEquatable
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEquatable
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEquatable: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Error: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ExpressibleByArrayLiteral: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneExpressibleByArrayLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExpressibleByArrayLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExpressibleByArrayLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExpressibleByArrayLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ExpressibleByDictionaryLiteral: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneExpressibleByDictionaryLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExpressibleByDictionaryLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExpressibleByDictionaryLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExpressibleByDictionaryLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ext: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneExt // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExt
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExt
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExt: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum extDecoder: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneExtDecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtDecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtDecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtDecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum extendedGraphemeClusterLiteral: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneExtendedGraphemeClusterLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtendedGraphemeClusterLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtendedGraphemeClusterLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtendedGraphemeClusterLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ExtendedGraphemeClusterLiteralType: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneExtendedGraphemeClusterLiteralType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtendedGraphemeClusterLiteralType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtendedGraphemeClusterLiteralType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtendedGraphemeClusterLiteralType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ExtensibleMessage: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneExtensibleMessage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtensibleMessage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtensibleMessage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtensibleMessage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ExtensionField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum extensionFieldNumber: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneExtensionFieldNumber // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtensionFieldNumber
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtensionFieldNumber
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtensionFieldNumber: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ExtensionFieldValueSet: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneExtensionFieldValueSet // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtensionFieldValueSet
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtensionFieldValueSet
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtensionFieldValueSet: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ExtensionMap: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneExtensionMap // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtensionMap
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtensionMap
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtensionMap: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum extensions: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneExtensions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtensions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtensions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtensions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum extras: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneExtras // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtras
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtras
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtras: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum f: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneF // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneF
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneF
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneF: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum falseEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFalse // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFalse
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFalse
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFalse: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum fieldData: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFieldData // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldData
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldData
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldData: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum FieldMask: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFieldMask // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldMask
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldMask
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldMask: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum fieldName: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFieldName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum fieldNameCount: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFieldNameCount // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldNameCount
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldNameCount
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldNameCount: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum fieldNum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFieldNum // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldNum
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldNum
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldNum: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum fieldNumber: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFieldNumber // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldNumber
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldNumber
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldNumber: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum fieldNumberForProto: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFieldNumberForProto // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldNumberForProto
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldNumberForProto
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldNumberForProto: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum fields: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFields // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFields
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFields
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFields: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum fieldSize: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFieldSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum FieldTag: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFieldTag // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldTag
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldTag
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldTag: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum fieldType: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFieldType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum fieldValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFieldValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum fileName: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFileName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFileName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFileName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFileName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum filter: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFilter // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFilter
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFilter
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFilter: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum firstItem: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFirstItem // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFirstItem
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFirstItem
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFirstItem: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum float: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFloat // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFloat
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFloat
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFloat: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum floatLiteral: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFloatLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFloatLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFloatLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFloatLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum FloatLiteralType: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFloatLiteralType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFloatLiteralType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFloatLiteralType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFloatLiteralType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum floatToUtf8: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFloatToUtf8 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFloatToUtf8
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFloatToUtf8
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFloatToUtf8: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum FloatValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFloatValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFloatValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFloatValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFloatValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum forMessageName: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneForMessageName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneForMessageName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneForMessageName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneForMessageName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum formUnion: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFormUnion // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFormUnion
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFormUnion
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFormUnion: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum forReadingFrom: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneForReadingFrom // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneForReadingFrom
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneForReadingFrom
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneForReadingFrom: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum forTypeURL: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneForTypeURL // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneForTypeURL
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneForTypeURL
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneForTypeURL: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ForwardParser: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneForwardParser // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneForwardParser
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneForwardParser
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneForwardParser: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum forWritingInto: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneForWritingInto // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneForWritingInto
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneForWritingInto
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneForWritingInto: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum from: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFrom // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFrom
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFrom
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFrom: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum fromAscii2: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFromAscii2 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFromAscii2
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFromAscii2
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFromAscii2: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum fromAscii4: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFromAscii4 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFromAscii4
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFromAscii4
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFromAscii4: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum fromHexDigit: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFromHexDigit // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFromHexDigit
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFromHexDigit
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFromHexDigit: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum funcEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneFunc // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFunc
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFunc
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFunc: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum G: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneG // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneG
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneG
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneG: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum get: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGet // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGet
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGet
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGet: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum getExtensionValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGetExtensionValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGetExtensionValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGetExtensionValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGetExtensionValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum googleapis: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleapis // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleapis
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleapis
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleapis: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_Any: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufAny // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufAny
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufAny
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufAny: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_Api: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufApi // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufApi
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufApi
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufApi: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_BoolValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufBoolValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufBoolValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufBoolValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufBoolValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_BytesValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufBytesValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufBytesValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufBytesValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufBytesValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_DoubleValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufDoubleValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufDoubleValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufDoubleValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufDoubleValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_Duration: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufDuration // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufDuration
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufDuration
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufDuration: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_Empty: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufEmpty // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufEmpty
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufEmpty
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufEmpty: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_Enum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufEnum // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufEnum
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufEnum
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufEnum: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_EnumValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufEnumValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufEnumValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufEnumValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufEnumValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_FieldMask: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufFieldMask // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufFieldMask
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufFieldMask
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufFieldMask: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_FloatValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufFloatValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufFloatValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufFloatValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufFloatValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_Int32Value: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufInt32Value // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufInt32Value
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufInt32Value
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufInt32Value: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_Int64Value: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufInt64Value // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufInt64Value
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufInt64Value
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufInt64Value: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_ListValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufListValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufListValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufListValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufListValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_Method: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufMethod // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufMethod
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufMethod
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufMethod: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_Mixin: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufMixin // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufMixin
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufMixin
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufMixin: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_NullValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufNullValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufNullValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufNullValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufNullValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_Option: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufOption // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufOption
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufOption
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufOption: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_SourceContext: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufSourceContext // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufSourceContext
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufSourceContext
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufSourceContext: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_StringValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufStringValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufStringValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufStringValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufStringValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_Struct: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufStruct // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufStruct
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufStruct
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufStruct: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_Syntax: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufSyntax // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufSyntax
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufSyntax
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufSyntax: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_Timestamp: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufTimestamp // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufTimestamp
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufTimestamp
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufTimestamp: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_Type: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_UInt32Value: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufUint32Value // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufUint32Value
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufUint32Value
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufUint32Value: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_UInt64Value: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufUint64Value // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufUint64Value
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufUint64Value
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufUint64Value: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Google_Protobuf_Value: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGoogleProtobufValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum group: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGroup // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGroup
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGroup
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGroup: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum groupSize: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneGroupSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGroupSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGroupSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGroupSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum h: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneH // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneH
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneH
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneH: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum handleConflictingOneOf: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneHandleConflictingOneOf // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHandleConflictingOneOf
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHandleConflictingOneOf
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHandleConflictingOneOf: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum hasExtensionValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneHasExtensionValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasExtensionValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasExtensionValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasExtensionValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum hash: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneHash // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHash
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHash
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHash: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Hashable: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneHashable // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHashable
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHashable
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHashable: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum hasher: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneHasher // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasher
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasher
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasher: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum hashValueEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneHashValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHashValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHashValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHashValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum HashVisitor: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneHashVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHashVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHashVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHashVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum hasSourceContext: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneHasSourceContext // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasSourceContext
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasSourceContext
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasSourceContext: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum hasValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneHasValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum hour: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneHour // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHour
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHour
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHour: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum i: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneI // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneI
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneI
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneI: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ignoreUnknownFields: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneIgnoreUnknownFields // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIgnoreUnknownFields
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIgnoreUnknownFields
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIgnoreUnknownFields: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum index: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneIndex // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIndex
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIndex
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIndex: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum initEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneInit // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInit
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInit
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInit: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum inoutEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneInout // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInout
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInout
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInout: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum insert: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneInsert // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInsert
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInsert
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInsert: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum IntEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneInt // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInt
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInt
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInt: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Int32Enum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneInt32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInt32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInt32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInt32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Int32Value: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneInt32Value // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInt32Value
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInt32Value
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInt32Value: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Int64Enum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneInt64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInt64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInt64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInt64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Int64Value: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneInt64Value // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInt64Value
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInt64Value
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInt64Value: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Int8: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneInt8 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInt8
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInt8
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInt8: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum integerLiteral: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneIntegerLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIntegerLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIntegerLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIntegerLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum IntegerLiteralType: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneIntegerLiteralType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIntegerLiteralType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIntegerLiteralType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIntegerLiteralType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum intern: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneIntern // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIntern
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIntern
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIntern: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Internal: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneInternal // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInternal
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInternal
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInternal: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum InternalState: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneInternalState // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInternalState
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInternalState
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInternalState: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum into: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneInto // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInto
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInto
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInto: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ints: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneInts // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInts
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInts
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInts: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum isA: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneIsA // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIsA
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIsA
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIsA: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum isEqual: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneIsEqual // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIsEqual
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIsEqual
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIsEqual: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum isEqualTo: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneIsEqualTo // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIsEqualTo
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIsEqualTo
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIsEqualTo: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum isInitializedEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneIsInitialized // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIsInitialized
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIsInitialized
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIsInitialized: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum itemTagsEncodedSize: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneItemTagsEncodedSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneItemTagsEncodedSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneItemTagsEncodedSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneItemTagsEncodedSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum i_2166136261: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneI2166136261 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneI2166136261
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneI2166136261
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneI2166136261: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum JSONDecoder: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneJsondecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsondecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsondecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsondecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum JSONDecodingError: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneJsondecodingError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsondecodingError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsondecodingError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsondecodingError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum JSONDecodingOptions: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneJsondecodingOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsondecodingOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsondecodingOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsondecodingOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum jsonEncoder: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneJsonEncoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonEncoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonEncoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonEncoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum JSONEncodingError: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneJsonencodingError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonencodingError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonencodingError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonencodingError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum JSONEncodingOptions: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneJsonencodingOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonencodingOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonencodingOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonencodingOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum JSONEncodingVisitor: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneJsonencodingVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonencodingVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonencodingVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonencodingVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum JSONMapEncodingVisitor: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneJsonmapEncodingVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonmapEncodingVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonmapEncodingVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonmapEncodingVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum jsonName: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneJsonName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum jsonPath: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneJsonPath // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonPath
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonPath
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonPath: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum jsonPaths: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneJsonPaths // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonPaths
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonPaths
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonPaths: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum JSONScanner: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneJsonscanner // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonscanner
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonscanner
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonscanner: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum jsonString: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneJsonString // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonString
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonString
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonString: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum jsonText: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneJsonText // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonText
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonText
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonText: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum jsonUTF8Data: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneJsonUtf8Data // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonUtf8Data
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonUtf8Data
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonUtf8Data: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum k: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneK // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneK
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneK
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneK: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Key: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneKey // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneKey
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneKey
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneKey: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum keyField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneKeyField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneKeyField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneKeyField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneKeyField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum KeyType: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneKeyType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneKeyType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneKeyType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneKeyType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum kind: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneKind // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneKind
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneKind
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneKind: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum l: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneL // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneL
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneL
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneL: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum length: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneLength // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLength
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLength
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLength: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum letEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneLet // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLet
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLet
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLet: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum lhs: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneLhs // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLhs
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLhs
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLhs: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum list: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneList // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneList
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneList
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneList: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum listOfMessages: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneListOfMessages // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneListOfMessages
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneListOfMessages
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneListOfMessages: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum listValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneListValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneListValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneListValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneListValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum littleEndian: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneLittleEndian // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLittleEndian
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLittleEndian
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLittleEndian: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum littleEndianBytes: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneLittleEndianBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLittleEndianBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLittleEndianBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLittleEndianBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum localHasher: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneLocalHasher // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLocalHasher
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLocalHasher
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLocalHasher: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum M: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneM // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneM
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneM
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneM: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum major: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMajor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMajor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMajor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMajor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum makeIterator: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMakeIterator // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMakeIterator
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMakeIterator
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMakeIterator: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum mapHash: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMapHash // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMapHash
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMapHash
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMapHash: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum MapKeyType: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMapKeyType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMapKeyType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMapKeyType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMapKeyType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum mapNameResolver: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMapNameResolver // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMapNameResolver
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMapNameResolver
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMapNameResolver: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum mapToMessages: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMapToMessages // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMapToMessages
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMapToMessages
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMapToMessages: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum MapValueType: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMapValueType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMapValueType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMapValueType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMapValueType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum mapVisitor: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMapVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMapVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMapVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMapVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum mdayStart: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMdayStart // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMdayStart
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMdayStart
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMdayStart: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum merge: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMerge // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMerge
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMerge
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMerge: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum message: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMessage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMessage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMessage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMessage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum messageDepthLimit: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMessageDepthLimit // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMessageDepthLimit
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMessageDepthLimit
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMessageDepthLimit: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum MessageExtension: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMessageExtension // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMessageExtension
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMessageExtension
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMessageExtension: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum MessageImplementationBase: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMessageImplementationBase // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMessageImplementationBase
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMessageImplementationBase
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMessageImplementationBase: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum MessageSet: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMessageSet // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMessageSet
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMessageSet
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMessageSet: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum messageType: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMessageType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMessageType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMessageType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMessageType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Method: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMethod // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMethod
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMethod
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMethod: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum methods: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMethods // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMethods
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMethods
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMethods: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum minor: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMinor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMinor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMinor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMinor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Mixin: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMixin // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMixin
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMixin
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMixin: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum mixins: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMixins // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMixins
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMixins
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMixins: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum month: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMonth // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMonth
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMonth
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMonth: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum msgExtension: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMsgExtension // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMsgExtension
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMsgExtension
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMsgExtension: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum mutating: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneMutating // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMutating
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMutating
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMutating: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum n: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case oneN // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .oneN
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .oneN
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .oneN: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum name: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum NameDescription: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNameDescription // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNameDescription
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNameDescription
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNameDescription: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum NameMap: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNameMap // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNameMap
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNameMap
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNameMap: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum nameResolver: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNameResolver // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNameResolver
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNameResolver
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNameResolver: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum names: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNames // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNames
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNames
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNames: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum nanos: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNanos // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNanos
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNanos
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNanos: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum nativeBytes: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNativeBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNativeBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNativeBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNativeBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum nativeEndianBytes: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNativeEndianBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNativeEndianBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNativeEndianBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNativeEndianBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum newL: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNewL // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNewL
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNewL
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNewL: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum newList: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNewList // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNewList
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNewList
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNewList: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum newValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNewValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNewValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNewValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNewValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum nextByte: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNextByte // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNextByte
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNextByte
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNextByte: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum nextFieldNumber: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNextFieldNumber // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNextFieldNumber
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNextFieldNumber
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNextFieldNumber: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum nilEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNil // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNil
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNil
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNil: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum nilLiteral: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNilLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNilLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNilLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNilLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum nullValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNullValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNullValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNullValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNullValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum number: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNumber // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNumber
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNumber
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNumber: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum numberValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneNumberValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNumberValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNumberValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNumberValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum of: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneOf // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOf
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOf
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOf: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum oneofIndex: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneOneofIndex // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOneofIndex
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOneofIndex
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOneofIndex: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum oneofs: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneOneofs // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOneofs
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOneofs
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOneofs: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum OneOf_Kind: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneOneOfKind // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOneOfKind
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOneOfKind
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOneOfKind: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Option: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneOption // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOption
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOption
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOption: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum OptionalEnumExtensionField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneOptionalEnumExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOptionalEnumExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOptionalEnumExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOptionalEnumExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum OptionalExtensionField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneOptionalExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOptionalExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOptionalExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOptionalExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum OptionalGroupExtensionField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneOptionalGroupExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOptionalGroupExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOptionalGroupExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOptionalGroupExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum OptionalMessageExtensionField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneOptionalMessageExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOptionalMessageExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOptionalMessageExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOptionalMessageExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum options: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum other: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneOther // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOther
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOther
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOther: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum others: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneOthers // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOthers
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOthers
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOthers: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum out: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneOut // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOut
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOut
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOut: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum p: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneP // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneP
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneP
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneP: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum packed: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePacked // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePacked
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePacked
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePacked: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum PackedEnumExtensionField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePackedEnumExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePackedEnumExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePackedEnumExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePackedEnumExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum PackedExtensionField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePackedExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePackedExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePackedExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePackedExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum packedSize: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePackedSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePackedSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePackedSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePackedSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum padding: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePadding // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePadding
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePadding
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePadding: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum parent: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneParent // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneParent
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneParent
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneParent: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum parse: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneParse // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneParse
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneParse
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneParse: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum partial: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePartial // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePartial
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePartial
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePartial: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum path: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePath // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePath
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePath
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePath: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum paths: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePaths // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePaths
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePaths
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePaths: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum payload: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePayload // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePayload
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePayload
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePayload: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum payloadSize: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePayloadSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePayloadSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePayloadSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePayloadSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum pointer: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePointer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePointer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePointer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePointer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum pos: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePos // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePos
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePos
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePos: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum prefix: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePrefix // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePrefix
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePrefix
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePrefix: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum preserveProtoFieldNames: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePreserveProtoFieldNames // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePreserveProtoFieldNames
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePreserveProtoFieldNames
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePreserveProtoFieldNames: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum preTraverse: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePreTraverse // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePreTraverse
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePreTraverse
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePreTraverse: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum printUnknownFields: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePrintUnknownFields // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePrintUnknownFields
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePrintUnknownFields
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePrintUnknownFields: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum proto2: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProto2 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProto2
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProto2
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProto2: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum proto3DefaultValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProto3DefaultValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProto3DefaultValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProto3DefaultValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProto3DefaultValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufAPIVersionCheck: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufApiversionCheck // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufApiversionCheck
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufApiversionCheck
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufApiversionCheck: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufAPIVersion_2: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufApiversion2 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufApiversion2
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufApiversion2
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufApiversion2: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufBool: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufBool // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufBool
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufBool
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufBool: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufBytes: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufDouble: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufDouble // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufDouble
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufDouble
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufDouble: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufEnumMap: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufEnumMap // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufEnumMap
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufEnumMap
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufEnumMap: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum protobufExtension: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufExtension // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufExtension
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufExtension
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufExtension: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufFixed32: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufFixed32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufFixed32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufFixed32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufFixed32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufFixed64: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufFixed64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufFixed64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufFixed64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufFixed64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufFloat: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufFloat // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufFloat
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufFloat
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufFloat: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufInt32: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufInt32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufInt32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufInt32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufInt32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufInt64: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufInt64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufInt64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufInt64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufInt64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufMap: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufMap // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufMap
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufMap
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufMap: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufMessageMap: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufMessageMap // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufMessageMap
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufMessageMap
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufMessageMap: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufSFixed32: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufSfixed32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufSfixed32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufSfixed32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufSfixed32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufSFixed64: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufSfixed64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufSfixed64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufSfixed64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufSfixed64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufSInt32: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufSint32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufSint32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufSint32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufSint32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufSInt64: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufSint64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufSint64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufSint64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufSint64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufString: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufString // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufString
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufString
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufString: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufUInt32: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufUint32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufUint32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufUint32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufUint32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtobufUInt64: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufUint64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufUint64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufUint64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufUint64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum protobuf_extensionFieldValues: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufExtensionFieldValues // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufExtensionFieldValues
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufExtensionFieldValues
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufExtensionFieldValues: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum protobuf_fieldNumber: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufFieldNumber // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufFieldNumber
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufFieldNumber
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufFieldNumber: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum protobuf_generated_isEqualTo: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufGeneratedIsEqualTo // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufGeneratedIsEqualTo
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufGeneratedIsEqualTo
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufGeneratedIsEqualTo: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum protobuf_nameMap: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufNameMap // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufNameMap
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufNameMap
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufNameMap: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum protobuf_newField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufNewField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufNewField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufNewField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufNewField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum protobuf_package: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtobufPackage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufPackage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufPackage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufPackage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum protocolEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtocol // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtocol
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtocol
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtocol: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum protoFieldName: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtoFieldName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtoFieldName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtoFieldName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtoFieldName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum protoMessageNameEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtoMessageName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtoMessageName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtoMessageName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtoMessageName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ProtoNameProviding: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtoNameProviding // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtoNameProviding
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtoNameProviding
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtoNameProviding: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum protoPaths: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneProtoPaths // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtoPaths
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtoPaths
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtoPaths: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum publicEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePublic // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePublic
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePublic
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePublic: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum putBoolValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePutBoolValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutBoolValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutBoolValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutBoolValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum putBytesValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePutBytesValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutBytesValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutBytesValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutBytesValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum putDoubleValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePutDoubleValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutDoubleValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutDoubleValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutDoubleValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum putEnumValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePutEnumValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutEnumValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutEnumValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutEnumValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum putFixedUInt32: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePutFixedUint32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutFixedUint32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutFixedUint32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutFixedUint32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum putFixedUInt64: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePutFixedUint64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutFixedUint64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutFixedUint64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutFixedUint64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum putFloatValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePutFloatValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutFloatValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutFloatValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutFloatValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum putInt64: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePutInt64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutInt64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutInt64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutInt64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum putStringValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePutStringValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutStringValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutStringValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutStringValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum putUInt64: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePutUint64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutUint64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutUint64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutUint64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum putUInt64Hex: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePutUint64Hex // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutUint64Hex
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutUint64Hex
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutUint64Hex: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum putVarInt: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePutVarInt // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutVarInt
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutVarInt
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutVarInt: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum putZigZagVarInt: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case nonePutZigZagVarInt // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutZigZagVarInt
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutZigZagVarInt
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutZigZagVarInt: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum rawChars: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneRawChars // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRawChars
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRawChars
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRawChars: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum RawRepresentable: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneRawRepresentable // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRawRepresentable
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRawRepresentable
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRawRepresentable: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum RawValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneRawValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRawValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRawValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRawValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum readBuffer: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneReadBuffer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneReadBuffer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneReadBuffer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneReadBuffer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum register: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneRegister // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRegister
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRegister
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRegister: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum RepeatedEnumExtensionField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneRepeatedEnumExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRepeatedEnumExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRepeatedEnumExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRepeatedEnumExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum RepeatedExtensionField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneRepeatedExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRepeatedExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRepeatedExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRepeatedExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum RepeatedGroupExtensionField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneRepeatedGroupExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRepeatedGroupExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRepeatedGroupExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRepeatedGroupExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum RepeatedMessageExtensionField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneRepeatedMessageExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRepeatedMessageExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRepeatedMessageExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRepeatedMessageExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum requestStreaming: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneRequestStreaming // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRequestStreaming
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRequestStreaming
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRequestStreaming: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum requestTypeURL: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneRequestTypeURL // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRequestTypeURL
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRequestTypeURL
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRequestTypeURL: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum requiredSize: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneRequiredSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRequiredSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRequiredSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRequiredSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum responseStreaming: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneResponseStreaming // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneResponseStreaming
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneResponseStreaming
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneResponseStreaming: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum responseTypeURL: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneResponseTypeURL // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneResponseTypeURL
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneResponseTypeURL
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneResponseTypeURL: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum result: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneResult // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneResult
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneResult
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneResult: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum rethrowsEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneRethrows // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRethrows
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRethrows
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRethrows: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum returnEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneReturn // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneReturn
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneReturn
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneReturn: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum revision: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneRevision // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRevision
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRevision
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRevision: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum rhs: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneRhs // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRhs
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRhs
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRhs: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum root: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneRoot // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRoot
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRoot
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRoot: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum s: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneS // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneS
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneS
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneS: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum sawBackslash: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSawBackslash // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSawBackslash
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSawBackslash
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSawBackslash: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum sawSection4Characters: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSawSection4Characters // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSawSection4Characters
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSawSection4Characters
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSawSection4Characters: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum sawSection5Characters: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSawSection5Characters // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSawSection5Characters
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSawSection5Characters
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSawSection5Characters: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum scanner: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneScanner // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneScanner
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneScanner
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneScanner: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum seconds: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSeconds // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSeconds
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSeconds
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSeconds: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum selfEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSelf // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSelf
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSelf
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSelf: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum separator: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSeparator // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSeparator
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSeparator
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSeparator: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum serialize: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSerialize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSerialize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSerialize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSerialize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum serializedData: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSerializedData // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSerializedData
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSerializedData
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSerializedData: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum serializedSize: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSerializedSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSerializedSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSerializedSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSerializedSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum set: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSet // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSet
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSet
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSet: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum setExtensionValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSetExtensionValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSetExtensionValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSetExtensionValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSetExtensionValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum shift: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneShift // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneShift
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneShift
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneShift: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum SimpleExtensionMap: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSimpleExtensionMap // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSimpleExtensionMap
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSimpleExtensionMap
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSimpleExtensionMap: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum sizer: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSizer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSizer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSizer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSizer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum source: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSource // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSource
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSource
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSource: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum sourceContext: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSourceContext // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSourceContext
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSourceContext
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSourceContext: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum sourceEncoding: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSourceEncoding // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSourceEncoding
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSourceEncoding
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSourceEncoding: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum split: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSplit // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSplit
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSplit
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSplit: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum start: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneStart // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStart
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStart
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStart: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum startArray: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneStartArray // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStartArray
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStartArray
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStartArray: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum startField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneStartField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStartField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStartField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStartField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum startIndex: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneStartIndex // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStartIndex
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStartIndex
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStartIndex: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum startMessageField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneStartMessageField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStartMessageField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStartMessageField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStartMessageField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum startObject: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneStartObject // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStartObject
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStartObject
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStartObject: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum startRegularField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneStartRegularField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStartRegularField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStartRegularField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStartRegularField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum state: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneState // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneState
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneState
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneState: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum staticEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneStatic // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStatic
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStatic
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStatic: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum StaticString: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneStaticString // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStaticString
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStaticString
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStaticString: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum storage: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneStorage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStorage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStorage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStorage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum StringEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneString // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneString
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneString
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneString: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum stringLiteral: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneStringLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStringLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStringLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStringLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum StringLiteralType: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneStringLiteralType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStringLiteralType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStringLiteralType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStringLiteralType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum stringResult: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneStringResult // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStringResult
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStringResult
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStringResult: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum stringValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneStringValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStringValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStringValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStringValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum structEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneStruct // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStruct
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStruct
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStruct: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum structValue: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneStructValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStructValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStructValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStructValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum subDecoder: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSubDecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSubDecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSubDecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSubDecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum subscriptEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSubscript // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSubscript
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSubscript
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSubscript: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum subVisitor: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSubVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSubVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSubVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSubVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Swift: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSwift // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSwift
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSwift
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSwift: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum SwiftProtobufEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSwiftProtobuf // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSwiftProtobuf
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSwiftProtobuf
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSwiftProtobuf: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum syntax: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneSyntax // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSyntax
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSyntax
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSyntax: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum T: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneT // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneT
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneT
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneT: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum tag: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTag // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTag
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTag
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTag: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum terminator: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTerminator // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTerminator
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTerminator
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTerminator: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum testDecoder: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTestDecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTestDecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTestDecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTestDecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum text: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneText // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneText
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneText
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneText: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum textDecoder: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTextDecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTextDecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTextDecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTextDecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum TextFormatDecoder: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTextFormatDecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTextFormatDecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTextFormatDecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTextFormatDecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum TextFormatDecodingError: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTextFormatDecodingError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTextFormatDecodingError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTextFormatDecodingError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTextFormatDecodingError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum TextFormatEncodingOptions: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTextFormatEncodingOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTextFormatEncodingOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTextFormatEncodingOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTextFormatEncodingOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum TextFormatEncodingVisitor: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTextFormatEncodingVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTextFormatEncodingVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTextFormatEncodingVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTextFormatEncodingVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum textFormatString: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTextFormatString // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTextFormatString
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTextFormatString
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTextFormatString: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum throwsEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneThrows // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneThrows
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneThrows
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneThrows: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum timeInterval: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTimeInterval // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTimeInterval
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTimeInterval
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTimeInterval: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum timeIntervalSince1970: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTimeIntervalSince1970 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTimeIntervalSince1970
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTimeIntervalSince1970
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTimeIntervalSince1970: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum timeIntervalSinceReferenceDate: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTimeIntervalSinceReferenceDate // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTimeIntervalSinceReferenceDate
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTimeIntervalSinceReferenceDate
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTimeIntervalSinceReferenceDate: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Timestamp: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTimestamp // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTimestamp
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTimestamp
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTimestamp: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum to: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTo // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTo
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTo
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTo: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum total: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTotal // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTotal
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTotal
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTotal: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum totalSize: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTotalSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTotalSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTotalSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTotalSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum traverseEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTraverse // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTraverse
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTraverse
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTraverse: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum trueEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTrue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTrue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTrue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTrue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum tryEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTry // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTry
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTry
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTry: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum type: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum typealiasEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTypealias // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTypealias
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTypealias
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTypealias: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum typePrefix: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTypePrefix // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTypePrefix
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTypePrefix
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTypePrefix: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum typeStart: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTypeStart // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTypeStart
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTypeStart
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTypeStart: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum typeUnknown: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTypeUnknown // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTypeUnknown
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTypeUnknown
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTypeUnknown: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum typeURL: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneTypeURL // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTypeURL
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTypeURL
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTypeURL: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum UInt32Enum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUint32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUint32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUint32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUint32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum UInt32Value: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUint32Value // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUint32Value
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUint32Value
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUint32Value: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum UInt64Enum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUint64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUint64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUint64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUint64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum UInt64Value: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUint64Value // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUint64Value
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUint64Value
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUint64Value: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum UInt8: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUint8 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUint8
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUint8
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUint8: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum unicodeScalarLiteral: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUnicodeScalarLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnicodeScalarLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnicodeScalarLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnicodeScalarLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum UnicodeScalarLiteralType: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUnicodeScalarLiteralType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnicodeScalarLiteralType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnicodeScalarLiteralType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnicodeScalarLiteralType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum unicodeScalars: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUnicodeScalars // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnicodeScalars
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnicodeScalars
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnicodeScalars: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum UnicodeScalarView: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUnicodeScalarView // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnicodeScalarView
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnicodeScalarView
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnicodeScalarView: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum union: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUnion // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnion
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnion
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnion: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum uniqueStorage: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUniqueStorage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUniqueStorage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUniqueStorage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUniqueStorage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum unknown: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUnknown // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnknown
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnknown
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnknown: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum unknownFieldsEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUnknownFields // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnknownFields
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnknownFields
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnknownFields: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum UnknownStorage: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUnknownStorage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnknownStorage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnknownStorage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnknownStorage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum unpackTo: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUnpackTo // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnpackTo
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnpackTo
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnpackTo: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum UnsafeBufferPointer: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUnsafeBufferPointer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnsafeBufferPointer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnsafeBufferPointer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnsafeBufferPointer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum UnsafeMutablePointer: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUnsafeMutablePointer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnsafeMutablePointer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnsafeMutablePointer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnsafeMutablePointer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum UnsafeMutableRawBufferPointer: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUnsafeMutableRawBufferPointer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnsafeMutableRawBufferPointer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnsafeMutableRawBufferPointer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnsafeMutableRawBufferPointer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum UnsafePointer: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUnsafePointer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnsafePointer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnsafePointer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnsafePointer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum UnsafeRawBufferPointer: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUnsafeRawBufferPointer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnsafeRawBufferPointer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnsafeRawBufferPointer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnsafeRawBufferPointer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum updatedOptions: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUpdatedOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUpdatedOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUpdatedOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUpdatedOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum url: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneURL // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneURL
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneURL
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneURL: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum utf8: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUtf8 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUtf8
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUtf8
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUtf8: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum utf8ToDouble: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUtf8ToDouble // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUtf8ToDouble
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUtf8ToDouble
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUtf8ToDouble: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum UTF8View: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneUtf8View // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUtf8View
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUtf8View
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUtf8View: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum v: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneV // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneV
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneV
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneV: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum value: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum valueField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneValueField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneValueField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneValueField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneValueField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum values: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneValues // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneValues
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneValues
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneValues: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum ValueType: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneValueType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneValueType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneValueType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneValueType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum varEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVar // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVar
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVar
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVar: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum Version: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVersion // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVersion
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVersion
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVersion: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum versionString: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVersionString // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVersionString
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVersionString
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVersionString: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitExtensionFields: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitExtensionFields // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitExtensionFields
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitExtensionFields
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitExtensionFields: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitExtensionFieldsAsMessageSet: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitExtensionFieldsAsMessageSet // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitExtensionFieldsAsMessageSet
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitExtensionFieldsAsMessageSet
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitExtensionFieldsAsMessageSet: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitMapField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitMapField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitMapField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitMapField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitMapField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitor: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitPacked: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitPacked // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPacked
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPacked
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPacked: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitPackedBoolField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitPackedBoolField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedBoolField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedBoolField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedBoolField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitPackedDoubleField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitPackedDoubleField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedDoubleField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedDoubleField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedDoubleField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitPackedEnumField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitPackedEnumField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedEnumField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedEnumField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedEnumField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitPackedFixed32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitPackedFixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedFixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedFixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedFixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitPackedFixed64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitPackedFixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedFixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedFixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedFixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitPackedFloatField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitPackedFloatField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedFloatField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedFloatField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedFloatField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitPackedInt32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitPackedInt32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedInt32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedInt32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedInt32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitPackedInt64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitPackedInt64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedInt64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedInt64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedInt64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitPackedSFixed32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitPackedSfixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedSfixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedSfixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedSfixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitPackedSFixed64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitPackedSfixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedSfixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedSfixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedSfixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitPackedSInt32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitPackedSint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedSint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedSint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedSint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitPackedSInt64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitPackedSint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedSint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedSint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedSint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitPackedUInt32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitPackedUint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedUint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedUint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedUint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitPackedUInt64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitPackedUint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedUint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedUint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedUint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeated: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeated // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeated
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeated
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeated: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedBoolField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedBoolField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedBoolField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedBoolField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedBoolField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedBytesField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedBytesField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedBytesField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedBytesField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedBytesField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedDoubleField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedDoubleField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedDoubleField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedDoubleField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedDoubleField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedEnumField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedEnumField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedEnumField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedEnumField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedEnumField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedFixed32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedFixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedFixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedFixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedFixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedFixed64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedFixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedFixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedFixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedFixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedFloatField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedFloatField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedFloatField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedFloatField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedFloatField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedGroupField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedGroupField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedGroupField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedGroupField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedGroupField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedInt32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedInt32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedInt32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedInt32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedInt32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedInt64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedInt64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedInt64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedInt64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedInt64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedMessageField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedMessageField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedMessageField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedMessageField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedMessageField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedSFixed32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedSfixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedSfixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedSfixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedSfixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedSFixed64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedSfixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedSfixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedSfixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedSfixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedSInt32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedSint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedSint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedSint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedSint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedSInt64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedSint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedSint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedSint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedSint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedStringField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedStringField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedStringField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedStringField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedStringField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedUInt32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedUint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedUint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedUint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedUint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitRepeatedUInt64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitRepeatedUint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedUint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedUint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedUint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingular: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingular // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingular
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingular
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingular: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularBoolField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularBoolField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularBoolField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularBoolField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularBoolField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularBytesField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularBytesField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularBytesField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularBytesField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularBytesField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularDoubleField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularDoubleField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularDoubleField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularDoubleField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularDoubleField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularEnumField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularEnumField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularEnumField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularEnumField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularEnumField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularFixed32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularFixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularFixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularFixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularFixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularFixed64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularFixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularFixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularFixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularFixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularFloatField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularFloatField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularFloatField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularFloatField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularFloatField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularGroupField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularGroupField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularGroupField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularGroupField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularGroupField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularInt32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularInt32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularInt32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularInt32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularInt32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularInt64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularInt64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularInt64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularInt64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularInt64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularMessageField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularMessageField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularMessageField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularMessageField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularMessageField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularSFixed32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularSfixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularSfixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularSfixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularSfixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularSFixed64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularSfixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularSfixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularSfixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularSfixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularSInt32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularSint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularSint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularSint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularSint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularSInt64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularSint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularSint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularSint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularSint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularStringField: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularStringField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularStringField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularStringField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularStringField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularUInt32Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularUint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularUint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularUint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularUint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitSingularUInt64Field: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitSingularUint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularUint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularUint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularUint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum visitUnknown: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneVisitUnknown // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitUnknown
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitUnknown
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitUnknown: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum wasDecoded: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneWasDecoded // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWasDecoded
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWasDecoded
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWasDecoded: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum whereEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneWhere // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWhere
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWhere
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWhere: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum wireFormat: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneWireFormat // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWireFormat
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWireFormat
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWireFormat: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum with: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneWith // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWith
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWith
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWith: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum withUnsafeBytes: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneWithUnsafeBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWithUnsafeBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWithUnsafeBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWithUnsafeBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum withUnsafeMutableBytes: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneWithUnsafeMutableBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWithUnsafeMutableBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWithUnsafeMutableBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWithUnsafeMutableBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum WrappedType: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneWrappedType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWrappedType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWrappedType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWrappedType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum written: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneWritten // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWritten
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWritten
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWritten: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  enum yday: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case noneYday // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneYday
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneYday
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneYday: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  init() {}
}

#if swift(>=4.2)

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.adjusted: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.adjusted] = [
    .noneAdjusted,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allCases: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allCases] = [
    .noneAllCases,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allocate: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allocate] = [
    .noneAllocate,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts] = [
    .noneAlwaysPrintEnumsAsInts,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.any: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.any] = [
    .noneAny,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyExtensionField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyExtensionField] = [
    .noneAnyExtensionField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageExtension: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageExtension] = [
    .noneAnyMessageExtension,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageStorage: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageStorage] = [
    .noneAnyMessageStorage,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyUnpackError: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyUnpackError] = [
    .noneAnyUnpackError,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Api: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Api] = [
    .noneApi,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appended: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appended] = [
    .noneAppended,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUIntHex: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUIntHex] = [
    .noneAppendUintHex,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUnknown: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUnknown] = [
    .noneAppendUnknown,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.areAllInitialized: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.areAllInitialized] = [
    .noneAreAllInitialized,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.array: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.array] = [
    .noneArray,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayLiteral: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayLiteral] = [
    .noneArrayLiteral,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arraySeparator: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arraySeparator] = [
    .noneArraySeparator,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asEnum] = [
    .noneAs,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket] = [
    .noneAsciiOpenCurlyBracket,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiZero: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiZero] = [
    .noneAsciiZero,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.assumingMemoryBound: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.assumingMemoryBound] = [
    .noneAssumingMemoryBound,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.available: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.available] = [
    .noneAvailable,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.b: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.b] = [
    .noneB,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.base64Values: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.base64Values] = [
    .noneBase64Values,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.baseAddress: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.baseAddress] = [
    .noneBaseAddress,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BaseType: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BaseType] = [
    .noneBaseType,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binary: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binary] = [
    .noneBinary,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecoder: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecoder] = [
    .noneBinaryDecoder,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingError: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingError] = [
    .noneBinaryDecodingError,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingOptions: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingOptions] = [
    .noneBinaryDecodingOptions,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDelimited: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDelimited] = [
    .noneBinaryDelimited,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncoder: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncoder] = [
    .noneBinaryEncoder,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingError: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingError] = [
    .noneBinaryEncodingError,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor] = [
    .noneBinaryEncodingMessageSetSizeVisitor,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor] = [
    .noneBinaryEncodingMessageSetVisitor,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor] = [
    .noneBinaryEncodingSizeVisitor,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor] = [
    .noneBinaryEncodingVisitor,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.body: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.body] = [
    .noneBody,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bodySize: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bodySize] = [
    .noneBodySize,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BoolEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BoolEnum] = [
    .noneBool,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.booleanLiteral: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.booleanLiteral] = [
    .noneBooleanLiteral,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BooleanLiteralType: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BooleanLiteralType] = [
    .noneBooleanLiteralType,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.boolValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.boolValue] = [
    .noneBoolValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.buffer: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.buffer] = [
    .noneBuffer,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytes: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytes] = [
    .noneBytes,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesInGroup: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesInGroup] = [
    .noneBytesInGroup,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesRead: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesRead] = [
    .noneBytesRead,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BytesValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BytesValue] = [
    .noneBytesValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.c: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.c] = [
    .noneC,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.capacity: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.capacity] = [
    .noneCapacity,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.capitalizeNext: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.capitalizeNext] = [
    .noneCapitalizeNext,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.cardinality: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.cardinality] = [
    .noneCardinality,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Character: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Character] = [
    .noneCharacter,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.chars: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.chars] = [
    .noneChars,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.classEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.classEnum] = [
    .noneClass,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtensionValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtensionValue] = [
    .noneClearExtensionValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceContext: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceContext] = [
    .noneClearSourceContext,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearValue] = [
    .noneClearValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codeUnits: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codeUnits] = [
    .noneCodeUnits,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Collection: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Collection] = [
    .noneCollection,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.com: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.com] = [
    .noneCom,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.comma: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.comma] = [
    .noneComma,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.contentsOf: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.contentsOf] = [
    .noneContentsOf,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.count: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.count] = [
    .noneCount,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.countVarintsInBuffer: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.countVarintsInBuffer] = [
    .noneCountVarintsInBuffer,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.customCodable: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.customCodable] = [
    .noneCustomCodable,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible] = [
    .noneCustomDebugStringConvertible,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.d: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.d] = [
    .noneD,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DataEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DataEnum] = [
    .noneData,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dataResult: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dataResult] = [
    .noneDataResult,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dataSize: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dataSize] = [
    .noneDataSize,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.date: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.date] = [
    .noneDate,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daySec: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daySec] = [
    .noneDaySec,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daysSinceEpoch: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daysSinceEpoch] = [
    .noneDaysSinceEpoch,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.debugDescriptionEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.debugDescriptionEnum] = [
    .noneDebugDescription,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoded: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoded] = [
    .noneDecoded,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodedFromJSONNull: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodedFromJSONNull] = [
    .noneDecodedFromJsonnull,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionField] = [
    .noneDecodeExtensionField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet] = [
    .noneDecodeExtensionFieldsAsMessageSet,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeJSON: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeJSON] = [
    .noneDecodeJson,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMapField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMapField] = [
    .noneDecodeMapField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMessageEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMessageEnum] = [
    .noneDecodeMessage,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoder: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoder] = [
    .noneDecoder,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeated: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeated] = [
    .noneDecodeRepeated,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField] = [
    .noneDecodeRepeatedBoolField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField] = [
    .noneDecodeRepeatedBytesField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField] = [
    .noneDecodeRepeatedDoubleField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField] = [
    .noneDecodeRepeatedEnumField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field] = [
    .noneDecodeRepeatedFixed32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field] = [
    .noneDecodeRepeatedFixed64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField] = [
    .noneDecodeRepeatedFloatField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField] = [
    .noneDecodeRepeatedGroupField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field] = [
    .noneDecodeRepeatedInt32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field] = [
    .noneDecodeRepeatedInt64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField] = [
    .noneDecodeRepeatedMessageField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field] = [
    .noneDecodeRepeatedSfixed32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field] = [
    .noneDecodeRepeatedSfixed64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field] = [
    .noneDecodeRepeatedSint32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field] = [
    .noneDecodeRepeatedSint64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedStringField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedStringField] = [
    .noneDecodeRepeatedStringField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field] = [
    .noneDecodeRepeatedUint32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field] = [
    .noneDecodeRepeatedUint64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingular: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingular] = [
    .noneDecodeSingular,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBoolField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBoolField] = [
    .noneDecodeSingularBoolField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBytesField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBytesField] = [
    .noneDecodeSingularBytesField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularDoubleField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularDoubleField] = [
    .noneDecodeSingularDoubleField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularEnumField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularEnumField] = [
    .noneDecodeSingularEnumField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field] = [
    .noneDecodeSingularFixed32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field] = [
    .noneDecodeSingularFixed64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFloatField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFloatField] = [
    .noneDecodeSingularFloatField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularGroupField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularGroupField] = [
    .noneDecodeSingularGroupField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt32Field] = [
    .noneDecodeSingularInt32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt64Field] = [
    .noneDecodeSingularInt64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularMessageField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularMessageField] = [
    .noneDecodeSingularMessageField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field] = [
    .noneDecodeSingularSfixed32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field] = [
    .noneDecodeSingularSfixed64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field] = [
    .noneDecodeSingularSint32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field] = [
    .noneDecodeSingularSint64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularStringField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularStringField] = [
    .noneDecodeSingularStringField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field] = [
    .noneDecodeSingularUint32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field] = [
    .noneDecodeSingularUint64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeTextFormat: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeTextFormat] = [
    .noneDecodeTextFormat,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix] = [
    .noneDefaultAnyTypeUrlprefix,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultValue] = [
    .noneDefaultValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.descriptionEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.descriptionEnum] = [
    .noneDescription,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Dictionary: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Dictionary] = [
    .noneDictionary,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dictionaryLiteral: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dictionaryLiteral] = [
    .noneDictionaryLiteral,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit] = [
    .noneDigit,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit0: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit0] = [
    .noneDigit0,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit1: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit1] = [
    .noneDigit1,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitCount: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitCount] = [
    .noneDigitCount,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digits: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digits] = [
    .noneDigits,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitValue] = [
    .noneDigitValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardableResult: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardableResult] = [
    .noneDiscardableResult,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardUnknownFields: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardUnknownFields] = [
    .noneDiscardUnknownFields,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.distance: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.distance] = [
    .noneDistance,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.double: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.double] = [
    .noneDouble,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.doubleToUtf8: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.doubleToUtf8] = [
    .noneDoubleToUtf8,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DoubleValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DoubleValue] = [
    .noneDoubleValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Duration: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Duration] = [
    .noneDuration,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.E: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.E] = [
    .noneE,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Element: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Element] = [
    .noneElement,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.elements: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.elements] = [
    .noneElements,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitExtensionFieldName: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitExtensionFieldName] = [
    .noneEmitExtensionFieldName,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldName: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldName] = [
    .noneEmitFieldName,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldNumber: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldNumber] = [
    .noneEmitFieldNumber,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Empty: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Empty] = [
    .noneEmpty,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emptyData: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emptyData] = [
    .noneEmptyData,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoded: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoded] = [
    .noneEncoded,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedJSONString: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedJSONString] = [
    .noneEncodedJsonstring,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedSize: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedSize] = [
    .noneEncodedSize,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeField] = [
    .noneEncodeField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoder: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoder] = [
    .noneEncoder,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.end: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.end] = [
    .noneEnd,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endArray: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endArray] = [
    .noneEndArray,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endMessageField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endMessageField] = [
    .noneEndMessageField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endObject: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endObject] = [
    .noneEndObject,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endRegularField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endRegularField] = [
    .noneEndRegularField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumEnum] = [
    .noneEnum,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumvalue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumvalue] = [
    .noneEnumvalue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Equatable: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Equatable] = [
    .noneEquatable,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Error: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Error] = [
    .noneError,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral] = [
    .noneExpressibleByArrayLiteral,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral] = [
    .noneExpressibleByDictionaryLiteral,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ext: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ext] = [
    .noneExt,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extDecoder: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extDecoder] = [
    .noneExtDecoder,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral] = [
    .noneExtendedGraphemeClusterLiteral,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType] = [
    .noneExtendedGraphemeClusterLiteralType,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensibleMessage: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensibleMessage] = [
    .noneExtensibleMessage,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionField] = [
    .noneExtensionField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionFieldNumber: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionFieldNumber] = [
    .noneExtensionFieldNumber,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet] = [
    .noneExtensionFieldValueSet,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionMap: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionMap] = [
    .noneExtensionMap,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensions: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensions] = [
    .noneExtensions,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extras: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extras] = [
    .noneExtras,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.f: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.f] = [
    .noneF,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.falseEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.falseEnum] = [
    .noneFalse,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.field] = [
    .noneField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldData: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldData] = [
    .noneFieldData,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldMask: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldMask] = [
    .noneFieldMask,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldName: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldName] = [
    .noneFieldName,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNameCount: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNameCount] = [
    .noneFieldNameCount,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNum] = [
    .noneFieldNum,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumber: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumber] = [
    .noneFieldNumber,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumberForProto: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumberForProto] = [
    .noneFieldNumberForProto,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fields: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fields] = [
    .noneFields,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldSize: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldSize] = [
    .noneFieldSize,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldTag: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldTag] = [
    .noneFieldTag,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldType: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldType] = [
    .noneFieldType,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldValue] = [
    .noneFieldValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fileName: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fileName] = [
    .noneFileName,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.filter: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.filter] = [
    .noneFilter,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.firstItem: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.firstItem] = [
    .noneFirstItem,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.float: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.float] = [
    .noneFloat,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.floatLiteral: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.floatLiteral] = [
    .noneFloatLiteral,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatLiteralType: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatLiteralType] = [
    .noneFloatLiteralType,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.floatToUtf8: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.floatToUtf8] = [
    .noneFloatToUtf8,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatValue] = [
    .noneFloatValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forMessageName: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forMessageName] = [
    .noneForMessageName,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.formUnion: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.formUnion] = [
    .noneFormUnion,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forReadingFrom: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forReadingFrom] = [
    .noneForReadingFrom,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forTypeURL: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forTypeURL] = [
    .noneForTypeURL,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ForwardParser: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ForwardParser] = [
    .noneForwardParser,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forWritingInto: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forWritingInto] = [
    .noneForWritingInto,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.from: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.from] = [
    .noneFrom,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii2: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii2] = [
    .noneFromAscii2,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii4: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii4] = [
    .noneFromAscii4,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromHexDigit: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromHexDigit] = [
    .noneFromHexDigit,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.funcEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.funcEnum] = [
    .noneFunc,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.G: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.G] = [
    .noneG,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.get: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.get] = [
    .noneGet,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.getExtensionValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.getExtensionValue] = [
    .noneGetExtensionValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.googleapis: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.googleapis] = [
    .noneGoogleapis,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Any: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Any] = [
    .noneGoogleProtobufAny,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Api: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Api] = [
    .noneGoogleProtobufApi,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue] = [
    .noneGoogleProtobufBoolValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue] = [
    .noneGoogleProtobufBytesValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue] = [
    .noneGoogleProtobufDoubleValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration] = [
    .noneGoogleProtobufDuration,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty] = [
    .noneGoogleProtobufEmpty,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum] = [
    .noneGoogleProtobufEnum,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue] = [
    .noneGoogleProtobufEnumValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Field] = [
    .noneGoogleProtobufField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask] = [
    .noneGoogleProtobufFieldMask,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue] = [
    .noneGoogleProtobufFloatValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value] = [
    .noneGoogleProtobufInt32Value,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value] = [
    .noneGoogleProtobufInt64Value,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue] = [
    .noneGoogleProtobufListValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Method: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Method] = [
    .noneGoogleProtobufMethod,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin] = [
    .noneGoogleProtobufMixin,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue] = [
    .noneGoogleProtobufNullValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Option: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Option] = [
    .noneGoogleProtobufOption,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext] = [
    .noneGoogleProtobufSourceContext,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue] = [
    .noneGoogleProtobufStringValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct] = [
    .noneGoogleProtobufStruct,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax] = [
    .noneGoogleProtobufSyntax,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp] = [
    .noneGoogleProtobufTimestamp,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Type: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Type] = [
    .noneGoogleProtobufType,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value] = [
    .noneGoogleProtobufUint32Value,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value] = [
    .noneGoogleProtobufUint64Value,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Value: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Value] = [
    .noneGoogleProtobufValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.group: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.group] = [
    .noneGroup,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupSize: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupSize] = [
    .noneGroupSize,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.h: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.h] = [
    .noneH,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.handleConflictingOneOf: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.handleConflictingOneOf] = [
    .noneHandleConflictingOneOf,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtensionValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtensionValue] = [
    .noneHasExtensionValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hash: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hash] = [
    .noneHash,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Hashable: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Hashable] = [
    .noneHashable,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasher: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasher] = [
    .noneHasher,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hashValueEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hashValueEnum] = [
    .noneHashValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.HashVisitor: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.HashVisitor] = [
    .noneHashVisitor,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceContext: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceContext] = [
    .noneHasSourceContext,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasValue] = [
    .noneHasValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hour: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hour] = [
    .noneHour,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i] = [
    .noneI,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ignoreUnknownFields: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ignoreUnknownFields] = [
    .noneIgnoreUnknownFields,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.index: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.index] = [
    .noneIndex,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.initEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.initEnum] = [
    .noneInit,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inoutEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inoutEnum] = [
    .noneInout,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.insert: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.insert] = [
    .noneInsert,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntEnum] = [
    .noneInt,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Enum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Enum] = [
    .noneInt32,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Value: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Value] = [
    .noneInt32Value,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Enum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Enum] = [
    .noneInt64,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Value: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Value] = [
    .noneInt64Value,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int8: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int8] = [
    .noneInt8,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.integerLiteral: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.integerLiteral] = [
    .noneIntegerLiteral,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntegerLiteralType: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntegerLiteralType] = [
    .noneIntegerLiteralType,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.intern: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.intern] = [
    .noneIntern,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Internal: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Internal] = [
    .noneInternal,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.InternalState: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.InternalState] = [
    .noneInternalState,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.into: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.into] = [
    .noneInto,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ints: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ints] = [
    .noneInts,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isA: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isA] = [
    .noneIsA,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqual: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqual] = [
    .noneIsEqual,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqualTo: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqualTo] = [
    .noneIsEqualTo,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isInitializedEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isInitializedEnum] = [
    .noneIsInitialized,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.itemTagsEncodedSize: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.itemTagsEncodedSize] = [
    .noneItemTagsEncodedSize,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i_2166136261: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i_2166136261] = [
    .noneI2166136261,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecoder: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecoder] = [
    .noneJsondecoder,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingError: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingError] = [
    .noneJsondecodingError,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingOptions: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingOptions] = [
    .noneJsondecodingOptions,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonEncoder: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonEncoder] = [
    .noneJsonEncoder,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingError: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingError] = [
    .noneJsonencodingError,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingOptions: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingOptions] = [
    .noneJsonencodingOptions,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingVisitor: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingVisitor] = [
    .noneJsonencodingVisitor,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor] = [
    .noneJsonmapEncodingVisitor,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonName: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonName] = [
    .noneJsonName,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPath: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPath] = [
    .noneJsonPath,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPaths: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPaths] = [
    .noneJsonPaths,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONScanner: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONScanner] = [
    .noneJsonscanner,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonString: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonString] = [
    .noneJsonString,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonText: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonText] = [
    .noneJsonText,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonUTF8Data: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonUTF8Data] = [
    .noneJsonUtf8Data,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.k: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.k] = [
    .noneK,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Key: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Key] = [
    .noneKey,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.keyField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.keyField] = [
    .noneKeyField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.KeyType: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.KeyType] = [
    .noneKeyType,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.kind: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.kind] = [
    .noneKind,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.l: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.l] = [
    .noneL,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.length: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.length] = [
    .noneLength,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.letEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.letEnum] = [
    .noneLet,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lhs: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lhs] = [
    .noneLhs,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.list: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.list] = [
    .noneList,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listOfMessages: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listOfMessages] = [
    .noneListOfMessages,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listValue] = [
    .noneListValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndian: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndian] = [
    .noneLittleEndian,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndianBytes: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndianBytes] = [
    .noneLittleEndianBytes,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.localHasher: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.localHasher] = [
    .noneLocalHasher,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.M: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.M] = [
    .noneM,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.major: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.major] = [
    .noneMajor,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.makeIterator: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.makeIterator] = [
    .noneMakeIterator,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapHash: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapHash] = [
    .noneMapHash,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapKeyType: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapKeyType] = [
    .noneMapKeyType,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapNameResolver: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapNameResolver] = [
    .noneMapNameResolver,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapToMessages: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapToMessages] = [
    .noneMapToMessages,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapValueType: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapValueType] = [
    .noneMapValueType,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapVisitor: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapVisitor] = [
    .noneMapVisitor,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mdayStart: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mdayStart] = [
    .noneMdayStart,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.merge: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.merge] = [
    .noneMerge,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.message: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.message] = [
    .noneMessage,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageDepthLimit: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageDepthLimit] = [
    .noneMessageDepthLimit,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageExtension: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageExtension] = [
    .noneMessageExtension,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageImplementationBase: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageImplementationBase] = [
    .noneMessageImplementationBase,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageSet: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageSet] = [
    .noneMessageSet,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageType: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageType] = [
    .noneMessageType,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Method: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Method] = [
    .noneMethod,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.methods: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.methods] = [
    .noneMethods,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.minor: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.minor] = [
    .noneMinor,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Mixin: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Mixin] = [
    .noneMixin,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mixins: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mixins] = [
    .noneMixins,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.month: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.month] = [
    .noneMonth,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.msgExtension: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.msgExtension] = [
    .noneMsgExtension,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mutating: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mutating] = [
    .noneMutating,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.n: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.n] = [
    .oneN,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.name: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.name] = [
    .noneName,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameDescription: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameDescription] = [
    .noneNameDescription,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameMap: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameMap] = [
    .noneNameMap,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nameResolver: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nameResolver] = [
    .noneNameResolver,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.names: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.names] = [
    .noneNames,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nanos: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nanos] = [
    .noneNanos,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeBytes: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeBytes] = [
    .noneNativeBytes,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeEndianBytes: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeEndianBytes] = [
    .noneNativeEndianBytes,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newL: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newL] = [
    .noneNewL,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newList: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newList] = [
    .noneNewList,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newValue] = [
    .noneNewValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextByte: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextByte] = [
    .noneNextByte,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextFieldNumber: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextFieldNumber] = [
    .noneNextFieldNumber,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilEnum] = [
    .noneNil,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilLiteral: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilLiteral] = [
    .noneNilLiteral,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nullValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nullValue] = [
    .noneNullValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.number: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.number] = [
    .noneNumber,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.numberValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.numberValue] = [
    .noneNumberValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.of: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.of] = [
    .noneOf,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofIndex: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofIndex] = [
    .noneOneofIndex,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofs: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofs] = [
    .noneOneofs,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneOf_Kind: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneOf_Kind] = [
    .noneOneOfKind,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Option: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Option] = [
    .noneOption,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField] = [
    .noneOptionalEnumExtensionField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalExtensionField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalExtensionField] = [
    .noneOptionalExtensionField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField] = [
    .noneOptionalGroupExtensionField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField] = [
    .noneOptionalMessageExtensionField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.options: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.options] = [
    .noneOptions,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.other: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.other] = [
    .noneOther,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.others: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.others] = [
    .noneOthers,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.out: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.out] = [
    .noneOut,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.p: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.p] = [
    .noneP,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.packed: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.packed] = [
    .nonePacked,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedEnumExtensionField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedEnumExtensionField] = [
    .nonePackedEnumExtensionField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedExtensionField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedExtensionField] = [
    .nonePackedExtensionField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.packedSize: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.packedSize] = [
    .nonePackedSize,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.padding: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.padding] = [
    .nonePadding,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parent: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parent] = [
    .noneParent,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parse: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parse] = [
    .noneParse,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.partial: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.partial] = [
    .nonePartial,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.path: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.path] = [
    .nonePath,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.paths: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.paths] = [
    .nonePaths,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payload: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payload] = [
    .nonePayload,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payloadSize: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payloadSize] = [
    .nonePayloadSize,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pointer: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pointer] = [
    .nonePointer,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pos: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pos] = [
    .nonePos,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.prefix: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.prefix] = [
    .nonePrefix,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preserveProtoFieldNames: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preserveProtoFieldNames] = [
    .nonePreserveProtoFieldNames,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preTraverse: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preTraverse] = [
    .nonePreTraverse,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.printUnknownFields: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.printUnknownFields] = [
    .nonePrintUnknownFields,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto2: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto2] = [
    .noneProto2,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3DefaultValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3DefaultValue] = [
    .noneProto3DefaultValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck] = [
    .noneProtobufApiversionCheck,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2] = [
    .noneProtobufApiversion2,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBool: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBool] = [
    .noneProtobufBool,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBytes: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBytes] = [
    .noneProtobufBytes,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufDouble: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufDouble] = [
    .noneProtobufDouble,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufEnumMap: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufEnumMap] = [
    .noneProtobufEnumMap,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobufExtension: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobufExtension] = [
    .noneProtobufExtension,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed32: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed32] = [
    .noneProtobufFixed32,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed64: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed64] = [
    .noneProtobufFixed64,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFloat: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFloat] = [
    .noneProtobufFloat,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt32: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt32] = [
    .noneProtobufInt32,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt64: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt64] = [
    .noneProtobufInt64,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMap: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMap] = [
    .noneProtobufMap,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMessageMap: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMessageMap] = [
    .noneProtobufMessageMap,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed32: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed32] = [
    .noneProtobufSfixed32,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed64: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed64] = [
    .noneProtobufSfixed64,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt32: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt32] = [
    .noneProtobufSint32,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt64: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt64] = [
    .noneProtobufSint64,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufString: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufString] = [
    .noneProtobufString,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt32: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt32] = [
    .noneProtobufUint32,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt64: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt64] = [
    .noneProtobufUint64,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues] = [
    .noneProtobufExtensionFieldValues,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_fieldNumber: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_fieldNumber] = [
    .noneProtobufFieldNumber,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo] = [
    .noneProtobufGeneratedIsEqualTo,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_nameMap: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_nameMap] = [
    .noneProtobufNameMap,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_newField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_newField] = [
    .noneProtobufNewField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_package: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_package] = [
    .noneProtobufPackage,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protocolEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protocolEnum] = [
    .noneProtocol,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoFieldName: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoFieldName] = [
    .noneProtoFieldName,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoMessageNameEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoMessageNameEnum] = [
    .noneProtoMessageName,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtoNameProviding: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtoNameProviding] = [
    .noneProtoNameProviding,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoPaths: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoPaths] = [
    .noneProtoPaths,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicEnum] = [
    .nonePublic,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBoolValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBoolValue] = [
    .nonePutBoolValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBytesValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBytesValue] = [
    .nonePutBytesValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putDoubleValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putDoubleValue] = [
    .nonePutDoubleValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putEnumValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putEnumValue] = [
    .nonePutEnumValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt32: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt32] = [
    .nonePutFixedUint32,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt64: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt64] = [
    .nonePutFixedUint64,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFloatValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFloatValue] = [
    .nonePutFloatValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putInt64: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putInt64] = [
    .nonePutInt64,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putStringValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putStringValue] = [
    .nonePutStringValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64] = [
    .nonePutUint64,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64Hex: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64Hex] = [
    .nonePutUint64Hex,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putVarInt: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putVarInt] = [
    .nonePutVarInt,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putZigZagVarInt: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putZigZagVarInt] = [
    .nonePutZigZagVarInt,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rawChars: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rawChars] = [
    .noneRawChars,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawRepresentable: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawRepresentable] = [
    .noneRawRepresentable,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawValue] = [
    .noneRawValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.readBuffer: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.readBuffer] = [
    .noneReadBuffer,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.register: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.register] = [
    .noneRegister,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField] = [
    .noneRepeatedEnumExtensionField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedExtensionField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedExtensionField] = [
    .noneRepeatedExtensionField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField] = [
    .noneRepeatedGroupExtensionField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField] = [
    .noneRepeatedMessageExtensionField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestStreaming: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestStreaming] = [
    .noneRequestStreaming,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestTypeURL: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestTypeURL] = [
    .noneRequestTypeURL,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requiredSize: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requiredSize] = [
    .noneRequiredSize,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseStreaming: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseStreaming] = [
    .noneResponseStreaming,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseTypeURL: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseTypeURL] = [
    .noneResponseTypeURL,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.result: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.result] = [
    .noneResult,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rethrowsEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rethrowsEnum] = [
    .noneRethrows,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.returnEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.returnEnum] = [
    .noneReturn,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.revision: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.revision] = [
    .noneRevision,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rhs: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rhs] = [
    .noneRhs,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.root: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.root] = [
    .noneRoot,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.s: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.s] = [
    .noneS,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawBackslash: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawBackslash] = [
    .noneSawBackslash,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection4Characters: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection4Characters] = [
    .noneSawSection4Characters,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection5Characters: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection5Characters] = [
    .noneSawSection5Characters,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.scanner: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.scanner] = [
    .noneScanner,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.seconds: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.seconds] = [
    .noneSeconds,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.selfEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.selfEnum] = [
    .noneSelf,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.separator: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.separator] = [
    .noneSeparator,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serialize: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serialize] = [
    .noneSerialize,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedData: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedData] = [
    .noneSerializedData,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedSize: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedSize] = [
    .noneSerializedSize,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.set: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.set] = [
    .noneSet,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.setExtensionValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.setExtensionValue] = [
    .noneSetExtensionValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.shift: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.shift] = [
    .noneShift,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SimpleExtensionMap: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SimpleExtensionMap] = [
    .noneSimpleExtensionMap,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sizer: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sizer] = [
    .noneSizer,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.source: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.source] = [
    .noneSource,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceContext: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceContext] = [
    .noneSourceContext,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceEncoding: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceEncoding] = [
    .noneSourceEncoding,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.split: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.split] = [
    .noneSplit,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.start: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.start] = [
    .noneStart,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArray: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArray] = [
    .noneStartArray,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startField] = [
    .noneStartField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startIndex: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startIndex] = [
    .noneStartIndex,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startMessageField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startMessageField] = [
    .noneStartMessageField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startObject: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startObject] = [
    .noneStartObject,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startRegularField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startRegularField] = [
    .noneStartRegularField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.state: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.state] = [
    .noneState,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.staticEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.staticEnum] = [
    .noneStatic,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StaticString: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StaticString] = [
    .noneStaticString,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.storage: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.storage] = [
    .noneStorage,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringEnum] = [
    .noneString,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringLiteral: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringLiteral] = [
    .noneStringLiteral,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringLiteralType: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringLiteralType] = [
    .noneStringLiteralType,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringResult: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringResult] = [
    .noneStringResult,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringValue] = [
    .noneStringValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structEnum] = [
    .noneStruct,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structValue: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structValue] = [
    .noneStructValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subDecoder: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subDecoder] = [
    .noneSubDecoder,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subscriptEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subscriptEnum] = [
    .noneSubscript,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subVisitor: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subVisitor] = [
    .noneSubVisitor,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Swift: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Swift] = [
    .noneSwift,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SwiftProtobufEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SwiftProtobufEnum] = [
    .noneSwiftProtobuf,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.syntax: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.syntax] = [
    .noneSyntax,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.T: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.T] = [
    .noneT,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tag: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tag] = [
    .noneTag,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.terminator: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.terminator] = [
    .noneTerminator,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.testDecoder: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.testDecoder] = [
    .noneTestDecoder,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.text: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.text] = [
    .noneText,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textDecoder: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textDecoder] = [
    .noneTextDecoder,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecoder: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecoder] = [
    .noneTextFormatDecoder,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingError: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingError] = [
    .noneTextFormatDecodingError,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions] = [
    .noneTextFormatEncodingOptions,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor] = [
    .noneTextFormatEncodingVisitor,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textFormatString: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textFormatString] = [
    .noneTextFormatString,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.throwsEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.throwsEnum] = [
    .noneThrows,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeInterval: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeInterval] = [
    .noneTimeInterval,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSince1970: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSince1970] = [
    .noneTimeIntervalSince1970,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate] = [
    .noneTimeIntervalSinceReferenceDate,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Timestamp: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Timestamp] = [
    .noneTimestamp,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.to: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.to] = [
    .noneTo,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.total: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.total] = [
    .noneTotal,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalSize: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalSize] = [
    .noneTotalSize,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.traverseEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.traverseEnum] = [
    .noneTraverse,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trueEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trueEnum] = [
    .noneTrue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tryEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tryEnum] = [
    .noneTry,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.type: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.type] = [
    .noneType,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typealiasEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typealiasEnum] = [
    .noneTypealias,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typePrefix: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typePrefix] = [
    .noneTypePrefix,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeStart: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeStart] = [
    .noneTypeStart,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeUnknown: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeUnknown] = [
    .noneTypeUnknown,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeURL: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeURL] = [
    .noneTypeURL,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Enum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Enum] = [
    .noneUint32,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Value: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Value] = [
    .noneUint32Value,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Enum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Enum] = [
    .noneUint64,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Value: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Value] = [
    .noneUint64Value,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt8: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt8] = [
    .noneUint8,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalarLiteral: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalarLiteral] = [
    .noneUnicodeScalarLiteral,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType] = [
    .noneUnicodeScalarLiteralType,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalars: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalars] = [
    .noneUnicodeScalars,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarView: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarView] = [
    .noneUnicodeScalarView,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.union: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.union] = [
    .noneUnion,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uniqueStorage: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uniqueStorage] = [
    .noneUniqueStorage,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknown: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknown] = [
    .noneUnknown,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknownFieldsEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknownFieldsEnum] = [
    .noneUnknownFields,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnknownStorage: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnknownStorage] = [
    .noneUnknownStorage,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unpackTo: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unpackTo] = [
    .noneUnpackTo,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeBufferPointer: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeBufferPointer] = [
    .noneUnsafeBufferPointer,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutablePointer: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutablePointer] = [
    .noneUnsafeMutablePointer,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer] = [
    .noneUnsafeMutableRawBufferPointer,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafePointer: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafePointer] = [
    .noneUnsafePointer,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer] = [
    .noneUnsafeRawBufferPointer,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.updatedOptions: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.updatedOptions] = [
    .noneUpdatedOptions,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.url: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.url] = [
    .noneURL,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8] = [
    .noneUtf8,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8ToDouble: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8ToDouble] = [
    .noneUtf8ToDouble,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UTF8View: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UTF8View] = [
    .noneUtf8View,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.v: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.v] = [
    .noneV,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.value: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.value] = [
    .noneValue,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.valueField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.valueField] = [
    .noneValueField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.values: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.values] = [
    .noneValues,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ValueType: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ValueType] = [
    .noneValueType,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.varEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.varEnum] = [
    .noneVar,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Version: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Version] = [
    .noneVersion,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.versionString: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.versionString] = [
    .noneVersionString,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFields: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFields] = [
    .noneVisitExtensionFields,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet] = [
    .noneVisitExtensionFieldsAsMessageSet,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitMapField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitMapField] = [
    .noneVisitMapField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitor: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitor] = [
    .noneVisitor,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPacked: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPacked] = [
    .noneVisitPacked,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedBoolField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedBoolField] = [
    .noneVisitPackedBoolField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedDoubleField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedDoubleField] = [
    .noneVisitPackedDoubleField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedEnumField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedEnumField] = [
    .noneVisitPackedEnumField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed32Field] = [
    .noneVisitPackedFixed32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed64Field] = [
    .noneVisitPackedFixed64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFloatField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFloatField] = [
    .noneVisitPackedFloatField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt32Field] = [
    .noneVisitPackedInt32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt64Field] = [
    .noneVisitPackedInt64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field] = [
    .noneVisitPackedSfixed32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field] = [
    .noneVisitPackedSfixed64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt32Field] = [
    .noneVisitPackedSint32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt64Field] = [
    .noneVisitPackedSint64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt32Field] = [
    .noneVisitPackedUint32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt64Field] = [
    .noneVisitPackedUint64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeated: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeated] = [
    .noneVisitRepeated,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBoolField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBoolField] = [
    .noneVisitRepeatedBoolField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBytesField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBytesField] = [
    .noneVisitRepeatedBytesField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField] = [
    .noneVisitRepeatedDoubleField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedEnumField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedEnumField] = [
    .noneVisitRepeatedEnumField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field] = [
    .noneVisitRepeatedFixed32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field] = [
    .noneVisitRepeatedFixed64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFloatField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFloatField] = [
    .noneVisitRepeatedFloatField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedGroupField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedGroupField] = [
    .noneVisitRepeatedGroupField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field] = [
    .noneVisitRepeatedInt32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field] = [
    .noneVisitRepeatedInt64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedMessageField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedMessageField] = [
    .noneVisitRepeatedMessageField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field] = [
    .noneVisitRepeatedSfixed32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field] = [
    .noneVisitRepeatedSfixed64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field] = [
    .noneVisitRepeatedSint32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field] = [
    .noneVisitRepeatedSint64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedStringField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedStringField] = [
    .noneVisitRepeatedStringField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field] = [
    .noneVisitRepeatedUint32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field] = [
    .noneVisitRepeatedUint64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingular: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingular] = [
    .noneVisitSingular,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBoolField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBoolField] = [
    .noneVisitSingularBoolField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBytesField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBytesField] = [
    .noneVisitSingularBytesField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularDoubleField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularDoubleField] = [
    .noneVisitSingularDoubleField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularEnumField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularEnumField] = [
    .noneVisitSingularEnumField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed32Field] = [
    .noneVisitSingularFixed32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed64Field] = [
    .noneVisitSingularFixed64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFloatField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFloatField] = [
    .noneVisitSingularFloatField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularGroupField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularGroupField] = [
    .noneVisitSingularGroupField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt32Field] = [
    .noneVisitSingularInt32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt64Field] = [
    .noneVisitSingularInt64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularMessageField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularMessageField] = [
    .noneVisitSingularMessageField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field] = [
    .noneVisitSingularSfixed32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field] = [
    .noneVisitSingularSfixed64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt32Field] = [
    .noneVisitSingularSint32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt64Field] = [
    .noneVisitSingularSint64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularStringField: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularStringField] = [
    .noneVisitSingularStringField,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt32Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt32Field] = [
    .noneVisitSingularUint32Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt64Field: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt64Field] = [
    .noneVisitSingularUint64Field,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitUnknown: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitUnknown] = [
    .noneVisitUnknown,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wasDecoded: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wasDecoded] = [
    .noneWasDecoded,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.whereEnum: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.whereEnum] = [
    .noneWhere,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wireFormat: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wireFormat] = [
    .noneWireFormat,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.with: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.with] = [
    .noneWith,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeBytes: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeBytes] = [
    .noneWithUnsafeBytes,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes] = [
    .noneWithUnsafeMutableBytes,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.WrappedType: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.WrappedType] = [
    .noneWrappedType,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.written: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.written] = [
    .noneWritten,
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.yday: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.yday] = [
    .noneYday,
  ]
}

#endif  // swift(>=4.2)

// MARK: - Code below here is support for the SwiftProtobuf runtime.

fileprivate let _protobuf_package = "protobuf_unittest_generated"

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".GeneratedSwiftReservedEnums"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let _ = try decoder.nextFieldNumber() {
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedEnums, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedEnums) -> Bool {
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.adjusted: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_adjusted"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allCases: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_allCases"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allocate: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_allocate"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_alwaysPrintEnumsAsInts"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.any: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_any"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_AnyExtensionField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageExtension: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_AnyMessageExtension"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageStorage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_AnyMessageStorage"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyUnpackError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_AnyUnpackError"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Api: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Api"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appended: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_appended"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUIntHex: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_appendUIntHex"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUnknown: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_appendUnknown"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.areAllInitialized: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_areAllInitialized"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.array: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_array"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_arrayLiteral"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arraySeparator: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_arraySeparator"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_as"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_asciiOpenCurlyBracket"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiZero: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_asciiZero"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.assumingMemoryBound: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_assumingMemoryBound"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.available: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_available"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.b: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_b"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.base64Values: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_base64Values"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.baseAddress: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_baseAddress"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BaseType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_BaseType"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binary: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_binary"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_BinaryDecoder"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_BinaryDecodingError"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_BinaryDecodingOptions"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDelimited: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_BinaryDelimited"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_BinaryEncoder"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_BinaryEncodingError"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_BinaryEncodingMessageSetSizeVisitor"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_BinaryEncodingMessageSetVisitor"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_BinaryEncodingSizeVisitor"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_BinaryEncodingVisitor"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.body: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_body"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bodySize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_bodySize"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BoolEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Bool"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.booleanLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_booleanLiteral"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BooleanLiteralType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_BooleanLiteralType"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.boolValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_boolValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.buffer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_buffer"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_bytes"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesInGroup: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_bytesInGroup"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesRead: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_bytesRead"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BytesValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_BytesValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.c: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_c"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.capacity: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_capacity"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.capitalizeNext: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_capitalizeNext"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.cardinality: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_cardinality"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Character: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Character"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.chars: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_chars"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.classEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_class"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtensionValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_clearExtensionValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceContext: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_clearSourceContext"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_clearValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codeUnits: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_codeUnits"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Collection: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Collection"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.com: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_com"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.comma: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_comma"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.contentsOf: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_contentsOf"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.count: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_count"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.countVarintsInBuffer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_countVarintsInBuffer"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.customCodable: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_customCodable"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_CustomDebugStringConvertible"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.d: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_d"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DataEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Data"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dataResult: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_dataResult"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dataSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_dataSize"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.date: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_date"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daySec: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_daySec"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daysSinceEpoch: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_daysSinceEpoch"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.debugDescriptionEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_debugDescription"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoded: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decoded"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodedFromJSONNull: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodedFromJSONNull"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeExtensionField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeExtensionFieldsAsMessageSet"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeJSON: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeJSON"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMapField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeMapField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMessageEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeMessage"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decoder"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeated: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeated"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedBoolField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedBytesField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedDoubleField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedEnumField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedFixed32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedFixed64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedFloatField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedGroupField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedInt32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedInt64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedMessageField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedSFixed32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedSFixed64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedSInt32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedSInt64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedStringField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedStringField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedUInt32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeRepeatedUInt64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingular: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingular"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBoolField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularBoolField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBytesField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularBytesField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularDoubleField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularDoubleField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularEnumField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularEnumField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularFixed32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularFixed64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFloatField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularFloatField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularGroupField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularGroupField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularInt32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularInt64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularMessageField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularMessageField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularSFixed32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularSFixed64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularSInt32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularSInt64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularStringField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularStringField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularUInt32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeSingularUInt64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeTextFormat: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_decodeTextFormat"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_defaultAnyTypeURLPrefix"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_defaultValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.descriptionEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_description"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Dictionary: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Dictionary"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dictionaryLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_dictionaryLiteral"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_digit"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit0: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_digit0"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit1: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_digit1"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitCount: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_digitCount"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digits: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_digits"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_digitValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardableResult: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_discardableResult"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardUnknownFields: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_discardUnknownFields"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.distance: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_distance"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.double: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_double"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.doubleToUtf8: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_doubleToUtf8"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DoubleValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_DoubleValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Duration: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Duration"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.E: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_E"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Element: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Element"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.elements: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_elements"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitExtensionFieldName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_emitExtensionFieldName"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_emitFieldName"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldNumber: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_emitFieldNumber"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Empty: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Empty"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emptyData: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_emptyData"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoded: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_encoded"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedJSONString: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_encodedJSONString"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_encodedSize"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_encodeField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_encoder"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.end: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_end"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endArray: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_endArray"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endMessageField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_endMessageField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endObject: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_endObject"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endRegularField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_endRegularField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_enum"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumvalue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_enumvalue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Equatable: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Equatable"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Error: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Error"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ExpressibleByArrayLiteral"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ExpressibleByDictionaryLiteral"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ext: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ext"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extDecoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_extDecoder"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_extendedGraphemeClusterLiteral"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ExtendedGraphemeClusterLiteralType"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensibleMessage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ExtensibleMessage"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ExtensionField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionFieldNumber: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_extensionFieldNumber"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ExtensionFieldValueSet"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionMap: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ExtensionMap"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_extensions"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extras: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_extras"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.f: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_f"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.falseEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_false"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldData: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_fieldData"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldMask: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_FieldMask"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_fieldName"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNameCount: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_fieldNameCount"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_fieldNum"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumber: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_fieldNumber"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumberForProto: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_fieldNumberForProto"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fields: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_fields"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_fieldSize"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldTag: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_FieldTag"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_fieldType"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_fieldValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fileName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_fileName"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.filter: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_filter"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.firstItem: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_firstItem"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.float: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_float"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.floatLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_floatLiteral"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatLiteralType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_FloatLiteralType"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.floatToUtf8: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_floatToUtf8"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_FloatValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forMessageName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_forMessageName"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.formUnion: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_formUnion"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forReadingFrom: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_forReadingFrom"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forTypeURL: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_forTypeURL"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ForwardParser: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ForwardParser"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forWritingInto: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_forWritingInto"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.from: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_from"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii2: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_fromAscii2"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii4: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_fromAscii4"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromHexDigit: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_fromHexDigit"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.funcEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_func"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.G: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_G"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.get: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_get"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.getExtensionValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_getExtensionValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.googleapis: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_googleapis"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Any: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_Any"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Api: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_Api"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_BoolValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_BytesValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_DoubleValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_Duration"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_Empty"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_Enum"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_EnumValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_FieldMask"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_FloatValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_Int32Value"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_Int64Value"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_ListValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Method: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_Method"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_Mixin"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_NullValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Option: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_Option"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_SourceContext"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_StringValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_Struct"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_Syntax"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_Timestamp"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Type: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_Type"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_UInt32Value"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_UInt64Value"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Value: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Google_Protobuf_Value"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.group: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_group"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_groupSize"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.h: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_h"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.handleConflictingOneOf: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_handleConflictingOneOf"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtensionValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_hasExtensionValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hash: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_hash"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Hashable: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Hashable"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasher: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_hasher"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hashValueEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_hashValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.HashVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_HashVisitor"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceContext: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_hasSourceContext"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_hasValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hour: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_hour"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_i"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ignoreUnknownFields: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ignoreUnknownFields"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.index: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_index"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.initEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_init"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inoutEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_inout"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.insert: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_insert"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Int"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Enum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Int32"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Value: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Int32Value"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Enum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Int64"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Value: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Int64Value"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int8: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Int8"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.integerLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_integerLiteral"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntegerLiteralType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_IntegerLiteralType"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.intern: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_intern"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Internal: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Internal"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.InternalState: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_InternalState"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.into: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_into"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ints: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ints"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isA: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_isA"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqual: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_isEqual"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqualTo: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_isEqualTo"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isInitializedEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_isInitialized"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.itemTagsEncodedSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_itemTagsEncodedSize"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i_2166136261: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_i_2166136261"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_JSONDecoder"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_JSONDecodingError"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_JSONDecodingOptions"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonEncoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_jsonEncoder"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_JSONEncodingError"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_JSONEncodingOptions"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_JSONEncodingVisitor"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_JSONMapEncodingVisitor"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_jsonName"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPath: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_jsonPath"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPaths: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_jsonPaths"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONScanner: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_JSONScanner"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonString: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_jsonString"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonText: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_jsonText"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonUTF8Data: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_jsonUTF8Data"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.k: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_k"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Key: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Key"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.keyField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_keyField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.KeyType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_KeyType"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.kind: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_kind"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.l: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_l"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.length: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_length"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.letEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_let"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lhs: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_lhs"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.list: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_list"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listOfMessages: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_listOfMessages"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_listValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndian: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_littleEndian"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndianBytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_littleEndianBytes"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.localHasher: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_localHasher"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.M: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_M"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.major: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_major"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.makeIterator: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_makeIterator"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapHash: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_mapHash"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapKeyType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_MapKeyType"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapNameResolver: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_mapNameResolver"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapToMessages: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_mapToMessages"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapValueType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_MapValueType"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_mapVisitor"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mdayStart: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_mdayStart"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.merge: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_merge"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.message: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_message"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageDepthLimit: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_messageDepthLimit"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageExtension: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_MessageExtension"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageImplementationBase: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_MessageImplementationBase"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageSet: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_MessageSet"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_messageType"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Method: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Method"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.methods: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_methods"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.minor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_minor"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Mixin: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Mixin"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mixins: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_mixins"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.month: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_month"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.msgExtension: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_msgExtension"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mutating: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_mutating"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.n: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_n"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.name: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_name"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameDescription: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_NameDescription"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameMap: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_NameMap"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nameResolver: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_nameResolver"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.names: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_names"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nanos: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_nanos"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeBytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_nativeBytes"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeEndianBytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_nativeEndianBytes"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newL: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_newL"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newList: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_newList"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_newValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextByte: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_nextByte"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextFieldNumber: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_nextFieldNumber"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_nil"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_nilLiteral"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nullValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_nullValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.number: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_number"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.numberValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_numberValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.of: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_of"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofIndex: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_oneofIndex"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofs: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_oneofs"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneOf_Kind: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_OneOf_Kind"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Option: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Option"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_OptionalEnumExtensionField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_OptionalExtensionField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_OptionalGroupExtensionField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_OptionalMessageExtensionField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.options: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_options"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.other: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_other"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.others: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_others"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.out: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_out"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.p: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_p"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.packed: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_packed"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedEnumExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_PackedEnumExtensionField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_PackedExtensionField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.packedSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_packedSize"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.padding: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_padding"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parent: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_parent"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parse: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_parse"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.partial: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_partial"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.path: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_path"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.paths: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_paths"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payload: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_payload"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payloadSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_payloadSize"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pointer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_pointer"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pos: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_pos"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.prefix: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_prefix"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preserveProtoFieldNames: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_preserveProtoFieldNames"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preTraverse: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_preTraverse"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.printUnknownFields: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_printUnknownFields"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto2: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_proto2"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3DefaultValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_proto3DefaultValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufAPIVersionCheck"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufAPIVersion_2"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBool: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufBool"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufBytes"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufDouble: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufDouble"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufEnumMap: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufEnumMap"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobufExtension: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_protobufExtension"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed32: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufFixed32"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufFixed64"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFloat: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufFloat"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt32: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufInt32"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufInt64"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMap: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufMap"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMessageMap: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufMessageMap"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed32: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufSFixed32"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufSFixed64"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt32: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufSInt32"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufSInt64"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufString: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufString"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt32: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufUInt32"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtobufUInt64"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_protobuf_extensionFieldValues"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_fieldNumber: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_protobuf_fieldNumber"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_protobuf_generated_isEqualTo"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_nameMap: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_protobuf_nameMap"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_newField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_protobuf_newField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_package: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_protobuf_package"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protocolEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_protocol"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoFieldName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_protoFieldName"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoMessageNameEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_protoMessageName"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtoNameProviding: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ProtoNameProviding"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoPaths: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_protoPaths"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_public"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBoolValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_putBoolValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBytesValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_putBytesValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putDoubleValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_putDoubleValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putEnumValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_putEnumValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt32: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_putFixedUInt32"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_putFixedUInt64"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFloatValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_putFloatValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putInt64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_putInt64"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putStringValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_putStringValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_putUInt64"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64Hex: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_putUInt64Hex"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putVarInt: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_putVarInt"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putZigZagVarInt: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_putZigZagVarInt"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rawChars: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_rawChars"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawRepresentable: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_RawRepresentable"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_RawValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.readBuffer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_readBuffer"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.register: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_register"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_RepeatedEnumExtensionField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_RepeatedExtensionField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_RepeatedGroupExtensionField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_RepeatedMessageExtensionField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestStreaming: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_requestStreaming"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestTypeURL: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_requestTypeURL"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requiredSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_requiredSize"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseStreaming: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_responseStreaming"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseTypeURL: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_responseTypeURL"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.result: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_result"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rethrowsEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_rethrows"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.returnEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_return"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.revision: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_revision"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rhs: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_rhs"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.root: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_root"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.s: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_s"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawBackslash: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_sawBackslash"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection4Characters: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_sawSection4Characters"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection5Characters: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_sawSection5Characters"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.scanner: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_scanner"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.seconds: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_seconds"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.selfEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_self"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.separator: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_separator"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serialize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_serialize"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedData: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_serializedData"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_serializedSize"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.set: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_set"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.setExtensionValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_setExtensionValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.shift: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_shift"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SimpleExtensionMap: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_SimpleExtensionMap"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sizer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_sizer"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.source: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_source"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceContext: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_sourceContext"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceEncoding: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_sourceEncoding"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.split: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_split"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.start: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_start"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArray: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_startArray"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_startField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startIndex: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_startIndex"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startMessageField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_startMessageField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startObject: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_startObject"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startRegularField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_startRegularField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.state: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_state"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.staticEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_static"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StaticString: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_StaticString"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.storage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_storage"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_String"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_stringLiteral"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringLiteralType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_StringLiteralType"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringResult: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_stringResult"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_stringValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_struct"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_structValue"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subDecoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_subDecoder"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subscriptEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_subscript"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_subVisitor"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Swift: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Swift"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SwiftProtobufEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_SwiftProtobuf"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.syntax: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_syntax"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.T: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_T"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tag: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_tag"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.terminator: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_terminator"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.testDecoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_testDecoder"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.text: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_text"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textDecoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_textDecoder"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_TextFormatDecoder"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_TextFormatDecodingError"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_TextFormatEncodingOptions"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_TextFormatEncodingVisitor"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textFormatString: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_textFormatString"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.throwsEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_throws"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeInterval: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_timeInterval"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSince1970: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_timeIntervalSince1970"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_timeIntervalSinceReferenceDate"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Timestamp: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Timestamp"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.to: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_to"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.total: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_total"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_totalSize"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.traverseEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_traverse"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trueEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_true"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tryEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_try"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.type: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_type"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typealiasEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_typealias"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typePrefix: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_typePrefix"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeStart: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_typeStart"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeUnknown: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_typeUnknown"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeURL: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_typeURL"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Enum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_UInt32"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Value: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_UInt32Value"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Enum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_UInt64"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Value: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_UInt64Value"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt8: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_UInt8"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalarLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_unicodeScalarLiteral"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_UnicodeScalarLiteralType"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalars: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_unicodeScalars"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarView: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_UnicodeScalarView"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.union: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_union"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uniqueStorage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_uniqueStorage"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknown: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_unknown"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknownFieldsEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_unknownFields"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnknownStorage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_UnknownStorage"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unpackTo: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_unpackTo"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeBufferPointer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_UnsafeBufferPointer"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutablePointer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_UnsafeMutablePointer"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_UnsafeMutableRawBufferPointer"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafePointer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_UnsafePointer"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_UnsafeRawBufferPointer"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.updatedOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_updatedOptions"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.url: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_url"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_utf8"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8ToDouble: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_utf8ToDouble"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UTF8View: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_UTF8View"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.v: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_v"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.value: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_value"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.valueField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_valueField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.values: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_values"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ValueType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_ValueType"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.varEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_var"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Version: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_Version"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.versionString: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_versionString"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFields: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitExtensionFields"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitExtensionFieldsAsMessageSet"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitMapField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitMapField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitor"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPacked: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitPacked"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedBoolField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitPackedBoolField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedDoubleField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitPackedDoubleField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedEnumField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitPackedEnumField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitPackedFixed32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitPackedFixed64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFloatField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitPackedFloatField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitPackedInt32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitPackedInt64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitPackedSFixed32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitPackedSFixed64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitPackedSInt32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitPackedSInt64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitPackedUInt32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitPackedUInt64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeated: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeated"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBoolField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedBoolField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBytesField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedBytesField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedDoubleField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedEnumField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedEnumField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedFixed32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedFixed64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFloatField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedFloatField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedGroupField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedGroupField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedInt32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedInt64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedMessageField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedMessageField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedSFixed32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedSFixed64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedSInt32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedSInt64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedStringField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedStringField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedUInt32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitRepeatedUInt64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingular: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingular"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBoolField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularBoolField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBytesField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularBytesField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularDoubleField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularDoubleField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularEnumField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularEnumField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularFixed32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularFixed64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFloatField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularFloatField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularGroupField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularGroupField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularInt32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularInt64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularMessageField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularMessageField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularSFixed32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularSFixed64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularSInt32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularSInt64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularStringField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularStringField"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularUInt32Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitSingularUInt64Field"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitUnknown: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_visitUnknown"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wasDecoded: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_wasDecoded"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.whereEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_where"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wireFormat: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_wireFormat"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.with: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_with"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeBytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_withUnsafeBytes"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_withUnsafeMutableBytes"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.WrappedType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_WrappedType"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.written: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_written"),
  ]
}

extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.yday: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NONE_yday"),
  ]
}