/// Generated by the Protocol Buffers 3.6.0 compiler.  DO NOT EDIT!
/// Protobuf-swift version: 4.0.0
/// Source file "unittest_no_arena.proto"
/// Syntax "Proto2"

import Foundation
import ProtocolBuffers


public struct ProtobufUnittestNoArena { }

public extension ProtobufUnittestNoArena {
    public struct UnittestNoArenaRoot {
        public static let `default` = UnittestNoArenaRoot()
        public var extensionRegistry:ExtensionRegistry

        init() {
            extensionRegistry = ExtensionRegistry()
            registerAllExtensions(registry: extensionRegistry)
            ProtobufUnittestImport.UnittestImportRoot.default.registerAllExtensions(registry: extensionRegistry)
            Proto2ArenaUnittest.UnittestArenaRoot.default.registerAllExtensions(registry: extensionRegistry)
        }
        public func registerAllExtensions(registry: ExtensionRegistry) {
        }
    }



    //Enum type declaration start 

    public enum ForeignEnum:Int32, GeneratedEnum {
        case foreignFoo = 4
        case foreignBar = 5
        case foreignBaz = 6
        public func toString() -> String {
            switch self {
            case .foreignFoo: return "FOREIGN_FOO"
            case .foreignBar: return "FOREIGN_BAR"
            case .foreignBaz: return "FOREIGN_BAZ"
            }
        }
        public static func fromString(_ str:String) throws -> ProtobufUnittestNoArena.ForeignEnum {
            switch str {
            case "FOREIGN_FOO":    return .foreignFoo
            case "FOREIGN_BAR":    return .foreignBar
            case "FOREIGN_BAZ":    return .foreignBaz
            default: throw ProtocolBuffersError.invalidProtocolBuffer("Conversion failed.")
            }
        }
        public var debugDescription:String { return getDescription() }
        public var description:String { return getDescription() }
        private func getDescription() -> String { 
            switch self {
            case .foreignFoo: return ".foreignFoo"
            case .foreignBar: return ".foreignBar"
            case .foreignBaz: return ".foreignBaz"
            }
        }
        public var hashValue:Int {
            return self.rawValue.hashValue
        }
        public static func ==(lhs:ForeignEnum, rhs:ForeignEnum) -> Bool {
            return lhs.hashValue == rhs.hashValue
        }
    }

    //Enum type declaration end 

    /// This proto includes every type of field in both singular and repeated
    /// forms.
    final public class TestAllTypes : GeneratedMessage {
        public typealias BuilderType = ProtobufUnittestNoArena.TestAllTypes.Builder

        public static func == (lhs: ProtobufUnittestNoArena.TestAllTypes, rhs: ProtobufUnittestNoArena.TestAllTypes) -> Bool {
            if lhs === rhs {
                return true
            }
            var fieldCheck:Bool = (lhs.hashValue == rhs.hashValue)
            fieldCheck = fieldCheck && (lhs.hasOptionalInt32 == rhs.hasOptionalInt32) && (!lhs.hasOptionalInt32 || lhs.optionalInt32 == rhs.optionalInt32)
            fieldCheck = fieldCheck && (lhs.hasOptionalInt64 == rhs.hasOptionalInt64) && (!lhs.hasOptionalInt64 || lhs.optionalInt64 == rhs.optionalInt64)
            fieldCheck = fieldCheck && (lhs.hasOptionalUint32 == rhs.hasOptionalUint32) && (!lhs.hasOptionalUint32 || lhs.optionalUint32 == rhs.optionalUint32)
            fieldCheck = fieldCheck && (lhs.hasOptionalUint64 == rhs.hasOptionalUint64) && (!lhs.hasOptionalUint64 || lhs.optionalUint64 == rhs.optionalUint64)
            fieldCheck = fieldCheck && (lhs.hasOptionalSint32 == rhs.hasOptionalSint32) && (!lhs.hasOptionalSint32 || lhs.optionalSint32 == rhs.optionalSint32)
            fieldCheck = fieldCheck && (lhs.hasOptionalSint64 == rhs.hasOptionalSint64) && (!lhs.hasOptionalSint64 || lhs.optionalSint64 == rhs.optionalSint64)
            fieldCheck = fieldCheck && (lhs.hasOptionalFixed32 == rhs.hasOptionalFixed32) && (!lhs.hasOptionalFixed32 || lhs.optionalFixed32 == rhs.optionalFixed32)
            fieldCheck = fieldCheck && (lhs.hasOptionalFixed64 == rhs.hasOptionalFixed64) && (!lhs.hasOptionalFixed64 || lhs.optionalFixed64 == rhs.optionalFixed64)
            fieldCheck = fieldCheck && (lhs.hasOptionalSfixed32 == rhs.hasOptionalSfixed32) && (!lhs.hasOptionalSfixed32 || lhs.optionalSfixed32 == rhs.optionalSfixed32)
            fieldCheck = fieldCheck && (lhs.hasOptionalSfixed64 == rhs.hasOptionalSfixed64) && (!lhs.hasOptionalSfixed64 || lhs.optionalSfixed64 == rhs.optionalSfixed64)
            fieldCheck = fieldCheck && (lhs.hasOptionalFloat == rhs.hasOptionalFloat) && (!lhs.hasOptionalFloat || lhs.optionalFloat == rhs.optionalFloat)
            fieldCheck = fieldCheck && (lhs.hasOptionalDouble == rhs.hasOptionalDouble) && (!lhs.hasOptionalDouble || lhs.optionalDouble == rhs.optionalDouble)
            fieldCheck = fieldCheck && (lhs.hasOptionalBool == rhs.hasOptionalBool) && (!lhs.hasOptionalBool || lhs.optionalBool == rhs.optionalBool)
            fieldCheck = fieldCheck && (lhs.hasOptionalString == rhs.hasOptionalString) && (!lhs.hasOptionalString || lhs.optionalString == rhs.optionalString)
            fieldCheck = fieldCheck && (lhs.hasOptionalBytes == rhs.hasOptionalBytes) && (!lhs.hasOptionalBytes || lhs.optionalBytes == rhs.optionalBytes)
            fieldCheck = fieldCheck && (lhs.hasOptionalGroup == rhs.hasOptionalGroup) && (!lhs.hasOptionalGroup || lhs.optionalGroup == rhs.optionalGroup)
            fieldCheck = fieldCheck && (lhs.hasOptionalNestedMessage == rhs.hasOptionalNestedMessage) && (!lhs.hasOptionalNestedMessage || lhs.optionalNestedMessage == rhs.optionalNestedMessage)
            fieldCheck = fieldCheck && (lhs.hasOptionalForeignMessage == rhs.hasOptionalForeignMessage) && (!lhs.hasOptionalForeignMessage || lhs.optionalForeignMessage == rhs.optionalForeignMessage)
            fieldCheck = fieldCheck && (lhs.hasOptionalImportMessage == rhs.hasOptionalImportMessage) && (!lhs.hasOptionalImportMessage || lhs.optionalImportMessage == rhs.optionalImportMessage)
            fieldCheck = fieldCheck && (lhs.hasOptionalNestedEnum == rhs.hasOptionalNestedEnum) && (!lhs.hasOptionalNestedEnum || lhs.optionalNestedEnum == rhs.optionalNestedEnum)
            fieldCheck = fieldCheck && (lhs.hasOptionalForeignEnum == rhs.hasOptionalForeignEnum) && (!lhs.hasOptionalForeignEnum || lhs.optionalForeignEnum == rhs.optionalForeignEnum)
            fieldCheck = fieldCheck && (lhs.hasOptionalImportEnum == rhs.hasOptionalImportEnum) && (!lhs.hasOptionalImportEnum || lhs.optionalImportEnum == rhs.optionalImportEnum)
            fieldCheck = fieldCheck && (lhs.hasOptionalStringPiece == rhs.hasOptionalStringPiece) && (!lhs.hasOptionalStringPiece || lhs.optionalStringPiece == rhs.optionalStringPiece)
            fieldCheck = fieldCheck && (lhs.hasOptionalCord == rhs.hasOptionalCord) && (!lhs.hasOptionalCord || lhs.optionalCord == rhs.optionalCord)
            fieldCheck = fieldCheck && (lhs.hasOptionalPublicImportMessage == rhs.hasOptionalPublicImportMessage) && (!lhs.hasOptionalPublicImportMessage || lhs.optionalPublicImportMessage == rhs.optionalPublicImportMessage)
            fieldCheck = fieldCheck && (lhs.hasOptionalMessage == rhs.hasOptionalMessage) && (!lhs.hasOptionalMessage || lhs.optionalMessage == rhs.optionalMessage)
            fieldCheck = fieldCheck && (lhs.repeatedInt32 == rhs.repeatedInt32)
            fieldCheck = fieldCheck && (lhs.repeatedInt64 == rhs.repeatedInt64)
            fieldCheck = fieldCheck && (lhs.repeatedUint32 == rhs.repeatedUint32)
            fieldCheck = fieldCheck && (lhs.repeatedUint64 == rhs.repeatedUint64)
            fieldCheck = fieldCheck && (lhs.repeatedSint32 == rhs.repeatedSint32)
            fieldCheck = fieldCheck && (lhs.repeatedSint64 == rhs.repeatedSint64)
            fieldCheck = fieldCheck && (lhs.repeatedFixed32 == rhs.repeatedFixed32)
            fieldCheck = fieldCheck && (lhs.repeatedFixed64 == rhs.repeatedFixed64)
            fieldCheck = fieldCheck && (lhs.repeatedSfixed32 == rhs.repeatedSfixed32)
            fieldCheck = fieldCheck && (lhs.repeatedSfixed64 == rhs.repeatedSfixed64)
            fieldCheck = fieldCheck && (lhs.repeatedFloat == rhs.repeatedFloat)
            fieldCheck = fieldCheck && (lhs.repeatedDouble == rhs.repeatedDouble)
            fieldCheck = fieldCheck && (lhs.repeatedBool == rhs.repeatedBool)
            fieldCheck = fieldCheck && (lhs.repeatedString == rhs.repeatedString)
            fieldCheck = fieldCheck && (lhs.repeatedBytes == rhs.repeatedBytes)
            fieldCheck = fieldCheck && (lhs.repeatedGroup == rhs.repeatedGroup)
            fieldCheck = fieldCheck && (lhs.repeatedNestedMessage == rhs.repeatedNestedMessage)
            fieldCheck = fieldCheck && (lhs.repeatedForeignMessage == rhs.repeatedForeignMessage)
            fieldCheck = fieldCheck && (lhs.repeatedImportMessage == rhs.repeatedImportMessage)
            fieldCheck = fieldCheck && (lhs.repeatedNestedEnum == rhs.repeatedNestedEnum)
            fieldCheck = fieldCheck && (lhs.repeatedForeignEnum == rhs.repeatedForeignEnum)
            fieldCheck = fieldCheck && (lhs.repeatedImportEnum == rhs.repeatedImportEnum)
            fieldCheck = fieldCheck && (lhs.repeatedStringPiece == rhs.repeatedStringPiece)
            fieldCheck = fieldCheck && (lhs.repeatedCord == rhs.repeatedCord)
            fieldCheck = fieldCheck && (lhs.repeatedLazyMessage == rhs.repeatedLazyMessage)
            fieldCheck = fieldCheck && (lhs.hasDefaultInt32 == rhs.hasDefaultInt32) && (!lhs.hasDefaultInt32 || lhs.defaultInt32 == rhs.defaultInt32)
            fieldCheck = fieldCheck && (lhs.hasDefaultInt64 == rhs.hasDefaultInt64) && (!lhs.hasDefaultInt64 || lhs.defaultInt64 == rhs.defaultInt64)
            fieldCheck = fieldCheck && (lhs.hasDefaultUint32 == rhs.hasDefaultUint32) && (!lhs.hasDefaultUint32 || lhs.defaultUint32 == rhs.defaultUint32)
            fieldCheck = fieldCheck && (lhs.hasDefaultUint64 == rhs.hasDefaultUint64) && (!lhs.hasDefaultUint64 || lhs.defaultUint64 == rhs.defaultUint64)
            fieldCheck = fieldCheck && (lhs.hasDefaultSint32 == rhs.hasDefaultSint32) && (!lhs.hasDefaultSint32 || lhs.defaultSint32 == rhs.defaultSint32)
            fieldCheck = fieldCheck && (lhs.hasDefaultSint64 == rhs.hasDefaultSint64) && (!lhs.hasDefaultSint64 || lhs.defaultSint64 == rhs.defaultSint64)
            fieldCheck = fieldCheck && (lhs.hasDefaultFixed32 == rhs.hasDefaultFixed32) && (!lhs.hasDefaultFixed32 || lhs.defaultFixed32 == rhs.defaultFixed32)
            fieldCheck = fieldCheck && (lhs.hasDefaultFixed64 == rhs.hasDefaultFixed64) && (!lhs.hasDefaultFixed64 || lhs.defaultFixed64 == rhs.defaultFixed64)
            fieldCheck = fieldCheck && (lhs.hasDefaultSfixed32 == rhs.hasDefaultSfixed32) && (!lhs.hasDefaultSfixed32 || lhs.defaultSfixed32 == rhs.defaultSfixed32)
            fieldCheck = fieldCheck && (lhs.hasDefaultSfixed64 == rhs.hasDefaultSfixed64) && (!lhs.hasDefaultSfixed64 || lhs.defaultSfixed64 == rhs.defaultSfixed64)
            fieldCheck = fieldCheck && (lhs.hasDefaultFloat == rhs.hasDefaultFloat) && (!lhs.hasDefaultFloat || lhs.defaultFloat == rhs.defaultFloat)
            fieldCheck = fieldCheck && (lhs.hasDefaultDouble == rhs.hasDefaultDouble) && (!lhs.hasDefaultDouble || lhs.defaultDouble == rhs.defaultDouble)
            fieldCheck = fieldCheck && (lhs.hasDefaultBool == rhs.hasDefaultBool) && (!lhs.hasDefaultBool || lhs.defaultBool == rhs.defaultBool)
            fieldCheck = fieldCheck && (lhs.hasDefaultString == rhs.hasDefaultString) && (!lhs.hasDefaultString || lhs.defaultString == rhs.defaultString)
            fieldCheck = fieldCheck && (lhs.hasDefaultBytes == rhs.hasDefaultBytes) && (!lhs.hasDefaultBytes || lhs.defaultBytes == rhs.defaultBytes)
            fieldCheck = fieldCheck && (lhs.hasDefaultNestedEnum == rhs.hasDefaultNestedEnum) && (!lhs.hasDefaultNestedEnum || lhs.defaultNestedEnum == rhs.defaultNestedEnum)
            fieldCheck = fieldCheck && (lhs.hasDefaultForeignEnum == rhs.hasDefaultForeignEnum) && (!lhs.hasDefaultForeignEnum || lhs.defaultForeignEnum == rhs.defaultForeignEnum)
            fieldCheck = fieldCheck && (lhs.hasDefaultImportEnum == rhs.hasDefaultImportEnum) && (!lhs.hasDefaultImportEnum || lhs.defaultImportEnum == rhs.defaultImportEnum)
            fieldCheck = fieldCheck && (lhs.hasDefaultStringPiece == rhs.hasDefaultStringPiece) && (!lhs.hasDefaultStringPiece || lhs.defaultStringPiece == rhs.defaultStringPiece)
            fieldCheck = fieldCheck && (lhs.hasDefaultCord == rhs.hasDefaultCord) && (!lhs.hasDefaultCord || lhs.defaultCord == rhs.defaultCord)
            fieldCheck = fieldCheck && (lhs.hasOneofUint32 == rhs.hasOneofUint32) && (!lhs.hasOneofUint32 || lhs.oneofUint32 == rhs.oneofUint32)
            fieldCheck = fieldCheck && (lhs.hasOneofNestedMessage == rhs.hasOneofNestedMessage) && (!lhs.hasOneofNestedMessage || lhs.oneofNestedMessage == rhs.oneofNestedMessage)
            fieldCheck = fieldCheck && (lhs.hasOneofString == rhs.hasOneofString) && (!lhs.hasOneofString || lhs.oneofString == rhs.oneofString)
            fieldCheck = fieldCheck && (lhs.hasOneofBytes == rhs.hasOneofBytes) && (!lhs.hasOneofBytes || lhs.oneofBytes == rhs.oneofBytes)
            fieldCheck = fieldCheck && (lhs.hasLazyOneofNestedMessage == rhs.hasLazyOneofNestedMessage) && (!lhs.hasLazyOneofNestedMessage || lhs.lazyOneofNestedMessage == rhs.lazyOneofNestedMessage)
            fieldCheck = (fieldCheck && (lhs.unknownFields == rhs.unknownFields))
            return fieldCheck
        }



        //Nested type declaration start

        final public class NestedMessage : GeneratedMessage {
            public typealias BuilderType = ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder

            public static func == (lhs: ProtobufUnittestNoArena.TestAllTypes.NestedMessage, rhs: ProtobufUnittestNoArena.TestAllTypes.NestedMessage) -> Bool {
                if lhs === rhs {
                    return true
                }
                var fieldCheck:Bool = (lhs.hashValue == rhs.hashValue)
                fieldCheck = fieldCheck && (lhs.hasBb == rhs.hasBb) && (!lhs.hasBb || lhs.bb == rhs.bb)
                fieldCheck = (fieldCheck && (lhs.unknownFields == rhs.unknownFields))
                return fieldCheck
            }

            /// The field name "b" fails to compile in proto1 because it conflicts with
            /// a local variable named "b" in one of the generated methods.  Doh.
            /// This file needs to compile in proto1 to test backwards-compatibility.
            public fileprivate(set) var bb:Int32! = nil
            public fileprivate(set) var hasBb:Bool = false

            required public init() {
                super.init()
            }
            override public func isInitialized() throws {
            }
            override public func writeTo(codedOutputStream: CodedOutputStream) throws {
                if hasBb {
                    try codedOutputStream.writeInt32(fieldNumber: 1, value:bb)
                }
                try unknownFields.writeTo(codedOutputStream: codedOutputStream)
            }
            override public func serializedSize() -> Int32 {
                var serialize_size:Int32 = memoizedSerializedSize
                if serialize_size != -1 {
                 return serialize_size
                }

                serialize_size = 0
                if hasBb {
                    serialize_size += bb.computeInt32Size(fieldNumber: 1)
                }
                serialize_size += unknownFields.serializedSize()
                memoizedSerializedSize = serialize_size
                return serialize_size
            }
            public class func getBuilder() -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder {
                return ProtobufUnittestNoArena.TestAllTypes.NestedMessage.classBuilder() as! ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder
            }
            public func getBuilder() -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder {
                return classBuilder() as! ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder
            }
            override public class func classBuilder() -> ProtocolBuffersMessageBuilder {
                return ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder()
            }
            override public func classBuilder() -> ProtocolBuffersMessageBuilder {
                return ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder()
            }
            public func toBuilder() throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder {
                return try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.builderWithPrototype(prototype:self)
            }
            public class func builderWithPrototype(prototype:ProtobufUnittestNoArena.TestAllTypes.NestedMessage) throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder {
                return try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder().mergeFrom(other:prototype)
            }
            override public func encode() throws -> Dictionary<String,Any> {
                try isInitialized()
                var jsonMap:Dictionary<String,Any> = Dictionary<String,Any>()
                if hasBb {
                    jsonMap["bb"] = Int(bb)
                }
                return jsonMap
            }
            override class public func decode(jsonMap:Dictionary<String,Any>) throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage {
                return try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder.decodeToBuilder(jsonMap:jsonMap).build()
            }
            override class public func fromJSON(data:Data, options: JSONSerialization.ReadingOptions = []) throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage {
                return try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder.fromJSONToBuilder(data:data, options:options).build()
            }
            override public func getDescription(indent:String) throws -> String {
                var output = ""
                if hasBb {
                    output += "\(indent) bb: \(String(describing: bb)) \n"
                }
                output += unknownFields.getDescription(indent: indent)
                return output
            }
            override public var hashValue:Int {
                get {
                    var hashCode:Int = 7
                    if hasBb {
                        hashCode = (hashCode &* 31) &+ bb.hashValue
                    }
                    hashCode = (hashCode &* 31) &+  unknownFields.hashValue
                    return hashCode
                }
            }


            //Meta information declaration start

            override public class func className() -> String {
                return "ProtobufUnittestNoArena.TestAllTypes.NestedMessage"
            }
            override public func className() -> String {
                return "ProtobufUnittestNoArena.TestAllTypes.NestedMessage"
            }
            //Meta information declaration end

            final public class Builder : GeneratedMessageBuilder {
                fileprivate var builderResult:ProtobufUnittestNoArena.TestAllTypes.NestedMessage = ProtobufUnittestNoArena.TestAllTypes.NestedMessage()
                public func getMessage() -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage {
                    return builderResult
                }

                required override public init () {
                    super.init()
                }
                /// The field name "b" fails to compile in proto1 because it conflicts with
                /// a local variable named "b" in one of the generated methods.  Doh.
                /// This file needs to compile in proto1 to test backwards-compatibility.
                public var bb:Int32 {
                    get {
                        return builderResult.bb
                    }
                    set (value) {
                        builderResult.hasBb = true
                        builderResult.bb = value
                    }
                }
                public var hasBb:Bool {
                    get {
                        return builderResult.hasBb
                    }
                }
                @discardableResult
                public func setBb(_ value:Int32) -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder {
                    self.bb = value
                    return self
                }
                @discardableResult
                public func clearBb() -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder{
                    builderResult.hasBb = false
                    builderResult.bb = nil
                    return self
                }
                override public var internalGetResult:GeneratedMessage {
                    get {
                        return builderResult
                    }
                }
                @discardableResult
                override public func clear() -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder {
                    builderResult = ProtobufUnittestNoArena.TestAllTypes.NestedMessage()
                    return self
                }
                override public func clone() throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder {
                    return try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.builderWithPrototype(prototype:builderResult)
                }
                override public func build() throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage {
                    try checkInitialized()
                    return buildPartial()
                }
                public func buildPartial() -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage {
                    let returnMe:ProtobufUnittestNoArena.TestAllTypes.NestedMessage = builderResult
                    return returnMe
                }
                @discardableResult
                public func mergeFrom(other:ProtobufUnittestNoArena.TestAllTypes.NestedMessage) throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder {
                    if other == ProtobufUnittestNoArena.TestAllTypes.NestedMessage() {
                        return self
                    }
                    if other.hasBb {
                        bb = other.bb
                    }
                    try merge(unknownField: other.unknownFields)
                    return self
                }
                @discardableResult
                override public func mergeFrom(codedInputStream: CodedInputStream) throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder {
                    return try mergeFrom(codedInputStream: codedInputStream, extensionRegistry:ExtensionRegistry())
                }
                @discardableResult
                override public func mergeFrom(codedInputStream: CodedInputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder {
                    let unknownFieldsBuilder:UnknownFieldSet.Builder = try UnknownFieldSet.builderWithUnknownFields(copyFrom:self.unknownFields)
                    while (true) {
                        let protobufTag = try codedInputStream.readTag()
                        switch protobufTag {
                        case 0: 
                            self.unknownFields = try unknownFieldsBuilder.build()
                            return self

                        case 8:
                            bb = try codedInputStream.readInt32()

                        default:
                            if (!(try parse(codedInputStream:codedInputStream, unknownFields:unknownFieldsBuilder, extensionRegistry:extensionRegistry, tag:protobufTag))) {
                                unknownFields = try unknownFieldsBuilder.build()
                                return self
                            }
                        }
                    }
                }
                class override public func decodeToBuilder(jsonMap:Dictionary<String,Any>) throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder {
                    let resultDecodedBuilder = ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder()
                    if let jsonValueBb = jsonMap["bb"] as? Int {
                        resultDecodedBuilder.bb = Int32(jsonValueBb)
                    } else if let jsonValueBb = jsonMap["bb"] as? String {
                        resultDecodedBuilder.bb = Int32(jsonValueBb)!
                    }
                    return resultDecodedBuilder
                }
                override class public func fromJSONToBuilder(data:Data, options: JSONSerialization.ReadingOptions = []) throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder {
                    let jsonData = try JSONSerialization.jsonObject(with:data, options: options)
                    guard let jsDataCast = jsonData as? Dictionary<String,Any> else {
                      throw ProtocolBuffersError.invalidProtocolBuffer("Invalid JSON data")
                    }
                    return try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder.decodeToBuilder(jsonMap:jsDataCast)
                }
            }

        }

        //Nested type declaration end



        //Nested type declaration start

        final public class OptionalGroup : GeneratedMessage {
            public typealias BuilderType = ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder

            public static func == (lhs: ProtobufUnittestNoArena.TestAllTypes.OptionalGroup, rhs: ProtobufUnittestNoArena.TestAllTypes.OptionalGroup) -> Bool {
                if lhs === rhs {
                    return true
                }
                var fieldCheck:Bool = (lhs.hashValue == rhs.hashValue)
                fieldCheck = fieldCheck && (lhs.hasA == rhs.hasA) && (!lhs.hasA || lhs.a == rhs.a)
                fieldCheck = (fieldCheck && (lhs.unknownFields == rhs.unknownFields))
                return fieldCheck
            }

            public fileprivate(set) var a:Int32! = nil
            public fileprivate(set) var hasA:Bool = false

            required public init() {
                super.init()
            }
            override public func isInitialized() throws {
            }
            override public func writeTo(codedOutputStream: CodedOutputStream) throws {
                if hasA {
                    try codedOutputStream.writeInt32(fieldNumber: 17, value:a)
                }
                try unknownFields.writeTo(codedOutputStream: codedOutputStream)
            }
            override public func serializedSize() -> Int32 {
                var serialize_size:Int32 = memoizedSerializedSize
                if serialize_size != -1 {
                 return serialize_size
                }

                serialize_size = 0
                if hasA {
                    serialize_size += a.computeInt32Size(fieldNumber: 17)
                }
                serialize_size += unknownFields.serializedSize()
                memoizedSerializedSize = serialize_size
                return serialize_size
            }
            public class func getBuilder() -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder {
                return ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.classBuilder() as! ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder
            }
            public func getBuilder() -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder {
                return classBuilder() as! ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder
            }
            override public class func classBuilder() -> ProtocolBuffersMessageBuilder {
                return ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder()
            }
            override public func classBuilder() -> ProtocolBuffersMessageBuilder {
                return ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder()
            }
            public func toBuilder() throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder {
                return try ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.builderWithPrototype(prototype:self)
            }
            public class func builderWithPrototype(prototype:ProtobufUnittestNoArena.TestAllTypes.OptionalGroup) throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder {
                return try ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder().mergeFrom(other:prototype)
            }
            override public func encode() throws -> Dictionary<String,Any> {
                try isInitialized()
                var jsonMap:Dictionary<String,Any> = Dictionary<String,Any>()
                if hasA {
                    jsonMap["a"] = Int(a)
                }
                return jsonMap
            }
            override class public func decode(jsonMap:Dictionary<String,Any>) throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup {
                return try ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder.decodeToBuilder(jsonMap:jsonMap).build()
            }
            override class public func fromJSON(data:Data, options: JSONSerialization.ReadingOptions = []) throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup {
                return try ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder.fromJSONToBuilder(data:data, options:options).build()
            }
            override public func getDescription(indent:String) throws -> String {
                var output = ""
                if hasA {
                    output += "\(indent) a: \(String(describing: a)) \n"
                }
                output += unknownFields.getDescription(indent: indent)
                return output
            }
            override public var hashValue:Int {
                get {
                    var hashCode:Int = 7
                    if hasA {
                        hashCode = (hashCode &* 31) &+ a.hashValue
                    }
                    hashCode = (hashCode &* 31) &+  unknownFields.hashValue
                    return hashCode
                }
            }


            //Meta information declaration start

            override public class func className() -> String {
                return "ProtobufUnittestNoArena.TestAllTypes.OptionalGroup"
            }
            override public func className() -> String {
                return "ProtobufUnittestNoArena.TestAllTypes.OptionalGroup"
            }
            //Meta information declaration end

            final public class Builder : GeneratedMessageBuilder {
                fileprivate var builderResult:ProtobufUnittestNoArena.TestAllTypes.OptionalGroup = ProtobufUnittestNoArena.TestAllTypes.OptionalGroup()
                public func getMessage() -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup {
                    return builderResult
                }

                required override public init () {
                    super.init()
                }
                public var a:Int32 {
                    get {
                        return builderResult.a
                    }
                    set (value) {
                        builderResult.hasA = true
                        builderResult.a = value
                    }
                }
                public var hasA:Bool {
                    get {
                        return builderResult.hasA
                    }
                }
                @discardableResult
                public func setA(_ value:Int32) -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder {
                    self.a = value
                    return self
                }
                @discardableResult
                public func clearA() -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder{
                    builderResult.hasA = false
                    builderResult.a = nil
                    return self
                }
                override public var internalGetResult:GeneratedMessage {
                    get {
                        return builderResult
                    }
                }
                @discardableResult
                override public func clear() -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder {
                    builderResult = ProtobufUnittestNoArena.TestAllTypes.OptionalGroup()
                    return self
                }
                override public func clone() throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder {
                    return try ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.builderWithPrototype(prototype:builderResult)
                }
                override public func build() throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup {
                    try checkInitialized()
                    return buildPartial()
                }
                public func buildPartial() -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup {
                    let returnMe:ProtobufUnittestNoArena.TestAllTypes.OptionalGroup = builderResult
                    return returnMe
                }
                @discardableResult
                public func mergeFrom(other:ProtobufUnittestNoArena.TestAllTypes.OptionalGroup) throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder {
                    if other == ProtobufUnittestNoArena.TestAllTypes.OptionalGroup() {
                        return self
                    }
                    if other.hasA {
                        a = other.a
                    }
                    try merge(unknownField: other.unknownFields)
                    return self
                }
                @discardableResult
                override public func mergeFrom(codedInputStream: CodedInputStream) throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder {
                    return try mergeFrom(codedInputStream: codedInputStream, extensionRegistry:ExtensionRegistry())
                }
                @discardableResult
                override public func mergeFrom(codedInputStream: CodedInputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder {
                    let unknownFieldsBuilder:UnknownFieldSet.Builder = try UnknownFieldSet.builderWithUnknownFields(copyFrom:self.unknownFields)
                    while (true) {
                        let protobufTag = try codedInputStream.readTag()
                        switch protobufTag {
                        case 0: 
                            self.unknownFields = try unknownFieldsBuilder.build()
                            return self

                        case 136:
                            a = try codedInputStream.readInt32()

                        default:
                            if (!(try parse(codedInputStream:codedInputStream, unknownFields:unknownFieldsBuilder, extensionRegistry:extensionRegistry, tag:protobufTag))) {
                                unknownFields = try unknownFieldsBuilder.build()
                                return self
                            }
                        }
                    }
                }
                class override public func decodeToBuilder(jsonMap:Dictionary<String,Any>) throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder {
                    let resultDecodedBuilder = ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder()
                    if let jsonValueA = jsonMap["a"] as? Int {
                        resultDecodedBuilder.a = Int32(jsonValueA)
                    } else if let jsonValueA = jsonMap["a"] as? String {
                        resultDecodedBuilder.a = Int32(jsonValueA)!
                    }
                    return resultDecodedBuilder
                }
                override class public func fromJSONToBuilder(data:Data, options: JSONSerialization.ReadingOptions = []) throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder {
                    let jsonData = try JSONSerialization.jsonObject(with:data, options: options)
                    guard let jsDataCast = jsonData as? Dictionary<String,Any> else {
                      throw ProtocolBuffersError.invalidProtocolBuffer("Invalid JSON data")
                    }
                    return try ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder.decodeToBuilder(jsonMap:jsDataCast)
                }
            }

        }

        //Nested type declaration end



        //Nested type declaration start

        final public class RepeatedGroup : GeneratedMessage {
            public typealias BuilderType = ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder

            public static func == (lhs: ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup, rhs: ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup) -> Bool {
                if lhs === rhs {
                    return true
                }
                var fieldCheck:Bool = (lhs.hashValue == rhs.hashValue)
                fieldCheck = fieldCheck && (lhs.hasA == rhs.hasA) && (!lhs.hasA || lhs.a == rhs.a)
                fieldCheck = (fieldCheck && (lhs.unknownFields == rhs.unknownFields))
                return fieldCheck
            }

            public fileprivate(set) var a:Int32! = nil
            public fileprivate(set) var hasA:Bool = false

            required public init() {
                super.init()
            }
            override public func isInitialized() throws {
            }
            override public func writeTo(codedOutputStream: CodedOutputStream) throws {
                if hasA {
                    try codedOutputStream.writeInt32(fieldNumber: 47, value:a)
                }
                try unknownFields.writeTo(codedOutputStream: codedOutputStream)
            }
            override public func serializedSize() -> Int32 {
                var serialize_size:Int32 = memoizedSerializedSize
                if serialize_size != -1 {
                 return serialize_size
                }

                serialize_size = 0
                if hasA {
                    serialize_size += a.computeInt32Size(fieldNumber: 47)
                }
                serialize_size += unknownFields.serializedSize()
                memoizedSerializedSize = serialize_size
                return serialize_size
            }
            public class func getBuilder() -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder {
                return ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.classBuilder() as! ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder
            }
            public func getBuilder() -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder {
                return classBuilder() as! ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder
            }
            override public class func classBuilder() -> ProtocolBuffersMessageBuilder {
                return ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder()
            }
            override public func classBuilder() -> ProtocolBuffersMessageBuilder {
                return ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder()
            }
            public func toBuilder() throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder {
                return try ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.builderWithPrototype(prototype:self)
            }
            public class func builderWithPrototype(prototype:ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup) throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder {
                return try ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder().mergeFrom(other:prototype)
            }
            override public func encode() throws -> Dictionary<String,Any> {
                try isInitialized()
                var jsonMap:Dictionary<String,Any> = Dictionary<String,Any>()
                if hasA {
                    jsonMap["a"] = Int(a)
                }
                return jsonMap
            }
            override class public func decode(jsonMap:Dictionary<String,Any>) throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup {
                return try ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder.decodeToBuilder(jsonMap:jsonMap).build()
            }
            override class public func fromJSON(data:Data, options: JSONSerialization.ReadingOptions = []) throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup {
                return try ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder.fromJSONToBuilder(data:data, options:options).build()
            }
            override public func getDescription(indent:String) throws -> String {
                var output = ""
                if hasA {
                    output += "\(indent) a: \(String(describing: a)) \n"
                }
                output += unknownFields.getDescription(indent: indent)
                return output
            }
            override public var hashValue:Int {
                get {
                    var hashCode:Int = 7
                    if hasA {
                        hashCode = (hashCode &* 31) &+ a.hashValue
                    }
                    hashCode = (hashCode &* 31) &+  unknownFields.hashValue
                    return hashCode
                }
            }


            //Meta information declaration start

            override public class func className() -> String {
                return "ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup"
            }
            override public func className() -> String {
                return "ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup"
            }
            //Meta information declaration end

            final public class Builder : GeneratedMessageBuilder {
                fileprivate var builderResult:ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup = ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup()
                public func getMessage() -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup {
                    return builderResult
                }

                required override public init () {
                    super.init()
                }
                public var a:Int32 {
                    get {
                        return builderResult.a
                    }
                    set (value) {
                        builderResult.hasA = true
                        builderResult.a = value
                    }
                }
                public var hasA:Bool {
                    get {
                        return builderResult.hasA
                    }
                }
                @discardableResult
                public func setA(_ value:Int32) -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder {
                    self.a = value
                    return self
                }
                @discardableResult
                public func clearA() -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder{
                    builderResult.hasA = false
                    builderResult.a = nil
                    return self
                }
                override public var internalGetResult:GeneratedMessage {
                    get {
                        return builderResult
                    }
                }
                @discardableResult
                override public func clear() -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder {
                    builderResult = ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup()
                    return self
                }
                override public func clone() throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder {
                    return try ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.builderWithPrototype(prototype:builderResult)
                }
                override public func build() throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup {
                    try checkInitialized()
                    return buildPartial()
                }
                public func buildPartial() -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup {
                    let returnMe:ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup = builderResult
                    return returnMe
                }
                @discardableResult
                public func mergeFrom(other:ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup) throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder {
                    if other == ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup() {
                        return self
                    }
                    if other.hasA {
                        a = other.a
                    }
                    try merge(unknownField: other.unknownFields)
                    return self
                }
                @discardableResult
                override public func mergeFrom(codedInputStream: CodedInputStream) throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder {
                    return try mergeFrom(codedInputStream: codedInputStream, extensionRegistry:ExtensionRegistry())
                }
                @discardableResult
                override public func mergeFrom(codedInputStream: CodedInputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder {
                    let unknownFieldsBuilder:UnknownFieldSet.Builder = try UnknownFieldSet.builderWithUnknownFields(copyFrom:self.unknownFields)
                    while (true) {
                        let protobufTag = try codedInputStream.readTag()
                        switch protobufTag {
                        case 0: 
                            self.unknownFields = try unknownFieldsBuilder.build()
                            return self

                        case 376:
                            a = try codedInputStream.readInt32()

                        default:
                            if (!(try parse(codedInputStream:codedInputStream, unknownFields:unknownFieldsBuilder, extensionRegistry:extensionRegistry, tag:protobufTag))) {
                                unknownFields = try unknownFieldsBuilder.build()
                                return self
                            }
                        }
                    }
                }
                class override public func decodeToBuilder(jsonMap:Dictionary<String,Any>) throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder {
                    let resultDecodedBuilder = ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder()
                    if let jsonValueA = jsonMap["a"] as? Int {
                        resultDecodedBuilder.a = Int32(jsonValueA)
                    } else if let jsonValueA = jsonMap["a"] as? String {
                        resultDecodedBuilder.a = Int32(jsonValueA)!
                    }
                    return resultDecodedBuilder
                }
                override class public func fromJSONToBuilder(data:Data, options: JSONSerialization.ReadingOptions = []) throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder {
                    let jsonData = try JSONSerialization.jsonObject(with:data, options: options)
                    guard let jsDataCast = jsonData as? Dictionary<String,Any> else {
                      throw ProtocolBuffersError.invalidProtocolBuffer("Invalid JSON data")
                    }
                    return try ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder.decodeToBuilder(jsonMap:jsDataCast)
                }
            }

        }

        //Nested type declaration end



        //OneOf declaration start

        /// For oneof test
        public enum OneofField {
            case oneOfOneofFieldNotSet

            public func checkOneOfIsSet() -> Bool {
                switch self {
                case .oneOfOneofFieldNotSet: return false
                default: return true
                }
            }
            case oneofUint32(UInt32)

            public static func getOneofUint32(_ value:OneofField) -> UInt32? {
                switch value {
                case .oneofUint32(let otherValue): return otherValue
                default: return nil
                }
            }
            public func getOneofUint32() -> UInt32? {
                switch self {
                case .oneofUint32(let otherValue): return otherValue
                default: return nil
                }
            }
            case oneofNestedMessage(ProtobufUnittestNoArena.TestAllTypes.NestedMessage)

            public static func getOneofNestedMessage(_ value:OneofField) -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage? {
                switch value {
                case .oneofNestedMessage(let messageValue): return messageValue
                default: return nil
                }
            }
            public func getOneofNestedMessage() -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage? {
                switch self {
                case .oneofNestedMessage(let messageValue): return messageValue
                default: return nil
                }
            }
            case oneofString(String)

            public static func getOneofString(_ value:OneofField) -> String? {
                switch value {
                case .oneofString(let otherValue): return otherValue
                default: return nil
                }
            }
            public func getOneofString() -> String? {
                switch self {
                case .oneofString(let otherValue): return otherValue
                default: return nil
                }
            }
            case oneofBytes(Data)

            public static func getOneofBytes(_ value:OneofField) -> Data? {
                switch value {
                case .oneofBytes(let otherValue): return otherValue
                default: return nil
                }
            }
            public func getOneofBytes() -> Data? {
                switch self {
                case .oneofBytes(let otherValue): return otherValue
                default: return nil
                }
            }
            case lazyOneofNestedMessage(ProtobufUnittestNoArena.TestAllTypes.NestedMessage)

            public static func getLazyOneofNestedMessage(_ value:OneofField) -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage? {
                switch value {
                case .lazyOneofNestedMessage(let messageValue): return messageValue
                default: return nil
                }
            }
            public func getLazyOneofNestedMessage() -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage? {
                switch self {
                case .lazyOneofNestedMessage(let messageValue): return messageValue
                default: return nil
                }
            }
        }
        //OneOf declaration end

        fileprivate var storageOneofField:TestAllTypes.OneofField =  TestAllTypes.OneofField.oneOfOneofFieldNotSet
        public func getOneOfOneofField() ->  TestAllTypes.OneofField {
            let copyObjectOneofField = storageOneofField
            return copyObjectOneofField
        }


            //Enum type declaration start 

            public enum NestedEnum:Int32, GeneratedEnum {
                case foo = 1
                case bar = 2
                case baz = 3

                /// Intentionally negative.
                case neg = -1
                public func toString() -> String {
                    switch self {
                    case .foo: return "FOO"
                    case .bar: return "BAR"
                    case .baz: return "BAZ"
                    case .neg: return "NEG"
                    }
                }
                public static func fromString(_ str:String) throws -> ProtobufUnittestNoArena.TestAllTypes.NestedEnum {
                    switch str {
                    case "FOO":    return .foo
                    case "BAR":    return .bar
                    case "BAZ":    return .baz
                    case "NEG":    return .neg
                    default: throw ProtocolBuffersError.invalidProtocolBuffer("Conversion failed.")
                    }
                }
                public var debugDescription:String { return getDescription() }
                public var description:String { return getDescription() }
                private func getDescription() -> String { 
                    switch self {
                    case .foo: return ".foo"
                    case .bar: return ".bar"
                    case .baz: return ".baz"
                    case .neg: return ".neg"
                    }
                }
                public var hashValue:Int {
                    return self.rawValue.hashValue
                }
                public static func ==(lhs:NestedEnum, rhs:NestedEnum) -> Bool {
                    return lhs.hashValue == rhs.hashValue
                }
            }

            //Enum type declaration end 

        /// Singular
        public fileprivate(set) var optionalInt32:Int32! = nil
        public fileprivate(set) var hasOptionalInt32:Bool = false

        public fileprivate(set) var optionalInt64:Int64! = nil
        public fileprivate(set) var hasOptionalInt64:Bool = false

        public fileprivate(set) var optionalUint32:UInt32! = nil
        public fileprivate(set) var hasOptionalUint32:Bool = false

        public fileprivate(set) var optionalUint64:UInt64! = nil
        public fileprivate(set) var hasOptionalUint64:Bool = false

        public fileprivate(set) var optionalSint32:Int32! = nil
        public fileprivate(set) var hasOptionalSint32:Bool = false

        public fileprivate(set) var optionalSint64:Int64! = nil
        public fileprivate(set) var hasOptionalSint64:Bool = false

        public fileprivate(set) var optionalFixed32:UInt32! = nil
        public fileprivate(set) var hasOptionalFixed32:Bool = false

        public fileprivate(set) var optionalFixed64:UInt64! = nil
        public fileprivate(set) var hasOptionalFixed64:Bool = false

        public fileprivate(set) var optionalSfixed32:Int32! = nil
        public fileprivate(set) var hasOptionalSfixed32:Bool = false

        public fileprivate(set) var optionalSfixed64:Int64! = nil
        public fileprivate(set) var hasOptionalSfixed64:Bool = false

        public fileprivate(set) var optionalFloat:Float! = nil
        public fileprivate(set) var hasOptionalFloat:Bool = false

        public fileprivate(set) var optionalDouble:Double! = nil
        public fileprivate(set) var hasOptionalDouble:Bool = false

        public fileprivate(set) var optionalBool:Bool! = nil
        public fileprivate(set) var hasOptionalBool:Bool = false

        public fileprivate(set) var optionalString:String! = nil
        public fileprivate(set) var hasOptionalString:Bool = false

        public fileprivate(set) var optionalBytes:Data! = nil
        public fileprivate(set) var hasOptionalBytes:Bool = false

        public fileprivate(set) var optionalGroup:ProtobufUnittestNoArena.TestAllTypes.OptionalGroup!
        public fileprivate(set) var hasOptionalGroup:Bool = false
        public fileprivate(set) var optionalNestedMessage:ProtobufUnittestNoArena.TestAllTypes.NestedMessage!
        public fileprivate(set) var hasOptionalNestedMessage:Bool = false
        public fileprivate(set) var optionalForeignMessage:ProtobufUnittestNoArena.ForeignMessage!
        public fileprivate(set) var hasOptionalForeignMessage:Bool = false
        public fileprivate(set) var optionalImportMessage:ProtobufUnittestImport.ImportMessage!
        public fileprivate(set) var hasOptionalImportMessage:Bool = false
        public fileprivate(set) var optionalNestedEnum:ProtobufUnittestNoArena.TestAllTypes.NestedEnum = ProtobufUnittestNoArena.TestAllTypes.NestedEnum.foo
        public fileprivate(set) var hasOptionalNestedEnum:Bool = false
        public fileprivate(set) var optionalForeignEnum:ProtobufUnittestNoArena.ForeignEnum = ProtobufUnittestNoArena.ForeignEnum.foreignFoo
        public fileprivate(set) var hasOptionalForeignEnum:Bool = false
        public fileprivate(set) var optionalImportEnum:ProtobufUnittestImport.ImportEnum = ProtobufUnittestImport.ImportEnum.importFoo
        public fileprivate(set) var hasOptionalImportEnum:Bool = false
        public fileprivate(set) var optionalStringPiece:String! = nil
        public fileprivate(set) var hasOptionalStringPiece:Bool = false

        public fileprivate(set) var optionalCord:String! = nil
        public fileprivate(set) var hasOptionalCord:Bool = false

        public fileprivate(set) var optionalPublicImportMessage:ProtobufUnittestImport.PublicImportMessage!
        public fileprivate(set) var hasOptionalPublicImportMessage:Bool = false
        public fileprivate(set) var optionalMessage:ProtobufUnittestNoArena.TestAllTypes.NestedMessage!
        public fileprivate(set) var hasOptionalMessage:Bool = false
        /// Repeated
        public fileprivate(set) var repeatedInt32:Array<Int32> = Array<Int32>()
        public fileprivate(set) var repeatedInt64:Array<Int64> = Array<Int64>()
        public fileprivate(set) var repeatedUint32:Array<UInt32> = Array<UInt32>()
        public fileprivate(set) var repeatedUint64:Array<UInt64> = Array<UInt64>()
        public fileprivate(set) var repeatedSint32:Array<Int32> = Array<Int32>()
        public fileprivate(set) var repeatedSint64:Array<Int64> = Array<Int64>()
        public fileprivate(set) var repeatedFixed32:Array<UInt32> = Array<UInt32>()
        public fileprivate(set) var repeatedFixed64:Array<UInt64> = Array<UInt64>()
        public fileprivate(set) var repeatedSfixed32:Array<Int32> = Array<Int32>()
        public fileprivate(set) var repeatedSfixed64:Array<Int64> = Array<Int64>()
        public fileprivate(set) var repeatedFloat:Array<Float> = Array<Float>()
        public fileprivate(set) var repeatedDouble:Array<Double> = Array<Double>()
        public fileprivate(set) var repeatedBool:Array<Bool> = Array<Bool>()
        public fileprivate(set) var repeatedString:Array<String> = Array<String>()
        public fileprivate(set) var repeatedBytes:Array<Data> = Array<Data>()
        public fileprivate(set) var repeatedGroup:Array<ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup>  = Array<ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup>()
        public fileprivate(set) var repeatedNestedMessage:Array<ProtobufUnittestNoArena.TestAllTypes.NestedMessage>  = Array<ProtobufUnittestNoArena.TestAllTypes.NestedMessage>()
        public fileprivate(set) var repeatedForeignMessage:Array<ProtobufUnittestNoArena.ForeignMessage>  = Array<ProtobufUnittestNoArena.ForeignMessage>()
        public fileprivate(set) var repeatedImportMessage:Array<ProtobufUnittestImport.ImportMessage>  = Array<ProtobufUnittestImport.ImportMessage>()
        private var repeatedNestedEnumMemoizedSerializedSize:Int32 = 0
        public fileprivate(set) var repeatedNestedEnum:Array<ProtobufUnittestNoArena.TestAllTypes.NestedEnum> = Array<ProtobufUnittestNoArena.TestAllTypes.NestedEnum>()
        private var repeatedForeignEnumMemoizedSerializedSize:Int32 = 0
        public fileprivate(set) var repeatedForeignEnum:Array<ProtobufUnittestNoArena.ForeignEnum> = Array<ProtobufUnittestNoArena.ForeignEnum>()
        private var repeatedImportEnumMemoizedSerializedSize:Int32 = 0
        public fileprivate(set) var repeatedImportEnum:Array<ProtobufUnittestImport.ImportEnum> = Array<ProtobufUnittestImport.ImportEnum>()
        public fileprivate(set) var repeatedStringPiece:Array<String> = Array<String>()
        public fileprivate(set) var repeatedCord:Array<String> = Array<String>()
        public fileprivate(set) var repeatedLazyMessage:Array<ProtobufUnittestNoArena.TestAllTypes.NestedMessage>  = Array<ProtobufUnittestNoArena.TestAllTypes.NestedMessage>()
        /// Singular with defaults
        public fileprivate(set) var defaultInt32:Int32! = Int32(41)
        public fileprivate(set) var hasDefaultInt32:Bool = false

        public fileprivate(set) var defaultInt64:Int64! = Int64(42)
        public fileprivate(set) var hasDefaultInt64:Bool = false

        public fileprivate(set) var defaultUint32:UInt32! = UInt32(43)
        public fileprivate(set) var hasDefaultUint32:Bool = false

        public fileprivate(set) var defaultUint64:UInt64! = UInt64(44)
        public fileprivate(set) var hasDefaultUint64:Bool = false

        public fileprivate(set) var defaultSint32:Int32! = Int32(-45)
        public fileprivate(set) var hasDefaultSint32:Bool = false

        public fileprivate(set) var defaultSint64:Int64! = Int64(46)
        public fileprivate(set) var hasDefaultSint64:Bool = false

        public fileprivate(set) var defaultFixed32:UInt32! = UInt32(47)
        public fileprivate(set) var hasDefaultFixed32:Bool = false

        public fileprivate(set) var defaultFixed64:UInt64! = UInt64(48)
        public fileprivate(set) var hasDefaultFixed64:Bool = false

        public fileprivate(set) var defaultSfixed32:Int32! = Int32(49)
        public fileprivate(set) var hasDefaultSfixed32:Bool = false

        public fileprivate(set) var defaultSfixed64:Int64! = Int64(-50)
        public fileprivate(set) var hasDefaultSfixed64:Bool = false

        public fileprivate(set) var defaultFloat:Float! = Float(51.5)
        public fileprivate(set) var hasDefaultFloat:Bool = false

        public fileprivate(set) var defaultDouble:Double! = Double(52000)
        public fileprivate(set) var hasDefaultDouble:Bool = false

        public fileprivate(set) var defaultBool:Bool! = true
        public fileprivate(set) var hasDefaultBool:Bool = false

        public fileprivate(set) var defaultString:String! = "hello"
        public fileprivate(set) var hasDefaultString:Bool = false

        public fileprivate(set) var defaultBytes:Data! = Data(bytes:([UInt8]() + "world".utf8), count:5)
        public fileprivate(set) var hasDefaultBytes:Bool = false

        public fileprivate(set) var defaultNestedEnum:ProtobufUnittestNoArena.TestAllTypes.NestedEnum = ProtobufUnittestNoArena.TestAllTypes.NestedEnum.bar
        public fileprivate(set) var hasDefaultNestedEnum:Bool = false
        public fileprivate(set) var defaultForeignEnum:ProtobufUnittestNoArena.ForeignEnum = ProtobufUnittestNoArena.ForeignEnum.foreignBar
        public fileprivate(set) var hasDefaultForeignEnum:Bool = false
        public fileprivate(set) var defaultImportEnum:ProtobufUnittestImport.ImportEnum = ProtobufUnittestImport.ImportEnum.importBar
        public fileprivate(set) var hasDefaultImportEnum:Bool = false
        public fileprivate(set) var defaultStringPiece:String! = "abc"
        public fileprivate(set) var hasDefaultStringPiece:Bool = false

        public fileprivate(set) var defaultCord:String! = "123"
        public fileprivate(set) var hasDefaultCord:Bool = false

        public fileprivate(set) var oneofUint32:UInt32!{
            get {
                return TestAllTypes.OneofField.getOneofUint32(storageOneofField)
            }
            set (newvalue) {
                storageOneofField = TestAllTypes.OneofField.oneofUint32(newvalue)
            }
        }
        public fileprivate(set) var hasOneofUint32:Bool {
            get {
                return TestAllTypes.OneofField.getOneofUint32(storageOneofField) != nil
            }
            set(newValue) {
            }
        }
        public fileprivate(set) var oneofNestedMessage:ProtobufUnittestNoArena.TestAllTypes.NestedMessage!{
            get {
                return TestAllTypes.OneofField.getOneofNestedMessage(storageOneofField)
            }
            set (newvalue) {
                storageOneofField = TestAllTypes.OneofField.oneofNestedMessage(newvalue)
            }
        }
        public fileprivate(set) var hasOneofNestedMessage:Bool {
            get {
                return TestAllTypes.OneofField.getOneofNestedMessage(storageOneofField) != nil
            }
            set(newValue) {
            }
        }
        public fileprivate(set) var oneofString:String!{
            get {
                return TestAllTypes.OneofField.getOneofString(storageOneofField)
            }
            set (newvalue) {
                storageOneofField = TestAllTypes.OneofField.oneofString(newvalue)
            }
        }
        public fileprivate(set) var hasOneofString:Bool {
            get {
                return TestAllTypes.OneofField.getOneofString(storageOneofField) != nil
            }
            set(newValue) {
            }
        }
        public fileprivate(set) var oneofBytes:Data!{
            get {
                return TestAllTypes.OneofField.getOneofBytes(storageOneofField)
            }
            set (newvalue) {
                storageOneofField = TestAllTypes.OneofField.oneofBytes(newvalue)
            }
        }
        public fileprivate(set) var hasOneofBytes:Bool {
            get {
                return TestAllTypes.OneofField.getOneofBytes(storageOneofField) != nil
            }
            set(newValue) {
            }
        }
        public fileprivate(set) var lazyOneofNestedMessage:ProtobufUnittestNoArena.TestAllTypes.NestedMessage!{
            get {
                return TestAllTypes.OneofField.getLazyOneofNestedMessage(storageOneofField)
            }
            set (newvalue) {
                storageOneofField = TestAllTypes.OneofField.lazyOneofNestedMessage(newvalue)
            }
        }
        public fileprivate(set) var hasLazyOneofNestedMessage:Bool {
            get {
                return TestAllTypes.OneofField.getLazyOneofNestedMessage(storageOneofField) != nil
            }
            set(newValue) {
            }
        }
        required public init() {
            super.init()
        }
        override public func isInitialized() throws {
        }
        override public func writeTo(codedOutputStream: CodedOutputStream) throws {
            if hasOptionalInt32 {
                try codedOutputStream.writeInt32(fieldNumber: 1, value:optionalInt32)
            }
            if hasOptionalInt64 {
                try codedOutputStream.writeInt64(fieldNumber: 2, value:optionalInt64)
            }
            if hasOptionalUint32 {
                try codedOutputStream.writeUInt32(fieldNumber: 3, value:optionalUint32)
            }
            if hasOptionalUint64 {
                try codedOutputStream.writeUInt64(fieldNumber: 4, value:optionalUint64)
            }
            if hasOptionalSint32 {
                try codedOutputStream.writeSInt32(fieldNumber: 5, value:optionalSint32)
            }
            if hasOptionalSint64 {
                try codedOutputStream.writeSInt64(fieldNumber: 6, value:optionalSint64)
            }
            if hasOptionalFixed32 {
                try codedOutputStream.writeFixed32(fieldNumber: 7, value:optionalFixed32)
            }
            if hasOptionalFixed64 {
                try codedOutputStream.writeFixed64(fieldNumber: 8, value:optionalFixed64)
            }
            if hasOptionalSfixed32 {
                try codedOutputStream.writeSFixed32(fieldNumber: 9, value:optionalSfixed32)
            }
            if hasOptionalSfixed64 {
                try codedOutputStream.writeSFixed64(fieldNumber: 10, value:optionalSfixed64)
            }
            if hasOptionalFloat {
                try codedOutputStream.writeFloat(fieldNumber: 11, value:optionalFloat)
            }
            if hasOptionalDouble {
                try codedOutputStream.writeDouble(fieldNumber: 12, value:optionalDouble)
            }
            if hasOptionalBool {
                try codedOutputStream.writeBool(fieldNumber: 13, value:optionalBool)
            }
            if hasOptionalString {
                try codedOutputStream.writeString(fieldNumber: 14, value:optionalString)
            }
            if hasOptionalBytes {
                try codedOutputStream.writeData(fieldNumber: 15, value:optionalBytes)
            }
            if hasOptionalGroup {
                try codedOutputStream.writeGroup(fieldNumber: 16, value:optionalGroup)
            }
            if hasOptionalNestedMessage {
                try codedOutputStream.writeMessage(fieldNumber: 18, value:optionalNestedMessage)
            }
            if hasOptionalForeignMessage {
                try codedOutputStream.writeMessage(fieldNumber: 19, value:optionalForeignMessage)
            }
            if hasOptionalImportMessage {
                try codedOutputStream.writeMessage(fieldNumber: 20, value:optionalImportMessage)
            }
            if hasOptionalNestedEnum {
                try codedOutputStream.writeEnum(fieldNumber: 21, value:optionalNestedEnum.rawValue)
            }
            if hasOptionalForeignEnum {
                try codedOutputStream.writeEnum(fieldNumber: 22, value:optionalForeignEnum.rawValue)
            }
            if hasOptionalImportEnum {
                try codedOutputStream.writeEnum(fieldNumber: 23, value:optionalImportEnum.rawValue)
            }
            if hasOptionalStringPiece {
                try codedOutputStream.writeString(fieldNumber: 24, value:optionalStringPiece)
            }
            if hasOptionalCord {
                try codedOutputStream.writeString(fieldNumber: 25, value:optionalCord)
            }
            if hasOptionalPublicImportMessage {
                try codedOutputStream.writeMessage(fieldNumber: 26, value:optionalPublicImportMessage)
            }
            if hasOptionalMessage {
                try codedOutputStream.writeMessage(fieldNumber: 27, value:optionalMessage)
            }
            if !repeatedInt32.isEmpty {
                for oneValuerepeatedInt32 in repeatedInt32 {
                    try codedOutputStream.writeInt32(fieldNumber: 31, value:oneValuerepeatedInt32)
                }
            }
            if !repeatedInt64.isEmpty {
                for oneValuerepeatedInt64 in repeatedInt64 {
                    try codedOutputStream.writeInt64(fieldNumber: 32, value:oneValuerepeatedInt64)
                }
            }
            if !repeatedUint32.isEmpty {
                for oneValuerepeatedUint32 in repeatedUint32 {
                    try codedOutputStream.writeUInt32(fieldNumber: 33, value:oneValuerepeatedUint32)
                }
            }
            if !repeatedUint64.isEmpty {
                for oneValuerepeatedUint64 in repeatedUint64 {
                    try codedOutputStream.writeUInt64(fieldNumber: 34, value:oneValuerepeatedUint64)
                }
            }
            if !repeatedSint32.isEmpty {
                for oneValuerepeatedSint32 in repeatedSint32 {
                    try codedOutputStream.writeSInt32(fieldNumber: 35, value:oneValuerepeatedSint32)
                }
            }
            if !repeatedSint64.isEmpty {
                for oneValuerepeatedSint64 in repeatedSint64 {
                    try codedOutputStream.writeSInt64(fieldNumber: 36, value:oneValuerepeatedSint64)
                }
            }
            if !repeatedFixed32.isEmpty {
                for oneValuerepeatedFixed32 in repeatedFixed32 {
                    try codedOutputStream.writeFixed32(fieldNumber: 37, value:oneValuerepeatedFixed32)
                }
            }
            if !repeatedFixed64.isEmpty {
                for oneValuerepeatedFixed64 in repeatedFixed64 {
                    try codedOutputStream.writeFixed64(fieldNumber: 38, value:oneValuerepeatedFixed64)
                }
            }
            if !repeatedSfixed32.isEmpty {
                for oneValuerepeatedSfixed32 in repeatedSfixed32 {
                    try codedOutputStream.writeSFixed32(fieldNumber: 39, value:oneValuerepeatedSfixed32)
                }
            }
            if !repeatedSfixed64.isEmpty {
                for oneValuerepeatedSfixed64 in repeatedSfixed64 {
                    try codedOutputStream.writeSFixed64(fieldNumber: 40, value:oneValuerepeatedSfixed64)
                }
            }
            if !repeatedFloat.isEmpty {
                for oneValuerepeatedFloat in repeatedFloat {
                    try codedOutputStream.writeFloat(fieldNumber: 41, value:oneValuerepeatedFloat)
                }
            }
            if !repeatedDouble.isEmpty {
                for oneValuerepeatedDouble in repeatedDouble {
                    try codedOutputStream.writeDouble(fieldNumber: 42, value:oneValuerepeatedDouble)
                }
            }
            if !repeatedBool.isEmpty {
                for oneValuerepeatedBool in repeatedBool {
                    try codedOutputStream.writeBool(fieldNumber: 43, value:oneValuerepeatedBool)
                }
            }
            if !repeatedString.isEmpty {
                for oneValuerepeatedString in repeatedString {
                    try codedOutputStream.writeString(fieldNumber: 44, value:oneValuerepeatedString)
                }
            }
            if !repeatedBytes.isEmpty {
                for oneValuerepeatedBytes in repeatedBytes {
                    try codedOutputStream.writeData(fieldNumber: 45, value:oneValuerepeatedBytes)
                }
            }
            for oneElementRepeatedGroup in repeatedGroup {
                  try codedOutputStream.writeGroup(fieldNumber: 46, value:oneElementRepeatedGroup)
            }
            for oneElementRepeatedNestedMessage in repeatedNestedMessage {
                  try codedOutputStream.writeMessage(fieldNumber: 48, value:oneElementRepeatedNestedMessage)
            }
            for oneElementRepeatedForeignMessage in repeatedForeignMessage {
                  try codedOutputStream.writeMessage(fieldNumber: 49, value:oneElementRepeatedForeignMessage)
            }
            for oneElementRepeatedImportMessage in repeatedImportMessage {
                  try codedOutputStream.writeMessage(fieldNumber: 50, value:oneElementRepeatedImportMessage)
            }
            for oneValueOfrepeatedNestedEnum in repeatedNestedEnum {
                  try codedOutputStream.writeEnum(fieldNumber: 51, value:oneValueOfrepeatedNestedEnum.rawValue)
            }
            for oneValueOfrepeatedForeignEnum in repeatedForeignEnum {
                  try codedOutputStream.writeEnum(fieldNumber: 52, value:oneValueOfrepeatedForeignEnum.rawValue)
            }
            for oneValueOfrepeatedImportEnum in repeatedImportEnum {
                  try codedOutputStream.writeEnum(fieldNumber: 53, value:oneValueOfrepeatedImportEnum.rawValue)
            }
            if !repeatedStringPiece.isEmpty {
                for oneValuerepeatedStringPiece in repeatedStringPiece {
                    try codedOutputStream.writeString(fieldNumber: 54, value:oneValuerepeatedStringPiece)
                }
            }
            if !repeatedCord.isEmpty {
                for oneValuerepeatedCord in repeatedCord {
                    try codedOutputStream.writeString(fieldNumber: 55, value:oneValuerepeatedCord)
                }
            }
            for oneElementRepeatedLazyMessage in repeatedLazyMessage {
                  try codedOutputStream.writeMessage(fieldNumber: 57, value:oneElementRepeatedLazyMessage)
            }
            if hasDefaultInt32 {
                try codedOutputStream.writeInt32(fieldNumber: 61, value:defaultInt32)
            }
            if hasDefaultInt64 {
                try codedOutputStream.writeInt64(fieldNumber: 62, value:defaultInt64)
            }
            if hasDefaultUint32 {
                try codedOutputStream.writeUInt32(fieldNumber: 63, value:defaultUint32)
            }
            if hasDefaultUint64 {
                try codedOutputStream.writeUInt64(fieldNumber: 64, value:defaultUint64)
            }
            if hasDefaultSint32 {
                try codedOutputStream.writeSInt32(fieldNumber: 65, value:defaultSint32)
            }
            if hasDefaultSint64 {
                try codedOutputStream.writeSInt64(fieldNumber: 66, value:defaultSint64)
            }
            if hasDefaultFixed32 {
                try codedOutputStream.writeFixed32(fieldNumber: 67, value:defaultFixed32)
            }
            if hasDefaultFixed64 {
                try codedOutputStream.writeFixed64(fieldNumber: 68, value:defaultFixed64)
            }
            if hasDefaultSfixed32 {
                try codedOutputStream.writeSFixed32(fieldNumber: 69, value:defaultSfixed32)
            }
            if hasDefaultSfixed64 {
                try codedOutputStream.writeSFixed64(fieldNumber: 70, value:defaultSfixed64)
            }
            if hasDefaultFloat {
                try codedOutputStream.writeFloat(fieldNumber: 71, value:defaultFloat)
            }
            if hasDefaultDouble {
                try codedOutputStream.writeDouble(fieldNumber: 72, value:defaultDouble)
            }
            if hasDefaultBool {
                try codedOutputStream.writeBool(fieldNumber: 73, value:defaultBool)
            }
            if hasDefaultString {
                try codedOutputStream.writeString(fieldNumber: 74, value:defaultString)
            }
            if hasDefaultBytes {
                try codedOutputStream.writeData(fieldNumber: 75, value:defaultBytes)
            }
            if hasDefaultNestedEnum {
                try codedOutputStream.writeEnum(fieldNumber: 81, value:defaultNestedEnum.rawValue)
            }
            if hasDefaultForeignEnum {
                try codedOutputStream.writeEnum(fieldNumber: 82, value:defaultForeignEnum.rawValue)
            }
            if hasDefaultImportEnum {
                try codedOutputStream.writeEnum(fieldNumber: 83, value:defaultImportEnum.rawValue)
            }
            if hasDefaultStringPiece {
                try codedOutputStream.writeString(fieldNumber: 84, value:defaultStringPiece)
            }
            if hasDefaultCord {
                try codedOutputStream.writeString(fieldNumber: 85, value:defaultCord)
            }
            if hasOneofUint32 {
                try codedOutputStream.writeUInt32(fieldNumber: 111, value:oneofUint32)
            }
            if hasOneofNestedMessage {
                try codedOutputStream.writeMessage(fieldNumber: 112, value:oneofNestedMessage)
            }
            if hasOneofString {
                try codedOutputStream.writeString(fieldNumber: 113, value:oneofString)
            }
            if hasOneofBytes {
                try codedOutputStream.writeData(fieldNumber: 114, value:oneofBytes)
            }
            if hasLazyOneofNestedMessage {
                try codedOutputStream.writeMessage(fieldNumber: 115, value:lazyOneofNestedMessage)
            }
            try unknownFields.writeTo(codedOutputStream: codedOutputStream)
        }
        override public func serializedSize() -> Int32 {
            var serialize_size:Int32 = memoizedSerializedSize
            if serialize_size != -1 {
             return serialize_size
            }

            serialize_size = 0
            if hasOptionalInt32 {
                serialize_size += optionalInt32.computeInt32Size(fieldNumber: 1)
            }
            if hasOptionalInt64 {
                serialize_size += optionalInt64.computeInt64Size(fieldNumber: 2)
            }
            if hasOptionalUint32 {
                serialize_size += optionalUint32.computeUInt32Size(fieldNumber: 3)
            }
            if hasOptionalUint64 {
                serialize_size += optionalUint64.computeUInt64Size(fieldNumber: 4)
            }
            if hasOptionalSint32 {
                serialize_size += optionalSint32.computeSInt32Size(fieldNumber: 5)
            }
            if hasOptionalSint64 {
                serialize_size += optionalSint64.computeSInt64Size(fieldNumber: 6)
            }
            if hasOptionalFixed32 {
                serialize_size += optionalFixed32.computeFixed32Size(fieldNumber: 7)
            }
            if hasOptionalFixed64 {
                serialize_size += optionalFixed64.computeFixed64Size(fieldNumber: 8)
            }
            if hasOptionalSfixed32 {
                serialize_size += optionalSfixed32.computeSFixed32Size(fieldNumber: 9)
            }
            if hasOptionalSfixed64 {
                serialize_size += optionalSfixed64.computeSFixed64Size(fieldNumber: 10)
            }
            if hasOptionalFloat {
                serialize_size += optionalFloat.computeFloatSize(fieldNumber: 11)
            }
            if hasOptionalDouble {
                serialize_size += optionalDouble.computeDoubleSize(fieldNumber: 12)
            }
            if hasOptionalBool {
                serialize_size += optionalBool.computeBoolSize(fieldNumber: 13)
            }
            if hasOptionalString {
                serialize_size += optionalString.computeStringSize(fieldNumber: 14)
            }
            if hasOptionalBytes {
                serialize_size += optionalBytes.computeDataSize(fieldNumber: 15)
            }
            if hasOptionalGroup {
                if let varSizeoptionalGroup = optionalGroup?.computeGroupSize(fieldNumber: 16) {
                    serialize_size += varSizeoptionalGroup
                }
            }
            if hasOptionalNestedMessage {
                if let varSizeoptionalNestedMessage = optionalNestedMessage?.computeMessageSize(fieldNumber: 18) {
                    serialize_size += varSizeoptionalNestedMessage
                }
            }
            if hasOptionalForeignMessage {
                if let varSizeoptionalForeignMessage = optionalForeignMessage?.computeMessageSize(fieldNumber: 19) {
                    serialize_size += varSizeoptionalForeignMessage
                }
            }
            if hasOptionalImportMessage {
                if let varSizeoptionalImportMessage = optionalImportMessage?.computeMessageSize(fieldNumber: 20) {
                    serialize_size += varSizeoptionalImportMessage
                }
            }
            if (hasOptionalNestedEnum) {
                serialize_size += optionalNestedEnum.rawValue.computeEnumSize(fieldNumber: 21)
            }
            if (hasOptionalForeignEnum) {
                serialize_size += optionalForeignEnum.rawValue.computeEnumSize(fieldNumber: 22)
            }
            if (hasOptionalImportEnum) {
                serialize_size += optionalImportEnum.rawValue.computeEnumSize(fieldNumber: 23)
            }
            if hasOptionalStringPiece {
                serialize_size += optionalStringPiece.computeStringSize(fieldNumber: 24)
            }
            if hasOptionalCord {
                serialize_size += optionalCord.computeStringSize(fieldNumber: 25)
            }
            if hasOptionalPublicImportMessage {
                if let varSizeoptionalPublicImportMessage = optionalPublicImportMessage?.computeMessageSize(fieldNumber: 26) {
                    serialize_size += varSizeoptionalPublicImportMessage
                }
            }
            if hasOptionalMessage {
                if let varSizeoptionalMessage = optionalMessage?.computeMessageSize(fieldNumber: 27) {
                    serialize_size += varSizeoptionalMessage
                }
            }
            var dataSizeRepeatedInt32:Int32 = 0
            for oneValuerepeatedInt32 in repeatedInt32 {
                dataSizeRepeatedInt32 += oneValuerepeatedInt32.computeInt32SizeNoTag()
            }
            serialize_size += dataSizeRepeatedInt32
            serialize_size += 2 * Int32(repeatedInt32.count)
            var dataSizeRepeatedInt64:Int32 = 0
            for oneValuerepeatedInt64 in repeatedInt64 {
                dataSizeRepeatedInt64 += oneValuerepeatedInt64.computeInt64SizeNoTag()
            }
            serialize_size += dataSizeRepeatedInt64
            serialize_size += 2 * Int32(repeatedInt64.count)
            var dataSizeRepeatedUint32:Int32 = 0
            for oneValuerepeatedUint32 in repeatedUint32 {
                dataSizeRepeatedUint32 += oneValuerepeatedUint32.computeUInt32SizeNoTag()
            }
            serialize_size += dataSizeRepeatedUint32
            serialize_size += 2 * Int32(repeatedUint32.count)
            var dataSizeRepeatedUint64:Int32 = 0
            for oneValuerepeatedUint64 in repeatedUint64 {
                dataSizeRepeatedUint64 += oneValuerepeatedUint64.computeUInt64SizeNoTag()
            }
            serialize_size += dataSizeRepeatedUint64
            serialize_size += 2 * Int32(repeatedUint64.count)
            var dataSizeRepeatedSint32:Int32 = 0
            for oneValuerepeatedSint32 in repeatedSint32 {
                dataSizeRepeatedSint32 += oneValuerepeatedSint32.computeSInt32SizeNoTag()
            }
            serialize_size += dataSizeRepeatedSint32
            serialize_size += 2 * Int32(repeatedSint32.count)
            var dataSizeRepeatedSint64:Int32 = 0
            for oneValuerepeatedSint64 in repeatedSint64 {
                dataSizeRepeatedSint64 += oneValuerepeatedSint64.computeSInt64SizeNoTag()
            }
            serialize_size += dataSizeRepeatedSint64
            serialize_size += 2 * Int32(repeatedSint64.count)
            var dataSizeRepeatedFixed32:Int32 = 0
            dataSizeRepeatedFixed32 = 4 * Int32(repeatedFixed32.count)
            serialize_size += dataSizeRepeatedFixed32
            serialize_size += 2 * Int32(repeatedFixed32.count)
            var dataSizeRepeatedFixed64:Int32 = 0
            dataSizeRepeatedFixed64 = 8 * Int32(repeatedFixed64.count)
            serialize_size += dataSizeRepeatedFixed64
            serialize_size += 2 * Int32(repeatedFixed64.count)
            var dataSizeRepeatedSfixed32:Int32 = 0
            dataSizeRepeatedSfixed32 = 4 * Int32(repeatedSfixed32.count)
            serialize_size += dataSizeRepeatedSfixed32
            serialize_size += 2 * Int32(repeatedSfixed32.count)
            var dataSizeRepeatedSfixed64:Int32 = 0
            dataSizeRepeatedSfixed64 = 8 * Int32(repeatedSfixed64.count)
            serialize_size += dataSizeRepeatedSfixed64
            serialize_size += 2 * Int32(repeatedSfixed64.count)
            var dataSizeRepeatedFloat:Int32 = 0
            dataSizeRepeatedFloat = 4 * Int32(repeatedFloat.count)
            serialize_size += dataSizeRepeatedFloat
            serialize_size += 2 * Int32(repeatedFloat.count)
            var dataSizeRepeatedDouble:Int32 = 0
            dataSizeRepeatedDouble = 8 * Int32(repeatedDouble.count)
            serialize_size += dataSizeRepeatedDouble
            serialize_size += 2 * Int32(repeatedDouble.count)
            var dataSizeRepeatedBool:Int32 = 0
            dataSizeRepeatedBool = 1 * Int32(repeatedBool.count)
            serialize_size += dataSizeRepeatedBool
            serialize_size += 2 * Int32(repeatedBool.count)
            var dataSizeRepeatedString:Int32 = 0
            for oneValuerepeatedString in repeatedString {
                dataSizeRepeatedString += oneValuerepeatedString.computeStringSizeNoTag()
            }
            serialize_size += dataSizeRepeatedString
            serialize_size += 2 * Int32(repeatedString.count)
            var dataSizeRepeatedBytes:Int32 = 0
            for oneValuerepeatedBytes in repeatedBytes {
                dataSizeRepeatedBytes += oneValuerepeatedBytes.computeDataSizeNoTag()
            }
            serialize_size += dataSizeRepeatedBytes
            serialize_size += 2 * Int32(repeatedBytes.count)
            for oneElementRepeatedGroup in repeatedGroup {
                serialize_size += oneElementRepeatedGroup.computeGroupSize(fieldNumber: 46)
            }
            for oneElementRepeatedNestedMessage in repeatedNestedMessage {
                serialize_size += oneElementRepeatedNestedMessage.computeMessageSize(fieldNumber: 48)
            }
            for oneElementRepeatedForeignMessage in repeatedForeignMessage {
                serialize_size += oneElementRepeatedForeignMessage.computeMessageSize(fieldNumber: 49)
            }
            for oneElementRepeatedImportMessage in repeatedImportMessage {
                serialize_size += oneElementRepeatedImportMessage.computeMessageSize(fieldNumber: 50)
            }
            var dataSizerepeatedNestedEnum:Int32 = 0
            for oneValueOfrepeatedNestedEnum in repeatedNestedEnum {
                dataSizerepeatedNestedEnum += oneValueOfrepeatedNestedEnum.rawValue.computeEnumSizeNoTag()
            }
            serialize_size += dataSizerepeatedNestedEnum
            serialize_size += (2 * Int32(repeatedNestedEnum.count))
            var dataSizerepeatedForeignEnum:Int32 = 0
            for oneValueOfrepeatedForeignEnum in repeatedForeignEnum {
                dataSizerepeatedForeignEnum += oneValueOfrepeatedForeignEnum.rawValue.computeEnumSizeNoTag()
            }
            serialize_size += dataSizerepeatedForeignEnum
            serialize_size += (2 * Int32(repeatedForeignEnum.count))
            var dataSizerepeatedImportEnum:Int32 = 0
            for oneValueOfrepeatedImportEnum in repeatedImportEnum {
                dataSizerepeatedImportEnum += oneValueOfrepeatedImportEnum.rawValue.computeEnumSizeNoTag()
            }
            serialize_size += dataSizerepeatedImportEnum
            serialize_size += (2 * Int32(repeatedImportEnum.count))
            var dataSizeRepeatedStringPiece:Int32 = 0
            for oneValuerepeatedStringPiece in repeatedStringPiece {
                dataSizeRepeatedStringPiece += oneValuerepeatedStringPiece.computeStringSizeNoTag()
            }
            serialize_size += dataSizeRepeatedStringPiece
            serialize_size += 2 * Int32(repeatedStringPiece.count)
            var dataSizeRepeatedCord:Int32 = 0
            for oneValuerepeatedCord in repeatedCord {
                dataSizeRepeatedCord += oneValuerepeatedCord.computeStringSizeNoTag()
            }
            serialize_size += dataSizeRepeatedCord
            serialize_size += 2 * Int32(repeatedCord.count)
            for oneElementRepeatedLazyMessage in repeatedLazyMessage {
                serialize_size += oneElementRepeatedLazyMessage.computeMessageSize(fieldNumber: 57)
            }
            if hasDefaultInt32 {
                serialize_size += defaultInt32.computeInt32Size(fieldNumber: 61)
            }
            if hasDefaultInt64 {
                serialize_size += defaultInt64.computeInt64Size(fieldNumber: 62)
            }
            if hasDefaultUint32 {
                serialize_size += defaultUint32.computeUInt32Size(fieldNumber: 63)
            }
            if hasDefaultUint64 {
                serialize_size += defaultUint64.computeUInt64Size(fieldNumber: 64)
            }
            if hasDefaultSint32 {
                serialize_size += defaultSint32.computeSInt32Size(fieldNumber: 65)
            }
            if hasDefaultSint64 {
                serialize_size += defaultSint64.computeSInt64Size(fieldNumber: 66)
            }
            if hasDefaultFixed32 {
                serialize_size += defaultFixed32.computeFixed32Size(fieldNumber: 67)
            }
            if hasDefaultFixed64 {
                serialize_size += defaultFixed64.computeFixed64Size(fieldNumber: 68)
            }
            if hasDefaultSfixed32 {
                serialize_size += defaultSfixed32.computeSFixed32Size(fieldNumber: 69)
            }
            if hasDefaultSfixed64 {
                serialize_size += defaultSfixed64.computeSFixed64Size(fieldNumber: 70)
            }
            if hasDefaultFloat {
                serialize_size += defaultFloat.computeFloatSize(fieldNumber: 71)
            }
            if hasDefaultDouble {
                serialize_size += defaultDouble.computeDoubleSize(fieldNumber: 72)
            }
            if hasDefaultBool {
                serialize_size += defaultBool.computeBoolSize(fieldNumber: 73)
            }
            if hasDefaultString {
                serialize_size += defaultString.computeStringSize(fieldNumber: 74)
            }
            if hasDefaultBytes {
                serialize_size += defaultBytes.computeDataSize(fieldNumber: 75)
            }
            if (hasDefaultNestedEnum) {
                serialize_size += defaultNestedEnum.rawValue.computeEnumSize(fieldNumber: 81)
            }
            if (hasDefaultForeignEnum) {
                serialize_size += defaultForeignEnum.rawValue.computeEnumSize(fieldNumber: 82)
            }
            if (hasDefaultImportEnum) {
                serialize_size += defaultImportEnum.rawValue.computeEnumSize(fieldNumber: 83)
            }
            if hasDefaultStringPiece {
                serialize_size += defaultStringPiece.computeStringSize(fieldNumber: 84)
            }
            if hasDefaultCord {
                serialize_size += defaultCord.computeStringSize(fieldNumber: 85)
            }
            if hasOneofUint32 {
                serialize_size += oneofUint32.computeUInt32Size(fieldNumber: 111)
            }
            if hasOneofNestedMessage {
                if let varSizeoneofNestedMessage = oneofNestedMessage?.computeMessageSize(fieldNumber: 112) {
                    serialize_size += varSizeoneofNestedMessage
                }
            }
            if hasOneofString {
                serialize_size += oneofString.computeStringSize(fieldNumber: 113)
            }
            if hasOneofBytes {
                serialize_size += oneofBytes.computeDataSize(fieldNumber: 114)
            }
            if hasLazyOneofNestedMessage {
                if let varSizelazyOneofNestedMessage = lazyOneofNestedMessage?.computeMessageSize(fieldNumber: 115) {
                    serialize_size += varSizelazyOneofNestedMessage
                }
            }
            serialize_size += unknownFields.serializedSize()
            memoizedSerializedSize = serialize_size
            return serialize_size
        }
        public class func getBuilder() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
            return ProtobufUnittestNoArena.TestAllTypes.classBuilder() as! ProtobufUnittestNoArena.TestAllTypes.Builder
        }
        public func getBuilder() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
            return classBuilder() as! ProtobufUnittestNoArena.TestAllTypes.Builder
        }
        override public class func classBuilder() -> ProtocolBuffersMessageBuilder {
            return ProtobufUnittestNoArena.TestAllTypes.Builder()
        }
        override public func classBuilder() -> ProtocolBuffersMessageBuilder {
            return ProtobufUnittestNoArena.TestAllTypes.Builder()
        }
        public func toBuilder() throws -> ProtobufUnittestNoArena.TestAllTypes.Builder {
            return try ProtobufUnittestNoArena.TestAllTypes.builderWithPrototype(prototype:self)
        }
        public class func builderWithPrototype(prototype:ProtobufUnittestNoArena.TestAllTypes) throws -> ProtobufUnittestNoArena.TestAllTypes.Builder {
            return try ProtobufUnittestNoArena.TestAllTypes.Builder().mergeFrom(other:prototype)
        }
        override public func encode() throws -> Dictionary<String,Any> {
            try isInitialized()
            var jsonMap:Dictionary<String,Any> = Dictionary<String,Any>()
            if hasOptionalInt32 {
                jsonMap["optionalInt32"] = Int(optionalInt32)
            }
            if hasOptionalInt64 {
                jsonMap["optionalInt64"] = "\(optionalInt64!)"
            }
            if hasOptionalUint32 {
                jsonMap["optionalUint32"] = UInt(optionalUint32)
            }
            if hasOptionalUint64 {
                jsonMap["optionalUint64"] = "\(optionalUint64!)"
            }
            if hasOptionalSint32 {
                jsonMap["optionalSint32"] = Int(optionalSint32)
            }
            if hasOptionalSint64 {
                jsonMap["optionalSint64"] = "\(optionalSint64!)"
            }
            if hasOptionalFixed32 {
                jsonMap["optionalFixed32"] = UInt(optionalFixed32)
            }
            if hasOptionalFixed64 {
                jsonMap["optionalFixed64"] = "\(optionalFixed64!)"
            }
            if hasOptionalSfixed32 {
                jsonMap["optionalSfixed32"] = Int(optionalSfixed32)
            }
            if hasOptionalSfixed64 {
                jsonMap["optionalSfixed64"] = "\(optionalSfixed64!)"
            }
            if hasOptionalFloat {
                jsonMap["optionalFloat"] = Float(optionalFloat)
            }
            if hasOptionalDouble {
                jsonMap["optionalDouble"] = Double(optionalDouble)
            }
            if hasOptionalBool {
                jsonMap["optionalBool"] = optionalBool
            }
            if hasOptionalString {
                jsonMap["optionalString"] = optionalString
            }
            if hasOptionalBytes {
                jsonMap["optionalBytes"] = optionalBytes.base64EncodedString(options: Data.Base64EncodingOptions(rawValue: 0))
            }
            if hasOptionalGroup {
                jsonMap["optionalgroup"] = try optionalGroup.encode()
            }
            if hasOptionalNestedMessage {
                jsonMap["optionalNestedMessage"] = try optionalNestedMessage.encode()
            }
            if hasOptionalForeignMessage {
                jsonMap["optionalForeignMessage"] = try optionalForeignMessage.encode()
            }
            if hasOptionalImportMessage {
                jsonMap["optionalImportMessage"] = try optionalImportMessage.encode()
            }
            if hasOptionalNestedEnum {
                jsonMap["optionalNestedEnum"] = optionalNestedEnum.toString()
            }
            if hasOptionalForeignEnum {
                jsonMap["optionalForeignEnum"] = optionalForeignEnum.toString()
            }
            if hasOptionalImportEnum {
                jsonMap["optionalImportEnum"] = optionalImportEnum.toString()
            }
            if hasOptionalStringPiece {
                jsonMap["optionalStringPiece"] = optionalStringPiece
            }
            if hasOptionalCord {
                jsonMap["optionalCord"] = optionalCord
            }
            if hasOptionalPublicImportMessage {
                jsonMap["optionalPublicImportMessage"] = try optionalPublicImportMessage.encode()
            }
            if hasOptionalMessage {
                jsonMap["optionalMessage"] = try optionalMessage.encode()
            }
            if !repeatedInt32.isEmpty {
                var jsonArrayRepeatedInt32:Array<Int> = []
                for oneValueRepeatedInt32 in repeatedInt32 {
                    jsonArrayRepeatedInt32.append(Int(oneValueRepeatedInt32))
                }
                jsonMap["repeatedInt32"] = jsonArrayRepeatedInt32
            }
            if !repeatedInt64.isEmpty {
                var jsonArrayRepeatedInt64:Array<String> = []
                for oneValueRepeatedInt64 in repeatedInt64 {
                    jsonArrayRepeatedInt64.append("\(oneValueRepeatedInt64)")
                }
                jsonMap["repeatedInt64"] = jsonArrayRepeatedInt64
            }
            if !repeatedUint32.isEmpty {
                var jsonArrayRepeatedUint32:Array<UInt> = []
                for oneValueRepeatedUint32 in repeatedUint32 {
                    jsonArrayRepeatedUint32.append(UInt(oneValueRepeatedUint32))
                }
                jsonMap["repeatedUint32"] = jsonArrayRepeatedUint32
            }
            if !repeatedUint64.isEmpty {
                var jsonArrayRepeatedUint64:Array<String> = []
                for oneValueRepeatedUint64 in repeatedUint64 {
                    jsonArrayRepeatedUint64.append("\(oneValueRepeatedUint64)")
                }
                jsonMap["repeatedUint64"] = jsonArrayRepeatedUint64
            }
            if !repeatedSint32.isEmpty {
                var jsonArrayRepeatedSint32:Array<Int> = []
                for oneValueRepeatedSint32 in repeatedSint32 {
                    jsonArrayRepeatedSint32.append(Int(oneValueRepeatedSint32))
                }
                jsonMap["repeatedSint32"] = jsonArrayRepeatedSint32
            }
            if !repeatedSint64.isEmpty {
                var jsonArrayRepeatedSint64:Array<String> = []
                for oneValueRepeatedSint64 in repeatedSint64 {
                    jsonArrayRepeatedSint64.append("\(oneValueRepeatedSint64)")
                }
                jsonMap["repeatedSint64"] = jsonArrayRepeatedSint64
            }
            if !repeatedFixed32.isEmpty {
                var jsonArrayRepeatedFixed32:Array<UInt> = []
                for oneValueRepeatedFixed32 in repeatedFixed32 {
                    jsonArrayRepeatedFixed32.append(UInt(oneValueRepeatedFixed32))
                }
                jsonMap["repeatedFixed32"] = jsonArrayRepeatedFixed32
            }
            if !repeatedFixed64.isEmpty {
                var jsonArrayRepeatedFixed64:Array<String> = []
                for oneValueRepeatedFixed64 in repeatedFixed64 {
                    jsonArrayRepeatedFixed64.append("\(oneValueRepeatedFixed64)")
                }
                jsonMap["repeatedFixed64"] = jsonArrayRepeatedFixed64
            }
            if !repeatedSfixed32.isEmpty {
                var jsonArrayRepeatedSfixed32:Array<Int> = []
                for oneValueRepeatedSfixed32 in repeatedSfixed32 {
                    jsonArrayRepeatedSfixed32.append(Int(oneValueRepeatedSfixed32))
                }
                jsonMap["repeatedSfixed32"] = jsonArrayRepeatedSfixed32
            }
            if !repeatedSfixed64.isEmpty {
                var jsonArrayRepeatedSfixed64:Array<String> = []
                for oneValueRepeatedSfixed64 in repeatedSfixed64 {
                    jsonArrayRepeatedSfixed64.append("\(oneValueRepeatedSfixed64)")
                }
                jsonMap["repeatedSfixed64"] = jsonArrayRepeatedSfixed64
            }
            if !repeatedFloat.isEmpty {
                var jsonArrayRepeatedFloat:Array<Float> = []
                for oneValueRepeatedFloat in repeatedFloat {
                    jsonArrayRepeatedFloat.append(Float(oneValueRepeatedFloat))
                }
                jsonMap["repeatedFloat"] = jsonArrayRepeatedFloat
            }
            if !repeatedDouble.isEmpty {
                var jsonArrayRepeatedDouble:Array<Double> = []
                for oneValueRepeatedDouble in repeatedDouble {
                    jsonArrayRepeatedDouble.append(Double(oneValueRepeatedDouble))
                }
                jsonMap["repeatedDouble"] = jsonArrayRepeatedDouble
            }
            if !repeatedBool.isEmpty {
                var jsonArrayRepeatedBool:Array<Bool> = []
                for oneValueRepeatedBool in repeatedBool {
                    jsonArrayRepeatedBool.append(oneValueRepeatedBool)
                }
                jsonMap["repeatedBool"] = jsonArrayRepeatedBool
            }
            if !repeatedString.isEmpty {
                var jsonArrayRepeatedString:Array<String> = []
                for oneValueRepeatedString in repeatedString {
                    jsonArrayRepeatedString.append(oneValueRepeatedString)
                }
                jsonMap["repeatedString"] = jsonArrayRepeatedString
            }
            if !repeatedBytes.isEmpty {
                var jsonArrayRepeatedBytes:Array<String> = []
                for oneValueRepeatedBytes in repeatedBytes {
                    jsonArrayRepeatedBytes.append(oneValueRepeatedBytes.base64EncodedString(options: Data.Base64EncodingOptions(rawValue: 0)))
                }
                jsonMap["repeatedBytes"] = jsonArrayRepeatedBytes
            }
            if !repeatedGroup.isEmpty {
                var jsonArrayRepeatedGroup:Array<Dictionary<String,Any>> = []
                for oneValueRepeatedGroup in repeatedGroup {
                    let ecodedMessageRepeatedGroup = try oneValueRepeatedGroup.encode()
                    jsonArrayRepeatedGroup.append(ecodedMessageRepeatedGroup)
                }
                jsonMap["repeatedgroup"] = jsonArrayRepeatedGroup
            }
            if !repeatedNestedMessage.isEmpty {
                var jsonArrayRepeatedNestedMessage:Array<Dictionary<String,Any>> = []
                for oneValueRepeatedNestedMessage in repeatedNestedMessage {
                    let ecodedMessageRepeatedNestedMessage = try oneValueRepeatedNestedMessage.encode()
                    jsonArrayRepeatedNestedMessage.append(ecodedMessageRepeatedNestedMessage)
                }
                jsonMap["repeatedNestedMessage"] = jsonArrayRepeatedNestedMessage
            }
            if !repeatedForeignMessage.isEmpty {
                var jsonArrayRepeatedForeignMessage:Array<Dictionary<String,Any>> = []
                for oneValueRepeatedForeignMessage in repeatedForeignMessage {
                    let ecodedMessageRepeatedForeignMessage = try oneValueRepeatedForeignMessage.encode()
                    jsonArrayRepeatedForeignMessage.append(ecodedMessageRepeatedForeignMessage)
                }
                jsonMap["repeatedForeignMessage"] = jsonArrayRepeatedForeignMessage
            }
            if !repeatedImportMessage.isEmpty {
                var jsonArrayRepeatedImportMessage:Array<Dictionary<String,Any>> = []
                for oneValueRepeatedImportMessage in repeatedImportMessage {
                    let ecodedMessageRepeatedImportMessage = try oneValueRepeatedImportMessage.encode()
                    jsonArrayRepeatedImportMessage.append(ecodedMessageRepeatedImportMessage)
                }
                jsonMap["repeatedImportMessage"] = jsonArrayRepeatedImportMessage
            }
            if !repeatedNestedEnum.isEmpty {
                var jsonArrayRepeatedNestedEnum:Array<String> = []
                for oneValueRepeatedNestedEnum in repeatedNestedEnum {
                    jsonArrayRepeatedNestedEnum.append(oneValueRepeatedNestedEnum.toString())
                }
                jsonMap["repeatedNestedEnum"] = jsonArrayRepeatedNestedEnum
            }
            if !repeatedForeignEnum.isEmpty {
                var jsonArrayRepeatedForeignEnum:Array<String> = []
                for oneValueRepeatedForeignEnum in repeatedForeignEnum {
                    jsonArrayRepeatedForeignEnum.append(oneValueRepeatedForeignEnum.toString())
                }
                jsonMap["repeatedForeignEnum"] = jsonArrayRepeatedForeignEnum
            }
            if !repeatedImportEnum.isEmpty {
                var jsonArrayRepeatedImportEnum:Array<String> = []
                for oneValueRepeatedImportEnum in repeatedImportEnum {
                    jsonArrayRepeatedImportEnum.append(oneValueRepeatedImportEnum.toString())
                }
                jsonMap["repeatedImportEnum"] = jsonArrayRepeatedImportEnum
            }
            if !repeatedStringPiece.isEmpty {
                var jsonArrayRepeatedStringPiece:Array<String> = []
                for oneValueRepeatedStringPiece in repeatedStringPiece {
                    jsonArrayRepeatedStringPiece.append(oneValueRepeatedStringPiece)
                }
                jsonMap["repeatedStringPiece"] = jsonArrayRepeatedStringPiece
            }
            if !repeatedCord.isEmpty {
                var jsonArrayRepeatedCord:Array<String> = []
                for oneValueRepeatedCord in repeatedCord {
                    jsonArrayRepeatedCord.append(oneValueRepeatedCord)
                }
                jsonMap["repeatedCord"] = jsonArrayRepeatedCord
            }
            if !repeatedLazyMessage.isEmpty {
                var jsonArrayRepeatedLazyMessage:Array<Dictionary<String,Any>> = []
                for oneValueRepeatedLazyMessage in repeatedLazyMessage {
                    let ecodedMessageRepeatedLazyMessage = try oneValueRepeatedLazyMessage.encode()
                    jsonArrayRepeatedLazyMessage.append(ecodedMessageRepeatedLazyMessage)
                }
                jsonMap["repeatedLazyMessage"] = jsonArrayRepeatedLazyMessage
            }
            if hasDefaultInt32 {
                jsonMap["defaultInt32"] = Int(defaultInt32)
            }
            if hasDefaultInt64 {
                jsonMap["defaultInt64"] = "\(defaultInt64!)"
            }
            if hasDefaultUint32 {
                jsonMap["defaultUint32"] = UInt(defaultUint32)
            }
            if hasDefaultUint64 {
                jsonMap["defaultUint64"] = "\(defaultUint64!)"
            }
            if hasDefaultSint32 {
                jsonMap["defaultSint32"] = Int(defaultSint32)
            }
            if hasDefaultSint64 {
                jsonMap["defaultSint64"] = "\(defaultSint64!)"
            }
            if hasDefaultFixed32 {
                jsonMap["defaultFixed32"] = UInt(defaultFixed32)
            }
            if hasDefaultFixed64 {
                jsonMap["defaultFixed64"] = "\(defaultFixed64!)"
            }
            if hasDefaultSfixed32 {
                jsonMap["defaultSfixed32"] = Int(defaultSfixed32)
            }
            if hasDefaultSfixed64 {
                jsonMap["defaultSfixed64"] = "\(defaultSfixed64!)"
            }
            if hasDefaultFloat {
                jsonMap["defaultFloat"] = Float(defaultFloat)
            }
            if hasDefaultDouble {
                jsonMap["defaultDouble"] = Double(defaultDouble)
            }
            if hasDefaultBool {
                jsonMap["defaultBool"] = defaultBool
            }
            if hasDefaultString {
                jsonMap["defaultString"] = defaultString
            }
            if hasDefaultBytes {
                jsonMap["defaultBytes"] = defaultBytes.base64EncodedString(options: Data.Base64EncodingOptions(rawValue: 0))
            }
            if hasDefaultNestedEnum {
                jsonMap["defaultNestedEnum"] = defaultNestedEnum.toString()
            }
            if hasDefaultForeignEnum {
                jsonMap["defaultForeignEnum"] = defaultForeignEnum.toString()
            }
            if hasDefaultImportEnum {
                jsonMap["defaultImportEnum"] = defaultImportEnum.toString()
            }
            if hasDefaultStringPiece {
                jsonMap["defaultStringPiece"] = defaultStringPiece
            }
            if hasDefaultCord {
                jsonMap["defaultCord"] = defaultCord
            }
            if hasOneofUint32 {
                jsonMap["oneofUint32"] = UInt(oneofUint32)
            }
            if hasOneofNestedMessage {
                jsonMap["oneofNestedMessage"] = try oneofNestedMessage.encode()
            }
            if hasOneofString {
                jsonMap["oneofString"] = oneofString
            }
            if hasOneofBytes {
                jsonMap["oneofBytes"] = oneofBytes.base64EncodedString(options: Data.Base64EncodingOptions(rawValue: 0))
            }
            if hasLazyOneofNestedMessage {
                jsonMap["lazyOneofNestedMessage"] = try lazyOneofNestedMessage.encode()
            }
            return jsonMap
        }
        override class public func decode(jsonMap:Dictionary<String,Any>) throws -> ProtobufUnittestNoArena.TestAllTypes {
            return try ProtobufUnittestNoArena.TestAllTypes.Builder.decodeToBuilder(jsonMap:jsonMap).build()
        }
        override class public func fromJSON(data:Data, options: JSONSerialization.ReadingOptions = []) throws -> ProtobufUnittestNoArena.TestAllTypes {
            return try ProtobufUnittestNoArena.TestAllTypes.Builder.fromJSONToBuilder(data:data, options:options).build()
        }
        override public func getDescription(indent:String) throws -> String {
            var output = ""
            if hasOptionalInt32 {
                output += "\(indent) optionalInt32: \(String(describing: optionalInt32)) \n"
            }
            if hasOptionalInt64 {
                output += "\(indent) optionalInt64: \(String(describing: optionalInt64)) \n"
            }
            if hasOptionalUint32 {
                output += "\(indent) optionalUint32: \(String(describing: optionalUint32)) \n"
            }
            if hasOptionalUint64 {
                output += "\(indent) optionalUint64: \(String(describing: optionalUint64)) \n"
            }
            if hasOptionalSint32 {
                output += "\(indent) optionalSint32: \(String(describing: optionalSint32)) \n"
            }
            if hasOptionalSint64 {
                output += "\(indent) optionalSint64: \(String(describing: optionalSint64)) \n"
            }
            if hasOptionalFixed32 {
                output += "\(indent) optionalFixed32: \(String(describing: optionalFixed32)) \n"
            }
            if hasOptionalFixed64 {
                output += "\(indent) optionalFixed64: \(String(describing: optionalFixed64)) \n"
            }
            if hasOptionalSfixed32 {
                output += "\(indent) optionalSfixed32: \(String(describing: optionalSfixed32)) \n"
            }
            if hasOptionalSfixed64 {
                output += "\(indent) optionalSfixed64: \(String(describing: optionalSfixed64)) \n"
            }
            if hasOptionalFloat {
                output += "\(indent) optionalFloat: \(String(describing: optionalFloat)) \n"
            }
            if hasOptionalDouble {
                output += "\(indent) optionalDouble: \(String(describing: optionalDouble)) \n"
            }
            if hasOptionalBool {
                output += "\(indent) optionalBool: \(String(describing: optionalBool)) \n"
            }
            if hasOptionalString {
                output += "\(indent) optionalString: \(String(describing: optionalString)) \n"
            }
            if hasOptionalBytes {
                output += "\(indent) optionalBytes: \(String(describing: optionalBytes)) \n"
            }
            if hasOptionalGroup {
                output += "\(indent) optionalGroup {\n"
                if let outDescOptionalGroup = optionalGroup {
                    output += try outDescOptionalGroup.getDescription(indent: "\(indent)  ")
                }
                output += "\(indent) }\n"
            }
            if hasOptionalNestedMessage {
                output += "\(indent) optionalNestedMessage {\n"
                if let outDescOptionalNestedMessage = optionalNestedMessage {
                    output += try outDescOptionalNestedMessage.getDescription(indent: "\(indent)  ")
                }
                output += "\(indent) }\n"
            }
            if hasOptionalForeignMessage {
                output += "\(indent) optionalForeignMessage {\n"
                if let outDescOptionalForeignMessage = optionalForeignMessage {
                    output += try outDescOptionalForeignMessage.getDescription(indent: "\(indent)  ")
                }
                output += "\(indent) }\n"
            }
            if hasOptionalImportMessage {
                output += "\(indent) optionalImportMessage {\n"
                if let outDescOptionalImportMessage = optionalImportMessage {
                    output += try outDescOptionalImportMessage.getDescription(indent: "\(indent)  ")
                }
                output += "\(indent) }\n"
            }
            if (hasOptionalNestedEnum) {
                output += "\(indent) optionalNestedEnum: \(optionalNestedEnum.description)\n"
            }
            if (hasOptionalForeignEnum) {
                output += "\(indent) optionalForeignEnum: \(optionalForeignEnum.description)\n"
            }
            if (hasOptionalImportEnum) {
                output += "\(indent) optionalImportEnum: \(optionalImportEnum.description)\n"
            }
            if hasOptionalStringPiece {
                output += "\(indent) optionalStringPiece: \(String(describing: optionalStringPiece)) \n"
            }
            if hasOptionalCord {
                output += "\(indent) optionalCord: \(String(describing: optionalCord)) \n"
            }
            if hasOptionalPublicImportMessage {
                output += "\(indent) optionalPublicImportMessage {\n"
                if let outDescOptionalPublicImportMessage = optionalPublicImportMessage {
                    output += try outDescOptionalPublicImportMessage.getDescription(indent: "\(indent)  ")
                }
                output += "\(indent) }\n"
            }
            if hasOptionalMessage {
                output += "\(indent) optionalMessage {\n"
                if let outDescOptionalMessage = optionalMessage {
                    output += try outDescOptionalMessage.getDescription(indent: "\(indent)  ")
                }
                output += "\(indent) }\n"
            }
            var repeatedInt32ElementIndex:Int = 0
            for oneValueRepeatedInt32 in repeatedInt32  {
                output += "\(indent) repeatedInt32[\(repeatedInt32ElementIndex)]: \(oneValueRepeatedInt32)\n"
                repeatedInt32ElementIndex += 1
            }
            var repeatedInt64ElementIndex:Int = 0
            for oneValueRepeatedInt64 in repeatedInt64  {
                output += "\(indent) repeatedInt64[\(repeatedInt64ElementIndex)]: \(oneValueRepeatedInt64)\n"
                repeatedInt64ElementIndex += 1
            }
            var repeatedUint32ElementIndex:Int = 0
            for oneValueRepeatedUint32 in repeatedUint32  {
                output += "\(indent) repeatedUint32[\(repeatedUint32ElementIndex)]: \(oneValueRepeatedUint32)\n"
                repeatedUint32ElementIndex += 1
            }
            var repeatedUint64ElementIndex:Int = 0
            for oneValueRepeatedUint64 in repeatedUint64  {
                output += "\(indent) repeatedUint64[\(repeatedUint64ElementIndex)]: \(oneValueRepeatedUint64)\n"
                repeatedUint64ElementIndex += 1
            }
            var repeatedSint32ElementIndex:Int = 0
            for oneValueRepeatedSint32 in repeatedSint32  {
                output += "\(indent) repeatedSint32[\(repeatedSint32ElementIndex)]: \(oneValueRepeatedSint32)\n"
                repeatedSint32ElementIndex += 1
            }
            var repeatedSint64ElementIndex:Int = 0
            for oneValueRepeatedSint64 in repeatedSint64  {
                output += "\(indent) repeatedSint64[\(repeatedSint64ElementIndex)]: \(oneValueRepeatedSint64)\n"
                repeatedSint64ElementIndex += 1
            }
            var repeatedFixed32ElementIndex:Int = 0
            for oneValueRepeatedFixed32 in repeatedFixed32  {
                output += "\(indent) repeatedFixed32[\(repeatedFixed32ElementIndex)]: \(oneValueRepeatedFixed32)\n"
                repeatedFixed32ElementIndex += 1
            }
            var repeatedFixed64ElementIndex:Int = 0
            for oneValueRepeatedFixed64 in repeatedFixed64  {
                output += "\(indent) repeatedFixed64[\(repeatedFixed64ElementIndex)]: \(oneValueRepeatedFixed64)\n"
                repeatedFixed64ElementIndex += 1
            }
            var repeatedSfixed32ElementIndex:Int = 0
            for oneValueRepeatedSfixed32 in repeatedSfixed32  {
                output += "\(indent) repeatedSfixed32[\(repeatedSfixed32ElementIndex)]: \(oneValueRepeatedSfixed32)\n"
                repeatedSfixed32ElementIndex += 1
            }
            var repeatedSfixed64ElementIndex:Int = 0
            for oneValueRepeatedSfixed64 in repeatedSfixed64  {
                output += "\(indent) repeatedSfixed64[\(repeatedSfixed64ElementIndex)]: \(oneValueRepeatedSfixed64)\n"
                repeatedSfixed64ElementIndex += 1
            }
            var repeatedFloatElementIndex:Int = 0
            for oneValueRepeatedFloat in repeatedFloat  {
                output += "\(indent) repeatedFloat[\(repeatedFloatElementIndex)]: \(oneValueRepeatedFloat)\n"
                repeatedFloatElementIndex += 1
            }
            var repeatedDoubleElementIndex:Int = 0
            for oneValueRepeatedDouble in repeatedDouble  {
                output += "\(indent) repeatedDouble[\(repeatedDoubleElementIndex)]: \(oneValueRepeatedDouble)\n"
                repeatedDoubleElementIndex += 1
            }
            var repeatedBoolElementIndex:Int = 0
            for oneValueRepeatedBool in repeatedBool  {
                output += "\(indent) repeatedBool[\(repeatedBoolElementIndex)]: \(oneValueRepeatedBool)\n"
                repeatedBoolElementIndex += 1
            }
            var repeatedStringElementIndex:Int = 0
            for oneValueRepeatedString in repeatedString  {
                output += "\(indent) repeatedString[\(repeatedStringElementIndex)]: \(oneValueRepeatedString)\n"
                repeatedStringElementIndex += 1
            }
            var repeatedBytesElementIndex:Int = 0
            for oneValueRepeatedBytes in repeatedBytes  {
                output += "\(indent) repeatedBytes[\(repeatedBytesElementIndex)]: \(oneValueRepeatedBytes)\n"
                repeatedBytesElementIndex += 1
            }
            var repeatedGroupElementIndex:Int = 0
            for oneElementRepeatedGroup in repeatedGroup {
                output += "\(indent) repeatedGroup[\(repeatedGroupElementIndex)] {\n"
                output += try oneElementRepeatedGroup.getDescription(indent: "\(indent)  ")
                output += "\(indent)}\n"
                repeatedGroupElementIndex += 1
            }
            var repeatedNestedMessageElementIndex:Int = 0
            for oneElementRepeatedNestedMessage in repeatedNestedMessage {
                output += "\(indent) repeatedNestedMessage[\(repeatedNestedMessageElementIndex)] {\n"
                output += try oneElementRepeatedNestedMessage.getDescription(indent: "\(indent)  ")
                output += "\(indent)}\n"
                repeatedNestedMessageElementIndex += 1
            }
            var repeatedForeignMessageElementIndex:Int = 0
            for oneElementRepeatedForeignMessage in repeatedForeignMessage {
                output += "\(indent) repeatedForeignMessage[\(repeatedForeignMessageElementIndex)] {\n"
                output += try oneElementRepeatedForeignMessage.getDescription(indent: "\(indent)  ")
                output += "\(indent)}\n"
                repeatedForeignMessageElementIndex += 1
            }
            var repeatedImportMessageElementIndex:Int = 0
            for oneElementRepeatedImportMessage in repeatedImportMessage {
                output += "\(indent) repeatedImportMessage[\(repeatedImportMessageElementIndex)] {\n"
                output += try oneElementRepeatedImportMessage.getDescription(indent: "\(indent)  ")
                output += "\(indent)}\n"
                repeatedImportMessageElementIndex += 1
            }
            var repeatedNestedEnumElementIndex:Int = 0
            for oneValueOfrepeatedNestedEnum in repeatedNestedEnum {
                output += "\(indent) repeatedNestedEnum[\(repeatedNestedEnumElementIndex)]: \(oneValueOfrepeatedNestedEnum.description)\n"
                repeatedNestedEnumElementIndex += 1
            }
            var repeatedForeignEnumElementIndex:Int = 0
            for oneValueOfrepeatedForeignEnum in repeatedForeignEnum {
                output += "\(indent) repeatedForeignEnum[\(repeatedForeignEnumElementIndex)]: \(oneValueOfrepeatedForeignEnum.description)\n"
                repeatedForeignEnumElementIndex += 1
            }
            var repeatedImportEnumElementIndex:Int = 0
            for oneValueOfrepeatedImportEnum in repeatedImportEnum {
                output += "\(indent) repeatedImportEnum[\(repeatedImportEnumElementIndex)]: \(oneValueOfrepeatedImportEnum.description)\n"
                repeatedImportEnumElementIndex += 1
            }
            var repeatedStringPieceElementIndex:Int = 0
            for oneValueRepeatedStringPiece in repeatedStringPiece  {
                output += "\(indent) repeatedStringPiece[\(repeatedStringPieceElementIndex)]: \(oneValueRepeatedStringPiece)\n"
                repeatedStringPieceElementIndex += 1
            }
            var repeatedCordElementIndex:Int = 0
            for oneValueRepeatedCord in repeatedCord  {
                output += "\(indent) repeatedCord[\(repeatedCordElementIndex)]: \(oneValueRepeatedCord)\n"
                repeatedCordElementIndex += 1
            }
            var repeatedLazyMessageElementIndex:Int = 0
            for oneElementRepeatedLazyMessage in repeatedLazyMessage {
                output += "\(indent) repeatedLazyMessage[\(repeatedLazyMessageElementIndex)] {\n"
                output += try oneElementRepeatedLazyMessage.getDescription(indent: "\(indent)  ")
                output += "\(indent)}\n"
                repeatedLazyMessageElementIndex += 1
            }
            if hasDefaultInt32 {
                output += "\(indent) defaultInt32: \(String(describing: defaultInt32)) \n"
            }
            if hasDefaultInt64 {
                output += "\(indent) defaultInt64: \(String(describing: defaultInt64)) \n"
            }
            if hasDefaultUint32 {
                output += "\(indent) defaultUint32: \(String(describing: defaultUint32)) \n"
            }
            if hasDefaultUint64 {
                output += "\(indent) defaultUint64: \(String(describing: defaultUint64)) \n"
            }
            if hasDefaultSint32 {
                output += "\(indent) defaultSint32: \(String(describing: defaultSint32)) \n"
            }
            if hasDefaultSint64 {
                output += "\(indent) defaultSint64: \(String(describing: defaultSint64)) \n"
            }
            if hasDefaultFixed32 {
                output += "\(indent) defaultFixed32: \(String(describing: defaultFixed32)) \n"
            }
            if hasDefaultFixed64 {
                output += "\(indent) defaultFixed64: \(String(describing: defaultFixed64)) \n"
            }
            if hasDefaultSfixed32 {
                output += "\(indent) defaultSfixed32: \(String(describing: defaultSfixed32)) \n"
            }
            if hasDefaultSfixed64 {
                output += "\(indent) defaultSfixed64: \(String(describing: defaultSfixed64)) \n"
            }
            if hasDefaultFloat {
                output += "\(indent) defaultFloat: \(String(describing: defaultFloat)) \n"
            }
            if hasDefaultDouble {
                output += "\(indent) defaultDouble: \(String(describing: defaultDouble)) \n"
            }
            if hasDefaultBool {
                output += "\(indent) defaultBool: \(String(describing: defaultBool)) \n"
            }
            if hasDefaultString {
                output += "\(indent) defaultString: \(String(describing: defaultString)) \n"
            }
            if hasDefaultBytes {
                output += "\(indent) defaultBytes: \(String(describing: defaultBytes)) \n"
            }
            if (hasDefaultNestedEnum) {
                output += "\(indent) defaultNestedEnum: \(defaultNestedEnum.description)\n"
            }
            if (hasDefaultForeignEnum) {
                output += "\(indent) defaultForeignEnum: \(defaultForeignEnum.description)\n"
            }
            if (hasDefaultImportEnum) {
                output += "\(indent) defaultImportEnum: \(defaultImportEnum.description)\n"
            }
            if hasDefaultStringPiece {
                output += "\(indent) defaultStringPiece: \(String(describing: defaultStringPiece)) \n"
            }
            if hasDefaultCord {
                output += "\(indent) defaultCord: \(String(describing: defaultCord)) \n"
            }
            if hasOneofUint32 {
                output += "\(indent) oneofUint32: \(String(describing: oneofUint32)) \n"
            }
            if hasOneofNestedMessage {
                output += "\(indent) oneofNestedMessage {\n"
                if let outDescOneofNestedMessage = oneofNestedMessage {
                    output += try outDescOneofNestedMessage.getDescription(indent: "\(indent)  ")
                }
                output += "\(indent) }\n"
            }
            if hasOneofString {
                output += "\(indent) oneofString: \(String(describing: oneofString)) \n"
            }
            if hasOneofBytes {
                output += "\(indent) oneofBytes: \(String(describing: oneofBytes)) \n"
            }
            if hasLazyOneofNestedMessage {
                output += "\(indent) lazyOneofNestedMessage {\n"
                if let outDescLazyOneofNestedMessage = lazyOneofNestedMessage {
                    output += try outDescLazyOneofNestedMessage.getDescription(indent: "\(indent)  ")
                }
                output += "\(indent) }\n"
            }
            output += unknownFields.getDescription(indent: indent)
            return output
        }
        override public var hashValue:Int {
            get {
                var hashCode:Int = 7
                if hasOptionalInt32 {
                    hashCode = (hashCode &* 31) &+ optionalInt32.hashValue
                }
                if hasOptionalInt64 {
                    hashCode = (hashCode &* 31) &+ optionalInt64.hashValue
                }
                if hasOptionalUint32 {
                    hashCode = (hashCode &* 31) &+ optionalUint32.hashValue
                }
                if hasOptionalUint64 {
                    hashCode = (hashCode &* 31) &+ optionalUint64.hashValue
                }
                if hasOptionalSint32 {
                    hashCode = (hashCode &* 31) &+ optionalSint32.hashValue
                }
                if hasOptionalSint64 {
                    hashCode = (hashCode &* 31) &+ optionalSint64.hashValue
                }
                if hasOptionalFixed32 {
                    hashCode = (hashCode &* 31) &+ optionalFixed32.hashValue
                }
                if hasOptionalFixed64 {
                    hashCode = (hashCode &* 31) &+ optionalFixed64.hashValue
                }
                if hasOptionalSfixed32 {
                    hashCode = (hashCode &* 31) &+ optionalSfixed32.hashValue
                }
                if hasOptionalSfixed64 {
                    hashCode = (hashCode &* 31) &+ optionalSfixed64.hashValue
                }
                if hasOptionalFloat {
                    hashCode = (hashCode &* 31) &+ optionalFloat.hashValue
                }
                if hasOptionalDouble {
                    hashCode = (hashCode &* 31) &+ optionalDouble.hashValue
                }
                if hasOptionalBool {
                    hashCode = (hashCode &* 31) &+ optionalBool.hashValue
                }
                if hasOptionalString {
                    hashCode = (hashCode &* 31) &+ optionalString.hashValue
                }
                if hasOptionalBytes {
                    hashCode = (hashCode &* 31) &+ optionalBytes.hashValue
                }
                if hasOptionalGroup {
                    if let hashValueoptionalGroup = optionalGroup?.hashValue {
                        hashCode = (hashCode &* 31) &+ hashValueoptionalGroup
                    }
                }
                if hasOptionalNestedMessage {
                    if let hashValueoptionalNestedMessage = optionalNestedMessage?.hashValue {
                        hashCode = (hashCode &* 31) &+ hashValueoptionalNestedMessage
                    }
                }
                if hasOptionalForeignMessage {
                    if let hashValueoptionalForeignMessage = optionalForeignMessage?.hashValue {
                        hashCode = (hashCode &* 31) &+ hashValueoptionalForeignMessage
                    }
                }
                if hasOptionalImportMessage {
                    if let hashValueoptionalImportMessage = optionalImportMessage?.hashValue {
                        hashCode = (hashCode &* 31) &+ hashValueoptionalImportMessage
                    }
                }
                if hasOptionalNestedEnum {
                     hashCode = (hashCode &* 31) &+ optionalNestedEnum.hashValue
                }
                if hasOptionalForeignEnum {
                     hashCode = (hashCode &* 31) &+ optionalForeignEnum.hashValue
                }
                if hasOptionalImportEnum {
                     hashCode = (hashCode &* 31) &+ optionalImportEnum.hashValue
                }
                if hasOptionalStringPiece {
                    hashCode = (hashCode &* 31) &+ optionalStringPiece.hashValue
                }
                if hasOptionalCord {
                    hashCode = (hashCode &* 31) &+ optionalCord.hashValue
                }
                if hasOptionalPublicImportMessage {
                    if let hashValueoptionalPublicImportMessage = optionalPublicImportMessage?.hashValue {
                        hashCode = (hashCode &* 31) &+ hashValueoptionalPublicImportMessage
                    }
                }
                if hasOptionalMessage {
                    if let hashValueoptionalMessage = optionalMessage?.hashValue {
                        hashCode = (hashCode &* 31) &+ hashValueoptionalMessage
                    }
                }
                for oneValueRepeatedInt32 in repeatedInt32 {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedInt32.hashValue
                }
                for oneValueRepeatedInt64 in repeatedInt64 {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedInt64.hashValue
                }
                for oneValueRepeatedUint32 in repeatedUint32 {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedUint32.hashValue
                }
                for oneValueRepeatedUint64 in repeatedUint64 {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedUint64.hashValue
                }
                for oneValueRepeatedSint32 in repeatedSint32 {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedSint32.hashValue
                }
                for oneValueRepeatedSint64 in repeatedSint64 {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedSint64.hashValue
                }
                for oneValueRepeatedFixed32 in repeatedFixed32 {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedFixed32.hashValue
                }
                for oneValueRepeatedFixed64 in repeatedFixed64 {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedFixed64.hashValue
                }
                for oneValueRepeatedSfixed32 in repeatedSfixed32 {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedSfixed32.hashValue
                }
                for oneValueRepeatedSfixed64 in repeatedSfixed64 {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedSfixed64.hashValue
                }
                for oneValueRepeatedFloat in repeatedFloat {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedFloat.hashValue
                }
                for oneValueRepeatedDouble in repeatedDouble {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedDouble.hashValue
                }
                for oneValueRepeatedBool in repeatedBool {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedBool.hashValue
                }
                for oneValueRepeatedString in repeatedString {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedString.hashValue
                }
                for oneValueRepeatedBytes in repeatedBytes {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedBytes.hashValue
                }
                for oneElementRepeatedGroup in repeatedGroup {
                    hashCode = (hashCode &* 31) &+ oneElementRepeatedGroup.hashValue
                }
                for oneElementRepeatedNestedMessage in repeatedNestedMessage {
                    hashCode = (hashCode &* 31) &+ oneElementRepeatedNestedMessage.hashValue
                }
                for oneElementRepeatedForeignMessage in repeatedForeignMessage {
                    hashCode = (hashCode &* 31) &+ oneElementRepeatedForeignMessage.hashValue
                }
                for oneElementRepeatedImportMessage in repeatedImportMessage {
                    hashCode = (hashCode &* 31) &+ oneElementRepeatedImportMessage.hashValue
                }
                for oneValueOfrepeatedNestedEnum in repeatedNestedEnum {
                    hashCode = (hashCode &* 31) &+ oneValueOfrepeatedNestedEnum.hashValue
                }
                for oneValueOfrepeatedForeignEnum in repeatedForeignEnum {
                    hashCode = (hashCode &* 31) &+ oneValueOfrepeatedForeignEnum.hashValue
                }
                for oneValueOfrepeatedImportEnum in repeatedImportEnum {
                    hashCode = (hashCode &* 31) &+ oneValueOfrepeatedImportEnum.hashValue
                }
                for oneValueRepeatedStringPiece in repeatedStringPiece {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedStringPiece.hashValue
                }
                for oneValueRepeatedCord in repeatedCord {
                    hashCode = (hashCode &* 31) &+ oneValueRepeatedCord.hashValue
                }
                for oneElementRepeatedLazyMessage in repeatedLazyMessage {
                    hashCode = (hashCode &* 31) &+ oneElementRepeatedLazyMessage.hashValue
                }
                if hasDefaultInt32 {
                    hashCode = (hashCode &* 31) &+ defaultInt32.hashValue
                }
                if hasDefaultInt64 {
                    hashCode = (hashCode &* 31) &+ defaultInt64.hashValue
                }
                if hasDefaultUint32 {
                    hashCode = (hashCode &* 31) &+ defaultUint32.hashValue
                }
                if hasDefaultUint64 {
                    hashCode = (hashCode &* 31) &+ defaultUint64.hashValue
                }
                if hasDefaultSint32 {
                    hashCode = (hashCode &* 31) &+ defaultSint32.hashValue
                }
                if hasDefaultSint64 {
                    hashCode = (hashCode &* 31) &+ defaultSint64.hashValue
                }
                if hasDefaultFixed32 {
                    hashCode = (hashCode &* 31) &+ defaultFixed32.hashValue
                }
                if hasDefaultFixed64 {
                    hashCode = (hashCode &* 31) &+ defaultFixed64.hashValue
                }
                if hasDefaultSfixed32 {
                    hashCode = (hashCode &* 31) &+ defaultSfixed32.hashValue
                }
                if hasDefaultSfixed64 {
                    hashCode = (hashCode &* 31) &+ defaultSfixed64.hashValue
                }
                if hasDefaultFloat {
                    hashCode = (hashCode &* 31) &+ defaultFloat.hashValue
                }
                if hasDefaultDouble {
                    hashCode = (hashCode &* 31) &+ defaultDouble.hashValue
                }
                if hasDefaultBool {
                    hashCode = (hashCode &* 31) &+ defaultBool.hashValue
                }
                if hasDefaultString {
                    hashCode = (hashCode &* 31) &+ defaultString.hashValue
                }
                if hasDefaultBytes {
                    hashCode = (hashCode &* 31) &+ defaultBytes.hashValue
                }
                if hasDefaultNestedEnum {
                     hashCode = (hashCode &* 31) &+ defaultNestedEnum.hashValue
                }
                if hasDefaultForeignEnum {
                     hashCode = (hashCode &* 31) &+ defaultForeignEnum.hashValue
                }
                if hasDefaultImportEnum {
                     hashCode = (hashCode &* 31) &+ defaultImportEnum.hashValue
                }
                if hasDefaultStringPiece {
                    hashCode = (hashCode &* 31) &+ defaultStringPiece.hashValue
                }
                if hasDefaultCord {
                    hashCode = (hashCode &* 31) &+ defaultCord.hashValue
                }
                if hasOneofUint32 {
                    hashCode = (hashCode &* 31) &+ oneofUint32.hashValue
                }
                if hasOneofNestedMessage {
                    if let hashValueoneofNestedMessage = oneofNestedMessage?.hashValue {
                        hashCode = (hashCode &* 31) &+ hashValueoneofNestedMessage
                    }
                }
                if hasOneofString {
                    hashCode = (hashCode &* 31) &+ oneofString.hashValue
                }
                if hasOneofBytes {
                    hashCode = (hashCode &* 31) &+ oneofBytes.hashValue
                }
                if hasLazyOneofNestedMessage {
                    if let hashValuelazyOneofNestedMessage = lazyOneofNestedMessage?.hashValue {
                        hashCode = (hashCode &* 31) &+ hashValuelazyOneofNestedMessage
                    }
                }
                hashCode = (hashCode &* 31) &+  unknownFields.hashValue
                return hashCode
            }
        }


        //Meta information declaration start

        override public class func className() -> String {
            return "ProtobufUnittestNoArena.TestAllTypes"
        }
        override public func className() -> String {
            return "ProtobufUnittestNoArena.TestAllTypes"
        }
        //Meta information declaration end

        final public class Builder : GeneratedMessageBuilder {
            fileprivate var builderResult:ProtobufUnittestNoArena.TestAllTypes = ProtobufUnittestNoArena.TestAllTypes()
            public func getMessage() -> ProtobufUnittestNoArena.TestAllTypes {
                return builderResult
            }

            required override public init () {
                super.init()
            }
            public func setOneofField(_ oneOf:TestAllTypes.OneofField) ->  ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.storageOneofField = oneOf
                return self
            }
            /// Singular
            public var optionalInt32:Int32 {
                get {
                    return builderResult.optionalInt32
                }
                set (value) {
                    builderResult.hasOptionalInt32 = true
                    builderResult.optionalInt32 = value
                }
            }
            public var hasOptionalInt32:Bool {
                get {
                    return builderResult.hasOptionalInt32
                }
            }
            @discardableResult
            public func setOptionalInt32(_ value:Int32) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalInt32 = value
                return self
            }
            @discardableResult
            public func clearOptionalInt32() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalInt32 = false
                builderResult.optionalInt32 = nil
                return self
            }
            public var optionalInt64:Int64 {
                get {
                    return builderResult.optionalInt64
                }
                set (value) {
                    builderResult.hasOptionalInt64 = true
                    builderResult.optionalInt64 = value
                }
            }
            public var hasOptionalInt64:Bool {
                get {
                    return builderResult.hasOptionalInt64
                }
            }
            @discardableResult
            public func setOptionalInt64(_ value:Int64) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalInt64 = value
                return self
            }
            @discardableResult
            public func clearOptionalInt64() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalInt64 = false
                builderResult.optionalInt64 = nil
                return self
            }
            public var optionalUint32:UInt32 {
                get {
                    return builderResult.optionalUint32
                }
                set (value) {
                    builderResult.hasOptionalUint32 = true
                    builderResult.optionalUint32 = value
                }
            }
            public var hasOptionalUint32:Bool {
                get {
                    return builderResult.hasOptionalUint32
                }
            }
            @discardableResult
            public func setOptionalUint32(_ value:UInt32) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalUint32 = value
                return self
            }
            @discardableResult
            public func clearOptionalUint32() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalUint32 = false
                builderResult.optionalUint32 = nil
                return self
            }
            public var optionalUint64:UInt64 {
                get {
                    return builderResult.optionalUint64
                }
                set (value) {
                    builderResult.hasOptionalUint64 = true
                    builderResult.optionalUint64 = value
                }
            }
            public var hasOptionalUint64:Bool {
                get {
                    return builderResult.hasOptionalUint64
                }
            }
            @discardableResult
            public func setOptionalUint64(_ value:UInt64) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalUint64 = value
                return self
            }
            @discardableResult
            public func clearOptionalUint64() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalUint64 = false
                builderResult.optionalUint64 = nil
                return self
            }
            public var optionalSint32:Int32 {
                get {
                    return builderResult.optionalSint32
                }
                set (value) {
                    builderResult.hasOptionalSint32 = true
                    builderResult.optionalSint32 = value
                }
            }
            public var hasOptionalSint32:Bool {
                get {
                    return builderResult.hasOptionalSint32
                }
            }
            @discardableResult
            public func setOptionalSint32(_ value:Int32) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalSint32 = value
                return self
            }
            @discardableResult
            public func clearOptionalSint32() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalSint32 = false
                builderResult.optionalSint32 = nil
                return self
            }
            public var optionalSint64:Int64 {
                get {
                    return builderResult.optionalSint64
                }
                set (value) {
                    builderResult.hasOptionalSint64 = true
                    builderResult.optionalSint64 = value
                }
            }
            public var hasOptionalSint64:Bool {
                get {
                    return builderResult.hasOptionalSint64
                }
            }
            @discardableResult
            public func setOptionalSint64(_ value:Int64) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalSint64 = value
                return self
            }
            @discardableResult
            public func clearOptionalSint64() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalSint64 = false
                builderResult.optionalSint64 = nil
                return self
            }
            public var optionalFixed32:UInt32 {
                get {
                    return builderResult.optionalFixed32
                }
                set (value) {
                    builderResult.hasOptionalFixed32 = true
                    builderResult.optionalFixed32 = value
                }
            }
            public var hasOptionalFixed32:Bool {
                get {
                    return builderResult.hasOptionalFixed32
                }
            }
            @discardableResult
            public func setOptionalFixed32(_ value:UInt32) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalFixed32 = value
                return self
            }
            @discardableResult
            public func clearOptionalFixed32() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalFixed32 = false
                builderResult.optionalFixed32 = nil
                return self
            }
            public var optionalFixed64:UInt64 {
                get {
                    return builderResult.optionalFixed64
                }
                set (value) {
                    builderResult.hasOptionalFixed64 = true
                    builderResult.optionalFixed64 = value
                }
            }
            public var hasOptionalFixed64:Bool {
                get {
                    return builderResult.hasOptionalFixed64
                }
            }
            @discardableResult
            public func setOptionalFixed64(_ value:UInt64) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalFixed64 = value
                return self
            }
            @discardableResult
            public func clearOptionalFixed64() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalFixed64 = false
                builderResult.optionalFixed64 = nil
                return self
            }
            public var optionalSfixed32:Int32 {
                get {
                    return builderResult.optionalSfixed32
                }
                set (value) {
                    builderResult.hasOptionalSfixed32 = true
                    builderResult.optionalSfixed32 = value
                }
            }
            public var hasOptionalSfixed32:Bool {
                get {
                    return builderResult.hasOptionalSfixed32
                }
            }
            @discardableResult
            public func setOptionalSfixed32(_ value:Int32) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalSfixed32 = value
                return self
            }
            @discardableResult
            public func clearOptionalSfixed32() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalSfixed32 = false
                builderResult.optionalSfixed32 = nil
                return self
            }
            public var optionalSfixed64:Int64 {
                get {
                    return builderResult.optionalSfixed64
                }
                set (value) {
                    builderResult.hasOptionalSfixed64 = true
                    builderResult.optionalSfixed64 = value
                }
            }
            public var hasOptionalSfixed64:Bool {
                get {
                    return builderResult.hasOptionalSfixed64
                }
            }
            @discardableResult
            public func setOptionalSfixed64(_ value:Int64) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalSfixed64 = value
                return self
            }
            @discardableResult
            public func clearOptionalSfixed64() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalSfixed64 = false
                builderResult.optionalSfixed64 = nil
                return self
            }
            public var optionalFloat:Float {
                get {
                    return builderResult.optionalFloat
                }
                set (value) {
                    builderResult.hasOptionalFloat = true
                    builderResult.optionalFloat = value
                }
            }
            public var hasOptionalFloat:Bool {
                get {
                    return builderResult.hasOptionalFloat
                }
            }
            @discardableResult
            public func setOptionalFloat(_ value:Float) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalFloat = value
                return self
            }
            @discardableResult
            public func clearOptionalFloat() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalFloat = false
                builderResult.optionalFloat = nil
                return self
            }
            public var optionalDouble:Double {
                get {
                    return builderResult.optionalDouble
                }
                set (value) {
                    builderResult.hasOptionalDouble = true
                    builderResult.optionalDouble = value
                }
            }
            public var hasOptionalDouble:Bool {
                get {
                    return builderResult.hasOptionalDouble
                }
            }
            @discardableResult
            public func setOptionalDouble(_ value:Double) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalDouble = value
                return self
            }
            @discardableResult
            public func clearOptionalDouble() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalDouble = false
                builderResult.optionalDouble = nil
                return self
            }
            public var optionalBool:Bool {
                get {
                    return builderResult.optionalBool
                }
                set (value) {
                    builderResult.hasOptionalBool = true
                    builderResult.optionalBool = value
                }
            }
            public var hasOptionalBool:Bool {
                get {
                    return builderResult.hasOptionalBool
                }
            }
            @discardableResult
            public func setOptionalBool(_ value:Bool) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalBool = value
                return self
            }
            @discardableResult
            public func clearOptionalBool() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalBool = false
                builderResult.optionalBool = nil
                return self
            }
            public var optionalString:String {
                get {
                    return builderResult.optionalString
                }
                set (value) {
                    builderResult.hasOptionalString = true
                    builderResult.optionalString = value
                }
            }
            public var hasOptionalString:Bool {
                get {
                    return builderResult.hasOptionalString
                }
            }
            @discardableResult
            public func setOptionalString(_ value:String) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalString = value
                return self
            }
            @discardableResult
            public func clearOptionalString() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalString = false
                builderResult.optionalString = nil
                return self
            }
            public var optionalBytes:Data {
                get {
                    return builderResult.optionalBytes
                }
                set (value) {
                    builderResult.hasOptionalBytes = true
                    builderResult.optionalBytes = value
                }
            }
            public var hasOptionalBytes:Bool {
                get {
                    return builderResult.hasOptionalBytes
                }
            }
            @discardableResult
            public func setOptionalBytes(_ value:Data) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalBytes = value
                return self
            }
            @discardableResult
            public func clearOptionalBytes() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalBytes = false
                builderResult.optionalBytes = nil
                return self
            }
            public var optionalGroup:ProtobufUnittestNoArena.TestAllTypes.OptionalGroup! {
                get {
                    if optionalGroupBuilder_ != nil {
                        builderResult.optionalGroup = optionalGroupBuilder_.getMessage()
                    }
                    return builderResult.optionalGroup
                }
                set (value) {
                    builderResult.hasOptionalGroup = value != nil
                    builderResult.optionalGroup = value
                }
            }
            public var hasOptionalGroup:Bool {
                get {
                    return builderResult.hasOptionalGroup
                }
            }
            fileprivate var optionalGroupBuilder_:ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder! {
                didSet {
                    builderResult.hasOptionalGroup = true
                }
            }
            public func getOptionalGroupBuilder() -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder {
                if optionalGroupBuilder_ == nil {
                    optionalGroupBuilder_ = ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder()
                    builderResult.optionalGroup = optionalGroupBuilder_.getMessage()
                    if optionalGroup != nil {
                        try! optionalGroupBuilder_.mergeFrom(other: optionalGroup)
                    }
                }
                return optionalGroupBuilder_
            }
            @discardableResult
            public func setOptionalGroup(_ value:ProtobufUnittestNoArena.TestAllTypes.OptionalGroup!) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalGroup = value
                return self
            }
            @discardableResult
            public func mergeOptionalGroup(value:ProtobufUnittestNoArena.TestAllTypes.OptionalGroup) throws -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                if builderResult.hasOptionalGroup {
                    builderResult.optionalGroup = try ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.builderWithPrototype(prototype:builderResult.optionalGroup).mergeFrom(other: value).buildPartial()
                } else {
                    builderResult.optionalGroup = value
                }
                builderResult.hasOptionalGroup = true
                return self
            }
            @discardableResult
            public func clearOptionalGroup() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                optionalGroupBuilder_ = nil
                builderResult.hasOptionalGroup = false
                builderResult.optionalGroup = nil
                return self
            }
            public var optionalNestedMessage:ProtobufUnittestNoArena.TestAllTypes.NestedMessage! {
                get {
                    if optionalNestedMessageBuilder_ != nil {
                        builderResult.optionalNestedMessage = optionalNestedMessageBuilder_.getMessage()
                    }
                    return builderResult.optionalNestedMessage
                }
                set (value) {
                    builderResult.hasOptionalNestedMessage = value != nil
                    builderResult.optionalNestedMessage = value
                }
            }
            public var hasOptionalNestedMessage:Bool {
                get {
                    return builderResult.hasOptionalNestedMessage
                }
            }
            fileprivate var optionalNestedMessageBuilder_:ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder! {
                didSet {
                    builderResult.hasOptionalNestedMessage = true
                }
            }
            public func getOptionalNestedMessageBuilder() -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder {
                if optionalNestedMessageBuilder_ == nil {
                    optionalNestedMessageBuilder_ = ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder()
                    builderResult.optionalNestedMessage = optionalNestedMessageBuilder_.getMessage()
                    if optionalNestedMessage != nil {
                        try! optionalNestedMessageBuilder_.mergeFrom(other: optionalNestedMessage)
                    }
                }
                return optionalNestedMessageBuilder_
            }
            @discardableResult
            public func setOptionalNestedMessage(_ value:ProtobufUnittestNoArena.TestAllTypes.NestedMessage!) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalNestedMessage = value
                return self
            }
            @discardableResult
            public func mergeOptionalNestedMessage(value:ProtobufUnittestNoArena.TestAllTypes.NestedMessage) throws -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                if builderResult.hasOptionalNestedMessage {
                    builderResult.optionalNestedMessage = try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.builderWithPrototype(prototype:builderResult.optionalNestedMessage).mergeFrom(other: value).buildPartial()
                } else {
                    builderResult.optionalNestedMessage = value
                }
                builderResult.hasOptionalNestedMessage = true
                return self
            }
            @discardableResult
            public func clearOptionalNestedMessage() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                optionalNestedMessageBuilder_ = nil
                builderResult.hasOptionalNestedMessage = false
                builderResult.optionalNestedMessage = nil
                return self
            }
            public var optionalForeignMessage:ProtobufUnittestNoArena.ForeignMessage! {
                get {
                    if optionalForeignMessageBuilder_ != nil {
                        builderResult.optionalForeignMessage = optionalForeignMessageBuilder_.getMessage()
                    }
                    return builderResult.optionalForeignMessage
                }
                set (value) {
                    builderResult.hasOptionalForeignMessage = value != nil
                    builderResult.optionalForeignMessage = value
                }
            }
            public var hasOptionalForeignMessage:Bool {
                get {
                    return builderResult.hasOptionalForeignMessage
                }
            }
            fileprivate var optionalForeignMessageBuilder_:ProtobufUnittestNoArena.ForeignMessage.Builder! {
                didSet {
                    builderResult.hasOptionalForeignMessage = true
                }
            }
            public func getOptionalForeignMessageBuilder() -> ProtobufUnittestNoArena.ForeignMessage.Builder {
                if optionalForeignMessageBuilder_ == nil {
                    optionalForeignMessageBuilder_ = ProtobufUnittestNoArena.ForeignMessage.Builder()
                    builderResult.optionalForeignMessage = optionalForeignMessageBuilder_.getMessage()
                    if optionalForeignMessage != nil {
                        try! optionalForeignMessageBuilder_.mergeFrom(other: optionalForeignMessage)
                    }
                }
                return optionalForeignMessageBuilder_
            }
            @discardableResult
            public func setOptionalForeignMessage(_ value:ProtobufUnittestNoArena.ForeignMessage!) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalForeignMessage = value
                return self
            }
            @discardableResult
            public func mergeOptionalForeignMessage(value:ProtobufUnittestNoArena.ForeignMessage) throws -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                if builderResult.hasOptionalForeignMessage {
                    builderResult.optionalForeignMessage = try ProtobufUnittestNoArena.ForeignMessage.builderWithPrototype(prototype:builderResult.optionalForeignMessage).mergeFrom(other: value).buildPartial()
                } else {
                    builderResult.optionalForeignMessage = value
                }
                builderResult.hasOptionalForeignMessage = true
                return self
            }
            @discardableResult
            public func clearOptionalForeignMessage() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                optionalForeignMessageBuilder_ = nil
                builderResult.hasOptionalForeignMessage = false
                builderResult.optionalForeignMessage = nil
                return self
            }
            public var optionalImportMessage:ProtobufUnittestImport.ImportMessage! {
                get {
                    if optionalImportMessageBuilder_ != nil {
                        builderResult.optionalImportMessage = optionalImportMessageBuilder_.getMessage()
                    }
                    return builderResult.optionalImportMessage
                }
                set (value) {
                    builderResult.hasOptionalImportMessage = value != nil
                    builderResult.optionalImportMessage = value
                }
            }
            public var hasOptionalImportMessage:Bool {
                get {
                    return builderResult.hasOptionalImportMessage
                }
            }
            fileprivate var optionalImportMessageBuilder_:ProtobufUnittestImport.ImportMessage.Builder! {
                didSet {
                    builderResult.hasOptionalImportMessage = true
                }
            }
            public func getOptionalImportMessageBuilder() -> ProtobufUnittestImport.ImportMessage.Builder {
                if optionalImportMessageBuilder_ == nil {
                    optionalImportMessageBuilder_ = ProtobufUnittestImport.ImportMessage.Builder()
                    builderResult.optionalImportMessage = optionalImportMessageBuilder_.getMessage()
                    if optionalImportMessage != nil {
                        try! optionalImportMessageBuilder_.mergeFrom(other: optionalImportMessage)
                    }
                }
                return optionalImportMessageBuilder_
            }
            @discardableResult
            public func setOptionalImportMessage(_ value:ProtobufUnittestImport.ImportMessage!) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalImportMessage = value
                return self
            }
            @discardableResult
            public func mergeOptionalImportMessage(value:ProtobufUnittestImport.ImportMessage) throws -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                if builderResult.hasOptionalImportMessage {
                    builderResult.optionalImportMessage = try ProtobufUnittestImport.ImportMessage.builderWithPrototype(prototype:builderResult.optionalImportMessage).mergeFrom(other: value).buildPartial()
                } else {
                    builderResult.optionalImportMessage = value
                }
                builderResult.hasOptionalImportMessage = true
                return self
            }
            @discardableResult
            public func clearOptionalImportMessage() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                optionalImportMessageBuilder_ = nil
                builderResult.hasOptionalImportMessage = false
                builderResult.optionalImportMessage = nil
                return self
            }
                public var optionalNestedEnum:ProtobufUnittestNoArena.TestAllTypes.NestedEnum {
                    get {
                        return builderResult.optionalNestedEnum
                    }
                    set (value) {
                        builderResult.hasOptionalNestedEnum = true
                        builderResult.optionalNestedEnum = value
                    }
                }
                public var hasOptionalNestedEnum:Bool{
                    get {
                        return builderResult.hasOptionalNestedEnum
                    }
                }
            @discardableResult
                public func setOptionalNestedEnum(_ value:ProtobufUnittestNoArena.TestAllTypes.NestedEnum) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                  self.optionalNestedEnum = value
                  return self
                }
            @discardableResult
                public func clearOptionalNestedEnum() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                   builderResult.hasOptionalNestedEnum = false
                   builderResult.optionalNestedEnum = .foo
                   return self
                }
                public var optionalForeignEnum:ProtobufUnittestNoArena.ForeignEnum {
                    get {
                        return builderResult.optionalForeignEnum
                    }
                    set (value) {
                        builderResult.hasOptionalForeignEnum = true
                        builderResult.optionalForeignEnum = value
                    }
                }
                public var hasOptionalForeignEnum:Bool{
                    get {
                        return builderResult.hasOptionalForeignEnum
                    }
                }
            @discardableResult
                public func setOptionalForeignEnum(_ value:ProtobufUnittestNoArena.ForeignEnum) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                  self.optionalForeignEnum = value
                  return self
                }
            @discardableResult
                public func clearOptionalForeignEnum() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                   builderResult.hasOptionalForeignEnum = false
                   builderResult.optionalForeignEnum = .foreignFoo
                   return self
                }
                public var optionalImportEnum:ProtobufUnittestImport.ImportEnum {
                    get {
                        return builderResult.optionalImportEnum
                    }
                    set (value) {
                        builderResult.hasOptionalImportEnum = true
                        builderResult.optionalImportEnum = value
                    }
                }
                public var hasOptionalImportEnum:Bool{
                    get {
                        return builderResult.hasOptionalImportEnum
                    }
                }
            @discardableResult
                public func setOptionalImportEnum(_ value:ProtobufUnittestImport.ImportEnum) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                  self.optionalImportEnum = value
                  return self
                }
            @discardableResult
                public func clearOptionalImportEnum() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                   builderResult.hasOptionalImportEnum = false
                   builderResult.optionalImportEnum = .importFoo
                   return self
                }
            public var optionalStringPiece:String {
                get {
                    return builderResult.optionalStringPiece
                }
                set (value) {
                    builderResult.hasOptionalStringPiece = true
                    builderResult.optionalStringPiece = value
                }
            }
            public var hasOptionalStringPiece:Bool {
                get {
                    return builderResult.hasOptionalStringPiece
                }
            }
            @discardableResult
            public func setOptionalStringPiece(_ value:String) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalStringPiece = value
                return self
            }
            @discardableResult
            public func clearOptionalStringPiece() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalStringPiece = false
                builderResult.optionalStringPiece = nil
                return self
            }
            public var optionalCord:String {
                get {
                    return builderResult.optionalCord
                }
                set (value) {
                    builderResult.hasOptionalCord = true
                    builderResult.optionalCord = value
                }
            }
            public var hasOptionalCord:Bool {
                get {
                    return builderResult.hasOptionalCord
                }
            }
            @discardableResult
            public func setOptionalCord(_ value:String) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalCord = value
                return self
            }
            @discardableResult
            public func clearOptionalCord() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOptionalCord = false
                builderResult.optionalCord = nil
                return self
            }
            /// Defined in unittest_import_public.proto
            public var optionalPublicImportMessage:ProtobufUnittestImport.PublicImportMessage! {
                get {
                    if optionalPublicImportMessageBuilder_ != nil {
                        builderResult.optionalPublicImportMessage = optionalPublicImportMessageBuilder_.getMessage()
                    }
                    return builderResult.optionalPublicImportMessage
                }
                set (value) {
                    builderResult.hasOptionalPublicImportMessage = value != nil
                    builderResult.optionalPublicImportMessage = value
                }
            }
            public var hasOptionalPublicImportMessage:Bool {
                get {
                    return builderResult.hasOptionalPublicImportMessage
                }
            }
            fileprivate var optionalPublicImportMessageBuilder_:ProtobufUnittestImport.PublicImportMessage.Builder! {
                didSet {
                    builderResult.hasOptionalPublicImportMessage = true
                }
            }
            public func getOptionalPublicImportMessageBuilder() -> ProtobufUnittestImport.PublicImportMessage.Builder {
                if optionalPublicImportMessageBuilder_ == nil {
                    optionalPublicImportMessageBuilder_ = ProtobufUnittestImport.PublicImportMessage.Builder()
                    builderResult.optionalPublicImportMessage = optionalPublicImportMessageBuilder_.getMessage()
                    if optionalPublicImportMessage != nil {
                        try! optionalPublicImportMessageBuilder_.mergeFrom(other: optionalPublicImportMessage)
                    }
                }
                return optionalPublicImportMessageBuilder_
            }
            @discardableResult
            public func setOptionalPublicImportMessage(_ value:ProtobufUnittestImport.PublicImportMessage!) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalPublicImportMessage = value
                return self
            }
            @discardableResult
            public func mergeOptionalPublicImportMessage(value:ProtobufUnittestImport.PublicImportMessage) throws -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                if builderResult.hasOptionalPublicImportMessage {
                    builderResult.optionalPublicImportMessage = try ProtobufUnittestImport.PublicImportMessage.builderWithPrototype(prototype:builderResult.optionalPublicImportMessage).mergeFrom(other: value).buildPartial()
                } else {
                    builderResult.optionalPublicImportMessage = value
                }
                builderResult.hasOptionalPublicImportMessage = true
                return self
            }
            @discardableResult
            public func clearOptionalPublicImportMessage() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                optionalPublicImportMessageBuilder_ = nil
                builderResult.hasOptionalPublicImportMessage = false
                builderResult.optionalPublicImportMessage = nil
                return self
            }
            public var optionalMessage:ProtobufUnittestNoArena.TestAllTypes.NestedMessage! {
                get {
                    if optionalMessageBuilder_ != nil {
                        builderResult.optionalMessage = optionalMessageBuilder_.getMessage()
                    }
                    return builderResult.optionalMessage
                }
                set (value) {
                    builderResult.hasOptionalMessage = value != nil
                    builderResult.optionalMessage = value
                }
            }
            public var hasOptionalMessage:Bool {
                get {
                    return builderResult.hasOptionalMessage
                }
            }
            fileprivate var optionalMessageBuilder_:ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder! {
                didSet {
                    builderResult.hasOptionalMessage = true
                }
            }
            public func getOptionalMessageBuilder() -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder {
                if optionalMessageBuilder_ == nil {
                    optionalMessageBuilder_ = ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder()
                    builderResult.optionalMessage = optionalMessageBuilder_.getMessage()
                    if optionalMessage != nil {
                        try! optionalMessageBuilder_.mergeFrom(other: optionalMessage)
                    }
                }
                return optionalMessageBuilder_
            }
            @discardableResult
            public func setOptionalMessage(_ value:ProtobufUnittestNoArena.TestAllTypes.NestedMessage!) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.optionalMessage = value
                return self
            }
            @discardableResult
            public func mergeOptionalMessage(value:ProtobufUnittestNoArena.TestAllTypes.NestedMessage) throws -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                if builderResult.hasOptionalMessage {
                    builderResult.optionalMessage = try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.builderWithPrototype(prototype:builderResult.optionalMessage).mergeFrom(other: value).buildPartial()
                } else {
                    builderResult.optionalMessage = value
                }
                builderResult.hasOptionalMessage = true
                return self
            }
            @discardableResult
            public func clearOptionalMessage() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                optionalMessageBuilder_ = nil
                builderResult.hasOptionalMessage = false
                builderResult.optionalMessage = nil
                return self
            }
            /// Repeated
            public var repeatedInt32:Array<Int32> {
                get {
                    return builderResult.repeatedInt32
                }
                set (array) {
                    builderResult.repeatedInt32 = array
                }
            }
            @discardableResult
            public func setRepeatedInt32(_ value:Array<Int32>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedInt32 = value
                return self
            }
            @discardableResult
            public func clearRepeatedInt32() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedInt32.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedInt64:Array<Int64> {
                get {
                    return builderResult.repeatedInt64
                }
                set (array) {
                    builderResult.repeatedInt64 = array
                }
            }
            @discardableResult
            public func setRepeatedInt64(_ value:Array<Int64>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedInt64 = value
                return self
            }
            @discardableResult
            public func clearRepeatedInt64() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedInt64.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedUint32:Array<UInt32> {
                get {
                    return builderResult.repeatedUint32
                }
                set (array) {
                    builderResult.repeatedUint32 = array
                }
            }
            @discardableResult
            public func setRepeatedUint32(_ value:Array<UInt32>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedUint32 = value
                return self
            }
            @discardableResult
            public func clearRepeatedUint32() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedUint32.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedUint64:Array<UInt64> {
                get {
                    return builderResult.repeatedUint64
                }
                set (array) {
                    builderResult.repeatedUint64 = array
                }
            }
            @discardableResult
            public func setRepeatedUint64(_ value:Array<UInt64>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedUint64 = value
                return self
            }
            @discardableResult
            public func clearRepeatedUint64() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedUint64.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedSint32:Array<Int32> {
                get {
                    return builderResult.repeatedSint32
                }
                set (array) {
                    builderResult.repeatedSint32 = array
                }
            }
            @discardableResult
            public func setRepeatedSint32(_ value:Array<Int32>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedSint32 = value
                return self
            }
            @discardableResult
            public func clearRepeatedSint32() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedSint32.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedSint64:Array<Int64> {
                get {
                    return builderResult.repeatedSint64
                }
                set (array) {
                    builderResult.repeatedSint64 = array
                }
            }
            @discardableResult
            public func setRepeatedSint64(_ value:Array<Int64>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedSint64 = value
                return self
            }
            @discardableResult
            public func clearRepeatedSint64() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedSint64.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedFixed32:Array<UInt32> {
                get {
                    return builderResult.repeatedFixed32
                }
                set (array) {
                    builderResult.repeatedFixed32 = array
                }
            }
            @discardableResult
            public func setRepeatedFixed32(_ value:Array<UInt32>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedFixed32 = value
                return self
            }
            @discardableResult
            public func clearRepeatedFixed32() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedFixed32.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedFixed64:Array<UInt64> {
                get {
                    return builderResult.repeatedFixed64
                }
                set (array) {
                    builderResult.repeatedFixed64 = array
                }
            }
            @discardableResult
            public func setRepeatedFixed64(_ value:Array<UInt64>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedFixed64 = value
                return self
            }
            @discardableResult
            public func clearRepeatedFixed64() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedFixed64.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedSfixed32:Array<Int32> {
                get {
                    return builderResult.repeatedSfixed32
                }
                set (array) {
                    builderResult.repeatedSfixed32 = array
                }
            }
            @discardableResult
            public func setRepeatedSfixed32(_ value:Array<Int32>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedSfixed32 = value
                return self
            }
            @discardableResult
            public func clearRepeatedSfixed32() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedSfixed32.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedSfixed64:Array<Int64> {
                get {
                    return builderResult.repeatedSfixed64
                }
                set (array) {
                    builderResult.repeatedSfixed64 = array
                }
            }
            @discardableResult
            public func setRepeatedSfixed64(_ value:Array<Int64>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedSfixed64 = value
                return self
            }
            @discardableResult
            public func clearRepeatedSfixed64() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedSfixed64.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedFloat:Array<Float> {
                get {
                    return builderResult.repeatedFloat
                }
                set (array) {
                    builderResult.repeatedFloat = array
                }
            }
            @discardableResult
            public func setRepeatedFloat(_ value:Array<Float>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedFloat = value
                return self
            }
            @discardableResult
            public func clearRepeatedFloat() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedFloat.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedDouble:Array<Double> {
                get {
                    return builderResult.repeatedDouble
                }
                set (array) {
                    builderResult.repeatedDouble = array
                }
            }
            @discardableResult
            public func setRepeatedDouble(_ value:Array<Double>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedDouble = value
                return self
            }
            @discardableResult
            public func clearRepeatedDouble() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedDouble.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedBool:Array<Bool> {
                get {
                    return builderResult.repeatedBool
                }
                set (array) {
                    builderResult.repeatedBool = array
                }
            }
            @discardableResult
            public func setRepeatedBool(_ value:Array<Bool>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedBool = value
                return self
            }
            @discardableResult
            public func clearRepeatedBool() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedBool.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedString:Array<String> {
                get {
                    return builderResult.repeatedString
                }
                set (array) {
                    builderResult.repeatedString = array
                }
            }
            @discardableResult
            public func setRepeatedString(_ value:Array<String>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedString = value
                return self
            }
            @discardableResult
            public func clearRepeatedString() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedString.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedBytes:Array<Data> {
                get {
                    return builderResult.repeatedBytes
                }
                set (array) {
                    builderResult.repeatedBytes = array
                }
            }
            @discardableResult
            public func setRepeatedBytes(_ value:Array<Data>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedBytes = value
                return self
            }
            @discardableResult
            public func clearRepeatedBytes() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedBytes.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedGroup:Array<ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup> {
                get {
                    return builderResult.repeatedGroup
                }
                set (value) {
                    builderResult.repeatedGroup = value
                }
            }
            @discardableResult
            public func setRepeatedGroup(_ value:Array<ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedGroup = value
                return self
            }
            @discardableResult
            public func clearRepeatedGroup() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedGroup.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedNestedMessage:Array<ProtobufUnittestNoArena.TestAllTypes.NestedMessage> {
                get {
                    return builderResult.repeatedNestedMessage
                }
                set (value) {
                    builderResult.repeatedNestedMessage = value
                }
            }
            @discardableResult
            public func setRepeatedNestedMessage(_ value:Array<ProtobufUnittestNoArena.TestAllTypes.NestedMessage>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedNestedMessage = value
                return self
            }
            @discardableResult
            public func clearRepeatedNestedMessage() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedNestedMessage.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedForeignMessage:Array<ProtobufUnittestNoArena.ForeignMessage> {
                get {
                    return builderResult.repeatedForeignMessage
                }
                set (value) {
                    builderResult.repeatedForeignMessage = value
                }
            }
            @discardableResult
            public func setRepeatedForeignMessage(_ value:Array<ProtobufUnittestNoArena.ForeignMessage>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedForeignMessage = value
                return self
            }
            @discardableResult
            public func clearRepeatedForeignMessage() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedForeignMessage.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedImportMessage:Array<ProtobufUnittestImport.ImportMessage> {
                get {
                    return builderResult.repeatedImportMessage
                }
                set (value) {
                    builderResult.repeatedImportMessage = value
                }
            }
            @discardableResult
            public func setRepeatedImportMessage(_ value:Array<ProtobufUnittestImport.ImportMessage>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedImportMessage = value
                return self
            }
            @discardableResult
            public func clearRepeatedImportMessage() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedImportMessage.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedNestedEnum:Array<ProtobufUnittestNoArena.TestAllTypes.NestedEnum> {
                get {
                    return builderResult.repeatedNestedEnum
                }
                set (value) {
                    builderResult.repeatedNestedEnum = value
                }
            }
            @discardableResult
            public func setRepeatedNestedEnum(_ value:Array<ProtobufUnittestNoArena.TestAllTypes.NestedEnum>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedNestedEnum = value
                return self
            }
            @discardableResult
            public func clearRepeatedNestedEnum() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedNestedEnum.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedForeignEnum:Array<ProtobufUnittestNoArena.ForeignEnum> {
                get {
                    return builderResult.repeatedForeignEnum
                }
                set (value) {
                    builderResult.repeatedForeignEnum = value
                }
            }
            @discardableResult
            public func setRepeatedForeignEnum(_ value:Array<ProtobufUnittestNoArena.ForeignEnum>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedForeignEnum = value
                return self
            }
            @discardableResult
            public func clearRepeatedForeignEnum() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedForeignEnum.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedImportEnum:Array<ProtobufUnittestImport.ImportEnum> {
                get {
                    return builderResult.repeatedImportEnum
                }
                set (value) {
                    builderResult.repeatedImportEnum = value
                }
            }
            @discardableResult
            public func setRepeatedImportEnum(_ value:Array<ProtobufUnittestImport.ImportEnum>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedImportEnum = value
                return self
            }
            @discardableResult
            public func clearRepeatedImportEnum() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedImportEnum.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedStringPiece:Array<String> {
                get {
                    return builderResult.repeatedStringPiece
                }
                set (array) {
                    builderResult.repeatedStringPiece = array
                }
            }
            @discardableResult
            public func setRepeatedStringPiece(_ value:Array<String>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedStringPiece = value
                return self
            }
            @discardableResult
            public func clearRepeatedStringPiece() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedStringPiece.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedCord:Array<String> {
                get {
                    return builderResult.repeatedCord
                }
                set (array) {
                    builderResult.repeatedCord = array
                }
            }
            @discardableResult
            public func setRepeatedCord(_ value:Array<String>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedCord = value
                return self
            }
            @discardableResult
            public func clearRepeatedCord() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedCord.removeAll(keepingCapacity: false)
                return self
            }
            public var repeatedLazyMessage:Array<ProtobufUnittestNoArena.TestAllTypes.NestedMessage> {
                get {
                    return builderResult.repeatedLazyMessage
                }
                set (value) {
                    builderResult.repeatedLazyMessage = value
                }
            }
            @discardableResult
            public func setRepeatedLazyMessage(_ value:Array<ProtobufUnittestNoArena.TestAllTypes.NestedMessage>) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.repeatedLazyMessage = value
                return self
            }
            @discardableResult
            public func clearRepeatedLazyMessage() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult.repeatedLazyMessage.removeAll(keepingCapacity: false)
                return self
            }
            /// Singular with defaults
            public var defaultInt32:Int32 {
                get {
                    return builderResult.defaultInt32
                }
                set (value) {
                    builderResult.hasDefaultInt32 = true
                    builderResult.defaultInt32 = value
                }
            }
            public var hasDefaultInt32:Bool {
                get {
                    return builderResult.hasDefaultInt32
                }
            }
            @discardableResult
            public func setDefaultInt32(_ value:Int32) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultInt32 = value
                return self
            }
            @discardableResult
            public func clearDefaultInt32() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultInt32 = false
                builderResult.defaultInt32 = Int32(41)
                return self
            }
            public var defaultInt64:Int64 {
                get {
                    return builderResult.defaultInt64
                }
                set (value) {
                    builderResult.hasDefaultInt64 = true
                    builderResult.defaultInt64 = value
                }
            }
            public var hasDefaultInt64:Bool {
                get {
                    return builderResult.hasDefaultInt64
                }
            }
            @discardableResult
            public func setDefaultInt64(_ value:Int64) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultInt64 = value
                return self
            }
            @discardableResult
            public func clearDefaultInt64() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultInt64 = false
                builderResult.defaultInt64 = Int64(42)
                return self
            }
            public var defaultUint32:UInt32 {
                get {
                    return builderResult.defaultUint32
                }
                set (value) {
                    builderResult.hasDefaultUint32 = true
                    builderResult.defaultUint32 = value
                }
            }
            public var hasDefaultUint32:Bool {
                get {
                    return builderResult.hasDefaultUint32
                }
            }
            @discardableResult
            public func setDefaultUint32(_ value:UInt32) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultUint32 = value
                return self
            }
            @discardableResult
            public func clearDefaultUint32() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultUint32 = false
                builderResult.defaultUint32 = UInt32(43)
                return self
            }
            public var defaultUint64:UInt64 {
                get {
                    return builderResult.defaultUint64
                }
                set (value) {
                    builderResult.hasDefaultUint64 = true
                    builderResult.defaultUint64 = value
                }
            }
            public var hasDefaultUint64:Bool {
                get {
                    return builderResult.hasDefaultUint64
                }
            }
            @discardableResult
            public func setDefaultUint64(_ value:UInt64) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultUint64 = value
                return self
            }
            @discardableResult
            public func clearDefaultUint64() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultUint64 = false
                builderResult.defaultUint64 = UInt64(44)
                return self
            }
            public var defaultSint32:Int32 {
                get {
                    return builderResult.defaultSint32
                }
                set (value) {
                    builderResult.hasDefaultSint32 = true
                    builderResult.defaultSint32 = value
                }
            }
            public var hasDefaultSint32:Bool {
                get {
                    return builderResult.hasDefaultSint32
                }
            }
            @discardableResult
            public func setDefaultSint32(_ value:Int32) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultSint32 = value
                return self
            }
            @discardableResult
            public func clearDefaultSint32() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultSint32 = false
                builderResult.defaultSint32 = Int32(-45)
                return self
            }
            public var defaultSint64:Int64 {
                get {
                    return builderResult.defaultSint64
                }
                set (value) {
                    builderResult.hasDefaultSint64 = true
                    builderResult.defaultSint64 = value
                }
            }
            public var hasDefaultSint64:Bool {
                get {
                    return builderResult.hasDefaultSint64
                }
            }
            @discardableResult
            public func setDefaultSint64(_ value:Int64) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultSint64 = value
                return self
            }
            @discardableResult
            public func clearDefaultSint64() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultSint64 = false
                builderResult.defaultSint64 = Int64(46)
                return self
            }
            public var defaultFixed32:UInt32 {
                get {
                    return builderResult.defaultFixed32
                }
                set (value) {
                    builderResult.hasDefaultFixed32 = true
                    builderResult.defaultFixed32 = value
                }
            }
            public var hasDefaultFixed32:Bool {
                get {
                    return builderResult.hasDefaultFixed32
                }
            }
            @discardableResult
            public func setDefaultFixed32(_ value:UInt32) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultFixed32 = value
                return self
            }
            @discardableResult
            public func clearDefaultFixed32() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultFixed32 = false
                builderResult.defaultFixed32 = UInt32(47)
                return self
            }
            public var defaultFixed64:UInt64 {
                get {
                    return builderResult.defaultFixed64
                }
                set (value) {
                    builderResult.hasDefaultFixed64 = true
                    builderResult.defaultFixed64 = value
                }
            }
            public var hasDefaultFixed64:Bool {
                get {
                    return builderResult.hasDefaultFixed64
                }
            }
            @discardableResult
            public func setDefaultFixed64(_ value:UInt64) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultFixed64 = value
                return self
            }
            @discardableResult
            public func clearDefaultFixed64() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultFixed64 = false
                builderResult.defaultFixed64 = UInt64(48)
                return self
            }
            public var defaultSfixed32:Int32 {
                get {
                    return builderResult.defaultSfixed32
                }
                set (value) {
                    builderResult.hasDefaultSfixed32 = true
                    builderResult.defaultSfixed32 = value
                }
            }
            public var hasDefaultSfixed32:Bool {
                get {
                    return builderResult.hasDefaultSfixed32
                }
            }
            @discardableResult
            public func setDefaultSfixed32(_ value:Int32) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultSfixed32 = value
                return self
            }
            @discardableResult
            public func clearDefaultSfixed32() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultSfixed32 = false
                builderResult.defaultSfixed32 = Int32(49)
                return self
            }
            public var defaultSfixed64:Int64 {
                get {
                    return builderResult.defaultSfixed64
                }
                set (value) {
                    builderResult.hasDefaultSfixed64 = true
                    builderResult.defaultSfixed64 = value
                }
            }
            public var hasDefaultSfixed64:Bool {
                get {
                    return builderResult.hasDefaultSfixed64
                }
            }
            @discardableResult
            public func setDefaultSfixed64(_ value:Int64) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultSfixed64 = value
                return self
            }
            @discardableResult
            public func clearDefaultSfixed64() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultSfixed64 = false
                builderResult.defaultSfixed64 = Int64(-50)
                return self
            }
            public var defaultFloat:Float {
                get {
                    return builderResult.defaultFloat
                }
                set (value) {
                    builderResult.hasDefaultFloat = true
                    builderResult.defaultFloat = value
                }
            }
            public var hasDefaultFloat:Bool {
                get {
                    return builderResult.hasDefaultFloat
                }
            }
            @discardableResult
            public func setDefaultFloat(_ value:Float) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultFloat = value
                return self
            }
            @discardableResult
            public func clearDefaultFloat() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultFloat = false
                builderResult.defaultFloat = Float(51.5)
                return self
            }
            public var defaultDouble:Double {
                get {
                    return builderResult.defaultDouble
                }
                set (value) {
                    builderResult.hasDefaultDouble = true
                    builderResult.defaultDouble = value
                }
            }
            public var hasDefaultDouble:Bool {
                get {
                    return builderResult.hasDefaultDouble
                }
            }
            @discardableResult
            public func setDefaultDouble(_ value:Double) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultDouble = value
                return self
            }
            @discardableResult
            public func clearDefaultDouble() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultDouble = false
                builderResult.defaultDouble = Double(52000)
                return self
            }
            public var defaultBool:Bool {
                get {
                    return builderResult.defaultBool
                }
                set (value) {
                    builderResult.hasDefaultBool = true
                    builderResult.defaultBool = value
                }
            }
            public var hasDefaultBool:Bool {
                get {
                    return builderResult.hasDefaultBool
                }
            }
            @discardableResult
            public func setDefaultBool(_ value:Bool) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultBool = value
                return self
            }
            @discardableResult
            public func clearDefaultBool() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultBool = false
                builderResult.defaultBool = true
                return self
            }
            public var defaultString:String {
                get {
                    return builderResult.defaultString
                }
                set (value) {
                    builderResult.hasDefaultString = true
                    builderResult.defaultString = value
                }
            }
            public var hasDefaultString:Bool {
                get {
                    return builderResult.hasDefaultString
                }
            }
            @discardableResult
            public func setDefaultString(_ value:String) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultString = value
                return self
            }
            @discardableResult
            public func clearDefaultString() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultString = false
                builderResult.defaultString = "hello"
                return self
            }
            public var defaultBytes:Data {
                get {
                    return builderResult.defaultBytes
                }
                set (value) {
                    builderResult.hasDefaultBytes = true
                    builderResult.defaultBytes = value
                }
            }
            public var hasDefaultBytes:Bool {
                get {
                    return builderResult.hasDefaultBytes
                }
            }
            @discardableResult
            public func setDefaultBytes(_ value:Data) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultBytes = value
                return self
            }
            @discardableResult
            public func clearDefaultBytes() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultBytes = false
                builderResult.defaultBytes = Data(bytes:([UInt8]() + "world".utf8), count:5)
                return self
            }
                public var defaultNestedEnum:ProtobufUnittestNoArena.TestAllTypes.NestedEnum {
                    get {
                        return builderResult.defaultNestedEnum
                    }
                    set (value) {
                        builderResult.hasDefaultNestedEnum = true
                        builderResult.defaultNestedEnum = value
                    }
                }
                public var hasDefaultNestedEnum:Bool{
                    get {
                        return builderResult.hasDefaultNestedEnum
                    }
                }
            @discardableResult
                public func setDefaultNestedEnum(_ value:ProtobufUnittestNoArena.TestAllTypes.NestedEnum) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                  self.defaultNestedEnum = value
                  return self
                }
            @discardableResult
                public func clearDefaultNestedEnum() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                   builderResult.hasDefaultNestedEnum = false
                   builderResult.defaultNestedEnum = .bar
                   return self
                }
                public var defaultForeignEnum:ProtobufUnittestNoArena.ForeignEnum {
                    get {
                        return builderResult.defaultForeignEnum
                    }
                    set (value) {
                        builderResult.hasDefaultForeignEnum = true
                        builderResult.defaultForeignEnum = value
                    }
                }
                public var hasDefaultForeignEnum:Bool{
                    get {
                        return builderResult.hasDefaultForeignEnum
                    }
                }
            @discardableResult
                public func setDefaultForeignEnum(_ value:ProtobufUnittestNoArena.ForeignEnum) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                  self.defaultForeignEnum = value
                  return self
                }
            @discardableResult
                public func clearDefaultForeignEnum() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                   builderResult.hasDefaultForeignEnum = false
                   builderResult.defaultForeignEnum = .foreignBar
                   return self
                }
                public var defaultImportEnum:ProtobufUnittestImport.ImportEnum {
                    get {
                        return builderResult.defaultImportEnum
                    }
                    set (value) {
                        builderResult.hasDefaultImportEnum = true
                        builderResult.defaultImportEnum = value
                    }
                }
                public var hasDefaultImportEnum:Bool{
                    get {
                        return builderResult.hasDefaultImportEnum
                    }
                }
            @discardableResult
                public func setDefaultImportEnum(_ value:ProtobufUnittestImport.ImportEnum) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                  self.defaultImportEnum = value
                  return self
                }
            @discardableResult
                public func clearDefaultImportEnum() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                   builderResult.hasDefaultImportEnum = false
                   builderResult.defaultImportEnum = .importBar
                   return self
                }
            public var defaultStringPiece:String {
                get {
                    return builderResult.defaultStringPiece
                }
                set (value) {
                    builderResult.hasDefaultStringPiece = true
                    builderResult.defaultStringPiece = value
                }
            }
            public var hasDefaultStringPiece:Bool {
                get {
                    return builderResult.hasDefaultStringPiece
                }
            }
            @discardableResult
            public func setDefaultStringPiece(_ value:String) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultStringPiece = value
                return self
            }
            @discardableResult
            public func clearDefaultStringPiece() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultStringPiece = false
                builderResult.defaultStringPiece = "abc"
                return self
            }
            public var defaultCord:String {
                get {
                    return builderResult.defaultCord
                }
                set (value) {
                    builderResult.hasDefaultCord = true
                    builderResult.defaultCord = value
                }
            }
            public var hasDefaultCord:Bool {
                get {
                    return builderResult.hasDefaultCord
                }
            }
            @discardableResult
            public func setDefaultCord(_ value:String) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.defaultCord = value
                return self
            }
            @discardableResult
            public func clearDefaultCord() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasDefaultCord = false
                builderResult.defaultCord = "123"
                return self
            }
            public var oneofUint32:UInt32 {
                get {
                    return builderResult.oneofUint32
                }
                set (value) {
                    builderResult.hasOneofUint32 = true
                    builderResult.oneofUint32 = value
                }
            }
            public var hasOneofUint32:Bool {
                get {
                    return builderResult.hasOneofUint32
                }
            }
            @discardableResult
            public func setOneofUint32(_ value:UInt32) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.oneofUint32 = value
                return self
            }
            @discardableResult
            public func clearOneofUint32() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOneofUint32 = false
                builderResult.oneofUint32 = nil
                return self
            }
            public var oneofNestedMessage:ProtobufUnittestNoArena.TestAllTypes.NestedMessage! {
                get {
                    if oneofNestedMessageBuilder_ != nil {
                        builderResult.oneofNestedMessage = oneofNestedMessageBuilder_.getMessage()
                    }
                    return builderResult.oneofNestedMessage
                }
                set (value) {
                    builderResult.hasOneofNestedMessage = value != nil
                    builderResult.oneofNestedMessage = value
                }
            }
            public var hasOneofNestedMessage:Bool {
                get {
                    return builderResult.hasOneofNestedMessage
                }
            }
            fileprivate var oneofNestedMessageBuilder_:ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder! {
                didSet {
                    builderResult.hasOneofNestedMessage = true
                }
            }
            public func getOneofNestedMessageBuilder() -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder {
                if oneofNestedMessageBuilder_ == nil {
                    oneofNestedMessageBuilder_ = ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder()
                    builderResult.oneofNestedMessage = oneofNestedMessageBuilder_.getMessage()
                    if oneofNestedMessage != nil {
                        try! oneofNestedMessageBuilder_.mergeFrom(other: oneofNestedMessage)
                    }
                }
                return oneofNestedMessageBuilder_
            }
            @discardableResult
            public func setOneofNestedMessage(_ value:ProtobufUnittestNoArena.TestAllTypes.NestedMessage!) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.oneofNestedMessage = value
                return self
            }
            @discardableResult
            public func mergeOneofNestedMessage(value:ProtobufUnittestNoArena.TestAllTypes.NestedMessage) throws -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                if builderResult.hasOneofNestedMessage {
                    builderResult.oneofNestedMessage = try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.builderWithPrototype(prototype:builderResult.oneofNestedMessage).mergeFrom(other: value).buildPartial()
                } else {
                    builderResult.oneofNestedMessage = value
                }
                builderResult.hasOneofNestedMessage = true
                return self
            }
            @discardableResult
            public func clearOneofNestedMessage() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                oneofNestedMessageBuilder_ = nil
                builderResult.hasOneofNestedMessage = false
                builderResult.oneofNestedMessage = nil
                return self
            }
            public var oneofString:String {
                get {
                    return builderResult.oneofString
                }
                set (value) {
                    builderResult.hasOneofString = true
                    builderResult.oneofString = value
                }
            }
            public var hasOneofString:Bool {
                get {
                    return builderResult.hasOneofString
                }
            }
            @discardableResult
            public func setOneofString(_ value:String) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.oneofString = value
                return self
            }
            @discardableResult
            public func clearOneofString() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOneofString = false
                builderResult.oneofString = nil
                return self
            }
            public var oneofBytes:Data {
                get {
                    return builderResult.oneofBytes
                }
                set (value) {
                    builderResult.hasOneofBytes = true
                    builderResult.oneofBytes = value
                }
            }
            public var hasOneofBytes:Bool {
                get {
                    return builderResult.hasOneofBytes
                }
            }
            @discardableResult
            public func setOneofBytes(_ value:Data) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.oneofBytes = value
                return self
            }
            @discardableResult
            public func clearOneofBytes() -> ProtobufUnittestNoArena.TestAllTypes.Builder{
                builderResult.hasOneofBytes = false
                builderResult.oneofBytes = nil
                return self
            }
            public var lazyOneofNestedMessage:ProtobufUnittestNoArena.TestAllTypes.NestedMessage! {
                get {
                    if lazyOneofNestedMessageBuilder_ != nil {
                        builderResult.lazyOneofNestedMessage = lazyOneofNestedMessageBuilder_.getMessage()
                    }
                    return builderResult.lazyOneofNestedMessage
                }
                set (value) {
                    builderResult.hasLazyOneofNestedMessage = value != nil
                    builderResult.lazyOneofNestedMessage = value
                }
            }
            public var hasLazyOneofNestedMessage:Bool {
                get {
                    return builderResult.hasLazyOneofNestedMessage
                }
            }
            fileprivate var lazyOneofNestedMessageBuilder_:ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder! {
                didSet {
                    builderResult.hasLazyOneofNestedMessage = true
                }
            }
            public func getLazyOneofNestedMessageBuilder() -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder {
                if lazyOneofNestedMessageBuilder_ == nil {
                    lazyOneofNestedMessageBuilder_ = ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder()
                    builderResult.lazyOneofNestedMessage = lazyOneofNestedMessageBuilder_.getMessage()
                    if lazyOneofNestedMessage != nil {
                        try! lazyOneofNestedMessageBuilder_.mergeFrom(other: lazyOneofNestedMessage)
                    }
                }
                return lazyOneofNestedMessageBuilder_
            }
            @discardableResult
            public func setLazyOneofNestedMessage(_ value:ProtobufUnittestNoArena.TestAllTypes.NestedMessage!) -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                self.lazyOneofNestedMessage = value
                return self
            }
            @discardableResult
            public func mergeLazyOneofNestedMessage(value:ProtobufUnittestNoArena.TestAllTypes.NestedMessage) throws -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                if builderResult.hasLazyOneofNestedMessage {
                    builderResult.lazyOneofNestedMessage = try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.builderWithPrototype(prototype:builderResult.lazyOneofNestedMessage).mergeFrom(other: value).buildPartial()
                } else {
                    builderResult.lazyOneofNestedMessage = value
                }
                builderResult.hasLazyOneofNestedMessage = true
                return self
            }
            @discardableResult
            public func clearLazyOneofNestedMessage() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                lazyOneofNestedMessageBuilder_ = nil
                builderResult.hasLazyOneofNestedMessage = false
                builderResult.lazyOneofNestedMessage = nil
                return self
            }
            override public var internalGetResult:GeneratedMessage {
                get {
                    return builderResult
                }
            }
            @discardableResult
            override public func clear() -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                builderResult = ProtobufUnittestNoArena.TestAllTypes()
                return self
            }
            override public func clone() throws -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                return try ProtobufUnittestNoArena.TestAllTypes.builderWithPrototype(prototype:builderResult)
            }
            override public func build() throws -> ProtobufUnittestNoArena.TestAllTypes {
                try checkInitialized()
                return buildPartial()
            }
            public func buildPartial() -> ProtobufUnittestNoArena.TestAllTypes {
                let returnMe:ProtobufUnittestNoArena.TestAllTypes = builderResult
                return returnMe
            }
            @discardableResult
            public func mergeFrom(other:ProtobufUnittestNoArena.TestAllTypes) throws -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                if other == ProtobufUnittestNoArena.TestAllTypes() {
                    return self
                }
                if other.hasOptionalInt32 {
                    optionalInt32 = other.optionalInt32
                }
                if other.hasOptionalInt64 {
                    optionalInt64 = other.optionalInt64
                }
                if other.hasOptionalUint32 {
                    optionalUint32 = other.optionalUint32
                }
                if other.hasOptionalUint64 {
                    optionalUint64 = other.optionalUint64
                }
                if other.hasOptionalSint32 {
                    optionalSint32 = other.optionalSint32
                }
                if other.hasOptionalSint64 {
                    optionalSint64 = other.optionalSint64
                }
                if other.hasOptionalFixed32 {
                    optionalFixed32 = other.optionalFixed32
                }
                if other.hasOptionalFixed64 {
                    optionalFixed64 = other.optionalFixed64
                }
                if other.hasOptionalSfixed32 {
                    optionalSfixed32 = other.optionalSfixed32
                }
                if other.hasOptionalSfixed64 {
                    optionalSfixed64 = other.optionalSfixed64
                }
                if other.hasOptionalFloat {
                    optionalFloat = other.optionalFloat
                }
                if other.hasOptionalDouble {
                    optionalDouble = other.optionalDouble
                }
                if other.hasOptionalBool {
                    optionalBool = other.optionalBool
                }
                if other.hasOptionalString {
                    optionalString = other.optionalString
                }
                if other.hasOptionalBytes {
                    optionalBytes = other.optionalBytes
                }
                if (other.hasOptionalGroup) {
                    try mergeOptionalGroup(value: other.optionalGroup)
                }
                if (other.hasOptionalNestedMessage) {
                    try mergeOptionalNestedMessage(value: other.optionalNestedMessage)
                }
                if (other.hasOptionalForeignMessage) {
                    try mergeOptionalForeignMessage(value: other.optionalForeignMessage)
                }
                if (other.hasOptionalImportMessage) {
                    try mergeOptionalImportMessage(value: other.optionalImportMessage)
                }
                if other.hasOptionalNestedEnum {
                    optionalNestedEnum = other.optionalNestedEnum
                }
                if other.hasOptionalForeignEnum {
                    optionalForeignEnum = other.optionalForeignEnum
                }
                if other.hasOptionalImportEnum {
                    optionalImportEnum = other.optionalImportEnum
                }
                if other.hasOptionalStringPiece {
                    optionalStringPiece = other.optionalStringPiece
                }
                if other.hasOptionalCord {
                    optionalCord = other.optionalCord
                }
                if (other.hasOptionalPublicImportMessage) {
                    try mergeOptionalPublicImportMessage(value: other.optionalPublicImportMessage)
                }
                if (other.hasOptionalMessage) {
                    try mergeOptionalMessage(value: other.optionalMessage)
                }
                if !other.repeatedInt32.isEmpty {
                    builderResult.repeatedInt32 += other.repeatedInt32
                }
                if !other.repeatedInt64.isEmpty {
                    builderResult.repeatedInt64 += other.repeatedInt64
                }
                if !other.repeatedUint32.isEmpty {
                    builderResult.repeatedUint32 += other.repeatedUint32
                }
                if !other.repeatedUint64.isEmpty {
                    builderResult.repeatedUint64 += other.repeatedUint64
                }
                if !other.repeatedSint32.isEmpty {
                    builderResult.repeatedSint32 += other.repeatedSint32
                }
                if !other.repeatedSint64.isEmpty {
                    builderResult.repeatedSint64 += other.repeatedSint64
                }
                if !other.repeatedFixed32.isEmpty {
                    builderResult.repeatedFixed32 += other.repeatedFixed32
                }
                if !other.repeatedFixed64.isEmpty {
                    builderResult.repeatedFixed64 += other.repeatedFixed64
                }
                if !other.repeatedSfixed32.isEmpty {
                    builderResult.repeatedSfixed32 += other.repeatedSfixed32
                }
                if !other.repeatedSfixed64.isEmpty {
                    builderResult.repeatedSfixed64 += other.repeatedSfixed64
                }
                if !other.repeatedFloat.isEmpty {
                    builderResult.repeatedFloat += other.repeatedFloat
                }
                if !other.repeatedDouble.isEmpty {
                    builderResult.repeatedDouble += other.repeatedDouble
                }
                if !other.repeatedBool.isEmpty {
                    builderResult.repeatedBool += other.repeatedBool
                }
                if !other.repeatedString.isEmpty {
                    builderResult.repeatedString += other.repeatedString
                }
                if !other.repeatedBytes.isEmpty {
                    builderResult.repeatedBytes += other.repeatedBytes
                }
                if !other.repeatedGroup.isEmpty  {
                     builderResult.repeatedGroup += other.repeatedGroup
                }
                if !other.repeatedNestedMessage.isEmpty  {
                     builderResult.repeatedNestedMessage += other.repeatedNestedMessage
                }
                if !other.repeatedForeignMessage.isEmpty  {
                     builderResult.repeatedForeignMessage += other.repeatedForeignMessage
                }
                if !other.repeatedImportMessage.isEmpty  {
                     builderResult.repeatedImportMessage += other.repeatedImportMessage
                }
                if !other.repeatedNestedEnum.isEmpty {
                     builderResult.repeatedNestedEnum += other.repeatedNestedEnum
                }
                if !other.repeatedForeignEnum.isEmpty {
                     builderResult.repeatedForeignEnum += other.repeatedForeignEnum
                }
                if !other.repeatedImportEnum.isEmpty {
                     builderResult.repeatedImportEnum += other.repeatedImportEnum
                }
                if !other.repeatedStringPiece.isEmpty {
                    builderResult.repeatedStringPiece += other.repeatedStringPiece
                }
                if !other.repeatedCord.isEmpty {
                    builderResult.repeatedCord += other.repeatedCord
                }
                if !other.repeatedLazyMessage.isEmpty  {
                     builderResult.repeatedLazyMessage += other.repeatedLazyMessage
                }
                if other.hasDefaultInt32 {
                    defaultInt32 = other.defaultInt32
                }
                if other.hasDefaultInt64 {
                    defaultInt64 = other.defaultInt64
                }
                if other.hasDefaultUint32 {
                    defaultUint32 = other.defaultUint32
                }
                if other.hasDefaultUint64 {
                    defaultUint64 = other.defaultUint64
                }
                if other.hasDefaultSint32 {
                    defaultSint32 = other.defaultSint32
                }
                if other.hasDefaultSint64 {
                    defaultSint64 = other.defaultSint64
                }
                if other.hasDefaultFixed32 {
                    defaultFixed32 = other.defaultFixed32
                }
                if other.hasDefaultFixed64 {
                    defaultFixed64 = other.defaultFixed64
                }
                if other.hasDefaultSfixed32 {
                    defaultSfixed32 = other.defaultSfixed32
                }
                if other.hasDefaultSfixed64 {
                    defaultSfixed64 = other.defaultSfixed64
                }
                if other.hasDefaultFloat {
                    defaultFloat = other.defaultFloat
                }
                if other.hasDefaultDouble {
                    defaultDouble = other.defaultDouble
                }
                if other.hasDefaultBool {
                    defaultBool = other.defaultBool
                }
                if other.hasDefaultString {
                    defaultString = other.defaultString
                }
                if other.hasDefaultBytes {
                    defaultBytes = other.defaultBytes
                }
                if other.hasDefaultNestedEnum {
                    defaultNestedEnum = other.defaultNestedEnum
                }
                if other.hasDefaultForeignEnum {
                    defaultForeignEnum = other.defaultForeignEnum
                }
                if other.hasDefaultImportEnum {
                    defaultImportEnum = other.defaultImportEnum
                }
                if other.hasDefaultStringPiece {
                    defaultStringPiece = other.defaultStringPiece
                }
                if other.hasDefaultCord {
                    defaultCord = other.defaultCord
                }
                if other.hasOneofUint32 {
                    oneofUint32 = other.oneofUint32
                }
                if (other.hasOneofNestedMessage) {
                    try mergeOneofNestedMessage(value: other.oneofNestedMessage)
                }
                if other.hasOneofString {
                    oneofString = other.oneofString
                }
                if other.hasOneofBytes {
                    oneofBytes = other.oneofBytes
                }
                if (other.hasLazyOneofNestedMessage) {
                    try mergeLazyOneofNestedMessage(value: other.lazyOneofNestedMessage)
                }
                try merge(unknownField: other.unknownFields)
                return self
            }
            @discardableResult
            override public func mergeFrom(codedInputStream: CodedInputStream) throws -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                return try mergeFrom(codedInputStream: codedInputStream, extensionRegistry:ExtensionRegistry())
            }
            @discardableResult
            override public func mergeFrom(codedInputStream: CodedInputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                let unknownFieldsBuilder:UnknownFieldSet.Builder = try UnknownFieldSet.builderWithUnknownFields(copyFrom:self.unknownFields)
                while (true) {
                    let protobufTag = try codedInputStream.readTag()
                    switch protobufTag {
                    case 0: 
                        self.unknownFields = try unknownFieldsBuilder.build()
                        return self

                    case 8:
                        optionalInt32 = try codedInputStream.readInt32()

                    case 16:
                        optionalInt64 = try codedInputStream.readInt64()

                    case 24:
                        optionalUint32 = try codedInputStream.readUInt32()

                    case 32:
                        optionalUint64 = try codedInputStream.readUInt64()

                    case 40:
                        optionalSint32 = try codedInputStream.readSInt32()

                    case 48:
                        optionalSint64 = try codedInputStream.readSInt64()

                    case 61:
                        optionalFixed32 = try codedInputStream.readFixed32()

                    case 65:
                        optionalFixed64 = try codedInputStream.readFixed64()

                    case 77:
                        optionalSfixed32 = try codedInputStream.readSFixed32()

                    case 81:
                        optionalSfixed64 = try codedInputStream.readSFixed64()

                    case 93:
                        optionalFloat = try codedInputStream.readFloat()

                    case 97:
                        optionalDouble = try codedInputStream.readDouble()

                    case 104:
                        optionalBool = try codedInputStream.readBool()

                    case 114:
                        optionalString = try codedInputStream.readString()

                    case 122:
                        optionalBytes = try codedInputStream.readData()

                    case 131:
                        let subBuilder:ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder = ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder()
                        if hasOptionalGroup {
                            try subBuilder.mergeFrom(other: optionalGroup)
                        }
                        try codedInputStream.readGroup(fieldNumber: 16, builder:subBuilder, extensionRegistry:extensionRegistry)
                        optionalGroup = subBuilder.buildPartial()

                    case 146:
                        let subBuilder:ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder = ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder()
                        if hasOptionalNestedMessage {
                            try subBuilder.mergeFrom(other: optionalNestedMessage)
                        }
                        try codedInputStream.readMessage(builder: subBuilder, extensionRegistry:extensionRegistry)
                        optionalNestedMessage = subBuilder.buildPartial()

                    case 154:
                        let subBuilder:ProtobufUnittestNoArena.ForeignMessage.Builder = ProtobufUnittestNoArena.ForeignMessage.Builder()
                        if hasOptionalForeignMessage {
                            try subBuilder.mergeFrom(other: optionalForeignMessage)
                        }
                        try codedInputStream.readMessage(builder: subBuilder, extensionRegistry:extensionRegistry)
                        optionalForeignMessage = subBuilder.buildPartial()

                    case 162:
                        let subBuilder:ProtobufUnittestImport.ImportMessage.Builder = ProtobufUnittestImport.ImportMessage.Builder()
                        if hasOptionalImportMessage {
                            try subBuilder.mergeFrom(other: optionalImportMessage)
                        }
                        try codedInputStream.readMessage(builder: subBuilder, extensionRegistry:extensionRegistry)
                        optionalImportMessage = subBuilder.buildPartial()

                    case 168:
                        let valueIntoptionalNestedEnum = try codedInputStream.readEnum()
                        if let enumsoptionalNestedEnum = ProtobufUnittestNoArena.TestAllTypes.NestedEnum(rawValue:valueIntoptionalNestedEnum){
                            optionalNestedEnum = enumsoptionalNestedEnum
                        } else {
                            try unknownFieldsBuilder.mergeVarintField(fieldNumber: 21, value:Int64(valueIntoptionalNestedEnum))
                        }

                    case 176:
                        let valueIntoptionalForeignEnum = try codedInputStream.readEnum()
                        if let enumsoptionalForeignEnum = ProtobufUnittestNoArena.ForeignEnum(rawValue:valueIntoptionalForeignEnum){
                            optionalForeignEnum = enumsoptionalForeignEnum
                        } else {
                            try unknownFieldsBuilder.mergeVarintField(fieldNumber: 22, value:Int64(valueIntoptionalForeignEnum))
                        }

                    case 184:
                        let valueIntoptionalImportEnum = try codedInputStream.readEnum()
                        if let enumsoptionalImportEnum = ProtobufUnittestImport.ImportEnum(rawValue:valueIntoptionalImportEnum){
                            optionalImportEnum = enumsoptionalImportEnum
                        } else {
                            try unknownFieldsBuilder.mergeVarintField(fieldNumber: 23, value:Int64(valueIntoptionalImportEnum))
                        }

                    case 194:
                        optionalStringPiece = try codedInputStream.readString()

                    case 202:
                        optionalCord = try codedInputStream.readString()

                    case 210:
                        let subBuilder:ProtobufUnittestImport.PublicImportMessage.Builder = ProtobufUnittestImport.PublicImportMessage.Builder()
                        if hasOptionalPublicImportMessage {
                            try subBuilder.mergeFrom(other: optionalPublicImportMessage)
                        }
                        try codedInputStream.readMessage(builder: subBuilder, extensionRegistry:extensionRegistry)
                        optionalPublicImportMessage = subBuilder.buildPartial()

                    case 218:
                        let subBuilder:ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder = ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder()
                        if hasOptionalMessage {
                            try subBuilder.mergeFrom(other: optionalMessage)
                        }
                        try codedInputStream.readMessage(builder: subBuilder, extensionRegistry:extensionRegistry)
                        optionalMessage = subBuilder.buildPartial()

                    case 248:
                        repeatedInt32 += [try codedInputStream.readInt32()]

                    case 256:
                        repeatedInt64 += [try codedInputStream.readInt64()]

                    case 264:
                        repeatedUint32 += [try codedInputStream.readUInt32()]

                    case 272:
                        repeatedUint64 += [try codedInputStream.readUInt64()]

                    case 280:
                        repeatedSint32 += [try codedInputStream.readSInt32()]

                    case 288:
                        repeatedSint64 += [try codedInputStream.readSInt64()]

                    case 301:
                        repeatedFixed32 += [try codedInputStream.readFixed32()]

                    case 305:
                        repeatedFixed64 += [try codedInputStream.readFixed64()]

                    case 317:
                        repeatedSfixed32 += [try codedInputStream.readSFixed32()]

                    case 321:
                        repeatedSfixed64 += [try codedInputStream.readSFixed64()]

                    case 333:
                        repeatedFloat += [try codedInputStream.readFloat()]

                    case 337:
                        repeatedDouble += [try codedInputStream.readDouble()]

                    case 344:
                        repeatedBool += [try codedInputStream.readBool()]

                    case 354:
                        repeatedString += [try codedInputStream.readString()]

                    case 362:
                        repeatedBytes += [try codedInputStream.readData()]

                    case 371:
                        let subBuilder = ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder()
                        try codedInputStream.readGroup(fieldNumber:46, builder:subBuilder,extensionRegistry:extensionRegistry)
                        repeatedGroup.append(subBuilder.buildPartial())

                    case 386:
                        let subBuilder = ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder()
                        try codedInputStream.readMessage(builder: subBuilder,extensionRegistry:extensionRegistry)
                        repeatedNestedMessage.append(subBuilder.buildPartial())

                    case 394:
                        let subBuilder = ProtobufUnittestNoArena.ForeignMessage.Builder()
                        try codedInputStream.readMessage(builder: subBuilder,extensionRegistry:extensionRegistry)
                        repeatedForeignMessage.append(subBuilder.buildPartial())

                    case 402:
                        let subBuilder = ProtobufUnittestImport.ImportMessage.Builder()
                        try codedInputStream.readMessage(builder: subBuilder,extensionRegistry:extensionRegistry)
                        repeatedImportMessage.append(subBuilder.buildPartial())

                    case 408:
                        let valueIntrepeatedNestedEnum = try codedInputStream.readEnum()
                        if let enumsrepeatedNestedEnum = ProtobufUnittestNoArena.TestAllTypes.NestedEnum(rawValue:valueIntrepeatedNestedEnum) {
                            builderResult.repeatedNestedEnum.append(enumsrepeatedNestedEnum)
                        } else {
                            try unknownFieldsBuilder.mergeVarintField(fieldNumber: 51, value:Int64(valueIntrepeatedNestedEnum))
                        }

                    case 416:
                        let valueIntrepeatedForeignEnum = try codedInputStream.readEnum()
                        if let enumsrepeatedForeignEnum = ProtobufUnittestNoArena.ForeignEnum(rawValue:valueIntrepeatedForeignEnum) {
                            builderResult.repeatedForeignEnum.append(enumsrepeatedForeignEnum)
                        } else {
                            try unknownFieldsBuilder.mergeVarintField(fieldNumber: 52, value:Int64(valueIntrepeatedForeignEnum))
                        }

                    case 424:
                        let valueIntrepeatedImportEnum = try codedInputStream.readEnum()
                        if let enumsrepeatedImportEnum = ProtobufUnittestImport.ImportEnum(rawValue:valueIntrepeatedImportEnum) {
                            builderResult.repeatedImportEnum.append(enumsrepeatedImportEnum)
                        } else {
                            try unknownFieldsBuilder.mergeVarintField(fieldNumber: 53, value:Int64(valueIntrepeatedImportEnum))
                        }

                    case 434:
                        repeatedStringPiece += [try codedInputStream.readString()]

                    case 442:
                        repeatedCord += [try codedInputStream.readString()]

                    case 458:
                        let subBuilder = ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder()
                        try codedInputStream.readMessage(builder: subBuilder,extensionRegistry:extensionRegistry)
                        repeatedLazyMessage.append(subBuilder.buildPartial())

                    case 488:
                        defaultInt32 = try codedInputStream.readInt32()

                    case 496:
                        defaultInt64 = try codedInputStream.readInt64()

                    case 504:
                        defaultUint32 = try codedInputStream.readUInt32()

                    case 512:
                        defaultUint64 = try codedInputStream.readUInt64()

                    case 520:
                        defaultSint32 = try codedInputStream.readSInt32()

                    case 528:
                        defaultSint64 = try codedInputStream.readSInt64()

                    case 541:
                        defaultFixed32 = try codedInputStream.readFixed32()

                    case 545:
                        defaultFixed64 = try codedInputStream.readFixed64()

                    case 557:
                        defaultSfixed32 = try codedInputStream.readSFixed32()

                    case 561:
                        defaultSfixed64 = try codedInputStream.readSFixed64()

                    case 573:
                        defaultFloat = try codedInputStream.readFloat()

                    case 577:
                        defaultDouble = try codedInputStream.readDouble()

                    case 584:
                        defaultBool = try codedInputStream.readBool()

                    case 594:
                        defaultString = try codedInputStream.readString()

                    case 602:
                        defaultBytes = try codedInputStream.readData()

                    case 648:
                        let valueIntdefaultNestedEnum = try codedInputStream.readEnum()
                        if let enumsdefaultNestedEnum = ProtobufUnittestNoArena.TestAllTypes.NestedEnum(rawValue:valueIntdefaultNestedEnum){
                            defaultNestedEnum = enumsdefaultNestedEnum
                        } else {
                            try unknownFieldsBuilder.mergeVarintField(fieldNumber: 81, value:Int64(valueIntdefaultNestedEnum))
                        }

                    case 656:
                        let valueIntdefaultForeignEnum = try codedInputStream.readEnum()
                        if let enumsdefaultForeignEnum = ProtobufUnittestNoArena.ForeignEnum(rawValue:valueIntdefaultForeignEnum){
                            defaultForeignEnum = enumsdefaultForeignEnum
                        } else {
                            try unknownFieldsBuilder.mergeVarintField(fieldNumber: 82, value:Int64(valueIntdefaultForeignEnum))
                        }

                    case 664:
                        let valueIntdefaultImportEnum = try codedInputStream.readEnum()
                        if let enumsdefaultImportEnum = ProtobufUnittestImport.ImportEnum(rawValue:valueIntdefaultImportEnum){
                            defaultImportEnum = enumsdefaultImportEnum
                        } else {
                            try unknownFieldsBuilder.mergeVarintField(fieldNumber: 83, value:Int64(valueIntdefaultImportEnum))
                        }

                    case 674:
                        defaultStringPiece = try codedInputStream.readString()

                    case 682:
                        defaultCord = try codedInputStream.readString()

                    case 888:
                        oneofUint32 = try codedInputStream.readUInt32()

                    case 898:
                        let subBuilder:ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder = ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder()
                        if hasOneofNestedMessage {
                            try subBuilder.mergeFrom(other: oneofNestedMessage)
                        }
                        try codedInputStream.readMessage(builder: subBuilder, extensionRegistry:extensionRegistry)
                        oneofNestedMessage = subBuilder.buildPartial()

                    case 906:
                        oneofString = try codedInputStream.readString()

                    case 914:
                        oneofBytes = try codedInputStream.readData()

                    case 922:
                        let subBuilder:ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder = ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder()
                        if hasLazyOneofNestedMessage {
                            try subBuilder.mergeFrom(other: lazyOneofNestedMessage)
                        }
                        try codedInputStream.readMessage(builder: subBuilder, extensionRegistry:extensionRegistry)
                        lazyOneofNestedMessage = subBuilder.buildPartial()

                    default:
                        if (!(try parse(codedInputStream:codedInputStream, unknownFields:unknownFieldsBuilder, extensionRegistry:extensionRegistry, tag:protobufTag))) {
                            unknownFields = try unknownFieldsBuilder.build()
                            return self
                        }
                    }
                }
            }
            class override public func decodeToBuilder(jsonMap:Dictionary<String,Any>) throws -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                let resultDecodedBuilder = ProtobufUnittestNoArena.TestAllTypes.Builder()
                if let jsonValueOptionalInt32 = jsonMap["optionalInt32"] as? Int {
                    resultDecodedBuilder.optionalInt32 = Int32(jsonValueOptionalInt32)
                } else if let jsonValueOptionalInt32 = jsonMap["optionalInt32"] as? String {
                    resultDecodedBuilder.optionalInt32 = Int32(jsonValueOptionalInt32)!
                }
                if let jsonValueOptionalInt64 = jsonMap["optionalInt64"] as? String {
                    resultDecodedBuilder.optionalInt64 = Int64(jsonValueOptionalInt64)!
                } else if let jsonValueOptionalInt64 = jsonMap["optionalInt64"] as? Int {
                    resultDecodedBuilder.optionalInt64 = Int64(jsonValueOptionalInt64)
                }
                if let jsonValueOptionalUint32 = jsonMap["optionalUint32"] as? UInt {
                    resultDecodedBuilder.optionalUint32 = UInt32(jsonValueOptionalUint32)
                } else if let jsonValueOptionalUint32 = jsonMap["optionalUint32"] as? String {
                    resultDecodedBuilder.optionalUint32 = UInt32(jsonValueOptionalUint32)!
                }
                if let jsonValueOptionalUint64 = jsonMap["optionalUint64"] as? String {
                    resultDecodedBuilder.optionalUint64 = UInt64(jsonValueOptionalUint64)!
                } else if let jsonValueOptionalUint64 = jsonMap["optionalUint64"] as? UInt {
                    resultDecodedBuilder.optionalUint64 = UInt64(jsonValueOptionalUint64)
                }
                if let jsonValueOptionalSint32 = jsonMap["optionalSint32"] as? Int {
                    resultDecodedBuilder.optionalSint32 = Int32(jsonValueOptionalSint32)
                } else if let jsonValueOptionalSint32 = jsonMap["optionalSint32"] as? String {
                    resultDecodedBuilder.optionalSint32 = Int32(jsonValueOptionalSint32)!
                }
                if let jsonValueOptionalSint64 = jsonMap["optionalSint64"] as? String {
                    resultDecodedBuilder.optionalSint64 = Int64(jsonValueOptionalSint64)!
                } else if let jsonValueOptionalSint64 = jsonMap["optionalSint64"] as? Int {
                    resultDecodedBuilder.optionalSint64 = Int64(jsonValueOptionalSint64)
                }
                if let jsonValueOptionalFixed32 = jsonMap["optionalFixed32"] as? UInt {
                    resultDecodedBuilder.optionalFixed32 = UInt32(jsonValueOptionalFixed32)
                } else if let jsonValueOptionalFixed32 = jsonMap["optionalFixed32"] as? String {
                    resultDecodedBuilder.optionalFixed32 = UInt32(jsonValueOptionalFixed32)!
                }
                if let jsonValueOptionalFixed64 = jsonMap["optionalFixed64"] as? String {
                    resultDecodedBuilder.optionalFixed64 = UInt64(jsonValueOptionalFixed64)!
                } else if let jsonValueOptionalFixed64 = jsonMap["optionalFixed64"] as? UInt {
                    resultDecodedBuilder.optionalFixed64 = UInt64(jsonValueOptionalFixed64)
                }
                if let jsonValueOptionalSfixed32 = jsonMap["optionalSfixed32"] as? Int {
                    resultDecodedBuilder.optionalSfixed32 = Int32(jsonValueOptionalSfixed32)
                } else if let jsonValueOptionalSfixed32 = jsonMap["optionalSfixed32"] as? String {
                    resultDecodedBuilder.optionalSfixed32 = Int32(jsonValueOptionalSfixed32)!
                }
                if let jsonValueOptionalSfixed64 = jsonMap["optionalSfixed64"] as? String {
                    resultDecodedBuilder.optionalSfixed64 = Int64(jsonValueOptionalSfixed64)!
                } else if let jsonValueOptionalSfixed64 = jsonMap["optionalSfixed64"] as? Int {
                    resultDecodedBuilder.optionalSfixed64 = Int64(jsonValueOptionalSfixed64)
                }
                if let jsonValueOptionalFloat = jsonMap["optionalFloat"] as? Float {
                    resultDecodedBuilder.optionalFloat = Float(jsonValueOptionalFloat)
                } else if let jsonValueOptionalFloat = jsonMap["optionalFloat"] as? String {
                    resultDecodedBuilder.optionalFloat = Float(jsonValueOptionalFloat)!
                }
                if let jsonValueOptionalDouble = jsonMap["optionalDouble"] as? Double {
                    resultDecodedBuilder.optionalDouble = Double(jsonValueOptionalDouble)
                } else if let jsonValueOptionalDouble = jsonMap["optionalDouble"] as? String {
                    resultDecodedBuilder.optionalDouble = Double(jsonValueOptionalDouble)!
                }
                if let jsonValueOptionalBool = jsonMap["optionalBool"] as? Bool {
                    resultDecodedBuilder.optionalBool = jsonValueOptionalBool
                }
                if let jsonValueOptionalString = jsonMap["optionalString"] as? String {
                    resultDecodedBuilder.optionalString = jsonValueOptionalString
                }
                if let jsonValueOptionalBytes = jsonMap["optionalBytes"] as? String {
                    resultDecodedBuilder.optionalBytes = Data(base64Encoded:jsonValueOptionalBytes, options: Data.Base64DecodingOptions(rawValue:0))!
                }
                if let jsonValueOptionalGroup = jsonMap["optionalgroup"] as? Dictionary<String,Any> {
                    resultDecodedBuilder.optionalGroup = try ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder.decodeToBuilder(jsonMap:jsonValueOptionalGroup).build()

                }
                if let jsonValueOptionalNestedMessage = jsonMap["optionalNestedMessage"] as? Dictionary<String,Any> {
                    resultDecodedBuilder.optionalNestedMessage = try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder.decodeToBuilder(jsonMap:jsonValueOptionalNestedMessage).build()

                }
                if let jsonValueOptionalForeignMessage = jsonMap["optionalForeignMessage"] as? Dictionary<String,Any> {
                    resultDecodedBuilder.optionalForeignMessage = try ProtobufUnittestNoArena.ForeignMessage.Builder.decodeToBuilder(jsonMap:jsonValueOptionalForeignMessage).build()

                }
                if let jsonValueOptionalImportMessage = jsonMap["optionalImportMessage"] as? Dictionary<String,Any> {
                    resultDecodedBuilder.optionalImportMessage = try ProtobufUnittestImport.ImportMessage.Builder.decodeToBuilder(jsonMap:jsonValueOptionalImportMessage).build()

                }
                if let jsonValueOptionalNestedEnum = jsonMap["optionalNestedEnum"] as? String {
                    resultDecodedBuilder.optionalNestedEnum = try ProtobufUnittestNoArena.TestAllTypes.NestedEnum.fromString(jsonValueOptionalNestedEnum)
                }
                if let jsonValueOptionalForeignEnum = jsonMap["optionalForeignEnum"] as? String {
                    resultDecodedBuilder.optionalForeignEnum = try ProtobufUnittestNoArena.ForeignEnum.fromString(jsonValueOptionalForeignEnum)
                }
                if let jsonValueOptionalImportEnum = jsonMap["optionalImportEnum"] as? String {
                    resultDecodedBuilder.optionalImportEnum = try ProtobufUnittestImport.ImportEnum.fromString(jsonValueOptionalImportEnum)
                }
                if let jsonValueOptionalStringPiece = jsonMap["optionalStringPiece"] as? String {
                    resultDecodedBuilder.optionalStringPiece = jsonValueOptionalStringPiece
                }
                if let jsonValueOptionalCord = jsonMap["optionalCord"] as? String {
                    resultDecodedBuilder.optionalCord = jsonValueOptionalCord
                }
                if let jsonValueOptionalPublicImportMessage = jsonMap["optionalPublicImportMessage"] as? Dictionary<String,Any> {
                    resultDecodedBuilder.optionalPublicImportMessage = try ProtobufUnittestImport.PublicImportMessage.Builder.decodeToBuilder(jsonMap:jsonValueOptionalPublicImportMessage).build()

                }
                if let jsonValueOptionalMessage = jsonMap["optionalMessage"] as? Dictionary<String,Any> {
                    resultDecodedBuilder.optionalMessage = try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder.decodeToBuilder(jsonMap:jsonValueOptionalMessage).build()

                }
                if let jsonValueRepeatedInt32 = jsonMap["repeatedInt32"] as? Array<Int> {
                    var jsonArrayRepeatedInt32:Array<Int32> = []
                    for oneValueRepeatedInt32 in jsonValueRepeatedInt32 {
                        jsonArrayRepeatedInt32.append(Int32(oneValueRepeatedInt32))
                    }
                    resultDecodedBuilder.repeatedInt32 = jsonArrayRepeatedInt32
                }
                if let jsonValueRepeatedInt64 = jsonMap["repeatedInt64"] as? Array<String> {
                    var jsonArrayRepeatedInt64:Array<Int64> = []
                    for oneValueRepeatedInt64 in jsonValueRepeatedInt64 {
                        jsonArrayRepeatedInt64.append(Int64(oneValueRepeatedInt64)!)
                    }
                    resultDecodedBuilder.repeatedInt64 = jsonArrayRepeatedInt64
                }
                if let jsonValueRepeatedUint32 = jsonMap["repeatedUint32"] as? Array<UInt> {
                    var jsonArrayRepeatedUint32:Array<UInt32> = []
                    for oneValueRepeatedUint32 in jsonValueRepeatedUint32 {
                        jsonArrayRepeatedUint32.append(UInt32(oneValueRepeatedUint32))
                    }
                    resultDecodedBuilder.repeatedUint32 = jsonArrayRepeatedUint32
                }
                if let jsonValueRepeatedUint64 = jsonMap["repeatedUint64"] as? Array<String> {
                    var jsonArrayRepeatedUint64:Array<UInt64> = []
                    for oneValueRepeatedUint64 in jsonValueRepeatedUint64 {
                        jsonArrayRepeatedUint64.append(UInt64(oneValueRepeatedUint64)!)
                    }
                    resultDecodedBuilder.repeatedUint64 = jsonArrayRepeatedUint64
                }
                if let jsonValueRepeatedSint32 = jsonMap["repeatedSint32"] as? Array<Int> {
                    var jsonArrayRepeatedSint32:Array<Int32> = []
                    for oneValueRepeatedSint32 in jsonValueRepeatedSint32 {
                        jsonArrayRepeatedSint32.append(Int32(oneValueRepeatedSint32))
                    }
                    resultDecodedBuilder.repeatedSint32 = jsonArrayRepeatedSint32
                }
                if let jsonValueRepeatedSint64 = jsonMap["repeatedSint64"] as? Array<String> {
                    var jsonArrayRepeatedSint64:Array<Int64> = []
                    for oneValueRepeatedSint64 in jsonValueRepeatedSint64 {
                        jsonArrayRepeatedSint64.append(Int64(oneValueRepeatedSint64)!)
                    }
                    resultDecodedBuilder.repeatedSint64 = jsonArrayRepeatedSint64
                }
                if let jsonValueRepeatedFixed32 = jsonMap["repeatedFixed32"] as? Array<UInt> {
                    var jsonArrayRepeatedFixed32:Array<UInt32> = []
                    for oneValueRepeatedFixed32 in jsonValueRepeatedFixed32 {
                        jsonArrayRepeatedFixed32.append(UInt32(oneValueRepeatedFixed32))
                    }
                    resultDecodedBuilder.repeatedFixed32 = jsonArrayRepeatedFixed32
                }
                if let jsonValueRepeatedFixed64 = jsonMap["repeatedFixed64"] as? Array<String> {
                    var jsonArrayRepeatedFixed64:Array<UInt64> = []
                    for oneValueRepeatedFixed64 in jsonValueRepeatedFixed64 {
                        jsonArrayRepeatedFixed64.append(UInt64(oneValueRepeatedFixed64)!)
                    }
                    resultDecodedBuilder.repeatedFixed64 = jsonArrayRepeatedFixed64
                }
                if let jsonValueRepeatedSfixed32 = jsonMap["repeatedSfixed32"] as? Array<Int> {
                    var jsonArrayRepeatedSfixed32:Array<Int32> = []
                    for oneValueRepeatedSfixed32 in jsonValueRepeatedSfixed32 {
                        jsonArrayRepeatedSfixed32.append(Int32(oneValueRepeatedSfixed32))
                    }
                    resultDecodedBuilder.repeatedSfixed32 = jsonArrayRepeatedSfixed32
                }
                if let jsonValueRepeatedSfixed64 = jsonMap["repeatedSfixed64"] as? Array<String> {
                    var jsonArrayRepeatedSfixed64:Array<Int64> = []
                    for oneValueRepeatedSfixed64 in jsonValueRepeatedSfixed64 {
                        jsonArrayRepeatedSfixed64.append(Int64(oneValueRepeatedSfixed64)!)
                    }
                    resultDecodedBuilder.repeatedSfixed64 = jsonArrayRepeatedSfixed64
                }
                if let jsonValueRepeatedFloat = jsonMap["repeatedFloat"] as? Array<Float> {
                    var jsonArrayRepeatedFloat:Array<Float> = []
                    for oneValueRepeatedFloat in jsonValueRepeatedFloat {
                        jsonArrayRepeatedFloat.append(Float(oneValueRepeatedFloat))
                    }
                    resultDecodedBuilder.repeatedFloat = jsonArrayRepeatedFloat
                }
                if let jsonValueRepeatedDouble = jsonMap["repeatedDouble"] as? Array<Double> {
                    var jsonArrayRepeatedDouble:Array<Double> = []
                    for oneValueRepeatedDouble in jsonValueRepeatedDouble {
                        jsonArrayRepeatedDouble.append(Double(oneValueRepeatedDouble))
                    }
                    resultDecodedBuilder.repeatedDouble = jsonArrayRepeatedDouble
                }
                if let jsonValueRepeatedBool = jsonMap["repeatedBool"] as? Array<Bool> {
                    var jsonArrayRepeatedBool:Array<Bool> = []
                    for oneValueRepeatedBool in jsonValueRepeatedBool {
                        jsonArrayRepeatedBool.append(oneValueRepeatedBool)
                    }
                    resultDecodedBuilder.repeatedBool = jsonArrayRepeatedBool
                }
                if let jsonValueRepeatedString = jsonMap["repeatedString"] as? Array<String> {
                    var jsonArrayRepeatedString:Array<String> = []
                    for oneValueRepeatedString in jsonValueRepeatedString {
                        jsonArrayRepeatedString.append(oneValueRepeatedString)
                    }
                    resultDecodedBuilder.repeatedString = jsonArrayRepeatedString
                }
                if let jsonValueRepeatedBytes = jsonMap["repeatedBytes"] as? Array<String> {
                    var jsonArrayRepeatedBytes:Array<Data> = []
                    for oneValueRepeatedBytes in jsonValueRepeatedBytes {
                        jsonArrayRepeatedBytes.append(Data(base64Encoded:oneValueRepeatedBytes, options: Data.Base64DecodingOptions(rawValue:0))!)
                    }
                    resultDecodedBuilder.repeatedBytes = jsonArrayRepeatedBytes
                }
                if let jsonValueRepeatedGroup = jsonMap["repeatedgroup"] as? Array<Dictionary<String,Any>> {
                    var jsonArrayRepeatedGroup:Array<ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup> = []
                    for oneValueRepeatedGroup in jsonValueRepeatedGroup {
                        let messageFromStringRepeatedGroup = try ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder.decodeToBuilder(jsonMap:oneValueRepeatedGroup).build()

                        jsonArrayRepeatedGroup.append(messageFromStringRepeatedGroup)
                    }
                    resultDecodedBuilder.repeatedGroup = jsonArrayRepeatedGroup
                }
                if let jsonValueRepeatedNestedMessage = jsonMap["repeatedNestedMessage"] as? Array<Dictionary<String,Any>> {
                    var jsonArrayRepeatedNestedMessage:Array<ProtobufUnittestNoArena.TestAllTypes.NestedMessage> = []
                    for oneValueRepeatedNestedMessage in jsonValueRepeatedNestedMessage {
                        let messageFromStringRepeatedNestedMessage = try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder.decodeToBuilder(jsonMap:oneValueRepeatedNestedMessage).build()

                        jsonArrayRepeatedNestedMessage.append(messageFromStringRepeatedNestedMessage)
                    }
                    resultDecodedBuilder.repeatedNestedMessage = jsonArrayRepeatedNestedMessage
                }
                if let jsonValueRepeatedForeignMessage = jsonMap["repeatedForeignMessage"] as? Array<Dictionary<String,Any>> {
                    var jsonArrayRepeatedForeignMessage:Array<ProtobufUnittestNoArena.ForeignMessage> = []
                    for oneValueRepeatedForeignMessage in jsonValueRepeatedForeignMessage {
                        let messageFromStringRepeatedForeignMessage = try ProtobufUnittestNoArena.ForeignMessage.Builder.decodeToBuilder(jsonMap:oneValueRepeatedForeignMessage).build()

                        jsonArrayRepeatedForeignMessage.append(messageFromStringRepeatedForeignMessage)
                    }
                    resultDecodedBuilder.repeatedForeignMessage = jsonArrayRepeatedForeignMessage
                }
                if let jsonValueRepeatedImportMessage = jsonMap["repeatedImportMessage"] as? Array<Dictionary<String,Any>> {
                    var jsonArrayRepeatedImportMessage:Array<ProtobufUnittestImport.ImportMessage> = []
                    for oneValueRepeatedImportMessage in jsonValueRepeatedImportMessage {
                        let messageFromStringRepeatedImportMessage = try ProtobufUnittestImport.ImportMessage.Builder.decodeToBuilder(jsonMap:oneValueRepeatedImportMessage).build()

                        jsonArrayRepeatedImportMessage.append(messageFromStringRepeatedImportMessage)
                    }
                    resultDecodedBuilder.repeatedImportMessage = jsonArrayRepeatedImportMessage
                }
                if let jsonValueRepeatedNestedEnum = jsonMap["repeatedNestedEnum"] as? Array<String> {
                    var jsonArrayRepeatedNestedEnum:Array<ProtobufUnittestNoArena.TestAllTypes.NestedEnum> = []
                    for oneValueRepeatedNestedEnum in jsonValueRepeatedNestedEnum {
                        let enumFromStringRepeatedNestedEnum = try ProtobufUnittestNoArena.TestAllTypes.NestedEnum.fromString(oneValueRepeatedNestedEnum)
                        jsonArrayRepeatedNestedEnum.append(enumFromStringRepeatedNestedEnum)
                    }
                    resultDecodedBuilder.repeatedNestedEnum = jsonArrayRepeatedNestedEnum
                }
                if let jsonValueRepeatedForeignEnum = jsonMap["repeatedForeignEnum"] as? Array<String> {
                    var jsonArrayRepeatedForeignEnum:Array<ProtobufUnittestNoArena.ForeignEnum> = []
                    for oneValueRepeatedForeignEnum in jsonValueRepeatedForeignEnum {
                        let enumFromStringRepeatedForeignEnum = try ProtobufUnittestNoArena.ForeignEnum.fromString(oneValueRepeatedForeignEnum)
                        jsonArrayRepeatedForeignEnum.append(enumFromStringRepeatedForeignEnum)
                    }
                    resultDecodedBuilder.repeatedForeignEnum = jsonArrayRepeatedForeignEnum
                }
                if let jsonValueRepeatedImportEnum = jsonMap["repeatedImportEnum"] as? Array<String> {
                    var jsonArrayRepeatedImportEnum:Array<ProtobufUnittestImport.ImportEnum> = []
                    for oneValueRepeatedImportEnum in jsonValueRepeatedImportEnum {
                        let enumFromStringRepeatedImportEnum = try ProtobufUnittestImport.ImportEnum.fromString(oneValueRepeatedImportEnum)
                        jsonArrayRepeatedImportEnum.append(enumFromStringRepeatedImportEnum)
                    }
                    resultDecodedBuilder.repeatedImportEnum = jsonArrayRepeatedImportEnum
                }
                if let jsonValueRepeatedStringPiece = jsonMap["repeatedStringPiece"] as? Array<String> {
                    var jsonArrayRepeatedStringPiece:Array<String> = []
                    for oneValueRepeatedStringPiece in jsonValueRepeatedStringPiece {
                        jsonArrayRepeatedStringPiece.append(oneValueRepeatedStringPiece)
                    }
                    resultDecodedBuilder.repeatedStringPiece = jsonArrayRepeatedStringPiece
                }
                if let jsonValueRepeatedCord = jsonMap["repeatedCord"] as? Array<String> {
                    var jsonArrayRepeatedCord:Array<String> = []
                    for oneValueRepeatedCord in jsonValueRepeatedCord {
                        jsonArrayRepeatedCord.append(oneValueRepeatedCord)
                    }
                    resultDecodedBuilder.repeatedCord = jsonArrayRepeatedCord
                }
                if let jsonValueRepeatedLazyMessage = jsonMap["repeatedLazyMessage"] as? Array<Dictionary<String,Any>> {
                    var jsonArrayRepeatedLazyMessage:Array<ProtobufUnittestNoArena.TestAllTypes.NestedMessage> = []
                    for oneValueRepeatedLazyMessage in jsonValueRepeatedLazyMessage {
                        let messageFromStringRepeatedLazyMessage = try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder.decodeToBuilder(jsonMap:oneValueRepeatedLazyMessage).build()

                        jsonArrayRepeatedLazyMessage.append(messageFromStringRepeatedLazyMessage)
                    }
                    resultDecodedBuilder.repeatedLazyMessage = jsonArrayRepeatedLazyMessage
                }
                if let jsonValueDefaultInt32 = jsonMap["defaultInt32"] as? Int {
                    resultDecodedBuilder.defaultInt32 = Int32(jsonValueDefaultInt32)
                } else if let jsonValueDefaultInt32 = jsonMap["defaultInt32"] as? String {
                    resultDecodedBuilder.defaultInt32 = Int32(jsonValueDefaultInt32)!
                }
                if let jsonValueDefaultInt64 = jsonMap["defaultInt64"] as? String {
                    resultDecodedBuilder.defaultInt64 = Int64(jsonValueDefaultInt64)!
                } else if let jsonValueDefaultInt64 = jsonMap["defaultInt64"] as? Int {
                    resultDecodedBuilder.defaultInt64 = Int64(jsonValueDefaultInt64)
                }
                if let jsonValueDefaultUint32 = jsonMap["defaultUint32"] as? UInt {
                    resultDecodedBuilder.defaultUint32 = UInt32(jsonValueDefaultUint32)
                } else if let jsonValueDefaultUint32 = jsonMap["defaultUint32"] as? String {
                    resultDecodedBuilder.defaultUint32 = UInt32(jsonValueDefaultUint32)!
                }
                if let jsonValueDefaultUint64 = jsonMap["defaultUint64"] as? String {
                    resultDecodedBuilder.defaultUint64 = UInt64(jsonValueDefaultUint64)!
                } else if let jsonValueDefaultUint64 = jsonMap["defaultUint64"] as? UInt {
                    resultDecodedBuilder.defaultUint64 = UInt64(jsonValueDefaultUint64)
                }
                if let jsonValueDefaultSint32 = jsonMap["defaultSint32"] as? Int {
                    resultDecodedBuilder.defaultSint32 = Int32(jsonValueDefaultSint32)
                } else if let jsonValueDefaultSint32 = jsonMap["defaultSint32"] as? String {
                    resultDecodedBuilder.defaultSint32 = Int32(jsonValueDefaultSint32)!
                }
                if let jsonValueDefaultSint64 = jsonMap["defaultSint64"] as? String {
                    resultDecodedBuilder.defaultSint64 = Int64(jsonValueDefaultSint64)!
                } else if let jsonValueDefaultSint64 = jsonMap["defaultSint64"] as? Int {
                    resultDecodedBuilder.defaultSint64 = Int64(jsonValueDefaultSint64)
                }
                if let jsonValueDefaultFixed32 = jsonMap["defaultFixed32"] as? UInt {
                    resultDecodedBuilder.defaultFixed32 = UInt32(jsonValueDefaultFixed32)
                } else if let jsonValueDefaultFixed32 = jsonMap["defaultFixed32"] as? String {
                    resultDecodedBuilder.defaultFixed32 = UInt32(jsonValueDefaultFixed32)!
                }
                if let jsonValueDefaultFixed64 = jsonMap["defaultFixed64"] as? String {
                    resultDecodedBuilder.defaultFixed64 = UInt64(jsonValueDefaultFixed64)!
                } else if let jsonValueDefaultFixed64 = jsonMap["defaultFixed64"] as? UInt {
                    resultDecodedBuilder.defaultFixed64 = UInt64(jsonValueDefaultFixed64)
                }
                if let jsonValueDefaultSfixed32 = jsonMap["defaultSfixed32"] as? Int {
                    resultDecodedBuilder.defaultSfixed32 = Int32(jsonValueDefaultSfixed32)
                } else if let jsonValueDefaultSfixed32 = jsonMap["defaultSfixed32"] as? String {
                    resultDecodedBuilder.defaultSfixed32 = Int32(jsonValueDefaultSfixed32)!
                }
                if let jsonValueDefaultSfixed64 = jsonMap["defaultSfixed64"] as? String {
                    resultDecodedBuilder.defaultSfixed64 = Int64(jsonValueDefaultSfixed64)!
                } else if let jsonValueDefaultSfixed64 = jsonMap["defaultSfixed64"] as? Int {
                    resultDecodedBuilder.defaultSfixed64 = Int64(jsonValueDefaultSfixed64)
                }
                if let jsonValueDefaultFloat = jsonMap["defaultFloat"] as? Float {
                    resultDecodedBuilder.defaultFloat = Float(jsonValueDefaultFloat)
                } else if let jsonValueDefaultFloat = jsonMap["defaultFloat"] as? String {
                    resultDecodedBuilder.defaultFloat = Float(jsonValueDefaultFloat)!
                }
                if let jsonValueDefaultDouble = jsonMap["defaultDouble"] as? Double {
                    resultDecodedBuilder.defaultDouble = Double(jsonValueDefaultDouble)
                } else if let jsonValueDefaultDouble = jsonMap["defaultDouble"] as? String {
                    resultDecodedBuilder.defaultDouble = Double(jsonValueDefaultDouble)!
                }
                if let jsonValueDefaultBool = jsonMap["defaultBool"] as? Bool {
                    resultDecodedBuilder.defaultBool = jsonValueDefaultBool
                }
                if let jsonValueDefaultString = jsonMap["defaultString"] as? String {
                    resultDecodedBuilder.defaultString = jsonValueDefaultString
                }
                if let jsonValueDefaultBytes = jsonMap["defaultBytes"] as? String {
                    resultDecodedBuilder.defaultBytes = Data(base64Encoded:jsonValueDefaultBytes, options: Data.Base64DecodingOptions(rawValue:0))!
                }
                if let jsonValueDefaultNestedEnum = jsonMap["defaultNestedEnum"] as? String {
                    resultDecodedBuilder.defaultNestedEnum = try ProtobufUnittestNoArena.TestAllTypes.NestedEnum.fromString(jsonValueDefaultNestedEnum)
                }
                if let jsonValueDefaultForeignEnum = jsonMap["defaultForeignEnum"] as? String {
                    resultDecodedBuilder.defaultForeignEnum = try ProtobufUnittestNoArena.ForeignEnum.fromString(jsonValueDefaultForeignEnum)
                }
                if let jsonValueDefaultImportEnum = jsonMap["defaultImportEnum"] as? String {
                    resultDecodedBuilder.defaultImportEnum = try ProtobufUnittestImport.ImportEnum.fromString(jsonValueDefaultImportEnum)
                }
                if let jsonValueDefaultStringPiece = jsonMap["defaultStringPiece"] as? String {
                    resultDecodedBuilder.defaultStringPiece = jsonValueDefaultStringPiece
                }
                if let jsonValueDefaultCord = jsonMap["defaultCord"] as? String {
                    resultDecodedBuilder.defaultCord = jsonValueDefaultCord
                }
                if let jsonValueOneofUint32 = jsonMap["oneofUint32"] as? UInt {
                    resultDecodedBuilder.oneofUint32 = UInt32(jsonValueOneofUint32)
                } else if let jsonValueOneofUint32 = jsonMap["oneofUint32"] as? String {
                    resultDecodedBuilder.oneofUint32 = UInt32(jsonValueOneofUint32)!
                }
                if let jsonValueOneofNestedMessage = jsonMap["oneofNestedMessage"] as? Dictionary<String,Any> {
                    resultDecodedBuilder.oneofNestedMessage = try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder.decodeToBuilder(jsonMap:jsonValueOneofNestedMessage).build()

                }
                if let jsonValueOneofString = jsonMap["oneofString"] as? String {
                    resultDecodedBuilder.oneofString = jsonValueOneofString
                }
                if let jsonValueOneofBytes = jsonMap["oneofBytes"] as? String {
                    resultDecodedBuilder.oneofBytes = Data(base64Encoded:jsonValueOneofBytes, options: Data.Base64DecodingOptions(rawValue:0))!
                }
                if let jsonValueLazyOneofNestedMessage = jsonMap["lazyOneofNestedMessage"] as? Dictionary<String,Any> {
                    resultDecodedBuilder.lazyOneofNestedMessage = try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder.decodeToBuilder(jsonMap:jsonValueLazyOneofNestedMessage).build()

                }
                return resultDecodedBuilder
            }
            override class public func fromJSONToBuilder(data:Data, options: JSONSerialization.ReadingOptions = []) throws -> ProtobufUnittestNoArena.TestAllTypes.Builder {
                let jsonData = try JSONSerialization.jsonObject(with:data, options: options)
                guard let jsDataCast = jsonData as? Dictionary<String,Any> else {
                  throw ProtocolBuffersError.invalidProtocolBuffer("Invalid JSON data")
                }
                return try ProtobufUnittestNoArena.TestAllTypes.Builder.decodeToBuilder(jsonMap:jsDataCast)
            }
        }

    }

    /// Define these after TestAllTypes to make sure the compiler can handle
    /// that.
    final public class ForeignMessage : GeneratedMessage {
        public typealias BuilderType = ProtobufUnittestNoArena.ForeignMessage.Builder

        public static func == (lhs: ProtobufUnittestNoArena.ForeignMessage, rhs: ProtobufUnittestNoArena.ForeignMessage) -> Bool {
            if lhs === rhs {
                return true
            }
            var fieldCheck:Bool = (lhs.hashValue == rhs.hashValue)
            fieldCheck = fieldCheck && (lhs.hasC == rhs.hasC) && (!lhs.hasC || lhs.c == rhs.c)
            fieldCheck = (fieldCheck && (lhs.unknownFields == rhs.unknownFields))
            return fieldCheck
        }

        public fileprivate(set) var c:Int32! = nil
        public fileprivate(set) var hasC:Bool = false

        required public init() {
            super.init()
        }
        override public func isInitialized() throws {
        }
        override public func writeTo(codedOutputStream: CodedOutputStream) throws {
            if hasC {
                try codedOutputStream.writeInt32(fieldNumber: 1, value:c)
            }
            try unknownFields.writeTo(codedOutputStream: codedOutputStream)
        }
        override public func serializedSize() -> Int32 {
            var serialize_size:Int32 = memoizedSerializedSize
            if serialize_size != -1 {
             return serialize_size
            }

            serialize_size = 0
            if hasC {
                serialize_size += c.computeInt32Size(fieldNumber: 1)
            }
            serialize_size += unknownFields.serializedSize()
            memoizedSerializedSize = serialize_size
            return serialize_size
        }
        public class func getBuilder() -> ProtobufUnittestNoArena.ForeignMessage.Builder {
            return ProtobufUnittestNoArena.ForeignMessage.classBuilder() as! ProtobufUnittestNoArena.ForeignMessage.Builder
        }
        public func getBuilder() -> ProtobufUnittestNoArena.ForeignMessage.Builder {
            return classBuilder() as! ProtobufUnittestNoArena.ForeignMessage.Builder
        }
        override public class func classBuilder() -> ProtocolBuffersMessageBuilder {
            return ProtobufUnittestNoArena.ForeignMessage.Builder()
        }
        override public func classBuilder() -> ProtocolBuffersMessageBuilder {
            return ProtobufUnittestNoArena.ForeignMessage.Builder()
        }
        public func toBuilder() throws -> ProtobufUnittestNoArena.ForeignMessage.Builder {
            return try ProtobufUnittestNoArena.ForeignMessage.builderWithPrototype(prototype:self)
        }
        public class func builderWithPrototype(prototype:ProtobufUnittestNoArena.ForeignMessage) throws -> ProtobufUnittestNoArena.ForeignMessage.Builder {
            return try ProtobufUnittestNoArena.ForeignMessage.Builder().mergeFrom(other:prototype)
        }
        override public func encode() throws -> Dictionary<String,Any> {
            try isInitialized()
            var jsonMap:Dictionary<String,Any> = Dictionary<String,Any>()
            if hasC {
                jsonMap["c"] = Int(c)
            }
            return jsonMap
        }
        override class public func decode(jsonMap:Dictionary<String,Any>) throws -> ProtobufUnittestNoArena.ForeignMessage {
            return try ProtobufUnittestNoArena.ForeignMessage.Builder.decodeToBuilder(jsonMap:jsonMap).build()
        }
        override class public func fromJSON(data:Data, options: JSONSerialization.ReadingOptions = []) throws -> ProtobufUnittestNoArena.ForeignMessage {
            return try ProtobufUnittestNoArena.ForeignMessage.Builder.fromJSONToBuilder(data:data, options:options).build()
        }
        override public func getDescription(indent:String) throws -> String {
            var output = ""
            if hasC {
                output += "\(indent) c: \(String(describing: c)) \n"
            }
            output += unknownFields.getDescription(indent: indent)
            return output
        }
        override public var hashValue:Int {
            get {
                var hashCode:Int = 7
                if hasC {
                    hashCode = (hashCode &* 31) &+ c.hashValue
                }
                hashCode = (hashCode &* 31) &+  unknownFields.hashValue
                return hashCode
            }
        }


        //Meta information declaration start

        override public class func className() -> String {
            return "ProtobufUnittestNoArena.ForeignMessage"
        }
        override public func className() -> String {
            return "ProtobufUnittestNoArena.ForeignMessage"
        }
        //Meta information declaration end

        final public class Builder : GeneratedMessageBuilder {
            fileprivate var builderResult:ProtobufUnittestNoArena.ForeignMessage = ProtobufUnittestNoArena.ForeignMessage()
            public func getMessage() -> ProtobufUnittestNoArena.ForeignMessage {
                return builderResult
            }

            required override public init () {
                super.init()
            }
            public var c:Int32 {
                get {
                    return builderResult.c
                }
                set (value) {
                    builderResult.hasC = true
                    builderResult.c = value
                }
            }
            public var hasC:Bool {
                get {
                    return builderResult.hasC
                }
            }
            @discardableResult
            public func setC(_ value:Int32) -> ProtobufUnittestNoArena.ForeignMessage.Builder {
                self.c = value
                return self
            }
            @discardableResult
            public func clearC() -> ProtobufUnittestNoArena.ForeignMessage.Builder{
                builderResult.hasC = false
                builderResult.c = nil
                return self
            }
            override public var internalGetResult:GeneratedMessage {
                get {
                    return builderResult
                }
            }
            @discardableResult
            override public func clear() -> ProtobufUnittestNoArena.ForeignMessage.Builder {
                builderResult = ProtobufUnittestNoArena.ForeignMessage()
                return self
            }
            override public func clone() throws -> ProtobufUnittestNoArena.ForeignMessage.Builder {
                return try ProtobufUnittestNoArena.ForeignMessage.builderWithPrototype(prototype:builderResult)
            }
            override public func build() throws -> ProtobufUnittestNoArena.ForeignMessage {
                try checkInitialized()
                return buildPartial()
            }
            public func buildPartial() -> ProtobufUnittestNoArena.ForeignMessage {
                let returnMe:ProtobufUnittestNoArena.ForeignMessage = builderResult
                return returnMe
            }
            @discardableResult
            public func mergeFrom(other:ProtobufUnittestNoArena.ForeignMessage) throws -> ProtobufUnittestNoArena.ForeignMessage.Builder {
                if other == ProtobufUnittestNoArena.ForeignMessage() {
                    return self
                }
                if other.hasC {
                    c = other.c
                }
                try merge(unknownField: other.unknownFields)
                return self
            }
            @discardableResult
            override public func mergeFrom(codedInputStream: CodedInputStream) throws -> ProtobufUnittestNoArena.ForeignMessage.Builder {
                return try mergeFrom(codedInputStream: codedInputStream, extensionRegistry:ExtensionRegistry())
            }
            @discardableResult
            override public func mergeFrom(codedInputStream: CodedInputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.ForeignMessage.Builder {
                let unknownFieldsBuilder:UnknownFieldSet.Builder = try UnknownFieldSet.builderWithUnknownFields(copyFrom:self.unknownFields)
                while (true) {
                    let protobufTag = try codedInputStream.readTag()
                    switch protobufTag {
                    case 0: 
                        self.unknownFields = try unknownFieldsBuilder.build()
                        return self

                    case 8:
                        c = try codedInputStream.readInt32()

                    default:
                        if (!(try parse(codedInputStream:codedInputStream, unknownFields:unknownFieldsBuilder, extensionRegistry:extensionRegistry, tag:protobufTag))) {
                            unknownFields = try unknownFieldsBuilder.build()
                            return self
                        }
                    }
                }
            }
            class override public func decodeToBuilder(jsonMap:Dictionary<String,Any>) throws -> ProtobufUnittestNoArena.ForeignMessage.Builder {
                let resultDecodedBuilder = ProtobufUnittestNoArena.ForeignMessage.Builder()
                if let jsonValueC = jsonMap["c"] as? Int {
                    resultDecodedBuilder.c = Int32(jsonValueC)
                } else if let jsonValueC = jsonMap["c"] as? String {
                    resultDecodedBuilder.c = Int32(jsonValueC)!
                }
                return resultDecodedBuilder
            }
            override class public func fromJSONToBuilder(data:Data, options: JSONSerialization.ReadingOptions = []) throws -> ProtobufUnittestNoArena.ForeignMessage.Builder {
                let jsonData = try JSONSerialization.jsonObject(with:data, options: options)
                guard let jsDataCast = jsonData as? Dictionary<String,Any> else {
                  throw ProtocolBuffersError.invalidProtocolBuffer("Invalid JSON data")
                }
                return try ProtobufUnittestNoArena.ForeignMessage.Builder.decodeToBuilder(jsonMap:jsDataCast)
            }
        }

    }

    final public class TestNoArenaMessage : GeneratedMessage {
        public typealias BuilderType = ProtobufUnittestNoArena.TestNoArenaMessage.Builder

        public static func == (lhs: ProtobufUnittestNoArena.TestNoArenaMessage, rhs: ProtobufUnittestNoArena.TestNoArenaMessage) -> Bool {
            if lhs === rhs {
                return true
            }
            var fieldCheck:Bool = (lhs.hashValue == rhs.hashValue)
            fieldCheck = fieldCheck && (lhs.hasArenaMessage == rhs.hasArenaMessage) && (!lhs.hasArenaMessage || lhs.arenaMessage == rhs.arenaMessage)
            fieldCheck = (fieldCheck && (lhs.unknownFields == rhs.unknownFields))
            return fieldCheck
        }

        public fileprivate(set) var arenaMessage:Proto2ArenaUnittest.ArenaMessage!
        public fileprivate(set) var hasArenaMessage:Bool = false
        required public init() {
            super.init()
        }
        override public func isInitialized() throws {
        }
        override public func writeTo(codedOutputStream: CodedOutputStream) throws {
            if hasArenaMessage {
                try codedOutputStream.writeMessage(fieldNumber: 1, value:arenaMessage)
            }
            try unknownFields.writeTo(codedOutputStream: codedOutputStream)
        }
        override public func serializedSize() -> Int32 {
            var serialize_size:Int32 = memoizedSerializedSize
            if serialize_size != -1 {
             return serialize_size
            }

            serialize_size = 0
            if hasArenaMessage {
                if let varSizearenaMessage = arenaMessage?.computeMessageSize(fieldNumber: 1) {
                    serialize_size += varSizearenaMessage
                }
            }
            serialize_size += unknownFields.serializedSize()
            memoizedSerializedSize = serialize_size
            return serialize_size
        }
        public class func getBuilder() -> ProtobufUnittestNoArena.TestNoArenaMessage.Builder {
            return ProtobufUnittestNoArena.TestNoArenaMessage.classBuilder() as! ProtobufUnittestNoArena.TestNoArenaMessage.Builder
        }
        public func getBuilder() -> ProtobufUnittestNoArena.TestNoArenaMessage.Builder {
            return classBuilder() as! ProtobufUnittestNoArena.TestNoArenaMessage.Builder
        }
        override public class func classBuilder() -> ProtocolBuffersMessageBuilder {
            return ProtobufUnittestNoArena.TestNoArenaMessage.Builder()
        }
        override public func classBuilder() -> ProtocolBuffersMessageBuilder {
            return ProtobufUnittestNoArena.TestNoArenaMessage.Builder()
        }
        public func toBuilder() throws -> ProtobufUnittestNoArena.TestNoArenaMessage.Builder {
            return try ProtobufUnittestNoArena.TestNoArenaMessage.builderWithPrototype(prototype:self)
        }
        public class func builderWithPrototype(prototype:ProtobufUnittestNoArena.TestNoArenaMessage) throws -> ProtobufUnittestNoArena.TestNoArenaMessage.Builder {
            return try ProtobufUnittestNoArena.TestNoArenaMessage.Builder().mergeFrom(other:prototype)
        }
        override public func encode() throws -> Dictionary<String,Any> {
            try isInitialized()
            var jsonMap:Dictionary<String,Any> = Dictionary<String,Any>()
            if hasArenaMessage {
                jsonMap["arenaMessage"] = try arenaMessage.encode()
            }
            return jsonMap
        }
        override class public func decode(jsonMap:Dictionary<String,Any>) throws -> ProtobufUnittestNoArena.TestNoArenaMessage {
            return try ProtobufUnittestNoArena.TestNoArenaMessage.Builder.decodeToBuilder(jsonMap:jsonMap).build()
        }
        override class public func fromJSON(data:Data, options: JSONSerialization.ReadingOptions = []) throws -> ProtobufUnittestNoArena.TestNoArenaMessage {
            return try ProtobufUnittestNoArena.TestNoArenaMessage.Builder.fromJSONToBuilder(data:data, options:options).build()
        }
        override public func getDescription(indent:String) throws -> String {
            var output = ""
            if hasArenaMessage {
                output += "\(indent) arenaMessage {\n"
                if let outDescArenaMessage = arenaMessage {
                    output += try outDescArenaMessage.getDescription(indent: "\(indent)  ")
                }
                output += "\(indent) }\n"
            }
            output += unknownFields.getDescription(indent: indent)
            return output
        }
        override public var hashValue:Int {
            get {
                var hashCode:Int = 7
                if hasArenaMessage {
                    if let hashValuearenaMessage = arenaMessage?.hashValue {
                        hashCode = (hashCode &* 31) &+ hashValuearenaMessage
                    }
                }
                hashCode = (hashCode &* 31) &+  unknownFields.hashValue
                return hashCode
            }
        }


        //Meta information declaration start

        override public class func className() -> String {
            return "ProtobufUnittestNoArena.TestNoArenaMessage"
        }
        override public func className() -> String {
            return "ProtobufUnittestNoArena.TestNoArenaMessage"
        }
        //Meta information declaration end

        final public class Builder : GeneratedMessageBuilder {
            fileprivate var builderResult:ProtobufUnittestNoArena.TestNoArenaMessage = ProtobufUnittestNoArena.TestNoArenaMessage()
            public func getMessage() -> ProtobufUnittestNoArena.TestNoArenaMessage {
                return builderResult
            }

            required override public init () {
                super.init()
            }
            public var arenaMessage:Proto2ArenaUnittest.ArenaMessage! {
                get {
                    if arenaMessageBuilder_ != nil {
                        builderResult.arenaMessage = arenaMessageBuilder_.getMessage()
                    }
                    return builderResult.arenaMessage
                }
                set (value) {
                    builderResult.hasArenaMessage = value != nil
                    builderResult.arenaMessage = value
                }
            }
            public var hasArenaMessage:Bool {
                get {
                    return builderResult.hasArenaMessage
                }
            }
            fileprivate var arenaMessageBuilder_:Proto2ArenaUnittest.ArenaMessage.Builder! {
                didSet {
                    builderResult.hasArenaMessage = true
                }
            }
            public func getArenaMessageBuilder() -> Proto2ArenaUnittest.ArenaMessage.Builder {
                if arenaMessageBuilder_ == nil {
                    arenaMessageBuilder_ = Proto2ArenaUnittest.ArenaMessage.Builder()
                    builderResult.arenaMessage = arenaMessageBuilder_.getMessage()
                    if arenaMessage != nil {
                        try! arenaMessageBuilder_.mergeFrom(other: arenaMessage)
                    }
                }
                return arenaMessageBuilder_
            }
            @discardableResult
            public func setArenaMessage(_ value:Proto2ArenaUnittest.ArenaMessage!) -> ProtobufUnittestNoArena.TestNoArenaMessage.Builder {
                self.arenaMessage = value
                return self
            }
            @discardableResult
            public func mergeArenaMessage(value:Proto2ArenaUnittest.ArenaMessage) throws -> ProtobufUnittestNoArena.TestNoArenaMessage.Builder {
                if builderResult.hasArenaMessage {
                    builderResult.arenaMessage = try Proto2ArenaUnittest.ArenaMessage.builderWithPrototype(prototype:builderResult.arenaMessage).mergeFrom(other: value).buildPartial()
                } else {
                    builderResult.arenaMessage = value
                }
                builderResult.hasArenaMessage = true
                return self
            }
            @discardableResult
            public func clearArenaMessage() -> ProtobufUnittestNoArena.TestNoArenaMessage.Builder {
                arenaMessageBuilder_ = nil
                builderResult.hasArenaMessage = false
                builderResult.arenaMessage = nil
                return self
            }
            override public var internalGetResult:GeneratedMessage {
                get {
                    return builderResult
                }
            }
            @discardableResult
            override public func clear() -> ProtobufUnittestNoArena.TestNoArenaMessage.Builder {
                builderResult = ProtobufUnittestNoArena.TestNoArenaMessage()
                return self
            }
            override public func clone() throws -> ProtobufUnittestNoArena.TestNoArenaMessage.Builder {
                return try ProtobufUnittestNoArena.TestNoArenaMessage.builderWithPrototype(prototype:builderResult)
            }
            override public func build() throws -> ProtobufUnittestNoArena.TestNoArenaMessage {
                try checkInitialized()
                return buildPartial()
            }
            public func buildPartial() -> ProtobufUnittestNoArena.TestNoArenaMessage {
                let returnMe:ProtobufUnittestNoArena.TestNoArenaMessage = builderResult
                return returnMe
            }
            @discardableResult
            public func mergeFrom(other:ProtobufUnittestNoArena.TestNoArenaMessage) throws -> ProtobufUnittestNoArena.TestNoArenaMessage.Builder {
                if other == ProtobufUnittestNoArena.TestNoArenaMessage() {
                    return self
                }
                if (other.hasArenaMessage) {
                    try mergeArenaMessage(value: other.arenaMessage)
                }
                try merge(unknownField: other.unknownFields)
                return self
            }
            @discardableResult
            override public func mergeFrom(codedInputStream: CodedInputStream) throws -> ProtobufUnittestNoArena.TestNoArenaMessage.Builder {
                return try mergeFrom(codedInputStream: codedInputStream, extensionRegistry:ExtensionRegistry())
            }
            @discardableResult
            override public func mergeFrom(codedInputStream: CodedInputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestNoArenaMessage.Builder {
                let unknownFieldsBuilder:UnknownFieldSet.Builder = try UnknownFieldSet.builderWithUnknownFields(copyFrom:self.unknownFields)
                while (true) {
                    let protobufTag = try codedInputStream.readTag()
                    switch protobufTag {
                    case 0: 
                        self.unknownFields = try unknownFieldsBuilder.build()
                        return self

                    case 10:
                        let subBuilder:Proto2ArenaUnittest.ArenaMessage.Builder = Proto2ArenaUnittest.ArenaMessage.Builder()
                        if hasArenaMessage {
                            try subBuilder.mergeFrom(other: arenaMessage)
                        }
                        try codedInputStream.readMessage(builder: subBuilder, extensionRegistry:extensionRegistry)
                        arenaMessage = subBuilder.buildPartial()

                    default:
                        if (!(try parse(codedInputStream:codedInputStream, unknownFields:unknownFieldsBuilder, extensionRegistry:extensionRegistry, tag:protobufTag))) {
                            unknownFields = try unknownFieldsBuilder.build()
                            return self
                        }
                    }
                }
            }
            class override public func decodeToBuilder(jsonMap:Dictionary<String,Any>) throws -> ProtobufUnittestNoArena.TestNoArenaMessage.Builder {
                let resultDecodedBuilder = ProtobufUnittestNoArena.TestNoArenaMessage.Builder()
                if let jsonValueArenaMessage = jsonMap["arenaMessage"] as? Dictionary<String,Any> {
                    resultDecodedBuilder.arenaMessage = try Proto2ArenaUnittest.ArenaMessage.Builder.decodeToBuilder(jsonMap:jsonValueArenaMessage).build()

                }
                return resultDecodedBuilder
            }
            override class public func fromJSONToBuilder(data:Data, options: JSONSerialization.ReadingOptions = []) throws -> ProtobufUnittestNoArena.TestNoArenaMessage.Builder {
                let jsonData = try JSONSerialization.jsonObject(with:data, options: options)
                guard let jsDataCast = jsonData as? Dictionary<String,Any> else {
                  throw ProtocolBuffersError.invalidProtocolBuffer("Invalid JSON data")
                }
                return try ProtobufUnittestNoArena.TestNoArenaMessage.Builder.decodeToBuilder(jsonMap:jsDataCast)
            }
        }

    }

}
extension ProtobufUnittestNoArena.TestAllTypes: GeneratedMessageProtocol {
    public class func parseArrayDelimitedFrom(inputStream: InputStream) throws -> Array<ProtobufUnittestNoArena.TestAllTypes> {
        var mergedArray = Array<ProtobufUnittestNoArena.TestAllTypes>()
        while let value = try parseDelimitedFrom(inputStream: inputStream) {
          mergedArray.append(value)
        }
        return mergedArray
    }
    public class func parseDelimitedFrom(inputStream: InputStream) throws -> ProtobufUnittestNoArena.TestAllTypes? {
        return try ProtobufUnittestNoArena.TestAllTypes.Builder().mergeDelimitedFrom(inputStream: inputStream)?.build()
    }
    public class func parseFrom(data: Data) throws -> ProtobufUnittestNoArena.TestAllTypes {
        return try ProtobufUnittestNoArena.TestAllTypes.Builder().mergeFrom(data: data, extensionRegistry:ProtobufUnittestNoArena.UnittestNoArenaRoot.default.extensionRegistry).build()
    }
    public class func parseFrom(data: Data, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestAllTypes {
        return try ProtobufUnittestNoArena.TestAllTypes.Builder().mergeFrom(data: data, extensionRegistry:extensionRegistry).build()
    }
    public class func parseFrom(inputStream: InputStream) throws -> ProtobufUnittestNoArena.TestAllTypes {
        return try ProtobufUnittestNoArena.TestAllTypes.Builder().mergeFrom(inputStream: inputStream).build()
    }
    public class func parseFrom(inputStream: InputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestAllTypes {
        return try ProtobufUnittestNoArena.TestAllTypes.Builder().mergeFrom(inputStream: inputStream, extensionRegistry:extensionRegistry).build()
    }
    public class func parseFrom(codedInputStream: CodedInputStream) throws -> ProtobufUnittestNoArena.TestAllTypes {
        return try ProtobufUnittestNoArena.TestAllTypes.Builder().mergeFrom(codedInputStream: codedInputStream).build()
    }
    public class func parseFrom(codedInputStream: CodedInputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestAllTypes {
        return try ProtobufUnittestNoArena.TestAllTypes.Builder().mergeFrom(codedInputStream: codedInputStream, extensionRegistry:extensionRegistry).build()
    }
    public subscript(key: String) -> Any? {
        switch key {
        case "optionalInt32": return self.optionalInt32
        case "optionalInt64": return self.optionalInt64
        case "optionalUint32": return self.optionalUint32
        case "optionalUint64": return self.optionalUint64
        case "optionalSint32": return self.optionalSint32
        case "optionalSint64": return self.optionalSint64
        case "optionalFixed32": return self.optionalFixed32
        case "optionalFixed64": return self.optionalFixed64
        case "optionalSfixed32": return self.optionalSfixed32
        case "optionalSfixed64": return self.optionalSfixed64
        case "optionalFloat": return self.optionalFloat
        case "optionalDouble": return self.optionalDouble
        case "optionalBool": return self.optionalBool
        case "optionalString": return self.optionalString
        case "optionalBytes": return self.optionalBytes
        case "optionalGroup": return self.optionalGroup
        case "optionalNestedMessage": return self.optionalNestedMessage
        case "optionalForeignMessage": return self.optionalForeignMessage
        case "optionalImportMessage": return self.optionalImportMessage
        case "optionalNestedEnum": return self.optionalNestedEnum
        case "optionalForeignEnum": return self.optionalForeignEnum
        case "optionalImportEnum": return self.optionalImportEnum
        case "optionalStringPiece": return self.optionalStringPiece
        case "optionalCord": return self.optionalCord
        case "optionalPublicImportMessage": return self.optionalPublicImportMessage
        case "optionalMessage": return self.optionalMessage
        case "repeatedInt32": return self.repeatedInt32
        case "repeatedInt64": return self.repeatedInt64
        case "repeatedUint32": return self.repeatedUint32
        case "repeatedUint64": return self.repeatedUint64
        case "repeatedSint32": return self.repeatedSint32
        case "repeatedSint64": return self.repeatedSint64
        case "repeatedFixed32": return self.repeatedFixed32
        case "repeatedFixed64": return self.repeatedFixed64
        case "repeatedSfixed32": return self.repeatedSfixed32
        case "repeatedSfixed64": return self.repeatedSfixed64
        case "repeatedFloat": return self.repeatedFloat
        case "repeatedDouble": return self.repeatedDouble
        case "repeatedBool": return self.repeatedBool
        case "repeatedString": return self.repeatedString
        case "repeatedBytes": return self.repeatedBytes
        case "repeatedGroup": return self.repeatedGroup
        case "repeatedNestedMessage": return self.repeatedNestedMessage
        case "repeatedForeignMessage": return self.repeatedForeignMessage
        case "repeatedImportMessage": return self.repeatedImportMessage
        case "repeatedNestedEnum": return self.repeatedNestedEnum
        case "repeatedForeignEnum": return self.repeatedForeignEnum
        case "repeatedImportEnum": return self.repeatedImportEnum
        case "repeatedStringPiece": return self.repeatedStringPiece
        case "repeatedCord": return self.repeatedCord
        case "repeatedLazyMessage": return self.repeatedLazyMessage
        case "defaultInt32": return self.defaultInt32
        case "defaultInt64": return self.defaultInt64
        case "defaultUint32": return self.defaultUint32
        case "defaultUint64": return self.defaultUint64
        case "defaultSint32": return self.defaultSint32
        case "defaultSint64": return self.defaultSint64
        case "defaultFixed32": return self.defaultFixed32
        case "defaultFixed64": return self.defaultFixed64
        case "defaultSfixed32": return self.defaultSfixed32
        case "defaultSfixed64": return self.defaultSfixed64
        case "defaultFloat": return self.defaultFloat
        case "defaultDouble": return self.defaultDouble
        case "defaultBool": return self.defaultBool
        case "defaultString": return self.defaultString
        case "defaultBytes": return self.defaultBytes
        case "defaultNestedEnum": return self.defaultNestedEnum
        case "defaultForeignEnum": return self.defaultForeignEnum
        case "defaultImportEnum": return self.defaultImportEnum
        case "defaultStringPiece": return self.defaultStringPiece
        case "defaultCord": return self.defaultCord
        case "oneofUint32": return self.oneofUint32
        case "oneofNestedMessage": return self.oneofNestedMessage
        case "oneofString": return self.oneofString
        case "oneofBytes": return self.oneofBytes
        case "lazyOneofNestedMessage": return self.lazyOneofNestedMessage
        default: return nil
        }
    }
}
extension ProtobufUnittestNoArena.TestAllTypes.NestedMessage: GeneratedMessageProtocol {
    public class func parseArrayDelimitedFrom(inputStream: InputStream) throws -> Array<ProtobufUnittestNoArena.TestAllTypes.NestedMessage> {
        var mergedArray = Array<ProtobufUnittestNoArena.TestAllTypes.NestedMessage>()
        while let value = try parseDelimitedFrom(inputStream: inputStream) {
          mergedArray.append(value)
        }
        return mergedArray
    }
    public class func parseDelimitedFrom(inputStream: InputStream) throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage? {
        return try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder().mergeDelimitedFrom(inputStream: inputStream)?.build()
    }
    public class func parseFrom(data: Data) throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage {
        return try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder().mergeFrom(data: data, extensionRegistry:ProtobufUnittestNoArena.UnittestNoArenaRoot.default.extensionRegistry).build()
    }
    public class func parseFrom(data: Data, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage {
        return try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder().mergeFrom(data: data, extensionRegistry:extensionRegistry).build()
    }
    public class func parseFrom(inputStream: InputStream) throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage {
        return try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder().mergeFrom(inputStream: inputStream).build()
    }
    public class func parseFrom(inputStream: InputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage {
        return try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder().mergeFrom(inputStream: inputStream, extensionRegistry:extensionRegistry).build()
    }
    public class func parseFrom(codedInputStream: CodedInputStream) throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage {
        return try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder().mergeFrom(codedInputStream: codedInputStream).build()
    }
    public class func parseFrom(codedInputStream: CodedInputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestAllTypes.NestedMessage {
        return try ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder().mergeFrom(codedInputStream: codedInputStream, extensionRegistry:extensionRegistry).build()
    }
    public subscript(key: String) -> Any? {
        switch key {
        case "bb": return self.bb
        default: return nil
        }
    }
}
extension ProtobufUnittestNoArena.TestAllTypes.OptionalGroup: GeneratedMessageProtocol {
    public class func parseArrayDelimitedFrom(inputStream: InputStream) throws -> Array<ProtobufUnittestNoArena.TestAllTypes.OptionalGroup> {
        var mergedArray = Array<ProtobufUnittestNoArena.TestAllTypes.OptionalGroup>()
        while let value = try parseDelimitedFrom(inputStream: inputStream) {
          mergedArray.append(value)
        }
        return mergedArray
    }
    public class func parseDelimitedFrom(inputStream: InputStream) throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup? {
        return try ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder().mergeDelimitedFrom(inputStream: inputStream)?.build()
    }
    public class func parseFrom(data: Data) throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup {
        return try ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder().mergeFrom(data: data, extensionRegistry:ProtobufUnittestNoArena.UnittestNoArenaRoot.default.extensionRegistry).build()
    }
    public class func parseFrom(data: Data, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup {
        return try ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder().mergeFrom(data: data, extensionRegistry:extensionRegistry).build()
    }
    public class func parseFrom(inputStream: InputStream) throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup {
        return try ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder().mergeFrom(inputStream: inputStream).build()
    }
    public class func parseFrom(inputStream: InputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup {
        return try ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder().mergeFrom(inputStream: inputStream, extensionRegistry:extensionRegistry).build()
    }
    public class func parseFrom(codedInputStream: CodedInputStream) throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup {
        return try ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder().mergeFrom(codedInputStream: codedInputStream).build()
    }
    public class func parseFrom(codedInputStream: CodedInputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestAllTypes.OptionalGroup {
        return try ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder().mergeFrom(codedInputStream: codedInputStream, extensionRegistry:extensionRegistry).build()
    }
    public subscript(key: String) -> Any? {
        switch key {
        case "a": return self.a
        default: return nil
        }
    }
}
extension ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup: GeneratedMessageProtocol {
    public class func parseArrayDelimitedFrom(inputStream: InputStream) throws -> Array<ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup> {
        var mergedArray = Array<ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup>()
        while let value = try parseDelimitedFrom(inputStream: inputStream) {
          mergedArray.append(value)
        }
        return mergedArray
    }
    public class func parseDelimitedFrom(inputStream: InputStream) throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup? {
        return try ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder().mergeDelimitedFrom(inputStream: inputStream)?.build()
    }
    public class func parseFrom(data: Data) throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup {
        return try ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder().mergeFrom(data: data, extensionRegistry:ProtobufUnittestNoArena.UnittestNoArenaRoot.default.extensionRegistry).build()
    }
    public class func parseFrom(data: Data, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup {
        return try ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder().mergeFrom(data: data, extensionRegistry:extensionRegistry).build()
    }
    public class func parseFrom(inputStream: InputStream) throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup {
        return try ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder().mergeFrom(inputStream: inputStream).build()
    }
    public class func parseFrom(inputStream: InputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup {
        return try ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder().mergeFrom(inputStream: inputStream, extensionRegistry:extensionRegistry).build()
    }
    public class func parseFrom(codedInputStream: CodedInputStream) throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup {
        return try ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder().mergeFrom(codedInputStream: codedInputStream).build()
    }
    public class func parseFrom(codedInputStream: CodedInputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup {
        return try ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder().mergeFrom(codedInputStream: codedInputStream, extensionRegistry:extensionRegistry).build()
    }
    public subscript(key: String) -> Any? {
        switch key {
        case "a": return self.a
        default: return nil
        }
    }
}
extension ProtobufUnittestNoArena.TestAllTypes.Builder: GeneratedMessageBuilderProtocol {
    public typealias GeneratedMessageType = ProtobufUnittestNoArena.TestAllTypes
    public subscript(key: String) -> Any? {
        get { 
            switch key {
            case "optionalInt32": return self.optionalInt32
            case "optionalInt64": return self.optionalInt64
            case "optionalUint32": return self.optionalUint32
            case "optionalUint64": return self.optionalUint64
            case "optionalSint32": return self.optionalSint32
            case "optionalSint64": return self.optionalSint64
            case "optionalFixed32": return self.optionalFixed32
            case "optionalFixed64": return self.optionalFixed64
            case "optionalSfixed32": return self.optionalSfixed32
            case "optionalSfixed64": return self.optionalSfixed64
            case "optionalFloat": return self.optionalFloat
            case "optionalDouble": return self.optionalDouble
            case "optionalBool": return self.optionalBool
            case "optionalString": return self.optionalString
            case "optionalBytes": return self.optionalBytes
            case "optionalGroup": return self.optionalGroup
            case "optionalNestedMessage": return self.optionalNestedMessage
            case "optionalForeignMessage": return self.optionalForeignMessage
            case "optionalImportMessage": return self.optionalImportMessage
            case "optionalNestedEnum": return self.optionalNestedEnum
            case "optionalForeignEnum": return self.optionalForeignEnum
            case "optionalImportEnum": return self.optionalImportEnum
            case "optionalStringPiece": return self.optionalStringPiece
            case "optionalCord": return self.optionalCord
            case "optionalPublicImportMessage": return self.optionalPublicImportMessage
            case "optionalMessage": return self.optionalMessage
            case "repeatedInt32": return self.repeatedInt32
            case "repeatedInt64": return self.repeatedInt64
            case "repeatedUint32": return self.repeatedUint32
            case "repeatedUint64": return self.repeatedUint64
            case "repeatedSint32": return self.repeatedSint32
            case "repeatedSint64": return self.repeatedSint64
            case "repeatedFixed32": return self.repeatedFixed32
            case "repeatedFixed64": return self.repeatedFixed64
            case "repeatedSfixed32": return self.repeatedSfixed32
            case "repeatedSfixed64": return self.repeatedSfixed64
            case "repeatedFloat": return self.repeatedFloat
            case "repeatedDouble": return self.repeatedDouble
            case "repeatedBool": return self.repeatedBool
            case "repeatedString": return self.repeatedString
            case "repeatedBytes": return self.repeatedBytes
            case "repeatedGroup": return self.repeatedGroup
            case "repeatedNestedMessage": return self.repeatedNestedMessage
            case "repeatedForeignMessage": return self.repeatedForeignMessage
            case "repeatedImportMessage": return self.repeatedImportMessage
            case "repeatedNestedEnum": return self.repeatedNestedEnum
            case "repeatedForeignEnum": return self.repeatedForeignEnum
            case "repeatedImportEnum": return self.repeatedImportEnum
            case "repeatedStringPiece": return self.repeatedStringPiece
            case "repeatedCord": return self.repeatedCord
            case "repeatedLazyMessage": return self.repeatedLazyMessage
            case "defaultInt32": return self.defaultInt32
            case "defaultInt64": return self.defaultInt64
            case "defaultUint32": return self.defaultUint32
            case "defaultUint64": return self.defaultUint64
            case "defaultSint32": return self.defaultSint32
            case "defaultSint64": return self.defaultSint64
            case "defaultFixed32": return self.defaultFixed32
            case "defaultFixed64": return self.defaultFixed64
            case "defaultSfixed32": return self.defaultSfixed32
            case "defaultSfixed64": return self.defaultSfixed64
            case "defaultFloat": return self.defaultFloat
            case "defaultDouble": return self.defaultDouble
            case "defaultBool": return self.defaultBool
            case "defaultString": return self.defaultString
            case "defaultBytes": return self.defaultBytes
            case "defaultNestedEnum": return self.defaultNestedEnum
            case "defaultForeignEnum": return self.defaultForeignEnum
            case "defaultImportEnum": return self.defaultImportEnum
            case "defaultStringPiece": return self.defaultStringPiece
            case "defaultCord": return self.defaultCord
            case "oneofUint32": return self.oneofUint32
            case "oneofNestedMessage": return self.oneofNestedMessage
            case "oneofString": return self.oneofString
            case "oneofBytes": return self.oneofBytes
            case "lazyOneofNestedMessage": return self.lazyOneofNestedMessage
            default: return nil
            }
        }
        set (newSubscriptValue) { 
            switch key {
            case "optionalInt32":
                guard let newSubscriptValue = newSubscriptValue as? Int32 else {
                    return
                }
                self.optionalInt32 = newSubscriptValue
            case "optionalInt64":
                guard let newSubscriptValue = newSubscriptValue as? Int64 else {
                    return
                }
                self.optionalInt64 = newSubscriptValue
            case "optionalUint32":
                guard let newSubscriptValue = newSubscriptValue as? UInt32 else {
                    return
                }
                self.optionalUint32 = newSubscriptValue
            case "optionalUint64":
                guard let newSubscriptValue = newSubscriptValue as? UInt64 else {
                    return
                }
                self.optionalUint64 = newSubscriptValue
            case "optionalSint32":
                guard let newSubscriptValue = newSubscriptValue as? Int32 else {
                    return
                }
                self.optionalSint32 = newSubscriptValue
            case "optionalSint64":
                guard let newSubscriptValue = newSubscriptValue as? Int64 else {
                    return
                }
                self.optionalSint64 = newSubscriptValue
            case "optionalFixed32":
                guard let newSubscriptValue = newSubscriptValue as? UInt32 else {
                    return
                }
                self.optionalFixed32 = newSubscriptValue
            case "optionalFixed64":
                guard let newSubscriptValue = newSubscriptValue as? UInt64 else {
                    return
                }
                self.optionalFixed64 = newSubscriptValue
            case "optionalSfixed32":
                guard let newSubscriptValue = newSubscriptValue as? Int32 else {
                    return
                }
                self.optionalSfixed32 = newSubscriptValue
            case "optionalSfixed64":
                guard let newSubscriptValue = newSubscriptValue as? Int64 else {
                    return
                }
                self.optionalSfixed64 = newSubscriptValue
            case "optionalFloat":
                guard let newSubscriptValue = newSubscriptValue as? Float else {
                    return
                }
                self.optionalFloat = newSubscriptValue
            case "optionalDouble":
                guard let newSubscriptValue = newSubscriptValue as? Double else {
                    return
                }
                self.optionalDouble = newSubscriptValue
            case "optionalBool":
                guard let newSubscriptValue = newSubscriptValue as? Bool else {
                    return
                }
                self.optionalBool = newSubscriptValue
            case "optionalString":
                guard let newSubscriptValue = newSubscriptValue as? String else {
                    return
                }
                self.optionalString = newSubscriptValue
            case "optionalBytes":
                guard let newSubscriptValue = newSubscriptValue as? Data else {
                    return
                }
                self.optionalBytes = newSubscriptValue
            case "optionalGroup":
                guard let newSubscriptValue = newSubscriptValue as? ProtobufUnittestNoArena.TestAllTypes.OptionalGroup else {
                    return
                }
                self.optionalGroup = newSubscriptValue
            case "optionalNestedMessage":
                guard let newSubscriptValue = newSubscriptValue as? ProtobufUnittestNoArena.TestAllTypes.NestedMessage else {
                    return
                }
                self.optionalNestedMessage = newSubscriptValue
            case "optionalForeignMessage":
                guard let newSubscriptValue = newSubscriptValue as? ProtobufUnittestNoArena.ForeignMessage else {
                    return
                }
                self.optionalForeignMessage = newSubscriptValue
            case "optionalImportMessage":
                guard let newSubscriptValue = newSubscriptValue as? ProtobufUnittestImport.ImportMessage else {
                    return
                }
                self.optionalImportMessage = newSubscriptValue
            case "optionalNestedEnum":
                guard let newSubscriptValue = newSubscriptValue as? ProtobufUnittestNoArena.TestAllTypes.NestedEnum else {
                    return
                }
                self.optionalNestedEnum = newSubscriptValue
            case "optionalForeignEnum":
                guard let newSubscriptValue = newSubscriptValue as? ProtobufUnittestNoArena.ForeignEnum else {
                    return
                }
                self.optionalForeignEnum = newSubscriptValue
            case "optionalImportEnum":
                guard let newSubscriptValue = newSubscriptValue as? ProtobufUnittestImport.ImportEnum else {
                    return
                }
                self.optionalImportEnum = newSubscriptValue
            case "optionalStringPiece":
                guard let newSubscriptValue = newSubscriptValue as? String else {
                    return
                }
                self.optionalStringPiece = newSubscriptValue
            case "optionalCord":
                guard let newSubscriptValue = newSubscriptValue as? String else {
                    return
                }
                self.optionalCord = newSubscriptValue
            case "optionalPublicImportMessage":
                guard let newSubscriptValue = newSubscriptValue as? ProtobufUnittestImport.PublicImportMessage else {
                    return
                }
                self.optionalPublicImportMessage = newSubscriptValue
            case "optionalMessage":
                guard let newSubscriptValue = newSubscriptValue as? ProtobufUnittestNoArena.TestAllTypes.NestedMessage else {
                    return
                }
                self.optionalMessage = newSubscriptValue
            case "repeatedInt32":
                guard let newSubscriptValue = newSubscriptValue as? Array<Int32> else {
                    return
                }
                self.repeatedInt32 = newSubscriptValue
            case "repeatedInt64":
                guard let newSubscriptValue = newSubscriptValue as? Array<Int64> else {
                    return
                }
                self.repeatedInt64 = newSubscriptValue
            case "repeatedUint32":
                guard let newSubscriptValue = newSubscriptValue as? Array<UInt32> else {
                    return
                }
                self.repeatedUint32 = newSubscriptValue
            case "repeatedUint64":
                guard let newSubscriptValue = newSubscriptValue as? Array<UInt64> else {
                    return
                }
                self.repeatedUint64 = newSubscriptValue
            case "repeatedSint32":
                guard let newSubscriptValue = newSubscriptValue as? Array<Int32> else {
                    return
                }
                self.repeatedSint32 = newSubscriptValue
            case "repeatedSint64":
                guard let newSubscriptValue = newSubscriptValue as? Array<Int64> else {
                    return
                }
                self.repeatedSint64 = newSubscriptValue
            case "repeatedFixed32":
                guard let newSubscriptValue = newSubscriptValue as? Array<UInt32> else {
                    return
                }
                self.repeatedFixed32 = newSubscriptValue
            case "repeatedFixed64":
                guard let newSubscriptValue = newSubscriptValue as? Array<UInt64> else {
                    return
                }
                self.repeatedFixed64 = newSubscriptValue
            case "repeatedSfixed32":
                guard let newSubscriptValue = newSubscriptValue as? Array<Int32> else {
                    return
                }
                self.repeatedSfixed32 = newSubscriptValue
            case "repeatedSfixed64":
                guard let newSubscriptValue = newSubscriptValue as? Array<Int64> else {
                    return
                }
                self.repeatedSfixed64 = newSubscriptValue
            case "repeatedFloat":
                guard let newSubscriptValue = newSubscriptValue as? Array<Float> else {
                    return
                }
                self.repeatedFloat = newSubscriptValue
            case "repeatedDouble":
                guard let newSubscriptValue = newSubscriptValue as? Array<Double> else {
                    return
                }
                self.repeatedDouble = newSubscriptValue
            case "repeatedBool":
                guard let newSubscriptValue = newSubscriptValue as? Array<Bool> else {
                    return
                }
                self.repeatedBool = newSubscriptValue
            case "repeatedString":
                guard let newSubscriptValue = newSubscriptValue as? Array<String> else {
                    return
                }
                self.repeatedString = newSubscriptValue
            case "repeatedBytes":
                guard let newSubscriptValue = newSubscriptValue as? Array<Data> else {
                    return
                }
                self.repeatedBytes = newSubscriptValue
            case "repeatedGroup":
                guard let newSubscriptValue = newSubscriptValue as? Array<ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup> else {
                    return
                }
                self.repeatedGroup = newSubscriptValue
            case "repeatedNestedMessage":
                guard let newSubscriptValue = newSubscriptValue as? Array<ProtobufUnittestNoArena.TestAllTypes.NestedMessage> else {
                    return
                }
                self.repeatedNestedMessage = newSubscriptValue
            case "repeatedForeignMessage":
                guard let newSubscriptValue = newSubscriptValue as? Array<ProtobufUnittestNoArena.ForeignMessage> else {
                    return
                }
                self.repeatedForeignMessage = newSubscriptValue
            case "repeatedImportMessage":
                guard let newSubscriptValue = newSubscriptValue as? Array<ProtobufUnittestImport.ImportMessage> else {
                    return
                }
                self.repeatedImportMessage = newSubscriptValue
            case "repeatedNestedEnum":
                guard let newSubscriptValue = newSubscriptValue as? Array<ProtobufUnittestNoArena.TestAllTypes.NestedEnum> else {
                    return
                }
                self.repeatedNestedEnum = newSubscriptValue
            case "repeatedForeignEnum":
                guard let newSubscriptValue = newSubscriptValue as? Array<ProtobufUnittestNoArena.ForeignEnum> else {
                    return
                }
                self.repeatedForeignEnum = newSubscriptValue
            case "repeatedImportEnum":
                guard let newSubscriptValue = newSubscriptValue as? Array<ProtobufUnittestImport.ImportEnum> else {
                    return
                }
                self.repeatedImportEnum = newSubscriptValue
            case "repeatedStringPiece":
                guard let newSubscriptValue = newSubscriptValue as? Array<String> else {
                    return
                }
                self.repeatedStringPiece = newSubscriptValue
            case "repeatedCord":
                guard let newSubscriptValue = newSubscriptValue as? Array<String> else {
                    return
                }
                self.repeatedCord = newSubscriptValue
            case "repeatedLazyMessage":
                guard let newSubscriptValue = newSubscriptValue as? Array<ProtobufUnittestNoArena.TestAllTypes.NestedMessage> else {
                    return
                }
                self.repeatedLazyMessage = newSubscriptValue
            case "defaultInt32":
                guard let newSubscriptValue = newSubscriptValue as? Int32 else {
                    return
                }
                self.defaultInt32 = newSubscriptValue
            case "defaultInt64":
                guard let newSubscriptValue = newSubscriptValue as? Int64 else {
                    return
                }
                self.defaultInt64 = newSubscriptValue
            case "defaultUint32":
                guard let newSubscriptValue = newSubscriptValue as? UInt32 else {
                    return
                }
                self.defaultUint32 = newSubscriptValue
            case "defaultUint64":
                guard let newSubscriptValue = newSubscriptValue as? UInt64 else {
                    return
                }
                self.defaultUint64 = newSubscriptValue
            case "defaultSint32":
                guard let newSubscriptValue = newSubscriptValue as? Int32 else {
                    return
                }
                self.defaultSint32 = newSubscriptValue
            case "defaultSint64":
                guard let newSubscriptValue = newSubscriptValue as? Int64 else {
                    return
                }
                self.defaultSint64 = newSubscriptValue
            case "defaultFixed32":
                guard let newSubscriptValue = newSubscriptValue as? UInt32 else {
                    return
                }
                self.defaultFixed32 = newSubscriptValue
            case "defaultFixed64":
                guard let newSubscriptValue = newSubscriptValue as? UInt64 else {
                    return
                }
                self.defaultFixed64 = newSubscriptValue
            case "defaultSfixed32":
                guard let newSubscriptValue = newSubscriptValue as? Int32 else {
                    return
                }
                self.defaultSfixed32 = newSubscriptValue
            case "defaultSfixed64":
                guard let newSubscriptValue = newSubscriptValue as? Int64 else {
                    return
                }
                self.defaultSfixed64 = newSubscriptValue
            case "defaultFloat":
                guard let newSubscriptValue = newSubscriptValue as? Float else {
                    return
                }
                self.defaultFloat = newSubscriptValue
            case "defaultDouble":
                guard let newSubscriptValue = newSubscriptValue as? Double else {
                    return
                }
                self.defaultDouble = newSubscriptValue
            case "defaultBool":
                guard let newSubscriptValue = newSubscriptValue as? Bool else {
                    return
                }
                self.defaultBool = newSubscriptValue
            case "defaultString":
                guard let newSubscriptValue = newSubscriptValue as? String else {
                    return
                }
                self.defaultString = newSubscriptValue
            case "defaultBytes":
                guard let newSubscriptValue = newSubscriptValue as? Data else {
                    return
                }
                self.defaultBytes = newSubscriptValue
            case "defaultNestedEnum":
                guard let newSubscriptValue = newSubscriptValue as? ProtobufUnittestNoArena.TestAllTypes.NestedEnum else {
                    return
                }
                self.defaultNestedEnum = newSubscriptValue
            case "defaultForeignEnum":
                guard let newSubscriptValue = newSubscriptValue as? ProtobufUnittestNoArena.ForeignEnum else {
                    return
                }
                self.defaultForeignEnum = newSubscriptValue
            case "defaultImportEnum":
                guard let newSubscriptValue = newSubscriptValue as? ProtobufUnittestImport.ImportEnum else {
                    return
                }
                self.defaultImportEnum = newSubscriptValue
            case "defaultStringPiece":
                guard let newSubscriptValue = newSubscriptValue as? String else {
                    return
                }
                self.defaultStringPiece = newSubscriptValue
            case "defaultCord":
                guard let newSubscriptValue = newSubscriptValue as? String else {
                    return
                }
                self.defaultCord = newSubscriptValue
            case "oneofUint32":
                guard let newSubscriptValue = newSubscriptValue as? UInt32 else {
                    return
                }
                self.oneofUint32 = newSubscriptValue
            case "oneofNestedMessage":
                guard let newSubscriptValue = newSubscriptValue as? ProtobufUnittestNoArena.TestAllTypes.NestedMessage else {
                    return
                }
                self.oneofNestedMessage = newSubscriptValue
            case "oneofString":
                guard let newSubscriptValue = newSubscriptValue as? String else {
                    return
                }
                self.oneofString = newSubscriptValue
            case "oneofBytes":
                guard let newSubscriptValue = newSubscriptValue as? Data else {
                    return
                }
                self.oneofBytes = newSubscriptValue
            case "lazyOneofNestedMessage":
                guard let newSubscriptValue = newSubscriptValue as? ProtobufUnittestNoArena.TestAllTypes.NestedMessage else {
                    return
                }
                self.lazyOneofNestedMessage = newSubscriptValue
            default: return
            }
        }
    }
}
extension ProtobufUnittestNoArena.TestAllTypes.NestedMessage.Builder: GeneratedMessageBuilderProtocol {
    public typealias GeneratedMessageType = ProtobufUnittestNoArena.TestAllTypes.NestedMessage
    public subscript(key: String) -> Any? {
        get { 
            switch key {
            case "bb": return self.bb
            default: return nil
            }
        }
        set (newSubscriptValue) { 
            switch key {
            case "bb":
                guard let newSubscriptValue = newSubscriptValue as? Int32 else {
                    return
                }
                self.bb = newSubscriptValue
            default: return
            }
        }
    }
}
extension ProtobufUnittestNoArena.TestAllTypes.OptionalGroup.Builder: GeneratedMessageBuilderProtocol {
    public typealias GeneratedMessageType = ProtobufUnittestNoArena.TestAllTypes.OptionalGroup
    public subscript(key: String) -> Any? {
        get { 
            switch key {
            case "a": return self.a
            default: return nil
            }
        }
        set (newSubscriptValue) { 
            switch key {
            case "a":
                guard let newSubscriptValue = newSubscriptValue as? Int32 else {
                    return
                }
                self.a = newSubscriptValue
            default: return
            }
        }
    }
}
extension ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup.Builder: GeneratedMessageBuilderProtocol {
    public typealias GeneratedMessageType = ProtobufUnittestNoArena.TestAllTypes.RepeatedGroup
    public subscript(key: String) -> Any? {
        get { 
            switch key {
            case "a": return self.a
            default: return nil
            }
        }
        set (newSubscriptValue) { 
            switch key {
            case "a":
                guard let newSubscriptValue = newSubscriptValue as? Int32 else {
                    return
                }
                self.a = newSubscriptValue
            default: return
            }
        }
    }
}
extension ProtobufUnittestNoArena.ForeignMessage: GeneratedMessageProtocol {
    public class func parseArrayDelimitedFrom(inputStream: InputStream) throws -> Array<ProtobufUnittestNoArena.ForeignMessage> {
        var mergedArray = Array<ProtobufUnittestNoArena.ForeignMessage>()
        while let value = try parseDelimitedFrom(inputStream: inputStream) {
          mergedArray.append(value)
        }
        return mergedArray
    }
    public class func parseDelimitedFrom(inputStream: InputStream) throws -> ProtobufUnittestNoArena.ForeignMessage? {
        return try ProtobufUnittestNoArena.ForeignMessage.Builder().mergeDelimitedFrom(inputStream: inputStream)?.build()
    }
    public class func parseFrom(data: Data) throws -> ProtobufUnittestNoArena.ForeignMessage {
        return try ProtobufUnittestNoArena.ForeignMessage.Builder().mergeFrom(data: data, extensionRegistry:ProtobufUnittestNoArena.UnittestNoArenaRoot.default.extensionRegistry).build()
    }
    public class func parseFrom(data: Data, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.ForeignMessage {
        return try ProtobufUnittestNoArena.ForeignMessage.Builder().mergeFrom(data: data, extensionRegistry:extensionRegistry).build()
    }
    public class func parseFrom(inputStream: InputStream) throws -> ProtobufUnittestNoArena.ForeignMessage {
        return try ProtobufUnittestNoArena.ForeignMessage.Builder().mergeFrom(inputStream: inputStream).build()
    }
    public class func parseFrom(inputStream: InputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.ForeignMessage {
        return try ProtobufUnittestNoArena.ForeignMessage.Builder().mergeFrom(inputStream: inputStream, extensionRegistry:extensionRegistry).build()
    }
    public class func parseFrom(codedInputStream: CodedInputStream) throws -> ProtobufUnittestNoArena.ForeignMessage {
        return try ProtobufUnittestNoArena.ForeignMessage.Builder().mergeFrom(codedInputStream: codedInputStream).build()
    }
    public class func parseFrom(codedInputStream: CodedInputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.ForeignMessage {
        return try ProtobufUnittestNoArena.ForeignMessage.Builder().mergeFrom(codedInputStream: codedInputStream, extensionRegistry:extensionRegistry).build()
    }
    public subscript(key: String) -> Any? {
        switch key {
        case "c": return self.c
        default: return nil
        }
    }
}
extension ProtobufUnittestNoArena.ForeignMessage.Builder: GeneratedMessageBuilderProtocol {
    public typealias GeneratedMessageType = ProtobufUnittestNoArena.ForeignMessage
    public subscript(key: String) -> Any? {
        get { 
            switch key {
            case "c": return self.c
            default: return nil
            }
        }
        set (newSubscriptValue) { 
            switch key {
            case "c":
                guard let newSubscriptValue = newSubscriptValue as? Int32 else {
                    return
                }
                self.c = newSubscriptValue
            default: return
            }
        }
    }
}
extension ProtobufUnittestNoArena.TestNoArenaMessage: GeneratedMessageProtocol {
    public class func parseArrayDelimitedFrom(inputStream: InputStream) throws -> Array<ProtobufUnittestNoArena.TestNoArenaMessage> {
        var mergedArray = Array<ProtobufUnittestNoArena.TestNoArenaMessage>()
        while let value = try parseDelimitedFrom(inputStream: inputStream) {
          mergedArray.append(value)
        }
        return mergedArray
    }
    public class func parseDelimitedFrom(inputStream: InputStream) throws -> ProtobufUnittestNoArena.TestNoArenaMessage? {
        return try ProtobufUnittestNoArena.TestNoArenaMessage.Builder().mergeDelimitedFrom(inputStream: inputStream)?.build()
    }
    public class func parseFrom(data: Data) throws -> ProtobufUnittestNoArena.TestNoArenaMessage {
        return try ProtobufUnittestNoArena.TestNoArenaMessage.Builder().mergeFrom(data: data, extensionRegistry:ProtobufUnittestNoArena.UnittestNoArenaRoot.default.extensionRegistry).build()
    }
    public class func parseFrom(data: Data, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestNoArenaMessage {
        return try ProtobufUnittestNoArena.TestNoArenaMessage.Builder().mergeFrom(data: data, extensionRegistry:extensionRegistry).build()
    }
    public class func parseFrom(inputStream: InputStream) throws -> ProtobufUnittestNoArena.TestNoArenaMessage {
        return try ProtobufUnittestNoArena.TestNoArenaMessage.Builder().mergeFrom(inputStream: inputStream).build()
    }
    public class func parseFrom(inputStream: InputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestNoArenaMessage {
        return try ProtobufUnittestNoArena.TestNoArenaMessage.Builder().mergeFrom(inputStream: inputStream, extensionRegistry:extensionRegistry).build()
    }
    public class func parseFrom(codedInputStream: CodedInputStream) throws -> ProtobufUnittestNoArena.TestNoArenaMessage {
        return try ProtobufUnittestNoArena.TestNoArenaMessage.Builder().mergeFrom(codedInputStream: codedInputStream).build()
    }
    public class func parseFrom(codedInputStream: CodedInputStream, extensionRegistry:ExtensionRegistry) throws -> ProtobufUnittestNoArena.TestNoArenaMessage {
        return try ProtobufUnittestNoArena.TestNoArenaMessage.Builder().mergeFrom(codedInputStream: codedInputStream, extensionRegistry:extensionRegistry).build()
    }
    public subscript(key: String) -> Any? {
        switch key {
        case "arenaMessage": return self.arenaMessage
        default: return nil
        }
    }
}
extension ProtobufUnittestNoArena.TestNoArenaMessage.Builder: GeneratedMessageBuilderProtocol {
    public typealias GeneratedMessageType = ProtobufUnittestNoArena.TestNoArenaMessage
    public subscript(key: String) -> Any? {
        get { 
            switch key {
            case "arenaMessage": return self.arenaMessage
            default: return nil
            }
        }
        set (newSubscriptValue) { 
            switch key {
            case "arenaMessage":
                guard let newSubscriptValue = newSubscriptValue as? Proto2ArenaUnittest.ArenaMessage else {
                    return
                }
                self.arenaMessage = newSubscriptValue
            default: return
            }
        }
    }
}

// @@protoc_insertion_point(global_scope)
