diff --git a/.travis.yml b/.travis.yml index f89eb2e6..32f6dacd 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,30 +7,20 @@ before_install: - sudo make install # Retrun to project directory - cd .. - - sudo -E ./install-protobuf.sh + - curl -SsfL -O https://github.com/protocolbuffers/protobuf/releases/download/v3.8.0/protoc-3.8.0-linux-x86_64.zip + - sudo -E unzip -d /usr protoc-3.8.0-linux-x86_64.zip - java -Xmx1g -version - javac -J-Xmx1g -version - export JRUBY_OPTS=-J-Xmx1g - gem update bundler language: ruby rvm: - - 1.9.3 - - 2.0.0 - - 2.1 - - 2.2 - 2.3 - 2.4 - 2.5 + - 2.6 - jruby-9.1.17.0 - - jruby-9.2.5.0 - - rbx-2 -env: - - PROTOBUF_VERSION=2.6.1 - - PROTOBUF_VERSION=3.0.0-alpha-2 -matrix: - allow_failures: - - rvm: rbx-2 - - env: PROTOBUF_VERSION=3.0.0-alpha-2 + - jruby-9.2.7.0 notifications: webhooks: urls: diff --git a/Rakefile b/Rakefile index 8df9895f..9b627846 100644 --- a/Rakefile +++ b/Rakefile @@ -18,11 +18,11 @@ task :default => ['compile:spec', 'compile:rpc', :spec, :rubocop] desc 'Run specs' namespace :compile do - desc 'Compile spec protos in spec/supprt/ directory' + desc 'Compile spec protos in spec/support/ directory' task :spec do proto_path = ::File.expand_path('../spec/support/', __FILE__) proto_files = Dir[File.join(proto_path, '**', '*.proto')] - cmd = %(protoc --plugin=./bin/protoc-gen-ruby --ruby_out=#{proto_path} -I #{proto_path} #{proto_files.join(' ')}) + cmd = %(protoc --plugin=protoc-gen-ruby-protobuf=./bin/protoc-gen-ruby --ruby-protobuf_out=#{proto_path} -I #{proto_path} #{proto_files.join(' ')}) puts cmd system(cmd) @@ -35,7 +35,7 @@ namespace :compile do output_dir = ::File.expand_path('../tmp/rpc', __FILE__) ::FileUtils.mkdir_p(output_dir) - cmd = %(protoc --plugin=./bin/protoc-gen-ruby --ruby_out=#{output_dir} -I #{proto_path} #{proto_files.join(' ')}) + cmd = %(protoc --plugin=protoc-gen-ruby-protobuf=./bin/protoc-gen-ruby --ruby-protobuf_out=#{output_dir} -I #{proto_path} #{proto_files.join(' ')}) puts cmd system(cmd) diff --git a/install-protobuf.sh b/install-protobuf.sh deleted file mode 100755 index b3872fd0..00000000 --- a/install-protobuf.sh +++ /dev/null @@ -1,28 +0,0 @@ -#!/usr/bin/env sh - -set -ex - -gdie() { - echo "$@" >&2 - exit 1 -} - -test -n "$PROTOBUF_VERSION" || die "PROTOBUF_VERSION env var is undefined" - -case "$PROTOBUF_VERSION" in -2*) - basename=protobuf-$PROTOBUF_VERSION - ;; -3*) - basename=protobuf-cpp-$PROTOBUF_VERSION - ;; -*) - die "unknown protobuf version: $PROTOBUF_VERSION" - ;; -esac - -curl -sL https://github.com/google/protobuf/releases/download/v$PROTOBUF_VERSION/$basename.tar.gz | tar zx - -cd protobuf-$PROTOBUF_VERSION - -./configure --prefix=/usr && make -j2 && make install diff --git a/lib/protobuf/code_generator.rb b/lib/protobuf/code_generator.rb index 7b04a32c..635e214d 100644 --- a/lib/protobuf/code_generator.rb +++ b/lib/protobuf/code_generator.rb @@ -1,6 +1,14 @@ require 'active_support/core_ext/module/aliasing' require 'protobuf/generators/file_generator' +::Google::Protobuf::FieldDescriptorProto.module_eval do + attr_writer :fully_qualified_name + + def fully_qualified_name + @fully_qualified_name || name + end +end + module Protobuf class CodeGenerator @@ -28,17 +36,18 @@ def self.warn(message) def initialize(request_bytes) @request_bytes = request_bytes self.request = ::Google::Protobuf::Compiler::CodeGeneratorRequest.decode(request_bytes) + @proto_file_to_descriptor = request.proto_file.map { |file_descriptor| [file_descriptor.name, file_descriptor] }.to_h.freeze end def eval_unknown_extensions! request.proto_file.each do |file_descriptor| - ::Protobuf::Generators::FileGenerator.new(file_descriptor).eval_unknown_extensions! + ::Protobuf::Generators::FileGenerator.new(file_descriptor, @proto_file_to_descriptor).eval_unknown_extensions! end self.request = ::Google::Protobuf::Compiler::CodeGeneratorRequest.decode(@request_bytes) end def generate_file(file_descriptor) - ::Protobuf::Generators::FileGenerator.new(file_descriptor).generate_output_file + ::Protobuf::Generators::FileGenerator.new(file_descriptor, @proto_file_to_descriptor).generate_output_file end def response_bytes diff --git a/lib/protobuf/descriptors/google/protobuf/compiler/plugin.pb.rb b/lib/protobuf/descriptors/google/protobuf/compiler/plugin.pb.rb index 354aa845..66ac6b4e 100644 --- a/lib/protobuf/descriptors/google/protobuf/compiler/plugin.pb.rb +++ b/lib/protobuf/descriptors/google/protobuf/compiler/plugin.pb.rb @@ -1,8 +1,11 @@ # encoding: utf-8 +# frozen_string_literal: true ## # This file is auto-generated. DO NOT EDIT! # +require 'base64' +require 'set' require 'protobuf' @@ -14,6 +17,28 @@ module Google module Protobuf module Compiler + FULLY_QUALIFIED_NAME = 'google.protobuf.compiler' unless defined?(self::FULLY_QUALIFIED_NAME) + + @descriptors = [] unless instance_variable_defined?(:@descriptors) + @descriptors << lambda do + bytes = File.read(__FILE__, mode: 'rb').split(/^__END__$/, 2).last + ::Google::Protobuf::FileDescriptorProto.decode(Base64.decode64(bytes)) + end + + @descriptor_dependencies = Set.new unless instance_variable_defined?(:@descriptor_dependencies) + @descriptor_dependencies |= [Google::Protobuf] + + unless respond_to?(:descriptor_set) + def self.descriptor_set + ::Google::Protobuf::FileDescriptorSet.new(:file => @descriptors.map(&:call)) + end + end + + unless respond_to?(:descriptor_dependencies) + def self.descriptor_dependencies + @descriptor_dependencies + end + end ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions } ## @@ -38,13 +63,16 @@ class File < ::Protobuf::Message; end # Message Fields # class CodeGeneratorRequest + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.CodeGeneratorRequest' repeated :string, :file_to_generate, 1 optional :string, :parameter, 2 repeated ::Google::Protobuf::FileDescriptorProto, :proto_file, 15 end class CodeGeneratorResponse + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.CodeGeneratorResponse' class File + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.File' optional :string, :name, 1 optional :string, :insertion_point, 2 optional :string, :content, 15 @@ -60,3 +88,181 @@ class File end + +# Raw descriptor bytes below +__END__ +CiVnb29nbGUvcHJvdG9idWYvY29tcGlsZXIvcGx1Z2luLnByb3RvEhhnb29n +bGUucHJvdG9idWYuY29tcGlsZXIaIGdvb2dsZS9wcm90b2J1Zi9kZXNjcmlw +dG9yLnByb3RvIqMBChRDb2RlR2VuZXJhdG9yUmVxdWVzdBIoChBmaWxlX3Rv +X2dlbmVyYXRlGAEgAygJUg5maWxlVG9HZW5lcmF0ZRIcCglwYXJhbWV0ZXIY +AiABKAlSCXBhcmFtZXRlchJDCgpwcm90b19maWxlGA8gAygLMiQuZ29vZ2xl +LnByb3RvYnVmLkZpbGVEZXNjcmlwdG9yUHJvdG9SCXByb3RvRmlsZSLWAQoV +Q29kZUdlbmVyYXRvclJlc3BvbnNlEhQKBWVycm9yGAEgASgJUgVlcnJvchJI +CgRmaWxlGA8gAygLMjQuZ29vZ2xlLnByb3RvYnVmLmNvbXBpbGVyLkNvZGVH +ZW5lcmF0b3JSZXNwb25zZS5GaWxlUgRmaWxlGl0KBEZpbGUSEgoEbmFtZRgB +IAEoCVIEbmFtZRInCg9pbnNlcnRpb25fcG9pbnQYAiABKAlSDmluc2VydGlv +blBvaW50EhgKB2NvbnRlbnQYDyABKAlSB2NvbnRlbnRCLAocY29tLmdvb2ds +ZS5wcm90b2J1Zi5jb21waWxlckIMUGx1Z2luUHJvdG9zSqY5CgcSBS4AkgEB +Cr0RCgECEgMuACEytAwgUHJvdG9jb2wgQnVmZmVycyAtIEdvb2dsZSdzIGRh +dGEgaW50ZXJjaGFuZ2UgZm9ybWF0CiBDb3B5cmlnaHQgMjAwOCBHb29nbGUg +SW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KIGh0dHA6Ly9jb2RlLmdvb2ds +ZS5jb20vcC9wcm90b2J1Zi8KCiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu +IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKIG1v +ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm +b2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKIG1ldDoKCiAgICAgKiBSZWRpc3Ry +aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3Zl +IGNvcHlyaWdodAogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh +bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgogICAgICogUmVkaXN0cmli +dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 +ZQogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg +YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgogaW4gdGhlIGRvY3VtZW50 +YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo +ZQogZGlzdHJpYnV0aW9uLgogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBH +b29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cwogY29udHJpYnV0b3Jz +IG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBk +ZXJpdmVkIGZyb20KIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBw +cmlvciB3cml0dGVuIHBlcm1pc3Npb24uCgogVEhJUyBTT0ZUV0FSRSBJUyBQ +Uk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJV +VE9SUwogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS +QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKIExJTUlURUQgVE8sIFRIRSBJ +TVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRO +RVNTIEZPUgogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu +IElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKIE9XTkVSIE9SIENP +TlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU +LCBJTkNJREVOVEFMLAogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFV +RU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAogTElNSVRFRCBU +TywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF +UzsgTE9TUyBPRiBVU0UsCiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT +UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKIFRI +RU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklD +VCBMSUFCSUxJVFksIE9SIFRPUlQKIChJTkNMVURJTkcgTkVHTElHRU5DRSBP +UiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT +RQogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ +T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KMvsEIEF1dGhvcjoga2VudG9u +QGdvb2dsZS5jb20gKEtlbnRvbiBWYXJkYSkKCiBXQVJOSU5HOiAgVGhlIHBs +dWdpbiBpbnRlcmZhY2UgaXMgY3VycmVudGx5IEVYUEVSSU1FTlRBTCBhbmQg +aXMgc3ViamVjdCB0bwogICBjaGFuZ2UuCgogcHJvdG9jIChha2EgdGhlIFBy +b3RvY29sIENvbXBpbGVyKSBjYW4gYmUgZXh0ZW5kZWQgdmlhIHBsdWdpbnMu +ICBBIHBsdWdpbiBpcwoganVzdCBhIHByb2dyYW0gdGhhdCByZWFkcyBhIENv +ZGVHZW5lcmF0b3JSZXF1ZXN0IGZyb20gc3RkaW4gYW5kIHdyaXRlcyBhCiBD +b2RlR2VuZXJhdG9yUmVzcG9uc2UgdG8gc3Rkb3V0LgoKIFBsdWdpbnMgd3Jp +dHRlbiB1c2luZyBDKysgY2FuIHVzZSBnb29nbGUvcHJvdG9idWYvY29tcGls +ZXIvcGx1Z2luLmggaW5zdGVhZAogb2YgZGVhbGluZyB3aXRoIHRoZSByYXcg +cHJvdG9jb2wgZGVmaW5lZCBoZXJlLgoKIEEgcGx1Z2luIGV4ZWN1dGFibGUg +bmVlZHMgb25seSB0byBiZSBwbGFjZWQgc29tZXdoZXJlIGluIHRoZSBwYXRo +LiAgVGhlCiBwbHVnaW4gc2hvdWxkIGJlIG5hbWVkICJwcm90b2MtZ2VuLSRO +QU1FIiwgYW5kIHdpbGwgdGhlbiBiZSB1c2VkIHdoZW4gdGhlCiBmbGFnICIt +LSR7TkFNRX1fb3V0IiBpcyBwYXNzZWQgdG8gcHJvdG9jLgoKCAoBCBIDLwA1 +CgkKAggBEgMvADUKCAoBCBIDMAAtCgkKAggIEgMwAC0KCQoCAwASAzIAKgpP +CgIEABIENQBKARpDIEFuIGVuY29kZWQgQ29kZUdlbmVyYXRvclJlcXVlc3Qg +aXMgd3JpdHRlbiB0byB0aGUgcGx1Z2luJ3Mgc3RkaW4uCgoKCgMEAAESAzUI +HArRAQoEBAACABIDOQInGsMBIFRoZSAucHJvdG8gZmlsZXMgdGhhdCB3ZXJl +IGV4cGxpY2l0bHkgbGlzdGVkIG9uIHRoZSBjb21tYW5kLWxpbmUuICBUaGUK +IGNvZGUgZ2VuZXJhdG9yIHNob3VsZCBnZW5lcmF0ZSBjb2RlIG9ubHkgZm9y +IHRoZXNlIGZpbGVzLiAgRWFjaCBmaWxlJ3MKIGRlc2NyaXB0b3Igd2lsbCBi +ZSBpbmNsdWRlZCBpbiBwcm90b19maWxlLCBiZWxvdy4KCgwKBQQAAgAEEgM5 +AgoKDAoFBAACAAUSAzkLEQoMCgUEAAIAARIDORIiCgwKBQQAAgADEgM5JSYK +QgoEBAACARIDPAIgGjUgVGhlIGdlbmVyYXRvciBwYXJhbWV0ZXIgcGFzc2Vk +IG9uIHRoZSBjb21tYW5kLWxpbmUuCgoMCgUEAAIBBBIDPAIKCgwKBQQAAgEF +EgM8CxEKDAoFBAACAQESAzwSGwoMCgUEAAIBAxIDPB4fCqkFCgQEAAICEgNJ +Ai8amwUgRmlsZURlc2NyaXB0b3JQcm90b3MgZm9yIGFsbCBmaWxlcyBpbiBm +aWxlc190b19nZW5lcmF0ZSBhbmQgZXZlcnl0aGluZwogdGhleSBpbXBvcnQu +ICBUaGUgZmlsZXMgd2lsbCBhcHBlYXIgaW4gdG9wb2xvZ2ljYWwgb3JkZXIs +IHNvIGVhY2ggZmlsZQogYXBwZWFycyBiZWZvcmUgYW55IGZpbGUgdGhhdCBp +bXBvcnRzIGl0LgoKIHByb3RvYyBndWFyYW50ZWVzIHRoYXQgYWxsIHByb3Rv +X2ZpbGVzIHdpbGwgYmUgd3JpdHRlbiBhZnRlcgogdGhlIGZpZWxkcyBhYm92 +ZSwgZXZlbiB0aG91Z2ggdGhpcyBpcyBub3QgdGVjaG5pY2FsbHkgZ3VhcmFu +dGVlZCBieSB0aGUKIHByb3RvYnVmIHdpcmUgZm9ybWF0LiAgVGhpcyB0aGVv +cmV0aWNhbGx5IGNvdWxkIGFsbG93IGEgcGx1Z2luIHRvIHN0cmVhbQogaW4g +dGhlIEZpbGVEZXNjcmlwdG9yUHJvdG9zIGFuZCBoYW5kbGUgdGhlbSBvbmUg +Ynkgb25lIHJhdGhlciB0aGFuIHJlYWQKIHRoZSBlbnRpcmUgc2V0IGludG8g +bWVtb3J5IGF0IG9uY2UuICBIb3dldmVyLCBhcyBvZiB0aGlzIHdyaXRpbmcs +IHRoaXMKIGlzIG5vdCBzaW1pbGFybHkgb3B0aW1pemVkIG9uIHByb3RvYydz +IGVuZCAtLSBpdCB3aWxsIHN0b3JlIGFsbCBmaWVsZHMgaW4KIG1lbW9yeSBh +dCBvbmNlIGJlZm9yZSBzZW5kaW5nIHRoZW0gdG8gdGhlIHBsdWdpbi4KCgwK +BQQAAgIEEgNJAgoKDAoFBAACAgYSA0kLHgoMCgUEAAICARIDSR8pCgwKBQQA +AgIDEgNJLC4KTAoCBAESBU0AkgEBGj8gVGhlIHBsdWdpbiB3cml0ZXMgYW4g +ZW5jb2RlZCBDb2RlR2VuZXJhdG9yUmVzcG9uc2UgdG8gc3Rkb3V0LgoKCgoD +BAEBEgNNCB0K7QMKBAQBAgASA1YCHBrfAyBFcnJvciBtZXNzYWdlLiAgSWYg +bm9uLWVtcHR5LCBjb2RlIGdlbmVyYXRpb24gZmFpbGVkLiAgVGhlIHBsdWdp +biBwcm9jZXNzCiBzaG91bGQgZXhpdCB3aXRoIHN0YXR1cyBjb2RlIHplcm8g +ZXZlbiBpZiBpdCByZXBvcnRzIGFuIGVycm9yIGluIHRoaXMgd2F5LgoKIFRo +aXMgc2hvdWxkIGJlIHVzZWQgdG8gaW5kaWNhdGUgZXJyb3JzIGluIC5wcm90 +byBmaWxlcyB3aGljaCBwcmV2ZW50IHRoZQogY29kZSBnZW5lcmF0b3IgZnJv +bSBnZW5lcmF0aW5nIGNvcnJlY3QgY29kZS4gIEVycm9ycyB3aGljaCBpbmRp +Y2F0ZSBhCiBwcm9ibGVtIGluIHByb3RvYyBpdHNlbGYgLS0gc3VjaCBhcyB0 +aGUgaW5wdXQgQ29kZUdlbmVyYXRvclJlcXVlc3QgYmVpbmcKIHVucGFyc2Vh +YmxlIC0tIHNob3VsZCBiZSByZXBvcnRlZCBieSB3cml0aW5nIGEgbWVzc2Fn +ZSB0byBzdGRlcnIgYW5kCiBleGl0aW5nIHdpdGggYSBub24temVybyBzdGF0 +dXMgY29kZS4KCgwKBQQBAgAEEgNWAgoKDAoFBAECAAUSA1YLEQoMCgUEAQIA +ARIDVhIXCgwKBQQBAgADEgNWGhsKNAoEBAEDABIFWQKQAQMaJSBSZXByZXNl +bnRzIGEgc2luZ2xlIGdlbmVyYXRlZCBmaWxlLgoKDAoFBAEDAAESA1kKDgqt +BQoGBAEDAAIAEgNlBB0anQUgVGhlIGZpbGUgbmFtZSwgcmVsYXRpdmUgdG8g +dGhlIG91dHB1dCBkaXJlY3RvcnkuICBUaGUgbmFtZSBtdXN0IG5vdAogY29u +dGFpbiAiLiIgb3IgIi4uIiBjb21wb25lbnRzIGFuZCBtdXN0IGJlIHJlbGF0 +aXZlLCBub3QgYmUgYWJzb2x1dGUgKHNvLAogdGhlIGZpbGUgY2Fubm90IGxp +ZSBvdXRzaWRlIHRoZSBvdXRwdXQgZGlyZWN0b3J5KS4gICIvIiBtdXN0IGJl +IHVzZWQgYXMKIHRoZSBwYXRoIHNlcGFyYXRvciwgbm90ICJcIi4KCiBJZiB0 +aGUgbmFtZSBpcyBvbWl0dGVkLCB0aGUgY29udGVudCB3aWxsIGJlIGFwcGVu +ZGVkIHRvIHRoZSBwcmV2aW91cwogZmlsZS4gIFRoaXMgYWxsb3dzIHRoZSBn +ZW5lcmF0b3IgdG8gYnJlYWsgbGFyZ2UgZmlsZXMgaW50byBzbWFsbCBjaHVu +a3MsCiBhbmQgYWxsb3dzIHRoZSBnZW5lcmF0ZWQgdGV4dCB0byBiZSBzdHJl +YW1lZCBiYWNrIHRvIHByb3RvYyBzbyB0aGF0IGxhcmdlCiBmaWxlcyBuZWVk +IG5vdCByZXNpZGUgY29tcGxldGVseSBpbiBtZW1vcnkgYXQgb25lIHRpbWUu +ICBOb3RlIHRoYXQgYXMgb2YKIHRoaXMgd3JpdGluZyBwcm90b2MgZG9lcyBu +b3Qgb3B0aW1pemUgZm9yIHRoaXMgLS0gaXQgd2lsbCByZWFkIHRoZSBlbnRp +cmUKIENvZGVHZW5lcmF0b3JSZXNwb25zZSBiZWZvcmUgd3JpdGluZyBmaWxl +cyB0byBkaXNrLgoKDgoHBAEDAAIABBIDZQQMCg4KBwQBAwACAAUSA2UNEwoO +CgcEAQMAAgABEgNlFBgKDgoHBAEDAAIAAxIDZRscCq4QCgYEAQMAAgESBIwB +BCganRAgSWYgbm9uLWVtcHR5LCBpbmRpY2F0ZXMgdGhhdCB0aGUgbmFtZWQg +ZmlsZSBzaG91bGQgYWxyZWFkeSBleGlzdCwgYW5kIHRoZQogY29udGVudCBo +ZXJlIGlzIHRvIGJlIGluc2VydGVkIGludG8gdGhhdCBmaWxlIGF0IGEgZGVm +aW5lZCBpbnNlcnRpb24KIHBvaW50LiAgVGhpcyBmZWF0dXJlIGFsbG93cyBh +IGNvZGUgZ2VuZXJhdG9yIHRvIGV4dGVuZCB0aGUgb3V0cHV0CiBwcm9kdWNl +ZCBieSBhbm90aGVyIGNvZGUgZ2VuZXJhdG9yLiAgVGhlIG9yaWdpbmFsIGdl +bmVyYXRvciBtYXkgcHJvdmlkZQogaW5zZXJ0aW9uIHBvaW50cyBieSBwbGFj +aW5nIHNwZWNpYWwgYW5ub3RhdGlvbnMgaW4gdGhlIGZpbGUgdGhhdCBsb29r +CiBsaWtlOgogICBAQHByb3RvY19pbnNlcnRpb25fcG9pbnQoTkFNRSkKIFRo +ZSBhbm5vdGF0aW9uIGNhbiBoYXZlIGFyYml0cmFyeSB0ZXh0IGJlZm9yZSBh +bmQgYWZ0ZXIgaXQgb24gdGhlIGxpbmUsCiB3aGljaCBhbGxvd3MgaXQgdG8g +YmUgcGxhY2VkIGluIGEgY29tbWVudC4gIE5BTUUgc2hvdWxkIGJlIHJlcGxh +Y2VkIHdpdGgKIGFuIGlkZW50aWZpZXIgbmFtaW5nIHRoZSBwb2ludCAtLSB0 +aGlzIGlzIHdoYXQgb3RoZXIgZ2VuZXJhdG9ycyB3aWxsIHVzZQogYXMgdGhl +IGluc2VydGlvbl9wb2ludC4gIENvZGUgaW5zZXJ0ZWQgYXQgdGhpcyBwb2lu +dCB3aWxsIGJlIHBsYWNlZAogaW1tZWRpYXRlbHkgYWJvdmUgdGhlIGxpbmUg +Y29udGFpbmluZyB0aGUgaW5zZXJ0aW9uIHBvaW50ICh0aHVzIG11bHRpcGxl +CiBpbnNlcnRpb25zIHRvIHRoZSBzYW1lIHBvaW50IHdpbGwgY29tZSBvdXQg +aW4gdGhlIG9yZGVyIHRoZXkgd2VyZSBhZGRlZCkuCiBUaGUgZG91YmxlLUAg +aXMgaW50ZW5kZWQgdG8gbWFrZSBpdCB1bmxpa2VseSB0aGF0IHRoZSBnZW5l +cmF0ZWQgY29kZQogY291bGQgY29udGFpbiB0aGluZ3MgdGhhdCBsb29rIGxp +a2UgaW5zZXJ0aW9uIHBvaW50cyBieSBhY2NpZGVudC4KCiBGb3IgZXhhbXBs +ZSwgdGhlIEMrKyBjb2RlIGdlbmVyYXRvciBwbGFjZXMgdGhlIGZvbGxvd2lu +ZyBsaW5lIGluIHRoZQogLnBiLmggZmlsZXMgdGhhdCBpdCBnZW5lcmF0ZXM6 +CiAgIC8vIEBAcHJvdG9jX2luc2VydGlvbl9wb2ludChuYW1lc3BhY2Vfc2Nv +cGUpCiBUaGlzIGxpbmUgYXBwZWFycyB3aXRoaW4gdGhlIHNjb3BlIG9mIHRo +ZSBmaWxlJ3MgcGFja2FnZSBuYW1lc3BhY2UsIGJ1dAogb3V0c2lkZSBvZiBh +bnkgcGFydGljdWxhciBjbGFzcy4gIEFub3RoZXIgcGx1Z2luIGNhbiB0aGVu +IHNwZWNpZnkgdGhlCiBpbnNlcnRpb25fcG9pbnQgIm5hbWVzcGFjZV9zY29w +ZSIgdG8gZ2VuZXJhdGUgYWRkaXRpb25hbCBjbGFzc2VzIG9yCiBvdGhlciBk +ZWNsYXJhdGlvbnMgdGhhdCBzaG91bGQgYmUgcGxhY2VkIGluIHRoaXMgc2Nv +cGUuCgogTm90ZSB0aGF0IGlmIHRoZSBsaW5lIGNvbnRhaW5pbmcgdGhlIGlu +c2VydGlvbiBwb2ludCBiZWdpbnMgd2l0aAogd2hpdGVzcGFjZSwgdGhlIHNh +bWUgd2hpdGVzcGFjZSB3aWxsIGJlIGFkZGVkIHRvIGV2ZXJ5IGxpbmUgb2Yg +dGhlCiBpbnNlcnRlZCB0ZXh0LiAgVGhpcyBpcyB1c2VmdWwgZm9yIGxhbmd1 +YWdlcyBsaWtlIFB5dGhvbiwgd2hlcmUKIGluZGVudGF0aW9uIG1hdHRlcnMu +ICBJbiB0aGVzZSBsYW5ndWFnZXMsIHRoZSBpbnNlcnRpb24gcG9pbnQgY29t +bWVudAogc2hvdWxkIGJlIGluZGVudGVkIHRoZSBzYW1lIGFtb3VudCBhcyBh +bnkgaW5zZXJ0ZWQgY29kZSB3aWxsIG5lZWQgdG8gYmUKIGluIG9yZGVyIHRv +IHdvcmsgY29ycmVjdGx5IGluIHRoYXQgY29udGV4dC4KCiBUaGUgY29kZSBn +ZW5lcmF0b3IgdGhhdCBnZW5lcmF0ZXMgdGhlIGluaXRpYWwgZmlsZSBhbmQg +dGhlIG9uZSB3aGljaAogaW5zZXJ0cyBpbnRvIGl0IG11c3QgYm90aCBydW4g +YXMgcGFydCBvZiBhIHNpbmdsZSBpbnZvY2F0aW9uIG9mIHByb3RvYy4KIENv +ZGUgZ2VuZXJhdG9ycyBhcmUgZXhlY3V0ZWQgaW4gdGhlIG9yZGVyIGluIHdo +aWNoIHRoZXkgYXBwZWFyIG9uIHRoZQogY29tbWFuZCBsaW5lLgoKIElmIHxp +bnNlcnRpb25fcG9pbnR8IGlzIHByZXNlbnQsIHxuYW1lfCBtdXN0IGFsc28g +YmUgcHJlc2VudC4KCg8KBwQBAwACAQQSBIwBBAwKDwoHBAEDAAIBBRIEjAEN +EwoPCgcEAQMAAgEBEgSMARQjCg8KBwQBAwACAQMSBIwBJicKJAoGBAEDAAIC +EgSPAQQhGhQgVGhlIGZpbGUgY29udGVudHMuCgoPCgcEAQMAAgIEEgSPAQQM +Cg8KBwQBAwACAgUSBI8BDRMKDwoHBAEDAAICARIEjwEUGwoPCgcEAQMAAgID +EgSPAR4gCgwKBAQBAgESBJEBAhoKDQoFBAECAQQSBJEBAgoKDQoFBAECAQYS +BJEBCw8KDQoFBAECAQESBJEBEBQKDQoFBAECAQMSBJEBFxk= diff --git a/lib/protobuf/descriptors/google/protobuf/descriptor.pb.rb b/lib/protobuf/descriptors/google/protobuf/descriptor.pb.rb index 534d83a5..e1e2c18f 100644 --- a/lib/protobuf/descriptors/google/protobuf/descriptor.pb.rb +++ b/lib/protobuf/descriptors/google/protobuf/descriptor.pb.rb @@ -1,12 +1,37 @@ # encoding: utf-8 +# frozen_string_literal: true ## # This file is auto-generated. DO NOT EDIT! # +require 'base64' +require 'set' require 'protobuf' module Google module Protobuf + FULLY_QUALIFIED_NAME = 'google.protobuf' unless defined?(self::FULLY_QUALIFIED_NAME) + + @descriptors = [] unless instance_variable_defined?(:@descriptors) + @descriptors << lambda do + bytes = File.read(__FILE__, mode: 'rb').split(/^__END__$/, 2).last + ::Google::Protobuf::FileDescriptorProto.decode(Base64.decode64(bytes)) + end + + @descriptor_dependencies = Set.new unless instance_variable_defined?(:@descriptor_dependencies) + @descriptor_dependencies |= [] + + unless respond_to?(:descriptor_set) + def self.descriptor_set + ::Google::Protobuf::FileDescriptorSet.new(:file => @descriptors.map(&:call)) + end + end + + unless respond_to?(:descriptor_dependencies) + def self.descriptor_dependencies + @descriptor_dependencies + end + end ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions } ## @@ -22,6 +47,8 @@ class ReservedRange < ::Protobuf::Message; end class FieldDescriptorProto < ::Protobuf::Message class Type < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Type' + define :TYPE_DOUBLE, 1 define :TYPE_FLOAT, 2 define :TYPE_INT64, 3 @@ -43,6 +70,8 @@ class Type < ::Protobuf::Enum end class Label < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Label' + define :LABEL_OPTIONAL, 1 define :LABEL_REQUIRED, 2 define :LABEL_REPEATED, 3 @@ -57,6 +86,8 @@ class ServiceDescriptorProto < ::Protobuf::Message; end class MethodDescriptorProto < ::Protobuf::Message; end class FileOptions < ::Protobuf::Message class OptimizeMode < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.OptimizeMode' + define :SPEED, 1 define :CODE_SIZE, 2 define :LITE_RUNTIME, 3 @@ -67,12 +98,16 @@ class OptimizeMode < ::Protobuf::Enum class MessageOptions < ::Protobuf::Message; end class FieldOptions < ::Protobuf::Message class CType < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.CType' + define :STRING, 0 define :CORD, 1 define :STRING_PIECE, 2 end class JSType < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.JSType' + define :JS_NORMAL, 0 define :JS_STRING, 1 define :JS_NUMBER, 2 @@ -111,10 +146,12 @@ class Location < ::Protobuf::Message; end # Message Fields # class FileDescriptorSet + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.FileDescriptorSet' repeated ::Google::Protobuf::FileDescriptorProto, :file, 1 end class FileDescriptorProto + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.FileDescriptorProto' optional :string, :name, 1 optional :string, :package, 2 repeated :string, :dependency, 3 @@ -130,12 +167,15 @@ class FileDescriptorProto end class DescriptorProto + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.DescriptorProto' class ExtensionRange + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ExtensionRange' optional :int32, :start, 1 optional :int32, :end, 2 end class ReservedRange + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ReservedRange' optional :int32, :start, 1 optional :int32, :end, 2 end @@ -153,6 +193,7 @@ class ReservedRange end class FieldDescriptorProto + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.FieldDescriptorProto' optional :string, :name, 1 optional :int32, :number, 3 optional ::Google::Protobuf::FieldDescriptorProto::Label, :label, 4 @@ -166,28 +207,33 @@ class FieldDescriptorProto end class OneofDescriptorProto + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.OneofDescriptorProto' optional :string, :name, 1 end class EnumDescriptorProto + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.EnumDescriptorProto' optional :string, :name, 1 repeated ::Google::Protobuf::EnumValueDescriptorProto, :value, 2 optional ::Google::Protobuf::EnumOptions, :options, 3 end class EnumValueDescriptorProto + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.EnumValueDescriptorProto' optional :string, :name, 1 optional :int32, :number, 2 optional ::Google::Protobuf::EnumValueOptions, :options, 3 end class ServiceDescriptorProto + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ServiceDescriptorProto' optional :string, :name, 1 repeated ::Google::Protobuf::MethodDescriptorProto, :method, 2 optional ::Google::Protobuf::ServiceOptions, :options, 3 end class MethodDescriptorProto + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.MethodDescriptorProto' optional :string, :name, 1 optional :string, :input_type, 2 optional :string, :output_type, 3 @@ -197,6 +243,7 @@ class MethodDescriptorProto end class FileOptions + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.FileOptions' optional :string, :java_package, 1 optional :string, :java_outer_classname, 8 optional :bool, :java_multiple_files, 10, :default => false @@ -218,6 +265,7 @@ class FileOptions end class MessageOptions + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.MessageOptions' optional :bool, :message_set_wire_format, 1, :default => false optional :bool, :no_standard_descriptor_accessor, 2, :default => false optional :bool, :deprecated, 3, :default => false @@ -228,6 +276,7 @@ class MessageOptions end class FieldOptions + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.FieldOptions' optional ::Google::Protobuf::FieldOptions::CType, :ctype, 1, :default => ::Google::Protobuf::FieldOptions::CType::STRING optional :bool, :packed, 2 optional ::Google::Protobuf::FieldOptions::JSType, :jstype, 6, :default => ::Google::Protobuf::FieldOptions::JSType::JS_NORMAL @@ -240,6 +289,7 @@ class FieldOptions end class EnumOptions + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.EnumOptions' optional :bool, :allow_alias, 2 optional :bool, :deprecated, 3, :default => false repeated ::Google::Protobuf::UninterpretedOption, :uninterpreted_option, 999 @@ -248,6 +298,7 @@ class EnumOptions end class EnumValueOptions + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.EnumValueOptions' optional :bool, :deprecated, 1, :default => false repeated ::Google::Protobuf::UninterpretedOption, :uninterpreted_option, 999 # Extension Fields @@ -255,6 +306,7 @@ class EnumValueOptions end class ServiceOptions + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ServiceOptions' optional :bool, :deprecated, 33, :default => false repeated ::Google::Protobuf::UninterpretedOption, :uninterpreted_option, 999 # Extension Fields @@ -262,6 +314,7 @@ class ServiceOptions end class MethodOptions + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.MethodOptions' optional :bool, :deprecated, 33, :default => false repeated ::Google::Protobuf::UninterpretedOption, :uninterpreted_option, 999 # Extension Fields @@ -269,7 +322,9 @@ class MethodOptions end class UninterpretedOption + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.UninterpretedOption' class NamePart + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.NamePart' required :string, :name_part, 1 required :bool, :is_extension, 2 end @@ -284,7 +339,9 @@ class NamePart end class SourceCodeInfo + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.SourceCodeInfo' class Location + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Location' repeated :int32, :path, 1, :packed => true repeated :int32, :span, 2, :packed => true optional :string, :leading_comments, 3 @@ -299,3 +356,947 @@ class Location end + +# Raw descriptor bytes below +__END__ +CiBnb29nbGUvcHJvdG9idWYvZGVzY3JpcHRvci5wcm90bxIPZ29vZ2xlLnBy +b3RvYnVmIk0KEUZpbGVEZXNjcmlwdG9yU2V0EjgKBGZpbGUYASADKAsyJC5n +b29nbGUucHJvdG9idWYuRmlsZURlc2NyaXB0b3JQcm90b1IEZmlsZSLkBAoT +RmlsZURlc2NyaXB0b3JQcm90bxISCgRuYW1lGAEgASgJUgRuYW1lEhgKB3Bh +Y2thZ2UYAiABKAlSB3BhY2thZ2USHgoKZGVwZW5kZW5jeRgDIAMoCVIKZGVw +ZW5kZW5jeRIrChFwdWJsaWNfZGVwZW5kZW5jeRgKIAMoBVIQcHVibGljRGVw +ZW5kZW5jeRInCg93ZWFrX2RlcGVuZGVuY3kYCyADKAVSDndlYWtEZXBlbmRl +bmN5EkMKDG1lc3NhZ2VfdHlwZRgEIAMoCzIgLmdvb2dsZS5wcm90b2J1Zi5E +ZXNjcmlwdG9yUHJvdG9SC21lc3NhZ2VUeXBlEkEKCWVudW1fdHlwZRgFIAMo +CzIkLmdvb2dsZS5wcm90b2J1Zi5FbnVtRGVzY3JpcHRvclByb3RvUghlbnVt +VHlwZRJBCgdzZXJ2aWNlGAYgAygLMicuZ29vZ2xlLnByb3RvYnVmLlNlcnZp +Y2VEZXNjcmlwdG9yUHJvdG9SB3NlcnZpY2USQwoJZXh0ZW5zaW9uGAcgAygL +MiUuZ29vZ2xlLnByb3RvYnVmLkZpZWxkRGVzY3JpcHRvclByb3RvUglleHRl +bnNpb24SNgoHb3B0aW9ucxgIIAEoCzIcLmdvb2dsZS5wcm90b2J1Zi5GaWxl +T3B0aW9uc1IHb3B0aW9ucxJJChBzb3VyY2VfY29kZV9pbmZvGAkgASgLMh8u +Z29vZ2xlLnByb3RvYnVmLlNvdXJjZUNvZGVJbmZvUg5zb3VyY2VDb2RlSW5m +bxIWCgZzeW50YXgYDCABKAlSBnN5bnRheCL3BQoPRGVzY3JpcHRvclByb3Rv +EhIKBG5hbWUYASABKAlSBG5hbWUSOwoFZmllbGQYAiADKAsyJS5nb29nbGUu +cHJvdG9idWYuRmllbGREZXNjcmlwdG9yUHJvdG9SBWZpZWxkEkMKCWV4dGVu +c2lvbhgGIAMoCzIlLmdvb2dsZS5wcm90b2J1Zi5GaWVsZERlc2NyaXB0b3JQ +cm90b1IJZXh0ZW5zaW9uEkEKC25lc3RlZF90eXBlGAMgAygLMiAuZ29vZ2xl +LnByb3RvYnVmLkRlc2NyaXB0b3JQcm90b1IKbmVzdGVkVHlwZRJBCgllbnVt +X3R5cGUYBCADKAsyJC5nb29nbGUucHJvdG9idWYuRW51bURlc2NyaXB0b3JQ +cm90b1IIZW51bVR5cGUSWAoPZXh0ZW5zaW9uX3JhbmdlGAUgAygLMi8uZ29v +Z2xlLnByb3RvYnVmLkRlc2NyaXB0b3JQcm90by5FeHRlbnNpb25SYW5nZVIO +ZXh0ZW5zaW9uUmFuZ2USRAoKb25lb2ZfZGVjbBgIIAMoCzIlLmdvb2dsZS5w +cm90b2J1Zi5PbmVvZkRlc2NyaXB0b3JQcm90b1IJb25lb2ZEZWNsEjkKB29w +dGlvbnMYByABKAsyHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnNS +B29wdGlvbnMSVQoOcmVzZXJ2ZWRfcmFuZ2UYCSADKAsyLi5nb29nbGUucHJv +dG9idWYuRGVzY3JpcHRvclByb3RvLlJlc2VydmVkUmFuZ2VSDXJlc2VydmVk +UmFuZ2USIwoNcmVzZXJ2ZWRfbmFtZRgKIAMoCVIMcmVzZXJ2ZWROYW1lGjgK +DkV4dGVuc2lvblJhbmdlEhQKBXN0YXJ0GAEgASgFUgVzdGFydBIQCgNlbmQY +AiABKAVSA2VuZBo3Cg1SZXNlcnZlZFJhbmdlEhQKBXN0YXJ0GAEgASgFUgVz +dGFydBIQCgNlbmQYAiABKAVSA2VuZCKYBgoURmllbGREZXNjcmlwdG9yUHJv +dG8SEgoEbmFtZRgBIAEoCVIEbmFtZRIWCgZudW1iZXIYAyABKAVSBm51bWJl +chJBCgVsYWJlbBgEIAEoDjIrLmdvb2dsZS5wcm90b2J1Zi5GaWVsZERlc2Ny +aXB0b3JQcm90by5MYWJlbFIFbGFiZWwSPgoEdHlwZRgFIAEoDjIqLmdvb2ds +ZS5wcm90b2J1Zi5GaWVsZERlc2NyaXB0b3JQcm90by5UeXBlUgR0eXBlEhsK +CXR5cGVfbmFtZRgGIAEoCVIIdHlwZU5hbWUSGgoIZXh0ZW5kZWUYAiABKAlS +CGV4dGVuZGVlEiMKDWRlZmF1bHRfdmFsdWUYByABKAlSDGRlZmF1bHRWYWx1 +ZRIfCgtvbmVvZl9pbmRleBgJIAEoBVIKb25lb2ZJbmRleBIbCglqc29uX25h +bWUYCiABKAlSCGpzb25OYW1lEjcKB29wdGlvbnMYCCABKAsyHS5nb29nbGUu +cHJvdG9idWYuRmllbGRPcHRpb25zUgdvcHRpb25zIrYCCgRUeXBlEg8KC1RZ +UEVfRE9VQkxFEAESDgoKVFlQRV9GTE9BVBACEg4KClRZUEVfSU5UNjQQAxIP +CgtUWVBFX1VJTlQ2NBAEEg4KClRZUEVfSU5UMzIQBRIQCgxUWVBFX0ZJWEVE +NjQQBhIQCgxUWVBFX0ZJWEVEMzIQBxINCglUWVBFX0JPT0wQCBIPCgtUWVBF +X1NUUklORxAJEg4KClRZUEVfR1JPVVAQChIQCgxUWVBFX01FU1NBR0UQCxIO +CgpUWVBFX0JZVEVTEAwSDwoLVFlQRV9VSU5UMzIQDRINCglUWVBFX0VOVU0Q +DhIRCg1UWVBFX1NGSVhFRDMyEA8SEQoNVFlQRV9TRklYRUQ2NBAQEg8KC1RZ +UEVfU0lOVDMyEBESDwoLVFlQRV9TSU5UNjQQEiJDCgVMYWJlbBISCg5MQUJF +TF9PUFRJT05BTBABEhIKDkxBQkVMX1JFUVVJUkVEEAISEgoOTEFCRUxfUkVQ +RUFURUQQAyIqChRPbmVvZkRlc2NyaXB0b3JQcm90bxISCgRuYW1lGAEgASgJ +UgRuYW1lIqIBChNFbnVtRGVzY3JpcHRvclByb3RvEhIKBG5hbWUYASABKAlS +BG5hbWUSPwoFdmFsdWUYAiADKAsyKS5nb29nbGUucHJvdG9idWYuRW51bVZh +bHVlRGVzY3JpcHRvclByb3RvUgV2YWx1ZRI2CgdvcHRpb25zGAMgASgLMhwu +Z29vZ2xlLnByb3RvYnVmLkVudW1PcHRpb25zUgdvcHRpb25zIoMBChhFbnVt +VmFsdWVEZXNjcmlwdG9yUHJvdG8SEgoEbmFtZRgBIAEoCVIEbmFtZRIWCgZu +dW1iZXIYAiABKAVSBm51bWJlchI7CgdvcHRpb25zGAMgASgLMiEuZ29vZ2xl +LnByb3RvYnVmLkVudW1WYWx1ZU9wdGlvbnNSB29wdGlvbnMipwEKFlNlcnZp +Y2VEZXNjcmlwdG9yUHJvdG8SEgoEbmFtZRgBIAEoCVIEbmFtZRI+CgZtZXRo +b2QYAiADKAsyJi5nb29nbGUucHJvdG9idWYuTWV0aG9kRGVzY3JpcHRvclBy +b3RvUgZtZXRob2QSOQoHb3B0aW9ucxgDIAEoCzIfLmdvb2dsZS5wcm90b2J1 +Zi5TZXJ2aWNlT3B0aW9uc1IHb3B0aW9ucyKJAgoVTWV0aG9kRGVzY3JpcHRv +clByb3RvEhIKBG5hbWUYASABKAlSBG5hbWUSHQoKaW5wdXRfdHlwZRgCIAEo +CVIJaW5wdXRUeXBlEh8KC291dHB1dF90eXBlGAMgASgJUgpvdXRwdXRUeXBl +EjgKB29wdGlvbnMYBCABKAsyHi5nb29nbGUucHJvdG9idWYuTWV0aG9kT3B0 +aW9uc1IHb3B0aW9ucxIwChBjbGllbnRfc3RyZWFtaW5nGAUgASgIOgVmYWxz +ZVIPY2xpZW50U3RyZWFtaW5nEjAKEHNlcnZlcl9zdHJlYW1pbmcYBiABKAg6 +BWZhbHNlUg9zZXJ2ZXJTdHJlYW1pbmci0gcKC0ZpbGVPcHRpb25zEiEKDGph +dmFfcGFja2FnZRgBIAEoCVILamF2YVBhY2thZ2USMAoUamF2YV9vdXRlcl9j +bGFzc25hbWUYCCABKAlSEmphdmFPdXRlckNsYXNzbmFtZRI1ChNqYXZhX211 +bHRpcGxlX2ZpbGVzGAogASgIOgVmYWxzZVIRamF2YU11bHRpcGxlRmlsZXMS +RwodamF2YV9nZW5lcmF0ZV9lcXVhbHNfYW5kX2hhc2gYFCABKAg6BWZhbHNl +UhlqYXZhR2VuZXJhdGVFcXVhbHNBbmRIYXNoEjoKFmphdmFfc3RyaW5nX2No +ZWNrX3V0ZjgYGyABKAg6BWZhbHNlUhNqYXZhU3RyaW5nQ2hlY2tVdGY4ElMK +DG9wdGltaXplX2ZvchgJIAEoDjIpLmdvb2dsZS5wcm90b2J1Zi5GaWxlT3B0 +aW9ucy5PcHRpbWl6ZU1vZGU6BVNQRUVEUgtvcHRpbWl6ZUZvchIdCgpnb19w +YWNrYWdlGAsgASgJUglnb1BhY2thZ2USNQoTY2NfZ2VuZXJpY19zZXJ2aWNl +cxgQIAEoCDoFZmFsc2VSEWNjR2VuZXJpY1NlcnZpY2VzEjkKFWphdmFfZ2Vu +ZXJpY19zZXJ2aWNlcxgRIAEoCDoFZmFsc2VSE2phdmFHZW5lcmljU2Vydmlj +ZXMSNQoTcHlfZ2VuZXJpY19zZXJ2aWNlcxgSIAEoCDoFZmFsc2VSEXB5R2Vu +ZXJpY1NlcnZpY2VzEiUKCmRlcHJlY2F0ZWQYFyABKAg6BWZhbHNlUgpkZXBy +ZWNhdGVkEi8KEGNjX2VuYWJsZV9hcmVuYXMYHyABKAg6BWZhbHNlUg5jY0Vu +YWJsZUFyZW5hcxIqChFvYmpjX2NsYXNzX3ByZWZpeBgkIAEoCVIPb2JqY0Ns +YXNzUHJlZml4EikKEGNzaGFycF9uYW1lc3BhY2UYJSABKAlSD2NzaGFycE5h +bWVzcGFjZRJFCh9qYXZhbmFub191c2VfZGVwcmVjYXRlZF9wYWNrYWdlGCYg +ASgIUhxqYXZhbmFub1VzZURlcHJlY2F0ZWRQYWNrYWdlElgKFHVuaW50ZXJw +cmV0ZWRfb3B0aW9uGOcHIAMoCzIkLmdvb2dsZS5wcm90b2J1Zi5VbmludGVy +cHJldGVkT3B0aW9uUhN1bmludGVycHJldGVkT3B0aW9uIjoKDE9wdGltaXpl +TW9kZRIJCgVTUEVFRBABEg0KCUNPREVfU0laRRACEhAKDExJVEVfUlVOVElN +RRADKgkI6AcQgICAgAIixQIKDk1lc3NhZ2VPcHRpb25zEjwKF21lc3NhZ2Vf +c2V0X3dpcmVfZm9ybWF0GAEgASgIOgVmYWxzZVIUbWVzc2FnZVNldFdpcmVG +b3JtYXQSTAofbm9fc3RhbmRhcmRfZGVzY3JpcHRvcl9hY2Nlc3NvchgCIAEo +CDoFZmFsc2VSHG5vU3RhbmRhcmREZXNjcmlwdG9yQWNjZXNzb3ISJQoKZGVw +cmVjYXRlZBgDIAEoCDoFZmFsc2VSCmRlcHJlY2F0ZWQSGwoJbWFwX2VudHJ5 +GAcgASgIUghtYXBFbnRyeRJYChR1bmludGVycHJldGVkX29wdGlvbhjnByAD +KAsyJC5nb29nbGUucHJvdG9idWYuVW5pbnRlcnByZXRlZE9wdGlvblITdW5p +bnRlcnByZXRlZE9wdGlvbioJCOgHEICAgIACItwDCgxGaWVsZE9wdGlvbnMS +QQoFY3R5cGUYASABKA4yIy5nb29nbGUucHJvdG9idWYuRmllbGRPcHRpb25z +LkNUeXBlOgZTVFJJTkdSBWN0eXBlEhYKBnBhY2tlZBgCIAEoCFIGcGFja2Vk +EkcKBmpzdHlwZRgGIAEoDjIkLmdvb2dsZS5wcm90b2J1Zi5GaWVsZE9wdGlv +bnMuSlNUeXBlOglKU19OT1JNQUxSBmpzdHlwZRIZCgRsYXp5GAUgASgIOgVm +YWxzZVIEbGF6eRIlCgpkZXByZWNhdGVkGAMgASgIOgVmYWxzZVIKZGVwcmVj +YXRlZBIZCgR3ZWFrGAogASgIOgVmYWxzZVIEd2VhaxJYChR1bmludGVycHJl +dGVkX29wdGlvbhjnByADKAsyJC5nb29nbGUucHJvdG9idWYuVW5pbnRlcnBy +ZXRlZE9wdGlvblITdW5pbnRlcnByZXRlZE9wdGlvbiIvCgVDVHlwZRIKCgZT +VFJJTkcQABIICgRDT1JEEAESEAoMU1RSSU5HX1BJRUNFEAIiNQoGSlNUeXBl +Eg0KCUpTX05PUk1BTBAAEg0KCUpTX1NUUklORxABEg0KCUpTX05VTUJFUhAC +KgkI6AcQgICAgAIiugEKC0VudW1PcHRpb25zEh8KC2FsbG93X2FsaWFzGAIg +ASgIUgphbGxvd0FsaWFzEiUKCmRlcHJlY2F0ZWQYAyABKAg6BWZhbHNlUgpk +ZXByZWNhdGVkElgKFHVuaW50ZXJwcmV0ZWRfb3B0aW9uGOcHIAMoCzIkLmdv +b2dsZS5wcm90b2J1Zi5VbmludGVycHJldGVkT3B0aW9uUhN1bmludGVycHJl +dGVkT3B0aW9uKgkI6AcQgICAgAIingEKEEVudW1WYWx1ZU9wdGlvbnMSJQoK +ZGVwcmVjYXRlZBgBIAEoCDoFZmFsc2VSCmRlcHJlY2F0ZWQSWAoUdW5pbnRl +cnByZXRlZF9vcHRpb24Y5wcgAygLMiQuZ29vZ2xlLnByb3RvYnVmLlVuaW50 +ZXJwcmV0ZWRPcHRpb25SE3VuaW50ZXJwcmV0ZWRPcHRpb24qCQjoBxCAgICA +AiKcAQoOU2VydmljZU9wdGlvbnMSJQoKZGVwcmVjYXRlZBghIAEoCDoFZmFs +c2VSCmRlcHJlY2F0ZWQSWAoUdW5pbnRlcnByZXRlZF9vcHRpb24Y5wcgAygL +MiQuZ29vZ2xlLnByb3RvYnVmLlVuaW50ZXJwcmV0ZWRPcHRpb25SE3VuaW50 +ZXJwcmV0ZWRPcHRpb24qCQjoBxCAgICAAiKbAQoNTWV0aG9kT3B0aW9ucxIl +CgpkZXByZWNhdGVkGCEgASgIOgVmYWxzZVIKZGVwcmVjYXRlZBJYChR1bmlu +dGVycHJldGVkX29wdGlvbhjnByADKAsyJC5nb29nbGUucHJvdG9idWYuVW5p +bnRlcnByZXRlZE9wdGlvblITdW5pbnRlcnByZXRlZE9wdGlvbioJCOgHEICA +gIACIpoDChNVbmludGVycHJldGVkT3B0aW9uEkEKBG5hbWUYAiADKAsyLS5n +b29nbGUucHJvdG9idWYuVW5pbnRlcnByZXRlZE9wdGlvbi5OYW1lUGFydFIE +bmFtZRIpChBpZGVudGlmaWVyX3ZhbHVlGAMgASgJUg9pZGVudGlmaWVyVmFs +dWUSLAoScG9zaXRpdmVfaW50X3ZhbHVlGAQgASgEUhBwb3NpdGl2ZUludFZh +bHVlEiwKEm5lZ2F0aXZlX2ludF92YWx1ZRgFIAEoA1IQbmVnYXRpdmVJbnRW +YWx1ZRIhCgxkb3VibGVfdmFsdWUYBiABKAFSC2RvdWJsZVZhbHVlEiEKDHN0 +cmluZ192YWx1ZRgHIAEoDFILc3RyaW5nVmFsdWUSJwoPYWdncmVnYXRlX3Zh +bHVlGAggASgJUg5hZ2dyZWdhdGVWYWx1ZRpKCghOYW1lUGFydBIbCgluYW1l +X3BhcnQYASACKAlSCG5hbWVQYXJ0EiEKDGlzX2V4dGVuc2lvbhgCIAIoCFIL +aXNFeHRlbnNpb24ipwIKDlNvdXJjZUNvZGVJbmZvEkQKCGxvY2F0aW9uGAEg +AygLMiguZ29vZ2xlLnByb3RvYnVmLlNvdXJjZUNvZGVJbmZvLkxvY2F0aW9u +Ughsb2NhdGlvbhrOAQoITG9jYXRpb24SFgoEcGF0aBgBIAMoBUICEAFSBHBh +dGgSFgoEc3BhbhgCIAMoBUICEAFSBHNwYW4SKQoQbGVhZGluZ19jb21tZW50 +cxgDIAEoCVIPbGVhZGluZ0NvbW1lbnRzEisKEXRyYWlsaW5nX2NvbW1lbnRz +GAQgASgJUhB0cmFpbGluZ0NvbW1lbnRzEjoKGWxlYWRpbmdfZGV0YWNoZWRf +Y29tbWVudHMYBiADKAlSF2xlYWRpbmdEZXRhY2hlZENvbW1lbnRzQlgKE2Nv +bS5nb29nbGUucHJvdG9idWZCEERlc2NyaXB0b3JQcm90b3NIAVoKZGVzY3Jp +cHRvcqICA0dQQqoCGkdvb2dsZS5Qcm90b2J1Zi5SZWZsZWN0aW9uSpeZAgoH +EgUnAIoGAQqqDwoBDBIDJwASMsEMIFByb3RvY29sIEJ1ZmZlcnMgLSBHb29n +bGUncyBkYXRhIGludGVyY2hhbmdlIGZvcm1hdAogQ29weXJpZ2h0IDIwMDgg +R29vZ2xlIEluYy4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiBodHRwczovL2Rl +dmVsb3BlcnMuZ29vZ2xlLmNvbS9wcm90b2NvbC1idWZmZXJzLwoKIFJlZGlz +dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs +IHdpdGggb3Igd2l0aG91dAogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk +IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQog +bWV0OgoKICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBt +dXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CiBub3RpY2UsIHRoaXMg +bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt +ZXIuCiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVz +dCByZXByb2R1Y2UgdGhlIGFib3ZlCiBjb3B5cmlnaHQgbm90aWNlLCB0aGlz +IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp +bWVyCiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp +YWxzIHByb3ZpZGVkIHdpdGggdGhlCiBkaXN0cmlidXRpb24uCiAgICAgKiBO +ZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMg +b2YgaXRzCiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBv +ciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQogdGhpcyBzb2Z0d2Fy +ZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4K +CiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQg +SE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCiAiQVMgSVMiIEFORCBBTlkgRVhQ +UkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5P +VAogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJD +SEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCiBBIFBBUlRJQ1VMQVIgUFVS +UE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENP +UFlSSUdIVAogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1Ig +QU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCiBTUEVDSUFMLCBF +WEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5H +LCBCVVQgTk9UCiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU +VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKIERBVEEsIE9S +IFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBD +QVVTRUQgQU5EIE9OIEFOWQogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhF +UiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAogKElO +Q0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBB +TlkgV0FZIE9VVCBPRiBUSEUgVVNFCiBPRiBUSElTIFNPRlRXQVJFLCBFVkVO +IElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF +Lgoy2wIgQXV0aG9yOiBrZW50b25AZ29vZ2xlLmNvbSAoS2VudG9uIFZhcmRh +KQogIEJhc2VkIG9uIG9yaWdpbmFsIFByb3RvY29sIEJ1ZmZlcnMgZGVzaWdu +IGJ5CiAgU2FuamF5IEdoZW1hd2F0LCBKZWZmIERlYW4sIGFuZCBvdGhlcnMu +CgogVGhlIG1lc3NhZ2VzIGluIHRoaXMgZmlsZSBkZXNjcmliZSB0aGUgZGVm +aW5pdGlvbnMgZm91bmQgaW4gLnByb3RvIGZpbGVzLgogQSB2YWxpZCAucHJv +dG8gZmlsZSBjYW4gYmUgdHJhbnNsYXRlZCBkaXJlY3RseSB0byBhIEZpbGVE +ZXNjcmlwdG9yUHJvdG8KIHdpdGhvdXQgYW55IG90aGVyIGluZm9ybWF0aW9u +IChlLmcuIHdpdGhvdXQgcmVhZGluZyBpdHMgaW1wb3J0cykuCgoICgECEgMp +ABgKCAoBCBIDKgAhCgkKAggLEgMqACEKCAoBCBIDKwAsCgkKAggBEgMrACwK +CAoBCBIDLAAxCgkKAggIEgMsADEKCAoBCBIDLQA3CgkKAgglEgMtADcKCAoB +CBIDLgAhCgkKAggkEgMuACEKCAoBCBIDMgAcCn8KAggJEgMyABwadCBkZXNj +cmlwdG9yLnByb3RvIG11c3QgYmUgb3B0aW1pemVkIGZvciBzcGVlZCBiZWNh +dXNlIHJlZmxlY3Rpb24tYmFzZWQKIGFsZ29yaXRobXMgZG9uJ3Qgd29yayBk +dXJpbmcgYm9vdHN0cmFwcGluZy4KCmoKAgQAEgQ2ADgBGl4gVGhlIHByb3Rv +Y29sIGNvbXBpbGVyIGNhbiBvdXRwdXQgYSBGaWxlRGVzY3JpcHRvclNldCBj +b250YWluaW5nIHRoZSAucHJvdG8KIGZpbGVzIGl0IHBhcnNlcy4KCgoKAwQA +ARIDNggZCgsKBAQAAgASAzcCKAoMCgUEAAIABBIDNwIKCgwKBQQAAgAGEgM3 +Cx4KDAoFBAACAAESAzcfIwoMCgUEAAIAAxIDNyYnCi8KAgQBEgQ7AFgBGiMg +RGVzY3JpYmVzIGEgY29tcGxldGUgLnByb3RvIGZpbGUuCgoKCgMEAQESAzsI +Gwo5CgQEAQIAEgM8AhsiLCBmaWxlIG5hbWUsIHJlbGF0aXZlIHRvIHJvb3Qg +b2Ygc291cmNlIHRyZWUKCgwKBQQBAgAEEgM8AgoKDAoFBAECAAUSAzwLEQoM +CgUEAQIAARIDPBIWCgwKBQQBAgADEgM8GRoKKgoEBAECARIDPQIeIh0gZS5n +LiAiZm9vIiwgImZvby5iYXIiLCBldGMuCgoMCgUEAQIBBBIDPQIKCgwKBQQB +AgEFEgM9CxEKDAoFBAECAQESAz0SGQoMCgUEAQIBAxIDPRwdCjQKBAQBAgIS +A0ACIRonIE5hbWVzIG9mIGZpbGVzIGltcG9ydGVkIGJ5IHRoaXMgZmlsZS4K +CgwKBQQBAgIEEgNAAgoKDAoFBAECAgUSA0ALEQoMCgUEAQICARIDQBIcCgwK +BQQBAgIDEgNAHyAKUQoEBAECAxIDQgIoGkQgSW5kZXhlcyBvZiB0aGUgcHVi +bGljIGltcG9ydGVkIGZpbGVzIGluIHRoZSBkZXBlbmRlbmN5IGxpc3QgYWJv +dmUuCgoMCgUEAQIDBBIDQgIKCgwKBQQBAgMFEgNCCxAKDAoFBAECAwESA0IR +IgoMCgUEAQIDAxIDQiUnCnoKBAQBAgQSA0UCJhptIEluZGV4ZXMgb2YgdGhl +IHdlYWsgaW1wb3J0ZWQgZmlsZXMgaW4gdGhlIGRlcGVuZGVuY3kgbGlzdC4K +IEZvciBHb29nbGUtaW50ZXJuYWwgbWlncmF0aW9uIG9ubHkuIERvIG5vdCB1 +c2UuCgoMCgUEAQIEBBIDRQIKCgwKBQQBAgQFEgNFCxAKDAoFBAECBAESA0UR +IAoMCgUEAQIEAxIDRSMlCjYKBAQBAgUSA0gCLBopIEFsbCB0b3AtbGV2ZWwg +ZGVmaW5pdGlvbnMgaW4gdGhpcyBmaWxlLgoKDAoFBAECBQQSA0gCCgoMCgUE +AQIFBhIDSAsaCgwKBQQBAgUBEgNIGycKDAoFBAECBQMSA0gqKwoLCgQEAQIG +EgNJAi0KDAoFBAECBgQSA0kCCgoMCgUEAQIGBhIDSQseCgwKBQQBAgYBEgNJ +HygKDAoFBAECBgMSA0krLAoLCgQEAQIHEgNKAi4KDAoFBAECBwQSA0oCCgoM +CgUEAQIHBhIDSgshCgwKBQQBAgcBEgNKIikKDAoFBAECBwMSA0osLQoLCgQE +AQIIEgNLAi4KDAoFBAECCAQSA0sCCgoMCgUEAQIIBhIDSwsfCgwKBQQBAggB +EgNLICkKDAoFBAECCAMSA0ssLQoLCgQEAQIJEgNNAiMKDAoFBAECCQQSA00C +CgoMCgUEAQIJBhIDTQsWCgwKBQQBAgkBEgNNFx4KDAoFBAECCQMSA00hIgr0 +AQoEBAECChIDUwIvGuYBIFRoaXMgZmllbGQgY29udGFpbnMgb3B0aW9uYWwg +aW5mb3JtYXRpb24gYWJvdXQgdGhlIG9yaWdpbmFsIHNvdXJjZSBjb2RlLgog +WW91IG1heSBzYWZlbHkgcmVtb3ZlIHRoaXMgZW50aXJlIGZpZWxkIHdpdGhv +dXQgaGFybWluZyBydW50aW1lCiBmdW5jdGlvbmFsaXR5IG9mIHRoZSBkZXNj +cmlwdG9ycyAtLSB0aGUgaW5mb3JtYXRpb24gaXMgbmVlZGVkIG9ubHkgYnkK +IGRldmVsb3BtZW50IHRvb2xzLgoKDAoFBAECCgQSA1MCCgoMCgUEAQIKBhID +UwsZCgwKBQQBAgoBEgNTGioKDAoFBAECCgMSA1MtLgpdCgQEAQILEgNXAh4a +UCBUaGUgc3ludGF4IG9mIHRoZSBwcm90byBmaWxlLgogVGhlIHN1cHBvcnRl +ZCB2YWx1ZXMgYXJlICJwcm90bzIiIGFuZCAicHJvdG8zIi4KCgwKBQQBAgsE +EgNXAgoKDAoFBAECCwUSA1cLEQoMCgUEAQILARIDVxIYCgwKBQQBAgsDEgNX +Gx0KJwoCBAISBFsAeQEaGyBEZXNjcmliZXMgYSBtZXNzYWdlIHR5cGUuCgoK +CgMEAgESA1sIFwoLCgQEAgIAEgNcAhsKDAoFBAICAAQSA1wCCgoMCgUEAgIA +BRIDXAsRCgwKBQQCAgABEgNcEhYKDAoFBAICAAMSA1wZGgoLCgQEAgIBEgNe +AioKDAoFBAICAQQSA14CCgoMCgUEAgIBBhIDXgsfCgwKBQQCAgEBEgNeICUK +DAoFBAICAQMSA14oKQoLCgQEAgICEgNfAi4KDAoFBAICAgQSA18CCgoMCgUE +AgICBhIDXwsfCgwKBQQCAgIBEgNfICkKDAoFBAICAgMSA18sLQoLCgQEAgID +EgNhAisKDAoFBAICAwQSA2ECCgoMCgUEAgIDBhIDYQsaCgwKBQQCAgMBEgNh +GyYKDAoFBAICAwMSA2EpKgoLCgQEAgIEEgNiAi0KDAoFBAICBAQSA2ICCgoM +CgUEAgIEBhIDYgseCgwKBQQCAgQBEgNiHygKDAoFBAICBAMSA2IrLAoMCgQE +AgMAEgRkAmcDCgwKBQQCAwABEgNkChgKDQoGBAIDAAIAEgNlBB0KDgoHBAID +AAIABBIDZQQMCg4KBwQCAwACAAUSA2UNEgoOCgcEAgMAAgABEgNlExgKDgoH +BAIDAAIAAxIDZRscCg0KBgQCAwACARIDZgQbCg4KBwQCAwACAQQSA2YEDAoO +CgcEAgMAAgEFEgNmDRIKDgoHBAIDAAIBARIDZhMWCg4KBwQCAwACAQMSA2YZ +GgoLCgQEAgIFEgNoAi4KDAoFBAICBQQSA2gCCgoMCgUEAgIFBhIDaAsZCgwK +BQQCAgUBEgNoGikKDAoFBAICBQMSA2gsLQoLCgQEAgIGEgNqAi8KDAoFBAIC +BgQSA2oCCgoMCgUEAgIGBhIDagsfCgwKBQQCAgYBEgNqICoKDAoFBAICBgMS +A2otLgoLCgQEAgIHEgNsAiYKDAoFBAICBwQSA2wCCgoMCgUEAgIHBhIDbAsZ +CgwKBQQCAgcBEgNsGiEKDAoFBAICBwMSA2wkJQqqAQoEBAIDARIEcQJ0Axqb +ASBSYW5nZSBvZiByZXNlcnZlZCB0YWcgbnVtYmVycy4gUmVzZXJ2ZWQgdGFn +IG51bWJlcnMgbWF5IG5vdCBiZSB1c2VkIGJ5CiBmaWVsZHMgb3IgZXh0ZW5z +aW9uIHJhbmdlcyBpbiB0aGUgc2FtZSBtZXNzYWdlLiBSZXNlcnZlZCByYW5n +ZXMgbWF5CiBub3Qgb3ZlcmxhcC4KCgwKBQQCAwEBEgNxChcKGwoGBAIDAQIA +EgNyBB0iDCBJbmNsdXNpdmUuCgoOCgcEAgMBAgAEEgNyBAwKDgoHBAIDAQIA +BRIDcg0SCg4KBwQCAwECAAESA3ITGAoOCgcEAgMBAgADEgNyGxwKGwoGBAID +AQIBEgNzBBsiDCBFeGNsdXNpdmUuCgoOCgcEAgMBAgEEEgNzBAwKDgoHBAID +AQIBBRIDcw0SCg4KBwQCAwECAQESA3MTFgoOCgcEAgMBAgEDEgNzGRoKCwoE +BAICCBIDdQIsCgwKBQQCAggEEgN1AgoKDAoFBAICCAYSA3ULGAoMCgUEAgII +ARIDdRknCgwKBQQCAggDEgN1KisKggEKBAQCAgkSA3gCJRp1IFJlc2VydmVk +IGZpZWxkIG5hbWVzLCB3aGljaCBtYXkgbm90IGJlIHVzZWQgYnkgZmllbGRz +IGluIHRoZSBzYW1lIG1lc3NhZ2UuCiBBIGdpdmVuIG5hbWUgbWF5IG9ubHkg +YmUgcmVzZXJ2ZWQgb25jZS4KCgwKBQQCAgkEEgN4AgoKDAoFBAICCQUSA3gL +EQoMCgUEAgIJARIDeBIfCgwKBQQCAgkDEgN4IiQKMgoCBAMSBXwAxwEBGiUg +RGVzY3JpYmVzIGEgZmllbGQgd2l0aGluIGEgbWVzc2FnZS4KCgoKAwQDARID +fAgcCg0KBAQDBAASBX0CmAEDCgwKBQQDBAABEgN9BwsKUwoGBAMEAAIAEgSA +AQQcGkMgMCBpcyByZXNlcnZlZCBmb3IgZXJyb3JzLgogT3JkZXIgaXMgd2Vp +cmQgZm9yIGhpc3RvcmljYWwgcmVhc29ucy4KCg8KBwQDBAACAAESBIABBA8K +DwoHBAMEAAIAAhIEgAEaGwoOCgYEAwQAAgESBIEBBBwKDwoHBAMEAAIBARIE +gQEEDgoPCgcEAwQAAgECEgSBARobCncKBgQDBAACAhIEhAEEHBpnIE5vdCBa +aWdaYWcgZW5jb2RlZC4gIE5lZ2F0aXZlIG51bWJlcnMgdGFrZSAxMCBieXRl +cy4gIFVzZSBUWVBFX1NJTlQ2NCBpZgogbmVnYXRpdmUgdmFsdWVzIGFyZSBs +aWtlbHkuCgoPCgcEAwQAAgIBEgSEAQQOCg8KBwQDBAACAgISBIQBGhsKDgoG +BAMEAAIDEgSFAQQcCg8KBwQDBAACAwESBIUBBA8KDwoHBAMEAAIDAhIEhQEa +Gwp3CgYEAwQAAgQSBIgBBBwaZyBOb3QgWmlnWmFnIGVuY29kZWQuICBOZWdh +dGl2ZSBudW1iZXJzIHRha2UgMTAgYnl0ZXMuICBVc2UgVFlQRV9TSU5UMzIg +aWYKIG5lZ2F0aXZlIHZhbHVlcyBhcmUgbGlrZWx5LgoKDwoHBAMEAAIEARIE +iAEEDgoPCgcEAwQAAgQCEgSIARobCg4KBgQDBAACBRIEiQEEHAoPCgcEAwQA +AgUBEgSJAQQQCg8KBwQDBAACBQISBIkBGhsKDgoGBAMEAAIGEgSKAQQcCg8K +BwQDBAACBgESBIoBBBAKDwoHBAMEAAIGAhIEigEaGwoOCgYEAwQAAgcSBIsB +BBwKDwoHBAMEAAIHARIEiwEEDQoPCgcEAwQAAgcCEgSLARobCg4KBgQDBAAC +CBIEjAEEHAoPCgcEAwQAAggBEgSMAQQPCg8KBwQDBAACCAISBIwBGhsKKgoG +BAMEAAIJEgSNAQQdIhogVGFnLWRlbGltaXRlZCBhZ2dyZWdhdGUuCgoPCgcE +AwQAAgkBEgSNAQQOCg8KBwQDBAACCQISBI0BGhwKLQoGBAMEAAIKEgSOAQQd +Ih0gTGVuZ3RoLWRlbGltaXRlZCBhZ2dyZWdhdGUuCgoPCgcEAwQAAgoBEgSO +AQQQCg8KBwQDBAACCgISBI4BGhwKIwoGBAMEAAILEgSRAQQdGhMgTmV3IGlu +IHZlcnNpb24gMi4KCg8KBwQDBAACCwESBJEBBA4KDwoHBAMEAAILAhIEkQEa +HAoOCgYEAwQAAgwSBJIBBB0KDwoHBAMEAAIMARIEkgEEDwoPCgcEAwQAAgwC +EgSSARocCg4KBgQDBAACDRIEkwEEHQoPCgcEAwQAAg0BEgSTAQQNCg8KBwQD +BAACDQISBJMBGhwKDgoGBAMEAAIOEgSUAQQdCg8KBwQDBAACDgESBJQBBBEK +DwoHBAMEAAIOAhIElAEaHAoOCgYEAwQAAg8SBJUBBB0KDwoHBAMEAAIPARIE +lQEEEQoPCgcEAwQAAg8CEgSVARocCicKBgQDBAACEBIElgEEHSIXIFVzZXMg +WmlnWmFnIGVuY29kaW5nLgoKDwoHBAMEAAIQARIElgEEDwoPCgcEAwQAAhAC +EgSWARocCicKBgQDBAACERIElwEEHSIXIFVzZXMgWmlnWmFnIGVuY29kaW5n +LgoKDwoHBAMEAAIRARIElwEEDwoPCgcEAwQAAhECEgSXARocCg4KBAQDBAES +BpoBAqABAwoNCgUEAwQBARIEmgEHDAoqCgYEAwQBAgASBJwBBBwaGiAwIGlz +IHJlc2VydmVkIGZvciBlcnJvcnMKCg8KBwQDBAECAAESBJwBBBIKDwoHBAME +AQIAAhIEnAEaGwoOCgYEAwQBAgESBJ0BBBwKDwoHBAMEAQIBARIEnQEEEgoP +CgcEAwQBAgECEgSdARobCjgKBgQDBAECAhIEngEEHCIoIFRPRE8oc2FuamF5 +KTogU2hvdWxkIHdlIGFkZCBMQUJFTF9NQVA/CgoPCgcEAwQBAgIBEgSeAQQS +Cg8KBwQDBAECAgISBJ4BGhsKDAoEBAMCABIEogECGwoNCgUEAwIABBIEogEC +CgoNCgUEAwIABRIEogELEQoNCgUEAwIAARIEogESFgoNCgUEAwIAAxIEogEZ +GgoMCgQEAwIBEgSjAQIcCg0KBQQDAgEEEgSjAQIKCg0KBQQDAgEFEgSjAQsQ +Cg0KBQQDAgEBEgSjAREXCg0KBQQDAgEDEgSjARobCgwKBAQDAgISBKQBAhsK +DQoFBAMCAgQSBKQBAgoKDQoFBAMCAgYSBKQBCxAKDQoFBAMCAgESBKQBERYK +DQoFBAMCAgMSBKQBGRoKnAEKBAQDAgMSBKgBAhkajQEgSWYgdHlwZV9uYW1l +IGlzIHNldCwgdGhpcyBuZWVkIG5vdCBiZSBzZXQuICBJZiBib3RoIHRoaXMg +YW5kIHR5cGVfbmFtZQogYXJlIHNldCwgdGhpcyBtdXN0IGJlIG9uZSBvZiBU +WVBFX0VOVU0sIFRZUEVfTUVTU0FHRSBvciBUWVBFX0dST1VQLgoKDQoFBAMC +AwQSBKgBAgoKDQoFBAMCAwYSBKgBCw8KDQoFBAMCAwESBKgBEBQKDQoFBAMC +AwMSBKgBFxgKtwIKBAQDAgQSBK8BAiAaqAIgRm9yIG1lc3NhZ2UgYW5kIGVu +dW0gdHlwZXMsIHRoaXMgaXMgdGhlIG5hbWUgb2YgdGhlIHR5cGUuICBJZiB0 +aGUgbmFtZQogc3RhcnRzIHdpdGggYSAnLicsIGl0IGlzIGZ1bGx5LXF1YWxp +ZmllZC4gIE90aGVyd2lzZSwgQysrLWxpa2Ugc2NvcGluZwogcnVsZXMgYXJl +IHVzZWQgdG8gZmluZCB0aGUgdHlwZSAoaS5lLiBmaXJzdCB0aGUgbmVzdGVk +IHR5cGVzIHdpdGhpbiB0aGlzCiBtZXNzYWdlIGFyZSBzZWFyY2hlZCwgdGhl +biB3aXRoaW4gdGhlIHBhcmVudCwgb24gdXAgdG8gdGhlIHJvb3QKIG5hbWVz +cGFjZSkuCgoNCgUEAwIEBBIErwECCgoNCgUEAwIEBRIErwELEQoNCgUEAwIE +ARIErwESGwoNCgUEAwIEAxIErwEeHwp+CgQEAwIFEgSzAQIfGnAgRm9yIGV4 +dGVuc2lvbnMsIHRoaXMgaXMgdGhlIG5hbWUgb2YgdGhlIHR5cGUgYmVpbmcg +ZXh0ZW5kZWQuICBJdCBpcwogcmVzb2x2ZWQgaW4gdGhlIHNhbWUgbWFubmVy +IGFzIHR5cGVfbmFtZS4KCg0KBQQDAgUEEgSzAQIKCg0KBQQDAgUFEgSzAQsR +Cg0KBQQDAgUBEgSzARIaCg0KBQQDAgUDEgSzAR0eCrECCgQEAwIGEgS6AQIk +GqICIEZvciBudW1lcmljIHR5cGVzLCBjb250YWlucyB0aGUgb3JpZ2luYWwg +dGV4dCByZXByZXNlbnRhdGlvbiBvZiB0aGUgdmFsdWUuCiBGb3IgYm9vbGVh +bnMsICJ0cnVlIiBvciAiZmFsc2UiLgogRm9yIHN0cmluZ3MsIGNvbnRhaW5z +IHRoZSBkZWZhdWx0IHRleHQgY29udGVudHMgKG5vdCBlc2NhcGVkIGluIGFu +eSB3YXkpLgogRm9yIGJ5dGVzLCBjb250YWlucyB0aGUgQyBlc2NhcGVkIHZh +bHVlLiAgQWxsIGJ5dGVzID49IDEyOCBhcmUgZXNjYXBlZC4KIFRPRE8oa2Vu +dG9uKTogIEJhc2UtNjQgZW5jb2RlPwoKDQoFBAMCBgQSBLoBAgoKDQoFBAMC +BgUSBLoBCxEKDQoFBAMCBgESBLoBEh8KDQoFBAMCBgMSBLoBIiMKhAEKBAQD +AgcSBL4BAiEadiBJZiBzZXQsIGdpdmVzIHRoZSBpbmRleCBvZiBhIG9uZW9m +IGluIHRoZSBjb250YWluaW5nIHR5cGUncyBvbmVvZl9kZWNsCiBsaXN0LiAg +VGhpcyBmaWVsZCBpcyBhIG1lbWJlciBvZiB0aGF0IG9uZW9mLgoKDQoFBAMC +BwQSBL4BAgoKDQoFBAMCBwUSBL4BCxAKDQoFBAMCBwESBL4BERwKDQoFBAMC +BwMSBL4BHyAK+gEKBAQDAggSBMQBAiEa6wEgSlNPTiBuYW1lIG9mIHRoaXMg +ZmllbGQuIFRoZSB2YWx1ZSBpcyBzZXQgYnkgcHJvdG9jb2wgY29tcGlsZXIu +IElmIHRoZQogdXNlciBoYXMgc2V0IGEgImpzb25fbmFtZSIgb3B0aW9uIG9u +IHRoaXMgZmllbGQsIHRoYXQgb3B0aW9uJ3MgdmFsdWUKIHdpbGwgYmUgdXNl +ZC4gT3RoZXJ3aXNlLCBpdCdzIGRlZHVjZWQgZnJvbSB0aGUgZmllbGQncyBu +YW1lIGJ5IGNvbnZlcnRpbmcKIGl0IHRvIGNhbWVsQ2FzZS4KCg0KBQQDAggE +EgTEAQIKCg0KBQQDAggFEgTEAQsRCg0KBQQDAggBEgTEARIbCg0KBQQDAggD +EgTEAR4gCgwKBAQDAgkSBMYBAiQKDQoFBAMCCQQSBMYBAgoKDQoFBAMCCQYS +BMYBCxcKDQoFBAMCCQESBMYBGB8KDQoFBAMCCQMSBMYBIiMKIgoCBAQSBsoB +AMwBARoUIERlc2NyaWJlcyBhIG9uZW9mLgoKCwoDBAQBEgTKAQgcCgwKBAQE +AgASBMsBAhsKDQoFBAQCAAQSBMsBAgoKDQoFBAQCAAUSBMsBCxEKDQoFBAQC +AAESBMsBEhYKDQoFBAQCAAMSBMsBGRoKJwoCBAUSBs8BANUBARoZIERlc2Ny +aWJlcyBhbiBlbnVtIHR5cGUuCgoLCgMEBQESBM8BCBsKDAoEBAUCABIE0AEC +GwoNCgUEBQIABBIE0AECCgoNCgUEBQIABRIE0AELEQoNCgUEBQIAARIE0AES +FgoNCgUEBQIAAxIE0AEZGgoMCgQEBQIBEgTSAQIuCg0KBQQFAgEEEgTSAQIK +Cg0KBQQFAgEGEgTSAQsjCg0KBQQFAgEBEgTSASQpCg0KBQQFAgEDEgTSASwt +CgwKBAQFAgISBNQBAiMKDQoFBAUCAgQSBNQBAgoKDQoFBAUCAgYSBNQBCxYK +DQoFBAUCAgESBNQBFx4KDQoFBAUCAgMSBNQBISIKMQoCBAYSBtgBAN0BARoj +IERlc2NyaWJlcyBhIHZhbHVlIHdpdGhpbiBhbiBlbnVtLgoKCwoDBAYBEgTY +AQggCgwKBAQGAgASBNkBAhsKDQoFBAYCAAQSBNkBAgoKDQoFBAYCAAUSBNkB +CxEKDQoFBAYCAAESBNkBEhYKDQoFBAYCAAMSBNkBGRoKDAoEBAYCARIE2gEC +HAoNCgUEBgIBBBIE2gECCgoNCgUEBgIBBRIE2gELEAoNCgUEBgIBARIE2gER +FwoNCgUEBgIBAxIE2gEaGwoMCgQEBgICEgTcAQIoCg0KBQQGAgIEEgTcAQIK +Cg0KBQQGAgIGEgTcAQsbCg0KBQQGAgIBEgTcARwjCg0KBQQGAgIDEgTcASYn +CiQKAgQHEgbgAQDlAQEaFiBEZXNjcmliZXMgYSBzZXJ2aWNlLgoKCwoDBAcB +EgTgAQgeCgwKBAQHAgASBOEBAhsKDQoFBAcCAAQSBOEBAgoKDQoFBAcCAAUS +BOEBCxEKDQoFBAcCAAESBOEBEhYKDQoFBAcCAAMSBOEBGRoKDAoEBAcCARIE +4gECLAoNCgUEBwIBBBIE4gECCgoNCgUEBwIBBhIE4gELIAoNCgUEBwIBARIE +4gEhJwoNCgUEBwIBAxIE4gEqKwoMCgQEBwICEgTkAQImCg0KBQQHAgIEEgTk +AQIKCg0KBQQHAgIGEgTkAQsZCg0KBQQHAgIBEgTkARohCg0KBQQHAgIDEgTk +ASQlCjAKAgQIEgboAQD2AQEaIiBEZXNjcmliZXMgYSBtZXRob2Qgb2YgYSBz +ZXJ2aWNlLgoKCwoDBAgBEgToAQgdCgwKBAQIAgASBOkBAhsKDQoFBAgCAAQS +BOkBAgoKDQoFBAgCAAUSBOkBCxEKDQoFBAgCAAESBOkBEhYKDQoFBAgCAAMS +BOkBGRoKlwEKBAQIAgESBO0BAiEaiAEgSW5wdXQgYW5kIG91dHB1dCB0eXBl +IG5hbWVzLiAgVGhlc2UgYXJlIHJlc29sdmVkIGluIHRoZSBzYW1lIHdheSBh +cwogRmllbGREZXNjcmlwdG9yUHJvdG8udHlwZV9uYW1lLCBidXQgbXVzdCBy +ZWZlciB0byBhIG1lc3NhZ2UgdHlwZS4KCg0KBQQIAgEEEgTtAQIKCg0KBQQI +AgEFEgTtAQsRCg0KBQQIAgEBEgTtARIcCg0KBQQIAgEDEgTtAR8gCgwKBAQI +AgISBO4BAiIKDQoFBAgCAgQSBO4BAgoKDQoFBAgCAgUSBO4BCxEKDQoFBAgC +AgESBO4BEh0KDQoFBAgCAgMSBO4BICEKDAoEBAgCAxIE8AECJQoNCgUECAID +BBIE8AECCgoNCgUECAIDBhIE8AELGAoNCgUECAIDARIE8AEZIAoNCgUECAID +AxIE8AEjJApFCgQECAIEEgTzAQI1GjcgSWRlbnRpZmllcyBpZiBjbGllbnQg +c3RyZWFtcyBtdWx0aXBsZSBjbGllbnQgbWVzc2FnZXMKCg0KBQQIAgQEEgTz +AQIKCg0KBQQIAgQFEgTzAQsPCg0KBQQIAgQBEgTzARAgCg0KBQQIAgQDEgTz +ASMkCg0KBQQIAgQIEgTzASU0Cg0KBQQIAgQHEgTzAS4zCkUKBAQIAgUSBPUB +AjUaNyBJZGVudGlmaWVzIGlmIHNlcnZlciBzdHJlYW1zIG11bHRpcGxlIHNl +cnZlciBtZXNzYWdlcwoKDQoFBAgCBQQSBPUBAgoKDQoFBAgCBQUSBPUBCw8K +DQoFBAgCBQESBPUBECAKDQoFBAgCBQMSBPUBIyQKDQoFBAgCBQgSBPUBJTQK +DQoFBAgCBQcSBPUBLjMKrw4KAgQJEgaaAgCEAwEyTiA9PT09PT09PT09PT09 +PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 +PT09PT09PT09CiBPcHRpb25zCjLQDSBFYWNoIG9mIHRoZSBkZWZpbml0aW9u +cyBhYm92ZSBtYXkgaGF2ZSAib3B0aW9ucyIgYXR0YWNoZWQuICBUaGVzZSBh +cmUKIGp1c3QgYW5ub3RhdGlvbnMgd2hpY2ggbWF5IGNhdXNlIGNvZGUgdG8g +YmUgZ2VuZXJhdGVkIHNsaWdodGx5IGRpZmZlcmVudGx5CiBvciBtYXkgY29u +dGFpbiBoaW50cyBmb3IgY29kZSB0aGF0IG1hbmlwdWxhdGVzIHByb3RvY29s +IG1lc3NhZ2VzLgoKIENsaWVudHMgbWF5IGRlZmluZSBjdXN0b20gb3B0aW9u +cyBhcyBleHRlbnNpb25zIG9mIHRoZSAqT3B0aW9ucyBtZXNzYWdlcy4KIFRo +ZXNlIGV4dGVuc2lvbnMgbWF5IG5vdCB5ZXQgYmUga25vd24gYXQgcGFyc2lu +ZyB0aW1lLCBzbyB0aGUgcGFyc2VyIGNhbm5vdAogc3RvcmUgdGhlIHZhbHVl +cyBpbiB0aGVtLiAgSW5zdGVhZCBpdCBzdG9yZXMgdGhlbSBpbiBhIGZpZWxk +IGluIHRoZSAqT3B0aW9ucwogbWVzc2FnZSBjYWxsZWQgdW5pbnRlcnByZXRl +ZF9vcHRpb24uIFRoaXMgZmllbGQgbXVzdCBoYXZlIHRoZSBzYW1lIG5hbWUK +IGFjcm9zcyBhbGwgKk9wdGlvbnMgbWVzc2FnZXMuIFdlIHRoZW4gdXNlIHRo +aXMgZmllbGQgdG8gcG9wdWxhdGUgdGhlCiBleHRlbnNpb25zIHdoZW4gd2Ug +YnVpbGQgYSBkZXNjcmlwdG9yLCBhdCB3aGljaCBwb2ludCBhbGwgcHJvdG9z +IGhhdmUgYmVlbgogcGFyc2VkIGFuZCBzbyBhbGwgZXh0ZW5zaW9ucyBhcmUg +a25vd24uCgogRXh0ZW5zaW9uIG51bWJlcnMgZm9yIGN1c3RvbSBvcHRpb25z +IG1heSBiZSBjaG9zZW4gYXMgZm9sbG93czoKICogRm9yIG9wdGlvbnMgd2hp +Y2ggd2lsbCBvbmx5IGJlIHVzZWQgd2l0aGluIGEgc2luZ2xlIGFwcGxpY2F0 +aW9uIG9yCiAgIG9yZ2FuaXphdGlvbiwgb3IgZm9yIGV4cGVyaW1lbnRhbCBv +cHRpb25zLCB1c2UgZmllbGQgbnVtYmVycyA1MDAwMAogICB0aHJvdWdoIDk5 +OTk5LiAgSXQgaXMgdXAgdG8geW91IHRvIGVuc3VyZSB0aGF0IHlvdSBkbyBu +b3QgdXNlIHRoZQogICBzYW1lIG51bWJlciBmb3IgbXVsdGlwbGUgb3B0aW9u +cy4KICogRm9yIG9wdGlvbnMgd2hpY2ggd2lsbCBiZSBwdWJsaXNoZWQgYW5k +IHVzZWQgcHVibGljbHkgYnkgbXVsdGlwbGUKICAgaW5kZXBlbmRlbnQgZW50 +aXRpZXMsIGUtbWFpbCBwcm90b2J1Zi1nbG9iYWwtZXh0ZW5zaW9uLXJlZ2lz +dHJ5QGdvb2dsZS5jb20KICAgdG8gcmVzZXJ2ZSBleHRlbnNpb24gbnVtYmVy +cy4gU2ltcGx5IHByb3ZpZGUgeW91ciBwcm9qZWN0IG5hbWUgKGUuZy4KICAg +T2JqZWN0aXZlLUMgcGx1Z2luKSBhbmQgeW91ciBwcm9qZWN0IHdlYnNpdGUg +KGlmIGF2YWlsYWJsZSkgLS0gdGhlcmUncyBubwogICBuZWVkIHRvIGV4cGxh +aW4gaG93IHlvdSBpbnRlbmQgdG8gdXNlIHRoZW0uIFVzdWFsbHkgeW91IG9u +bHkgbmVlZCBvbmUKICAgZXh0ZW5zaW9uIG51bWJlci4gWW91IGNhbiBkZWNs +YXJlIG11bHRpcGxlIG9wdGlvbnMgd2l0aCBvbmx5IG9uZSBleHRlbnNpb24K +ICAgbnVtYmVyIGJ5IHB1dHRpbmcgdGhlbSBpbiBhIHN1Yi1tZXNzYWdlLiBT +ZWUgdGhlIEN1c3RvbSBPcHRpb25zIHNlY3Rpb24gb2YKICAgdGhlIGRvY3Mg +Zm9yIGV4YW1wbGVzOgogICBodHRwczovL2RldmVsb3BlcnMuZ29vZ2xlLmNv +bS9wcm90b2NvbC1idWZmZXJzL2RvY3MvcHJvdG8jb3B0aW9ucwogICBJZiB0 +aGlzIHR1cm5zIG91dCB0byBiZSBwb3B1bGFyLCBhIHdlYiBzZXJ2aWNlIHdp +bGwgYmUgc2V0IHVwCiAgIHRvIGF1dG9tYXRpY2FsbHkgYXNzaWduIG9wdGlv +biBudW1iZXJzLgoKCwoDBAkBEgSaAggTCvQBCgQECQIAEgSgAgIjGuUBIFNl +dHMgdGhlIEphdmEgcGFja2FnZSB3aGVyZSBjbGFzc2VzIGdlbmVyYXRlZCBm +cm9tIHRoaXMgLnByb3RvIHdpbGwgYmUKIHBsYWNlZC4gIEJ5IGRlZmF1bHQs +IHRoZSBwcm90byBwYWNrYWdlIGlzIHVzZWQsIGJ1dCB0aGlzIGlzIG9mdGVu +CiBpbmFwcHJvcHJpYXRlIGJlY2F1c2UgcHJvdG8gcGFja2FnZXMgZG8gbm90 +IG5vcm1hbGx5IHN0YXJ0IHdpdGggYmFja3dhcmRzCiBkb21haW4gbmFtZXMu +CgoNCgUECQIABBIEoAICCgoNCgUECQIABRIEoAILEQoNCgUECQIAARIEoAIS +HgoNCgUECQIAAxIEoAIhIgq/AgoEBAkCARIEqAICKxqwAiBJZiBzZXQsIGFs +bCB0aGUgY2xhc3NlcyBmcm9tIHRoZSAucHJvdG8gZmlsZSBhcmUgd3JhcHBl +ZCBpbiBhIHNpbmdsZQogb3V0ZXIgY2xhc3Mgd2l0aCB0aGUgZ2l2ZW4gbmFt +ZS4gIFRoaXMgYXBwbGllcyB0byBib3RoIFByb3RvMQogKGVxdWl2YWxlbnQg +dG8gdGhlIG9sZCAiLS1vbmVfamF2YV9maWxlIiBvcHRpb24pIGFuZCBQcm90 +bzIgKHdoZXJlCiBhIC5wcm90byBhbHdheXMgdHJhbnNsYXRlcyB0byBhIHNp +bmdsZSBjbGFzcywgYnV0IHlvdSBtYXkgd2FudCB0bwogZXhwbGljaXRseSBj +aG9vc2UgdGhlIGNsYXNzIG5hbWUpLgoKDQoFBAkCAQQSBKgCAgoKDQoFBAkC +AQUSBKgCCxEKDQoFBAkCAQESBKgCEiYKDQoFBAkCAQMSBKgCKSoKowMKBAQJ +AgISBLACAjkalAMgSWYgc2V0IHRydWUsIHRoZW4gdGhlIEphdmEgY29kZSBn +ZW5lcmF0b3Igd2lsbCBnZW5lcmF0ZSBhIHNlcGFyYXRlIC5qYXZhCiBmaWxl +IGZvciBlYWNoIHRvcC1sZXZlbCBtZXNzYWdlLCBlbnVtLCBhbmQgc2Vydmlj +ZSBkZWZpbmVkIGluIHRoZSAucHJvdG8KIGZpbGUuICBUaHVzLCB0aGVzZSB0 +eXBlcyB3aWxsICpub3QqIGJlIG5lc3RlZCBpbnNpZGUgdGhlIG91dGVyIGNs +YXNzCiBuYW1lZCBieSBqYXZhX291dGVyX2NsYXNzbmFtZS4gIEhvd2V2ZXIs +IHRoZSBvdXRlciBjbGFzcyB3aWxsIHN0aWxsIGJlCiBnZW5lcmF0ZWQgdG8g +Y29udGFpbiB0aGUgZmlsZSdzIGdldERlc2NyaXB0b3IoKSBtZXRob2QgYXMg +d2VsbCBhcyBhbnkKIHRvcC1sZXZlbCBleHRlbnNpb25zIGRlZmluZWQgaW4g +dGhlIGZpbGUuCgoNCgUECQICBBIEsAICCgoNCgUECQICBRIEsAILDwoNCgUE +CQICARIEsAIQIwoNCgUECQICAxIEsAImKAoNCgUECQICCBIEsAIpOAoNCgUE +CQICBxIEsAIyNwqbBgoEBAkCAxIEvgICQxqMBiBJZiBzZXQgdHJ1ZSwgdGhl +biB0aGUgSmF2YSBjb2RlIGdlbmVyYXRvciB3aWxsIGdlbmVyYXRlIGVxdWFs +cygpIGFuZAogaGFzaENvZGUoKSBtZXRob2RzIGZvciBhbGwgbWVzc2FnZXMg +ZGVmaW5lZCBpbiB0aGUgLnByb3RvIGZpbGUuCiBUaGlzIGluY3JlYXNlcyBn +ZW5lcmF0ZWQgY29kZSBzaXplLCBwb3RlbnRpYWxseSBzdWJzdGFudGlhbGx5 +IGZvciBsYXJnZQogcHJvdG9zLCB3aGljaCBtYXkgaGFybSBhIG1lbW9yeS1j +b25zdHJhaW5lZCBhcHBsaWNhdGlvbi4KIC0gSW4gdGhlIGZ1bGwgcnVudGlt +ZSB0aGlzIGlzIGEgc3BlZWQgb3B0aW1pemF0aW9uLCBhcyB0aGUKIEFic3Ry +YWN0TWVzc2FnZSBiYXNlIGNsYXNzIGluY2x1ZGVzIHJlZmxlY3Rpb24tYmFz +ZWQgaW1wbGVtZW50YXRpb25zIG9mCiB0aGVzZSBtZXRob2RzLgogLSBJbiB0 +aGUgbGl0ZSBydW50aW1lLCBzZXR0aW5nIHRoaXMgb3B0aW9uIGNoYW5nZXMg +dGhlIHNlbWFudGljcyBvZgogZXF1YWxzKCkgYW5kIGhhc2hDb2RlKCkgdG8g +bW9yZSBjbG9zZWx5IG1hdGNoIHRob3NlIG9mIHRoZSBmdWxsIHJ1bnRpbWU7 +CiB0aGUgZ2VuZXJhdGVkIG1ldGhvZHMgY29tcHV0ZSB0aGVpciByZXN1bHRz +IGJhc2VkIG9uIGZpZWxkIHZhbHVlcyByYXRoZXIKIHRoYW4gb2JqZWN0IGlk +ZW50aXR5LiAoSW1wbGVtZW50YXRpb25zIHNob3VsZCBub3QgYXNzdW1lIHRo +YXQgaGFzaGNvZGVzCiB3aWxsIGJlIGNvbnNpc3RlbnQgYWNyb3NzIHJ1bnRp +bWVzIG9yIHZlcnNpb25zIG9mIHRoZSBwcm90b2NvbCBjb21waWxlci4pCgoN +CgUECQIDBBIEvgICCgoNCgUECQIDBRIEvgILDwoNCgUECQIDARIEvgIQLQoN +CgUECQIDAxIEvgIwMgoNCgUECQIDCBIEvgIzQgoNCgUECQIDBxIEvgI8QQrm +AgoEBAkCBBIExgICPBrXAiBJZiBzZXQgdHJ1ZSwgdGhlbiB0aGUgSmF2YTIg +Y29kZSBnZW5lcmF0b3Igd2lsbCBnZW5lcmF0ZSBjb2RlIHRoYXQKIHRocm93 +cyBhbiBleGNlcHRpb24gd2hlbmV2ZXIgYW4gYXR0ZW1wdCBpcyBtYWRlIHRv +IGFzc2lnbiBhIG5vbi1VVEYtOAogYnl0ZSBzZXF1ZW5jZSB0byBhIHN0cmlu +ZyBmaWVsZC4KIE1lc3NhZ2UgcmVmbGVjdGlvbiB3aWxsIGRvIHRoZSBzYW1l +LgogSG93ZXZlciwgYW4gZXh0ZW5zaW9uIGZpZWxkIHN0aWxsIGFjY2VwdHMg +bm9uLVVURi04IGJ5dGUgc2VxdWVuY2VzLgogVGhpcyBvcHRpb24gaGFzIG5v +IGVmZmVjdCBvbiB3aGVuIHVzZWQgd2l0aCB0aGUgbGl0ZSBydW50aW1lLgoK +DQoFBAkCBAQSBMYCAgoKDQoFBAkCBAUSBMYCCw8KDQoFBAkCBAESBMYCECYK +DQoFBAkCBAMSBMYCKSsKDQoFBAkCBAgSBMYCLDsKDQoFBAkCBAcSBMYCNToK +TAoEBAkEABIGygICzwIDGjwgR2VuZXJhdGVkIGNsYXNzZXMgY2FuIGJlIG9w +dGltaXplZCBmb3Igc3BlZWQgb3IgY29kZSBzaXplLgoKDQoFBAkEAAESBMoC +BxMKRAoGBAkEAAIAEgTLAgQOIjQgR2VuZXJhdGUgY29tcGxldGUgY29kZSBm +b3IgcGFyc2luZywgc2VyaWFsaXphdGlvbiwKCg8KBwQJBAACAAESBMsCBAkK +DwoHBAkEAAIAAhIEywIMDQpHCgYECQQAAgESBM0CBBIaBiBldGMuCiIvIFVz +ZSBSZWZsZWN0aW9uT3BzIHRvIGltcGxlbWVudCB0aGVzZSBtZXRob2RzLgoK +DwoHBAkEAAIBARIEzQIEDQoPCgcECQQAAgECEgTNAhARCkcKBgQJBAACAhIE +zgIEFSI3IEdlbmVyYXRlIGNvZGUgdXNpbmcgTWVzc2FnZUxpdGUgYW5kIHRo +ZSBsaXRlIHJ1bnRpbWUuCgoPCgcECQQAAgIBEgTOAgQQCg8KBwQJBAACAgIS +BM4CExQKDAoEBAkCBRIE0AICOQoNCgUECQIFBBIE0AICCgoNCgUECQIFBhIE +0AILFwoNCgUECQIFARIE0AIYJAoNCgUECQIFAxIE0AInKAoNCgUECQIFCBIE +0AIpOAoNCgUECQIFBxIE0AIyNwriAgoEBAkCBhIE1wICIhrTAiBTZXRzIHRo +ZSBHbyBwYWNrYWdlIHdoZXJlIHN0cnVjdHMgZ2VuZXJhdGVkIGZyb20gdGhp +cyAucHJvdG8gd2lsbCBiZQogcGxhY2VkLiBJZiBvbWl0dGVkLCB0aGUgR28g +cGFja2FnZSB3aWxsIGJlIGRlcml2ZWQgZnJvbSB0aGUgZm9sbG93aW5nOgog +ICAtIFRoZSBiYXNlbmFtZSBvZiB0aGUgcGFja2FnZSBpbXBvcnQgcGF0aCwg +aWYgcHJvdmlkZWQuCiAgIC0gT3RoZXJ3aXNlLCB0aGUgcGFja2FnZSBzdGF0 +ZW1lbnQgaW4gdGhlIC5wcm90byBmaWxlLCBpZiBwcmVzZW50LgogICAtIE90 +aGVyd2lzZSwgdGhlIGJhc2VuYW1lIG9mIHRoZSAucHJvdG8gZmlsZSwgd2l0 +aG91dCBleHRlbnNpb24uCgoNCgUECQIGBBIE1wICCgoNCgUECQIGBRIE1wIL +EQoNCgUECQIGARIE1wISHAoNCgUECQIGAxIE1wIfIQrUBAoEBAkCBxIE5QIC +ORrFBCBTaG91bGQgZ2VuZXJpYyBzZXJ2aWNlcyBiZSBnZW5lcmF0ZWQgaW4g +ZWFjaCBsYW5ndWFnZT8gICJHZW5lcmljIiBzZXJ2aWNlcwogYXJlIG5vdCBz +cGVjaWZpYyB0byBhbnkgcGFydGljdWxhciBSUEMgc3lzdGVtLiAgVGhleSBh +cmUgZ2VuZXJhdGVkIGJ5IHRoZQogbWFpbiBjb2RlIGdlbmVyYXRvcnMgaW4g +ZWFjaCBsYW5ndWFnZSAod2l0aG91dCBhZGRpdGlvbmFsIHBsdWdpbnMpLgog +R2VuZXJpYyBzZXJ2aWNlcyB3ZXJlIHRoZSBvbmx5IGtpbmQgb2Ygc2Vydmlj +ZSBnZW5lcmF0aW9uIHN1cHBvcnRlZCBieQogZWFybHkgdmVyc2lvbnMgb2Yg +Z29vZ2xlLnByb3RvYnVmLgoKIEdlbmVyaWMgc2VydmljZXMgYXJlIG5vdyBj +b25zaWRlcmVkIGRlcHJlY2F0ZWQgaW4gZmF2b3Igb2YgdXNpbmcgcGx1Z2lu +cwogdGhhdCBnZW5lcmF0ZSBjb2RlIHNwZWNpZmljIHRvIHlvdXIgcGFydGlj +dWxhciBSUEMgc3lzdGVtLiAgVGhlcmVmb3JlLAogdGhlc2UgZGVmYXVsdCB0 +byBmYWxzZS4gIE9sZCBjb2RlIHdoaWNoIGRlcGVuZHMgb24gZ2VuZXJpYyBz +ZXJ2aWNlcyBzaG91bGQKIGV4cGxpY2l0bHkgc2V0IHRoZW0gdG8gdHJ1ZS4K +Cg0KBQQJAgcEEgTlAgIKCg0KBQQJAgcFEgTlAgsPCg0KBQQJAgcBEgTlAhAj +Cg0KBQQJAgcDEgTlAiYoCg0KBQQJAgcIEgTlAik4Cg0KBQQJAgcHEgTlAjI3 +CgwKBAQJAggSBOYCAjsKDQoFBAkCCAQSBOYCAgoKDQoFBAkCCAUSBOYCCw8K +DQoFBAkCCAESBOYCECUKDQoFBAkCCAMSBOYCKCoKDQoFBAkCCAgSBOYCKzoK +DQoFBAkCCAcSBOYCNDkKDAoEBAkCCRIE5wICOQoNCgUECQIJBBIE5wICCgoN +CgUECQIJBRIE5wILDwoNCgUECQIJARIE5wIQIwoNCgUECQIJAxIE5wImKAoN +CgUECQIJCBIE5wIpOAoNCgUECQIJBxIE5wIyNwrzAQoEBAkCChIE7QICMBrk +ASBJcyB0aGlzIGZpbGUgZGVwcmVjYXRlZD8KIERlcGVuZGluZyBvbiB0aGUg +dGFyZ2V0IHBsYXRmb3JtLCB0aGlzIGNhbiBlbWl0IERlcHJlY2F0ZWQgYW5u +b3RhdGlvbnMKIGZvciBldmVyeXRoaW5nIGluIHRoZSBmaWxlLCBvciBpdCB3 +aWxsIGJlIGNvbXBsZXRlbHkgaWdub3JlZDsgaW4gdGhlIHZlcnkKIGxlYXN0 +LCB0aGlzIGlzIGEgZm9ybWFsaXphdGlvbiBmb3IgZGVwcmVjYXRpbmcgZmls +ZXMuCgoNCgUECQIKBBIE7QICCgoNCgUECQIKBRIE7QILDwoNCgUECQIKARIE +7QIQGgoNCgUECQIKAxIE7QIdHwoNCgUECQIKCBIE7QIgLwoNCgUECQIKBxIE +7QIpLgp/CgQECQILEgTxAgI2GnEgRW5hYmxlcyB0aGUgdXNlIG9mIGFyZW5h +cyBmb3IgdGhlIHByb3RvIG1lc3NhZ2VzIGluIHRoaXMgZmlsZS4gVGhpcyBh +cHBsaWVzCiBvbmx5IHRvIGdlbmVyYXRlZCBjbGFzc2VzIGZvciBDKysuCgoN +CgUECQILBBIE8QICCgoNCgUECQILBRIE8QILDwoNCgUECQILARIE8QIQIAoN +CgUECQILAxIE8QIjJQoNCgUECQILCBIE8QImNQoNCgUECQILBxIE8QIvNAqS +AQoEBAkCDBIE9gICKRqDASBTZXRzIHRoZSBvYmplY3RpdmUgYyBjbGFzcyBw +cmVmaXggd2hpY2ggaXMgcHJlcGVuZGVkIHRvIGFsbCBvYmplY3RpdmUgYwog +Z2VuZXJhdGVkIGNsYXNzZXMgZnJvbSB0aGlzIC5wcm90by4gVGhlcmUgaXMg +bm8gZGVmYXVsdC4KCg0KBQQJAgwEEgT2AgIKCg0KBQQJAgwFEgT2AgsRCg0K +BQQJAgwBEgT2AhIjCg0KBQQJAgwDEgT2AiYoCkkKBAQJAg0SBPkCAigaOyBO +YW1lc3BhY2UgZm9yIGdlbmVyYXRlZCBjbGFzc2VzOyBkZWZhdWx0cyB0byB0 +aGUgcGFja2FnZS4KCg0KBQQJAg0EEgT5AgIKCg0KBQQJAg0FEgT5AgsRCg0K +BQQJAg0BEgT5AhIiCg0KBQQJAg0DEgT5AiUnCm0KBAQJAg4SBP0CAjUaXyBX +aGV0aGVyIHRoZSBuYW5vIHByb3RvIGNvbXBpbGVyIHNob3VsZCBnZW5lcmF0 +ZSBpbiB0aGUgZGVwcmVjYXRlZCBub24tbmFubwogc3VmZml4ZWQgcGFja2Fn +ZS4KCg0KBQQJAg4EEgT9AgIKCg0KBQQJAg4FEgT9AgsPCg0KBQQJAg4BEgT9 +AhAvCg0KBQQJAg4DEgT9AjI0Ck8KBAQJAg8SBIADAjoaQSBUaGUgcGFyc2Vy +IHN0b3JlcyBvcHRpb25zIGl0IGRvZXNuJ3QgcmVjb2duaXplIGhlcmUuIFNl +ZSBhYm92ZS4KCg0KBQQJAg8EEgSAAwIKCg0KBQQJAg8GEgSAAwseCg0KBQQJ +Ag8BEgSAAx8zCg0KBQQJAg8DEgSAAzY5CloKAwQJBRIEgwMCGRpNIENsaWVu +dHMgY2FuIGRlZmluZSBjdXN0b20gb3B0aW9ucyBpbiBleHRlbnNpb25zIG9m +IHRoaXMgbWVzc2FnZS4gU2VlIGFib3ZlLgoKDAoEBAkFABIEgwMNGAoNCgUE +CQUAARIEgwMNEQoNCgUECQUAAhIEgwMVGAoMCgIEChIGhgMAwgMBCgsKAwQK +ARIEhgMIFgrYBQoEBAoCABIEmQMCPBrJBSBTZXQgdHJ1ZSB0byB1c2UgdGhl +IG9sZCBwcm90bzEgTWVzc2FnZVNldCB3aXJlIGZvcm1hdCBmb3IgZXh0ZW5z +aW9ucy4KIFRoaXMgaXMgcHJvdmlkZWQgZm9yIGJhY2t3YXJkcy1jb21wYXRp +YmlsaXR5IHdpdGggdGhlIE1lc3NhZ2VTZXQgd2lyZQogZm9ybWF0LiAgWW91 +IHNob3VsZCBub3QgdXNlIHRoaXMgZm9yIGFueSBvdGhlciByZWFzb246ICBJ +dCdzIGxlc3MKIGVmZmljaWVudCwgaGFzIGZld2VyIGZlYXR1cmVzLCBhbmQg +aXMgbW9yZSBjb21wbGljYXRlZC4KCiBUaGUgbWVzc2FnZSBtdXN0IGJlIGRl +ZmluZWQgZXhhY3RseSBhcyBmb2xsb3dzOgogICBtZXNzYWdlIEZvbyB7CiAg +ICAgb3B0aW9uIG1lc3NhZ2Vfc2V0X3dpcmVfZm9ybWF0ID0gdHJ1ZTsKICAg +ICBleHRlbnNpb25zIDQgdG8gbWF4OwogICB9CiBOb3RlIHRoYXQgdGhlIG1l +c3NhZ2UgY2Fubm90IGhhdmUgYW55IGRlZmluZWQgZmllbGRzOyBNZXNzYWdl +U2V0cyBvbmx5CiBoYXZlIGV4dGVuc2lvbnMuCgogQWxsIGV4dGVuc2lvbnMg +b2YgeW91ciB0eXBlIG11c3QgYmUgc2luZ3VsYXIgbWVzc2FnZXM7IGUuZy4g +dGhleSBjYW5ub3QKIGJlIGludDMycywgZW51bXMsIG9yIHJlcGVhdGVkIG1l +c3NhZ2VzLgoKIEJlY2F1c2UgdGhpcyBpcyBhbiBvcHRpb24sIHRoZSBhYm92 +ZSB0d28gcmVzdHJpY3Rpb25zIGFyZSBub3QgZW5mb3JjZWQgYnkKIHRoZSBw +cm90b2NvbCBjb21waWxlci4KCg0KBQQKAgAEEgSZAwIKCg0KBQQKAgAFEgSZ +AwsPCg0KBQQKAgABEgSZAxAnCg0KBQQKAgADEgSZAyorCg0KBQQKAgAIEgSZ +Ayw7Cg0KBQQKAgAHEgSZAzU6CusBCgQECgIBEgSeAwJEGtwBIERpc2FibGVz +IHRoZSBnZW5lcmF0aW9uIG9mIHRoZSBzdGFuZGFyZCAiZGVzY3JpcHRvcigp +IiBhY2Nlc3Nvciwgd2hpY2ggY2FuCiBjb25mbGljdCB3aXRoIGEgZmllbGQg +b2YgdGhlIHNhbWUgbmFtZS4gIFRoaXMgaXMgbWVhbnQgdG8gbWFrZSBtaWdy +YXRpb24KIGZyb20gcHJvdG8xIGVhc2llcjsgbmV3IGNvZGUgc2hvdWxkIGF2 +b2lkIGZpZWxkcyBuYW1lZCAiZGVzY3JpcHRvciIuCgoNCgUECgIBBBIEngMC +CgoNCgUECgIBBRIEngMLDwoNCgUECgIBARIEngMQLwoNCgUECgIBAxIEngMy +MwoNCgUECgIBCBIEngM0QwoNCgUECgIBBxIEngM9QgruAQoEBAoCAhIEpAMC +LxrfASBJcyB0aGlzIG1lc3NhZ2UgZGVwcmVjYXRlZD8KIERlcGVuZGluZyBv +biB0aGUgdGFyZ2V0IHBsYXRmb3JtLCB0aGlzIGNhbiBlbWl0IERlcHJlY2F0 +ZWQgYW5ub3RhdGlvbnMKIGZvciB0aGUgbWVzc2FnZSwgb3IgaXQgd2lsbCBi +ZSBjb21wbGV0ZWx5IGlnbm9yZWQ7IGluIHRoZSB2ZXJ5IGxlYXN0LAogdGhp +cyBpcyBhIGZvcm1hbGl6YXRpb24gZm9yIGRlcHJlY2F0aW5nIG1lc3NhZ2Vz +LgoKDQoFBAoCAgQSBKQDAgoKDQoFBAoCAgUSBKQDCw8KDQoFBAoCAgESBKQD +EBoKDQoFBAoCAgMSBKQDHR4KDQoFBAoCAggSBKQDHy4KDQoFBAoCAgcSBKQD +KC0KngYKBAQKAgMSBLsDAh4ajwYgV2hldGhlciB0aGUgbWVzc2FnZSBpcyBh +biBhdXRvbWF0aWNhbGx5IGdlbmVyYXRlZCBtYXAgZW50cnkgdHlwZSBmb3Ig +dGhlCiBtYXBzIGZpZWxkLgoKIEZvciBtYXBzIGZpZWxkczoKICAgICBtYXA8 +S2V5VHlwZSwgVmFsdWVUeXBlPiBtYXBfZmllbGQgPSAxOwogVGhlIHBhcnNl +ZCBkZXNjcmlwdG9yIGxvb2tzIGxpa2U6CiAgICAgbWVzc2FnZSBNYXBGaWVs +ZEVudHJ5IHsKICAgICAgICAgb3B0aW9uIG1hcF9lbnRyeSA9IHRydWU7CiAg +ICAgICAgIG9wdGlvbmFsIEtleVR5cGUga2V5ID0gMTsKICAgICAgICAgb3B0 +aW9uYWwgVmFsdWVUeXBlIHZhbHVlID0gMjsKICAgICB9CiAgICAgcmVwZWF0 +ZWQgTWFwRmllbGRFbnRyeSBtYXBfZmllbGQgPSAxOwoKIEltcGxlbWVudGF0 +aW9ucyBtYXkgY2hvb3NlIG5vdCB0byBnZW5lcmF0ZSB0aGUgbWFwX2VudHJ5 +PXRydWUgbWVzc2FnZSwgYnV0CiB1c2UgYSBuYXRpdmUgbWFwIGluIHRoZSB0 +YXJnZXQgbGFuZ3VhZ2UgdG8gaG9sZCB0aGUga2V5cyBhbmQgdmFsdWVzLgog +VGhlIHJlZmxlY3Rpb24gQVBJcyBpbiBzdWNoIGltcGxlbWVudGlvbnMgc3Rp +bGwgbmVlZCB0byB3b3JrIGFzCiBpZiB0aGUgZmllbGQgaXMgYSByZXBlYXRl +ZCBtZXNzYWdlIGZpZWxkLgoKIE5PVEU6IERvIG5vdCBzZXQgdGhlIG9wdGlv +biBpbiAucHJvdG8gZmlsZXMuIEFsd2F5cyB1c2UgdGhlIG1hcHMgc3ludGF4 +CiBpbnN0ZWFkLiBUaGUgb3B0aW9uIHNob3VsZCBvbmx5IGJlIGltcGxpY2l0 +bHkgc2V0IGJ5IHRoZSBwcm90byBjb21waWxlcgogcGFyc2VyLgoKDQoFBAoC +AwQSBLsDAgoKDQoFBAoCAwUSBLsDCw8KDQoFBAoCAwESBLsDEBkKDQoFBAoC +AwMSBLsDHB0KTwoEBAoCBBIEvgMCOhpBIFRoZSBwYXJzZXIgc3RvcmVzIG9w +dGlvbnMgaXQgZG9lc24ndCByZWNvZ25pemUgaGVyZS4gU2VlIGFib3ZlLgoK +DQoFBAoCBAQSBL4DAgoKDQoFBAoCBAYSBL4DCx4KDQoFBAoCBAESBL4DHzMK +DQoFBAoCBAMSBL4DNjkKWgoDBAoFEgTBAwIZGk0gQ2xpZW50cyBjYW4gZGVm +aW5lIGN1c3RvbSBvcHRpb25zIGluIGV4dGVuc2lvbnMgb2YgdGhpcyBtZXNz +YWdlLiBTZWUgYWJvdmUuCgoMCgQECgUAEgTBAw0YCg0KBQQKBQABEgTBAw0R +Cg0KBQQKBQACEgTBAxUYCgwKAgQLEgbEAwCcBAEKCwoDBAsBEgTEAwgUCqMC +CgQECwIAEgTJAwIuGpQCIFRoZSBjdHlwZSBvcHRpb24gaW5zdHJ1Y3RzIHRo +ZSBDKysgY29kZSBnZW5lcmF0b3IgdG8gdXNlIGEgZGlmZmVyZW50CiByZXBy +ZXNlbnRhdGlvbiBvZiB0aGUgZmllbGQgdGhhbiBpdCBub3JtYWxseSB3b3Vs +ZC4gIFNlZSB0aGUgc3BlY2lmaWMKIG9wdGlvbnMgYmVsb3cuICBUaGlzIG9w +dGlvbiBpcyBub3QgeWV0IGltcGxlbWVudGVkIGluIHRoZSBvcGVuIHNvdXJj +ZQogcmVsZWFzZSAtLSBzb3JyeSwgd2UnbGwgdHJ5IHRvIGluY2x1ZGUgaXQg +aW4gYSBmdXR1cmUgdmVyc2lvbiEKCg0KBQQLAgAEEgTJAwIKCg0KBQQLAgAG +EgTJAwsQCg0KBQQLAgABEgTJAxEWCg0KBQQLAgADEgTJAxkaCg0KBQQLAgAI +EgTJAxstCg0KBQQLAgAHEgTJAyYsCg4KBAQLBAASBsoDAtEDAwoNCgUECwQA +ARIEygMHDAofCgYECwQAAgASBMwDBA8aDyBEZWZhdWx0IG1vZGUuCgoPCgcE +CwQAAgABEgTMAwQKCg8KBwQLBAACAAISBMwDDQ4KDgoGBAsEAAIBEgTOAwQN +Cg8KBwQLBAACAQESBM4DBAgKDwoHBAsEAAIBAhIEzgMLDAoOCgYECwQAAgIS +BNADBBUKDwoHBAsEAAICARIE0AMEEAoPCgcECwQAAgICEgTQAxMUCtoCCgQE +CwIBEgTXAwIbGssCIFRoZSBwYWNrZWQgb3B0aW9uIGNhbiBiZSBlbmFibGVk +IGZvciByZXBlYXRlZCBwcmltaXRpdmUgZmllbGRzIHRvIGVuYWJsZQogYSBt +b3JlIGVmZmljaWVudCByZXByZXNlbnRhdGlvbiBvbiB0aGUgd2lyZS4gUmF0 +aGVyIHRoYW4gcmVwZWF0ZWRseQogd3JpdGluZyB0aGUgdGFnIGFuZCB0eXBl +IGZvciBlYWNoIGVsZW1lbnQsIHRoZSBlbnRpcmUgYXJyYXkgaXMgZW5jb2Rl +ZCBhcwogYSBzaW5nbGUgbGVuZ3RoLWRlbGltaXRlZCBibG9iLiBJbiBwcm90 +bzMsIG9ubHkgZXhwbGljaXQgc2V0dGluZyBpdCB0bwogZmFsc2Ugd2lsbCBh +dm9pZCB1c2luZyBwYWNrZWQgZW5jb2RpbmcuCgoNCgUECwIBBBIE1wMCCgoN +CgUECwIBBRIE1wMLDwoNCgUECwIBARIE1wMQFgoNCgUECwIBAxIE1wMZGgrk +BAoEBAsCAhIE4wMCMxrVBCBUaGUganN0eXBlIG9wdGlvbiBkZXRlcm1pbmVz +IHRoZSBKYXZhU2NyaXB0IHR5cGUgdXNlZCBmb3IgdmFsdWVzIG9mIHRoZQog +ZmllbGQuICBUaGUgb3B0aW9uIGlzIHBlcm1pdHRlZCBvbmx5IGZvciA2NCBi +aXQgaW50ZWdyYWwgYW5kIGZpeGVkIHR5cGVzCiAoaW50NjQsIHVpbnQ2NCwg +c2ludDY0LCBmaXhlZDY0LCBzZml4ZWQ2NCkuICBCeSBkZWZhdWx0IHRoZXNl +IHR5cGVzIGFyZQogcmVwcmVzZW50ZWQgYXMgSmF2YVNjcmlwdCBzdHJpbmdz +LiAgVGhpcyBhdm9pZHMgbG9zcyBvZiBwcmVjaXNpb24gdGhhdCBjYW4KIGhh +cHBlbiB3aGVuIGEgbGFyZ2UgdmFsdWUgaXMgY29udmVydGVkIHRvIGEgZmxv +YXRpbmcgcG9pbnQgSmF2YVNjcmlwdAogbnVtYmVycy4gIFNwZWNpZnlpbmcg +SlNfTlVNQkVSIGZvciB0aGUganN0eXBlIGNhdXNlcyB0aGUgZ2VuZXJhdGVk +CiBKYXZhU2NyaXB0IGNvZGUgdG8gdXNlIHRoZSBKYXZhU2NyaXB0ICJudW1i +ZXIiIHR5cGUgaW5zdGVhZCBvZiBzdHJpbmdzLgogVGhpcyBvcHRpb24gaXMg +YW4gZW51bSB0byBwZXJtaXQgYWRkaXRpb25hbCB0eXBlcyB0byBiZSBhZGRl +ZCwKIGUuZy4gZ29vZy5tYXRoLkludGVnZXIuCgoNCgUECwICBBIE4wMCCgoN +CgUECwICBhIE4wMLEQoNCgUECwICARIE4wMSGAoNCgUECwICAxIE4wMbHAoN +CgUECwICCBIE4wMdMgoNCgUECwICBxIE4wMoMQoOCgQECwQBEgbkAwLtAwMK +DQoFBAsEAQESBOQDBw0KJwoGBAsEAQIAEgTmAwQSGhcgVXNlIHRoZSBkZWZh +dWx0IHR5cGUuCgoPCgcECwQBAgABEgTmAwQNCg8KBwQLBAECAAISBOYDEBEK +KQoGBAsEAQIBEgTpAwQSGhkgVXNlIEphdmFTY3JpcHQgc3RyaW5ncy4KCg8K +BwQLBAECAQESBOkDBA0KDwoHBAsEAQIBAhIE6QMQEQopCgYECwQBAgISBOwD +BBIaGSBVc2UgSmF2YVNjcmlwdCBudW1iZXJzLgoKDwoHBAsEAQICARIE7AME +DQoPCgcECwQBAgICEgTsAxARCvAMCgQECwIDEgSLBAIpGuEMIFNob3VsZCB0 +aGlzIGZpZWxkIGJlIHBhcnNlZCBsYXppbHk/ICBMYXp5IGFwcGxpZXMgb25s +eSB0byBtZXNzYWdlLXR5cGUKIGZpZWxkcy4gIEl0IG1lYW5zIHRoYXQgd2hl +biB0aGUgb3V0ZXIgbWVzc2FnZSBpcyBpbml0aWFsbHkgcGFyc2VkLCB0aGUK +IGlubmVyIG1lc3NhZ2UncyBjb250ZW50cyB3aWxsIG5vdCBiZSBwYXJzZWQg +YnV0IGluc3RlYWQgc3RvcmVkIGluIGVuY29kZWQKIGZvcm0uICBUaGUgaW5u +ZXIgbWVzc2FnZSB3aWxsIGFjdHVhbGx5IGJlIHBhcnNlZCB3aGVuIGl0IGlz +IGZpcnN0IGFjY2Vzc2VkLgoKIFRoaXMgaXMgb25seSBhIGhpbnQuICBJbXBs +ZW1lbnRhdGlvbnMgYXJlIGZyZWUgdG8gY2hvb3NlIHdoZXRoZXIgdG8gdXNl +CiBlYWdlciBvciBsYXp5IHBhcnNpbmcgcmVnYXJkbGVzcyBvZiB0aGUgdmFs +dWUgb2YgdGhpcyBvcHRpb24uICBIb3dldmVyLAogc2V0dGluZyB0aGlzIG9w +dGlvbiB0cnVlIHN1Z2dlc3RzIHRoYXQgdGhlIHByb3RvY29sIGF1dGhvciBi +ZWxpZXZlcyB0aGF0CiB1c2luZyBsYXp5IHBhcnNpbmcgb24gdGhpcyBmaWVs +ZCBpcyB3b3J0aCB0aGUgYWRkaXRpb25hbCBib29ra2VlcGluZwogb3Zlcmhl +YWQgdHlwaWNhbGx5IG5lZWRlZCB0byBpbXBsZW1lbnQgaXQuCgogVGhpcyBv +cHRpb24gZG9lcyBub3QgYWZmZWN0IHRoZSBwdWJsaWMgaW50ZXJmYWNlIG9m +IGFueSBnZW5lcmF0ZWQgY29kZTsKIGFsbCBtZXRob2Qgc2lnbmF0dXJlcyBy +ZW1haW4gdGhlIHNhbWUuICBGdXJ0aGVybW9yZSwgdGhyZWFkLXNhZmV0eSBv +ZiB0aGUKIGludGVyZmFjZSBpcyBub3QgYWZmZWN0ZWQgYnkgdGhpcyBvcHRp +b247IGNvbnN0IG1ldGhvZHMgcmVtYWluIHNhZmUgdG8KIGNhbGwgZnJvbSBt +dWx0aXBsZSB0aHJlYWRzIGNvbmN1cnJlbnRseSwgd2hpbGUgbm9uLWNvbnN0 +IG1ldGhvZHMgY29udGludWUKIHRvIHJlcXVpcmUgZXhjbHVzaXZlIGFjY2Vz +cy4KCgogTm90ZSB0aGF0IGltcGxlbWVudGF0aW9ucyBtYXkgY2hvb3NlIG5v +dCB0byBjaGVjayByZXF1aXJlZCBmaWVsZHMgd2l0aGluCiBhIGxhenkgc3Vi +LW1lc3NhZ2UuICBUaGF0IGlzLCBjYWxsaW5nIElzSW5pdGlhbGl6ZWQoKSBv +biB0aGUgb3V0aGVyIG1lc3NhZ2UKIG1heSByZXR1cm4gdHJ1ZSBldmVuIGlm +IHRoZSBpbm5lciBtZXNzYWdlIGhhcyBtaXNzaW5nIHJlcXVpcmVkIGZpZWxk +cy4KIFRoaXMgaXMgbmVjZXNzYXJ5IGJlY2F1c2Ugb3RoZXJ3aXNlIHRoZSBp +bm5lciBtZXNzYWdlIHdvdWxkIGhhdmUgdG8gYmUKIHBhcnNlZCBpbiBvcmRl +ciB0byBwZXJmb3JtIHRoZSBjaGVjaywgZGVmZWF0aW5nIHRoZSBwdXJwb3Nl +IG9mIGxhenkKIHBhcnNpbmcuICBBbiBpbXBsZW1lbnRhdGlvbiB3aGljaCBj +aG9vc2VzIG5vdCB0byBjaGVjayByZXF1aXJlZCBmaWVsZHMKIG11c3QgYmUg +Y29uc2lzdGVudCBhYm91dCBpdC4gIFRoYXQgaXMsIGZvciBhbnkgcGFydGlj +dWxhciBzdWItbWVzc2FnZSwgdGhlCiBpbXBsZW1lbnRhdGlvbiBtdXN0IGVp +dGhlciAqYWx3YXlzKiBjaGVjayBpdHMgcmVxdWlyZWQgZmllbGRzLCBvciAq +bmV2ZXIqCiBjaGVjayBpdHMgcmVxdWlyZWQgZmllbGRzLCByZWdhcmRsZXNz +IG9mIHdoZXRoZXIgb3Igbm90IHRoZSBtZXNzYWdlIGhhcwogYmVlbiBwYXJz +ZWQuCgoNCgUECwIDBBIEiwQCCgoNCgUECwIDBRIEiwQLDwoNCgUECwIDARIE +iwQQFAoNCgUECwIDAxIEiwQXGAoNCgUECwIDCBIEiwQZKAoNCgUECwIDBxIE +iwQiJwroAQoEBAsCBBIEkQQCLxrZASBJcyB0aGlzIGZpZWxkIGRlcHJlY2F0 +ZWQ/CiBEZXBlbmRpbmcgb24gdGhlIHRhcmdldCBwbGF0Zm9ybSwgdGhpcyBj +YW4gZW1pdCBEZXByZWNhdGVkIGFubm90YXRpb25zCiBmb3IgYWNjZXNzb3Jz +LCBvciBpdCB3aWxsIGJlIGNvbXBsZXRlbHkgaWdub3JlZDsgaW4gdGhlIHZl +cnkgbGVhc3QsIHRoaXMKIGlzIGEgZm9ybWFsaXphdGlvbiBmb3IgZGVwcmVj +YXRpbmcgZmllbGRzLgoKDQoFBAsCBAQSBJEEAgoKDQoFBAsCBAUSBJEECw8K +DQoFBAsCBAESBJEEEBoKDQoFBAsCBAMSBJEEHR4KDQoFBAsCBAgSBJEEHy4K +DQoFBAsCBAcSBJEEKC0KPwoEBAsCBRIElAQCKhoxIEZvciBHb29nbGUtaW50 +ZXJuYWwgbWlncmF0aW9uIG9ubHkuIERvIG5vdCB1c2UuCgoNCgUECwIFBBIE +lAQCCgoNCgUECwIFBRIElAQLDwoNCgUECwIFARIElAQQFAoNCgUECwIFAxIE +lAQXGQoNCgUECwIFCBIElAQaKQoNCgUECwIFBxIElAQjKApPCgQECwIGEgSY +BAI6GkEgVGhlIHBhcnNlciBzdG9yZXMgb3B0aW9ucyBpdCBkb2Vzbid0IHJl +Y29nbml6ZSBoZXJlLiBTZWUgYWJvdmUuCgoNCgUECwIGBBIEmAQCCgoNCgUE +CwIGBhIEmAQLHgoNCgUECwIGARIEmAQfMwoNCgUECwIGAxIEmAQ2OQpaCgME +CwUSBJsEAhkaTSBDbGllbnRzIGNhbiBkZWZpbmUgY3VzdG9tIG9wdGlvbnMg +aW4gZXh0ZW5zaW9ucyBvZiB0aGlzIG1lc3NhZ2UuIFNlZSBhYm92ZS4KCgwK +BAQLBQASBJsEDRgKDQoFBAsFAAESBJsEDREKDQoFBAsFAAISBJsEFRgKDAoC +BAwSBp4EAK8EAQoLCgMEDAESBJ4ECBMKYAoEBAwCABIEogQCIBpSIFNldCB0 +aGlzIG9wdGlvbiB0byB0cnVlIHRvIGFsbG93IG1hcHBpbmcgZGlmZmVyZW50 +IHRhZyBuYW1lcyB0byB0aGUgc2FtZQogdmFsdWUuCgoNCgUEDAIABBIEogQC +CgoNCgUEDAIABRIEogQLDwoNCgUEDAIAARIEogQQGwoNCgUEDAIAAxIEogQe +HwrlAQoEBAwCARIEqAQCLxrWASBJcyB0aGlzIGVudW0gZGVwcmVjYXRlZD8K +IERlcGVuZGluZyBvbiB0aGUgdGFyZ2V0IHBsYXRmb3JtLCB0aGlzIGNhbiBl +bWl0IERlcHJlY2F0ZWQgYW5ub3RhdGlvbnMKIGZvciB0aGUgZW51bSwgb3Ig +aXQgd2lsbCBiZSBjb21wbGV0ZWx5IGlnbm9yZWQ7IGluIHRoZSB2ZXJ5IGxl +YXN0LCB0aGlzCiBpcyBhIGZvcm1hbGl6YXRpb24gZm9yIGRlcHJlY2F0aW5n +IGVudW1zLgoKDQoFBAwCAQQSBKgEAgoKDQoFBAwCAQUSBKgECw8KDQoFBAwC +AQESBKgEEBoKDQoFBAwCAQMSBKgEHR4KDQoFBAwCAQgSBKgEHy4KDQoFBAwC +AQcSBKgEKC0KTwoEBAwCAhIEqwQCOhpBIFRoZSBwYXJzZXIgc3RvcmVzIG9w +dGlvbnMgaXQgZG9lc24ndCByZWNvZ25pemUgaGVyZS4gU2VlIGFib3ZlLgoK +DQoFBAwCAgQSBKsEAgoKDQoFBAwCAgYSBKsECx4KDQoFBAwCAgESBKsEHzMK +DQoFBAwCAgMSBKsENjkKWgoDBAwFEgSuBAIZGk0gQ2xpZW50cyBjYW4gZGVm +aW5lIGN1c3RvbSBvcHRpb25zIGluIGV4dGVuc2lvbnMgb2YgdGhpcyBtZXNz +YWdlLiBTZWUgYWJvdmUuCgoMCgQEDAUAEgSuBA0YCg0KBQQMBQABEgSuBA0R +Cg0KBQQMBQACEgSuBBUYCgwKAgQNEgaxBAC9BAEKCwoDBA0BEgSxBAgYCvcB +CgQEDQIAEgS2BAIvGugBIElzIHRoaXMgZW51bSB2YWx1ZSBkZXByZWNhdGVk +PwogRGVwZW5kaW5nIG9uIHRoZSB0YXJnZXQgcGxhdGZvcm0sIHRoaXMgY2Fu +IGVtaXQgRGVwcmVjYXRlZCBhbm5vdGF0aW9ucwogZm9yIHRoZSBlbnVtIHZh +bHVlLCBvciBpdCB3aWxsIGJlIGNvbXBsZXRlbHkgaWdub3JlZDsgaW4gdGhl +IHZlcnkgbGVhc3QsCiB0aGlzIGlzIGEgZm9ybWFsaXphdGlvbiBmb3IgZGVw +cmVjYXRpbmcgZW51bSB2YWx1ZXMuCgoNCgUEDQIABBIEtgQCCgoNCgUEDQIA +BRIEtgQLDwoNCgUEDQIAARIEtgQQGgoNCgUEDQIAAxIEtgQdHgoNCgUEDQIA +CBIEtgQfLgoNCgUEDQIABxIEtgQoLQpPCgQEDQIBEgS5BAI6GkEgVGhlIHBh +cnNlciBzdG9yZXMgb3B0aW9ucyBpdCBkb2Vzbid0IHJlY29nbml6ZSBoZXJl +LiBTZWUgYWJvdmUuCgoNCgUEDQIBBBIEuQQCCgoNCgUEDQIBBhIEuQQLHgoN +CgUEDQIBARIEuQQfMwoNCgUEDQIBAxIEuQQ2OQpaCgMEDQUSBLwEAhkaTSBD +bGllbnRzIGNhbiBkZWZpbmUgY3VzdG9tIG9wdGlvbnMgaW4gZXh0ZW5zaW9u +cyBvZiB0aGlzIG1lc3NhZ2UuIFNlZSBhYm92ZS4KCgwKBAQNBQASBLwEDRgK +DQoFBA0FAAESBLwEDREKDQoFBA0FAAISBLwEFRgKDAoCBA4SBr8EANEEAQoL +CgMEDgESBL8ECBYK2QMKBAQOAgASBMoEAjAa3wEgSXMgdGhpcyBzZXJ2aWNl +IGRlcHJlY2F0ZWQ/CiBEZXBlbmRpbmcgb24gdGhlIHRhcmdldCBwbGF0Zm9y +bSwgdGhpcyBjYW4gZW1pdCBEZXByZWNhdGVkIGFubm90YXRpb25zCiBmb3Ig +dGhlIHNlcnZpY2UsIG9yIGl0IHdpbGwgYmUgY29tcGxldGVseSBpZ25vcmVk +OyBpbiB0aGUgdmVyeSBsZWFzdCwKIHRoaXMgaXMgYSBmb3JtYWxpemF0aW9u +IGZvciBkZXByZWNhdGluZyBzZXJ2aWNlcy4KMugBIE5vdGU6ICBGaWVsZCBu +dW1iZXJzIDEgdGhyb3VnaCAzMiBhcmUgcmVzZXJ2ZWQgZm9yIEdvb2dsZSdz +IGludGVybmFsIFJQQwogICBmcmFtZXdvcmsuICBXZSBhcG9sb2dpemUgZm9y +IGhvYXJkaW5nIHRoZXNlIG51bWJlcnMgdG8gb3Vyc2VsdmVzLCBidXQKICAg +d2Ugd2VyZSBhbHJlYWR5IHVzaW5nIHRoZW0gbG9uZyBiZWZvcmUgd2UgZGVj +aWRlZCB0byByZWxlYXNlIFByb3RvY29sCiAgIEJ1ZmZlcnMuCgoNCgUEDgIA +BBIEygQCCgoNCgUEDgIABRIEygQLDwoNCgUEDgIAARIEygQQGgoNCgUEDgIA +AxIEygQdHwoNCgUEDgIACBIEygQgLwoNCgUEDgIABxIEygQpLgpPCgQEDgIB +EgTNBAI6GkEgVGhlIHBhcnNlciBzdG9yZXMgb3B0aW9ucyBpdCBkb2Vzbid0 +IHJlY29nbml6ZSBoZXJlLiBTZWUgYWJvdmUuCgoNCgUEDgIBBBIEzQQCCgoN +CgUEDgIBBhIEzQQLHgoNCgUEDgIBARIEzQQfMwoNCgUEDgIBAxIEzQQ2OQpa +CgMEDgUSBNAEAhkaTSBDbGllbnRzIGNhbiBkZWZpbmUgY3VzdG9tIG9wdGlv +bnMgaW4gZXh0ZW5zaW9ucyBvZiB0aGlzIG1lc3NhZ2UuIFNlZSBhYm92ZS4K +CgwKBAQOBQASBNAEDRgKDQoFBA4FAAESBNAEDREKDQoFBA4FAAISBNAEFRgK +DAoCBA8SBtMEAOUEAQoLCgMEDwESBNMECBUK1gMKBAQPAgASBN4EAjAa3AEg +SXMgdGhpcyBtZXRob2QgZGVwcmVjYXRlZD8KIERlcGVuZGluZyBvbiB0aGUg +dGFyZ2V0IHBsYXRmb3JtLCB0aGlzIGNhbiBlbWl0IERlcHJlY2F0ZWQgYW5u +b3RhdGlvbnMKIGZvciB0aGUgbWV0aG9kLCBvciBpdCB3aWxsIGJlIGNvbXBs +ZXRlbHkgaWdub3JlZDsgaW4gdGhlIHZlcnkgbGVhc3QsCiB0aGlzIGlzIGEg +Zm9ybWFsaXphdGlvbiBmb3IgZGVwcmVjYXRpbmcgbWV0aG9kcy4KMugBIE5v +dGU6ICBGaWVsZCBudW1iZXJzIDEgdGhyb3VnaCAzMiBhcmUgcmVzZXJ2ZWQg +Zm9yIEdvb2dsZSdzIGludGVybmFsIFJQQwogICBmcmFtZXdvcmsuICBXZSBh +cG9sb2dpemUgZm9yIGhvYXJkaW5nIHRoZXNlIG51bWJlcnMgdG8gb3Vyc2Vs +dmVzLCBidXQKICAgd2Ugd2VyZSBhbHJlYWR5IHVzaW5nIHRoZW0gbG9uZyBi +ZWZvcmUgd2UgZGVjaWRlZCB0byByZWxlYXNlIFByb3RvY29sCiAgIEJ1ZmZl +cnMuCgoNCgUEDwIABBIE3gQCCgoNCgUEDwIABRIE3gQLDwoNCgUEDwIAARIE +3gQQGgoNCgUEDwIAAxIE3gQdHwoNCgUEDwIACBIE3gQgLwoNCgUEDwIABxIE +3gQpLgpPCgQEDwIBEgThBAI6GkEgVGhlIHBhcnNlciBzdG9yZXMgb3B0aW9u +cyBpdCBkb2Vzbid0IHJlY29nbml6ZSBoZXJlLiBTZWUgYWJvdmUuCgoNCgUE +DwIBBBIE4QQCCgoNCgUEDwIBBhIE4QQLHgoNCgUEDwIBARIE4QQfMwoNCgUE +DwIBAxIE4QQ2OQpaCgMEDwUSBOQEAhkaTSBDbGllbnRzIGNhbiBkZWZpbmUg +Y3VzdG9tIG9wdGlvbnMgaW4gZXh0ZW5zaW9ucyBvZiB0aGlzIG1lc3NhZ2Uu +IFNlZSBhYm92ZS4KCgwKBAQPBQASBOQEDRgKDQoFBA8FAAESBOQEDREKDQoF +BA8FAAISBOQEFRgKiwMKAgQQEgbuBACCBQEa/AIgQSBtZXNzYWdlIHJlcHJl +c2VudGluZyBhIG9wdGlvbiB0aGUgcGFyc2VyIGRvZXMgbm90IHJlY29nbml6 +ZS4gVGhpcyBvbmx5CiBhcHBlYXJzIGluIG9wdGlvbnMgcHJvdG9zIGNyZWF0 +ZWQgYnkgdGhlIGNvbXBpbGVyOjpQYXJzZXIgY2xhc3MuCiBEZXNjcmlwdG9y +UG9vbCByZXNvbHZlcyB0aGVzZSB3aGVuIGJ1aWxkaW5nIERlc2NyaXB0b3Ig +b2JqZWN0cy4gVGhlcmVmb3JlLAogb3B0aW9ucyBwcm90b3MgaW4gZGVzY3Jp +cHRvciBvYmplY3RzIChlLmcuIHJldHVybmVkIGJ5IERlc2NyaXB0b3I6Om9w +dGlvbnMoKSwKIG9yIHByb2R1Y2VkIGJ5IERlc2NyaXB0b3I6OkNvcHlUbygp +KSB3aWxsIG5ldmVyIGhhdmUgVW5pbnRlcnByZXRlZE9wdGlvbnMKIGluIHRo +ZW0uCgoLCgMEEAESBO4ECBsKywIKBAQQAwASBvQEAvcEAxq6AiBUaGUgbmFt +ZSBvZiB0aGUgdW5pbnRlcnByZXRlZCBvcHRpb24uICBFYWNoIHN0cmluZyBy +ZXByZXNlbnRzIGEgc2VnbWVudCBpbgogYSBkb3Qtc2VwYXJhdGVkIG5hbWUu +ICBpc19leHRlbnNpb24gaXMgdHJ1ZSBpZmYgYSBzZWdtZW50IHJlcHJlc2Vu +dHMgYW4KIGV4dGVuc2lvbiAoZGVub3RlZCB3aXRoIHBhcmVudGhlc2VzIGlu +IG9wdGlvbnMgc3BlY3MgaW4gLnByb3RvIGZpbGVzKS4KIEUuZy4seyBbImZv +byIsIGZhbHNlXSwgWyJiYXIuYmF6IiwgdHJ1ZV0sIFsicXV4IiwgZmFsc2Vd +IH0gcmVwcmVzZW50cwogImZvby4oYmFyLmJheikucXV4Ii4KCg0KBQQQAwAB +EgT0BAoSCg4KBgQQAwACABIE9QQEIgoPCgcEEAMAAgAEEgT1BAQMCg8KBwQQ +AwACAAUSBPUEDRMKDwoHBBADAAIAARIE9QQUHQoPCgcEEAMAAgADEgT1BCAh +Cg4KBgQQAwACARIE9gQEIwoPCgcEEAMAAgEEEgT2BAQMCg8KBwQQAwACAQUS +BPYEDREKDwoHBBADAAIBARIE9gQSHgoPCgcEEAMAAgEDEgT2BCEiCgwKBAQQ +AgASBPgEAh0KDQoFBBACAAQSBPgEAgoKDQoFBBACAAYSBPgECxMKDQoFBBAC +AAESBPgEFBgKDQoFBBACAAMSBPgEGxwKnAEKBAQQAgESBPwEAicajQEgVGhl +IHZhbHVlIG9mIHRoZSB1bmludGVycHJldGVkIG9wdGlvbiwgaW4gd2hhdGV2 +ZXIgdHlwZSB0aGUgdG9rZW5pemVyCiBpZGVudGlmaWVkIGl0IGFzIGR1cmlu +ZyBwYXJzaW5nLiBFeGFjdGx5IG9uZSBvZiB0aGVzZSBzaG91bGQgYmUgc2V0 +LgoKDQoFBBACAQQSBPwEAgoKDQoFBBACAQUSBPwECxEKDQoFBBACAQESBPwE +EiIKDQoFBBACAQMSBPwEJSYKDAoEBBACAhIE/QQCKQoNCgUEEAICBBIE/QQC +CgoNCgUEEAICBRIE/QQLEQoNCgUEEAICARIE/QQSJAoNCgUEEAICAxIE/QQn +KAoMCgQEEAIDEgT+BAIoCg0KBQQQAgMEEgT+BAIKCg0KBQQQAgMFEgT+BAsQ +Cg0KBQQQAgMBEgT+BBEjCg0KBQQQAgMDEgT+BCYnCgwKBAQQAgQSBP8EAiMK +DQoFBBACBAQSBP8EAgoKDQoFBBACBAUSBP8ECxEKDQoFBBACBAESBP8EEh4K +DQoFBBACBAMSBP8EISIKDAoEBBACBRIEgAUCIgoNCgUEEAIFBBIEgAUCCgoN +CgUEEAIFBRIEgAULEAoNCgUEEAIFARIEgAURHQoNCgUEEAIFAxIEgAUgIQoM +CgQEEAIGEgSBBQImCg0KBQQQAgYEEgSBBQIKCg0KBQQQAgYFEgSBBQsRCg0K +BQQQAgYBEgSBBRIhCg0KBQQQAgYDEgSBBSQlCtoBCgIEERIGiQUAigYBGmog +RW5jYXBzdWxhdGVzIGluZm9ybWF0aW9uIGFib3V0IHRoZSBvcmlnaW5hbCBz +b3VyY2UgZmlsZSBmcm9tIHdoaWNoIGEKIEZpbGVEZXNjcmlwdG9yUHJvdG8g +d2FzIGdlbmVyYXRlZC4KMmAgPT09PT09PT09PT09PT09PT09PT09PT09PT09 +PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogT3B0 +aW9uYWwgc291cmNlIGNvZGUgaW5mbwoKCwoDBBEBEgSJBQgWCoIRCgQEEQIA +EgS1BQIhGvMQIEEgTG9jYXRpb24gaWRlbnRpZmllcyBhIHBpZWNlIG9mIHNv +dXJjZSBjb2RlIGluIGEgLnByb3RvIGZpbGUgd2hpY2gKIGNvcnJlc3BvbmRz +IHRvIGEgcGFydGljdWxhciBkZWZpbml0aW9uLiAgVGhpcyBpbmZvcm1hdGlv +biBpcyBpbnRlbmRlZAogdG8gYmUgdXNlZnVsIHRvIElERXMsIGNvZGUgaW5k +ZXhlcnMsIGRvY3VtZW50YXRpb24gZ2VuZXJhdG9ycywgYW5kIHNpbWlsYXIK +IHRvb2xzLgoKIEZvciBleGFtcGxlLCBzYXkgd2UgaGF2ZSBhIGZpbGUgbGlr +ZToKICAgbWVzc2FnZSBGb28gewogICAgIG9wdGlvbmFsIHN0cmluZyBmb28g +PSAxOwogICB9CiBMZXQncyBsb29rIGF0IGp1c3QgdGhlIGZpZWxkIGRlZmlu +aXRpb246CiAgIG9wdGlvbmFsIHN0cmluZyBmb28gPSAxOwogICBeICAgICAg +IF5eICAgICBeXiAgXiAgXl5eCiAgIGEgICAgICAgYmMgICAgIGRlICBmICBn +aGkKIFdlIGhhdmUgdGhlIGZvbGxvd2luZyBsb2NhdGlvbnM6CiAgIHNwYW4g +ICBwYXRoICAgICAgICAgICAgICAgcmVwcmVzZW50cwogICBbYSxpKSAgWyA0 +LCAwLCAyLCAwIF0gICAgIFRoZSB3aG9sZSBmaWVsZCBkZWZpbml0aW9uLgog +ICBbYSxiKSAgWyA0LCAwLCAyLCAwLCA0IF0gIFRoZSBsYWJlbCAob3B0aW9u +YWwpLgogICBbYyxkKSAgWyA0LCAwLCAyLCAwLCA1IF0gIFRoZSB0eXBlIChz +dHJpbmcpLgogICBbZSxmKSAgWyA0LCAwLCAyLCAwLCAxIF0gIFRoZSBuYW1l +IChmb28pLgogICBbZyxoKSAgWyA0LCAwLCAyLCAwLCAzIF0gIFRoZSBudW1i +ZXIgKDEpLgoKIE5vdGVzOgogLSBBIGxvY2F0aW9uIG1heSByZWZlciB0byBh +IHJlcGVhdGVkIGZpZWxkIGl0c2VsZiAoaS5lLiBub3QgdG8gYW55CiAgIHBh +cnRpY3VsYXIgaW5kZXggd2l0aGluIGl0KS4gIFRoaXMgaXMgdXNlZCB3aGVu +ZXZlciBhIHNldCBvZiBlbGVtZW50cyBhcmUKICAgbG9naWNhbGx5IGVuY2xv +c2VkIGluIGEgc2luZ2xlIGNvZGUgc2VnbWVudC4gIEZvciBleGFtcGxlLCBh +biBlbnRpcmUKICAgZXh0ZW5kIGJsb2NrIChwb3NzaWJseSBjb250YWluaW5n +IG11bHRpcGxlIGV4dGVuc2lvbiBkZWZpbml0aW9ucykgd2lsbAogICBoYXZl +IGFuIG91dGVyIGxvY2F0aW9uIHdob3NlIHBhdGggcmVmZXJzIHRvIHRoZSAi +ZXh0ZW5zaW9ucyIgcmVwZWF0ZWQKICAgZmllbGQgd2l0aG91dCBhbiBpbmRl +eC4KIC0gTXVsdGlwbGUgbG9jYXRpb25zIG1heSBoYXZlIHRoZSBzYW1lIHBh +dGguICBUaGlzIGhhcHBlbnMgd2hlbiBhIHNpbmdsZQogICBsb2dpY2FsIGRl +Y2xhcmF0aW9uIGlzIHNwcmVhZCBvdXQgYWNyb3NzIG11bHRpcGxlIHBsYWNl +cy4gIFRoZSBtb3N0CiAgIG9idmlvdXMgZXhhbXBsZSBpcyB0aGUgImV4dGVu +ZCIgYmxvY2sgYWdhaW4gLS0gdGhlcmUgbWF5IGJlIG11bHRpcGxlCiAgIGV4 +dGVuZCBibG9ja3MgaW4gdGhlIHNhbWUgc2NvcGUsIGVhY2ggb2Ygd2hpY2gg +d2lsbCBoYXZlIHRoZSBzYW1lIHBhdGguCiAtIEEgbG9jYXRpb24ncyBzcGFu +IGlzIG5vdCBhbHdheXMgYSBzdWJzZXQgb2YgaXRzIHBhcmVudCdzIHNwYW4u +ICBGb3IKICAgZXhhbXBsZSwgdGhlICJleHRlbmRlZSIgb2YgYW4gZXh0ZW5z +aW9uIGRlY2xhcmF0aW9uIGFwcGVhcnMgYXQgdGhlCiAgIGJlZ2lubmluZyBv +ZiB0aGUgImV4dGVuZCIgYmxvY2sgYW5kIGlzIHNoYXJlZCBieSBhbGwgZXh0 +ZW5zaW9ucyB3aXRoaW4KICAgdGhlIGJsb2NrLgogLSBKdXN0IGJlY2F1c2Ug +YSBsb2NhdGlvbidzIHNwYW4gaXMgYSBzdWJzZXQgb2Ygc29tZSBvdGhlciBs +b2NhdGlvbidzIHNwYW4KICAgZG9lcyBub3QgbWVhbiB0aGF0IGl0IGlzIGEg +ZGVzY2VuZGVudC4gIEZvciBleGFtcGxlLCBhICJncm91cCIgZGVmaW5lcwog +ICBib3RoIGEgdHlwZSBhbmQgYSBmaWVsZCBpbiBhIHNpbmdsZSBkZWNsYXJh +dGlvbi4gIFRodXMsIHRoZSBsb2NhdGlvbnMKICAgY29ycmVzcG9uZGluZyB0 +byB0aGUgdHlwZSBhbmQgZmllbGQgYW5kIHRoZWlyIGNvbXBvbmVudHMgd2ls +bCBvdmVybGFwLgogLSBDb2RlIHdoaWNoIHRyaWVzIHRvIGludGVycHJldCBs +b2NhdGlvbnMgc2hvdWxkIHByb2JhYmx5IGJlIGRlc2lnbmVkIHRvCiAgIGln +bm9yZSB0aG9zZSB0aGF0IGl0IGRvZXNuJ3QgdW5kZXJzdGFuZCwgYXMgbW9y +ZSB0eXBlcyBvZiBsb2NhdGlvbnMgY291bGQKICAgYmUgcmVjb3JkZWQgaW4g +dGhlIGZ1dHVyZS4KCg0KBQQRAgAEEgS1BQIKCg0KBQQRAgAGEgS1BQsTCg0K +BQQRAgABEgS1BRQcCg0KBQQRAgADEgS1BR8gCg4KBAQRAwASBrYFAokGAwoN +CgUEEQMAARIEtgUKEgqDBwoGBBEDAAIAEgTOBQQqGvIGIElkZW50aWZpZXMg +d2hpY2ggcGFydCBvZiB0aGUgRmlsZURlc2NyaXB0b3JQcm90byB3YXMgZGVm +aW5lZCBhdCB0aGlzCiBsb2NhdGlvbi4KCiBFYWNoIGVsZW1lbnQgaXMgYSBm +aWVsZCBudW1iZXIgb3IgYW4gaW5kZXguICBUaGV5IGZvcm0gYSBwYXRoIGZy +b20KIHRoZSByb290IEZpbGVEZXNjcmlwdG9yUHJvdG8gdG8gdGhlIHBsYWNl +IHdoZXJlIHRoZSBkZWZpbml0aW9uLiAgRm9yCiBleGFtcGxlLCB0aGlzIHBh +dGg6CiAgIFsgNCwgMywgMiwgNywgMSBdCiByZWZlcnMgdG86CiAgIGZpbGUu +bWVzc2FnZV90eXBlKDMpICAvLyA0LCAzCiAgICAgICAuZmllbGQoNykgICAg +ICAgICAvLyAyLCA3CiAgICAgICAubmFtZSgpICAgICAgICAgICAvLyAxCiBU +aGlzIGlzIGJlY2F1c2UgRmlsZURlc2NyaXB0b3JQcm90by5tZXNzYWdlX3R5 +cGUgaGFzIGZpZWxkIG51bWJlciA0OgogICByZXBlYXRlZCBEZXNjcmlwdG9y +UHJvdG8gbWVzc2FnZV90eXBlID0gNDsKIGFuZCBEZXNjcmlwdG9yUHJvdG8u +ZmllbGQgaGFzIGZpZWxkIG51bWJlciAyOgogICByZXBlYXRlZCBGaWVsZERl +c2NyaXB0b3JQcm90byBmaWVsZCA9IDI7CiBhbmQgRmllbGREZXNjcmlwdG9y +UHJvdG8ubmFtZSBoYXMgZmllbGQgbnVtYmVyIDE6CiAgIG9wdGlvbmFsIHN0 +cmluZyBuYW1lID0gMTsKCiBUaHVzLCB0aGUgYWJvdmUgcGF0aCBnaXZlcyB0 +aGUgbG9jYXRpb24gb2YgYSBmaWVsZCBuYW1lLiAgSWYgd2UgcmVtb3ZlZAog +dGhlIGxhc3QgZWxlbWVudDoKICAgWyA0LCAzLCAyLCA3IF0KIHRoaXMgcGF0 +aCByZWZlcnMgdG8gdGhlIHdob2xlIGZpZWxkIGRlY2xhcmF0aW9uIChmcm9t +IHRoZSBiZWdpbm5pbmcKIG9mIHRoZSBsYWJlbCB0byB0aGUgdGVybWluYXRp +bmcgc2VtaWNvbG9uKS4KCg8KBwQRAwACAAQSBM4FBAwKDwoHBBEDAAIABRIE +zgUNEgoPCgcEEQMAAgABEgTOBRMXCg8KBwQRAwACAAMSBM4FGhsKDwoHBBED +AAIACBIEzgUcKQoQCggEEQMAAgAIAhIEzgUdKArSAgoGBBEDAAIBEgTVBQQq +GsECIEFsd2F5cyBoYXMgZXhhY3RseSB0aHJlZSBvciBmb3VyIGVsZW1lbnRz +OiBzdGFydCBsaW5lLCBzdGFydCBjb2x1bW4sCiBlbmQgbGluZSAob3B0aW9u +YWwsIG90aGVyd2lzZSBhc3N1bWVkIHNhbWUgYXMgc3RhcnQgbGluZSksIGVu +ZCBjb2x1bW4uCiBUaGVzZSBhcmUgcGFja2VkIGludG8gYSBzaW5nbGUgZmll +bGQgZm9yIGVmZmljaWVuY3kuICBOb3RlIHRoYXQgbGluZQogYW5kIGNvbHVt +biBudW1iZXJzIGFyZSB6ZXJvLWJhc2VkIC0tIHR5cGljYWxseSB5b3Ugd2ls +bCB3YW50IHRvIGFkZAogMSB0byBlYWNoIGJlZm9yZSBkaXNwbGF5aW5nIHRv +IGEgdXNlci4KCg8KBwQRAwACAQQSBNUFBAwKDwoHBBEDAAIBBRIE1QUNEgoP +CgcEEQMAAgEBEgTVBRMXCg8KBwQRAwACAQMSBNUFGhsKDwoHBBEDAAIBCBIE +1QUcKQoQCggEEQMAAgEIAhIE1QUdKAqlDAoGBBEDAAICEgSGBgQpGpQMIElm +IHRoaXMgU291cmNlQ29kZUluZm8gcmVwcmVzZW50cyBhIGNvbXBsZXRlIGRl +Y2xhcmF0aW9uLCB0aGVzZSBhcmUgYW55CiBjb21tZW50cyBhcHBlYXJpbmcg +YmVmb3JlIGFuZCBhZnRlciB0aGUgZGVjbGFyYXRpb24gd2hpY2ggYXBwZWFy +IHRvIGJlCiBhdHRhY2hlZCB0byB0aGUgZGVjbGFyYXRpb24uCgogQSBzZXJp +ZXMgb2YgbGluZSBjb21tZW50cyBhcHBlYXJpbmcgb24gY29uc2VjdXRpdmUg +bGluZXMsIHdpdGggbm8gb3RoZXIKIHRva2VucyBhcHBlYXJpbmcgb24gdGhv +c2UgbGluZXMsIHdpbGwgYmUgdHJlYXRlZCBhcyBhIHNpbmdsZSBjb21tZW50 +LgoKIGxlYWRpbmdfZGV0YWNoZWRfY29tbWVudHMgd2lsbCBrZWVwIHBhcmFn +cmFwaHMgb2YgY29tbWVudHMgdGhhdCBhcHBlYXIKIGJlZm9yZSAoYnV0IG5v +dCBjb25uZWN0ZWQgdG8pIHRoZSBjdXJyZW50IGVsZW1lbnQuIEVhY2ggcGFy +YWdyYXBoLAogc2VwYXJhdGVkIGJ5IGVtcHR5IGxpbmVzLCB3aWxsIGJlIG9u +ZSBjb21tZW50IGVsZW1lbnQgaW4gdGhlIHJlcGVhdGVkCiBmaWVsZC4KCiBP +bmx5IHRoZSBjb21tZW50IGNvbnRlbnQgaXMgcHJvdmlkZWQ7IGNvbW1lbnQg +bWFya2VycyAoZS5nLiAvLykgYXJlCiBzdHJpcHBlZCBvdXQuICBGb3IgYmxv +Y2sgY29tbWVudHMsIGxlYWRpbmcgd2hpdGVzcGFjZSBhbmQgYW4gYXN0ZXJp +c2sKIHdpbGwgYmUgc3RyaXBwZWQgZnJvbSB0aGUgYmVnaW5uaW5nIG9mIGVh +Y2ggbGluZSBvdGhlciB0aGFuIHRoZSBmaXJzdC4KIE5ld2xpbmVzIGFyZSBp +bmNsdWRlZCBpbiB0aGUgb3V0cHV0LgoKIEV4YW1wbGVzOgoKICAgb3B0aW9u +YWwgaW50MzIgZm9vID0gMTsgIC8vIENvbW1lbnQgYXR0YWNoZWQgdG8gZm9v +LgogICAvLyBDb21tZW50IGF0dGFjaGVkIHRvIGJhci4KICAgb3B0aW9uYWwg +aW50MzIgYmFyID0gMjsKCiAgIG9wdGlvbmFsIHN0cmluZyBiYXogPSAzOwog +ICAvLyBDb21tZW50IGF0dGFjaGVkIHRvIGJhei4KICAgLy8gQW5vdGhlciBs +aW5lIGF0dGFjaGVkIHRvIGJhei4KCiAgIC8vIENvbW1lbnQgYXR0YWNoZWQg +dG8gcXV4LgogICAvLwogICAvLyBBbm90aGVyIGxpbmUgYXR0YWNoZWQgdG8g +cXV4LgogICBvcHRpb25hbCBkb3VibGUgcXV4ID0gNDsKCiAgIC8vIERldGFj +aGVkIGNvbW1lbnQgZm9yIGNvcmdlLiBUaGlzIGlzIG5vdCBsZWFkaW5nIG9y +IHRyYWlsaW5nIGNvbW1lbnRzCiAgIC8vIHRvIHF1eCBvciBjb3JnZSBiZWNh +dXNlIHRoZXJlIGFyZSBibGFuayBsaW5lcyBzZXBhcmF0aW5nIGl0IGZyb20K +ICAgLy8gYm90aC4KCiAgIC8vIERldGFjaGVkIGNvbW1lbnQgZm9yIGNvcmdl +IHBhcmFncmFwaCAyLgoKICAgb3B0aW9uYWwgc3RyaW5nIGNvcmdlID0gNTsK +ICAgLyogQmxvY2sgY29tbWVudCBhdHRhY2hlZAogICAgKiB0byBjb3JnZS4g +IExlYWRpbmcgYXN0ZXJpc2tzCiAgICAqIHdpbGwgYmUgcmVtb3ZlZC4gKi8K +ICAgLyogQmxvY2sgY29tbWVudCBhdHRhY2hlZCB0bwogICAgKiBncmF1bHQu +ICovCiAgIG9wdGlvbmFsIGludDMyIGdyYXVsdCA9IDY7CgogICAvLyBpZ25v +cmVkIGRldGFjaGVkIGNvbW1lbnRzLgoKDwoHBBEDAAICBBIEhgYEDAoPCgcE +EQMAAgIFEgSGBg0TCg8KBwQRAwACAgESBIYGFCQKDwoHBBEDAAICAxIEhgYn +KAoOCgYEEQMAAgMSBIcGBCoKDwoHBBEDAAIDBBIEhwYEDAoPCgcEEQMAAgMF +EgSHBg0TCg8KBwQRAwACAwESBIcGFCUKDwoHBBEDAAIDAxIEhwYoKQoOCgYE +EQMAAgQSBIgGBDIKDwoHBBEDAAIEBBIEiAYEDAoPCgcEEQMAAgQFEgSIBg0T +Cg8KBwQRAwACBAESBIgGFC0KDwoHBBEDAAIEAxIEiAYwMQ== diff --git a/lib/protobuf/generators/enum_generator.rb b/lib/protobuf/generators/enum_generator.rb index 1088e3ed..cd040b2f 100644 --- a/lib/protobuf/generators/enum_generator.rb +++ b/lib/protobuf/generators/enum_generator.rb @@ -10,6 +10,8 @@ def compile tags = [] print_class(descriptor.name, :enum) do + puts "FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.#{descriptor.name}'" unless @options[:dependency_eval] + puts if descriptor.options print OptionGenerator.new(descriptor.options, current_indent).to_s puts diff --git a/lib/protobuf/generators/field_generator.rb b/lib/protobuf/generators/field_generator.rb index 68652fcc..73510294 100644 --- a/lib/protobuf/generators/field_generator.rb +++ b/lib/protobuf/generators/field_generator.rb @@ -79,7 +79,7 @@ def label end def name - @name ||= descriptor.name.to_sym.inspect + @name ||= descriptor.fully_qualified_name.to_sym.inspect end def number diff --git a/lib/protobuf/generators/file_generator.rb b/lib/protobuf/generators/file_generator.rb index f94d2264..813c2d33 100644 --- a/lib/protobuf/generators/file_generator.rb +++ b/lib/protobuf/generators/file_generator.rb @@ -8,8 +8,9 @@ class FileGenerator < Base attr_reader :output_file - def initialize(*args) - super + def initialize(*args, proto_file_to_descriptor) + super(*args) + @proto_file_to_descriptor = proto_file_to_descriptor @output_file = ::Google::Protobuf::Compiler::CodeGeneratorResponse::File.new(:name => file_name) @extension_fields = Hash.new { |h, k| h[k] = [] } @known_messages = {} @@ -30,6 +31,7 @@ def compile print_import_requires print_package do + add_descriptor inject_optionable group = GroupGenerator.new(current_indent) group.add_options(descriptor.options) if descriptor.options @@ -48,6 +50,7 @@ def compile print group.to_s end + print_descriptor_bytes end end @@ -56,7 +59,7 @@ def unknown_extensions message_klass = modulize(message_name).safe_constantize if message_klass unknown_fields = fields.reject do |field| - @known_messages[message_name] && message_klass.get_field(field.name, true) + @known_messages[message_name] && message_klass.get_field(field.fully_qualified_name, true) end [message_name, unknown_fields] else @@ -91,7 +94,7 @@ def map_extensions(descriptor, namespaces) descriptor.extension.each do |field_descriptor| unless fully_qualified_token?(field_descriptor.name) && fully_qualified_namespace - field_descriptor.name = "#{fully_qualified_namespace}.#{field_descriptor.name}" + field_descriptor.fully_qualified_name = "#{fully_qualified_namespace}.#{field_descriptor.name}" end @extension_fields[field_descriptor.extendee] << field_descriptor end @@ -106,14 +109,19 @@ def map_extensions(descriptor, namespaces) end def print_file_comment - puts "# encoding: utf-8" - puts - puts "##" - puts "# This file is auto-generated. DO NOT EDIT!" - puts "#" + puts <<~END_OF_FILE_COMMENT + # encoding: utf-8 + # frozen_string_literal: true + + ## + # This file is auto-generated. DO NOT EDIT! + # + END_OF_FILE_COMMENT end def print_generic_requires + print_require("base64") + print_require("set") print_require("protobuf") print_require("protobuf/rpc/service") if descriptor.service.count > 0 puts @@ -233,7 +241,7 @@ def eval_message_code(fully_qualified_namespace, fields = []) def eval_enum_code(enum, fully_qualified_namespace) group = GroupGenerator.new(0) - group.add_enums([enum], :namespace => [fully_qualified_namespace]) + group.add_enums([enum], :namespace => [fully_qualified_namespace], :dependency_eval => true) print group.to_s eval_code(modulize(fully_qualified_namespace).safe_constantize || Object) end @@ -253,10 +261,50 @@ def create_ruby_namespace_heiarchy(namespace) end end + def add_descriptor + dependencies = descriptor.dependency.map do |proto_file| + modulize(@proto_file_to_descriptor[proto_file].package) + end.uniq.join(', ') + + puts <<~END_OF_DESCRIPTOR + FULLY_QUALIFIED_NAME = '#{descriptor.package}' unless defined?(self::FULLY_QUALIFIED_NAME) + + @descriptors = [] unless instance_variable_defined?(:@descriptors) + @descriptors << lambda do + bytes = File.read(__FILE__, mode: 'rb').split(/^__END__$/, 2).last + ::Google::Protobuf::FileDescriptorProto.decode(Base64.decode64(bytes)) + end + + @descriptor_dependencies = Set.new unless instance_variable_defined?(:@descriptor_dependencies) + @descriptor_dependencies |= [#{dependencies}] + + unless respond_to?(:descriptor_set) + def self.descriptor_set + ::Google::Protobuf::FileDescriptorSet.new(:file => @descriptors.map(&:call)) + end + end + + unless respond_to?(:descriptor_dependencies) + def self.descriptor_dependencies + @descriptor_dependencies + end + end + END_OF_DESCRIPTOR + end + def inject_optionable return if descriptor.package.empty? && !ENV.key?('PB_ALLOW_DEFAULT_PACKAGE_NAME') puts "::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions }" end + + def print_descriptor_bytes + puts <<~BYTES + + # Raw descriptor bytes below + __END__ + #{Base64.encode64(descriptor.encode)} + BYTES + end end end end diff --git a/lib/protobuf/generators/group_generator.rb b/lib/protobuf/generators/group_generator.rb index 33e7b5be..79eca3ce 100644 --- a/lib/protobuf/generators/group_generator.rb +++ b/lib/protobuf/generators/group_generator.rb @@ -13,12 +13,13 @@ class GroupGenerator attr_reader :groups, :indent_level attr_writer :order - def initialize(indent_level = 0) + def initialize(indent_level = 0, name = nil) @groups = Hash.new { |h, k| h[k] = [] } @headers = {} @comments = {} @handlers = {} @indent_level = indent_level + @name = name @order = [:enum, :message_declaration, :options, :message, :extended_message, :service] init_printer(indent_level) end @@ -88,6 +89,8 @@ def add_services(service_descriptors) end def compile + puts "FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.#{@name}'" if @name + @order.each do |type| items = @groups[type] next if items.empty? diff --git a/lib/protobuf/generators/message_generator.rb b/lib/protobuf/generators/message_generator.rb index bbaf84d5..de7771bf 100644 --- a/lib/protobuf/generators/message_generator.rb +++ b/lib/protobuf/generators/message_generator.rb @@ -40,7 +40,7 @@ def compile_message run_once(:compile_message) do if printable? print_class(descriptor.name, nil) do - group = GroupGenerator.new(current_indent) + group = GroupGenerator.new(current_indent, descriptor.name) group.add_messages(descriptor.nested_type, :extension_fields => @extension_fields, :namespace => type_namespace) group.add_comment(:options, 'Message Options') group.add_options(descriptor.options) if options? diff --git a/lib/protobuf/generators/printable.rb b/lib/protobuf/generators/printable.rb index 3d8fe770..9c6fd174 100644 --- a/lib/protobuf/generators/printable.rb +++ b/lib/protobuf/generators/printable.rb @@ -136,7 +136,14 @@ def print_require(file, relative = false) # def puts(message = nil) if message - @io.puts((" " * current_indent) + message) + message.split("\n").each do |line| + if line.empty? + @io.puts + next + end + + @io.puts((" " * current_indent) + line) + end else @io.puts end diff --git a/lib/protobuf/generators/service_generator.rb b/lib/protobuf/generators/service_generator.rb index f7e9febd..93559c58 100644 --- a/lib/protobuf/generators/service_generator.rb +++ b/lib/protobuf/generators/service_generator.rb @@ -8,6 +8,8 @@ class ServiceGenerator < Base def compile run_once(:compile) do print_class(descriptor.name, :service) do + puts "FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.#{descriptor.name}'" + puts print OptionGenerator.new(descriptor.options, current_indent).to_s if descriptor.options descriptor.method.each do |method_descriptor| print_method(method_descriptor) diff --git a/lib/protobuf/rpc/dynamic_discovery.pb.rb b/lib/protobuf/rpc/dynamic_discovery.pb.rb index b8dd5869..9f9263a5 100644 --- a/lib/protobuf/rpc/dynamic_discovery.pb.rb +++ b/lib/protobuf/rpc/dynamic_discovery.pb.rb @@ -1,19 +1,46 @@ # encoding: utf-8 +# frozen_string_literal: true ## # This file is auto-generated. DO NOT EDIT! # +require 'base64' +require 'set' require 'protobuf' module Protobuf module Rpc module DynamicDiscovery + FULLY_QUALIFIED_NAME = 'protobuf.rpc.dynamicDiscovery' unless defined?(self::FULLY_QUALIFIED_NAME) + + @descriptors = [] unless instance_variable_defined?(:@descriptors) + @descriptors << lambda do + bytes = File.read(__FILE__, mode: 'rb').split(/^__END__$/, 2).last + ::Google::Protobuf::FileDescriptorProto.decode(Base64.decode64(bytes)) + end + + @descriptor_dependencies = Set.new unless instance_variable_defined?(:@descriptor_dependencies) + @descriptor_dependencies |= [] + + unless respond_to?(:descriptor_set) + def self.descriptor_set + ::Google::Protobuf::FileDescriptorSet.new(:file => @descriptors.map(&:call)) + end + end + + unless respond_to?(:descriptor_dependencies) + def self.descriptor_dependencies + @descriptor_dependencies + end + end ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions } ## # Enum Classes # class BeaconType < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.BeaconType' + define :HEARTBEAT, 0 define :FLATLINE, 1 end @@ -30,6 +57,7 @@ class Beacon < ::Protobuf::Message; end # Message Fields # class Server + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Server' optional :string, :uuid, 1 optional :string, :address, 2 optional :string, :port, 3 @@ -38,6 +66,7 @@ class Server end class Beacon + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Beacon' optional ::Protobuf::Rpc::DynamicDiscovery::BeaconType, :beacon_type, 1 optional ::Protobuf::Rpc::DynamicDiscovery::Server, :server, 2 end @@ -48,3 +77,55 @@ class Beacon end + +# Raw descriptor bytes below +__END__ +ChdkeW5hbWljX2Rpc2NvdmVyeS5wcm90bxIdcHJvdG9idWYucnBjLmR5bmFt +aWNEaXNjb3ZlcnkieAoGU2VydmVyEhIKBHV1aWQYASABKAlSBHV1aWQSGAoH +YWRkcmVzcxgCIAEoCVIHYWRkcmVzcxISCgRwb3J0GAMgASgJUgRwb3J0EhAK +A3R0bBgEIAEoBVIDdHRsEhoKCHNlcnZpY2VzGAUgAygJUghzZXJ2aWNlcyKT +AQoGQmVhY29uEkoKC2JlYWNvbl90eXBlGAEgASgOMikucHJvdG9idWYucnBj +LmR5bmFtaWNEaXNjb3ZlcnkuQmVhY29uVHlwZVIKYmVhY29uVHlwZRI9CgZz +ZXJ2ZXIYAiABKAsyJS5wcm90b2J1Zi5ycGMuZHluYW1pY0Rpc2NvdmVyeS5T +ZXJ2ZXJSBnNlcnZlciopCgpCZWFjb25UeXBlEg0KCUhFQVJUQkVBVBAAEgwK +CEZMQVRMSU5FEAFKpw4KBhIEGAAqAQqfCQoBAhIDGAAmMrYIIENvcHlyaWdo +dCAoYykgMjAxMyBNb25leURlc2t0b3AsIEluYy4KCiBQZXJtaXNzaW9uIGlz +IGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNv +biBvYnRhaW5pbmcgYSBjb3B5CiBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3Nv +Y2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSAiU29mdHdhcmUiKSwg +dG8gZGVhbAogaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24s +IGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24gdGhlIHJpZ2h0cwogdG8g +dXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRl +LCBzdWJsaWNlbnNlLCBhbmQvb3Igc2VsbAogY29waWVzIG9mIHRoZSBTb2Z0 +d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3 +YXJlIGlzCiBmdXJuaXNoZWQgdG8gZG8gc28sIHN1YmplY3QgdG8gdGhlIGZv +bGxvd2luZyBjb25kaXRpb25zOgoKIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90 +aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1 +ZGVkIGluCiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9m +IHRoZSBTb2Z0d2FyZS4KCiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFT +IElTIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBP +UgogSU1QTElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUg +V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFksCiBGSVRORVNTIEZPUiBB +IFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OSU5GUklOR0VNRU5ULiBJTiBO +TyBFVkVOVCBTSEFMTCBUSEUKIEFVVEhPUlMgT1IgQ09QWVJJR0hUIEhPTERF +UlMgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1IgT1RIRVIK +IExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1Qs +IFRPUlQgT1IgT1RIRVJXSVNFLCBBUklTSU5HIEZST00sCiBPVVQgT0YgT1Ig +SU4gQ09OTkVDVElPTiBXSVRIIFRIRSBTT0ZUV0FSRSBPUiBUSEUgVVNFIE9S +IE9USEVSIERFQUxJTkdTIElOCiBUSEUgU09GVFdBUkUuCjJcIEF1dGhvcnM6 +IERldmluIENocmlzdGVuc2VuCgogUHJvdG9idWZzIG5lZWRlZCBmb3IgZHlu +YW1pYyBkaXNjb3Zlcnkgem1xIHNlcnZlciBhbmQgY2xpZW50LgoKCgoCBQAS +BBoAHQEKCgoDBQABEgMaBQ8KCwoEBQACABIDGwIQCgwKBQUAAgABEgMbAgsK +DAoFBQACAAISAxsODwoLCgQFAAIBEgMcAg8KDAoFBQACAQESAxwCCgoMCgUF +AAIBAhIDHA0OCgoKAgQAEgQfACUBCgoKAwQAARIDHwgOCgsKBAQAAgASAyAC +GwoMCgUEAAIABBIDIAIKCgwKBQQAAgAFEgMgCxEKDAoFBAACAAESAyASFgoM +CgUEAAIAAxIDIBkaCgsKBAQAAgESAyECHgoMCgUEAAIBBBIDIQIKCgwKBQQA +AgEFEgMhCxEKDAoFBAACAQESAyESGQoMCgUEAAIBAxIDIRwdCgsKBAQAAgIS +AyICGwoMCgUEAAICBBIDIgIKCgwKBQQAAgIFEgMiCxEKDAoFBAACAgESAyIS +FgoMCgUEAAICAxIDIhkaCgsKBAQAAgMSAyMCGQoMCgUEAAIDBBIDIwIKCgwK +BQQAAgMFEgMjCxAKDAoFBAACAwESAyMRFAoMCgUEAAIDAxIDIxcYCgsKBAQA +AgQSAyQCHwoMCgUEAAIEBBIDJAIKCgwKBQQAAgQFEgMkCxEKDAoFBAACBAES +AyQSGgoMCgUEAAIEAxIDJB0eCgoKAgQBEgQnACoBCgoKAwQBARIDJwgOCgsK +BAQBAgASAygCJgoMCgUEAQIABBIDKAIKCgwKBQQBAgAGEgMoCxUKDAoFBAEC +AAESAygWIQoMCgUEAQIAAxIDKCQlCgsKBAQBAgESAykCHQoMCgUEAQIBBBID +KQIKCgwKBQQBAgEGEgMpCxEKDAoFBAECAQESAykSGAoMCgUEAQIBAxIDKRsc diff --git a/lib/protobuf/rpc/rpc.pb.rb b/lib/protobuf/rpc/rpc.pb.rb index 0d2937a7..972a3b1a 100644 --- a/lib/protobuf/rpc/rpc.pb.rb +++ b/lib/protobuf/rpc/rpc.pb.rb @@ -1,18 +1,45 @@ # encoding: utf-8 +# frozen_string_literal: true ## # This file is auto-generated. DO NOT EDIT! # +require 'base64' +require 'set' require 'protobuf' module Protobuf module Socketrpc + FULLY_QUALIFIED_NAME = 'protobuf.socketrpc' unless defined?(self::FULLY_QUALIFIED_NAME) + + @descriptors = [] unless instance_variable_defined?(:@descriptors) + @descriptors << lambda do + bytes = File.read(__FILE__, mode: 'rb').split(/^__END__$/, 2).last + ::Google::Protobuf::FileDescriptorProto.decode(Base64.decode64(bytes)) + end + + @descriptor_dependencies = Set.new unless instance_variable_defined?(:@descriptor_dependencies) + @descriptor_dependencies |= [] + + unless respond_to?(:descriptor_set) + def self.descriptor_set + ::Google::Protobuf::FileDescriptorSet.new(:file => @descriptors.map(&:call)) + end + end + + unless respond_to?(:descriptor_dependencies) + def self.descriptor_dependencies + @descriptor_dependencies + end + end ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions } ## # Enum Classes # class ErrorReason < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ErrorReason' + define :BAD_REQUEST_DATA, 0 define :BAD_REQUEST_PROTO, 1 define :SERVICE_NOT_FOUND, 2 @@ -38,6 +65,7 @@ class Header < ::Protobuf::Message; end # Message Fields # class Request + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Request' required :string, :service_name, 1 required :string, :method_name, 2 optional :bytes, :request_proto, 3 @@ -46,6 +74,7 @@ class Request end class Response + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Response' optional :bytes, :response_proto, 1 optional :string, :error, 2 optional :bool, :callback, 3, :default => false @@ -54,6 +83,7 @@ class Response end class Header + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Header' required :string, :key, 1 optional :string, :value, 2 end @@ -62,3 +92,99 @@ class Header end + +# Raw descriptor bytes below +__END__ +CglycGMucHJvdG8SEnByb3RvYnVmLnNvY2tldHJwYyLAAQoHUmVxdWVzdBIh +CgxzZXJ2aWNlX25hbWUYASACKAlSC3NlcnZpY2VOYW1lEh8KC21ldGhvZF9u +YW1lGAIgAigJUgptZXRob2ROYW1lEiMKDXJlcXVlc3RfcHJvdG8YAyABKAxS +DHJlcXVlc3RQcm90bxIWCgZjYWxsZXIYBCABKAlSBmNhbGxlchI0CgdoZWFk +ZXJzGAUgAygLMhoucHJvdG9idWYuc29ja2V0cnBjLkhlYWRlclIHaGVhZGVy +cyLGAQoIUmVzcG9uc2USJQoOcmVzcG9uc2VfcHJvdG8YASABKAxSDXJlc3Bv +bnNlUHJvdG8SFAoFZXJyb3IYAiABKAlSBWVycm9yEiEKCGNhbGxiYWNrGAMg +ASgIOgVmYWxzZVIIY2FsbGJhY2sSQgoMZXJyb3JfcmVhc29uGAQgASgOMh8u +cHJvdG9idWYuc29ja2V0cnBjLkVycm9yUmVhc29uUgtlcnJvclJlYXNvbhIW +CgZzZXJ2ZXIYBSABKAlSBnNlcnZlciIwCgZIZWFkZXISEAoDa2V5GAEgAigJ +UgNrZXkSFAoFdmFsdWUYAiABKAlSBXZhbHVlKtkBCgtFcnJvclJlYXNvbhIU +ChBCQURfUkVRVUVTVF9EQVRBEAASFQoRQkFEX1JFUVVFU1RfUFJPVE8QARIV +ChFTRVJWSUNFX05PVF9GT1VORBACEhQKEE1FVEhPRF9OT1RfRk9VTkQQAxIN +CglSUENfRVJST1IQBBIOCgpSUENfRkFJTEVEEAUSGQoVSU5WQUxJRF9SRVFV +RVNUX1BST1RPEAYSFgoSQkFEX1JFU1BPTlNFX1BST1RPEAcSEAoMVU5LTk9X +Tl9IT1NUEAgSDAoISU9fRVJST1IQCUqdGwoGEgQYAEQBCoIJCgECEgMYABsy +rwggQ29weXJpZ2h0IChjKSAyMDA5IFNoYXJkdWwgRGVvCgogUGVybWlzc2lv +biBpcyBoZXJlYnkgZ3JhbnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBw +ZXJzb24gb2J0YWluaW5nIGEgY29weQogb2YgdGhpcyBzb2Z0d2FyZSBhbmQg +YXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgIlNvZnR3YXJl +IiksIHRvIGRlYWwKIGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0IHJlc3RyaWN0 +aW9uLCBpbmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uIHRoZSByaWdodHMK +IHRvIHVzZSwgY29weSwgbW9kaWZ5LCBtZXJnZSwgcHVibGlzaCwgZGlzdHJp +YnV0ZSwgc3VibGljZW5zZSwgYW5kL29yIHNlbGwKIGNvcGllcyBvZiB0aGUg +U29mdHdhcmUsIGFuZCB0byBwZXJtaXQgcGVyc29ucyB0byB3aG9tIHRoZSBT +b2Z0d2FyZSBpcwogZnVybmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRvIHRo +ZSBmb2xsb3dpbmcgY29uZGl0aW9uczoKCiBUaGUgYWJvdmUgY29weXJpZ2h0 +IG5vdGljZSBhbmQgdGhpcyBwZXJtaXNzaW9uIG5vdGljZSBzaGFsbCBiZSBp +bmNsdWRlZCBpbgogYWxsIGNvcGllcyBvciBzdWJzdGFudGlhbCBwb3J0aW9u +cyBvZiB0aGUgU29mdHdhcmUuCgogVEhFIFNPRlRXQVJFIElTIFBST1ZJREVE +ICJBUyBJUyIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJF +U1MgT1IKIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8g +VEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZLAogRklUTkVTUyBG +T1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4g +SU4gTk8gRVZFTlQgU0hBTEwgVEhFCiBBVVRIT1JTIE9SIENPUFlSSUdIVCBI +T0xERVJTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9U +SEVSCiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRS +QUNULCBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lORyBGUk9NLAogT1VUIE9G +IE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVT +RSBPUiBPVEhFUiBERUFMSU5HUyBJTgogVEhFIFNPRlRXQVJFLgoyRiBBdXRo +b3JzOiBTaGFyZHVsIERlbywgQkogTmVpbHNlbgoKIFByb3RvYnVmcyBuZWVk +ZWQgZm9yIHNvY2tldCBycGNzLgoKCgoCBAASBBoAIQEKCgoDBAABEgMaCA8K +MgoEBAACABIDHAIjIiUgRnVsbHktIHF1YWxpZmllZCBTZXJ2aWNlIGNsYXNz +IG5hbWUKCgwKBQQAAgAEEgMcAgoKDAoFBAACAAUSAxwLEQoMCgUEAAIAARID +HBIeCgwKBQQAAgADEgMcISIKJwoEBAACARIDHQIiIhogU2VydmljZSBtZXRo +b2QgdG8gaW52b2tlCgoMCgUEAAIBBBIDHQIKCgwKBQQAAgEFEgMdCxEKDAoF +BAACAQESAx0SHQoMCgUEAAIBAxIDHSAhCicKBAQAAgISAx4CIyIaIFNlcmlh +bGl6ZWQgcmVxdWVzdCBieXRlcwoKDAoFBAACAgQSAx4CCgoMCgUEAAICBRID +HgsQCgwKBQQAAgIBEgMeER4KDAoFBAACAgMSAx4hIgoqCgQEAAIDEgMfAh0i +HSBDYWxsaW5nIGhvc3RuYW1lIG9yIGFkZHJlc3MKCgwKBQQAAgMEEgMfAgoK +DAoFBAACAwUSAx8LEQoMCgUEAAIDARIDHxIYCgwKBQQAAgMDEgMfGxwKLgoE +BAACBBIDIAIeIiEgR2VuZXJhbCBwdXJwb3NlIHJlcXVlc3QgaGVhZGVycwoK +DAoFBAACBAQSAyACCgoMCgUEAAIEBhIDIAsRCgwKBQQAAgQBEgMgEhkKDAoF +BAACBAMSAyAcHQoKCgIEARIEIwAqAQoKCgMEAQESAyMIEAoiCgQEAQIAEgMl +AiQiFSBTZXJpYWxpemVkIHJlc3BvbnNlCgoMCgUEAQIABBIDJQIKCgwKBQQB +AgAFEgMlCxAKDAoFBAECAAESAyURHwoMCgUEAQIAAxIDJSIjCiQKBAQBAgES +AyYCHCIXIEVycm9yIG1lc3NhZ2UsIGlmIGFueQoKDAoFBAECAQQSAyYCCgoM +CgUEAQIBBRIDJgsRCgwKBQQBAgEBEgMmEhcKDAoFBAECAQMSAyYaGwo/CgQE +AQICEgMnAi8iMiBXYXMgY2FsbGJhY2sgaW52b2tlZCAobm90IHN1cmUgd2hh +dCB0aGlzIGlzIGZvcikKCgwKBQQBAgIEEgMnAgoKDAoFBAECAgUSAycLDwoM +CgUEAQICARIDJxAYCgwKBQQBAgIDEgMnGxwKDAoFBAECAggSAycdLgoMCgUE +AQICBxIDJygtChsKBAQBAgMSAygCKCIOIEVycm9yIFJlYXNvbgoKDAoFBAEC +AwQSAygCCgoMCgUEAQIDBhIDKAsWCgwKBQQBAgMBEgMoFyMKDAoFBAECAwMS +AygmJwopCgQEAQIEEgMpAh0iHCBTZXJ2ZXIgaG9zdG5hbWUgb3IgYWRkcmVz +cwoKDAoFBAECBAQSAykCCgoMCgUEAQIEBRIDKQsRCgwKBQQBAgQBEgMpEhgK +DAoFBAECBAMSAykbHAoKCgIEAhIELAAvAQoKCgMEAgESAywIDgoLCgQEAgIA +EgMtAhoKDAoFBAICAAQSAy0CCgoMCgUEAgIABRIDLQsRCgwKBQQCAgABEgMt +EhUKDAoFBAICAAMSAy0YGQoLCgQEAgIBEgMuAhwKDAoFBAICAQQSAy4CCgoM +CgUEAgIBBRIDLgsRCgwKBQQCAgEBEgMuEhcKDAoFBAICAQMSAy4aGwraAQoC +BQASBDUARAEazQEgUG9zc2libGUgZXJyb3IgcmVhc29ucwogVGhlIHNlcnZl +ci1zaWRlIGVycm9ycyBhcmUgcmV0dXJuZWQgaW4gdGhlIHJlc3BvbnNlIGZy +b20gdGhlIHNlcnZlci4KIFRoZSBjbGllbnQtc2lkZSBlcnJvcnMgYXJlIHJl +dHVybmVkIGJ5IHRoZSBjbGllbnQtc2lkZSBjb2RlIHdoZW4gaXQgZG9lc24n +dAogaGF2ZSBhIHJlc3BvbnNlIGZyb20gdGhlIHNlcnZlci4KCgoKAwUAARID +NQUQCkUKBAUAAgASAzgCFxoUIFNlcnZlci1zaWRlIGVycm9ycwoiIiBTZXJ2 +ZXIgcmVjZWl2ZWQgYmFkIHJlcXVlc3QgZGF0YQoKDAoFBQACAAESAzgCEgoM +CgUFAAIAAhIDOBUWCjAKBAUAAgESAzkCGCIjIFNlcnZlciByZWNlaXZlZCBi +YWQgcmVxdWVzdCBwcm90bwoKDAoFBQACAQESAzkCEwoMCgUFAAIBAhIDORYX +CioKBAUAAgISAzoCGCIdIFNlcnZpY2Ugbm90IGZvdW5kIG9uIHNlcnZlcgoK +DAoFBQACAgESAzoCEwoMCgUFAAICAhIDOhYXCikKBAUAAgMSAzsCFyIcIE1l +dGhvZCBub3QgZm91bmQgb24gc2VydmVyCgoMCgUFAAIDARIDOwISCgwKBQUA +AgMCEgM7FRYKLAoEBQACBBIDPAIQIh8gUnBjIHRocmV3IGV4Y2VwdGlvbiBv +biBzZXJ2ZXIKCgwKBQUAAgQBEgM8AgsKDAoFBQACBAISAzwODwojCgQFAAIF +EgM9AhEiFiBScGMgZmFpbGVkIG9uIHNlcnZlcgoKDAoFBQACBQESAz0CDAoM +CgUFAAIFAhIDPQ8QCnsKBAUAAgYSA0ACHBpBIENsaWVudC1zaWRlIGVycm9y +cyAodGhlc2UgYXJlIHJldHVybmVkIGJ5IHRoZSBjbGllbnQtc2lkZSBjb2Rl +KQoiKyBScGMgd2FzIGNhbGxlZCB3aXRoIGludmFsaWQgcmVxdWVzdCBwcm90 +bwoKDAoFBQACBgESA0ACFwoMCgUFAAIGAhIDQBobCjMKBAUAAgcSA0ECGSIm +IFNlcnZlciByZXR1cm5lZCBhIGJhZCByZXNwb25zZSBwcm90bwoKDAoFBQAC +BwESA0ECFAoMCgUFAAIHAhIDQRcYCisKBAUAAggSA0ICEyIeIENvdWxkIG5v +dCBmaW5kIHN1cHBsaWVkIGhvc3QKCgwKBQUAAggBEgNCAg4KDAoFBQACCAIS +A0IREgo4CgQFAAIJEgNDAg8iKyBJL08gZXJyb3Igd2hpbGUgY29tbXVuaWNh +dGluZyB3aXRoIHNlcnZlcgoKDAoFBQACCQESA0MCCgoMCgUFAAIJAhIDQw0O diff --git a/spec/functional/code_generator_spec.rb b/spec/functional/code_generator_spec.rb index aac45319..f0f1d6be 100644 --- a/spec/functional/code_generator_spec.rb +++ b/spec/functional/code_generator_spec.rb @@ -4,55 +4,46 @@ require 'protobuf/code_generator' RSpec.describe 'code generation' do - it "generates code for google's unittest.proto" do - bytes = IO.read(PROTOS_PATH.join('google_unittest.bin'), :mode => 'rb') - - expected_files = - ["google_unittest_import_public.pb.rb", "google_unittest_import.pb.rb", "google_unittest.pb.rb"] - - expected_file_descriptors = expected_files.map do |file_name| - file_content = File.open(PROTOS_PATH.join(file_name), "r:UTF-8", &:read) - ::Google::Protobuf::Compiler::CodeGeneratorResponse::File.new( - :name => "protos/" + file_name, :content => file_content) - end - - expected_output = - ::Google::Protobuf::Compiler::CodeGeneratorResponse.encode(:file => expected_file_descriptors) - - code_generator = ::Protobuf::CodeGenerator.new(bytes) - code_generator.eval_unknown_extensions! - expect(code_generator.response_bytes).to eq(expected_output) + before(:all) do + require PROTOS_PATH.join('google_unittest.pb') unless defined?(::Protobuf_unittest::ForeignEnum) + require PROTOS_PATH.join('map-test.pb') unless defined?(::Foo::Bar) + require PROTOS_PATH.join('google_unittest_custom_options.pb') unless defined?(::Protobuf_unittest::MethodOpt1) end - it "generates code for map types" do - input_descriptor = ::Google::Protobuf::FileDescriptorSet.decode( - IO.read(PROTOS_PATH.join('map-test.bin'), :mode => 'rb')) - request = ::Google::Protobuf::Compiler::CodeGeneratorRequest.new(:file_to_generate => ['map-test.proto'], - :proto_file => input_descriptor.file) - - file_name = "map-test.pb.rb" - file_content = File.open(PROTOS_PATH.join(file_name), "r:UTF-8", &:read) - expected_file_output = - ::Google::Protobuf::Compiler::CodeGeneratorResponse::File.new( - :name => file_name, :content => file_content) - - expected_response = - ::Google::Protobuf::Compiler::CodeGeneratorResponse.encode(:file => [expected_file_output]) - - code_generator = ::Protobuf::CodeGenerator.new(request.encode) - code_generator.eval_unknown_extensions! - expect(code_generator.response_bytes).to eq(expected_response) + it "generates code for google's unittest.proto" do + attrs = { + optional_int32: 1, + repeated_string: %w[boom], + optional_nested_message: { bb: 10 }, + optional_nested_enum: ::Protobuf_unittest::TestAllTypes::NestedEnum::BAZ, + optional_foreign_message: { c: 12 }, + repeated_import_message: [{ d: 13 }], + } + bytes = ::Protobuf_unittest::TestAllTypes.new(attrs).encode + message = ::Protobuf_unittest::TestAllTypes.decode(bytes) + expect(message.to_hash).to eq(attrs) + expect(message.default_int32).to eq(41) + expect(::Protobuf_unittest::TestAllTypes::FULLY_QUALIFIED_NAME).to eq('protobuf_unittest.TestAllTypes') + descriptor_file = ::Protobuf_unittest.descriptor_set.file.first + expect(descriptor_file.name).to eq('protos/google_unittest.proto') + expect(descriptor_file.package).to eq('protobuf_unittest') end - it "generates code (including service stubs) with custom field and method options" do - expected_unittest_custom_options = - File.open(PROTOS_PATH.join('google_unittest_custom_options.pb.rb'), "r:UTF-8", &:read) + it "generates code for google's unittest.proto extensions" do + attrs = { optional_import_message_extension: { d: 14 } } + bytes = ::Protobuf_unittest::TestAllExtensions.new(attrs).encode + message = ::Protobuf_unittest::TestAllExtensions.decode(bytes) + expect(message.to_hash).to eq(attrs) + expect(message.default_int64_extension).to eq(42) + ::Protobuf_unittest::TestService.send(:set_option, '.protobuf_unittest.service_opt1', 10) + expect(::Protobuf_unittest::TestService.get_option!('.protobuf_unittest.service_opt1')).to eq(10) + rpc = ::Protobuf_unittest::TestService.rpcs[:foo] + rpc.send(:set_option, '.protobuf_unittest.method_opt1', :METHODOPT1_VAL2) + expect(rpc.get_option!('.protobuf_unittest.method_opt1')).to eq(:METHODOPT1_VAL2) + end - bytes = IO.read(PROTOS_PATH.join('google_unittest_custom_options.bin'), :mode => 'rb') - code_generator = ::Protobuf::CodeGenerator.new(bytes) - code_generator.eval_unknown_extensions! - response = ::Google::Protobuf::Compiler::CodeGeneratorResponse.decode(code_generator.response_bytes) - expect(response.file.find { |f| f.name == 'protos/google_unittest_custom_options.pb.rb' }.content) - .to eq(expected_unittest_custom_options) + it "generates code for map types" do + bar = ::Foo::Bar.new(int32_to_baz: { 4 => { looks_like_map: { 'goat' => 'sheep' } } }) + expect(bar.int32_to_baz[4].looks_like_map).to eq('goat' => 'sheep') end end diff --git a/spec/lib/protobuf/code_generator_spec.rb b/spec/lib/protobuf/code_generator_spec.rb index 230029c0..05e2d735 100644 --- a/spec/lib/protobuf/code_generator_spec.rb +++ b/spec/lib/protobuf/code_generator_spec.rb @@ -27,8 +27,12 @@ end before do - expect(::Protobuf::Generators::FileGenerator).to receive(:new).with(input_file1).and_return(file_generator1) - expect(::Protobuf::Generators::FileGenerator).to receive(:new).with(input_file2).and_return(file_generator2) + expect(::Protobuf::Generators::FileGenerator).to receive(:new) + .with(input_file1, 'test/bar.proto' => input_file2, 'test/foo.proto' => input_file1) + .and_return(file_generator1) + expect(::Protobuf::Generators::FileGenerator).to receive(:new) + .with(input_file2, 'test/bar.proto' => input_file2, 'test/foo.proto' => input_file1) + .and_return(file_generator2) end it 'returns the serialized CodeGeneratorResponse which contains the generated file contents' do diff --git a/spec/lib/protobuf/generators/enum_generator_spec.rb b/spec/lib/protobuf/generators/enum_generator_spec.rb index 1c263188..4f49df19 100644 --- a/spec/lib/protobuf/generators/enum_generator_spec.rb +++ b/spec/lib/protobuf/generators/enum_generator_spec.rb @@ -28,6 +28,8 @@ let(:compiled) do <<-RUBY class TestEnum < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestEnum' + define :FOO, 1 define :BAR, 2 define :BAZ, 3 @@ -45,6 +47,8 @@ class TestEnum < ::Protobuf::Enum let(:compiled) do <<-RUBY class TestEnum < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestEnum' + set_option :allow_alias, true define :FOO, 1 diff --git a/spec/lib/protobuf/generators/file_generator_spec.rb b/spec/lib/protobuf/generators/file_generator_spec.rb index 51a6156f..3d383596 100644 --- a/spec/lib/protobuf/generators/file_generator_spec.rb +++ b/spec/lib/protobuf/generators/file_generator_spec.rb @@ -8,7 +8,7 @@ let(:descriptor_fields) { base_descriptor_fields } let(:file_descriptor) { ::Google::Protobuf::FileDescriptorProto.new(descriptor_fields) } - subject { described_class.new(file_descriptor) } + subject { described_class.new(file_descriptor, {}) } specify { expect(subject.file_name).to eq('test/foo.pb.rb') } describe '#print_import_requires' do @@ -39,14 +39,43 @@ describe '#compile' do it 'generates the file contents' do subject.compile - expect(subject.to_s).to eq < @descriptors.map(&:call)) + end +end + +unless respond_to?(:descriptor_dependencies) + def self.descriptor_dependencies + @descriptor_dependencies + end +end + +# Raw descriptor bytes below +__END__ +#{Base64.encode64(file_descriptor.encode)} EOF end @@ -54,18 +83,47 @@ allow(ENV).to receive(:key?).with('PB_ALLOW_DEFAULT_PACKAGE_NAME') .and_return(true) subject.compile - expect(subject.to_s).to eq < @descriptors.map(&:call)) + end + end + + unless respond_to?(:descriptor_dependencies) + def self.descriptor_dependencies + @descriptor_dependencies + end + end ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions } end + +# Raw descriptor bytes below +__END__ +#{Base64.encode64(file_descriptor.encode)} EOF end @@ -85,17 +143,42 @@ module Foo it 'generates the file contents that include the namespaced extension name' do subject.compile - expect(subject.to_s).to eq < @descriptors.map(&:call)) + end + end + + unless respond_to?(:descriptor_dependencies) + def self.descriptor_dependencies + @descriptor_dependencies + end + end ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions } ## @@ -111,6 +194,10 @@ class ::Google::Protobuf::FieldOptions < ::Protobuf::Message end + +# Raw descriptor bytes below +__END__ +#{Base64.encode64(file_descriptor.encode)} EOF end end diff --git a/spec/lib/protobuf/generators/service_generator_spec.rb b/spec/lib/protobuf/generators/service_generator_spec.rb index 07d1c9af..28a42cc1 100644 --- a/spec/lib/protobuf/generators/service_generator_spec.rb +++ b/spec/lib/protobuf/generators/service_generator_spec.rb @@ -53,6 +53,8 @@ class ::Google::Protobuf::MethodOptions < ::Protobuf::Message let(:compiled) do < @descriptors.map(&:call)) + end + end + + unless respond_to?(:descriptor_dependencies) + def self.descriptor_dependencies + @descriptor_dependencies + end + end ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions } ## # Enum Classes # class EnumTestType < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.EnumTestType' + define :ZERO, 0 define :ONE, 1 define :TWO, 2 end class AliasedEnum < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.AliasedEnum' + set_option :allow_alias, true define :THREE, 3 @@ -43,6 +72,7 @@ class EnumTestMessage < ::Protobuf::Message; end # Message Fields # class EnumTestMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.EnumTestMessage' optional ::Test::EnumTestType, :non_default_enum, 1 optional ::Test::EnumTestType, :default_enum, 2, :default => ::Test::EnumTestType::ONE repeated ::Test::EnumTestType, :repeated_enums, 3 @@ -61,3 +91,44 @@ class ::Test::Resource < ::Protobuf::Message end + +# Raw descriptor bytes below +__END__ +ChFwcm90b3MvZW51bS5wcm90bxIEdGVzdBoVcHJvdG9zL3Jlc291cmNlLnBy +b3RvIpwDCg9FbnVtVGVzdE1lc3NhZ2USPAoQbm9uX2RlZmF1bHRfZW51bRgB +IAEoDjISLnRlc3QuRW51bVRlc3RUeXBlUg5ub25EZWZhdWx0RW51bRI6Cgxk +ZWZhdWx0X2VudW0YAiABKA4yEi50ZXN0LkVudW1UZXN0VHlwZToDT05FUgtk +ZWZhdWx0RW51bRI5Cg5yZXBlYXRlZF9lbnVtcxgDIAMoDjISLnRlc3QuRW51 +bVRlc3RUeXBlUg1yZXBlYXRlZEVudW1zEkYKFmFsaWFzX25vbl9kZWZhdWx0 +X2VudW0YBCABKA4yES50ZXN0LkFsaWFzZWRFbnVtUhNhbGlhc05vbkRlZmF1 +bHRFbnVtEkcKEmFsaWFzX2RlZmF1bHRfZW51bRgFIAEoDjIRLnRlc3QuQWxp +YXNlZEVudW06BkNVQVRST1IQYWxpYXNEZWZhdWx0RW51bRJDChRhbGlhc19y +ZXBlYXRlZF9lbnVtcxgGIAMoDjIRLnRlc3QuQWxpYXNlZEVudW1SEmFsaWFz +UmVwZWF0ZWRFbnVtcyoqCgxFbnVtVGVzdFR5cGUSCAoEWkVSTxAAEgcKA09O +RRABEgcKA1RXTxACKjwKC0FsaWFzZWRFbnVtEgkKBVRIUkVFEAMSCAoEVFJF +UxADEggKBEZPVVIQBBIKCgZDVUFUUk8QBBoCEAE6TwocZXh0X290aGVyX2Zp +bGVfZGVmaW5lZF9maWVsZBIOLnRlc3QuUmVzb3VyY2UYyAEgASgFUhhleHRP +dGhlckZpbGVEZWZpbmVkRmllbGRKmAgKBhIEAAAkAQoICgEMEgMAABIKCAoB +AhIDAgANCgkKAgMAEgMDAB8KQwoCBQASBAcACwEyNyBUZXN0IGV4dGVuZGlu +ZyBhbm90aGVyIG1lc3NhZ2UgZnJvbSBhbiBpbXBvcnRlZCBmaWxlLgoKCgoD +BQABEgMHBREKCwoEBQACABIDCAILCgwKBQUAAgABEgMIAgYKDAoFBQACAAIS +AwgJCgoLCgQFAAIBEgMJAgoKDAoFBQACAQESAwkCBQoMCgUFAAIBAhIDCQgJ +CgsKBAUAAgISAwoCCgoMCgUFAAICARIDCgIFCgwKBQUAAgICEgMKCAkKGgoC +BQESBA4AFgEaDiBVc2VzIGFsaWFzZXMKCgoKAwUBARIDDgUQCgoKAwUBAxID +DwIcCgsKBAUBAwISAw8CHAoLCgQFAQIAEgMRAg0KDAoFBQECAAESAxECBwoM +CgUFAQIAAhIDEQsMCgsKBAUBAgESAxICDQoMCgUFAQIBARIDEgIGCgwKBQUB +AgECEgMSCwwKCwoEBQECAhIDFAINCgwKBQUBAgIBEgMUAgYKDAoFBQECAgIS +AxQLDAoLCgQFAQIDEgMVAg0KDAoFBQECAwESAxUCCAoMCgUFAQIDAhIDFQsM +CgoKAgQAEgQYACABCgoKAwQAARIDGAgXCgsKBAQAAgASAxkCLQoMCgUEAAIA +BBIDGQIKCgwKBQQAAgAGEgMZCxcKDAoFBAACAAESAxkYKAoMCgUEAAIAAxID +GSssCgsKBAQAAgESAxoCNwoMCgUEAAIBBBIDGgIKCgwKBQQAAgEGEgMaCxcK +DAoFBAACAQESAxoYJAoMCgUEAAIBAxIDGicoCgwKBQQAAgEIEgMaKTYKDAoF +BAACAQcSAxoyNQoLCgQEAAICEgMbAisKDAoFBAACAgQSAxsCCgoMCgUEAAIC +BhIDGwsXCgwKBQQAAgIBEgMbGCYKDAoFBAACAgMSAxspKgoLCgQEAAIDEgMd +AjIKDAoFBAACAwQSAx0CCgoMCgUEAAIDBhIDHQsWCgwKBQQAAgMBEgMdFy0K +DAoFBAACAwMSAx0wMQoLCgQEAAIEEgMeAj8KDAoFBAACBAQSAx4CCgoMCgUE +AAIEBhIDHgsWCgwKBQQAAgQBEgMeFykKDAoFBAACBAMSAx4sLQoMCgUEAAIE +CBIDHi4+CgwKBQQAAgQHEgMeNz0KCwoEBAACBRIDHwIwCgwKBQQAAgUEEgMf +AgoKDAoFBAACBQYSAx8LFgoMCgUEAAIFARIDHxcrCgwKBQQAAgUDEgMfLi8K +CQoBBxIEIgAkAQoJCgIHABIDIwI0CgoKAwcAAhIDIgcUCgoKAwcABBIDIwIK +CgoKAwcABRIDIwsQCgoKAwcAARIDIxEtCgoKAwcAAxIDIzAz diff --git a/spec/support/protos/google_unittest.pb.rb b/spec/support/protos/google_unittest.pb.rb index c2c7d650..78d4f29d 100644 --- a/spec/support/protos/google_unittest.pb.rb +++ b/spec/support/protos/google_unittest.pb.rb @@ -1,8 +1,11 @@ # encoding: utf-8 +# frozen_string_literal: true ## # This file is auto-generated. DO NOT EDIT! # +require 'base64' +require 'set' require 'protobuf' require 'protobuf/rpc/service' @@ -13,18 +16,44 @@ require 'protos/google_unittest_import.pb' module Protobuf_unittest + FULLY_QUALIFIED_NAME = 'protobuf_unittest' unless defined?(self::FULLY_QUALIFIED_NAME) + + @descriptors = [] unless instance_variable_defined?(:@descriptors) + @descriptors << lambda do + bytes = File.read(__FILE__, mode: 'rb').split(/^__END__$/, 2).last + ::Google::Protobuf::FileDescriptorProto.decode(Base64.decode64(bytes)) + end + + @descriptor_dependencies = Set.new unless instance_variable_defined?(:@descriptor_dependencies) + @descriptor_dependencies |= [Protobuf_unittest_import] + + unless respond_to?(:descriptor_set) + def self.descriptor_set + ::Google::Protobuf::FileDescriptorSet.new(:file => @descriptors.map(&:call)) + end + end + + unless respond_to?(:descriptor_dependencies) + def self.descriptor_dependencies + @descriptor_dependencies + end + end ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions } ## # Enum Classes # class ForeignEnum < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ForeignEnum' + define :FOREIGN_FOO, 4 define :FOREIGN_BAR, 5 define :FOREIGN_BAZ, 6 end class TestEnumWithDupValue < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestEnumWithDupValue' + set_option :allow_alias, true define :FOO1, 1 @@ -35,6 +64,8 @@ class TestEnumWithDupValue < ::Protobuf::Enum end class TestSparseEnum < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestSparseEnum' + define :SPARSE_A, 123 define :SPARSE_B, 62374 define :SPARSE_C, 12589234 @@ -50,6 +81,8 @@ class TestSparseEnum < ::Protobuf::Enum # class TestAllTypes < ::Protobuf::Message class NestedEnum < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.NestedEnum' + define :FOO, 1 define :BAR, 2 define :BAZ, 3 @@ -123,6 +156,8 @@ class FooGroup < ::Protobuf::Message; end class TestOneof2 < ::Protobuf::Message class NestedEnum < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.NestedEnum' + define :FOO, 1 define :BAR, 2 define :BAZ, 3 @@ -144,6 +179,8 @@ class TestPackedExtensions < ::Protobuf::Message; end class TestUnpackedExtensions < ::Protobuf::Message; end class TestDynamicExtensions < ::Protobuf::Message class DynamicEnumType < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.DynamicEnumType' + define :DYNAMIC_FOO, 2200 define :DYNAMIC_BAR, 2201 define :DYNAMIC_BAZ, 2202 @@ -190,15 +227,19 @@ class BarResponse < ::Protobuf::Message; end # Message Fields # class TestAllTypes + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestAllTypes' class NestedMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.NestedMessage' optional :int32, :bb, 1 end class OptionalGroup + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.OptionalGroup' optional :int32, :a, 17 end class RepeatedGroup + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.RepeatedGroup' optional :int32, :a, 47 end @@ -280,20 +321,24 @@ class RepeatedGroup end class NestedTestAllTypes + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.NestedTestAllTypes' optional ::Protobuf_unittest::NestedTestAllTypes, :child, 1 optional ::Protobuf_unittest::TestAllTypes, :payload, 2 repeated ::Protobuf_unittest::NestedTestAllTypes, :repeated_child, 3 end class TestDeprecatedFields + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestDeprecatedFields' optional :int32, :deprecated_int32, 1, :deprecated => true end class ForeignMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ForeignMessage' optional :int32, :c, 1 end class TestAllExtensions + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestAllExtensions' # Extension Fields extensions 1...536870912 optional :int32, :".protobuf_unittest.optional_int32_extension", 1, :extension => true @@ -379,14 +424,17 @@ class TestAllExtensions end class OptionalGroup_extension + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.OptionalGroup_extension' optional :int32, :a, 17 end class RepeatedGroup_extension + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.RepeatedGroup_extension' optional :int32, :a, 47 end class TestRequired + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestRequired' required :int32, :a, 1 optional :int32, :dummy2, 2 required :int32, :b, 3 @@ -423,40 +471,49 @@ class TestRequired end class TestRequiredForeign + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestRequiredForeign' optional ::Protobuf_unittest::TestRequired, :optional_message, 1 repeated ::Protobuf_unittest::TestRequired, :repeated_message, 2 optional :int32, :dummy, 3 end class TestForeignNested + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestForeignNested' optional ::Protobuf_unittest::TestAllTypes::NestedMessage, :foreign_nested, 1 end class TestReallyLargeTagNumber + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestReallyLargeTagNumber' optional :int32, :a, 1 optional :int32, :bb, 268435455 end class TestRecursiveMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestRecursiveMessage' optional ::Protobuf_unittest::TestRecursiveMessage, :a, 1 optional :int32, :i, 2 end class TestMutualRecursionA + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestMutualRecursionA' optional ::Protobuf_unittest::TestMutualRecursionB, :bb, 1 end class TestMutualRecursionB + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestMutualRecursionB' optional ::Protobuf_unittest::TestMutualRecursionA, :a, 1 optional :int32, :optional_int32, 2 end class TestDupFieldNumber + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestDupFieldNumber' class Foo + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Foo' optional :int32, :a, 1 end class Bar + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Bar' optional :int32, :a, 1 end @@ -466,15 +523,19 @@ class Bar end class TestEagerMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestEagerMessage' optional ::Protobuf_unittest::TestAllTypes, :sub_message, 1, :lazy => false end class TestLazyMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestLazyMessage' optional ::Protobuf_unittest::TestAllTypes, :sub_message, 1, :lazy => true end class TestNestedMessageHasBits + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestNestedMessageHasBits' class NestedMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.NestedMessage' repeated :int32, :nestedmessage_repeated_int32, 1 repeated ::Protobuf_unittest::ForeignMessage, :nestedmessage_repeated_foreignmessage, 2 end @@ -483,6 +544,7 @@ class NestedMessage end class TestCamelCaseFieldNames + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestCamelCaseFieldNames' optional :int32, :PrimitiveField, 1 optional :string, :StringField, 2 optional ::Protobuf_unittest::ForeignEnum, :EnumField, 3 @@ -498,7 +560,9 @@ class TestCamelCaseFieldNames end class TestFieldOrderings + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestFieldOrderings' class NestedMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.NestedMessage' optional :int64, :oo, 2 optional :int32, :bb, 1 end @@ -515,6 +579,7 @@ class NestedMessage end class TestExtremeDefaultValues + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestExtremeDefaultValues' optional :bytes, :escaped_bytes, 1, :default => "\000\001\007\010\014\n\r\t\013\\\\'\"\376" optional :uint32, :large_uint32, 2, :default => 4294967295 optional :uint64, :large_uint64, 3, :default => 18446744073709551615 @@ -545,47 +610,59 @@ class TestExtremeDefaultValues end class SparseEnumMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.SparseEnumMessage' optional ::Protobuf_unittest::TestSparseEnum, :sparse_enum, 1 end class OneString + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.OneString' optional :string, :data, 1 end class MoreString + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.MoreString' repeated :string, :data, 1 end class OneBytes + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.OneBytes' optional :bytes, :data, 1 end class MoreBytes + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.MoreBytes' repeated :bytes, :data, 1 end class Int32Message + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Int32Message' optional :int32, :data, 1 end class Uint32Message + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Uint32Message' optional :uint32, :data, 1 end class Int64Message + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Int64Message' optional :int64, :data, 1 end class Uint64Message + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Uint64Message' optional :uint64, :data, 1 end class BoolMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.BoolMessage' optional :bool, :data, 1 end class TestOneof + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestOneof' class FooGroup + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.FooGroup' optional :int32, :a, 5 optional :string, :b, 6 end @@ -597,7 +674,9 @@ class FooGroup end class TestOneofBackwardsCompatible + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestOneofBackwardsCompatible' class FooGroup + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.FooGroup' optional :int32, :a, 5 optional :string, :b, 6 end @@ -609,12 +688,15 @@ class FooGroup end class TestOneof2 + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestOneof2' class FooGroup + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.FooGroup' optional :int32, :a, 9 optional :string, :b, 10 end class NestedMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.NestedMessage' optional :int64, :qux_int, 1 repeated :int32, :corge_int, 2 end @@ -639,7 +721,9 @@ class NestedMessage end class TestRequiredOneof + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestRequiredOneof' class NestedMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.NestedMessage' required :double, :required_double, 1 end @@ -649,6 +733,7 @@ class NestedMessage end class TestPackedTypes + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestPackedTypes' repeated :int32, :packed_int32, 90, :packed => true repeated :int64, :packed_int64, 91, :packed => true repeated :uint32, :packed_uint32, 92, :packed => true @@ -666,6 +751,7 @@ class TestPackedTypes end class TestUnpackedTypes + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestUnpackedTypes' repeated :int32, :unpacked_int32, 90, :packed => false repeated :int64, :unpacked_int64, 91, :packed => false repeated :uint32, :unpacked_uint32, 92, :packed => false @@ -683,6 +769,7 @@ class TestUnpackedTypes end class TestPackedExtensions + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestPackedExtensions' # Extension Fields extensions 1...536870912 repeated :int32, :".protobuf_unittest.packed_int32_extension", 90, :packed => true, :extension => true @@ -702,6 +789,7 @@ class TestPackedExtensions end class TestUnpackedExtensions + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestUnpackedExtensions' # Extension Fields extensions 1...536870912 repeated :int32, :".protobuf_unittest.unpacked_int32_extension", 90, :extension => true, :packed => false @@ -721,7 +809,9 @@ class TestUnpackedExtensions end class TestDynamicExtensions + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestDynamicExtensions' class DynamicMessageType + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.DynamicMessageType' optional :int32, :dynamic_field, 2100 end @@ -735,6 +825,7 @@ class DynamicMessageType end class TestRepeatedScalarDifferentTagSizes + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestRepeatedScalarDifferentTagSizes' repeated :fixed32, :repeated_fixed32, 12 repeated :int32, :repeated_int32, 13 repeated :fixed64, :repeated_fixed64, 2046 @@ -744,12 +835,16 @@ class TestRepeatedScalarDifferentTagSizes end class TestParsingMerge + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestParsingMerge' class RepeatedFieldsGenerator + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.RepeatedFieldsGenerator' class Group1 + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Group1' optional ::Protobuf_unittest::TestAllTypes, :field1, 11 end class Group2 + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Group2' optional ::Protobuf_unittest::TestAllTypes, :field1, 21 end @@ -763,10 +858,12 @@ class Group2 end class OptionalGroup + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.OptionalGroup' optional ::Protobuf_unittest::TestAllTypes, :optional_group_all_types, 11 end class RepeatedGroup + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.RepeatedGroup' optional ::Protobuf_unittest::TestAllTypes, :repeated_group_all_types, 21 end @@ -782,6 +879,7 @@ class RepeatedGroup end class TestCommentInjectionMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestCommentInjectionMessage' optional :string, :a, 1, :default => "*/ <- Neither should this." end @@ -790,9 +888,1683 @@ class TestCommentInjectionMessage # Service Classes # class TestService < ::Protobuf::Rpc::Service + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestService' + rpc :foo, ::Protobuf_unittest::FooRequest, ::Protobuf_unittest::FooResponse rpc :bar, ::Protobuf_unittest::BarRequest, ::Protobuf_unittest::BarResponse end end + +# Raw descriptor bytes below +__END__ +Chxwcm90b3MvZ29vZ2xlX3VuaXR0ZXN0LnByb3RvEhFwcm90b2J1Zl91bml0 +dGVzdBojcHJvdG9zL2dvb2dsZV91bml0dGVzdF9pbXBvcnQucHJvdG8i/iIK +DFRlc3RBbGxUeXBlcxIlCg5vcHRpb25hbF9pbnQzMhgBIAEoBVINb3B0aW9u +YWxJbnQzMhIlCg5vcHRpb25hbF9pbnQ2NBgCIAEoA1INb3B0aW9uYWxJbnQ2 +NBInCg9vcHRpb25hbF91aW50MzIYAyABKA1SDm9wdGlvbmFsVWludDMyEicK +D29wdGlvbmFsX3VpbnQ2NBgEIAEoBFIOb3B0aW9uYWxVaW50NjQSJwoPb3B0 +aW9uYWxfc2ludDMyGAUgASgRUg5vcHRpb25hbFNpbnQzMhInCg9vcHRpb25h +bF9zaW50NjQYBiABKBJSDm9wdGlvbmFsU2ludDY0EikKEG9wdGlvbmFsX2Zp +eGVkMzIYByABKAdSD29wdGlvbmFsRml4ZWQzMhIpChBvcHRpb25hbF9maXhl +ZDY0GAggASgGUg9vcHRpb25hbEZpeGVkNjQSKwoRb3B0aW9uYWxfc2ZpeGVk +MzIYCSABKA9SEG9wdGlvbmFsU2ZpeGVkMzISKwoRb3B0aW9uYWxfc2ZpeGVk +NjQYCiABKBBSEG9wdGlvbmFsU2ZpeGVkNjQSJQoOb3B0aW9uYWxfZmxvYXQY +CyABKAJSDW9wdGlvbmFsRmxvYXQSJwoPb3B0aW9uYWxfZG91YmxlGAwgASgB +Ug5vcHRpb25hbERvdWJsZRIjCg1vcHRpb25hbF9ib29sGA0gASgIUgxvcHRp +b25hbEJvb2wSJwoPb3B0aW9uYWxfc3RyaW5nGA4gASgJUg5vcHRpb25hbFN0 +cmluZxIlCg5vcHRpb25hbF9ieXRlcxgPIAEoDFINb3B0aW9uYWxCeXRlcxJT +Cg1vcHRpb25hbGdyb3VwGBAgASgKMi0ucHJvdG9idWZfdW5pdHRlc3QuVGVz +dEFsbFR5cGVzLk9wdGlvbmFsR3JvdXBSDW9wdGlvbmFsZ3JvdXASZQoXb3B0 +aW9uYWxfbmVzdGVkX21lc3NhZ2UYEiABKAsyLS5wcm90b2J1Zl91bml0dGVz +dC5UZXN0QWxsVHlwZXMuTmVzdGVkTWVzc2FnZVIVb3B0aW9uYWxOZXN0ZWRN +ZXNzYWdlElsKGG9wdGlvbmFsX2ZvcmVpZ25fbWVzc2FnZRgTIAEoCzIhLnBy +b3RvYnVmX3VuaXR0ZXN0LkZvcmVpZ25NZXNzYWdlUhZvcHRpb25hbEZvcmVp +Z25NZXNzYWdlEl8KF29wdGlvbmFsX2ltcG9ydF9tZXNzYWdlGBQgASgLMicu +cHJvdG9idWZfdW5pdHRlc3RfaW1wb3J0LkltcG9ydE1lc3NhZ2VSFW9wdGlv +bmFsSW1wb3J0TWVzc2FnZRJcChRvcHRpb25hbF9uZXN0ZWRfZW51bRgVIAEo +DjIqLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxUeXBlcy5OZXN0ZWRFbnVt +UhJvcHRpb25hbE5lc3RlZEVudW0SUgoVb3B0aW9uYWxfZm9yZWlnbl9lbnVt +GBYgASgOMh4ucHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbkVudW1SE29wdGlv +bmFsRm9yZWlnbkVudW0SVgoUb3B0aW9uYWxfaW1wb3J0X2VudW0YFyABKA4y +JC5wcm90b2J1Zl91bml0dGVzdF9pbXBvcnQuSW1wb3J0RW51bVISb3B0aW9u +YWxJbXBvcnRFbnVtEjYKFW9wdGlvbmFsX3N0cmluZ19waWVjZRgYIAEoCUIC +CAJSE29wdGlvbmFsU3RyaW5nUGllY2USJwoNb3B0aW9uYWxfY29yZBgZIAEo +CUICCAFSDG9wdGlvbmFsQ29yZBJyCh5vcHRpb25hbF9wdWJsaWNfaW1wb3J0 +X21lc3NhZ2UYGiABKAsyLS5wcm90b2J1Zl91bml0dGVzdF9pbXBvcnQuUHVi +bGljSW1wb3J0TWVzc2FnZVIbb3B0aW9uYWxQdWJsaWNJbXBvcnRNZXNzYWdl +EmUKFW9wdGlvbmFsX2xhenlfbWVzc2FnZRgbIAEoCzItLnByb3RvYnVmX3Vu +aXR0ZXN0LlRlc3RBbGxUeXBlcy5OZXN0ZWRNZXNzYWdlQgIoAVITb3B0aW9u +YWxMYXp5TWVzc2FnZRIlCg5yZXBlYXRlZF9pbnQzMhgfIAMoBVINcmVwZWF0 +ZWRJbnQzMhIlCg5yZXBlYXRlZF9pbnQ2NBggIAMoA1INcmVwZWF0ZWRJbnQ2 +NBInCg9yZXBlYXRlZF91aW50MzIYISADKA1SDnJlcGVhdGVkVWludDMyEicK +D3JlcGVhdGVkX3VpbnQ2NBgiIAMoBFIOcmVwZWF0ZWRVaW50NjQSJwoPcmVw +ZWF0ZWRfc2ludDMyGCMgAygRUg5yZXBlYXRlZFNpbnQzMhInCg9yZXBlYXRl +ZF9zaW50NjQYJCADKBJSDnJlcGVhdGVkU2ludDY0EikKEHJlcGVhdGVkX2Zp +eGVkMzIYJSADKAdSD3JlcGVhdGVkRml4ZWQzMhIpChByZXBlYXRlZF9maXhl +ZDY0GCYgAygGUg9yZXBlYXRlZEZpeGVkNjQSKwoRcmVwZWF0ZWRfc2ZpeGVk +MzIYJyADKA9SEHJlcGVhdGVkU2ZpeGVkMzISKwoRcmVwZWF0ZWRfc2ZpeGVk +NjQYKCADKBBSEHJlcGVhdGVkU2ZpeGVkNjQSJQoOcmVwZWF0ZWRfZmxvYXQY +KSADKAJSDXJlcGVhdGVkRmxvYXQSJwoPcmVwZWF0ZWRfZG91YmxlGCogAygB +Ug5yZXBlYXRlZERvdWJsZRIjCg1yZXBlYXRlZF9ib29sGCsgAygIUgxyZXBl +YXRlZEJvb2wSJwoPcmVwZWF0ZWRfc3RyaW5nGCwgAygJUg5yZXBlYXRlZFN0 +cmluZxIlCg5yZXBlYXRlZF9ieXRlcxgtIAMoDFINcmVwZWF0ZWRCeXRlcxJT +Cg1yZXBlYXRlZGdyb3VwGC4gAygKMi0ucHJvdG9idWZfdW5pdHRlc3QuVGVz +dEFsbFR5cGVzLlJlcGVhdGVkR3JvdXBSDXJlcGVhdGVkZ3JvdXASZQoXcmVw +ZWF0ZWRfbmVzdGVkX21lc3NhZ2UYMCADKAsyLS5wcm90b2J1Zl91bml0dGVz +dC5UZXN0QWxsVHlwZXMuTmVzdGVkTWVzc2FnZVIVcmVwZWF0ZWROZXN0ZWRN +ZXNzYWdlElsKGHJlcGVhdGVkX2ZvcmVpZ25fbWVzc2FnZRgxIAMoCzIhLnBy +b3RvYnVmX3VuaXR0ZXN0LkZvcmVpZ25NZXNzYWdlUhZyZXBlYXRlZEZvcmVp +Z25NZXNzYWdlEl8KF3JlcGVhdGVkX2ltcG9ydF9tZXNzYWdlGDIgAygLMicu +cHJvdG9idWZfdW5pdHRlc3RfaW1wb3J0LkltcG9ydE1lc3NhZ2VSFXJlcGVh +dGVkSW1wb3J0TWVzc2FnZRJcChRyZXBlYXRlZF9uZXN0ZWRfZW51bRgzIAMo +DjIqLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxUeXBlcy5OZXN0ZWRFbnVt +UhJyZXBlYXRlZE5lc3RlZEVudW0SUgoVcmVwZWF0ZWRfZm9yZWlnbl9lbnVt +GDQgAygOMh4ucHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbkVudW1SE3JlcGVh +dGVkRm9yZWlnbkVudW0SVgoUcmVwZWF0ZWRfaW1wb3J0X2VudW0YNSADKA4y +JC5wcm90b2J1Zl91bml0dGVzdF9pbXBvcnQuSW1wb3J0RW51bVIScmVwZWF0 +ZWRJbXBvcnRFbnVtEjYKFXJlcGVhdGVkX3N0cmluZ19waWVjZRg2IAMoCUIC +CAJSE3JlcGVhdGVkU3RyaW5nUGllY2USJwoNcmVwZWF0ZWRfY29yZBg3IAMo +CUICCAFSDHJlcGVhdGVkQ29yZBJlChVyZXBlYXRlZF9sYXp5X21lc3NhZ2UY +OSADKAsyLS5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsVHlwZXMuTmVzdGVk +TWVzc2FnZUICKAFSE3JlcGVhdGVkTGF6eU1lc3NhZ2USJwoNZGVmYXVsdF9p +bnQzMhg9IAEoBToCNDFSDGRlZmF1bHRJbnQzMhInCg1kZWZhdWx0X2ludDY0 +GD4gASgDOgI0MlIMZGVmYXVsdEludDY0EikKDmRlZmF1bHRfdWludDMyGD8g +ASgNOgI0M1INZGVmYXVsdFVpbnQzMhIpCg5kZWZhdWx0X3VpbnQ2NBhAIAEo +BDoCNDRSDWRlZmF1bHRVaW50NjQSKgoOZGVmYXVsdF9zaW50MzIYQSABKBE6 +Ay00NVINZGVmYXVsdFNpbnQzMhIpCg5kZWZhdWx0X3NpbnQ2NBhCIAEoEjoC +NDZSDWRlZmF1bHRTaW50NjQSKwoPZGVmYXVsdF9maXhlZDMyGEMgASgHOgI0 +N1IOZGVmYXVsdEZpeGVkMzISKwoPZGVmYXVsdF9maXhlZDY0GEQgASgGOgI0 +OFIOZGVmYXVsdEZpeGVkNjQSLQoQZGVmYXVsdF9zZml4ZWQzMhhFIAEoDzoC +NDlSD2RlZmF1bHRTZml4ZWQzMhIuChBkZWZhdWx0X3NmaXhlZDY0GEYgASgQ +OgMtNTBSD2RlZmF1bHRTZml4ZWQ2NBIpCg1kZWZhdWx0X2Zsb2F0GEcgASgC +OgQ1MS41UgxkZWZhdWx0RmxvYXQSLAoOZGVmYXVsdF9kb3VibGUYSCABKAE6 +BTUyMDAwUg1kZWZhdWx0RG91YmxlEicKDGRlZmF1bHRfYm9vbBhJIAEoCDoE +dHJ1ZVILZGVmYXVsdEJvb2wSLAoOZGVmYXVsdF9zdHJpbmcYSiABKAk6BWhl +bGxvUg1kZWZhdWx0U3RyaW5nEioKDWRlZmF1bHRfYnl0ZXMYSyABKAw6BXdv +cmxkUgxkZWZhdWx0Qnl0ZXMSXwoTZGVmYXVsdF9uZXN0ZWRfZW51bRhRIAEo +DjIqLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxUeXBlcy5OZXN0ZWRFbnVt +OgNCQVJSEWRlZmF1bHROZXN0ZWRFbnVtEl0KFGRlZmF1bHRfZm9yZWlnbl9l +bnVtGFIgASgOMh4ucHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbkVudW06C0ZP +UkVJR05fQkFSUhJkZWZhdWx0Rm9yZWlnbkVudW0SYAoTZGVmYXVsdF9pbXBv +cnRfZW51bRhTIAEoDjIkLnByb3RvYnVmX3VuaXR0ZXN0X2ltcG9ydC5JbXBv +cnRFbnVtOgpJTVBPUlRfQkFSUhFkZWZhdWx0SW1wb3J0RW51bRI5ChRkZWZh +dWx0X3N0cmluZ19waWVjZRhUIAEoCToDYWJjQgIIAlISZGVmYXVsdFN0cmlu +Z1BpZWNlEioKDGRlZmF1bHRfY29yZBhVIAEoCToDMTIzQgIIAVILZGVmYXVs +dENvcmQSIwoMb25lb2ZfdWludDMyGG8gASgNSABSC29uZW9mVWludDMyEmEK +FG9uZW9mX25lc3RlZF9tZXNzYWdlGHAgASgLMi0ucHJvdG9idWZfdW5pdHRl +c3QuVGVzdEFsbFR5cGVzLk5lc3RlZE1lc3NhZ2VIAFISb25lb2ZOZXN0ZWRN +ZXNzYWdlEiMKDG9uZW9mX3N0cmluZxhxIAEoCUgAUgtvbmVvZlN0cmluZxIh +CgtvbmVvZl9ieXRlcxhyIAEoDEgAUgpvbmVvZkJ5dGVzGh8KDU5lc3RlZE1l +c3NhZ2USDgoCYmIYASABKAVSAmJiGh0KDU9wdGlvbmFsR3JvdXASDAoBYRgR +IAEoBVIBYRodCg1SZXBlYXRlZEdyb3VwEgwKAWEYLyABKAVSAWEiOQoKTmVz +dGVkRW51bRIHCgNGT08QARIHCgNCQVIQAhIHCgNCQVoQAxIQCgNORUcQ//// +////////AUINCgtvbmVvZl9maWVsZCLaAQoSTmVzdGVkVGVzdEFsbFR5cGVz +EjsKBWNoaWxkGAEgASgLMiUucHJvdG9idWZfdW5pdHRlc3QuTmVzdGVkVGVz +dEFsbFR5cGVzUgVjaGlsZBI5CgdwYXlsb2FkGAIgASgLMh8ucHJvdG9idWZf +dW5pdHRlc3QuVGVzdEFsbFR5cGVzUgdwYXlsb2FkEkwKDnJlcGVhdGVkX2No +aWxkGAMgAygLMiUucHJvdG9idWZfdW5pdHRlc3QuTmVzdGVkVGVzdEFsbFR5 +cGVzUg1yZXBlYXRlZENoaWxkIkUKFFRlc3REZXByZWNhdGVkRmllbGRzEi0K +EGRlcHJlY2F0ZWRfaW50MzIYASABKAVCAhgBUg9kZXByZWNhdGVkSW50MzIi +HgoORm9yZWlnbk1lc3NhZ2USDAoBYxgBIAEoBVIBYyIwChJUZXN0UmVzZXJ2 +ZWRGaWVsZHNKBAgCEANKBAgPEBBKBAgJEAxSA2JhclIDYmF6Ih0KEVRlc3RB +bGxFeHRlbnNpb25zKggIARCAgICAAiInChdPcHRpb25hbEdyb3VwX2V4dGVu +c2lvbhIMCgFhGBEgASgFUgFhIicKF1JlcGVhdGVkR3JvdXBfZXh0ZW5zaW9u +EgwKAWEYLyABKAVSAWEitQEKE1Rlc3ROZXN0ZWRFeHRlbnNpb24yPwoEdGVz +dBIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGOoHIAEo +CToEdGVzdFIEdGVzdDJdChduZXN0ZWRfc3RyaW5nX2V4dGVuc2lvbhIkLnBy +b3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGOsHIAEoCVIVbmVz +dGVkU3RyaW5nRXh0ZW5zaW9uImYKF1Rlc3RNb3JlTmVzdGVkRXh0ZW5zaW9u +MksKBHRlc3QSJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9u +cxjsByABKAk6EGEgZGlmZmVyZW50IHRlc3RSBHRlc3Qi9AcKDFRlc3RSZXF1 +aXJlZBIMCgFhGAEgAigFUgFhEhYKBmR1bW15MhgCIAEoBVIGZHVtbXkyEgwK +AWIYAyACKAVSAWISFgoGZHVtbXk0GAQgASgFUgZkdW1teTQSFgoGZHVtbXk1 +GAUgASgFUgZkdW1teTUSFgoGZHVtbXk2GAYgASgFUgZkdW1teTYSFgoGZHVt +bXk3GAcgASgFUgZkdW1teTcSFgoGZHVtbXk4GAggASgFUgZkdW1teTgSFgoG +ZHVtbXk5GAkgASgFUgZkdW1teTkSGAoHZHVtbXkxMBgKIAEoBVIHZHVtbXkx +MBIYCgdkdW1teTExGAsgASgFUgdkdW1teTExEhgKB2R1bW15MTIYDCABKAVS +B2R1bW15MTISGAoHZHVtbXkxMxgNIAEoBVIHZHVtbXkxMxIYCgdkdW1teTE0 +GA4gASgFUgdkdW1teTE0EhgKB2R1bW15MTUYDyABKAVSB2R1bW15MTUSGAoH +ZHVtbXkxNhgQIAEoBVIHZHVtbXkxNhIYCgdkdW1teTE3GBEgASgFUgdkdW1t +eTE3EhgKB2R1bW15MTgYEiABKAVSB2R1bW15MTgSGAoHZHVtbXkxORgTIAEo +BVIHZHVtbXkxORIYCgdkdW1teTIwGBQgASgFUgdkdW1teTIwEhgKB2R1bW15 +MjEYFSABKAVSB2R1bW15MjESGAoHZHVtbXkyMhgWIAEoBVIHZHVtbXkyMhIY +CgdkdW1teTIzGBcgASgFUgdkdW1teTIzEhgKB2R1bW15MjQYGCABKAVSB2R1 +bW15MjQSGAoHZHVtbXkyNRgZIAEoBVIHZHVtbXkyNRIYCgdkdW1teTI2GBog +ASgFUgdkdW1teTI2EhgKB2R1bW15MjcYGyABKAVSB2R1bW15MjcSGAoHZHVt +bXkyOBgcIAEoBVIHZHVtbXkyOBIYCgdkdW1teTI5GB0gASgFUgdkdW1teTI5 +EhgKB2R1bW15MzAYHiABKAVSB2R1bW15MzASGAoHZHVtbXkzMRgfIAEoBVIH +ZHVtbXkzMRIYCgdkdW1teTMyGCAgASgFUgdkdW1teTMyEgwKAWMYISACKAVS +AWMyXgoGc2luZ2xlEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVu +c2lvbnMY6AcgASgLMh8ucHJvdG9idWZfdW5pdHRlc3QuVGVzdFJlcXVpcmVk +UgZzaW5nbGUyXAoFbXVsdGkSJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxs +RXh0ZW5zaW9ucxjpByADKAsyHy5wcm90b2J1Zl91bml0dGVzdC5UZXN0UmVx +dWlyZWRSBW11bHRpIsMBChNUZXN0UmVxdWlyZWRGb3JlaWduEkoKEG9wdGlv +bmFsX21lc3NhZ2UYASABKAsyHy5wcm90b2J1Zl91bml0dGVzdC5UZXN0UmVx +dWlyZWRSD29wdGlvbmFsTWVzc2FnZRJKChByZXBlYXRlZF9tZXNzYWdlGAIg +AygLMh8ucHJvdG9idWZfdW5pdHRlc3QuVGVzdFJlcXVpcmVkUg9yZXBlYXRl +ZE1lc3NhZ2USFAoFZHVtbXkYAyABKAVSBWR1bW15ImkKEVRlc3RGb3JlaWdu +TmVzdGVkElQKDmZvcmVpZ25fbmVzdGVkGAEgASgLMi0ucHJvdG9idWZfdW5p +dHRlc3QuVGVzdEFsbFR5cGVzLk5lc3RlZE1lc3NhZ2VSDWZvcmVpZ25OZXN0 +ZWQiEgoQVGVzdEVtcHR5TWVzc2FnZSIqCh5UZXN0RW1wdHlNZXNzYWdlV2l0 +aEV4dGVuc2lvbnMqCAgBEICAgIACIjcKG1Rlc3RNdWx0aXBsZUV4dGVuc2lv +blJhbmdlcyoECCoQKyoGCK8gEJQhKgoIgIAEEICAgIACIjsKGFRlc3RSZWFs +bHlMYXJnZVRhZ051bWJlchIMCgFhGAEgASgFUgFhEhEKAmJiGP///38gASgF +UgJiYiJbChRUZXN0UmVjdXJzaXZlTWVzc2FnZRI1CgFhGAEgASgLMicucHJv +dG9idWZfdW5pdHRlc3QuVGVzdFJlY3Vyc2l2ZU1lc3NhZ2VSAWESDAoBaRgC +IAEoBVIBaSJPChRUZXN0TXV0dWFsUmVjdXJzaW9uQRI3CgJiYhgBIAEoCzIn +LnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RNdXR1YWxSZWN1cnNpb25CUgJiYiJ0 +ChRUZXN0TXV0dWFsUmVjdXJzaW9uQhI1CgFhGAEgASgLMicucHJvdG9idWZf +dW5pdHRlc3QuVGVzdE11dHVhbFJlY3Vyc2lvbkFSAWESJQoOb3B0aW9uYWxf +aW50MzIYAiABKAVSDW9wdGlvbmFsSW50MzIixgEKElRlc3REdXBGaWVsZE51 +bWJlchIMCgFhGAEgASgFUgFhEjsKA2ZvbxgCIAEoCjIpLnByb3RvYnVmX3Vu +aXR0ZXN0LlRlc3REdXBGaWVsZE51bWJlci5Gb29SA2ZvbxI7CgNiYXIYAyAB +KAoyKS5wcm90b2J1Zl91bml0dGVzdC5UZXN0RHVwRmllbGROdW1iZXIuQmFy +UgNiYXIaEwoDRm9vEgwKAWEYASABKAVSAWEaEwoDQmFyEgwKAWEYASABKAVS +AWEiWAoQVGVzdEVhZ2VyTWVzc2FnZRJECgtzdWJfbWVzc2FnZRgBIAEoCzIf +LnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxUeXBlc0ICKABSCnN1Yk1lc3Nh +Z2UiVwoPVGVzdExhenlNZXNzYWdlEkQKC3N1Yl9tZXNzYWdlGAEgASgLMh8u +cHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbFR5cGVzQgIoAVIKc3ViTWVzc2Fn +ZSLYAgoYVGVzdE5lc3RlZE1lc3NhZ2VIYXNCaXRzEnEKF29wdGlvbmFsX25l +c3RlZF9tZXNzYWdlGAEgASgLMjkucHJvdG9idWZfdW5pdHRlc3QuVGVzdE5l +c3RlZE1lc3NhZ2VIYXNCaXRzLk5lc3RlZE1lc3NhZ2VSFW9wdGlvbmFsTmVz +dGVkTWVzc2FnZRrIAQoNTmVzdGVkTWVzc2FnZRJAChxuZXN0ZWRtZXNzYWdl +X3JlcGVhdGVkX2ludDMyGAEgAygFUhpuZXN0ZWRtZXNzYWdlUmVwZWF0ZWRJ +bnQzMhJ1CiVuZXN0ZWRtZXNzYWdlX3JlcGVhdGVkX2ZvcmVpZ25tZXNzYWdl +GAIgAygLMiEucHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbk1lc3NhZ2VSI25l +c3RlZG1lc3NhZ2VSZXBlYXRlZEZvcmVpZ25tZXNzYWdlIrsFChdUZXN0Q2Ft +ZWxDYXNlRmllbGROYW1lcxImCg5QcmltaXRpdmVGaWVsZBgBIAEoBVIOUHJp +bWl0aXZlRmllbGQSIAoLU3RyaW5nRmllbGQYAiABKAlSC1N0cmluZ0ZpZWxk +EjwKCUVudW1GaWVsZBgDIAEoDjIeLnByb3RvYnVmX3VuaXR0ZXN0LkZvcmVp +Z25FbnVtUglFbnVtRmllbGQSRQoMTWVzc2FnZUZpZWxkGAQgASgLMiEucHJv +dG9idWZfdW5pdHRlc3QuRm9yZWlnbk1lc3NhZ2VSDE1lc3NhZ2VGaWVsZBIu +ChBTdHJpbmdQaWVjZUZpZWxkGAUgASgJQgIIAlIQU3RyaW5nUGllY2VGaWVs +ZBIgCglDb3JkRmllbGQYBiABKAlCAggBUglDb3JkRmllbGQSNgoWUmVwZWF0 +ZWRQcmltaXRpdmVGaWVsZBgHIAMoBVIWUmVwZWF0ZWRQcmltaXRpdmVGaWVs +ZBIwChNSZXBlYXRlZFN0cmluZ0ZpZWxkGAggAygJUhNSZXBlYXRlZFN0cmlu +Z0ZpZWxkEkwKEVJlcGVhdGVkRW51bUZpZWxkGAkgAygOMh4ucHJvdG9idWZf +dW5pdHRlc3QuRm9yZWlnbkVudW1SEVJlcGVhdGVkRW51bUZpZWxkElUKFFJl +cGVhdGVkTWVzc2FnZUZpZWxkGAogAygLMiEucHJvdG9idWZfdW5pdHRlc3Qu +Rm9yZWlnbk1lc3NhZ2VSFFJlcGVhdGVkTWVzc2FnZUZpZWxkEj4KGFJlcGVh +dGVkU3RyaW5nUGllY2VGaWVsZBgLIAMoCUICCAJSGFJlcGVhdGVkU3RyaW5n +UGllY2VGaWVsZBIwChFSZXBlYXRlZENvcmRGaWVsZBgMIAMoCUICCAFSEVJl +cGVhdGVkQ29yZEZpZWxkIo4CChJUZXN0RmllbGRPcmRlcmluZ3MSGwoJbXlf +c3RyaW5nGAsgASgJUghteVN0cmluZxIVCgZteV9pbnQYASABKANSBW15SW50 +EhkKCG15X2Zsb2F0GGUgASgCUgdteUZsb2F0EmwKF29wdGlvbmFsX25lc3Rl +ZF9tZXNzYWdlGMgBIAEoCzIzLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RGaWVs +ZE9yZGVyaW5ncy5OZXN0ZWRNZXNzYWdlUhVvcHRpb25hbE5lc3RlZE1lc3Nh +Z2UaLwoNTmVzdGVkTWVzc2FnZRIOCgJvbxgCIAEoA1ICb28SDgoCYmIYASAB +KAVSAmJiKgQIAhALKgQIDBBlIq8KChhUZXN0RXh0cmVtZURlZmF1bHRWYWx1 +ZXMSTQoNZXNjYXBlZF9ieXRlcxgBIAEoDDooXDAwMFwwMDFcMDA3XDAxMFww +MTRcblxyXHRcMDEzXFxcJ1wiXDM3NlIMZXNjYXBlZEJ5dGVzEi0KDGxhcmdl +X3VpbnQzMhgCIAEoDToKNDI5NDk2NzI5NVILbGFyZ2VVaW50MzISNwoMbGFy +Z2VfdWludDY0GAMgASgEOhQxODQ0Njc0NDA3MzcwOTU1MTYxNVILbGFyZ2VV +aW50NjQSLAoLc21hbGxfaW50MzIYBCABKAU6Cy0yMTQ3NDgzNjQ3UgpzbWFs +bEludDMyEjUKC3NtYWxsX2ludDY0GAUgASgDOhQtOTIyMzM3MjAzNjg1NDc3 +NTgwN1IKc21hbGxJbnQ2NBI5ChJyZWFsbHlfc21hbGxfaW50MzIYFSABKAU6 +Cy0yMTQ3NDgzNjQ4UhByZWFsbHlTbWFsbEludDMyEkIKEnJlYWxseV9zbWFs +bF9pbnQ2NBgWIAEoAzoULTkyMjMzNzIwMzY4NTQ3NzU4MDhSEHJlYWxseVNt +YWxsSW50NjQSJAoLdXRmOF9zdHJpbmcYBiABKAk6A+GItFIKdXRmOFN0cmlu +ZxIgCgp6ZXJvX2Zsb2F0GAcgASgCOgEwUgl6ZXJvRmxvYXQSHgoJb25lX2Zs +b2F0GAggASgCOgExUghvbmVGbG9hdBIkCgtzbWFsbF9mbG9hdBgJIAEoAjoD +MS41UgpzbWFsbEZsb2F0EjAKEm5lZ2F0aXZlX29uZV9mbG9hdBgKIAEoAjoC +LTFSEG5lZ2F0aXZlT25lRmxvYXQSKwoObmVnYXRpdmVfZmxvYXQYCyABKAI6 +BC0xLjVSDW5lZ2F0aXZlRmxvYXQSJgoLbGFyZ2VfZmxvYXQYDCABKAI6BTJl +KzA4UgpsYXJnZUZsb2F0EjgKFHNtYWxsX25lZ2F0aXZlX2Zsb2F0GA0gASgC +OgYtOGUtMjhSEnNtYWxsTmVnYXRpdmVGbG9hdBIiCgppbmZfZG91YmxlGA4g +ASgBOgNpbmZSCWluZkRvdWJsZRIqCg5uZWdfaW5mX2RvdWJsZRgPIAEoAToE +LWluZlIMbmVnSW5mRG91YmxlEiIKCm5hbl9kb3VibGUYECABKAE6A25hblIJ +bmFuRG91YmxlEiAKCWluZl9mbG9hdBgRIAEoAjoDaW5mUghpbmZGbG9hdBIo +Cg1uZWdfaW5mX2Zsb2F0GBIgASgCOgQtaW5mUgtuZWdJbmZGbG9hdBIgCglu +YW5fZmxvYXQYEyABKAI6A25hblIIbmFuRmxvYXQSOAoMY3BwX3RyaWdyYXBo +GBQgASgJOhU/ID8gPz8gPz8gPz8/ID8/LyA/Py1SC2NwcFRyaWdyYXBoEjAK +EHN0cmluZ193aXRoX3plcm8YFyABKAk6BmhlbABsb1IOc3RyaW5nV2l0aFpl +cm8SMQoPYnl0ZXNfd2l0aF96ZXJvGBggASgMOgl3b3JcMDAwbGRSDWJ5dGVz +V2l0aFplcm8SPQoWc3RyaW5nX3BpZWNlX3dpdGhfemVybxgZIAEoCToEYWIA +Y0ICCAJSE3N0cmluZ1BpZWNlV2l0aFplcm8SLgoOY29yZF93aXRoX3plcm8Y +GiABKAk6BDEyADNCAggBUgxjb3JkV2l0aFplcm8SOQoScmVwbGFjZW1lbnRf +c3RyaW5nGBsgASgJOgoke3Vua25vd259UhFyZXBsYWNlbWVudFN0cmluZyJX +ChFTcGFyc2VFbnVtTWVzc2FnZRJCCgtzcGFyc2VfZW51bRgBIAEoDjIhLnBy +b3RvYnVmX3VuaXR0ZXN0LlRlc3RTcGFyc2VFbnVtUgpzcGFyc2VFbnVtIh8K +CU9uZVN0cmluZxISCgRkYXRhGAEgASgJUgRkYXRhIiAKCk1vcmVTdHJpbmcS +EgoEZGF0YRgBIAMoCVIEZGF0YSIeCghPbmVCeXRlcxISCgRkYXRhGAEgASgM +UgRkYXRhIh8KCU1vcmVCeXRlcxISCgRkYXRhGAEgAygMUgRkYXRhIiIKDElu +dDMyTWVzc2FnZRISCgRkYXRhGAEgASgFUgRkYXRhIiMKDVVpbnQzMk1lc3Nh +Z2USEgoEZGF0YRgBIAEoDVIEZGF0YSIiCgxJbnQ2NE1lc3NhZ2USEgoEZGF0 +YRgBIAEoA1IEZGF0YSIjCg1VaW50NjRNZXNzYWdlEhIKBGRhdGEYASABKARS +BGRhdGEiIQoLQm9vbE1lc3NhZ2USEgoEZGF0YRgBIAEoCFIEZGF0YSL/AQoJ +VGVzdE9uZW9mEhkKB2Zvb19pbnQYASABKAVIAFIGZm9vSW50Eh8KCmZvb19z +dHJpbmcYAiABKAlIAFIJZm9vU3RyaW5nEkIKC2Zvb19tZXNzYWdlGAMgASgL +Mh8ucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbFR5cGVzSABSCmZvb01lc3Nh +Z2USQwoIZm9vZ3JvdXAYBCABKAoyJS5wcm90b2J1Zl91bml0dGVzdC5UZXN0 +T25lb2YuRm9vR3JvdXBIAFIIZm9vZ3JvdXAaJgoIRm9vR3JvdXASDAoBYRgF +IAEoBVIBYRIMCgFiGAYgASgJUgFiQgUKA2ZvbyKWAgocVGVzdE9uZW9mQmFj +a3dhcmRzQ29tcGF0aWJsZRIXCgdmb29faW50GAEgASgFUgZmb29JbnQSHQoK +Zm9vX3N0cmluZxgCIAEoCVIJZm9vU3RyaW5nEkAKC2Zvb19tZXNzYWdlGAMg +ASgLMh8ucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbFR5cGVzUgpmb29NZXNz +YWdlElQKCGZvb2dyb3VwGAQgASgKMjgucHJvdG9idWZfdW5pdHRlc3QuVGVz +dE9uZW9mQmFja3dhcmRzQ29tcGF0aWJsZS5Gb29Hcm91cFIIZm9vZ3JvdXAa +JgoIRm9vR3JvdXASDAoBYRgFIAEoBVIBYRIMCgFiGAYgASgJUgFiIu0HCgpU +ZXN0T25lb2YyEhkKB2Zvb19pbnQYASABKAVIAFIGZm9vSW50Eh8KCmZvb19z +dHJpbmcYAiABKAlIAFIJZm9vU3RyaW5nEh8KCGZvb19jb3JkGAMgASgJQgII +AUgAUgdmb29Db3JkEi4KEGZvb19zdHJpbmdfcGllY2UYBCABKAlCAggCSABS +DmZvb1N0cmluZ1BpZWNlEh0KCWZvb19ieXRlcxgFIAEoDEgAUghmb29CeXRl +cxJFCghmb29fZW51bRgGIAEoDjIoLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RP +bmVvZjIuTmVzdGVkRW51bUgAUgdmb29FbnVtEk4KC2Zvb19tZXNzYWdlGAcg +ASgLMisucHJvdG9idWZfdW5pdHRlc3QuVGVzdE9uZW9mMi5OZXN0ZWRNZXNz +YWdlSABSCmZvb01lc3NhZ2USRAoIZm9vZ3JvdXAYCCABKAoyJi5wcm90b2J1 +Zl91bml0dGVzdC5UZXN0T25lb2YyLkZvb0dyb3VwSABSCGZvb2dyb3VwElsK +EGZvb19sYXp5X21lc3NhZ2UYCyABKAsyKy5wcm90b2J1Zl91bml0dGVzdC5U +ZXN0T25lb2YyLk5lc3RlZE1lc3NhZ2VCAigBSABSDmZvb0xhenlNZXNzYWdl +EhwKB2Jhcl9pbnQYDCABKAU6ATVIAVIGYmFySW50EicKCmJhcl9zdHJpbmcY +DSABKAk6BlNUUklOR0gBUgliYXJTdHJpbmcSJQoIYmFyX2NvcmQYDiABKAk6 +BENPUkRCAggBSAFSB2JhckNvcmQSNgoQYmFyX3N0cmluZ19waWVjZRgPIAEo +CToGU1BJRUNFQgIIAkgBUg5iYXJTdHJpbmdQaWVjZRIkCgliYXJfYnl0ZXMY +ECABKAw6BUJZVEVTSAFSCGJhckJ5dGVzEkoKCGJhcl9lbnVtGBEgASgOMigu +cHJvdG9idWZfdW5pdHRlc3QuVGVzdE9uZW9mMi5OZXN0ZWRFbnVtOgNCQVJI +AVIHYmFyRW51bRIXCgdiYXpfaW50GBIgASgFUgZiYXpJbnQSIgoKYmF6X3N0 +cmluZxgTIAEoCToDQkFaUgliYXpTdHJpbmcaJgoIRm9vR3JvdXASDAoBYRgJ +IAEoBVIBYRIMCgFiGAogASgJUgFiGkUKDU5lc3RlZE1lc3NhZ2USFwoHcXV4 +X2ludBgBIAEoA1IGcXV4SW50EhsKCWNvcmdlX2ludBgCIAMoBVIIY29yZ2VJ +bnQiJwoKTmVzdGVkRW51bRIHCgNGT08QARIHCgNCQVIQAhIHCgNCQVoQA0IF +CgNmb29CBQoDYmFyIucBChFUZXN0UmVxdWlyZWRPbmVvZhIZCgdmb29faW50 +GAEgASgFSABSBmZvb0ludBIfCgpmb29fc3RyaW5nGAIgASgJSABSCWZvb1N0 +cmluZxJVCgtmb29fbWVzc2FnZRgDIAEoCzIyLnByb3RvYnVmX3VuaXR0ZXN0 +LlRlc3RSZXF1aXJlZE9uZW9mLk5lc3RlZE1lc3NhZ2VIAFIKZm9vTWVzc2Fn +ZRo4Cg1OZXN0ZWRNZXNzYWdlEicKD3JlcXVpcmVkX2RvdWJsZRgBIAIoAVIO +cmVxdWlyZWREb3VibGVCBQoDZm9vIu0ECg9UZXN0UGFja2VkVHlwZXMSJQoM +cGFja2VkX2ludDMyGFogAygFQgIQAVILcGFja2VkSW50MzISJQoMcGFja2Vk +X2ludDY0GFsgAygDQgIQAVILcGFja2VkSW50NjQSJwoNcGFja2VkX3VpbnQz +MhhcIAMoDUICEAFSDHBhY2tlZFVpbnQzMhInCg1wYWNrZWRfdWludDY0GF0g +AygEQgIQAVIMcGFja2VkVWludDY0EicKDXBhY2tlZF9zaW50MzIYXiADKBFC +AhABUgxwYWNrZWRTaW50MzISJwoNcGFja2VkX3NpbnQ2NBhfIAMoEkICEAFS +DHBhY2tlZFNpbnQ2NBIpCg5wYWNrZWRfZml4ZWQzMhhgIAMoB0ICEAFSDXBh +Y2tlZEZpeGVkMzISKQoOcGFja2VkX2ZpeGVkNjQYYSADKAZCAhABUg1wYWNr +ZWRGaXhlZDY0EisKD3BhY2tlZF9zZml4ZWQzMhhiIAMoD0ICEAFSDnBhY2tl +ZFNmaXhlZDMyEisKD3BhY2tlZF9zZml4ZWQ2NBhjIAMoEEICEAFSDnBhY2tl +ZFNmaXhlZDY0EiUKDHBhY2tlZF9mbG9hdBhkIAMoAkICEAFSC3BhY2tlZEZs +b2F0EicKDXBhY2tlZF9kb3VibGUYZSADKAFCAhABUgxwYWNrZWREb3VibGUS +IwoLcGFja2VkX2Jvb2wYZiADKAhCAhABUgpwYWNrZWRCb29sEkMKC3BhY2tl +ZF9lbnVtGGcgAygOMh4ucHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbkVudW1C +AhABUgpwYWNrZWRFbnVtIqcFChFUZXN0VW5wYWNrZWRUeXBlcxIpCg51bnBh +Y2tlZF9pbnQzMhhaIAMoBUICEABSDXVucGFja2VkSW50MzISKQoOdW5wYWNr +ZWRfaW50NjQYWyADKANCAhAAUg11bnBhY2tlZEludDY0EisKD3VucGFja2Vk +X3VpbnQzMhhcIAMoDUICEABSDnVucGFja2VkVWludDMyEisKD3VucGFja2Vk +X3VpbnQ2NBhdIAMoBEICEABSDnVucGFja2VkVWludDY0EisKD3VucGFja2Vk +X3NpbnQzMhheIAMoEUICEABSDnVucGFja2VkU2ludDMyEisKD3VucGFja2Vk +X3NpbnQ2NBhfIAMoEkICEABSDnVucGFja2VkU2ludDY0Ei0KEHVucGFja2Vk +X2ZpeGVkMzIYYCADKAdCAhAAUg91bnBhY2tlZEZpeGVkMzISLQoQdW5wYWNr +ZWRfZml4ZWQ2NBhhIAMoBkICEABSD3VucGFja2VkRml4ZWQ2NBIvChF1bnBh +Y2tlZF9zZml4ZWQzMhhiIAMoD0ICEABSEHVucGFja2VkU2ZpeGVkMzISLwoR +dW5wYWNrZWRfc2ZpeGVkNjQYYyADKBBCAhAAUhB1bnBhY2tlZFNmaXhlZDY0 +EikKDnVucGFja2VkX2Zsb2F0GGQgAygCQgIQAFINdW5wYWNrZWRGbG9hdBIr +Cg91bnBhY2tlZF9kb3VibGUYZSADKAFCAhAAUg51bnBhY2tlZERvdWJsZRIn +Cg11bnBhY2tlZF9ib29sGGYgAygIQgIQAFIMdW5wYWNrZWRCb29sEkcKDXVu +cGFja2VkX2VudW0YZyADKA4yHi5wcm90b2J1Zl91bml0dGVzdC5Gb3JlaWdu +RW51bUICEABSDHVucGFja2VkRW51bSIgChRUZXN0UGFja2VkRXh0ZW5zaW9u +cyoICAEQgICAgAIiIgoWVGVzdFVucGFja2VkRXh0ZW5zaW9ucyoICAEQgICA +gAIirAUKFVRlc3REeW5hbWljRXh0ZW5zaW9ucxIqChBzY2FsYXJfZXh0ZW5z +aW9uGNAPIAEoB1IPc2NhbGFyRXh0ZW5zaW9uEkYKDmVudW1fZXh0ZW5zaW9u +GNEPIAEoDjIeLnByb3RvYnVmX3VuaXR0ZXN0LkZvcmVpZ25FbnVtUg1lbnVt +RXh0ZW5zaW9uEm8KFmR5bmFtaWNfZW51bV9leHRlbnNpb24Y0g8gASgOMjgu +cHJvdG9idWZfdW5pdHRlc3QuVGVzdER5bmFtaWNFeHRlbnNpb25zLkR5bmFt +aWNFbnVtVHlwZVIUZHluYW1pY0VudW1FeHRlbnNpb24STwoRbWVzc2FnZV9l +eHRlbnNpb24Y0w8gASgLMiEucHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbk1l +c3NhZ2VSEG1lc3NhZ2VFeHRlbnNpb24SeAoZZHluYW1pY19tZXNzYWdlX2V4 +dGVuc2lvbhjUDyABKAsyOy5wcm90b2J1Zl91bml0dGVzdC5UZXN0RHluYW1p +Y0V4dGVuc2lvbnMuRHluYW1pY01lc3NhZ2VUeXBlUhdkeW5hbWljTWVzc2Fn +ZUV4dGVuc2lvbhIuChJyZXBlYXRlZF9leHRlbnNpb24Y1Q8gAygJUhFyZXBl +YXRlZEV4dGVuc2lvbhIuChBwYWNrZWRfZXh0ZW5zaW9uGNYPIAMoEUICEAFS +D3BhY2tlZEV4dGVuc2lvbho6ChJEeW5hbWljTWVzc2FnZVR5cGUSJAoNZHlu +YW1pY19maWVsZBi0ECABKAVSDGR5bmFtaWNGaWVsZCJHCg9EeW5hbWljRW51 +bVR5cGUSEAoLRFlOQU1JQ19GT08QmBESEAoLRFlOQU1JQ19CQVIQmRESEAoL +RFlOQU1JQ19CQVoQmhEinwIKI1Rlc3RSZXBlYXRlZFNjYWxhckRpZmZlcmVu +dFRhZ1NpemVzEikKEHJlcGVhdGVkX2ZpeGVkMzIYDCADKAdSD3JlcGVhdGVk +Rml4ZWQzMhIlCg5yZXBlYXRlZF9pbnQzMhgNIAMoBVINcmVwZWF0ZWRJbnQz +MhIqChByZXBlYXRlZF9maXhlZDY0GP4PIAMoBlIPcmVwZWF0ZWRGaXhlZDY0 +EiYKDnJlcGVhdGVkX2ludDY0GP8PIAMoA1INcmVwZWF0ZWRJbnQ2NBInCg5y +ZXBlYXRlZF9mbG9hdBj+/w8gAygCUg1yZXBlYXRlZEZsb2F0EikKD3JlcGVh +dGVkX3VpbnQ2NBj//w8gAygEUg5yZXBlYXRlZFVpbnQ2NCLXCwoQVGVzdFBh +cnNpbmdNZXJnZRJNChJyZXF1aXJlZF9hbGxfdHlwZXMYASACKAsyHy5wcm90 +b2J1Zl91bml0dGVzdC5UZXN0QWxsVHlwZXNSEHJlcXVpcmVkQWxsVHlwZXMS +TQoSb3B0aW9uYWxfYWxsX3R5cGVzGAIgASgLMh8ucHJvdG9idWZfdW5pdHRl +c3QuVGVzdEFsbFR5cGVzUhBvcHRpb25hbEFsbFR5cGVzEk0KEnJlcGVhdGVk +X2FsbF90eXBlcxgDIAMoCzIfLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxU +eXBlc1IQcmVwZWF0ZWRBbGxUeXBlcxJXCg1vcHRpb25hbGdyb3VwGAogASgK +MjEucHJvdG9idWZfdW5pdHRlc3QuVGVzdFBhcnNpbmdNZXJnZS5PcHRpb25h +bEdyb3VwUg1vcHRpb25hbGdyb3VwElcKDXJlcGVhdGVkZ3JvdXAYFCADKAoy +MS5wcm90b2J1Zl91bml0dGVzdC5UZXN0UGFyc2luZ01lcmdlLlJlcGVhdGVk +R3JvdXBSDXJlcGVhdGVkZ3JvdXAa7gQKF1JlcGVhdGVkRmllbGRzR2VuZXJh +dG9yEjcKBmZpZWxkMRgBIAMoCzIfLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RB +bGxUeXBlc1IGZmllbGQxEjcKBmZpZWxkMhgCIAMoCzIfLnByb3RvYnVmX3Vu +aXR0ZXN0LlRlc3RBbGxUeXBlc1IGZmllbGQyEjcKBmZpZWxkMxgDIAMoCzIf +LnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxUeXBlc1IGZmllbGQzEloKBmdy +b3VwMRgKIAMoCjJCLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RQYXJzaW5nTWVy +Z2UuUmVwZWF0ZWRGaWVsZHNHZW5lcmF0b3IuR3JvdXAxUgZncm91cDESWgoG +Z3JvdXAyGBQgAygKMkIucHJvdG9idWZfdW5pdHRlc3QuVGVzdFBhcnNpbmdN +ZXJnZS5SZXBlYXRlZEZpZWxkc0dlbmVyYXRvci5Hcm91cDJSBmdyb3VwMhI0 +CgRleHQxGOgHIAMoCzIfLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxUeXBl +c1IEZXh0MRI0CgRleHQyGOkHIAMoCzIfLnByb3RvYnVmX3VuaXR0ZXN0LlRl +c3RBbGxUeXBlc1IEZXh0MhpBCgZHcm91cDESNwoGZmllbGQxGAsgASgLMh8u +cHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbFR5cGVzUgZmaWVsZDEaQQoGR3Jv +dXAyEjcKBmZpZWxkMRgVIAEoCzIfLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RB +bGxUeXBlc1IGZmllbGQxGmkKDU9wdGlvbmFsR3JvdXASWAoYb3B0aW9uYWxf +Z3JvdXBfYWxsX3R5cGVzGAsgASgLMh8ucHJvdG9idWZfdW5pdHRlc3QuVGVz +dEFsbFR5cGVzUhVvcHRpb25hbEdyb3VwQWxsVHlwZXMaaQoNUmVwZWF0ZWRH +cm91cBJYChhyZXBlYXRlZF9ncm91cF9hbGxfdHlwZXMYFSABKAsyHy5wcm90 +b2J1Zl91bml0dGVzdC5UZXN0QWxsVHlwZXNSFXJlcGVhdGVkR3JvdXBBbGxU +eXBlcyoJCOgHEICAgIACMmgKDG9wdGlvbmFsX2V4dBIjLnByb3RvYnVmX3Vu +aXR0ZXN0LlRlc3RQYXJzaW5nTWVyZ2UY6AcgASgLMh8ucHJvdG9idWZfdW5p +dHRlc3QuVGVzdEFsbFR5cGVzUgtvcHRpb25hbEV4dDJoCgxyZXBlYXRlZF9l +eHQSIy5wcm90b2J1Zl91bml0dGVzdC5UZXN0UGFyc2luZ01lcmdlGOkHIAMo +CzIfLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxUeXBlc1ILcmVwZWF0ZWRF +eHQiRwobVGVzdENvbW1lbnRJbmplY3Rpb25NZXNzYWdlEigKAWEYASABKAk6 +GiovIDwtIE5laXRoZXIgc2hvdWxkIHRoaXMuUgFhIgwKCkZvb1JlcXVlc3Qi +DQoLRm9vUmVzcG9uc2UiEgoQRm9vQ2xpZW50TWVzc2FnZSISChBGb29TZXJ2 +ZXJNZXNzYWdlIgwKCkJhclJlcXVlc3QiDQoLQmFyUmVzcG9uc2UqQAoLRm9y +ZWlnbkVudW0SDwoLRk9SRUlHTl9GT08QBBIPCgtGT1JFSUdOX0JBUhAFEg8K +C0ZPUkVJR05fQkFaEAYqSwoUVGVzdEVudW1XaXRoRHVwVmFsdWUSCAoERk9P +MRABEggKBEJBUjEQAhIHCgNCQVoQAxIICgRGT08yEAESCAoEQkFSMhACGgIQ +ASqJAQoOVGVzdFNwYXJzZUVudW0SDAoIU1BBUlNFX0EQexIOCghTUEFSU0Vf +QhCm5wMSDwoIU1BBUlNFX0MQsrGABhIVCghTUEFSU0VfRBDx//////////8B +EhUKCFNQQVJTRV9FELTe/P///////wESDAoIU1BBUlNFX0YQABIMCghTUEFS +U0VfRxACMpkBCgtUZXN0U2VydmljZRJECgNGb28SHS5wcm90b2J1Zl91bml0 +dGVzdC5Gb29SZXF1ZXN0Gh4ucHJvdG9idWZfdW5pdHRlc3QuRm9vUmVzcG9u +c2USRAoDQmFyEh0ucHJvdG9idWZfdW5pdHRlc3QuQmFyUmVxdWVzdBoeLnBy +b3RvYnVmX3VuaXR0ZXN0LkJhclJlc3BvbnNlOl4KGG9wdGlvbmFsX2ludDMy +X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNp +b25zGAEgASgFUhZvcHRpb25hbEludDMyRXh0ZW5zaW9uOl4KGG9wdGlvbmFs +X2ludDY0X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxF +eHRlbnNpb25zGAIgASgDUhZvcHRpb25hbEludDY0RXh0ZW5zaW9uOmAKGW9w +dGlvbmFsX3VpbnQzMl9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5U +ZXN0QWxsRXh0ZW5zaW9ucxgDIAEoDVIXb3B0aW9uYWxVaW50MzJFeHRlbnNp +b246YAoZb3B0aW9uYWxfdWludDY0X2V4dGVuc2lvbhIkLnByb3RvYnVmX3Vu +aXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGAQgASgEUhdvcHRpb25hbFVpbnQ2 +NEV4dGVuc2lvbjpgChlvcHRpb25hbF9zaW50MzJfZXh0ZW5zaW9uEiQucHJv +dG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYBSABKBFSF29wdGlv +bmFsU2ludDMyRXh0ZW5zaW9uOmAKGW9wdGlvbmFsX3NpbnQ2NF9leHRlbnNp +b24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgGIAEo +ElIXb3B0aW9uYWxTaW50NjRFeHRlbnNpb246Ygoab3B0aW9uYWxfZml4ZWQz +Ml9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5z +aW9ucxgHIAEoB1IYb3B0aW9uYWxGaXhlZDMyRXh0ZW5zaW9uOmIKGm9wdGlv +bmFsX2ZpeGVkNjRfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVz +dEFsbEV4dGVuc2lvbnMYCCABKAZSGG9wdGlvbmFsRml4ZWQ2NEV4dGVuc2lv +bjpkChtvcHRpb25hbF9zZml4ZWQzMl9leHRlbnNpb24SJC5wcm90b2J1Zl91 +bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgJIAEoD1IZb3B0aW9uYWxTZml4 +ZWQzMkV4dGVuc2lvbjpkChtvcHRpb25hbF9zZml4ZWQ2NF9leHRlbnNpb24S +JC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgKIAEoEFIZ +b3B0aW9uYWxTZml4ZWQ2NEV4dGVuc2lvbjpeChhvcHRpb25hbF9mbG9hdF9l +eHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9u +cxgLIAEoAlIWb3B0aW9uYWxGbG9hdEV4dGVuc2lvbjpgChlvcHRpb25hbF9k +b3VibGVfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4 +dGVuc2lvbnMYDCABKAFSF29wdGlvbmFsRG91YmxlRXh0ZW5zaW9uOlwKF29w +dGlvbmFsX2Jvb2xfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVz +dEFsbEV4dGVuc2lvbnMYDSABKAhSFW9wdGlvbmFsQm9vbEV4dGVuc2lvbjpg +ChlvcHRpb25hbF9zdHJpbmdfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRl +c3QuVGVzdEFsbEV4dGVuc2lvbnMYDiABKAlSF29wdGlvbmFsU3RyaW5nRXh0 +ZW5zaW9uOl4KGG9wdGlvbmFsX2J5dGVzX2V4dGVuc2lvbhIkLnByb3RvYnVm +X3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGA8gASgMUhZvcHRpb25hbEJ5 +dGVzRXh0ZW5zaW9uOokBChdvcHRpb25hbGdyb3VwX2V4dGVuc2lvbhIkLnBy +b3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGBAgASgKMioucHJv +dG9idWZfdW5pdHRlc3QuT3B0aW9uYWxHcm91cF9leHRlbnNpb25SFm9wdGlv +bmFsZ3JvdXBFeHRlbnNpb246ngEKIW9wdGlvbmFsX25lc3RlZF9tZXNzYWdl +X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNp +b25zGBIgASgLMi0ucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbFR5cGVzLk5l +c3RlZE1lc3NhZ2VSHm9wdGlvbmFsTmVzdGVkTWVzc2FnZUV4dGVuc2lvbjqU +AQoib3B0aW9uYWxfZm9yZWlnbl9tZXNzYWdlX2V4dGVuc2lvbhIkLnByb3Rv +YnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGBMgASgLMiEucHJvdG9i +dWZfdW5pdHRlc3QuRm9yZWlnbk1lc3NhZ2VSH29wdGlvbmFsRm9yZWlnbk1l +c3NhZ2VFeHRlbnNpb246mAEKIW9wdGlvbmFsX2ltcG9ydF9tZXNzYWdlX2V4 +dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25z +GBQgASgLMicucHJvdG9idWZfdW5pdHRlc3RfaW1wb3J0LkltcG9ydE1lc3Nh +Z2VSHm9wdGlvbmFsSW1wb3J0TWVzc2FnZUV4dGVuc2lvbjqVAQoeb3B0aW9u +YWxfbmVzdGVkX2VudW1fZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3Qu +VGVzdEFsbEV4dGVuc2lvbnMYFSABKA4yKi5wcm90b2J1Zl91bml0dGVzdC5U +ZXN0QWxsVHlwZXMuTmVzdGVkRW51bVIbb3B0aW9uYWxOZXN0ZWRFbnVtRXh0 +ZW5zaW9uOosBCh9vcHRpb25hbF9mb3JlaWduX2VudW1fZXh0ZW5zaW9uEiQu +cHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYFiABKA4yHi5w +cm90b2J1Zl91bml0dGVzdC5Gb3JlaWduRW51bVIcb3B0aW9uYWxGb3JlaWdu +RW51bUV4dGVuc2lvbjqPAQoeb3B0aW9uYWxfaW1wb3J0X2VudW1fZXh0ZW5z +aW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYFyAB +KA4yJC5wcm90b2J1Zl91bml0dGVzdF9pbXBvcnQuSW1wb3J0RW51bVIbb3B0 +aW9uYWxJbXBvcnRFbnVtRXh0ZW5zaW9uOm8KH29wdGlvbmFsX3N0cmluZ19w +aWVjZV9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0 +ZW5zaW9ucxgYIAEoCUICCAJSHG9wdGlvbmFsU3RyaW5nUGllY2VFeHRlbnNp +b246YAoXb3B0aW9uYWxfY29yZF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0 +dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgZIAEoCUICCAFSFW9wdGlvbmFsQ29y +ZEV4dGVuc2lvbjqrAQoob3B0aW9uYWxfcHVibGljX2ltcG9ydF9tZXNzYWdl +X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNp +b25zGBogASgLMi0ucHJvdG9idWZfdW5pdHRlc3RfaW1wb3J0LlB1YmxpY0lt +cG9ydE1lc3NhZ2VSJG9wdGlvbmFsUHVibGljSW1wb3J0TWVzc2FnZUV4dGVu +c2lvbjqeAQofb3B0aW9uYWxfbGF6eV9tZXNzYWdlX2V4dGVuc2lvbhIkLnBy +b3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGBsgASgLMi0ucHJv +dG9idWZfdW5pdHRlc3QuVGVzdEFsbFR5cGVzLk5lc3RlZE1lc3NhZ2VCAigB +UhxvcHRpb25hbExhenlNZXNzYWdlRXh0ZW5zaW9uOl4KGHJlcGVhdGVkX2lu +dDMyX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRl +bnNpb25zGB8gAygFUhZyZXBlYXRlZEludDMyRXh0ZW5zaW9uOl4KGHJlcGVh +dGVkX2ludDY0X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RB +bGxFeHRlbnNpb25zGCAgAygDUhZyZXBlYXRlZEludDY0RXh0ZW5zaW9uOmAK +GXJlcGVhdGVkX3VpbnQzMl9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVz +dC5UZXN0QWxsRXh0ZW5zaW9ucxghIAMoDVIXcmVwZWF0ZWRVaW50MzJFeHRl +bnNpb246YAoZcmVwZWF0ZWRfdWludDY0X2V4dGVuc2lvbhIkLnByb3RvYnVm +X3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGCIgAygEUhdyZXBlYXRlZFVp +bnQ2NEV4dGVuc2lvbjpgChlyZXBlYXRlZF9zaW50MzJfZXh0ZW5zaW9uEiQu +cHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYIyADKBFSF3Jl +cGVhdGVkU2ludDMyRXh0ZW5zaW9uOmAKGXJlcGVhdGVkX3NpbnQ2NF9leHRl +bnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgk +IAMoElIXcmVwZWF0ZWRTaW50NjRFeHRlbnNpb246YgoacmVwZWF0ZWRfZml4 +ZWQzMl9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0 +ZW5zaW9ucxglIAMoB1IYcmVwZWF0ZWRGaXhlZDMyRXh0ZW5zaW9uOmIKGnJl +cGVhdGVkX2ZpeGVkNjRfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3Qu +VGVzdEFsbEV4dGVuc2lvbnMYJiADKAZSGHJlcGVhdGVkRml4ZWQ2NEV4dGVu +c2lvbjpkChtyZXBlYXRlZF9zZml4ZWQzMl9leHRlbnNpb24SJC5wcm90b2J1 +Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgnIAMoD1IZcmVwZWF0ZWRT +Zml4ZWQzMkV4dGVuc2lvbjpkChtyZXBlYXRlZF9zZml4ZWQ2NF9leHRlbnNp +b24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgoIAMo +EFIZcmVwZWF0ZWRTZml4ZWQ2NEV4dGVuc2lvbjpeChhyZXBlYXRlZF9mbG9h +dF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5z +aW9ucxgpIAMoAlIWcmVwZWF0ZWRGbG9hdEV4dGVuc2lvbjpgChlyZXBlYXRl +ZF9kb3VibGVfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFs +bEV4dGVuc2lvbnMYKiADKAFSF3JlcGVhdGVkRG91YmxlRXh0ZW5zaW9uOlwK +F3JlcGVhdGVkX2Jvb2xfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3Qu +VGVzdEFsbEV4dGVuc2lvbnMYKyADKAhSFXJlcGVhdGVkQm9vbEV4dGVuc2lv +bjpgChlyZXBlYXRlZF9zdHJpbmdfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5p +dHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYLCADKAlSF3JlcGVhdGVkU3RyaW5n +RXh0ZW5zaW9uOl4KGHJlcGVhdGVkX2J5dGVzX2V4dGVuc2lvbhIkLnByb3Rv +YnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGC0gAygMUhZyZXBlYXRl +ZEJ5dGVzRXh0ZW5zaW9uOokBChdyZXBlYXRlZGdyb3VwX2V4dGVuc2lvbhIk +LnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGC4gAygKMiou +cHJvdG9idWZfdW5pdHRlc3QuUmVwZWF0ZWRHcm91cF9leHRlbnNpb25SFnJl +cGVhdGVkZ3JvdXBFeHRlbnNpb246ngEKIXJlcGVhdGVkX25lc3RlZF9tZXNz +YWdlX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRl +bnNpb25zGDAgAygLMi0ucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbFR5cGVz +Lk5lc3RlZE1lc3NhZ2VSHnJlcGVhdGVkTmVzdGVkTWVzc2FnZUV4dGVuc2lv +bjqUAQoicmVwZWF0ZWRfZm9yZWlnbl9tZXNzYWdlX2V4dGVuc2lvbhIkLnBy +b3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGDEgAygLMiEucHJv +dG9idWZfdW5pdHRlc3QuRm9yZWlnbk1lc3NhZ2VSH3JlcGVhdGVkRm9yZWln +bk1lc3NhZ2VFeHRlbnNpb246mAEKIXJlcGVhdGVkX2ltcG9ydF9tZXNzYWdl +X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNp +b25zGDIgAygLMicucHJvdG9idWZfdW5pdHRlc3RfaW1wb3J0LkltcG9ydE1l +c3NhZ2VSHnJlcGVhdGVkSW1wb3J0TWVzc2FnZUV4dGVuc2lvbjqVAQoecmVw +ZWF0ZWRfbmVzdGVkX2VudW1fZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRl +c3QuVGVzdEFsbEV4dGVuc2lvbnMYMyADKA4yKi5wcm90b2J1Zl91bml0dGVz +dC5UZXN0QWxsVHlwZXMuTmVzdGVkRW51bVIbcmVwZWF0ZWROZXN0ZWRFbnVt +RXh0ZW5zaW9uOosBCh9yZXBlYXRlZF9mb3JlaWduX2VudW1fZXh0ZW5zaW9u +EiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYNCADKA4y +Hi5wcm90b2J1Zl91bml0dGVzdC5Gb3JlaWduRW51bVIccmVwZWF0ZWRGb3Jl +aWduRW51bUV4dGVuc2lvbjqPAQoecmVwZWF0ZWRfaW1wb3J0X2VudW1fZXh0 +ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMY +NSADKA4yJC5wcm90b2J1Zl91bml0dGVzdF9pbXBvcnQuSW1wb3J0RW51bVIb +cmVwZWF0ZWRJbXBvcnRFbnVtRXh0ZW5zaW9uOm8KH3JlcGVhdGVkX3N0cmlu +Z19waWVjZV9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxs +RXh0ZW5zaW9ucxg2IAMoCUICCAJSHHJlcGVhdGVkU3RyaW5nUGllY2VFeHRl +bnNpb246YAoXcmVwZWF0ZWRfY29yZF9leHRlbnNpb24SJC5wcm90b2J1Zl91 +bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxg3IAMoCUICCAFSFXJlcGVhdGVk +Q29yZEV4dGVuc2lvbjqeAQofcmVwZWF0ZWRfbGF6eV9tZXNzYWdlX2V4dGVu +c2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGDkg +AygLMi0ucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbFR5cGVzLk5lc3RlZE1l +c3NhZ2VCAigBUhxyZXBlYXRlZExhenlNZXNzYWdlRXh0ZW5zaW9uOmAKF2Rl +ZmF1bHRfaW50MzJfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVz +dEFsbEV4dGVuc2lvbnMYPSABKAU6AjQxUhVkZWZhdWx0SW50MzJFeHRlbnNp +b246YAoXZGVmYXVsdF9pbnQ2NF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0 +dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxg+IAEoAzoCNDJSFWRlZmF1bHRJbnQ2 +NEV4dGVuc2lvbjpiChhkZWZhdWx0X3VpbnQzMl9leHRlbnNpb24SJC5wcm90 +b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxg/IAEoDToCNDNSFmRl +ZmF1bHRVaW50MzJFeHRlbnNpb246YgoYZGVmYXVsdF91aW50NjRfZXh0ZW5z +aW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYQCAB +KAQ6AjQ0UhZkZWZhdWx0VWludDY0RXh0ZW5zaW9uOmMKGGRlZmF1bHRfc2lu +dDMyX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRl +bnNpb25zGEEgASgROgMtNDVSFmRlZmF1bHRTaW50MzJFeHRlbnNpb246YgoY +ZGVmYXVsdF9zaW50NjRfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3Qu +VGVzdEFsbEV4dGVuc2lvbnMYQiABKBI6AjQ2UhZkZWZhdWx0U2ludDY0RXh0 +ZW5zaW9uOmQKGWRlZmF1bHRfZml4ZWQzMl9leHRlbnNpb24SJC5wcm90b2J1 +Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxhDIAEoBzoCNDdSF2RlZmF1 +bHRGaXhlZDMyRXh0ZW5zaW9uOmQKGWRlZmF1bHRfZml4ZWQ2NF9leHRlbnNp +b24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxhEIAEo +BjoCNDhSF2RlZmF1bHRGaXhlZDY0RXh0ZW5zaW9uOmYKGmRlZmF1bHRfc2Zp +eGVkMzJfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4 +dGVuc2lvbnMYRSABKA86AjQ5UhhkZWZhdWx0U2ZpeGVkMzJFeHRlbnNpb246 +ZwoaZGVmYXVsdF9zZml4ZWQ2NF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0 +dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxhGIAEoEDoDLTUwUhhkZWZhdWx0U2Zp +eGVkNjRFeHRlbnNpb246YgoXZGVmYXVsdF9mbG9hdF9leHRlbnNpb24SJC5w +cm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxhHIAEoAjoENTEu +NVIVZGVmYXVsdEZsb2F0RXh0ZW5zaW9uOmUKGGRlZmF1bHRfZG91YmxlX2V4 +dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25z +GEggASgBOgU1MjAwMFIWZGVmYXVsdERvdWJsZUV4dGVuc2lvbjpgChZkZWZh +dWx0X2Jvb2xfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFs +bEV4dGVuc2lvbnMYSSABKAg6BHRydWVSFGRlZmF1bHRCb29sRXh0ZW5zaW9u +OmUKGGRlZmF1bHRfc3RyaW5nX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0 +ZXN0LlRlc3RBbGxFeHRlbnNpb25zGEogASgJOgVoZWxsb1IWZGVmYXVsdFN0 +cmluZ0V4dGVuc2lvbjpjChdkZWZhdWx0X2J5dGVzX2V4dGVuc2lvbhIkLnBy +b3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGEsgASgMOgV3b3Js +ZFIVZGVmYXVsdEJ5dGVzRXh0ZW5zaW9uOpgBCh1kZWZhdWx0X25lc3RlZF9l +bnVtX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRl +bnNpb25zGFEgASgOMioucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbFR5cGVz +Lk5lc3RlZEVudW06A0JBUlIaZGVmYXVsdE5lc3RlZEVudW1FeHRlbnNpb246 +lgEKHmRlZmF1bHRfZm9yZWlnbl9lbnVtX2V4dGVuc2lvbhIkLnByb3RvYnVm +X3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGFIgASgOMh4ucHJvdG9idWZf +dW5pdHRlc3QuRm9yZWlnbkVudW06C0ZPUkVJR05fQkFSUhtkZWZhdWx0Rm9y +ZWlnbkVudW1FeHRlbnNpb246mQEKHWRlZmF1bHRfaW1wb3J0X2VudW1fZXh0 +ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMY +UyABKA4yJC5wcm90b2J1Zl91bml0dGVzdF9pbXBvcnQuSW1wb3J0RW51bToK +SU1QT1JUX0JBUlIaZGVmYXVsdEltcG9ydEVudW1FeHRlbnNpb246cgoeZGVm +YXVsdF9zdHJpbmdfcGllY2VfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRl +c3QuVGVzdEFsbEV4dGVuc2lvbnMYVCABKAk6A2FiY0ICCAJSG2RlZmF1bHRT +dHJpbmdQaWVjZUV4dGVuc2lvbjpjChZkZWZhdWx0X2NvcmRfZXh0ZW5zaW9u +EiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYVSABKAk6 +AzEyM0ICCAFSFGRlZmF1bHRDb3JkRXh0ZW5zaW9uOloKFm9uZW9mX3VpbnQz +Ml9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5z +aW9ucxhvIAEoDVIUb25lb2ZVaW50MzJFeHRlbnNpb246mAEKHm9uZW9mX25l +c3RlZF9tZXNzYWdlX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRl +c3RBbGxFeHRlbnNpb25zGHAgASgLMi0ucHJvdG9idWZfdW5pdHRlc3QuVGVz +dEFsbFR5cGVzLk5lc3RlZE1lc3NhZ2VSG29uZW9mTmVzdGVkTWVzc2FnZUV4 +dGVuc2lvbjpaChZvbmVvZl9zdHJpbmdfZXh0ZW5zaW9uEiQucHJvdG9idWZf +dW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYcSABKAlSFG9uZW9mU3RyaW5n +RXh0ZW5zaW9uOlgKFW9uZW9mX2J5dGVzX2V4dGVuc2lvbhIkLnByb3RvYnVm +X3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGHIgASgMUhNvbmVvZkJ5dGVz +RXh0ZW5zaW9uOlUKE215X2V4dGVuc2lvbl9zdHJpbmcSJS5wcm90b2J1Zl91 +bml0dGVzdC5UZXN0RmllbGRPcmRlcmluZ3MYMiABKAlSEW15RXh0ZW5zaW9u +U3RyaW5nOk8KEG15X2V4dGVuc2lvbl9pbnQSJS5wcm90b2J1Zl91bml0dGVz +dC5UZXN0RmllbGRPcmRlcmluZ3MYBSABKAVSDm15RXh0ZW5zaW9uSW50OmEK +FnBhY2tlZF9pbnQzMl9leHRlbnNpb24SJy5wcm90b2J1Zl91bml0dGVzdC5U +ZXN0UGFja2VkRXh0ZW5zaW9ucxhaIAMoBUICEAFSFHBhY2tlZEludDMyRXh0 +ZW5zaW9uOmEKFnBhY2tlZF9pbnQ2NF9leHRlbnNpb24SJy5wcm90b2J1Zl91 +bml0dGVzdC5UZXN0UGFja2VkRXh0ZW5zaW9ucxhbIAMoA0ICEAFSFHBhY2tl +ZEludDY0RXh0ZW5zaW9uOmMKF3BhY2tlZF91aW50MzJfZXh0ZW5zaW9uEicu +cHJvdG9idWZfdW5pdHRlc3QuVGVzdFBhY2tlZEV4dGVuc2lvbnMYXCADKA1C +AhABUhVwYWNrZWRVaW50MzJFeHRlbnNpb246YwoXcGFja2VkX3VpbnQ2NF9l +eHRlbnNpb24SJy5wcm90b2J1Zl91bml0dGVzdC5UZXN0UGFja2VkRXh0ZW5z +aW9ucxhdIAMoBEICEAFSFXBhY2tlZFVpbnQ2NEV4dGVuc2lvbjpjChdwYWNr +ZWRfc2ludDMyX2V4dGVuc2lvbhInLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RQ +YWNrZWRFeHRlbnNpb25zGF4gAygRQgIQAVIVcGFja2VkU2ludDMyRXh0ZW5z +aW9uOmMKF3BhY2tlZF9zaW50NjRfZXh0ZW5zaW9uEicucHJvdG9idWZfdW5p +dHRlc3QuVGVzdFBhY2tlZEV4dGVuc2lvbnMYXyADKBJCAhABUhVwYWNrZWRT +aW50NjRFeHRlbnNpb246ZQoYcGFja2VkX2ZpeGVkMzJfZXh0ZW5zaW9uEicu +cHJvdG9idWZfdW5pdHRlc3QuVGVzdFBhY2tlZEV4dGVuc2lvbnMYYCADKAdC +AhABUhZwYWNrZWRGaXhlZDMyRXh0ZW5zaW9uOmUKGHBhY2tlZF9maXhlZDY0 +X2V4dGVuc2lvbhInLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RQYWNrZWRFeHRl +bnNpb25zGGEgAygGQgIQAVIWcGFja2VkRml4ZWQ2NEV4dGVuc2lvbjpnChlw +YWNrZWRfc2ZpeGVkMzJfZXh0ZW5zaW9uEicucHJvdG9idWZfdW5pdHRlc3Qu +VGVzdFBhY2tlZEV4dGVuc2lvbnMYYiADKA9CAhABUhdwYWNrZWRTZml4ZWQz +MkV4dGVuc2lvbjpnChlwYWNrZWRfc2ZpeGVkNjRfZXh0ZW5zaW9uEicucHJv +dG9idWZfdW5pdHRlc3QuVGVzdFBhY2tlZEV4dGVuc2lvbnMYYyADKBBCAhAB +UhdwYWNrZWRTZml4ZWQ2NEV4dGVuc2lvbjphChZwYWNrZWRfZmxvYXRfZXh0 +ZW5zaW9uEicucHJvdG9idWZfdW5pdHRlc3QuVGVzdFBhY2tlZEV4dGVuc2lv +bnMYZCADKAJCAhABUhRwYWNrZWRGbG9hdEV4dGVuc2lvbjpjChdwYWNrZWRf +ZG91YmxlX2V4dGVuc2lvbhInLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RQYWNr +ZWRFeHRlbnNpb25zGGUgAygBQgIQAVIVcGFja2VkRG91YmxlRXh0ZW5zaW9u +Ol8KFXBhY2tlZF9ib29sX2V4dGVuc2lvbhInLnByb3RvYnVmX3VuaXR0ZXN0 +LlRlc3RQYWNrZWRFeHRlbnNpb25zGGYgAygIQgIQAVITcGFja2VkQm9vbEV4 +dGVuc2lvbjp/ChVwYWNrZWRfZW51bV9leHRlbnNpb24SJy5wcm90b2J1Zl91 +bml0dGVzdC5UZXN0UGFja2VkRXh0ZW5zaW9ucxhnIAMoDjIeLnByb3RvYnVm +X3VuaXR0ZXN0LkZvcmVpZ25FbnVtQgIQAVITcGFja2VkRW51bUV4dGVuc2lv +bjpnChh1bnBhY2tlZF9pbnQzMl9leHRlbnNpb24SKS5wcm90b2J1Zl91bml0 +dGVzdC5UZXN0VW5wYWNrZWRFeHRlbnNpb25zGFogAygFQgIQAFIWdW5wYWNr +ZWRJbnQzMkV4dGVuc2lvbjpnChh1bnBhY2tlZF9pbnQ2NF9leHRlbnNpb24S +KS5wcm90b2J1Zl91bml0dGVzdC5UZXN0VW5wYWNrZWRFeHRlbnNpb25zGFsg +AygDQgIQAFIWdW5wYWNrZWRJbnQ2NEV4dGVuc2lvbjppChl1bnBhY2tlZF91 +aW50MzJfZXh0ZW5zaW9uEikucHJvdG9idWZfdW5pdHRlc3QuVGVzdFVucGFj +a2VkRXh0ZW5zaW9ucxhcIAMoDUICEABSF3VucGFja2VkVWludDMyRXh0ZW5z +aW9uOmkKGXVucGFja2VkX3VpbnQ2NF9leHRlbnNpb24SKS5wcm90b2J1Zl91 +bml0dGVzdC5UZXN0VW5wYWNrZWRFeHRlbnNpb25zGF0gAygEQgIQAFIXdW5w +YWNrZWRVaW50NjRFeHRlbnNpb246aQoZdW5wYWNrZWRfc2ludDMyX2V4dGVu +c2lvbhIpLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RVbnBhY2tlZEV4dGVuc2lv +bnMYXiADKBFCAhAAUhd1bnBhY2tlZFNpbnQzMkV4dGVuc2lvbjppChl1bnBh +Y2tlZF9zaW50NjRfZXh0ZW5zaW9uEikucHJvdG9idWZfdW5pdHRlc3QuVGVz +dFVucGFja2VkRXh0ZW5zaW9ucxhfIAMoEkICEABSF3VucGFja2VkU2ludDY0 +RXh0ZW5zaW9uOmsKGnVucGFja2VkX2ZpeGVkMzJfZXh0ZW5zaW9uEikucHJv +dG9idWZfdW5pdHRlc3QuVGVzdFVucGFja2VkRXh0ZW5zaW9ucxhgIAMoB0IC +EABSGHVucGFja2VkRml4ZWQzMkV4dGVuc2lvbjprChp1bnBhY2tlZF9maXhl +ZDY0X2V4dGVuc2lvbhIpLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RVbnBhY2tl +ZEV4dGVuc2lvbnMYYSADKAZCAhAAUhh1bnBhY2tlZEZpeGVkNjRFeHRlbnNp +b246bQobdW5wYWNrZWRfc2ZpeGVkMzJfZXh0ZW5zaW9uEikucHJvdG9idWZf +dW5pdHRlc3QuVGVzdFVucGFja2VkRXh0ZW5zaW9ucxhiIAMoD0ICEABSGXVu +cGFja2VkU2ZpeGVkMzJFeHRlbnNpb246bQobdW5wYWNrZWRfc2ZpeGVkNjRf +ZXh0ZW5zaW9uEikucHJvdG9idWZfdW5pdHRlc3QuVGVzdFVucGFja2VkRXh0 +ZW5zaW9ucxhjIAMoEEICEABSGXVucGFja2VkU2ZpeGVkNjRFeHRlbnNpb246 +ZwoYdW5wYWNrZWRfZmxvYXRfZXh0ZW5zaW9uEikucHJvdG9idWZfdW5pdHRl +c3QuVGVzdFVucGFja2VkRXh0ZW5zaW9ucxhkIAMoAkICEABSFnVucGFja2Vk +RmxvYXRFeHRlbnNpb246aQoZdW5wYWNrZWRfZG91YmxlX2V4dGVuc2lvbhIp +LnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RVbnBhY2tlZEV4dGVuc2lvbnMYZSAD +KAFCAhAAUhd1bnBhY2tlZERvdWJsZUV4dGVuc2lvbjplChd1bnBhY2tlZF9i +b29sX2V4dGVuc2lvbhIpLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RVbnBhY2tl +ZEV4dGVuc2lvbnMYZiADKAhCAhAAUhV1bnBhY2tlZEJvb2xFeHRlbnNpb246 +hQEKF3VucGFja2VkX2VudW1fZXh0ZW5zaW9uEikucHJvdG9idWZfdW5pdHRl +c3QuVGVzdFVucGFja2VkRXh0ZW5zaW9ucxhnIAMoDjIeLnByb3RvYnVmX3Vu +aXR0ZXN0LkZvcmVpZ25FbnVtQgIQAFIVdW5wYWNrZWRFbnVtRXh0ZW5zaW9u +Qh1CDVVuaXR0ZXN0UHJvdG9IAYABAYgBAZABAfgBAUql6wIKBxIFJADzBhYK +/w0KAQwSAyQAEjLBDCBQcm90b2NvbCBCdWZmZXJzIC0gR29vZ2xlJ3MgZGF0 +YSBpbnRlcmNoYW5nZSBmb3JtYXQKIENvcHlyaWdodCAyMDA4IEdvb2dsZSBJ +bmMuICBBbGwgcmlnaHRzIHJlc2VydmVkLgogaHR0cHM6Ly9kZXZlbG9wZXJz +Lmdvb2dsZS5jb20vcHJvdG9jb2wtYnVmZmVycy8KCiBSZWRpc3RyaWJ1dGlv +biBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y +IHdpdGhvdXQKIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl +ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKIG1ldDoKCiAg +ICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh +aW4gdGhlIGFib3ZlIGNvcHlyaWdodAogbm90aWNlLCB0aGlzIGxpc3Qgb2Yg +Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgogICAg +ICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k +dWNlIHRoZSBhYm92ZQogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9m +IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgogaW4g +dGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92 +aWRlZCB3aXRoIHRoZQogZGlzdHJpYnV0aW9uLgogICAgICogTmVpdGhlciB0 +aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cwog +Y29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90 +ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KIHRoaXMgc29mdHdhcmUgd2l0aG91 +dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCgogVEhJUyBT +T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMg +QU5EIENPTlRSSUJVVE9SUwogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1Ig +SU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKIExJTUlU +RUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM +SVRZIEFORCBGSVRORVNTIEZPUgogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJF +IERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQK +IE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJF +Q1QsIElORElSRUNULCBJTkNJREVOVEFMLAogU1BFQ0lBTCwgRVhFTVBMQVJZ +LCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P +VAogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E +UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCiBEQVRBLCBPUiBQUk9GSVRT +OyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO +RCBPTiBBTlkKIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09O +VFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKIChJTkNMVURJTkcg +TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBP +VVQgT0YgVEhFIFVTRQogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJ +U0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KMrABIEF1 +dGhvcjoga2VudG9uQGdvb2dsZS5jb20gKEtlbnRvbiBWYXJkYSkKICBCYXNl +ZCBvbiBvcmlnaW5hbCBQcm90b2NvbCBCdWZmZXJzIGRlc2lnbiBieQogIFNh +bmpheSBHaGVtYXdhdCwgSmVmZiBEZWFuLCBhbmQgb3RoZXJzLgoKIEEgcHJv +dG8gZmlsZSB3ZSB3aWxsIHVzZSBmb3IgdW5pdCB0ZXN0aW5nLgoKCAoBCBID +KAAiCoABCgIIEBIDKAAiGmcgU29tZSBnZW5lcmljX3NlcnZpY2VzIG9wdGlv +bihzKSBhZGRlZCBhdXRvbWF0aWNhbGx5LgogU2VlOiAgaHR0cDovL2dvL3By +b3RvMi1nZW5lcmljLXNlcnZpY2VzLWRlZmF1bHQKIgwgYXV0by1hZGRlZAoK +CAoBCBIDKQAkChcKAggREgMpACQiDCBhdXRvLWFkZGVkCgoICgEIEgMqACIK +FwoCCBISAyoAIiIMIGF1dG8tYWRkZWQKCggKAQgSAysAHwoJCgIIHxIDKwAf +CgkKAgMAEgMtAC0K5gEKAQISAzIAGhrbASBXZSBkb24ndCBwdXQgdGhpcyBp +biBhIHBhY2thZ2Ugd2l0aGluIHByb3RvMiBiZWNhdXNlIHdlIG5lZWQgdG8g +bWFrZSBzdXJlCiB0aGF0IHRoZSBnZW5lcmF0ZWQgY29kZSBkb2Vzbid0IGRl +cGVuZCBvbiBiZWluZyBpbiB0aGUgcHJvdG8yIG5hbWVzcGFjZS4KIEluIHRl +c3RfdXRpbC5oIHdlIGRvICJ1c2luZyBuYW1lc3BhY2UgdW5pdHRlc3QgPSBw +cm90b2J1Zl91bml0dGVzdCIuCgoICgEIEgM3ABwK4gEKAggJEgM3ABwa1gEg +UHJvdG9zIG9wdGltaXplZCBmb3IgU1BFRUQgdXNlIGEgc3RyaWN0IHN1cGVy +c2V0IG9mIHRoZSBnZW5lcmF0ZWQgY29kZQogb2YgZXF1aXZhbGVudCBvbmVz +IG9wdGltaXplZCBmb3IgQ09ERV9TSVpFLCBzbyB3ZSBzaG91bGQgb3B0aW1p +emUgYWxsIG91cgogdGVzdHMgZm9yIHNwZWVkIHVubGVzcyBleHBsaWNpdGx5 +IHRlc3RpbmcgY29kZSBzaXplIG9wdGltaXphdGlvbi4KCggKAQgSAzkALgoJ +CgIICBIDOQAuClwKAgQAEgU9ALQBARpPIFRoaXMgcHJvdG8gaW5jbHVkZXMg +ZXZlcnkgdHlwZSBvZiBmaWVsZCBpbiBib3RoIHNpbmd1bGFyIGFuZCByZXBl +YXRlZAogZm9ybXMuCgoKCgMEAAESAz0IFAoMCgQEAAMAEgQ+AkMDCgwKBQQA +AwABEgM+ChcK4wEKBgQAAwACABIDQgQaGtMBIFRoZSBmaWVsZCBuYW1lICJi +IiBmYWlscyB0byBjb21waWxlIGluIHByb3RvMSBiZWNhdXNlIGl0IGNvbmZs +aWN0cyB3aXRoCiBhIGxvY2FsIHZhcmlhYmxlIG5hbWVkICJiIiBpbiBvbmUg +b2YgdGhlIGdlbmVyYXRlZCBtZXRob2RzLiAgRG9oLgogVGhpcyBmaWxlIG5l +ZWRzIHRvIGNvbXBpbGUgaW4gcHJvdG8xIHRvIHRlc3QgYmFja3dhcmRzLWNv +bXBhdGliaWxpdHkuCgoOCgcEAAMAAgAEEgNCBAwKDgoHBAADAAIABRIDQg0S +Cg4KBwQAAwACAAESA0ITFQoOCgcEAAMAAgADEgNCGBkKDAoEBAAEABIERQJK +AwoMCgUEAAQAARIDRQcRCg0KBgQABAACABIDRgQMCg4KBwQABAACAAESA0YE +BwoOCgcEAAQAAgACEgNGCgsKDQoGBAAEAAIBEgNHBAwKDgoHBAAEAAIBARID +RwQHCg4KBwQABAACAQISA0cKCwoNCgYEAAQAAgISA0gEDAoOCgcEAAQAAgIB +EgNIBAcKDgoHBAAEAAICAhIDSAoLCigKBgQABAACAxIDSQQNIhkgSW50ZW50 +aW9uYWxseSBuZWdhdGl2ZS4KCg4KBwQABAACAwESA0kEBwoOCgcEAAQAAgMC +EgNJCgwKFwoEBAACABIDTQIrGgogU2luZ3VsYXIKCgwKBQQAAgAEEgNNAgoK +DAoFBAACAAUSA00OEwoMCgUEAAIAARIDTRQiCgwKBQQAAgADEgNNKSoKCwoE +BAACARIDTgIrCgwKBQQAAgEEEgNOAgoKDAoFBAACAQUSA04OEwoMCgUEAAIB +ARIDThQiCgwKBQQAAgEDEgNOKSoKCwoEBAACAhIDTwIrCgwKBQQAAgIEEgNP +AgoKDAoFBAACAgUSA08NEwoMCgUEAAICARIDTxQjCgwKBQQAAgIDEgNPKSoK +CwoEBAACAxIDUAIrCgwKBQQAAgMEEgNQAgoKDAoFBAACAwUSA1ANEwoMCgUE +AAIDARIDUBQjCgwKBQQAAgMDEgNQKSoKCwoEBAACBBIDUQIrCgwKBQQAAgQE +EgNRAgoKDAoFBAACBAUSA1ENEwoMCgUEAAIEARIDURQjCgwKBQQAAgQDEgNR +KSoKCwoEBAACBRIDUgIrCgwKBQQAAgUEEgNSAgoKDAoFBAACBQUSA1INEwoM +CgUEAAIFARIDUhQjCgwKBQQAAgUDEgNSKSoKCwoEBAACBhIDUwIrCgwKBQQA +AgYEEgNTAgoKDAoFBAACBgUSA1MMEwoMCgUEAAIGARIDUxQkCgwKBQQAAgYD +EgNTKSoKCwoEBAACBxIDVAIrCgwKBQQAAgcEEgNUAgoKDAoFBAACBwUSA1QM +EwoMCgUEAAIHARIDVBQkCgwKBQQAAgcDEgNUKSoKCwoEBAACCBIDVQIrCgwK +BQQAAggEEgNVAgoKDAoFBAACCAUSA1ULEwoMCgUEAAIIARIDVRQlCgwKBQQA +AggDEgNVKSoKCwoEBAACCRIDVgIrCgwKBQQAAgkEEgNWAgoKDAoFBAACCQUS +A1YLEwoMCgUEAAIJARIDVhQlCgwKBQQAAgkDEgNWKCoKCwoEBAACChIDVwIr +CgwKBQQAAgoEEgNXAgoKDAoFBAACCgUSA1cOEwoMCgUEAAIKARIDVxQiCgwK +BQQAAgoDEgNXKCoKCwoEBAACCxIDWAIrCgwKBQQAAgsEEgNYAgoKDAoFBAAC +CwUSA1gNEwoMCgUEAAILARIDWBQjCgwKBQQAAgsDEgNYKCoKCwoEBAACDBID +WQIrCgwKBQQAAgwEEgNZAgoKDAoFBAACDAUSA1kPEwoMCgUEAAIMARIDWRQh +CgwKBQQAAgwDEgNZKCoKCwoEBAACDRIDWgIrCgwKBQQAAg0EEgNaAgoKDAoF +BAACDQUSA1oNEwoMCgUEAAINARIDWhQjCgwKBQQAAg0DEgNaKCoKCwoEBAAC +DhIDWwIrCgwKBQQAAg4EEgNbAgoKDAoFBAACDgUSA1sOEwoMCgUEAAIOARID +WxQiCgwKBQQAAg4DEgNbKCoKDAoEBAACDxIEXQJfAwoMCgUEAAIPBBIDXQIK +CgwKBQQAAg8FEgNdCxAKDAoFBAACDwESA10RHgoMCgUEAAIPAxIDXSEjCgwK +BAQAAwESBF0CXwMKDAoFBAADAQESA10RHgoMCgUEAAIPBhIDXREeCg0KBgQA +AwECABIDXgQaCg4KBwQAAwECAAQSA14EDAoOCgcEAAMBAgAFEgNeDRIKDgoH +BAADAQIAARIDXhMUCg4KBwQAAwECAAMSA14XGQoLCgQEAAIQEgNhAk4KDAoF +BAACEAQSA2ECCgoMCgUEAAIQBhIDYQsYCgwKBQQAAhABEgNhMEcKDAoFBAAC +EAMSA2FLTQoLCgQEAAIREgNiAk4KDAoFBAACEQQSA2ICCgoMCgUEAAIRBhID +YgsZCgwKBQQAAhEBEgNiMEgKDAoFBAACEQMSA2JLTQoLCgQEAAISEgNjAlAK +DAoFBAACEgQSA2MCCgoMCgUEAAISBhIDYwsxCgwKBQQAAhIBEgNjMkkKDAoF +BAACEgMSA2NNTwoLCgQEAAITEgNlAk4KDAoFBAACEwQSA2UCCgoMCgUEAAIT +BhIDZQsVCgwKBQQAAhMBEgNlMEQKDAoFBAACEwMSA2VLTQoLCgQEAAIUEgNm +Ak4KDAoFBAACFAQSA2YCCgoMCgUEAAIUBhIDZgsWCgwKBQQAAhQBEgNmMEUK +DAoFBAACFAMSA2ZLTQoLCgQEAAIVEgNnAlAKDAoFBAACFQQSA2cCCgoMCgUE +AAIVBhIDZwsuCgwKBQQAAhUBEgNnMkYKDAoFBAACFQMSA2dNTwoLCgQEAAIW +EgNpAkIKDAoFBAACFgQSA2kCCgoMCgUEAAIWBRIDaQsRCgwKBQQAAhYBEgNp +EicKDAoFBAACFgMSA2kqLAoMCgUEAAIWCBIDaS1BCg0KBgQAAhYIARIDaS5A +CgsKBAQAAhcSA2oCMgoMCgUEAAIXBBIDagIKCgwKBQQAAhcFEgNqCxEKDAoF +BAACFwESA2oSHwoMCgUEAAIXAxIDaiIkCgwKBQQAAhcIEgNqJTEKDQoGBAAC +FwgBEgNqJjAKNwoEBAACGBIEbQJuKhopIERlZmluZWQgaW4gdW5pdHRlc3Rf +aW1wb3J0X3B1YmxpYy5wcm90bwoKDAoFBAACGAQSA20CCgoMCgUEAAIYBhID +bQs3CgwKBQQAAhgBEgNuBiQKDAoFBAACGAMSA24nKQoLCgQEAAIZEgNwAkAK +DAoFBAACGQQSA3ACCgoMCgUEAAIZBhIDcAsYCgwKBQQAAhkBEgNwGS4KDAoF +BAACGQMSA3AxMwoMCgUEAAIZCBIDcDQ/Cg0KBgQAAhkIBRIDcDU+ChcKBAQA +AhoSA3MCKxoKIFJlcGVhdGVkCgoMCgUEAAIaBBIDcwIKCgwKBQQAAhoFEgNz +DhMKDAoFBAACGgESA3MUIgoMCgUEAAIaAxIDcygqCgsKBAQAAhsSA3QCKwoM +CgUEAAIbBBIDdAIKCgwKBQQAAhsFEgN0DhMKDAoFBAACGwESA3QUIgoMCgUE +AAIbAxIDdCgqCgsKBAQAAhwSA3UCKwoMCgUEAAIcBBIDdQIKCgwKBQQAAhwF +EgN1DRMKDAoFBAACHAESA3UUIwoMCgUEAAIcAxIDdSgqCgsKBAQAAh0SA3YC +KwoMCgUEAAIdBBIDdgIKCgwKBQQAAh0FEgN2DRMKDAoFBAACHQESA3YUIwoM +CgUEAAIdAxIDdigqCgsKBAQAAh4SA3cCKwoMCgUEAAIeBBIDdwIKCgwKBQQA +Ah4FEgN3DRMKDAoFBAACHgESA3cUIwoMCgUEAAIeAxIDdygqCgsKBAQAAh8S +A3gCKwoMCgUEAAIfBBIDeAIKCgwKBQQAAh8FEgN4DRMKDAoFBAACHwESA3gU +IwoMCgUEAAIfAxIDeCgqCgsKBAQAAiASA3kCKwoMCgUEAAIgBBIDeQIKCgwK +BQQAAiAFEgN5DBMKDAoFBAACIAESA3kUJAoMCgUEAAIgAxIDeSgqCgsKBAQA +AiESA3oCKwoMCgUEAAIhBBIDegIKCgwKBQQAAiEFEgN6DBMKDAoFBAACIQES +A3oUJAoMCgUEAAIhAxIDeigqCgsKBAQAAiISA3sCKwoMCgUEAAIiBBIDewIK +CgwKBQQAAiIFEgN7CxMKDAoFBAACIgESA3sUJQoMCgUEAAIiAxIDeygqCgsK +BAQAAiMSA3wCKwoMCgUEAAIjBBIDfAIKCgwKBQQAAiMFEgN8CxMKDAoFBAAC +IwESA3wUJQoMCgUEAAIjAxIDfCgqCgsKBAQAAiQSA30CKwoMCgUEAAIkBBID +fQIKCgwKBQQAAiQFEgN9DhMKDAoFBAACJAESA30UIgoMCgUEAAIkAxIDfSgq +CgsKBAQAAiUSA34CKwoMCgUEAAIlBBIDfgIKCgwKBQQAAiUFEgN+DRMKDAoF +BAACJQESA34UIwoMCgUEAAIlAxIDfigqCgsKBAQAAiYSA38CKwoMCgUEAAIm +BBIDfwIKCgwKBQQAAiYFEgN/DxMKDAoFBAACJgESA38UIQoMCgUEAAImAxID +fygqCgwKBAQAAicSBIABAisKDQoFBAACJwQSBIABAgoKDQoFBAACJwUSBIAB +DRMKDQoFBAACJwESBIABFCMKDQoFBAACJwMSBIABKCoKDAoEBAACKBIEgQEC +KwoNCgUEAAIoBBIEgQECCgoNCgUEAAIoBRIEgQEOEwoNCgUEAAIoARIEgQEU +IgoNCgUEAAIoAxIEgQEoKgoOCgQEAAIpEgaDAQKFAQMKDQoFBAACKQQSBIMB +AgoKDQoFBAACKQUSBIMBCxAKDQoFBAACKQESBIMBER4KDQoFBAACKQMSBIMB +ISMKDgoEBAADAhIGgwEChQEDCg0KBQQAAwIBEgSDAREeCg0KBQQAAikGEgSD +AREeCg4KBgQAAwICABIEhAEEGgoPCgcEAAMCAgAEEgSEAQQMCg8KBwQAAwIC +AAUSBIQBDRIKDwoHBAADAgIAARIEhAETFAoPCgcEAAMCAgADEgSEARcZCgwK +BAQAAioSBIcBAk4KDQoFBAACKgQSBIcBAgoKDQoFBAACKgYSBIcBCxgKDQoF +BAACKgESBIcBMEcKDQoFBAACKgMSBIcBS00KDAoEBAACKxIEiAECTgoNCgUE +AAIrBBIEiAECCgoNCgUEAAIrBhIEiAELGQoNCgUEAAIrARIEiAEwSAoNCgUE +AAIrAxIEiAFLTQoMCgQEAAIsEgSJAQJQCg0KBQQAAiwEEgSJAQIKCg0KBQQA +AiwGEgSJAQsxCg0KBQQAAiwBEgSJATJJCg0KBQQAAiwDEgSJAU1PCgwKBAQA +Ai0SBIsBAk4KDQoFBAACLQQSBIsBAgoKDQoFBAACLQYSBIsBCxUKDQoFBAAC +LQESBIsBMEQKDQoFBAACLQMSBIsBS00KDAoEBAACLhIEjAECTgoNCgUEAAIu +BBIEjAECCgoNCgUEAAIuBhIEjAELFgoNCgUEAAIuARIEjAEwRQoNCgUEAAIu +AxIEjAFLTQoMCgQEAAIvEgSNAQJQCg0KBQQAAi8EEgSNAQIKCg0KBQQAAi8G +EgSNAQsuCg0KBQQAAi8BEgSNATJGCg0KBQQAAi8DEgSNAU1PCgwKBAQAAjAS +BI8BAkIKDQoFBAACMAQSBI8BAgoKDQoFBAACMAUSBI8BCxEKDQoFBAACMAES +BI8BEicKDQoFBAACMAMSBI8BKiwKDQoFBAACMAgSBI8BLUEKDgoGBAACMAgB +EgSPAS5ACgwKBAQAAjESBJABAjIKDQoFBAACMQQSBJABAgoKDQoFBAACMQUS +BJABCxEKDQoFBAACMQESBJABEh8KDQoFBAACMQMSBJABIiQKDQoFBAACMQgS +BJABJTEKDgoGBAACMQgBEgSQASYwCgwKBAQAAjISBJIBAkAKDQoFBAACMgQS +BJIBAgoKDQoFBAACMgYSBJIBCxgKDQoFBAACMgESBJIBGS4KDQoFBAACMgMS +BJIBMTMKDQoFBAACMggSBJIBND8KDgoGBAACMggFEgSSATU+CiYKBAQAAjMS +BJUBAj4aGCBTaW5ndWxhciB3aXRoIGRlZmF1bHRzCgoNCgUEAAIzBBIElQEC +CgoNCgUEAAIzBRIElQEOEwoNCgUEAAIzARIElQEUIQoNCgUEAAIzAxIElQEn +KQoNCgUEAAIzCBIElQEqPQoNCgUEAAIzBxIElQE2OAoMCgQEAAI0EgSWAQI+ +Cg0KBQQAAjQEEgSWAQIKCg0KBQQAAjQFEgSWAQ4TCg0KBQQAAjQBEgSWARQh +Cg0KBQQAAjQDEgSWAScpCg0KBQQAAjQIEgSWASo9Cg0KBQQAAjQHEgSWATY4 +CgwKBAQAAjUSBJcBAj4KDQoFBAACNQQSBJcBAgoKDQoFBAACNQUSBJcBDRMK +DQoFBAACNQESBJcBFCIKDQoFBAACNQMSBJcBJykKDQoFBAACNQgSBJcBKj0K +DQoFBAACNQcSBJcBNjgKDAoEBAACNhIEmAECPgoNCgUEAAI2BBIEmAECCgoN +CgUEAAI2BRIEmAENEwoNCgUEAAI2ARIEmAEUIgoNCgUEAAI2AxIEmAEnKQoN +CgUEAAI2CBIEmAEqPQoNCgUEAAI2BxIEmAE2OAoMCgQEAAI3EgSZAQI+Cg0K +BQQAAjcEEgSZAQIKCg0KBQQAAjcFEgSZAQ0TCg0KBQQAAjcBEgSZARQiCg0K +BQQAAjcDEgSZAScpCg0KBQQAAjcIEgSZASo9Cg0KBQQAAjcHEgSZATU4CgwK +BAQAAjgSBJoBAj4KDQoFBAACOAQSBJoBAgoKDQoFBAACOAUSBJoBDRMKDQoF +BAACOAESBJoBFCIKDQoFBAACOAMSBJoBJykKDQoFBAACOAgSBJoBKj0KDQoF +BAACOAcSBJoBNjgKDAoEBAACORIEmwECPgoNCgUEAAI5BBIEmwECCgoNCgUE +AAI5BRIEmwEMEwoNCgUEAAI5ARIEmwEUIwoNCgUEAAI5AxIEmwEnKQoNCgUE +AAI5CBIEmwEqPQoNCgUEAAI5BxIEmwE2OAoMCgQEAAI6EgScAQI+Cg0KBQQA +AjoEEgScAQIKCg0KBQQAAjoFEgScAQwTCg0KBQQAAjoBEgScARQjCg0KBQQA +AjoDEgScAScpCg0KBQQAAjoIEgScASo9Cg0KBQQAAjoHEgScATY4CgwKBAQA +AjsSBJ0BAj4KDQoFBAACOwQSBJ0BAgoKDQoFBAACOwUSBJ0BCxMKDQoFBAAC +OwESBJ0BFCQKDQoFBAACOwMSBJ0BJykKDQoFBAACOwgSBJ0BKj0KDQoFBAAC +OwcSBJ0BNjgKDAoEBAACPBIEngECPgoNCgUEAAI8BBIEngECCgoNCgUEAAI8 +BRIEngELEwoNCgUEAAI8ARIEngEUJAoNCgUEAAI8AxIEngEnKQoNCgUEAAI8 +CBIEngEqPQoNCgUEAAI8BxIEngE1OAoMCgQEAAI9EgSfAQI+Cg0KBQQAAj0E +EgSfAQIKCg0KBQQAAj0FEgSfAQ4TCg0KBQQAAj0BEgSfARQhCg0KBQQAAj0D +EgSfAScpCg0KBQQAAj0IEgSfASo9Cg0KBQQAAj0HEgSfATY6CgwKBAQAAj4S +BKABAj4KDQoFBAACPgQSBKABAgoKDQoFBAACPgUSBKABDRMKDQoFBAACPgES +BKABFCIKDQoFBAACPgMSBKABJykKDQoFBAACPggSBKABKj0KDQoFBAACPgcS +BKABNjoKDAoEBAACPxIEoQECPgoNCgUEAAI/BBIEoQECCgoNCgUEAAI/BRIE +oQEPEwoNCgUEAAI/ARIEoQEUIAoNCgUEAAI/AxIEoQEnKQoNCgUEAAI/CBIE +oQEqPQoNCgUEAAI/BxIEoQE1OQoMCgQEAAJAEgSiAQI+Cg0KBQQAAkAEEgSi +AQIKCg0KBQQAAkAFEgSiAQ0TCg0KBQQAAkABEgSiARQiCg0KBQQAAkADEgSi +AScpCg0KBQQAAkAIEgSiASo9Cg0KBQQAAkAHEgSiATU8CgwKBAQAAkESBKMB +Aj4KDQoFBAACQQQSBKMBAgoKDQoFBAACQQUSBKMBDhMKDQoFBAACQQESBKMB +FCEKDQoFBAACQQMSBKMBJykKDQoFBAACQQgSBKMBKj0KDQoFBAACQQcSBKMB +NTwKDAoEBAACQhIEpQECSQoNCgUEAAJCBBIEpQECCgoNCgUEAAJCBhIEpQEL +FQoNCgUEAAJCARIEpQEXKgoNCgUEAAJCAxIEpQEuMAoNCgUEAAJCCBIEpQEx +SAoNCgUEAAJCBxIEpQE8PwoMCgQEAAJDEgSmAQJJCg0KBQQAAkMEEgSmAQIK +Cg0KBQQAAkMGEgSmAQsWCg0KBQQAAkMBEgSmARcrCg0KBQQAAkMDEgSmAS4w +Cg0KBQQAAkMIEgSmATFICg0KBQQAAkMHEgSmATxHCg4KBAQAAkQSBqcBAqgB +NgoNCgUEAAJEBBIEpwECCgoNCgUEAAJEBhIEpwELLgoNCgUEAAJEARIEqAEG +GQoNCgUEAAJEAxIEqAEcHgoNCgUEAAJECBIEqAEfNQoNCgUEAAJEBxIEqAEq +NAoMCgQEAAJFEgSqAQJPCg0KBQQAAkUEEgSqAQIKCg0KBQQAAkUFEgSqAQsR +Cg0KBQQAAkUBEgSqARImCg0KBQQAAkUDEgSqASkrCg0KBQQAAkUIEgSqASxO +Cg4KBgQAAkUIARIEqgEtPwoNCgUEAAJFBxIEqgFITQoMCgQEAAJGEgSrAQI/ +Cg0KBQQAAkYEEgSrAQIKCg0KBQQAAkYFEgSrAQsRCg0KBQQAAkYBEgSrARIe +Cg0KBQQAAkYDEgSrASEjCg0KBQQAAkYIEgSrASQ+Cg4KBgQAAkYIARIEqwEl +LwoNCgUEAAJGBxIEqwE4PQogCgQEAAgAEgauAQKzAQMaECBGb3Igb25lb2Yg +dGVzdAoKDQoFBAAIAAESBK4BCBMKDAoEBAACRxIErwEEHgoNCgUEAAJHBRIE +rwEECgoNCgUEAAJHARIErwELFwoNCgUEAAJHAxIErwEaHQoMCgQEAAJIEgSw +AQQtCg0KBQQAAkgGEgSwAQQRCg0KBQQAAkgBEgSwARImCg0KBQQAAkgDEgSw +ASksCgwKBAQAAkkSBLEBBB4KDQoFBAACSQUSBLEBBAoKDQoFBAACSQESBLEB +CxcKDQoFBAACSQMSBLEBGh0KDAoEBAACShIEsgEEHAoNCgUEAAJKBRIEsgEE +CQoNCgUEAAJKARIEsgEKFQoNCgUEAAJKAxIEsgEYGwpACgIEARIGtwEAuwEB +GjIgVGhpcyBwcm90byBpbmNsdWRlcyBhIHJlY3VzaXZlbHkgbmVzdGVkIG1l +c3NhZ2UuCgoLCgMEAQESBLcBCBoKDAoEBAECABIEuAECKAoNCgUEAQIABBIE +uAECCgoNCgUEAQIABhIEuAELHQoNCgUEAQIAARIEuAEeIwoNCgUEAQIAAxIE +uAEmJwoMCgQEAQIBEgS5AQIkCg0KBQQBAgEEEgS5AQIKCg0KBQQBAgEGEgS5 +AQsXCg0KBQQBAgEBEgS5ARgfCg0KBQQBAgEDEgS5ASIjCgwKBAQBAgISBLoB +AjEKDQoFBAECAgQSBLoBAgoKDQoFBAECAgYSBLoBCx0KDQoFBAECAgESBLoB +HiwKDQoFBAECAgMSBLoBLzAKDAoCBAISBr0BAL8BAQoLCgMEAgESBL0BCBwK +DAoEBAICABIEvgECOAoNCgUEAgIABBIEvgECCgoNCgUEAgIABRIEvgELEAoN +CgUEAgIAARIEvgERIQoNCgUEAgIAAxIEvgEkJQoNCgUEAgIACBIEvgEmNwoO +CgYEAgIACAMSBL4BJzYKWwoCBAMSBsMBAMUBARpNIERlZmluZSB0aGVzZSBh +ZnRlciBUZXN0QWxsVHlwZXMgdG8gbWFrZSBzdXJlIHRoZSBjb21waWxlciBj +YW4gaGFuZGxlCiB0aGF0LgoKCwoDBAMBEgTDAQgWCgwKBAQDAgASBMQBAhcK +DQoFBAMCAAQSBMQBAgoKDQoFBAMCAAUSBMQBCxAKDQoFBAMCAAESBMQBERIK +DQoFBAMCAAMSBMQBFRYKDAoCBQASBscBAMsBAQoLCgMFAAESBMcBBRAKDAoE +BQACABIEyAECEgoNCgUFAAIAARIEyAECDQoNCgUFAAIAAhIEyAEQEQoMCgQF +AAIBEgTJAQISCg0KBQUAAgEBEgTJAQINCg0KBQUAAgECEgTJARARCgwKBAUA +AgISBMoBAhIKDQoFBQACAgESBMoBAg0KDQoFBQACAgISBMoBEBEKDAoCBAQS +Bs0BANABAQoLCgMEBAESBM0BCBoKCwoDBAQJEgTOAQIaCgwKBAQECQASBM4B +CwwKDQoFBAQJAAESBM4BCwwKDQoFBAQJAAISBM4BCwwKDAoEBAQJARIEzgEO +EAoNCgUEBAkBARIEzgEOEAoNCgUEBAkBAhIEzgEOEAoMCgQEBAkCEgTOARIZ +Cg0KBQQECQIBEgTOARITCg0KBQQECQICEgTOARcZCgsKAwQEChIEzwECGAoM +CgQEBAoAEgTPAQsQCgwKBAQECgESBM8BEhcKDAoCBAUSBtIBANQBAQoLCgME +BQESBNIBCBkKCwoDBAUFEgTTAQIWCgwKBAQFBQASBNMBDRUKDQoFBAUFAAES +BNMBDQ4KDQoFBAUFAAISBNMBEhUKCwoBBxIG1gEAxQIBChYKAgcAEgTYAQI1 +GgogU2luZ3VsYXIKCgsKAwcAAhIE1gEHGAoLCgMHAAQSBNgBAgoKCwoDBwAF +EgTYAQ4TCgsKAwcAARIE2AEULAoLCgMHAAMSBNgBMzQKCgoCBwESBNkBAjUK +CwoDBwECEgTWAQcYCgsKAwcBBBIE2QECCgoLCgMHAQUSBNkBDhMKCwoDBwEB +EgTZARQsCgsKAwcBAxIE2QEzNAoKCgIHAhIE2gECNQoLCgMHAgISBNYBBxgK +CwoDBwIEEgTaAQIKCgsKAwcCBRIE2gENEwoLCgMHAgESBNoBFC0KCwoDBwID +EgTaATM0CgoKAgcDEgTbAQI1CgsKAwcDAhIE1gEHGAoLCgMHAwQSBNsBAgoK +CwoDBwMFEgTbAQ0TCgsKAwcDARIE2wEULQoLCgMHAwMSBNsBMzQKCgoCBwQS +BNwBAjUKCwoDBwQCEgTWAQcYCgsKAwcEBBIE3AECCgoLCgMHBAUSBNwBDRMK +CwoDBwQBEgTcARQtCgsKAwcEAxIE3AEzNAoKCgIHBRIE3QECNQoLCgMHBQIS +BNYBBxgKCwoDBwUEEgTdAQIKCgsKAwcFBRIE3QENEwoLCgMHBQESBN0BFC0K +CwoDBwUDEgTdATM0CgoKAgcGEgTeAQI1CgsKAwcGAhIE1gEHGAoLCgMHBgQS +BN4BAgoKCwoDBwYFEgTeAQwTCgsKAwcGARIE3gEULgoLCgMHBgMSBN4BMzQK +CgoCBwcSBN8BAjUKCwoDBwcCEgTWAQcYCgsKAwcHBBIE3wECCgoLCgMHBwUS +BN8BDBMKCwoDBwcBEgTfARQuCgsKAwcHAxIE3wEzNAoKCgIHCBIE4AECNQoL +CgMHCAISBNYBBxgKCwoDBwgEEgTgAQIKCgsKAwcIBRIE4AELEwoLCgMHCAES +BOABFC8KCwoDBwgDEgTgATM0CgoKAgcJEgThAQI1CgsKAwcJAhIE1gEHGAoL +CgMHCQQSBOEBAgoKCwoDBwkFEgThAQsTCgsKAwcJARIE4QEULwoLCgMHCQMS +BOEBMjQKCgoCBwoSBOIBAjUKCwoDBwoCEgTWAQcYCgsKAwcKBBIE4gECCgoL +CgMHCgUSBOIBDhMKCwoDBwoBEgTiARQsCgsKAwcKAxIE4gEyNAoKCgIHCxIE +4wECNQoLCgMHCwISBNYBBxgKCwoDBwsEEgTjAQIKCgsKAwcLBRIE4wENEwoL +CgMHCwESBOMBFC0KCwoDBwsDEgTjATI0CgoKAgcMEgTkAQI1CgsKAwcMAhIE +1gEHGAoLCgMHDAQSBOQBAgoKCwoDBwwFEgTkAQ8TCgsKAwcMARIE5AEUKwoL +CgMHDAMSBOQBMjQKCgoCBw0SBOUBAjUKCwoDBw0CEgTWAQcYCgsKAwcNBBIE +5QECCgoLCgMHDQUSBOUBDRMKCwoDBw0BEgTlARQtCgsKAwcNAxIE5QEyNAoK +CgIHDhIE5gECNQoLCgMHDgISBNYBBxgKCwoDBw4EEgTmAQIKCgsKAwcOBRIE +5gEOEwoLCgMHDgESBOYBFCwKCwoDBw4DEgTmATI0CgwKAgcPEgboAQLqAQMK +CwoDBw8CEgTWAQcYCgsKAwcPBBIE6AECCgoLCgMHDwUSBOgBCxAKCwoDBw8B +EgToAREoCgsKAwcPAxIE6AErLQoMCgIEBhIG6AEC6gEDCgsKAwQGARIE6AER +KAoLCgMHDwYSBOgBESgKDAoEBAYCABIE6QEEGgoNCgUEBgIABBIE6QEEDAoN +CgUEBgIABRIE6QENEgoNCgUEBgIAARIE6QETFAoNCgUEBgIAAxIE6QEXGQoK +CgIHEBIE7AECTQoLCgMHEAISBNYBBxgKCwoDBxAEEgTsAQIKCgsKAwcQBhIE +7AELJQoLCgMHEAESBOwBJkcKCwoDBxADEgTsAUpMCgoKAgcREgTtAQJCCgsK +AwcRAhIE1gEHGAoLCgMHEQQSBO0BAgoKCwoDBxEGEgTtAQsZCgsKAwcRARIE +7QEaPAoLCgMHEQMSBO0BP0EKDAoCBxISBu4BAu8BKwoLCgMHEgISBNYBBxgK +CwoDBxIEEgTuAQIKCgsKAwcSBhIE7gELMQoLCgMHEgESBO8BBCUKCwoDBxID +EgTvASgqCgoKAgcTEgTxAQJHCgsKAwcTAhIE1gEHGAoLCgMHEwQSBPEBAgoK +CwoDBxMGEgTxAQsiCgsKAwcTARIE8QEjQQoLCgMHEwMSBPEBREYKCgoCBxQS +BPIBAjwKCwoDBxQCEgTWAQcYCgsKAwcUBBIE8gECCgoLCgMHFAYSBPIBCxYK +CwoDBxQBEgTyARc2CgsKAwcUAxIE8gE5OwoMCgIHFRIG8wEC9AEoCgsKAwcV +AhIE1gEHGAoLCgMHFQQSBPMBAgoKCwoDBxUGEgTzAQsuCgsKAwcVARIE9AEE +IgoLCgMHFQMSBPQBJScKCgoCBxYSBPYBAkwKCwoDBxYCEgTWAQcYCgsKAwcW +BBIE9gECCgoLCgMHFgUSBPYBCxEKCwoDBxYBEgT2ARIxCgsKAwcWAxIE9gE0 +NgoLCgMHFggSBPYBN0sKDAoEBxYIARIE9gE4SgoKCgIHFxIE9wECPAoLCgMH +FwISBNYBBxgKCwoDBxcEEgT3AQIKCgsKAwcXBRIE9wELEQoLCgMHFwESBPcB +EikKCwoDBxcDEgT3ASwuCgsKAwcXCBIE9wEvOwoMCgQHFwgBEgT3ATA6CgwK +AgcYEgb5AQL6ATIKCwoDBxgCEgTWAQcYCgsKAwcYBBIE+QECCgoLCgMHGAYS +BPkBCzcKCwoDBxgBEgT6AQQsCgsKAwcYAxIE+gEvMQoMCgIHGRIG/AEC/QE1 +CgsKAwcZAhIE1gEHGAoLCgMHGQQSBPwBAgoKCwoDBxkGEgT8AQslCgsKAwcZ +ARIE/QEEIwoLCgMHGQMSBP0BJigKCwoDBxkIEgT9ASk0CgwKBAcZCAUSBP0B +KjMKFgoCBxoSBIACAjUaCiBSZXBlYXRlZAoKCwoDBxoCEgTWAQcYCgsKAwca +BBIEgAICCgoLCgMHGgUSBIACDhMKCwoDBxoBEgSAAhQsCgsKAwcaAxIEgAIy +NAoKCgIHGxIEgQICNQoLCgMHGwISBNYBBxgKCwoDBxsEEgSBAgIKCgsKAwcb +BRIEgQIOEwoLCgMHGwESBIECFCwKCwoDBxsDEgSBAjI0CgoKAgccEgSCAgI1 +CgsKAwccAhIE1gEHGAoLCgMHHAQSBIICAgoKCwoDBxwFEgSCAg0TCgsKAwcc +ARIEggIULQoLCgMHHAMSBIICMjQKCgoCBx0SBIMCAjUKCwoDBx0CEgTWAQcY +CgsKAwcdBBIEgwICCgoLCgMHHQUSBIMCDRMKCwoDBx0BEgSDAhQtCgsKAwcd +AxIEgwIyNAoKCgIHHhIEhAICNQoLCgMHHgISBNYBBxgKCwoDBx4EEgSEAgIK +CgsKAwceBRIEhAINEwoLCgMHHgESBIQCFC0KCwoDBx4DEgSEAjI0CgoKAgcf +EgSFAgI1CgsKAwcfAhIE1gEHGAoLCgMHHwQSBIUCAgoKCwoDBx8FEgSFAg0T +CgsKAwcfARIEhQIULQoLCgMHHwMSBIUCMjQKCgoCByASBIYCAjUKCwoDByAC +EgTWAQcYCgsKAwcgBBIEhgICCgoLCgMHIAUSBIYCDBMKCwoDByABEgSGAhQu +CgsKAwcgAxIEhgIyNAoKCgIHIRIEhwICNQoLCgMHIQISBNYBBxgKCwoDByEE +EgSHAgIKCgsKAwchBRIEhwIMEwoLCgMHIQESBIcCFC4KCwoDByEDEgSHAjI0 +CgoKAgciEgSIAgI1CgsKAwciAhIE1gEHGAoLCgMHIgQSBIgCAgoKCwoDByIF +EgSIAgsTCgsKAwciARIEiAIULwoLCgMHIgMSBIgCMjQKCgoCByMSBIkCAjUK +CwoDByMCEgTWAQcYCgsKAwcjBBIEiQICCgoLCgMHIwUSBIkCCxMKCwoDByMB +EgSJAhQvCgsKAwcjAxIEiQIyNAoKCgIHJBIEigICNQoLCgMHJAISBNYBBxgK +CwoDByQEEgSKAgIKCgsKAwckBRIEigIOEwoLCgMHJAESBIoCFCwKCwoDByQD +EgSKAjI0CgoKAgclEgSLAgI1CgsKAwclAhIE1gEHGAoLCgMHJQQSBIsCAgoK +CwoDByUFEgSLAg0TCgsKAwclARIEiwIULQoLCgMHJQMSBIsCMjQKCgoCByYS +BIwCAjUKCwoDByYCEgTWAQcYCgsKAwcmBBIEjAICCgoLCgMHJgUSBIwCDxMK +CwoDByYBEgSMAhQrCgsKAwcmAxIEjAIyNAoKCgIHJxIEjQICNQoLCgMHJwIS +BNYBBxgKCwoDBycEEgSNAgIKCgsKAwcnBRIEjQINEwoLCgMHJwESBI0CFC0K +CwoDBycDEgSNAjI0CgoKAgcoEgSOAgI1CgsKAwcoAhIE1gEHGAoLCgMHKAQS +BI4CAgoKCwoDBygFEgSOAg4TCgsKAwcoARIEjgIULAoLCgMHKAMSBI4CMjQK +DAoCBykSBpACApICAwoLCgMHKQISBNYBBxgKCwoDBykEEgSQAgIKCgsKAwcp +BRIEkAILEAoLCgMHKQESBJACESgKCwoDBykDEgSQAistCgwKAgQHEgaQAgKS +AgMKCwoDBAcBEgSQAhEoCgsKAwcpBhIEkAIRKAoMCgQEBwIAEgSRAgQaCg0K +BQQHAgAEEgSRAgQMCg0KBQQHAgAFEgSRAg0SCg0KBQQHAgABEgSRAhMUCg0K +BQQHAgADEgSRAhcZCgoKAgcqEgSUAgJNCgsKAwcqAhIE1gEHGAoLCgMHKgQS +BJQCAgoKCwoDByoGEgSUAgslCgsKAwcqARIElAImRwoLCgMHKgMSBJQCSkwK +CgoCBysSBJUCAkIKCwoDBysCEgTWAQcYCgsKAwcrBBIElQICCgoLCgMHKwYS +BJUCCxkKCwoDBysBEgSVAho8CgsKAwcrAxIElQI/QQoMCgIHLBIGlgIClwIr +CgsKAwcsAhIE1gEHGAoLCgMHLAQSBJYCAgoKCwoDBywGEgSWAgsxCgsKAwcs +ARIElwIEJQoLCgMHLAMSBJcCKCoKCgoCBy0SBJkCAkcKCwoDBy0CEgTWAQcY +CgsKAwctBBIEmQICCgoLCgMHLQYSBJkCCyIKCwoDBy0BEgSZAiNBCgsKAwct +AxIEmQJERgoKCgIHLhIEmgICPAoLCgMHLgISBNYBBxgKCwoDBy4EEgSaAgIK +CgsKAwcuBhIEmgILFgoLCgMHLgESBJoCFzYKCwoDBy4DEgSaAjk7CgwKAgcv +EgabAgKcAigKCwoDBy8CEgTWAQcYCgsKAwcvBBIEmwICCgoLCgMHLwYSBJsC +Cy4KCwoDBy8BEgScAgQiCgsKAwcvAxIEnAIlJwoKCgIHMBIEngICTAoLCgMH +MAISBNYBBxgKCwoDBzAEEgSeAgIKCgsKAwcwBRIEngILEQoLCgMHMAESBJ4C +EjEKCwoDBzADEgSeAjQ2CgsKAwcwCBIEngI3SwoMCgQHMAgBEgSeAjhKCgoK +AgcxEgSfAgI8CgsKAwcxAhIE1gEHGAoLCgMHMQQSBJ8CAgoKCwoDBzEFEgSf +AgsRCgsKAwcxARIEnwISKQoLCgMHMQMSBJ8CLC4KCwoDBzEIEgSfAi87CgwK +BAcxCAESBJ8CMDoKDAoCBzISBqECAqICNQoLCgMHMgISBNYBBxgKCwoDBzIE +EgShAgIKCgsKAwcyBhIEoQILJQoLCgMHMgESBKICBCMKCwoDBzIDEgSiAiYo +CgsKAwcyCBIEogIpNAoMCgQHMggFEgSiAiozCiQKAgczEgSlAgJIGhggU2lu +Z3VsYXIgd2l0aCBkZWZhdWx0cwoKCwoDBzMCEgTWAQcYCgsKAwczBBIEpQIC +CgoLCgMHMwUSBKUCDhMKCwoDBzMBEgSlAhQrCgsKAwczAxIEpQIxMwoLCgMH +MwgSBKUCNEcKCwoDBzMHEgSlAkBCCgoKAgc0EgSmAgJICgsKAwc0AhIE1gEH +GAoLCgMHNAQSBKYCAgoKCwoDBzQFEgSmAg4TCgsKAwc0ARIEpgIUKwoLCgMH +NAMSBKYCMTMKCwoDBzQIEgSmAjRHCgsKAwc0BxIEpgJAQgoKCgIHNRIEpwIC +SAoLCgMHNQISBNYBBxgKCwoDBzUEEgSnAgIKCgsKAwc1BRIEpwINEwoLCgMH +NQESBKcCFCwKCwoDBzUDEgSnAjEzCgsKAwc1CBIEpwI0RwoLCgMHNQcSBKcC +QEIKCgoCBzYSBKgCAkgKCwoDBzYCEgTWAQcYCgsKAwc2BBIEqAICCgoLCgMH +NgUSBKgCDRMKCwoDBzYBEgSoAhQsCgsKAwc2AxIEqAIxMwoLCgMHNggSBKgC +NEcKCwoDBzYHEgSoAkBCCgoKAgc3EgSpAgJICgsKAwc3AhIE1gEHGAoLCgMH +NwQSBKkCAgoKCwoDBzcFEgSpAg0TCgsKAwc3ARIEqQIULAoLCgMHNwMSBKkC +MTMKCwoDBzcIEgSpAjRHCgsKAwc3BxIEqQI/QgoKCgIHOBIEqgICSAoLCgMH +OAISBNYBBxgKCwoDBzgEEgSqAgIKCgsKAwc4BRIEqgINEwoLCgMHOAESBKoC +FCwKCwoDBzgDEgSqAjEzCgsKAwc4CBIEqgI0RwoLCgMHOAcSBKoCQEIKCgoC +BzkSBKsCAkgKCwoDBzkCEgTWAQcYCgsKAwc5BBIEqwICCgoLCgMHOQUSBKsC +DBMKCwoDBzkBEgSrAhQtCgsKAwc5AxIEqwIxMwoLCgMHOQgSBKsCNEcKCwoD +BzkHEgSrAkBCCgoKAgc6EgSsAgJICgsKAwc6AhIE1gEHGAoLCgMHOgQSBKwC +AgoKCwoDBzoFEgSsAgwTCgsKAwc6ARIErAIULQoLCgMHOgMSBKwCMTMKCwoD +BzoIEgSsAjRHCgsKAwc6BxIErAJAQgoKCgIHOxIErQICSAoLCgMHOwISBNYB +BxgKCwoDBzsEEgStAgIKCgsKAwc7BRIErQILEwoLCgMHOwESBK0CFC4KCwoD +BzsDEgStAjEzCgsKAwc7CBIErQI0RwoLCgMHOwcSBK0CQEIKCgoCBzwSBK4C +AkgKCwoDBzwCEgTWAQcYCgsKAwc8BBIErgICCgoLCgMHPAUSBK4CCxMKCwoD +BzwBEgSuAhQuCgsKAwc8AxIErgIxMwoLCgMHPAgSBK4CNEcKCwoDBzwHEgSu +Aj9CCgoKAgc9EgSvAgJICgsKAwc9AhIE1gEHGAoLCgMHPQQSBK8CAgoKCwoD +Bz0FEgSvAg4TCgsKAwc9ARIErwIUKwoLCgMHPQMSBK8CMTMKCwoDBz0IEgSv +AjRHCgsKAwc9BxIErwJARAoKCgIHPhIEsAICSAoLCgMHPgISBNYBBxgKCwoD +Bz4EEgSwAgIKCgsKAwc+BRIEsAINEwoLCgMHPgESBLACFCwKCwoDBz4DEgSw +AjEzCgsKAwc+CBIEsAI0RwoLCgMHPgcSBLACQEQKCgoCBz8SBLECAkgKCwoD +Bz8CEgTWAQcYCgsKAwc/BBIEsQICCgoLCgMHPwUSBLECDxMKCwoDBz8BEgSx +AhQqCgsKAwc/AxIEsQIxMwoLCgMHPwgSBLECNEcKCwoDBz8HEgSxAj9DCgoK +AgdAEgSyAgJICgsKAwdAAhIE1gEHGAoLCgMHQAQSBLICAgoKCwoDB0AFEgSy +Ag0TCgsKAwdAARIEsgIULAoLCgMHQAMSBLICMTMKCwoDB0AIEgSyAjRHCgsK +AwdABxIEsgI/RgoKCgIHQRIEswICSAoLCgMHQQISBNYBBxgKCwoDB0EEEgSz +AgIKCgsKAwdBBRIEswIOEwoLCgMHQQESBLMCFCsKCwoDB0EDEgSzAjEzCgsK +AwdBCBIEswI0RwoLCgMHQQcSBLMCP0YKDAoCB0ISBrUCArYCNwoLCgMHQgIS +BNYBBxgKCwoDB0IEEgS1AgIKCgsKAwdCBhIEtQILIgoLCgMHQgESBLYCBCEK +CwoDB0IDEgS2AiQmCgsKAwdCCBIEtgInNgoLCgMHQgcSBLYCMjUKDAoCB0MS +BrcCArgCQAoLCgMHQwISBNYBBxgKCwoDB0MEEgS3AgIKCgsKAwdDBhIEtwIL +FgoLCgMHQwESBLgCBCIKCwoDB0MDEgS4AiUnCgsKAwdDCBIEuAIoPwoLCgMH +QwcSBLgCMz4KDAoCB0QSBrkCAroCPgoLCgMHRAISBNYBBxgKCwoDB0QEEgS5 +AgIKCgsKAwdEBhIEuQILLgoLCgMHRAESBLoCBCEKCwoDB0QDEgS6AiQmCgsK +AwdECBIEugInPQoLCgMHRAcSBLoCMjwKDAoCB0USBrwCAr0CRgoLCgMHRQIS +BNYBBxgKCwoDB0UEEgS8AgIKCgsKAwdFBRIEvAILEQoLCgMHRQESBLwCEjAK +CwoDB0UDEgS8AjM1Cg0KAwdFCBIGvAI2vQJFCgwKBAdFCAESBLwCN0kKCwoD +B0UHEgS9Aj9ECgoKAgdGEgS+AgJKCgsKAwdGAhIE1gEHGAoLCgMHRgQSBL4C +AgoKCwoDB0YFEgS+AgsRCgsKAwdGARIEvgISKAoLCgMHRgMSBL4CKy0KCwoD +B0YIEgS+Ai5JCgwKBAdGCAESBL4CLzkKCwoDB0YHEgS+AkNIChwKAgdHEgTB +AgIvGhAgRm9yIG9uZW9mIHRlc3QKCgsKAwdHAhIE1gEHGAoLCgMHRwQSBMEC +AgoKCwoDB0cFEgTBAgsRCgsKAwdHARIEwQISKAoLCgMHRwMSBMECKy4KCgoC +B0gSBMICAksKCwoDB0gCEgTWAQcYCgsKAwdIBBIEwgICCgoLCgMHSAYSBMIC +CyUKCwoDB0gBEgTCAiZECgsKAwdIAxIEwgJHSgoKCgIHSRIEwwICLwoLCgMH +SQISBNYBBxgKCwoDB0kEEgTDAgIKCgsKAwdJBRIEwwILEQoLCgMHSQESBMMC +EigKCwoDB0kDEgTDAisuCgoKAgdKEgTEAgItCgsKAwdKAhIE1gEHGAoLCgMH +SgQSBMQCAgoKCwoDB0oFEgTEAgsQCgsKAwdKARIExAIRJgoLCgMHSgMSBMQC +KSwKDAoCBAgSBscCANACAQoLCgMECAESBMcCCBsKDQoDBAgGEgbIAgLPAgMK +YAoEBAgGABIEywIEMRpSIENoZWNrIGZvciBidWcgd2hlcmUgc3RyaW5nIGV4 +dGVuc2lvbnMgZGVjbGFyZWQgaW4gdGVzdGVkIHNjb3BlIGRpZCBub3QKIGNv +bXBpbGUuCgoNCgUECAYAAhIEyAIJGgoNCgUECAYABBIEywIEDAoNCgUECAYA +BRIEywINEwoNCgUECAYAARIEywIUGAoNCgUECAYAAxIEywIbHwoNCgUECAYA +CBIEywIgMAoNCgUECAYABxIEywIpLwpgCgQECAYBEgTOAgQzGlIgVXNlZCB0 +byB0ZXN0IGlmIGdlbmVyYXRlZCBleHRlbnNpb24gbmFtZSBpcyBjb3JyZWN0 +IHdoZW4gdGhlcmUgYXJlCiB1bmRlcnNjb3Jlcy4KCg0KBQQIBgECEgTIAgka +Cg0KBQQIBgEEEgTOAgQMCg0KBQQIBgEFEgTOAg0TCg0KBQQIBgEBEgTOAhQr +Cg0KBQQIBgEDEgTOAi4yCgwKAgQJEgbSAgDXAgEKCwoDBAkBEgTSAggfCg0K +AwQJBhIG0wIC1gIDCk0KBAQJBgASBNUCBD0aPyBDaGVjayB0aGF0IGR1cGxp +Y2F0ZSBmaWVsZCBuYW1lcyBpbiBkaWZmZXJlbnQgbmFtZXNwYWNlcyB3b3Jr +CgoNCgUECQYAAhIE0wIJGgoNCgUECQYABBIE1QIEDAoNCgUECQYABRIE1QIN +EwoNCgUECQYAARIE1QIUGAoNCgUECQYAAxIE1QIbHwoNCgUECQYACBIE1QIg +PAoNCgUECQYABxIE1QIpOwrAAgoCBAoSBt4CAIkDARqxAiBXZSBoYXZlIHNl +cGFyYXRlIG1lc3NhZ2VzIGZvciB0ZXN0aW5nIHJlcXVpcmVkIGZpZWxkcyBi +ZWNhdXNlIGl0J3MKIGFubm95aW5nIHRvIGhhdmUgdG8gZmlsbCBpbiByZXF1 +aXJlZCBmaWVsZHMgaW4gVGVzdFByb3RvIGluIG9yZGVyIHRvCiBkbyBhbnl0 +aGluZyB3aXRoIGl0LiAgTm90ZSB0aGF0IHdlIGRvbid0IG5lZWQgdG8gdGVz +dCBldmVyeSB0eXBlIG9mCiByZXF1aXJlZCBmaWxlZCBiZWNhdXNlIHRoZSBj +b2RlIG91dHB1dCBpcyBiYXNpY2FsbHkgaWRlbnRpY2FsIHRvCiBvcHRpb25h +bCBmaWVsZHMgZm9yIGFsbCB0eXBlcy4KCgsKAwQKARIE3gIIFAoMCgQECgIA +EgTfAgIXCg0KBQQKAgAEEgTfAgIKCg0KBQQKAgAFEgTfAgsQCg0KBQQKAgAB +EgTfAhESCg0KBQQKAgADEgTfAhUWCgwKBAQKAgESBOACAhwKDQoFBAoCAQQS +BOACAgoKDQoFBAoCAQUSBOACCxAKDQoFBAoCAQESBOACERcKDQoFBAoCAQMS +BOACGhsKDAoEBAoCAhIE4QICFwoNCgUECgICBBIE4QICCgoNCgUECgICBRIE +4QILEAoNCgUECgICARIE4QIREgoNCgUECgICAxIE4QIVFgoNCgMECgYSBuMC +AuYCAwoMCgQECgYAEgTkAgQoCg0KBQQKBgACEgTjAgkaCg0KBQQKBgAEEgTk +AgQMCg0KBQQKBgAGEgTkAg0ZCg0KBQQKBgABEgTkAhogCg0KBQQKBgADEgTk +AiMnCgwKBAQKBgESBOUCBCgKDQoFBAoGAQISBOMCCRoKDQoFBAoGAQQSBOUC +BAwKDQoFBAoGAQYSBOUCDRkKDQoFBAoGAQESBOUCGh8KDQoFBAoGAQMSBOUC +IycKgwEKBAQKAgMSBOoCAh4adSBQYWQgdGhlIGZpZWxkIGNvdW50IHRvIDMy +IHNvIHRoYXQgd2UgY2FuIHRlc3QgdGhhdCBJc0luaXRpYWxpemVkKCkKIHBy +b3Blcmx5IGNoZWNrcyBtdWx0aXBsZSBlbGVtZW50cyBvZiBoYXNfYml0c18u +CgoNCgUECgIDBBIE6gICCgoNCgUECgIDBRIE6gILEAoNCgUECgIDARIE6gIR +FwoNCgUECgIDAxIE6gIcHQoMCgQECgIEEgTrAgIeCg0KBQQKAgQEEgTrAgIK +Cg0KBQQKAgQFEgTrAgsQCg0KBQQKAgQBEgTrAhEXCg0KBQQKAgQDEgTrAhwd +CgwKBAQKAgUSBOwCAh4KDQoFBAoCBQQSBOwCAgoKDQoFBAoCBQUSBOwCCxAK +DQoFBAoCBQESBOwCERcKDQoFBAoCBQMSBOwCHB0KDAoEBAoCBhIE7QICHgoN +CgUECgIGBBIE7QICCgoNCgUECgIGBRIE7QILEAoNCgUECgIGARIE7QIRFwoN +CgUECgIGAxIE7QIcHQoMCgQECgIHEgTuAgIeCg0KBQQKAgcEEgTuAgIKCg0K +BQQKAgcFEgTuAgsQCg0KBQQKAgcBEgTuAhEXCg0KBQQKAgcDEgTuAhwdCgwK +BAQKAggSBO8CAh4KDQoFBAoCCAQSBO8CAgoKDQoFBAoCCAUSBO8CCxAKDQoF +BAoCCAESBO8CERcKDQoFBAoCCAMSBO8CHB0KDAoEBAoCCRIE8AICHgoNCgUE +CgIJBBIE8AICCgoNCgUECgIJBRIE8AILEAoNCgUECgIJARIE8AIRGAoNCgUE +CgIJAxIE8AIbHQoMCgQECgIKEgTxAgIeCg0KBQQKAgoEEgTxAgIKCg0KBQQK +AgoFEgTxAgsQCg0KBQQKAgoBEgTxAhEYCg0KBQQKAgoDEgTxAhsdCgwKBAQK +AgsSBPICAh4KDQoFBAoCCwQSBPICAgoKDQoFBAoCCwUSBPICCxAKDQoFBAoC +CwESBPICERgKDQoFBAoCCwMSBPICGx0KDAoEBAoCDBIE8wICHgoNCgUECgIM +BBIE8wICCgoNCgUECgIMBRIE8wILEAoNCgUECgIMARIE8wIRGAoNCgUECgIM +AxIE8wIbHQoMCgQECgINEgT0AgIeCg0KBQQKAg0EEgT0AgIKCg0KBQQKAg0F +EgT0AgsQCg0KBQQKAg0BEgT0AhEYCg0KBQQKAg0DEgT0AhsdCgwKBAQKAg4S +BPUCAh4KDQoFBAoCDgQSBPUCAgoKDQoFBAoCDgUSBPUCCxAKDQoFBAoCDgES +BPUCERgKDQoFBAoCDgMSBPUCGx0KDAoEBAoCDxIE9gICHgoNCgUECgIPBBIE +9gICCgoNCgUECgIPBRIE9gILEAoNCgUECgIPARIE9gIRGAoNCgUECgIPAxIE +9gIbHQoMCgQECgIQEgT3AgIeCg0KBQQKAhAEEgT3AgIKCg0KBQQKAhAFEgT3 +AgsQCg0KBQQKAhABEgT3AhEYCg0KBQQKAhADEgT3AhsdCgwKBAQKAhESBPgC +Ah4KDQoFBAoCEQQSBPgCAgoKDQoFBAoCEQUSBPgCCxAKDQoFBAoCEQESBPgC +ERgKDQoFBAoCEQMSBPgCGx0KDAoEBAoCEhIE+QICHgoNCgUECgISBBIE+QIC +CgoNCgUECgISBRIE+QILEAoNCgUECgISARIE+QIRGAoNCgUECgISAxIE+QIb +HQoMCgQECgITEgT6AgIeCg0KBQQKAhMEEgT6AgIKCg0KBQQKAhMFEgT6AgsQ +Cg0KBQQKAhMBEgT6AhEYCg0KBQQKAhMDEgT6AhsdCgwKBAQKAhQSBPsCAh4K +DQoFBAoCFAQSBPsCAgoKDQoFBAoCFAUSBPsCCxAKDQoFBAoCFAESBPsCERgK +DQoFBAoCFAMSBPsCGx0KDAoEBAoCFRIE/AICHgoNCgUECgIVBBIE/AICCgoN +CgUECgIVBRIE/AILEAoNCgUECgIVARIE/AIRGAoNCgUECgIVAxIE/AIbHQoM +CgQECgIWEgT9AgIeCg0KBQQKAhYEEgT9AgIKCg0KBQQKAhYFEgT9AgsQCg0K +BQQKAhYBEgT9AhEYCg0KBQQKAhYDEgT9AhsdCgwKBAQKAhcSBP4CAh4KDQoF +BAoCFwQSBP4CAgoKDQoFBAoCFwUSBP4CCxAKDQoFBAoCFwESBP4CERgKDQoF +BAoCFwMSBP4CGx0KDAoEBAoCGBIE/wICHgoNCgUECgIYBBIE/wICCgoNCgUE +CgIYBRIE/wILEAoNCgUECgIYARIE/wIRGAoNCgUECgIYAxIE/wIbHQoMCgQE +CgIZEgSAAwIeCg0KBQQKAhkEEgSAAwIKCg0KBQQKAhkFEgSAAwsQCg0KBQQK +AhkBEgSAAxEYCg0KBQQKAhkDEgSAAxsdCgwKBAQKAhoSBIEDAh4KDQoFBAoC +GgQSBIEDAgoKDQoFBAoCGgUSBIEDCxAKDQoFBAoCGgESBIEDERgKDQoFBAoC +GgMSBIEDGx0KDAoEBAoCGxIEggMCHgoNCgUECgIbBBIEggMCCgoNCgUECgIb +BRIEggMLEAoNCgUECgIbARIEggMRGAoNCgUECgIbAxIEggMbHQoMCgQECgIc +EgSDAwIeCg0KBQQKAhwEEgSDAwIKCg0KBQQKAhwFEgSDAwsQCg0KBQQKAhwB +EgSDAxEYCg0KBQQKAhwDEgSDAxsdCgwKBAQKAh0SBIQDAh4KDQoFBAoCHQQS +BIQDAgoKDQoFBAoCHQUSBIQDCxAKDQoFBAoCHQESBIQDERgKDQoFBAoCHQMS +BIQDGx0KDAoEBAoCHhIEhQMCHgoNCgUECgIeBBIEhQMCCgoNCgUECgIeBRIE +hQMLEAoNCgUECgIeARIEhQMRGAoNCgUECgIeAxIEhQMbHQoMCgQECgIfEgSG +AwIeCg0KBQQKAh8EEgSGAwIKCg0KBQQKAh8FEgSGAwsQCg0KBQQKAh8BEgSG +AxEYCg0KBQQKAh8DEgSGAxsdCgwKBAQKAiASBIgDAhgKDQoFBAoCIAQSBIgD +AgoKDQoFBAoCIAUSBIgDCxAKDQoFBAoCIAESBIgDERIKDQoFBAoCIAMSBIgD +FRcKDAoCBAsSBosDAI8DAQoLCgMECwESBIsDCBsKDAoEBAsCABIEjAMCLQoN +CgUECwIABBIEjAMCCgoNCgUECwIABhIEjAMLFwoNCgUECwIAARIEjAMYKAoN +CgUECwIAAxIEjAMrLAoMCgQECwIBEgSNAwItCg0KBQQLAgEEEgSNAwIKCg0K +BQQLAgEGEgSNAwsXCg0KBQQLAgEBEgSNAxgoCg0KBQQLAgEDEgSNAyssCgwK +BAQLAgISBI4DAhsKDQoFBAsCAgQSBI4DAgoKDQoFBAsCAgUSBI4DCxAKDQoF +BAsCAgESBI4DERYKDQoFBAsCAgMSBI4DGRoKTQoCBAwSBpIDAJQDARo/IFRl +c3QgdGhhdCB3ZSBjYW4gdXNlIE5lc3RlZE1lc3NhZ2UgZnJvbSBvdXRzaWRl +IFRlc3RBbGxUeXBlcy4KCgsKAwQMARIEkgMIGQoMCgQEDAIAEgSTAwI5Cg0K +BQQMAgAEEgSTAwIKCg0KBQQMAgAGEgSTAwslCg0KBQQMAgABEgSTAyY0Cg0K +BQQMAgADEgSTAzc4CkcKAgQNEgaXAwCYAwEaOSBUZXN0RW1wdHlNZXNzYWdl +IGlzIHVzZWQgdG8gdGVzdCB1bmtub3duIGZpZWxkIHN1cHBvcnQuCgoLCgME +DQESBJcDCBgKkAEKAgQOEgacAwCeAwEagQEgTGlrZSBhYm92ZSwgYnV0IGRl +Y2xhcmUgYWxsIGZpZWxkIG51bWJlcnMgYXMgcG90ZW50aWFsIGV4dGVuc2lv +bnMuICBObwogYWN0dWFsIGV4dGVuc2lvbnMgc2hvdWxkIGV2ZXIgYmUgZGVm +aW5lZCBmb3IgdGhpcyB0eXBlLgoKCwoDBA4BEgScAwgmCgsKAwQOBRIEnQMC +FgoMCgQEDgUAEgSdAw0VCg0KBQQOBQABEgSdAw0OCg0KBQQOBQACEgSdAxIV +CgwKAgQPEgagAwCkAwEKCwoDBA8BEgSgAwgjCgsKAwQPBRIEoQMCEAoMCgQE +DwUAEgShAw0PCg0KBQQPBQABEgShAw0PCg0KBQQPBQACEgShAw0PCgsKAwQP +BRIEogMCGgoMCgQEDwUBEgSiAw0ZCg0KBQQPBQEBEgSiAw0RCg0KBQQPBQEC +EgSiAxUZCgsKAwQPBRIEowMCGgoMCgQEDwUCEgSjAw0ZCg0KBQQPBQIBEgSj +Aw0SCg0KBQQPBQICEgSjAxYZCkgKAgQQEganAwCsAwEaOiBUZXN0IHRoYXQg +cmVhbGx5IGxhcmdlIHRhZyBudW1iZXJzIGRvbid0IGJyZWFrIGFueXRoaW5n +LgoKCwoDBBABEgSnAwggCn0KBAQQAgASBKoDAhcabyBUaGUgbGFyZ2VzdCBw +b3NzaWJsZSB0YWcgbnVtYmVyIGlzIDJeMjggLSAxLCBzaW5jZSB0aGUgd2ly +ZSBmb3JtYXQgdXNlcwogdGhyZWUgYml0cyB0byBjb21tdW5pY2F0ZSB3aXJl +IHR5cGUuCgoNCgUEEAIABBIEqgMCCgoNCgUEEAIABRIEqgMLEAoNCgUEEAIA +ARIEqgMREgoNCgUEEAIAAxIEqgMVFgoMCgQEEAIBEgSrAwIgCg0KBQQQAgEE +EgSrAwIKCg0KBQQQAgEFEgSrAwsQCg0KBQQQAgEBEgSrAxETCg0KBQQQAgED +EgSrAxYfCgwKAgQREgauAwCxAwEKCwoDBBEBEgSuAwgcCgwKBAQRAgASBK8D +AiYKDQoFBBECAAQSBK8DAgoKDQoFBBECAAYSBK8DCx8KDQoFBBECAAESBK8D +ICEKDQoFBBECAAMSBK8DJCUKDAoEBBECARIEsAMCFwoNCgUEEQIBBBIEsAMC +CgoNCgUEEQIBBRIEsAMLEAoNCgUEEQIBARIEsAMREgoNCgUEEQIBAxIEsAMV +FgoxCgIEEhIGtAMAtgMBGiMgVGVzdCB0aGF0IG11dHVhbCByZWN1cnNpb24g +d29ya3MuCgoLCgMEEgESBLQDCBwKDAoEBBICABIEtQMCJwoNCgUEEgIABBIE +tQMCCgoNCgUEEgIABhIEtQMLHwoNCgUEEgIAARIEtQMgIgoNCgUEEgIAAxIE +tQMlJgoMCgIEExIGuAMAuwMBCgsKAwQTARIEuAMIHAoMCgQEEwIAEgS5AwIm +Cg0KBQQTAgAEEgS5AwIKCg0KBQQTAgAGEgS5AwsfCg0KBQQTAgABEgS5AyAh +Cg0KBQQTAgADEgS5AyQlCgwKBAQTAgESBLoDAiQKDQoFBBMCAQQSBLoDAgoK +DQoFBBMCAQUSBLoDCxAKDQoFBBMCAQESBLoDER8KDQoFBBMCAQMSBLoDIiMK +mQIKAgQUEgbBAwDFAwEa/QEgVGVzdCB0aGF0IGdyb3VwcyBoYXZlIGRpc2pv +aW50IGZpZWxkIG51bWJlcnMgZnJvbSB0aGVpciBzaWJsaW5ncyBhbmQKIHBh +cmVudHMuICBUaGlzIGlzIE5PVCBwb3NzaWJsZSBpbiBwcm90bzE7IG9ubHkg +Z29vZ2xlLnByb3RvYnVmLiAgV2hlbiBhdHRlbXB0aW5nCiB0byBjb21waWxl +IHdpdGggcHJvdG8xLCB0aGlzIHdpbGwgZW1pdCBhbiBlcnJvcjsgc28gd2Ug +b25seSBpbmNsdWRlIGl0CiBpbiBwcm90b2J1Zl91bml0dGVzdF9wcm90by4K +IgsgTk9fUFJPVE8xCgoLCgMEFAESBMEDCBoKGQoEBBQCABIEwgMCFyILIE5P +X1BST1RPMQoKDQoFBBQCAAQSBMIDAgoKDQoFBBQCAAUSBMIDCxAKDQoFBBQC +AAESBMIDERIKDQoFBBQCAAMSBMIDFRYKDAoEBBQCARIEwwMCMgoNCgUEFAIB +BBIEwwMCCgoNCgUEFAIBBRIEwwMLEAoNCgUEFAIBARIEwwMRFAoNCgUEFAIB +AxIEwwMXGAoMCgQEFAMAEgTDAwIyCg0KBQQUAwABEgTDAxEUCg0KBQQUAgEG +EgTDAxEUCg4KBgQUAwACABIEwwMbMAoPCgcEFAMAAgAEEgTDAxsjCg8KBwQU +AwACAAUSBMMDJCkKDwoHBBQDAAIAARIEwwMqKwoPCgcEFAMAAgADEgTDAy4v +CgwKBAQUAgISBMQDAjIKDQoFBBQCAgQSBMQDAgoKDQoFBBQCAgUSBMQDCxAK +DQoFBBQCAgESBMQDERQKDQoFBBQCAgMSBMQDFxgKDAoEBBQDARIExAMCMgoN +CgUEFAMBARIExAMRFAoNCgUEFAICBhIExAMRFAoOCgYEFAMBAgASBMQDGzAK +DwoHBBQDAQIABBIExAMbIwoPCgcEFAMBAgAFEgTEAyQpCg8KBwQUAwECAAES +BMQDKisKDwoHBBQDAQIAAxIExAMuLwo8CgIEFRIGyAMAygMBGi4gQWRkaXRp +b25hbCBtZXNzYWdlcyBmb3IgdGVzdGluZyBsYXp5IGZpZWxkcy4KCgsKAwQV +ARIEyAMIGAoMCgQEFQIAEgTJAwI1Cg0KBQQVAgAEEgTJAwIKCg0KBQQVAgAG +EgTJAwsXCg0KBQQVAgABEgTJAxgjCg0KBQQVAgADEgTJAyYnCg0KBQQVAgAI +EgTJAyg0Cg4KBgQVAgAIBRIEyQMpMwoMCgIEFhIGywMAzQMBCgsKAwQWARIE +ywMIFwoMCgQEFgIAEgTMAwI0Cg0KBQQWAgAEEgTMAwIKCg0KBQQWAgAGEgTM +AwsXCg0KBQQWAgABEgTMAxgjCg0KBQQWAgADEgTMAyYnCg0KBQQWAgAIEgTM +AygzCg4KBgQWAgAIBRIEzAMpMgopCgIEFxIG0AMA1gMBGhsgTmVlZGVkIGZv +ciBhIFB5dGhvbiB0ZXN0LgoKCwoDBBcBEgTQAwggCg4KBAQXAwASBtEDAtQD +AwoNCgUEFwMAARIE0QMKFwoOCgYEFwMAAgASBNIDBDQKDwoHBBcDAAIABBIE +0gMEDAoPCgcEFwMAAgAFEgTSAw0SCg8KBwQXAwACAAESBNIDEy8KDwoHBBcD +AAIAAxIE0gMyMwoOCgYEFwMAAgESBNMDBEYKDwoHBBcDAAIBBBIE0wMEDAoP +CgcEFwMAAgEGEgTTAw0bCg8KBwQXAwACAQESBNMDHEEKDwoHBBcDAAIBAxIE +0wNERQoMCgQEFwIAEgTVAwI1Cg0KBQQXAgAEEgTVAwIKCg0KBQQXAgAGEgTV +AwsYCg0KBQQXAgABEgTVAxkwCg0KBQQXAgADEgTVAzM0CksKAgUBEgbaAwDi +AwEaPSBUZXN0IGFuIGVudW0gdGhhdCBoYXMgbXVsdGlwbGUgdmFsdWVzIHdp +dGggdGhlIHNhbWUgbnVtYmVyLgoKCwoDBQEBEgTaAwUZCgsKAwUBAxIE2wMC +HAoMCgQFAQMCEgTbAwIcCgwKBAUBAgASBN0DAgsKDQoFBQECAAESBN0DAgYK +DQoFBQECAAISBN0DCQoKDAoEBQECARIE3gMCCwoNCgUFAQIBARIE3gMCBgoN +CgUFAQIBAhIE3gMJCgoMCgQFAQICEgTfAwIKCg0KBQUBAgIBEgTfAwIFCg0K +BQUBAgICEgTfAwgJCgwKBAUBAgMSBOADAgsKDQoFBQECAwESBOADAgYKDQoF +BQECAwISBOADCQoKDAoEBQECBBIE4QMCCwoNCgUFAQIEARIE4QMCBgoNCgUF +AQIEAhIE4QMJCgo6CgIFAhIG5QMA7QMBGiwgVGVzdCBhbiBlbnVtIHdpdGgg +bGFyZ2UsIHVub3JkZXJlZCB2YWx1ZXMuCgoLCgMFAgESBOUDBRMKDAoEBQIC +ABIE5gMCEQoNCgUFAgIAARIE5gMCCgoNCgUFAgIAAhIE5gMNEAoMCgQFAgIB +EgTnAwITCg0KBQUCAgEBEgTnAwIKCg0KBQUCAgECEgTnAw0SCgwKBAUCAgIS +BOgDAhYKDQoFBQICAgESBOgDAgoKDQoFBQICAgISBOgDDRUKDAoEBQICAxIE +6QMCEQoNCgUFAgIDARIE6QMCCgoNCgUFAgIDAhIE6QMNEAoMCgQFAgIEEgTq +AwIUCg0KBQUCAgQBEgTqAwIKCg0KBQUCAgQCEgTqAw0TCgwKBAUCAgUSBOsD +Ag8KDQoFBQICBQESBOsDAgoKDQoFBQICBQISBOsDDQ4KDAoEBQICBhIE7AMC +DwoNCgUFAgIGARIE7AMCCgoNCgUFAgIGAhIE7AMNDgpoCgIEGBIG8QMA/wMB +GlogVGVzdCBtZXNzYWdlIHdpdGggQ2FtZWxDYXNlIGZpZWxkIG5hbWVzLiAg +VGhpcyB2aW9sYXRlcyBQcm90b2NvbCBCdWZmZXIKIHN0YW5kYXJkIHN0eWxl +LgoKCwoDBBgBEgTxAwgfCgwKBAQYAgASBPIDAiQKDQoFBBgCAAQSBPIDAgoK +DQoFBBgCAAUSBPIDCxAKDQoFBBgCAAESBPIDER8KDQoFBBgCAAMSBPIDIiMK +DAoEBBgCARIE8wMCIgoNCgUEGAIBBBIE8wMCCgoNCgUEGAIBBRIE8wMLEQoN +CgUEGAIBARIE8wMSHQoNCgUEGAIBAxIE8wMgIQoMCgQEGAICEgT0AwIlCg0K +BQQYAgIEEgT0AwIKCg0KBQQYAgIGEgT0AwsWCg0KBQQYAgIBEgT0AxcgCg0K +BQQYAgIDEgT0AyMkCgwKBAQYAgMSBPUDAisKDQoFBBgCAwQSBPUDAgoKDQoF +BBgCAwYSBPUDCxkKDQoFBBgCAwESBPUDGiYKDQoFBBgCAwMSBPUDKSoKDAoE +BBgCBBIE9gMCPAoNCgUEGAIEBBIE9gMCCgoNCgUEGAIEBRIE9gMLEQoNCgUE +GAIEARIE9gMSIgoNCgUEGAIEAxIE9gMlJgoNCgUEGAIECBIE9gMnOwoOCgYE +GAIECAESBPYDKDoKDAoEBBgCBRIE9wMCLQoNCgUEGAIFBBIE9wMCCgoNCgUE +GAIFBRIE9wMLEQoNCgUEGAIFARIE9wMSGwoNCgUEGAIFAxIE9wMeHwoNCgUE +GAIFCBIE9wMgLAoOCgYEGAIFCAESBPcDISsKDAoEBBgCBhIE+QMCLAoNCgUE +GAIGBBIE+QMCCgoNCgUEGAIGBRIE+QMLEAoNCgUEGAIGARIE+QMRJwoNCgUE +GAIGAxIE+QMqKwoMCgQEGAIHEgT6AwIqCg0KBQQYAgcEEgT6AwIKCg0KBQQY +AgcFEgT6AwsRCg0KBQQYAgcBEgT6AxIlCg0KBQQYAgcDEgT6AygpCgwKBAQY +AggSBPsDAi0KDQoFBBgCCAQSBPsDAgoKDQoFBBgCCAYSBPsDCxYKDQoFBBgC +CAESBPsDFygKDQoFBBgCCAMSBPsDKywKDAoEBBgCCRIE/AMCNAoNCgUEGAIJ +BBIE/AMCCgoNCgUEGAIJBhIE/AMLGQoNCgUEGAIJARIE/AMaLgoNCgUEGAIJ +AxIE/AMxMwoMCgQEGAIKEgT9AwJFCg0KBQQYAgoEEgT9AwIKCg0KBQQYAgoF +EgT9AwsRCg0KBQQYAgoBEgT9AxIqCg0KBQQYAgoDEgT9Ay0vCg0KBQQYAgoI +EgT9AzBECg4KBgQYAgoIARIE/QMxQwoMCgQEGAILEgT+AwI2Cg0KBQQYAgsE +EgT+AwIKCg0KBQQYAgsFEgT+AwsRCg0KBQQYAgsBEgT+AxIjCg0KBQQYAgsD +EgT+AyYoCg0KBQQYAgsIEgT+Ayk1Cg4KBgQYAgsIARIE/gMqNAqLAQoCBBkS +BoQEAJMEARp9IFdlIGxpc3QgZmllbGRzIG91dCBvZiBvcmRlciwgdG8gZW5z +dXJlIHRoYXQgd2UncmUgdXNpbmcgZmllbGQgbnVtYmVyIGFuZCBub3QKIGZp +ZWxkIGluZGV4IHRvIGRldGVybWluZSBzZXJpYWxpemF0aW9uIG9yZGVyLgoK +CwoDBBkBEgSEBAgaCgwKBAQZAgASBIUEAiEKDQoFBBkCAAQSBIUEAgoKDQoF +BBkCAAUSBIUECxEKDQoFBBkCAAESBIUEEhsKDQoFBBkCAAMSBIUEHiAKCwoD +BBkFEgSGBAIVCgwKBAQZBQASBIYEDRQKDQoFBBkFAAESBIYEDQ4KDQoFBBkF +AAISBIYEEhQKDAoEBBkCARIEhwQCHAoNCgUEGQIBBBIEhwQCCgoNCgUEGQIB +BRIEhwQLEAoNCgUEGQIBARIEhwQRFwoNCgUEGQIBAxIEhwQaGwoLCgMEGQUS +BIgEAhcKDAoEBBkFARIEiAQNFgoNCgUEGQUBARIEiAQNDwoNCgUEGQUBAhIE +iAQTFgoMCgQEGQICEgSJBAIgCg0KBQQZAgIEEgSJBAIKCg0KBQQZAgIFEgSJ +BAsQCg0KBQQZAgIBEgSJBBEZCg0KBQQZAgIDEgSJBBwfCg4KBAQZAwASBooE +ApAEAwoNCgUEGQMAARIEigQKFwoOCgYEGQMAAgASBIsEBBoKDwoHBBkDAAIA +BBIEiwQEDAoPCgcEGQMAAgAFEgSLBA0SCg8KBwQZAwACAAESBIsEExUKDwoH +BBkDAAIAAxIEiwQYGQrkAQoGBBkDAAIBEgSPBAQaGtMBIFRoZSBmaWVsZCBu +YW1lICJiIiBmYWlscyB0byBjb21waWxlIGluIHByb3RvMSBiZWNhdXNlIGl0 +IGNvbmZsaWN0cyB3aXRoCiBhIGxvY2FsIHZhcmlhYmxlIG5hbWVkICJiIiBp +biBvbmUgb2YgdGhlIGdlbmVyYXRlZCBtZXRob2RzLiAgRG9oLgogVGhpcyBm +aWxlIG5lZWRzIHRvIGNvbXBpbGUgaW4gcHJvdG8xIHRvIHRlc3QgYmFja3dh +cmRzLWNvbXBhdGliaWxpdHkuCgoPCgcEGQMAAgEEEgSPBAQMCg8KBwQZAwAC +AQUSBI8EDRIKDwoHBBkDAAIBARIEjwQTFQoPCgcEGQMAAgEDEgSPBBgZCgwK +BAQZAgMSBJIEAjgKDQoFBBkCAwQSBJIEAgoKDQoFBBkCAwYSBJIECxgKDQoF +BBkCAwESBJIEGTAKDQoFBBkCAwMSBJIENDcKCwoBBxIGlgQAmQQBCgoKAgdL +EgSXBAIrCgsKAwdLAhIElgQHGQoLCgMHSwQSBJcEAgoKCwoDB0sFEgSXBAsR +CgsKAwdLARIElwQSJQoLCgMHSwMSBJcEKCoKCgoCB0wSBJgEAiYKCwoDB0wC +EgSWBAcZCgsKAwdMBBIEmAQCCgoLCgMHTAUSBJgECxAKCwoDB0wBEgSYBBEh +CgsKAwdMAxIEmAQkJQoMCgIEGhIGnAQAywQBCgsKAwQaARIEnAQIIAoMCgQE +GgIAEgSdBAJQCg0KBQQaAgAEEgSdBAIKCg0KBQQaAgAFEgSdBAsQCg0KBQQa +AgABEgSdBBEeCg0KBQQaAgADEgSdBCEiCg0KBQQaAgAIEgSdBCNPCg0KBQQa +AgAHEgSdBC5OCgwKBAQaAgESBJ4EAjoKDQoFBBoCAQQSBJ4EAgoKDQoFBBoC +AQUSBJ4ECxEKDQoFBBoCAQESBJ4EEh4KDQoFBBoCAQMSBJ4EISIKDQoFBBoC +AQgSBJ4EIzkKDQoFBBoCAQcSBJ4ELjgKDAoEBBoCAhIEnwQCQgoNCgUEGgIC +BBIEnwQCCgoNCgUEGgICBRIEnwQLEQoNCgUEGgICARIEnwQSHgoNCgUEGgIC +AxIEnwQhIgoNCgUEGgICCBIEnwQjQQoNCgUEGgICBxIEnwQuQAoMCgQEGgID +EgSgBAI7Cg0KBQQaAgMEEgSgBAIKCg0KBQQaAgMFEgSgBAwRCg0KBQQaAgMB +EgSgBBIdCg0KBQQaAgMDEgSgBCEiCg0KBQQaAgMIEgSgBCM6Cg0KBQQaAgMH +EgSgBC45CgwKBAQaAgQSBKEEAkMKDQoFBBoCBAQSBKEEAgoKDQoFBBoCBAUS +BKEEDBEKDQoFBBoCBAESBKEEEh0KDQoFBBoCBAMSBKEEISIKDQoFBBoCBAgS +BKEEI0IKDQoFBBoCBAcSBKEELkEKDAoEBBoCBRIEogQCQgoNCgUEGgIFBBIE +ogQCCgoNCgUEGgIFBRIEogQMEQoNCgUEGgIFARIEogQSJAoNCgUEGgIFAxIE +ogQnKQoNCgUEGgIFCBIEogQqQQoNCgUEGgIFBxIEogQ1QAoMCgQEGgIGEgSj +BAJKCg0KBQQaAgYEEgSjBAIKCg0KBQQaAgYFEgSjBAwRCg0KBQQaAgYBEgSj +BBIkCg0KBQQaAgYDEgSjBCcpCg0KBQQaAgYIEgSjBCpJCg0KBQQaAgYHEgSj +BDVICt0BCgQEGgIHEgSoBAI9Gs4BIFRoZSBkZWZhdWx0IHZhbHVlIGhlcmUg +aXMgVVRGLTggZm9yICJcdTEyMzQiLiAgKFdlIGNvdWxkIGFsc28ganVzdCB0 +eXBlCiB0aGUgVVRGLTggdGV4dCBkaXJlY3RseSBpbnRvIHRoaXMgdGV4dCBm +aWxlIHJhdGhlciB0aGFuIGVzY2FwZSBpdCwgYnV0CiBsb3RzIG9mIHBlb3Bs +ZSB1c2UgZWRpdG9ycyB0aGF0IHdvdWxkIGJlIGNvbmZ1c2VkIGJ5IHRoaXMu +KQoKDQoFBBoCBwQSBKgEAgoKDQoFBBoCBwUSBKgECxEKDQoFBBoCBwESBKgE +Eh0KDQoFBBoCBwMSBKgEICEKDQoFBBoCBwgSBKgEIjwKDQoFBBoCBwcSBKgE +LTsKQQoEBBoCCBIEqwQCLhozIFRlc3RzIGZvciBzaW5nbGUtcHJlY2lzaW9u +IGZsb2F0aW5nLXBvaW50IHZhbHVlcy4KCg0KBQQaAggEEgSrBAIKCg0KBQQa +AggFEgSrBAsQCg0KBQQaAggBEgSrBBEbCg0KBQQaAggDEgSrBB4fCg0KBQQa +AggIEgSrBCAtCg0KBQQaAggHEgSrBCssCgwKBAQaAgkSBKwEAi0KDQoFBBoC +CQQSBKwEAgoKDQoFBBoCCQUSBKwECxAKDQoFBBoCCQESBKwEERoKDQoFBBoC +CQMSBKwEHR4KDQoFBBoCCQgSBKwEHywKDQoFBBoCCQcSBKwEKisKDAoEBBoC +ChIErQQCMQoNCgUEGgIKBBIErQQCCgoNCgUEGgIKBRIErQQLEAoNCgUEGgIK +ARIErQQRHAoNCgUEGgIKAxIErQQfIAoNCgUEGgIKCBIErQQhMAoNCgUEGgIK +BxIErQQsLwoMCgQEGgILEgSuBAI4Cg0KBQQaAgsEEgSuBAIKCg0KBQQaAgsF +EgSuBAsQCg0KBQQaAgsBEgSuBBEjCg0KBQQaAgsDEgSuBCYoCg0KBQQaAgsI +EgSuBCk3Cg0KBQQaAgsHEgSuBDQ2CgwKBAQaAgwSBK8EAjYKDQoFBBoCDAQS +BK8EAgoKDQoFBBoCDAUSBK8ECxAKDQoFBBoCDAESBK8EER8KDQoFBBoCDAMS +BK8EIiQKDQoFBBoCDAgSBK8EJTUKDQoFBBoCDAcSBK8EMDQKHwoEBBoCDRIE +sQQCMhoRIFVzaW5nIGV4cG9uZW50cwoKDQoFBBoCDQQSBLEEAgoKDQoFBBoC +DQUSBLEECxAKDQoFBBoCDQESBLEEERwKDQoFBBoCDQMSBLEEHyEKDQoFBBoC +DQgSBLEEIjEKDQoFBBoCDQcSBLEELTAKDAoEBBoCDhIEsgQCPgoNCgUEGgIO +BBIEsgQCCgoNCgUEGgIOBRIEsgQLEAoNCgUEGgIOARIEsgQRJQoNCgUEGgIO +AxIEsgQoKgoNCgUEGgIOCBIEsgQrPQoNCgUEGgIOBxIEsgQ2PAo5CgQEGgIP +EgS1BAIyGisgVGV4dCBmb3Igbm9uZmluaXRlIGZsb2F0aW5nLXBvaW50IHZh +bHVlcy4KCg0KBQQaAg8EEgS1BAIKCg0KBQQaAg8FEgS1BAsRCg0KBQQaAg8B +EgS1BBIcCg0KBQQaAg8DEgS1BB8hCg0KBQQaAg8IEgS1BCIxCg0KBQQaAg8H +EgS1BC0wCgwKBAQaAhASBLYEAjcKDQoFBBoCEAQSBLYEAgoKDQoFBBoCEAUS +BLYECxEKDQoFBBoCEAESBLYEEiAKDQoFBBoCEAMSBLYEIyUKDQoFBBoCEAgS +BLYEJjYKDQoFBBoCEAcSBLYEMTUKDAoEBBoCERIEtwQCMgoNCgUEGgIRBBIE +twQCCgoNCgUEGgIRBRIEtwQLEQoNCgUEGgIRARIEtwQSHAoNCgUEGgIRAxIE +twQfIQoNCgUEGgIRCBIEtwQiMQoNCgUEGgIRBxIEtwQtMAoMCgQEGgISEgS4 +BAIwCg0KBQQaAhIEEgS4BAIKCg0KBQQaAhIFEgS4BAsQCg0KBQQaAhIBEgS4 +BBEaCg0KBQQaAhIDEgS4BB0fCg0KBQQaAhIIEgS4BCAvCg0KBQQaAhIHEgS4 +BCsuCgwKBAQaAhMSBLkEAjUKDQoFBBoCEwQSBLkEAgoKDQoFBBoCEwUSBLkE +CxAKDQoFBBoCEwESBLkEER4KDQoFBBoCEwMSBLkEISMKDQoFBBoCEwgSBLkE +JDQKDQoFBBoCEwcSBLkELzMKDAoEBBoCFBIEugQCMAoNCgUEGgIUBBIEugQC +CgoNCgUEGgIUBRIEugQLEAoNCgUEGgIUARIEugQRGgoNCgUEGgIUAxIEugQd +HwoNCgUEGgIUCBIEugQgLwoNCgUEGgIUBxIEugQrLgrjAQoEBBoCFRIEwQQC +TBrUASBUZXN0cyBmb3IgQysrIHRyaWdyYXBocy4KIFRyaWdyYXBocyBzaG91 +bGQgYmUgZXNjYXBlZCBpbiBDKysgZ2VuZXJhdGVkIGZpbGVzLCBidXQgdGhl +eSBzaG91bGQgbm90IGJlCiBlc2NhcGVkIGZvciBvdGhlciBsYW5ndWFnZXMu +CiBOb3RlIHRoYXQgaW4gLnByb3RvIGZpbGUsICJcPyIgaXMgYSB2YWxpZCB3 +YXkgdG8gZXNjYXBlID8gaW4gc3RyaW5nCiBsaXRlcmFscy4KCg0KBQQaAhUE +EgTBBAIKCg0KBQQaAhUFEgTBBAsRCg0KBQQaAhUBEgTBBBIeCg0KBQQaAhUD +EgTBBCEjCg0KBQQaAhUIEgTBBCRLCg0KBQQaAhUHEgTBBC9KCj8KBAQaAhYS +BMQEAkYaMSBTdHJpbmcgZGVmYXVsdHMgY29udGFpbmluZyB0aGUgY2hhcmFj +dGVyICdcMDAwJwoKDQoFBBoCFgQSBMQEAgoKDQoFBBoCFgUSBMQECxEKDQoF +BBoCFgESBMQEEiIKDQoFBBoCFgMSBMQEKy0KDQoFBBoCFggSBMQELkUKDQoF +BBoCFgcSBMQEOUQKDAoEBBoCFxIExQQCRgoNCgUEGgIXBBIExQQCCgoNCgUE +GgIXBRIExQQMEQoNCgUEGgIXARIExQQSIQoNCgUEGgIXAxIExQQrLQoNCgUE +GgIXCBIExQQuRQoNCgUEGgIXBxIExQQ5RAoOCgQEGgIYEgbGBALHBEIKDQoF +BBoCGAQSBMYEAgoKDQoFBBoCGAUSBMYECxEKDQoFBBoCGAESBMYEEigKDQoF +BBoCGAMSBMYEKy0KDwoFBBoCGAgSBsYELscEQQoOCgYEGgIYCAESBMYEL0EK +DQoFBBoCGAcSBMcEN0AKDgoEBBoCGRIGyAQCyQRCCg0KBQQaAhkEEgTIBAIK +Cg0KBQQaAhkFEgTIBAsRCg0KBQQaAhkBEgTIBBIgCg0KBQQaAhkDEgTIBCst +Cg8KBQQaAhkIEgbIBC7JBEEKDgoGBBoCGQgBEgTIBC85Cg0KBQQaAhkHEgTJ +BDdACgwKBAQaAhoSBMoEAkUKDQoFBBoCGgQSBMoEAgoKDQoFBBoCGgUSBMoE +CxEKDQoFBBoCGgESBMoEEiQKDQoFBBoCGgMSBMoEKy0KDQoFBBoCGggSBMoE +LkQKDQoFBBoCGgcSBMoEN0MKDAoCBBsSBs0EAM8EAQoLCgMEGwESBM0ECBkK +DAoEBBsCABIEzgQCKgoNCgUEGwIABBIEzgQCCgoNCgUEGwIABhIEzgQLGQoN +CgUEGwIAARIEzgQaJQoNCgUEGwIAAxIEzgQoKQpICgIEHBIG0gQA1AQBGjog +VGVzdCBTdHJpbmcgYW5kIEJ5dGVzOiBzdHJpbmcgaXMgZm9yIHZhbGlkIFVU +Ri04IHN0cmluZ3MKCgsKAwQcARIE0gQIEQoMCgQEHAIAEgTTBAIbCg0KBQQc +AgAEEgTTBAIKCg0KBQQcAgAFEgTTBAsRCg0KBQQcAgABEgTTBBIWCg0KBQQc +AgADEgTTBBkaCgwKAgQdEgbWBADYBAEKCwoDBB0BEgTWBAgSCgwKBAQdAgAS +BNcEAhsKDQoFBB0CAAQSBNcEAgoKDQoFBB0CAAUSBNcECxEKDQoFBB0CAAES +BNcEEhYKDQoFBB0CAAMSBNcEGRoKDAoCBB4SBtoEANwEAQoLCgMEHgESBNoE +CBAKDAoEBB4CABIE2wQCGgoNCgUEHgIABBIE2wQCCgoNCgUEHgIABRIE2wQL +EAoNCgUEHgIAARIE2wQRFQoNCgUEHgIAAxIE2wQYGQoMCgIEHxIG3gQA4AQB +CgsKAwQfARIE3gQIEQoMCgQEHwIAEgTfBAIaCg0KBQQfAgAEEgTfBAIKCg0K +BQQfAgAFEgTfBAsQCg0KBQQfAgABEgTfBBEVCg0KBQQfAgADEgTfBBgZCk4K +AgQgEgbjBADlBAEaQCBUZXN0IGludDMyLCB1aW50MzIsIGludDY0LCB1aW50 +NjQsIGFuZCBib29sIGFyZSBhbGwgY29tcGF0aWJsZQoKCwoDBCABEgTjBAgU +CgwKBAQgAgASBOQEAhoKDQoFBCACAAQSBOQEAgoKDQoFBCACAAUSBOQECxAK +DQoFBCACAAESBOQEERUKDQoFBCACAAMSBOQEGBkKDAoCBCESBucEAOkEAQoL +CgMEIQESBOcECBUKDAoEBCECABIE6AQCGwoNCgUEIQIABBIE6AQCCgoNCgUE +IQIABRIE6AQLEQoNCgUEIQIAARIE6AQSFgoNCgUEIQIAAxIE6AQZGgoMCgIE +IhIG6wQA7QQBCgsKAwQiARIE6wQIFAoMCgQEIgIAEgTsBAIaCg0KBQQiAgAE +EgTsBAIKCg0KBQQiAgAFEgTsBAsQCg0KBQQiAgABEgTsBBEVCg0KBQQiAgAD +EgTsBBgZCgwKAgQjEgbvBADxBAEKCwoDBCMBEgTvBAgVCgwKBAQjAgASBPAE +AhsKDQoFBCMCAAQSBPAEAgoKDQoFBCMCAAUSBPAECxEKDQoFBCMCAAESBPAE +EhYKDQoFBCMCAAMSBPAEGRoKDAoCBCQSBvMEAPUEAQoLCgMEJAESBPMECBMK +DAoEBCQCABIE9AQCGQoNCgUEJAIABBIE9AQCCgoNCgUEJAIABRIE9AQLDwoN +CgUEJAIAARIE9AQQFAoNCgUEJAIAAxIE9AQXGAocCgIEJRIG+AQAggUBGg4g +VGVzdCBvbmVvZnMuCgoLCgMEJQESBPgECBEKDgoEBCUIABIG+QQCgQUDCg0K +BQQlCAABEgT5BAgLCgwKBAQlAgASBPoEBBYKDQoFBCUCAAUSBPoEBAkKDQoF +BCUCAAESBPoEChEKDQoFBCUCAAMSBPoEFBUKDAoEBCUCARIE+wQEGgoNCgUE +JQIBBRIE+wQECgoNCgUEJQIBARIE+wQLFQoNCgUEJQIBAxIE+wQYGQoMCgQE +JQICEgT8BAQhCg0KBQQlAgIGEgT8BAQQCg0KBQQlAgIBEgT8BBEcCg0KBQQl +AgIDEgT8BB8gCg4KBAQlAgMSBv0EBIAFBQoNCgUEJQIDBRIE/QQECQoNCgUE +JQIDARIE/QQKEgoNCgUEJQIDAxIE/QQVFgoOCgQEJQMAEgb9BASABQUKDQoF +BCUDAAESBP0EChIKDQoFBCUCAwYSBP0EChIKDgoGBCUDAAIAEgT+BAYbCg8K +BwQlAwACAAQSBP4EBg4KDwoHBCUDAAIABRIE/gQPFAoPCgcEJQMAAgABEgT+ +BBUWCg8KBwQlAwACAAMSBP4EGRoKDgoGBCUDAAIBEgT/BAYcCg8KBwQlAwAC +AQQSBP8EBg4KDwoHBCUDAAIBBRIE/wQPFQoPCgcEJQMAAgEBEgT/BBYXCg8K +BwQlAwACAQMSBP8EGhsKDAoCBCYSBoQFAIwFAQoLCgMEJgESBIQFCCQKDAoE +BCYCABIEhQUCHQoNCgUEJgIABBIEhQUCCgoNCgUEJgIABRIEhQULEAoNCgUE +JgIAARIEhQURGAoNCgUEJgIAAxIEhQUbHAoMCgQEJgIBEgSGBQIhCg0KBQQm +AgEEEgSGBQIKCg0KBQQmAgEFEgSGBQsRCg0KBQQmAgEBEgSGBRIcCg0KBQQm +AgEDEgSGBR8gCgwKBAQmAgISBIcFAigKDQoFBCYCAgQSBIcFAgoKDQoFBCYC +AgYSBIcFCxcKDQoFBCYCAgESBIcFGCMKDQoFBCYCAgMSBIcFJicKDgoEBCYC +AxIGiAUCiwUDCg0KBQQmAgMEEgSIBQIKCg0KBQQmAgMFEgSIBQsQCg0KBQQm +AgMBEgSIBREZCg0KBQQmAgMDEgSIBRwdCg4KBAQmAwASBogFAosFAwoNCgUE +JgMAARIEiAURGQoNCgUEJgIDBhIEiAURGQoOCgYEJgMAAgASBIkFBBkKDwoH +BCYDAAIABBIEiQUEDAoPCgcEJgMAAgAFEgSJBQ0SCg8KBwQmAwACAAESBIkF +ExQKDwoHBCYDAAIAAxIEiQUXGAoOCgYEJgMAAgESBIoFBBoKDwoHBCYDAAIB +BBIEigUEDAoPCgcEJgMAAgEFEgSKBQ0TCg8KBwQmAwACAQESBIoFFBUKDwoH +BCYDAAIBAxIEigUYGQoMCgIEJxIGjgUAtAUBCgsKAwQnARIEjgUIEgoOCgQE +JwgAEgaPBQKcBQMKDQoFBCcIAAESBI8FCAsKDAoEBCcCABIEkAUEFgoNCgUE +JwIABRIEkAUECQoNCgUEJwIAARIEkAUKEQoNCgUEJwIAAxIEkAUUFQoMCgQE +JwIBEgSRBQQaCg0KBQQnAgEFEgSRBQQKCg0KBQQnAgEBEgSRBQsVCg0KBQQn +AgEDEgSRBRgZCgwKBAQnAgISBJIFBCUKDQoFBCcCAgUSBJIFBAoKDQoFBCcC +AgESBJIFCxMKDQoFBCcCAgMSBJIFFhcKDQoFBCcCAggSBJIFGCQKDgoGBCcC +AggBEgSSBRkjCgwKBAQnAgMSBJMFBDUKDQoFBCcCAwUSBJMFBAoKDQoFBCcC +AwESBJMFCxsKDQoFBCcCAwMSBJMFHh8KDQoFBCcCAwgSBJMFIDQKDgoGBCcC +AwgBEgSTBSEzCgwKBAQnAgQSBJQFBBgKDQoFBCcCBAUSBJQFBAkKDQoFBCcC +BAESBJQFChMKDQoFBCcCBAMSBJQFFhcKDAoEBCcCBRIElQUEHAoNCgUEJwIF +BhIElQUEDgoNCgUEJwIFARIElQUPFwoNCgUEJwIFAxIElQUaGwoMCgQEJwIG +EgSWBQQiCg0KBQQnAgYGEgSWBQQRCg0KBQQnAgYBEgSWBRIdCg0KBQQnAgYD +EgSWBSAhCg4KBAQnAgcSBpcFBJoFBQoNCgUEJwIHBRIElwUECQoNCgUEJwIH +ARIElwUKEgoNCgUEJwIHAxIElwUVFgoOCgQEJwMAEgaXBQSaBQUKDQoFBCcD +AAESBJcFChIKDQoFBCcCBwYSBJcFChIKDgoGBCcDAAIAEgSYBQYbCg8KBwQn +AwACAAQSBJgFBg4KDwoHBCcDAAIABRIEmAUPFAoPCgcEJwMAAgABEgSYBRUW +Cg8KBwQnAwACAAMSBJgFGRoKDgoGBCcDAAIBEgSZBQYdCg8KBwQnAwACAQQS +BJkFBg4KDwoHBCcDAAIBBRIEmQUPFQoPCgcEJwMAAgEBEgSZBRYXCg8KBwQn +AwACAQMSBJkFGhwKDAoEBCcCCBIEmwUENAoNCgUEJwIIBhIEmwUEEQoNCgUE +JwIIARIEmwUSIgoNCgUEJwIIAxIEmwUlJwoNCgUEJwIICBIEmwUoMwoOCgYE +JwIICAUSBJsFKTIKDgoEBCcIARIGngUCpQUDCg0KBQQnCAEBEgSeBQgLCgwK +BAQnAgkSBJ8FBCUKDQoFBCcCCQUSBJ8FBAkKDQoFBCcCCQESBJ8FChEKDQoF +BCcCCQMSBJ8FFBYKDQoFBCcCCQgSBJ8FFyQKDQoFBCcCCQcSBJ8FIiMKDAoE +BCcCChIEoAUEMAoNCgUEJwIKBRIEoAUECgoNCgUEJwIKARIEoAULFQoNCgUE +JwIKAxIEoAUYGgoNCgUEJwIKCBIEoAUbLwoNCgUEJwIKBxIEoAUmLgoMCgQE +JwILEgShBQQ4Cg0KBQQnAgsFEgShBQQKCg0KBQQnAgsBEgShBQsTCg0KBQQn +AgsDEgShBRYYCg0KBQQnAgsIEgShBRk3Cg4KBgQnAgsIARIEoQUaJAoNCgUE +JwILBxIEoQUwNgoMCgQEJwIMEgSiBQRKCg0KBQQnAgwFEgSiBQQKCg0KBQQn +AgwBEgSiBQsbCg0KBQQnAgwDEgSiBR4gCg0KBQQnAgwIEgSiBSFJCg4KBgQn +AgwIARIEogUiNAoNCgUEJwIMBxIEogVASAoMCgQEJwINEgSjBQQtCg0KBQQn +Ag0FEgSjBQQJCg0KBQQnAg0BEgSjBQoTCg0KBQQnAg0DEgSjBRYYCg0KBQQn +Ag0IEgSjBRksCg0KBQQnAg0HEgSjBSQrCgwKBAQnAg4SBKQFBC0KDQoFBCcC +DgYSBKQFBA4KDQoFBCcCDgESBKQFDxcKDQoFBCcCDgMSBKQFGhwKDQoFBCcC +DggSBKQFHSwKDQoFBCcCDgcSBKQFKCsKDAoEBCcCDxIEpwUCHgoNCgUEJwIP +BBIEpwUCCgoNCgUEJwIPBRIEpwULEAoNCgUEJwIPARIEpwURGAoNCgUEJwIP +AxIEpwUbHQoMCgQEJwIQEgSoBQI0Cg0KBQQnAhAEEgSoBQIKCg0KBQQnAhAF +EgSoBQsRCg0KBQQnAhABEgSoBRIcCg0KBQQnAhADEgSoBR8hCg0KBQQnAhAI +EgSoBSIzCg0KBQQnAhAHEgSoBS0yCg4KBAQnAwESBqoFAq0FAwoNCgUEJwMB +ARIEqgUKFwoOCgYEJwMBAgASBKsFBB8KDwoHBCcDAQIABBIEqwUEDAoPCgcE +JwMBAgAFEgSrBQ0SCg8KBwQnAwECAAESBKsFExoKDwoHBCcDAQIAAxIEqwUd +HgoOCgYEJwMBAgESBKwFBCEKDwoHBCcDAQIBBBIErAUEDAoPCgcEJwMBAgEF +EgSsBQ0SCg8KBwQnAwECAQESBKwFExwKDwoHBCcDAQIBAxIErAUfIAoOCgQE +JwQAEgavBQKzBQMKDQoFBCcEAAESBK8FBxEKDgoGBCcEAAIAEgSwBQQMCg8K +BwQnBAACAAESBLAFBAcKDwoHBCcEAAIAAhIEsAUKCwoOCgYEJwQAAgESBLEF +BAwKDwoHBCcEAAIBARIEsQUEBwoPCgcEJwQAAgECEgSxBQoLCg4KBgQnBAAC +AhIEsgUEDAoPCgcEJwQAAgIBEgSyBQQHCg8KBwQnBAACAgISBLIFCgsKDAoC +BCgSBrYFAL8FAQoLCgMEKAESBLYFCBkKDgoEBCgIABIGtwUCuwUDCg0KBQQo +CAABEgS3BQgLCgwKBAQoAgASBLgFBBYKDQoFBCgCAAUSBLgFBAkKDQoFBCgC +AAESBLgFChEKDQoFBCgCAAMSBLgFFBUKDAoEBCgCARIEuQUEGgoNCgUEKAIB +BRIEuQUECgoNCgUEKAIBARIEuQULFQoNCgUEKAIBAxIEuQUYGQoMCgQEKAIC +EgS6BQQiCg0KBQQoAgIGEgS6BQQRCg0KBQQoAgIBEgS6BRIdCg0KBQQoAgID +EgS6BSAhCg4KBAQoAwASBrwFAr4FAwoNCgUEKAMAARIEvAUKFwoOCgYEKAMA +AgASBL0FBCgKDwoHBCgDAAIABBIEvQUEDAoPCgcEKAMAAgAFEgS9BQ0TCg8K +BwQoAwACAAESBL0FFCMKDwoHBCgDAAIAAxIEvQUmJwovCgIEKRIGwwUA0gUB +MiEgVGVzdCBtZXNzYWdlcyBmb3IgcGFja2VkIGZpZWxkcwoKCwoDBCkBEgTD +BQgXCgwKBAQpAgASBMQFAjoKDQoFBCkCAAQSBMQFAgoKDQoFBCkCAAUSBMQF +DhMKDQoFBCkCAAESBMQFFCAKDQoFBCkCAAMSBMQFJykKDQoFBCkCAAgSBMQF +KjkKDgoGBCkCAAgCEgTEBSs4CgwKBAQpAgESBMUFAjoKDQoFBCkCAQQSBMUF +AgoKDQoFBCkCAQUSBMUFDhMKDQoFBCkCAQESBMUFFCAKDQoFBCkCAQMSBMUF +JykKDQoFBCkCAQgSBMUFKjkKDgoGBCkCAQgCEgTFBSs4CgwKBAQpAgISBMYF +AjoKDQoFBCkCAgQSBMYFAgoKDQoFBCkCAgUSBMYFDRMKDQoFBCkCAgESBMYF +FCEKDQoFBCkCAgMSBMYFJykKDQoFBCkCAggSBMYFKjkKDgoGBCkCAggCEgTG +BSs4CgwKBAQpAgMSBMcFAjoKDQoFBCkCAwQSBMcFAgoKDQoFBCkCAwUSBMcF +DRMKDQoFBCkCAwESBMcFFCEKDQoFBCkCAwMSBMcFJykKDQoFBCkCAwgSBMcF +KjkKDgoGBCkCAwgCEgTHBSs4CgwKBAQpAgQSBMgFAjoKDQoFBCkCBAQSBMgF +AgoKDQoFBCkCBAUSBMgFDRMKDQoFBCkCBAESBMgFFCEKDQoFBCkCBAMSBMgF +JykKDQoFBCkCBAgSBMgFKjkKDgoGBCkCBAgCEgTIBSs4CgwKBAQpAgUSBMkF +AjoKDQoFBCkCBQQSBMkFAgoKDQoFBCkCBQUSBMkFDRMKDQoFBCkCBQESBMkF +FCEKDQoFBCkCBQMSBMkFJykKDQoFBCkCBQgSBMkFKjkKDgoGBCkCBQgCEgTJ +BSs4CgwKBAQpAgYSBMoFAjoKDQoFBCkCBgQSBMoFAgoKDQoFBCkCBgUSBMoF +DBMKDQoFBCkCBgESBMoFFCIKDQoFBCkCBgMSBMoFJykKDQoFBCkCBggSBMoF +KjkKDgoGBCkCBggCEgTKBSs4CgwKBAQpAgcSBMsFAjoKDQoFBCkCBwQSBMsF +AgoKDQoFBCkCBwUSBMsFDBMKDQoFBCkCBwESBMsFFCIKDQoFBCkCBwMSBMsF +JykKDQoFBCkCBwgSBMsFKjkKDgoGBCkCBwgCEgTLBSs4CgwKBAQpAggSBMwF +AjoKDQoFBCkCCAQSBMwFAgoKDQoFBCkCCAUSBMwFCxMKDQoFBCkCCAESBMwF +FCMKDQoFBCkCCAMSBMwFJykKDQoFBCkCCAgSBMwFKjkKDgoGBCkCCAgCEgTM +BSs4CgwKBAQpAgkSBM0FAjoKDQoFBCkCCQQSBM0FAgoKDQoFBCkCCQUSBM0F +CxMKDQoFBCkCCQESBM0FFCMKDQoFBCkCCQMSBM0FJykKDQoFBCkCCQgSBM0F +KjkKDgoGBCkCCQgCEgTNBSs4CgwKBAQpAgoSBM4FAjoKDQoFBCkCCgQSBM4F +AgoKDQoFBCkCCgUSBM4FDhMKDQoFBCkCCgESBM4FFCAKDQoFBCkCCgMSBM4F +JikKDQoFBCkCCggSBM4FKjkKDgoGBCkCCggCEgTOBSs4CgwKBAQpAgsSBM8F +AjoKDQoFBCkCCwQSBM8FAgoKDQoFBCkCCwUSBM8FDRMKDQoFBCkCCwESBM8F +FCEKDQoFBCkCCwMSBM8FJikKDQoFBCkCCwgSBM8FKjkKDgoGBCkCCwgCEgTP +BSs4CgwKBAQpAgwSBNAFAjoKDQoFBCkCDAQSBNAFAgoKDQoFBCkCDAUSBNAF +DxMKDQoFBCkCDAESBNAFFB8KDQoFBCkCDAMSBNAFJikKDQoFBCkCDAgSBNAF +KjkKDgoGBCkCDAgCEgTQBSs4CgwKBAQpAg0SBNEFAjoKDQoFBCkCDQQSBNEF +AgoKDQoFBCkCDQYSBNEFCxYKDQoFBCkCDQESBNEFFyIKDQoFBCkCDQMSBNEF +JikKDQoFBCkCDQgSBNEFKjkKDgoGBCkCDQgCEgTRBSs4Co0BCgIEKhIG1gUA +5QUBGn8gQSBtZXNzYWdlIHdpdGggdGhlIHNhbWUgZmllbGRzIGFzIFRlc3RQ +YWNrZWRUeXBlcywgYnV0IHdpdGhvdXQgcGFja2luZy4gVXNlZAogdG8gdGVz +dCBwYWNrZWQgPC0+IHVucGFja2VkIHdpcmUgY29tcGF0aWJpbGl0eS4KCgsK +AwQqARIE1gUIGQoMCgQEKgIAEgTXBQI9Cg0KBQQqAgAEEgTXBQIKCg0KBQQq +AgAFEgTXBQ4TCg0KBQQqAgABEgTXBRQiCg0KBQQqAgADEgTXBSkrCg0KBQQq +AgAIEgTXBSw8Cg4KBgQqAgAIAhIE1wUtOwoMCgQEKgIBEgTYBQI9Cg0KBQQq +AgEEEgTYBQIKCg0KBQQqAgEFEgTYBQ4TCg0KBQQqAgEBEgTYBRQiCg0KBQQq +AgEDEgTYBSkrCg0KBQQqAgEIEgTYBSw8Cg4KBgQqAgEIAhIE2AUtOwoMCgQE +KgICEgTZBQI9Cg0KBQQqAgIEEgTZBQIKCg0KBQQqAgIFEgTZBQ0TCg0KBQQq +AgIBEgTZBRQjCg0KBQQqAgIDEgTZBSkrCg0KBQQqAgIIEgTZBSw8Cg4KBgQq +AgIIAhIE2QUtOwoMCgQEKgIDEgTaBQI9Cg0KBQQqAgMEEgTaBQIKCg0KBQQq +AgMFEgTaBQ0TCg0KBQQqAgMBEgTaBRQjCg0KBQQqAgMDEgTaBSkrCg0KBQQq +AgMIEgTaBSw8Cg4KBgQqAgMIAhIE2gUtOwoMCgQEKgIEEgTbBQI9Cg0KBQQq +AgQEEgTbBQIKCg0KBQQqAgQFEgTbBQ0TCg0KBQQqAgQBEgTbBRQjCg0KBQQq +AgQDEgTbBSkrCg0KBQQqAgQIEgTbBSw8Cg4KBgQqAgQIAhIE2wUtOwoMCgQE +KgIFEgTcBQI9Cg0KBQQqAgUEEgTcBQIKCg0KBQQqAgUFEgTcBQ0TCg0KBQQq +AgUBEgTcBRQjCg0KBQQqAgUDEgTcBSkrCg0KBQQqAgUIEgTcBSw8Cg4KBgQq +AgUIAhIE3AUtOwoMCgQEKgIGEgTdBQI9Cg0KBQQqAgYEEgTdBQIKCg0KBQQq +AgYFEgTdBQwTCg0KBQQqAgYBEgTdBRQkCg0KBQQqAgYDEgTdBSkrCg0KBQQq +AgYIEgTdBSw8Cg4KBgQqAgYIAhIE3QUtOwoMCgQEKgIHEgTeBQI9Cg0KBQQq +AgcEEgTeBQIKCg0KBQQqAgcFEgTeBQwTCg0KBQQqAgcBEgTeBRQkCg0KBQQq +AgcDEgTeBSkrCg0KBQQqAgcIEgTeBSw8Cg4KBgQqAgcIAhIE3gUtOwoMCgQE +KgIIEgTfBQI9Cg0KBQQqAggEEgTfBQIKCg0KBQQqAggFEgTfBQsTCg0KBQQq +AggBEgTfBRQlCg0KBQQqAggDEgTfBSkrCg0KBQQqAggIEgTfBSw8Cg4KBgQq +AggIAhIE3wUtOwoMCgQEKgIJEgTgBQI9Cg0KBQQqAgkEEgTgBQIKCg0KBQQq +AgkFEgTgBQsTCg0KBQQqAgkBEgTgBRQlCg0KBQQqAgkDEgTgBSkrCg0KBQQq +AgkIEgTgBSw8Cg4KBgQqAgkIAhIE4AUtOwoMCgQEKgIKEgThBQI9Cg0KBQQq +AgoEEgThBQIKCg0KBQQqAgoFEgThBQ4TCg0KBQQqAgoBEgThBRQiCg0KBQQq +AgoDEgThBSgrCg0KBQQqAgoIEgThBSw8Cg4KBgQqAgoIAhIE4QUtOwoMCgQE +KgILEgTiBQI9Cg0KBQQqAgsEEgTiBQIKCg0KBQQqAgsFEgTiBQ0TCg0KBQQq +AgsBEgTiBRQjCg0KBQQqAgsDEgTiBSgrCg0KBQQqAgsIEgTiBSw8Cg4KBgQq +AgsIAhIE4gUtOwoMCgQEKgIMEgTjBQI9Cg0KBQQqAgwEEgTjBQIKCg0KBQQq +AgwFEgTjBQ8TCg0KBQQqAgwBEgTjBRQhCg0KBQQqAgwDEgTjBSgrCg0KBQQq +AgwIEgTjBSw8Cg4KBgQqAgwIAhIE4wUtOwoMCgQEKgINEgTkBQI9Cg0KBQQq +Ag0EEgTkBQIKCg0KBQQqAg0GEgTkBQsWCg0KBQQqAg0BEgTkBRckCg0KBQQq +Ag0DEgTkBSgrCg0KBQQqAg0IEgTkBSw8Cg4KBgQqAg0IAhIE5AUtOwoMCgIE +KxIG5wUA6QUBCgsKAwQrARIE5wUIHAoLCgMEKwUSBOgFAhYKDAoEBCsFABIE +6AUNFQoNCgUEKwUAARIE6AUNDgoNCgUEKwUAAhIE6AUSFQoLCgEHEgbrBQD6 +BQEKCgoCB00SBOwFAkQKCwoDB00CEgTrBQcbCgsKAwdNBBIE7AUCCgoLCgMH +TQUSBOwFDhMKCwoDB00BEgTsBRQqCgsKAwdNAxIE7AUxMwoLCgMHTQgSBOwF +NEMKDAoEB00IAhIE7AU1QgoKCgIHThIE7QUCRAoLCgMHTgISBOsFBxsKCwoD +B04EEgTtBQIKCgsKAwdOBRIE7QUOEwoLCgMHTgESBO0FFCoKCwoDB04DEgTt +BTEzCgsKAwdOCBIE7QU0QwoMCgQHTggCEgTtBTVCCgoKAgdPEgTuBQJECgsK +AwdPAhIE6wUHGwoLCgMHTwQSBO4FAgoKCwoDB08FEgTuBQ0TCgsKAwdPARIE +7gUUKwoLCgMHTwMSBO4FMTMKCwoDB08IEgTuBTRDCgwKBAdPCAISBO4FNUIK +CgoCB1ASBO8FAkQKCwoDB1ACEgTrBQcbCgsKAwdQBBIE7wUCCgoLCgMHUAUS +BO8FDRMKCwoDB1ABEgTvBRQrCgsKAwdQAxIE7wUxMwoLCgMHUAgSBO8FNEMK +DAoEB1AIAhIE7wU1QgoKCgIHURIE8AUCRAoLCgMHUQISBOsFBxsKCwoDB1EE +EgTwBQIKCgsKAwdRBRIE8AUNEwoLCgMHUQESBPAFFCsKCwoDB1EDEgTwBTEz +CgsKAwdRCBIE8AU0QwoMCgQHUQgCEgTwBTVCCgoKAgdSEgTxBQJECgsKAwdS +AhIE6wUHGwoLCgMHUgQSBPEFAgoKCwoDB1IFEgTxBQ0TCgsKAwdSARIE8QUU +KwoLCgMHUgMSBPEFMTMKCwoDB1IIEgTxBTRDCgwKBAdSCAISBPEFNUIKCgoC +B1MSBPIFAkQKCwoDB1MCEgTrBQcbCgsKAwdTBBIE8gUCCgoLCgMHUwUSBPIF +DBMKCwoDB1MBEgTyBRQsCgsKAwdTAxIE8gUxMwoLCgMHUwgSBPIFNEMKDAoE +B1MIAhIE8gU1QgoKCgIHVBIE8wUCRAoLCgMHVAISBOsFBxsKCwoDB1QEEgTz +BQIKCgsKAwdUBRIE8wUMEwoLCgMHVAESBPMFFCwKCwoDB1QDEgTzBTEzCgsK +AwdUCBIE8wU0QwoMCgQHVAgCEgTzBTVCCgoKAgdVEgT0BQJECgsKAwdVAhIE +6wUHGwoLCgMHVQQSBPQFAgoKCwoDB1UFEgT0BQsTCgsKAwdVARIE9AUULQoL +CgMHVQMSBPQFMTMKCwoDB1UIEgT0BTRDCgwKBAdVCAISBPQFNUIKCgoCB1YS +BPUFAkQKCwoDB1YCEgTrBQcbCgsKAwdWBBIE9QUCCgoLCgMHVgUSBPUFCxMK +CwoDB1YBEgT1BRQtCgsKAwdWAxIE9QUxMwoLCgMHVggSBPUFNEMKDAoEB1YI +AhIE9QU1QgoKCgIHVxIE9gUCRAoLCgMHVwISBOsFBxsKCwoDB1cEEgT2BQIK +CgsKAwdXBRIE9gUOEwoLCgMHVwESBPYFFCoKCwoDB1cDEgT2BTAzCgsKAwdX +CBIE9gU0QwoMCgQHVwgCEgT2BTVCCgoKAgdYEgT3BQJECgsKAwdYAhIE6wUH +GwoLCgMHWAQSBPcFAgoKCwoDB1gFEgT3BQ0TCgsKAwdYARIE9wUUKwoLCgMH +WAMSBPcFMDMKCwoDB1gIEgT3BTRDCgwKBAdYCAISBPcFNUIKCgoCB1kSBPgF +AkQKCwoDB1kCEgTrBQcbCgsKAwdZBBIE+AUCCgoLCgMHWQUSBPgFDxMKCwoD +B1kBEgT4BRQpCgsKAwdZAxIE+AUwMwoLCgMHWQgSBPgFNEMKDAoEB1kIAhIE ++AU1QgoKCgIHWhIE+QUCRAoLCgMHWgISBOsFBxsKCwoDB1oEEgT5BQIKCgsK +AwdaBhIE+QULFgoLCgMHWgESBPkFFywKCwoDB1oDEgT5BTAzCgsKAwdaCBIE ++QU0QwoMCgQHWggCEgT5BTVCCgwKAgQsEgb8BQD+BQEKCwoDBCwBEgT8BQge +CgsKAwQsBRIE/QUCFgoMCgQELAUAEgT9BQ0VCg0KBQQsBQABEgT9BQ0OCg0K +BQQsBQACEgT9BRIVCgsKAQcSBoAGAI8GAQoKCgIHWxIEgQYCRwoLCgMHWwIS +BIAGBx0KCwoDB1sEEgSBBgIKCgsKAwdbBRIEgQYOEwoLCgMHWwESBIEGFCwK +CwoDB1sDEgSBBjM1CgsKAwdbCBIEgQY2RgoMCgQHWwgCEgSBBjdFCgoKAgdc +EgSCBgJHCgsKAwdcAhIEgAYHHQoLCgMHXAQSBIIGAgoKCwoDB1wFEgSCBg4T +CgsKAwdcARIEggYULAoLCgMHXAMSBIIGMzUKCwoDB1wIEgSCBjZGCgwKBAdc +CAISBIIGN0UKCgoCB10SBIMGAkcKCwoDB10CEgSABgcdCgsKAwddBBIEgwYC +CgoLCgMHXQUSBIMGDRMKCwoDB10BEgSDBhQtCgsKAwddAxIEgwYzNQoLCgMH +XQgSBIMGNkYKDAoEB10IAhIEgwY3RQoKCgIHXhIEhAYCRwoLCgMHXgISBIAG +Bx0KCwoDB14EEgSEBgIKCgsKAwdeBRIEhAYNEwoLCgMHXgESBIQGFC0KCwoD +B14DEgSEBjM1CgsKAwdeCBIEhAY2RgoMCgQHXggCEgSEBjdFCgoKAgdfEgSF +BgJHCgsKAwdfAhIEgAYHHQoLCgMHXwQSBIUGAgoKCwoDB18FEgSFBg0TCgsK +AwdfARIEhQYULQoLCgMHXwMSBIUGMzUKCwoDB18IEgSFBjZGCgwKBAdfCAIS +BIUGN0UKCgoCB2ASBIYGAkcKCwoDB2ACEgSABgcdCgsKAwdgBBIEhgYCCgoL +CgMHYAUSBIYGDRMKCwoDB2ABEgSGBhQtCgsKAwdgAxIEhgYzNQoLCgMHYAgS +BIYGNkYKDAoEB2AIAhIEhgY3RQoKCgIHYRIEhwYCRwoLCgMHYQISBIAGBx0K +CwoDB2EEEgSHBgIKCgsKAwdhBRIEhwYMEwoLCgMHYQESBIcGFC4KCwoDB2ED +EgSHBjM1CgsKAwdhCBIEhwY2RgoMCgQHYQgCEgSHBjdFCgoKAgdiEgSIBgJH +CgsKAwdiAhIEgAYHHQoLCgMHYgQSBIgGAgoKCwoDB2IFEgSIBgwTCgsKAwdi +ARIEiAYULgoLCgMHYgMSBIgGMzUKCwoDB2IIEgSIBjZGCgwKBAdiCAISBIgG +N0UKCgoCB2MSBIkGAkcKCwoDB2MCEgSABgcdCgsKAwdjBBIEiQYCCgoLCgMH +YwUSBIkGCxMKCwoDB2MBEgSJBhQvCgsKAwdjAxIEiQYzNQoLCgMHYwgSBIkG +NkYKDAoEB2MIAhIEiQY3RQoKCgIHZBIEigYCRwoLCgMHZAISBIAGBx0KCwoD +B2QEEgSKBgIKCgsKAwdkBRIEigYLEwoLCgMHZAESBIoGFC8KCwoDB2QDEgSK +BjM1CgsKAwdkCBIEigY2RgoMCgQHZAgCEgSKBjdFCgoKAgdlEgSLBgJHCgsK +AwdlAhIEgAYHHQoLCgMHZQQSBIsGAgoKCwoDB2UFEgSLBg4TCgsKAwdlARIE +iwYULAoLCgMHZQMSBIsGMjUKCwoDB2UIEgSLBjZGCgwKBAdlCAISBIsGN0UK +CgoCB2YSBIwGAkcKCwoDB2YCEgSABgcdCgsKAwdmBBIEjAYCCgoLCgMHZgUS +BIwGDRMKCwoDB2YBEgSMBhQtCgsKAwdmAxIEjAYyNQoLCgMHZggSBIwGNkYK +DAoEB2YIAhIEjAY3RQoKCgIHZxIEjQYCRwoLCgMHZwISBIAGBx0KCwoDB2cE +EgSNBgIKCgsKAwdnBRIEjQYPEwoLCgMHZwESBI0GFCsKCwoDB2cDEgSNBjI1 +CgsKAwdnCBIEjQY2RgoMCgQHZwgCEgSNBjdFCgoKAgdoEgSOBgJHCgsKAwdo +AhIEgAYHHQoLCgMHaAQSBI4GAgoKCwoDB2gGEgSOBgsWCgsKAwdoARIEjgYX +LgoLCgMHaAMSBI4GMjUKCwoDB2gIEgSOBjZGCgwKBAdoCAISBI4GN0UKuAEK +AgQtEgaUBgCnBgEaqQEgVXNlZCBieSBFeHRlbnNpb25TZXRUZXN0L0R5bmFt +aWNFeHRlbnNpb25zLiAgVGhlIHRlc3QgYWN0dWFsbHkgYnVpbGRzCiBhIHNl +dCBvZiBleHRlbnNpb25zIHRvIFRlc3RBbGxFeHRlbnNpb25zIGR5bmFtaWNh +bGx5LCBiYXNlZCBvbiB0aGUgZmllbGRzCiBvZiB0aGlzIG1lc3NhZ2UgdHlw +ZS4KCgsKAwQtARIElAYIHQoOCgQELQQAEgaVBgKZBgMKDQoFBC0EAAESBJUG +BxYKDgoGBC0EAAIAEgSWBgQXCg8KBwQtBAACAAESBJYGBA8KDwoHBC0EAAIA +AhIElgYSFgoOCgYELQQAAgESBJcGBBcKDwoHBC0EAAIBARIElwYEDwoPCgcE +LQQAAgECEgSXBhIWCg4KBgQtBAACAhIEmAYEFwoPCgcELQQAAgIBEgSYBgQP +Cg8KBwQtBAACAgISBJgGEhYKDgoEBC0DABIGmgYCnAYDCg0KBQQtAwABEgSa +BgocCg4KBgQtAwACABIEmwYEKAoPCgcELQMAAgAEEgSbBgQMCg8KBwQtAwAC +AAUSBJsGDRIKDwoHBC0DAAIAARIEmwYTIAoPCgcELQMAAgADEgSbBiMnCgwK +BAQtAgASBJ4GAisKDQoFBC0CAAQSBJ4GAgoKDQoFBC0CAAUSBJ4GCxIKDQoF +BC0CAAESBJ4GEyMKDQoFBC0CAAMSBJ4GJioKDAoEBC0CARIEnwYCLQoNCgUE +LQIBBBIEnwYCCgoNCgUELQIBBhIEnwYLFgoNCgUELQIBARIEnwYXJQoNCgUE +LQIBAxIEnwYoLAoMCgQELQICEgSgBgI5Cg0KBQQtAgIEEgSgBgIKCg0KBQQt +AgIGEgSgBgsaCg0KBQQtAgIBEgSgBhsxCg0KBQQtAgIDEgSgBjQ4CgwKBAQt +AgMSBKIGAjMKDQoFBC0CAwQSBKIGAgoKDQoFBC0CAwYSBKIGCxkKDQoFBC0C +AwESBKIGGisKDQoFBC0CAwMSBKIGLjIKDAoEBC0CBBIEowYCPwoNCgUELQIE +BBIEowYCCgoNCgUELQIEBhIEowYLHQoNCgUELQIEARIEowYeNwoNCgUELQIE +AxIEowY6PgoMCgQELQIFEgSlBgIsCg0KBQQtAgUEEgSlBgIKCg0KBQQtAgUF +EgSlBgsRCg0KBQQtAgUBEgSlBhIkCg0KBQQtAgUDEgSlBicrCgwKBAQtAgYS +BKYGAjoKDQoFBC0CBgQSBKYGAgoKDQoFBC0CBgUSBKYGCxEKDQoFBC0CBgES +BKYGEiIKDQoFBC0CBgMSBKYGJSkKDQoFBC0CBggSBKYGKjkKDgoGBC0CBggC +EgSmBis4CgwKAgQuEgapBgC4BgEKCwoDBC4BEgSpBggrCs8BCgQELgIAEgSt +BgIpGsABIFBhcnNpbmcgcmVwZWF0ZWQgZml4ZWQgc2l6ZSB2YWx1ZXMgdXNl +ZCB0byBmYWlsLiBUaGlzIG1lc3NhZ2UgbmVlZHMgdG8gYmUKIHVzZWQgaW4g +b3JkZXIgdG8gZ2V0IGEgdGFnIG9mIHRoZSByaWdodCBzaXplOyBhbGwgb2Yg +dGhlIHJlcGVhdGVkIGZpZWxkcwogaW4gVGVzdEFsbFR5cGVzIGRpZG4ndCB0 +cmlnZ2VyIHRoZSBjaGVjay4KCg0KBQQuAgAEEgStBgIKCg0KBQQuAgAFEgSt +BgsSCg0KBQQuAgABEgStBhMjCg0KBQQuAgADEgStBiYoCj8KBAQuAgESBK8G +AikaMSBDaGVjayBmb3IgYSB2YXJpbnQgdHlwZSwganVzdCBmb3IgZ29vZCBt +ZWFzdXJlLgoKDQoFBC4CAQQSBK8GAgoKDQoFBC4CAQUSBK8GCxAKDQoFBC4C +AQESBK8GEyEKDQoFBC4CAQMSBK8GJigKKQoEBC4CAhIEsgYCKxobIFRoZXNl +IGhhdmUgdHdvLWJ5dGUgdGFncy4KCg0KBQQuAgIEEgSyBgIKCg0KBQQuAgIF +EgSyBgsSCg0KBQQuAgIBEgSyBhMjCg0KBQQuAgIDEgSyBiYqCgwKBAQuAgMS +BLMGAisKDQoFBC4CAwQSBLMGAgoKDQoFBC4CAwUSBLMGCxAKDQoFBC4CAwES +BLMGEyEKDQoFBC4CAwMSBLMGJioKIAoEBC4CBBIEtgYCLRoSIFRocmVlIGJ5 +dGUgdGFncy4KCg0KBQQuAgQEEgS2BgIKCg0KBQQuAgQFEgS2BgsQCg0KBQQu +AgQBEgS2BhMhCg0KBQQuAgQDEgS2BiYsCgwKBAQuAgUSBLcGAi0KDQoFBC4C +BQQSBLcGAgoKDQoFBC4CBQUSBLcGCxEKDQoFBC4CBQESBLcGEyIKDQoFBC4C +BQMSBLcGJiwKhgEKAgQvEga8BgDdBgEaeCBUZXN0IHRoYXQgaWYgYW4gb3B0 +aW9uYWwgb3IgcmVxdWlyZWQgbWVzc2FnZS9ncm91cCBmaWVsZCBhcHBlYXJz +IG11bHRpcGxlCiB0aW1lcyBpbiB0aGUgaW5wdXQsIHRoZXkgbmVlZCB0byBi +ZSBtZXJnZWQuCgoLCgMELwESBLwGCBgK/gIKBAQvAwASBsIGAs4GAxrtAiBS +ZXBlYXRlZEZpZWxkc0dlbmVyYXRvciBkZWZpbmVzIG1hdGNoaW5nIGZpZWxk +IHR5cGVzIGFzIFRlc3RQYXJzaW5nTWVyZ2UsCiBleGNlcHQgdGhhdCBhbGwg +ZmllbGRzIGFyZSByZXBlYXRlZC4gSW4gdGhlIHRlc3RzLCB3ZSB3aWxsIHNl +cmlhbGl6ZSB0aGUKIFJlcGVhdGVkRmllbGRzR2VuZXJhdG9yIHRvIGJ5dGVz +LCBhbmQgcGFyc2UgdGhlIGJ5dGVzIHRvIFRlc3RQYXJzaW5nTWVyZ2UuCiBS +ZXBlYXRlZCBmaWVsZHMgaW4gUmVwZWF0ZWRGaWVsZHNHZW5lcmF0b3IgYXJl +IGV4cGVjdGVkIHRvIGJlIG1lcmdlZCBpbnRvCiB0aGUgY29ycmVzcG9uZGlu +ZyByZXF1aXJlZC9vcHRpb25hbCBmaWVsZHMgaW4gVGVzdFBhcnNpbmdNZXJn +ZS4KCg0KBQQvAwABEgTCBgohCg4KBgQvAwACABIEwwYEJQoPCgcELwMAAgAE +EgTDBgQMCg8KBwQvAwACAAYSBMMGDRkKDwoHBC8DAAIAARIEwwYaIAoPCgcE +LwMAAgADEgTDBiMkCg4KBgQvAwACARIExAYEJQoPCgcELwMAAgEEEgTEBgQM +Cg8KBwQvAwACAQYSBMQGDRkKDwoHBC8DAAIBARIExAYaIAoPCgcELwMAAgED +EgTEBiMkCg4KBgQvAwACAhIExQYEJQoPCgcELwMAAgIEEgTFBgQMCg8KBwQv +AwACAgYSBMUGDRkKDwoHBC8DAAICARIExQYaIAoPCgcELwMAAgIDEgTFBiMk +ChAKBgQvAwACAxIGxgYEyAYFCg8KBwQvAwACAwQSBMYGBAwKDwoHBC8DAAID +BRIExgYNEgoPCgcELwMAAgMBEgTGBhMZCg8KBwQvAwACAwMSBMYGHB4KEAoG +BC8DAAMAEgbGBgTIBgUKDwoHBC8DAAMAARIExgYTGQoPCgcELwMAAgMGEgTG +BhMZChAKCAQvAwADAAIAEgTHBgYoChEKCQQvAwADAAIABBIExwYGDgoRCgkE +LwMAAwACAAYSBMcGDxsKEQoJBC8DAAMAAgABEgTHBhwiChEKCQQvAwADAAIA +AxIExwYlJwoQCgYELwMAAgQSBskGBMsGBQoPCgcELwMAAgQEEgTJBgQMCg8K +BwQvAwACBAUSBMkGDRIKDwoHBC8DAAIEARIEyQYTGQoPCgcELwMAAgQDEgTJ +BhweChAKBgQvAwADARIGyQYEywYFCg8KBwQvAwADAQESBMkGExkKDwoHBC8D +AAIEBhIEyQYTGQoQCggELwMAAwECABIEygYGKAoRCgkELwMAAwECAAQSBMoG +Bg4KEQoJBC8DAAMBAgAGEgTKBg8bChEKCQQvAwADAQIAARIEygYcIgoRCgkE +LwMAAwECAAMSBMoGJScKDgoGBC8DAAIFEgTMBgQmCg8KBwQvAwACBQQSBMwG +BAwKDwoHBC8DAAIFBhIEzAYNGQoPCgcELwMAAgUBEgTMBhoeCg8KBwQvAwAC +BQMSBMwGISUKDgoGBC8DAAIGEgTNBgQmCg8KBwQvAwACBgQSBM0GBAwKDwoH +BC8DAAIGBhIEzQYNGQoPCgcELwMAAgYBEgTNBhoeCg8KBwQvAwACBgMSBM0G +ISUKDAoEBC8CABIEzwYCLwoNCgUELwIABBIEzwYCCgoNCgUELwIABhIEzwYL +FwoNCgUELwIAARIEzwYYKgoNCgUELwIAAxIEzwYtLgoMCgQELwIBEgTQBgIv +Cg0KBQQvAgEEEgTQBgIKCg0KBQQvAgEGEgTQBgsXCg0KBQQvAgEBEgTQBhgq +Cg0KBQQvAgEDEgTQBi0uCgwKBAQvAgISBNEGAi8KDQoFBC8CAgQSBNEGAgoK +DQoFBC8CAgYSBNEGCxcKDQoFBC8CAgESBNEGGCoKDQoFBC8CAgMSBNEGLS4K +DgoEBC8CAxIG0gYC1AYDCg0KBQQvAgMEEgTSBgIKCg0KBQQvAgMFEgTSBgsQ +Cg0KBQQvAgMBEgTSBhEeCg0KBQQvAgMDEgTSBiEjCg4KBAQvAwESBtIGAtQG +AwoNCgUELwMBARIE0gYRHgoNCgUELwIDBhIE0gYRHgoOCgYELwMBAgASBNMG +BDgKDwoHBC8DAQIABBIE0wYEDAoPCgcELwMBAgAGEgTTBg0ZCg8KBwQvAwEC +AAESBNMGGjIKDwoHBC8DAQIAAxIE0wY1NwoOCgQELwIEEgbVBgLXBgMKDQoF +BC8CBAQSBNUGAgoKDQoFBC8CBAUSBNUGCxAKDQoFBC8CBAESBNUGER4KDQoF +BC8CBAMSBNUGISMKDgoEBC8DAhIG1QYC1wYDCg0KBQQvAwIBEgTVBhEeCg0K +BQQvAgQGEgTVBhEeCg4KBgQvAwICABIE1gYEOAoPCgcELwMCAgAEEgTWBgQM +Cg8KBwQvAwICAAYSBNYGDRkKDwoHBC8DAgIAARIE1gYaMgoPCgcELwMCAgAD +EgTWBjU3CgsKAwQvBRIE2AYCGQoMCgQELwUAEgTYBg0YCg0KBQQvBQABEgTY +Bg0RCg0KBQQvBQACEgTYBhUYCg0KAwQvBhIG2QYC3AYDCgwKBAQvBgASBNoG +BC4KDQoFBC8GAAISBNkGCRkKDQoFBC8GAAQSBNoGBAwKDQoFBC8GAAYSBNoG +DRkKDQoFBC8GAAESBNoGGiYKDQoFBC8GAAMSBNoGKS0KDAoEBC8GARIE2wYE +LgoNCgUELwYBAhIE2QYJGQoNCgUELwYBBBIE2wYEDAoNCgUELwYBBhIE2wYN +GQoNCgUELwYBARIE2wYaJgoNCgUELwYBAxIE2wYpLQoMCgIEMBIG3wYA4gYB +CgsKAwQwARIE3wYIIwpFCgQEMAIAEgThBgI/GjcgKi8gPC0gVGhpcyBzaG91 +bGQgbm90IGNsb3NlIHRoZSBnZW5lcmF0ZWQgZG9jIGNvbW1lbnQKCg0KBQQw +AgAEEgThBgIKCg0KBQQwAgAFEgThBgsRCg0KBQQwAgABEgThBhITCg0KBQQw +AgADEgThBhYXCg0KBQQwAgAIEgThBhg+Cg0KBQQwAgAHEgThBiE9CioKAgQx +EgTmBgAWGh4gVGVzdCB0aGF0IFJQQyBzZXJ2aWNlcyB3b3JrLgoKCwoDBDEB +EgTmBggSCgoKAgQyEgTnBgAWCgsKAwQyARIE5wYIEwoKCgIEMxIE6QYAGwoL +CgMEMwESBOkGCBgKCgoCBDQSBOoGABoKCwoDBDQBEgTqBggYCgwKAgYAEgbs +BgDvBgEKCwoDBgABEgTsBggTCgwKBAYAAgASBO0GAiwKDQoFBgACAAESBO0G +BgkKDQoFBgACAAISBO0GChQKDQoFBgACAAMSBO0GHyoKDAoEBgACARIE7gYC +LAoNCgUGAAIBARIE7gYGCQoNCgUGAAIBAhIE7gYKFAoNCgUGAAIBAxIE7gYf +KgoKCgIENRIE8gYAFgoLCgMENQESBPIGCBIKCgoCBDYSBPMGABYKCwoDBDYB +EgTzBggT diff --git a/spec/support/protos/google_unittest_custom_options.pb.rb b/spec/support/protos/google_unittest_custom_options.pb.rb index 9ca77aee..624d5b37 100644 --- a/spec/support/protos/google_unittest_custom_options.pb.rb +++ b/spec/support/protos/google_unittest_custom_options.pb.rb @@ -1,8 +1,11 @@ # encoding: utf-8 +# frozen_string_literal: true ## # This file is auto-generated. DO NOT EDIT! # +require 'base64' +require 'set' require 'protobuf' require 'protobuf/rpc/service' @@ -13,17 +16,43 @@ require 'google/protobuf/descriptor.pb' module Protobuf_unittest + FULLY_QUALIFIED_NAME = 'protobuf_unittest' unless defined?(self::FULLY_QUALIFIED_NAME) + + @descriptors = [] unless instance_variable_defined?(:@descriptors) + @descriptors << lambda do + bytes = File.read(__FILE__, mode: 'rb').split(/^__END__$/, 2).last + ::Google::Protobuf::FileDescriptorProto.decode(Base64.decode64(bytes)) + end + + @descriptor_dependencies = Set.new unless instance_variable_defined?(:@descriptor_dependencies) + @descriptor_dependencies |= [Google::Protobuf] + + unless respond_to?(:descriptor_set) + def self.descriptor_set + ::Google::Protobuf::FileDescriptorSet.new(:file => @descriptors.map(&:call)) + end + end + + unless respond_to?(:descriptor_dependencies) + def self.descriptor_dependencies + @descriptor_dependencies + end + end ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions } ## # Enum Classes # class MethodOpt1 < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.MethodOpt1' + define :METHODOPT1_VAL1, 1 define :METHODOPT1_VAL2, 2 end class AggregateEnum < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.AggregateEnum' + set_option :".protobuf_unittest.enumopt", { :s => "EnumAnnotation" } define :VALUE, 1 @@ -35,6 +64,8 @@ class AggregateEnum < ::Protobuf::Enum # class TestMessageWithCustomOptions < ::Protobuf::Message class AnEnum < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.AnEnum' + set_option :".protobuf_unittest.enum_opt1", -789 define :ANENUM_VAL1, 1 @@ -49,6 +80,8 @@ class CustomOptionFooClientMessage < ::Protobuf::Message; end class CustomOptionFooServerMessage < ::Protobuf::Message; end class DummyMessageContainingEnum < ::Protobuf::Message class TestEnumType < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestEnumType' + define :TEST_OPTION_ENUM_TYPE1, 22 define :TEST_OPTION_ENUM_TYPE2, -23 end @@ -75,6 +108,8 @@ class Aggregate < ::Protobuf::Message; end class AggregateMessage < ::Protobuf::Message; end class NestedOptionType < ::Protobuf::Message class NestedEnum < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.NestedEnum' + set_option :".protobuf_unittest.enum_opt1", 1003 define :NESTED_ENUM_VALUE, 1 @@ -86,6 +121,8 @@ class NestedMessage < ::Protobuf::Message; end class OldOptionType < ::Protobuf::Message class TestEnum < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestEnum' + define :OLD_VALUE, 0 end @@ -93,6 +130,8 @@ class TestEnum < ::Protobuf::Enum class NewOptionType < ::Protobuf::Message class TestEnum < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestEnum' + define :OLD_VALUE, 0 define :NEW_VALUE, 1 end @@ -116,6 +155,7 @@ class TestMessageWithRequiredEnumOption < ::Protobuf::Message; end # Message Fields # class TestMessageWithCustomOptions + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestMessageWithCustomOptions' # Message Options set_option :message_set_wire_format, false set_option :".protobuf_unittest.message_opt1", -56 @@ -124,6 +164,7 @@ class TestMessageWithCustomOptions end class CustomOptionMinIntegerValues + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.CustomOptionMinIntegerValues' # Message Options set_option :".protobuf_unittest.sfixed64_opt", -9223372036854775808 set_option :".protobuf_unittest.sfixed32_opt", -2147483648 @@ -140,6 +181,7 @@ class CustomOptionMinIntegerValues end class CustomOptionMaxIntegerValues + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.CustomOptionMaxIntegerValues' # Message Options set_option :".protobuf_unittest.sfixed64_opt", 9223372036854775807 set_option :".protobuf_unittest.sfixed32_opt", 2147483647 @@ -156,6 +198,7 @@ class CustomOptionMaxIntegerValues end class CustomOptionOtherValues + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.CustomOptionOtherValues' # Message Options set_option :".protobuf_unittest.enum_opt", ::Protobuf_unittest::DummyMessageContainingEnum::TestEnumType::TEST_OPTION_ENUM_TYPE2 set_option :".protobuf_unittest.bytes_opt", "Hello\x00World" @@ -167,6 +210,7 @@ class CustomOptionOtherValues end class SettingRealsFromPositiveInts + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.SettingRealsFromPositiveInts' # Message Options set_option :".protobuf_unittest.double_opt", 154.0 set_option :".protobuf_unittest.float_opt", 12.0 @@ -174,6 +218,7 @@ class SettingRealsFromPositiveInts end class SettingRealsFromNegativeInts + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.SettingRealsFromNegativeInts' # Message Options set_option :".protobuf_unittest.double_opt", -154.0 set_option :".protobuf_unittest.float_opt", -12.0 @@ -181,6 +226,7 @@ class SettingRealsFromNegativeInts end class ComplexOptionType1 + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ComplexOptionType1' optional :int32, :foo, 1 optional :int32, :foo2, 2 optional :int32, :foo3, 3 @@ -192,7 +238,9 @@ class ComplexOptionType1 end class ComplexOptionType2 + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ComplexOptionType2' class ComplexOptionType4 + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ComplexOptionType4' optional :int32, :waldo, 1 end @@ -207,10 +255,12 @@ class ComplexOptionType4 end class ComplexOptionType3 + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ComplexOptionType3' optional :int32, :qux, 1 end class VariousComplexOptions + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.VariousComplexOptions' # Message Options set_option :".protobuf_unittest.ComplexOptionType2.ComplexOptionType4.complex_opt4", { :waldo => 1971 } set_option :".protobuf_unittest.complex_opt3", { :qux => 9 } @@ -222,6 +272,7 @@ class VariousComplexOptions end class AggregateMessageSet + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.AggregateMessageSet' # Message Options set_option :message_set_wire_format, false @@ -231,10 +282,12 @@ class AggregateMessageSet end class AggregateMessageSetElement + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.AggregateMessageSetElement' optional :string, :s, 1 end class Aggregate + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Aggregate' optional :int32, :i, 1 optional :string, :s, 2 optional ::Protobuf_unittest::Aggregate, :sub, 3 @@ -243,6 +296,7 @@ class Aggregate end class AggregateMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.AggregateMessage' # Message Options set_option :".protobuf_unittest.msgopt", { :i => 101, :s => "MessageAnnotation" } @@ -250,7 +304,9 @@ class AggregateMessage end class NestedOptionType + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.NestedOptionType' class NestedMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.NestedMessage' # Message Options set_option :".protobuf_unittest.message_opt1", 1001 @@ -260,14 +316,17 @@ class NestedMessage end class OldOptionType + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.OldOptionType' required ::Protobuf_unittest::OldOptionType::TestEnum, :value, 1 end class NewOptionType + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.NewOptionType' required ::Protobuf_unittest::NewOptionType::TestEnum, :value, 1 end class TestMessageWithRequiredEnumOption + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestMessageWithRequiredEnumOption' # Message Options set_option :".protobuf_unittest.required_enum_opt", { :value => ::Protobuf_unittest::OldOptionType::TestEnum::OLD_VALUE } @@ -344,6 +403,8 @@ class ::Google::Protobuf::MethodOptions < ::Protobuf::Message # Service Classes # class TestServiceWithCustomOptions < ::Protobuf::Rpc::Service + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.TestServiceWithCustomOptions' + set_option :".protobuf_unittest.service_opt1", -9876543210 rpc :foo, ::Protobuf_unittest::CustomOptionFooRequest, ::Protobuf_unittest::CustomOptionFooResponse do set_option :".protobuf_unittest.method_opt1", ::Protobuf_unittest::MethodOpt1::METHODOPT1_VAL2 @@ -351,6 +412,8 @@ class TestServiceWithCustomOptions < ::Protobuf::Rpc::Service end class AggregateService < ::Protobuf::Rpc::Service + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.AggregateService' + set_option :".protobuf_unittest.serviceopt", { :s => "ServiceAnnotation" } rpc :method, ::Protobuf_unittest::AggregateMessage, ::Protobuf_unittest::AggregateMessage do set_option :".protobuf_unittest.methodopt", { :s => "MethodAnnotation" } @@ -359,3 +422,460 @@ class AggregateService < ::Protobuf::Rpc::Service end + +# Raw descriptor bytes below +__END__ +Citwcm90b3MvZ29vZ2xlX3VuaXR0ZXN0X2N1c3RvbV9vcHRpb25zLnByb3Rv +EhFwcm90b2J1Zl91bml0dGVzdBogZ29vZ2xlL3Byb3RvYnVmL2Rlc2NyaXB0 +b3IucHJvdG8ilQEKHFRlc3RNZXNzYWdlV2l0aEN1c3RvbU9wdGlvbnMSJgoG +ZmllbGQxGAEgASgJQg4IAcHgwx0t4XUKAgAAAFIGZmllbGQxIjsKBkFuRW51 +bRIPCgtBTkVOVU1fVkFMMRABEhYKC0FORU5VTV9WQUwyEAIaBbCG+gV7GgjF +9skd6/z//zoQCADg6cIdyP//////////ASIYChZDdXN0b21PcHRpb25Gb29S +ZXF1ZXN0IhkKF0N1c3RvbU9wdGlvbkZvb1Jlc3BvbnNlIh4KHEN1c3RvbU9w +dGlvbkZvb0NsaWVudE1lc3NhZ2UiHgocQ3VzdG9tT3B0aW9uRm9vU2VydmVy +TWVzc2FnZSJtChpEdW1teU1lc3NhZ2VDb250YWluaW5nRW51bSJPCgxUZXN0 +RW51bVR5cGUSGgoWVEVTVF9PUFRJT05fRU5VTV9UWVBFMRAWEiMKFlRFU1Rf +T1BUSU9OX0VOVU1fVFlQRTIQ6f//////////ASIhCh9EdW1teU1lc3NhZ2VJ +bnZhbGlkQXNPcHRpb25UeXBlIooBChxDdXN0b21PcHRpb25NaW5JbnRlZ2Vy +VmFsdWVzOmrQ3rIdAOjGsh2AgICA+P////8BsLyyHYCAgICAgICAgAGAk7Id +APj1sB0AgMSwHf////8P+JewHf///////////wGd9a8dAAAAAJHurx0AAAAA +AAAAAK2Nrx0AAACAmdaoHQAAAAAAAACAIpEBChxDdXN0b21PcHRpb25NYXhJ +bnRlZ2VyVmFsdWVzOnHQ3rIdAejGsh3/////B7C8sh3//////////3+Ak7Id +/////w/49bAd////////////AYDEsB3+////D/iXsB3+//////////8BnfWv +Hf////+R7q8d//////////+tja8d////f5nWqB3/////////fyJuChdDdXN0 +b21PcHRpb25PdGhlclZhbHVlczpT6MayHZz//////////wH136Md54dFQenc +oh37WYxCysDzP6rcoh0OSGVsbG8sICJXb3JsZCKy2aIdC0hlbGxvAFdvcmxk +iNmiHen//////////wEiNAocU2V0dGluZ1JlYWxzRnJvbVBvc2l0aXZlSW50 +czoU9d+jHQAAQEHp3KIdAAAAAABAY0AiNAocU2V0dGluZ1JlYWxzRnJvbU5l +Z2F0aXZlSW50czoU9d+jHQAAQMHp3KIdAAAAAABAY8AibAoSQ29tcGxleE9w +dGlvblR5cGUxEhAKA2ZvbxgBIAEoBVIDZm9vEhIKBGZvbzIYAiABKAVSBGZv +bzISEgoEZm9vMxgDIAEoBVIEZm9vMxISCgRmb280GAQgAygFUgRmb280KggI +ZBCAgICAAiK3AwoSQ29tcGxleE9wdGlvblR5cGUyEjcKA2JhchgBIAEoCzIl +LnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBlMVIDYmFyEhAK +A2JhehgCIAEoBVIDYmF6EkwKBGZyZWQYAyABKAsyOC5wcm90b2J1Zl91bml0 +dGVzdC5Db21wbGV4T3B0aW9uVHlwZTIuQ29tcGxleE9wdGlvblR5cGU0UgRm +cmVkElAKBmJhcm5leRgEIAMoCzI4LnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBs +ZXhPcHRpb25UeXBlMi5Db21wbGV4T3B0aW9uVHlwZTRSBmJhcm5leRqrAQoS +Q29tcGxleE9wdGlvblR5cGU0EhQKBXdhbGRvGAEgASgFUgV3YWxkbzJ/Cgxj +b21wbGV4X29wdDQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMY +ivXRAyABKAsyOC5wcm90b2J1Zl91bml0dGVzdC5Db21wbGV4T3B0aW9uVHlw +ZTIuQ29tcGxleE9wdGlvblR5cGU0Ugtjb21wbGV4T3B0NCoICGQQgICAgAIi +JgoSQ29tcGxleE9wdGlvblR5cGUzEhAKA3F1eBgBIAEoBVIDcXV4Ip8BChVW +YXJpb3VzQ29tcGxleE9wdGlvbnM6hQGi4pUdFAgq2IWeHcQCkvWdHQMI7AYg +YyBYqv2QHUAQ2wf45pcdjgUKEQjnBdiFnh3PD5L1nR0DCNgPwqyXHREI5QXY +hZ4dzg+S9Z0dAwjJEBoDCMECIgIIZSIDCNQB0qiPHQMIsw/63pAdAggJgN+Q +HQGA35AdAorfkB0CCAOK35AdAggEIiMKE0FnZ3JlZ2F0ZU1lc3NhZ2VTZXQq +CAgEEICAgIACOgIIACK5AQoaQWdncmVnYXRlTWVzc2FnZVNldEVsZW1lbnQS +DAoBcxgBIAEoCVIBczKMAQoVbWVzc2FnZV9zZXRfZXh0ZW5zaW9uEiYucHJv +dG9idWZfdW5pdHRlc3QuQWdncmVnYXRlTWVzc2FnZVNldBj2664HIAEoCzIt +LnByb3RvYnVmX3VuaXR0ZXN0LkFnZ3JlZ2F0ZU1lc3NhZ2VTZXRFbGVtZW50 +UhNtZXNzYWdlU2V0RXh0ZW5zaW9uIpwCCglBZ2dyZWdhdGUSDAoBaRgBIAEo +BVIBaRIMCgFzGAIgASgJUgFzEi4KA3N1YhgDIAEoCzIcLnByb3RvYnVmX3Vu +aXR0ZXN0LkFnZ3JlZ2F0ZVIDc3ViEjAKBGZpbGUYBCABKAsyHC5nb29nbGUu +cHJvdG9idWYuRmlsZU9wdGlvbnNSBGZpbGUSOgoEbXNldBgFIAEoCzImLnBy +b3RvYnVmX3VuaXR0ZXN0LkFnZ3JlZ2F0ZU1lc3NhZ2VTZXRSBG1zZXQyVQoG +bmVzdGVkEhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGKfRsAcgASgL +MhwucHJvdG9idWZfdW5pdHRlc3QuQWdncmVnYXRlUgZuZXN0ZWQiZAoQQWdn +cmVnYXRlTWVzc2FnZRI0CglmaWVsZG5hbWUYASABKAVCFvKhhzsREg9GaWVs +ZEFubm90YXRpb25SCWZpZWxkbmFtZToawtGGOxUIZRIRTWVzc2FnZUFubm90 +YXRpb24i5wEKEE5lc3RlZE9wdGlvblR5cGUaSAoNTmVzdGVkTWVzc2FnZRIv +CgxuZXN0ZWRfZmllbGQYASABKAVCDMHgwx3qAwAAAAAAAFILbmVzdGVkRmll +bGQ6BuDpwh3pByI1CgpOZXN0ZWRFbnVtEh0KEU5FU1RFRF9FTlVNX1ZBTFVF +EAEaBrCG+gXsBxoIxfbJHesDAAAyUgoQbmVzdGVkX2V4dGVuc2lvbhIcLmdv +b2dsZS5wcm90b2J1Zi5GaWxlT3B0aW9ucxj9+OIDIAEoBUIGyIvKHe0HUg9u +ZXN0ZWRFeHRlbnNpb24iawoNT2xkT3B0aW9uVHlwZRI/CgV2YWx1ZRgBIAIo +DjIpLnByb3RvYnVmX3VuaXR0ZXN0Lk9sZE9wdGlvblR5cGUuVGVzdEVudW1S +BXZhbHVlIhkKCFRlc3RFbnVtEg0KCU9MRF9WQUxVRRAAInoKDU5ld09wdGlv +blR5cGUSPwoFdmFsdWUYASACKA4yKS5wcm90b2J1Zl91bml0dGVzdC5OZXdP +cHRpb25UeXBlLlRlc3RFbnVtUgV2YWx1ZSIoCghUZXN0RW51bRINCglPTERf +VkFMVUUQABINCglORVdfVkFMVUUQASItCiFUZXN0TWVzc2FnZVdpdGhSZXF1 +aXJlZEVudW1PcHRpb246CPro/JQDAggAKjYKCk1ldGhvZE9wdDESEwoPTUVU +SE9ET1BUMV9WQUwxEAESEwoPTUVUSE9ET1BUMV9WQUwyEAIqTQoNQWdncmVn +YXRlRW51bRIlCgVWQUxVRRABGhrK/Ik7FRITRW51bVZhbHVlQW5ub3RhdGlv +bhoVkpWIOxASDkVudW1Bbm5vdGF0aW9uMo4BChxUZXN0U2VydmljZVdpdGhD +dXN0b21PcHRpb25zEmMKA0ZvbxIpLnByb3RvYnVmX3VuaXR0ZXN0LkN1c3Rv +bU9wdGlvbkZvb1JlcXVlc3QaKi5wcm90b2J1Zl91bml0dGVzdC5DdXN0b21P +cHRpb25Gb29SZXNwb25zZSIF4PqMHgIaCZCyix7T24DLSTKZAQoQQWdncmVn +YXRlU2VydmljZRJrCgZNZXRob2QSIy5wcm90b2J1Zl91bml0dGVzdC5BZ2dy +ZWdhdGVNZXNzYWdlGiMucHJvdG9idWZfdW5pdHRlc3QuQWdncmVnYXRlTWVz +c2FnZSIXysiWOxISEE1ldGhvZEFubm90YXRpb24aGMr7jjsTEhFTZXJ2aWNl +QW5ub3RhdGlvbjo8CglmaWxlX29wdDESHC5nb29nbGUucHJvdG9idWYuRmls +ZU9wdGlvbnMYjp3YAyABKARSCGZpbGVPcHQxOkUKDG1lc3NhZ2Vfb3B0MRIf +Lmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxicrdgDIAEoBVILbWVz +c2FnZU9wdDE6PwoKZmllbGRfb3B0MRIdLmdvb2dsZS5wcm90b2J1Zi5GaWVs +ZE9wdGlvbnMYiLzYAyABKAZSCWZpZWxkT3B0MTpDCgpmaWVsZF9vcHQyEh0u +Z29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucxi5odkDIAEoBToCNDJSCWZp +ZWxkT3B0Mjo8CgllbnVtX29wdDESHC5nb29nbGUucHJvdG9idWYuRW51bU9w +dGlvbnMY6J7ZAyABKA9SCGVudW1PcHQxOksKD2VudW1fdmFsdWVfb3B0MRIh +Lmdvb2dsZS5wcm90b2J1Zi5FbnVtVmFsdWVPcHRpb25zGOagXyABKAVSDWVu +dW1WYWx1ZU9wdDE6RQoMc2VydmljZV9vcHQxEh8uZ29vZ2xlLnByb3RvYnVm +LlNlcnZpY2VPcHRpb25zGKK24QMgASgSUgtzZXJ2aWNlT3B0MTphCgttZXRo +b2Rfb3B0MRIeLmdvb2dsZS5wcm90b2J1Zi5NZXRob2RPcHRpb25zGKzP4QMg +ASgOMh0ucHJvdG9idWZfdW5pdHRlc3QuTWV0aG9kT3B0MVIKbWV0aG9kT3B0 +MTo9Cghib29sX29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9u +cxjqq9YDIAEoCFIHYm9vbE9wdDo/CglpbnQzMl9vcHQSHy5nb29nbGUucHJv +dG9idWYuTWVzc2FnZU9wdGlvbnMY7ajWAyABKAVSCGludDMyT3B0Oj8KCWlu +dDY0X29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxjGp9YD +IAEoA1IIaW50NjRPcHQ6QQoKdWludDMyX29wdBIfLmdvb2dsZS5wcm90b2J1 +Zi5NZXNzYWdlT3B0aW9ucxiwotYDIAEoDVIJdWludDMyT3B0OkEKCnVpbnQ2 +NF9vcHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMY347WAyAB +KARSCXVpbnQ2NE9wdDpBCgpzaW50MzJfb3B0Eh8uZ29vZ2xlLnByb3RvYnVm +Lk1lc3NhZ2VPcHRpb25zGMCI1gMgASgRUglzaW50MzJPcHQ6QQoKc2ludDY0 +X29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxj/gtYDIAEo +ElIJc2ludDY0T3B0OkMKC2ZpeGVkMzJfb3B0Eh8uZ29vZ2xlLnByb3RvYnVm +Lk1lc3NhZ2VPcHRpb25zGNP+1QMgASgHUgpmaXhlZDMyT3B0OkMKC2ZpeGVk +NjRfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGOL91QMg +ASgGUgpmaXhlZDY0T3B0OkUKDHNmaXhlZDMyX29wdBIfLmdvb2dsZS5wcm90 +b2J1Zi5NZXNzYWdlT3B0aW9ucxjV8dUDIAEoD1ILc2ZpeGVkMzJPcHQ6RQoM +c2ZpeGVkNjRfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25z +GOOK1QMgASgQUgtzZml4ZWQ2NE9wdDo/CglmbG9hdF9vcHQSHy5nb29nbGUu +cHJvdG9idWYuTWVzc2FnZU9wdGlvbnMY/rvUAyABKAJSCGZsb2F0T3B0OkEK +CmRvdWJsZV9vcHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMY +zavUAyABKAFSCWRvdWJsZU9wdDpBCgpzdHJpbmdfb3B0Eh8uZ29vZ2xlLnBy +b3RvYnVmLk1lc3NhZ2VPcHRpb25zGMWr1AMgASgJUglzdHJpbmdPcHQ6PwoJ +Ynl0ZXNfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGJar +1AMgASgMUghieXRlc09wdDp5CghlbnVtX29wdBIfLmdvb2dsZS5wcm90b2J1 +Zi5NZXNzYWdlT3B0aW9ucxiRq9QDIAEoDjI6LnByb3RvYnVmX3VuaXR0ZXN0 +LkR1bW15TWVzc2FnZUNvbnRhaW5pbmdFbnVtLlRlc3RFbnVtVHlwZVIHZW51 +bU9wdDqAAQoQbWVzc2FnZV90eXBlX29wdBIfLmdvb2dsZS5wcm90b2J1Zi5N +ZXNzYWdlT3B0aW9ucxiv8tMDIAEoCzIyLnByb3RvYnVmX3VuaXR0ZXN0LkR1 +bW15TWVzc2FnZUludmFsaWRBc09wdGlvblR5cGVSDm1lc3NhZ2VUeXBlT3B0 +OjwKBHF1dXgSJS5wcm90b2J1Zl91bml0dGVzdC5Db21wbGV4T3B0aW9uVHlw +ZTEY2+DTAyABKAVSBHF1dXg6ZQoFY29yZ2USJS5wcm90b2J1Zl91bml0dGVz +dC5Db21wbGV4T3B0aW9uVHlwZTEY0t7TAyABKAsyJS5wcm90b2J1Zl91bml0 +dGVzdC5Db21wbGV4T3B0aW9uVHlwZTNSBWNvcmdlOkAKBmdyYXVsdBIlLnBy +b3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBlMhjv/NIDIAEoBVIG +Z3JhdWx0OmcKBmdhcnBseRIlLnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhP +cHRpb25UeXBlMhjI9dIDIAEoCzIlLnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBs +ZXhPcHRpb25UeXBlMVIGZ2FycGx5OmwKDGNvbXBsZXhfb3B0MRIfLmdvb2ds +ZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxik3NIDIAEoCzIlLnByb3RvYnVm +X3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBlMVILY29tcGxleE9wdDE6bAoM +Y29tcGxleF9vcHQyEh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25z +GNWP0gMgASgLMiUucHJvdG9idWZfdW5pdHRlc3QuQ29tcGxleE9wdGlvblR5 +cGUyUgtjb21wbGV4T3B0MjpsCgxjb21wbGV4X29wdDMSHy5nb29nbGUucHJv +dG9idWYuTWVzc2FnZU9wdGlvbnMY74vSAyABKAsyJS5wcm90b2J1Zl91bml0 +dGVzdC5Db21wbGV4T3B0aW9uVHlwZTNSC2NvbXBsZXhPcHQzOkcKDXJlcGVh +dGVkX29wdDESHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMY8IvS +AyADKAVSDHJlcGVhdGVkT3B0MTpuCg1yZXBlYXRlZF9vcHQyEh8uZ29vZ2xl +LnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGPGL0gMgAygLMiUucHJvdG9idWZf +dW5pdHRlc3QuQ29tcGxleE9wdGlvblR5cGUzUgxyZXBlYXRlZE9wdDI6VwoH +ZmlsZW9wdBIcLmdvb2dsZS5wcm90b2J1Zi5GaWxlT3B0aW9ucxjP3bAHIAEo +CzIcLnByb3RvYnVmX3VuaXR0ZXN0LkFnZ3JlZ2F0ZVIHZmlsZW9wdDpYCgZt +c2dvcHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYmOqwByAB +KAsyHC5wcm90b2J1Zl91bml0dGVzdC5BZ2dyZWdhdGVSBm1zZ29wdDpaCghm +aWVsZG9wdBIdLmdvb2dsZS5wcm90b2J1Zi5GaWVsZE9wdGlvbnMYnvSwByAB +KAsyHC5wcm90b2J1Zl91bml0dGVzdC5BZ2dyZWdhdGVSCGZpZWxkb3B0OlcK +B2VudW1vcHQSHC5nb29nbGUucHJvdG9idWYuRW51bU9wdGlvbnMY0oKxByAB +KAsyHC5wcm90b2J1Zl91bml0dGVzdC5BZ2dyZWdhdGVSB2VudW1vcHQ6YgoK +ZW51bXZhbG9wdBIhLmdvb2dsZS5wcm90b2J1Zi5FbnVtVmFsdWVPcHRpb25z +GMmfsQcgASgLMhwucHJvdG9idWZfdW5pdHRlc3QuQWdncmVnYXRlUgplbnVt +dmFsb3B0OmAKCnNlcnZpY2VvcHQSHy5nb29nbGUucHJvdG9idWYuU2Vydmlj +ZU9wdGlvbnMYue+xByABKAsyHC5wcm90b2J1Zl91bml0dGVzdC5BZ2dyZWdh +dGVSCnNlcnZpY2VvcHQ6XQoJbWV0aG9kb3B0Eh4uZ29vZ2xlLnByb3RvYnVm +Lk1ldGhvZE9wdGlvbnMYiemyByABKAsyHC5wcm90b2J1Zl91bml0dGVzdC5B +Z2dyZWdhdGVSCW1ldGhvZG9wdDpwChFyZXF1aXJlZF9lbnVtX29wdBIfLmdv +b2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxiPzc8yIAEoCzIgLnByb3Rv +YnVmX3VuaXR0ZXN0Lk9sZE9wdGlvblR5cGVSD3JlcXVpcmVkRW51bU9wdEKD +AYABAYgBAZABAfDowR3qrcDlJPrshTtsCGQSDkZpbGVBbm5vdGF0aW9uGhYS +FE5lc3RlZEZpbGVBbm5vdGF0aW9uIh767IU7GRIXRmlsZUV4dGVuc2lvbkFu +bm90YXRpb24qILLf9jobChlFbWJlZGRlZE1lc3NhZ2VTZXRFbGVtZW50Sphp +CgcSBSQApwMBCqIOCgEMEgMkABIywQwgUHJvdG9jb2wgQnVmZmVycyAtIEdv +b2dsZSdzIGRhdGEgaW50ZXJjaGFuZ2UgZm9ybWF0CiBDb3B5cmlnaHQgMjAw +OCBHb29nbGUgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KIGh0dHBzOi8v +ZGV2ZWxvcGVycy5nb29nbGUuY29tL3Byb3RvY29sLWJ1ZmZlcnMvCgogUmVk +aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jt +cywgd2l0aCBvciB3aXRob3V0CiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0 +ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJl +CiBtZXQ6CgogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2Rl +IG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKIG5vdGljZSwgdGhp +cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh +aW1lci4KICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBt +dXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKIGNvcHlyaWdodCBub3RpY2UsIHRo +aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns +YWltZXIKIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl +cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKIGRpc3RyaWJ1dGlvbi4KICAgICAq +IE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1l +cyBvZiBpdHMKIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNl +IG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCiB0aGlzIHNvZnR3 +YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9u +LgoKIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdI +VCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKICJBUyBJUyIgQU5EIEFOWSBF +WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQg +Tk9UCiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1F +UkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKIEEgUEFSVElDVUxBUiBQ +VVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUg +Q09QWVJJR0hUCiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZP +UiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKIFNQRUNJQUws +IEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ +TkcsIEJVVCBOT1QKIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNU +SVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAogREFUQSwg +T1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVS +IENBVVNFRCBBTkQgT04gQU5ZCiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVU +SEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCiAo +SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElO +IEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKIE9GIFRISVMgU09GVFdBUkUsIEVW +RU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B +R0UuCjLTASBBdXRob3I6IGJlbmp5QGdvb2dsZS5jb20gKEJlbmp5IFdlaW5i +ZXJnZXIpCiAgQmFzZWQgb24gb3JpZ2luYWwgUHJvdG9jb2wgQnVmZmVycyBk +ZXNpZ24gYnkKICBTYW5qYXkgR2hlbWF3YXQsIEplZmYgRGVhbiwgYW5kIG90 +aGVycy4KCiBBIHByb3RvIGZpbGUgdXNlZCB0byB0ZXN0IHRoZSAiY3VzdG9t +IG9wdGlvbnMiIGZlYXR1cmUgb2YgZ29vZ2xlLnByb3RvYnVmLgoKCAoBCBID +KAAiCoABCgIIEBIDKAAiGmcgU29tZSBnZW5lcmljX3NlcnZpY2VzIG9wdGlv +bihzKSBhZGRlZCBhdXRvbWF0aWNhbGx5LgogU2VlOiAgaHR0cDovL2dvL3By +b3RvMi1nZW5lcmljLXNlcnZpY2VzLWRlZmF1bHQKIgwgYXV0by1hZGRlZAoK +CAoBCBIDKQAkChcKAggREgMpACQiDCBhdXRvLWFkZGVkCgoICgEIEgMqACIK +CQoCCBISAyoAIgoICgEIEgMtACAKNQoFCI6d2AMSAy0AIBonIEEgY3VzdG9t +IGZpbGUgb3B0aW9uIChkZWZpbmVkIGJlbG93KS4KCgkKAgMAEgMvACoKoAEK +AQISAzMAGhqVASBXZSBkb24ndCBwdXQgdGhpcyBpbiBhIHBhY2thZ2Ugd2l0 +aGluIHByb3RvMiBiZWNhdXNlIHdlIG5lZWQgdG8gbWFrZSBzdXJlCiB0aGF0 +IHRoZSBnZW5lcmF0ZWQgY29kZSBkb2Vzbid0IGRlcGVuZCBvbiBiZWluZyBp +biB0aGUgcHJvdG8yIG5hbWVzcGFjZS4KCj4KAQcSBDgAOgEyMyBTb21lIHNp +bXBsZSB0ZXN0IGN1c3RvbSBvcHRpb25zIG9mIHZhcmlvdXMgdHlwZXMuCgoJ +CgIHABIDOQImCgoKAwcAAhIDOAciCgoKAwcABBIDOQIKCgoKAwcABRIDOQsR +CgoKAwcAARIDORIbCgoKAwcAAxIDOR4lCgkKAQcSBDwAPgEKCQoCBwESAz0C +KAoKCgMHAQISAzwHJQoKCgMHAQQSAz0CCgoKCgMHAQUSAz0LEAoKCgMHAQES +Az0RHQoKCgMHAQMSAz0gJwoJCgEHEgRAAEUBCgkKAgcCEgNBAigKCgoDBwIC +EgNAByMKCgoDBwIEEgNBAgoKCgoDBwIFEgNBCxIKCgoDBwIBEgNBEx0KCgoD +BwIDEgNBICcKaQoCBwMSA0QCMxpeIFRoaXMgaXMgdXNlZnVsIGZvciB0ZXN0 +aW5nIHRoYXQgd2UgY29ycmVjdGx5IHJlZ2lzdGVyIGRlZmF1bHQgdmFsdWVz +IGZvcgogZXh0ZW5zaW9uIG9wdGlvbnMuCgoKCgMHAwISA0AHIwoKCgMHAwQS +A0QCCgoKCgMHAwUSA0QLEAoKCgMHAwESA0QRGwoKCgMHAwMSA0QeJQoKCgMH +AwgSA0QmMgoKCgMHAwcSA0QvMQoJCgEHEgRHAEkBCgkKAgcEEgNIAigKCgoD +BwQCEgNHByIKCgoDBwQEEgNIAgoKCgoDBwQFEgNICxMKCgoDBwQBEgNIFB0K +CgoDBwQDEgNIICcKCQoBBxIESwBNAQoJCgIHBRIDTAIrCgoKAwcFAhIDSwcn +CgoKAwcFBBIDTAIKCgoKAwcFBRIDTAsQCgoKAwcFARIDTBEgCgoKAwcFAxID +TCMqCgkKAQcSBE8AUQEKCQoCBwYSA1ACKQoKCgMHBgISA08HJQoKCgMHBgQS +A1ACCgoKCgMHBgUSA1ALEQoKCgMHBgESA1ASHgoKCgMHBgMSA1AhKAoKCgIF +ABIEUwBWAQoKCgMFAAESA1MFDwoLCgQFAAIAEgNUAhYKDAoFBQACAAESA1QC +EQoMCgUFAAIAAhIDVBQVCgsKBAUAAgESA1UCFgoMCgUFAAIBARIDVQIRCgwK +BQUAAgECEgNVFBUKCQoBBxIEWABaAQoJCgIHBxIDWQIsCgoKAwcHAhIDWAck +CgoKAwcHBBIDWQIKCgoKAwcHBhIDWQsVCgoKAwcHARIDWRYhCgoKAwcHAxID +WSQrCpABCgIEABIEXgBsARqDASBBIHRlc3QgbWVzc2FnZSB3aXRoIGN1c3Rv +bSBvcHRpb25zIGF0IGFsbCBwb3NzaWJsZSBsb2NhdGlvbnMgKGFuZCBhbHNv +IHNvbWUKIHJlZ3VsYXIgb3B0aW9ucywgdG8gbWFrZSBzdXJlIHRoZXkgaW50 +ZXJhY3QgbmljZWx5KS4KCgoKAwQAARIDXggkCgoKAwQABxIDXwIpCgsKBAQA +BwESA18CKQoKCgMEAAcSA2ECHgoOCgcEAAecrdgDEgNhAh4KDAoEBAACABIE +YwJkNwoMCgUEAAIABBIDYwIKCgwKBQQAAgAFEgNjCxEKDAoFBAACAAESA2MS +GAoMCgUEAAIAAxIDYxscCg0KBQQAAgAIEgRjHWQ2Cg0KBgQAAgAIARIDYx4o +ChAKCQQAAgAIiLzYAxIDZB41CgwKBAQABAASBGYCawMKDAoFBAAEAAESA2YH +DQoMCgUEAAQAAxIDZwQeChAKCQQABAAD6J7ZAxIDZwQeCg0KBgQABAACABID +aQQUCg4KBwQABAACAAESA2kEDwoOCgcEAAQAAgACEgNpEhMKDQoGBAAEAAIB +EgNqBC4KDgoHBAAEAAIBARIDagQPCg4KBwQABAACAQISA2oSEwoOCgcEAAQA +AgEDEgNqFC0KEQoKBAAEAAIBA+agXxIDahUsCpQBCgIEARIEcQByARqHASBB +IHRlc3QgUlBDIHNlcnZpY2Ugd2l0aCBjdXN0b20gb3B0aW9ucyBhdCBhbGwg +cG9zc2libGUgbG9jYXRpb25zIChhbmQgYWxzbwogc29tZSByZWd1bGFyIG9w +dGlvbnMsIHRvIG1ha2Ugc3VyZSB0aGV5IGludGVyYWN0IG5pY2VseSkuCgoK +CgMEAQESA3EIHgoKCgIEAhIEdAB1AQoKCgMEAgESA3QIHwoKCgIEAxIEdwB4 +AQoKCgMEAwESA3cIJAoKCgIEBBIEegB7AQoKCgMEBAESA3oIJAoLCgIGABIF +fQCDAQEKCgoDBgABEgN9CCQKCgoDBgADEgN+AiYKDgoHBgADorbhAxIDfgIm +Cg4KBAYAAgASBoABAoIBAwoNCgUGAAIAARIEgAEGCQoNCgUGAAIAAhIEgAEK +IAoNCgUGAAIAAxIEgAErQgoNCgUGAAIABBIEgQEEKwoRCgkGAAIABKzP4QMS +BIEBBCsKWwoCBAUSBokBAI4BATJNIE9wdGlvbnMgb2YgZXZlcnkgcG9zc2li +bGUgZmllbGQgdHlwZSwgc28gd2UgY2FuIHRlc3QgdGhlbSBhbGwgZXhoYXVz +dGl2ZWx5LgoKCwoDBAUBEgSJAQgiCg4KBAQFBAASBooBAo0BAwoNCgUEBQQA +ARIEigEHEwoOCgYEBQQAAgASBIsBBCAKDwoHBAUEAAIAARIEiwEEGgoPCgcE +BQQAAgACEgSLAR0fCg4KBgQFBAACARIEjAEEIQoPCgcEBQQAAgEBEgSMAQQa +Cg8KBwQFBAACAQISBIwBHSAKDAoCBAYSBpABAJEBAQoLCgMEBgESBJABCCcK +CwoBBxIGkwEApQEBCgoKAgcIEgSUAQIvCgsKAwcIAhIEkwEHJQoLCgMHCAQS +BJQBAgoKCwoDBwgFEgSUARMXCgsKAwcIARIElAEcJAoLCgMHCAMSBJQBJy4K +CgoCBwkSBJUBAi8KCwoDBwkCEgSTAQclCgsKAwcJBBIElQECCgoLCgMHCQUS +BJUBEhcKCwoDBwkBEgSVARskCgsKAwcJAxIElQEnLgoKCgIHChIElgECLwoL +CgMHCgISBJMBByUKCwoDBwoEEgSWAQIKCgsKAwcKBRIElgESFwoLCgMHCgES +BJYBGyQKCwoDBwoDEgSWAScuCgoKAgcLEgSXAQIvCgsKAwcLAhIEkwEHJQoL +CgMHCwQSBJcBAgoKCwoDBwsFEgSXAREXCgsKAwcLARIElwEaJAoLCgMHCwMS +BJcBJy4KCgoCBwwSBJgBAi8KCwoDBwwCEgSTAQclCgsKAwcMBBIEmAECCgoL +CgMHDAUSBJgBERcKCwoDBwwBEgSYARokCgsKAwcMAxIEmAEnLgoKCgIHDRIE +mQECLwoLCgMHDQISBJMBByUKCwoDBw0EEgSZAQIKCgsKAwcNBRIEmQERFwoL +CgMHDQESBJkBGiQKCwoDBw0DEgSZAScuCgoKAgcOEgSaAQIvCgsKAwcOAhIE +kwEHJQoLCgMHDgQSBJoBAgoKCwoDBw4FEgSaAREXCgsKAwcOARIEmgEaJAoL +CgMHDgMSBJoBJy4KCgoCBw8SBJsBAi8KCwoDBw8CEgSTAQclCgsKAwcPBBIE +mwECCgoLCgMHDwUSBJsBEBcKCwoDBw8BEgSbARkkCgsKAwcPAxIEmwEnLgoK +CgIHEBIEnAECLwoLCgMHEAISBJMBByUKCwoDBxAEEgScAQIKCgsKAwcQBRIE +nAEQFwoLCgMHEAESBJwBGSQKCwoDBxADEgScAScuCgoKAgcREgSdAQIvCgsK +AwcRAhIEkwEHJQoLCgMHEQQSBJ0BAgoKCwoDBxEFEgSdAQ8XCgsKAwcRARIE +nQEYJAoLCgMHEQMSBJ0BJy4KCgoCBxISBJ4BAi8KCwoDBxICEgSTAQclCgsK +AwcSBBIEngECCgoLCgMHEgUSBJ4BDxcKCwoDBxIBEgSeARgkCgsKAwcSAxIE +ngEnLgoKCgIHExIEnwECLwoLCgMHEwISBJMBByUKCwoDBxMEEgSfAQIKCgsK +AwcTBRIEnwESFwoLCgMHEwESBJ8BGyQKCwoDBxMDEgSfAScuCgoKAgcUEgSg +AQIvCgsKAwcUAhIEkwEHJQoLCgMHFAQSBKABAgoKCwoDBxQFEgSgAREXCgsK +AwcUARIEoAEaJAoLCgMHFAMSBKABJy4KCgoCBxUSBKEBAi8KCwoDBxUCEgST +AQclCgsKAwcVBBIEoQECCgoLCgMHFQUSBKEBERcKCwoDBxUBEgShARokCgsK +AwcVAxIEoQEnLgoKCgIHFhIEogECLwoLCgMHFgISBJMBByUKCwoDBxYEEgSi +AQIKCgsKAwcWBRIEogESFwoLCgMHFgESBKIBGyQKCwoDBxYDEgSiAScuCgoK +AgcXEgSjAQJGCgsKAwcXAhIEkwEHJQoLCgMHFwQSBKMBAgoKCwoDBxcGEgSj +AQsyCgsKAwcXARIEowEzOwoLCgMHFwMSBKMBPkUKCgoCBxgSBKQBAkYKCwoD +BxgCEgSTAQclCgsKAwcYBBIEpAECCgoLCgMHGAYSBKQBCyoKCwoDBxgBEgSk +ASs7CgsKAwcYAxIEpAE+RQoMCgIEBxIGpwEAswEBCgsKAwQHARIEpwEIJAoL +CgMEBwcSBKgBAiAKDwoHBAcH6qvWAxIEqAECIAoLCgMEBwcSBKkBAiYKDwoH +BAcH7ajWAxIEqQECJgoLCgMEBwcSBKoBAi4KDwoHBAcHxqfWAxIEqgECLgoL +CgMEBwcSBKsBAhwKDwoHBAcHsKLWAxIEqwECHAoLCgMEBwcSBKwBAhwKDwoH +BAcH347WAxIErAECHAoLCgMEBwcSBK0BAiYKDwoHBAcHwIjWAxIErQECJgoL +CgMEBwcSBK4BAi4KDwoHBAcH/4LWAxIErgECLgoLCgMEBwcSBK8BAhwKDwoH +BAcH0/7VAxIErwECHAoLCgMEBwcSBLABAhwKDwoHBAcH4v3VAxIEsAECHAoL +CgMEBwcSBLEBAiYKDwoHBAcH1fHVAxIEsQECJgoLCgMEBwcSBLIBAi4KDwoH +BAcH44rVAxIEsgECLgoMCgIECBIGtQEAwQEBCgsKAwQIARIEtQEIJAoLCgME +CAcSBLYBAh8KDwoHBAgH6qvWAxIEtgECHwoLCgMECAcSBLcBAiUKDwoHBAgH +7ajWAxIEtwECJQoLCgMECAcSBLgBAi0KDwoHBAgHxqfWAxIEuAECLQoLCgME +CAcSBLkBAiUKDwoHBAgHsKLWAxIEuQECJQoLCgMECAcSBLoBAi0KDwoHBAgH +347WAxIEugECLQoLCgMECAcSBLsBAiUKDwoHBAgHwIjWAxIEuwECJQoLCgME +CAcSBLwBAi0KDwoHBAgH/4LWAxIEvAECLQoLCgMECAcSBL0BAiUKDwoHBAgH +0/7VAxIEvQECJQoLCgMECAcSBL4BAi0KDwoHBAgH4v3VAxIEvgECLQoLCgME +CAcSBL8BAiUKDwoHBAgH1fHVAxIEvwECJQoLCgMECAcSBMABAi0KDwoHBAgH +44rVAxIEwAECLQoMCgIECRIGwwEAygEBCgsKAwQJARIEwwEIHwoLCgMECQcS +BMQBAh0KKgoHBAkH7ajWAxIExAECHSIZIFRvIHRlc3Qgc2lnbi1leHRlbnNp +b24uCgoLCgMECQcSBMUBAiMKDwoHBAkH/rvUAxIExQECIwoLCgMECQcSBMYB +Ai0KDwoHBAkHzavUAxIExgECLQoLCgMECQcSBMcBAisKDwoHBAkHxavUAxIE +xwECKwoLCgMECQcSBMgBAicKDwoHBAkHlqvUAxIEyAECJwoLCgMECQcSBMkB +Ai8KDwoHBAkHkavUAxIEyQECLwoMCgIEChIGzAEAzwEBCgsKAwQKARIEzAEI +JAoLCgMECgcSBM0BAhsKDwoHBAoH/rvUAxIEzQECGwoLCgMECgcSBM4BAhwK +DwoHBAoHzavUAxIEzgECHAoMCgIECxIG0QEA1AEBCgsKAwQLARIE0QEIJAoL +CgMECwcSBNIBAhwKDwoHBAsH/rvUAxIE0gECHAoLCgMECwcSBNMBAh4KDwoH +BAsHzavUAxIE0wECHgrAAQoCBAwSBtsBAOIBARpaIFRPRE86IGRvIHdlIHdh +bnQgdG8gc3VwcG9ydCBwYWNrZWQgaW50cz8KIGUuZy46IHJlcGVhdGVkIGlu +dDMyIGZvbzQgPSA0IFtwYWNrZWQgPSB0cnVlXTsKMlYgT3B0aW9ucyBvZiBj +b21wbGV4IG1lc3NhZ2UgdHlwZXMsIHRoZW1zZWx2ZXMgY29tYmluZWQgYW5k +IGV4dGVuZGVkIGluCiB2YXJpb3VzIHdheXMuCgoLCgMEDAESBNsBCBoKDAoE +BAwCABIE3AECGQoNCgUEDAIABBIE3AECCgoNCgUEDAIABRIE3AELEAoNCgUE +DAIAARIE3AERFAoNCgUEDAIAAxIE3AEXGAoMCgQEDAIBEgTdAQIaCg0KBQQM +AgEEEgTdAQIKCg0KBQQMAgEFEgTdAQsQCg0KBQQMAgEBEgTdAREVCg0KBQQM +AgEDEgTdARgZCgwKBAQMAgISBN4BAhoKDQoFBAwCAgQSBN4BAgoKDQoFBAwC +AgUSBN4BCxAKDQoFBAwCAgESBN4BERUKDQoFBAwCAgMSBN4BGBkKDAoEBAwC +AxIE3wECGgoNCgUEDAIDBBIE3wECCgoNCgUEDAIDBRIE3wELEAoNCgUEDAID +ARIE3wERFQoNCgUEDAIDAxIE3wEYGQoLCgMEDAUSBOEBAhgKDAoEBAwFABIE +4QENFwoNCgUEDAUAARIE4QENEAoNCgUEDAUAAhIE4QEUFwoMCgIEDRIG5AEA +9AEBCgsKAwQNARIE5AEIGgoMCgQEDQIAEgTlAQImCg0KBQQNAgAEEgTlAQIK +Cg0KBQQNAgAGEgTlAQsdCg0KBQQNAgABEgTlAR4hCg0KBQQNAgADEgTlASQl +CgwKBAQNAgESBOYBAhkKDQoFBA0CAQQSBOYBAgoKDQoFBA0CAQUSBOYBCxAK +DQoFBA0CAQESBOYBERQKDQoFBA0CAQMSBOYBFxgKDgoEBA0DABIG6AEC7gED +Cg0KBQQNAwABEgToAQocCg4KBgQNAwACABIE6QEEHQoPCgcEDQMAAgAEEgTp +AQQMCg8KBwQNAwACAAUSBOkBDRIKDwoHBA0DAAIAARIE6QETGAoPCgcEDQMA +AgADEgTpARscCg8KBQQNAwAGEgbrAQTtAQUKDgoGBA0DAAYAEgTsAQY5Cg8K +BwQNAwAGAAISBOsBCykKDwoHBA0DAAYABBIE7AEGDgoPCgcEDQMABgAGEgTs +AQ8hCg8KBwQNAwAGAAESBOwBIi4KDwoHBA0DAAYAAxIE7AExOAoMCgQEDQIC +EgTwAQInCg0KBQQNAgIEEgTwAQIKCg0KBQQNAgIGEgTwAQsdCg0KBQQNAgIB +EgTwAR4iCg0KBQQNAgIDEgTwASUmCgwKBAQNAgMSBPEBAikKDQoFBA0CAwQS +BPEBAgoKDQoFBA0CAwYSBPEBCx0KDQoFBA0CAwESBPEBHiQKDQoFBA0CAwMS +BPEBJygKCwoDBA0FEgTzAQIYCgwKBAQNBQASBPMBDRcKDQoFBA0FAAESBPMB +DRAKDQoFBA0FAAISBPMBFBcKDAoCBA4SBvYBAPgBAQoLCgMEDgESBPYBCBoK +DAoEBA4CABIE9wECGQoNCgUEDgIABBIE9wECCgoNCgUEDgIABRIE9wELEAoN +CgUEDgIAARIE9wERFAoNCgUEDgIAAxIE9wEXGAoLCgEHEgb6AQD9AQEKCgoC +BxkSBPsBAiAKCwoDBxkCEgT6AQcZCgsKAwcZBBIE+wECCgoLCgMHGQUSBPsB +CxAKCwoDBxkBEgT7AREVCgsKAwcZAxIE+wEYHwoKCgIHGhIE/AECLgoLCgMH +GgISBPoBBxkKCwoDBxoEEgT8AQIKCgsKAwcaBhIE/AELHQoLCgMHGgESBPwB +HiMKCwoDBxoDEgT8ASYtCgsKAQcSBv8BAIICAQoKCgIHGxIEgAICIgoLCgMH +GwISBP8BBxkKCwoDBxsEEgSAAgIKCgsKAwcbBRIEgAILEAoLCgMHGwESBIAC +ERcKCwoDBxsDEgSAAhohCgoKAgccEgSBAgIvCgsKAwccAhIE/wEHGQoLCgMH +HAQSBIECAgoKCwoDBxwGEgSBAgsdCgsKAwccARIEgQIeJAoLCgMHHAMSBIEC +Jy4KCwoBBxIGhAIAigIBCgoKAgcdEgSFAgJHCgsKAwcdAhIEhAIHJQoLCgMH +HQQSBIUCAgoKCwoDBx0GEgSFAgsvCgsKAwcdARIEhQIwPAoLCgMHHQMSBIUC +P0YKCgoCBx4SBIYCAjUKCwoDBx4CEgSEAgclCgsKAwceBBIEhgICCgoLCgMH +HgYSBIYCCx0KCwoDBx4BEgSGAh4qCgsKAwceAxIEhgItNAoKCgIHHxIEhwIC +NQoLCgMHHwISBIQCByUKCwoDBx8EEgSHAgIKCgsKAwcfBhIEhwILHQoLCgMH +HwESBIcCHioKCwoDBx8DEgSHAi00CgoKAgcgEgSIAgIpCgsKAwcgAhIEhAIH +JQoLCgMHIAQSBIgCAgoKCwoDByAFEgSIAgsQCgsKAwcgARIEiAIRHgoLCgMH +IAMSBIgCISgKCgoCByESBIkCAkgKCwoDByECEgSEAgclCgsKAwchBBIEiQIC +CgoLCgMHIQYSBIkCCy8KCwoDByEBEgSJAjA9CgsKAwchAxIEiQJARwpVCgIE +DxIGjQIApgIBGkcgTm90ZSB0aGF0IHdlIHRyeSB2YXJpb3VzIGRpZmZlcmVu +dCB3YXlzIG9mIG5hbWluZyB0aGUgc2FtZSBleHRlbnNpb24uCgoLCgMEDwES +BI0CCB0KCwoDBA8HEgSOAgI0ChAKCAQPB6Tc0gMBEgSOAgI0CgsKAwQPBxIE +jwICSgoTCgsEDwek3NID2+DTAxIEjwICSgoLCgMEDwcSBJACAk8KFAoMBA8H +pNzSA9Le0wMBEgSQAgJPCgsKAwQPBxIEkQICNAoRCgkEDwek3NIDBAASBJEC +AjQKCwoDBA8HEgSSAgI0ChEKCQQPB6Tc0gMEARIEkgICNAoLCgMEDwcSBJMC +AiIKEAoIBA8H1Y/SAwISBJMCAiIKCwoDBA8HEgSUAgInChMKCwQPB9WP0gPv +/NIDEgSUAgInCgsKAwQPBxIElQICJgoRCgkEDwfVj9IDAQESBJUCAiYKCwoD +BA8HEgSWAgIqChQKDAQPB9WP0gMB2+DTAxIElgICKgoLCgMEDwcSBJcCAkEK +FQoNBA8H1Y/SAwHS3tMDARIElwICQQoLCgMEDwcSBJgCAisKFAoMBA8H1Y/S +A8j10gMBEgSYAgIrCgsKAwQPBxIEmQICQgoXCg8EDwfVj9IDyPXSA9vg0wMS +BJkCAkIKCwoDBA8HEgSaAgJGChgKEAQPB9WP0gPI9dID0t7TAwESBJoCAkYK +CwoDBA8HEgSbAgJLChAKCAQPB4r10QMBEgSbAgJLCgsKAwQPBxIEnAICKQoR +CgkEDwfVj9IDAwESBJwCAikKCwoDBA8HEgSdAgIwChEKCQQPB9WP0gMEABIE +nQICMAoLCgMEDwcSBJ4CAjAKEQoJBA8H1Y/SAwQBEgSeAgIwCgsKAwQPBxIE +nwICMgoQCggEDwfvi9IDARIEnwICMgoLCgMEDwcSBKACAh0KEAoIBA8H8IvS +AwASBKACAh0KCwoDBA8HEgShAgIdChAKCAQPB/CL0gMBEgShAgIdCgsKAwQP +BxIEogICJgoQCggEDwfxi9IDABIEogICJgoLCgMEDwcSBKMCAiYKRgoIBA8H +8YvSAwESBKMCAiYiNG9wdGlvbiAoY29tcGxleF9vcHQzKS5jb21wbGV4b3B0 +aW9udHlwZTUucGx1Z2ggPSAyMjsKlwEKAgQQEgasAgCvAgEyiAEgLS0tLS0t +LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t +LS0tCiBEZWZpbml0aW9ucyBmb3IgdGVzdGluZyBhZ2dyZWdhdGUgb3B0aW9u +IHBhcnNpbmcuCiBTZWUgZGVzY3JpcHRvcl91bml0dGVzdC5jYy4KCgsKAwQQ +ARIErAIIGwoLCgMEEAcSBK0CAikKDAoEBBAHARIErQICKQoLCgMEEAUSBK4C +AhYKDAoEBBAFABIErgINFQoNCgUEEAUAARIErgINDgoNCgUEEAUAAhIErgIS +FQoMCgIEERIGsQIAtgIBCgsKAwQRARIEsQIIIgoNCgMEEQYSBrICArQCAwoM +CgQEEQYAEgSzAgRJCg0KBQQRBgACEgSyAgkcCg0KBQQRBgAEEgSzAgQMCg0K +BQQRBgAGEgSzAg0nCg0KBQQRBgABEgSzAig9Cg0KBQQRBgADEgSzAkBICgwK +BAQRAgASBLUCAhgKDQoFBBECAAQSBLUCAgoKDQoFBBECAAUSBLUCCxEKDQoF +BBECAAESBLUCEhMKDQoFBBECAAMSBLUCFhcKQwoCBBISBrkCAMgCARo1IEEg +aGVscGVyIHR5cGUgdXNlZCB0byB0ZXN0IGFnZ3JlZ2F0ZSBvcHRpb24gcGFy +c2luZwoKCwoDBBIBEgS5AggRCgwKBAQSAgASBLoCAhcKDQoFBBICAAQSBLoC +AgoKDQoFBBICAAUSBLoCCxAKDQoFBBICAAESBLoCERIKDQoFBBICAAMSBLoC +FRYKDAoEBBICARIEuwICGAoNCgUEEgIBBBIEuwICCgoNCgUEEgIBBRIEuwIL +EQoNCgUEEgIBARIEuwISEwoNCgUEEgIBAxIEuwIWFwofCgQEEgICEgS+AgId +GhEgQSBuZXN0ZWQgb2JqZWN0CgoNCgUEEgICBBIEvgICCgoNCgUEEgICBhIE +vgILFAoNCgUEEgICARIEvgIVGAoNCgUEEgICAxIEvgIbHApJCgQEEgIDEgTB +AgIwGjsgVG8gdGVzdCB0aGUgcGFyc2luZyBvZiBleHRlbnNpb25zIGluc2lk +ZSBhZ2dyZWdhdGUgdmFsdWVzCgoNCgUEEgIDBBIEwQICCgoNCgUEEgIDBhIE +wQILJgoNCgUEEgIDARIEwQInKwoNCgUEEgIDAxIEwQIuLwoNCgMEEgYSBsIC +AsQCAwoMCgQEEgYAEgTDAgQpCg0KBQQSBgACEgTCAgkkCg0KBQQSBgAEEgTD +AgQMCg0KBQQSBgAGEgTDAg0WCg0KBQQSBgABEgTDAhcdCg0KBQQSBgADEgTD +AiAoCicKBAQSAgQSBMcCAigaGSBBbiBlbWJlZGRlZCBtZXNzYWdlIHNldAoK +DQoFBBICBAQSBMcCAgoKDQoFBBICBAYSBMcCCx4KDQoFBBICBAESBMcCHyMK +DQoFBBICBAMSBMcCJicKZgoBBxIEzAIAVRpbIEFsbG93IEFnZ3JlZ2F0ZSB0 +byBiZSB1c2VkIGFzIGFuIG9wdGlvbiBhdCBhbGwgcG9zc2libGUgbG9jYXRp +b25zCiBpbiB0aGUgLnByb3RvIGdyYW1tZXIuCgoKCgIHIhIEzAIqUwoLCgMH +IgISBMwCByIKCwoDByIEEgTMAioyCgsKAwciBhIEzAIzPAoLCgMHIgESBMwC +PUQKCwoDByIDEgTMAkpSCgkKAQcSBM0CAFUKCgoCByMSBM0CKlMKCwoDByMC +EgTNAgclCgsKAwcjBBIEzQIqMgoLCgMHIwYSBM0CMzwKCwoDByMBEgTNAj1D +CgsKAwcjAxIEzQJKUgoJCgEHEgTOAgBVCgoKAgckEgTOAipTCgsKAwckAhIE +zgIHIwoLCgMHJAQSBM4CKjIKCwoDByQGEgTOAjM8CgsKAwckARIEzgI9RQoL +CgMHJAMSBM4CSlIKCQoBBxIEzwIAVQoKCgIHJRIEzwIqUwoLCgMHJQISBM8C +ByIKCwoDByUEEgTPAioyCgsKAwclBhIEzwIzPAoLCgMHJQESBM8CPUQKCwoD +ByUDEgTPAkpSCgkKAQcSBNACAFUKCgoCByYSBNACKlMKCwoDByYCEgTQAgcn +CgsKAwcmBBIE0AIqMgoLCgMHJgYSBNACMzwKCwoDByYBEgTQAj1HCgsKAwcm +AxIE0AJKUgoJCgEHEgTRAgBVCgoKAgcnEgTRAipTCgsKAwcnAhIE0QIHJQoL +CgMHJwQSBNECKjIKCwoDBycGEgTRAjM8CgsKAwcnARIE0QI9RwoLCgMHJwMS +BNECSlIKCQoBBxIE0gIAVQoKCgIHKBIE0gIqUwoLCgMHKAISBNICByQKCwoD +BygEEgTSAioyCgsKAwcoBhIE0gIzPAoLCgMHKAESBNICPUYKCwoDBygDEgTS +AkpSCgsKAQgSBtUCAOoCAgpVCgUIz92wBxIG1QIA6gICGkQgVHJ5IHVzaW5n +IEFnZ3JlZ2F0ZU9wdGlvbiBhdCBkaWZmZXJlbnQgcG9pbnRzIGluIHRoZSBw +cm90byBncmFtbWFyCgoMCgIEExIG7AIA7wIBCgsKAwQTARIE7AIIGAoLCgME +EwcSBO0CAjQKDwoHBBMHmOqwBxIE7QICNAoMCgQEEwIAEgTuAgJGCg0KBQQT +AgAEEgTuAgIKCg0KBQQTAgAFEgTuAgsQCg0KBQQTAgABEgTuAhEaCg0KBQQT +AgADEgTuAh0eCg0KBQQTAgAIEgTuAh9FChEKCQQTAgAInvSwBxIE7gIgRAoM +CgIGARIG8QIA9gIBCgsKAwYBARIE8QIIGAoLCgMGAQMSBPICAjIKDwoHBgED +ue+xBxIE8gICMgoOCgQGAQIAEgbzAgL1AgMKDQoFBgECAAESBPMCBgwKDQoF +BgECAAISBPMCDh4KDQoFBgECAAMSBPMCKTkKDQoFBgECAAQSBPQCBDIKEQoJ +BgECAASJ6bIHEgT0AgQyCgwKAgUBEgb4AgD8AgEKCwoDBQEBEgT4AgUSCgsK +AwUBAxIE+QICLAoPCgcFAQPSgrEHEgT5AgIsCjAKBAUBAgASBPsCAjkaIiBU +T0RPOiBzdXBwb3J0IGVudW0gdmFsdWUgb3B0aW9ucwoKDQoFBQECAAESBPsC +AgcKDQoFBQECAAISBPsCCgsKDQoFBQECAAMSBPsCDDgKEQoJBQECAAPJn7EH +EgT7Ag03CjQKAgQUEgb/AgCMAwEaJiBUZXN0IGN1c3RvbSBvcHRpb25zIGZv +ciBuZXN0ZWQgdHlwZS4KCgsKAwQUARIE/wIIGAoOCgQEFAMAEgaAAwKDAwMK +DQoFBBQDAAESBIADChcKDQoFBBQDAAcSBIEDBCEKEQoJBBQDAAecrdgDEgSB +AwQhCg4KBgQUAwACABIEggMEOgoPCgcEFAMAAgAEEgSCAwQMCg8KBwQUAwAC +AAUSBIIDDRIKDwoHBBQDAAIAARIEggMTHwoPCgcEFAMAAgADEgSCAyIjCg8K +BwQUAwACAAgSBIIDJDkKEwoLBBQDAAIACIi82AMSBIIDJTgKDgoEBBQEABIG +hAMCiAMDCg0KBQQUBAABEgSEAwcRCg0KBQQUBAADEgSFAwQeChEKCQQUBAAD +6J7ZAxIEhQMEHgoyCgYEFAQAAgASBIcDBDUaIiBUT0RPOiBzdXBwb3J0IGVu +dW0gdmFsdWUgb3B0aW9ucwoKDwoHBBQEAAIAARIEhwMEFQoPCgcEFAQAAgAC +EgSHAxgZCg8KBwQUBAACAAMSBIcDGjQKEgoKBBQEAAIAA+agXxIEhwMbMwoN +CgMEFAYSBokDAosDAwoMCgQEFAYAEgSKAwRECg0KBQQUBgACEgSJAwkkCg0K +BQQUBgAEEgSKAwQMCg0KBQQUBgAFEgSKAw0SCg0KBQQUBgABEgSKAxMjCg0K +BQQUBgADEgSKAyYtCg0KBQQUBgAIEgSKAy5DChEKCQQUBgAIuaHZAxIEigMv +QgptCgIEFRIGkAMAlQMBGl8gQ3VzdG9tIG1lc3NhZ2Ugb3B0aW9uIHRoYXQg +aGFzIGEgcmVxdWlyZWQgZW51bSBmaWVsZC4KIFdBUk5JTkc6IHRoaXMgaXMg +c3Ryb25nbHkgZGlzY291cmFnZWQhCgoLCgMEFQESBJADCBUKDgoEBBUEABIG +kQMCkwMDCg0KBQQVBAABEgSRAwcPCg4KBgQVBAACABIEkgMEEgoPCgcEFQQA +AgABEgSSAwQNCg8KBwQVBAACAAISBJIDEBEKDAoEBBUCABIElAMCHgoNCgUE +FQIABBIElAMCCgoNCgUEFQIABhIElAMLEwoNCgUEFQIAARIElAMUGQoNCgUE +FQIAAxIElAMcHQo7CgIEFhIGmAMAngMBGi0gVXBkYXRlZCB2ZXJzaW9uIG9m +IHRoZSBjdXN0b20gb3B0aW9uIGFib3ZlLgoKCwoDBBYBEgSYAwgVCg4KBAQW +BAASBpkDApwDAwoNCgUEFgQAARIEmQMHDwoOCgYEFgQAAgASBJoDBBIKDwoH +BBYEAAIAARIEmgMEDQoPCgcEFgQAAgACEgSaAxARCg4KBgQWBAACARIEmwME +EgoPCgcEFgQAAgEBEgSbAwQNCg8KBwQWBAACAQISBJsDEBEKDAoEBBYCABIE +nQMCHgoNCgUEFgIABBIEnQMCCgoNCgUEFgIABhIEnQMLEwoNCgUEFgIAARIE +nQMUGQoNCgUEFgIAAxIEnQMcHQoLCgEHEgagAwCiAwEKCgoCBykSBKEDAjcK +CwoDBykCEgSgAwclCgsKAwcpBBIEoQMCCgoLCgMHKQYSBKEDCxgKCwoDBykB +EgShAxkqCgsKAwcpAxIEoQMtNgpQCgIEFxIGpQMApwMBGkIgVGVzdCBtZXNz +YWdlIHVzaW5nIHRoZSAicmVxdWlyZWRfZW51bV9vcHQiIG9wdGlvbiBkZWZp +bmVkIGFib3ZlLgoKCwoDBBcBEgSlAwgpCgsKAwQXBxIEpgMCNAoPCgcEFweP +zc8yEgSmAwI0 diff --git a/spec/support/protos/google_unittest_import.pb.rb b/spec/support/protos/google_unittest_import.pb.rb index 99beaf06..272ec829 100644 --- a/spec/support/protos/google_unittest_import.pb.rb +++ b/spec/support/protos/google_unittest_import.pb.rb @@ -1,8 +1,11 @@ # encoding: utf-8 +# frozen_string_literal: true ## # This file is auto-generated. DO NOT EDIT! # +require 'base64' +require 'set' require 'protobuf' @@ -12,18 +15,44 @@ require 'protos/google_unittest_import_public.pb' module Protobuf_unittest_import + FULLY_QUALIFIED_NAME = 'protobuf_unittest_import' unless defined?(self::FULLY_QUALIFIED_NAME) + + @descriptors = [] unless instance_variable_defined?(:@descriptors) + @descriptors << lambda do + bytes = File.read(__FILE__, mode: 'rb').split(/^__END__$/, 2).last + ::Google::Protobuf::FileDescriptorProto.decode(Base64.decode64(bytes)) + end + + @descriptor_dependencies = Set.new unless instance_variable_defined?(:@descriptor_dependencies) + @descriptor_dependencies |= [Protobuf_unittest_import] + + unless respond_to?(:descriptor_set) + def self.descriptor_set + ::Google::Protobuf::FileDescriptorSet.new(:file => @descriptors.map(&:call)) + end + end + + unless respond_to?(:descriptor_dependencies) + def self.descriptor_dependencies + @descriptor_dependencies + end + end ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions } ## # Enum Classes # class ImportEnum < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ImportEnum' + define :IMPORT_FOO, 7 define :IMPORT_BAR, 8 define :IMPORT_BAZ, 9 end class ImportEnumForMap < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ImportEnumForMap' + define :UNKNOWN, 0 define :FOO, 1 define :BAR, 2 @@ -48,8 +77,80 @@ class ImportMessage < ::Protobuf::Message; end # Message Fields # class ImportMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ImportMessage' optional :int32, :d, 1 end end + +# Raw descriptor bytes below +__END__ +CiNwcm90b3MvZ29vZ2xlX3VuaXR0ZXN0X2ltcG9ydC5wcm90bxIYcHJvdG9i +dWZfdW5pdHRlc3RfaW1wb3J0Gipwcm90b3MvZ29vZ2xlX3VuaXR0ZXN0X2lt +cG9ydF9wdWJsaWMucHJvdG8iHQoNSW1wb3J0TWVzc2FnZRIMCgFkGAEgASgF +UgFkKjwKCkltcG9ydEVudW0SDgoKSU1QT1JUX0ZPTxAHEg4KCklNUE9SVF9C +QVIQCBIOCgpJTVBPUlRfQkFaEAkqMQoQSW1wb3J0RW51bUZvck1hcBILCgdV +TktOT1dOEAASBwoDRk9PEAESBwoDQkFSEAJCHwoYY29tLmdvb2dsZS5wcm90 +b2J1Zi50ZXN0SAH4AQFKwBUKBhIEJABIAQqYDgoBDBIDJAASMsEMIFByb3Rv +Y29sIEJ1ZmZlcnMgLSBHb29nbGUncyBkYXRhIGludGVyY2hhbmdlIGZvcm1h +dAogQ29weXJpZ2h0IDIwMDggR29vZ2xlIEluYy4gIEFsbCByaWdodHMgcmVz +ZXJ2ZWQuCiBodHRwczovL2RldmVsb3BlcnMuZ29vZ2xlLmNvbS9wcm90b2Nv +bC1idWZmZXJzLwoKIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl +IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogbW9kaWZpY2F0 +aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu +ZyBjb25kaXRpb25zIGFyZQogbWV0OgoKICAgICAqIFJlZGlzdHJpYnV0aW9u +cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJp +Z2h0CiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg +Zm9sbG93aW5nIGRpc2NsYWltZXIuCiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMg +aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCiBjb3B5 +cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl +IGZvbGxvd2luZyBkaXNjbGFpbWVyCiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBh +bmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCiBkaXN0 +cmlidXRpb24uCiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJ +bmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCiBjb250cmlidXRvcnMgbWF5IGJl +IHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQg +ZnJvbQogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdy +aXR0ZW4gcGVybWlzc2lvbi4KCiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVE +IEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCiAi +QVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMs +IElOQ0xVRElORywgQlVUIE5PVAogTElNSVRFRCBUTywgVEhFIElNUExJRUQg +V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S +CiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8g +RVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAogT1dORVIgT1IgQ09OVFJJQlVU +T1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE +RU5UQUwsCiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwg +REFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCiBMSU1JVEVEIFRPLCBQUk9D +VVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NT +IE9GIFVTRSwKIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVS +UlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQogVEhFT1JZIE9G +IExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJ +TElUWSwgT1IgVE9SVAogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS +V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCiBPRiBU +SElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklM +SVRZIE9GIFNVQ0ggREFNQUdFLgoyyQEgQXV0aG9yOiBrZW50b25AZ29vZ2xl +LmNvbSAoS2VudG9uIFZhcmRhKQogIEJhc2VkIG9uIG9yaWdpbmFsIFByb3Rv +Y29sIEJ1ZmZlcnMgZGVzaWduIGJ5CiAgU2FuamF5IEdoZW1hd2F0LCBKZWZm +IERlYW4sIGFuZCBvdGhlcnMuCgogQSBwcm90byBmaWxlIHdoaWNoIGlzIGlt +cG9ydGVkIGJ5IHVuaXR0ZXN0LnByb3RvIHRvIHRlc3QgaW1wb3J0aW5nLgoK +9QEKAQISAyoAIRrqASBXZSBkb24ndCBwdXQgdGhpcyBpbiBhIHBhY2thZ2Ug +d2l0aGluIHByb3RvMiBiZWNhdXNlIHdlIG5lZWQgdG8gbWFrZSBzdXJlCiB0 +aGF0IHRoZSBnZW5lcmF0ZWQgY29kZSBkb2Vzbid0IGRlcGVuZCBvbiBiZWlu +ZyBpbiB0aGUgcHJvdG8yIG5hbWVzcGFjZS4KIEluIHRlc3RfdXRpbC5oIHdl +IGRvCiAidXNpbmcgbmFtZXNwYWNlIHVuaXR0ZXN0X2ltcG9ydCA9IHByb3Rv +YnVmX3VuaXR0ZXN0X2ltcG9ydCIuCgoICgEIEgMsABwKCQoCCAkSAywAHAoI +CgEIEgMtAB8KCQoCCB8SAy0AHwoICgEIEgMwADEKLgoCCAESAzAAMRojIEV4 +ZXJjaXNlIHRoZSBqYXZhX3BhY2thZ2Ugb3B0aW9uLgoKcwoCAwASAzYAOxoU +IFRlc3QgcHVibGljIGltcG9ydAoyUiBEbyBub3Qgc2V0IGEgamF2YV9vdXRl +cl9jbGFzc25hbWUgaGVyZSB0byB2ZXJpZnkgdGhhdCBQcm90bzIgd29ya3Mg +d2l0aG91dAogb25lLgoKCQoCCgASAzYHDQoKCgIEABIEOAA6AQoKCgMEAAES +AzgIFQoLCgQEAAIAEgM5AhcKDAoFBAACAAQSAzkCCgoMCgUEAAIABRIDOQsQ +CgwKBQQAAgABEgM5ERIKDAoFBAACAAMSAzkVFgoKCgIFABIEPABAAQoKCgMF +AAESAzwFDwoLCgQFAAIAEgM9AhEKDAoFBQACAAESAz0CDAoMCgUFAAIAAhID +PQ8QCgsKBAUAAgESAz4CEQoMCgUFAAIBARIDPgIMCgwKBQUAAgECEgM+DxAK +CwoEBQACAhIDPwIRCgwKBQUAAgIBEgM/AgwKDAoFBQACAgISAz8PEApICgIF +ARIERABIARo8IFRvIHVzZSBhbiBlbnVtIGluIGEgbWFwLCBpdCBtdXN0IGhh +cyB0aGUgZmlyc3QgdmFsdWUgYXMgMC4KCgoKAwUBARIDRAUVCgsKBAUBAgAS +A0UCDgoMCgUFAQIAARIDRQIJCgwKBQUBAgACEgNFDA0KCwoEBQECARIDRgIK +CgwKBQUBAgEBEgNGAgUKDAoFBQECAQISA0YICQoLCgQFAQICEgNHAgoKDAoF +BQECAgESA0cCBQoMCgUFAQICAhIDRwgJUAA= diff --git a/spec/support/protos/google_unittest_import_public.pb.rb b/spec/support/protos/google_unittest_import_public.pb.rb index c6c295d2..c24d2396 100644 --- a/spec/support/protos/google_unittest_import_public.pb.rb +++ b/spec/support/protos/google_unittest_import_public.pb.rb @@ -1,11 +1,36 @@ # encoding: utf-8 +# frozen_string_literal: true ## # This file is auto-generated. DO NOT EDIT! # +require 'base64' +require 'set' require 'protobuf' module Protobuf_unittest_import + FULLY_QUALIFIED_NAME = 'protobuf_unittest_import' unless defined?(self::FULLY_QUALIFIED_NAME) + + @descriptors = [] unless instance_variable_defined?(:@descriptors) + @descriptors << lambda do + bytes = File.read(__FILE__, mode: 'rb').split(/^__END__$/, 2).last + ::Google::Protobuf::FileDescriptorProto.decode(Base64.decode64(bytes)) + end + + @descriptor_dependencies = Set.new unless instance_variable_defined?(:@descriptor_dependencies) + @descriptor_dependencies |= [] + + unless respond_to?(:descriptor_set) + def self.descriptor_set + ::Google::Protobuf::FileDescriptorSet.new(:file => @descriptors.map(&:call)) + end + end + + unless respond_to?(:descriptor_dependencies) + def self.descriptor_dependencies + @descriptor_dependencies + end + end ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions } ## @@ -24,8 +49,55 @@ class PublicImportMessage < ::Protobuf::Message; end # Message Fields # class PublicImportMessage + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.PublicImportMessage' optional :int32, :e, 1 end end + +# Raw descriptor bytes below +__END__ +Cipwcm90b3MvZ29vZ2xlX3VuaXR0ZXN0X2ltcG9ydF9wdWJsaWMucHJvdG8S +GHByb3RvYnVmX3VuaXR0ZXN0X2ltcG9ydCIjChNQdWJsaWNJbXBvcnRNZXNz +YWdlEgwKAWUYASABKAVSAWVCGgoYY29tLmdvb2dsZS5wcm90b2J1Zi50ZXN0 +Sv0NCgYSBCAAKAEK9gwKAQwSAyAAEjLBDCBQcm90b2NvbCBCdWZmZXJzIC0g +R29vZ2xlJ3MgZGF0YSBpbnRlcmNoYW5nZSBmb3JtYXQKIENvcHlyaWdodCAy +MDA4IEdvb2dsZSBJbmMuICBBbGwgcmlnaHRzIHJlc2VydmVkLgogaHR0cHM6 +Ly9kZXZlbG9wZXJzLmdvb2dsZS5jb20vcHJvdG9jb2wtYnVmZmVycy8KCiBS +ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv +cm1zLCB3aXRoIG9yIHdpdGhvdXQKIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p +dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBh +cmUKIG1ldDoKCiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv +ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAogbm90aWNlLCB0 +aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj +bGFpbWVyLgogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt +IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQogY29weXJpZ2h0IG5vdGljZSwg +dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz +Y2xhaW1lcgogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h +dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQogZGlzdHJpYnV0aW9uLgogICAg +ICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5h +bWVzIG9mIGl0cwogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9y +c2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KIHRoaXMgc29m +dHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Np +b24uCgogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJ +R0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUwogIkFTIElTIiBBTkQgQU5Z +IEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV +VCBOT1QKIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0Yg +TUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgogQSBQQVJUSUNVTEFS +IFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRI +RSBDT1BZUklHSFQKIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUg +Rk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAogU1BFQ0lB +TCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xV +RElORywgQlVUIE5PVAogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VC +U1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCiBEQVRB +LCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VW +RVIgQ0FVU0VEIEFORCBPTiBBTlkKIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdI +RVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK +IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcg +SU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQogT0YgVEhJUyBTT0ZUV0FSRSwg +RVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERB +TUFHRS4KMiggQXV0aG9yOiBsaXVqaXNpQGdvb2dsZS5jb20gKFBoZXJsIExp +dSkKCggKAQISAyIAIQoICgEIEgMkADEKCQoCCAESAyQAMQoKCgIEABIEJgAo +AQoKCgMEAAESAyYIGwoLCgQEAAIAEgMnAhcKDAoFBAACAAQSAycCCgoMCgUE +AAIABRIDJwsQCgwKBQQAAgABEgMnERIKDAoFBAACAAMSAycVFg== diff --git a/spec/support/protos/map-test.pb.rb b/spec/support/protos/map-test.pb.rb index bd856360..c535b47c 100644 --- a/spec/support/protos/map-test.pb.rb +++ b/spec/support/protos/map-test.pb.rb @@ -1,19 +1,46 @@ # encoding: utf-8 +# frozen_string_literal: true ## # This file is auto-generated. DO NOT EDIT! # +require 'base64' +require 'set' require 'protobuf' module Foo + FULLY_QUALIFIED_NAME = 'foo' unless defined?(self::FULLY_QUALIFIED_NAME) + + @descriptors = [] unless instance_variable_defined?(:@descriptors) + @descriptors << lambda do + bytes = File.read(__FILE__, mode: 'rb').split(/^__END__$/, 2).last + ::Google::Protobuf::FileDescriptorProto.decode(Base64.decode64(bytes)) + end + + @descriptor_dependencies = Set.new unless instance_variable_defined?(:@descriptor_dependencies) + @descriptor_dependencies |= [] + + unless respond_to?(:descriptor_set) + def self.descriptor_set + ::Google::Protobuf::FileDescriptorSet.new(:file => @descriptors.map(&:call)) + end + end + + unless respond_to?(:descriptor_dependencies) + def self.descriptor_dependencies + @descriptor_dependencies + end + end ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions } ## # Enum Classes # class Frobnitz < ::Protobuf::Enum - define :FROB, 1 - define :NITZ, 2 + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Frobnitz' + + define :FROB, 0 + define :NITZ, 1 end @@ -34,7 +61,9 @@ class Bar < ::Protobuf::Message # Message Fields # class Baz + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Baz' class DoesNotLookLikeMapEntry + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.DoesNotLookLikeMapEntry' optional :string, :key, 1 optional :string, :value, 2 end @@ -44,6 +73,7 @@ class DoesNotLookLikeMapEntry end class Bar + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Bar' map :sint32, ::Foo::Baz, :sint32_to_baz, 1 map :sint64, ::Foo::Baz, :sint64_to_baz, 2 map :int32, ::Foo::Baz, :int32_to_baz, 3 @@ -83,3 +113,198 @@ class Bar end + +# Raw descriptor bytes below +__END__ +ChVwcm90b3MvbWFwLXRlc3QucHJvdG8SA2ZvbyKhAgoDQmF6EkAKDmxvb2tz +X2xpa2VfbWFwGAEgAygLMhouZm9vLkJhei5Mb29rc0xpa2VNYXBFbnRyeVIM +bG9va3NMaWtlTWFwElQKFmRvZXNfbm90X2xvb2tfbGlrZV9tYXAYAiADKAsy +IC5mb28uQmF6LkRvZXNOb3RMb29rTGlrZU1hcEVudHJ5UhJkb2VzTm90TG9v +a0xpa2VNYXAaPwoRTG9va3NMaWtlTWFwRW50cnkSEAoDa2V5GAEgASgJUgNr +ZXkSFAoFdmFsdWUYAiABKAlSBXZhbHVlOgI4ARpBChdEb2VzTm90TG9va0xp +a2VNYXBFbnRyeRIQCgNrZXkYASABKAlSA2tleRIUCgV2YWx1ZRgCIAEoCVIF +dmFsdWUi1SYKA0JhchI9Cg1zaW50MzJfdG9fYmF6GAEgAygLMhkuZm9vLkJh +ci5TaW50MzJUb0JhekVudHJ5UgtzaW50MzJUb0JhehI9Cg1zaW50NjRfdG9f +YmF6GAIgAygLMhkuZm9vLkJhci5TaW50NjRUb0JhekVudHJ5UgtzaW50NjRU +b0JhehI6CgxpbnQzMl90b19iYXoYAyADKAsyGC5mb28uQmFyLkludDMyVG9C +YXpFbnRyeVIKaW50MzJUb0JhehI6CgxpbnQ2NF90b19iYXoYBCADKAsyGC5m +b28uQmFyLkludDY0VG9CYXpFbnRyeVIKaW50NjRUb0JhehI9Cg11aW50MzJf +dG9fYmF6GAUgAygLMhkuZm9vLkJhci5VaW50MzJUb0JhekVudHJ5Ugt1aW50 +MzJUb0JhehI9Cg11aW50NjRfdG9fYmF6GAYgAygLMhkuZm9vLkJhci5VaW50 +NjRUb0JhekVudHJ5Ugt1aW50NjRUb0JhehI9Cg1zdHJpbmdfdG9fYmF6GAcg +AygLMhkuZm9vLkJhci5TdHJpbmdUb0JhekVudHJ5UgtzdHJpbmdUb0JhehJM +ChJzaW50MzJfdG9fZnJvYm5pdHoYCCADKAsyHi5mb28uQmFyLlNpbnQzMlRv +RnJvYm5pdHpFbnRyeVIQc2ludDMyVG9Gcm9ibml0ehJMChJzaW50NjRfdG9f +ZnJvYm5pdHoYCSADKAsyHi5mb28uQmFyLlNpbnQ2NFRvRnJvYm5pdHpFbnRy +eVIQc2ludDY0VG9Gcm9ibml0ehJJChFpbnQzMl90b19mcm9ibml0ehgKIAMo +CzIdLmZvby5CYXIuSW50MzJUb0Zyb2JuaXR6RW50cnlSD2ludDMyVG9Gcm9i +bml0ehJJChFpbnQ2NF90b19mcm9ibml0ehgLIAMoCzIdLmZvby5CYXIuSW50 +NjRUb0Zyb2JuaXR6RW50cnlSD2ludDY0VG9Gcm9ibml0ehJMChJ1aW50MzJf +dG9fZnJvYm5pdHoYDCADKAsyHi5mb28uQmFyLlVpbnQzMlRvRnJvYm5pdHpF +bnRyeVIQdWludDMyVG9Gcm9ibml0ehJMChJ1aW50NjRfdG9fZnJvYm5pdHoY +DSADKAsyHi5mb28uQmFyLlVpbnQ2NFRvRnJvYm5pdHpFbnRyeVIQdWludDY0 +VG9Gcm9ibml0ehJMChJzdHJpbmdfdG9fZnJvYm5pdHoYDiADKAsyHi5mb28u +QmFyLlN0cmluZ1RvRnJvYm5pdHpFbnRyeVIQc3RyaW5nVG9Gcm9ibml0ehJG +ChBzaW50MzJfdG9fc3RyaW5nGA8gAygLMhwuZm9vLkJhci5TaW50MzJUb1N0 +cmluZ0VudHJ5Ug5zaW50MzJUb1N0cmluZxJGChBzaW50NjRfdG9fc3RyaW5n +GBAgAygLMhwuZm9vLkJhci5TaW50NjRUb1N0cmluZ0VudHJ5Ug5zaW50NjRU +b1N0cmluZxJDCg9pbnQzMl90b19zdHJpbmcYESADKAsyGy5mb28uQmFyLklu +dDMyVG9TdHJpbmdFbnRyeVINaW50MzJUb1N0cmluZxJDCg9pbnQ2NF90b19z +dHJpbmcYEiADKAsyGy5mb28uQmFyLkludDY0VG9TdHJpbmdFbnRyeVINaW50 +NjRUb1N0cmluZxJGChB1aW50MzJfdG9fc3RyaW5nGBMgAygLMhwuZm9vLkJh +ci5VaW50MzJUb1N0cmluZ0VudHJ5Ug51aW50MzJUb1N0cmluZxJGChB1aW50 +NjRfdG9fc3RyaW5nGBQgAygLMhwuZm9vLkJhci5VaW50NjRUb1N0cmluZ0Vu +dHJ5Ug51aW50NjRUb1N0cmluZxJGChBzdHJpbmdfdG9fc3RyaW5nGBUgAygL +MhwuZm9vLkJhci5TdHJpbmdUb1N0cmluZ0VudHJ5Ug5zdHJpbmdUb1N0cmlu +ZxJDCg9zaW50MzJfdG9fZmxvYXQYFiADKAsyGy5mb28uQmFyLlNpbnQzMlRv +RmxvYXRFbnRyeVINc2ludDMyVG9GbG9hdBJDCg9zaW50NjRfdG9fZmxvYXQY +FyADKAsyGy5mb28uQmFyLlNpbnQ2NFRvRmxvYXRFbnRyeVINc2ludDY0VG9G +bG9hdBJACg5pbnQzMl90b19mbG9hdBgYIAMoCzIaLmZvby5CYXIuSW50MzJU +b0Zsb2F0RW50cnlSDGludDMyVG9GbG9hdBJACg5pbnQ2NF90b19mbG9hdBgZ +IAMoCzIaLmZvby5CYXIuSW50NjRUb0Zsb2F0RW50cnlSDGludDY0VG9GbG9h +dBJDCg91aW50MzJfdG9fZmxvYXQYGiADKAsyGy5mb28uQmFyLlVpbnQzMlRv +RmxvYXRFbnRyeVINdWludDMyVG9GbG9hdBJDCg91aW50NjRfdG9fZmxvYXQY +GyADKAsyGy5mb28uQmFyLlVpbnQ2NFRvRmxvYXRFbnRyeVINdWludDY0VG9G +bG9hdBJDCg9zdHJpbmdfdG9fZmxvYXQYHCADKAsyGy5mb28uQmFyLlN0cmlu +Z1RvRmxvYXRFbnRyeVINc3RyaW5nVG9GbG9hdBJGChBzaW50MzJfdG9fZG91 +YmxlGB0gAygLMhwuZm9vLkJhci5TaW50MzJUb0RvdWJsZUVudHJ5Ug5zaW50 +MzJUb0RvdWJsZRJGChBzaW50NjRfdG9fZG91YmxlGB4gAygLMhwuZm9vLkJh +ci5TaW50NjRUb0RvdWJsZUVudHJ5Ug5zaW50NjRUb0RvdWJsZRJDCg9pbnQz +Ml90b19kb3VibGUYHyADKAsyGy5mb28uQmFyLkludDMyVG9Eb3VibGVFbnRy +eVINaW50MzJUb0RvdWJsZRJDCg9pbnQ2NF90b19kb3VibGUYICADKAsyGy5m +b28uQmFyLkludDY0VG9Eb3VibGVFbnRyeVINaW50NjRUb0RvdWJsZRJGChB1 +aW50MzJfdG9fZG91YmxlGCEgAygLMhwuZm9vLkJhci5VaW50MzJUb0RvdWJs +ZUVudHJ5Ug51aW50MzJUb0RvdWJsZRJGChB1aW50NjRfdG9fZG91YmxlGCIg +AygLMhwuZm9vLkJhci5VaW50NjRUb0RvdWJsZUVudHJ5Ug51aW50NjRUb0Rv +dWJsZRJGChBzdHJpbmdfdG9fZG91YmxlGCMgAygLMhwuZm9vLkJhci5TdHJp +bmdUb0RvdWJsZUVudHJ5Ug5zdHJpbmdUb0RvdWJsZRpIChBTaW50MzJUb0Jh +ekVudHJ5EhAKA2tleRgBIAEoEVIDa2V5Eh4KBXZhbHVlGAIgASgLMgguZm9v +LkJhelIFdmFsdWU6AjgBGkgKEFNpbnQ2NFRvQmF6RW50cnkSEAoDa2V5GAEg +ASgSUgNrZXkSHgoFdmFsdWUYAiABKAsyCC5mb28uQmF6UgV2YWx1ZToCOAEa +RwoPSW50MzJUb0JhekVudHJ5EhAKA2tleRgBIAEoBVIDa2V5Eh4KBXZhbHVl +GAIgASgLMgguZm9vLkJhelIFdmFsdWU6AjgBGkcKD0ludDY0VG9CYXpFbnRy +eRIQCgNrZXkYASABKANSA2tleRIeCgV2YWx1ZRgCIAEoCzIILmZvby5CYXpS +BXZhbHVlOgI4ARpIChBVaW50MzJUb0JhekVudHJ5EhAKA2tleRgBIAEoDVID +a2V5Eh4KBXZhbHVlGAIgASgLMgguZm9vLkJhelIFdmFsdWU6AjgBGkgKEFVp +bnQ2NFRvQmF6RW50cnkSEAoDa2V5GAEgASgEUgNrZXkSHgoFdmFsdWUYAiAB +KAsyCC5mb28uQmF6UgV2YWx1ZToCOAEaSAoQU3RyaW5nVG9CYXpFbnRyeRIQ +CgNrZXkYASABKAlSA2tleRIeCgV2YWx1ZRgCIAEoCzIILmZvby5CYXpSBXZh +bHVlOgI4ARpSChVTaW50MzJUb0Zyb2JuaXR6RW50cnkSEAoDa2V5GAEgASgR +UgNrZXkSIwoFdmFsdWUYAiABKA4yDS5mb28uRnJvYm5pdHpSBXZhbHVlOgI4 +ARpSChVTaW50NjRUb0Zyb2JuaXR6RW50cnkSEAoDa2V5GAEgASgSUgNrZXkS +IwoFdmFsdWUYAiABKA4yDS5mb28uRnJvYm5pdHpSBXZhbHVlOgI4ARpRChRJ +bnQzMlRvRnJvYm5pdHpFbnRyeRIQCgNrZXkYASABKAVSA2tleRIjCgV2YWx1 +ZRgCIAEoDjINLmZvby5Gcm9ibml0elIFdmFsdWU6AjgBGlEKFEludDY0VG9G +cm9ibml0ekVudHJ5EhAKA2tleRgBIAEoA1IDa2V5EiMKBXZhbHVlGAIgASgO +Mg0uZm9vLkZyb2JuaXR6UgV2YWx1ZToCOAEaUgoVVWludDMyVG9Gcm9ibml0 +ekVudHJ5EhAKA2tleRgBIAEoDVIDa2V5EiMKBXZhbHVlGAIgASgOMg0uZm9v +LkZyb2JuaXR6UgV2YWx1ZToCOAEaUgoVVWludDY0VG9Gcm9ibml0ekVudHJ5 +EhAKA2tleRgBIAEoBFIDa2V5EiMKBXZhbHVlGAIgASgOMg0uZm9vLkZyb2Ju +aXR6UgV2YWx1ZToCOAEaUgoVU3RyaW5nVG9Gcm9ibml0ekVudHJ5EhAKA2tl +eRgBIAEoCVIDa2V5EiMKBXZhbHVlGAIgASgOMg0uZm9vLkZyb2JuaXR6UgV2 +YWx1ZToCOAEaQQoTU2ludDMyVG9TdHJpbmdFbnRyeRIQCgNrZXkYASABKBFS +A2tleRIUCgV2YWx1ZRgCIAEoCVIFdmFsdWU6AjgBGkEKE1NpbnQ2NFRvU3Ry +aW5nRW50cnkSEAoDa2V5GAEgASgSUgNrZXkSFAoFdmFsdWUYAiABKAlSBXZh +bHVlOgI4ARpAChJJbnQzMlRvU3RyaW5nRW50cnkSEAoDa2V5GAEgASgFUgNr +ZXkSFAoFdmFsdWUYAiABKAlSBXZhbHVlOgI4ARpAChJJbnQ2NFRvU3RyaW5n +RW50cnkSEAoDa2V5GAEgASgDUgNrZXkSFAoFdmFsdWUYAiABKAlSBXZhbHVl +OgI4ARpBChNVaW50MzJUb1N0cmluZ0VudHJ5EhAKA2tleRgBIAEoDVIDa2V5 +EhQKBXZhbHVlGAIgASgJUgV2YWx1ZToCOAEaQQoTVWludDY0VG9TdHJpbmdF +bnRyeRIQCgNrZXkYASABKARSA2tleRIUCgV2YWx1ZRgCIAEoCVIFdmFsdWU6 +AjgBGkEKE1N0cmluZ1RvU3RyaW5nRW50cnkSEAoDa2V5GAEgASgJUgNrZXkS +FAoFdmFsdWUYAiABKAlSBXZhbHVlOgI4ARpAChJTaW50MzJUb0Zsb2F0RW50 +cnkSEAoDa2V5GAEgASgRUgNrZXkSFAoFdmFsdWUYAiABKAJSBXZhbHVlOgI4 +ARpAChJTaW50NjRUb0Zsb2F0RW50cnkSEAoDa2V5GAEgASgSUgNrZXkSFAoF +dmFsdWUYAiABKAJSBXZhbHVlOgI4ARo/ChFJbnQzMlRvRmxvYXRFbnRyeRIQ +CgNrZXkYASABKAVSA2tleRIUCgV2YWx1ZRgCIAEoAlIFdmFsdWU6AjgBGj8K +EUludDY0VG9GbG9hdEVudHJ5EhAKA2tleRgBIAEoA1IDa2V5EhQKBXZhbHVl +GAIgASgCUgV2YWx1ZToCOAEaQAoSVWludDMyVG9GbG9hdEVudHJ5EhAKA2tl +eRgBIAEoDVIDa2V5EhQKBXZhbHVlGAIgASgCUgV2YWx1ZToCOAEaQAoSVWlu +dDY0VG9GbG9hdEVudHJ5EhAKA2tleRgBIAEoBFIDa2V5EhQKBXZhbHVlGAIg +ASgCUgV2YWx1ZToCOAEaQAoSU3RyaW5nVG9GbG9hdEVudHJ5EhAKA2tleRgB +IAEoCVIDa2V5EhQKBXZhbHVlGAIgASgCUgV2YWx1ZToCOAEaQQoTU2ludDMy +VG9Eb3VibGVFbnRyeRIQCgNrZXkYASABKBFSA2tleRIUCgV2YWx1ZRgCIAEo +AVIFdmFsdWU6AjgBGkEKE1NpbnQ2NFRvRG91YmxlRW50cnkSEAoDa2V5GAEg +ASgSUgNrZXkSFAoFdmFsdWUYAiABKAFSBXZhbHVlOgI4ARpAChJJbnQzMlRv +RG91YmxlRW50cnkSEAoDa2V5GAEgASgFUgNrZXkSFAoFdmFsdWUYAiABKAFS +BXZhbHVlOgI4ARpAChJJbnQ2NFRvRG91YmxlRW50cnkSEAoDa2V5GAEgASgD +UgNrZXkSFAoFdmFsdWUYAiABKAFSBXZhbHVlOgI4ARpBChNVaW50MzJUb0Rv +dWJsZUVudHJ5EhAKA2tleRgBIAEoDVIDa2V5EhQKBXZhbHVlGAIgASgBUgV2 +YWx1ZToCOAEaQQoTVWludDY0VG9Eb3VibGVFbnRyeRIQCgNrZXkYASABKARS +A2tleRIUCgV2YWx1ZRgCIAEoAVIFdmFsdWU6AjgBGkEKE1N0cmluZ1RvRG91 +YmxlRW50cnkSEAoDa2V5GAEgASgJUgNrZXkSFAoFdmFsdWUYAiABKAFSBXZh +bHVlOgI4ASoeCghGcm9ibml0ehIICgRGUk9CEAASCAoETklUWhABSt0ZCgYS +BAMAQwEKgQEKAQwSAwMAEjJ3IFVzZSBwcm90b2MgdjMuMC4wIHRvIGNvbXBp +bGUgdGhpcyBmaWxlIGludG8gbWFwLXRlc3QuYmluOgogICBwcm90b2MgLS1k +ZXNjcmlwdG9yX3NldF9vdXQ9bWFwLXRlc3QuYmluIG1hcC10ZXN0LnByb3Rv +IAoKCAoBAhIDBQAMCgoKAgUAEgQHAAoBCgoKAwUAARIDBwUNCgsKBAUAAgAS +AwgCCwoMCgUFAAIAARIDCAIGCgwKBQUAAgACEgMICQoKCwoEBQACARIDCQIL +CgwKBQUAAgEBEgMJAgYKDAoFBQACAQISAwkJCgoKCgIEABIEDAAZAQoKCgME +AAESAwwICwoMCgQEAAMAEgQNAhEDCgwKBQQAAwABEgMNChsKDAoFBAADAAcS +Aw4EHAoNCgYEAAMABwcSAw4EHAoNCgYEAAMAAgASAw8EHAoOCgcEAAMAAgAE +EgMPBAwKDgoHBAADAAIABRIDDw0TCg4KBwQAAwACAAESAw8UFwoOCgcEAAMA +AgADEgMPGhsKDQoGBAADAAIBEgMQBB4KDgoHBAADAAIBBBIDEAQMCg4KBwQA +AwACAQUSAxANEwoOCgcEAAMAAgEBEgMQFBkKDgoHBAADAAIBAxIDEBwdCgsK +BAQAAgASAxICMAoMCgUEAAIABBIDEgIKCgwKBQQAAgAGEgMSCxwKDAoFBAAC +AAESAxIdKwoMCgUEAAIAAxIDEi4vCgwKBAQAAwESBBQCFwMKDAoFBAADAQES +AxQKIQoNCgYEAAMBAgASAxUEHAoOCgcEAAMBAgAEEgMVBAwKDgoHBAADAQIA +BRIDFQ0TCg4KBwQAAwECAAESAxUUFwoOCgcEAAMBAgADEgMVGhsKDQoGBAAD +AQIBEgMWBB4KDgoHBAADAQIBBBIDFgQMCg4KBwQAAwECAQUSAxYNEwoOCgcE +AAMBAgEBEgMWFBkKDgoHBAADAQIBAxIDFhwdCgsKBAQAAgESAxgCPgoMCgUE +AAIBBBIDGAIKCgwKBQQAAgEGEgMYCyIKDAoFBAACAQESAxgjOQoMCgUEAAIB +AxIDGDw9CgoKAgQBEgQbAEMBCgoKAwQBARIDGwgLCgsKBAQBAgASAxwCJQoN +CgUEAQIABBIEHAIbDQoMCgUEAQIABhIDHAISCgwKBQQBAgABEgMcEyAKDAoF +BAECAAMSAxwjJAoLCgQEAQIBEgMdAiUKDQoFBAECAQQSBB0CHCUKDAoFBAEC +AQYSAx0CEgoMCgUEAQIBARIDHRMgCgwKBQQBAgEDEgMdIyQKCwoEBAECAhID +HgIjCg0KBQQBAgIEEgQeAh0lCgwKBQQBAgIGEgMeAhEKDAoFBAECAgESAx4S +HgoMCgUEAQICAxIDHiEiCgsKBAQBAgMSAx8CIwoNCgUEAQIDBBIEHwIeIwoM +CgUEAQIDBhIDHwIRCgwKBQQBAgMBEgMfEh4KDAoFBAECAwMSAx8hIgoLCgQE +AQIEEgMgAiUKDQoFBAECBAQSBCACHyMKDAoFBAECBAYSAyACEgoMCgUEAQIE +ARIDIBMgCgwKBQQBAgQDEgMgIyQKCwoEBAECBRIDIQIlCg0KBQQBAgUEEgQh +AiAlCgwKBQQBAgUGEgMhAhIKDAoFBAECBQESAyETIAoMCgUEAQIFAxIDISMk +CgsKBAQBAgYSAyICJQoNCgUEAQIGBBIEIgIhJQoMCgUEAQIGBhIDIgISCgwK +BQQBAgYBEgMiEyAKDAoFBAECBgMSAyIjJAoLCgQEAQIHEgMkAi8KDQoFBAEC +BwQSBCQCIiUKDAoFBAECBwYSAyQCFwoMCgUEAQIHARIDJBgqCgwKBQQBAgcD +EgMkLS4KCwoEBAECCBIDJQIvCg0KBQQBAggEEgQlAiQvCgwKBQQBAggGEgMl +AhcKDAoFBAECCAESAyUYKgoMCgUEAQIIAxIDJS0uCgsKBAQBAgkSAyYCLgoN +CgUEAQIJBBIEJgIlLwoMCgUEAQIJBhIDJgIWCgwKBQQBAgkBEgMmFygKDAoF +BAECCQMSAyYrLQoLCgQEAQIKEgMnAi4KDQoFBAECCgQSBCcCJi4KDAoFBAEC +CgYSAycCFgoMCgUEAQIKARIDJxcoCgwKBQQBAgoDEgMnKy0KCwoEBAECCxID +KAIwCg0KBQQBAgsEEgQoAicuCgwKBQQBAgsGEgMoAhcKDAoFBAECCwESAygY +KgoMCgUEAQILAxIDKC0vCgsKBAQBAgwSAykCMAoNCgUEAQIMBBIEKQIoMAoM +CgUEAQIMBhIDKQIXCgwKBQQBAgwBEgMpGCoKDAoFBAECDAMSAyktLwoLCgQE +AQINEgMqAjAKDQoFBAECDQQSBCoCKTAKDAoFBAECDQYSAyoCFwoMCgUEAQIN +ARIDKhgqCgwKBQQBAg0DEgMqLS8KCwoEBAECDhIDLAIsCg0KBQQBAg4EEgQs +AiowCgwKBQQBAg4GEgMsAhUKDAoFBAECDgESAywWJgoMCgUEAQIOAxIDLCkr +CgsKBAQBAg8SAy0CLAoNCgUEAQIPBBIELQIsLAoMCgUEAQIPBhIDLQIVCgwK +BQQBAg8BEgMtFiYKDAoFBAECDwMSAy0pKwoLCgQEAQIQEgMuAioKDQoFBAEC +EAQSBC4CLSwKDAoFBAECEAYSAy4CFAoMCgUEAQIQARIDLhUkCgwKBQQBAhAD +EgMuJykKCwoEBAECERIDLwIqCg0KBQQBAhEEEgQvAi4qCgwKBQQBAhEGEgMv +AhQKDAoFBAECEQESAy8VJAoMCgUEAQIRAxIDLycpCgsKBAQBAhISAzACLAoN +CgUEAQISBBIEMAIvKgoMCgUEAQISBhIDMAIVCgwKBQQBAhIBEgMwFiYKDAoF +BAECEgMSAzApKwoLCgQEAQITEgMxAiwKDQoFBAECEwQSBDECMCwKDAoFBAEC +EwYSAzECFQoMCgUEAQITARIDMRYmCgwKBQQBAhMDEgMxKSsKCwoEBAECFBID +MgIsCg0KBQQBAhQEEgQyAjEsCgwKBQQBAhQGEgMyAhUKDAoFBAECFAESAzIW +JgoMCgUEAQIUAxIDMikrCgsKBAQBAhUSAzQCKgoNCgUEAQIVBBIENAIyLAoM +CgUEAQIVBhIDNAIUCgwKBQQBAhUBEgM0FSQKDAoFBAECFQMSAzQnKQoLCgQE +AQIWEgM1AioKDQoFBAECFgQSBDUCNCoKDAoFBAECFgYSAzUCFAoMCgUEAQIW +ARIDNRUkCgwKBQQBAhYDEgM1JykKCwoEBAECFxIDNgIoCg0KBQQBAhcEEgQ2 +AjUqCgwKBQQBAhcGEgM2AhMKDAoFBAECFwESAzYUIgoMCgUEAQIXAxIDNiUn +CgsKBAQBAhgSAzcCKAoNCgUEAQIYBBIENwI2KAoMCgUEAQIYBhIDNwITCgwK +BQQBAhgBEgM3FCIKDAoFBAECGAMSAzclJwoLCgQEAQIZEgM4AioKDQoFBAEC +GQQSBDgCNygKDAoFBAECGQYSAzgCFAoMCgUEAQIZARIDOBUkCgwKBQQBAhkD +EgM4JykKCwoEBAECGhIDOQIqCg0KBQQBAhoEEgQ5AjgqCgwKBQQBAhoGEgM5 +AhQKDAoFBAECGgESAzkVJAoMCgUEAQIaAxIDOScpCgsKBAQBAhsSAzoCKgoN +CgUEAQIbBBIEOgI5KgoMCgUEAQIbBhIDOgIUCgwKBQQBAhsBEgM6FSQKDAoF +BAECGwMSAzonKQoLCgQEAQIcEgM8AiwKDQoFBAECHAQSBDwCOioKDAoFBAEC +HAYSAzwCFQoMCgUEAQIcARIDPBYmCgwKBQQBAhwDEgM8KSsKCwoEBAECHRID +PQIsCg0KBQQBAh0EEgQ9AjwsCgwKBQQBAh0GEgM9AhUKDAoFBAECHQESAz0W +JgoMCgUEAQIdAxIDPSkrCgsKBAQBAh4SAz4CKgoNCgUEAQIeBBIEPgI9LAoM +CgUEAQIeBhIDPgIUCgwKBQQBAh4BEgM+FSQKDAoFBAECHgMSAz4nKQoLCgQE +AQIfEgM/AioKDQoFBAECHwQSBD8CPioKDAoFBAECHwYSAz8CFAoMCgUEAQIf +ARIDPxUkCgwKBQQBAh8DEgM/JykKCwoEBAECIBIDQAIsCg0KBQQBAiAEEgRA +Aj8qCgwKBQQBAiAGEgNAAhUKDAoFBAECIAESA0AWJgoMCgUEAQIgAxIDQCkr +CgsKBAQBAiESA0ECLAoNCgUEAQIhBBIEQQJALAoMCgUEAQIhBhIDQQIVCgwK +BQQBAiEBEgNBFiYKDAoFBAECIQMSA0EpKwoLCgQEAQIiEgNCAiwKDQoFBAEC +IgQSBEICQSwKDAoFBAECIgYSA0ICFQoMCgUEAQIiARIDQhYmCgwKBQQBAiID +EgNCKSs= diff --git a/spec/support/protos/map-test.proto b/spec/support/protos/map-test.proto index 6f7f221d..b5f968e8 100644 --- a/spec/support/protos/map-test.proto +++ b/spec/support/protos/map-test.proto @@ -6,8 +6,8 @@ syntax = "proto2"; package foo; enum Frobnitz { - FROB = 1; - NITZ = 2; + FROB = 0; + NITZ = 1; } message Baz { diff --git a/spec/support/protos/multi_field_extensions.pb.rb b/spec/support/protos/multi_field_extensions.pb.rb index 5e48581d..ff67c0af 100644 --- a/spec/support/protos/multi_field_extensions.pb.rb +++ b/spec/support/protos/multi_field_extensions.pb.rb @@ -1,11 +1,36 @@ # encoding: utf-8 +# frozen_string_literal: true ## # This file is auto-generated. DO NOT EDIT! # +require 'base64' +require 'set' require 'protobuf' module Test + FULLY_QUALIFIED_NAME = 'test' unless defined?(self::FULLY_QUALIFIED_NAME) + + @descriptors = [] unless instance_variable_defined?(:@descriptors) + @descriptors << lambda do + bytes = File.read(__FILE__, mode: 'rb').split(/^__END__$/, 2).last + ::Google::Protobuf::FileDescriptorProto.decode(Base64.decode64(bytes)) + end + + @descriptor_dependencies = Set.new unless instance_variable_defined?(:@descriptor_dependencies) + @descriptor_dependencies |= [] + + unless respond_to?(:descriptor_set) + def self.descriptor_set + ::Google::Protobuf::FileDescriptorSet.new(:file => @descriptors.map(&:call)) + end + end + + unless respond_to?(:descriptor_dependencies) + def self.descriptor_dependencies + @descriptor_dependencies + end + end ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions } ## @@ -13,6 +38,8 @@ module Test # class Header < ::Protobuf::Message class Type < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Type' + define :PayloadTypeA, 1 define :PayloadTypeB, 2 end @@ -35,6 +62,7 @@ class Foo < ::Protobuf::Message; end # Message Fields # class Header + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Header' required ::Test::Header::Type, :type, 1 # Extension Fields extensions 100...536870912 @@ -42,14 +70,18 @@ class Header end class PayloadA + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.PayloadA' class Foo + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Foo' optional :string, :foo_a, 1 end end class PayloadB + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.PayloadB' class Foo + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Foo' optional :string, :foo_b, 1 end @@ -57,3 +89,27 @@ class Foo end + +# Raw descriptor bytes below +__END__ +CiNwcm90b3MvbXVsdGlfZmllbGRfZXh0ZW5zaW9ucy5wcm90bxIEdGVzdCJl +CgZIZWFkZXISJQoEdHlwZRgBIAIoDjIRLnRlc3QuSGVhZGVyLlR5cGVSBHR5 +cGUiKgoEVHlwZRIQCgxQYXlsb2FkVHlwZUEQARIQCgxQYXlsb2FkVHlwZUIQ +AioICGQQgICAgAIiXgoIUGF5bG9hZEEaGgoDRm9vEhMKBWZvb19hGAEgASgJ +UgRmb29BMjYKB3BheWxvYWQSDC50ZXN0LkhlYWRlchhkIAEoCzIOLnRlc3Qu +UGF5bG9hZEFSB3BheWxvYWQiJgoIUGF5bG9hZEIaGgoDRm9vEhMKBWZvb19i +GAEgASgJUgRmb29CSo4FCgYSBAAAIgEKCAoBDBIDAAASCggKAQISAwIADQoK +CgIEABIEBAANAQoKCgMEAAESAwQIDgoKCgMEAAUSAwUCGAoLCgQEAAUAEgMF +DRcKDAoFBAAFAAESAwUNEAoMCgUEAAUAAhIDBRQXCgwKBAQABAASBAcCCgMK +DAoFBAAEAAESAwcHCwoNCgYEAAQAAgASAwgEFQoOCgcEAAQAAgABEgMIBBAK +DgoHBAAEAAIAAhIDCBMUCg0KBgQABAACARIDCQQVCg4KBwQABAACAQESAwkE +EAoOCgcEAAQAAgECEgMJExQKCwoEBAACABIDDAIZCgwKBQQAAgAEEgMMAgoK +DAoFBAACAAYSAwwLDwoMCgUEAAIAARIDDBAUCgwKBQQAAgADEgMMFxgKCgoC +BAESBA8AFwEKCgoDBAEBEgMPCBAKDAoEBAEDABIEEAISAwoMCgUEAQMAARID +EAoNCg0KBgQBAwACABIDEQQeCg4KBwQBAwACAAQSAxEEDAoOCgcEAQMAAgAF +EgMRDRMKDgoHBAEDAAIAARIDERQZCg4KBwQBAwACAAMSAxEcHQoLCgMEAQYS +BBQCFgMKCwoEBAEGABIDFQQkCgwKBQQBBgACEgMUCQ8KDAoFBAEGAAQSAxUE +DAoMCgUEAQYABhIDFQ0VCgwKBQQBBgABEgMVFh0KDAoFBAEGAAMSAxUgIwoK +CgIEAhIEGQAiAQoKCgMEAgESAxkIEAoMCgQEAgMAEgQaAhwDCgwKBQQCAwAB +EgMaCg0KDQoGBAIDAAIAEgMbBB4KDgoHBAIDAAIABBIDGwQMCg4KBwQCAwAC +AAUSAxsNEwoOCgcEAgMAAgABEgMbFBkKDgoHBAIDAAIAAxIDGxwd diff --git a/spec/support/protos/resource.pb.rb b/spec/support/protos/resource.pb.rb index f81ef52f..82ddc6e8 100644 --- a/spec/support/protos/resource.pb.rb +++ b/spec/support/protos/resource.pb.rb @@ -1,8 +1,11 @@ # encoding: utf-8 +# frozen_string_literal: true ## # This file is auto-generated. DO NOT EDIT! # +require 'base64' +require 'set' require 'protobuf' require 'protobuf/rpc/service' @@ -13,12 +16,36 @@ require 'google/protobuf/descriptor.pb' module Test + FULLY_QUALIFIED_NAME = 'test' unless defined?(self::FULLY_QUALIFIED_NAME) + + @descriptors = [] unless instance_variable_defined?(:@descriptors) + @descriptors << lambda do + bytes = File.read(__FILE__, mode: 'rb').split(/^__END__$/, 2).last + ::Google::Protobuf::FileDescriptorProto.decode(Base64.decode64(bytes)) + end + + @descriptor_dependencies = Set.new unless instance_variable_defined?(:@descriptor_dependencies) + @descriptor_dependencies |= [Google::Protobuf] + + unless respond_to?(:descriptor_set) + def self.descriptor_set + ::Google::Protobuf::FileDescriptorSet.new(:file => @descriptors.map(&:call)) + end + end + + unless respond_to?(:descriptor_dependencies) + def self.descriptor_dependencies + @descriptor_dependencies + end + end ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions } ## # Enum Classes # class StatusType < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.StatusType' + set_option :allow_alias, true set_option :".test.enum_option", -789 @@ -39,6 +66,8 @@ class Resource < ::Protobuf::Message; end class ResourceWithRequiredField < ::Protobuf::Message; end class Searchable < ::Protobuf::Message class SearchType < ::Protobuf::Enum + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.SearchType' + define :FLAT, 1 define :NESTED, 2 end @@ -68,6 +97,7 @@ class NestedLevelOne < ::Protobuf::Message; end # Message Fields # class ResourceFindRequest + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ResourceFindRequest' required :string, :name, 1 optional :bool, :active, 2 repeated :string, :widgets, 3 @@ -75,10 +105,12 @@ class ResourceFindRequest end class ResourceSleepRequest + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ResourceSleepRequest' optional :int32, :sleep, 1 end class Resource + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Resource' # Message Options set_option :map_entry, false set_option :".test.message_option", -56 @@ -97,18 +129,23 @@ class Resource end class ResourceWithRequiredField + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ResourceWithRequiredField' required :string, :foo_is_required, 1 end class MessageParent + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.MessageParent' class MessageChild + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.MessageChild' optional :string, :child1, 1 end end class Nested + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.Nested' class NestedLevelOne + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.NestedLevelOne' optional :bool, :level_one, 1, :default => true # Extension Fields extensions 100...102 @@ -159,6 +196,8 @@ class ::Google::Protobuf::MethodOptions < ::Protobuf::Message # Service Classes # class ResourceService < ::Protobuf::Rpc::Service + FULLY_QUALIFIED_NAME = FULLY_QUALIFIED_NAME + '.ResourceService' + set_option :".test.service_option", -9876543210 rpc :find, ::Test::ResourceFindRequest, ::Test::Resource do set_option :".test.method_option", 2 @@ -170,3 +209,140 @@ class ResourceService < ::Protobuf::Rpc::Service end + +# Raw descriptor bytes below +__END__ +ChVwcm90b3MvcmVzb3VyY2UucHJvdG8SBHRlc3QaIGdvb2dsZS9wcm90b2J1 +Zi9kZXNjcmlwdG9yLnByb3RvIn4KE1Jlc291cmNlRmluZFJlcXVlc3QSEgoE +bmFtZRgBIAIoCVIEbmFtZRIWCgZhY3RpdmUYAiABKAhSBmFjdGl2ZRIYCgd3 +aWRnZXRzGAMgAygJUgd3aWRnZXRzEiEKDHdpZGdldF9ieXRlcxgEIAMoDFIL +d2lkZ2V0Qnl0ZXMiLAoUUmVzb3VyY2VTbGVlcFJlcXVlc3QSFAoFc2xlZXAY +ASABKAVSBXNsZWVwIssBCghSZXNvdXJjZRIfCgRuYW1lGAEgAigJQgsIAYip +owOtwtfTIFIEbmFtZRIhCgxkYXRlX2NyZWF0ZWQYAiABKANSC2RhdGVDcmVh +dGVkEigKBnN0YXR1cxgDIAEoDjIQLnRlc3QuU3RhdHVzVHlwZVIGc3RhdHVz +EjUKDXJlcGVhdGVkX2VudW0YBCADKA4yEC50ZXN0LlN0YXR1c1R5cGVSDHJl +cGVhdGVkRW51bSoICGQQgICAgAI6EDgAiKXtAcj//////////wEiQwoZUmVz +b3VyY2VXaXRoUmVxdWlyZWRGaWVsZBImCg9mb29faXNfcmVxdWlyZWQYASAC +KAlSDWZvb0lzUmVxdWlyZWQi+wEKClNlYXJjaGFibGUiIgoKU2VhcmNoVHlw +ZRIICgRGTEFUEAESCgoGTkVTVEVEEAIyOgoRZXh0X2lzX3NlYXJjaGFibGUS +Di50ZXN0LlJlc291cmNlGGQgASgIUg9leHRJc1NlYXJjaGFibGUyMgoNZXh0 +X2lzX2hpZGRlbhIOLnRlc3QuUmVzb3VyY2UYZSABKAhSC2V4dElzSGlkZGVu +MlkKD2V4dF9zZWFyY2hfdHlwZRIOLnRlc3QuUmVzb3VyY2UYZiABKA4yGy50 +ZXN0LlNlYXJjaGFibGUuU2VhcmNoVHlwZToERkxBVFINZXh0U2VhcmNoVHlw +ZSI3Cg1NZXNzYWdlUGFyZW50GiYKDE1lc3NhZ2VDaGlsZBIWCgZjaGlsZDEY +ASABKAlSBmNoaWxkMSK7AwoGTmVzdGVkEhIKBG5hbWUYASABKAlSBG5hbWUS +KgoIcmVzb3VyY2UYAiABKAsyDi50ZXN0LlJlc291cmNlUghyZXNvdXJjZRI9 +ChJtdWx0aXBsZV9yZXNvdXJjZXMYAyADKAsyDi50ZXN0LlJlc291cmNlUhFt +dWx0aXBsZVJlc291cmNlcxIoCgZzdGF0dXMYBCABKA4yEC50ZXN0LlN0YXR1 +c1R5cGVSBnN0YXR1cxqzAQoOTmVzdGVkTGV2ZWxPbmUSIQoJbGV2ZWxfb25l +GAEgASgIOgR0cnVlUghsZXZlbE9uZSoECGQQZjJEChdleHRfbmVzdGVkX2lu +X2xldmVsX29uZRIOLnRlc3QuUmVzb3VyY2UYaSABKAhSE2V4dE5lc3RlZElu +TGV2ZWxPbmUyMgoNZXh0X2R1cF9maWVsZBIOLnRlc3QuUmVzb3VyY2UYaiAB +KAhSC2V4dER1cEZpZWxkKgQIZBBvMkwKFGV4dF9uZXN0ZWRfbGV2ZWxfb25l +EhsudGVzdC5OZXN0ZWQuTmVzdGVkTGV2ZWxPbmUYZCABKAhSEWV4dE5lc3Rl +ZExldmVsT25lKmAKClN0YXR1c1R5cGUSCwoHUEVORElORxAAEgsKB0VOQUJM +RUQQARIMCghESVNBQkxFRBACEgsKB0RFTEVURUQQAxILCgdBTElBU0VEEAMa +EBAB4JygAuv5/////////wEymQIKD1Jlc291cmNlU2VydmljZRI4CgRGaW5k +EhkudGVzdC5SZXNvdXJjZUZpbmRSZXF1ZXN0Gg4udGVzdC5SZXNvdXJjZSIF +iI+OHgISPgoRRmluZFdpdGhScGNGYWlsZWQSGS50ZXN0LlJlc291cmNlRmlu +ZFJlcXVlc3QaDi50ZXN0LlJlc291cmNlEjsKDUZpbmRXaXRoU2xlZXASGi50 +ZXN0LlJlc291cmNlU2xlZXBSZXF1ZXN0Gg4udGVzdC5SZXNvdXJjZRI/ChJG +aW5kTm90SW1wbGVtZW50ZWQSGS50ZXN0LlJlc291cmNlRmluZFJlcXVlc3Qa +Di50ZXN0LlJlc291cmNlGg64grIWltK/mtv/////ATpACgtmaWxlX29wdGlv +bhIcLmdvb2dsZS5wcm90b2J1Zi5GaWxlT3B0aW9ucxjNickEIAEoBFIKZmls +ZU9wdGlvbjpCCgxmaWVsZF9vcHRpb24SHS5nb29nbGUucHJvdG9idWYuRmll +bGRPcHRpb25zGJG1NCABKARSC2ZpZWxkT3B0aW9uOj8KC2VudW1fb3B0aW9u +EhwuZ29vZ2xlLnByb3RvYnVmLkVudW1PcHRpb25zGMyDJCABKANSCmVudW1P +cHRpb246SAoObWVzc2FnZV9vcHRpb24SHy5nb29nbGUucHJvdG9idWYuTWVz +c2FnZU9wdGlvbnMY0dQdIAEoA1INbWVzc2FnZU9wdGlvbjpJCg5zZXJ2aWNl +X29wdGlvbhIfLmdvb2dsZS5wcm90b2J1Zi5TZXJ2aWNlT3B0aW9ucxinoOYC +IAEoA1INc2VydmljZU9wdGlvbjpGCg1tZXRob2Rfb3B0aW9uEh4uZ29vZ2xl +LnByb3RvYnVmLk1ldGhvZE9wdGlvbnMY8eHhAyABKANSDG1ldGhvZE9wdGlv +bjoeCgNmb28SDC50ZXN0Lk5lc3RlZBhkIAEoCVIDZm9vOh4KA2JhchIMLnRl +c3QuTmVzdGVkGGUgASgDUgNiYXI6VwoaZXh0X25lc3RlZF9sZXZlbF9vbmVf +b3V0ZXISGy50ZXN0Lk5lc3RlZC5OZXN0ZWRMZXZlbE9uZRhlIAEoCFIWZXh0 +TmVzdGVkTGV2ZWxPbmVPdXRlckIMgAEB6MzIJOqtwOUkSsAdCgcSBQAAhwEB +CggKAQwSAwAAEgoJCgIDABIDAgAqCggKAQISAwQADQoICgEIEgMGACIKCQoC +CBASAwYAIgoICgEIEgMHACIKDAoFCM2JyQQSAwcAIgoJCgEHEgQJAAsBCgkK +AgcAEgMKAigKCgoDBwACEgMJByIKCgoDBwAEEgMKAgoKCgoDBwAFEgMKCxEK +CgoDBwABEgMKEh0KCgoDBwADEgMKICcKCQoBBxIEDQAPAQoJCgIHARIDDgIo +CgoKAwcBAhIDDQcjCgoKAwcBBBIDDgIKCgoKAwcBBRIDDgsRCgoKAwcBARID +DhIeCgoKAwcBAxIDDiEnCgkKAQcSBBEAEwEKCQoCBwISAxICJgoKCgMHAgIS +AxEHIgoKCgMHAgQSAxICCgoKCgMHAgUSAxILEAoKCgMHAgESAxIRHAoKCgMH +AgMSAxIfJQoJCgEHEgQVABcBCgkKAgcDEgMWAikKCgoDBwMCEgMVByUKCgoD +BwMEEgMWAgoKCgoDBwMFEgMWCxAKCgoDBwMBEgMWER8KCgoDBwMDEgMWIigK +CQoBBxIEGQAbAQoJCgIHBBIDGgIqCgoKAwcEAhIDGQclCgoKAwcEBBIDGgIK +CgoKAwcEBRIDGgsQCgoKAwcEARIDGhEfCgoKAwcEAxIDGiIpCgkKAQcSBB0A +HwEKCQoCBwUSAx4CKQoKCgMHBQISAx0HJAoKCgMHBQQSAx4CCgoKCgMHBQUS +Ax4LEAoKCgMHBQESAx4RHgoKCgMHBQMSAx4hKAoKCgIFABIEIQAqAQoKCgMF +AAESAyEFDwoKCgMFAAMSAyICHAoLCgQFAAMCEgMiAhwKCgoDBQADEgMjAh4K +DQoGBQADzIMkEgMjAh4KCwoEBQACABIDJQIOCgwKBQUAAgABEgMlAgkKDAoF +BQACAAISAyUMDQoLCgQFAAIBEgMmAg4KDAoFBQACAQESAyYCCQoMCgUFAAIB +AhIDJgwNCgsKBAUAAgISAycCDwoMCgUFAAICARIDJwIKCgwKBQUAAgICEgMn +DQ4KCwoEBQACAxIDKAIOCgwKBQUAAgMBEgMoAgkKDAoFBQACAwISAygMDQoL +CgQFAAIEEgMpAg4KDAoFBQACBAESAykCCQoMCgUFAAIEAhIDKQwNCgoKAgQA +EgQsADEBCgoKAwQAARIDLAgbCgsKBAQAAgASAy0CGwoMCgUEAAIABBIDLQIK +CgwKBQQAAgAFEgMtCxEKDAoFBAACAAESAy0SFgoMCgUEAAIAAxIDLRkaCgsK +BAQAAgESAy4CGwoMCgUEAAIBBBIDLgIKCgwKBQQAAgEFEgMuCw8KDAoFBAAC +AQESAy4QFgoMCgUEAAIBAxIDLhkaCgsKBAQAAgISAy8CHgoMCgUEAAICBBID +LwIKCgwKBQQAAgIFEgMvCxEKDAoFBAACAgESAy8SGQoMCgUEAAICAxIDLxwd +CgsKBAQAAgMSAzACIgoMCgUEAAIDBBIDMAIKCgwKBQQAAgMFEgMwCxAKDAoF +BAACAwESAzARHQoMCgUEAAIDAxIDMCAhCgoKAgQBEgQzADUBCgoKAwQBARID +MwgcCgsKBAQBAgASAzQCGwoMCgUEAQIABBIDNAIKCgwKBQQBAgAFEgM0CxAK +DAoFBAECAAESAzQRFgoMCgUEAQIAAxIDNBkaCgoKAgQCEgQ3AEEBCgoKAwQC +ARIDNwgQCgoKAwQCBxIDOAIbCgsKBAQCBwcSAzgCGwoKCgMEAgcSAzkCIAoN +CgYEAgfR1B0SAzkCIAoKCgMEAgUSAzsCGAoLCgQEAgUAEgM7DRcKDAoFBAIF +AAESAzsNEAoMCgUEAgUAAhIDOxQXCgsKBAQCAgASAz0CRwoMCgUEAgIABBID +PQIKCgwKBQQCAgAFEgM9CxEKDAoFBAICAAESAz0SFgoMCgUEAgIAAxIDPRka +CgwKBQQCAgAIEgM9G0YKDwoIBAICAAiRtTQSAz0cNwoNCgYEAgIACAESAz05 +RQoLCgQEAgIBEgM+AiIKDAoFBAICAQQSAz4CCgoMCgUEAgIBBRIDPgsQCgwK +BQQCAgEBEgM+ER0KDAoFBAICAQMSAz4gIQoLCgQEAgICEgM/AiEKDAoFBAIC +AgQSAz8CCgoMCgUEAgICBhIDPwsVCgwKBQQCAgIBEgM/FhwKDAoFBAICAgMS +Az8fIAoLCgQEAgIDEgNAAigKDAoFBAICAwQSA0ACCgoMCgUEAgIDBhIDQAsV +CgwKBQQCAgMBEgNAFiMKDAoFBAICAwMSA0AmJwoKCgIEAxIEQwBFAQoKCgME +AwESA0MIIQoLCgQEAwIAEgNEAiYKDAoFBAMCAAQSA0QCCgoMCgUEAwIABRID +RAsRCgwKBQQDAgABEgNEEiEKDAoFBAMCAAMSA0QkJQoKCgIEBBIERwBSAQoK +CgMEBAESA0cIEgoMCgQEBAQAEgRIAksDCgwKBQQEBAABEgNIBxEKDQoGBAQE +AAIAEgNJBA0KDgoHBAQEAAIAARIDSQQICg4KBwQEBAACAAISA0kLDAoNCgYE +BAQAAgESA0oEDwoOCgcEBAQAAgEBEgNKBAoKDgoHBAQEAAIBAhIDSg0OCgsK +AwQEBhIETQJRAwoLCgQEBAYAEgNOBCoKDAoFBAQGAAISA00JFgoMCgUEBAYA +BBIDTgQMCgwKBQQEBgAFEgNODREKDAoFBAQGAAESA04SIwoMCgUEBAYAAxID +TiYpCgsKBAQEBgESA08EJgoMCgUEBAYBAhIDTQkWCgwKBQQEBgEEEgNPBAwK +DAoFBAQGAQUSA08NEQoMCgUEBAYBARIDTxIfCgwKBQQEBgEDEgNPIiUKCwoE +BAQGAhIDUARICgwKBQQEBgICEgNNCRYKDAoFBAQGAgQSA1AEDAoMCgUEBAYC +BhIDUA0iCgwKBQQEBgIBEgNQIzIKDAoFBAQGAgMSA1A1OAoMCgUEBAYCCBID +UDlHCgwKBQQEBgIHEgNQQkYKCgoCBAUSBFQAWAEKCgoDBAUBEgNUCBUKDAoE +BAUDABIEVQJXAwoMCgUEBQMAARIDVQoWCg0KBgQFAwACABIDVgQfCg4KBwQF +AwACAAQSA1YEDAoOCgcEBQMAAgAFEgNWDRMKDgoHBAUDAAIAARIDVhQaCg4K +BwQFAwACAAMSA1YdHgoKCgIEBhIEWgBzAQoKCgMEBgESA1oIDgoKCgMEBgUS +A1sCGAoLCgQEBgUAEgNbDRcKDAoFBAYFAAESA1sNEAoMCgUEBgUAAhIDWxQX +CgsKBAQGAgASA10CGwoMCgUEBgIABBIDXQIKCgwKBQQGAgAFEgNdCxEKDAoF +BAYCAAESA10SFgoMCgUEBgIAAxIDXRkaCgsKBAQGAgESA14CIQoMCgUEBgIB +BBIDXgIKCgwKBQQGAgEGEgNeCxMKDAoFBAYCAQESA14UHAoMCgUEBgIBAxID +Xh8gCgsKBAQGAgISA18CKwoMCgUEBgICBBIDXwIKCgwKBQQGAgIGEgNfCxMK +DAoFBAYCAgESA18UJgoMCgUEBgICAxIDXykqCgsKBAQGAgMSA2ACIQoMCgUE +BgIDBBIDYAIKCgwKBQQGAgMGEgNgCxUKDAoFBAYCAwESA2AWHAoMCgUEBgID +AxIDYB8gCgwKBAQGAwASBGICagMKDAoFBAYDAAESA2IKGAoMCgUEBgMABRID +YwQaCg0KBgQGAwAFABIDYw8ZCg4KBwQGAwAFAAESA2MPEgoOCgcEBgMABQAC +EgNjFhkKDQoGBAYDAAIAEgNkBC8KDgoHBAYDAAIABBIDZAQMCg4KBwQGAwAC +AAUSA2QNEQoOCgcEBgMAAgABEgNkEhsKDgoHBAYDAAIAAxIDZB4fCg4KBwQG +AwACAAgSA2QgLgoOCgcEBgMAAgAHEgNkKS0KDQoFBAYDAAYSBGYEaQUKDQoG +BAYDAAYAEgNnBjIKDgoHBAYDAAYAAhIDZgsTCg4KBwQGAwAGAAQSA2cGDgoO +CgcEBgMABgAFEgNnDxMKDgoHBAYDAAYAARIDZxQrCg4KBwQGAwAGAAMSA2cu +MQoNCgYEBgMABgESA2gGKAoOCgcEBgMABgECEgNmCxMKDgoHBAYDAAYBBBID +aAYOCg4KBwQGAwAGAQUSA2gPEwoOCgcEBgMABgEBEgNoFCEKDgoHBAYDAAYB +AxIDaCQnCgsKAwQGBhIEbAJuAwoLCgQEBgYAEgNtBC0KDAoFBAYGAAISA2wJ +FwoMCgUEBgYABBIDbQQMCgwKBQQGBgAFEgNtDREKDAoFBAYGAAESA20SJgoM +CgUEBgYAAxIDbSksCgkKAQcSBHUAeAEKCQoCBwYSA3YCHAoKCgMHBgISA3UH +DQoKCgMHBgQSA3YCCgoKCgMHBgUSA3YLEQoKCgMHBgESA3YSFQoKCgMHBgMS +A3YYGwoJCgIHBxIDdwIbCgoKAwcHAhIDdQcNCgoKAwcHBBIDdwIKCgoKAwcH +BRIDdwsQCgoKAwcHARIDdxEUCgoKAwcHAxIDdxcaCgkKAQcSBHoAfAEKCQoC +BwgSA3sCMQoKCgMHCAISA3oHHAoKCgMHCAQSA3sCCgoKCgMHCAUSA3sLDwoK +CgMHCAESA3sQKgoKCgMHCAMSA3stMAoLCgIGABIFfgCHAQEKCgoDBgABEgN+ +CBcKCgoDBgADEgN/AigKDgoHBgADp6DmAhIDfwIoCg4KBAYAAgASBoEBAoMB +AwoNCgUGAAIAARIEgQEGCgoNCgUGAAIAAhIEgQEMHwoNCgUGAAIAAxIEgQEq +MgoNCgUGAAIABBIEggEEHwoRCgkGAAIABPHh4QMSBIIBBB8KDAoEBgACARIE +hAECQQoNCgUGAAIBARIEhAEGFwoNCgUGAAIBAhIEhAEZLAoNCgUGAAIBAxIE +hAE3PwoMCgQGAAICEgSFAQI+Cg0KBQYAAgIBEgSFAQYTCg0KBQYAAgICEgSF +ARUpCg0KBQYAAgIDEgSFATQ8CgwKBAYAAgMSBIYBAkIKDQoFBgACAwESBIYB +BhgKDQoFBgACAwISBIYBGi0KDQoFBgACAwMSBIYBOEA=