From 8f8186a30b9b8d865c6211eb91a4df8aae1f40d5 Mon Sep 17 00:00:00 2001 From: Jon Skeet Date: Fri, 16 Jan 2009 10:57:40 +0000 Subject: [PATCH] Benchmarking, dumping and munging --- .gitignore | 6 + ProtocolBuffers.build | 10 + protos/google/protobuf/benchmark.proto | 140 + src/ProtoBench/BenchmarkProtoFile.cs | 5742 +++++++++++++++++ src/ProtoBench/Program.cs | 90 + src/ProtoBench/Properties/AssemblyInfo.cs | 36 + src/ProtoBench/ProtoBench.csproj | 62 + src/ProtoBench/app.config | 3 + src/ProtoDump/Program.cs | 43 + src/ProtoDump/Properties/AssemblyInfo.cs | 36 + src/ProtoDump/ProtoDump.csproj | 59 + src/ProtoDump/app.config | 3 + src/ProtoGen.Test/DependencyResolutionTest.cs | 5 +- src/ProtoGen.Test/GeneratorTest.cs | 10 - src/ProtoGen.Test/ProtoGen.Test.csproj | 1 - src/ProtoGen/Program.cs | 2 - src/ProtoMunge/Program.cs | 228 + src/ProtoMunge/Properties/AssemblyInfo.cs | 36 + src/ProtoMunge/ProtoMunge.csproj | 59 + src/ProtoMunge/app.config | 3 + src/ProtocolBuffers.Test/MessageUtilTest.cs | 45 + .../ProtocolBuffers.Test.csproj | 1 + src/ProtocolBuffers.sln | 18 + src/ProtocolBuffers/ByteString.cs | 4 +- src/ProtocolBuffers/MessageUtil.cs | 62 + src/ProtocolBuffers/ProtocolBuffers.csproj | 1 + testdata/benchmark_message1.dat | Bin 0 -> 228 bytes testdata/benchmark_message2.dat | Bin 0 -> 84570 bytes 28 files changed, 6686 insertions(+), 19 deletions(-) create mode 100644 protos/google/protobuf/benchmark.proto create mode 100644 src/ProtoBench/BenchmarkProtoFile.cs create mode 100644 src/ProtoBench/Program.cs create mode 100644 src/ProtoBench/Properties/AssemblyInfo.cs create mode 100644 src/ProtoBench/ProtoBench.csproj create mode 100644 src/ProtoBench/app.config create mode 100644 src/ProtoDump/Program.cs create mode 100644 src/ProtoDump/Properties/AssemblyInfo.cs create mode 100644 src/ProtoDump/ProtoDump.csproj create mode 100644 src/ProtoDump/app.config delete mode 100644 src/ProtoGen.Test/GeneratorTest.cs create mode 100644 src/ProtoMunge/Program.cs create mode 100644 src/ProtoMunge/Properties/AssemblyInfo.cs create mode 100644 src/ProtoMunge/ProtoMunge.csproj create mode 100644 src/ProtoMunge/app.config create mode 100644 src/ProtocolBuffers.Test/MessageUtilTest.cs create mode 100644 src/ProtocolBuffers/MessageUtil.cs create mode 100644 testdata/benchmark_message1.dat create mode 100644 testdata/benchmark_message2.dat diff --git a/.gitignore b/.gitignore index 54ed9562f4..0127b4aa42 100644 --- a/.gitignore +++ b/.gitignore @@ -6,10 +6,16 @@ src/ProtocolBuffers/bin/ src/ProtocolBuffers/obj/ src/ProtocolBuffers.Test/bin/ src/ProtocolBuffers.Test/obj/ +src/ProtoBench/bin/ +src/ProtoBench/obj/ +src/ProtoDump/bin/ +src/ProtoDump/obj/ src/ProtoGen/bin/ src/ProtoGen/obj/ src/ProtoGen.Test/bin/ src/ProtoGen.Test/obj/ +src/ProtoMunge/bin/ +src/ProtoMunge/obj/ tmp/ dist/ *.user diff --git a/ProtocolBuffers.build b/ProtocolBuffers.build index 97ff2c5d92..23cd6b4042 100644 --- a/ProtocolBuffers.build +++ b/ProtocolBuffers.build @@ -72,6 +72,7 @@ workingdir="${tmp-dir}"> + @@ -114,6 +115,12 @@ + + + + + + + + + diff --git a/protos/google/protobuf/benchmark.proto b/protos/google/protobuf/benchmark.proto new file mode 100644 index 0000000000..2dbcdc897c --- /dev/null +++ b/protos/google/protobuf/benchmark.proto @@ -0,0 +1,140 @@ +import "google/protobuf/csharp_options.proto"; +import "google/protobuf/descriptor.proto"; +option (google.protobuf.csharp_file_options).namespace = "Google.ProtocolBuffers.BenchmarkProtos"; +option (google.protobuf.csharp_file_options).umbrella_classname = "BenchmarkProtoFile"; + +package proto2.benchmark.v2_api; + +option optimize_for = SPEED; + +message Message1 { + required string field1 = 1; + optional string field9 = 9; + optional string field18 = 18; + optional bool field80 = 80 [default=false]; + optional bool field81 = 81 [default=true]; + required int32 field2 = 2; + required int32 field3 = 3; + optional int32 field280 = 280; + optional int32 field6 = 6 [default=0]; + optional int64 field22 = 22; + optional string field4 = 4; + repeated fixed64 field5 = 5; + optional bool field59 = 59 [default=false]; + optional string field7 = 7; + optional int32 field16 = 16; + optional int32 field130 = 130 [default=0]; + optional bool field12 = 12 [default=true]; + optional bool field17 = 17 [default=true]; + optional bool field13 = 13 [default=true]; + optional bool field14 = 14 [default=true]; + optional int32 field104 = 104 [default=0]; + optional int32 field100 = 100 [default=0]; + optional int32 field101 = 101 [default=0]; + optional string field102 = 102; + optional string field103 = 103; + optional int32 field29 = 29 [default=0]; + optional bool field30 = 30 [default=false]; + optional int32 field60 = 60 [default=-1]; + optional int32 field271 = 271 [default=-1]; + optional int32 field272 = 272 [default=-1]; + optional int32 field150 = 150; + optional int32 field23 = 23 [default=0]; + optional bool field24 = 24 [default=false]; + optional int32 field25 = 25 [default=0]; + optional Message2 field15 = 15; + optional bool field78 = 78; + optional int32 field67 = 67 [default=0]; + optional int32 field68 = 68; + optional int32 field128 = 128 [default=0]; + optional string field129 = 129 [default="xxxxxxxxxxxxxxxxxxxxx"]; + optional int32 field131 = 131 [default=0]; +} + +message Message2 { + optional int32 field1 = 1 [default=0]; + optional int32 field2 = 2 [default=0]; + optional int32 field3 = 3 [default=0]; + optional string field15 = 15; + optional bool field12 = 12 [default=true]; + optional int64 field13 = 13; + optional int64 field14 = 14; + optional int32 field16 = 16; + optional int32 field19 = 19 [default=2]; + optional bool field20 = 20 [default=true]; + optional bool field28 = 28 [default=true]; + optional fixed64 field21 = 21; + optional int32 field22 = 22; + optional bool field23 = 23 [ default=false ]; + optional bool field206 = 206 [default=false]; + optional fixed32 field203 = 203; + optional int32 field204 = 204; + optional string field205 = 205; + optional uint64 field207 = 207; + optional uint64 field300 = 300; +} + +message Message3 { + optional string field1 = 1; + optional int64 field3 = 3; + optional int64 field4 = 4; + optional int64 field30 = 30; + optional bool field75 = 75 [default=false]; + optional string field6 = 6; + optional bytes field2 = 2; + optional int32 field21 = 21 [default=0]; + optional int32 field71 = 71; + optional float field25 = 25; + optional int32 field109 = 109 [default=0]; + optional int32 field210 = 210 [default=0]; + optional int32 field211 = 211 [default=0]; + optional int32 field212 = 212 [default=0]; + optional int32 field213 = 213 [default=0]; + optional int32 field216 = 216 [default=0]; + optional int32 field217 = 217 [default=0]; + optional int32 field218 = 218 [default=0]; + optional int32 field220 = 220 [default=0]; + optional int32 field221 = 221 [default=0]; + optional float field222 = 222 [default=0.0]; + optional int32 field63 = 63; + + repeated group Group1 = 10 { + required float field11 = 11; + optional float field26 = 26; + optional string field12 = 12; + optional string field13 = 13; + repeated string field14 = 14; + required uint64 field15 = 15; + optional int32 field5 = 5; + optional string field27 = 27; + optional int32 field28 = 28; + optional string field29 = 29; + optional string field16 = 16; + repeated string field22 = 22; + repeated int32 field73 = 73; + optional int32 field20 = 20 [default=0]; + optional string field24 = 24; + optional Message4 field31 = 31; + } + repeated string field128 = 128; + optional int64 field131 = 131; + repeated string field127 = 127; + optional int32 field129 = 129; + repeated int64 field130 = 130; + optional bool field205 = 205 [default=false]; + optional bool field206 = 206 [default=false]; +} + +message Message4 { + optional float field1 = 1; + optional float field2 = 2; + optional float field3 = 3 [default=0.0]; + optional bool field4 = 4; + optional bool field5 = 5; + optional bool field6 = 6 [default=true]; + optional bool field7 = 7 [default=false]; + optional float field8 = 8; + optional bool field9 = 9; + optional float field10 = 10; + optional int64 field11 = 11; +} diff --git a/src/ProtoBench/BenchmarkProtoFile.cs b/src/ProtoBench/BenchmarkProtoFile.cs new file mode 100644 index 0000000000..2301603fd1 --- /dev/null +++ b/src/ProtoBench/BenchmarkProtoFile.cs @@ -0,0 +1,5742 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! + +using pb = global::Google.ProtocolBuffers; +using pbc = global::Google.ProtocolBuffers.Collections; +using pbd = global::Google.ProtocolBuffers.Descriptors; +using scg = global::System.Collections.Generic; +namespace Google.ProtocolBuffers.BenchmarkProtos { + + public static partial class BenchmarkProtoFile { + + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom( + global::System.Convert.FromBase64String( + "Ch9nb29nbGUvcHJvdG9idWYvYmVuY2htYXJrLnByb3RvEhdwcm90bzIuYmVu" + + "Y2htYXJrLnYyX2FwaRokZ29vZ2xlL3Byb3RvYnVmL2NzaGFycF9vcHRpb25z" + + "LnByb3RvGiBnb29nbGUvcHJvdG9idWYvZGVzY3JpcHRvci5wcm90byLxBgoI" + + "TWVzc2FnZTESDgoGZmllbGQxGAEgAigJEg4KBmZpZWxkORgJIAEoCRIPCgdm" + + "aWVsZDE4GBIgASgJEhYKB2ZpZWxkODAYUCABKAg6BWZhbHNlEhUKB2ZpZWxk" + + "ODEYUSABKAg6BHRydWUSDgoGZmllbGQyGAIgAigFEg4KBmZpZWxkMxgDIAIo" + + "BRIRCghmaWVsZDI4MBiYAiABKAUSEQoGZmllbGQ2GAYgASgFOgEwEg8KB2Zp" + + "ZWxkMjIYFiABKAMSDgoGZmllbGQ0GAQgASgJEg4KBmZpZWxkNRgFIAMoBhIW" + + "CgdmaWVsZDU5GDsgASgIOgVmYWxzZRIOCgZmaWVsZDcYByABKAkSDwoHZmll" + + "bGQxNhgQIAEoBRIUCghmaWVsZDEzMBiCASABKAU6ATASFQoHZmllbGQxMhgM" + + "IAEoCDoEdHJ1ZRIVCgdmaWVsZDE3GBEgASgIOgR0cnVlEhUKB2ZpZWxkMTMY" + + "DSABKAg6BHRydWUSFQoHZmllbGQxNBgOIAEoCDoEdHJ1ZRITCghmaWVsZDEw" + + "NBhoIAEoBToBMBITCghmaWVsZDEwMBhkIAEoBToBMBITCghmaWVsZDEwMRhl" + + "IAEoBToBMBIQCghmaWVsZDEwMhhmIAEoCRIQCghmaWVsZDEwMxhnIAEoCRIS" + + "CgdmaWVsZDI5GB0gASgFOgEwEhYKB2ZpZWxkMzAYHiABKAg6BWZhbHNlEhMK" + + "B2ZpZWxkNjAYPCABKAU6Ai0xEhUKCGZpZWxkMjcxGI8CIAEoBToCLTESFQoI" + + "ZmllbGQyNzIYkAIgASgFOgItMRIRCghmaWVsZDE1MBiWASABKAUSEgoHZmll" + + "bGQyMxgXIAEoBToBMBIWCgdmaWVsZDI0GBggASgIOgVmYWxzZRISCgdmaWVs" + + "ZDI1GBkgASgFOgEwEjIKB2ZpZWxkMTUYDyABKAsyIS5wcm90bzIuYmVuY2ht" + + "YXJrLnYyX2FwaS5NZXNzYWdlMhIPCgdmaWVsZDc4GE4gASgIEhIKB2ZpZWxk" + + "NjcYQyABKAU6ATASDwoHZmllbGQ2OBhEIAEoBRIUCghmaWVsZDEyOBiAASAB" + + "KAU6ATASKAoIZmllbGQxMjkYgQEgASgJOhV4eHh4eHh4eHh4eHh4eHh4eHh4" + + "eHgSFAoIZmllbGQxMzEYgwEgASgFOgEwIpMDCghNZXNzYWdlMhIRCgZmaWVs" + + "ZDEYASABKAU6ATASEQoGZmllbGQyGAIgASgFOgEwEhEKBmZpZWxkMxgDIAEo" + + "BToBMBIPCgdmaWVsZDE1GA8gASgJEhUKB2ZpZWxkMTIYDCABKAg6BHRydWUS" + + "DwoHZmllbGQxMxgNIAEoAxIPCgdmaWVsZDE0GA4gASgDEg8KB2ZpZWxkMTYY" + + "ECABKAUSEgoHZmllbGQxORgTIAEoBToBMhIVCgdmaWVsZDIwGBQgASgIOgR0" + + "cnVlEhUKB2ZpZWxkMjgYHCABKAg6BHRydWUSDwoHZmllbGQyMRgVIAEoBhIP" + + "CgdmaWVsZDIyGBYgASgFEhYKB2ZpZWxkMjMYFyABKAg6BWZhbHNlEhgKCGZp" + + "ZWxkMjA2GM4BIAEoCDoFZmFsc2USEQoIZmllbGQyMDMYywEgASgHEhEKCGZp" + + "ZWxkMjA0GMwBIAEoBRIRCghmaWVsZDIwNRjNASABKAkSEQoIZmllbGQyMDcY" + + "zwEgASgEEhEKCGZpZWxkMzAwGKwCIAEoBCLHBwoITWVzc2FnZTMSDgoGZmll" + + "bGQxGAEgASgJEg4KBmZpZWxkMxgDIAEoAxIOCgZmaWVsZDQYBCABKAMSDwoH" + + "ZmllbGQzMBgeIAEoAxIWCgdmaWVsZDc1GEsgASgIOgVmYWxzZRIOCgZmaWVs" + + "ZDYYBiABKAkSDgoGZmllbGQyGAIgASgMEhIKB2ZpZWxkMjEYFSABKAU6ATAS" + + "DwoHZmllbGQ3MRhHIAEoBRIPCgdmaWVsZDI1GBkgASgCEhMKCGZpZWxkMTA5" + + "GG0gASgFOgEwEhQKCGZpZWxkMjEwGNIBIAEoBToBMBIUCghmaWVsZDIxMRjT" + + "ASABKAU6ATASFAoIZmllbGQyMTIY1AEgASgFOgEwEhQKCGZpZWxkMjEzGNUB" + + "IAEoBToBMBIUCghmaWVsZDIxNhjYASABKAU6ATASFAoIZmllbGQyMTcY2QEg" + + "ASgFOgEwEhQKCGZpZWxkMjE4GNoBIAEoBToBMBIUCghmaWVsZDIyMBjcASAB" + + "KAU6ATASFAoIZmllbGQyMjEY3QEgASgFOgEwEhQKCGZpZWxkMjIyGN4BIAEo" + + "AjoBMBIPCgdmaWVsZDYzGD8gASgFEjgKBmdyb3VwMRgKIAMoCjIoLnByb3Rv" + + "Mi5iZW5jaG1hcmsudjJfYXBpLk1lc3NhZ2UzLkdyb3VwMRIRCghmaWVsZDEy" + + "OBiAASADKAkSEQoIZmllbGQxMzEYgwEgASgDEhAKCGZpZWxkMTI3GH8gAygJ" + + "EhEKCGZpZWxkMTI5GIEBIAEoBRIRCghmaWVsZDEzMBiCASADKAMSGAoIZmll" + + "bGQyMDUYzQEgASgIOgVmYWxzZRIYCghmaWVsZDIwNhjOASABKAg6BWZhbHNl" + + "Gr0CCgZHcm91cDESDwoHZmllbGQxMRgLIAIoAhIPCgdmaWVsZDI2GBogASgC" + + "Eg8KB2ZpZWxkMTIYDCABKAkSDwoHZmllbGQxMxgNIAEoCRIPCgdmaWVsZDE0" + + "GA4gAygJEg8KB2ZpZWxkMTUYDyACKAQSDgoGZmllbGQ1GAUgASgFEg8KB2Zp" + + "ZWxkMjcYGyABKAkSDwoHZmllbGQyOBgcIAEoBRIPCgdmaWVsZDI5GB0gASgJ" + + "Eg8KB2ZpZWxkMTYYECABKAkSDwoHZmllbGQyMhgWIAMoCRIPCgdmaWVsZDcz" + + "GEkgAygFEhIKB2ZpZWxkMjAYFCABKAU6ATASDwoHZmllbGQyNBgYIAEoCRIy" + + "CgdmaWVsZDMxGB8gASgLMiEucHJvdG8yLmJlbmNobWFyay52Ml9hcGkuTWVz" + + "c2FnZTQizAEKCE1lc3NhZ2U0Eg4KBmZpZWxkMRgBIAEoAhIOCgZmaWVsZDIY" + + "AiABKAISEQoGZmllbGQzGAMgASgCOgEwEg4KBmZpZWxkNBgEIAEoCBIOCgZm" + + "aWVsZDUYBSABKAgSFAoGZmllbGQ2GAYgASgIOgR0cnVlEhUKBmZpZWxkNxgH" + + "IAEoCDoFZmFsc2USDgoGZmllbGQ4GAggASgCEg4KBmZpZWxkORgJIAEoCBIP" + + "CgdmaWVsZDEwGAogASgCEg8KB2ZpZWxkMTEYCyABKANCQUgBwj48CiZHb29n" + + "bGUuUHJvdG9jb2xCdWZmZXJzLkJlbmNobWFya1Byb3RvcxISQmVuY2htYXJr" + + "UHJvdG9GaWxl"), + new pbd::FileDescriptor[] { + global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, + }); + #endregion + + #region Static variables + internal static readonly pbd::MessageDescriptor internal__static_proto2_benchmark_v2_api_Message1__Descriptor + = Descriptor.MessageTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_proto2_benchmark_v2_api_Message1__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_proto2_benchmark_v2_api_Message1__Descriptor, + new string[] { "Field1", "Field9", "Field18", "Field80", "Field81", "Field2", "Field3", "Field280", "Field6", "Field22", "Field4", "Field5", "Field59", "Field7", "Field16", "Field130", "Field12", "Field17", "Field13", "Field14", "Field104", "Field100", "Field101", "Field102", "Field103", "Field29", "Field30", "Field60", "Field271", "Field272", "Field150", "Field23", "Field24", "Field25", "Field15", "Field78", "Field67", "Field68", "Field128", "Field129", "Field131", }); + internal static readonly pbd::MessageDescriptor internal__static_proto2_benchmark_v2_api_Message2__Descriptor + = Descriptor.MessageTypes[1]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_proto2_benchmark_v2_api_Message2__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_proto2_benchmark_v2_api_Message2__Descriptor, + new string[] { "Field1", "Field2", "Field3", "Field15", "Field12", "Field13", "Field14", "Field16", "Field19", "Field20", "Field28", "Field21", "Field22", "Field23", "Field206", "Field203", "Field204", "Field205", "Field207", "Field300", }); + internal static readonly pbd::MessageDescriptor internal__static_proto2_benchmark_v2_api_Message3__Descriptor + = Descriptor.MessageTypes[2]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_proto2_benchmark_v2_api_Message3__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_proto2_benchmark_v2_api_Message3__Descriptor, + new string[] { "Field1", "Field3", "Field4", "Field30", "Field75", "Field6", "Field2", "Field21", "Field71", "Field25", "Field109", "Field210", "Field211", "Field212", "Field213", "Field216", "Field217", "Field218", "Field220", "Field221", "Field222", "Field63", "Group1", "Field128", "Field131", "Field127", "Field129", "Field130", "Field205", "Field206", }); + internal static readonly pbd::MessageDescriptor internal__static_proto2_benchmark_v2_api_Message3_Group1__Descriptor + = internal__static_proto2_benchmark_v2_api_Message3__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_proto2_benchmark_v2_api_Message3_Group1__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_proto2_benchmark_v2_api_Message3_Group1__Descriptor, + new string[] { "Field11", "Field26", "Field12", "Field13", "Field14", "Field15", "Field5", "Field27", "Field28", "Field29", "Field16", "Field22", "Field73", "Field20", "Field24", "Field31", }); + internal static readonly pbd::MessageDescriptor internal__static_proto2_benchmark_v2_api_Message4__Descriptor + = Descriptor.MessageTypes[3]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_proto2_benchmark_v2_api_Message4__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_proto2_benchmark_v2_api_Message4__Descriptor, + new string[] { "Field1", "Field2", "Field3", "Field4", "Field5", "Field6", "Field7", "Field8", "Field9", "Field10", "Field11", }); + #endregion + } + #region Messages + public sealed partial class Message1 : pb::GeneratedMessage { + private static readonly Message1 defaultInstance = new Builder().BuildPartial(); + public static Message1 DefaultInstance { + get { return defaultInstance; } + } + + public override Message1 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Message1 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message1__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message1__FieldAccessorTable; } + } + + private bool hasField1; + private string field1_ = ""; + public bool HasField1 { + get { return hasField1; } + } + public string Field1 { + get { return field1_; } + } + + private bool hasField9; + private string field9_ = ""; + public bool HasField9 { + get { return hasField9; } + } + public string Field9 { + get { return field9_; } + } + + private bool hasField18; + private string field18_ = ""; + public bool HasField18 { + get { return hasField18; } + } + public string Field18 { + get { return field18_; } + } + + private bool hasField80; + private bool field80_ = false; + public bool HasField80 { + get { return hasField80; } + } + public bool Field80 { + get { return field80_; } + } + + private bool hasField81; + private bool field81_ = true; + public bool HasField81 { + get { return hasField81; } + } + public bool Field81 { + get { return field81_; } + } + + private bool hasField2; + private int field2_ = 0; + public bool HasField2 { + get { return hasField2; } + } + public int Field2 { + get { return field2_; } + } + + private bool hasField3; + private int field3_ = 0; + public bool HasField3 { + get { return hasField3; } + } + public int Field3 { + get { return field3_; } + } + + private bool hasField280; + private int field280_ = 0; + public bool HasField280 { + get { return hasField280; } + } + public int Field280 { + get { return field280_; } + } + + private bool hasField6; + private int field6_ = 0; + public bool HasField6 { + get { return hasField6; } + } + public int Field6 { + get { return field6_; } + } + + private bool hasField22; + private long field22_ = 0L; + public bool HasField22 { + get { return hasField22; } + } + public long Field22 { + get { return field22_; } + } + + private bool hasField4; + private string field4_ = ""; + public bool HasField4 { + get { return hasField4; } + } + public string Field4 { + get { return field4_; } + } + + private pbc::PopsicleList field5_ = new pbc::PopsicleList(); + public scg::IList Field5List { + get { return pbc::Lists.AsReadOnly(field5_); } + } + public int Field5Count { + get { return field5_.Count; } + } + public ulong GetField5(int index) { + return field5_[index]; + } + + private bool hasField59; + private bool field59_ = false; + public bool HasField59 { + get { return hasField59; } + } + public bool Field59 { + get { return field59_; } + } + + private bool hasField7; + private string field7_ = ""; + public bool HasField7 { + get { return hasField7; } + } + public string Field7 { + get { return field7_; } + } + + private bool hasField16; + private int field16_ = 0; + public bool HasField16 { + get { return hasField16; } + } + public int Field16 { + get { return field16_; } + } + + private bool hasField130; + private int field130_ = 0; + public bool HasField130 { + get { return hasField130; } + } + public int Field130 { + get { return field130_; } + } + + private bool hasField12; + private bool field12_ = true; + public bool HasField12 { + get { return hasField12; } + } + public bool Field12 { + get { return field12_; } + } + + private bool hasField17; + private bool field17_ = true; + public bool HasField17 { + get { return hasField17; } + } + public bool Field17 { + get { return field17_; } + } + + private bool hasField13; + private bool field13_ = true; + public bool HasField13 { + get { return hasField13; } + } + public bool Field13 { + get { return field13_; } + } + + private bool hasField14; + private bool field14_ = true; + public bool HasField14 { + get { return hasField14; } + } + public bool Field14 { + get { return field14_; } + } + + private bool hasField104; + private int field104_ = 0; + public bool HasField104 { + get { return hasField104; } + } + public int Field104 { + get { return field104_; } + } + + private bool hasField100; + private int field100_ = 0; + public bool HasField100 { + get { return hasField100; } + } + public int Field100 { + get { return field100_; } + } + + private bool hasField101; + private int field101_ = 0; + public bool HasField101 { + get { return hasField101; } + } + public int Field101 { + get { return field101_; } + } + + private bool hasField102; + private string field102_ = ""; + public bool HasField102 { + get { return hasField102; } + } + public string Field102 { + get { return field102_; } + } + + private bool hasField103; + private string field103_ = ""; + public bool HasField103 { + get { return hasField103; } + } + public string Field103 { + get { return field103_; } + } + + private bool hasField29; + private int field29_ = 0; + public bool HasField29 { + get { return hasField29; } + } + public int Field29 { + get { return field29_; } + } + + private bool hasField30; + private bool field30_ = false; + public bool HasField30 { + get { return hasField30; } + } + public bool Field30 { + get { return field30_; } + } + + private bool hasField60; + private int field60_ = -1; + public bool HasField60 { + get { return hasField60; } + } + public int Field60 { + get { return field60_; } + } + + private bool hasField271; + private int field271_ = -1; + public bool HasField271 { + get { return hasField271; } + } + public int Field271 { + get { return field271_; } + } + + private bool hasField272; + private int field272_ = -1; + public bool HasField272 { + get { return hasField272; } + } + public int Field272 { + get { return field272_; } + } + + private bool hasField150; + private int field150_ = 0; + public bool HasField150 { + get { return hasField150; } + } + public int Field150 { + get { return field150_; } + } + + private bool hasField23; + private int field23_ = 0; + public bool HasField23 { + get { return hasField23; } + } + public int Field23 { + get { return field23_; } + } + + private bool hasField24; + private bool field24_ = false; + public bool HasField24 { + get { return hasField24; } + } + public bool Field24 { + get { return field24_; } + } + + private bool hasField25; + private int field25_ = 0; + public bool HasField25 { + get { return hasField25; } + } + public int Field25 { + get { return field25_; } + } + + private bool hasField15; + private global::Google.ProtocolBuffers.BenchmarkProtos.Message2 field15_ = global::Google.ProtocolBuffers.BenchmarkProtos.Message2.DefaultInstance; + public bool HasField15 { + get { return hasField15; } + } + public global::Google.ProtocolBuffers.BenchmarkProtos.Message2 Field15 { + get { return field15_; } + } + + private bool hasField78; + private bool field78_ = false; + public bool HasField78 { + get { return hasField78; } + } + public bool Field78 { + get { return field78_; } + } + + private bool hasField67; + private int field67_ = 0; + public bool HasField67 { + get { return hasField67; } + } + public int Field67 { + get { return field67_; } + } + + private bool hasField68; + private int field68_ = 0; + public bool HasField68 { + get { return hasField68; } + } + public int Field68 { + get { return field68_; } + } + + private bool hasField128; + private int field128_ = 0; + public bool HasField128 { + get { return hasField128; } + } + public int Field128 { + get { return field128_; } + } + + private bool hasField129; + private string field129_ = "xxxxxxxxxxxxxxxxxxxxx"; + public bool HasField129 { + get { return hasField129; } + } + public string Field129 { + get { return field129_; } + } + + private bool hasField131; + private int field131_ = 0; + public bool HasField131 { + get { return hasField131; } + } + public int Field131 { + get { return field131_; } + } + + public override bool IsInitialized { + get { + if (!hasField1) return false; + if (!hasField2) return false; + if (!hasField3) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasField1) { + output.WriteString(1, Field1); + } + if (HasField2) { + output.WriteInt32(2, Field2); + } + if (HasField3) { + output.WriteInt32(3, Field3); + } + if (HasField4) { + output.WriteString(4, Field4); + } + foreach (ulong element in Field5List) { + output.WriteFixed64(5, element); + } + if (HasField6) { + output.WriteInt32(6, Field6); + } + if (HasField7) { + output.WriteString(7, Field7); + } + if (HasField9) { + output.WriteString(9, Field9); + } + if (HasField12) { + output.WriteBool(12, Field12); + } + if (HasField13) { + output.WriteBool(13, Field13); + } + if (HasField14) { + output.WriteBool(14, Field14); + } + if (HasField15) { + output.WriteMessage(15, Field15); + } + if (HasField16) { + output.WriteInt32(16, Field16); + } + if (HasField17) { + output.WriteBool(17, Field17); + } + if (HasField18) { + output.WriteString(18, Field18); + } + if (HasField22) { + output.WriteInt64(22, Field22); + } + if (HasField23) { + output.WriteInt32(23, Field23); + } + if (HasField24) { + output.WriteBool(24, Field24); + } + if (HasField25) { + output.WriteInt32(25, Field25); + } + if (HasField29) { + output.WriteInt32(29, Field29); + } + if (HasField30) { + output.WriteBool(30, Field30); + } + if (HasField59) { + output.WriteBool(59, Field59); + } + if (HasField60) { + output.WriteInt32(60, Field60); + } + if (HasField67) { + output.WriteInt32(67, Field67); + } + if (HasField68) { + output.WriteInt32(68, Field68); + } + if (HasField78) { + output.WriteBool(78, Field78); + } + if (HasField80) { + output.WriteBool(80, Field80); + } + if (HasField81) { + output.WriteBool(81, Field81); + } + if (HasField100) { + output.WriteInt32(100, Field100); + } + if (HasField101) { + output.WriteInt32(101, Field101); + } + if (HasField102) { + output.WriteString(102, Field102); + } + if (HasField103) { + output.WriteString(103, Field103); + } + if (HasField104) { + output.WriteInt32(104, Field104); + } + if (HasField128) { + output.WriteInt32(128, Field128); + } + if (HasField129) { + output.WriteString(129, Field129); + } + if (HasField130) { + output.WriteInt32(130, Field130); + } + if (HasField131) { + output.WriteInt32(131, Field131); + } + if (HasField150) { + output.WriteInt32(150, Field150); + } + if (HasField271) { + output.WriteInt32(271, Field271); + } + if (HasField272) { + output.WriteInt32(272, Field272); + } + if (HasField280) { + output.WriteInt32(280, Field280); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasField1) { + size += pb::CodedOutputStream.ComputeStringSize(1, Field1); + } + if (HasField9) { + size += pb::CodedOutputStream.ComputeStringSize(9, Field9); + } + if (HasField18) { + size += pb::CodedOutputStream.ComputeStringSize(18, Field18); + } + if (HasField80) { + size += pb::CodedOutputStream.ComputeBoolSize(80, Field80); + } + if (HasField81) { + size += pb::CodedOutputStream.ComputeBoolSize(81, Field81); + } + if (HasField2) { + size += pb::CodedOutputStream.ComputeInt32Size(2, Field2); + } + if (HasField3) { + size += pb::CodedOutputStream.ComputeInt32Size(3, Field3); + } + if (HasField280) { + size += pb::CodedOutputStream.ComputeInt32Size(280, Field280); + } + if (HasField6) { + size += pb::CodedOutputStream.ComputeInt32Size(6, Field6); + } + if (HasField22) { + size += pb::CodedOutputStream.ComputeInt64Size(22, Field22); + } + if (HasField4) { + size += pb::CodedOutputStream.ComputeStringSize(4, Field4); + } + foreach (ulong element in Field5List) { + size += pb::CodedOutputStream.ComputeFixed64Size(5, element); + } + if (HasField59) { + size += pb::CodedOutputStream.ComputeBoolSize(59, Field59); + } + if (HasField7) { + size += pb::CodedOutputStream.ComputeStringSize(7, Field7); + } + if (HasField16) { + size += pb::CodedOutputStream.ComputeInt32Size(16, Field16); + } + if (HasField130) { + size += pb::CodedOutputStream.ComputeInt32Size(130, Field130); + } + if (HasField12) { + size += pb::CodedOutputStream.ComputeBoolSize(12, Field12); + } + if (HasField17) { + size += pb::CodedOutputStream.ComputeBoolSize(17, Field17); + } + if (HasField13) { + size += pb::CodedOutputStream.ComputeBoolSize(13, Field13); + } + if (HasField14) { + size += pb::CodedOutputStream.ComputeBoolSize(14, Field14); + } + if (HasField104) { + size += pb::CodedOutputStream.ComputeInt32Size(104, Field104); + } + if (HasField100) { + size += pb::CodedOutputStream.ComputeInt32Size(100, Field100); + } + if (HasField101) { + size += pb::CodedOutputStream.ComputeInt32Size(101, Field101); + } + if (HasField102) { + size += pb::CodedOutputStream.ComputeStringSize(102, Field102); + } + if (HasField103) { + size += pb::CodedOutputStream.ComputeStringSize(103, Field103); + } + if (HasField29) { + size += pb::CodedOutputStream.ComputeInt32Size(29, Field29); + } + if (HasField30) { + size += pb::CodedOutputStream.ComputeBoolSize(30, Field30); + } + if (HasField60) { + size += pb::CodedOutputStream.ComputeInt32Size(60, Field60); + } + if (HasField271) { + size += pb::CodedOutputStream.ComputeInt32Size(271, Field271); + } + if (HasField272) { + size += pb::CodedOutputStream.ComputeInt32Size(272, Field272); + } + if (HasField150) { + size += pb::CodedOutputStream.ComputeInt32Size(150, Field150); + } + if (HasField23) { + size += pb::CodedOutputStream.ComputeInt32Size(23, Field23); + } + if (HasField24) { + size += pb::CodedOutputStream.ComputeBoolSize(24, Field24); + } + if (HasField25) { + size += pb::CodedOutputStream.ComputeInt32Size(25, Field25); + } + if (HasField15) { + size += pb::CodedOutputStream.ComputeMessageSize(15, Field15); + } + if (HasField78) { + size += pb::CodedOutputStream.ComputeBoolSize(78, Field78); + } + if (HasField67) { + size += pb::CodedOutputStream.ComputeInt32Size(67, Field67); + } + if (HasField68) { + size += pb::CodedOutputStream.ComputeInt32Size(68, Field68); + } + if (HasField128) { + size += pb::CodedOutputStream.ComputeInt32Size(128, Field128); + } + if (HasField129) { + size += pb::CodedOutputStream.ComputeStringSize(129, Field129); + } + if (HasField131) { + size += pb::CodedOutputStream.ComputeInt32Size(131, Field131); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Message1 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Message1 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Message1 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Message1 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Message1 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Message1 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Message1 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Message1 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Message1 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Message1 result = new Message1(); + + protected override Message1 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Message1(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return Message1.Descriptor; } + } + + public override Message1 DefaultInstanceForType { + get { return Message1.DefaultInstance; } + } + + public override Message1 BuildPartial() { + result.field5_.MakeReadOnly(); + Message1 returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Message1) { + return MergeFrom((Message1) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Message1 other) { + if (other == Message1.DefaultInstance) return this; + if (other.HasField1) { + Field1 = other.Field1; + } + if (other.HasField9) { + Field9 = other.Field9; + } + if (other.HasField18) { + Field18 = other.Field18; + } + if (other.HasField80) { + Field80 = other.Field80; + } + if (other.HasField81) { + Field81 = other.Field81; + } + if (other.HasField2) { + Field2 = other.Field2; + } + if (other.HasField3) { + Field3 = other.Field3; + } + if (other.HasField280) { + Field280 = other.Field280; + } + if (other.HasField6) { + Field6 = other.Field6; + } + if (other.HasField22) { + Field22 = other.Field22; + } + if (other.HasField4) { + Field4 = other.Field4; + } + if (other.field5_.Count != 0) { + base.AddRange(other.field5_, result.field5_); + } + if (other.HasField59) { + Field59 = other.Field59; + } + if (other.HasField7) { + Field7 = other.Field7; + } + if (other.HasField16) { + Field16 = other.Field16; + } + if (other.HasField130) { + Field130 = other.Field130; + } + if (other.HasField12) { + Field12 = other.Field12; + } + if (other.HasField17) { + Field17 = other.Field17; + } + if (other.HasField13) { + Field13 = other.Field13; + } + if (other.HasField14) { + Field14 = other.Field14; + } + if (other.HasField104) { + Field104 = other.Field104; + } + if (other.HasField100) { + Field100 = other.Field100; + } + if (other.HasField101) { + Field101 = other.Field101; + } + if (other.HasField102) { + Field102 = other.Field102; + } + if (other.HasField103) { + Field103 = other.Field103; + } + if (other.HasField29) { + Field29 = other.Field29; + } + if (other.HasField30) { + Field30 = other.Field30; + } + if (other.HasField60) { + Field60 = other.Field60; + } + if (other.HasField271) { + Field271 = other.Field271; + } + if (other.HasField272) { + Field272 = other.Field272; + } + if (other.HasField150) { + Field150 = other.Field150; + } + if (other.HasField23) { + Field23 = other.Field23; + } + if (other.HasField24) { + Field24 = other.Field24; + } + if (other.HasField25) { + Field25 = other.Field25; + } + if (other.HasField15) { + MergeField15(other.Field15); + } + if (other.HasField78) { + Field78 = other.Field78; + } + if (other.HasField67) { + Field67 = other.Field67; + } + if (other.HasField68) { + Field68 = other.Field68; + } + if (other.HasField128) { + Field128 = other.Field128; + } + if (other.HasField129) { + Field129 = other.Field129; + } + if (other.HasField131) { + Field131 = other.Field131; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + Field1 = input.ReadString(); + break; + } + case 16: { + Field2 = input.ReadInt32(); + break; + } + case 24: { + Field3 = input.ReadInt32(); + break; + } + case 34: { + Field4 = input.ReadString(); + break; + } + case 41: { + AddField5(input.ReadFixed64()); + break; + } + case 48: { + Field6 = input.ReadInt32(); + break; + } + case 58: { + Field7 = input.ReadString(); + break; + } + case 74: { + Field9 = input.ReadString(); + break; + } + case 96: { + Field12 = input.ReadBool(); + break; + } + case 104: { + Field13 = input.ReadBool(); + break; + } + case 112: { + Field14 = input.ReadBool(); + break; + } + case 122: { + global::Google.ProtocolBuffers.BenchmarkProtos.Message2.Builder subBuilder = global::Google.ProtocolBuffers.BenchmarkProtos.Message2.CreateBuilder(); + if (HasField15) { + subBuilder.MergeFrom(Field15); + } + input.ReadMessage(subBuilder, extensionRegistry); + Field15 = subBuilder.BuildPartial(); + break; + } + case 128: { + Field16 = input.ReadInt32(); + break; + } + case 136: { + Field17 = input.ReadBool(); + break; + } + case 146: { + Field18 = input.ReadString(); + break; + } + case 176: { + Field22 = input.ReadInt64(); + break; + } + case 184: { + Field23 = input.ReadInt32(); + break; + } + case 192: { + Field24 = input.ReadBool(); + break; + } + case 200: { + Field25 = input.ReadInt32(); + break; + } + case 232: { + Field29 = input.ReadInt32(); + break; + } + case 240: { + Field30 = input.ReadBool(); + break; + } + case 472: { + Field59 = input.ReadBool(); + break; + } + case 480: { + Field60 = input.ReadInt32(); + break; + } + case 536: { + Field67 = input.ReadInt32(); + break; + } + case 544: { + Field68 = input.ReadInt32(); + break; + } + case 624: { + Field78 = input.ReadBool(); + break; + } + case 640: { + Field80 = input.ReadBool(); + break; + } + case 648: { + Field81 = input.ReadBool(); + break; + } + case 800: { + Field100 = input.ReadInt32(); + break; + } + case 808: { + Field101 = input.ReadInt32(); + break; + } + case 818: { + Field102 = input.ReadString(); + break; + } + case 826: { + Field103 = input.ReadString(); + break; + } + case 832: { + Field104 = input.ReadInt32(); + break; + } + case 1024: { + Field128 = input.ReadInt32(); + break; + } + case 1034: { + Field129 = input.ReadString(); + break; + } + case 1040: { + Field130 = input.ReadInt32(); + break; + } + case 1048: { + Field131 = input.ReadInt32(); + break; + } + case 1200: { + Field150 = input.ReadInt32(); + break; + } + case 2168: { + Field271 = input.ReadInt32(); + break; + } + case 2176: { + Field272 = input.ReadInt32(); + break; + } + case 2240: { + Field280 = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasField1 { + get { return result.HasField1; } + } + public string Field1 { + get { return result.Field1; } + set { SetField1(value); } + } + public Builder SetField1(string value) { + result.hasField1 = true; + result.field1_ = value; + return this; + } + public Builder ClearField1() { + result.hasField1 = false; + result.field1_ = ""; + return this; + } + + public bool HasField9 { + get { return result.HasField9; } + } + public string Field9 { + get { return result.Field9; } + set { SetField9(value); } + } + public Builder SetField9(string value) { + result.hasField9 = true; + result.field9_ = value; + return this; + } + public Builder ClearField9() { + result.hasField9 = false; + result.field9_ = ""; + return this; + } + + public bool HasField18 { + get { return result.HasField18; } + } + public string Field18 { + get { return result.Field18; } + set { SetField18(value); } + } + public Builder SetField18(string value) { + result.hasField18 = true; + result.field18_ = value; + return this; + } + public Builder ClearField18() { + result.hasField18 = false; + result.field18_ = ""; + return this; + } + + public bool HasField80 { + get { return result.HasField80; } + } + public bool Field80 { + get { return result.Field80; } + set { SetField80(value); } + } + public Builder SetField80(bool value) { + result.hasField80 = true; + result.field80_ = value; + return this; + } + public Builder ClearField80() { + result.hasField80 = false; + result.field80_ = false; + return this; + } + + public bool HasField81 { + get { return result.HasField81; } + } + public bool Field81 { + get { return result.Field81; } + set { SetField81(value); } + } + public Builder SetField81(bool value) { + result.hasField81 = true; + result.field81_ = value; + return this; + } + public Builder ClearField81() { + result.hasField81 = false; + result.field81_ = true; + return this; + } + + public bool HasField2 { + get { return result.HasField2; } + } + public int Field2 { + get { return result.Field2; } + set { SetField2(value); } + } + public Builder SetField2(int value) { + result.hasField2 = true; + result.field2_ = value; + return this; + } + public Builder ClearField2() { + result.hasField2 = false; + result.field2_ = 0; + return this; + } + + public bool HasField3 { + get { return result.HasField3; } + } + public int Field3 { + get { return result.Field3; } + set { SetField3(value); } + } + public Builder SetField3(int value) { + result.hasField3 = true; + result.field3_ = value; + return this; + } + public Builder ClearField3() { + result.hasField3 = false; + result.field3_ = 0; + return this; + } + + public bool HasField280 { + get { return result.HasField280; } + } + public int Field280 { + get { return result.Field280; } + set { SetField280(value); } + } + public Builder SetField280(int value) { + result.hasField280 = true; + result.field280_ = value; + return this; + } + public Builder ClearField280() { + result.hasField280 = false; + result.field280_ = 0; + return this; + } + + public bool HasField6 { + get { return result.HasField6; } + } + public int Field6 { + get { return result.Field6; } + set { SetField6(value); } + } + public Builder SetField6(int value) { + result.hasField6 = true; + result.field6_ = value; + return this; + } + public Builder ClearField6() { + result.hasField6 = false; + result.field6_ = 0; + return this; + } + + public bool HasField22 { + get { return result.HasField22; } + } + public long Field22 { + get { return result.Field22; } + set { SetField22(value); } + } + public Builder SetField22(long value) { + result.hasField22 = true; + result.field22_ = value; + return this; + } + public Builder ClearField22() { + result.hasField22 = false; + result.field22_ = 0L; + return this; + } + + public bool HasField4 { + get { return result.HasField4; } + } + public string Field4 { + get { return result.Field4; } + set { SetField4(value); } + } + public Builder SetField4(string value) { + result.hasField4 = true; + result.field4_ = value; + return this; + } + public Builder ClearField4() { + result.hasField4 = false; + result.field4_ = ""; + return this; + } + + public scg::IList Field5List { + get { return result.field5_; } + } + public int Field5Count { + get { return result.Field5Count; } + } + public ulong GetField5(int index) { + return result.GetField5(index); + } + public Builder SetField5(int index, ulong value) { + result.field5_[index] = value; + return this; + } + public Builder AddField5(ulong value) { + result.field5_.Add(value); + return this; + } + public Builder AddRangeField5(scg::IEnumerable values) { + base.AddRange(values, result.field5_); + return this; + } + public Builder ClearField5() { + result.field5_.Clear(); + return this; + } + + public bool HasField59 { + get { return result.HasField59; } + } + public bool Field59 { + get { return result.Field59; } + set { SetField59(value); } + } + public Builder SetField59(bool value) { + result.hasField59 = true; + result.field59_ = value; + return this; + } + public Builder ClearField59() { + result.hasField59 = false; + result.field59_ = false; + return this; + } + + public bool HasField7 { + get { return result.HasField7; } + } + public string Field7 { + get { return result.Field7; } + set { SetField7(value); } + } + public Builder SetField7(string value) { + result.hasField7 = true; + result.field7_ = value; + return this; + } + public Builder ClearField7() { + result.hasField7 = false; + result.field7_ = ""; + return this; + } + + public bool HasField16 { + get { return result.HasField16; } + } + public int Field16 { + get { return result.Field16; } + set { SetField16(value); } + } + public Builder SetField16(int value) { + result.hasField16 = true; + result.field16_ = value; + return this; + } + public Builder ClearField16() { + result.hasField16 = false; + result.field16_ = 0; + return this; + } + + public bool HasField130 { + get { return result.HasField130; } + } + public int Field130 { + get { return result.Field130; } + set { SetField130(value); } + } + public Builder SetField130(int value) { + result.hasField130 = true; + result.field130_ = value; + return this; + } + public Builder ClearField130() { + result.hasField130 = false; + result.field130_ = 0; + return this; + } + + public bool HasField12 { + get { return result.HasField12; } + } + public bool Field12 { + get { return result.Field12; } + set { SetField12(value); } + } + public Builder SetField12(bool value) { + result.hasField12 = true; + result.field12_ = value; + return this; + } + public Builder ClearField12() { + result.hasField12 = false; + result.field12_ = true; + return this; + } + + public bool HasField17 { + get { return result.HasField17; } + } + public bool Field17 { + get { return result.Field17; } + set { SetField17(value); } + } + public Builder SetField17(bool value) { + result.hasField17 = true; + result.field17_ = value; + return this; + } + public Builder ClearField17() { + result.hasField17 = false; + result.field17_ = true; + return this; + } + + public bool HasField13 { + get { return result.HasField13; } + } + public bool Field13 { + get { return result.Field13; } + set { SetField13(value); } + } + public Builder SetField13(bool value) { + result.hasField13 = true; + result.field13_ = value; + return this; + } + public Builder ClearField13() { + result.hasField13 = false; + result.field13_ = true; + return this; + } + + public bool HasField14 { + get { return result.HasField14; } + } + public bool Field14 { + get { return result.Field14; } + set { SetField14(value); } + } + public Builder SetField14(bool value) { + result.hasField14 = true; + result.field14_ = value; + return this; + } + public Builder ClearField14() { + result.hasField14 = false; + result.field14_ = true; + return this; + } + + public bool HasField104 { + get { return result.HasField104; } + } + public int Field104 { + get { return result.Field104; } + set { SetField104(value); } + } + public Builder SetField104(int value) { + result.hasField104 = true; + result.field104_ = value; + return this; + } + public Builder ClearField104() { + result.hasField104 = false; + result.field104_ = 0; + return this; + } + + public bool HasField100 { + get { return result.HasField100; } + } + public int Field100 { + get { return result.Field100; } + set { SetField100(value); } + } + public Builder SetField100(int value) { + result.hasField100 = true; + result.field100_ = value; + return this; + } + public Builder ClearField100() { + result.hasField100 = false; + result.field100_ = 0; + return this; + } + + public bool HasField101 { + get { return result.HasField101; } + } + public int Field101 { + get { return result.Field101; } + set { SetField101(value); } + } + public Builder SetField101(int value) { + result.hasField101 = true; + result.field101_ = value; + return this; + } + public Builder ClearField101() { + result.hasField101 = false; + result.field101_ = 0; + return this; + } + + public bool HasField102 { + get { return result.HasField102; } + } + public string Field102 { + get { return result.Field102; } + set { SetField102(value); } + } + public Builder SetField102(string value) { + result.hasField102 = true; + result.field102_ = value; + return this; + } + public Builder ClearField102() { + result.hasField102 = false; + result.field102_ = ""; + return this; + } + + public bool HasField103 { + get { return result.HasField103; } + } + public string Field103 { + get { return result.Field103; } + set { SetField103(value); } + } + public Builder SetField103(string value) { + result.hasField103 = true; + result.field103_ = value; + return this; + } + public Builder ClearField103() { + result.hasField103 = false; + result.field103_ = ""; + return this; + } + + public bool HasField29 { + get { return result.HasField29; } + } + public int Field29 { + get { return result.Field29; } + set { SetField29(value); } + } + public Builder SetField29(int value) { + result.hasField29 = true; + result.field29_ = value; + return this; + } + public Builder ClearField29() { + result.hasField29 = false; + result.field29_ = 0; + return this; + } + + public bool HasField30 { + get { return result.HasField30; } + } + public bool Field30 { + get { return result.Field30; } + set { SetField30(value); } + } + public Builder SetField30(bool value) { + result.hasField30 = true; + result.field30_ = value; + return this; + } + public Builder ClearField30() { + result.hasField30 = false; + result.field30_ = false; + return this; + } + + public bool HasField60 { + get { return result.HasField60; } + } + public int Field60 { + get { return result.Field60; } + set { SetField60(value); } + } + public Builder SetField60(int value) { + result.hasField60 = true; + result.field60_ = value; + return this; + } + public Builder ClearField60() { + result.hasField60 = false; + result.field60_ = -1; + return this; + } + + public bool HasField271 { + get { return result.HasField271; } + } + public int Field271 { + get { return result.Field271; } + set { SetField271(value); } + } + public Builder SetField271(int value) { + result.hasField271 = true; + result.field271_ = value; + return this; + } + public Builder ClearField271() { + result.hasField271 = false; + result.field271_ = -1; + return this; + } + + public bool HasField272 { + get { return result.HasField272; } + } + public int Field272 { + get { return result.Field272; } + set { SetField272(value); } + } + public Builder SetField272(int value) { + result.hasField272 = true; + result.field272_ = value; + return this; + } + public Builder ClearField272() { + result.hasField272 = false; + result.field272_ = -1; + return this; + } + + public bool HasField150 { + get { return result.HasField150; } + } + public int Field150 { + get { return result.Field150; } + set { SetField150(value); } + } + public Builder SetField150(int value) { + result.hasField150 = true; + result.field150_ = value; + return this; + } + public Builder ClearField150() { + result.hasField150 = false; + result.field150_ = 0; + return this; + } + + public bool HasField23 { + get { return result.HasField23; } + } + public int Field23 { + get { return result.Field23; } + set { SetField23(value); } + } + public Builder SetField23(int value) { + result.hasField23 = true; + result.field23_ = value; + return this; + } + public Builder ClearField23() { + result.hasField23 = false; + result.field23_ = 0; + return this; + } + + public bool HasField24 { + get { return result.HasField24; } + } + public bool Field24 { + get { return result.Field24; } + set { SetField24(value); } + } + public Builder SetField24(bool value) { + result.hasField24 = true; + result.field24_ = value; + return this; + } + public Builder ClearField24() { + result.hasField24 = false; + result.field24_ = false; + return this; + } + + public bool HasField25 { + get { return result.HasField25; } + } + public int Field25 { + get { return result.Field25; } + set { SetField25(value); } + } + public Builder SetField25(int value) { + result.hasField25 = true; + result.field25_ = value; + return this; + } + public Builder ClearField25() { + result.hasField25 = false; + result.field25_ = 0; + return this; + } + + public bool HasField15 { + get { return result.HasField15; } + } + public global::Google.ProtocolBuffers.BenchmarkProtos.Message2 Field15 { + get { return result.Field15; } + set { SetField15(value); } + } + public Builder SetField15(global::Google.ProtocolBuffers.BenchmarkProtos.Message2 value) { + result.hasField15 = true; + result.field15_ = value; + return this; + } + public Builder SetField15(global::Google.ProtocolBuffers.BenchmarkProtos.Message2.Builder builderForValue) { + result.hasField15 = true; + result.field15_ = builderForValue.Build(); + return this; + } + public Builder MergeField15(global::Google.ProtocolBuffers.BenchmarkProtos.Message2 value) { + if (result.HasField15 && + result.field15_ != global::Google.ProtocolBuffers.BenchmarkProtos.Message2.DefaultInstance) { + result.field15_ = global::Google.ProtocolBuffers.BenchmarkProtos.Message2.CreateBuilder(result.field15_).MergeFrom(value).BuildPartial(); + } else { + result.field15_ = value; + } + result.hasField15 = true; + return this; + } + public Builder ClearField15() { + result.hasField15 = false; + result.field15_ = global::Google.ProtocolBuffers.BenchmarkProtos.Message2.DefaultInstance; + return this; + } + + public bool HasField78 { + get { return result.HasField78; } + } + public bool Field78 { + get { return result.Field78; } + set { SetField78(value); } + } + public Builder SetField78(bool value) { + result.hasField78 = true; + result.field78_ = value; + return this; + } + public Builder ClearField78() { + result.hasField78 = false; + result.field78_ = false; + return this; + } + + public bool HasField67 { + get { return result.HasField67; } + } + public int Field67 { + get { return result.Field67; } + set { SetField67(value); } + } + public Builder SetField67(int value) { + result.hasField67 = true; + result.field67_ = value; + return this; + } + public Builder ClearField67() { + result.hasField67 = false; + result.field67_ = 0; + return this; + } + + public bool HasField68 { + get { return result.HasField68; } + } + public int Field68 { + get { return result.Field68; } + set { SetField68(value); } + } + public Builder SetField68(int value) { + result.hasField68 = true; + result.field68_ = value; + return this; + } + public Builder ClearField68() { + result.hasField68 = false; + result.field68_ = 0; + return this; + } + + public bool HasField128 { + get { return result.HasField128; } + } + public int Field128 { + get { return result.Field128; } + set { SetField128(value); } + } + public Builder SetField128(int value) { + result.hasField128 = true; + result.field128_ = value; + return this; + } + public Builder ClearField128() { + result.hasField128 = false; + result.field128_ = 0; + return this; + } + + public bool HasField129 { + get { return result.HasField129; } + } + public string Field129 { + get { return result.Field129; } + set { SetField129(value); } + } + public Builder SetField129(string value) { + result.hasField129 = true; + result.field129_ = value; + return this; + } + public Builder ClearField129() { + result.hasField129 = false; + result.field129_ = "xxxxxxxxxxxxxxxxxxxxx"; + return this; + } + + public bool HasField131 { + get { return result.HasField131; } + } + public int Field131 { + get { return result.Field131; } + set { SetField131(value); } + } + public Builder SetField131(int value) { + result.hasField131 = true; + result.field131_ = value; + return this; + } + public Builder ClearField131() { + result.hasField131 = false; + result.field131_ = 0; + return this; + } + } + } + + public sealed partial class Message2 : pb::GeneratedMessage { + private static readonly Message2 defaultInstance = new Builder().BuildPartial(); + public static Message2 DefaultInstance { + get { return defaultInstance; } + } + + public override Message2 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Message2 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message2__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message2__FieldAccessorTable; } + } + + private bool hasField1; + private int field1_ = 0; + public bool HasField1 { + get { return hasField1; } + } + public int Field1 { + get { return field1_; } + } + + private bool hasField2; + private int field2_ = 0; + public bool HasField2 { + get { return hasField2; } + } + public int Field2 { + get { return field2_; } + } + + private bool hasField3; + private int field3_ = 0; + public bool HasField3 { + get { return hasField3; } + } + public int Field3 { + get { return field3_; } + } + + private bool hasField15; + private string field15_ = ""; + public bool HasField15 { + get { return hasField15; } + } + public string Field15 { + get { return field15_; } + } + + private bool hasField12; + private bool field12_ = true; + public bool HasField12 { + get { return hasField12; } + } + public bool Field12 { + get { return field12_; } + } + + private bool hasField13; + private long field13_ = 0L; + public bool HasField13 { + get { return hasField13; } + } + public long Field13 { + get { return field13_; } + } + + private bool hasField14; + private long field14_ = 0L; + public bool HasField14 { + get { return hasField14; } + } + public long Field14 { + get { return field14_; } + } + + private bool hasField16; + private int field16_ = 0; + public bool HasField16 { + get { return hasField16; } + } + public int Field16 { + get { return field16_; } + } + + private bool hasField19; + private int field19_ = 2; + public bool HasField19 { + get { return hasField19; } + } + public int Field19 { + get { return field19_; } + } + + private bool hasField20; + private bool field20_ = true; + public bool HasField20 { + get { return hasField20; } + } + public bool Field20 { + get { return field20_; } + } + + private bool hasField28; + private bool field28_ = true; + public bool HasField28 { + get { return hasField28; } + } + public bool Field28 { + get { return field28_; } + } + + private bool hasField21; + private ulong field21_ = 0; + public bool HasField21 { + get { return hasField21; } + } + public ulong Field21 { + get { return field21_; } + } + + private bool hasField22; + private int field22_ = 0; + public bool HasField22 { + get { return hasField22; } + } + public int Field22 { + get { return field22_; } + } + + private bool hasField23; + private bool field23_ = false; + public bool HasField23 { + get { return hasField23; } + } + public bool Field23 { + get { return field23_; } + } + + private bool hasField206; + private bool field206_ = false; + public bool HasField206 { + get { return hasField206; } + } + public bool Field206 { + get { return field206_; } + } + + private bool hasField203; + private uint field203_ = 0; + public bool HasField203 { + get { return hasField203; } + } + public uint Field203 { + get { return field203_; } + } + + private bool hasField204; + private int field204_ = 0; + public bool HasField204 { + get { return hasField204; } + } + public int Field204 { + get { return field204_; } + } + + private bool hasField205; + private string field205_ = ""; + public bool HasField205 { + get { return hasField205; } + } + public string Field205 { + get { return field205_; } + } + + private bool hasField207; + private ulong field207_ = 0UL; + public bool HasField207 { + get { return hasField207; } + } + public ulong Field207 { + get { return field207_; } + } + + private bool hasField300; + private ulong field300_ = 0UL; + public bool HasField300 { + get { return hasField300; } + } + public ulong Field300 { + get { return field300_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasField1) { + output.WriteInt32(1, Field1); + } + if (HasField2) { + output.WriteInt32(2, Field2); + } + if (HasField3) { + output.WriteInt32(3, Field3); + } + if (HasField12) { + output.WriteBool(12, Field12); + } + if (HasField13) { + output.WriteInt64(13, Field13); + } + if (HasField14) { + output.WriteInt64(14, Field14); + } + if (HasField15) { + output.WriteString(15, Field15); + } + if (HasField16) { + output.WriteInt32(16, Field16); + } + if (HasField19) { + output.WriteInt32(19, Field19); + } + if (HasField20) { + output.WriteBool(20, Field20); + } + if (HasField21) { + output.WriteFixed64(21, Field21); + } + if (HasField22) { + output.WriteInt32(22, Field22); + } + if (HasField23) { + output.WriteBool(23, Field23); + } + if (HasField28) { + output.WriteBool(28, Field28); + } + if (HasField203) { + output.WriteFixed32(203, Field203); + } + if (HasField204) { + output.WriteInt32(204, Field204); + } + if (HasField205) { + output.WriteString(205, Field205); + } + if (HasField206) { + output.WriteBool(206, Field206); + } + if (HasField207) { + output.WriteUInt64(207, Field207); + } + if (HasField300) { + output.WriteUInt64(300, Field300); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasField1) { + size += pb::CodedOutputStream.ComputeInt32Size(1, Field1); + } + if (HasField2) { + size += pb::CodedOutputStream.ComputeInt32Size(2, Field2); + } + if (HasField3) { + size += pb::CodedOutputStream.ComputeInt32Size(3, Field3); + } + if (HasField15) { + size += pb::CodedOutputStream.ComputeStringSize(15, Field15); + } + if (HasField12) { + size += pb::CodedOutputStream.ComputeBoolSize(12, Field12); + } + if (HasField13) { + size += pb::CodedOutputStream.ComputeInt64Size(13, Field13); + } + if (HasField14) { + size += pb::CodedOutputStream.ComputeInt64Size(14, Field14); + } + if (HasField16) { + size += pb::CodedOutputStream.ComputeInt32Size(16, Field16); + } + if (HasField19) { + size += pb::CodedOutputStream.ComputeInt32Size(19, Field19); + } + if (HasField20) { + size += pb::CodedOutputStream.ComputeBoolSize(20, Field20); + } + if (HasField28) { + size += pb::CodedOutputStream.ComputeBoolSize(28, Field28); + } + if (HasField21) { + size += pb::CodedOutputStream.ComputeFixed64Size(21, Field21); + } + if (HasField22) { + size += pb::CodedOutputStream.ComputeInt32Size(22, Field22); + } + if (HasField23) { + size += pb::CodedOutputStream.ComputeBoolSize(23, Field23); + } + if (HasField206) { + size += pb::CodedOutputStream.ComputeBoolSize(206, Field206); + } + if (HasField203) { + size += pb::CodedOutputStream.ComputeFixed32Size(203, Field203); + } + if (HasField204) { + size += pb::CodedOutputStream.ComputeInt32Size(204, Field204); + } + if (HasField205) { + size += pb::CodedOutputStream.ComputeStringSize(205, Field205); + } + if (HasField207) { + size += pb::CodedOutputStream.ComputeUInt64Size(207, Field207); + } + if (HasField300) { + size += pb::CodedOutputStream.ComputeUInt64Size(300, Field300); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Message2 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Message2 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Message2 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Message2 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Message2 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Message2 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Message2 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Message2 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Message2 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Message2 result = new Message2(); + + protected override Message2 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Message2(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return Message2.Descriptor; } + } + + public override Message2 DefaultInstanceForType { + get { return Message2.DefaultInstance; } + } + + public override Message2 BuildPartial() { + Message2 returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Message2) { + return MergeFrom((Message2) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Message2 other) { + if (other == Message2.DefaultInstance) return this; + if (other.HasField1) { + Field1 = other.Field1; + } + if (other.HasField2) { + Field2 = other.Field2; + } + if (other.HasField3) { + Field3 = other.Field3; + } + if (other.HasField15) { + Field15 = other.Field15; + } + if (other.HasField12) { + Field12 = other.Field12; + } + if (other.HasField13) { + Field13 = other.Field13; + } + if (other.HasField14) { + Field14 = other.Field14; + } + if (other.HasField16) { + Field16 = other.Field16; + } + if (other.HasField19) { + Field19 = other.Field19; + } + if (other.HasField20) { + Field20 = other.Field20; + } + if (other.HasField28) { + Field28 = other.Field28; + } + if (other.HasField21) { + Field21 = other.Field21; + } + if (other.HasField22) { + Field22 = other.Field22; + } + if (other.HasField23) { + Field23 = other.Field23; + } + if (other.HasField206) { + Field206 = other.Field206; + } + if (other.HasField203) { + Field203 = other.Field203; + } + if (other.HasField204) { + Field204 = other.Field204; + } + if (other.HasField205) { + Field205 = other.Field205; + } + if (other.HasField207) { + Field207 = other.Field207; + } + if (other.HasField300) { + Field300 = other.Field300; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + Field1 = input.ReadInt32(); + break; + } + case 16: { + Field2 = input.ReadInt32(); + break; + } + case 24: { + Field3 = input.ReadInt32(); + break; + } + case 96: { + Field12 = input.ReadBool(); + break; + } + case 104: { + Field13 = input.ReadInt64(); + break; + } + case 112: { + Field14 = input.ReadInt64(); + break; + } + case 122: { + Field15 = input.ReadString(); + break; + } + case 128: { + Field16 = input.ReadInt32(); + break; + } + case 152: { + Field19 = input.ReadInt32(); + break; + } + case 160: { + Field20 = input.ReadBool(); + break; + } + case 169: { + Field21 = input.ReadFixed64(); + break; + } + case 176: { + Field22 = input.ReadInt32(); + break; + } + case 184: { + Field23 = input.ReadBool(); + break; + } + case 224: { + Field28 = input.ReadBool(); + break; + } + case 1629: { + Field203 = input.ReadFixed32(); + break; + } + case 1632: { + Field204 = input.ReadInt32(); + break; + } + case 1642: { + Field205 = input.ReadString(); + break; + } + case 1648: { + Field206 = input.ReadBool(); + break; + } + case 1656: { + Field207 = input.ReadUInt64(); + break; + } + case 2400: { + Field300 = input.ReadUInt64(); + break; + } + } + } + } + + + public bool HasField1 { + get { return result.HasField1; } + } + public int Field1 { + get { return result.Field1; } + set { SetField1(value); } + } + public Builder SetField1(int value) { + result.hasField1 = true; + result.field1_ = value; + return this; + } + public Builder ClearField1() { + result.hasField1 = false; + result.field1_ = 0; + return this; + } + + public bool HasField2 { + get { return result.HasField2; } + } + public int Field2 { + get { return result.Field2; } + set { SetField2(value); } + } + public Builder SetField2(int value) { + result.hasField2 = true; + result.field2_ = value; + return this; + } + public Builder ClearField2() { + result.hasField2 = false; + result.field2_ = 0; + return this; + } + + public bool HasField3 { + get { return result.HasField3; } + } + public int Field3 { + get { return result.Field3; } + set { SetField3(value); } + } + public Builder SetField3(int value) { + result.hasField3 = true; + result.field3_ = value; + return this; + } + public Builder ClearField3() { + result.hasField3 = false; + result.field3_ = 0; + return this; + } + + public bool HasField15 { + get { return result.HasField15; } + } + public string Field15 { + get { return result.Field15; } + set { SetField15(value); } + } + public Builder SetField15(string value) { + result.hasField15 = true; + result.field15_ = value; + return this; + } + public Builder ClearField15() { + result.hasField15 = false; + result.field15_ = ""; + return this; + } + + public bool HasField12 { + get { return result.HasField12; } + } + public bool Field12 { + get { return result.Field12; } + set { SetField12(value); } + } + public Builder SetField12(bool value) { + result.hasField12 = true; + result.field12_ = value; + return this; + } + public Builder ClearField12() { + result.hasField12 = false; + result.field12_ = true; + return this; + } + + public bool HasField13 { + get { return result.HasField13; } + } + public long Field13 { + get { return result.Field13; } + set { SetField13(value); } + } + public Builder SetField13(long value) { + result.hasField13 = true; + result.field13_ = value; + return this; + } + public Builder ClearField13() { + result.hasField13 = false; + result.field13_ = 0L; + return this; + } + + public bool HasField14 { + get { return result.HasField14; } + } + public long Field14 { + get { return result.Field14; } + set { SetField14(value); } + } + public Builder SetField14(long value) { + result.hasField14 = true; + result.field14_ = value; + return this; + } + public Builder ClearField14() { + result.hasField14 = false; + result.field14_ = 0L; + return this; + } + + public bool HasField16 { + get { return result.HasField16; } + } + public int Field16 { + get { return result.Field16; } + set { SetField16(value); } + } + public Builder SetField16(int value) { + result.hasField16 = true; + result.field16_ = value; + return this; + } + public Builder ClearField16() { + result.hasField16 = false; + result.field16_ = 0; + return this; + } + + public bool HasField19 { + get { return result.HasField19; } + } + public int Field19 { + get { return result.Field19; } + set { SetField19(value); } + } + public Builder SetField19(int value) { + result.hasField19 = true; + result.field19_ = value; + return this; + } + public Builder ClearField19() { + result.hasField19 = false; + result.field19_ = 2; + return this; + } + + public bool HasField20 { + get { return result.HasField20; } + } + public bool Field20 { + get { return result.Field20; } + set { SetField20(value); } + } + public Builder SetField20(bool value) { + result.hasField20 = true; + result.field20_ = value; + return this; + } + public Builder ClearField20() { + result.hasField20 = false; + result.field20_ = true; + return this; + } + + public bool HasField28 { + get { return result.HasField28; } + } + public bool Field28 { + get { return result.Field28; } + set { SetField28(value); } + } + public Builder SetField28(bool value) { + result.hasField28 = true; + result.field28_ = value; + return this; + } + public Builder ClearField28() { + result.hasField28 = false; + result.field28_ = true; + return this; + } + + public bool HasField21 { + get { return result.HasField21; } + } + public ulong Field21 { + get { return result.Field21; } + set { SetField21(value); } + } + public Builder SetField21(ulong value) { + result.hasField21 = true; + result.field21_ = value; + return this; + } + public Builder ClearField21() { + result.hasField21 = false; + result.field21_ = 0; + return this; + } + + public bool HasField22 { + get { return result.HasField22; } + } + public int Field22 { + get { return result.Field22; } + set { SetField22(value); } + } + public Builder SetField22(int value) { + result.hasField22 = true; + result.field22_ = value; + return this; + } + public Builder ClearField22() { + result.hasField22 = false; + result.field22_ = 0; + return this; + } + + public bool HasField23 { + get { return result.HasField23; } + } + public bool Field23 { + get { return result.Field23; } + set { SetField23(value); } + } + public Builder SetField23(bool value) { + result.hasField23 = true; + result.field23_ = value; + return this; + } + public Builder ClearField23() { + result.hasField23 = false; + result.field23_ = false; + return this; + } + + public bool HasField206 { + get { return result.HasField206; } + } + public bool Field206 { + get { return result.Field206; } + set { SetField206(value); } + } + public Builder SetField206(bool value) { + result.hasField206 = true; + result.field206_ = value; + return this; + } + public Builder ClearField206() { + result.hasField206 = false; + result.field206_ = false; + return this; + } + + public bool HasField203 { + get { return result.HasField203; } + } + public uint Field203 { + get { return result.Field203; } + set { SetField203(value); } + } + public Builder SetField203(uint value) { + result.hasField203 = true; + result.field203_ = value; + return this; + } + public Builder ClearField203() { + result.hasField203 = false; + result.field203_ = 0; + return this; + } + + public bool HasField204 { + get { return result.HasField204; } + } + public int Field204 { + get { return result.Field204; } + set { SetField204(value); } + } + public Builder SetField204(int value) { + result.hasField204 = true; + result.field204_ = value; + return this; + } + public Builder ClearField204() { + result.hasField204 = false; + result.field204_ = 0; + return this; + } + + public bool HasField205 { + get { return result.HasField205; } + } + public string Field205 { + get { return result.Field205; } + set { SetField205(value); } + } + public Builder SetField205(string value) { + result.hasField205 = true; + result.field205_ = value; + return this; + } + public Builder ClearField205() { + result.hasField205 = false; + result.field205_ = ""; + return this; + } + + public bool HasField207 { + get { return result.HasField207; } + } + public ulong Field207 { + get { return result.Field207; } + set { SetField207(value); } + } + public Builder SetField207(ulong value) { + result.hasField207 = true; + result.field207_ = value; + return this; + } + public Builder ClearField207() { + result.hasField207 = false; + result.field207_ = 0UL; + return this; + } + + public bool HasField300 { + get { return result.HasField300; } + } + public ulong Field300 { + get { return result.Field300; } + set { SetField300(value); } + } + public Builder SetField300(ulong value) { + result.hasField300 = true; + result.field300_ = value; + return this; + } + public Builder ClearField300() { + result.hasField300 = false; + result.field300_ = 0UL; + return this; + } + } + } + + public sealed partial class Message3 : pb::GeneratedMessage { + private static readonly Message3 defaultInstance = new Builder().BuildPartial(); + public static Message3 DefaultInstance { + get { return defaultInstance; } + } + + public override Message3 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Message3 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message3__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message3__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public sealed partial class Group1 : pb::GeneratedMessage { + private static readonly Group1 defaultInstance = new Builder().BuildPartial(); + public static Group1 DefaultInstance { + get { return defaultInstance; } + } + + public override Group1 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Group1 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message3_Group1__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message3_Group1__FieldAccessorTable; } + } + + private bool hasField11; + private float field11_ = 0F; + public bool HasField11 { + get { return hasField11; } + } + public float Field11 { + get { return field11_; } + } + + private bool hasField26; + private float field26_ = 0F; + public bool HasField26 { + get { return hasField26; } + } + public float Field26 { + get { return field26_; } + } + + private bool hasField12; + private string field12_ = ""; + public bool HasField12 { + get { return hasField12; } + } + public string Field12 { + get { return field12_; } + } + + private bool hasField13; + private string field13_ = ""; + public bool HasField13 { + get { return hasField13; } + } + public string Field13 { + get { return field13_; } + } + + private pbc::PopsicleList field14_ = new pbc::PopsicleList(); + public scg::IList Field14List { + get { return pbc::Lists.AsReadOnly(field14_); } + } + public int Field14Count { + get { return field14_.Count; } + } + public string GetField14(int index) { + return field14_[index]; + } + + private bool hasField15; + private ulong field15_ = 0UL; + public bool HasField15 { + get { return hasField15; } + } + public ulong Field15 { + get { return field15_; } + } + + private bool hasField5; + private int field5_ = 0; + public bool HasField5 { + get { return hasField5; } + } + public int Field5 { + get { return field5_; } + } + + private bool hasField27; + private string field27_ = ""; + public bool HasField27 { + get { return hasField27; } + } + public string Field27 { + get { return field27_; } + } + + private bool hasField28; + private int field28_ = 0; + public bool HasField28 { + get { return hasField28; } + } + public int Field28 { + get { return field28_; } + } + + private bool hasField29; + private string field29_ = ""; + public bool HasField29 { + get { return hasField29; } + } + public string Field29 { + get { return field29_; } + } + + private bool hasField16; + private string field16_ = ""; + public bool HasField16 { + get { return hasField16; } + } + public string Field16 { + get { return field16_; } + } + + private pbc::PopsicleList field22_ = new pbc::PopsicleList(); + public scg::IList Field22List { + get { return pbc::Lists.AsReadOnly(field22_); } + } + public int Field22Count { + get { return field22_.Count; } + } + public string GetField22(int index) { + return field22_[index]; + } + + private pbc::PopsicleList field73_ = new pbc::PopsicleList(); + public scg::IList Field73List { + get { return pbc::Lists.AsReadOnly(field73_); } + } + public int Field73Count { + get { return field73_.Count; } + } + public int GetField73(int index) { + return field73_[index]; + } + + private bool hasField20; + private int field20_ = 0; + public bool HasField20 { + get { return hasField20; } + } + public int Field20 { + get { return field20_; } + } + + private bool hasField24; + private string field24_ = ""; + public bool HasField24 { + get { return hasField24; } + } + public string Field24 { + get { return field24_; } + } + + private bool hasField31; + private global::Google.ProtocolBuffers.BenchmarkProtos.Message4 field31_ = global::Google.ProtocolBuffers.BenchmarkProtos.Message4.DefaultInstance; + public bool HasField31 { + get { return hasField31; } + } + public global::Google.ProtocolBuffers.BenchmarkProtos.Message4 Field31 { + get { return field31_; } + } + + public override bool IsInitialized { + get { + if (!hasField11) return false; + if (!hasField15) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasField5) { + output.WriteInt32(5, Field5); + } + if (HasField11) { + output.WriteFloat(11, Field11); + } + if (HasField12) { + output.WriteString(12, Field12); + } + if (HasField13) { + output.WriteString(13, Field13); + } + foreach (string element in Field14List) { + output.WriteString(14, element); + } + if (HasField15) { + output.WriteUInt64(15, Field15); + } + if (HasField16) { + output.WriteString(16, Field16); + } + if (HasField20) { + output.WriteInt32(20, Field20); + } + foreach (string element in Field22List) { + output.WriteString(22, element); + } + if (HasField24) { + output.WriteString(24, Field24); + } + if (HasField26) { + output.WriteFloat(26, Field26); + } + if (HasField27) { + output.WriteString(27, Field27); + } + if (HasField28) { + output.WriteInt32(28, Field28); + } + if (HasField29) { + output.WriteString(29, Field29); + } + if (HasField31) { + output.WriteMessage(31, Field31); + } + foreach (int element in Field73List) { + output.WriteInt32(73, element); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasField11) { + size += pb::CodedOutputStream.ComputeFloatSize(11, Field11); + } + if (HasField26) { + size += pb::CodedOutputStream.ComputeFloatSize(26, Field26); + } + if (HasField12) { + size += pb::CodedOutputStream.ComputeStringSize(12, Field12); + } + if (HasField13) { + size += pb::CodedOutputStream.ComputeStringSize(13, Field13); + } + foreach (string element in Field14List) { + size += pb::CodedOutputStream.ComputeStringSize(14, element); + } + if (HasField15) { + size += pb::CodedOutputStream.ComputeUInt64Size(15, Field15); + } + if (HasField5) { + size += pb::CodedOutputStream.ComputeInt32Size(5, Field5); + } + if (HasField27) { + size += pb::CodedOutputStream.ComputeStringSize(27, Field27); + } + if (HasField28) { + size += pb::CodedOutputStream.ComputeInt32Size(28, Field28); + } + if (HasField29) { + size += pb::CodedOutputStream.ComputeStringSize(29, Field29); + } + if (HasField16) { + size += pb::CodedOutputStream.ComputeStringSize(16, Field16); + } + foreach (string element in Field22List) { + size += pb::CodedOutputStream.ComputeStringSize(22, element); + } + foreach (int element in Field73List) { + size += pb::CodedOutputStream.ComputeInt32Size(73, element); + } + if (HasField20) { + size += pb::CodedOutputStream.ComputeInt32Size(20, Field20); + } + if (HasField24) { + size += pb::CodedOutputStream.ComputeStringSize(24, Field24); + } + if (HasField31) { + size += pb::CodedOutputStream.ComputeMessageSize(31, Field31); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Group1 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Group1 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Group1 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Group1 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Group1 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Group1 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Group1 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Group1 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Group1 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Group1 result = new Group1(); + + protected override Group1 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Group1(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return Group1.Descriptor; } + } + + public override Group1 DefaultInstanceForType { + get { return Group1.DefaultInstance; } + } + + public override Group1 BuildPartial() { + result.field14_.MakeReadOnly(); + result.field22_.MakeReadOnly(); + result.field73_.MakeReadOnly(); + Group1 returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Group1) { + return MergeFrom((Group1) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Group1 other) { + if (other == Group1.DefaultInstance) return this; + if (other.HasField11) { + Field11 = other.Field11; + } + if (other.HasField26) { + Field26 = other.Field26; + } + if (other.HasField12) { + Field12 = other.Field12; + } + if (other.HasField13) { + Field13 = other.Field13; + } + if (other.field14_.Count != 0) { + base.AddRange(other.field14_, result.field14_); + } + if (other.HasField15) { + Field15 = other.Field15; + } + if (other.HasField5) { + Field5 = other.Field5; + } + if (other.HasField27) { + Field27 = other.Field27; + } + if (other.HasField28) { + Field28 = other.Field28; + } + if (other.HasField29) { + Field29 = other.Field29; + } + if (other.HasField16) { + Field16 = other.Field16; + } + if (other.field22_.Count != 0) { + base.AddRange(other.field22_, result.field22_); + } + if (other.field73_.Count != 0) { + base.AddRange(other.field73_, result.field73_); + } + if (other.HasField20) { + Field20 = other.Field20; + } + if (other.HasField24) { + Field24 = other.Field24; + } + if (other.HasField31) { + MergeField31(other.Field31); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 40: { + Field5 = input.ReadInt32(); + break; + } + case 93: { + Field11 = input.ReadFloat(); + break; + } + case 98: { + Field12 = input.ReadString(); + break; + } + case 106: { + Field13 = input.ReadString(); + break; + } + case 114: { + AddField14(input.ReadString()); + break; + } + case 120: { + Field15 = input.ReadUInt64(); + break; + } + case 130: { + Field16 = input.ReadString(); + break; + } + case 160: { + Field20 = input.ReadInt32(); + break; + } + case 178: { + AddField22(input.ReadString()); + break; + } + case 194: { + Field24 = input.ReadString(); + break; + } + case 213: { + Field26 = input.ReadFloat(); + break; + } + case 218: { + Field27 = input.ReadString(); + break; + } + case 224: { + Field28 = input.ReadInt32(); + break; + } + case 234: { + Field29 = input.ReadString(); + break; + } + case 250: { + global::Google.ProtocolBuffers.BenchmarkProtos.Message4.Builder subBuilder = global::Google.ProtocolBuffers.BenchmarkProtos.Message4.CreateBuilder(); + if (HasField31) { + subBuilder.MergeFrom(Field31); + } + input.ReadMessage(subBuilder, extensionRegistry); + Field31 = subBuilder.BuildPartial(); + break; + } + case 584: { + AddField73(input.ReadInt32()); + break; + } + } + } + } + + + public bool HasField11 { + get { return result.HasField11; } + } + public float Field11 { + get { return result.Field11; } + set { SetField11(value); } + } + public Builder SetField11(float value) { + result.hasField11 = true; + result.field11_ = value; + return this; + } + public Builder ClearField11() { + result.hasField11 = false; + result.field11_ = 0F; + return this; + } + + public bool HasField26 { + get { return result.HasField26; } + } + public float Field26 { + get { return result.Field26; } + set { SetField26(value); } + } + public Builder SetField26(float value) { + result.hasField26 = true; + result.field26_ = value; + return this; + } + public Builder ClearField26() { + result.hasField26 = false; + result.field26_ = 0F; + return this; + } + + public bool HasField12 { + get { return result.HasField12; } + } + public string Field12 { + get { return result.Field12; } + set { SetField12(value); } + } + public Builder SetField12(string value) { + result.hasField12 = true; + result.field12_ = value; + return this; + } + public Builder ClearField12() { + result.hasField12 = false; + result.field12_ = ""; + return this; + } + + public bool HasField13 { + get { return result.HasField13; } + } + public string Field13 { + get { return result.Field13; } + set { SetField13(value); } + } + public Builder SetField13(string value) { + result.hasField13 = true; + result.field13_ = value; + return this; + } + public Builder ClearField13() { + result.hasField13 = false; + result.field13_ = ""; + return this; + } + + public scg::IList Field14List { + get { return result.field14_; } + } + public int Field14Count { + get { return result.Field14Count; } + } + public string GetField14(int index) { + return result.GetField14(index); + } + public Builder SetField14(int index, string value) { + result.field14_[index] = value; + return this; + } + public Builder AddField14(string value) { + result.field14_.Add(value); + return this; + } + public Builder AddRangeField14(scg::IEnumerable values) { + base.AddRange(values, result.field14_); + return this; + } + public Builder ClearField14() { + result.field14_.Clear(); + return this; + } + + public bool HasField15 { + get { return result.HasField15; } + } + public ulong Field15 { + get { return result.Field15; } + set { SetField15(value); } + } + public Builder SetField15(ulong value) { + result.hasField15 = true; + result.field15_ = value; + return this; + } + public Builder ClearField15() { + result.hasField15 = false; + result.field15_ = 0UL; + return this; + } + + public bool HasField5 { + get { return result.HasField5; } + } + public int Field5 { + get { return result.Field5; } + set { SetField5(value); } + } + public Builder SetField5(int value) { + result.hasField5 = true; + result.field5_ = value; + return this; + } + public Builder ClearField5() { + result.hasField5 = false; + result.field5_ = 0; + return this; + } + + public bool HasField27 { + get { return result.HasField27; } + } + public string Field27 { + get { return result.Field27; } + set { SetField27(value); } + } + public Builder SetField27(string value) { + result.hasField27 = true; + result.field27_ = value; + return this; + } + public Builder ClearField27() { + result.hasField27 = false; + result.field27_ = ""; + return this; + } + + public bool HasField28 { + get { return result.HasField28; } + } + public int Field28 { + get { return result.Field28; } + set { SetField28(value); } + } + public Builder SetField28(int value) { + result.hasField28 = true; + result.field28_ = value; + return this; + } + public Builder ClearField28() { + result.hasField28 = false; + result.field28_ = 0; + return this; + } + + public bool HasField29 { + get { return result.HasField29; } + } + public string Field29 { + get { return result.Field29; } + set { SetField29(value); } + } + public Builder SetField29(string value) { + result.hasField29 = true; + result.field29_ = value; + return this; + } + public Builder ClearField29() { + result.hasField29 = false; + result.field29_ = ""; + return this; + } + + public bool HasField16 { + get { return result.HasField16; } + } + public string Field16 { + get { return result.Field16; } + set { SetField16(value); } + } + public Builder SetField16(string value) { + result.hasField16 = true; + result.field16_ = value; + return this; + } + public Builder ClearField16() { + result.hasField16 = false; + result.field16_ = ""; + return this; + } + + public scg::IList Field22List { + get { return result.field22_; } + } + public int Field22Count { + get { return result.Field22Count; } + } + public string GetField22(int index) { + return result.GetField22(index); + } + public Builder SetField22(int index, string value) { + result.field22_[index] = value; + return this; + } + public Builder AddField22(string value) { + result.field22_.Add(value); + return this; + } + public Builder AddRangeField22(scg::IEnumerable values) { + base.AddRange(values, result.field22_); + return this; + } + public Builder ClearField22() { + result.field22_.Clear(); + return this; + } + + public scg::IList Field73List { + get { return result.field73_; } + } + public int Field73Count { + get { return result.Field73Count; } + } + public int GetField73(int index) { + return result.GetField73(index); + } + public Builder SetField73(int index, int value) { + result.field73_[index] = value; + return this; + } + public Builder AddField73(int value) { + result.field73_.Add(value); + return this; + } + public Builder AddRangeField73(scg::IEnumerable values) { + base.AddRange(values, result.field73_); + return this; + } + public Builder ClearField73() { + result.field73_.Clear(); + return this; + } + + public bool HasField20 { + get { return result.HasField20; } + } + public int Field20 { + get { return result.Field20; } + set { SetField20(value); } + } + public Builder SetField20(int value) { + result.hasField20 = true; + result.field20_ = value; + return this; + } + public Builder ClearField20() { + result.hasField20 = false; + result.field20_ = 0; + return this; + } + + public bool HasField24 { + get { return result.HasField24; } + } + public string Field24 { + get { return result.Field24; } + set { SetField24(value); } + } + public Builder SetField24(string value) { + result.hasField24 = true; + result.field24_ = value; + return this; + } + public Builder ClearField24() { + result.hasField24 = false; + result.field24_ = ""; + return this; + } + + public bool HasField31 { + get { return result.HasField31; } + } + public global::Google.ProtocolBuffers.BenchmarkProtos.Message4 Field31 { + get { return result.Field31; } + set { SetField31(value); } + } + public Builder SetField31(global::Google.ProtocolBuffers.BenchmarkProtos.Message4 value) { + result.hasField31 = true; + result.field31_ = value; + return this; + } + public Builder SetField31(global::Google.ProtocolBuffers.BenchmarkProtos.Message4.Builder builderForValue) { + result.hasField31 = true; + result.field31_ = builderForValue.Build(); + return this; + } + public Builder MergeField31(global::Google.ProtocolBuffers.BenchmarkProtos.Message4 value) { + if (result.HasField31 && + result.field31_ != global::Google.ProtocolBuffers.BenchmarkProtos.Message4.DefaultInstance) { + result.field31_ = global::Google.ProtocolBuffers.BenchmarkProtos.Message4.CreateBuilder(result.field31_).MergeFrom(value).BuildPartial(); + } else { + result.field31_ = value; + } + result.hasField31 = true; + return this; + } + public Builder ClearField31() { + result.hasField31 = false; + result.field31_ = global::Google.ProtocolBuffers.BenchmarkProtos.Message4.DefaultInstance; + return this; + } + } + } + + } + #endregion + + private bool hasField1; + private string field1_ = ""; + public bool HasField1 { + get { return hasField1; } + } + public string Field1 { + get { return field1_; } + } + + private bool hasField3; + private long field3_ = 0L; + public bool HasField3 { + get { return hasField3; } + } + public long Field3 { + get { return field3_; } + } + + private bool hasField4; + private long field4_ = 0L; + public bool HasField4 { + get { return hasField4; } + } + public long Field4 { + get { return field4_; } + } + + private bool hasField30; + private long field30_ = 0L; + public bool HasField30 { + get { return hasField30; } + } + public long Field30 { + get { return field30_; } + } + + private bool hasField75; + private bool field75_ = false; + public bool HasField75 { + get { return hasField75; } + } + public bool Field75 { + get { return field75_; } + } + + private bool hasField6; + private string field6_ = ""; + public bool HasField6 { + get { return hasField6; } + } + public string Field6 { + get { return field6_; } + } + + private bool hasField2; + private pb::ByteString field2_ = pb::ByteString.Empty; + public bool HasField2 { + get { return hasField2; } + } + public pb::ByteString Field2 { + get { return field2_; } + } + + private bool hasField21; + private int field21_ = 0; + public bool HasField21 { + get { return hasField21; } + } + public int Field21 { + get { return field21_; } + } + + private bool hasField71; + private int field71_ = 0; + public bool HasField71 { + get { return hasField71; } + } + public int Field71 { + get { return field71_; } + } + + private bool hasField25; + private float field25_ = 0F; + public bool HasField25 { + get { return hasField25; } + } + public float Field25 { + get { return field25_; } + } + + private bool hasField109; + private int field109_ = 0; + public bool HasField109 { + get { return hasField109; } + } + public int Field109 { + get { return field109_; } + } + + private bool hasField210; + private int field210_ = 0; + public bool HasField210 { + get { return hasField210; } + } + public int Field210 { + get { return field210_; } + } + + private bool hasField211; + private int field211_ = 0; + public bool HasField211 { + get { return hasField211; } + } + public int Field211 { + get { return field211_; } + } + + private bool hasField212; + private int field212_ = 0; + public bool HasField212 { + get { return hasField212; } + } + public int Field212 { + get { return field212_; } + } + + private bool hasField213; + private int field213_ = 0; + public bool HasField213 { + get { return hasField213; } + } + public int Field213 { + get { return field213_; } + } + + private bool hasField216; + private int field216_ = 0; + public bool HasField216 { + get { return hasField216; } + } + public int Field216 { + get { return field216_; } + } + + private bool hasField217; + private int field217_ = 0; + public bool HasField217 { + get { return hasField217; } + } + public int Field217 { + get { return field217_; } + } + + private bool hasField218; + private int field218_ = 0; + public bool HasField218 { + get { return hasField218; } + } + public int Field218 { + get { return field218_; } + } + + private bool hasField220; + private int field220_ = 0; + public bool HasField220 { + get { return hasField220; } + } + public int Field220 { + get { return field220_; } + } + + private bool hasField221; + private int field221_ = 0; + public bool HasField221 { + get { return hasField221; } + } + public int Field221 { + get { return field221_; } + } + + private bool hasField222; + private float field222_ = 0F; + public bool HasField222 { + get { return hasField222; } + } + public float Field222 { + get { return field222_; } + } + + private bool hasField63; + private int field63_ = 0; + public bool HasField63 { + get { return hasField63; } + } + public int Field63 { + get { return field63_; } + } + + private pbc::PopsicleList group1_ = new pbc::PopsicleList(); + public scg::IList Group1List { + get { return group1_; } + } + public int Group1Count { + get { return group1_.Count; } + } + public global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1 GetGroup1(int index) { + return group1_[index]; + } + + private pbc::PopsicleList field128_ = new pbc::PopsicleList(); + public scg::IList Field128List { + get { return pbc::Lists.AsReadOnly(field128_); } + } + public int Field128Count { + get { return field128_.Count; } + } + public string GetField128(int index) { + return field128_[index]; + } + + private bool hasField131; + private long field131_ = 0L; + public bool HasField131 { + get { return hasField131; } + } + public long Field131 { + get { return field131_; } + } + + private pbc::PopsicleList field127_ = new pbc::PopsicleList(); + public scg::IList Field127List { + get { return pbc::Lists.AsReadOnly(field127_); } + } + public int Field127Count { + get { return field127_.Count; } + } + public string GetField127(int index) { + return field127_[index]; + } + + private bool hasField129; + private int field129_ = 0; + public bool HasField129 { + get { return hasField129; } + } + public int Field129 { + get { return field129_; } + } + + private pbc::PopsicleList field130_ = new pbc::PopsicleList(); + public scg::IList Field130List { + get { return pbc::Lists.AsReadOnly(field130_); } + } + public int Field130Count { + get { return field130_.Count; } + } + public long GetField130(int index) { + return field130_[index]; + } + + private bool hasField205; + private bool field205_ = false; + public bool HasField205 { + get { return hasField205; } + } + public bool Field205 { + get { return field205_; } + } + + private bool hasField206; + private bool field206_ = false; + public bool HasField206 { + get { return hasField206; } + } + public bool Field206 { + get { return field206_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasField1) { + output.WriteString(1, Field1); + } + if (HasField2) { + output.WriteBytes(2, Field2); + } + if (HasField3) { + output.WriteInt64(3, Field3); + } + if (HasField4) { + output.WriteInt64(4, Field4); + } + if (HasField6) { + output.WriteString(6, Field6); + } + foreach (global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1 element in Group1List) { + output.WriteGroup(10, element); + } + if (HasField21) { + output.WriteInt32(21, Field21); + } + if (HasField25) { + output.WriteFloat(25, Field25); + } + if (HasField30) { + output.WriteInt64(30, Field30); + } + if (HasField63) { + output.WriteInt32(63, Field63); + } + if (HasField71) { + output.WriteInt32(71, Field71); + } + if (HasField75) { + output.WriteBool(75, Field75); + } + if (HasField109) { + output.WriteInt32(109, Field109); + } + foreach (string element in Field127List) { + output.WriteString(127, element); + } + foreach (string element in Field128List) { + output.WriteString(128, element); + } + if (HasField129) { + output.WriteInt32(129, Field129); + } + foreach (long element in Field130List) { + output.WriteInt64(130, element); + } + if (HasField131) { + output.WriteInt64(131, Field131); + } + if (HasField205) { + output.WriteBool(205, Field205); + } + if (HasField206) { + output.WriteBool(206, Field206); + } + if (HasField210) { + output.WriteInt32(210, Field210); + } + if (HasField211) { + output.WriteInt32(211, Field211); + } + if (HasField212) { + output.WriteInt32(212, Field212); + } + if (HasField213) { + output.WriteInt32(213, Field213); + } + if (HasField216) { + output.WriteInt32(216, Field216); + } + if (HasField217) { + output.WriteInt32(217, Field217); + } + if (HasField218) { + output.WriteInt32(218, Field218); + } + if (HasField220) { + output.WriteInt32(220, Field220); + } + if (HasField221) { + output.WriteInt32(221, Field221); + } + if (HasField222) { + output.WriteFloat(222, Field222); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasField1) { + size += pb::CodedOutputStream.ComputeStringSize(1, Field1); + } + if (HasField3) { + size += pb::CodedOutputStream.ComputeInt64Size(3, Field3); + } + if (HasField4) { + size += pb::CodedOutputStream.ComputeInt64Size(4, Field4); + } + if (HasField30) { + size += pb::CodedOutputStream.ComputeInt64Size(30, Field30); + } + if (HasField75) { + size += pb::CodedOutputStream.ComputeBoolSize(75, Field75); + } + if (HasField6) { + size += pb::CodedOutputStream.ComputeStringSize(6, Field6); + } + if (HasField2) { + size += pb::CodedOutputStream.ComputeBytesSize(2, Field2); + } + if (HasField21) { + size += pb::CodedOutputStream.ComputeInt32Size(21, Field21); + } + if (HasField71) { + size += pb::CodedOutputStream.ComputeInt32Size(71, Field71); + } + if (HasField25) { + size += pb::CodedOutputStream.ComputeFloatSize(25, Field25); + } + if (HasField109) { + size += pb::CodedOutputStream.ComputeInt32Size(109, Field109); + } + if (HasField210) { + size += pb::CodedOutputStream.ComputeInt32Size(210, Field210); + } + if (HasField211) { + size += pb::CodedOutputStream.ComputeInt32Size(211, Field211); + } + if (HasField212) { + size += pb::CodedOutputStream.ComputeInt32Size(212, Field212); + } + if (HasField213) { + size += pb::CodedOutputStream.ComputeInt32Size(213, Field213); + } + if (HasField216) { + size += pb::CodedOutputStream.ComputeInt32Size(216, Field216); + } + if (HasField217) { + size += pb::CodedOutputStream.ComputeInt32Size(217, Field217); + } + if (HasField218) { + size += pb::CodedOutputStream.ComputeInt32Size(218, Field218); + } + if (HasField220) { + size += pb::CodedOutputStream.ComputeInt32Size(220, Field220); + } + if (HasField221) { + size += pb::CodedOutputStream.ComputeInt32Size(221, Field221); + } + if (HasField222) { + size += pb::CodedOutputStream.ComputeFloatSize(222, Field222); + } + if (HasField63) { + size += pb::CodedOutputStream.ComputeInt32Size(63, Field63); + } + foreach (global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1 element in Group1List) { + size += pb::CodedOutputStream.ComputeGroupSize(10, element); + } + foreach (string element in Field128List) { + size += pb::CodedOutputStream.ComputeStringSize(128, element); + } + if (HasField131) { + size += pb::CodedOutputStream.ComputeInt64Size(131, Field131); + } + foreach (string element in Field127List) { + size += pb::CodedOutputStream.ComputeStringSize(127, element); + } + if (HasField129) { + size += pb::CodedOutputStream.ComputeInt32Size(129, Field129); + } + foreach (long element in Field130List) { + size += pb::CodedOutputStream.ComputeInt64Size(130, element); + } + if (HasField205) { + size += pb::CodedOutputStream.ComputeBoolSize(205, Field205); + } + if (HasField206) { + size += pb::CodedOutputStream.ComputeBoolSize(206, Field206); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Message3 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Message3 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Message3 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Message3 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Message3 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Message3 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Message3 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Message3 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Message3 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Message3 result = new Message3(); + + protected override Message3 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Message3(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return Message3.Descriptor; } + } + + public override Message3 DefaultInstanceForType { + get { return Message3.DefaultInstance; } + } + + public override Message3 BuildPartial() { + result.group1_.MakeReadOnly(); + result.field128_.MakeReadOnly(); + result.field127_.MakeReadOnly(); + result.field130_.MakeReadOnly(); + Message3 returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Message3) { + return MergeFrom((Message3) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Message3 other) { + if (other == Message3.DefaultInstance) return this; + if (other.HasField1) { + Field1 = other.Field1; + } + if (other.HasField3) { + Field3 = other.Field3; + } + if (other.HasField4) { + Field4 = other.Field4; + } + if (other.HasField30) { + Field30 = other.Field30; + } + if (other.HasField75) { + Field75 = other.Field75; + } + if (other.HasField6) { + Field6 = other.Field6; + } + if (other.HasField2) { + Field2 = other.Field2; + } + if (other.HasField21) { + Field21 = other.Field21; + } + if (other.HasField71) { + Field71 = other.Field71; + } + if (other.HasField25) { + Field25 = other.Field25; + } + if (other.HasField109) { + Field109 = other.Field109; + } + if (other.HasField210) { + Field210 = other.Field210; + } + if (other.HasField211) { + Field211 = other.Field211; + } + if (other.HasField212) { + Field212 = other.Field212; + } + if (other.HasField213) { + Field213 = other.Field213; + } + if (other.HasField216) { + Field216 = other.Field216; + } + if (other.HasField217) { + Field217 = other.Field217; + } + if (other.HasField218) { + Field218 = other.Field218; + } + if (other.HasField220) { + Field220 = other.Field220; + } + if (other.HasField221) { + Field221 = other.Field221; + } + if (other.HasField222) { + Field222 = other.Field222; + } + if (other.HasField63) { + Field63 = other.Field63; + } + if (other.group1_.Count != 0) { + base.AddRange(other.group1_, result.group1_); + } + if (other.field128_.Count != 0) { + base.AddRange(other.field128_, result.field128_); + } + if (other.HasField131) { + Field131 = other.Field131; + } + if (other.field127_.Count != 0) { + base.AddRange(other.field127_, result.field127_); + } + if (other.HasField129) { + Field129 = other.Field129; + } + if (other.field130_.Count != 0) { + base.AddRange(other.field130_, result.field130_); + } + if (other.HasField205) { + Field205 = other.Field205; + } + if (other.HasField206) { + Field206 = other.Field206; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + Field1 = input.ReadString(); + break; + } + case 18: { + Field2 = input.ReadBytes(); + break; + } + case 24: { + Field3 = input.ReadInt64(); + break; + } + case 32: { + Field4 = input.ReadInt64(); + break; + } + case 50: { + Field6 = input.ReadString(); + break; + } + case 83: { + global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1.Builder subBuilder = global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1.CreateBuilder(); + input.ReadGroup(10, subBuilder, extensionRegistry); + AddGroup1(subBuilder.BuildPartial()); + break; + } + case 168: { + Field21 = input.ReadInt32(); + break; + } + case 205: { + Field25 = input.ReadFloat(); + break; + } + case 240: { + Field30 = input.ReadInt64(); + break; + } + case 504: { + Field63 = input.ReadInt32(); + break; + } + case 568: { + Field71 = input.ReadInt32(); + break; + } + case 600: { + Field75 = input.ReadBool(); + break; + } + case 872: { + Field109 = input.ReadInt32(); + break; + } + case 1018: { + AddField127(input.ReadString()); + break; + } + case 1026: { + AddField128(input.ReadString()); + break; + } + case 1032: { + Field129 = input.ReadInt32(); + break; + } + case 1040: { + AddField130(input.ReadInt64()); + break; + } + case 1048: { + Field131 = input.ReadInt64(); + break; + } + case 1640: { + Field205 = input.ReadBool(); + break; + } + case 1648: { + Field206 = input.ReadBool(); + break; + } + case 1680: { + Field210 = input.ReadInt32(); + break; + } + case 1688: { + Field211 = input.ReadInt32(); + break; + } + case 1696: { + Field212 = input.ReadInt32(); + break; + } + case 1704: { + Field213 = input.ReadInt32(); + break; + } + case 1728: { + Field216 = input.ReadInt32(); + break; + } + case 1736: { + Field217 = input.ReadInt32(); + break; + } + case 1744: { + Field218 = input.ReadInt32(); + break; + } + case 1760: { + Field220 = input.ReadInt32(); + break; + } + case 1768: { + Field221 = input.ReadInt32(); + break; + } + case 1781: { + Field222 = input.ReadFloat(); + break; + } + } + } + } + + + public bool HasField1 { + get { return result.HasField1; } + } + public string Field1 { + get { return result.Field1; } + set { SetField1(value); } + } + public Builder SetField1(string value) { + result.hasField1 = true; + result.field1_ = value; + return this; + } + public Builder ClearField1() { + result.hasField1 = false; + result.field1_ = ""; + return this; + } + + public bool HasField3 { + get { return result.HasField3; } + } + public long Field3 { + get { return result.Field3; } + set { SetField3(value); } + } + public Builder SetField3(long value) { + result.hasField3 = true; + result.field3_ = value; + return this; + } + public Builder ClearField3() { + result.hasField3 = false; + result.field3_ = 0L; + return this; + } + + public bool HasField4 { + get { return result.HasField4; } + } + public long Field4 { + get { return result.Field4; } + set { SetField4(value); } + } + public Builder SetField4(long value) { + result.hasField4 = true; + result.field4_ = value; + return this; + } + public Builder ClearField4() { + result.hasField4 = false; + result.field4_ = 0L; + return this; + } + + public bool HasField30 { + get { return result.HasField30; } + } + public long Field30 { + get { return result.Field30; } + set { SetField30(value); } + } + public Builder SetField30(long value) { + result.hasField30 = true; + result.field30_ = value; + return this; + } + public Builder ClearField30() { + result.hasField30 = false; + result.field30_ = 0L; + return this; + } + + public bool HasField75 { + get { return result.HasField75; } + } + public bool Field75 { + get { return result.Field75; } + set { SetField75(value); } + } + public Builder SetField75(bool value) { + result.hasField75 = true; + result.field75_ = value; + return this; + } + public Builder ClearField75() { + result.hasField75 = false; + result.field75_ = false; + return this; + } + + public bool HasField6 { + get { return result.HasField6; } + } + public string Field6 { + get { return result.Field6; } + set { SetField6(value); } + } + public Builder SetField6(string value) { + result.hasField6 = true; + result.field6_ = value; + return this; + } + public Builder ClearField6() { + result.hasField6 = false; + result.field6_ = ""; + return this; + } + + public bool HasField2 { + get { return result.HasField2; } + } + public pb::ByteString Field2 { + get { return result.Field2; } + set { SetField2(value); } + } + public Builder SetField2(pb::ByteString value) { + result.hasField2 = true; + result.field2_ = value; + return this; + } + public Builder ClearField2() { + result.hasField2 = false; + result.field2_ = pb::ByteString.Empty; + return this; + } + + public bool HasField21 { + get { return result.HasField21; } + } + public int Field21 { + get { return result.Field21; } + set { SetField21(value); } + } + public Builder SetField21(int value) { + result.hasField21 = true; + result.field21_ = value; + return this; + } + public Builder ClearField21() { + result.hasField21 = false; + result.field21_ = 0; + return this; + } + + public bool HasField71 { + get { return result.HasField71; } + } + public int Field71 { + get { return result.Field71; } + set { SetField71(value); } + } + public Builder SetField71(int value) { + result.hasField71 = true; + result.field71_ = value; + return this; + } + public Builder ClearField71() { + result.hasField71 = false; + result.field71_ = 0; + return this; + } + + public bool HasField25 { + get { return result.HasField25; } + } + public float Field25 { + get { return result.Field25; } + set { SetField25(value); } + } + public Builder SetField25(float value) { + result.hasField25 = true; + result.field25_ = value; + return this; + } + public Builder ClearField25() { + result.hasField25 = false; + result.field25_ = 0F; + return this; + } + + public bool HasField109 { + get { return result.HasField109; } + } + public int Field109 { + get { return result.Field109; } + set { SetField109(value); } + } + public Builder SetField109(int value) { + result.hasField109 = true; + result.field109_ = value; + return this; + } + public Builder ClearField109() { + result.hasField109 = false; + result.field109_ = 0; + return this; + } + + public bool HasField210 { + get { return result.HasField210; } + } + public int Field210 { + get { return result.Field210; } + set { SetField210(value); } + } + public Builder SetField210(int value) { + result.hasField210 = true; + result.field210_ = value; + return this; + } + public Builder ClearField210() { + result.hasField210 = false; + result.field210_ = 0; + return this; + } + + public bool HasField211 { + get { return result.HasField211; } + } + public int Field211 { + get { return result.Field211; } + set { SetField211(value); } + } + public Builder SetField211(int value) { + result.hasField211 = true; + result.field211_ = value; + return this; + } + public Builder ClearField211() { + result.hasField211 = false; + result.field211_ = 0; + return this; + } + + public bool HasField212 { + get { return result.HasField212; } + } + public int Field212 { + get { return result.Field212; } + set { SetField212(value); } + } + public Builder SetField212(int value) { + result.hasField212 = true; + result.field212_ = value; + return this; + } + public Builder ClearField212() { + result.hasField212 = false; + result.field212_ = 0; + return this; + } + + public bool HasField213 { + get { return result.HasField213; } + } + public int Field213 { + get { return result.Field213; } + set { SetField213(value); } + } + public Builder SetField213(int value) { + result.hasField213 = true; + result.field213_ = value; + return this; + } + public Builder ClearField213() { + result.hasField213 = false; + result.field213_ = 0; + return this; + } + + public bool HasField216 { + get { return result.HasField216; } + } + public int Field216 { + get { return result.Field216; } + set { SetField216(value); } + } + public Builder SetField216(int value) { + result.hasField216 = true; + result.field216_ = value; + return this; + } + public Builder ClearField216() { + result.hasField216 = false; + result.field216_ = 0; + return this; + } + + public bool HasField217 { + get { return result.HasField217; } + } + public int Field217 { + get { return result.Field217; } + set { SetField217(value); } + } + public Builder SetField217(int value) { + result.hasField217 = true; + result.field217_ = value; + return this; + } + public Builder ClearField217() { + result.hasField217 = false; + result.field217_ = 0; + return this; + } + + public bool HasField218 { + get { return result.HasField218; } + } + public int Field218 { + get { return result.Field218; } + set { SetField218(value); } + } + public Builder SetField218(int value) { + result.hasField218 = true; + result.field218_ = value; + return this; + } + public Builder ClearField218() { + result.hasField218 = false; + result.field218_ = 0; + return this; + } + + public bool HasField220 { + get { return result.HasField220; } + } + public int Field220 { + get { return result.Field220; } + set { SetField220(value); } + } + public Builder SetField220(int value) { + result.hasField220 = true; + result.field220_ = value; + return this; + } + public Builder ClearField220() { + result.hasField220 = false; + result.field220_ = 0; + return this; + } + + public bool HasField221 { + get { return result.HasField221; } + } + public int Field221 { + get { return result.Field221; } + set { SetField221(value); } + } + public Builder SetField221(int value) { + result.hasField221 = true; + result.field221_ = value; + return this; + } + public Builder ClearField221() { + result.hasField221 = false; + result.field221_ = 0; + return this; + } + + public bool HasField222 { + get { return result.HasField222; } + } + public float Field222 { + get { return result.Field222; } + set { SetField222(value); } + } + public Builder SetField222(float value) { + result.hasField222 = true; + result.field222_ = value; + return this; + } + public Builder ClearField222() { + result.hasField222 = false; + result.field222_ = 0F; + return this; + } + + public bool HasField63 { + get { return result.HasField63; } + } + public int Field63 { + get { return result.Field63; } + set { SetField63(value); } + } + public Builder SetField63(int value) { + result.hasField63 = true; + result.field63_ = value; + return this; + } + public Builder ClearField63() { + result.hasField63 = false; + result.field63_ = 0; + return this; + } + + public scg::IList Group1List { + get { return result.group1_; } + } + public int Group1Count { + get { return result.Group1Count; } + } + public global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1 GetGroup1(int index) { + return result.GetGroup1(index); + } + public Builder SetGroup1(int index, global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1 value) { + result.group1_[index] = value; + return this; + } + public Builder SetGroup1(int index, global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1.Builder builderForValue) { + result.group1_[index] = builderForValue.Build(); + return this; + } + public Builder AddGroup1(global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1 value) { + result.group1_.Add(value); + return this; + } + public Builder AddGroup1(global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1.Builder builderForValue) { + result.group1_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeGroup1(scg::IEnumerable values) { + base.AddRange(values, result.group1_); + return this; + } + public Builder ClearGroup1() { + result.group1_.Clear(); + return this; + } + + public scg::IList Field128List { + get { return result.field128_; } + } + public int Field128Count { + get { return result.Field128Count; } + } + public string GetField128(int index) { + return result.GetField128(index); + } + public Builder SetField128(int index, string value) { + result.field128_[index] = value; + return this; + } + public Builder AddField128(string value) { + result.field128_.Add(value); + return this; + } + public Builder AddRangeField128(scg::IEnumerable values) { + base.AddRange(values, result.field128_); + return this; + } + public Builder ClearField128() { + result.field128_.Clear(); + return this; + } + + public bool HasField131 { + get { return result.HasField131; } + } + public long Field131 { + get { return result.Field131; } + set { SetField131(value); } + } + public Builder SetField131(long value) { + result.hasField131 = true; + result.field131_ = value; + return this; + } + public Builder ClearField131() { + result.hasField131 = false; + result.field131_ = 0L; + return this; + } + + public scg::IList Field127List { + get { return result.field127_; } + } + public int Field127Count { + get { return result.Field127Count; } + } + public string GetField127(int index) { + return result.GetField127(index); + } + public Builder SetField127(int index, string value) { + result.field127_[index] = value; + return this; + } + public Builder AddField127(string value) { + result.field127_.Add(value); + return this; + } + public Builder AddRangeField127(scg::IEnumerable values) { + base.AddRange(values, result.field127_); + return this; + } + public Builder ClearField127() { + result.field127_.Clear(); + return this; + } + + public bool HasField129 { + get { return result.HasField129; } + } + public int Field129 { + get { return result.Field129; } + set { SetField129(value); } + } + public Builder SetField129(int value) { + result.hasField129 = true; + result.field129_ = value; + return this; + } + public Builder ClearField129() { + result.hasField129 = false; + result.field129_ = 0; + return this; + } + + public scg::IList Field130List { + get { return result.field130_; } + } + public int Field130Count { + get { return result.Field130Count; } + } + public long GetField130(int index) { + return result.GetField130(index); + } + public Builder SetField130(int index, long value) { + result.field130_[index] = value; + return this; + } + public Builder AddField130(long value) { + result.field130_.Add(value); + return this; + } + public Builder AddRangeField130(scg::IEnumerable values) { + base.AddRange(values, result.field130_); + return this; + } + public Builder ClearField130() { + result.field130_.Clear(); + return this; + } + + public bool HasField205 { + get { return result.HasField205; } + } + public bool Field205 { + get { return result.Field205; } + set { SetField205(value); } + } + public Builder SetField205(bool value) { + result.hasField205 = true; + result.field205_ = value; + return this; + } + public Builder ClearField205() { + result.hasField205 = false; + result.field205_ = false; + return this; + } + + public bool HasField206 { + get { return result.HasField206; } + } + public bool Field206 { + get { return result.Field206; } + set { SetField206(value); } + } + public Builder SetField206(bool value) { + result.hasField206 = true; + result.field206_ = value; + return this; + } + public Builder ClearField206() { + result.hasField206 = false; + result.field206_ = false; + return this; + } + } + } + + public sealed partial class Message4 : pb::GeneratedMessage { + private static readonly Message4 defaultInstance = new Builder().BuildPartial(); + public static Message4 DefaultInstance { + get { return defaultInstance; } + } + + public override Message4 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Message4 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message4__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message4__FieldAccessorTable; } + } + + private bool hasField1; + private float field1_ = 0F; + public bool HasField1 { + get { return hasField1; } + } + public float Field1 { + get { return field1_; } + } + + private bool hasField2; + private float field2_ = 0F; + public bool HasField2 { + get { return hasField2; } + } + public float Field2 { + get { return field2_; } + } + + private bool hasField3; + private float field3_ = 0F; + public bool HasField3 { + get { return hasField3; } + } + public float Field3 { + get { return field3_; } + } + + private bool hasField4; + private bool field4_ = false; + public bool HasField4 { + get { return hasField4; } + } + public bool Field4 { + get { return field4_; } + } + + private bool hasField5; + private bool field5_ = false; + public bool HasField5 { + get { return hasField5; } + } + public bool Field5 { + get { return field5_; } + } + + private bool hasField6; + private bool field6_ = true; + public bool HasField6 { + get { return hasField6; } + } + public bool Field6 { + get { return field6_; } + } + + private bool hasField7; + private bool field7_ = false; + public bool HasField7 { + get { return hasField7; } + } + public bool Field7 { + get { return field7_; } + } + + private bool hasField8; + private float field8_ = 0F; + public bool HasField8 { + get { return hasField8; } + } + public float Field8 { + get { return field8_; } + } + + private bool hasField9; + private bool field9_ = false; + public bool HasField9 { + get { return hasField9; } + } + public bool Field9 { + get { return field9_; } + } + + private bool hasField10; + private float field10_ = 0F; + public bool HasField10 { + get { return hasField10; } + } + public float Field10 { + get { return field10_; } + } + + private bool hasField11; + private long field11_ = 0L; + public bool HasField11 { + get { return hasField11; } + } + public long Field11 { + get { return field11_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasField1) { + output.WriteFloat(1, Field1); + } + if (HasField2) { + output.WriteFloat(2, Field2); + } + if (HasField3) { + output.WriteFloat(3, Field3); + } + if (HasField4) { + output.WriteBool(4, Field4); + } + if (HasField5) { + output.WriteBool(5, Field5); + } + if (HasField6) { + output.WriteBool(6, Field6); + } + if (HasField7) { + output.WriteBool(7, Field7); + } + if (HasField8) { + output.WriteFloat(8, Field8); + } + if (HasField9) { + output.WriteBool(9, Field9); + } + if (HasField10) { + output.WriteFloat(10, Field10); + } + if (HasField11) { + output.WriteInt64(11, Field11); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasField1) { + size += pb::CodedOutputStream.ComputeFloatSize(1, Field1); + } + if (HasField2) { + size += pb::CodedOutputStream.ComputeFloatSize(2, Field2); + } + if (HasField3) { + size += pb::CodedOutputStream.ComputeFloatSize(3, Field3); + } + if (HasField4) { + size += pb::CodedOutputStream.ComputeBoolSize(4, Field4); + } + if (HasField5) { + size += pb::CodedOutputStream.ComputeBoolSize(5, Field5); + } + if (HasField6) { + size += pb::CodedOutputStream.ComputeBoolSize(6, Field6); + } + if (HasField7) { + size += pb::CodedOutputStream.ComputeBoolSize(7, Field7); + } + if (HasField8) { + size += pb::CodedOutputStream.ComputeFloatSize(8, Field8); + } + if (HasField9) { + size += pb::CodedOutputStream.ComputeBoolSize(9, Field9); + } + if (HasField10) { + size += pb::CodedOutputStream.ComputeFloatSize(10, Field10); + } + if (HasField11) { + size += pb::CodedOutputStream.ComputeInt64Size(11, Field11); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Message4 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Message4 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Message4 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Message4 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Message4 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Message4 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Message4 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Message4 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Message4 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Message4 result = new Message4(); + + protected override Message4 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Message4(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return Message4.Descriptor; } + } + + public override Message4 DefaultInstanceForType { + get { return Message4.DefaultInstance; } + } + + public override Message4 BuildPartial() { + Message4 returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Message4) { + return MergeFrom((Message4) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Message4 other) { + if (other == Message4.DefaultInstance) return this; + if (other.HasField1) { + Field1 = other.Field1; + } + if (other.HasField2) { + Field2 = other.Field2; + } + if (other.HasField3) { + Field3 = other.Field3; + } + if (other.HasField4) { + Field4 = other.Field4; + } + if (other.HasField5) { + Field5 = other.Field5; + } + if (other.HasField6) { + Field6 = other.Field6; + } + if (other.HasField7) { + Field7 = other.Field7; + } + if (other.HasField8) { + Field8 = other.Field8; + } + if (other.HasField9) { + Field9 = other.Field9; + } + if (other.HasField10) { + Field10 = other.Field10; + } + if (other.HasField11) { + Field11 = other.Field11; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 13: { + Field1 = input.ReadFloat(); + break; + } + case 21: { + Field2 = input.ReadFloat(); + break; + } + case 29: { + Field3 = input.ReadFloat(); + break; + } + case 32: { + Field4 = input.ReadBool(); + break; + } + case 40: { + Field5 = input.ReadBool(); + break; + } + case 48: { + Field6 = input.ReadBool(); + break; + } + case 56: { + Field7 = input.ReadBool(); + break; + } + case 69: { + Field8 = input.ReadFloat(); + break; + } + case 72: { + Field9 = input.ReadBool(); + break; + } + case 85: { + Field10 = input.ReadFloat(); + break; + } + case 88: { + Field11 = input.ReadInt64(); + break; + } + } + } + } + + + public bool HasField1 { + get { return result.HasField1; } + } + public float Field1 { + get { return result.Field1; } + set { SetField1(value); } + } + public Builder SetField1(float value) { + result.hasField1 = true; + result.field1_ = value; + return this; + } + public Builder ClearField1() { + result.hasField1 = false; + result.field1_ = 0F; + return this; + } + + public bool HasField2 { + get { return result.HasField2; } + } + public float Field2 { + get { return result.Field2; } + set { SetField2(value); } + } + public Builder SetField2(float value) { + result.hasField2 = true; + result.field2_ = value; + return this; + } + public Builder ClearField2() { + result.hasField2 = false; + result.field2_ = 0F; + return this; + } + + public bool HasField3 { + get { return result.HasField3; } + } + public float Field3 { + get { return result.Field3; } + set { SetField3(value); } + } + public Builder SetField3(float value) { + result.hasField3 = true; + result.field3_ = value; + return this; + } + public Builder ClearField3() { + result.hasField3 = false; + result.field3_ = 0F; + return this; + } + + public bool HasField4 { + get { return result.HasField4; } + } + public bool Field4 { + get { return result.Field4; } + set { SetField4(value); } + } + public Builder SetField4(bool value) { + result.hasField4 = true; + result.field4_ = value; + return this; + } + public Builder ClearField4() { + result.hasField4 = false; + result.field4_ = false; + return this; + } + + public bool HasField5 { + get { return result.HasField5; } + } + public bool Field5 { + get { return result.Field5; } + set { SetField5(value); } + } + public Builder SetField5(bool value) { + result.hasField5 = true; + result.field5_ = value; + return this; + } + public Builder ClearField5() { + result.hasField5 = false; + result.field5_ = false; + return this; + } + + public bool HasField6 { + get { return result.HasField6; } + } + public bool Field6 { + get { return result.Field6; } + set { SetField6(value); } + } + public Builder SetField6(bool value) { + result.hasField6 = true; + result.field6_ = value; + return this; + } + public Builder ClearField6() { + result.hasField6 = false; + result.field6_ = true; + return this; + } + + public bool HasField7 { + get { return result.HasField7; } + } + public bool Field7 { + get { return result.Field7; } + set { SetField7(value); } + } + public Builder SetField7(bool value) { + result.hasField7 = true; + result.field7_ = value; + return this; + } + public Builder ClearField7() { + result.hasField7 = false; + result.field7_ = false; + return this; + } + + public bool HasField8 { + get { return result.HasField8; } + } + public float Field8 { + get { return result.Field8; } + set { SetField8(value); } + } + public Builder SetField8(float value) { + result.hasField8 = true; + result.field8_ = value; + return this; + } + public Builder ClearField8() { + result.hasField8 = false; + result.field8_ = 0F; + return this; + } + + public bool HasField9 { + get { return result.HasField9; } + } + public bool Field9 { + get { return result.Field9; } + set { SetField9(value); } + } + public Builder SetField9(bool value) { + result.hasField9 = true; + result.field9_ = value; + return this; + } + public Builder ClearField9() { + result.hasField9 = false; + result.field9_ = false; + return this; + } + + public bool HasField10 { + get { return result.HasField10; } + } + public float Field10 { + get { return result.Field10; } + set { SetField10(value); } + } + public Builder SetField10(float value) { + result.hasField10 = true; + result.field10_ = value; + return this; + } + public Builder ClearField10() { + result.hasField10 = false; + result.field10_ = 0F; + return this; + } + + public bool HasField11 { + get { return result.HasField11; } + } + public long Field11 { + get { return result.Field11; } + set { SetField11(value); } + } + public Builder SetField11(long value) { + result.hasField11 = true; + result.field11_ = value; + return this; + } + public Builder ClearField11() { + result.hasField11 = false; + result.field11_ = 0L; + return this; + } + } + } + + #endregion + +} diff --git a/src/ProtoBench/Program.cs b/src/ProtoBench/Program.cs new file mode 100644 index 0000000000..9b65c0b155 --- /dev/null +++ b/src/ProtoBench/Program.cs @@ -0,0 +1,90 @@ +using System; +using System.Diagnostics; +using System.IO; +using Google.ProtocolBuffers; + +namespace ProtoBench { + /// + /// Simple benchmarking of arbitrary messages. + /// + public sealed class Program { + + private static readonly TimeSpan MinSampleTime = TimeSpan.FromSeconds(2); + private static readonly TimeSpan TargetTime = TimeSpan.FromSeconds(30); + + // Avoid a .NET 3.5 dependency + delegate void Action(); + + public static int Main(string[] args) { + if (args.Length != 2) { + Console.Error.WriteLine("Usage: ProtoBecnh "); + Console.Error.WriteLine("The descriptor type name is the fully-qualified message name,"); + Console.Error.WriteLine("including assembly - e.g. Google.ProtocolBuffers.BenchmarkProtos.Message1,ProtoBench"); + return 1; + } + IMessage defaultMessage; + try { + defaultMessage = MessageUtil.GetDefaultMessage(args[0]); + } catch (ArgumentException e) { + Console.Error.WriteLine(e.Message); + return 1; + } + try { + IBuilder builder = defaultMessage.WeakCreateBuilderForType(); + byte[] inputData = File.ReadAllBytes(args[1]); + ByteString inputString = ByteString.CopyFrom(inputData); + IMessage sampleMessage = defaultMessage.WeakCreateBuilderForType().WeakMergeFrom(inputString).WeakBuild(); + sampleMessage.ToByteString(); + Console.WriteLine("Benchmarking {0} with file {1}", sampleMessage.GetType().Name, args[1]); + Benchmark("Serialize to byte string", inputData.Length, () => sampleMessage.ToByteString()); + Benchmark("Serialize to byte array", inputData.Length, () => sampleMessage.ToByteArray()); + Benchmark("Serialize to memory stream", inputData.Length, () => sampleMessage.WriteTo(new MemoryStream())); + Benchmark("Deserialize from byte array", inputData.Length, () => + defaultMessage.WeakCreateBuilderForType() + .WeakMergeFrom(CodedInputStream.CreateInstance(inputData)) + .WeakBuild() + ); + Benchmark("Deserialize from byte array", inputData.Length, () => + defaultMessage.WeakCreateBuilderForType() + .WeakMergeFrom(inputString) + .WeakBuild() + ); + return 0; + } catch (Exception e) { + Console.Error.WriteLine("Error: {0}", e.Message); + Console.Error.WriteLine(); + Console.Error.WriteLine("Detailed exception information: {0}", e); + return 1; + } + } + + private static void Benchmark(string name, int dataSize, Action action) { + // Make sure it's JITted + action(); + // Run it progressively more times until we've got a reasonable sample + + int iterations = 1; + TimeSpan elapsed = TimeAction(action, iterations); + while (elapsed < MinSampleTime) { + iterations *= 2; + elapsed = TimeAction(action, iterations); + } + // Upscale the sample to the target time. Do this in floating point arithmetic + // to avoid overflow issues. + iterations = (int) ((TargetTime.Ticks / (double)elapsed.Ticks) * iterations); + elapsed = TimeAction(action, iterations); + Console.WriteLine("{0}: {1} iterations in {2:f3}s; {3:f3}MB/s", + name, iterations, elapsed.TotalSeconds, + (iterations * dataSize) / (elapsed.TotalSeconds * 1024 * 1024)); + } + + private static TimeSpan TimeAction(Action action, int iterations) { + Stopwatch sw = Stopwatch.StartNew(); + for (int i = 0; i < iterations; i++) { + action(); + } + sw.Stop(); + return sw.Elapsed; + } + } +} diff --git a/src/ProtoBench/Properties/AssemblyInfo.cs b/src/ProtoBench/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..0d1f095d6e --- /dev/null +++ b/src/ProtoBench/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("ProtoBench")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ProtoBench")] +[assembly: AssemblyCopyright("Copyright © 2009")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("0f515d09-9a6c-49ec-8500-14a5303ebadf")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/src/ProtoBench/ProtoBench.csproj b/src/ProtoBench/ProtoBench.csproj new file mode 100644 index 0000000000..fa24f5c8a0 --- /dev/null +++ b/src/ProtoBench/ProtoBench.csproj @@ -0,0 +1,62 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {C7A4A435-2813-41C8-AA87-BD914BA5223D} + Exe + Properties + Google.ProtocolBuffers.ProtoBench + ProtoBench + v2.0 + 512 + + + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + {6908BDCE-D925-43F3-94AC-A531E6DF2591} + ProtocolBuffers + + + + + + + + \ No newline at end of file diff --git a/src/ProtoBench/app.config b/src/ProtoBench/app.config new file mode 100644 index 0000000000..df20690a1c --- /dev/null +++ b/src/ProtoBench/app.config @@ -0,0 +1,3 @@ + + + diff --git a/src/ProtoDump/Program.cs b/src/ProtoDump/Program.cs new file mode 100644 index 0000000000..0c66c93027 --- /dev/null +++ b/src/ProtoDump/Program.cs @@ -0,0 +1,43 @@ +using System; +using System.IO; +using System.Reflection; +using Google.ProtocolBuffers; + +namespace ProtoDump { + /// + /// Small utility to load a binary message and dump it in text form + /// + class Program { + static int Main(string[] args) { + if (args.Length != 2) { + Console.Error.WriteLine("Usage: ProtoDump "); + Console.Error.WriteLine("The descriptor type name is the fully-qualified message name,"); + Console.Error.WriteLine("including assembly e.g. ProjectNamespace.Message,Company.Project"); + return 1; + } + IMessage defaultMessage; + try { + defaultMessage = MessageUtil.GetDefaultMessage(args[0]); + } catch (ArgumentException e) { + Console.Error.WriteLine(e.Message); + return 1; + } + try { + IBuilder builder = defaultMessage.WeakCreateBuilderForType(); + if (builder == null) { + Console.Error.WriteLine("Unable to create builder"); + return 1; + } + byte[] inputData = File.ReadAllBytes(args[1]); + builder.WeakMergeFrom(ByteString.CopyFrom(inputData)); + Console.WriteLine(TextFormat.PrintToString(builder.WeakBuild())); + return 0; + } catch (Exception e) { + Console.Error.WriteLine("Error: {0}", e.Message); + Console.Error.WriteLine(); + Console.Error.WriteLine("Detailed exception information: {0}", e); + return 1; + } + } + } +} diff --git a/src/ProtoDump/Properties/AssemblyInfo.cs b/src/ProtoDump/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..93427f7cf5 --- /dev/null +++ b/src/ProtoDump/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("ProtoDump")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ProtoDump")] +[assembly: AssemblyCopyright("Copyright © 2009")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("fed7572b-d747-4704-a6da-6c3c61088346")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/src/ProtoDump/ProtoDump.csproj b/src/ProtoDump/ProtoDump.csproj new file mode 100644 index 0000000000..db1ab3f4e1 --- /dev/null +++ b/src/ProtoDump/ProtoDump.csproj @@ -0,0 +1,59 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {D7282E99-2DC3-405B-946F-177DB2FD2AE2} + Exe + Properties + Google.ProtocolBuffers.ProtoDump + ProtoDump + v2.0 + 512 + + + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + {6908BDCE-D925-43F3-94AC-A531E6DF2591} + ProtocolBuffers + + + + + + + + \ No newline at end of file diff --git a/src/ProtoDump/app.config b/src/ProtoDump/app.config new file mode 100644 index 0000000000..df20690a1c --- /dev/null +++ b/src/ProtoDump/app.config @@ -0,0 +1,3 @@ + + + diff --git a/src/ProtoGen.Test/DependencyResolutionTest.cs b/src/ProtoGen.Test/DependencyResolutionTest.cs index d9fca15ea7..afe9c81aac 100644 --- a/src/ProtoGen.Test/DependencyResolutionTest.cs +++ b/src/ProtoGen.Test/DependencyResolutionTest.cs @@ -1,10 +1,7 @@ -using System; using System.Collections.Generic; -using System.Text; +using Google.ProtocolBuffers.DescriptorProtos; using Google.ProtocolBuffers.Descriptors; using NUnit.Framework; -using Google.ProtocolBuffers.DescriptorProtos; -using Google.ProtocolBuffers.ProtoGen; namespace Google.ProtocolBuffers.ProtoGen { /// diff --git a/src/ProtoGen.Test/GeneratorTest.cs b/src/ProtoGen.Test/GeneratorTest.cs deleted file mode 100644 index d1beb585f2..0000000000 --- a/src/ProtoGen.Test/GeneratorTest.cs +++ /dev/null @@ -1,10 +0,0 @@ -using Google.ProtocolBuffers.DescriptorProtos; -using NUnit.Framework; -using Google.ProtocolBuffers.Descriptors; - -namespace Google.ProtocolBuffers.ProtoGen { - [TestFixture] - public class GeneratorTest { - - } -} \ No newline at end of file diff --git a/src/ProtoGen.Test/ProtoGen.Test.csproj b/src/ProtoGen.Test/ProtoGen.Test.csproj index 426431b288..33fe6e421f 100644 --- a/src/ProtoGen.Test/ProtoGen.Test.csproj +++ b/src/ProtoGen.Test/ProtoGen.Test.csproj @@ -45,7 +45,6 @@ - diff --git a/src/ProtoGen/Program.cs b/src/ProtoGen/Program.cs index e7d460897e..8a49759716 100644 --- a/src/ProtoGen/Program.cs +++ b/src/ProtoGen/Program.cs @@ -23,8 +23,6 @@ namespace Google.ProtocolBuffers.ProtoGen { Generator generator = Generator.CreateGenerator(options); generator.Generate(); - - return 0; } catch (Exception e) { Console.Error.WriteLine("Error: {0}", e.Message); diff --git a/src/ProtoMunge/Program.cs b/src/ProtoMunge/Program.cs new file mode 100644 index 0000000000..704f506034 --- /dev/null +++ b/src/ProtoMunge/Program.cs @@ -0,0 +1,228 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using System.Reflection; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.ProtoMunge +{ + /// + /// Utility console application which takes a message descriptor and a corresponding message, + /// and produces a new message with similar but random data. The data is the same length + /// as the original, but with random values within appropriate bands. (For instance, a compressed + /// integer in the range 0-127 will end up as another integer in the same range, to keep the length + /// the same.) + /// TODO(jonskeet): Potentially refactor to use an instance instead, making it simpler to + /// be thread-safe for external use. + /// + public sealed class Program { + + static readonly Random rng = new Random(); + + static int Main(string[] args) { + if (args.Length != 3) { + Console.Error.WriteLine("Usage: ProtoMunge "); + Console.Error.WriteLine("The descriptor type name is the fully-qualified message name, including assembly."); + Console.Error.WriteLine("(At a future date it may be possible to do this without building the .NET assembly at all.)"); + return 1; + } + IMessage defaultMessage; + try { + defaultMessage = MessageUtil.GetDefaultMessage(args[0]); + } catch (ArgumentException e) { + Console.Error.WriteLine(e.Message); + return 1; + } + try { + IBuilder builder = defaultMessage.WeakCreateBuilderForType(); + byte[] inputData = File.ReadAllBytes(args[1]); + builder.WeakMergeFrom(ByteString.CopyFrom(inputData)); + IMessage original = builder.WeakBuild(); + IMessage munged = Munge(original); + if (original.SerializedSize != munged.SerializedSize) { + throw new Exception("Serialized sizes don't match"); + } + File.WriteAllBytes(args[2], munged.ToByteArray()); + return 0; + } catch (Exception e) { + Console.Error.WriteLine("Error: {0}", e.Message); + Console.Error.WriteLine(); + Console.Error.WriteLine("Detailed exception information: {0}", e); + return 1; + } + } + + /// + /// Munges a message recursively. + /// + /// A new message of the same type as the original message, + /// but munged so that all the data is desensitised. + private static IMessage Munge(IMessage message) { + IBuilder builder = message.WeakCreateBuilderForType(); + foreach (var pair in message.AllFields) { + if (pair.Key.IsRepeated) { + foreach (object singleValue in (IEnumerable)pair.Value) { + builder.WeakAddRepeatedField(pair.Key, CheckedMungeValue(pair.Key, singleValue)); + } + } else { + builder[pair.Key] = CheckedMungeValue(pair.Key, pair.Value); + } + } + IMessage munged = builder.WeakBuild(); + if (message.SerializedSize != munged.SerializedSize) { + Console.WriteLine("Sub message sizes: {0}/{1}", message.SerializedSize, munged.SerializedSize); + } + return munged; + } + + /// + /// Munges a single value and checks that the length ends up the same as it was before. + /// + private static object CheckedMungeValue(FieldDescriptor fieldDescriptor, object value) { + int currentSize = CodedOutputStream.ComputeFieldSize(fieldDescriptor.FieldType, fieldDescriptor.FieldNumber, value); + object mungedValue = MungeValue(fieldDescriptor, value); + int mungedSize = CodedOutputStream.ComputeFieldSize(fieldDescriptor.FieldType, fieldDescriptor.FieldNumber, mungedValue); + // Exceptions log more easily than assertions + if (currentSize != mungedSize) { + throw new Exception("Munged value had wrong size. Field type: " + fieldDescriptor.FieldType + + "; old value: " + value + "; new value: " + mungedValue); + } + return mungedValue; + } + + /// + /// Munges a single value of the specified field descriptor. (i.e. if the field is + /// actually a repeated int, this method receives a single int value to munge, and + /// is called multiple times). + /// + private static object MungeValue(FieldDescriptor fieldDescriptor, object value) { + switch (fieldDescriptor.FieldType) { + case FieldType.SInt64: + case FieldType.Int64: + return (long) MungeVarint64((ulong) (long)value); + case FieldType.UInt64: + return MungeVarint64((ulong)value); + case FieldType.SInt32: + return (int)MungeVarint32((uint)(int)value); + case FieldType.Int32: + return MungeInt32((int) value); + case FieldType.UInt32: + return MungeVarint32((uint)value); + case FieldType.Double: + return rng.NextDouble(); + case FieldType.Float: + return (float)rng.NextDouble(); + case FieldType.Fixed64: { + byte[] data = new byte[8]; + rng.NextBytes(data); + return BitConverter.ToUInt64(data, 0); + } + case FieldType.Fixed32: { + byte[] data = new byte[4]; + rng.NextBytes(data); + return BitConverter.ToUInt32(data, 0); + } + case FieldType.Bool: + return rng.Next(2) == 1; + case FieldType.String: + return MungeString((string)value); + case FieldType.Group: + case FieldType.Message: + return Munge((IMessage)value); + case FieldType.Bytes: + return MungeByteString((ByteString)value); + case FieldType.SFixed64: { + byte[] data = new byte[8]; + rng.NextBytes(data); + return BitConverter.ToInt64(data, 0); + } + case FieldType.SFixed32: { + byte[] data = new byte[4]; + rng.NextBytes(data); + return BitConverter.ToInt32(data, 0); + } + case FieldType.Enum: + return MungeEnum(fieldDescriptor, (int) value); + default: + // TODO(jonskeet): Different exception? + throw new ArgumentException("Invalid field descriptor"); + } + } + + private static object MungeString(string original) { + foreach (char c in original) { + if (c > 127) { + throw new ArgumentException("Can't handle non-ascii yet"); + } + } + char[] chars = new char[original.Length]; + // Convert to pure ASCII - no control characters. + for (int i = 0; i < chars.Length; i++) { + chars[i] = (char) rng.Next(32, 127); + } + return new string(chars); + } + + /// + /// Int32 fields are slightly strange - we need to keep the sign the same way it is: + /// negative numbers can munge to any other negative number (it'll always take + /// 10 bytes) but positive numbers have to stay positive, so we can't use the + /// full range of 32 bits. + /// + private static int MungeInt32(int value) { + if (value < 0) { + return rng.Next(int.MinValue, 0); + } + int length = CodedOutputStream.ComputeRawVarint32Size((uint) value); + uint min = length == 1 ? 0 : 1U << ((length - 1) * 7); + uint max = length == 5 ? int.MaxValue : (1U << (length * 7)) - 1; + return (int) NextRandomUInt64(min, max); + } + + private static uint MungeVarint32(uint original) { + int length = CodedOutputStream.ComputeRawVarint32Size(original); + uint min = length == 1 ? 0 : 1U << ((length - 1) * 7); + uint max = length == 5 ? uint.MaxValue : (1U << (length * 7)) - 1; + return (uint)NextRandomUInt64(min, max); + } + + private static ulong MungeVarint64(ulong original) { + int length = CodedOutputStream.ComputeRawVarint64Size(original); + ulong min = length == 1 ? 0 : 1UL << ((length - 1) * 7); + ulong max = length == 10 ? ulong.MaxValue : (1UL<< (length * 7)) - 1; + return NextRandomUInt64(min, max); + } + + /// + /// Returns a random number in the range [min, max] (both inclusive). + /// + private static ulong NextRandomUInt64(ulong min, ulong max) { + if (min > max) { + throw new ArgumentException("min must be <= max; min=" + min + "; max = " + max); + } + ulong range = max - min; + // This isn't actually terribly good at very large ranges - but it doesn't really matter for the sake + // of this program. + return min + (ulong)(range * rng.NextDouble()); + } + + private static object MungeEnum(FieldDescriptor fieldDescriptor, int original) { + // Find all the values which get encoded to the same size as the current value, and pick one at random + int originalSize = CodedOutputStream.ComputeRawVarint32Size((uint)original); + List sameSizeValues = new List (); + foreach (EnumValueDescriptor candidate in fieldDescriptor.EnumType.Values) { + if (CodedOutputStream.ComputeRawVarint32Size((uint)candidate.Number) == originalSize) { + sameSizeValues.Add(candidate); + } + } + return sameSizeValues[rng.Next(sameSizeValues.Count)].Number; + } + + private static object MungeByteString(ByteString byteString) { + byte[] data = new byte[byteString.Length]; + rng.NextBytes(data); + return ByteString.CopyFrom(data); + } + } +} \ No newline at end of file diff --git a/src/ProtoMunge/Properties/AssemblyInfo.cs b/src/ProtoMunge/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..179b04beba --- /dev/null +++ b/src/ProtoMunge/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("ProtoMunge")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ProtoMunge")] +[assembly: AssemblyCopyright("Copyright © 2008")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("4d26ed0e-a6ca-4df9-bb87-59429d49b676")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/src/ProtoMunge/ProtoMunge.csproj b/src/ProtoMunge/ProtoMunge.csproj new file mode 100644 index 0000000000..f8a9af9a32 --- /dev/null +++ b/src/ProtoMunge/ProtoMunge.csproj @@ -0,0 +1,59 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {8F09AF72-3327-4FA7-BC09-070B80221AB9} + Exe + Properties + Google.ProtocolBuffers.ProtoMunge + ProtoMunge + v2.0 + 512 + + + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + {6908BDCE-D925-43F3-94AC-A531E6DF2591} + ProtocolBuffers + + + + + + + + \ No newline at end of file diff --git a/src/ProtoMunge/app.config b/src/ProtoMunge/app.config new file mode 100644 index 0000000000..df20690a1c --- /dev/null +++ b/src/ProtoMunge/app.config @@ -0,0 +1,3 @@ + + + diff --git a/src/ProtocolBuffers.Test/MessageUtilTest.cs b/src/ProtocolBuffers.Test/MessageUtilTest.cs new file mode 100644 index 0000000000..16495bf517 --- /dev/null +++ b/src/ProtocolBuffers.Test/MessageUtilTest.cs @@ -0,0 +1,45 @@ +using System; +using System.Collections.Generic; +using System.Text; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class MessageUtilTest { + + [Test] + [ExpectedException(typeof(ArgumentNullException))] + public void NullTypeName() { + MessageUtil.GetDefaultMessage((string)null); + } + + [Test] + [ExpectedException(typeof(ArgumentException))] + public void InvalidTypeName() { + MessageUtil.GetDefaultMessage("invalidtypename"); + } + + [Test] + public void ValidTypeName() { + Assert.AreSame(TestAllTypes.DefaultInstance, MessageUtil.GetDefaultMessage(typeof(TestAllTypes).AssemblyQualifiedName)); + } + + [Test] + [ExpectedException(typeof(ArgumentNullException))] + public void NullType() { + MessageUtil.GetDefaultMessage((Type)null); + } + + [Test] + [ExpectedException(typeof(ArgumentException))] + public void NonMessageType() { + MessageUtil.GetDefaultMessage(typeof(string)); + } + + [Test] + public void ValidType() { + Assert.AreSame(TestAllTypes.DefaultInstance, MessageUtil.GetDefaultMessage(typeof(TestAllTypes))); + } + } +} diff --git a/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj b/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj index 277348cc55..2eb81e503d 100644 --- a/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj +++ b/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj @@ -58,6 +58,7 @@ + diff --git a/src/ProtocolBuffers.sln b/src/ProtocolBuffers.sln index c2cd0bf6dd..cdcb2dbb09 100644 --- a/src/ProtocolBuffers.sln +++ b/src/ProtocolBuffers.sln @@ -11,6 +11,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtoGen.Test", "ProtoGen.T EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AddressBook", "AddressBook\AddressBook.csproj", "{A31F5FB2-4FF3-432A-B35B-5CD203606311}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtoMunge", "ProtoMunge\ProtoMunge.csproj", "{8F09AF72-3327-4FA7-BC09-070B80221AB9}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtoBench", "ProtoBench\ProtoBench.csproj", "{C7A4A435-2813-41C8-AA87-BD914BA5223D}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtoDump", "ProtoDump\ProtoDump.csproj", "{D7282E99-2DC3-405B-946F-177DB2FD2AE2}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -37,6 +43,18 @@ Global {A31F5FB2-4FF3-432A-B35B-5CD203606311}.Debug|Any CPU.Build.0 = Debug|Any CPU {A31F5FB2-4FF3-432A-B35B-5CD203606311}.Release|Any CPU.ActiveCfg = Release|Any CPU {A31F5FB2-4FF3-432A-B35B-5CD203606311}.Release|Any CPU.Build.0 = Release|Any CPU + {8F09AF72-3327-4FA7-BC09-070B80221AB9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {8F09AF72-3327-4FA7-BC09-070B80221AB9}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8F09AF72-3327-4FA7-BC09-070B80221AB9}.Release|Any CPU.ActiveCfg = Release|Any CPU + {8F09AF72-3327-4FA7-BC09-070B80221AB9}.Release|Any CPU.Build.0 = Release|Any CPU + {C7A4A435-2813-41C8-AA87-BD914BA5223D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C7A4A435-2813-41C8-AA87-BD914BA5223D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C7A4A435-2813-41C8-AA87-BD914BA5223D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C7A4A435-2813-41C8-AA87-BD914BA5223D}.Release|Any CPU.Build.0 = Release|Any CPU + {D7282E99-2DC3-405B-946F-177DB2FD2AE2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D7282E99-2DC3-405B-946F-177DB2FD2AE2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D7282E99-2DC3-405B-946F-177DB2FD2AE2}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D7282E99-2DC3-405B-946F-177DB2FD2AE2}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/src/ProtocolBuffers/ByteString.cs b/src/ProtocolBuffers/ByteString.cs index 53811205ae..0d67a53961 100644 --- a/src/ProtocolBuffers/ByteString.cs +++ b/src/ProtocolBuffers/ByteString.cs @@ -184,7 +184,7 @@ namespace Google.ProtocolBuffers { output = CodedOutputStream.CreateInstance(buffer); } - public ByteString Build() { + internal ByteString Build() { output.CheckNoSpaceLeft(); // We can be confident that the CodedOutputStream will not modify the @@ -193,7 +193,7 @@ namespace Google.ProtocolBuffers { return new ByteString(buffer); } - public CodedOutputStream CodedOutput { + internal CodedOutputStream CodedOutput { get { return output; } diff --git a/src/ProtocolBuffers/MessageUtil.cs b/src/ProtocolBuffers/MessageUtil.cs new file mode 100644 index 0000000000..d53af9c5c2 --- /dev/null +++ b/src/ProtocolBuffers/MessageUtil.cs @@ -0,0 +1,62 @@ +using System; +using System.Collections.Generic; +using System.Reflection; +using System.Text; + +namespace Google.ProtocolBuffers { + /// + /// Utilities for arbitrary messages of an unknown type. This class does not use + /// generics precisely because it is designed for dynamically discovered types. + /// + public static class MessageUtil { + + /// + /// Returns the default message for the given type. If an exception is thrown + /// (directly from this code), the message will be suitable to be displayed to a user. + /// + /// + /// The type parameter is null. + /// The type doesn't implement IMessage, or doesn't + /// have a static DefaultMessage property of the same type, or is generic or abstract. + /// + public static IMessage GetDefaultMessage(Type type) { + if (type == null) { + throw new ArgumentNullException("type", "No type specified."); + } + if (type.IsAbstract || type.IsGenericTypeDefinition) { + throw new ArgumentException("Unable to get a default message for an abstract or generic type (" + type.FullName + ")"); + } + if (!typeof(IMessage).IsAssignableFrom(type)) { + throw new ArgumentException("Unable to get a default message for non-message type (" + type.FullName + ")"); + } + PropertyInfo property = type.GetProperty("DefaultInstance", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); + if (property == null) { + throw new ArgumentException(type.FullName + " doesn't have a static DefaultInstance property"); + } + if (property.PropertyType != type) { + throw new ArgumentException(type.FullName + ".DefaultInstance property is of the wrong type"); + } + return (IMessage) property.GetValue(null, null); + } + + /// + /// Returns the default message for the type with the given name. This is just + /// a convenience wrapper around calling Type.GetType and then GetDefaultMessage. + /// If an exception is thrown, the message will be suitable to be displayed to a user. + /// + /// + /// The typeName parameter is null. + /// The type doesn't implement IMessage, or doesn't + /// have a static DefaultMessage property of the same type, or can't be found. + public static IMessage GetDefaultMessage(string typeName) { + if (typeName == null) { + throw new ArgumentNullException("typeName", "No type name specified."); + } + Type type = Type.GetType(typeName); + if (type == null) { + throw new ArgumentException("Unable to load type " + typeName); + } + return GetDefaultMessage(type); + } + } +} diff --git a/src/ProtocolBuffers/ProtocolBuffers.csproj b/src/ProtocolBuffers/ProtocolBuffers.csproj index 6a746cc938..520594f547 100644 --- a/src/ProtocolBuffers/ProtocolBuffers.csproj +++ b/src/ProtocolBuffers/ProtocolBuffers.csproj @@ -97,6 +97,7 @@ + diff --git a/testdata/benchmark_message1.dat b/testdata/benchmark_message1.dat new file mode 100644 index 0000000000000000000000000000000000000000..02f410b163e2003fb92944ccce4db04f41828fcc GIT binary patch literal 228 zcmd;L5a5zn(95R8mXTjvVrA?VsgbBqkdc{VWol7lXzCLYP#Ne51VB2`CBxr8H`CO} zucAWNIntycE8i{GC)m@qG}EXs$Hmhk#n?F0&oRfy#m&=1!K$RPAl0f^AtN;>CttxT zUsEB0A%mfSu_}^-K|rL+nF@BSWZdV%A7%2IGid`O!wyEq4n~Gaj9ftXgYDE*n85<{ I*a9{N0HNJPx&QzG literal 0 HcmV?d00001 diff --git a/testdata/benchmark_message2.dat b/testdata/benchmark_message2.dat new file mode 100644 index 0000000000000000000000000000000000000000..06c09441b9e1a3fc8577f6c36dbb583d85481b2c GIT binary patch literal 84570 zcmXtfhhtOq`nLlviu7K`bsJ66W;A;?J148zZDzAil4kF{N3G%jT(}o1AS$v&MO09> zC@Q!RaG|0CqM}?y5#jxw^!NS&-{(Age4giA`oKlAo=Sao;L*0|hu0~a?)zb@m}!O`=VpYwL~nlsbYCoB5lzUr4+*9MBDHos1J{owC6zP3?s$qfGY zJ`{|7u=u}kV-GypE_5D>aub)_b?w{*&kHZO^$sEFuYHGtM$)NAAKrD-ii;nu;}7iJ#3 z`n-=%JKn2&wEoA|l~>#|cYd32*@ek-cHr;Ok3N5FGw#Ta=x^DlFC3cj?^UZ$KK^Iy z)i2i4u7C2}+Et=eg^O<7^~1^S^DQqtaota)6SMhh=J>T8={`?nkxEr<}F6|#C zy|!C~;XLU)BV6tNQL^`@7c)l_ubxcIh%Y+ykz{`M zInRen_kOYR#oWP%7JFtB9$K*ET;tZSQ6JwjUw`nt_ywk|uNBW;{opxErmyeJ=^yKx z4PB(6iIvZ97yr{geE)lE{Y338U!c$4vFMK*_Fs16#ml!`TYUWz z{*3DC&uiJ@6?e<#eR=w+;B&?ko8KkB_QP3L;GS4){K3P=csG+_g(qRjPqU&a!HGa z^q&dYE1!Pwlg~U(rSbjr-?yDzA>8y!^zr-G&O7$Qf9@E0xJKT7XT2Mx@zgqyWYQW#ooowe*3~{>xug6O7P8#En^g}V-NkDJ*Ect0{Ii3 z3YJOO_3-h%g938ppXKLDzdHJsZSzBQL1*s=j#T@^#bYRumHx2m)u`j5>z;Y-Jlv?z zaeYhw=$Fe*F8_V|W9gOZYpy?7Sp9F!vwc6M=6N63^3jSJblfKo&YTTD$2(^F->#$n zz4I1eUw(@6??x7;+f3oZn5*v--(I-oGWgONd%cdUFgH?exe)il$@uwK!o-#K3tbjCdC?|NJG z*S~jPsM>hLj*Gv>UBf^6;!#iQ2AZq%*1M{C^BXsR{ncN~?3Y$p=ia~T<0meMLZ>;8 z5sD93MaECHH{7-TRm!tU+Ii&sx1UPayMM5|UxRN?YQ}!ITrzUk8~)Ba_9f!|Ptx4q zOL%u$wjO>}l=|TW>gXf=-N?`w>+5Rvl33r-%TWJ*nH;R?Sg%iGC0v(a_oe~|H{A3_ zC9#h%ZRb0!qc5L%=6Wx4=Z5m=uUi7=|8!uF^`U2HP^kC$A04p@N;f5B*K|^Af7|iQ z;>DTlJ*O{^{5Zm{vOoT2?w-pwZTYr3``q{D-lV$iX2O?u96vw0Y14V3TaLt!NoR2~ z{1cBp$(pvAdP8dAzgl~~NZ`hfDE4%BUVI5GJ=OQn*3I_IXWe&r?uy&#dxst9zkhh~ zqBA>=V1Ir5b@JRhKi=`y4RfCR>V@c5!;K4;hAunBD;>YQHt(1J>^|^hxM_*|Pw(5D zShr!7On>t)n{Fh@Hhr;Z_WDO_e(|RluYXrI`eW%^^iz8lEmyX-uHJRxG1~lR9{cjv zeebQ>erxlV`Oi-K=A6GD>VEFOBYy+Sf8p;(m!}pzKY1BzeCK6LxZbNB*Im1y_VudW zFv`Nbn)If%we{5l2d+B1=d1<&-O_0`;x+IK^Oj0Omov&~qQ&U7YX+-wCr3O~3Zy8u z#^lb$@4b2Cfuprk=l-Yfiiaj3)XIl1hK9r6)gil$=zza@GXsTC6o#=asPX80SWmSn zxF)5_X-Gx*h7J#(8fr`~eCUDa=dWE2%#c@zyEZ* zG;~Fa>ea~x`dwNpFDcP_nJO+-Q$sf<4<7jG%{hC2I&KLtO5Mow&%Ca zt0o`3r$_LL*WZ<*)?Fo>BG`f763v1_c&x2UA}d_uu8h)6pxe0~>}Z`6SEK7i-{>e> z#%a4916538a_O!ub3QxpfErU!V55Q z_RplKT}Pyno@r;mmpp$36yi0so@h7&DMlKQHx$Df3j&5WpX|>VwOviYj~(m^gDrm5 z%^Xwm;AnQlGpuza2efg(*ZdRj?6~F8|01MUU$j$-qBTrY>K%Y@*ldA9)Vd{G9fCDD z0;d(|;tf_6!QWJ1v;^LO-C`Nj`y@(VQ5!eWads)&+nBs({^1Y)n%sOh(B1UDPV)XqA0CA+c48!GYc)1VfP>t z*naQbe=c16`=*}59SCigqJFyBHKmd1aO&zEfI^&?C*;fFSRNwMDM6UTO_~)Y4Wo^% zGq{|_6=m$!@D;A=GTa%&EZE!0+K&AVrvA0(02qqvD+EcEBr-cS=;WCk`v} zqwql4A|A96$VLiqn>$zE{@l-hzP7%nwEH#tkx+HO%fH$x4KeciU{$B|@LGYeU6DXX zWVM!yZxcy0E_2x<(?+D+8Y|cs5a@gkpK2m3Z%nR#W5vTSocQ*&oYl=a-w*xn{6`F>PtMZ0Oo_>j*Jq$eJqhCJx z_OXB5h*>@g+z6pUclR8M1#@k0BktfZ!^%=1T_1(adR#j!(b;4%bpKE?((!|2GJpO0 zw|?KW_4OVv|9F8zGF%sk0WWA+^1ua9XdobglQ|YwFY$=1B^56?Jf^|HajT&0uVT!G zl9XRl!9dkt?^w0tu5}llI(J6j1JnLb%M>^ReJ=^oMdRAmP|>M&6YwrprJhn%7-Dv_ z7;6h!6K+qTg=@<3B#AFA@l;jmD6X;apEq7Uc=Y7***$f?zwsADH(B_+xpXLWHLSx` z<+)(DU3I0qT#}V%Ed=mgb_dp;_u*R_5Ml;9Q6xT>DVqpaB9yFgxS7Zz|P$pMBG>)=hg{I$$ZJ00;zBCgHdvXOG za~M;^CzDPxp_Bs3Sath5kDq*PPmd*;%>tobfG%6b@<3TzxPNjRSkJkrXvVB24k&mz}lERw&1thzx)1PCL-V94X;R1!DVcO z#Ch;v%Px_Is4S+p4f27O%@uRnfwo41(dQv_DQO7_2%2JIHDl>6RLa2J*_DV?S>{bLfvt z5jVT~@u8{on}=_DaT*k2cP30^;hs}G*|<*%D{Ncvp- z0~tb5lKd5G zfV1g+-BSicyJq+g^K$Ss6K%U1?zGrIiIG@C7J>pZ(pD33s(Qh!=7W5)XxB@d?mDmp zJe}3I>yC#csHZLuP37(Y+&H%hg|1O%JQ1HBpALqE&OxWbPml)ck$^Ku90XZy_tTHu z{?`KFCA0eOa$F-pbt4REuO-RCZ>cYYLf7d8G(k+9H$!6OILz1Ns@{pQT8}n5$E2vkE2xO*e%L+Y0vW7Ea;h?6E-^8b8-{9`lBI%o*hsc) zw=wzkp-11H`|SI`4`%f-e*Rd3GClX}R4e6yu`k^x4P6r(!;vFIx-6e(mlP~qxLVNG z)ozA3JqAkqPtU%&?dNr2#4kTv_uf?c8-XwH`$Q5#R|i^zyf8&f%I!ljh{yCcWNbkq zRi>)q5M7dRg3x;R^xr>!e+Y$qeC07AgyIUHoT9;jCB3 z3f&Gd5{=0<%XZv->ql#=$X9nS$3v*ni?*qVnt<l#K$gtP~<}r#%h!HS5fl3${asAtyzuvs-&YmHjJwTPBW~vt< zfpH-`^ZB?mq+>`j))Gw0*W;Zsx|@nog0`rNE)AxQ=zdc_kDbz^*)fW*j`7R+Vo7Iw zu+te$$n)q4a#ZajKoxU>Xzw~ECI%XlfBtXwsh!U~g=ER;eV6R%wI@D!XKNG+$#Kfj zQE9`9i|cgm364k26*i@YxQ(L?TRUAn)kk7CV!XPPn#skb{^o>2<;=Wg4*k)qa5yKTxpAh`I_ZJ-q366Tg)sIzeg zC^c6$uEE+>G*BIh=yp;XXs~p4Y%V<>RdT`Lw0g&$hflAyA?mtX*Bc@I@TZ-*k`PLW z=0cA0P*^Kh%9xr~$V@7U3*&OfL@Oc!9q`QyzIp$ygZEyJaPimdb0O5BmskIPF7$^? zATgk0`dB(NiebZ}Zb2##u?F=VCk)HHbdb6qUA^weyMHy1*bLA57la})=OW5X!JA*4 zE(uALL3gW-QxIJ8Agy7R=}l%`CtwwE<-|dP=_g_mxyiz^M#^J^E4nArcS6eJvtO!r8n6({z zxf*E6X`NhW!WJ)Tn}c?aMTW8XMh2Q12x$lw?|k#NhqjysW}De}-N{d+sB`wLMHoZD zOSZS65S=+}!iF8zqSn$4GD>8uOjPsX6ar>V9rKyd4wj`fWOrLk%?yo5HYt*zBiOob z-mOo)1m@+Ledk^5l@8BxJb(~1!_O+uk%pprcRfpykR|zwT-!|3#9oIsn{MZ7LfW{^ z$I^0@hIp-|(TLS7QY{@|gxSVAT*^WtDYUKYaRhuu%D`wpPtK-M)UHB}?CEqNx)7u- zvVhVoYlAtu!!h4=P+jHgfk31qp^@pCCst?oPk6o8Qp({lms>;X5HMRXt z3@KhAi>t+mG6B;2zSB=X@!oe&9qoPgi~ESkXVLJTM$igft80d(Wn)@Rmv_kpnM$ml z!1KfQ(uCRs;^)3EZ+&|1uPYw`4`=jUZkaxnbN@D8ZX6khana4?Y9J|GF~EiXVV* z?S5f}ttjAk-^kS0ZwYV9zQr`d#T{ z47Kp`+<3QT0ZG+2%BY8!0VYt^f;Gp_?7wL?5ee2){C`8JF9aD-8g@<_04h3le4dY{tPsR?wfP(|b&t~7?J*5R>XTMok??LdxFgrSVW4NR*>A0Lin zC?aiw%c%o{E`0xoS0DLp!}~oBuf&NV)V&5jQnY8mBs#!?_?EC%H0a6GNj(41go@=I zDotcDl{TI|sAvktd_kLPls8gxB`YwtKVjkKA~|IVC$a*F=kW2j)_#23n*l`aJ5}ou zwaTU3RB+fWwk;$X?j)iaY`ez9O8r(9-qd_< zvIsL7_~9j9fGg#y_VJ+*yTBo9v_z9`(56$@@MVccEB6YGep!d-wr9q4X1l@DvNuR^ zBFKktuQ+k!okNcSlGFQ|6Sp8f_iy-#TmJ!Yi=~-rx~PIOp{}y0^o-G_*EU!$8uazV z2#A*XTX!Eh{>W(rOF3DD)y8x>QZ3Gq3$rG8tvEw z>D-7@73a#EL9r@p!n<+|IYB70lTG=cy-8EFjX`EVD~3^q8#-Q{+L%1>>E7jEY<&4j z#JfZ0KL7;z#dA}oNCUtB_)}n@@ff>ift+Z^2Q(?EtWK3;hY9qqLSB%t<$e~I?P^S( z`FhdHU+%dZgy!_Vd(K&j*zFwn#1Sy+VuFc0Y!vrf;JSl@rHf@FG~b{v(56MJpsKTk zXaLH5{M_;%9@%&RffA+d@nlP~Dmw$uFT{}K5&9R5Q6mNgMM5=_U1DH&(KBjd^ z4X{J(u=J;J1`s+2=kNaJrrZANS$)Gc4TQSmd=o-O2w(FT$b{EgU4pztMpTJ0YOkSe zrU)YDcnp`vnahO6rUeIIx$V$RZ}b}0?gW@upZ`WarQGY`1w$b6BttZ*$VuoZ1Og$w z;;h-AAWj_4jU+fyAHTn8tI`Ra2rD0iZNRhb6_1!<9wgwJd3C@};Dg9M{QbTSJJ#(0 zsMGYm+_TRj>KTOpng>#*R5g)NFy*ERO#+gSbD*${Xe}7?TwWI76B>37N5j!8*~SFj zO@NuEfi4uc4|>xhe0y@tP6@?86*v-~l~~GBi}a7P)q%XW!B^^?89X^9wQwYs z`~=1?HiOFj)BfGFe||rUh(7JM7D9alevw{-LXfBo$p%beJbkdjY_jy40)J4;7rR;P z5G$sD94()Q9x_GS760h9c*Prvo#+Q+&GE2GPL zSQ;7~wx|HYsTz`o$NULa$f&O&J4;0h`Lv5Lcn(pR<<^Djx#>EFfr@46HosU0w^EZIZjJ}&r zo&?JhK!XZ@$~Yekk&b4NA#&J;T_#mH!OHS7FwTMIjS>f}9D7FyUcdFp%G)=tfDsj0 zMhp<@Iu~Qxv3HcOPHY^6utl56}#X6?odzDE1td@Lfv!& z9jV$b*s~j8mkfNT%??JDIZP)m!;cW~gXnH`RLl%D!d_K|=@pZ$YPGvI~W&$`3~1bS;?@2s)%LHYd|_Y=nT3l~5;?jdF50 zQRewgjma(Zx9qw5mU|J`oZfe-YH}*wT)*fBkZ!zQ$R`+~5p3-dsX8zcFy;OI)_iTW z%pQs&CE}0VDK?;sVg(!3Z+s(7KYm#juxue zf_dPq`*tk*{H>Qi1`N;YlllGwp$3k=K7|-u3XqO8$ln8;fH20Obq0J5fgl>~O1*HN zV@&cy5g7n0K0JB)*?Tws(0ea5d88=%n*CFq@OAJXq7--!cGkcUBiSK(TI~@u2ZKXK zrzGUmX}ef3$89+L;l6LTrjXAYK3@f(`Ky#ue#(HyBpfKjmCI_x3?F7-I${tX`r(k3 znew^0L+m)A2^&Z3nh?K%#gw{PwJ0hyI3-Spdg86)Q}ut#XE!2l5r7{) z^NS?J3YKwS6+FHLu#xZo z`0l+I)~&t)Vf4VVeh5|n!#b67Oz_DHm%uJ;56Z4+E7*qg>>@( zGdGrSj2FxbYpqQHA+vGe%3FV&JvBerZ<&r{mVS8NvOXw82qmixg0X{9DVRA$G+B!% zI9igEPbrL-Gu5zHPK-EJZW6$^K7am&cRqP<9u1M^+7*{WsGo@cS9S;CzjqNpZ#q5! zfKItlQqYksNy4y;K?+23F_@|nd-%n?Vz@CvA1C+=3fjPs$XLqvhZ7o~*_CU`{fT&t zqelZyCl|bQ$FE;4`m7h8GrtDQP1D!+BW_!PLpXqt^2}y|*qJgZ0v3bQKB$dUWPXlJ zTP1p%ZZ10^w3E^Ns)CK_*G+VX#5BL$DbMkI2A5%!H@oENJ-YO45o}^6YPZ@Okg z1W>U>Osld;FAye%Lu4}!O{-&S7=LS+EeCzz!6)X;`}3y{5QJt{pVs=g6eYi+HRS=+HzMm8{AaKM zX1*@3JT^ASoUqcpap#zU=NlO>=8~cQyttZ#^1Xh{{FMCu0b3%c;kywRBc{w z?#IIZB}{-RtIEZ)KL|8pS* z62fW!r(noc4~f*JxF_Q>Q!D9iM-db2b3q#$XR?9Xa&XzYSD)Csc2`f!*I&qlP~Gni zP4&bPc#C5-=-zXBBA;U%04m3x zT=L0*KNc+m^k(#(`_!dVxg`z%oI5KGG1a1yqOJ-PoOrB+R_40#gW*8}M;jgE=O7;K=Bk%czD%tVbaTayD9)u+E0wHv5u}pCuidtP!`>HrM*t@_ zb|BQ35A-0TG<>}WxU-z-^;_c_VT9xu!D}M?R8X7N`fPb3q3y#POt1o%aCXL$SxKra z$X6w)A-C5(25T+0ltZ6RaRhEKAN=&t=?{*q`}*Gq+ve1dBEYs4{+`_jf!lpvnHe%uw^-T@3!U7+`R}u|1jHFZ{CgwjM{%Chn4=j&qkH-dKkp@|8hML~6x> zK!c%W=R+x9&P>dWM*?P}jU`veCklL4GZgh(36R_B%ep6sHCq?7@jFkid4AEM+j}<& zOW>3gwRY|m2tyon zIn2rXUz@w(DLf+7d-JLY4FUX)wFE_m{4&_x5ngtj#M1t9j zE}fL<2P4gnvj=~D>9h(_64nwyXjR|^ukZoNWtQ2nX@XtXX_rSVtYMnI5GEDdahj<@ zCi;q9W*D%t;;|Kg`Bk1u=s*pGYP={0TKo7fPl^MVm!Km^aYm<87AgYAN3Adk;yv@|7FAVODL zMaY%yRv|Pd>}`N8)tnzbz4?vxZ#>v@QHg#+iu!!f7gNRKhKvxbeWB58*kX?wGlXOz zI9`f3sZLS1*&WEr*=2v1>`IRX)D&u_pJ*oXxpZs;hXGrVdAHrX?fo_L|AVOH-M`%k zM_0i!c1xiUOJz=07_ve(*J9#G7=tGR*;pgRXx1+kWPJ%t%#{^Z6g*#OXj~v3Al2$_ za0>G7TVJpHY{Q-FdKSM`panxc*!lPJD;AzVA6#>wQ>~!_zMp|_>J6gU7~ei#Xs2A- zq)jbn^PnNEyRm-flMlbR^?#tw&FI_l00c3R*^mt{eEm9c2%Gk@EG)ST_A&>kC8Du^ zv?*tf>%#d)G>j?6x`rZHoi07PYSnum{_$Hc98qtLBT5>FA6txg@i2i=O)=<$MrzxE z&&0V>MNQ!}!p?M=hp;YL)BbA>x0dcP>8lfdq5zLRyw8-~G_96G(ubIBJJbpZ;W?N;-B})d7_G-4ag6 z@tFF9R|DjA&07!t zaPR9Y!0prYzF&qZ2)qAKN-t_1rf6v*u`Fwy-Gw{uIyJfWm=yUwsoblXQh4K{H>4q%uG{aT2L@GCak$2-azg?)WrSFk zj#OE}mJwT*bj9I{I9X}gjE-QN01xum)UpjD9P^KbI$dfFAk~vM&)xgmJv-O*d~9K4 z7b0B^cFrq-vkfLRJQ`s%y%L`}XLp7K<$i!6(YT;=K7VNI)~$=51l`BrHpv^Sa zuCdzDW6Ezlkz}(ixrG&7l6)0nx6QQI>1!~2jjjz2n z_h@e%sJ+$;Ee8Bg+6o+)uhW+$iUI~t>W)N*t zIHeZfVF18j>3s{1EWYn+W>X4x7xS1UElSk+wMjhgEiQX@U0^)p-zP#^X@@XpEIOFr-;(zUMv^e)acT$X;m{*fIJc6mI_6sf>CxY+mFBbq5{6G4La{kp$7;R%QCT_N*6c z$K*mrC79E1IkD>ddmlNuwx{zyCx4fsUN^slaCJVs^dLBU#6v_Zn;-91ZQ5W-HJJCBROTzzs6I34Y2n8xhJ@h(U z=$8%A(*5FUzsNGI6;v3`y1HI77la{(A3HE;HH^}fkq*fewd4{u4l#`HQX7*SwyfFn z)%~|1r*<>?&Ro!)5)Ov_vx~s1ET)#hs}dHQ30w^jWRGY9!-SX^?=d(Bsstfu>6dmP$MT`$=R?C zgK10p`<0YJJR&l)V#Pp5O;L3xWLQij+-~5}xfI9~XV$#)>o2!|gj|4t?SZU!7kMo_ zyb$1=SE*r1LnU8J~=(;(E6`;i;3ozq~z z+6C}S6dYKtR1AaYQKBnlEon`IF=yS)^AN#&Ss3h+jTYi~f!>BHjmhV>et!Jb#}3`v z(@yc0_ob*G-&l`Gcp+^3@hbpL4-qx4%$OERkhtWI!*1o*%xwx^&u~Cg&3Ktjv-}dG)h-J&kMBQ>S?ZOZ= zqD(2xHTI9OA+t*BY*~2Nh$J=y*)5ug8d404Vtx^4)Ms)TlH|hJ$jESm2P*rTFMd1n z-O&fZygI#a#ny+B2n)d{PLsgWa$rOv$i}=wg$CD`5QBNmLMe1eqZ9p2sgaP$bvqM7 zF{X07kh2MDP(BQTcFpUnPT%#}2>_f-?|WY!K#0|0RgxzOiNRvK*_Cq3S~_ijG!#hU zx`m;<5Th+P!8VU8D3wy#0kJqyqGmJ!6*oP|X!diIA$FxE7(@`@_clCs;P4@2!8*Nf z=<{%OGGO%g)}-bI;yvqk`pC(tT`qrk7la_gO1^vBNK^|Noh6!k2sS(Trnwo2fNcDJRUW%&HX@`dzDxW4~B_x|A zwn5Y{C-p~T;(~mnzaqeihrw;Y!kd5i`-tf<0DvwF69kMwwEvS>7mT#6s4E#Nc9a!{bk_+x*#ILWJZ< zdljPJ0XUy}5P&pAVJ%8DDIy&Y)q`UV6})I=sFUVS2zVThO4iks8|kP4Y$o&7xEreC zhYWfSI4=i|f9JEeZvJA;vN=7Y{dQvr@!2x`<*6T~0BaLcWnOPIN>-axj&Pue@An22 zjBcVqu_ncyXwdEg3)asUKXmGg2iNitrWg$tqB9M=_P_-oW;!lLGuOhyv2KKi)$s-c zVwHN7*w&eYxqOEQzCGvg{a16Q6Lvb*V!gv;!mMM*-(hfz4Co!cd zQkt*qi|POhw`ShH`%iti=@P_N4k;Mue$o1R?BJ5lR=qS|Lf_!AKdZ7D58Y-x7>sX!hr+l zE&>P)KdM(!!}&r;J0|Z>CUs(I!|d{Ma_J%koGRQmYE#Y3mGHJn&{Was9cN%rYY%wv zBj6UgmN5>>#2A*<+0Wx;3OH(LqLbBiLUDmY2u>?WKvVlx-2KtY?|uW-XL{c`SFD!q zoR$Xcl;Qu*nNEpD4+ls=Rx{kKwZKK7I zt_z85b-baHad$DC2A$T0YDy&+@>1)imb0Uz>*PfbPa2y5W9*-^mmYonsZAgDTxB~d zi0ID&|7!yh%EKYNA~;5CO7ZatzZ%UpOLE+-qlCBB{LVTx!hlmTZrWMZa5!Wk$>XfY z(h-QOZybE$gXi}BGo~u)WAp#x^I>s%xev& z>sg&v!RxQ+>EUX;<)e~g!ycNjDp#BRI@mK>iF!xK38|eLFOLH>_|LCy`DM%5XZ{2d z&+Pk~`mhxBQbmP0bqBtT6#;`A#c3K#!oE5ITXedI@_`(KY&5GfEPheovTI1vpv{8q zg7eipJ17p>slH;6Ovam4U`knY@8-{s&6|r@YI@&i)ZU;#fVbWUR&jFWfHF|G)^L%` z_$Y_s6NgNuP{bE2i@Q8JJ;@7V`#tGAT1EE}>jPbHtyw1Y3o~w3Ofsr$2;fFKbOV(pS9UmlV943!GA zW9rbN8i4mPjJ7eX#~mtmKz=*CZr;Yd>pnW%qiD98!0hPnh3F;l=-P3xR*}I93eK-* z=wqy!Sytg2httC)0r8fcJ$y$C;l?;rC%vc3kq#b9P32a#=4H||&-hX-jx|5)x z2d6{V2oWAHge@9?2eM4VWV|&_XbTCNHpw|b5-H8JG2K9%kmq9CcYu-kg!k({#2ll2Up)r}F8?xdi=p7SGQCFM! za)rbbX}i{U8w65R`VP~A~2fDb`y1_K3^Y>+Ic*_N<^n92^mUF zk`DW@Dz>Q!{#4wy>+=myetrmCMo;hi>iA_y(2c`u$JQaM5G}e*ce=I1Sf8OG@`*Iv zAYM-nWHUA<*Mm+4-3?htN%Gkw6@czM^6poQw|srtiO{)t#*GLaEiB|70hm|4hg{-VEW@0j;!5oV&nf4O2jdK~3au^CjNEeA zFUr{iZXvza2|x^=%H%*){m$wmPkem3htb?OpND))34gb*41oIV1cxn>mi&tF62r!9Nx4df$E`0vDOa4Btd+LQwGaU;g{9?aPqm^7Otr_rHjccEf({%K#=! z5jncgBom6p&tskts*;4nWgH;tw;mLih_+zuRi_2!gn8E zjHI>ceVhN(AgZpz8*lFi7if@4pQS3z5h2%<7-mW`9ciuQXhxNGie43E$OB@m5Sx$I z&=L*3VrW^7k&*CtX#%fG;`zvl-KPtleBrh4e(iy@->mBWA~Xvw>;jlGI%ibYgqn?XEz&H9c;&z3f7^x9hI>6U2XE*Ko`^@bt zTk@K_LG!Dd`iPf{WvDS2cEXg`MIt#dS*IC_O(?++azZe={dxD6*B?GP--Jl`*}E1* zLI}QYC+G@ph=;W)mn3e}NWv*{ja3;e*xFW3*H>V0<*{+F$NF>gGrzxl&k8UC%;>w} z^9cxz?A)C24Wk5c=qk}bC=)DYbs|@^zog7ODYq?A}jv5pChi!7co;fNv=KKaCO*lFz3=8qZh&dz422%{L z4QZC%K6J;sJD2pjtRtKLgIN43_zdolG&DTkt=9E|3JH?otE5&5i*`z~c|Ap$afn%D zHU&)_(1C*b4vG6!AdH1LR|_Qm&F5+>d$BA%-#OVmYqFqSJs7) zPgvju&sLz2cC@SOGJMz?LFaBIm|-2mAmk+q6pbt%?6?9fky`@|Gx)&@u~p$Knfmge zPf2PHv)}^Or)dvJH9V3w(1-j00azp&*l@T-ThUGAre z)1|hUAmeby?NkrH(eE>2a0L=Jr7+0GhE&1M#3+f*l#}TlGMSzri_HcyW3<$fu#yB< zA(raoF-{tVmMDTFu=R5{{<>w?;U3%<`J=alp9wqv0-C?7Tfz>}a)V?Ja}dL*4TBC> z%cO~DAYaY@V8`y?=Da+0@BhnImK62R(caav3*LV4RscCvsF;e2UB$`A>*GaFZiLbr zQp7C;ZFMXZDF`|SbrBjMQk?8M1DA)*%w=S7T`O+-h4d;D}q`9KgkmipCobiz~-rpv(VJKZGW@O-w=kUH; zp8RmfGsk<6zh?E^(F||9D+qvXW(O|h+|{^eETqZVGZ8b$V8>7FeC*pN-L#gu1#=W0 z8pYDEl`)GuH>Pu_6>>k$3-Z{8vuD0J^mhtzhIy49Fh_)^t&&PZxWbTun=fd&g`#e_ z(ogF|M_tyMDjH|S2Ri9WrBIhJ>kgofvv2;q>+iE*`#P)7Rue%e-KU^2LDnut_;W9~ zOuEWJL61ny#EOia78pz+EHQ1+wcD-{;PAVjeeR>PFM<8stiDUCpsN?m$b$J}=d=sK z^C0X$0J=tsToR;vn1ZMwjJEs8{ZUQH3zwsexW{I#8inIor%2aM$_Rxlej)~lZ9efrGi6tIMkaDTIwJ0{;HkDZsO_+tLlOsTSZH-iDwXJE+fU%9M@VcM@v~?+= zu6|Gqs^X?OpRYT*^&kKhX7nw3c80Wf+8Bqgh|UN9m{;3`bOoQ*g#t959u_AWG z2fm=q`iC{@03}B%hvi+q*yhRw$l3~y%4vI}qW{OzS1{aJTwC|{HlPnHLn8Pknazn`d72_{y|kbl3?nm)GpuxSxuVhfX|Nm37t~9spGxj#6tDfO?{3 zSu-}~i8Xv~Nzh`m2V?QP8f*lqQO82LRJUlrBD&zkEl+*&#s_;}0~B!c8s#DoLwxrBik#m>uG)OH zDl1KhDd~#TW*i`r{+yJ~dm$dM{0x@4qDl7?Hw>g=i z)Zp#+oc+fA$8PLNx+$yl+V~)j~nF#z( zl$LpR|Vk#DH)a6MIy@s#JxG_{c`_Rif{{6^-4_1ZF&-$yBrH5GG z1i}hksZk-Juyi1s2&`7H<%qIP5?zI~%wi(aSdLllFSSw$Ta-0QA@Dwa;Ke()U-Qfd zt95&!!;h|8CUX3b;bLztEmO%+2r>Gl>S+i#F2TAjU?piB)^V;&83{NVc3V0j3V7mZ z12YyRbH;_7sIQyS2v4x=0y;)yMa|3tf= z;}=So4qAd;^Ou0=))J^3O5UUr6$evD)j@ZMEXw2(IGWr=Uq?zVXi!xB=%%w?`}S&- zfwpOF^BXH!7#q2JS5uuew7f)PIfk{=9i427z%8mMEw_zL7r?5Cgo8vHg_k7ghJ8cU z=FT&CS)5Z;bGN##w6U$xku5E;sT74x_b>a-eeRss4qUhT2Q2odXgG0@kDZ_Z)9~!I zWy(b9`eZaQ~J4;_e=%+^d z1R)CzthYZq`@}o1Hli{6_20ng$8z6Z<=!9Jp$!Z2FG&*)rGT|btyE1xX);kK;*%qH zJD!fx_2pcqjV+PFw-mZ7NEt$ISz)){&ojS~XWIJ#|*73r1nU z=HfAocyJ`KNi^P24`TL)y;~nT_r4A4b^Op(Z6ko>PR7Don@}VRT{Z5)WkT^Wc!T7O z8V%JL4rzr@(ux-K%6Y9ZS8ext3+Yn2#=)!Q2p|Qci;cgo!_je zTCd;z19V2%h~$+8++YW@=Lz}pY+jAvX{*Ca;7?xp z=KW9nX6Hhk$i+(AY-EtM zlqMKhqEPhMf8?JZ-gVXX4FbpalPgv0KR-u@UW0yzT;R_`M1laj?^m06)`-<*9VKG? zxrZ+FRcbkYK;|bW1Z->@4_V^{_kDNU7iWEHL1X*SH%h>}zEO=%1r~Ysr#LhtX1P7| zBBpBAdB{t;2G3Df7>I5L@Z^oRU4Hu2k36!$A-y^J+$upr*F+XMXAeQ0{a;e48}Y{# zd~#h{PD*oRTp?RChUSb#oGazzl4eXrQ4$zKx#CPR>-4i3uh^&^EX1yAAvUt&aC%m! z)Spkgan^!pQDLN%k-IonD!n*wedeqnvfQNCz%U#6prOngj+&f`-M1XesKmA=uVXI_ zK-Jp${lf=#fAzcu9qIaVrTe8Lu9M)BNU-vx6IzuU2+*R`Y=VmwCpFe~bDp%=0-@zF z%L{9Ykfm?G^v@UHb=}#hwsh0leS*~{+D5h?g#lAAYQR%0#FD$XDT+wc&vkYB` zEEv0%UA2m;i1U3@GB>1=FVoo`uRYcTLhuujBoq+0m9{}N=Q0K;no5$UYw7!XO))|A zR*I5DXD%~%$9WtOSr^8dqK&DJ3W{+@2c@cAH($2rzUyy?d}Y(xk3ab#I=_EFKDiqz z<$oO0JHRgr)n}4|LA{hW43mjk;8`}j>Jc5*&E8jE`TqWIP-_vO;61Ri1R)`3-}HRyYUYbopexMiiaApR6?2Xy`)v2-PE$ubop%7#oF>g>W@6~E z3?YR$;-V)GoVfJ}P=jw?yYK<0dj0E7D_~TKh@X27c$E?(QG??T3fUQ5VKHzPx`Cft zYIc{pL@Q|#MrCDR&fXX`V0zDd=;(WIdk8eBo7ZrEgx&aggpH2PPY}TqV%Q(OQ8J<6 z><#dWq{T;E81*8hL)Y>R(s_=RT(^+Q8D}Y28%?!Yk-aM$mnIgyS08DlAz|M4(UFh7 z@y*r0MaM0T+<|`P50MYkSEH^{ zB_pX4C!yUiy9aV1DlD|6*9fUi*kK#*z?KB+izIS?00AR(HZ#663hwyyWBY zOzjmydEEQwe)Ys_|5&wsPHY7j3J`(uLx{I<+hjL|_^M1mg(1}OS{&b3OS5%yQ+)_! zsn>3N?!z}OxdDwgF!?wG>Qcv^_9JvktO%m`0n|MlE;rIahz*gPFW|AF4MH!QsIWI38nblvhA+RZaa0uqygM0&^CXHoZmV}k)`_XK>gmsp*`TrPxMGiLJ@`}*O<1+aIX^xZG85g@W6@6>dV&g%gcU|IB2MWPxtcl0 z)JzDkJ^kLBFTDl~<~FVUzh9q={#JrqdVE5i%|pWFvcT3hN*3lOOQgs&urNs$ zB@YL1kIJ@%m{uISRDv>}uUlSlrrtgu%Ntqw{02wTVwcEeKC3k|S{Fv9OT&<>i^Mo~ z(PxQ~tf;98yG)*;jTV3_=r@-?x#iWzk7J-6@ce8AYX1V6?0N^{QvgCw3Tf!F@C2+f zFE;Zq3PFl#P@F?Cq5`DazAxqF@uTcvhb8A~Sz>oY$rlH8jl9YZIoAmamEKJwkcRUp=X*g(%msGyz0gjR-(AidHuObDPK;!KE1*&qc76c>gye=BhrxvKH)CX_vlEwki-eV6wu2fX(e^pWQR3@WSs`qv@iNa8_Yv?SAI@pOV4XrwF*T0K<;ZZTmoA2B+&rHaD7Ca| zQW2>~eWWmelP7Gu^QpgYJ$UMBEoDg|(4D`dL6>{P|n5D6>&^sH_0`U z5j)3cd!_s-4LY$Gh?P=$;16(_o)}0`Pn&#udbxK zPf4T8;AhDBr|k!gs=qCxh3Hegk5Mtma@f9@7|=vaV>pPOIPRM7PJH$Yl*M}JT3WhW zvHpiYytYv{EF)L`H{ev9yr>qp#=2NOUEg6^cvutB)THE8#U^7&76dY+fXM8RBxOdN zux*_eq@M8wA6$LLYX?8SexvsG!ueVC`pcjE5$z8f`S|V6U>{!!FhfF3k*n5|7Nv5C zNm@!(Y`xR%Rj6GfNi|W1gE&*%-&tft79J*L(R#FwPQ<~3isbv>Z`t+wcSnQpanst@ zntz}HghPgBaiFwoQRba_dcM?;;(CL+DrimjXlYMB*CFTV`jjLpm~EfmcEi@|(6jK+wfd_#_4;|7CpX4{gBWj0qqHGQEH9oCT>J$a zgJ0-n^x?c%tl6mS1TegS;=KRtC$2@|L#W~%dNGuGU{JjEEqkWOYQyG`Br^=_e;1ym8yA!PZSTp&|Y!Op-(*zO$C^P2Q+G7u(E+g{VJB*CgcT?bbB4Op+0&-@8l79KiPHkH)G$N= z4EezIul)P+GybJOH|P^s&neeWe*Sy3<8V#;Ep!||EHTAg3s=WeFQ&3_CT}X$6&wS_ z-*0N-c8z|akOH>(@(r*5<<%X>LuGOETJQ)5Aibx2gm#vU9P$Qe57;cpNEpv05=K5r zn~@H^$%sx%4h}j~41(o|ymDKQIdpVJTwYcrk>cQ{bM%MzUU1vTXKdWTUKFgDitC8Z z1NKp8%+;_h#n+RtdD($y!6PDHY3TYm#hQHT2X19)S`YH~EsqWJO+;6$FZCX*M^`?E`rOMF7rz z@8)-(eF3&Xa2=bj@Od8c&JX_=a$&@3b4nz9cfL5D4M~{!%#Kr(V2il%rI(M|`4WJ* zhpyfDEx2&}4<*qD4e<8L=o`ELr%b z+l}-0L4%>N1ANXSo4r>U|6Q#@;p=y^+lJF}#B>l}P4 z9MDGCiS&$OU?;1kF{5iGv<$HsA+~JbEx0^;H~{?cwzr=@{Gr>)XqOmAtJUj&J$+R^ zDj}vvfzERnv6PTCn!((dxLoQPJlQ;=Sg@N3KPkB^^=wd6*nZ!EFK;?)C!`ZV)%q%q z#@H0O@da=X5|c}6mVhAdEi5<{dd$RzF`fGJ9TIHfIU=^;07WuFc!Ozx9(_zkG1x2#MVX9<*CNTY2EIkRN=$6E3U|Z=LtKgw^2Hp@POGSAnQ#*mUHHd#eu|0+#adU|-Ukp3$7%bW zz`c3;#+&as{gN9t)UH1`^+`196-Z$R)ClY`@0>M4NK}5+Kc0|1_VUc4v}LW9daGxs#7E`43BI4@vmRRm6 z-yZSo`GFX2+y@`L@6Qk41xE^4Ev8|`KI&YcZT1mM0noJHX$=xSKkOD&C>__5hmnNK ziS9J6YXE%o#TO?&ck_cEp#=Ry*M55VeKx^WWgVAE7GLUT9A+m^FlXDtVLr%gCjjTa_2T`{?mOpR)ZF3F zwY`7Ysamf{0vpwqJaR?ma(R{@WjRbm$tW?M%tF1Ig6d1UrbN6_$iTK`VSn0Z=b(vXsIQ_e)b`KqoE=4$vGgKV^1rQ(5&4O*Eo~bMA#Nf3nnC&sNjtG zQKZvb5J2+ej|T}DYudA1Y6Q@^Jv$!0{f76SgfO2qfE;I7C&&Ym3Vnji3xJW zW3h3_9n@JYWh|RE@$rlbp5T@hI&K0M9#!y>3^fu@7HLp?Bv-(Ymc%JOt`P1~&pdM4 z5xf4r^Au=&(;7*jL5I#Xji#Nei&G57 zXrwkd-F$-;Bhc}Aqg4ti#j^+B{>!dM?^<;MY2S}7CmLc6$$(H9G50EM3$AJn;aj0t zr2+oHDLh+h7@3SyAFvLNdF=at-TU!3=&WsC`|#ucQm;RaS$Q*7kT+GZPB;r8QEkiO z^LVV>L5;^V0cDD5VY)gtJV~NcL8+=y4f~?;ImRZ`$H#I=FSnj>)V4EUzZQ^EaEy@L zhxR6dJoM5Lu+?MI`gVcWGsUagyq}Smw+QS>Cd*tvs{X;#kL-Tyyubef{ng<=Yofo> zAn#KEp=TAfi@1PEvQFCSyig;gdYUc)#?=v)gG#?~9G&TtJ&TT_UL@NCUK66`n6oZ? zw5+30Q2tsksewhBdXU5sw|&8ijO1042x0kPwkySpTU~fg@sV6 zrC0fTL%(y(lp?JzlULJPwb|S_%_qTefB#e4&pGY12UfM~-wc0_MwLdG6E;zPfeC;Xrl;)4V5Fc)tW0?exG<1`IWRhc(9axq}8B*NR%P zb&Ab`X%&SsrfRxWc^5fLDlAZ^n3a+Y?s8k+diU;6FMAGkso%VI=WjnztzR2o5tDy| zgnvMSg+l9Sb#(pA9`Dw&V_sO!RGKCourXI6k|0S`k1>^fJ3AI30)T$>6~}*j*Zz$> z;I+nQ%Js+p^jmZkWXO&ypm3+Owu4zi2Moz-3d5M-pqq>a5+@i_&>7ymR#@O;{Jnan zlQASbeNUJq3ev~QJl~k>3MC;4gx!`8-ro1s+jmLPuhw6&@~8PBa_5dEfs?ZM zb4yDqP0bVg)2MlbS;kt}kVS4K@`^nh%+EWgeE;s=lfHa@HTBQYBkJ|t&PO&%gBk=U zGeBt!E12PVbiYTZZ)+$-YB|87V#HFQs6O}H!Sims>Cr!-QB!;tY#5FmJ2r{~>&OKX zka)QXLDrD9s3NtdtydwZwWg}kFp`TkZf{Xqpc@@Zrm~T-j7ds*NsZ7QJW0=sm9%Un zRl}SRdxvSuJeVkhrlYMU*Zso`V7UK${IM&K|DJ<>?v|~5G*K`j(=&gj$YMJYy}+3X zxO-T6v&JV6(t(!MCJCLLF)*5@8G+76ifLjrrWCtQRx$%?{n zEX=Vs3QXg^Pe1zX)t#sl;pVlEcipU7e~hv!k8_c2-$Hp@TEw|xGV!uQ&Z_u9VVE_N zh4lPDJDPJdQc|U_-fVR`MZLn78VcJauc_9VkV!n8nG0Fl$1k3J^(oIky8$I#b4U@5 zz8rGVWuJm%OBE@zy@rCWU_y)Ma`n>BqiX7Ekv&>7r&Dc*SEW(e(|%?OSU?{f`PKt( zUA=3yS5+@P1Z_r-{QR)HAuT4U7;UaLm#KOsz8o0KWr#tNy{?`2luLqT2z3gb-zjfG zxSjjA?N=Xo^1c->$1>)S1kj&Zht~M#@HXTiko;Ke7 z=kHH{_?$1U`A;;|etrk&uQ;Fna^sXGAul`v1>E0By~C+S=OS_AO;JJSX0&5WS_s_s zP$9=D58UzPahH40A0Hw(T(vI#`#&~999)3^2^Vhukd0Z|#aQ2x!_Dv#kr*Y~$Iga4 zLfEV9#r}q38NpRMLxO= zSb?rYik`Ax)CjVgs0KkPxOxuol4_GDa?l{W<8I(0PW4$O5UZD=QWVop1lJJGb^$f(i4 zq|Hv)3%7oE(TDGSd?pH8Y+n1~q`#@wA5SIGzWoY0j|*ost6M5)ED?;YX<}kaq7dk1 zZ5}mNM>a74tm9bU4ZWp?M42wNNk&2G zrg*7+s1Cey+LrxKU3&NiqH$jRwT<)k+*?84%nT3eI0=$qEJpN%Pi#$c*&Q`~;q4~e zONlGXO539*tAv=<Q z=*NaqQlF4jtejCBW2DBOww9);VOEq2x`|3VtJzHjf+G6(xp=K`Pc-TbYlkhz^(7p5usm>BT%5 z^_cTM9{~D+B-`Si%m948^59=j`PakGt+xJ8dk>-m^m8P2Z5GrJ>PRflNiTg?H53fNW=!6}OY^;6@j@&P zrqk7uXVxiD=3=QWy&QHBf*Y4^(6w-L-+s(xXWVnotsB7m>l9#$9Dmp!g0ax&iy74XqJP;*8lxd1$w5$;Y!PR{%n0Y^NYz!f+Id*>ZhOWlZSJc}SNhs+H#BYy|^Bwg0|d zXFj^){=Y#m9J=<=C+q5U@`npG1(HS$G*m&(|EnMBmU>}AQBdlz;=x$Rkr+t>X}et} zF9h`{Uo7QTEP`}oKHh!88K+!(;M!w15Yfx8gnayJ-%46PKyKUw`ba`CkE;Y)OOl^j zNG_~$k=aeB(TXIx8{Dg04l*#is#$$~;^#XC- zH^Lb!sY!-vU5Gjs7cWC3@?#V2ASkM5%sd+lZoi~HhQCB7`QlG@{QazLDEn#C+9j8- zjCOp;;g3O$-c@9gr7JEkLIO-amZg+5RBgl?2?ixRva$jXRX}a?w9gKnu=DcAS8(3e zn@(1(AH8PC~*if>d!aaJOV4i$o)dE6e7LuAOL8M5R=BKu+iYzE%Y} zQaPYzdoMn4?&IfPw4zv)e*Z1H#x2NU#Gfj&6of`jQcWcZ(GC?ymPnWw^CHCNvZO3V zSf-kuDJ6yzVL=_T_ggR#0 z(T;>HWVeISgqiNm&TQ0}nG&RHI?cA6Qua!^wvJp(Zww1{yTt;x=a>Ke@^c67eEX)= zxIOe+3%ZknS>zdJMOLE6y6XT~ruiv{A^tGjl2XiCl+aOiGUi}2>L$jP z(IU4gvT3^dh9EGpR{Fih(A$m8D9H3*YK(v0d-)J$cU?OLTSqDGSeG z4ZmFFx=ZBaOCc3dc4bq^*y~gaGX$Z^;$}9h*7&%P))?9gS&VKq&1OE#Os8^--A=R6 zo1~e#?6^a(V@9G~GF+11f9tZXFJFBZ5CJ!>o%PhJM!beRs{u?)NWl9rJgzE`=_ow@yiu#|Noxys@89bpT1Ed`xElL z8niMhd`CA-f>f`7S4L`qVK^@po2RY7NS~=T+;qK<*&p}Va%`A3v`lS5@bxV@andG( zr?C3wxgKn`_rLJwB^U17v9bH?`vbcB1d+d-4tbo=K8)kdR&i2EFh?B?9;sAJXe7!~ zA(Sr>y25lrmZpX&I1PNchg`|b^A&`F%DH!*c)?AVyt@S@MSR~v zzCD}f*U0*)x|)m53&wB|sikNAB2Frxa$8gO)XEPc`e4JFW$U}?>lMqFY-4<(3$!H^4AXo>a1TkuXzJlY9LFof%IZ7TW0cc zk21 z^VPp7o?21<8_3gN;Z<30$Y;jL(kU885SYrO1*j4w^uXtM-RokzjdgM$3Pwnpd)DuA$BQ%Y7!LyimAMuZs95{3Q|Dt19 zKzPPOlvx6=OTlo<28OLl1sgX5f;Z@`3SvUUYYaRwxhYaq3=-old+ylz=Jf|IJ{!7w z$XZ(klz3G8BShX=0;tT_n~OrDh!PL${asywDQY)#ot~Gi_tew3L^6Ayxnij5x z$2i5Fs)a^ZlfxLJg=Fx``Iz{kZ*A2*Whu!k&v}V@OlQKelLN#))@v)$8i7XDj14zZ z^O3eA4Js5}UDlA&;QfApBlg~V!<|>1cJ6zt@z0&OhW>pSIcC!~xb+dSEb-hiq7te+ z?p#6>$lc+561Y(;0hqab_v*Vl-~Iksuz&@o#!ph{?`((~knk+Ls+xw;z=oTKvTDe6 z>MB+>Q!}H+=W`3SoJou9__0QAta_vX-R^qf>?>b<_}SN2|KI;+MGEgAd&mGJ(HQoDETV9>J0moMCK@FBFczG)5n#j0Fm zL(VdGV2Afw#5zhmq3erfzDk^x4=*SSRnnt(4(-iWR}u@fI>L}!6Qb+Xk?4>~%+Jk< zKxEh%b^9Dn-G_r@=!>iG+~@|!Py$cg^+enJNwry+9OkG#+?d9|Tl;tNyXlBzOQGO3V0 zip7>=HoKD+pyQOyc#x(h(BgQ(+@Xvr%JDe6AkvI@5Kvw3h}#0Iysc+^``53pJ&59t zo7Vi_9ES#U7*Smw0xf?^7q=Hfb-Y~JV&`4sshsS}>BH=lh(^ORW^qkyG?Vyct}=}! z?D%svi=-!rR_6{fZz@RG%L7%$1$VnI&VKoud!BzCMI1J-J^B$ioBz)zH1r$zh!+79 zGkqi<5o(ompE6UG6tRJXy+@1?J4&s1z$UOUgRp~-CFw=^KCH;{0tu%kLk+lqO$#RR z+{Ps7lr-KMO zC)nCm>hnXS7&}v$MUpa8j2BEK1m%UY*0E{j`iX(1 zf3gn^Wis;4Iky9;+1+mp%dMshS9CBq>QQ&b9(T2s7NVC@T&Xlx5EwE9a2-N|tiiVD zT6lP+Ki+cbyC;2k+f$!I4P^7$5!>JyhU&>HGyX%7H$>o8_lAP_IE?pcQ*@9g~uWIA@aHbqq{D)QUCYpxT4GC*{gd*ySNzPDT>zi67 zePz*#XVOH{XW)yG@j-Fn=GPaO5+F{?dcBS#5z4h>wwO1Jc~c%t zz@b1ma24CL`;mKZ_zPglo7VXM^`Ge8*FeYvD;)Q9R&0?~H7MA$pxY{|JX{x*>X?Lz z9ZzPM=LM4{_%u7$-=q3GOF1K#TQDKacV2h+vpbJFenYSMf%aK+xKhY(ixNJ%2KL~Yzcy1PZ{&rCXrdAQq1N_o(|E;>k|egVU&}cMfnC2 z*4)B+v>auT`#@(&}A<^`{-&8&Ty}YKtbfMN)|jD ztPr}ixh9j|n6U&3hl)~{lM)2h$VIp5D~zs6ppKhp1{>ccZ`-H9%6;t2vu}IrjwgSO zcJj1etk}&Zr1aY%$RYhfl@gy|DV9R1O}CsN<6fF5$m+;pEiW^tPTPS-M2Q(F7LtZh zFu{*H04D4{{M3s-KYlypPlv7@dB{6ZWxVIqjSE8x`OULX19r4{qC(ncR}W<7e!!GS z;KG@@Ny%jTt!hpRNsjBp60OXM`D;$s#LLv#dnrp+IMwWOz?AU3Z(`0Eh7H~YYfcgRDYK76|}tLw>^!fCdX6M}?FZ}Bw5Dm<}U z*VRG=K%a6gSCu1Lrm@MYsA{nZx{-p58tjKOe9{OWnT-!*9w8+A*Z%vor;oh-va?pB zoxR15M#*oG(yumw0+lIDN*WaXFq~s(?P}(9WSfC!p5Dq*yN5zT%H*HTG(we^p20++ zytwV-XLf8o{IWyQgmuelTQ@2;6Xc5j1@$CTCN7CEwq!?0bw%tMKfX|R!5b6Naoa`e zSv1|g-#>+v+UHd`mjW=Iz2K!IUq1ZBtMur^W!AvJ1%2PM{oWDEEN7r~PQ$?f(lmGt zRZCA4A&!bgdQdtisSAd_T2gHImd43+VPa9M7={<%ijOY-6zBfr7Ya+O+v=xxSDSN^0eP^6>#DN=EKmP60E0nX2 z+;RXsE0t_lna`bDi{U;yUvvjpLPk}m7Z-|{F=I9rv>kkv)4|9j(WWwhkc<|i2uDWA2zo|>D>h%xLy&e73O~^-oaFG z6Nt=P!CI~u$kAP8rKIK^<1WH#=Xw__@ozS}_+le+%wDv?DG9J++cUL`j?WZ511+YzPhSti7 zFp0di_BK2UrxyrXc)m5|M8ry=!ndeaBA%gc8A?aGJns0)?=E@#^-r$hqif`bhp5W+ z_{(RZT^b`hHzz?~6m-&?B^+y{NU{ZZS#UC=OGJE(0D)ZazJDEc#98P53XNCuf4sR7 zuZJNIF5&ri6*)H1X^X_}6dTelNE(wP5RQwjBSJ0}lsHn#%+Mwv2s#8##kzPp$I{TXY;l8V zVHwK>A+1WV)aTL#BfK6$2@}ZJyoVs{`RZc7nWd1;*ecniYXn$f@7BM6_1IqyZlFLU z^QwrgM$R`u$Y9MObJ<_x4NUwhN9(AXicN*rLT^d5jRYsnBv2vKzV*4Azj*kDo9%HM>rY3A;rGaq zLbx{ImSeAEnj(anks8l0h_wB!;|Jb0<$UA_dokmlsq%qAAYPf$?n^a`aH%%KeEEAD^s;r$nFXu7o^UsGnE z-+0T%i5zZZ!RsxGHjN`8a{P|0UKh?;>MA2h1%#bRY&J&JYP}t{WF<~t6_2C{fM#|+gF{N9CbKy= ze_~f~oa1JakTHeoVWY0gei9{l#Q=kO;^C@me~S*16;a<21g1h~;Te1IJjS5Qba1j=ud&^acbFwV z)hB@5HP++$CVpo^nyW}MSdy?wVG|@E?z;D$r(Zhlgq0{jY5$*%?JR#YXf*_R(HxAe zL2@jS%8{~~P!4lDQG3DJ%`wJ$qoW|=3Y6};yr1%0%C!kc-NLwokfC4p`i>9pJZ^^0 z;+cZ$(GDh&Z)|Yu<+$B5X@;ZeR{aErALpOResCe_ zXRDBgU%U0e=ePg)HaG+}t-bTcPtXa*BKdtV!R&rooFAVH)sDc7Ol%`R{!FD$1jQM*u!s;T^w2{O|t~PS>Gn8R9l8 z0VC8_tE8APm5_C32Gz2ni1)e^JgbpgPLse6oa8EXy*wO*^+C* zkk)Qq+ZUv&*MpVS%LKnc-uk@~O2Y)KsvS3jD}*XtBN}z1px(tVEOTnvA~=uK24;P< zFOq?qHbWmlti3Fy7*NPXa|}Vb3?S|ITY*B zj4X{=FI2j7>MmxZlj_Bu1F!RnoEx_PkJ%Q0LeLnEF!mZetCh#k>I{Z4Qr4da%4ySu(fj`WOM= z{%5{<#HDwibq2%^Ja2l^d8+lVt{94ftxi?!M#r$G>`Wqa60(X;-7uQ$Q|iybiqJF3!)= z;R+2LEh(n=xe|DCsjODb#W);SUYl~LW@6JkuRHNrhdY1?qBM?=Kl$@LN1eGqKUhcq z1sZ{MWb=!Eh5HvVgr@}v3WmCE!;vS!CXrN@2RMadw_y=ED*XH;M)&F`Qhhqj;)Sf{ zsI9;o)`HbuTOlsQh)FobuYL6H8$NjV8-O4-t-ULipp9=vGS7p(sk8|^+?p}k#rfD4 zW3yTaD@OXJC{51#OEGLD(9zDSW*M1gnvOb3cqz0d9nCehTs#7IuPcxE=Ex7Xy>`uN zOrJj#igHrxswD44o+LwgQ_!}|l_V=(Z})J$mZ4rZ=?i8WN?brh)I7p4)hW+N7EQC% zFZCUEmQl>GYJXc@wznrZ zIzz>`#o45qJ~k&hnGLd184ril)nRZHYq}d<>0DvRJ9!KwV<)(}GE&x)Vfs{nZ`^vz z(NFKa{dRZ*VbhuvvjX@H$Zu3j$BbG*5@sYD&i~u)jY=}>LK+$w1BA+d5i}3= zV%IvW`8(9vY*;|%(S@2k9_AxXZziU;AdadtDU3O2j(pYx8^9B%e);XmJ03!51Dn^% zTPW)FPvGG>Xf27n8wRTffsGlWP?jDF(=e2B1Xi1iYayAnjBZye^au-0c!{qsCmS*@ zCc{bQ@dC~nK@X?nF(2-_`@xU**wK&w$62e5w1mtLfihMTlNA)pn65c!QdQL~J=HZC z%X)-Vs$TMg=?^dyYjQnjnr8s0U+b2cjkIim6n*?D&OgRFGDLxsAnt#MdM6HcubEz;!p=<`CKxML8r(UR1Uhv5iXMB9h(HlecE84Hop-LjBe-3D< z##H1j+I$at;zJZ(H{Dtnh32khrBN8S!am-J-v?J0Bi2S$8d4TKemHKD!`x8WXqxLK zBi$%bgz@{}rOVI%;1v`e*u3_i(>GP?%~PI3|AL2@_L~92;}NP=N0O@6Rx{XP*%mFv z>4m`*TlN(VrBNds^AzKF$k1Q@;LTmHd~n|C;&A4VUIcRKCoiG92N4OJ4q976EF2uz z**s>qp-3rUk&6pbt=Y#TyE#l#L*vC*ni|Nmb{&1;#Si}N7_>|S@7=z&vfCvfszDi8 z?ZN7_qH0?W*a}nMnk2~vmr;g;w?g4Wa16q*KYVuTj%Tkve?vWb#jjS>6bW+LuY}61 zq?QO<%E>~>fafzgF33~!Vhq1xw>WXpxzjrJjcY8ddzvoqOR)GBTmS2FvdSIb-7DEJ!k2iS~8(!qeS@>!* z6$5YhLc;j*p8HQe>z19UkJ+JXKmPFt09qV=58SQx{zw8H(IfC?G$abHqQZlBH57Wb zE8{m$nIa{>;Z%XrXkH+M#mQ38>v!|{#=MtSXsPEAQ>VT5#nBfXzUS`MSN*(sIJ#gc zi1e&q0&%w^%G)?`3Di)_dAg@a$MtMu{Lm@aM`T$|NQ9HnYMwSp-Ip4y5wCx- zoY3GR{L1@BANcoMsF-2%+RGQ1RO_c6x0*jW@>3E3@cL!DWLeg{23Es{8--)KkcGB1 zQM95yC2X?kltXC**KxL|c|xRHA$f@=RcTo9I2=Q_$3NiHCN+;AZpG*R^U_P+KK2&0 z*t>ZxaQQF5K;Wh(b^TFKY(Q-nG7yY=i@SbIq*jJUVG8S_x}Y|i$NuD2M;~-4ny|5`ZU~|8cmwmMr4-& zV4zFOcv%Tx*&3-#!E1t?=wfDBcOL%83Lg+s=khKo@4l~m+Fg3)d81Rsjj$N<_dAvr2 z)MykDqnRSm#$+Xd!OYI^|36D_;W$@ybq&|j_D%b13r|~~mp1LVySux)-*I>MnKvb* zI0Og~q$GH7C>EqZAh^2~4-kTr0zv!jJNf>AIdksOeb!!kEvs9TaX{ki#aI4)@-wf# z^TlcoZ$1-PAs=7;6SO@6V(;Cn%(8-REXCfbDaylmXebOhfNh2$dX@%hfuR-VGlMi8 zxUI>uH`X1=8?eESz2onnU;f4o@P1jpwqpkf0e|$TJlfvRkk^Dz)6XxnOn9O@(JT~f zWV|pxs9EiTDYs?dg+VG;k+kzHqoR~jh{js@DyP~bQE`d!-Ittm+<~i}eh4n;^=n)? z)ZslA@u7_}kPWXN4z|K7T-#A2IW6QxFQ%9$a@kIV&LZ+nxr9TNisAGmEo68q{vT7zXx!+J!V_$9%RC6iA2U+BaE>Rd>ngs zSeqzh5)qE$)@8AVX=-Gog>v*NwMZ-vWroq*NCW{BKD_=mf3^9Uox9KgXWiPl)Rk%b z82RKzw3DPF4qN9DYYQf+$F5;pL7`h+s)dZoDMMAyVJ-0i0S~5X!H&~dg?ae?mOG!= zch`YcOTWOb=Cp$tKKl>|EpaTu;>L+mc0AiA6&F%^LLx2B%gx!?AvM-$eNZ)m zf~(jlw$7-^TEMC;%NU}7b%OW76S_?px>bxgm8=|^yBJ znRJ}ddJb4ZZ+yJ<%71@xDLg6HuU)zSCe?=DU$SzgP$0L*ft82^fzw*2NWGMzi?7ud zw835?&2Lyb{fW)#i*DN|lHzHQ@js^!TCom-4d}!_JGmd74p~^$jZ;+#-StIXF|dHzM`$h~cuZ zt(37Oy=1r?Z%#Q(reZL(O)Neae;9~NeQsU3+a%ga-F#lR%m(NIt&J{_Ga1dAszDa# z;FR3;&6_vA_{=GBbb&{%6QLmu4!Ld*9q&N$7{X<*28O7g8$2VHMCEDqyEqJ%7ye zPyX{?Xoc(gwK3hH-thjX0kp*>^5_t#C^|nBfDCLzC6yktifqaG}75cFb3Y z5;K4OV70`#$Oq~70G-CE2b~5VKSf+VVlf!ixTH#Our7ck0K@Gy`)wJyGfW6`@}VV8 zRTzQ!gJTa z#Fa8QWali(>!|b#;xLF1LNx;ti1kb*e>>HIwesEGtKWO&vX56J%lprwy6vS~-rn=jYKMkTxD{<#gZ!R$qAGiYPqc8^xhh3?UQOfa3PIOaBPq!-cpB_} z_mfXfyzx*S;PbnHc7KugA#?*AhS-k=iz=5f1w=G{g6Si*15vSu=faL%4(x&+w9f3Y zWm-pY4MrX#v*~1|>k+Yo6f(POY(!_sXqr?p*XuX9JTy%>L+#SAN;RZxKmGpR3y%I| zy8)f(Kfinl+Q}*MXt)S@hdv)1#*GZGkR2q16bXizR?y}bAR4pnt_#k*`s)+Gd;QmI z*F9`iZrHdHd#E((=g2A7{1o0u4L3uhP!T+G+M=oT`kKCcnpd(!Vw{14JY$u~j=YvM z5@D2-VI!^^#QEU5JJhwy#-W!3LgRi0L`wT^zi{iG*MQ}{ZtXm6<t8NFaMQmjE2}4`znk%oa+pqKat}6LXo8v}t*ft}Qg+IYmX7+KFValn@h= zP6l6OWr_Hph!LAsM)GhTR?2lJZTj%&54No)?(62S(TQ^+nV)+>dt}Or=88EtGvdq) z3|8-@ z!;$Out3hG@<9#vRrrssQEp(?g|MUulpA zp#41|(6tbcY&_}Nt;g)!v6|5@f4e#@e}v?9;043h>$w$7p%t;^CsbLI*Afq9OogIY zY6W~Ec~e~SjFmnHqQ}pjwy2E+c>Z({P&9SUV{{AfkAjUo>p2F0Cp zStm(KSjIM9L=kuJB3f-K7xjzS4RF3G_gSh6J>f)T;z2eyf|G3HiTn1P@&-DT>(>6e zTZGOj)SsLM`tN3mQ;C-}sANK>#dp&=;GOAnw{jB_t%4cEj8z1;B*;T_(i9i4POW%T z*srV65S7C36OEh=z8x9zxNZ`<{B~aT{%iNV_3)RgIo|TK5c(%pbyX$e2CahB%&LW8KM&V6~NG|p|6BSOfMU3|*R zH(&e>svrsSBbO7<*44;6x+f@##Chd1K2VieU3Yh%AnL?)PY`AnrJxUS!+NaO<3S+<71FeejLd zcS_DU9PN=2`R=Q?!A;E;tIo|%#<%FDO(rkQcrxecclxd?itzmOU zxIxpxYt-6ODTiJ#rWkw?y*Z;UgLQaX{p+T$uitm&DhYGnKR~1pYH87a%aK37nS>LS z+g*gBR(e!oRDi;|mlT#26b>35j)8$Brf!c7M2dpRs)+y%dvVJv$33+9r9%iup}*pO zz#Z~7*eExq@f4vb%P=@#KogIpeci<0`F^oXn)Ux~GQ{j?l2 zPUJFGd~37O;U|Cz?yJT0iX^RT44Y}flBuV!F+oo@lcLrPMBbF8wvfj8QPJ%3a^b=F z;&I1azT>e6A6$*j5x-j17tI|1^LADH-7rnjhCRh=IhsxC+|~i*kd_})<6Z2>nu<| zsf?4bLd4v43k^~Xsob$~r!E!`Y?TvqGst5NTTM;~Ft%XO6l^ETN{gB#Y>~WPr-nj` z_yD83`--E#|K^zsS2^daKiY_X**fI44?yw=YvJ^Hu4ddgD#ooEs8=JCaoV;D%!=gx zIWCx1!s6Ng&^u4R@c30|T4>$chnHS~{`@c`@D>y&$(Ugy6fjoW!(w0B8X>|=jMnAN z_;N(2C8^@@gV&q3|@e2BFu?M`=~ZA-F9 z(-@Y}8EdfGY`2XME7clIBizy$<8hfYWjFf)vAS-{^~apO>9|!r%~M-fX)6tK`j1Gx43YtCwxDpa(B-Od#B7zxAq`S; z0oBDG^#sGBVJyJJQgc!#+l2}mQiSSe)suK5uHKw=QbH@C$*39Y1Tu|76Yy$4TeSom z1|pTL^>I<|_qP2PoqN$!=cCdd>(*-beT*)8E+V6VBB?;y^n@(w8o^9R1R8u%M@g~J zOvGiLVC%%&auXpR9?z{4Td7i>VI4l7da7|i6uIT>|J--fLl;EQ6|rY=s%pc1{grpg zkw|$Bo*TTHZ_!}$>4|VlD3zM^NLrnsF2tUpH|1{BbXHxSnK0SM(ICj|W)#HCm zZ)%;@n4AI}OAzsmi2R{7IOqgmdYylA#c=(7AM}iP8-fU0~k(3LF2lTiXJ() zSX7fWR;^;_$*}gSug`&+o`0Wk^k)yex`U05^}0t^$j}gBy)RQ{*|&9{ zjoZ&#<)L@(_MjJw5INy&$V30R>{(R1ew+i7?*ypCLCc??dZl$zP23Cs9DnyC?>_kE zD>u5)=`MXI17WR8S9K6U1rUyE9;IG#-gY`P$5Y5lRPzUO`V^ zCZ>U;tX!1I!vb-_%ft{<@+ANa|JnWB$CsV*J9LUJdy|a*p$vKX$RC5LYmtJ@rj?q2 zKEv}iq=7%rl*@UF?~3^M8$8Ka>F#(1-Pc%1cMPV zSp&3GBQa?*+TEJPE*6X;hB(Pu72^arct>1y>4CdH`sX<`wB!HxkO-3&k(y3{9KD|& zaWWAj*WRnPqACGCH_Q8qbIr2SL87s;djPscicWHSXeg_d=5XYXmasSQN{cV-{H{Z0%*|?GWet#Tf=X)d~4^T7@XKFBvx>W9H zqSc0s5v8Y5N~tpB(O|*N^93nlP%KG{vxAhrTfm#787Jg;_nrI58#lc6QVQ+trR%up zj2(s?@el-rvJltRbGXJC{URq-)KttNu|A|IY*PYwzU9OYc)u=4m0CqGUo88$GR>jW z1k-&%NLuj2fxlPN<&ROk#C-UoiUV~&^ zF<>T9$4r(}9Hm-$WHHy>G>HvryspHGnMFv#Xidmt%pj+sfR%L22{)bmuNPNEbiYmI z&;vV&e0lG!;5_AB_>@L|kI&T#3|URZR}e*JSxlf7$4`*()FIPhgd8%pZ7cJ{GLpzD zFv){ydoJm<6w_L%C?@Jpuvxg&cRc^d*?X^l_0iQ@UB3Aax>nuD34TyAWU}~B=ax4{ z@*=sR+DK}0MUBPH^+GWmLr|dA+hc{&%__67@)E!S@CG~h$^&QJ^LiaU9iA~gtK9Gh z^;c+*S%~sSyI|f;Z5qEn2f2q{gwu&xZFZN3#hXS{%wobTVaqWceRf(Xm^2L`MrNk< z$HA^K78P*pzz2Kq){{;;{m~Ed=mfoU#{zBja3nAQB8iZliiE=|*U**Elfj{2q8#8m z*_ol7HX?j+W|ER(l0kE}Su^2Ctd!r{=X<6-C^Nh9)F=OQ_6dKxWcA(ONLDPp|3!)~ z!XDB#hrF~bS*sB1?3BqDBa3Y5zL3h8l`zF3DKXbOWZ`Op#?Z+Ou>v4I3r)S+nkoo| zifAMo5y8R@2zi zc*rZ)6X9r)yLld8uHWayYA#$X(P>nrK~Y>l$5dunbpZl>!nCLD`t0R^o)q-;92_n^ z6Kjr=a+0T9;sxy?0;GrTe&p#VPX71S?^l1oWv&X)(g^V+kOn7D#f^GK%nUmEZXYYA zW7uI&$h4Jg2!ugBssRWvajbP5JbbsEx_isD#~mj`JNfioe?UK8gHSKP0;!-YNt)XH zQK_S63nEUMFsFv{g=LoJw2oDle$Q4>4uDi}_ouDfd6XQfQ_hMy)b0Py{H z&;kzeZoU$%gY4m{w1e%=6ES^#thC^}x`c~e=%9X2=hln{enGDpabeu+bjD;rE~cG3$L z@Od-f8hbuG_Sx-w@87W+h;_POqV0x}-&Ib9L?DBn?p7=9*?8gWGRQ%FbT-unb1*k8 zib-S9Oz6=V!BFzy<-`g&T}5YXyg|;<gEpA*4L_j$j3e*A3m6-Tud;=k^SC%$v2+3gaw=+uDx!$k!*_c!c^7}wZ6LHJ z@LG0)GUd7Vytg{+4nH_LbRGZ5yBQck6B%upBQhFLYZn?vLGe*#pZNG8_p%t8w>$1} zTAQ4k_%&N#SdFUXJv^?jivZmAuM>A2^YPnvuR8Uor&k1E2<>(Q5rmqJVrDM(yhBY5 z!c&@$SC#X4)$Ovi`{;Y<_!Dow@)^{d zY~9*TKdjVJevAAr0ssn>KW8+=WJB-oN$ISv2q|~7I@7|U!L{9*G;K1BXadZ5#$uRF zEG3UY6N-t8w>j0qL_UHp2-TLMotGX`?emlB$euezXbe$rLA=y+$ zM=;e)ct!=QuETHP{5hFkAaseBO;*Pzh4|%|+a7%At|#wZO|t8-Jo@V(@~=27V~bJO zv6VgPtgt91k=U7PSzpWwDFZ>MovtpDJV8cSce1I|O2&&RVMe7TyXa=Q<|c(5=?+`{ zT*!~tx3q#dy!f}h@bTXtzx9ioSO0RvA6HtgKSo$2(1Z|BSOSESiHTT*LcZa_dWHCL zt#0AZ0>i|F-pqSuS%JbTXfS0?vs;Pa+I*_jIKKOeFE^d}>_4{y;Q(X|9*Cmd?jis4 zB7`yijL1VgQ&Cx=Jkz(Uw?n~{ZB+u(&K%%Zaq}MesmBCEYp4(^5 zs%MIWRkMHF-g}<7|AJL^1@|m)-|n@qkTD7(c&!C2XIIbQp$>8~oE#&pj+keOW0$JUfp){mkp{*>?S^^*HN2boGpoUmpNdASQ`wWpONIFUegH3kNMz zEh~=ZsGKH-*9%TU1#iL$s- zbRpgD^C14+`OiCFyXCY4hbSidPhM%*@R8eo{yUH?pbhZTFcUK}PNh`EJeJ4kl6Y*t z!7NL<7$_RXw{Y~4Mm`O;Alf^)>Et(G-~Q<;G^Nb|H$VS>o&zX_LEA=)%Uc3HkSJce`d<(2|7icJ zxKd15(FA^t{O0A06G-bpf|g2-FMZskKB96^X29rR;2vj zBS!^5{7r%IT|>K(s%^WOf?%%Z&pWI+Vj7&^z@DwDUlKLb35jh;2(mH5qKI9N%6O7m zZY#{`M6wdj_mkf~Wz&IetF+Wn=L^uY#ESg}EpT9PORvG!kXfDd zWe)LlOtoSHU?;?qqy_RIgkxpbO|1bTw(`7N+O zQdgVfB|dyqpRX8+v(7ALVZd3v>wzo&dE4#JcF<-{dh9&ahC3c!rG;h4i?_mM#K*bi zIRdvAp#)u`Xw^Trr?VraMoJcN^ZhuDi1Da|xZ*(NAJpe2T^@^sr4Vj!d+qFtZ~p8t z4|*5Nu9Og~yqf1w6ulmW}o3yE!+9q|l`;quIz`^#cBS z-KOi``{A5p(KDW6^>fMWsF%wmigJm5ypJNWl zw3KnybX(>^RgJx{j^FtB@r!qS`Q^n&t=f9v#R@u10_3X~u2EzKmP%THTIGrK6s@|T zZ<|FUQ`#l9IAoqtNTsPN(|LxmZ^^MBiO}yYiB$#;_RbrduQ~Rst3M^9oxAoGGRmE$ zBLxGT^mMnRG-D4+Bb)+{V8u3XoiE`E1^$TK#<0qRPKBl#XEGfDNl^pIlxTPfG1mQ4i( zJJ{;mcr=!xZ}QjO<1LRr@%Ilu{qDw}pdYpUgO!oG7rCipfTuPxh-3`u$++qi3sWJI zU)}8|RfBOd=E_qOl5ENzDmQZuE^Fd3Cx%dU<&?0Q(nYrj+v>$#M_>QyeHV?;R%<^y z7oEor^3WQjk)>_9uM(Rj~OUIlM~d8t42AGD(rPMat2mxQP})Y zB$MX);v^yDTu%Jx@AvQ9ce502^>j%BozXuafBbA4p!3F>f#85=b~t7=Ntj*zv`T~A zQkfI!CK+9&6=5$6LV#EZ7{r+nSAe7O!KSl5f9ZTY+Ejf1*JxA!izHuz`|7W=BvnZ% z=>4c`lPJl%pHQ+^X=jHF5w(pTE(A3B;)_xjlAEKQwkY5%+k&5K+ z4CdVANT`es`3{F4L-y+oIfC661sVh$dtTplGTbd3;^~wzPa<3Q;xm=w$&Eg=BS}7m5UrxfYh~s zUnCEk0V)QmH)L#Ybv* zxULV^KwAL@<+!iU-2C8!x2y(b{gz*#L+?Vqyy}mTl+Z}ahL(aS2n~mGOgL7hG|fX5 zE@&i+v%%KFT3aLnHI?5&mf=XazA+?VX{*tER;tYDmEmYYA9m0ddVCWuik)w~y6c}u zeSF{QPc~li5c(%{Wcvu-Gd9J{?@6a!CMT~+mgz*4sj%%p5NDub;&at~kw8zHYuO!; zX%_ZD?JkF@72V1}cZs-`1*tIwpSDQJo727`MenX4KfgXW019$8Y=U zlmkJu51)&lN4EhVdFb;!%B+K__4i0NCu63tm4y*q#+DT}20R1_C!1Ck64i*xk`5u9 z^A$#T{yg3BS)I07FT$H<`wCMGUsq1 z>P0h^jE%!|?Y)2h6Bpk6>}tBsJ7<*+IUKp<1PF7bp24)A4X0Q!n^5Lrg|t|?iLTYD z%t?-5I&m8Hg@DiIOD}l&T+ovhQBZAo_po1} zdys{AND}aGBW*}w{0*oS|)}y~r&gIYK%CKcBE~unbIc8!IlVfQ) zCIEujsjgo*ml2foDU^FpTDE$zr%|Qm0QkRn+xM^C_1p(vt!AxXkD<*ok)zya0Y2a7 zo4TZ0iIQ_`m&AF0QP#53tv0XWAJ~`urMv`mhGC%8WN_h7+jrZJ_b-2b(<&cvfA~DK z84g16gT?_~rl~HfVPe`&z=qWvO_`SyL`llv+=}tx++=FsnuKHa!OQnOwfoU~PG0pR zpIe~-U1UcJw126&tXQre%q&UZa^on~#=P1HR0%k)e!^g;0z$vS?HM$&JQ7?CFK*oN z&{LZ?KD^qF#lK}Bk$LaxV)#GE&SRmJg-fm_TZr1IwIox-p{3F&QG-3HH{4s!B1JNv z4L5FA?P?AOtO>a-EK@5G{_gwlyIXJn;g$e80f+x>RSS_rB0m7TLBW><1eJECkdz7C z{V6yzt4F+4US%sH!cNm>HW+Bbh?1UL2-)sbTdQf{1zq(ZjB$>s4hB$0-@f6w7tcQ* zl8Ecp{`0LLUDZA0l`G(r*_}46LU4#wvB}IMM50Eexe*IfoHeQ?DL}${qgdWpih||P z+@G7q+`!+u`16PNo^#p@7q7+-7yBv-Ushs9##=A>y)Wj9T4?UNIGdnS;eF{ zf!BMvQLa80EOQK#Bq2WTvnqh{?L6m%*Y17#B~$1xlEG=#c001HER&({jhcycJSHcms`X}G6R(;UogpqY%8BrbnJtrB zW&$3UBT@d_OR*~IMWsvl8mek%B4@S1IN*!B} z>r8fwp==1`5Jz5j`sa@xJm=K+R^2?J`Wv*H2=YHahDb^&kg)qCW1t|+Ng@FzSDcM9 zs4*y4nGl`hc^IGJ#D!{>%^&uWhW3!ZoWcW5)tpFcknRKvG1_(Ke{tCtpQEk=>(*W$ ztZKr%$bmE+l=p&`@u)+U5Cb9qjGYJDxc=DGlKLjSw9M@Tcx=lZSM2@Uo6q#n)8o6) z1*#24e{dZ7Q90zLt-n`fmGoALI~g&%M25l13goGUrno8ZFYug3+1E=6GlrbZPRuP_ zS(CF4XWO(M;<#|roT#10(jjKr_4p0DPCsy-3+>s7l_mPk90Umg4b}}h)lvxo+bT2q zCa!OmY2=meV#>0_M>W}wnqs018njG0;AJJH&1N&jC0I56OrMQQ*@Q?=HMiiMN?E>x zVREV(iZKd|<~M%0@uIK4xa{230NajSsR;fL5;_bhffmb>pXV2=K#LzVTIp6*<2Bm3 z7G7@PC&x)LY%Y)lm+~^zKe3cE(z(YJY&5fhjB{CYHB(8JZf4<0I1JMa&iCtHzVx%N zp1x_7Avx?|6#XI{(h)!@FgfYAjqoXw#HM0(xB)~nw)U!|x|9qh_Uw*GmSyKPasp~E zwe!l)Ucchy;}5X{WLs`Uug^8)mRo+R&U$Hh&<-fYkomlr>4~N^VxppVIYM4mG?uRFFUQq%a#@vXX z>ogk;<-+U4gt#(%x#XMFN{-CbmM_WSNxbK@dk(x6zxr*;50bgOryRSq@WLxTkFvpEuwNA{H%N z4m+QE;i~J8|JOUKel32nvURH=i}@Gu=xGorUByh^0jnaHkBjm6XpX@$(T3{JTBQL= z(hyh{rD*(RK+Xt+vH)P+zU!=Auipzqn{{j1J690A2ze$8d?}VN-JUo({Bl3Y_TsrI zWC*?=E%VT!&3WXI^D}7YDS0!Y%9jR$L<`bYkN)@Ay)S+Dz@e1V+x#xN_FBjX4?@O3 zTbP)_dE~Qazj+NM)qtSI!{4E^aU{a~`Nztv)9T?-kd9u|@!E(HX4ooW40B6g zp*N6#e!pOTaA6AuILo4Y_gs4WE9baZ?rSk%SOgsL0 z;|Xt{deI@Rf{TeG^shR|?O342(2~IsYf)kAs%72KSSMA9R)1_Tpp%C&rO!wvk>m^x zHRuYfg^+kUc-3pS?Rf8V^j)=XO>SMCTwLU58Nj}IQ^#OZk%Fdk+1e88?TL8~irXad zxggjP7+J!0CY5Z(ZHk&6TQw*1VnG)+_s)~HpK$yBgITn>TXZWrfd$$BG1NM8V%hdM z&o{ezJYR$r%Ehr>(_kERLJff`p=}tXvIubolEM^2j}h*ZLU6QR_r?BaH(q(jV*Tl# zkI`?mAje;^ga{#!r3%so#7eA;Wffy$8`w_!R7$;4n7}vFfegcmm5LR#k;2T# zx(05eYY7|-hzvHqd(OVC*FC>`HC*rf=oPd}KSv(FkPC4?cQMO}C?rxZUC=IB3_+95 zjrC0hvA?w-@msU7AV7l<;KA*?{`2H_yMckZZjCJbBf0|rh`jgJ;owsmH{+T~=F+c~ zI-tC-UKQuqCfc$?$g>zWJVq>if#9SFCf(x1(6L4#=LOaC{ z%W&g;w|;rt&PQ*6POe{juXl}V1M{%=(GxO*?EVY9Q2vmVjZ&GDy~j#NjCL=1qWyAS;1oDa_Z>+=j3dF7$8)UtBqsQtJ#)-tDwe`dEbgqu!%OUG7$De%32=@>QHan{pJmipK#*&tB*h9-Fs9UHXVLCI!#Gr{sGXuIC%}2 z8;IumCRrs^$t*KFWOfD~gW1odFTzfCcFL#XRTVy6%_&=CejG$v2fw|3|81|I^2};n zj%9y@ww6T_$rqK`%|B*_T7s#iNTDrjnqf>z=Nb|j60VgmPMH`QJma&(ph4fK3~+R; z+F9yRXaDikQx|@;GXK0RyI#G4@z+12Ls3WGAp#{+53XQxYHrzHMmx10 z)}j{+W>rbKlATR8w#GojoXwg2Jjg##Yi^6Z(;o39c{PueUIeG0OA)|P^m#bfu6ujW z4?mo9=^^&R=_jVp4>2IWdX)$vhzSFixKtyeQq7_uXE+_mS?aQv$ncj<#3Ft|NJUku zqF#^}&S%aSHk^emjTF?~!Yw%sLsJYLgU0Drmags(S0`|^W_N|%out{|iY z(h=t27PPx1q3OimpO9gfxWmf@{WC&o2b>VnQiJmhb&s7pXE zc3yM#`Hz48FlyVee(k0cexly+df^WA1J@xx+6}Olu9{ZsorpKCC)dPXPrXWy%KVaa zspuFAQ_IZE(;N%yAiFu5X(jGbL>A%F%0r4niDm3K*qxpytI#NhnoimTG1RA9095_^*}GPYq4Nt5`WZ50@4KhUvL0ih zxU4B-6g-14wA6ZbQKLpx$E~EMh0jTo3Zp0s!^m@p!G2827cYmT`V|sVwB@b;1U0)ayPz@7VJXynE;dIrq=MLjR40Y}q6Q<|UEl5j%w~!ZKsG z^A!zxCLtvXCmk+pY9@8mojEBzl*Nd(;4n=hRZ1SBIm_yGlpt8GrogfK<=xv(z44em ztIs(6%9UAg7P;W}DqzkhTTT$n^m*d#9Lo<1ye6wQ$>uI-C17vLW|AV@OIu#p`@=W8 zF43TaZU5kLv|AexEeEP%>AFR_$Mxb^?5W5x%1|71tfQ@uYa(u8Dl)?o903NwmaZ&P z(s5b1%Ux@aph+O?5V2%MJuHh})l(l3i z;dQ3043|6WBibkqted3)pG#GfKgBNeNVqPN$x8#iieUz`0-0|z)_SChc?hJ_v$DLI zNo&&z4R$?8lQ#uGTz>wvi(a|zjI$v%zHaR+(C>jigxuRfSkNj^l1g+9Ampu;TlwQ? zP8#ZZ0{IFfVVpZlr7kPRjONrHv7n(6J^$D5l04f zxd7L%N?l8z$cUfl`t(3l(DPtp0Dbc#IcZDpq3H#4ZJEMqH%y&gT1Z^>5_+6M78!Fa z#DPo#;qzA~z54zgpR81KWR*>d4M%NVA#+valZU`kiI!sW+KhaPFA%lT3t!&I!?+sM z7=f$CiGu-5OVbt`+Uc4|k$|Xd->&l?zxw_I9CSSP9J8XcQjy7BAhY%-vOdt|V+pt( zk&5xqoK&!cbhV1iZq5W^K^MhOkz2NnA@J39BGVo=Q)?=k zI&~=}XEb~kw!AgefDvk4+-Y~}CDxD~p-drZ_r}o|e*MuUTMpqy!z;9q7vCL2lVfaT z;{-|^!Sk9H*CSCf5u1r7RsLnjHurd!Uj1BXa};w(e`XHRGBGDlT*xqlfl1kH#uV{g z86Dz#?RZuq?6+QJouh zC`?;qI@4h2Morl=%wZNZLPZjDH5d^QTmW0Pp8Vh`7kqYz(DlwWThVy#N63Fp0osGq zJ_%41ZQU|nffsf>?+K;Jf+REQOeXBQg2PQPLP54JmSvWROs9+7_H^^|=CZm_!9(*@gB_m^{Y7uKXpE#mR`XW@Fx-i@nF`ApRWL$iy zSY7ZtjgT5`8C;T9U$QP|C^bgZq$Qm#SZ=D6j*Ctr5k zw};@z2lrag`6DBjJ^>qns1o@w5q%2Z3}l1DZaAovyLFi)0+k(jnjp(e*=rq_e7xhp zmZKj%=a>st$-l%Im!mBliBxq^bRlI=l?B;=o~vjOcq6C6xo%ApXwpqM8XZfK!K>5f z%V{W`!O&#YxfdQSZx~|wyD|+N%n#nM`}|wZI{}S6)~_8nU#Q;jAM;AxGly*Y&t7HL z7IT9Nr+G9J#jyh`(@+`^BIO1*%eGj=+@4jRq1S3-RU=Hbh*DE}!pfYIG06~CVX60| zb9Mog|5cTQ)^4RZ+;9tQJ^G~&FT8+(t`J{w#qrc4hrJ7L5<0%Rq={;l9G&XcF|2{; zIK%2@Yu#Gaoftv5lphh>&IQ3O*ZcS|nmhje!P`f@6++uNwY$1Z7D(;)m#MNxF8$pg zVn*xYd%Ofo#YT#dVyHagwzH1E|LR+x0@lN?*A&0{UbVsTE7l<~>m!g*h6*I0 z8VAvcqkf> zn_)lz&iLqD5VZhBbEXIH}I*Q`5}&_kn5FgPca3z&9)~`{qmN-opgu{ zkoQY5Bb=~X{(0fS_qLpVXk-8A^#{2e0mSM_hDuq z8vvRzEKq1EiZF#Wd6^Nur$!+zEprb}w_u7Gn4zoP038!NvQ!%}iEbSdxL<92a^ua% zY}~v$oPKlBo#;0lhTwl$13*!rr!u9+T%PXhP?NM_THVtq!O}j3n|E2k0JVdmWa-7U z-QiYx?GA<3H>1r`X-zCsRaNj8_ znk^k!3mQSQ$!Z(7IOB0$8Dvi;%n8oPuhQ9Edy$3BHgh6limS^r-0V>tqE4!0+*K~Z zd2dUAlPq~@HoO4HAio{9G`#TK-F5oCZ$5PH*+leDl0U(sALK(0ye= zqFP)Wq#4YZNuSe|ExCSPrmB%TOP&ain4wCy=xw*A4P0Q>a19}f-MRDGYhJqN!Y@`$ zUDR1+jl{@lU)%xLzYLKm6Rwm~;!h#YJT0u9wTIynDO1obLer8A9|AN>Pam+2~(|X<7Pd@FVx1}4odOOe$w9SH$ zSW`E9eO|n)&X9>w1%}!5P?}t9u@iJdRUgGyl{qR{XtKpf_ z0CLfvo^jdTr(b(3lpd~MtGx3k^@hNXDLR?INB*{HE3EV?(_1lE`rL7VQtxNId_{#Q zVDutOq(%{S!njN&O=+1$)TqS)S#Tgr+_C+dv)=mlv(?qM=j)X~TLU>c2G;}w+u}`F z!+?(w(I6_V*M#TCGBr}#R!fR>goHTM3^_y2 z5Hf(u&?z|xqQD>nd~2WI{R7T>_S@@y*7H2;ne|tknq1cD$HtokE$_ z60Sj2WNWiTt{ycxQ&X1#KHcgWr+ChpgrIN)yyZBUG*K#ZRZ-6&@&*(qBhc?cBI=Ga z{&LE*pK-BOv2pYkY|6~YAsnD|f>^~BXH4+gXkXXH@m)4x`-eR&C50R2ju6D?9=C*Q zr9sfpwVcY3*g2s93E<%F0~hRh>=>-3&X$e+!?gh^7wK$(1JO?^PM5_VtT3_@Z+FC7 za@f`JOq|KC{Fp7@Z}z_V&nHg0a})Xb?2L$Z8~%>sh#G_g!}TeQ*8xNx(j~ zY@DK8!(b>oLe{S<1E$5_|`{U);e!k>EQvJd}fO;ek$I@BMg$wRt=%b=;my)9gJnrBWS-3<`*zPH}^@T&W7T{9tW=Nyf#9|v-G z7Py_v!3ejMXd1|z7+v!1_{BiTmvEt6i>_-f;q`Gy{rbCi9RC(Z z%-FK=gVWaw@xKtxRwJg6bLqNHias%_4pYVnC7G}*#o%3@rnhmzrd+xZ(wp*(hb^{f zG8rp-C7l=O&d$(Z7~~+Fzw3dM9(@1W9MJdI^yt^tzdv=Y2vQ?li3HY8p2e%oxixA$ zuyWL^nqk3RYB2Kz>(WvkhRxh^S;|UKHNvD$JP(-ylXBZo4_dHUzk2`v2k(1$&BgoQ z$G?lo?>CU?&kR~LPz##}exXr|iuOrNSY9;+J>4djH{<&R(zohi}C!J@X>$V&Wi2Ujp=Ij;kaVv?}bCUC2@P zQY(j8#~wGvm1SF$G?tiJbHx|OoAL78pjnxi0O7ynt;6r0b?<{Ots6Y>=-i-0P<}YUs!BEeieFDykc1Qma93Kfpo^!p3Q)ghMj>(1=@2vQASbJ4 z8v|(fyFPj7v%BuN=lS*WyyB^&uwILiOJDx82EFd95fd9}a%S!plP48g=Hp?|Ivm;Z z)p>@WhAU4Ux(dwPOw)vW-nW zw~CU{sohQBsJmGsdzdjq@@jP}YOhY)0FxYf_WFn4e)>HPwxT~G{SjLZP>(nVNYl?n zB|^+ToRjTCw}qDu;)EQhgih+r7>V&Jo(5#+kuyFy@|PpKzJ;Avdu4j0BXy|FBfZdVix(uH?2S#$qov5zfN9cf*%j#p0uz#3lst@rF|UgISl%4 zxC30ohpyfE+q<9Nw03`JxpsK?8baFoZ@3`2c6F$%NP|J}pgbmv@_4S?#ZINho#240 zCpjmnLe4MZ);cMArLjOAN~GIbs>1pJeB^ZpE;|0@qd(ewi0!DXiS$24uDS-;Pde|C zp`0@XM%2?a+SOQtXt8OJr&c?ndKy_ z*(@-#=4iM%BAA^???OSffUh_#mV@W)-gEEun@Y*s;^6c8@C9bDxI&=GA0vFx=^!cf z>Xbp14UrSA__z%vcC@g^1{2^a%eZ-Z8=01E6c<#$B`m~~E~P#jPYMP`o??pd&^k#z z;R-8Mh>dn#_{lw&zqb1q*rK?=xmMa*kplQNqNGk3$4jr&ftgxTGr5D39MP*9XUSzE zrAS{+XG(*|7lKuF)+HAlcgim}eJjpn7O+kykqf{4J{YHWd7ToGQ!9u&yctWT=J{mo zm`oJJ>!;Si9G01S>?pT2`GEr8V^>yOI$uX}l$n}TvTdRlhZTw1m=eLY`P%ERpK{Ta z73>pbN3Zc(26EcD;M4Z=piCpxnWg%g22D()%dLm6IM#tl23baCfB#?<{CC=umpc2_bGQ~{76SwGgan4_vw~O_K zEuBz@L~36>NHPxbGGhkK;%y#MknZR=-QJ~qtgY3ivqA|z;^jRLyz}aD*KN`xAO7(R zSYSg!Y9AKB2brwN%FId@sTQ2ZDME(UOH_qwPN3u33d3W#hDa*77G5xqk|I8)Agb$W;g32zSAn&S+>@Q!}YU z3u7S78RJC`Q@O^3G~Ol8-TcVe&;DQ0?_Y5r!G>0bn7#llnP9F_MpAN5hDgjS<`gIn zSB(;q^R}T7HE~)l@MW#oRx(Rb&U5#dKAtVB1|`tt=REMMbANx$TFggVtT{t^1va;Emj z+HJ=^*1~p}0lDMfAYV2xYnF(|tT%J3xmLDajFTO$9K9~Atb9$ruh5S>l14K}MM{9D zcePlgbUU~Sm(i+fB1mKr;q~nU$jcl!>EH*)KelNBcO@-`4YvZh?3wGJX0x+w7HaE# z8v(?rI$youO>{{uZ-GkW+uZ|1k2iZmyvooEB}{?2k!TwcE_gs$d^4hk$1zxfrjae& zoHIbDw$s(p#`Ia?8eRKU%9Hf{360EAaDz zdhkfiPnr1moL~T0r5ZBTxW8o>uQ+=ZiaLBJ@Mksy%;G5JmJ+3 zXtrHW;c3^UoW{ueNf5~}hoTu%S)NS>{HUlkCpzb5)N6 z%$aW*=uUyzQfCymywv#m>@{9xc*XI86`Y& zs03P;IJuOSV+z2^j>o<{W6#@1wqf6JEiH?E0}0ustf11<9kh4+?qBY` zY2PWEA&w4WCTQ=6$jLwXn+E+J$3_!!f`XB}-euOgoE#K1*nY{QAMg0!m75=0ugznS z^Rc5ni;N8v8$PyhEx~1 z%@{&5>a&CI{q@C%HoXx4=i+~1?G2H4o`DAryEzDz(hcWCXDjiH#j%r@)%%6`Qefno z5rb4_X|@RaLdD_OY>v<2vApk?H(%X(;VvL=Z{0Xb{*-##Isdb^hV3Iq-AV!Tz5<_R zsnpqo7QbUN$Du+tTYtOh+J|mfchbCLE#dDY z-y6%|q^B-$dW4e$saHvEK@~HTKHY4Hl%9dXl;K-QrXU&e{CjrY_~h~TAA`M(wrrgF zhzA?hZzAVx-vA+tNCTUTLko;#G9#`>8+Efjr=p4vlpJ8!t!J?{B8L|!!@5S>ZJiKE zeh1s*f(3cU8~=Xb*_$X>=kQMhL?>de?|T{Ylm7vK3NEY2uN(Lw7K2=~Mk@?F7-gNOY{ZZew<4)l78v1Yes<-v zM-JZhE|4GGyMicxq6jlR z#h|%WU?o@+4tX}wK_u8@_MLK0Fwa^A38|`En&`GGqI{+6omv@2xq&}TyBrdrCLVd@ zix>C3^e+%rZP_^Rjs4h1*O7C#ybFw!D4R-Gn&1WIo&iNbPnc^+X~rXpIa zlhGVvXm~g5KX02Xd+r|%Pbry=2Ptt`{>fD^Jd-AmD^H*L-pX(m+pJ=uG8SE z+PZ=M8f1`y*T6@cgDDh^#p zpw06Ulr4`(P5Hu*)150hv|>1%R!_Zl$o&tqCYzT+j_DC4cc};seO{6pkDKgy@89nn zduT0%-m>wN!be!M3gjg?E>Vx#k`kikA@J#SZlpd$p$LdMYAh31lcvQCKEm^5B|YOz z2l7VUA0~8V7L71Wq)ewsTv&;EYB9atpCL+1h&RNlM&L3(_0XYXUwruuH8$**eX%ye z*oy4E0u=ei6*b4~4T(*>e#TQ*@j@QU%NKDYVX|k!HCUPA9Nv>3Ny5pbNMb^@QhnJ- z*1LwfwwFmZ&HK){q~L+maObnHzjMx0zgwR!SDw7C8%jm~AvjlqYA4}-7&jL5iqeQ> zsjpUQfN0cs{7ku=;w;-Uii66m#k9JSN~UF-+-|9Jh9;AAU&SPBN|i(ia&}#D=?#Cp z{Nzn|l>W2xuz}JcyY^zo>`=VqI<%!xphHr~6{Z}4rE%yZ28+p0OUjM*PTwEFyX#U_ zpT8XICc(uJZkHP$f9|ede)jz4o#~mcH4}5>>xz~dRmU|wh{+{Pgkuqy%cwyl9uUIZ zn1kY6G7DpWuGbn#IYWYmTnV=PU_&hrvXZ^2$6mDhG*jTpe0JMSPanKzojbnW@+kJD zDddH}fhU>2ppCShLYSv{BUzb@$AT`uHfT@Tt@27UA}2569&8MTTkD9$shmub8J>W(XSQd6gbS_-&8p^ zK;qVXwBPNIm~-jMWN_O(BEwQ{cE)o?F zzO(*-4MQENUKRqWyUv~%mi$?b&9-!T-NS)WF*LGk4xH9X zB9V-%P>;u|n$-z)nr@>(`bZ`jm|%Imc;728eDvE*diqbk{VLX=64?sYVW=s*N`y7; zq=IC#L1izdXPJ)XNqWPiC#W|$t0B|k4p*xsWt-SCrBl7ZkZHEqyJbX_%Au@mgGmmk zAvv-A#5eZe`O=Ml+O+#Sk8zSsA{DiqLr9S2COAEjl|`MQ4Ld* zB{8a5F1U5VGCl9v2XDONiCbU~9JO)$##pnB^>K4ks~kfzcY(U;r!@w65tD*An=mC1 z#q540y3ojKW2()!Z#=R}9OyY@R0@reHml|NK5uT~YCO#R6l~c|ycBHp0~h@H=1-o#bn_g!HU9&w zK_fz=e569HB}Iw_PgNY%p4rGEJBT!Yo};%Cdk$pPjH*o*}(mj!&Ja zQdJm_b$yaDZ%aESnz$pah0yKHzkYhdNq>B7lgM+Md#zq6AzywD#TO|IEg>y+P?tDr zbAd05LJpx>l-H5wRk3Q8h*xGFawDn+?CIbW&z}0b)Bdt46FGlR7`s#b$X(~Z4o+o= zk*Sa7>@`bq8k<#>lmUUmGMLp}_k5O=h%KRrJeTR%QVCyMNW>56M3q!q&G~3DvaFXZ zHG_POiIAlw#7S!1*Qt z3d^0w0sHil=k9swAJ2Tg_CM2Jw@wIr3-M#sqqrHmiy5Gcc>G+(-eP;kDQj*O`yD!V25m(i>q0U}$T2xH**R2a zLgoa;tOXXx1hIZhcBwNXr#i-@Q3FxeG{W`<#o{QhK~fOoApSaV(oJW6`RI;g)_eb% zty?wQcwb+?dcKByYZshsTFugcBcXj_pg%1c^fVkdkY(oFDsM7rMZ2__$fxJbL~KV# zFCeLU>T%Xr=*D@&P$$_vKC&lY3nZAq<^YL*Ln>utECM_SV6l+dQDFl}!VK|!<4f_rSMGr-0oYG($mO^KLQ>(JHpB;@xr;e>2ziz9#6;tn#UNW z&>AZ^oknraapBeKSXE~7*&4*!WcwSpY`=Hs4ac0h9+!j90*L<32iIYvoj^X^kyq1o!L}JFMUX?J+o~q{7F+!w+I#n>q^;>XPu$3vw?=C`9j1LW#waKd5xxU&WbX2xX$Twx>_S=9Lhs7 zanGSA{(Ri)r-Q-FmW{#V>r8JHsh{u&0Jg~hKHg3@rFcBwvWg3YX;ziq4i`wGWsL-d zV_Z>#Mkomu*xDqk%~^0Y1}~%BiODH&#$EK`p#vZNpK8_r{My@(kDxzBdw#mqt3St>Hah6A`D<3VB!od=DAT9fObs%&b!sbS?1<8A@2)pM0yWxZ~>sx4XJRmKw@C}<^^w&ptsUXYFmJBz(xG!S|Ku}4s!H-ECc`g@~`(j{pIiW z-nqW37GGbxmqTHv$nW5_Mxkm)Qn${pu?1x=Gl$MDBjzbS6(^06rk&F1_PVNxG~rX3 zNXfL`hH2^og|W;;vIB~I;?wV5f5omBHUWR`>?&*>RgrJZzYgn?CXHrIak{7*km~RQ z^HP>jYK`E3J&n7i9)Fqd?#_*r42d8T=K*lu{=peLK0Wlso=xELfmhdllp5sPy8wML zI$ScMha<|nN>x^;psSI4+zDYE3(J^nZYX6iEMr8Hm%T(w>G)VafPz#aD@qF|1N~gh zfG2ZXMk_4Ai>};%$tQn&7>AAg{tLOA55d9LF^x<2Ym>5$4 zf9=y?cVNlUrqy{cZ0Ywr`S5^EPRJb;zFt{OH3Y>)O?}NgMcu$0n<^|6lohGHb>vG(?Yq3RH=yC#Tns<1Z0wcV-#}{ z%^I4VA}0=PMDQsO<_V5a15%xUQ$PBz8$bELbXLJ;Zj?pS=x)!*P^R*zP5^nWU>Hr6&pyMJ)6$s&U+kUN4U&n!UawAr-DWT zw7>nHJ-__?lVjH6!QbL{0M#7V@F){X- z3k3~Qv#>=$(iqmyu}_`!%;`HGTYqKzwY8KggKT^S43mfwm!jo~EpQXEo0CE43JzZh zcDTllMdL1s(^@<~33u7cI}cpB{oG?6uN7Jc0|Le%v*tNH1j}EinpbJXMVE+= zkb`bb9X7M5BD1p8)fA!YO$nmv7({+|UUkD6FWvFs+Wl_lsEftdDr9fqr@*15g?-B+ zzvZ(ziy2_@GgpyiD2gTuL8nVHU?f#-GD}dhS(r0c%v@Pe1Piw?Mi~=Kv$|c8k0mv2 zdz&KT7$dx1+({SDAUHVT)nhNX=S&B-oCwc8sM+@WAFhD`JaPl|Nk~eJ2;woZES;^G z7K2w2(y#&Dpr>p?O;}NAcL#Qj$l4T+h`y06LUKxHtxVEx(mT}h7(VWH`xz|Bf~f4l zb#nGSkG}oePuKK?M_cRiUq3~5LM=!%W*cS6rZOe&B#CTZYJbQU^VMOZN#kgEgqhjI zC$vohDWOmv=;2*Mv^3zDivG#SVh$MMQF(9bW1=D|=$0q=F;TBgLv3b7SP8+%@Q z>f${|e*5{Rb?z}2d<$CuD@6L^Q^Ce4mV|RERN~VQ&X$3OBy;^1d%m zKK{Y=q7MCit$NEMzfQgdG=+HvbZ9cKV$4SCr8;R@ce8aWZGyA%tE#3>pwUTt9No6J z;*7E)11+WE=;0_yDH8wZ4vvZwF64YuMH(_I1z}1!)YfZs=K}UB{~=}MAR-g+7SmsJ*UZFJMcYTfWzUg1QTMNJmQq?1%F4= z=CbBu9LZxbXSF00w)=^{KK5^qU2>@j>xcUvYtzUq^76Bgx;B$&8Qq|;T$Ex3dQ{1R z>M7wdo9V3w3{ISgAfn8}4KcSVkw}T^VNOLOjr~?nz1^Bb`^|uS0XB^Yo8SR>`mrbe zaPOg0*BP_-|JhJ&bM0Q|{Y%Irm@gtZOK-#(61f#TYm0JLv5zQmd8q6d^$|Jb5WyG7 zx;O>+(3gL6{a-Hp>)T6g&+YlbtlifC?E3(+Vm_V?TW7TnTl>qcKH((}?P=%MRRg@41+1B3!xj1Db7z%XKZ8eW%v9QR9{O5ZSn8T4>Eoc|LPL1C`Y*q0f zNN)$y6rCbKOmmmAj)a)yQBpo9y=@>PW=3wZ{U68gKINp__Cda4%f{01eXK1ha_?S% zz*t-pF4UnDG7YNMP0lKMz*$a7{H2@{m+RYfAwtlU?Gjm9pv|RWB;UI8gk2B6amS{f zZOd!xOZh8E=zd7K1{so|PtZuE5VfprVN0BT^(3>hw(#-=!Q9RBt++y!UnjLnWg=AR z^+sHAp;s`~E^=1CL|m2DCd^JNXC$ZH9>EyY{G5t84A0dY-?{nb6Q8;gOr5^5anrRa z4ezV)?JDHEzXw|+G?4^3WL^p3V(9y!87lFd(Uy3Qh^_b*5CsZSv~FprfdMG2{$E1 zbxDNxw~&E2-*W4q7Dw2C_e3K(03F=|nVEoOW=>q2K}xSMuFgF#-17RT?{(@xD94aj3e;j(Z6x6{50Zaw_?^MAZ=y}llMdVT9Hk>Sq(XH~H1 zyy48E>J3E(d$`^3cE&T&7z*L>4a)LLhFZ-1xJ_qUE{%@4DqLHQ%J14G9m7E00|G&R$(0JY+oj~-?PKu~T zhK9IYXiCiCfX4Ljb?V9STJhgeWnDx3>5;GJ%#>Lk;Nd z$Di=QO~2o@9Wx=?vhi)&$Jl>pk#D~bst}ef(;j;b!jwH(xSRiW(6j_LpC{`nu!){=lp7XpxFdv9T*(L>%f z{|Deo5>ve9kha537Sj!NskJzTlD%M%{EdQ@-j&`%CiLh8du3y0HN?!*gepn98g(jpOhPZIg@zkgcTI}~McVm7A=X;)S18CczBU0Wk+4aKZr zzQc!e=Mq1kRN}2<%=Ia<(CF*)}A-uIr#_xY|1Q!90!kK zT4{z)Sp%#DW0}h>a_WA8M$GzK_G*#m_l+tomfRp%ctEe(OUL{pQ)gM>LCXKm-KU@M z)+7G}5)C*lC?ur-0X@+UA-nyF7^Umd|ly? zNJ$FmTx!tIr5g#O2EkR%UNqwP+P)iACq1y$H443Vq{o2B>FtnE~Mz@ely0s>52?Z|I)la|j=B>A%cK3Q8eKpa- zR(lBfLkwI&`GRyYXE8{)u8Les*Q)hnb6(GwaWpF~%?YPVNX?_645h7<2#I?loT6<9 z%;@QT=R9}k1J|va+kN{C8?J97Ti^aqPqAx{`f;*!*2UJMl#^krX$ zPnp!j)wILUMft9_k>&L*4Y4*u#|T9sjyds`v-a=5`jqwL{_XVjM^X{VZBl5}K&S)@ zgF zxgYP{G!^(J`aRXQa~bPoMicqPAvZkMlSQ(VCs>eMT7kAgW;-j3O5au}+PrDbg6e6N zqDf7PJu}g?xGulIoTbrGlQ>#dhq%<-N5n03UPqY?vH9UU&N;aErE4)0k*yo%;>DV6 zmBhN1odc;iApxfhLb(~#nD;7p*?KG1u_b-0K3PlfXXVD`m>iDSxOR0hBPaDCb`D3WO>Stu>?Wd;Vm2PB(1P)*FqdxzmtCi~#2`teOitV#O!Jcp zA^7L;g~fnbTXhc%xMYMLF!bDfkKJwK!hsP50k?dJW@QyXYp%Zc^Sdtp)gg$Ywrsq5 zniN|>N@V&6(1qD0wODr^O3N)EY3!i2$i!^o58b_Dv1e1nGZhyhBTa=%MDs+wszR=5 z;o>VaIz_iU?y~4CQ@XV1v-nOnp09`a@^3HQ^U?3W*sLD)z)wHIZ}?b){(#n8 z5*!Vy$<8V@yahBqm4y)S)7bakhlg%Ebnd31<)zC1z@98_q<9L6@ubn#@UN3ECU5Rj=(p;A4+1X=)c@>%ie20 z`u%zm_gqfG+J>@VrR^HDQq5QBD=K-BX&3znBg82LbRaP#8^Wf_m}7>rYStX5*|#=< z*Xe4R#1@=8)<6TLBw`LG)a;f#8RUsUQ`BMj>w;J;$m1HunTFZZ%#giSUEN3ZDB23q zY7qx~`^2j+zhm#7?_oo~;nQM6A45d9h#;|53KGd(gL5k8xFlqK$S@fD)ZmG)uE=IQ zvpN8Zd@2i|U+j$xZRx#WR!uYK^Eo1a;$_;~-`i_PxOk?s``9Z02dTOG^{ zdg6tx=#z^YOd`I~lH!^kHAkbI%ZXrwq7kd5S$0>cBbhAxEOE9p0D$@Yr4L>8+-bLC zxs_DUc%aya~sk4kOLFHZz~4EA-JKCBrMT3LqFKaOj+_ zAf(bpCB5ckffDzMQ(n9HvS&BFQQnmt!gO#s zYCs-l0SqwKP(;?Ug^wq2`bBnwLn$H>WoWfjPjMZBilk%PEQ3BsvW03D)u&Z2nK7GE ztd=yj)RC(k;ue<8qN+5Kr{sL%LOOOYQ~092UtzWd(Qv~Lbt^bg8XCh(MVcCcsE~!N zu}QnwDz?QCAz%8z#pj)LG?ducvT@X}q*_2AA%8IZn7~4 z?#+Fm=2tHZxSUew(78Dy1J_yZy0QaRo;t(jQ=WvvMxv&GMU12gTtveMa>WN{KY!{U zE`BA0_3i%A8g^kI&$a|wG==h6(kv}Ds;-vlPK!*Yw~FzZP}o2UY4d<46R7HAy0T#o z&g0c|)~IgDSe0?DSn@8k@wr`y&z5R>GKAqu8$YGDg;;V+i(S#^tPzrpIfp*HaQSO{ z-~a7z)_pK0U%}S-22x(=0osVsMni&htTebiVDL||3bmm)MQX4Zs(5#&L0wS?U;!tQ za7SHBr`z%%dbH9TcyhX;FCY`!9bvP_2dD9lXO92lj{Ubl5diS-Id*N1gCf`d4Bq`B zni&;!e4(Jy$YK*k^r*lZW1-85+tPL#)Jj}@0wyScK#Jze1(fvi^UY%%tb^l^|J`Lb z-gxz96uJ1yTAqwY{FE2eXv!&W;K+RO%HS7C?Xh}(Y~oMn!H?RDb*EMh-N0Cxw@#GkCMlQN?1g+i!C!^)Ql(jd9sxYZ7w2+e+f^92e10_ zjhpT)VO{y^(|2HFWkG(r8)&dB*|5M3EhQl23j*BTM6!sS6fH3I^fG^xBd59@B8byE z-rz)6f@5;$hYuZn(%JX?dOhklKe6W0agnEf2H8(dyAR|@uQpgSkn0VNNFd3H!V1=+ z%`PycOP@ezOjDW_cUhO04AeEW6lVqvu3!_4+?+V083OwqS0CARVDGD&TzQ}OWb7+{ zfLI`sL1k99%wn%hpcu3yO?E83OgpF02wM$9mCHCwWRq-)GN#YdW5MiP{a|&e zSf*jF|NhbSZ~XIy_t#VO;t$v7^ccB(nFKZ-g{ml{0g}IjPg=6-IfyOb zdL*>x{OnTBK}E|8_pWMA*q zl6XrSQ`HSgvi@L5?9eE^Y9K)!e*38xpLqPD^&&0*QI7o^5vd_D*i{_YA~o`dgo*qD z3a#j~24*;9%5qx`w$4Oi#(M*{JgpI>3M|dIEsNkg>=ZtpD1hq?r(NX%mVNZa_uqTg z;Y&An?EgD{El%4&cn`j$Mgt2T7uB=f9UG;h4U1VGsfE6ha<*VF|Maa)lSYv=5W zKC7ZK=NC`{1M0$>8Qq4*pyQVlYM=$jtVv~~!4mh}Jq68#RlquO;k~E7^yXRHu!*?l z{k1dQ7UXrupTVAwkW|)m8aj>XbGE$(BX6PaGZI{haVnC};tR9W=20(L?U@H9GC+-W z*RJgc-?@*AwKJ9-!6JmOAwN*T;@}tXmS%r3srO8y4vWNba~LZto@^nqEM`lT)YFaZ zp{ao5cYAY=sA$!+11<8v!GFAU@&l)Bo-J?gTl-?*k>kGlEzB+pTuTkWF87N7hMI!8 zkYW|}k2Q&Aixr)93ADIcneJ;_F4AD(N>UIqbE1L5Bu_iBC?ap43Z=7HTW{qFq7J}Y1&`C5HlpSX)KkG)HcM!hpZ zP%OlErK}X{D%344ErT~x)K?}nS|_Tr*$PFcTUwZ8KWHi0&5W8ysye3ywwNpA1d^iW z)H$D;O-`##L`tK5ayLwnCznA{akA&dPal2dpO3xyb?iSsfJ#vCx!*y)Xn{5@QjnkROluj}vJ9G?P)TfWN%o54aC0C^Qse~R3gR{A^Zm1V7TT6G9Voy`3`8b6% zT{hBo95=2&`4eqsSjOkve3=Dcv8!Ks{qd(yz7o?&ZrLaczk>bePmq89#RlM&KO9UU zx?(9m&ARj?V@RoNmnszvnZO#<0@M~q)JTy^lwdSI5j3?TCcEEFplP?QB6TPH&MEdX zJNfv3-~Hr`2iA?xu3TrG4M_U%LW8P;R&7&Uma*FrZ?S3UozS26`}lDBI1xb z$$^ff*Yt)dxopxFbvvB@bRFJAK$A7kKD>fS| z!0tB&r@=8R9%klL##z^Dgb3l|SC9MsAI`hszp3Jy$GH>VVHG@T%2-*#4ZzW;SYZh&5Cc+&WZKA3#!%__**`}dQc58JLyg_Cy zu3BnYGsI)2`pf0AL#T@N3H~&=1On8aFOL4xm;XF(O~$plZ^Qm_D>A(9N)YrT>>v~8 zspj-OkJb|6d%9E)ymD)JL|k{YTY9IfG( zM3vE}iajo|GBq)DN-5NawL=`f@A})GyYJBLn>@J3ckESfyD+(CCNhy*2|s~6*I1bI zHlx~^5Rw?-S}|W2@on;s&ohg*Og6ueh9fr9?%-5U;;?zmU`3LbkNf7amWm33lFBTQ z9ctlUcARj`hd1utu?|sxGFXEQ-$dTKstef&sk~)mqS~yr1tpK*Qlg@zxdNAu(UVSv z2kL1e#7sOK6d4VErj@5KQ6tG=OH7|h!xFhiO6K>V$`W%@WCh)Zcx9l%im3l)*I5@n zxA&Aa$8ah6zl-U+YKS&zX$$C1ZA7iSz*K8x|G%Z{j=QU@?@+~R%ByX)3ewl!z4zXG zzjyC-?%sRvdkqj9hEx(%pscWz(hv-@R*)gaFvAEm282Wrf+Qh?8H=>Pb6)?==aciE zd!FC(JiqZBt*%VQ>3Bfh!y_=rn+|DTuNCqYE}|FmpHn+`{9*gmm~+C*BNrN~ctoQD znIM)_X-~L<;ib51P?3400j26~xuo+IDH*Pcfmuq6#6{&|UEY@?0IN9m>tBC(@1EV5 z{MF=G1%1#zAnx&Db&hIh+eb==Vx_f5+RJ)5oJ$Lxp%zQGlum_FCxPv8>S#hKppQ@8 zbkC{V|8GYCjpnV}!M*WI>lnhegZz68(4!j8OhNNfYpPs27{k%WBoEcnwb*sOjkIw? zj*0{}p+nHk`7#B2Yh0w!H3qf>#O3p`N}>bws7K#D`P7laAHT8<+xQ~sKWWzc#4n(4 z>OxN3K?CtH!MIOBj00W<=ZhA?a@NQ?DUOFOyHE`E%q2UYKYifJ3jv6E?%Me`+^bpt z(bxYv*ry@^&Mt^j>X7eHdb*mfBv0dx8sdL>8+_zutY-{m;!_ff;UY9jRY#Ig<%=g1>r`#E zao8$L8JA<2EAz-K=AXFYk|ffQCbZN@W-?D0;le)j*4_JWz5nw~1Ev zb2_TLPD+u1Mj=U= zM|H?fI*6DV@u7xA&FlN(g#zH!lq;@G-YpNkLp`1k$Ngk0@E3d=LBty&QCzn6}(1VA!!f6dI@RwpT5*g%$Z(X3yU64`;JtmFWGj>V* z?YtPN#0D!bhG7di5;4e2Tu7gY^7UFWXoWw3={12z@j~%NaTUyP-TD`^vZ3AAK7;E z^P9bJ4h_>@q#?(4LzCZ@_1PK0bK@c;juK0u%pj+t1G&y4LKnMun3PZri+TH@j}qf>uq3HTjpwN zttfPSz0*lTYi|urMjfBSDWv$F1U2l0F!=D{cVF1{-m92hsZoGQJ>!t1Wlfvg80uCw z<`j_lD}B#A*dWau%NQ=o1ilB=Lvp2T)WIZZnu;a3DK6b!iUka-w4opT>jy(27IF;Cy*}#-ov_&>uLPwM<4Tfq} zHxd-YqKYT#B)jsJz-YOY1!V5LfeQrxN8i5cwp$*$5$Gl7tO>q~fn`$2h}wbXiBSxa z{KK#$#p^jGB|~o%cI(w9hQ!+uwu8eIyON@{`QVqLD{H8kI`p)5J@%`Ic3gHnX7$3{ zk72Ya$Se2#k0z&FvP_93gRGM0ikXTJCekTi7C-6WLli==5S6s0t~A~V&3R_jIEzt2 zp&2c$cEv3ur4e1LTmEh9%R5eE`Puh8ccBd)9U|4kcutqu7}}JbyfzqwHeP68aeJLH zP+K)5DT%^r1_dBK>&YeM1xcAv$&glV^E_fr45wvZpe_=xbkK_Y*{@!=m}D|Ox%G5Qe&A)W{Q2LaFR_Gv3fl+DNE z66(ar8lfxd#;!aYF65U<3uvQd3aOAb5Lw~Ks&QRng8tMU`ySbS%{`xC{D}j<`7*jg zImjdNyH&XhmW`ySRVGd2o~q4APK=~o85E6%`n(ER{P7!)Jb3iu3(<5GtZ2{NqFMh& z6_Z0KA-MNI`9~>=NBUHIG3-g2Jc@px6mt<4iiU=7??}muP-2uF3Mf%XYG&L6KK<>fv~nh zdf<{tBr|GHE%cLOR$oHY@(M~uK`K(~t66rtBNvI-dW{@|9ApLEoKDC|Y&HyerOO#Z zHYk;1ze3aDTlBJpX=d{!NoZ?5^!#7;y?*hD&C%}zFSgMSN=4#CXql<$@dRz9V$9`S zDM{Iq)hvxx(V(zq=OKoqWf%F%Hsgh|Y>|mr`Su1$(4Y7__>_uGad8&{ z1Ai5g6NxNu-jU#PjB5JCG~4j{B9pDBpZoobmwoa>)G*?lwg0YQDiVK>T)Z7ZR-Fz= zB8sZUY>o4(c#2U>69IayJrC6IrB2#vA`f{Rb7xm)YAuFtAiSE{O3zFmpSB~px{L_4 z>D%{z^5R{OZ&IG_xf;{oI}6#f71()6Mz0OHYH{C{0aw!+kE+WXNA|o@oG@0&G@V{L zkRe5St>{-!`;+C6F-q{W6+OLfiNu%073hR&^CS`5z6dQlNqt){Ey}z05fUBLH>4a$ zyLX*>>$4j!dT^7(`GgiTNiZUroyXNVzOodPcLo){kX7?+*h3PdtimevU8Sb1GE}-N zO0|zdD=h{_x-{o&n6!9M4ZZTyU%qt3W1kGrPc-v?usIPve0u{Fn4rZc?*XvAJIotA z{Hf9DHXF?Z7jHJPO-f>;QDhjgQmvj(C526V-%sw^bHlxV!U&ejuP)IT`37>f@;c~6 z3e1SeS^#<{I7v?kDO1v~W3v^_LNd{(uxl(qJs}RzaWjP2@&l9Q_a`p7;fE(LK;P$~ zzdMX>6Fm}sqpi&m+{s?7iQu{8@Hkv=GtAK%(Wk026$ucSQkP;%CO|lzICj&%+n)G* zQ*voPZMT#aPSWl4Ou+{Ih|qE;6|4 zElP1|tQWN8GTL!^@bT9k{P|UwTg`(XCeXJLAd^EyFe~Yab%5G7ddESz7~hq-0%D8Q z&rVce{IHC>A#qumLp{MLvJq_9>EXPqp%4oi9AhySSr&ulp&gl}3C>(huWr^CT0uI_ zsXz!v6-)VVUJ{o6G^Ge~PTJaGL%V*KE)8tc8k| zf$*$0A*lk*?;yxk+2fG*Y`^@9_wPG&486LytiARW%)q~53!)MA1!Vt4KrQB{W-M-= zOVM`Wn$YhG3oZ8L8u6-(CP5l>r@hTv8o~BTC7GxK*taym`d*@NOrDwX)@fr*3{-rxh*4>5S#3?TQ8NP@w@yK(HA2zw z{Li0x?y_h9fSN);K5*gr=$_FdWl2t(OKGN7D~I1E1#vc!CmXNQ(-A7gAqi8}3b2Pr zYpZbi;>{9)Yh=ka5~6TE>XdHSo4s6H*B+WjJT2Xh=dmj}n>orQ`Ku0kt{50w`?^dL zL{p$(-hI;*??3tHcQ9Rh#r=EGKYbSRG`}djE|-f8oUspR}Ow9E#w<==Yod zg08Ix+5R;E**Ha#VSX4Q)*F=BD4eC}WO-Mm&#{HF;sjz7N}Q8u2(QW2HB5PoTO~`= zF1H49u*hh=oJNF&j^U^(e zG?Kpe8fE~LK-5Y=GmB>4P|h9|3N-Q#VU=;Ht(K`)1N>*zfF0`aODg$1OlaVMkLwoL z$+ILc8aBb4^P0yVz5C@$w|$0fo$p@`!g`hS%jgIBI`X?caH!KQ=D}8H$!A>Z{UfTC-1(W`g1f2N~7{?E!N`*Vod6IT;C3)H`0>zUS!9hr##( zRDKn9?fRMfFp)MYvVPW$Fe5himYkS?mtO@7LnPeqdn7d5yuMh;c@;stWmk5z-mx&F zoG225nkhxja0LK$J@wRWTR(Z_HVA-o*8XxcX5`pGu74JQg~ZrkHL%;3bS|h$swwky zYsO`R3V$rlpb@O`A$7JKPL8~A?T>d{@$6n`z-(E2d~Z^-e#DP0X#;t+bT**rRsKR| z7AwbvK68{*2Bk=oT%((1gF-!B!<%jp=qYFv9r?rQhu*&7ub8caU&Q=}49L-+LNZ3g z8ChF=K zpLIanP&?ENbc0*+@j~@JUyE)rjk<3_9VF5jQH1d>oR^6LNt9 zFC6AC9=!U#t8af8Tl_yik2wo`0lCu#--ONqud8u^t_A7z9#58vI(hR9nQNhy?DKv;^ zyX(f=J;7)R*J{t%Wd5w*Gc3Xkk~^at#=GJI428Qy?lJ>gh}YEE^K-K=>j17boflIY?D5!=S4wz> zDKB5D?l5w^B8N>K%S}TMjo=0B->3U`-~GyO-o)4irf<^G)i@t{`#3->n0V6yT*!o! zBHklhFf`^>pDog7wK2KG?*!h3pA>BsihedU<@u0V9ld(nuFHRkUg=xbUg6}m>(k!? z$_5oA%^rbMhm!{ciEnApk_|?kqL{I|79688mU5QrN}ZQd2!XS=d~U~4B%YL!QwPhA z$M#?K!VjMK3c6)(`;7%%4F(c4n4rR`jf0#l-Pt!3vV_(OX(aLs>jr5~W7k3YdRnC8 zO3FGu)JrvJRHaFnNf-27y?CrH0zC!x_wJjv{_^*K#@GoTJ&Hr0`%R>IE|`m|tjj2# zn(x#oZFStR$mFLCMQC0%_Gq?XCm33I6TXzHCWy{@A-Z?0o>mlPO06G@C1ZsNz$}jc z_|en9f8fH+x%v;p7ofGyI?_o4J?#8mW7$y~$0Z*ykkh?c)m0BQJc0y%JbCnzgBRZQ zt6f(BI&aHb_X3`F{SQxXM=wkq;>|!lNo;hrF@&L^1C~!C3yy?~Qia1aIBcslZ!uA2 zyY2`~nXi0p>(1XE`CbF<#2q;Hef9cJblcPzxvPd8xa@7fEP~A9oIjy5@}#MXUIB}b z*kY>ZvPH{QhCpGB{Nr35U*Bk!XkC%46g0JHcJ78`NEZq1OTCN)qQe%Gd2Wl_VP&>m z_mlVj^Uz*Qb?R&HM$tvqAm!sw4Fv{Ho1-&L%pEF1EYj4woGwx`$<*;yy>zpfUXfyQ z^&&K~GOV#ILtit+<#SEBkx^G!vW=wzNFb^OPVF&`LzIbyU=ufmE;2f*Km7RK*AM;( z|Qz+dVS$y^R{fvTSe;`AiF zk@8t>a64rR;h+i02qsDibFDkS?%5wS(wWt!#SNg4%kvqZ(7WNsbM^SDFmQr`dzZ!DoVuwo?%IE!B#^ljM zCtrT~iI4XD4f?8Ic^^Bc!U$UdxOK8r#IVkj%0{M3sA)u0a32#6v%x~5FV*QvJcmJ5 zlsaut{{8N!mmYoRVH8b%&e~Ncu$HnBc~39{YKOIw&{R!s$5KI!*IHS(+n-m?$X-jz z6p`g;#=J%T-_d?A*EagaCpS~!z^qtIds`T_)lOq5pE zeJu)sHthz7Ccdp>C#&Pc(L4*8qp)fpjQoRSld7daY&25(RJ5Eh!l{4gjc0ei`j-<} zlZzErpqtKzXb?d7=E_<+olkA4z4N5e6MzJHnJ8BnYHgV$4qFnF-XPz1FC_gKajwkf z6*Lh(mRkV-5g}A{?2dHQCsy6HG_&4g5c2hAJno#~L-onbu~LeifCj)4A*zd?xae--kdF=M(BimMt7v9RN1$p?13OW-%) zz!FWKZIPm&M5n9QrxvoY4FZ>v@YoMfMPdWd@xK25w`vNFk*$u106`^5k}|B$9_jG;Q3}V>?7F zpRtrz0TzY?>PIF!=F6ojUjI{|76<(Oduk literal 0 HcmV?d00001