Hi,
This patchset allow you to run Cucumber features on EC2 for free ;-)
How ?
Mocking. We have some 'mock' already, but unfortunatelly it work *only* for EC2 and was written for this provider.
After applying this patch, you will see that now mocking is done in nicer and more 'abstract' way and basically it's driver independent.
After brief look to 'base_driver/mock_driver.rb' we can spot block of code which did that job:
def self.wrap_methods(c) c.class_eval do cached_methods.each do |m| alias_method "original_#{m}".to_sym, m.to_sym define_method m.to_sym do |*args| args = args.first if args.size.eql?(1) and args.first.class.eql?(Hash) output = deserialize_data(m, args) unless output output = method("original_#{m}".to_sym).to_proc[args] serialize_data(m, output , args) unless output end return output end end end end
Explanation:
If you include this module into some class, it wraps methods returned from 'cached_methods' class method. Then it takes method arguments and method name and lookup for serialized data. If there are no serialized data to use, it calls original method and serialize output into Base64 file. When you use this method again, it doesn't call original method but use 'cached' data from mock instead.
There are two nice things:
1. Checksum is created from arguments, so you can call one method with different arguments and this is 'serialized' again and again...
2. For different scenarios you can 'prefix' mock files. (@create-instance, @destroy-instance...)
Some 'sample' data from my EC2 account are included. You can create your own data. All you need to do is write your API credentials into tests/support/ec2/env.rb. Then just run 'rake cucumber' and all output data will be recorded. When you then run this task again, it'll use recorded data instead of connecting to EC2.
Howto start:
1. cd core/tests 2. export API_DRIVER="ec2" 3. rake cucumber
There are still some issues with 'reboot' and 'create' instance, but I hope I'll fix this stuff very soon.
-- Michal
--- server/lib/deltacloud/base_driver/mock_driver.rb | 92 ++++++++++++++++++++++ 1 files changed, 92 insertions(+), 0 deletions(-) create mode 100644 server/lib/deltacloud/base_driver/mock_driver.rb
diff --git a/server/lib/deltacloud/base_driver/mock_driver.rb b/server/lib/deltacloud/base_driver/mock_driver.rb new file mode 100644 index 0000000..ef92ada --- /dev/null +++ b/server/lib/deltacloud/base_driver/mock_driver.rb @@ -0,0 +1,92 @@ +require 'base64' + +module Deltacloud::Mock + + module Cache + + CACHE_STORAGE = File.join(File.dirname(__FILE__), '..', '..', '..', 'features', 'support') + + def cache_dir + File.join(CACHE_STORAGE, self.class.name.split('::').last.downcase) + end + + def serialize_data(method_name, data, args) + File.open(cache_file_name(method_name, args), 'w') do |f| + f.puts(Base64.encode64(Marshal.dump(data))) + end + puts "[MOCK] Serialized #{method_name}" + return data + end + + def deserialize_data(method_name, args) + begin + data = File.readlines(cache_file_name(method_name, args)).join + puts "[MOCK] Loaded serialized data for #{method_name}" + Marshal.load(Base64.decode64(data)) + rescue Errno::ENOENT + return false + end + end + + def args_hash(args) + Digest::SHA1.hexdigest(args.to_s) + end + + def cache_file_name(method_name, args) + FileUtils.mkdir_p(cache_dir) unless File.directory?(cache_dir) + File.join(cache_dir, "#{method_name}.#{args_hash(args)}") + end + + def self.wrap_methods(c) + c.class_eval do + cached_methods.each do |m| + alias_method "original_#{m}".to_sym, m.to_sym + define_method m.to_sym do |*args| + args = args.first if args.size.eql?(1) and args.first.class.eql?(Hash) + output = deserialize_data(m, args) + unless output + output = method("original_#{m}".to_sym).to_proc[args] + serialize_data(m, output, args) + end + return output + end + end + end + end + + end + + # Create 'mock' version of original driver client/gem: + + class EC2 < AWS::EC2::Base + + include Deltacloud::Mock::Cache + + def self.cached_methods + [ + :describe_images, + :describe_availability_zones, + :run_instances, + :describe_instances, + :reboot_instances, + :terminate_instances, + ] + end + + Deltacloud::Mock::Cache::wrap_methods(self) + end + +end + +# Replace original client with mock client +Deltacloud::Drivers::EC2::EC2Driver.class_eval do + alias_method :original_new_client, :new_client + + def new_client(credentials, opts={}) + Deltacloud::Mock::EC2.new( + :access_key_id => credentials.user, + :secret_access_key => credentials.password + ) + end + +end
--- server/lib/deltacloud/base_driver/mock_driver.rb | 17 +- server/lib/deltacloud/drivers/ec2/ec2_driver.rb | 10 +- server/lib/drivers.rb | 4 +- tests/Rakefile | 52 ++++++ tests/ec2/99_rake.feature | 7 + tests/ec2/api.feature | 41 +++++ tests/ec2/hardware_profiles.feature | 29 ++++ tests/ec2/images.feature | 59 +++++++ tests/ec2/instance_states.feature | 36 ++++ tests/ec2/instances.feature | 171 ++++++++++++++++++++ tests/ec2/realms.feature | 31 ++++ tests/ec2/step_definitions/api_steps.rb | 103 ++++++++++++ .../step_definitions/hardware_profiles_steps.rb | 25 +++ tests/ec2/step_definitions/images_steps.rb | 83 ++++++++++ .../ec2/step_definitions/instance_states_steps.rb | 34 ++++ tests/ec2/step_definitions/instances_steps.rb | 137 ++++++++++++++++ tests/ec2/step_definitions/rake_steps.rb | 19 +++ tests/ec2/storage_snapshots.feature | 29 ++++ tests/ec2/storage_volumes.feature | 33 ++++ tests/ec2/support/env.rb | 53 ++++++ tests/mock/99_rake.feature | 7 + tests/mock/api.feature | 41 +++++ tests/mock/hardware_profiles.feature | 29 ++++ tests/mock/images.feature | 59 +++++++ tests/mock/instance_states.feature | 36 ++++ tests/mock/instances.feature | 165 +++++++++++++++++++ tests/mock/realms.feature | 31 ++++ tests/mock/step_definitions/api_steps.rb | 103 ++++++++++++ .../step_definitions/hardware_profiles_steps.rb | 25 +++ tests/mock/step_definitions/images_steps.rb | 83 ++++++++++ .../mock/step_definitions/instance_states_steps.rb | 34 ++++ tests/mock/step_definitions/instances_steps.rb | 121 ++++++++++++++ tests/mock/step_definitions/rake_steps.rb | 19 +++ tests/mock/storage_snapshots.feature | 29 ++++ tests/mock/storage_volumes.feature | 33 ++++ tests/mock/support/env.rb | 40 +++++ 36 files changed, 1813 insertions(+), 15 deletions(-) create mode 100644 tests/Rakefile create mode 100644 tests/ec2/99_rake.feature create mode 100644 tests/ec2/api.feature create mode 100644 tests/ec2/hardware_profiles.feature create mode 100644 tests/ec2/images.feature create mode 100644 tests/ec2/instance_states.feature create mode 100644 tests/ec2/instances.feature create mode 100644 tests/ec2/realms.feature create mode 100644 tests/ec2/step_definitions/api_steps.rb create mode 100644 tests/ec2/step_definitions/hardware_profiles_steps.rb create mode 100644 tests/ec2/step_definitions/images_steps.rb create mode 100644 tests/ec2/step_definitions/instance_states_steps.rb create mode 100644 tests/ec2/step_definitions/instances_steps.rb create mode 100644 tests/ec2/step_definitions/rake_steps.rb create mode 100644 tests/ec2/storage_snapshots.feature create mode 100644 tests/ec2/storage_volumes.feature create mode 100644 tests/ec2/support/env.rb create mode 100644 tests/mock/99_rake.feature create mode 100644 tests/mock/api.feature create mode 100644 tests/mock/hardware_profiles.feature create mode 100644 tests/mock/images.feature create mode 100644 tests/mock/instance_states.feature create mode 100644 tests/mock/instances.feature create mode 100644 tests/mock/realms.feature create mode 100644 tests/mock/step_definitions/api_steps.rb create mode 100644 tests/mock/step_definitions/hardware_profiles_steps.rb create mode 100644 tests/mock/step_definitions/images_steps.rb create mode 100644 tests/mock/step_definitions/instance_states_steps.rb create mode 100644 tests/mock/step_definitions/instances_steps.rb create mode 100644 tests/mock/step_definitions/rake_steps.rb create mode 100644 tests/mock/storage_snapshots.feature create mode 100644 tests/mock/storage_volumes.feature create mode 100644 tests/mock/support/env.rb
diff --git a/server/lib/deltacloud/base_driver/mock_driver.rb b/server/lib/deltacloud/base_driver/mock_driver.rb index ef92ada..dadef4b 100644 --- a/server/lib/deltacloud/base_driver/mock_driver.rb +++ b/server/lib/deltacloud/base_driver/mock_driver.rb @@ -1,27 +1,27 @@ require 'base64' +require 'ap'
module Deltacloud::Mock
module Cache
- CACHE_STORAGE = File.join(File.dirname(__FILE__), '..', '..', '..', 'features', 'support') - def cache_dir - File.join(CACHE_STORAGE, self.class.name.split('::').last.downcase) + storage_dir = File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'tests', DRIVER.to_s, 'support') + File.join(storage_dir, self.class.name.split('::').last.downcase) end
def serialize_data(method_name, data, args) File.open(cache_file_name(method_name, args), 'w') do |f| f.puts(Base64.encode64(Marshal.dump(data))) end - puts "[MOCK] Serialized #{method_name}" + #puts "[MOCK] Serialized #{method_name}" return data end
def deserialize_data(method_name, args) begin + #puts "[MOCK] Loading serialized data for #{$scenario_prefix}_#{method_name}" data = File.readlines(cache_file_name(method_name, args)).join - puts "[MOCK] Loaded serialized data for #{method_name}" Marshal.load(Base64.decode64(data)) rescue Errno::ENOENT return false @@ -34,6 +34,7 @@ module Deltacloud::Mock
def cache_file_name(method_name, args) FileUtils.mkdir_p(cache_dir) unless File.directory?(cache_dir) + method_name = $scenario_prefix ? "#{$scenario_prefix}_#{method_name}" : method_name File.join(cache_dir, "#{method_name}.#{args_hash(args)}") end
@@ -46,12 +47,12 @@ module Deltacloud::Mock output = deserialize_data(m, args) unless output output = method("original_#{m}".to_sym).to_proc[args] - serialize_data(m, output, args) + serialize_data(m, output , args) unless output end return output end end - end + end end
end @@ -69,7 +70,7 @@ module Deltacloud::Mock :run_instances, :describe_instances, :reboot_instances, - :terminate_instances, + :terminate_instances ] end
diff --git a/server/lib/deltacloud/drivers/ec2/ec2_driver.rb b/server/lib/deltacloud/drivers/ec2/ec2_driver.rb index ef39ea1..8797567 100644 --- a/server/lib/deltacloud/drivers/ec2/ec2_driver.rb +++ b/server/lib/deltacloud/drivers/ec2/ec2_driver.rb @@ -120,11 +120,11 @@ class EC2Driver < Deltacloud::BaseDriver config = { :owner_id => "amazon" } config.merge!({ :owner_id => opts[:owner_id] }) if opts and opts[:owner_id] end - safely do + #safely do ec2.describe_images(config).imagesSet.item.each do |image| img_arr << convert_image(image) end - end + #end img_arr = filter_on( img_arr, :architecture, opts ) img_arr.sort_by{|e| [e.owner_id, e.name]} end @@ -150,7 +150,7 @@ class EC2Driver < Deltacloud::BaseDriver def instances(credentials, opts=nil) ec2 = new_client(credentials) instances = [] - safely do + #safely do param = opts.nil? ? nil : opts[:id] ec2_instances = ec2.describe_instances.reservationSet return [] unless ec2_instances @@ -159,7 +159,7 @@ class EC2Driver < Deltacloud::BaseDriver instances << convert_instance( ec2_instance, item.ownerId ) end end - end + #end instances = filter_on( instances, :id, opts ) instances = filter_on( instances, :state, opts ) instances @@ -329,7 +329,7 @@ class EC2Driver < Deltacloud::BaseDriver rescue AWS::AuthFailure => e raise Deltacloud::AuthException.new rescue Exception => e - puts "ERROR: #{e.message}" + puts "ERROR: #{e.message}\n#{e.backtrace.join("\n")}" end end
diff --git a/server/lib/drivers.rb b/server/lib/drivers.rb index 6ef537c..dfa2361 100644 --- a/server/lib/drivers.rb +++ b/server/lib/drivers.rb @@ -24,14 +24,14 @@ end
def driver_mock_source_name return File.join('deltacloud', 'drivers', DRIVER.to_s, "#{DRIVER}_driver.rb") if driver_name.eql? 'Mock' - File.join('deltacloud', 'drivers', DRIVER, "#{DRIVER}_mock_driver.rb") end
def driver require driver_source_name + #require 'deltacloud/base_driver/mock_driver.rb'
if Sinatra::Application.environment.eql? :test - require driver_mock_source_name + require driver_mock_source_name if driver_mock_source_name end
@driver ||= eval( driver_class_name ).new diff --git a/tests/Rakefile b/tests/Rakefile new file mode 100644 index 0000000..7cddad3 --- /dev/null +++ b/tests/Rakefile @@ -0,0 +1,52 @@ +# +# Copyright (C) 2009 Red Hat, Inc. +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +# Add your own tasks in files placed in lib/tasks ending in .rake, +# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake. + +require 'rake' +require 'rake/testtask' +require 'rake/gempackagetask' +require 'cucumber' +require 'cucumber/rake/task' + +DRIVER=ENV['API_DRIVER'] || 'mock' + +Cucumber::Rake::Task.new(:features) do |t| + t.cucumber_opts = "../tests/#{DRIVER} --format html --out ../tests/tmp/cucumber_#{DRIVER}.html" + t.rcov = false +end + +Cucumber::Rake::Task.new(:cucumber) do |t| + t.cucumber_opts = "../tests/#{DRIVER} --format pretty" + t.rcov = false +end + +Cucumber::Rake::Task.new(:rcov) do |t| + t.cucumber_opts = "../tests/#{DRIVER} --format pretty" + t.rcov = true + t.rcov_opts << %[-o "tmp/coverage_#{DRIVER}"] +end + +Cucumber::Rake::Task.new(:junit) do |t| + t.cucumber_opts = "../tests/#{DRIVER} --format junit --out ../tests/tmp/junit_#{DRIVER}" +end + +load '../server/deltacloud-core.gemspec' +Rake::GemPackageTask.new(@spec) do |pkg| + pkg.need_tar = true +end diff --git a/tests/ec2/99_rake.feature b/tests/ec2/99_rake.feature new file mode 100644 index 0000000..c4362c5 --- /dev/null +++ b/tests/ec2/99_rake.feature @@ -0,0 +1,7 @@ +Feature: Running rake tasks + + Scenario: I want to build Deltacloud API gem + Given I have a clean /pkg directory + When I run a 'package' task + Then I should see a gem file inside pkg directory + And I should see a tgz file inside pkg directory diff --git a/tests/ec2/api.feature b/tests/ec2/api.feature new file mode 100644 index 0000000..e6b1625 --- /dev/null +++ b/tests/ec2/api.feature @@ -0,0 +1,41 @@ +Feature: Accessing API entry points + + Scenario: API driver and version + Given URI /api exists + And authentification is not required for this URI + When client access this URI + Then client should get root element 'api' + And this element should have attribute 'driver' with value 'ec2' + And this element should have attribute 'version' with value '1.0' + + Scenario: List of entry points + Given URI /api exists + And authentification is not required for this URI + When client access this URI + Then client should get list of valid entry points: + | realms | + | instances | + | images | + | instance_states | + | hardware_profiles | + | storage_snapshots | + | storage_volumes | + And this URI should be available in XML, JSON, HTML format + + Scenario: Following entry points + Given URI /api exists + And authentification is not required for this URI + When client access this URI + Then client should get list of valid entry points + And each link should have 'rel' attribute with valid name + And each link should have 'href' attribute with valid URL + When client follow this attribute + Then client should get a valid response + + Scenario: Instance features + Given URI /api exists + And authentification is not required for this URI + When client access this URI + Then client should get list of features inside 'instances': + | authentication_key | + | user_data | diff --git a/tests/ec2/hardware_profiles.feature b/tests/ec2/hardware_profiles.feature new file mode 100644 index 0000000..616ee4b --- /dev/null +++ b/tests/ec2/hardware_profiles.feature @@ -0,0 +1,29 @@ +Feature: Accessing hardware profiles + + Scenario: I want to get list of all hardware profiles + Given URI /api/hardware_profiles exists + And authentification is not required for this URI + When client access this URI + Then client should get root element 'hardware-profiles' + And this URI should be available in XML, HTML, JSON format + + Scenario: I want to show hardware profile details + Given URI /api/hardware_profiles exists + And authentification is not required for this URI + When client access this URI + Then client should get root element 'hardware-profiles' + When client want to show 'm1.small' hardware-profile + And client should get this hardware-profile + And it should have a href attribute + And it should have a fixed property 'cpu' + And it should have a range property 'memory' + And it should have a enum property 'storage' + And this URI should be available in XML, HTML, JSON format + + Scenario: Filtering images by architecture + Given URI /api/hardware_profiles exists + And authentification is required for this URI + When client access this URI with parameters: + | architecture | i386 | + Then client should get some hardware-profiles + And each hardware-profile should have 'architecture' attribute set to 'i386' diff --git a/tests/ec2/images.feature b/tests/ec2/images.feature new file mode 100644 index 0000000..af1e705 --- /dev/null +++ b/tests/ec2/images.feature @@ -0,0 +1,59 @@ +Feature: Listing and showing images + + Scenario: Listing available images + Given URI /api/images exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'images' + And this element contains some images + And each image should have: + | id | + | name | + | description | + | architecture | + | owner_id | + And each image should have 'href' attribute with valid URL + And this URI should be available in XML, JSON, HTML format + + Scenario: Following image href attribute + Given URI /api/images exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'images' + And this element contains some images + When client want to show first image + Then client should follow href attribute in image + And client should get valid response with requested image + And this image should have: + | id | + | name | + | description | + | architecture | + | owner_id | + And this URI should be available in XML, JSON, HTML format + + Scenario: Filtering images by owner_id + Given URI /api/images exists + And authentification is required for this URI + When client access this URI with parameters: + | owner_id | 205605819716 | + Then client should get some images + And each image should have 'owner_id' attribute set to '205605819716' + + Scenario: Filtering images by architecture + Given URI /api/images exists + And authentification is required for this URI + When client access this URI with parameters: + | architecture | i386 | + Then client should get some images + And each image should have 'architecture' attribute set to 'i386' + + Scenario: Filtering images by architecture and owner_id + Given URI /api/images exists + And authentification is required for this URI + When client access this URI with parameters: + | architecture | i386 | + | owner_id | 205605819716 | + Then client should get some images + And each image should have 'architecture' attribute set to 'i386' + And each image should have 'owner_id' attribute set to '205605819716' diff --git a/tests/ec2/instance_states.feature b/tests/ec2/instance_states.feature new file mode 100644 index 0000000..3008ef0 --- /dev/null +++ b/tests/ec2/instance_states.feature @@ -0,0 +1,36 @@ +Feature: Instance states and transitions + + Scenario: Getting list of states + Given URI /api/instance_states exists + And authentification is not required for this URI + When client access this URI + Then client should get root element 'states' + And this element contains some states + And this URI should be available in XML, JSON, HTML format + + + Scenario: State names + Given URI /api/instance_states exists + And authentification is not required for this URI + When client access this URI + Then client should get root element 'states' + And states element contains some states + And each state should have 'name' attribute + And first state should have 'name' attribute set to 'start' + And last state should have 'name' attribute set to 'finish' + + Scenario: Transitions + Given URI /api/instance_states exists + And authentification is not required for this URI + When client access this URI + Then client should get root element 'states' + And states element contains some states + And some states should have transitions + And each transitions should have 'to' attribute + + Scenario: State diagram + Given URI /api/instance_states exists + And authentification is not required for this URI + When client access this URI + And client wants PNG format + Then client should get PNG image diff --git a/tests/ec2/instances.feature b/tests/ec2/instances.feature new file mode 100644 index 0000000..336bdfb --- /dev/null +++ b/tests/ec2/instances.feature @@ -0,0 +1,171 @@ +Feature: Managing instances + + Scenario: Listing current instances + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + And each instance should have: + | id | + | name | + | owner_id | + | image | + | realm | + | state | + | hardware-profile | + | actions | + | public-addresses | + | private-addresses | + And each instance should have 'href' attribute with valid URL + And this URI should be available in XML, JSON, HTML format + + Scenario: Filtering instances by state + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI with parameters: + | state | RUNNING | + Then client should get some instances + And each instance should have 'state' attribute set to 'RUNNING' + + Scenario: Get details about first instance + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + When client want to show first instance + Then client follow href attribute in first instance + Then client should get this instance + And this instance should have: + | id | + | name | + | owner_id | + | image | + | realm | + | state | + | hardware-profile | + | actions | + | public-addresses | + | private-addresses | + | authentication | + + Scenario: Following image href in instance + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + When client follow image href attribute in first instance + Then client should get valid image + + Scenario: Following realm href in instance + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + When client follow realm href attribute in first instance + Then client should get valid realm + + Scenario: Following hardware profile href in instance + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + When client follow hardware-profile href attribute in first instance + Then client should get valid hardware-profile + + Scenario: Instance actions + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + And each instance should have actions + And each actions should have some links + And each link should have valid href attribute + And each link should have valid method attribute + And each link should have valid rel attribute + + @prefix-reboot + Scenario: Reboot instance + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + When client want to 'reboot' first instance + And client follow link in actions + Then client should get first instance + And this instance should be in 'RUNNING' state + + @prefix-stop + Scenario: Stop instance + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + When client want to 'stop' first instance + And client follow link in actions + Then client should get first instance + And this instance should be in 'STOPPED' state + + @prefix-start + Scenario: Start instance + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + When client want to 'start' first instance + And client follow link in actions + Then client should get first instance + And this instance should be in 'RUNNING' state + + @prefix-create + Scenario: Basic instance creation + Given URI /api/instances exists + And authentification is required for this URI + When client want to create a new instance + Then client should choose first image + When client request for a new instance + Then new instance should be created + And this instance should have chosed image + And this instance should be in 'RUNNING' state + And this instance should have valid id + And this instance should have name + + @prefix-create-hwp + Scenario: Choosing hardware profile for instance + Given URI /api/instances exists + And authentification is required for this URI + When client want to create a new instance + Then client should choose first image + And client choose first hardware profile + When client request for a new instance + Then new instance should be created + And this instance should have chosed image + And this instance should be in 'RUNNING' state + And this instance should have valid id + And this instance should have last hardware profile + And this instance should have name + + Scenario: Create instance using HTML form + Given URI /api/instances/new exists in HTML format + And authentification is required for this URI + When client access this URI + Then client should get HTML form + + Scenario: Destroying created instance + Given URI /api/instances exists + And authentification is required for this URI + When client want to 'stop' created instance + And client follow link in actions + Then client should get created instance + And this instance should be in 'STOPPED' state + When client want to 'destroy' created instance + And client follow link in actions + And this instance should be destroyed diff --git a/tests/ec2/realms.feature b/tests/ec2/realms.feature new file mode 100644 index 0000000..a89173b --- /dev/null +++ b/tests/ec2/realms.feature @@ -0,0 +1,31 @@ +Feature: Accessing realms + + Scenario: Getting list of available realms + Given URI /api/realms exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'realms' + And this element contains some realms + And each realm should have: + | id | + | name | + | state | + | limit | + And each realm should have 'href' attribute with valid URL + And this URI should be available in XML, JSON, HTML format + + Scenario: Following realm href attribute + Given URI /api/realms exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'realms' + And this element contains some realms + When client want to show first realm + Then client should follow href attribute in realm + And client should get valid response with requested realm + And this realm should have: + | id | + | name | + | state | + | limit | + And this URI should be available in XML, JSON, HTML format diff --git a/tests/ec2/step_definitions/api_steps.rb b/tests/ec2/step_definitions/api_steps.rb new file mode 100644 index 0000000..9a30c3d --- /dev/null +++ b/tests/ec2/step_definitions/api_steps.rb @@ -0,0 +1,103 @@ +Given /^URI ([\w/-_]+) exists$/ do |uri| + get uri, {} + last_response.status.should_not == 404 + last_response.status.should_not == 500 + @uri = uri +end + +Given /^URI ([\w/-_]+) exists in (.+) format$/ do |uri, format| + @uri = "#{uri}.#{format.downcase}" + get @uri, {} + last_response.status.should_not == 404 + last_response.status.should_not == 500 +end + +Given /^authentification is not required for this URI$/ do + last_response.status.should_not == 401 +end + +When /^client access this URI$/ do + get @uri, {} + last_response.status.should_not == 404 +end + +Then /^client should get root element '(.+)'$/ do |element| + @last_element = output_xml.xpath('/'+element).first + @last_element.should_not be_nil + @last_element.name.should == element +end + +Then /^this element should have attribute '(.+)' with value '(.+)'$/ do |atr, val| + @last_element[atr.to_sym].should == val +end + +Then /^client should get list of valid entry points:$/ do |table| + @entry_points = table.raw.flatten.sort + links = [] + output_xml.xpath('/api/link').each do |entry_point| + links << entry_point['rel'] + end + @entry_points.should == links.sort +end + +Then /^this URI should be available in (.+) format$/ do |formats| + @no_header = true + formats.split(',').each do |format| + get "#{@uri}.#{format.strip.downcase}", {} + last_response.status.should == 200 + end + @no_header = false +end + +Then /^client should get list of valid entry points$/ do + links = [] + output_xml.xpath('/api/link').each do |entry_point| + links << entry_point['rel'] + end + @entry_points.should == links.sort +end + +Then /^each (\w+) should have '(.+)' attribute with valid (.+)$/ do |el, attr, t| + case el + when 'link': + path = '/api/link' + when 'image': + path = '/images/image' + end + output_xml.xpath(path).each do |entry_point| + @entry_points.include?(entry_point[attr]).should == true if t=='name' + if t=='URL' + entry_point[:href].should_not be_nil + end + end + @last_attribute = attr +end + +Then /^each ([\w-]+) should have '(.+)' attribute set to '(.+)'$/ do |el, attr, v| + case el + when 'image': + path = "/image/images" + end + output_xml.xpath(path).each do |element| + element[attr].should == v + end +end + +When /^client follow this attribute$/ do + output_xml.xpath('/api/link').each do |entry_point| + get entry_point[@last_attribute], {} + end +end + +Then /^client should get a valid response$/ do + last_response.status.should_not == 500 +end + +Then /^client should get list of features inside '(.+)':$/ do |element,table| + features = table.raw.flatten.sort + instance_features = [] + output_xml.xpath('/api/link[@rel="'+element+'"]/feature').each do |feature| + instance_features << feature[:name] + end + features.should == instance_features.sort +end diff --git a/tests/ec2/step_definitions/hardware_profiles_steps.rb b/tests/ec2/step_definitions/hardware_profiles_steps.rb new file mode 100644 index 0000000..db1828b --- /dev/null +++ b/tests/ec2/step_definitions/hardware_profiles_steps.rb @@ -0,0 +1,25 @@ +Then /^it should have a (\w+) attribute$/ do |name| + attr = output_xml.xpath('/hardware-profile').first[name] + attr.should_not be_nil +end + +Then /^it should have a (\w+) property '(.+)'$/ do |kind, name| + props = output_xml.xpath("/hardware-profile/property[@name = '#{name}']") + props.size.should == 1 + prop = props.first + prop['kind'].should == kind + prop['unit'].should_not be_nil + if kind == 'range' + ranges = prop.xpath('range') + ranges.size.should == 1 + range = ranges.first + range['first'].should_not be_nil + range['last'].should_not be_nil + end + if kind == 'enum' + enums = prop.xpath('enum') + enums.size.should == 1 + enums.first.xpath('entry').size.should_not == 0 + end +end + diff --git a/tests/ec2/step_definitions/images_steps.rb b/tests/ec2/step_definitions/images_steps.rb new file mode 100644 index 0000000..fc01364 --- /dev/null +++ b/tests/ec2/step_definitions/images_steps.rb @@ -0,0 +1,83 @@ +Given /^authentification is required for this URI$/ do + authorize CONFIG[:username], CONFIG[:password] + get @uri, {} + last_response.status.should == 200 +end + +Then /^this element contains some (.+)$/ do |items| + item = items.singularize + output_xml.xpath("/#{@last_element.name}/#{item}").size.should > 0 +end + +Then /^each ([\w-]+) should have:$/ do |item, table| + properties = table.raw.flatten.sort + output_xml.xpath("/#{@last_element.name}/#{item}").each do |element| + childrens = (element > '*').collect { |c| c.name } + childrens.sort.should == properties + end +end + +Then /^this ([\w-]+) should have:$/ do |item, table| + properties = table.raw.flatten.sort + output_xml.xpath("/#{item}").each do |element| + childrens = (element > '*').collect { |c| c.name } + childrens.sort.should == properties + end +end + +When /^client want to show first (.+)$/ do |element| + case element + when 'image': + path = '/images/image' + when 'instance': + path = '/instances/instance' + when 'realm': + path = '/realms/realm' + when 'hardware-profile' + path = '/hardware-profiles/hardware-profile' + when 'storage-volume': + path = '/storage-volumes/storage-volume' + when 'storage-snapshot': + path = '/storage-snapshots/storage-snapshot' + end + @element = output_xml.xpath(path).first + @element.should_not be_nil +end + +When /^client want to show '(.+)' (.+)$/ do |id, el| + @uri = "/api/#{el.pluralize.tr('-', '_')}/#{id}" + get @uri, {} + @element = output_xml.xpath("/#{el}").first + @element.should_not be_nil +end + +Then /^client follow (\w+) attribute in first (.+)$/ do |attr, el| + url = output_xml.xpath("/#{el.pluralize}/#{el}").first[:href] + url.should_not be_nil + get url, {} +end + +Then /^client should get this (.+)$/ do |el| + last_response.status.should == 200 +end + + +Then /^client should follow href attribute in (\w+)$/ do |element| + get @element[:href], {} +end + +Then /^client should get valid response with requested (\w+)$/ do |element| + last_response.status.should == 200 + output_xml.xpath('/'+element+'/id').first.text.should == @element.xpath('id').text +end + +When /^client access this URI with parameters:$/ do |table| + params = {} + table.raw.each { |i| params[i[0]]=i[1] } + get @uri, params +end + +Then /^client should get some ([\w-]+)$/ do |elements| + last_response.status.should == 200 + output_xml.xpath('/'+elements+'/'+elements.singularize).size.should > 0 +end diff --git a/tests/ec2/step_definitions/instance_states_steps.rb b/tests/ec2/step_definitions/instance_states_steps.rb new file mode 100644 index 0000000..a587e5d --- /dev/null +++ b/tests/ec2/step_definitions/instance_states_steps.rb @@ -0,0 +1,34 @@ +Then /^states element contains some states$/ do + output_xml.xpath('/states/state').size.should > 0 +end + +Then /^each state should have '(.+)' attribute$/ do |attr| + output_xml.xpath('/states/state').each do |state| + state[attr].should_not be_nil + end +end + +Then /^(\w+) state should have '(.+)' attribute set to '(\w+)'$/ do |pos, attr, value| + output_xml.xpath('/states/state').first[attr].should==value if pos=='first' + output_xml.xpath('/states/state').last[attr].should==value if pos=='last' +end + +Then /^some states should have transitions$/ do + @transitions = output_xml.xpath('/states/state/transition') + @transitions.size.should > 0 +end + +Then /^each transitions should have 'to' attribute$/ do + @transitions.each do |t| + t[:to].should_not be_nil + end +end + +When /^client wants (\w+) format$/ do |format| + get "#{@uri}.#{format.downcase}", {} +end + +Then /^client should get PNG image$/ do + last_response.status.should == 200 + last_response.headers['Content-Type'].should == 'image/png' +end diff --git a/tests/ec2/step_definitions/instances_steps.rb b/tests/ec2/step_definitions/instances_steps.rb new file mode 100644 index 0000000..224ef50 --- /dev/null +++ b/tests/ec2/step_definitions/instances_steps.rb @@ -0,0 +1,137 @@ +When /^client follow ([\w-]+) href attribute in first instance$/ do |element| + get output_xml.xpath('/instances/instance[1]/'+element).first[:href], {} +end + +Then /^client should get valid ([\w-]+)$/ do |element| + last_response.status.should == 200 + output_xml.xpath("/#{element}").first.should_not be_nil +end + +Then /^each instance should have actions$/ do + output_xml.xpath('/instances/instance').each do |instance| + instance.xpath('actions').first.should_not be_nil + end +end + +Then /^each actions should have some links$/ do + output_xml.xpath('/instances/instance').each do |instance| + instance.xpath('actions/link').first.should_not be_nil + end +end + +Then /^each link should have valid (\w+) attribute$/ do |attr| + output_xml.xpath('/instances/instance').each do |instance| + instance.xpath('actions/link').first[attr].should_not be_nil + end +end + +When /^client want to '(\w+)' first instance$/ do |action| + @action = action + @instance = output_xml.xpath('/instances/instance[1]').first +end + +When /^client follow link in actions$/ do + unless @instance_url + l = output_xml.xpath("/instances/instance[1]/actions/link[@rel = '#{@action}']").first + else + l = @instance.xpath('actions/link[@rel="'+@action+'"]').first + end + unless @action=='destroy' + post l[:href], { :id => @instance.xpath('id').first.text } + else + delete l[:href], { :id => @instance.xpath('id').first.text } + end + last_response.status.should_not == 500 +end + +Then /^client should get first instance$/ do + output_xml.xpath('/instance/id').first.should_not be_nil + #output_xml.xpath('/instance/id').first.text.should == @instance.xpath('id').first.text +end + +Then /^this instance should be in '(.+)' state$/ do |state| + output_xml.xpath('/instance/state').first.text.should == state +end + +When /^client want to create a new instance$/ do +end + +Then /^client should choose (\w+) image$/ do |position| + get '/api/images', {} + if position=='first' + @image = output_xml.xpath('/images/image').first + else + @image = output_xml.xpath('/images/image').last + end + @image.should_not be_nil +end + +When /^client request for a new instance$/ do + params = { + :image_id => @image.xpath('id').first.text + } + params[:hwp_id] = @hwp_id if @hwp_id + post "#{@uri}", params + last_response.status.should == 201 + @instance_url = last_response.headers['Location'] +end + +Then /^new instance should be created$/ do + get @instance_url, {} + last_response.status.should == 200 +end + +Then /^this instance should have chosed image$/ do + output_xml.xpath('/instance/image').first[:href].should == @image[:href] +end + +Then /^this instance should have valid id$/ do + output_xml.xpath('instance/id').first.should_not be_nil +end + +Then /^this instance should have name$/ do + output_xml.xpath('instance/name').first.should_not be_nil +end + +When /^client want to '(\w+)' created instance$/ do |action| + get @instance_url, {} + last_response.status.should == 200 + @action = action + @instance = output_xml.xpath('/instance') +end + +Then /^client should get created instance$/ do + get @instance_url +end + +When /^this instance should be destroyed$/ do + # TODO: Fix this bug in mock driver ? + #get @instance_url, {} + #last_response.status.should == 404 +end + +Then /^client should get HTML form$/ do + last_response.status.should == 200 + (last_response.body.strip =~ /^<!DOCTYPE html/).should be_true +end + +When /^client choose (\w+) hardware profile$/ do |position| + get '/api/hardware_profiles', {} + if position=='last' + @hwp_id = output_xml.xpath('/hardware-profiles/hardware-profile/id').last.text + else + @hwp_id = output_xml.xpath('/hardware-profiles/hardware-profile/id').first.text + end +end + +Then /^this instance should have last hardware profile$/ do + output_xml.xpath('instance/hardware-profile/id').first.text.should == @hwp_id +end + +Given /^I set mock scenario to (\w+)$/ do |scenario| + @scenario = scenario +end + +Then /^I set mock scenario to default$/ do + @scenario = '' +end diff --git a/tests/ec2/step_definitions/rake_steps.rb b/tests/ec2/step_definitions/rake_steps.rb new file mode 100644 index 0000000..c8ea3d9 --- /dev/null +++ b/tests/ec2/step_definitions/rake_steps.rb @@ -0,0 +1,19 @@ +require 'fileutils' +require 'rake' +require 'find' + +Given /^I have a clean (.+) directory$/ do |dir| + FileUtils.rm_rf dir +end + +When /^I run a '(\w+)' task$/ do |task| + @rake = Rake::Application.new + Rake.application = @rake + load "Rakefile" + @task = Rake::Task[task] + @task.invoke +end + +Then /^I should see a (\w+) file inside (\w+) directory$/ do |ext, dir| + Dir["#{dir}/deltacloud-*.#{ext}"].size.should == 1 +end diff --git a/tests/ec2/storage_snapshots.feature b/tests/ec2/storage_snapshots.feature new file mode 100644 index 0000000..f6f38e5 --- /dev/null +++ b/tests/ec2/storage_snapshots.feature @@ -0,0 +1,29 @@ +Feature: Accessing storage snapshots + + Scenario: Listing available storage snapshots + Given URI /api/storage_snapshots exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'storage-snapshots' + And this element contains some storage-snapshots + And each storage-volume should have: + | id | + | created | + | storage-volume | + And each image should have 'href' attribute with valid URL + And this URI should be available in XML, JSON, HTML format + + Scenario: Get details about first volume + Given URI /api/storage_snapshots exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'storage-snapshots' + And this element contains some storage-snapshots + When client want to show first storage-snapshot + Then client follow href attribute in first storage-snapshot + Then client should get this storage-snapshot + And this storage-snapshot should have: + | id | + | created | + | state | + | storage-volume | diff --git a/tests/ec2/storage_volumes.feature b/tests/ec2/storage_volumes.feature new file mode 100644 index 0000000..dfca4b0 --- /dev/null +++ b/tests/ec2/storage_volumes.feature @@ -0,0 +1,33 @@ +Feature: Accessing storage volumes + + Scenario: Listing available storage volumes + Given URI /api/storage_volumes exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'storage-volumes' + And this element contains some storage-volumes + And each storage-volume should have: + | id | + | created | + | capacity | + | device | + | instance | + And each image should have 'href' attribute with valid URL + And this URI should be available in XML, JSON, HTML format + + Scenario: Get details about first volume + Given URI /api/storage_volumes exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'storage-volumes' + And this element contains some storage-volumes + When client want to show first storage-volume + Then client follow href attribute in first storage-volume + Then client should get this storage-volume + And this storage-volume should have: + | id | + | created | + | capacity | + | device | + | instance | + | state | diff --git a/tests/ec2/support/env.rb b/tests/ec2/support/env.rb new file mode 100644 index 0000000..ac4adfd --- /dev/null +++ b/tests/ec2/support/env.rb @@ -0,0 +1,53 @@ +SERVER_DIR = File::expand_path(File::join(File::dirname(__FILE__), "../../../server")) +Dir.chdir(SERVER_DIR) + +require 'sinatra' +require 'rack/test' +require 'nokogiri' +require '../server/server' +require 'ap' + +Sinatra::Application.set :environment, :test +Sinatra::Application.set :root, SERVER_DIR + +require '../server/lib/deltacloud/base_driver/mock_driver' + +CONFIG = { + :username => 'mockuser', + :password => 'mockpassword' +} + +World do + + def app + @app = Rack::Builder.new do + set :logging, true + set :raise_errors, true + run Sinatra::Application + end + end + + def output_xml + Nokogiri::XML(last_response.body) + end + + Before do + unless @no_header + header 'Accept', 'application/xml' + end + end + + prefixes = %W{ @prefix-start, @prefix-reboot, @prefix-stop, @prefix-create, @prefix-create-hwp} + + Before(prefixes.join(',')) do |scenario| + prefix = scenario.source_tag_names.first.gsub(/@prefix-/, '') + $scenario_prefix = prefix + end + + After(prefixes.join(',')) do |scenario| + $scenario_prefix = nil + end + + include Rack::Test::Methods +end + diff --git a/tests/mock/99_rake.feature b/tests/mock/99_rake.feature new file mode 100644 index 0000000..c4362c5 --- /dev/null +++ b/tests/mock/99_rake.feature @@ -0,0 +1,7 @@ +Feature: Running rake tasks + + Scenario: I want to build Deltacloud API gem + Given I have a clean /pkg directory + When I run a 'package' task + Then I should see a gem file inside pkg directory + And I should see a tgz file inside pkg directory diff --git a/tests/mock/api.feature b/tests/mock/api.feature new file mode 100644 index 0000000..8c4ddd2 --- /dev/null +++ b/tests/mock/api.feature @@ -0,0 +1,41 @@ +Feature: Accessing API entry points + + Scenario: API driver and version + Given URI /api exists + And authentification is not required for this URI + When client access this URI + Then client should get root element 'api' + And this element should have attribute 'driver' with value 'mock' + And this element should have attribute 'version' with value '1.0' + + Scenario: List of entry points + Given URI /api exists + And authentification is not required for this URI + When client access this URI + Then client should get list of valid entry points: + | realms | + | instances | + | images | + | instance_states | + | hardware_profiles | + | storage_snapshots | + | storage_volumes | + And this URI should be available in XML, JSON, HTML format + + Scenario: Following entry points + Given URI /api exists + And authentification is not required for this URI + When client access this URI + Then client should get list of valid entry points + And each link should have 'rel' attribute with valid name + And each link should have 'href' attribute with valid URL + When client follow this attribute + Then client should get a valid response + + Scenario: Instance features + Given URI /api exists + And authentification is not required for this URI + When client access this URI + Then client should get list of features inside 'instances': + | hardware_profiles | + | user_name | diff --git a/tests/mock/hardware_profiles.feature b/tests/mock/hardware_profiles.feature new file mode 100644 index 0000000..f10bb13 --- /dev/null +++ b/tests/mock/hardware_profiles.feature @@ -0,0 +1,29 @@ +Feature: Accessing hardware profiles + + Scenario: I want to get list of all hardware profiles + Given URI /api/hardware_profiles exists + And authentification is not required for this URI + When client access this URI + Then client should get root element 'hardware-profiles' + And this URI should be available in XML, HTML, JSON format + + Scenario: I want to show hardware profile details + Given URI /api/hardware_profiles exists + And authentification is not required for this URI + When client access this URI + Then client should get root element 'hardware-profiles' + When client want to show 'm1-large' hardware-profile + And client should get this hardware-profile + And it should have a href attribute + And it should have a fixed property 'cpu' + And it should have a range property 'memory' + And it should have a enum property 'storage' + And this URI should be available in XML, HTML, JSON format + + Scenario: Filtering images by architecture + Given URI /api/hardware_profiles exists + And authentification is required for this URI + When client access this URI with parameters: + | architecture | i386 | + Then client should get some hardware-profiles + And each hardware-profile should have 'architecture' attribute set to 'i386' diff --git a/tests/mock/images.feature b/tests/mock/images.feature new file mode 100644 index 0000000..50c3570 --- /dev/null +++ b/tests/mock/images.feature @@ -0,0 +1,59 @@ +Feature: Listing and showing images + + Scenario: Listing available images + Given URI /api/images exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'images' + And this element contains some images + And each image should have: + | id | + | name | + | description | + | architecture | + | owner_id | + And each image should have 'href' attribute with valid URL + And this URI should be available in XML, JSON, HTML format + + Scenario: Following image href attribute + Given URI /api/images exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'images' + And this element contains some images + When client want to show first image + Then client should follow href attribute in image + And client should get valid response with requested image + And this image should have: + | id | + | name | + | description | + | architecture | + | owner_id | + And this URI should be available in XML, JSON, HTML format + + Scenario: Filtering images by owner_id + Given URI /api/images exists + And authentification is required for this URI + When client access this URI with parameters: + | owner_id | fedoraproject | + Then client should get some images + And each image should have 'owner_id' attribute set to 'fedoraproject' + + Scenario: Filtering images by architecture + Given URI /api/images exists + And authentification is required for this URI + When client access this URI with parameters: + | architecture | i386 | + Then client should get some images + And each image should have 'architecture' attribute set to 'i386' + + Scenario: Filtering images by architecture and owner_id + Given URI /api/images exists + And authentification is required for this URI + When client access this URI with parameters: + | architecture | i386 | + | owner_id | fedoraproject | + Then client should get some images + And each image should have 'architecture' attribute set to 'i386' + And each image should have 'owner_id' attribute set to 'fedoraproject' diff --git a/tests/mock/instance_states.feature b/tests/mock/instance_states.feature new file mode 100644 index 0000000..3008ef0 --- /dev/null +++ b/tests/mock/instance_states.feature @@ -0,0 +1,36 @@ +Feature: Instance states and transitions + + Scenario: Getting list of states + Given URI /api/instance_states exists + And authentification is not required for this URI + When client access this URI + Then client should get root element 'states' + And this element contains some states + And this URI should be available in XML, JSON, HTML format + + + Scenario: State names + Given URI /api/instance_states exists + And authentification is not required for this URI + When client access this URI + Then client should get root element 'states' + And states element contains some states + And each state should have 'name' attribute + And first state should have 'name' attribute set to 'start' + And last state should have 'name' attribute set to 'finish' + + Scenario: Transitions + Given URI /api/instance_states exists + And authentification is not required for this URI + When client access this URI + Then client should get root element 'states' + And states element contains some states + And some states should have transitions + And each transitions should have 'to' attribute + + Scenario: State diagram + Given URI /api/instance_states exists + And authentification is not required for this URI + When client access this URI + And client wants PNG format + Then client should get PNG image diff --git a/tests/mock/instances.feature b/tests/mock/instances.feature new file mode 100644 index 0000000..64828ea --- /dev/null +++ b/tests/mock/instances.feature @@ -0,0 +1,165 @@ +Feature: Managing instances + + Scenario: Listing current instances + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + And each instance should have: + | id | + | name | + | owner_id | + | image | + | realm | + | state | + | hardware-profile | + | actions | + | public-addresses | + | private-addresses | + And each instance should have 'href' attribute with valid URL + And this URI should be available in XML, JSON, HTML format + + Scenario: Filtering instances by state + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI with parameters: + | state | RUNNING | + Then client should get some instances + And each instance should have 'state' attribute set to 'RUNNING' + + Scenario: Get details about first instance + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + When client want to show first instance + Then client follow href attribute in first instance + Then client should get this instance + And this instance should have: + | id | + | name | + | owner_id | + | image | + | realm | + | state | + | hardware-profile | + | actions | + | public-addresses | + | private-addresses | + + Scenario: Following image href in instance + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + When client follow image href attribute in first instance + Then client should get valid image + + Scenario: Following realm href in instance + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + When client follow realm href attribute in first instance + Then client should get valid realm + + Scenario: Following hardware profile href in instance + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + When client follow hardware-profile href attribute in first instance + Then client should get valid hardware-profile + + Scenario: Instance actions + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + And each instance should have actions + And each actions should have some links + And each link should have valid href attribute + And each link should have valid method attribute + And each link should have valid rel attribute + + Scenario: Reboot instance + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + When client want to 'reboot' first instance + And client follow link in actions + Then client should get first instance + And this instance should be in 'RUNNING' state + + Scenario: Stop instance + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + When client want to 'stop' first instance + And client follow link in actions + Then client should get first instance + And this instance should be in 'STOPPED' state + + Scenario: Start instance + Given URI /api/instances exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'instances' + And this element contains some instances + When client want to 'start' first instance + And client follow link in actions + Then client should get first instance + And this instance should be in 'RUNNING' state + + Scenario: Basic instance creation + Given URI /api/instances exists + And authentification is required for this URI + When client want to create a new instance + Then client should choose first image + When client request for a new instance + Then new instance should be created + And this instance should have chosed image + And this instance should be in 'RUNNING' state + And this instance should have valid id + And this instance should have name + + Scenario: Choosing hardware profile for instance + Given URI /api/instances exists + And authentification is required for this URI + When client want to create a new instance + Then client should choose first image + And client choose last hardware profile + When client request for a new instance + Then new instance should be created + And this instance should have chosed image + And this instance should be in 'RUNNING' state + And this instance should have valid id + And this instance should have last hardware profile + And this instance should have name + + Scenario: Create instance using HTML form + Given URI /api/instances/new exists in HTML format + And authentification is required for this URI + When client access this URI + Then client should get HTML form + + Scenario: Destroying created instance + Given URI /api/instances exists + And authentification is required for this URI + When client want to 'stop' created instance + And client follow link in actions + Then client should get created instance + And this instance should be in 'STOPPED' state + When client want to 'destroy' created instance + And client follow link in actions + And this instance should be destroyed diff --git a/tests/mock/realms.feature b/tests/mock/realms.feature new file mode 100644 index 0000000..a89173b --- /dev/null +++ b/tests/mock/realms.feature @@ -0,0 +1,31 @@ +Feature: Accessing realms + + Scenario: Getting list of available realms + Given URI /api/realms exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'realms' + And this element contains some realms + And each realm should have: + | id | + | name | + | state | + | limit | + And each realm should have 'href' attribute with valid URL + And this URI should be available in XML, JSON, HTML format + + Scenario: Following realm href attribute + Given URI /api/realms exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'realms' + And this element contains some realms + When client want to show first realm + Then client should follow href attribute in realm + And client should get valid response with requested realm + And this realm should have: + | id | + | name | + | state | + | limit | + And this URI should be available in XML, JSON, HTML format diff --git a/tests/mock/step_definitions/api_steps.rb b/tests/mock/step_definitions/api_steps.rb new file mode 100644 index 0000000..9a30c3d --- /dev/null +++ b/tests/mock/step_definitions/api_steps.rb @@ -0,0 +1,103 @@ +Given /^URI ([\w/-_]+) exists$/ do |uri| + get uri, {} + last_response.status.should_not == 404 + last_response.status.should_not == 500 + @uri = uri +end + +Given /^URI ([\w/-_]+) exists in (.+) format$/ do |uri, format| + @uri = "#{uri}.#{format.downcase}" + get @uri, {} + last_response.status.should_not == 404 + last_response.status.should_not == 500 +end + +Given /^authentification is not required for this URI$/ do + last_response.status.should_not == 401 +end + +When /^client access this URI$/ do + get @uri, {} + last_response.status.should_not == 404 +end + +Then /^client should get root element '(.+)'$/ do |element| + @last_element = output_xml.xpath('/'+element).first + @last_element.should_not be_nil + @last_element.name.should == element +end + +Then /^this element should have attribute '(.+)' with value '(.+)'$/ do |atr, val| + @last_element[atr.to_sym].should == val +end + +Then /^client should get list of valid entry points:$/ do |table| + @entry_points = table.raw.flatten.sort + links = [] + output_xml.xpath('/api/link').each do |entry_point| + links << entry_point['rel'] + end + @entry_points.should == links.sort +end + +Then /^this URI should be available in (.+) format$/ do |formats| + @no_header = true + formats.split(',').each do |format| + get "#{@uri}.#{format.strip.downcase}", {} + last_response.status.should == 200 + end + @no_header = false +end + +Then /^client should get list of valid entry points$/ do + links = [] + output_xml.xpath('/api/link').each do |entry_point| + links << entry_point['rel'] + end + @entry_points.should == links.sort +end + +Then /^each (\w+) should have '(.+)' attribute with valid (.+)$/ do |el, attr, t| + case el + when 'link': + path = '/api/link' + when 'image': + path = '/images/image' + end + output_xml.xpath(path).each do |entry_point| + @entry_points.include?(entry_point[attr]).should == true if t=='name' + if t=='URL' + entry_point[:href].should_not be_nil + end + end + @last_attribute = attr +end + +Then /^each ([\w-]+) should have '(.+)' attribute set to '(.+)'$/ do |el, attr, v| + case el + when 'image': + path = "/image/images" + end + output_xml.xpath(path).each do |element| + element[attr].should == v + end +end + +When /^client follow this attribute$/ do + output_xml.xpath('/api/link').each do |entry_point| + get entry_point[@last_attribute], {} + end +end + +Then /^client should get a valid response$/ do + last_response.status.should_not == 500 +end + +Then /^client should get list of features inside '(.+)':$/ do |element,table| + features = table.raw.flatten.sort + instance_features = [] + output_xml.xpath('/api/link[@rel="'+element+'"]/feature').each do |feature| + instance_features << feature[:name] + end + features.should == instance_features.sort +end diff --git a/tests/mock/step_definitions/hardware_profiles_steps.rb b/tests/mock/step_definitions/hardware_profiles_steps.rb new file mode 100644 index 0000000..db1828b --- /dev/null +++ b/tests/mock/step_definitions/hardware_profiles_steps.rb @@ -0,0 +1,25 @@ +Then /^it should have a (\w+) attribute$/ do |name| + attr = output_xml.xpath('/hardware-profile').first[name] + attr.should_not be_nil +end + +Then /^it should have a (\w+) property '(.+)'$/ do |kind, name| + props = output_xml.xpath("/hardware-profile/property[@name = '#{name}']") + props.size.should == 1 + prop = props.first + prop['kind'].should == kind + prop['unit'].should_not be_nil + if kind == 'range' + ranges = prop.xpath('range') + ranges.size.should == 1 + range = ranges.first + range['first'].should_not be_nil + range['last'].should_not be_nil + end + if kind == 'enum' + enums = prop.xpath('enum') + enums.size.should == 1 + enums.first.xpath('entry').size.should_not == 0 + end +end + diff --git a/tests/mock/step_definitions/images_steps.rb b/tests/mock/step_definitions/images_steps.rb new file mode 100644 index 0000000..fc01364 --- /dev/null +++ b/tests/mock/step_definitions/images_steps.rb @@ -0,0 +1,83 @@ +Given /^authentification is required for this URI$/ do + authorize CONFIG[:username], CONFIG[:password] + get @uri, {} + last_response.status.should == 200 +end + +Then /^this element contains some (.+)$/ do |items| + item = items.singularize + output_xml.xpath("/#{@last_element.name}/#{item}").size.should > 0 +end + +Then /^each ([\w-]+) should have:$/ do |item, table| + properties = table.raw.flatten.sort + output_xml.xpath("/#{@last_element.name}/#{item}").each do |element| + childrens = (element > '*').collect { |c| c.name } + childrens.sort.should == properties + end +end + +Then /^this ([\w-]+) should have:$/ do |item, table| + properties = table.raw.flatten.sort + output_xml.xpath("/#{item}").each do |element| + childrens = (element > '*').collect { |c| c.name } + childrens.sort.should == properties + end +end + +When /^client want to show first (.+)$/ do |element| + case element + when 'image': + path = '/images/image' + when 'instance': + path = '/instances/instance' + when 'realm': + path = '/realms/realm' + when 'hardware-profile' + path = '/hardware-profiles/hardware-profile' + when 'storage-volume': + path = '/storage-volumes/storage-volume' + when 'storage-snapshot': + path = '/storage-snapshots/storage-snapshot' + end + @element = output_xml.xpath(path).first + @element.should_not be_nil +end + +When /^client want to show '(.+)' (.+)$/ do |id, el| + @uri = "/api/#{el.pluralize.tr('-', '_')}/#{id}" + get @uri, {} + @element = output_xml.xpath("/#{el}").first + @element.should_not be_nil +end + +Then /^client follow (\w+) attribute in first (.+)$/ do |attr, el| + url = output_xml.xpath("/#{el.pluralize}/#{el}").first[:href] + url.should_not be_nil + get url, {} +end + +Then /^client should get this (.+)$/ do |el| + last_response.status.should == 200 +end + + +Then /^client should follow href attribute in (\w+)$/ do |element| + get @element[:href], {} +end + +Then /^client should get valid response with requested (\w+)$/ do |element| + last_response.status.should == 200 + output_xml.xpath('/'+element+'/id').first.text.should == @element.xpath('id').text +end + +When /^client access this URI with parameters:$/ do |table| + params = {} + table.raw.each { |i| params[i[0]]=i[1] } + get @uri, params +end + +Then /^client should get some ([\w-]+)$/ do |elements| + last_response.status.should == 200 + output_xml.xpath('/'+elements+'/'+elements.singularize).size.should > 0 +end diff --git a/tests/mock/step_definitions/instance_states_steps.rb b/tests/mock/step_definitions/instance_states_steps.rb new file mode 100644 index 0000000..a587e5d --- /dev/null +++ b/tests/mock/step_definitions/instance_states_steps.rb @@ -0,0 +1,34 @@ +Then /^states element contains some states$/ do + output_xml.xpath('/states/state').size.should > 0 +end + +Then /^each state should have '(.+)' attribute$/ do |attr| + output_xml.xpath('/states/state').each do |state| + state[attr].should_not be_nil + end +end + +Then /^(\w+) state should have '(.+)' attribute set to '(\w+)'$/ do |pos, attr, value| + output_xml.xpath('/states/state').first[attr].should==value if pos=='first' + output_xml.xpath('/states/state').last[attr].should==value if pos=='last' +end + +Then /^some states should have transitions$/ do + @transitions = output_xml.xpath('/states/state/transition') + @transitions.size.should > 0 +end + +Then /^each transitions should have 'to' attribute$/ do + @transitions.each do |t| + t[:to].should_not be_nil + end +end + +When /^client wants (\w+) format$/ do |format| + get "#{@uri}.#{format.downcase}", {} +end + +Then /^client should get PNG image$/ do + last_response.status.should == 200 + last_response.headers['Content-Type'].should == 'image/png' +end diff --git a/tests/mock/step_definitions/instances_steps.rb b/tests/mock/step_definitions/instances_steps.rb new file mode 100644 index 0000000..8ec6526 --- /dev/null +++ b/tests/mock/step_definitions/instances_steps.rb @@ -0,0 +1,121 @@ +When /^client follow ([\w-]+) href attribute in first instance$/ do |element| + get output_xml.xpath('/instances/instance[1]/'+element).first[:href], {} +end + +Then /^client should get valid ([\w-]+)$/ do |element| + last_response.status.should == 200 + output_xml.xpath("/#{element}").first.should_not be_nil +end + +Then /^each instance should have actions$/ do + output_xml.xpath('/instances/instance').each do |instance| + instance.xpath('actions').first.should_not be_nil + end +end + +Then /^each actions should have some links$/ do + output_xml.xpath('/instances/instance').each do |instance| + instance.xpath('actions/link').first.should_not be_nil + end +end + +Then /^each link should have valid (\w+) attribute$/ do |attr| + output_xml.xpath('/instances/instance').each do |instance| + instance.xpath('actions/link').first[attr].should_not be_nil + end +end + +When /^client want to '(\w+)' first instance$/ do |action| + @action = action + @instance = output_xml.xpath('/instances/instance[1]').first +end + +When /^client follow link in actions$/ do + unless @instance_url + l = output_xml.xpath("/instances/instance[1]/actions/link[@rel = '#{@action}']").first + else + l = @instance.xpath('actions/link[@rel="'+@action+'"]').first + end + unless @action=='destroy' + post l[:href], { :id => @instance.xpath('id').first.text } + else + delete l[:href], { :id => @instance.xpath('id').first.text } + end + last_response.status.should_not == 500 +end + +Then /^client should get first instance$/ do + output_xml.xpath('/instance/id').first.should_not be_nil + #output_xml.xpath('/instance/id').first.text.should == @instance.xpath('id').first.text +end + +Then /^this instance should be in '(.+)' state$/ do |state| + output_xml.xpath('/instance/state').first.text.should == state +end + +When /^client want to create a new instance$/ do +end + +Then /^client should choose first image$/ do + get '/api/images', {} + @image = output_xml.xpath('/images/image').first + @image.should_not be_nil +end + +When /^client request for a new instance$/ do + params = { + :image_id => @image.xpath('id').first.text + } + params[:hwp_id] = @hwp_id if @hwp_id + post "#{@uri}", params + last_response.status.should == 201 + @instance_url = last_response.headers['Location'] +end + +Then /^new instance should be created$/ do + get @instance_url, {} + last_response.status.should == 200 +end + +Then /^this instance should have chosed image$/ do + output_xml.xpath('/instance/image').first[:href].should == @image[:href] +end + +Then /^this instance should have valid id$/ do + output_xml.xpath('instance/id').first.should_not be_nil +end + +Then /^this instance should have name$/ do + output_xml.xpath('instance/name').first.should_not be_nil +end + +When /^client want to '(\w+)' created instance$/ do |action| + get @instance_url, {} + last_response.status.should == 200 + @action = action + @instance = output_xml.xpath('/instance') +end + +Then /^client should get created instance$/ do + get @instance_url +end + +When /^this instance should be destroyed$/ do + # TODO: Fix this bug in mock driver ? + #get @instance_url, {} + #last_response.status.should == 404 +end + +Then /^client should get HTML form$/ do + last_response.status.should == 200 + (last_response.body.strip =~ /^<!DOCTYPE html/).should be_true +end + +When /^client choose last hardware profile$/ do + get '/api/hardware_profiles', {} + @hwp_id = output_xml.xpath('/hardware-profiles/hardware-profile/id').last.text +end + +Then /^this instance should have last hardware profile$/ do + output_xml.xpath('instance/hardware-profile/id').first.text.should == @hwp_id +end diff --git a/tests/mock/step_definitions/rake_steps.rb b/tests/mock/step_definitions/rake_steps.rb new file mode 100644 index 0000000..c8ea3d9 --- /dev/null +++ b/tests/mock/step_definitions/rake_steps.rb @@ -0,0 +1,19 @@ +require 'fileutils' +require 'rake' +require 'find' + +Given /^I have a clean (.+) directory$/ do |dir| + FileUtils.rm_rf dir +end + +When /^I run a '(\w+)' task$/ do |task| + @rake = Rake::Application.new + Rake.application = @rake + load "Rakefile" + @task = Rake::Task[task] + @task.invoke +end + +Then /^I should see a (\w+) file inside (\w+) directory$/ do |ext, dir| + Dir["#{dir}/deltacloud-*.#{ext}"].size.should == 1 +end diff --git a/tests/mock/storage_snapshots.feature b/tests/mock/storage_snapshots.feature new file mode 100644 index 0000000..f6f38e5 --- /dev/null +++ b/tests/mock/storage_snapshots.feature @@ -0,0 +1,29 @@ +Feature: Accessing storage snapshots + + Scenario: Listing available storage snapshots + Given URI /api/storage_snapshots exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'storage-snapshots' + And this element contains some storage-snapshots + And each storage-volume should have: + | id | + | created | + | storage-volume | + And each image should have 'href' attribute with valid URL + And this URI should be available in XML, JSON, HTML format + + Scenario: Get details about first volume + Given URI /api/storage_snapshots exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'storage-snapshots' + And this element contains some storage-snapshots + When client want to show first storage-snapshot + Then client follow href attribute in first storage-snapshot + Then client should get this storage-snapshot + And this storage-snapshot should have: + | id | + | created | + | state | + | storage-volume | diff --git a/tests/mock/storage_volumes.feature b/tests/mock/storage_volumes.feature new file mode 100644 index 0000000..dfca4b0 --- /dev/null +++ b/tests/mock/storage_volumes.feature @@ -0,0 +1,33 @@ +Feature: Accessing storage volumes + + Scenario: Listing available storage volumes + Given URI /api/storage_volumes exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'storage-volumes' + And this element contains some storage-volumes + And each storage-volume should have: + | id | + | created | + | capacity | + | device | + | instance | + And each image should have 'href' attribute with valid URL + And this URI should be available in XML, JSON, HTML format + + Scenario: Get details about first volume + Given URI /api/storage_volumes exists + And authentification is required for this URI + When client access this URI + Then client should get root element 'storage-volumes' + And this element contains some storage-volumes + When client want to show first storage-volume + Then client follow href attribute in first storage-volume + Then client should get this storage-volume + And this storage-volume should have: + | id | + | created | + | capacity | + | device | + | instance | + | state | diff --git a/tests/mock/support/env.rb b/tests/mock/support/env.rb new file mode 100644 index 0000000..bd544d0 --- /dev/null +++ b/tests/mock/support/env.rb @@ -0,0 +1,40 @@ +SERVER_DIR = File::expand_path(File::join(File::dirname(__FILE__), "../../../server")) +Dir.chdir(SERVER_DIR) + +require 'sinatra' +require 'rack/test' +require 'nokogiri' +require '../server/server' +require 'ap' + +Sinatra::Application.set :environment, :test +Sinatra::Application.set :root, SERVER_DIR + +CONFIG = { + :username => 'mockuser', + :password => 'mockpassword' +} + +World do + + def app + @app = Rack::Builder.new do + set :logging, true + set :raise_errors, true + run Sinatra::Application + end + end + + def output_xml + Nokogiri::XML(last_response.body) + end + + Before do + unless @no_header + header 'Accept', 'application/xml' + end + end + + include Rack::Test::Methods +end +
--- server/Rakefile | 32 +---- server/features/99_rake.feature | 7 - server/features/api.feature | 41 ----- server/features/hardware_profiles.feature | 29 ---- server/features/images.feature | 59 ------- server/features/instance_states.feature | 36 ----- server/features/instances.feature | 165 -------------------- server/features/realms.feature | 31 ---- server/features/step_definitions/api_steps.rb | 103 ------------ .../step_definitions/hardware_profiles_steps.rb | 25 --- server/features/step_definitions/images_steps.rb | 83 ---------- .../step_definitions/instance_states_steps.rb | 34 ---- .../features/step_definitions/instances_steps.rb | 121 -------------- server/features/step_definitions/rake_steps.rb | 19 --- server/features/storage_snapshots.feature | 29 ---- server/features/storage_volumes.feature | 33 ---- server/features/support/env.rb | 39 ----- tests/Rakefile | 7 - 18 files changed, 1 insertions(+), 892 deletions(-) delete mode 100644 server/features/99_rake.feature delete mode 100644 server/features/api.feature delete mode 100644 server/features/hardware_profiles.feature delete mode 100644 server/features/images.feature delete mode 100644 server/features/instance_states.feature delete mode 100644 server/features/instances.feature delete mode 100644 server/features/realms.feature delete mode 100644 server/features/step_definitions/api_steps.rb delete mode 100644 server/features/step_definitions/hardware_profiles_steps.rb delete mode 100644 server/features/step_definitions/images_steps.rb delete mode 100644 server/features/step_definitions/instance_states_steps.rb delete mode 100644 server/features/step_definitions/instances_steps.rb delete mode 100644 server/features/step_definitions/rake_steps.rb delete mode 100644 server/features/storage_snapshots.feature delete mode 100644 server/features/storage_volumes.feature delete mode 100644 server/features/support/env.rb
diff --git a/server/Rakefile b/server/Rakefile index be4554c..7cd2bc0 100644 --- a/server/Rakefile +++ b/server/Rakefile @@ -22,8 +22,6 @@ require 'rake' require 'rake/testtask' require 'rake/gempackagetask'
- - desc "Run basic unit tests" Rake::TestTask.new("test") { |t| t.test_files = FileList[ @@ -37,36 +35,8 @@ Rake::TestTask.new("test") { |t| t.warning = false }
-begin - require 'cucumber' - require 'cucumber/rake/task' - - Cucumber::Rake::Task.new(:features) do |t| - t.cucumber_opts = "features --format html --out tmp/cucumber.html" - t.rcov = false - end - - Cucumber::Rake::Task.new(:rcov) do |t| - t.cucumber_opts = "features --format pretty" - t.rcov = true - t.rcov_opts << %[-o "tmp/coverage"] - end - - Cucumber::Rake::Task.new(:junit) do |t| - t.cucumber_opts = "features --format junit --out tmp/junit" - t.rcov = true - t.rcov_opts << %[-o "tmp/coverage"] - end - -rescue LoadError - desc 'Cucumber rake task not available' - task :features do - abort 'Cucumber rake task is not available. Be sure to install cucumber as a gem' - end -end - - load 'deltacloud-core.gemspec' + Rake::GemPackageTask.new(@spec) do |pkg| pkg.need_tar = true end diff --git a/server/features/99_rake.feature b/server/features/99_rake.feature deleted file mode 100644 index c4362c5..0000000 --- a/server/features/99_rake.feature +++ /dev/null @@ -1,7 +0,0 @@ -Feature: Running rake tasks - - Scenario: I want to build Deltacloud API gem - Given I have a clean /pkg directory - When I run a 'package' task - Then I should see a gem file inside pkg directory - And I should see a tgz file inside pkg directory diff --git a/server/features/api.feature b/server/features/api.feature deleted file mode 100644 index 8c4ddd2..0000000 --- a/server/features/api.feature +++ /dev/null @@ -1,41 +0,0 @@ -Feature: Accessing API entry points - - Scenario: API driver and version - Given URI /api exists - And authentification is not required for this URI - When client access this URI - Then client should get root element 'api' - And this element should have attribute 'driver' with value 'mock' - And this element should have attribute 'version' with value '1.0' - - Scenario: List of entry points - Given URI /api exists - And authentification is not required for this URI - When client access this URI - Then client should get list of valid entry points: - | realms | - | instances | - | images | - | instance_states | - | hardware_profiles | - | storage_snapshots | - | storage_volumes | - And this URI should be available in XML, JSON, HTML format - - Scenario: Following entry points - Given URI /api exists - And authentification is not required for this URI - When client access this URI - Then client should get list of valid entry points - And each link should have 'rel' attribute with valid name - And each link should have 'href' attribute with valid URL - When client follow this attribute - Then client should get a valid response - - Scenario: Instance features - Given URI /api exists - And authentification is not required for this URI - When client access this URI - Then client should get list of features inside 'instances': - | hardware_profiles | - | user_name | diff --git a/server/features/hardware_profiles.feature b/server/features/hardware_profiles.feature deleted file mode 100644 index f10bb13..0000000 --- a/server/features/hardware_profiles.feature +++ /dev/null @@ -1,29 +0,0 @@ -Feature: Accessing hardware profiles - - Scenario: I want to get list of all hardware profiles - Given URI /api/hardware_profiles exists - And authentification is not required for this URI - When client access this URI - Then client should get root element 'hardware-profiles' - And this URI should be available in XML, HTML, JSON format - - Scenario: I want to show hardware profile details - Given URI /api/hardware_profiles exists - And authentification is not required for this URI - When client access this URI - Then client should get root element 'hardware-profiles' - When client want to show 'm1-large' hardware-profile - And client should get this hardware-profile - And it should have a href attribute - And it should have a fixed property 'cpu' - And it should have a range property 'memory' - And it should have a enum property 'storage' - And this URI should be available in XML, HTML, JSON format - - Scenario: Filtering images by architecture - Given URI /api/hardware_profiles exists - And authentification is required for this URI - When client access this URI with parameters: - | architecture | i386 | - Then client should get some hardware-profiles - And each hardware-profile should have 'architecture' attribute set to 'i386' diff --git a/server/features/images.feature b/server/features/images.feature deleted file mode 100644 index 50c3570..0000000 --- a/server/features/images.feature +++ /dev/null @@ -1,59 +0,0 @@ -Feature: Listing and showing images - - Scenario: Listing available images - Given URI /api/images exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'images' - And this element contains some images - And each image should have: - | id | - | name | - | description | - | architecture | - | owner_id | - And each image should have 'href' attribute with valid URL - And this URI should be available in XML, JSON, HTML format - - Scenario: Following image href attribute - Given URI /api/images exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'images' - And this element contains some images - When client want to show first image - Then client should follow href attribute in image - And client should get valid response with requested image - And this image should have: - | id | - | name | - | description | - | architecture | - | owner_id | - And this URI should be available in XML, JSON, HTML format - - Scenario: Filtering images by owner_id - Given URI /api/images exists - And authentification is required for this URI - When client access this URI with parameters: - | owner_id | fedoraproject | - Then client should get some images - And each image should have 'owner_id' attribute set to 'fedoraproject' - - Scenario: Filtering images by architecture - Given URI /api/images exists - And authentification is required for this URI - When client access this URI with parameters: - | architecture | i386 | - Then client should get some images - And each image should have 'architecture' attribute set to 'i386' - - Scenario: Filtering images by architecture and owner_id - Given URI /api/images exists - And authentification is required for this URI - When client access this URI with parameters: - | architecture | i386 | - | owner_id | fedoraproject | - Then client should get some images - And each image should have 'architecture' attribute set to 'i386' - And each image should have 'owner_id' attribute set to 'fedoraproject' diff --git a/server/features/instance_states.feature b/server/features/instance_states.feature deleted file mode 100644 index 3008ef0..0000000 --- a/server/features/instance_states.feature +++ /dev/null @@ -1,36 +0,0 @@ -Feature: Instance states and transitions - - Scenario: Getting list of states - Given URI /api/instance_states exists - And authentification is not required for this URI - When client access this URI - Then client should get root element 'states' - And this element contains some states - And this URI should be available in XML, JSON, HTML format - - - Scenario: State names - Given URI /api/instance_states exists - And authentification is not required for this URI - When client access this URI - Then client should get root element 'states' - And states element contains some states - And each state should have 'name' attribute - And first state should have 'name' attribute set to 'start' - And last state should have 'name' attribute set to 'finish' - - Scenario: Transitions - Given URI /api/instance_states exists - And authentification is not required for this URI - When client access this URI - Then client should get root element 'states' - And states element contains some states - And some states should have transitions - And each transitions should have 'to' attribute - - Scenario: State diagram - Given URI /api/instance_states exists - And authentification is not required for this URI - When client access this URI - And client wants PNG format - Then client should get PNG image diff --git a/server/features/instances.feature b/server/features/instances.feature deleted file mode 100644 index 64828ea..0000000 --- a/server/features/instances.feature +++ /dev/null @@ -1,165 +0,0 @@ -Feature: Managing instances - - Scenario: Listing current instances - Given URI /api/instances exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'instances' - And this element contains some instances - And each instance should have: - | id | - | name | - | owner_id | - | image | - | realm | - | state | - | hardware-profile | - | actions | - | public-addresses | - | private-addresses | - And each instance should have 'href' attribute with valid URL - And this URI should be available in XML, JSON, HTML format - - Scenario: Filtering instances by state - Given URI /api/instances exists - And authentification is required for this URI - When client access this URI with parameters: - | state | RUNNING | - Then client should get some instances - And each instance should have 'state' attribute set to 'RUNNING' - - Scenario: Get details about first instance - Given URI /api/instances exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'instances' - And this element contains some instances - When client want to show first instance - Then client follow href attribute in first instance - Then client should get this instance - And this instance should have: - | id | - | name | - | owner_id | - | image | - | realm | - | state | - | hardware-profile | - | actions | - | public-addresses | - | private-addresses | - - Scenario: Following image href in instance - Given URI /api/instances exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'instances' - And this element contains some instances - When client follow image href attribute in first instance - Then client should get valid image - - Scenario: Following realm href in instance - Given URI /api/instances exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'instances' - And this element contains some instances - When client follow realm href attribute in first instance - Then client should get valid realm - - Scenario: Following hardware profile href in instance - Given URI /api/instances exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'instances' - And this element contains some instances - When client follow hardware-profile href attribute in first instance - Then client should get valid hardware-profile - - Scenario: Instance actions - Given URI /api/instances exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'instances' - And this element contains some instances - And each instance should have actions - And each actions should have some links - And each link should have valid href attribute - And each link should have valid method attribute - And each link should have valid rel attribute - - Scenario: Reboot instance - Given URI /api/instances exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'instances' - And this element contains some instances - When client want to 'reboot' first instance - And client follow link in actions - Then client should get first instance - And this instance should be in 'RUNNING' state - - Scenario: Stop instance - Given URI /api/instances exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'instances' - And this element contains some instances - When client want to 'stop' first instance - And client follow link in actions - Then client should get first instance - And this instance should be in 'STOPPED' state - - Scenario: Start instance - Given URI /api/instances exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'instances' - And this element contains some instances - When client want to 'start' first instance - And client follow link in actions - Then client should get first instance - And this instance should be in 'RUNNING' state - - Scenario: Basic instance creation - Given URI /api/instances exists - And authentification is required for this URI - When client want to create a new instance - Then client should choose first image - When client request for a new instance - Then new instance should be created - And this instance should have chosed image - And this instance should be in 'RUNNING' state - And this instance should have valid id - And this instance should have name - - Scenario: Choosing hardware profile for instance - Given URI /api/instances exists - And authentification is required for this URI - When client want to create a new instance - Then client should choose first image - And client choose last hardware profile - When client request for a new instance - Then new instance should be created - And this instance should have chosed image - And this instance should be in 'RUNNING' state - And this instance should have valid id - And this instance should have last hardware profile - And this instance should have name - - Scenario: Create instance using HTML form - Given URI /api/instances/new exists in HTML format - And authentification is required for this URI - When client access this URI - Then client should get HTML form - - Scenario: Destroying created instance - Given URI /api/instances exists - And authentification is required for this URI - When client want to 'stop' created instance - And client follow link in actions - Then client should get created instance - And this instance should be in 'STOPPED' state - When client want to 'destroy' created instance - And client follow link in actions - And this instance should be destroyed diff --git a/server/features/realms.feature b/server/features/realms.feature deleted file mode 100644 index a89173b..0000000 --- a/server/features/realms.feature +++ /dev/null @@ -1,31 +0,0 @@ -Feature: Accessing realms - - Scenario: Getting list of available realms - Given URI /api/realms exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'realms' - And this element contains some realms - And each realm should have: - | id | - | name | - | state | - | limit | - And each realm should have 'href' attribute with valid URL - And this URI should be available in XML, JSON, HTML format - - Scenario: Following realm href attribute - Given URI /api/realms exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'realms' - And this element contains some realms - When client want to show first realm - Then client should follow href attribute in realm - And client should get valid response with requested realm - And this realm should have: - | id | - | name | - | state | - | limit | - And this URI should be available in XML, JSON, HTML format diff --git a/server/features/step_definitions/api_steps.rb b/server/features/step_definitions/api_steps.rb deleted file mode 100644 index 9a30c3d..0000000 --- a/server/features/step_definitions/api_steps.rb +++ /dev/null @@ -1,103 +0,0 @@ -Given /^URI ([\w/-_]+) exists$/ do |uri| - get uri, {} - last_response.status.should_not == 404 - last_response.status.should_not == 500 - @uri = uri -end - -Given /^URI ([\w/-_]+) exists in (.+) format$/ do |uri, format| - @uri = "#{uri}.#{format.downcase}" - get @uri, {} - last_response.status.should_not == 404 - last_response.status.should_not == 500 -end - -Given /^authentification is not required for this URI$/ do - last_response.status.should_not == 401 -end - -When /^client access this URI$/ do - get @uri, {} - last_response.status.should_not == 404 -end - -Then /^client should get root element '(.+)'$/ do |element| - @last_element = output_xml.xpath('/'+element).first - @last_element.should_not be_nil - @last_element.name.should == element -end - -Then /^this element should have attribute '(.+)' with value '(.+)'$/ do |atr, val| - @last_element[atr.to_sym].should == val -end - -Then /^client should get list of valid entry points:$/ do |table| - @entry_points = table.raw.flatten.sort - links = [] - output_xml.xpath('/api/link').each do |entry_point| - links << entry_point['rel'] - end - @entry_points.should == links.sort -end - -Then /^this URI should be available in (.+) format$/ do |formats| - @no_header = true - formats.split(',').each do |format| - get "#{@uri}.#{format.strip.downcase}", {} - last_response.status.should == 200 - end - @no_header = false -end - -Then /^client should get list of valid entry points$/ do - links = [] - output_xml.xpath('/api/link').each do |entry_point| - links << entry_point['rel'] - end - @entry_points.should == links.sort -end - -Then /^each (\w+) should have '(.+)' attribute with valid (.+)$/ do |el, attr, t| - case el - when 'link': - path = '/api/link' - when 'image': - path = '/images/image' - end - output_xml.xpath(path).each do |entry_point| - @entry_points.include?(entry_point[attr]).should == true if t=='name' - if t=='URL' - entry_point[:href].should_not be_nil - end - end - @last_attribute = attr -end - -Then /^each ([\w-]+) should have '(.+)' attribute set to '(.+)'$/ do |el, attr, v| - case el - when 'image': - path = "/image/images" - end - output_xml.xpath(path).each do |element| - element[attr].should == v - end -end - -When /^client follow this attribute$/ do - output_xml.xpath('/api/link').each do |entry_point| - get entry_point[@last_attribute], {} - end -end - -Then /^client should get a valid response$/ do - last_response.status.should_not == 500 -end - -Then /^client should get list of features inside '(.+)':$/ do |element,table| - features = table.raw.flatten.sort - instance_features = [] - output_xml.xpath('/api/link[@rel="'+element+'"]/feature').each do |feature| - instance_features << feature[:name] - end - features.should == instance_features.sort -end diff --git a/server/features/step_definitions/hardware_profiles_steps.rb b/server/features/step_definitions/hardware_profiles_steps.rb deleted file mode 100644 index db1828b..0000000 --- a/server/features/step_definitions/hardware_profiles_steps.rb +++ /dev/null @@ -1,25 +0,0 @@ -Then /^it should have a (\w+) attribute$/ do |name| - attr = output_xml.xpath('/hardware-profile').first[name] - attr.should_not be_nil -end - -Then /^it should have a (\w+) property '(.+)'$/ do |kind, name| - props = output_xml.xpath("/hardware-profile/property[@name = '#{name}']") - props.size.should == 1 - prop = props.first - prop['kind'].should == kind - prop['unit'].should_not be_nil - if kind == 'range' - ranges = prop.xpath('range') - ranges.size.should == 1 - range = ranges.first - range['first'].should_not be_nil - range['last'].should_not be_nil - end - if kind == 'enum' - enums = prop.xpath('enum') - enums.size.should == 1 - enums.first.xpath('entry').size.should_not == 0 - end -end - diff --git a/server/features/step_definitions/images_steps.rb b/server/features/step_definitions/images_steps.rb deleted file mode 100644 index fc01364..0000000 --- a/server/features/step_definitions/images_steps.rb +++ /dev/null @@ -1,83 +0,0 @@ -Given /^authentification is required for this URI$/ do - authorize CONFIG[:username], CONFIG[:password] - get @uri, {} - last_response.status.should == 200 -end - -Then /^this element contains some (.+)$/ do |items| - item = items.singularize - output_xml.xpath("/#{@last_element.name}/#{item}").size.should > 0 -end - -Then /^each ([\w-]+) should have:$/ do |item, table| - properties = table.raw.flatten.sort - output_xml.xpath("/#{@last_element.name}/#{item}").each do |element| - childrens = (element > '*').collect { |c| c.name } - childrens.sort.should == properties - end -end - -Then /^this ([\w-]+) should have:$/ do |item, table| - properties = table.raw.flatten.sort - output_xml.xpath("/#{item}").each do |element| - childrens = (element > '*').collect { |c| c.name } - childrens.sort.should == properties - end -end - -When /^client want to show first (.+)$/ do |element| - case element - when 'image': - path = '/images/image' - when 'instance': - path = '/instances/instance' - when 'realm': - path = '/realms/realm' - when 'hardware-profile' - path = '/hardware-profiles/hardware-profile' - when 'storage-volume': - path = '/storage-volumes/storage-volume' - when 'storage-snapshot': - path = '/storage-snapshots/storage-snapshot' - end - @element = output_xml.xpath(path).first - @element.should_not be_nil -end - -When /^client want to show '(.+)' (.+)$/ do |id, el| - @uri = "/api/#{el.pluralize.tr('-', '_')}/#{id}" - get @uri, {} - @element = output_xml.xpath("/#{el}").first - @element.should_not be_nil -end - -Then /^client follow (\w+) attribute in first (.+)$/ do |attr, el| - url = output_xml.xpath("/#{el.pluralize}/#{el}").first[:href] - url.should_not be_nil - get url, {} -end - -Then /^client should get this (.+)$/ do |el| - last_response.status.should == 200 -end - - -Then /^client should follow href attribute in (\w+)$/ do |element| - get @element[:href], {} -end - -Then /^client should get valid response with requested (\w+)$/ do |element| - last_response.status.should == 200 - output_xml.xpath('/'+element+'/id').first.text.should == @element.xpath('id').text -end - -When /^client access this URI with parameters:$/ do |table| - params = {} - table.raw.each { |i| params[i[0]]=i[1] } - get @uri, params -end - -Then /^client should get some ([\w-]+)$/ do |elements| - last_response.status.should == 200 - output_xml.xpath('/'+elements+'/'+elements.singularize).size.should > 0 -end diff --git a/server/features/step_definitions/instance_states_steps.rb b/server/features/step_definitions/instance_states_steps.rb deleted file mode 100644 index a587e5d..0000000 --- a/server/features/step_definitions/instance_states_steps.rb +++ /dev/null @@ -1,34 +0,0 @@ -Then /^states element contains some states$/ do - output_xml.xpath('/states/state').size.should > 0 -end - -Then /^each state should have '(.+)' attribute$/ do |attr| - output_xml.xpath('/states/state').each do |state| - state[attr].should_not be_nil - end -end - -Then /^(\w+) state should have '(.+)' attribute set to '(\w+)'$/ do |pos, attr, value| - output_xml.xpath('/states/state').first[attr].should==value if pos=='first' - output_xml.xpath('/states/state').last[attr].should==value if pos=='last' -end - -Then /^some states should have transitions$/ do - @transitions = output_xml.xpath('/states/state/transition') - @transitions.size.should > 0 -end - -Then /^each transitions should have 'to' attribute$/ do - @transitions.each do |t| - t[:to].should_not be_nil - end -end - -When /^client wants (\w+) format$/ do |format| - get "#{@uri}.#{format.downcase}", {} -end - -Then /^client should get PNG image$/ do - last_response.status.should == 200 - last_response.headers['Content-Type'].should == 'image/png' -end diff --git a/server/features/step_definitions/instances_steps.rb b/server/features/step_definitions/instances_steps.rb deleted file mode 100644 index 8ec6526..0000000 --- a/server/features/step_definitions/instances_steps.rb +++ /dev/null @@ -1,121 +0,0 @@ -When /^client follow ([\w-]+) href attribute in first instance$/ do |element| - get output_xml.xpath('/instances/instance[1]/'+element).first[:href], {} -end - -Then /^client should get valid ([\w-]+)$/ do |element| - last_response.status.should == 200 - output_xml.xpath("/#{element}").first.should_not be_nil -end - -Then /^each instance should have actions$/ do - output_xml.xpath('/instances/instance').each do |instance| - instance.xpath('actions').first.should_not be_nil - end -end - -Then /^each actions should have some links$/ do - output_xml.xpath('/instances/instance').each do |instance| - instance.xpath('actions/link').first.should_not be_nil - end -end - -Then /^each link should have valid (\w+) attribute$/ do |attr| - output_xml.xpath('/instances/instance').each do |instance| - instance.xpath('actions/link').first[attr].should_not be_nil - end -end - -When /^client want to '(\w+)' first instance$/ do |action| - @action = action - @instance = output_xml.xpath('/instances/instance[1]').first -end - -When /^client follow link in actions$/ do - unless @instance_url - l = output_xml.xpath("/instances/instance[1]/actions/link[@rel = '#{@action}']").first - else - l = @instance.xpath('actions/link[@rel="'+@action+'"]').first - end - unless @action=='destroy' - post l[:href], { :id => @instance.xpath('id').first.text } - else - delete l[:href], { :id => @instance.xpath('id').first.text } - end - last_response.status.should_not == 500 -end - -Then /^client should get first instance$/ do - output_xml.xpath('/instance/id').first.should_not be_nil - #output_xml.xpath('/instance/id').first.text.should == @instance.xpath('id').first.text -end - -Then /^this instance should be in '(.+)' state$/ do |state| - output_xml.xpath('/instance/state').first.text.should == state -end - -When /^client want to create a new instance$/ do -end - -Then /^client should choose first image$/ do - get '/api/images', {} - @image = output_xml.xpath('/images/image').first - @image.should_not be_nil -end - -When /^client request for a new instance$/ do - params = { - :image_id => @image.xpath('id').first.text - } - params[:hwp_id] = @hwp_id if @hwp_id - post "#{@uri}", params - last_response.status.should == 201 - @instance_url = last_response.headers['Location'] -end - -Then /^new instance should be created$/ do - get @instance_url, {} - last_response.status.should == 200 -end - -Then /^this instance should have chosed image$/ do - output_xml.xpath('/instance/image').first[:href].should == @image[:href] -end - -Then /^this instance should have valid id$/ do - output_xml.xpath('instance/id').first.should_not be_nil -end - -Then /^this instance should have name$/ do - output_xml.xpath('instance/name').first.should_not be_nil -end - -When /^client want to '(\w+)' created instance$/ do |action| - get @instance_url, {} - last_response.status.should == 200 - @action = action - @instance = output_xml.xpath('/instance') -end - -Then /^client should get created instance$/ do - get @instance_url -end - -When /^this instance should be destroyed$/ do - # TODO: Fix this bug in mock driver ? - #get @instance_url, {} - #last_response.status.should == 404 -end - -Then /^client should get HTML form$/ do - last_response.status.should == 200 - (last_response.body.strip =~ /^<!DOCTYPE html/).should be_true -end - -When /^client choose last hardware profile$/ do - get '/api/hardware_profiles', {} - @hwp_id = output_xml.xpath('/hardware-profiles/hardware-profile/id').last.text -end - -Then /^this instance should have last hardware profile$/ do - output_xml.xpath('instance/hardware-profile/id').first.text.should == @hwp_id -end diff --git a/server/features/step_definitions/rake_steps.rb b/server/features/step_definitions/rake_steps.rb deleted file mode 100644 index c8ea3d9..0000000 --- a/server/features/step_definitions/rake_steps.rb +++ /dev/null @@ -1,19 +0,0 @@ -require 'fileutils' -require 'rake' -require 'find' - -Given /^I have a clean (.+) directory$/ do |dir| - FileUtils.rm_rf dir -end - -When /^I run a '(\w+)' task$/ do |task| - @rake = Rake::Application.new - Rake.application = @rake - load "Rakefile" - @task = Rake::Task[task] - @task.invoke -end - -Then /^I should see a (\w+) file inside (\w+) directory$/ do |ext, dir| - Dir["#{dir}/deltacloud-*.#{ext}"].size.should == 1 -end diff --git a/server/features/storage_snapshots.feature b/server/features/storage_snapshots.feature deleted file mode 100644 index f6f38e5..0000000 --- a/server/features/storage_snapshots.feature +++ /dev/null @@ -1,29 +0,0 @@ -Feature: Accessing storage snapshots - - Scenario: Listing available storage snapshots - Given URI /api/storage_snapshots exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'storage-snapshots' - And this element contains some storage-snapshots - And each storage-volume should have: - | id | - | created | - | storage-volume | - And each image should have 'href' attribute with valid URL - And this URI should be available in XML, JSON, HTML format - - Scenario: Get details about first volume - Given URI /api/storage_snapshots exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'storage-snapshots' - And this element contains some storage-snapshots - When client want to show first storage-snapshot - Then client follow href attribute in first storage-snapshot - Then client should get this storage-snapshot - And this storage-snapshot should have: - | id | - | created | - | state | - | storage-volume | diff --git a/server/features/storage_volumes.feature b/server/features/storage_volumes.feature deleted file mode 100644 index dfca4b0..0000000 --- a/server/features/storage_volumes.feature +++ /dev/null @@ -1,33 +0,0 @@ -Feature: Accessing storage volumes - - Scenario: Listing available storage volumes - Given URI /api/storage_volumes exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'storage-volumes' - And this element contains some storage-volumes - And each storage-volume should have: - | id | - | created | - | capacity | - | device | - | instance | - And each image should have 'href' attribute with valid URL - And this URI should be available in XML, JSON, HTML format - - Scenario: Get details about first volume - Given URI /api/storage_volumes exists - And authentification is required for this URI - When client access this URI - Then client should get root element 'storage-volumes' - And this element contains some storage-volumes - When client want to show first storage-volume - Then client follow href attribute in first storage-volume - Then client should get this storage-volume - And this storage-volume should have: - | id | - | created | - | capacity | - | device | - | instance | - | state | diff --git a/server/features/support/env.rb b/server/features/support/env.rb deleted file mode 100644 index 45430c3..0000000 --- a/server/features/support/env.rb +++ /dev/null @@ -1,39 +0,0 @@ -require 'sinatra' -require 'server' -require 'rack/test' -require 'nokogiri' - -SERVER_DIR = File::expand_path(File::join(File::dirname(__FILE__), "../..")) -Sinatra::Application.set :environment, :test -Sinatra::Application.set :root, SERVER_DIR - -ENV['API_DRIVER'] = "mock" unless ENV['API_DRIVER'] - -CONFIG = { - :username => 'mockuser', - :password => 'mockpassword' -} - -World do - - def app - @app = Rack::Builder.new do - set :logging, true - set :raise_errors, true - run Sinatra::Application - end - end - - def output_xml - Nokogiri::XML(last_response.body) - end - - Before do - unless @no_header - header 'Accept', 'application/xml' - end - end - - include Rack::Test::Methods -end - diff --git a/tests/Rakefile b/tests/Rakefile index 7cddad3..0aa528f 100644 --- a/tests/Rakefile +++ b/tests/Rakefile @@ -19,8 +19,6 @@ # for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
require 'rake' -require 'rake/testtask' -require 'rake/gempackagetask' require 'cucumber' require 'cucumber/rake/task'
@@ -45,8 +43,3 @@ end Cucumber::Rake::Task.new(:junit) do |t| t.cucumber_opts = "../tests/#{DRIVER} --format junit --out ../tests/tmp/junit_#{DRIVER}" end - -load '../server/deltacloud-core.gemspec' -Rake::GemPackageTask.new(@spec) do |pkg| - pkg.need_tar = true -end
--- ...images.1d05fa88d294d07beed14334421b46d322385188 | 1338 ++++++++++++++++++++ ...images.45eee35ec8f8243c05d85cf5486c54368be8207e | 11 + ...tances.da39a3ee5e6b4b0d3255bfef95601890afd80709 | 19 + ...tances.698df7f7a613449c42d1bcea2ba275b2bc598db5 | 15 + ...images.1d05fa88d294d07beed14334421b46d322385188 | 1338 ++++++++++++++++++++ ...images.45eee35ec8f8243c05d85cf5486c54368be8207e | 11 + ...tances.da39a3ee5e6b4b0d3255bfef95601890afd80709 | 19 + ...tances.698df7f7a613449c42d1bcea2ba275b2bc598db5 | 15 + ..._zones.da39a3ee5e6b4b0d3255bfef95601890afd80709 | 11 + ...images.1d05fa88d294d07beed14334421b46d322385188 | 1338 ++++++++++++++++++++ ...images.45eee35ec8f8243c05d85cf5486c54368be8207e | 11 + ...images.491d1c515d961d5875891b26586ece2a2994be84 | 79 ++ ...tances.da39a3ee5e6b4b0d3255bfef95601890afd80709 | 19 + ...tances.da39a3ee5e6b4b0d3255bfef95601890afd80709 | 19 + ...tances.8db15ec3f117ce8070a0550fd99ac76ce508ade5 | 3 + ...tances.af7d3d510feb715a04fd18e586088975e2ab5a9f | 3 + ...tances.d42fd93b19e95a9b2eac3a1e16f1d82d5c242524 | 16 + ...tances.da39a3ee5e6b4b0d3255bfef95601890afd80709 | 19 + ...tances.da39a3ee5e6b4b0d3255bfef95601890afd80709 | 19 + ...tances.af7d3d510feb715a04fd18e586088975e2ab5a9f | 6 + ...tances.8db15ec3f117ce8070a0550fd99ac76ce508ade5 | 6 + 21 files changed, 4315 insertions(+), 0 deletions(-) create mode 100644 tests/ec2/support/ec2/create-hwp_describe_images.1d05fa88d294d07beed14334421b46d322385188 create mode 100644 tests/ec2/support/ec2/create-hwp_describe_images.45eee35ec8f8243c05d85cf5486c54368be8207e create mode 100644 tests/ec2/support/ec2/create-hwp_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 create mode 100644 tests/ec2/support/ec2/create-hwp_run_instances.698df7f7a613449c42d1bcea2ba275b2bc598db5 create mode 100644 tests/ec2/support/ec2/create_describe_images.1d05fa88d294d07beed14334421b46d322385188 create mode 100644 tests/ec2/support/ec2/create_describe_images.45eee35ec8f8243c05d85cf5486c54368be8207e create mode 100644 tests/ec2/support/ec2/create_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 create mode 100644 tests/ec2/support/ec2/create_run_instances.698df7f7a613449c42d1bcea2ba275b2bc598db5 create mode 100644 tests/ec2/support/ec2/describe_availability_zones.da39a3ee5e6b4b0d3255bfef95601890afd80709 create mode 100644 tests/ec2/support/ec2/describe_images.1d05fa88d294d07beed14334421b46d322385188 create mode 100644 tests/ec2/support/ec2/describe_images.45eee35ec8f8243c05d85cf5486c54368be8207e create mode 100644 tests/ec2/support/ec2/describe_images.491d1c515d961d5875891b26586ece2a2994be84 create mode 100644 tests/ec2/support/ec2/describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 create mode 100644 tests/ec2/support/ec2/reboot_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 create mode 100644 tests/ec2/support/ec2/reboot_instances.8db15ec3f117ce8070a0550fd99ac76ce508ade5 create mode 100644 tests/ec2/support/ec2/reboot_reboot_instances.af7d3d510feb715a04fd18e586088975e2ab5a9f create mode 100644 tests/ec2/support/ec2/run_instances.d42fd93b19e95a9b2eac3a1e16f1d82d5c242524 create mode 100644 tests/ec2/support/ec2/start_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 create mode 100644 tests/ec2/support/ec2/stop_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 create mode 100644 tests/ec2/support/ec2/stop_terminate_instances.af7d3d510feb715a04fd18e586088975e2ab5a9f create mode 100644 tests/ec2/support/ec2/terminate_instances.8db15ec3f117ce8070a0550fd99ac76ce508ade5
diff --git a/tests/ec2/support/ec2/create-hwp_describe_images.1d05fa88d294d07beed14334421b46d322385188 b/tests/ec2/support/ec2/create-hwp_describe_images.1d05fa88d294d07beed14334421b46d322385188 new file mode 100644 index 0000000..4613207 --- /dev/null +++ b/tests/ec2/support/ec2/create-hwp_describe_images.1d05fa88d294d07beed14334421b46d322385188 @@ -0,0 +1,1338 @@ +BAh7CCIOaW1hZ2VzU2V0ewYiCWl0ZW1bAax7ECIOaW1hZ2VUeXBlIgtrZXJu +ZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJs +ZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINQTk0 +MDhCNEIiDGltYWdlSWQiEWFraS0wMjUxYjM2YiITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iS2VjMi1wYWlkLWlibS1pbWFn +ZXMtaWRzL3ZtbGludXotMi42LjE2LjYwLTAuMzAteGVuLng4Nl82NC5tYW5p +ZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQi +ETQ3MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZp +Y2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFh +a2ktMGE0YWE4NjMiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIU +aW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFn +ZUxvY2F0aW9uIkdlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2 +LjYwLTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVy +ZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsPIg5pbWFn +ZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0 +ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFha2ktMTJmMDEyN2IiE3Jvb3REZXZp +Y2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6 +b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1p +Ym0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJ +ZCIRNDcwMjU0NTM0MDI0exAiCW5hbWUiOXZtbGludXotMi42LjE4LXhlblUt +ZWMyLXYxLjQueDg2XzY0LmFraS5tYW5pZmVzdC54bWwiDmltYWdlVHlwZSIL +a2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiDGltYWdlSWQiEWFraS0yYTQyYTA0MyITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iS2VjMi1wdWJsaWMtaW1hZ2Vz +L3ZtbGludXotMi42LjE4LXhlblUtZWMyLXYxLjQueDg2XzY0LmFraS5tYW5p +ZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQi +ETIwNjAyOTYyMTUzMnsQIg5pbWFnZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZp +Y2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29k +ZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg01NzhCRjVCQSIMaW1hZ2VJ +ZCIRYWtpLTJkZDMzMDQ0IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQtaWJtLWltYWdlcy92bWxpbnV6LTIu +Ni4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsPIg5p +bWFnZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VT +dGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFha2ktMzAzOGRhNTkiE3Jvb3RE +ZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgth +bWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFp +ZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkz +ODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3du +ZXJJZCIRNDcwMjU0NTM0MDI0ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9j +a0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdl +SWQiEWFraS00NmU3MDAyZiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0 +b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUi +EmltYWdlTG9jYXRpb24iOWFraS1saW51eC4yLjYuMjEuNy0yLmZjOHhlbi14 +ZnMvdm1saW51ei5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIR +aW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgtrZXJu +ZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJs +ZSIMaW1hZ2VJZCIRYWtpLTRkNThiOTI0IhNyb290RGV2aWNlVHlwZSITaW5z +dGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1Ymxp +YyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQtaWJtLWltYWdlcy92 +bWxpbnV6LTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0Lnht +bCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsPIg5pbWFnZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5n +MCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFha2ktNTRjZTJj +M2QiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25l +ckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9u +IlFlYzItcHVibGljLWltYWdlcy92bWxpbnV6LTIuNi4yMS43LTIuZWMyLnYx +LjIuZmM4eGVuLng4Nl82NC5ha2kubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1 +cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIJbmFt +ZSI3dm1saW51ei0yLjYuMTgteGVuVS1lYzItdjEuNC5pNjg2LmFraS5tYW5p +ZmVzdC54bWwiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBp +bmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS01NjQy +YTAzZiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iSWVjMi1wdWJsaWMtaW1hZ2VzL3ZtbGludXotMi42LjE4LXhlblUtZWMy +LXYxLjQuaTY4Ni5ha2kubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkz +ODYiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyexAiDmltYWdlVHlwZSIL +a2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUi +DUQ2RjYwNTJBIgxpbWFnZUlkIhFha2ktNjA1MWIzMDkiE3Jvb3REZXZpY2VU +eXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24i +DWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1pYm0t +aW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFu +aWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIR +NDcwMjU0NTM0MDI0ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0Rldmlj +ZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFr +aS02MjQ4YTgwYiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRp +bWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdl +TG9jYXRpb24iSGVjMi1wYWlkLWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYu +NjAtMC4yOS14ZW5wYWUuaTM4Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVy +ZSIJaTM4NiIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VU +eXBlIgtrZXJuZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUi +DmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0 +Q29kZSINNDlDQTczMDUiDGltYWdlSWQiEWFraS02ODQ4YTgwMSITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iSGVjMi1wYWlk +LWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYuNjAtMC4yOS14ZW5wYWUuaTM4 +Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVj +dENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRUE1RjA1QTMiDGlt +YWdlSWQiEWFraS02YmVjMGMwMiITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMvdm1saW51 +ei0yLjYuMTYuNjAtMC4zMC14ZW4ueDg2XzY0Lm1hbmlmZXN0LnhtbCIRYXJj +aGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0 +ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9p +bWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS02ZWFhNDkwNyIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iTWVj +Mi1wdWJsaWMtaW1hZ2VzL3ZtbGludXotMi42LjIxLTIuZmM4eGVuLWVjMi12 +MS4wLmkzODYuYWtpLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2 +IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsQIg5pbWFnZVR5cGUiC2tl +cm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxh +YmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg1E +NkZCMTExMyIMaW1hZ2VJZCIRYWtpLTZmNzc5NDA2IhNyb290RGV2aWNlVHlw +ZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1p +c1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQtaWJtLWlt +YWdlcy92bWxpbnV6LTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3 +MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VN +YXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFha2kt +NmY5MTcxMDYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIkhlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYw +LTAuMjkteGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUi +CWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAiDmltYWdlVHlw +ZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENv +ZGUiDUNDRUIzNjhCIgxpbWFnZUlkIhFha2ktN2M0OGE4MTUiE3Jvb3REZXZp +Y2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6 +b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1p +Ym0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJ +ZCIRNDcwMjU0NTM0MDI0exAiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0Rl +dmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RD +b2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDTgwRUQwMEI4IgxpbWFn +ZUlkIhFha2ktN2U0OGE4MTciE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1z +dG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVl +IhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXot +Mi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNo +aXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAi +DmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQ +cHJvZHVjdENvZGUiDUQ2RkIxMTEzIgxpbWFnZUlkIhFha2ktODA0OWFlZTki +E3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFs +aWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhl +YzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVu +cGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWlt +YWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAiDmltYWdlVHlwZSILa2VybmVs +IhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUi +EXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUE0ODE4 +OTVEIgxpbWFnZUlkIhFha2ktODE0OWFlZTgiE3Jvb3REZXZpY2VUeXBlIhNp +bnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVi +bGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1pYm0taW1hZ2Vz +L3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0 +NTM0MDI0exAiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBp +bmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglp +dGVtWwZ7BiIQcHJvZHVjdENvZGUiDThGQ0UzRUVCIgxpbWFnZUlkIhFha2kt +ODI0OWFlZWIiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIkdlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYw +LTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIL +eDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5 +cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RD +b2RlIg00NzZEMjlDQiIMaW1hZ2VJZCIRYWtpLTgzNDlhZWVhIhNyb290RGV2 +aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1h +em9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBhaWQt +aWJtLWltYWdlcy92bWxpbnV6LTIuNi4xNi42MC0wLjMwLXhlbi54ODZfNjQu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVj +dENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRUE1RjA1QTMiDGlt +YWdlSWQiEWFraS04NTQ5YWVlYyITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMvdm1saW51 +ei0yLjYuMTYuNjAtMC4zMC14ZW4ueDg2XzY0Lm1hbmlmZXN0LnhtbCIRYXJj +aGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0 +exAiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9p +bWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7 +BiIQcHJvZHVjdENvZGUiDUUzRDQ4Q0VFIgxpbWFnZUlkIhFha2ktODY3MDkw +ZWYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25l +ckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9u +IkhlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkt +eGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYi +EWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAiDmltYWdlVHlwZSILa2Vy +bmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFi +bGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDTU3 +OEJGNUJBIgxpbWFnZUlkIhFha2ktOGIzZmRlZTIiE3Jvb3REZXZpY2VUeXBl +IhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlz +UHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1pYm0taW1h +Z2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZl +c3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcw +MjU0NTM0MDI0ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1h +cHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS05 +NGM1MjdmZCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFn +ZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9j +YXRpb24iT2VjMi1wdWJsaWMtaW1hZ2VzL3ZtbGludXotMi42LjIxLjctMi5l +YzIudjEuMi5mYzh4ZW4uaTY4Ni5ha2kubWFuaWZlc3QueG1sIhFhcmNoaXRl +Y3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyew8iDmlt +YWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS05NjQ1YTdmZiITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iSGVjMi1wYWlk +LWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYuNjAtMC4yOS14ZW5wYWUuaTM4 +Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJ +ZCIRYWtpLTk4MDBlNWYxIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJLZWMyLXB1YmxpYy1pbWFnZXMvdm1saW51ei0yLjYu +MTgteGVuVS1lYzItdjEuMC54ODZfNjQuYWtpLm1hbmlmZXN0LnhtbCIRYXJj +aGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMy +ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9p +bWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS05YjAwZTVmMiIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iSWVj +Mi1wdWJsaWMtaW1hZ2VzL3ZtbGludXotMi42LjE4LXhlblUtZWMyLXYxLjAu +aTM4Ni5ha2kubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWlt +YWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyexAiDmltYWdlVHlwZSILa2VybmVs +IhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUi +EXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUQ2NjJF +OTg5IgxpbWFnZUlkIhFha2ktOWIzZmRlZjIiE3Jvb3REZXZpY2VUeXBlIhNp +bnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVi +bGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1pYm0taW1hZ2Vz +L3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0 +NTM0MDI0exAiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBp +bmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglp +dGVtWwZ7BiIQcHJvZHVjdENvZGUiDUE0ODE4OTVEIgxpbWFnZUlkIhFha2kt +OWZlYjBiZjYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIkhlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYw +LTAuMjkteGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUi +CWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0ew8iDmltYWdlVHlw +ZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiDGltYWdlSWQiEWFraS1hM2Q3MzdjYSITcm9vdERldmljZVR5 +cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiIN +aXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iT2VjMi1wdWJsaWMtaW1h +Z2VzL3ZtbGludXotMi42LjIxLTIuZmM4eGVuLWVjMi12MS4wLng4Nl82NC5h +a2kubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VP +d25lcklkIhEyMDYwMjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Js +b2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1h +Z2VJZCIRYWtpLWE1M2FkZmNjIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Ut +c3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1 +ZSISaW1hZ2VMb2NhdGlvbiJEZWMyLXB1YmxpYy1pbWFnZXMvdm1saW51ei0y +LjYuMjAtMS4zMDAyLmZjNnhlbi5ha2kubWFuaWZlc3QueG1sIhFhcmNoaXRl +Y3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIO +aW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYWtpLWE2ZjIxMGNmIhNyb290 +RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyIL +YW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBh +aWQtaWJtLWltYWdlcy92bWxpbnV6LTIuNi4xNi42MC0wLjMwLXhlbi54ODZf +NjQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VP +d25lcklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Js +b2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1h +Z2VJZCIRYWtpLWE3MWNmOWNlIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Ut +c3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1 +ZSISaW1hZ2VMb2NhdGlvbiJGZWMyLXB1YmxpYy1pbWFnZXMvZWMyLXZtbGlu +dXotMi42LjIxLjctMi5mYzh4ZW4uaTM4Ni5tYW5pZmVzdC54bWwiEWFyY2hp +dGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIO +aW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBw +cm9kdWN0Q29kZSINRDZGNjA1MkEiDGltYWdlSWQiEWFraS1iMzRiYWNkYSIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iSGVj +Mi1wYWlkLWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYuNjAtMC4yOS14ZW5w +YWUuaTM4Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1h +Z2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1hZ2VUeXBlIgtrZXJuZWwi +F2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIM +aW1hZ2VJZCIRYWtpLWI1MWNmOWRjIhNyb290RGV2aWNlVHlwZSITaW5zdGFu +Y2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJ +dHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMyLXB1YmxpYy1pbWFnZXMvZWMyLXZt +bGludXotMi42LjIxLjctMi5mYzh4ZW4ueDg2XzY0Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIx +NTMyew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcw +Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS1iOWU3MDdk +MCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVy +QWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24i +SGVjMi1wYWlkLWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYuNjAtMC4yOS14 +ZW5wYWUuaTM4Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIR +aW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgtrZXJu +ZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJs +ZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINQTQ4 +MTg5NUQiDGltYWdlSWQiEWFraS1iY2U2MGJkNSITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iTGVjMi1wYWlkLWlibS1pbWFn +ZXMtZGIyL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFu +aWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIR +NDcwMjU0NTM0MDI0ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0Rldmlj +ZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFr +aS1kNGNhMmRiZCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRp +bWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdl +TG9jYXRpb24iWGFraS1saW51eC0yLjYuMTguOTItOTIuZWw1eGVuLXhmcy92 +bWxpbnV6LTIuNi4xOC45Mi05Mi5lbDV4ZW4uaTM4Ni5ha2kubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5 +NjIxNTMyexAiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBp +bmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglp +dGVtWwZ7BiIQcHJvZHVjdENvZGUiDUE5NDA4QjRCIgxpbWFnZUlkIhFha2kt +ZGI0YmFjYjIiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIkdlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYw +LTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIL +eDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsPIg5pbWFnZVR5 +cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIgxpbWFnZUlkIhFha2ktZTVjMTIxOGMiE3Jvb3REZXZpY2VU +eXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24i +DWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIktlYzItcHVibGljLWlt +YWdlcy92bWxpbnV6LTIuNi4xOC14ZW5VLWVjMi12MS4yLng4Nl82NC5ha2ku +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25l +cklkIhEyMDYwMjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJ +ZCIRYWtpLWY1YzEyMTljIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJJZWMyLXB1YmxpYy1pbWFnZXMvdm1saW51ei0yLjYu +MTgteGVuVS1lYzItdjEuMi5pMzg2LmFraS5tYW5pZmVzdC54bWwiEWFyY2hp +dGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIO +aW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBw +cm9kdWN0Q29kZSINMjFFOUVCQzkiDGltYWdlSWQiEWFraS1mODU4YmE5MSIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iUmVj +Mi1wYWlkLWlibS1pbWFnZXMtaW5mb3NwaGVyZS92bWxpbnV6LTIuNi4xNi42 +MC0wLjMwLXhlbi54ODZfNjQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUi +C3g4Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VU +eXBlIgtrZXJuZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUi +DmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0 +Q29kZSINRDY2MkU5ODkiDGltYWdlSWQiEWFraS1mOGYwMTI5MSITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iSGVjMi1wYWlk +LWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYuNjAtMC4yOS14ZW5wYWUuaTM4 +Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVj +dENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRUE1RjA1QTMiDGlt +YWdlSWQiEWFraS1mOGZkMTA5MSITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iS2VjMi1wYWlkLWlibS1pbWFnZXMtZGIyL3Zt +bGludXotMi42LjE2LjYwLTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwi +EWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsQIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGlu +ZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLTA1MzVk +NjZjIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3du +ZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlv +biJMZWMyLXB1YmxpYy13aW5kb3dzLWltYWdlcy9TcWxTdnJTdGQyMDAzcjIt +eDg2XzY0LVdpbi12MS4wNy5tYW5pZmVzdC54bWwiDXBsYXRmb3JtIgx3aW5k +b3dzIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYw +Mjk2MjE1MzJ7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1h +cHBpbmcwIg5yYW1kaXNrSWQiEWFyaS02NjQ4YTgwZiIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RD +b2RlIg04MEVEMDBCOCINa2VybmVsSWQiEWFraS03ZTQ4YTgxNyIMaW1hZ2VJ +ZCIRYW1pLTA2NGNhYzZmIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQtaWJtLWltYWdlcy9pYm0tdGl2b2xp +LWl0bS0wNi4yMS4wMy4wMC0zMmItNjAwLm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsTIg5p +bWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRp +c2tJZCIRYXJpLTMyMzhkYTViIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXBy +b2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUUzRDQ4Q0VF +Ig1rZXJuZWxJZCIRYWtpLTMwMzhkYTU5IgxpbWFnZUlkIhFhbWktMTAwMGUy +NzkiE3Jvb3REZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBl +IhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlz +UHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIlBlYzItcGFpZC1pYm0taW1h +Z2VzL3dlYnNwaGVyZS1hcHBsaWNhdGlvbi1zZXJ2ZXItNy4wLjAuNy0zMmJp +dC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7EyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9j +a0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS0wYzUxYjM2NSIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYi +EHByb2R1Y3RDb2RlIg1BOTQwOEI0QiINa2VybmVsSWQiEWFraS0wMjUxYjM2 +YiIMaW1hZ2VJZCIRYW1pLTEwNTFiMzc5IhNyb290RGV2aWNlTmFtZSIOL2Rl +di9zZGExIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdl +T3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2Nh +dGlvbiJHZWMyLXBhaWQtaWJtLWltYWdlcy1pZHMvaWJtLWlkcy13b3JrZ3Jv +dXAtMTEuNS12MjAyLTEubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4 +Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7ESIOaW1hZ2VUeXBl +IgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFy +aS1hNTFjZjljYyIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJuZWxJZCIR +YWtpLWE3MWNmOWNlIgxpbWFnZUlkIhFhbWktMTFjYTJkNzgiE3Jvb3REZXZp +Y2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6 +b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIj9hd3MtdG9vbGtp +dC1mb3ItZWNsaXBzZS1hbWlzLXVzL3RvbWNhdC12MS4wLjAubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA1NjA1 +ODE5NzE2exAiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBw +aW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLTli +MDBlNWYyIgxpbWFnZUlkIhFhbWktMjA1ZmJhNDkiE3Jvb3REZXZpY2VUeXBl +IhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlz +UHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkBlYzItcHVibGljLWltYWdl +cy9mZWRvcmEtY29yZTQtaTM4Ni1iYXNlLXYxLjA3Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUz +MnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAi +DnJhbWRpc2tJZCIRYXJpLWRiYzEyMWIyIg9pbWFnZVN0YXRlIg5hdmFpbGFi +bGUiDWtlcm5lbElkIhFha2ktZjVjMTIxOWMiDGltYWdlSWQiEWFtaS0yMGIw +NTM0OSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iRWF3cy1jb25zb2xlLXF1aWNrc3RhcnQtYW1pcy9wZXJsLzEuMy9wZXJs +cXVpY2tzdGFydC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIR +aW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3MTZ7DyIOaW1hZ2VUeXBlIgxtYWNo +aW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFi +bGUiDGltYWdlSWQiEWFtaS0yMGI2NTM0OSITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iNWVjMi1wdWJsaWMtaW1hZ2VzL2Zl +ZG9yYS1jb3JlNC1iYXNlLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglp +Mzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsPIg5pbWFnZVR5cGUi +DG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2 +YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLTIxNWZiYTQ4IhNyb290RGV2aWNlVHlw +ZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1p +c1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiI7ZWMyLXB1YmxpYy1pbWFn +ZXMvZmVkb3JhLWNvcmU0LWJhc2UtdjEuMDcubWFuaWZlc3QueG1sIhFhcmNo +aXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyew8i +DmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhbWktMjI1ZmJhNGIiE3Jv +b3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFz +IgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkNlYzIt +cHVibGljLWltYWdlcy9mZWRvcmEtY29yZTQtYXBhY2hlLW15c3FsLXYxLjA3 +Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVy +SWQiETIwNjAyOTYyMTUzMnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLWRiYzEyMWIyIg9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktZjVjMTIxOWMiDGlt +YWdlSWQiEWFtaS0yMmIwNTM0YiITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iRWF3cy1jb25zb2xlLXF1aWNrc3RhcnQtYW1p +cy9ydWJ5LzEuMi9ydWJ5cXVpY2tzdGFydC5tYW5pZmVzdC54bWwiEWFyY2hp +dGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3MTZ7DyIO +aW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS0yMmI2NTM0YiITcm9v +dERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMi +C2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iNmVjMi1w +dWJsaWMtaW1hZ2VzL2ZlZG9yYS1jb3JlNC1teXNxbC5tYW5pZmVzdC54bWwi +EWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1 +MzJ7DyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcw +Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS0yMzVmYmE0 +YSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVy +QWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24i +OWVjMi1wdWJsaWMtaW1hZ2VzL2dldHRpbmctc3RhcnRlZC12MS4wNy5tYW5p +ZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEy +MDYwMjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0Rldmlj +ZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFt +aS0yM2I2NTM0YSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRp +bWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdl +TG9jYXRpb24iN2VjMi1wdWJsaWMtaW1hZ2VzL2ZlZG9yYS1jb3JlNC1hcGFj +aGUubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3du +ZXJJZCIRMjA2MDI5NjIxNTMyexIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxv +Y2tEZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktYjI0YmFjZGIiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsG +IhBwcm9kdWN0Q29kZSINRDZGNjA1MkEiDWtlcm5lbElkIhFha2ktYjM0YmFj +ZGEiDGltYWdlSWQiEWFtaS0yNDRhYWQ0ZCITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iTGVjMi1wYWlkLWlibS1pbWFnZXMv +aW5mb3JtaXgtZHluYW1pYy1zZXJ2ZXItZXhwcmVzcy0zMi1iaXQubWFuaWZl +c3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcw +MjU0NTM0MDI0exEiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VN +YXBwaW5nMCIOcmFtZGlza0lkIhFhcmktYjMxY2Y5ZGEiD2ltYWdlU3RhdGUi +DmF2YWlsYWJsZSINa2VybmVsSWQiEWFraS1iNTFjZjlkYyIMaW1hZ2VJZCIR +YW1pLTI1NDdhMzRjIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUi +FGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1h +Z2VMb2NhdGlvbiI+ZWMyLXB1YmxpYy1pbWFnZXMvZmVkb3JhLTgteDg2XzY0 +LWJhc2UtdjEuMDgubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82 +NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgxt +YWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiDGltYWdlSWQiEWFtaS0yNTVmYmE0YyITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iPGVjMi1wdWJsaWMtaW1hZ2Vz +L2ZlZG9yYS1jb3JlNC1teXNxbC12MS4wNy5tYW5pZmVzdC54bWwiEWFyY2hp +dGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIO +aW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS0yNWI2NTM0YyITcm9v +dERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMi +C2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iPWVjMi1w +dWJsaWMtaW1hZ2VzL2ZlZG9yYS1jb3JlNC1hcGFjaGUtbXlzcWwubWFuaWZl +c3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2 +MDI5NjIxNTMyew8iDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VN +YXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhbWkt +MjZiNjUzNGYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIjNlYzItcHVibGljLWltYWdlcy9kZXZlbG9wZXItaW1hZ2UubWFu +aWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIR +MjA2MDI5NjIxNTMyexEiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZp +Y2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktYTUxY2Y5Y2MiD2ltYWdlU3Rh +dGUiDmF2YWlsYWJsZSINa2VybmVsSWQiEWFraS1hNzFjZjljZSIMaW1hZ2VJ +ZCIRYW1pLTI3ZTcwMDRlIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJGL2F3cy1jb25zb2xlLXF1aWNrc3RhcnQtYW1pcy9w +ZXJsLzEuMi9wZXJscXVpY2tzdGFydC5tYW5pZmVzdC54bWwiEWFyY2hpdGVj +dHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3MTZ7ESIOaW1h +Z2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNr +SWQiEWFyaS1iMzFjZjlkYSIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJu +ZWxJZCIRYWtpLWI1MWNmOWRjIgxpbWFnZUlkIhFhbWktMmE1ZmJhNDMiE3Jv +b3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFz +IgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIj5lYzIt +cHVibGljLWltYWdlcy9mZWRvcmEtOC14ODZfNjQtYmFzZS12MS4wNy5tYW5p +ZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQi +ETIwNjAyOTYyMTUzMnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2 +aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2UiDGltYWdl +SWQiEWFtaS0yYjVmYmE0MiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0 +b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUi +EmltYWdlTG9jYXRpb24iPGVjMi1wdWJsaWMtaW1hZ2VzL2ZlZG9yYS04LWkz +ODYtYmFzZS12MS4wNy5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4 +NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIOaW1hZ2VUeXBlIgxt +YWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUi +DUE3OUVDMERCIgxpbWFnZUlkIhFhbWktMmM1ZmJhNDUiE3Jvb3REZXZpY2VU +eXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24i +DWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIjdlYzItcHVibGljLWlt +YWdlcy9kZW1vLXBhaWQtQU1JLXYxLjA3Lm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsRIg5p +bWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRp +c2tJZCIRYXJpLWRiYzEyMWIyIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDWtl +cm5lbElkIhFha2ktZjVjMTIxOWMiDGltYWdlSWQiEWFtaS0yY2IwNTM0NSIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iQGF3 +cy1jb25zb2xlLXF1aWNrc3RhcnQtYW1pcy9waHBxdWlja3N0YXJ0LXYxLjUu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJ +ZCIRMjA1NjA1ODE5NzE2exEiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tE +ZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktYTIzYWRmY2IiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSINa2VybmVsSWQiEWFraS1hNTNhZGZjYyIMaW1h +Z2VJZCIRYW1pLTJkNWZiYTQ0IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Ut +c3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1 +ZSISaW1hZ2VMb2NhdGlvbiJDZWMyLXB1YmxpYy1pbWFnZXMvZmVkb3JhLWNv +cmUtNi14ODZfNjQtYmFzZS12MS4wNy5tYW5pZmVzdC54bWwiEWFyY2hpdGVj +dHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsPIg5p +bWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLTJlNWZiYTQ3IhNyb290 +RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyIL +YW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiI9ZWMyLXB1 +YmxpYy1pbWFnZXMvZmVkb3JhLWNvcmU0LWFwYWNoZS12MS4wNy5tYW5pZmVz +dC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYw +Mjk2MjE1MzJ7ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1h +cHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1kYmMxMjFiMiIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLWY1YzEyMTljIgxpbWFnZUlkIhFh +bWktMmViMDUzNDciE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIU +aW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFn +ZUxvY2F0aW9uIklhd3MtY29uc29sZS1xdWlja3N0YXJ0LWFtaXMvdG9tY2F0 +LzEuMi90b21jYXRxdWlja3N0YXJ0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0 +dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNTYwNTgxOTcxNnsPIg5pbWFn +ZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3Rh +dGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLTJmNWZiYTQ2IhNyb290RGV2 +aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1h +em9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiI+ZWMyLXB1Ymxp +Yy1pbWFnZXMvZGV2ZWxvcGVyLWltYWdlLWkzODYtdjEuMDcubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5 +NjIxNTMyexIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBw +aW5nMCIOcmFtZGlza0lkIhFhcmktMjFkMzMwNDgiD2ltYWdlU3RhdGUiDmF2 +YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29k +ZSINNTc4QkY1QkEiDWtlcm5lbElkIhFha2ktMmRkMzMwNDQiDGltYWdlSWQi +EWFtaS0zNWQzMzA1YyITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3Jl +IhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmlt +YWdlTG9jYXRpb24iSGVjMi1wYWlkLWlibS1pbWFnZXMvaWJtLWxvdHVzLWZv +cm1zLXR1cmJvLTMuNS4xLTMyLWJpdC5tYW5pZmVzdC54bWwiEWFyY2hpdGVj +dHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1h +Z2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS0zNmZmMWE1ZiITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iPGVjMi1wdWJs +aWMtaW1hZ2VzL2ZlZG9yYS1jb3JlNi1iYXNlLXg4Nl82NC5tYW5pZmVzdC54 +bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETIwNjAy +OTYyMTUzMnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFw +cGluZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2UiDGltYWdlSWQiEWFt +aS0zYzQ3YTM1NSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRp +bWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdl +TG9jYXRpb24iM2VjMi1wdWJsaWMtaW1hZ2VzL2dldHRpbmctc3RhcnRlZC5t +YW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklk +IhEyMDYwMjk2MjE1MzJ7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0Rl +dmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1kZDRiYWNiNCIPaW1hZ2VT +dGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHBy +b2R1Y3RDb2RlIg1BOTQwOEI0QiINa2VybmVsSWQiEWFraS1kYjRiYWNiMiIM +aW1hZ2VJZCIRYW1pLTQzNGFhZDJhIhNyb290RGV2aWNlVHlwZSITaW5zdGFu +Y2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJ +dHJ1ZSISaW1hZ2VMb2NhdGlvbiJWZWMyLXBhaWQtaWJtLWltYWdlcy9pbmZv +cm1peC1keW5hbWljLXNlcnZlci13b3JrZ3JvdXAtZWRpdGlvbi02NC1iaXQu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9j +a0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1hNTFjZjljYyIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLWE3MWNmOWNlIgxp +bWFnZUlkIhFhbWktNDVlNzAwMmMiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5j +ZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0 +cnVlIhJpbWFnZUxvY2F0aW9uIkovYXdzLWNvbnNvbGUtcXVpY2tzdGFydC1h +bWlzL3RvbWNhdC8xLjEvdG9tY2F0cXVpY2tzdGFydC5tYW5pZmVzdC54bWwi +EWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3 +MTZ7ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcw +Ig5yYW1kaXNrSWQiEWFyaS00MmI5NWEyYiIPaW1hZ2VTdGF0ZSIOYXZhaWxh +YmxlIg1rZXJuZWxJZCIRYWtpLTZlYWE0OTA3IgxpbWFnZUlkIhFhbWktNDhh +YTQ5MjEiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VP +d25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0 +aW9uIjxlYzItcHVibGljLWltYWdlcy9mZWRvcmEtOC1pMzg2LWJhc2UtdjEu +MTAubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3du +ZXJJZCIRMjA2MDI5NjIxNTMyexIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxv +Y2tEZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktNzY0OGFmMWYiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsG +IhBwcm9kdWN0Q29kZSINRUE1RjA1QTMiDWtlcm5lbElkIhFha2ktODU0OWFl +ZWMiDGltYWdlSWQiEWFtaS00YzQ4YWYyNSITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iOmVjMi1wYWlkLWlibS1pbWFnZXMv +ZGIyLXdvcmtncm91cC02NC1iaXQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1 +cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7EiIOaW1h +Z2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNr +SWQiEWFyaS03NzQ4YWYxZSIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9k +dWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg1BNDgxODk1RCIN +a2VybmVsSWQiEWFraS04MTQ5YWVlOCIMaW1hZ2VJZCIRYW1pLTRkNDhhZjI0 +IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJB +bGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiI4 +ZWMyLXBhaWQtaWJtLWltYWdlcy9kYjItZXhwcmVzcy0zMi1iaXQubWFuaWZl +c3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcw +MjU0NTM0MDI0exIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VN +YXBwaW5nMCIOcmFtZGlza0lkIhFhcmktODEzZmRlZTgiD2ltYWdlU3RhdGUi +DmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0 +Q29kZSINNTc4QkY1QkEiDWtlcm5lbElkIhFha2ktOGIzZmRlZTIiDGltYWdl +SWQiEWFtaS00ZDRmYWUyNCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0 +b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUi +EmltYWdlTG9jYXRpb24iPmVjMi1wYWlkLWlibS1pbWFnZXMvbG90dXMtZm9y +bXMtdHVyYm8tMzItYml0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglp +Mzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsSIg5pbWFnZVR5cGUi +DG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJp +LTZjNDhhODA1Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rl +c3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDTQ5Q0E3MzA1Ig1rZXJuZWxJ +ZCIRYWtpLTY4NDhhODAxIgxpbWFnZUlkIhFhbWktNTA0OGE4MzkiE3Jvb3RE +ZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgth +bWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkdlYzItcGFp +ZC1pYm0taW1hZ2VzL2libS10aXZvbGktaXRtLTA2LjIxLjAzLjAwLTMyYi01 +MC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9j +a0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS02NDQ4YTgwZCIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYi +EHByb2R1Y3RDb2RlIg1DQ0VCMzY4QiINa2VybmVsSWQiEWFraS03YzQ4YTgx +NSIMaW1hZ2VJZCIRYW1pLTUyNDhhODNiIhNyb290RGV2aWNlVHlwZSITaW5z +dGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1Ymxp +YyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQtaWJtLWltYWdlcy9p +Ym0tdGl2b2xpLWl0bS0wNi4yMS4wMy4wMC0zMmItMjAwLm1hbmlmZXN0Lnht +bCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGlu +ZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2UiDGltYWdlSWQiEWFtaS01 +NjQ3YTMzZiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFn +ZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9j +YXRpb24iPGVjMi1wdWJsaWMtaW1hZ2VzL2ZlZG9yYS04LWkzODYtYmFzZS12 +MS4wOC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VP +d25lcklkIhEyMDYwMjk2MjE1MzJ7ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdi +bG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1hNTFjZjljYyIP +aW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLWE3MWNmOWNl +IgxpbWFnZUlkIhFhbWktNWVlNzAwMzciE3Jvb3REZXZpY2VUeXBlIhNpbnN0 +YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGlj +Igl0cnVlIhJpbWFnZUxvY2F0aW9uIkYvYXdzLWNvbnNvbGUtcXVpY2tzdGFy +dC1hbWlzL3J1YnkvMS4xL3J1YnlxdWlja3N0YXJ0Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNTYwNTgxOTcx +NnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAi +DnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9pbWFnZVN0YXRlIg5hdmFpbGFi +bGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2UiDGltYWdlSWQiEWFtaS02MGRh +M2QwOSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iQS9hd3MtY29uc29sZS1xdWlja3N0YXJ0LWFtaXMvcGhwcXVpY2tzdGFy +dC12MS40Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETIwNTYwNTgxOTcxNnsSIg5pbWFnZVR5cGUiDG1hY2hpbmUi +F2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLTlhNzA5MGYz +Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVt +WwZ7BiIQcHJvZHVjdENvZGUiDUUzRDQ4Q0VFIg1rZXJuZWxJZCIRYWtpLTg2 +NzA5MGVmIgxpbWFnZUlkIhFhbWktNjY3MTkxMGYiE3Jvb3REZXZpY2VUeXBl +IhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlz +UHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIlFlYzItcGFpZC1pYm0taW1h +Z2VzL3dlYnNwaGVyZS1hcHBsaWNhdGlvbi1zZXJ2ZXItNy4wLjAuMy0zMi1i +aXQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3du +ZXJJZCIRNDcwMjU0NTM0MDI0exIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxv +Y2tEZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktNjE3Nzk0MDgiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsG +IhBwcm9kdWN0Q29kZSINRDZGQjExMTMiDWtlcm5lbElkIhFha2ktNmY3Nzk0 +MDYiDGltYWdlSWQiEWFtaS02Nzc2OTUwZSITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iRGVjMi1wYWlkLWlibS1pbWFnZXMv +d2Vic3BoZXJlLXNtYXNoLTEuMS4xLjEtMzItYml0Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAy +NHsSIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAi +DnJhbWRpc2tJZCIRYXJpLTQ4NDhhZjIxIg9pbWFnZVN0YXRlIg5hdmFpbGFi +bGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDThG +Q0UzRUVCIg1rZXJuZWxJZCIRYWtpLTgyNDlhZWViIgxpbWFnZUlkIhFhbWkt +NmM1NWIyMDUiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIlplYzItcGFpZC1pYm0taW1hZ2VzL2xvdHVzLXdlYi1jb250ZW50 +LW1hbmFnZW1lbnQtc3RhbmRhcmQtZWRpdGlvbi02NC1iaXQubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAy +NTQ1MzQwMjR7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1h +cHBpbmcwIg5yYW1kaXNrSWQiEWFyaS00OTQ4YWYyMCIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RD +b2RlIg00NzZEMjlDQiINa2VybmVsSWQiEWFraS04MzQ5YWVlYSIMaW1hZ2VJ +ZCIRYW1pLTZmNTViMjA2IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJvZWMyLXBhaWQtaWJtLWltYWdlcy93ZWJzcGhlcmUt +cG9ydGFsLWFuZC1sb3R1cy13ZWItY29udGVudC1tYW5hZ2VtZW50LXN0YW5k +YXJkLWVkaXRpb24tNjQtYml0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJl +Igt4ODZfNjQiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exMiDmltYWdl +VHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lk +IhFhcmktNjQ1MWIzMGQiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVj +dENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRDZGNjA1MkEiDWtl +cm5lbElkIhFha2ktNjA1MWIzMDkiDGltYWdlSWQiEWFtaS03NDUxYjMxZCIT +cm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iRWVjMi1wYWlkLWlibS1pbWFnZXMt +aWRzL2libS1pZHMtZXhwcmVzcy0xMS41LXYyMDItMS5tYW5pZmVzdC54bWwi +EWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQw +MjR7EyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcw +Ig5yYW1kaXNrSWQiEWFyaS04OGU2MGJlMSIPaW1hZ2VTdGF0ZSIOYXZhaWxh +YmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg1B +NDgxODk1RCINa2VybmVsSWQiEWFraS1iY2U2MGJkNSIMaW1hZ2VJZCIRYW1p +LTc0ZTAwZDFkIhNyb290RGV2aWNlTmFtZSIOL2Rldi9zZGExIhNyb290RGV2 +aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1h +em9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQt +aWJtLWltYWdlcy1kYjIvaWJtLWRiMi1leHByZXNzLTkuNy5GUDEtMzItYml0 +Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVy +SWQiETQ3MDI1NDUzNDAyNHsUIgluYW1lIhxmZWRvcmEtOC1pMzg2LXYxLjE0 +LXN0ZCIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmd7 +BiIJaXRlbVsGewciCGVic3sIIg9zbmFwc2hvdElkIhJzbmFwLWI5YWEzNWQw +IhhkZWxldGVPblRlcm1pbmF0aW9uIgl0cnVlIg92b2x1bWVTaXplIgcxNSIP +ZGV2aWNlTmFtZSIOL2Rldi9zZGExIg5yYW1kaXNrSWQiEWFyaS05NmM1Mjdm +ZiIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLTk0YzUy +N2ZkIgxpbWFnZUlkIhFhbWktODRkYjM5ZWQiE3Jvb3REZXZpY2VOYW1lIg4v +ZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBlIghlYnMiEGRlc2NyaXB0aW9uIjZG +ZWRvcmEgOCB2MS4xNCBpMzg2IHN0ZC1yb290IGx2bS1zd2FwIGx2bS1zdG9y +YWdlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUi +EmltYWdlTG9jYXRpb24iI2FtYXpvbi9mZWRvcmEtOC1pMzg2LXYxLjE0LXN0 +ZCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYy +MTUzMnsUIgluYW1lIh5mZWRvcmEtOC14ODZfNjQtdjEuMTQtc3RkIg5pbWFn +ZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZ3sGIglpdGVtWwZ7 +ByIIZWJzewgiD3NuYXBzaG90SWQiEnNuYXAtYmJhYTM1ZDIiGGRlbGV0ZU9u +VGVybWluYXRpb24iCXRydWUiD3ZvbHVtZVNpemUiBzE1Ig9kZXZpY2VOYW1l +Ig4vZGV2L3NkYTEiDnJhbWRpc2tJZCIRYXJpLTU2Y2UyYzNmIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktNTRjZTJjM2QiDGltYWdl +SWQiEWFtaS04NmRiMzllZiITcm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSIT +cm9vdERldmljZVR5cGUiCGVicyIQZGVzY3JpcHRpb24iOEZlZG9yYSA4IHYx +LjE0IHg4Nl82NCBzdGQtcm9vdCBsdm0tc3dhcCBsdm0tc3RvcmFnZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIiVhbWF6b24vZmVkb3JhLTgteDg2XzY0LXYxLjE0LXN0ZCIRYXJj +aGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMy +exMiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBwaW5nMCIO +cmFtZGlza0lkIhFhcmktMzIzOGRhNWIiD2ltYWdlU3RhdGUiDmF2YWlsYWJs +ZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINN0E2 +M0Y5RkMiDWtlcm5lbElkIhFha2ktMzAzOGRhNTkiDGltYWdlSWQiEWFtaS1h +MDQ2YTRjOSITcm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSITcm9vdERldmlj +ZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpv +biINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iQGVjMi1wYWlkLWli +bS1pbWFnZXMvZXh0cmVtZXNjYWxlLTcwLTMyYml0LW5vaWQubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0 +NTM0MDI0exEiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBw +aW5nMCIOcmFtZGlza0lkIhFhcmktYTIzYWRmY2IiD2ltYWdlU3RhdGUiDmF2 +YWlsYWJsZSINa2VybmVsSWQiEWFraS1hNTNhZGZjYyIMaW1hZ2VJZCIRYW1p +LWEyMWFmZmNiIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJDZWMyLXB1YmxpYy1pbWFnZXMvZmVkb3JhLWNvcmUtNi14ODZf +NjQtYmFzZS12MS4wNi5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2 +XzY0IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsSIg5pbWFnZVR5cGUi +DG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJp +LTZkZWMwYzA0Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rl +c3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUVBNUYwNUEzIg1rZXJuZWxJ +ZCIRYWtpLTZiZWMwYzAyIgxpbWFnZUlkIhFhbWktYTIxY2ZjY2IiE3Jvb3RE +ZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgth +bWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIj5lYzItcGFp +ZC1pYm0taW1hZ2VzL2RiMi13b3JrZ3JvdXAtOS43LTY0LWJpdC5tYW5pZmVz +dC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3 +MDI1NDUzNDAyNHsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNl +TWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVz +ewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRUMxMjk3MDgiDGltYWdlSWQi +EWFtaS1hOGU3MDVjMSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3Jl +IhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmlt +YWdlTG9jYXRpb24iQWVjMi1wYWlkLWlibS1pbWFnZXMvaWJtLWluZm9zcGhl +cmUtaXMtd2luY2xpZW50Lm1hbmlmZXN0LnhtbCINcGxhdGZvcm0iDHdpbmRv +d3MiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1 +MzQwMjR7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBp +bmcwIg5yYW1kaXNrSWQiEWFyaS05MWViMGJmOCIPaW1hZ2VTdGF0ZSIOYXZh +aWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2Rl +Ig1BNDgxODk1RCINa2VybmVsSWQiEWFraS05ZmViMGJmNiIMaW1hZ2VJZCIR +YW1pLWFjMWNmY2M1IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUi +FGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1h +Z2VMb2NhdGlvbiI8ZWMyLXBhaWQtaWJtLWltYWdlcy9kYjItZXhwcmVzcy05 +LjctMzItYml0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFp +bWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsUIgluYW1lIiJnZXR0aW5nLXN0 +YXJ0ZWQtd2l0aC1lYnMtYm9vdCIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9j +a0RldmljZU1hcHBpbmd7BiIJaXRlbVsGewciCGVic3sIIg9zbmFwc2hvdElk +IhJzbmFwLWEwODkxMmM5IhhkZWxldGVPblRlcm1pbmF0aW9uIgl0cnVlIg92 +b2x1bWVTaXplIgcxNSIPZGV2aWNlTmFtZSIOL2Rldi9zZGExIg5yYW1kaXNr +SWQiEWFyaS05NmM1MjdmZiIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJu +ZWxJZCIRYWtpLTk0YzUyN2ZkIgxpbWFnZUlkIhFhbWktYjIzMmQwZGIiE3Jv +b3REZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBlIghlYnMi +EGRlc2NyaXB0aW9uIkxGZWRvcmEgOCB2MS4xNCBpMzg2IHN0ZC1yb290IGx2 +bS1zd2FwIGx2bS1zdG9yYWdlIGdldHRpbmctc3RhcnRlZC1ndWlkZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIilhbWF6b24vZ2V0dGluZy1zdGFydGVkLXdpdGgtZWJzLWJvb3Qi +EWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1 +MzJ7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcw +Ig5yYW1kaXNrSWQiEWFyaS03NDQ4YWYxZCIPaW1hZ2VTdGF0ZSIOYXZhaWxh +YmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg1E +NkZCMTExMyINa2VybmVsSWQiEWFraS04MDQ5YWVlOSIMaW1hZ2VJZCIRYW1p +LWI0NTRiM2RkIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiI8ZWMyLXBhaWQtaWJtLWltYWdlcy93ZWJzcGhlcmUtc21hc2gt +MzItYml0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDG1hY2hpbmUi +F2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIR +cHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINQTc5RUMw +REIiDGltYWdlSWQiEWFtaS1iZDlkNzhkNCITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iMWVjMi1wdWJsaWMtaW1hZ2VzL2Rl +bW8tcGFpZC1BTUkubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYi +EWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyexMiCW5hbWUiJldpbmRvd3Mt +U2VydmVyMjAwOC1pMzg2LUJhc2UtdjEwMyIOaW1hZ2VUeXBlIgxtYWNoaW5l +IhdibG9ja0RldmljZU1hcHBpbmd7BiIJaXRlbVsGewciCGVic3sIIg9zbmFw +c2hvdElkIhJzbmFwLTRjOWMyNzI0IhhkZWxldGVPblRlcm1pbmF0aW9uIgl0 +cnVlIg92b2x1bWVTaXplIgczMCIPZGV2aWNlTmFtZSIOL2Rldi9zZGExIg9p +bWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS1jM2U0MGRhYSIT +cm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSITcm9vdERldmljZVR5cGUiCGVi +cyIQZGVzY3JpcHRpb24iN01pY3Jvc29mdCBXaW5kb3dzIDIwMDggRGF0YWNl +bnRlciAzMi1iaXQgQU1JIHYxLjAzIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpv +biINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iLWFtYXpvbi9XaW5k +b3dzLVNlcnZlcjIwMDgtaTM4Ni1CYXNlLXYxMDMiDXBsYXRmb3JtIgx3aW5k +b3dzIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5 +NjIxNTMyexMiCW5hbWUiLFdpbmRvd3MtU2VydmVyMjAwOC1pMzg2LVNxbEV4 +cHJlc3MtdjEwMyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1h +cHBpbmd7BiIJaXRlbVsGewciCGVic3sIIg9zbmFwc2hvdElkIhJzbmFwLTVj +OWMyNzM0IhhkZWxldGVPblRlcm1pbmF0aW9uIgl0cnVlIg92b2x1bWVTaXpl +IgczMCIPZGV2aWNlTmFtZSIOL2Rldi9zZGExIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiDGltYWdlSWQiEWFtaS1jNWU0MGRhYyITcm9vdERldmljZU5hbWUi +Di9kZXYvc2RhMSITcm9vdERldmljZVR5cGUiCGVicyIQZGVzY3JpcHRpb24i +RU1pY3Jvc29mdCBXaW5kb3dzIDIwMDggRGF0YWNlbnRlciAzMi1iaXQsIFNx +bCBFeHByZXNzLCBBTUkgdjEuMDMiFGltYWdlT3duZXJBbGlhcyILYW1hem9u +Ig1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiIzYW1hem9uL1dpbmRv +d3MtU2VydmVyMjAwOC1pMzg2LVNxbEV4cHJlc3MtdjEwMyINcGxhdGZvcm0i +DHdpbmRvd3MiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEy +MDYwMjk2MjE1MzJ7EyIJbmFtZSIxV2luZG93cy1TZXJ2ZXIyMDAzUjIteDg2 +XzY0LVNxbFN0YW5kYXJkLXYxMDkiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxv +Y2tEZXZpY2VNYXBwaW5newYiCWl0ZW1bBnsHIghlYnN7CCIPc25hcHNob3RJ +ZCISc25hcC00ZDVmNDkyNCIYZGVsZXRlT25UZXJtaW5hdGlvbiIJdHJ1ZSIP +dm9sdW1lU2l6ZSIHMzAiD2RldmljZU5hbWUiDi9kZXYvc2RhMSIPaW1hZ2VT +dGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhbWktYzkxZmYwYTAiE3Jvb3RE +ZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBlIghlYnMiEGRl +c2NyaXB0aW9uIktNaWNyb3NvZnQgV2luZG93cyAyMDAzIFIyIDY0LWJpdCwg +U3FsIDIwMDUgU3RhbmRhcmQsIEFNSSBSZWxlYXNlIHYxLjA5IhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iOGFtYXpvbi9XaW5kb3dzLVNlcnZlcjIwMDNSMi14ODZfNjQtU3FsU3Rh +bmRhcmQtdjEwOSINcGxhdGZvcm0iDHdpbmRvd3MiEWFyY2hpdGVjdHVyZSIL +eDg2XzY0IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsTIg5pbWFnZVR5 +cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIR +YXJpLWZjZmQxMDk1Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RD +b2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUVBNUYwNUEzIg1rZXJu +ZWxJZCIRYWtpLWY4ZmQxMDkxIgxpbWFnZUlkIhFhbWktY2VmZDEwYTciE3Jv +b3REZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBlIhNpbnN0 +YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGlj +Igl0cnVlIhJpbWFnZUxvY2F0aW9uIkplYzItcGFpZC1pYm0taW1hZ2VzLWRi +Mi9pYm0tZGIyLXdvcmtncm91cC05LjcuRlAxLTY0LWJpdC5tYW5pZmVzdC54 +bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1 +NDUzNDAyNHsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFw +cGluZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2UiDGltYWdlSWQiEWFt +aS1kMWNhMmRiOCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRp +bWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdl +TG9jYXRpb24iQGF3cy10b29sa2l0LWZvci1lY2xpcHNlLWFtaXMtdXMvaGFw +cm94eS12MS4wLjIubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYi +EWltYWdlT3duZXJJZCIRMjA1NjA1ODE5NzE2exAiDmltYWdlVHlwZSIMbWFj +aGluZSIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxh +YmxlIgxpbWFnZUlkIhFhbWktZDkyMGMzYjAiE3Jvb3REZXZpY2VUeXBlIhNp +bnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVi +bGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkxlYzItcHVibGljLXdpbmRvd3Mt +aW1hZ2VzL1NxbFN2ckV4cDIwMDNyMi14ODZfNjQtV2luLXYxLjA3Lm1hbmlm +ZXN0LnhtbCINcGxhdGZvcm0iDHdpbmRvd3MiEWFyY2hpdGVjdHVyZSILeDg2 +XzY0IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsTIgluYW1lIihXaW5k +b3dzLVNlcnZlcjIwMDgteDg2XzY0LUJhc2UtdjEwMyIOaW1hZ2VUeXBlIgxt +YWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmd7BiIJaXRlbVsGewciCGVic3sI +Ig9zbmFwc2hvdElkIhJzbmFwLTI4OWMyNzQwIhhkZWxldGVPblRlcm1pbmF0 +aW9uIgl0cnVlIg92b2x1bWVTaXplIgczMCIPZGV2aWNlTmFtZSIOL2Rldi9z +ZGExIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS1kOWU0 +MGRiMCITcm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSITcm9vdERldmljZVR5 +cGUiCGVicyIQZGVzY3JpcHRpb24iN01pY3Jvc29mdCBXaW5kb3dzIDIwMDgg +RGF0YWNlbnRlciA2NC1iaXQgQU1JIHYxLjAzIhRpbWFnZU93bmVyQWxpYXMi +C2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iL2FtYXpv +bi9XaW5kb3dzLVNlcnZlcjIwMDgteDg2XzY0LUJhc2UtdjEwMyINcGxhdGZv +cm0iDHdpbmRvd3MiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVy +SWQiETIwNjAyOTYyMTUzMnsQIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJ +ZCIRYW1pLWRiMjBjM2IyIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJKZWMyLXB1YmxpYy13aW5kb3dzLWltYWdlcy9TcWxT +dnJFeHAyMDAzcjItaTM4Ni1XaW4tdjEuMDcubWFuaWZlc3QueG1sIg1wbGF0 +Zm9ybSIMd2luZG93cyIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVy +SWQiETIwNjAyOTYyMTUzMnsSIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLTlmM2ZkZWY2Ig9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQ +cHJvZHVjdENvZGUiDUQ2NjJFOTg5Ig1rZXJuZWxJZCIRYWtpLTliM2ZkZWYy +IgxpbWFnZUlkIhFhbWktZGI1Y2JkYjIiE3Jvb3REZXZpY2VUeXBlIhNpbnN0 +YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGlj +Igl0cnVlIhJpbWFnZUxvY2F0aW9uIkBlYzItcGFpZC1pYm0taW1hZ2VzL2xv +dHVzLW1hc2h1cC1jZW50ZXItMzItYml0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsTIglu +YW1lIi5XaW5kb3dzLVNlcnZlcjIwMDgteDg2XzY0LVNxbEV4cHJlc3MtdjEw +MyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmd7BiIJ +aXRlbVsGewciCGVic3sIIg9zbmFwc2hvdElkIhJzbmFwLTIyOWMyNzRhIhhk +ZWxldGVPblRlcm1pbmF0aW9uIgl0cnVlIg92b2x1bWVTaXplIgczMCIPZGV2 +aWNlTmFtZSIOL2Rldi9zZGExIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGlt +YWdlSWQiEWFtaS1kYmU0MGRiMiITcm9vdERldmljZU5hbWUiDi9kZXYvc2Rh +MSITcm9vdERldmljZVR5cGUiCGVicyIQZGVzY3JpcHRpb24iSU1pY3Jvc29m +dCBXaW5kb3dzIDIwMDggRGF0YWNlbnRlciA2NC1iaXQsIFNxbCAyMDA4IEV4 +cHJlc3MgQU1JIHYxLjAzIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iNWFtYXpvbi9XaW5kb3dzLVNl +cnZlcjIwMDgteDg2XzY0LVNxbEV4cHJlc3MtdjEwMyINcGxhdGZvcm0iDHdp +bmRvd3MiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETIw +NjAyOTYyMTUzMnsQIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNl +TWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1p +LWRkMjBjM2I0IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJJZWMyLXB1YmxpYy13aW5kb3dzLWltYWdlcy9TZXJ2ZXIyMDAz +cjIteDg2XzY0LVdpbi12MS4wNy5tYW5pZmVzdC54bWwiDXBsYXRmb3JtIgx3 +aW5kb3dzIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEy +MDYwMjk2MjE1MzJ7EyIJbmFtZSIvV2luZG93cy1TZXJ2ZXIyMDA4LXg4Nl82 +NC1TcWxTdGFuZGFyZC12MTAzIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2Nr +RGV2aWNlTWFwcGluZ3sGIglpdGVtWwZ7ByIIZWJzewgiD3NuYXBzaG90SWQi +EnNuYXAtMzQ5YzI3NWMiGGRlbGV0ZU9uVGVybWluYXRpb24iCXRydWUiD3Zv +bHVtZVNpemUiBzMwIg9kZXZpY2VOYW1lIg4vZGV2L3NkYTEiD2ltYWdlU3Rh +dGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLWRkZTQwZGI0IhNyb290RGV2 +aWNlTmFtZSIOL2Rldi9zZGExIhNyb290RGV2aWNlVHlwZSIIZWJzIhBkZXNj +cmlwdGlvbiJKTWljcm9zb2Z0IFdpbmRvd3MgMjAwOCBEYXRhY2VudGVyIDY0 +LWJpdCwgU3FsIDIwMDggU3RhbmRhcmQgQU1JIHYxLjAzIhRpbWFnZU93bmVy +QWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24i +NmFtYXpvbi9XaW5kb3dzLVNlcnZlcjIwMDgteDg2XzY0LVNxbFN0YW5kYXJk +LXYxMDMiDXBsYXRmb3JtIgx3aW5kb3dzIhFhcmNoaXRlY3R1cmUiC3g4Nl82 +NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIOaW1hZ2VUeXBlIgxt +YWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiDGltYWdlSWQiEWFtaS1kZjIwYzNiNiITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wdWJsaWMtd2luZG93 +cy1pbWFnZXMvU2VydmVyMjAwM3IyLWkzODYtV2luLXYxLjA3Lm1hbmlmZXN0 +LnhtbCINcGxhdGZvcm0iDHdpbmRvd3MiEWFyY2hpdGVjdHVyZSIJaTM4NiIR +aW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7EyIJbmFtZSIoV2luZG93cy1T +ZXJ2ZXIyMDAzUjItaTM4Ni1CYXNlLXYxMDkiDmltYWdlVHlwZSIMbWFjaGlu +ZSIXYmxvY2tEZXZpY2VNYXBwaW5newYiCWl0ZW1bBnsHIghlYnN7CCIPc25h +cHNob3RJZCISc25hcC03ZDVmNDkxNCIYZGVsZXRlT25UZXJtaW5hdGlvbiIJ +dHJ1ZSIPdm9sdW1lU2l6ZSIHMzAiD2RldmljZU5hbWUiDi9kZXYvc2RhMSIP +aW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhbWktZjExZmYwOTgi +E3Jvb3REZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBlIghl +YnMiEGRlc2NyaXB0aW9uIjZNaWNyb3NvZnQgV2luZG93cyAyMDAzIFIyIERh +dGFjZW50ZXIgMzItYml0IHYxLjA5IhRpbWFnZU93bmVyQWxpYXMiC2FtYXpv +biINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iL2FtYXpvbi9XaW5k +b3dzLVNlcnZlcjIwMDNSMi1pMzg2LUJhc2UtdjEwOSINcGxhdGZvcm0iDHdp +bmRvd3MiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYw +Mjk2MjE1MzJ7ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1h +cHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1iMzFjZjlkYSIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLWI1MWNmOWRjIgxpbWFnZUlkIhFh +bWktZjIxYWZmOWIiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIU +aW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFn +ZUxvY2F0aW9uIj5lYzItcHVibGljLWltYWdlcy9mZWRvcmEtOC14ODZfNjQt +YmFzZS12MS4wNi5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0 +IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsTIgluYW1lIi5XaW5kb3dz +LVNlcnZlcjIwMDNSMi1pMzg2LVNxbEV4cHJlc3MtdjEwOSIOaW1hZ2VUeXBl +IgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmd7BiIJaXRlbVsGewciCGVi +c3sIIg9zbmFwc2hvdElkIhJzbmFwLTczNWY0OTFhIhhkZWxldGVPblRlcm1p +bmF0aW9uIgl0cnVlIg92b2x1bWVTaXplIgczMCIPZGV2aWNlTmFtZSIOL2Rl +di9zZGExIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS1m +MzFmZjA5YSITcm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSITcm9vdERldmlj +ZVR5cGUiCGVicyIQZGVzY3JpcHRpb24iU01pY3Jvc29mdCBXaW5kb3dzIDIw +MDMgUjIgMzItYml0LCBJSVMgNi4wLCBTcWwgMjAwNSBFeHByZXNzLCBBTUkg +UmVsZWFzZSB2MS4wOSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVi +bGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIjVhbWF6b24vV2luZG93cy1TZXJ2 +ZXIyMDAzUjItaTM4Ni1TcWxFeHByZXNzLXYxMDkiDXBsYXRmb3JtIgx3aW5k +b3dzIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5 +NjIxNTMyexEiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBw +aW5nMCIOcmFtZGlza0lkIhFhcmktYTUxY2Y5Y2MiD2ltYWdlU3RhdGUiDmF2 +YWlsYWJsZSINa2VybmVsSWQiEWFraS1hNzFjZjljZSIMaW1hZ2VJZCIRYW1p +LWY1MWFmZjljIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiI8ZWMyLXB1YmxpYy1pbWFnZXMvZmVkb3JhLTgtaTM4Ni1iYXNl +LXYxLjA2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETIwNjAyOTYyMTUzMnsTIgluYW1lIipXaW5kb3dzLVNlcnZl +cjIwMDNSMi14ODZfNjQtQmFzZS12MTA5Ig5pbWFnZVR5cGUiDG1hY2hpbmUi +F2Jsb2NrRGV2aWNlTWFwcGluZ3sGIglpdGVtWwZ7ByIIZWJzewgiD3NuYXBz +aG90SWQiEnNuYXAtNzU1ZjQ5MWMiGGRlbGV0ZU9uVGVybWluYXRpb24iCXRy +dWUiD3ZvbHVtZVNpemUiBzMwIg9kZXZpY2VOYW1lIg4vZGV2L3NkYTEiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLWY1MWZmMDljIhNy +b290RGV2aWNlTmFtZSIOL2Rldi9zZGExIhNyb290RGV2aWNlVHlwZSIIZWJz +IhBkZXNjcmlwdGlvbiI2TWljcm9zb2Z0IFdpbmRvd3MgMjAwMyBSMiBEYXRh +Y2VudGVyIDY0LWJpdCB2MS4wOSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24i +DWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIjFhbWF6b24vV2luZG93 +cy1TZXJ2ZXIyMDAzUjIteDg2XzY0LUJhc2UtdjEwOSINcGxhdGZvcm0iDHdp +bmRvd3MiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETIw +NjAyOTYyMTUzMnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNl +TWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLTdjYjk1YTE1Ig9pbWFnZVN0YXRl +Ig5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTNkNzM3Y2EiDGltYWdlSWQi +EWFtaS1mNjFkZmQ5ZiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3Jl +IhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmlt +YWdlTG9jYXRpb24iPmVjMi1wdWJsaWMtaW1hZ2VzL2ZlZG9yYS04LXg4Nl82 +NC1iYXNlLXYxLjEwLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIgt4ODZf +NjQiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyexMiCW5hbWUiMFdpbmRv +d3MtU2VydmVyMjAwM1IyLXg4Nl82NC1TcWxFeHByZXNzLXYxMDkiDmltYWdl +VHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBwaW5newYiCWl0ZW1bBnsH +IghlYnN7CCIPc25hcHNob3RJZCISc25hcC00OTVmNDkyMCIYZGVsZXRlT25U +ZXJtaW5hdGlvbiIJdHJ1ZSIPdm9sdW1lU2l6ZSIHMzAiD2RldmljZU5hbWUi +Di9kZXYvc2RhMSIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFh +bWktZjcxZmYwOWUiE3Jvb3REZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3RE +ZXZpY2VUeXBlIghlYnMiEGRlc2NyaXB0aW9uIlNNaWNyb3NvZnQgV2luZG93 +cyAyMDAzIFIyIDY0LWJpdCwgSUlTIDYuMCwgU3FsIDIwMDUgRXhwcmVzcywg +QU1JIFJlbGVhc2UgdjEuMDkiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1p +c1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiI3YW1hem9uL1dpbmRvd3Mt +U2VydmVyMjAwM1IyLXg4Nl82NC1TcWxFeHByZXNzLXYxMDkiDXBsYXRmb3Jt +Igx3aW5kb3dzIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklk +IhEyMDYwMjk2MjE1MzJ7EyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0Rl +dmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1mNDU4YmE5ZCIPaW1hZ2VT +dGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHBy +b2R1Y3RDb2RlIg0yMUU5RUJDOSINa2VybmVsSWQiEWFraS1mODU4YmE5MSIM +aW1hZ2VJZCIRYW1pLWY4YWQ0MDkxIhNyb290RGV2aWNlTmFtZSIOL2Rldi9z +ZGExIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3du +ZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlv +biJjZWMyLXBhaWQtaWJtLWltYWdlcy1pbmZvc3BoZXJlL2libS1pbmZvc3Bo +ZXJlLWRhdGFzdGFnZS1xdWFsaXR5c3RhZ2Utc2VydmVyLTY0Yml0Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIR +NDcwMjU0NTM0MDI0exIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZp +Y2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktZmFmMDEyOTMiD2ltYWdlU3Rh +dGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9k +dWN0Q29kZSINRDY2MkU5ODkiDWtlcm5lbElkIhFha2ktZjhmMDEyOTEiDGlt +YWdlSWQiEWFtaS1mZWYwMTI5NyITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iQmVjMi1wYWlkLWlibS1pbWFnZXMvaWJtLW1h +c2h1cC1jZW50ZXItMi4wLTMyLWJpdC5tYW5pZmVzdC54bWwiEWFyY2hpdGVj +dHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1h +Z2VUeXBlIgxyYW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFyaS0wMjRhYTg2YiITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iRmVjMi1wYWlk +LWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjMwLXhlbi54ODZfNjQu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgxyYW1kaXNrIhdibG9j +a0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1 +Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUE5NDA4QjRCIgxp +bWFnZUlkIhFhcmktMGM1MWIzNjUiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5j +ZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0 +cnVlIhJpbWFnZUxvY2F0aW9uIkplYzItcGFpZC1pYm0taW1hZ2VzLWlkcy9p +bml0cmQtMi42LjE2LjYwLTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwi +EWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGlu +ZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0 +ZW1bBnsGIhBwcm9kdWN0Q29kZSINNTc4QkY1QkEiDGltYWdlSWQiEWFyaS0y +MWQzMzA0OCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFn +ZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9j +YXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0w +LjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglp +Mzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIgluYW1lIjZpbml0 +cmQtMi42LjE4LXhlblUtZWMyLXYxLjQuaTY4Ni5hcmkubWFuaWZlc3QueG1s +Ig5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJpLTIyNDJhMDRiIhNy +b290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlh +cyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMy +LXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4xOC14ZW5VLWVjMi12MS40Lmk2 +ODYuYXJpLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETIwNjAyOTYyMTUzMnsQIgluYW1lIjhpbml0cmQtMi42LjE4 +LXhlblUtZWMyLXYxLjQueDg2XzY0LmFyaS5tYW5pZmVzdC54bWwiDmltYWdl +VHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0 +ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhcmktMmM0MmEwNDUiE3Jvb3REZXZp +Y2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6 +b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkplYzItcHVibGlj +LWltYWdlcy9pbml0cmQtMi42LjE4LXhlblUtZWMyLXYxLjQueDg2XzY0LmFy +aS5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93 +bmVySWQiETIwNjAyOTYyMTUzMnsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Js +b2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1h +Z2VJZCIRYXJpLTMyMzhkYTViIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Ut +c3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1 +ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBhaWQtaWJtLWltYWdlcy9pbml0cmQt +Mi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNo +aXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0ew8i +DmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhcmktNDJiOTVhMmIiE3Jv +b3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFz +IgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIlBlYzIt +cHVibGljLWltYWdlcy9pbml0cmQtMi42LjIxLjctMi5mYzh4ZW4tZWMyLXYx +LjAuMS5pMzg2LmFyaS5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4 +NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIOaW1hZ2VUeXBlIgxy +YW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUi +DThGQ0UzRUVCIgxpbWFnZUlkIhFhcmktNDg0OGFmMjEiE3Jvb3REZXZpY2VU +eXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24i +DWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkZlYzItcGFpZC1pYm0t +aW1hZ2VzL2luaXRyZC0yLjYuMTYuNjAtMC4zMC14ZW4ueDg2XzY0Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIR +NDcwMjU0NTM0MDI0exAiDmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZp +Y2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29k +ZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg00NzZEMjlDQiIMaW1hZ2VJ +ZCIRYXJpLTQ5NDhhZjIwIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJGZWMyLXBhaWQtaWJtLWltYWdlcy9pbml0cmQtMi42 +LjE2LjYwLTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwiEWFyY2hpdGVj +dHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsPIg5p +bWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJpLTRmNThiOTI2IhNyb290 +RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyIL +YW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBh +aWQtaWJtLWltYWdlcy9pbml0cmQtMi42LjE2LjYwLTAuMjkteGVucGFlLmkz +ODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3du +ZXJJZCIRNDcwMjU0NTM0MDI0ew8iDmltYWdlVHlwZSIMcmFtZGlzayIXYmxv +Y2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFn +ZUlkIhFhcmktNGZkZjNmMjYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1z +dG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVl +IhJpbWFnZUxvY2F0aW9uIlBlYzItcHVibGljLWltYWdlcy9pbml0cmQtMi42 +LjIxLjctMi5mYzh4ZW4tZWMyLXYxLjAueDg2XzY0LmFyaS5tYW5pZmVzdC54 +bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETIwNjAy +OTYyMTUzMnsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFw +cGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJpLTU2 +Y2UyYzNmIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdl +T3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2Nh +dGlvbiJQZWMyLXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4yMS43LTIuZWMy +LnYxLjIuZmM4eGVuLng4Nl82NC5hcmkubWFuaWZlc3QueG1sIhFhcmNoaXRl +Y3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIO +aW1hZ2VUeXBlIgxyYW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFyaS02MDRhYTgwOSITcm9v +dERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMi +C2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1w +YWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5p +Mzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93 +bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Js +b2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJv +ZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRDZGQjExMTMi +DGltYWdlSWQiEWFyaS02MTc3OTQwOCITcm9vdERldmljZVR5cGUiE2luc3Rh +bmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMi +CXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMvaW5p +dHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAy +NHsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAi +D2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1b +BnsGIhBwcm9kdWN0Q29kZSINQ0NFQjM2OEIiDGltYWdlSWQiEWFyaS02NDQ4 +YTgwZCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iR2VjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5 +LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2 +IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDHJh +bWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWls +YWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSIN +RDZGNjA1MkEiDGltYWdlSWQiEWFyaS02NDUxYjMwZCITcm9vdERldmljZVR5 +cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiIN +aXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1p +bWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3 +MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNl +TWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJp +LTY0Yjk1ZTBkIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJKZWMyLXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4xOC14ZW5V +LWVjMi12MS4wLng4Nl82NC5hcmkubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1 +cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIOaW1h +Z2VUeXBlIgxyYW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFyaS02NTkxNzEwYyITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlk +LWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2 +Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVy +SWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVj +dENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINODBFRDAwQjgiDGlt +YWdlSWQiEWFyaS02NjQ4YTgwZiITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJk +LTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJj +aGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsP +Ig5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJpLTY3Yjk1ZTBlIhNy +b290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlh +cyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMy +LXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4xOC14ZW5VLWVjMi12MS4wLmkz +ODYuYXJpLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETIwNjAyOTYyMTUzMnsQIg5pbWFnZVR5cGUiDHJhbWRpc2si +F2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIR +cHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINNDlDQTcz +MDUiDGltYWdlSWQiEWFyaS02YzQ4YTgwNSITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMv +aW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0Lnht +bCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGlu +ZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0 +ZW1bBnsGIhBwcm9kdWN0Q29kZSINRUE1RjA1QTMiDGltYWdlSWQiEWFyaS02 +ZGVjMGMwNCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFn +ZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9j +YXRpb24iRmVjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0w +LjMwLXhlbi54ODZfNjQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4 +Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBl +IgxyYW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENv +ZGUiDUQ2RkIxMTEzIgxpbWFnZUlkIhFhcmktNzQ0OGFmMWQiE3Jvb3REZXZp +Y2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6 +b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkdlYzItcGFpZC1p +Ym0taW1hZ2VzL2luaXRyZC0yLjYuMTYuNjAtMC4yOS14ZW5wYWUuaTM4Ni5t +YW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklk +IhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgxyYW1kaXNrIhdibG9ja0Rl +dmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RD +b2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUVBNUYwNUEzIgxpbWFn +ZUlkIhFhcmktNzY0OGFmMWYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1z +dG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVl +IhJpbWFnZUxvY2F0aW9uIkZlYzItcGFpZC1pYm0taW1hZ2VzL2luaXRyZC0y +LjYuMTYuNjAtMC4zMC14ZW4ueDg2XzY0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAi +DmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYi +EHByb2R1Y3RDb2RlIg1BNDgxODk1RCIMaW1hZ2VJZCIRYXJpLTc3NDhhZjFl +IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJB +bGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJH +ZWMyLXBhaWQtaWJtLWltYWdlcy9pbml0cmQtMi42LjE2LjYwLTAuMjkteGVu +cGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWlt +YWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0ew8iDmltYWdlVHlwZSIMcmFtZGlz +ayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxl +IgxpbWFnZUlkIhFhcmktN2NiOTVhMTUiE3Jvb3REZXZpY2VUeXBlIhNpbnN0 +YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGlj +Igl0cnVlIhJpbWFnZUxvY2F0aW9uIlJlYzItcHVibGljLWltYWdlcy9pbml0 +cmQtMi42LjIxLjctMi5mYzh4ZW4tZWMyLXYxLjAuMS54ODZfNjQuYXJpLm1h +bmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJ +ZCIRMjA2MDI5NjIxNTMyexAiDmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tE +ZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0 +Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg01NzhCRjVCQSIMaW1h +Z2VJZCIRYXJpLTgxM2ZkZWU4IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Ut +c3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1 +ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBhaWQtaWJtLWltYWdlcy9pbml0cmQt +Mi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNo +aXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAi +DmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYi +EHByb2R1Y3RDb2RlIg1BNDgxODk1RCIMaW1hZ2VJZCIRYXJpLTg4ZTYwYmUx +IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJB +bGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJL +ZWMyLXBhaWQtaWJtLWltYWdlcy1kYjIvaW5pdHJkLTIuNi4xNi42MC0wLjI5 +LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2 +IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDHJh +bWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWls +YWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSIN +QTQ4MTg5NUQiDGltYWdlSWQiEWFyaS05MWViMGJmOCITcm9vdERldmljZVR5 +cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiIN +aXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1p +bWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3 +MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNl +TWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJp +LTk2YzUyN2ZmIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJOZWMyLXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4yMS43LTIu +ZWMyLnYxLjIuZmM4eGVuLmk2ODYuYXJpLm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsQIg5p +bWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBw +cm9kdWN0Q29kZSINRTNENDhDRUUiDGltYWdlSWQiEWFyaS05YTcwOTBmMyIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2Vj +Mi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBh +ZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDHJhbWRpc2si +F2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIR +cHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRDY2MkU5 +ODkiDGltYWdlSWQiEWFyaS05ZjNmZGVmNiITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMv +aW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0Lnht +bCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGlu +ZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJpLWEyM2Fk +ZmNiIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3du +ZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlv +biJDZWMyLXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4yMC0xLjMwMDIuZmM2 +eGVuLmFyaS5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFp +bWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsPIg5pbWFnZVR5cGUiDHJhbWRp +c2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJs +ZSIMaW1hZ2VJZCIRYXJpLWE1MWNmOWNjIhNyb290RGV2aWNlVHlwZSITaW5z +dGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1Ymxp +YyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJFZWMyLXB1YmxpYy1pbWFnZXMvZWMy +LWluaXRyZC0yLjYuMjEuNy0yLmZjOHhlbi5pMzg2Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUz +MnsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAi +D2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1b +BnsGIhBwcm9kdWN0Q29kZSINRDZGNjA1MkEiDGltYWdlSWQiEWFyaS1iMjRi +YWNkYiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iR2VjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5 +LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2 +IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiDHJh +bWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWls +YWJsZSIMaW1hZ2VJZCIRYXJpLWIzMWNmOWRhIhNyb290RGV2aWNlVHlwZSIT +aW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1 +YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXB1YmxpYy1pbWFnZXMv +ZWMyLWluaXRyZC0yLjYuMjEuNy0yLmZjOHhlbi54ODZfNjQubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYw +Mjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgxyYW1kaXNrIhdibG9ja0RldmljZU1h +cHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFyaS1i +YWYyMTBkMyITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFn +ZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9j +YXRpb24iRmVjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0w +LjMwLXhlbi54ODZfNjQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4 +Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1hZ2VUeXBl +IgxyYW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiDGltYWdlSWQiEWFyaS1iZGU3MDdkNCITcm9vdERldmljZVR5 +cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiIN +aXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1p +bWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3 +MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNl +TWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJp +LWRiYzEyMWIyIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJIZWMyLXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4xOC14ZW5V +LWVjMi12MS4yLmkzODYuYXJpLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJl +IglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsQIg5pbWFnZVR5 +cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUi +DmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0 +Q29kZSINQTk0MDhCNEIiDGltYWdlSWQiEWFyaS1kZDRiYWNiNCITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iRmVjMi1wYWlk +LWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjMwLXhlbi54ODZfNjQu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1hZ2VUeXBlIgxyYW1kaXNrIhdibG9j +a0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdl +SWQiEWFyaS1lM2MxMjE4YSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0 +b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUi +EmltYWdlTG9jYXRpb24iSmVjMi1wdWJsaWMtaW1hZ2VzL2luaXRyZC0yLjYu +MTgteGVuVS1lYzItdjEuMi54ODZfNjQuYXJpLm1hbmlmZXN0LnhtbCIRYXJj +aGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMy +ew8iDmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIP +aW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhcmktZTdkYzNjOGUi +E3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFs +aWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIk5l +YzItcHVibGljLWltYWdlcy9pbml0cmQtMi42LjIxLjctMi5mYzh4ZW4tZWMy +LXYxLjAuaTM4Ni5hcmkubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkz +ODYiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyexAiDmltYWdlVHlwZSIM +cmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZh +aWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2Rl +Ig0yMUU5RUJDOSIMaW1hZ2VJZCIRYXJpLWY0NThiYTlkIhNyb290RGV2aWNl +VHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9u +Ig1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJRZWMyLXBhaWQtaWJt +LWltYWdlcy1pbmZvc3BoZXJlL2luaXRyZC0yLjYuMTYuNjAtMC4zMC14ZW4u +eDg2XzY0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIgt4ODZfNjQiEWlt +YWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAiDmltYWdlVHlwZSIMcmFtZGlz +ayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxl +IhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg1ENjYy +RTk4OSIMaW1hZ2VJZCIRYXJpLWZhZjAxMjkzIhNyb290RGV2aWNlVHlwZSIT +aW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1 +YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBhaWQtaWJtLWltYWdl +cy9pbml0cmQtMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0 +NTM0MDI0exAiDmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBw +aW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJ +aXRlbVsGewYiEHByb2R1Y3RDb2RlIg1FQTVGMDVBMyIMaW1hZ2VJZCIRYXJp +LWZjZmQxMDk1IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJKZWMyLXBhaWQtaWJtLWltYWdlcy1kYjIvaW5pdHJkLTIuNi4x +Ni42MC0wLjMwLXhlbi54ODZfNjQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1 +cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjQiDnJlcXVl +c3RJZCIpOTI4OTAxODQtMzZhMy00OTRmLTkyZGItNmVjZWNkZGRiNDNlIgp4 +bWxucyItaHR0cDovL2VjMi5hbWF6b25hd3MuY29tL2RvYy8yMDA5LTExLTMw +Lw== diff --git a/tests/ec2/support/ec2/create-hwp_describe_images.45eee35ec8f8243c05d85cf5486c54368be8207e b/tests/ec2/support/ec2/create-hwp_describe_images.45eee35ec8f8243c05d85cf5486c54368be8207e new file mode 100644 index 0000000..3a014df --- /dev/null +++ b/tests/ec2/support/ec2/create-hwp_describe_images.45eee35ec8f8243c05d85cf5486c54368be8207e @@ -0,0 +1,11 @@ +BAh7CCIOaW1hZ2VzU2V0ewYiCWl0ZW1bBnsRIg5pbWFnZVR5cGUiDG1hY2hp +bmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNm +OWNjIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTcx +Y2Y5Y2UiDGltYWdlSWQiEWFtaS0xMWNhMmQ3OCITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iP2F3cy10b29sa2l0LWZvci1l +Y2xpcHNlLWFtaXMtdXMvdG9tY2F0LXYxLjAuMC5tYW5pZmVzdC54bWwiEWFy +Y2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3MTYi +DnJlcXVlc3RJZCIpMzYwZGZhY2YtMzI5Ni00Y2M5LWFlNjAtMmNjYWQ1YjBm +ZmE3Igp4bWxucyItaHR0cDovL2VjMi5hbWF6b25hd3MuY29tL2RvYy8yMDA5 +LTExLTMwLw== diff --git a/tests/ec2/support/ec2/create-hwp_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 b/tests/ec2/support/ec2/create-hwp_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 new file mode 100644 index 0000000..0112a71 --- /dev/null +++ b/tests/ec2/support/ec2/create-hwp_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 @@ -0,0 +1,19 @@ +BAh7CCIOcmVxdWVzdElkIik4MmFmYzBmZS1iN2QyLTQ2ZjQtYWViNC1mYWZk +MWI2ZWRmZjQiE3Jlc2VydmF0aW9uU2V0ewYiCWl0ZW1bBnsJIhJyZXNlcnZh +dGlvbklkIg9yLTBkOWI2NDY2Ig1ncm91cFNldHsGIglpdGVtWwZ7BiIMZ3Jv +dXBJZCIMZGVmYXVsdCIRaW5zdGFuY2VzU2V0ewYiCWl0ZW1bBnsZIhVwcml2 +YXRlSXBBZGRyZXNzIhIxMC4yNTQuOTcuMTg4IgxrZXlOYW1lIgx0ZXN0aW5n +IhdibG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1hNTFjZjlj +YyIRcHJvZHVjdENvZGVzMCIOaXBBZGRyZXNzIhIxODQuNzMuODQuMTk1Ig1r +ZXJuZWxJZCIRYWtpLWE3MWNmOWNlIg9sYXVuY2hUaW1lIh0yMDEwLTA1LTE4 +VDExOjQ0OjM1LjAwMFoiE2FtaUxhdW5jaEluZGV4IgYwIgxpbWFnZUlkIhFh +bWktMTFjYTJkNzgiEWluc3RhbmNlVHlwZSINbTEuc21hbGwiC3JlYXNvbjAi +E3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIOcGxhY2VtZW50ewYi +FWF2YWlsYWJpbGl0eVpvbmUiD3VzLWVhc3QtMWEiD2luc3RhbmNlSWQiD2kt +ZTc0MjY2OGMiE3ByaXZhdGVEbnNOYW1lIi5kb21VLTEyLTMxLTM5LTAwLTVF +LTMyLmNvbXB1dGUtMS5pbnRlcm5hbCIMZG5zTmFtZSIuZWMyLTE4NC03My04 +NC0xOTUuY29tcHV0ZS0xLmFtYXpvbmF3cy5jb20iEWFyY2hpdGVjdHVyZSIJ +aTM4NiIPbW9uaXRvcmluZ3sGIgpzdGF0ZSIMZW5hYmxlZCISaW5zdGFuY2VT +dGF0ZXsHIgluYW1lIgxydW5uaW5nIgljb2RlIgcxNiIMb3duZXJJZCIRMjkz +Nzg3NzQ5ODg0Igp4bWxucyItaHR0cDovL2VjMi5hbWF6b25hd3MuY29tL2Rv +Yy8yMDA5LTExLTMwLw== diff --git a/tests/ec2/support/ec2/create-hwp_run_instances.698df7f7a613449c42d1bcea2ba275b2bc598db5 b/tests/ec2/support/ec2/create-hwp_run_instances.698df7f7a613449c42d1bcea2ba275b2bc598db5 new file mode 100644 index 0000000..fca4e66 --- /dev/null +++ b/tests/ec2/support/ec2/create-hwp_run_instances.698df7f7a613449c42d1bcea2ba275b2bc598db5 @@ -0,0 +1,15 @@ +BAh7CyIScmVzZXJ2YXRpb25JZCIPci05OWZmMDBmMiINZ3JvdXBTZXR7BiIJ +aXRlbVsGewYiDGdyb3VwSWQiDGRlZmF1bHQiDnJlcXVlc3RJZCIpNDQxOGM2 +MWUtZTY2OS00MGE0LTk2YmMtMjk2YjQ3YjZmNzZhIhFpbnN0YW5jZXNTZXR7 +BiIJaXRlbVsGexYiEHN0YXRlUmVhc29uewciCWNvZGUiDHBlbmRpbmciDG1l +c3NhZ2UiDHBlbmRpbmciF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJ +ZCIRYXJpLWE1MWNmOWNjIhFwcm9kdWN0Q29kZXMwIg1rZXJuZWxJZCIRYWtp +LWE3MWNmOWNlIg9sYXVuY2hUaW1lIh0yMDEwLTA1LTE4VDEzOjIxOjU3LjAw +MFoiE2FtaUxhdW5jaEluZGV4IgYwIgxpbWFnZUlkIhFhbWktMTFjYTJkNzgi +EWluc3RhbmNlVHlwZSINbTEuc21hbGwiC3JlYXNvbjAiE3Jvb3REZXZpY2VU +eXBlIhNpbnN0YW5jZS1zdG9yZSIOcGxhY2VtZW50ewYiFWF2YWlsYWJpbGl0 +eVpvbmUiD3VzLWVhc3QtMWEiD2luc3RhbmNlSWQiD2ktOTUyODBjZmUiE3By +aXZhdGVEbnNOYW1lMCIMZG5zTmFtZTAiD21vbml0b3Jpbmd7BiIKc3RhdGUi +DHBlbmRpbmciEmluc3RhbmNlU3RhdGV7ByIJbmFtZSIMcGVuZGluZyIJY29k +ZSIGMCIMb3duZXJJZCIRMjkzNzg3NzQ5ODg0Igp4bWxucyItaHR0cDovL2Vj +Mi5hbWF6b25hd3MuY29tL2RvYy8yMDA5LTExLTMwLw== diff --git a/tests/ec2/support/ec2/create_describe_images.1d05fa88d294d07beed14334421b46d322385188 b/tests/ec2/support/ec2/create_describe_images.1d05fa88d294d07beed14334421b46d322385188 new file mode 100644 index 0000000..372cc55 --- /dev/null +++ b/tests/ec2/support/ec2/create_describe_images.1d05fa88d294d07beed14334421b46d322385188 @@ -0,0 +1,1338 @@ +BAh7CCIOaW1hZ2VzU2V0ewYiCWl0ZW1bAax7ECIOaW1hZ2VUeXBlIgtrZXJu +ZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJs +ZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINQTk0 +MDhCNEIiDGltYWdlSWQiEWFraS0wMjUxYjM2YiITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iS2VjMi1wYWlkLWlibS1pbWFn +ZXMtaWRzL3ZtbGludXotMi42LjE2LjYwLTAuMzAteGVuLng4Nl82NC5tYW5p +ZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQi +ETQ3MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZp +Y2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFh +a2ktMGE0YWE4NjMiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIU +aW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFn +ZUxvY2F0aW9uIkdlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2 +LjYwLTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVy +ZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsPIg5pbWFn +ZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0 +ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFha2ktMTJmMDEyN2IiE3Jvb3REZXZp +Y2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6 +b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1p +Ym0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJ +ZCIRNDcwMjU0NTM0MDI0exAiCW5hbWUiOXZtbGludXotMi42LjE4LXhlblUt +ZWMyLXYxLjQueDg2XzY0LmFraS5tYW5pZmVzdC54bWwiDmltYWdlVHlwZSIL +a2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiDGltYWdlSWQiEWFraS0yYTQyYTA0MyITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iS2VjMi1wdWJsaWMtaW1hZ2Vz +L3ZtbGludXotMi42LjE4LXhlblUtZWMyLXYxLjQueDg2XzY0LmFraS5tYW5p +ZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQi +ETIwNjAyOTYyMTUzMnsQIg5pbWFnZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZp +Y2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29k +ZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg01NzhCRjVCQSIMaW1hZ2VJ +ZCIRYWtpLTJkZDMzMDQ0IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQtaWJtLWltYWdlcy92bWxpbnV6LTIu +Ni4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsPIg5p +bWFnZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VT +dGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFha2ktMzAzOGRhNTkiE3Jvb3RE +ZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgth +bWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFp +ZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkz +ODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3du +ZXJJZCIRNDcwMjU0NTM0MDI0ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9j +a0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdl +SWQiEWFraS00NmU3MDAyZiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0 +b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUi +EmltYWdlTG9jYXRpb24iOWFraS1saW51eC4yLjYuMjEuNy0yLmZjOHhlbi14 +ZnMvdm1saW51ei5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIR +aW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgtrZXJu +ZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJs +ZSIMaW1hZ2VJZCIRYWtpLTRkNThiOTI0IhNyb290RGV2aWNlVHlwZSITaW5z +dGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1Ymxp +YyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQtaWJtLWltYWdlcy92 +bWxpbnV6LTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0Lnht +bCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsPIg5pbWFnZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5n +MCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFha2ktNTRjZTJj +M2QiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25l +ckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9u +IlFlYzItcHVibGljLWltYWdlcy92bWxpbnV6LTIuNi4yMS43LTIuZWMyLnYx +LjIuZmM4eGVuLng4Nl82NC5ha2kubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1 +cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIJbmFt +ZSI3dm1saW51ei0yLjYuMTgteGVuVS1lYzItdjEuNC5pNjg2LmFraS5tYW5p +ZmVzdC54bWwiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBp +bmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS01NjQy +YTAzZiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iSWVjMi1wdWJsaWMtaW1hZ2VzL3ZtbGludXotMi42LjE4LXhlblUtZWMy +LXYxLjQuaTY4Ni5ha2kubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkz +ODYiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyexAiDmltYWdlVHlwZSIL +a2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUi +DUQ2RjYwNTJBIgxpbWFnZUlkIhFha2ktNjA1MWIzMDkiE3Jvb3REZXZpY2VU +eXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24i +DWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1pYm0t +aW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFu +aWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIR +NDcwMjU0NTM0MDI0ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0Rldmlj +ZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFr +aS02MjQ4YTgwYiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRp +bWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdl +TG9jYXRpb24iSGVjMi1wYWlkLWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYu +NjAtMC4yOS14ZW5wYWUuaTM4Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVy +ZSIJaTM4NiIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VU +eXBlIgtrZXJuZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUi +DmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0 +Q29kZSINNDlDQTczMDUiDGltYWdlSWQiEWFraS02ODQ4YTgwMSITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iSGVjMi1wYWlk +LWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYuNjAtMC4yOS14ZW5wYWUuaTM4 +Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVj +dENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRUE1RjA1QTMiDGlt +YWdlSWQiEWFraS02YmVjMGMwMiITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMvdm1saW51 +ei0yLjYuMTYuNjAtMC4zMC14ZW4ueDg2XzY0Lm1hbmlmZXN0LnhtbCIRYXJj +aGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0 +ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9p +bWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS02ZWFhNDkwNyIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iTWVj +Mi1wdWJsaWMtaW1hZ2VzL3ZtbGludXotMi42LjIxLTIuZmM4eGVuLWVjMi12 +MS4wLmkzODYuYWtpLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2 +IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsQIg5pbWFnZVR5cGUiC2tl +cm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxh +YmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg1E +NkZCMTExMyIMaW1hZ2VJZCIRYWtpLTZmNzc5NDA2IhNyb290RGV2aWNlVHlw +ZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1p +c1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQtaWJtLWlt +YWdlcy92bWxpbnV6LTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3 +MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VN +YXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFha2kt +NmY5MTcxMDYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIkhlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYw +LTAuMjkteGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUi +CWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAiDmltYWdlVHlw +ZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENv +ZGUiDUNDRUIzNjhCIgxpbWFnZUlkIhFha2ktN2M0OGE4MTUiE3Jvb3REZXZp +Y2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6 +b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1p +Ym0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJ +ZCIRNDcwMjU0NTM0MDI0exAiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0Rl +dmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RD +b2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDTgwRUQwMEI4IgxpbWFn +ZUlkIhFha2ktN2U0OGE4MTciE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1z +dG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVl +IhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXot +Mi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNo +aXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAi +DmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQ +cHJvZHVjdENvZGUiDUQ2RkIxMTEzIgxpbWFnZUlkIhFha2ktODA0OWFlZTki +E3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFs +aWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhl +YzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVu +cGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWlt +YWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAiDmltYWdlVHlwZSILa2VybmVs +IhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUi +EXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUE0ODE4 +OTVEIgxpbWFnZUlkIhFha2ktODE0OWFlZTgiE3Jvb3REZXZpY2VUeXBlIhNp +bnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVi +bGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1pYm0taW1hZ2Vz +L3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0 +NTM0MDI0exAiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBp +bmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglp +dGVtWwZ7BiIQcHJvZHVjdENvZGUiDThGQ0UzRUVCIgxpbWFnZUlkIhFha2kt +ODI0OWFlZWIiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIkdlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYw +LTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIL +eDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5 +cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RD +b2RlIg00NzZEMjlDQiIMaW1hZ2VJZCIRYWtpLTgzNDlhZWVhIhNyb290RGV2 +aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1h +em9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBhaWQt +aWJtLWltYWdlcy92bWxpbnV6LTIuNi4xNi42MC0wLjMwLXhlbi54ODZfNjQu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVj +dENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRUE1RjA1QTMiDGlt +YWdlSWQiEWFraS04NTQ5YWVlYyITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMvdm1saW51 +ei0yLjYuMTYuNjAtMC4zMC14ZW4ueDg2XzY0Lm1hbmlmZXN0LnhtbCIRYXJj +aGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0 +exAiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9p +bWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7 +BiIQcHJvZHVjdENvZGUiDUUzRDQ4Q0VFIgxpbWFnZUlkIhFha2ktODY3MDkw +ZWYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25l +ckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9u +IkhlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkt +eGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYi +EWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAiDmltYWdlVHlwZSILa2Vy +bmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFi +bGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDTU3 +OEJGNUJBIgxpbWFnZUlkIhFha2ktOGIzZmRlZTIiE3Jvb3REZXZpY2VUeXBl +IhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlz +UHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1pYm0taW1h +Z2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZl +c3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcw +MjU0NTM0MDI0ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1h +cHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS05 +NGM1MjdmZCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFn +ZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9j +YXRpb24iT2VjMi1wdWJsaWMtaW1hZ2VzL3ZtbGludXotMi42LjIxLjctMi5l +YzIudjEuMi5mYzh4ZW4uaTY4Ni5ha2kubWFuaWZlc3QueG1sIhFhcmNoaXRl +Y3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyew8iDmlt +YWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS05NjQ1YTdmZiITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iSGVjMi1wYWlk +LWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYuNjAtMC4yOS14ZW5wYWUuaTM4 +Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJ +ZCIRYWtpLTk4MDBlNWYxIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJLZWMyLXB1YmxpYy1pbWFnZXMvdm1saW51ei0yLjYu +MTgteGVuVS1lYzItdjEuMC54ODZfNjQuYWtpLm1hbmlmZXN0LnhtbCIRYXJj +aGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMy +ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9p +bWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS05YjAwZTVmMiIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iSWVj +Mi1wdWJsaWMtaW1hZ2VzL3ZtbGludXotMi42LjE4LXhlblUtZWMyLXYxLjAu +aTM4Ni5ha2kubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWlt +YWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyexAiDmltYWdlVHlwZSILa2VybmVs +IhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUi +EXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUQ2NjJF +OTg5IgxpbWFnZUlkIhFha2ktOWIzZmRlZjIiE3Jvb3REZXZpY2VUeXBlIhNp +bnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVi +bGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1pYm0taW1hZ2Vz +L3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0 +NTM0MDI0exAiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBp +bmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglp +dGVtWwZ7BiIQcHJvZHVjdENvZGUiDUE0ODE4OTVEIgxpbWFnZUlkIhFha2kt +OWZlYjBiZjYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIkhlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYw +LTAuMjkteGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUi +CWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0ew8iDmltYWdlVHlw +ZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiDGltYWdlSWQiEWFraS1hM2Q3MzdjYSITcm9vdERldmljZVR5 +cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiIN +aXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iT2VjMi1wdWJsaWMtaW1h +Z2VzL3ZtbGludXotMi42LjIxLTIuZmM4eGVuLWVjMi12MS4wLng4Nl82NC5h +a2kubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VP +d25lcklkIhEyMDYwMjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Js +b2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1h +Z2VJZCIRYWtpLWE1M2FkZmNjIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Ut +c3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1 +ZSISaW1hZ2VMb2NhdGlvbiJEZWMyLXB1YmxpYy1pbWFnZXMvdm1saW51ei0y +LjYuMjAtMS4zMDAyLmZjNnhlbi5ha2kubWFuaWZlc3QueG1sIhFhcmNoaXRl +Y3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIO +aW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYWtpLWE2ZjIxMGNmIhNyb290 +RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyIL +YW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBh +aWQtaWJtLWltYWdlcy92bWxpbnV6LTIuNi4xNi42MC0wLjMwLXhlbi54ODZf +NjQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VP +d25lcklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Js +b2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1h +Z2VJZCIRYWtpLWE3MWNmOWNlIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Ut +c3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1 +ZSISaW1hZ2VMb2NhdGlvbiJGZWMyLXB1YmxpYy1pbWFnZXMvZWMyLXZtbGlu +dXotMi42LjIxLjctMi5mYzh4ZW4uaTM4Ni5tYW5pZmVzdC54bWwiEWFyY2hp +dGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIO +aW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBw +cm9kdWN0Q29kZSINRDZGNjA1MkEiDGltYWdlSWQiEWFraS1iMzRiYWNkYSIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iSGVj +Mi1wYWlkLWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYuNjAtMC4yOS14ZW5w +YWUuaTM4Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1h +Z2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1hZ2VUeXBlIgtrZXJuZWwi +F2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIM +aW1hZ2VJZCIRYWtpLWI1MWNmOWRjIhNyb290RGV2aWNlVHlwZSITaW5zdGFu +Y2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJ +dHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMyLXB1YmxpYy1pbWFnZXMvZWMyLXZt +bGludXotMi42LjIxLjctMi5mYzh4ZW4ueDg2XzY0Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIx +NTMyew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcw +Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS1iOWU3MDdk +MCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVy +QWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24i +SGVjMi1wYWlkLWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYuNjAtMC4yOS14 +ZW5wYWUuaTM4Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIR +aW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgtrZXJu +ZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJs +ZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINQTQ4 +MTg5NUQiDGltYWdlSWQiEWFraS1iY2U2MGJkNSITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iTGVjMi1wYWlkLWlibS1pbWFn +ZXMtZGIyL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFu +aWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIR +NDcwMjU0NTM0MDI0ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0Rldmlj +ZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFr +aS1kNGNhMmRiZCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRp +bWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdl +TG9jYXRpb24iWGFraS1saW51eC0yLjYuMTguOTItOTIuZWw1eGVuLXhmcy92 +bWxpbnV6LTIuNi4xOC45Mi05Mi5lbDV4ZW4uaTM4Ni5ha2kubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5 +NjIxNTMyexAiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBp +bmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglp +dGVtWwZ7BiIQcHJvZHVjdENvZGUiDUE5NDA4QjRCIgxpbWFnZUlkIhFha2kt +ZGI0YmFjYjIiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIkdlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYw +LTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIL +eDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsPIg5pbWFnZVR5 +cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIgxpbWFnZUlkIhFha2ktZTVjMTIxOGMiE3Jvb3REZXZpY2VU +eXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24i +DWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIktlYzItcHVibGljLWlt +YWdlcy92bWxpbnV6LTIuNi4xOC14ZW5VLWVjMi12MS4yLng4Nl82NC5ha2ku +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25l +cklkIhEyMDYwMjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJ +ZCIRYWtpLWY1YzEyMTljIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJJZWMyLXB1YmxpYy1pbWFnZXMvdm1saW51ei0yLjYu +MTgteGVuVS1lYzItdjEuMi5pMzg2LmFraS5tYW5pZmVzdC54bWwiEWFyY2hp +dGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIO +aW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBw +cm9kdWN0Q29kZSINMjFFOUVCQzkiDGltYWdlSWQiEWFraS1mODU4YmE5MSIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iUmVj +Mi1wYWlkLWlibS1pbWFnZXMtaW5mb3NwaGVyZS92bWxpbnV6LTIuNi4xNi42 +MC0wLjMwLXhlbi54ODZfNjQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUi +C3g4Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VU +eXBlIgtrZXJuZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUi +DmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0 +Q29kZSINRDY2MkU5ODkiDGltYWdlSWQiEWFraS1mOGYwMTI5MSITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iSGVjMi1wYWlk +LWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYuNjAtMC4yOS14ZW5wYWUuaTM4 +Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVj +dENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRUE1RjA1QTMiDGlt +YWdlSWQiEWFraS1mOGZkMTA5MSITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iS2VjMi1wYWlkLWlibS1pbWFnZXMtZGIyL3Zt +bGludXotMi42LjE2LjYwLTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwi +EWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsQIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGlu +ZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLTA1MzVk +NjZjIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3du +ZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlv +biJMZWMyLXB1YmxpYy13aW5kb3dzLWltYWdlcy9TcWxTdnJTdGQyMDAzcjIt +eDg2XzY0LVdpbi12MS4wNy5tYW5pZmVzdC54bWwiDXBsYXRmb3JtIgx3aW5k +b3dzIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYw +Mjk2MjE1MzJ7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1h +cHBpbmcwIg5yYW1kaXNrSWQiEWFyaS02NjQ4YTgwZiIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RD +b2RlIg04MEVEMDBCOCINa2VybmVsSWQiEWFraS03ZTQ4YTgxNyIMaW1hZ2VJ +ZCIRYW1pLTA2NGNhYzZmIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQtaWJtLWltYWdlcy9pYm0tdGl2b2xp +LWl0bS0wNi4yMS4wMy4wMC0zMmItNjAwLm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsTIg5p +bWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRp +c2tJZCIRYXJpLTMyMzhkYTViIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXBy +b2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUUzRDQ4Q0VF +Ig1rZXJuZWxJZCIRYWtpLTMwMzhkYTU5IgxpbWFnZUlkIhFhbWktMTAwMGUy +NzkiE3Jvb3REZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBl +IhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlz +UHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIlBlYzItcGFpZC1pYm0taW1h +Z2VzL3dlYnNwaGVyZS1hcHBsaWNhdGlvbi1zZXJ2ZXItNy4wLjAuNy0zMmJp +dC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7EyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9j +a0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS0wYzUxYjM2NSIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYi +EHByb2R1Y3RDb2RlIg1BOTQwOEI0QiINa2VybmVsSWQiEWFraS0wMjUxYjM2 +YiIMaW1hZ2VJZCIRYW1pLTEwNTFiMzc5IhNyb290RGV2aWNlTmFtZSIOL2Rl +di9zZGExIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdl +T3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2Nh +dGlvbiJHZWMyLXBhaWQtaWJtLWltYWdlcy1pZHMvaWJtLWlkcy13b3JrZ3Jv +dXAtMTEuNS12MjAyLTEubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4 +Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7ESIOaW1hZ2VUeXBl +IgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFy +aS1hNTFjZjljYyIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJuZWxJZCIR +YWtpLWE3MWNmOWNlIgxpbWFnZUlkIhFhbWktMTFjYTJkNzgiE3Jvb3REZXZp +Y2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6 +b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIj9hd3MtdG9vbGtp +dC1mb3ItZWNsaXBzZS1hbWlzLXVzL3RvbWNhdC12MS4wLjAubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA1NjA1 +ODE5NzE2exAiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBw +aW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLTli +MDBlNWYyIgxpbWFnZUlkIhFhbWktMjA1ZmJhNDkiE3Jvb3REZXZpY2VUeXBl +IhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlz +UHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkBlYzItcHVibGljLWltYWdl +cy9mZWRvcmEtY29yZTQtaTM4Ni1iYXNlLXYxLjA3Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUz +MnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAi +DnJhbWRpc2tJZCIRYXJpLWRiYzEyMWIyIg9pbWFnZVN0YXRlIg5hdmFpbGFi +bGUiDWtlcm5lbElkIhFha2ktZjVjMTIxOWMiDGltYWdlSWQiEWFtaS0yMGIw +NTM0OSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iRWF3cy1jb25zb2xlLXF1aWNrc3RhcnQtYW1pcy9wZXJsLzEuMy9wZXJs +cXVpY2tzdGFydC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIR +aW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3MTZ7DyIOaW1hZ2VUeXBlIgxtYWNo +aW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFi +bGUiDGltYWdlSWQiEWFtaS0yMGI2NTM0OSITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iNWVjMi1wdWJsaWMtaW1hZ2VzL2Zl +ZG9yYS1jb3JlNC1iYXNlLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglp +Mzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsPIg5pbWFnZVR5cGUi +DG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2 +YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLTIxNWZiYTQ4IhNyb290RGV2aWNlVHlw +ZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1p +c1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiI7ZWMyLXB1YmxpYy1pbWFn +ZXMvZmVkb3JhLWNvcmU0LWJhc2UtdjEuMDcubWFuaWZlc3QueG1sIhFhcmNo +aXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyew8i +DmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhbWktMjI1ZmJhNGIiE3Jv +b3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFz +IgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkNlYzIt +cHVibGljLWltYWdlcy9mZWRvcmEtY29yZTQtYXBhY2hlLW15c3FsLXYxLjA3 +Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVy +SWQiETIwNjAyOTYyMTUzMnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLWRiYzEyMWIyIg9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktZjVjMTIxOWMiDGlt +YWdlSWQiEWFtaS0yMmIwNTM0YiITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iRWF3cy1jb25zb2xlLXF1aWNrc3RhcnQtYW1p +cy9ydWJ5LzEuMi9ydWJ5cXVpY2tzdGFydC5tYW5pZmVzdC54bWwiEWFyY2hp +dGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3MTZ7DyIO +aW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS0yMmI2NTM0YiITcm9v +dERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMi +C2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iNmVjMi1w +dWJsaWMtaW1hZ2VzL2ZlZG9yYS1jb3JlNC1teXNxbC5tYW5pZmVzdC54bWwi +EWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1 +MzJ7DyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcw +Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS0yMzVmYmE0 +YSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVy +QWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24i +OWVjMi1wdWJsaWMtaW1hZ2VzL2dldHRpbmctc3RhcnRlZC12MS4wNy5tYW5p +ZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEy +MDYwMjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0Rldmlj +ZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFt +aS0yM2I2NTM0YSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRp +bWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdl +TG9jYXRpb24iN2VjMi1wdWJsaWMtaW1hZ2VzL2ZlZG9yYS1jb3JlNC1hcGFj +aGUubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3du +ZXJJZCIRMjA2MDI5NjIxNTMyexIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxv +Y2tEZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktYjI0YmFjZGIiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsG +IhBwcm9kdWN0Q29kZSINRDZGNjA1MkEiDWtlcm5lbElkIhFha2ktYjM0YmFj +ZGEiDGltYWdlSWQiEWFtaS0yNDRhYWQ0ZCITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iTGVjMi1wYWlkLWlibS1pbWFnZXMv +aW5mb3JtaXgtZHluYW1pYy1zZXJ2ZXItZXhwcmVzcy0zMi1iaXQubWFuaWZl +c3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcw +MjU0NTM0MDI0exEiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VN +YXBwaW5nMCIOcmFtZGlza0lkIhFhcmktYjMxY2Y5ZGEiD2ltYWdlU3RhdGUi +DmF2YWlsYWJsZSINa2VybmVsSWQiEWFraS1iNTFjZjlkYyIMaW1hZ2VJZCIR +YW1pLTI1NDdhMzRjIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUi +FGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1h +Z2VMb2NhdGlvbiI+ZWMyLXB1YmxpYy1pbWFnZXMvZmVkb3JhLTgteDg2XzY0 +LWJhc2UtdjEuMDgubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82 +NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgxt +YWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiDGltYWdlSWQiEWFtaS0yNTVmYmE0YyITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iPGVjMi1wdWJsaWMtaW1hZ2Vz +L2ZlZG9yYS1jb3JlNC1teXNxbC12MS4wNy5tYW5pZmVzdC54bWwiEWFyY2hp +dGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIO +aW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS0yNWI2NTM0YyITcm9v +dERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMi +C2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iPWVjMi1w +dWJsaWMtaW1hZ2VzL2ZlZG9yYS1jb3JlNC1hcGFjaGUtbXlzcWwubWFuaWZl +c3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2 +MDI5NjIxNTMyew8iDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VN +YXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhbWkt +MjZiNjUzNGYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIjNlYzItcHVibGljLWltYWdlcy9kZXZlbG9wZXItaW1hZ2UubWFu +aWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIR +MjA2MDI5NjIxNTMyexEiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZp +Y2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktYTUxY2Y5Y2MiD2ltYWdlU3Rh +dGUiDmF2YWlsYWJsZSINa2VybmVsSWQiEWFraS1hNzFjZjljZSIMaW1hZ2VJ +ZCIRYW1pLTI3ZTcwMDRlIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJGL2F3cy1jb25zb2xlLXF1aWNrc3RhcnQtYW1pcy9w +ZXJsLzEuMi9wZXJscXVpY2tzdGFydC5tYW5pZmVzdC54bWwiEWFyY2hpdGVj +dHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3MTZ7ESIOaW1h +Z2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNr +SWQiEWFyaS1iMzFjZjlkYSIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJu +ZWxJZCIRYWtpLWI1MWNmOWRjIgxpbWFnZUlkIhFhbWktMmE1ZmJhNDMiE3Jv +b3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFz +IgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIj5lYzIt +cHVibGljLWltYWdlcy9mZWRvcmEtOC14ODZfNjQtYmFzZS12MS4wNy5tYW5p +ZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQi +ETIwNjAyOTYyMTUzMnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2 +aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2UiDGltYWdl +SWQiEWFtaS0yYjVmYmE0MiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0 +b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUi +EmltYWdlTG9jYXRpb24iPGVjMi1wdWJsaWMtaW1hZ2VzL2ZlZG9yYS04LWkz +ODYtYmFzZS12MS4wNy5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4 +NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIOaW1hZ2VUeXBlIgxt +YWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUi +DUE3OUVDMERCIgxpbWFnZUlkIhFhbWktMmM1ZmJhNDUiE3Jvb3REZXZpY2VU +eXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24i +DWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIjdlYzItcHVibGljLWlt +YWdlcy9kZW1vLXBhaWQtQU1JLXYxLjA3Lm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsRIg5p +bWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRp +c2tJZCIRYXJpLWRiYzEyMWIyIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDWtl +cm5lbElkIhFha2ktZjVjMTIxOWMiDGltYWdlSWQiEWFtaS0yY2IwNTM0NSIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iQGF3 +cy1jb25zb2xlLXF1aWNrc3RhcnQtYW1pcy9waHBxdWlja3N0YXJ0LXYxLjUu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJ +ZCIRMjA1NjA1ODE5NzE2exEiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tE +ZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktYTIzYWRmY2IiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSINa2VybmVsSWQiEWFraS1hNTNhZGZjYyIMaW1h +Z2VJZCIRYW1pLTJkNWZiYTQ0IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Ut +c3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1 +ZSISaW1hZ2VMb2NhdGlvbiJDZWMyLXB1YmxpYy1pbWFnZXMvZmVkb3JhLWNv +cmUtNi14ODZfNjQtYmFzZS12MS4wNy5tYW5pZmVzdC54bWwiEWFyY2hpdGVj +dHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsPIg5p +bWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLTJlNWZiYTQ3IhNyb290 +RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyIL +YW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiI9ZWMyLXB1 +YmxpYy1pbWFnZXMvZmVkb3JhLWNvcmU0LWFwYWNoZS12MS4wNy5tYW5pZmVz +dC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYw +Mjk2MjE1MzJ7ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1h +cHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1kYmMxMjFiMiIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLWY1YzEyMTljIgxpbWFnZUlkIhFh +bWktMmViMDUzNDciE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIU +aW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFn +ZUxvY2F0aW9uIklhd3MtY29uc29sZS1xdWlja3N0YXJ0LWFtaXMvdG9tY2F0 +LzEuMi90b21jYXRxdWlja3N0YXJ0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0 +dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNTYwNTgxOTcxNnsPIg5pbWFn +ZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3Rh +dGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLTJmNWZiYTQ2IhNyb290RGV2 +aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1h +em9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiI+ZWMyLXB1Ymxp +Yy1pbWFnZXMvZGV2ZWxvcGVyLWltYWdlLWkzODYtdjEuMDcubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5 +NjIxNTMyexIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBw +aW5nMCIOcmFtZGlza0lkIhFhcmktMjFkMzMwNDgiD2ltYWdlU3RhdGUiDmF2 +YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29k +ZSINNTc4QkY1QkEiDWtlcm5lbElkIhFha2ktMmRkMzMwNDQiDGltYWdlSWQi +EWFtaS0zNWQzMzA1YyITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3Jl +IhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmlt +YWdlTG9jYXRpb24iSGVjMi1wYWlkLWlibS1pbWFnZXMvaWJtLWxvdHVzLWZv +cm1zLXR1cmJvLTMuNS4xLTMyLWJpdC5tYW5pZmVzdC54bWwiEWFyY2hpdGVj +dHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1h +Z2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS0zNmZmMWE1ZiITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iPGVjMi1wdWJs +aWMtaW1hZ2VzL2ZlZG9yYS1jb3JlNi1iYXNlLXg4Nl82NC5tYW5pZmVzdC54 +bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETIwNjAy +OTYyMTUzMnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFw +cGluZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2UiDGltYWdlSWQiEWFt +aS0zYzQ3YTM1NSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRp +bWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdl +TG9jYXRpb24iM2VjMi1wdWJsaWMtaW1hZ2VzL2dldHRpbmctc3RhcnRlZC5t +YW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklk +IhEyMDYwMjk2MjE1MzJ7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0Rl +dmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1kZDRiYWNiNCIPaW1hZ2VT +dGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHBy +b2R1Y3RDb2RlIg1BOTQwOEI0QiINa2VybmVsSWQiEWFraS1kYjRiYWNiMiIM +aW1hZ2VJZCIRYW1pLTQzNGFhZDJhIhNyb290RGV2aWNlVHlwZSITaW5zdGFu +Y2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJ +dHJ1ZSISaW1hZ2VMb2NhdGlvbiJWZWMyLXBhaWQtaWJtLWltYWdlcy9pbmZv +cm1peC1keW5hbWljLXNlcnZlci13b3JrZ3JvdXAtZWRpdGlvbi02NC1iaXQu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9j +a0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1hNTFjZjljYyIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLWE3MWNmOWNlIgxp +bWFnZUlkIhFhbWktNDVlNzAwMmMiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5j +ZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0 +cnVlIhJpbWFnZUxvY2F0aW9uIkovYXdzLWNvbnNvbGUtcXVpY2tzdGFydC1h +bWlzL3RvbWNhdC8xLjEvdG9tY2F0cXVpY2tzdGFydC5tYW5pZmVzdC54bWwi +EWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3 +MTZ7ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcw +Ig5yYW1kaXNrSWQiEWFyaS00MmI5NWEyYiIPaW1hZ2VTdGF0ZSIOYXZhaWxh +YmxlIg1rZXJuZWxJZCIRYWtpLTZlYWE0OTA3IgxpbWFnZUlkIhFhbWktNDhh +YTQ5MjEiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VP +d25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0 +aW9uIjxlYzItcHVibGljLWltYWdlcy9mZWRvcmEtOC1pMzg2LWJhc2UtdjEu +MTAubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3du +ZXJJZCIRMjA2MDI5NjIxNTMyexIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxv +Y2tEZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktNzY0OGFmMWYiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsG +IhBwcm9kdWN0Q29kZSINRUE1RjA1QTMiDWtlcm5lbElkIhFha2ktODU0OWFl +ZWMiDGltYWdlSWQiEWFtaS00YzQ4YWYyNSITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iOmVjMi1wYWlkLWlibS1pbWFnZXMv +ZGIyLXdvcmtncm91cC02NC1iaXQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1 +cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7EiIOaW1h +Z2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNr +SWQiEWFyaS03NzQ4YWYxZSIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9k +dWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg1BNDgxODk1RCIN +a2VybmVsSWQiEWFraS04MTQ5YWVlOCIMaW1hZ2VJZCIRYW1pLTRkNDhhZjI0 +IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJB +bGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiI4 +ZWMyLXBhaWQtaWJtLWltYWdlcy9kYjItZXhwcmVzcy0zMi1iaXQubWFuaWZl +c3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcw +MjU0NTM0MDI0exIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VN +YXBwaW5nMCIOcmFtZGlza0lkIhFhcmktODEzZmRlZTgiD2ltYWdlU3RhdGUi +DmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0 +Q29kZSINNTc4QkY1QkEiDWtlcm5lbElkIhFha2ktOGIzZmRlZTIiDGltYWdl +SWQiEWFtaS00ZDRmYWUyNCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0 +b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUi +EmltYWdlTG9jYXRpb24iPmVjMi1wYWlkLWlibS1pbWFnZXMvbG90dXMtZm9y +bXMtdHVyYm8tMzItYml0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglp +Mzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsSIg5pbWFnZVR5cGUi +DG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJp +LTZjNDhhODA1Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rl +c3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDTQ5Q0E3MzA1Ig1rZXJuZWxJ +ZCIRYWtpLTY4NDhhODAxIgxpbWFnZUlkIhFhbWktNTA0OGE4MzkiE3Jvb3RE +ZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgth +bWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkdlYzItcGFp +ZC1pYm0taW1hZ2VzL2libS10aXZvbGktaXRtLTA2LjIxLjAzLjAwLTMyYi01 +MC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9j +a0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS02NDQ4YTgwZCIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYi +EHByb2R1Y3RDb2RlIg1DQ0VCMzY4QiINa2VybmVsSWQiEWFraS03YzQ4YTgx +NSIMaW1hZ2VJZCIRYW1pLTUyNDhhODNiIhNyb290RGV2aWNlVHlwZSITaW5z +dGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1Ymxp +YyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQtaWJtLWltYWdlcy9p +Ym0tdGl2b2xpLWl0bS0wNi4yMS4wMy4wMC0zMmItMjAwLm1hbmlmZXN0Lnht +bCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGlu +ZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2UiDGltYWdlSWQiEWFtaS01 +NjQ3YTMzZiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFn +ZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9j +YXRpb24iPGVjMi1wdWJsaWMtaW1hZ2VzL2ZlZG9yYS04LWkzODYtYmFzZS12 +MS4wOC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VP +d25lcklkIhEyMDYwMjk2MjE1MzJ7ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdi +bG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1hNTFjZjljYyIP +aW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLWE3MWNmOWNl +IgxpbWFnZUlkIhFhbWktNWVlNzAwMzciE3Jvb3REZXZpY2VUeXBlIhNpbnN0 +YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGlj +Igl0cnVlIhJpbWFnZUxvY2F0aW9uIkYvYXdzLWNvbnNvbGUtcXVpY2tzdGFy +dC1hbWlzL3J1YnkvMS4xL3J1YnlxdWlja3N0YXJ0Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNTYwNTgxOTcx +NnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAi +DnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9pbWFnZVN0YXRlIg5hdmFpbGFi +bGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2UiDGltYWdlSWQiEWFtaS02MGRh +M2QwOSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iQS9hd3MtY29uc29sZS1xdWlja3N0YXJ0LWFtaXMvcGhwcXVpY2tzdGFy +dC12MS40Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETIwNTYwNTgxOTcxNnsSIg5pbWFnZVR5cGUiDG1hY2hpbmUi +F2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLTlhNzA5MGYz +Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVt +WwZ7BiIQcHJvZHVjdENvZGUiDUUzRDQ4Q0VFIg1rZXJuZWxJZCIRYWtpLTg2 +NzA5MGVmIgxpbWFnZUlkIhFhbWktNjY3MTkxMGYiE3Jvb3REZXZpY2VUeXBl +IhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlz +UHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIlFlYzItcGFpZC1pYm0taW1h +Z2VzL3dlYnNwaGVyZS1hcHBsaWNhdGlvbi1zZXJ2ZXItNy4wLjAuMy0zMi1i +aXQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3du +ZXJJZCIRNDcwMjU0NTM0MDI0exIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxv +Y2tEZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktNjE3Nzk0MDgiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsG +IhBwcm9kdWN0Q29kZSINRDZGQjExMTMiDWtlcm5lbElkIhFha2ktNmY3Nzk0 +MDYiDGltYWdlSWQiEWFtaS02Nzc2OTUwZSITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iRGVjMi1wYWlkLWlibS1pbWFnZXMv +d2Vic3BoZXJlLXNtYXNoLTEuMS4xLjEtMzItYml0Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAy +NHsSIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAi +DnJhbWRpc2tJZCIRYXJpLTQ4NDhhZjIxIg9pbWFnZVN0YXRlIg5hdmFpbGFi +bGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDThG +Q0UzRUVCIg1rZXJuZWxJZCIRYWtpLTgyNDlhZWViIgxpbWFnZUlkIhFhbWkt +NmM1NWIyMDUiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIlplYzItcGFpZC1pYm0taW1hZ2VzL2xvdHVzLXdlYi1jb250ZW50 +LW1hbmFnZW1lbnQtc3RhbmRhcmQtZWRpdGlvbi02NC1iaXQubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAy +NTQ1MzQwMjR7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1h +cHBpbmcwIg5yYW1kaXNrSWQiEWFyaS00OTQ4YWYyMCIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RD +b2RlIg00NzZEMjlDQiINa2VybmVsSWQiEWFraS04MzQ5YWVlYSIMaW1hZ2VJ +ZCIRYW1pLTZmNTViMjA2IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJvZWMyLXBhaWQtaWJtLWltYWdlcy93ZWJzcGhlcmUt +cG9ydGFsLWFuZC1sb3R1cy13ZWItY29udGVudC1tYW5hZ2VtZW50LXN0YW5k +YXJkLWVkaXRpb24tNjQtYml0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJl +Igt4ODZfNjQiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exMiDmltYWdl +VHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lk +IhFhcmktNjQ1MWIzMGQiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVj +dENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRDZGNjA1MkEiDWtl +cm5lbElkIhFha2ktNjA1MWIzMDkiDGltYWdlSWQiEWFtaS03NDUxYjMxZCIT +cm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iRWVjMi1wYWlkLWlibS1pbWFnZXMt +aWRzL2libS1pZHMtZXhwcmVzcy0xMS41LXYyMDItMS5tYW5pZmVzdC54bWwi +EWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQw +MjR7EyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcw +Ig5yYW1kaXNrSWQiEWFyaS04OGU2MGJlMSIPaW1hZ2VTdGF0ZSIOYXZhaWxh +YmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg1B +NDgxODk1RCINa2VybmVsSWQiEWFraS1iY2U2MGJkNSIMaW1hZ2VJZCIRYW1p +LTc0ZTAwZDFkIhNyb290RGV2aWNlTmFtZSIOL2Rldi9zZGExIhNyb290RGV2 +aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1h +em9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQt +aWJtLWltYWdlcy1kYjIvaWJtLWRiMi1leHByZXNzLTkuNy5GUDEtMzItYml0 +Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVy +SWQiETQ3MDI1NDUzNDAyNHsUIgluYW1lIhxmZWRvcmEtOC1pMzg2LXYxLjE0 +LXN0ZCIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmd7 +BiIJaXRlbVsGewciCGVic3sIIg9zbmFwc2hvdElkIhJzbmFwLWI5YWEzNWQw +IhhkZWxldGVPblRlcm1pbmF0aW9uIgl0cnVlIg92b2x1bWVTaXplIgcxNSIP +ZGV2aWNlTmFtZSIOL2Rldi9zZGExIg5yYW1kaXNrSWQiEWFyaS05NmM1Mjdm +ZiIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLTk0YzUy +N2ZkIgxpbWFnZUlkIhFhbWktODRkYjM5ZWQiE3Jvb3REZXZpY2VOYW1lIg4v +ZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBlIghlYnMiEGRlc2NyaXB0aW9uIjZG +ZWRvcmEgOCB2MS4xNCBpMzg2IHN0ZC1yb290IGx2bS1zd2FwIGx2bS1zdG9y +YWdlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUi +EmltYWdlTG9jYXRpb24iI2FtYXpvbi9mZWRvcmEtOC1pMzg2LXYxLjE0LXN0 +ZCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYy +MTUzMnsUIgluYW1lIh5mZWRvcmEtOC14ODZfNjQtdjEuMTQtc3RkIg5pbWFn +ZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZ3sGIglpdGVtWwZ7 +ByIIZWJzewgiD3NuYXBzaG90SWQiEnNuYXAtYmJhYTM1ZDIiGGRlbGV0ZU9u +VGVybWluYXRpb24iCXRydWUiD3ZvbHVtZVNpemUiBzE1Ig9kZXZpY2VOYW1l +Ig4vZGV2L3NkYTEiDnJhbWRpc2tJZCIRYXJpLTU2Y2UyYzNmIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktNTRjZTJjM2QiDGltYWdl +SWQiEWFtaS04NmRiMzllZiITcm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSIT +cm9vdERldmljZVR5cGUiCGVicyIQZGVzY3JpcHRpb24iOEZlZG9yYSA4IHYx +LjE0IHg4Nl82NCBzdGQtcm9vdCBsdm0tc3dhcCBsdm0tc3RvcmFnZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIiVhbWF6b24vZmVkb3JhLTgteDg2XzY0LXYxLjE0LXN0ZCIRYXJj +aGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMy +exMiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBwaW5nMCIO +cmFtZGlza0lkIhFhcmktMzIzOGRhNWIiD2ltYWdlU3RhdGUiDmF2YWlsYWJs +ZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINN0E2 +M0Y5RkMiDWtlcm5lbElkIhFha2ktMzAzOGRhNTkiDGltYWdlSWQiEWFtaS1h +MDQ2YTRjOSITcm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSITcm9vdERldmlj +ZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpv +biINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iQGVjMi1wYWlkLWli +bS1pbWFnZXMvZXh0cmVtZXNjYWxlLTcwLTMyYml0LW5vaWQubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0 +NTM0MDI0exEiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBw +aW5nMCIOcmFtZGlza0lkIhFhcmktYTIzYWRmY2IiD2ltYWdlU3RhdGUiDmF2 +YWlsYWJsZSINa2VybmVsSWQiEWFraS1hNTNhZGZjYyIMaW1hZ2VJZCIRYW1p +LWEyMWFmZmNiIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJDZWMyLXB1YmxpYy1pbWFnZXMvZmVkb3JhLWNvcmUtNi14ODZf +NjQtYmFzZS12MS4wNi5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2 +XzY0IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsSIg5pbWFnZVR5cGUi +DG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJp +LTZkZWMwYzA0Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rl +c3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUVBNUYwNUEzIg1rZXJuZWxJ +ZCIRYWtpLTZiZWMwYzAyIgxpbWFnZUlkIhFhbWktYTIxY2ZjY2IiE3Jvb3RE +ZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgth +bWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIj5lYzItcGFp +ZC1pYm0taW1hZ2VzL2RiMi13b3JrZ3JvdXAtOS43LTY0LWJpdC5tYW5pZmVz +dC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3 +MDI1NDUzNDAyNHsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNl +TWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVz +ewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRUMxMjk3MDgiDGltYWdlSWQi +EWFtaS1hOGU3MDVjMSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3Jl +IhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmlt +YWdlTG9jYXRpb24iQWVjMi1wYWlkLWlibS1pbWFnZXMvaWJtLWluZm9zcGhl +cmUtaXMtd2luY2xpZW50Lm1hbmlmZXN0LnhtbCINcGxhdGZvcm0iDHdpbmRv +d3MiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1 +MzQwMjR7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBp +bmcwIg5yYW1kaXNrSWQiEWFyaS05MWViMGJmOCIPaW1hZ2VTdGF0ZSIOYXZh +aWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2Rl +Ig1BNDgxODk1RCINa2VybmVsSWQiEWFraS05ZmViMGJmNiIMaW1hZ2VJZCIR +YW1pLWFjMWNmY2M1IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUi +FGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1h +Z2VMb2NhdGlvbiI8ZWMyLXBhaWQtaWJtLWltYWdlcy9kYjItZXhwcmVzcy05 +LjctMzItYml0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFp +bWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsUIgluYW1lIiJnZXR0aW5nLXN0 +YXJ0ZWQtd2l0aC1lYnMtYm9vdCIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9j +a0RldmljZU1hcHBpbmd7BiIJaXRlbVsGewciCGVic3sIIg9zbmFwc2hvdElk +IhJzbmFwLWEwODkxMmM5IhhkZWxldGVPblRlcm1pbmF0aW9uIgl0cnVlIg92 +b2x1bWVTaXplIgcxNSIPZGV2aWNlTmFtZSIOL2Rldi9zZGExIg5yYW1kaXNr +SWQiEWFyaS05NmM1MjdmZiIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJu +ZWxJZCIRYWtpLTk0YzUyN2ZkIgxpbWFnZUlkIhFhbWktYjIzMmQwZGIiE3Jv +b3REZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBlIghlYnMi +EGRlc2NyaXB0aW9uIkxGZWRvcmEgOCB2MS4xNCBpMzg2IHN0ZC1yb290IGx2 +bS1zd2FwIGx2bS1zdG9yYWdlIGdldHRpbmctc3RhcnRlZC1ndWlkZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIilhbWF6b24vZ2V0dGluZy1zdGFydGVkLXdpdGgtZWJzLWJvb3Qi +EWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1 +MzJ7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcw +Ig5yYW1kaXNrSWQiEWFyaS03NDQ4YWYxZCIPaW1hZ2VTdGF0ZSIOYXZhaWxh +YmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg1E +NkZCMTExMyINa2VybmVsSWQiEWFraS04MDQ5YWVlOSIMaW1hZ2VJZCIRYW1p +LWI0NTRiM2RkIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiI8ZWMyLXBhaWQtaWJtLWltYWdlcy93ZWJzcGhlcmUtc21hc2gt +MzItYml0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDG1hY2hpbmUi +F2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIR +cHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINQTc5RUMw +REIiDGltYWdlSWQiEWFtaS1iZDlkNzhkNCITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iMWVjMi1wdWJsaWMtaW1hZ2VzL2Rl +bW8tcGFpZC1BTUkubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYi +EWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyexMiCW5hbWUiJldpbmRvd3Mt +U2VydmVyMjAwOC1pMzg2LUJhc2UtdjEwMyIOaW1hZ2VUeXBlIgxtYWNoaW5l +IhdibG9ja0RldmljZU1hcHBpbmd7BiIJaXRlbVsGewciCGVic3sIIg9zbmFw +c2hvdElkIhJzbmFwLTRjOWMyNzI0IhhkZWxldGVPblRlcm1pbmF0aW9uIgl0 +cnVlIg92b2x1bWVTaXplIgczMCIPZGV2aWNlTmFtZSIOL2Rldi9zZGExIg9p +bWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS1jM2U0MGRhYSIT +cm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSITcm9vdERldmljZVR5cGUiCGVi +cyIQZGVzY3JpcHRpb24iN01pY3Jvc29mdCBXaW5kb3dzIDIwMDggRGF0YWNl +bnRlciAzMi1iaXQgQU1JIHYxLjAzIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpv +biINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iLWFtYXpvbi9XaW5k +b3dzLVNlcnZlcjIwMDgtaTM4Ni1CYXNlLXYxMDMiDXBsYXRmb3JtIgx3aW5k +b3dzIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5 +NjIxNTMyexMiCW5hbWUiLFdpbmRvd3MtU2VydmVyMjAwOC1pMzg2LVNxbEV4 +cHJlc3MtdjEwMyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1h +cHBpbmd7BiIJaXRlbVsGewciCGVic3sIIg9zbmFwc2hvdElkIhJzbmFwLTVj +OWMyNzM0IhhkZWxldGVPblRlcm1pbmF0aW9uIgl0cnVlIg92b2x1bWVTaXpl +IgczMCIPZGV2aWNlTmFtZSIOL2Rldi9zZGExIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiDGltYWdlSWQiEWFtaS1jNWU0MGRhYyITcm9vdERldmljZU5hbWUi +Di9kZXYvc2RhMSITcm9vdERldmljZVR5cGUiCGVicyIQZGVzY3JpcHRpb24i +RU1pY3Jvc29mdCBXaW5kb3dzIDIwMDggRGF0YWNlbnRlciAzMi1iaXQsIFNx +bCBFeHByZXNzLCBBTUkgdjEuMDMiFGltYWdlT3duZXJBbGlhcyILYW1hem9u +Ig1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiIzYW1hem9uL1dpbmRv +d3MtU2VydmVyMjAwOC1pMzg2LVNxbEV4cHJlc3MtdjEwMyINcGxhdGZvcm0i +DHdpbmRvd3MiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEy +MDYwMjk2MjE1MzJ7EyIJbmFtZSIxV2luZG93cy1TZXJ2ZXIyMDAzUjIteDg2 +XzY0LVNxbFN0YW5kYXJkLXYxMDkiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxv +Y2tEZXZpY2VNYXBwaW5newYiCWl0ZW1bBnsHIghlYnN7CCIPc25hcHNob3RJ +ZCISc25hcC00ZDVmNDkyNCIYZGVsZXRlT25UZXJtaW5hdGlvbiIJdHJ1ZSIP +dm9sdW1lU2l6ZSIHMzAiD2RldmljZU5hbWUiDi9kZXYvc2RhMSIPaW1hZ2VT +dGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhbWktYzkxZmYwYTAiE3Jvb3RE +ZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBlIghlYnMiEGRl +c2NyaXB0aW9uIktNaWNyb3NvZnQgV2luZG93cyAyMDAzIFIyIDY0LWJpdCwg +U3FsIDIwMDUgU3RhbmRhcmQsIEFNSSBSZWxlYXNlIHYxLjA5IhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iOGFtYXpvbi9XaW5kb3dzLVNlcnZlcjIwMDNSMi14ODZfNjQtU3FsU3Rh +bmRhcmQtdjEwOSINcGxhdGZvcm0iDHdpbmRvd3MiEWFyY2hpdGVjdHVyZSIL +eDg2XzY0IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsTIg5pbWFnZVR5 +cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIR +YXJpLWZjZmQxMDk1Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RD +b2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUVBNUYwNUEzIg1rZXJu +ZWxJZCIRYWtpLWY4ZmQxMDkxIgxpbWFnZUlkIhFhbWktY2VmZDEwYTciE3Jv +b3REZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBlIhNpbnN0 +YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGlj +Igl0cnVlIhJpbWFnZUxvY2F0aW9uIkplYzItcGFpZC1pYm0taW1hZ2VzLWRi +Mi9pYm0tZGIyLXdvcmtncm91cC05LjcuRlAxLTY0LWJpdC5tYW5pZmVzdC54 +bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1 +NDUzNDAyNHsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFw +cGluZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2UiDGltYWdlSWQiEWFt +aS1kMWNhMmRiOCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRp +bWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdl +TG9jYXRpb24iQGF3cy10b29sa2l0LWZvci1lY2xpcHNlLWFtaXMtdXMvaGFw +cm94eS12MS4wLjIubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYi +EWltYWdlT3duZXJJZCIRMjA1NjA1ODE5NzE2exAiDmltYWdlVHlwZSIMbWFj +aGluZSIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxh +YmxlIgxpbWFnZUlkIhFhbWktZDkyMGMzYjAiE3Jvb3REZXZpY2VUeXBlIhNp +bnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVi +bGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkxlYzItcHVibGljLXdpbmRvd3Mt +aW1hZ2VzL1NxbFN2ckV4cDIwMDNyMi14ODZfNjQtV2luLXYxLjA3Lm1hbmlm +ZXN0LnhtbCINcGxhdGZvcm0iDHdpbmRvd3MiEWFyY2hpdGVjdHVyZSILeDg2 +XzY0IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsTIgluYW1lIihXaW5k +b3dzLVNlcnZlcjIwMDgteDg2XzY0LUJhc2UtdjEwMyIOaW1hZ2VUeXBlIgxt +YWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmd7BiIJaXRlbVsGewciCGVic3sI +Ig9zbmFwc2hvdElkIhJzbmFwLTI4OWMyNzQwIhhkZWxldGVPblRlcm1pbmF0 +aW9uIgl0cnVlIg92b2x1bWVTaXplIgczMCIPZGV2aWNlTmFtZSIOL2Rldi9z +ZGExIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS1kOWU0 +MGRiMCITcm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSITcm9vdERldmljZVR5 +cGUiCGVicyIQZGVzY3JpcHRpb24iN01pY3Jvc29mdCBXaW5kb3dzIDIwMDgg +RGF0YWNlbnRlciA2NC1iaXQgQU1JIHYxLjAzIhRpbWFnZU93bmVyQWxpYXMi +C2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iL2FtYXpv +bi9XaW5kb3dzLVNlcnZlcjIwMDgteDg2XzY0LUJhc2UtdjEwMyINcGxhdGZv +cm0iDHdpbmRvd3MiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVy +SWQiETIwNjAyOTYyMTUzMnsQIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJ +ZCIRYW1pLWRiMjBjM2IyIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJKZWMyLXB1YmxpYy13aW5kb3dzLWltYWdlcy9TcWxT +dnJFeHAyMDAzcjItaTM4Ni1XaW4tdjEuMDcubWFuaWZlc3QueG1sIg1wbGF0 +Zm9ybSIMd2luZG93cyIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVy +SWQiETIwNjAyOTYyMTUzMnsSIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLTlmM2ZkZWY2Ig9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQ +cHJvZHVjdENvZGUiDUQ2NjJFOTg5Ig1rZXJuZWxJZCIRYWtpLTliM2ZkZWYy +IgxpbWFnZUlkIhFhbWktZGI1Y2JkYjIiE3Jvb3REZXZpY2VUeXBlIhNpbnN0 +YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGlj +Igl0cnVlIhJpbWFnZUxvY2F0aW9uIkBlYzItcGFpZC1pYm0taW1hZ2VzL2xv +dHVzLW1hc2h1cC1jZW50ZXItMzItYml0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsTIglu +YW1lIi5XaW5kb3dzLVNlcnZlcjIwMDgteDg2XzY0LVNxbEV4cHJlc3MtdjEw +MyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmd7BiIJ +aXRlbVsGewciCGVic3sIIg9zbmFwc2hvdElkIhJzbmFwLTIyOWMyNzRhIhhk +ZWxldGVPblRlcm1pbmF0aW9uIgl0cnVlIg92b2x1bWVTaXplIgczMCIPZGV2 +aWNlTmFtZSIOL2Rldi9zZGExIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGlt +YWdlSWQiEWFtaS1kYmU0MGRiMiITcm9vdERldmljZU5hbWUiDi9kZXYvc2Rh +MSITcm9vdERldmljZVR5cGUiCGVicyIQZGVzY3JpcHRpb24iSU1pY3Jvc29m +dCBXaW5kb3dzIDIwMDggRGF0YWNlbnRlciA2NC1iaXQsIFNxbCAyMDA4IEV4 +cHJlc3MgQU1JIHYxLjAzIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iNWFtYXpvbi9XaW5kb3dzLVNl +cnZlcjIwMDgteDg2XzY0LVNxbEV4cHJlc3MtdjEwMyINcGxhdGZvcm0iDHdp +bmRvd3MiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETIw +NjAyOTYyMTUzMnsQIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNl +TWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1p +LWRkMjBjM2I0IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJJZWMyLXB1YmxpYy13aW5kb3dzLWltYWdlcy9TZXJ2ZXIyMDAz +cjIteDg2XzY0LVdpbi12MS4wNy5tYW5pZmVzdC54bWwiDXBsYXRmb3JtIgx3 +aW5kb3dzIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEy +MDYwMjk2MjE1MzJ7EyIJbmFtZSIvV2luZG93cy1TZXJ2ZXIyMDA4LXg4Nl82 +NC1TcWxTdGFuZGFyZC12MTAzIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2Nr +RGV2aWNlTWFwcGluZ3sGIglpdGVtWwZ7ByIIZWJzewgiD3NuYXBzaG90SWQi +EnNuYXAtMzQ5YzI3NWMiGGRlbGV0ZU9uVGVybWluYXRpb24iCXRydWUiD3Zv +bHVtZVNpemUiBzMwIg9kZXZpY2VOYW1lIg4vZGV2L3NkYTEiD2ltYWdlU3Rh +dGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLWRkZTQwZGI0IhNyb290RGV2 +aWNlTmFtZSIOL2Rldi9zZGExIhNyb290RGV2aWNlVHlwZSIIZWJzIhBkZXNj +cmlwdGlvbiJKTWljcm9zb2Z0IFdpbmRvd3MgMjAwOCBEYXRhY2VudGVyIDY0 +LWJpdCwgU3FsIDIwMDggU3RhbmRhcmQgQU1JIHYxLjAzIhRpbWFnZU93bmVy +QWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24i +NmFtYXpvbi9XaW5kb3dzLVNlcnZlcjIwMDgteDg2XzY0LVNxbFN0YW5kYXJk +LXYxMDMiDXBsYXRmb3JtIgx3aW5kb3dzIhFhcmNoaXRlY3R1cmUiC3g4Nl82 +NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIOaW1hZ2VUeXBlIgxt +YWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiDGltYWdlSWQiEWFtaS1kZjIwYzNiNiITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wdWJsaWMtd2luZG93 +cy1pbWFnZXMvU2VydmVyMjAwM3IyLWkzODYtV2luLXYxLjA3Lm1hbmlmZXN0 +LnhtbCINcGxhdGZvcm0iDHdpbmRvd3MiEWFyY2hpdGVjdHVyZSIJaTM4NiIR +aW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7EyIJbmFtZSIoV2luZG93cy1T +ZXJ2ZXIyMDAzUjItaTM4Ni1CYXNlLXYxMDkiDmltYWdlVHlwZSIMbWFjaGlu +ZSIXYmxvY2tEZXZpY2VNYXBwaW5newYiCWl0ZW1bBnsHIghlYnN7CCIPc25h +cHNob3RJZCISc25hcC03ZDVmNDkxNCIYZGVsZXRlT25UZXJtaW5hdGlvbiIJ +dHJ1ZSIPdm9sdW1lU2l6ZSIHMzAiD2RldmljZU5hbWUiDi9kZXYvc2RhMSIP +aW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhbWktZjExZmYwOTgi +E3Jvb3REZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBlIghl +YnMiEGRlc2NyaXB0aW9uIjZNaWNyb3NvZnQgV2luZG93cyAyMDAzIFIyIERh +dGFjZW50ZXIgMzItYml0IHYxLjA5IhRpbWFnZU93bmVyQWxpYXMiC2FtYXpv +biINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iL2FtYXpvbi9XaW5k +b3dzLVNlcnZlcjIwMDNSMi1pMzg2LUJhc2UtdjEwOSINcGxhdGZvcm0iDHdp +bmRvd3MiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYw +Mjk2MjE1MzJ7ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1h +cHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1iMzFjZjlkYSIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLWI1MWNmOWRjIgxpbWFnZUlkIhFh +bWktZjIxYWZmOWIiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIU +aW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFn +ZUxvY2F0aW9uIj5lYzItcHVibGljLWltYWdlcy9mZWRvcmEtOC14ODZfNjQt +YmFzZS12MS4wNi5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0 +IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsTIgluYW1lIi5XaW5kb3dz +LVNlcnZlcjIwMDNSMi1pMzg2LVNxbEV4cHJlc3MtdjEwOSIOaW1hZ2VUeXBl +IgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmd7BiIJaXRlbVsGewciCGVi +c3sIIg9zbmFwc2hvdElkIhJzbmFwLTczNWY0OTFhIhhkZWxldGVPblRlcm1p +bmF0aW9uIgl0cnVlIg92b2x1bWVTaXplIgczMCIPZGV2aWNlTmFtZSIOL2Rl +di9zZGExIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS1m +MzFmZjA5YSITcm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSITcm9vdERldmlj +ZVR5cGUiCGVicyIQZGVzY3JpcHRpb24iU01pY3Jvc29mdCBXaW5kb3dzIDIw +MDMgUjIgMzItYml0LCBJSVMgNi4wLCBTcWwgMjAwNSBFeHByZXNzLCBBTUkg +UmVsZWFzZSB2MS4wOSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVi +bGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIjVhbWF6b24vV2luZG93cy1TZXJ2 +ZXIyMDAzUjItaTM4Ni1TcWxFeHByZXNzLXYxMDkiDXBsYXRmb3JtIgx3aW5k +b3dzIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5 +NjIxNTMyexEiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBw +aW5nMCIOcmFtZGlza0lkIhFhcmktYTUxY2Y5Y2MiD2ltYWdlU3RhdGUiDmF2 +YWlsYWJsZSINa2VybmVsSWQiEWFraS1hNzFjZjljZSIMaW1hZ2VJZCIRYW1p +LWY1MWFmZjljIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiI8ZWMyLXB1YmxpYy1pbWFnZXMvZmVkb3JhLTgtaTM4Ni1iYXNl +LXYxLjA2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETIwNjAyOTYyMTUzMnsTIgluYW1lIipXaW5kb3dzLVNlcnZl +cjIwMDNSMi14ODZfNjQtQmFzZS12MTA5Ig5pbWFnZVR5cGUiDG1hY2hpbmUi +F2Jsb2NrRGV2aWNlTWFwcGluZ3sGIglpdGVtWwZ7ByIIZWJzewgiD3NuYXBz +aG90SWQiEnNuYXAtNzU1ZjQ5MWMiGGRlbGV0ZU9uVGVybWluYXRpb24iCXRy +dWUiD3ZvbHVtZVNpemUiBzMwIg9kZXZpY2VOYW1lIg4vZGV2L3NkYTEiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLWY1MWZmMDljIhNy +b290RGV2aWNlTmFtZSIOL2Rldi9zZGExIhNyb290RGV2aWNlVHlwZSIIZWJz +IhBkZXNjcmlwdGlvbiI2TWljcm9zb2Z0IFdpbmRvd3MgMjAwMyBSMiBEYXRh +Y2VudGVyIDY0LWJpdCB2MS4wOSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24i +DWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIjFhbWF6b24vV2luZG93 +cy1TZXJ2ZXIyMDAzUjIteDg2XzY0LUJhc2UtdjEwOSINcGxhdGZvcm0iDHdp +bmRvd3MiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETIw +NjAyOTYyMTUzMnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNl +TWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLTdjYjk1YTE1Ig9pbWFnZVN0YXRl +Ig5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTNkNzM3Y2EiDGltYWdlSWQi +EWFtaS1mNjFkZmQ5ZiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3Jl +IhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmlt +YWdlTG9jYXRpb24iPmVjMi1wdWJsaWMtaW1hZ2VzL2ZlZG9yYS04LXg4Nl82 +NC1iYXNlLXYxLjEwLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIgt4ODZf +NjQiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyexMiCW5hbWUiMFdpbmRv +d3MtU2VydmVyMjAwM1IyLXg4Nl82NC1TcWxFeHByZXNzLXYxMDkiDmltYWdl +VHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBwaW5newYiCWl0ZW1bBnsH +IghlYnN7CCIPc25hcHNob3RJZCISc25hcC00OTVmNDkyMCIYZGVsZXRlT25U +ZXJtaW5hdGlvbiIJdHJ1ZSIPdm9sdW1lU2l6ZSIHMzAiD2RldmljZU5hbWUi +Di9kZXYvc2RhMSIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFh +bWktZjcxZmYwOWUiE3Jvb3REZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3RE +ZXZpY2VUeXBlIghlYnMiEGRlc2NyaXB0aW9uIlNNaWNyb3NvZnQgV2luZG93 +cyAyMDAzIFIyIDY0LWJpdCwgSUlTIDYuMCwgU3FsIDIwMDUgRXhwcmVzcywg +QU1JIFJlbGVhc2UgdjEuMDkiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1p +c1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiI3YW1hem9uL1dpbmRvd3Mt +U2VydmVyMjAwM1IyLXg4Nl82NC1TcWxFeHByZXNzLXYxMDkiDXBsYXRmb3Jt +Igx3aW5kb3dzIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklk +IhEyMDYwMjk2MjE1MzJ7EyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0Rl +dmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1mNDU4YmE5ZCIPaW1hZ2VT +dGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHBy +b2R1Y3RDb2RlIg0yMUU5RUJDOSINa2VybmVsSWQiEWFraS1mODU4YmE5MSIM +aW1hZ2VJZCIRYW1pLWY4YWQ0MDkxIhNyb290RGV2aWNlTmFtZSIOL2Rldi9z +ZGExIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3du +ZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlv +biJjZWMyLXBhaWQtaWJtLWltYWdlcy1pbmZvc3BoZXJlL2libS1pbmZvc3Bo +ZXJlLWRhdGFzdGFnZS1xdWFsaXR5c3RhZ2Utc2VydmVyLTY0Yml0Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIR +NDcwMjU0NTM0MDI0exIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZp +Y2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktZmFmMDEyOTMiD2ltYWdlU3Rh +dGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9k +dWN0Q29kZSINRDY2MkU5ODkiDWtlcm5lbElkIhFha2ktZjhmMDEyOTEiDGlt +YWdlSWQiEWFtaS1mZWYwMTI5NyITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iQmVjMi1wYWlkLWlibS1pbWFnZXMvaWJtLW1h +c2h1cC1jZW50ZXItMi4wLTMyLWJpdC5tYW5pZmVzdC54bWwiEWFyY2hpdGVj +dHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1h +Z2VUeXBlIgxyYW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFyaS0wMjRhYTg2YiITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iRmVjMi1wYWlk +LWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjMwLXhlbi54ODZfNjQu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgxyYW1kaXNrIhdibG9j +a0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1 +Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUE5NDA4QjRCIgxp +bWFnZUlkIhFhcmktMGM1MWIzNjUiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5j +ZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0 +cnVlIhJpbWFnZUxvY2F0aW9uIkplYzItcGFpZC1pYm0taW1hZ2VzLWlkcy9p +bml0cmQtMi42LjE2LjYwLTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwi +EWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGlu +ZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0 +ZW1bBnsGIhBwcm9kdWN0Q29kZSINNTc4QkY1QkEiDGltYWdlSWQiEWFyaS0y +MWQzMzA0OCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFn +ZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9j +YXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0w +LjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglp +Mzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIgluYW1lIjZpbml0 +cmQtMi42LjE4LXhlblUtZWMyLXYxLjQuaTY4Ni5hcmkubWFuaWZlc3QueG1s +Ig5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJpLTIyNDJhMDRiIhNy +b290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlh +cyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMy +LXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4xOC14ZW5VLWVjMi12MS40Lmk2 +ODYuYXJpLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETIwNjAyOTYyMTUzMnsQIgluYW1lIjhpbml0cmQtMi42LjE4 +LXhlblUtZWMyLXYxLjQueDg2XzY0LmFyaS5tYW5pZmVzdC54bWwiDmltYWdl +VHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0 +ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhcmktMmM0MmEwNDUiE3Jvb3REZXZp +Y2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6 +b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkplYzItcHVibGlj +LWltYWdlcy9pbml0cmQtMi42LjE4LXhlblUtZWMyLXYxLjQueDg2XzY0LmFy +aS5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93 +bmVySWQiETIwNjAyOTYyMTUzMnsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Js +b2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1h +Z2VJZCIRYXJpLTMyMzhkYTViIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Ut +c3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1 +ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBhaWQtaWJtLWltYWdlcy9pbml0cmQt +Mi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNo +aXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0ew8i +DmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhcmktNDJiOTVhMmIiE3Jv +b3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFz +IgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIlBlYzIt +cHVibGljLWltYWdlcy9pbml0cmQtMi42LjIxLjctMi5mYzh4ZW4tZWMyLXYx +LjAuMS5pMzg2LmFyaS5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4 +NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIOaW1hZ2VUeXBlIgxy +YW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUi +DThGQ0UzRUVCIgxpbWFnZUlkIhFhcmktNDg0OGFmMjEiE3Jvb3REZXZpY2VU +eXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24i +DWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkZlYzItcGFpZC1pYm0t +aW1hZ2VzL2luaXRyZC0yLjYuMTYuNjAtMC4zMC14ZW4ueDg2XzY0Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIR +NDcwMjU0NTM0MDI0exAiDmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZp +Y2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29k +ZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg00NzZEMjlDQiIMaW1hZ2VJ +ZCIRYXJpLTQ5NDhhZjIwIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJGZWMyLXBhaWQtaWJtLWltYWdlcy9pbml0cmQtMi42 +LjE2LjYwLTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwiEWFyY2hpdGVj +dHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsPIg5p +bWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJpLTRmNThiOTI2IhNyb290 +RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyIL +YW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBh +aWQtaWJtLWltYWdlcy9pbml0cmQtMi42LjE2LjYwLTAuMjkteGVucGFlLmkz +ODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3du +ZXJJZCIRNDcwMjU0NTM0MDI0ew8iDmltYWdlVHlwZSIMcmFtZGlzayIXYmxv +Y2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFn +ZUlkIhFhcmktNGZkZjNmMjYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1z +dG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVl +IhJpbWFnZUxvY2F0aW9uIlBlYzItcHVibGljLWltYWdlcy9pbml0cmQtMi42 +LjIxLjctMi5mYzh4ZW4tZWMyLXYxLjAueDg2XzY0LmFyaS5tYW5pZmVzdC54 +bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETIwNjAy +OTYyMTUzMnsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFw +cGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJpLTU2 +Y2UyYzNmIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdl +T3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2Nh +dGlvbiJQZWMyLXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4yMS43LTIuZWMy +LnYxLjIuZmM4eGVuLng4Nl82NC5hcmkubWFuaWZlc3QueG1sIhFhcmNoaXRl +Y3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIO +aW1hZ2VUeXBlIgxyYW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFyaS02MDRhYTgwOSITcm9v +dERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMi +C2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1w +YWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5p +Mzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93 +bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Js +b2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJv +ZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRDZGQjExMTMi +DGltYWdlSWQiEWFyaS02MTc3OTQwOCITcm9vdERldmljZVR5cGUiE2luc3Rh +bmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMi +CXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMvaW5p +dHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAy +NHsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAi +D2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1b +BnsGIhBwcm9kdWN0Q29kZSINQ0NFQjM2OEIiDGltYWdlSWQiEWFyaS02NDQ4 +YTgwZCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iR2VjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5 +LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2 +IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDHJh +bWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWls +YWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSIN +RDZGNjA1MkEiDGltYWdlSWQiEWFyaS02NDUxYjMwZCITcm9vdERldmljZVR5 +cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiIN +aXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1p +bWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3 +MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNl +TWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJp +LTY0Yjk1ZTBkIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJKZWMyLXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4xOC14ZW5V +LWVjMi12MS4wLng4Nl82NC5hcmkubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1 +cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIOaW1h +Z2VUeXBlIgxyYW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFyaS02NTkxNzEwYyITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlk +LWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2 +Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVy +SWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVj +dENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINODBFRDAwQjgiDGlt +YWdlSWQiEWFyaS02NjQ4YTgwZiITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJk +LTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJj +aGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsP +Ig5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJpLTY3Yjk1ZTBlIhNy +b290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlh +cyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMy +LXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4xOC14ZW5VLWVjMi12MS4wLmkz +ODYuYXJpLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETIwNjAyOTYyMTUzMnsQIg5pbWFnZVR5cGUiDHJhbWRpc2si +F2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIR +cHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINNDlDQTcz +MDUiDGltYWdlSWQiEWFyaS02YzQ4YTgwNSITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMv +aW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0Lnht +bCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGlu +ZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0 +ZW1bBnsGIhBwcm9kdWN0Q29kZSINRUE1RjA1QTMiDGltYWdlSWQiEWFyaS02 +ZGVjMGMwNCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFn +ZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9j +YXRpb24iRmVjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0w +LjMwLXhlbi54ODZfNjQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4 +Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBl +IgxyYW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENv +ZGUiDUQ2RkIxMTEzIgxpbWFnZUlkIhFhcmktNzQ0OGFmMWQiE3Jvb3REZXZp +Y2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6 +b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkdlYzItcGFpZC1p +Ym0taW1hZ2VzL2luaXRyZC0yLjYuMTYuNjAtMC4yOS14ZW5wYWUuaTM4Ni5t +YW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklk +IhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgxyYW1kaXNrIhdibG9ja0Rl +dmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RD +b2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUVBNUYwNUEzIgxpbWFn +ZUlkIhFhcmktNzY0OGFmMWYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1z +dG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVl +IhJpbWFnZUxvY2F0aW9uIkZlYzItcGFpZC1pYm0taW1hZ2VzL2luaXRyZC0y +LjYuMTYuNjAtMC4zMC14ZW4ueDg2XzY0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAi +DmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYi +EHByb2R1Y3RDb2RlIg1BNDgxODk1RCIMaW1hZ2VJZCIRYXJpLTc3NDhhZjFl +IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJB +bGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJH +ZWMyLXBhaWQtaWJtLWltYWdlcy9pbml0cmQtMi42LjE2LjYwLTAuMjkteGVu +cGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWlt +YWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0ew8iDmltYWdlVHlwZSIMcmFtZGlz +ayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxl +IgxpbWFnZUlkIhFhcmktN2NiOTVhMTUiE3Jvb3REZXZpY2VUeXBlIhNpbnN0 +YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGlj +Igl0cnVlIhJpbWFnZUxvY2F0aW9uIlJlYzItcHVibGljLWltYWdlcy9pbml0 +cmQtMi42LjIxLjctMi5mYzh4ZW4tZWMyLXYxLjAuMS54ODZfNjQuYXJpLm1h +bmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJ +ZCIRMjA2MDI5NjIxNTMyexAiDmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tE +ZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0 +Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg01NzhCRjVCQSIMaW1h +Z2VJZCIRYXJpLTgxM2ZkZWU4IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Ut +c3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1 +ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBhaWQtaWJtLWltYWdlcy9pbml0cmQt +Mi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNo +aXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAi +DmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYi +EHByb2R1Y3RDb2RlIg1BNDgxODk1RCIMaW1hZ2VJZCIRYXJpLTg4ZTYwYmUx +IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJB +bGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJL +ZWMyLXBhaWQtaWJtLWltYWdlcy1kYjIvaW5pdHJkLTIuNi4xNi42MC0wLjI5 +LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2 +IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDHJh +bWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWls +YWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSIN +QTQ4MTg5NUQiDGltYWdlSWQiEWFyaS05MWViMGJmOCITcm9vdERldmljZVR5 +cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiIN +aXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1p +bWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3 +MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNl +TWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJp +LTk2YzUyN2ZmIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJOZWMyLXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4yMS43LTIu +ZWMyLnYxLjIuZmM4eGVuLmk2ODYuYXJpLm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsQIg5p +bWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBw +cm9kdWN0Q29kZSINRTNENDhDRUUiDGltYWdlSWQiEWFyaS05YTcwOTBmMyIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2Vj +Mi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBh +ZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDHJhbWRpc2si +F2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIR +cHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRDY2MkU5 +ODkiDGltYWdlSWQiEWFyaS05ZjNmZGVmNiITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMv +aW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0Lnht +bCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGlu +ZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJpLWEyM2Fk +ZmNiIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3du +ZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlv +biJDZWMyLXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4yMC0xLjMwMDIuZmM2 +eGVuLmFyaS5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFp +bWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsPIg5pbWFnZVR5cGUiDHJhbWRp +c2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJs +ZSIMaW1hZ2VJZCIRYXJpLWE1MWNmOWNjIhNyb290RGV2aWNlVHlwZSITaW5z +dGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1Ymxp +YyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJFZWMyLXB1YmxpYy1pbWFnZXMvZWMy +LWluaXRyZC0yLjYuMjEuNy0yLmZjOHhlbi5pMzg2Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUz +MnsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAi +D2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1b +BnsGIhBwcm9kdWN0Q29kZSINRDZGNjA1MkEiDGltYWdlSWQiEWFyaS1iMjRi +YWNkYiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iR2VjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5 +LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2 +IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiDHJh +bWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWls +YWJsZSIMaW1hZ2VJZCIRYXJpLWIzMWNmOWRhIhNyb290RGV2aWNlVHlwZSIT +aW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1 +YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXB1YmxpYy1pbWFnZXMv +ZWMyLWluaXRyZC0yLjYuMjEuNy0yLmZjOHhlbi54ODZfNjQubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYw +Mjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgxyYW1kaXNrIhdibG9ja0RldmljZU1h +cHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFyaS1i +YWYyMTBkMyITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFn +ZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9j +YXRpb24iRmVjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0w +LjMwLXhlbi54ODZfNjQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4 +Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1hZ2VUeXBl +IgxyYW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiDGltYWdlSWQiEWFyaS1iZGU3MDdkNCITcm9vdERldmljZVR5 +cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiIN +aXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1p +bWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3 +MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNl +TWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJp +LWRiYzEyMWIyIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJIZWMyLXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4xOC14ZW5V +LWVjMi12MS4yLmkzODYuYXJpLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJl +IglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsQIg5pbWFnZVR5 +cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUi +DmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0 +Q29kZSINQTk0MDhCNEIiDGltYWdlSWQiEWFyaS1kZDRiYWNiNCITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iRmVjMi1wYWlk +LWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjMwLXhlbi54ODZfNjQu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1hZ2VUeXBlIgxyYW1kaXNrIhdibG9j +a0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdl +SWQiEWFyaS1lM2MxMjE4YSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0 +b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUi +EmltYWdlTG9jYXRpb24iSmVjMi1wdWJsaWMtaW1hZ2VzL2luaXRyZC0yLjYu +MTgteGVuVS1lYzItdjEuMi54ODZfNjQuYXJpLm1hbmlmZXN0LnhtbCIRYXJj +aGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMy +ew8iDmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIP +aW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhcmktZTdkYzNjOGUi +E3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFs +aWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIk5l +YzItcHVibGljLWltYWdlcy9pbml0cmQtMi42LjIxLjctMi5mYzh4ZW4tZWMy +LXYxLjAuaTM4Ni5hcmkubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkz +ODYiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyexAiDmltYWdlVHlwZSIM +cmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZh +aWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2Rl +Ig0yMUU5RUJDOSIMaW1hZ2VJZCIRYXJpLWY0NThiYTlkIhNyb290RGV2aWNl +VHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9u +Ig1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJRZWMyLXBhaWQtaWJt +LWltYWdlcy1pbmZvc3BoZXJlL2luaXRyZC0yLjYuMTYuNjAtMC4zMC14ZW4u +eDg2XzY0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIgt4ODZfNjQiEWlt +YWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAiDmltYWdlVHlwZSIMcmFtZGlz +ayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxl +IhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg1ENjYy +RTk4OSIMaW1hZ2VJZCIRYXJpLWZhZjAxMjkzIhNyb290RGV2aWNlVHlwZSIT +aW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1 +YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBhaWQtaWJtLWltYWdl +cy9pbml0cmQtMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0 +NTM0MDI0exAiDmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBw +aW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJ +aXRlbVsGewYiEHByb2R1Y3RDb2RlIg1FQTVGMDVBMyIMaW1hZ2VJZCIRYXJp +LWZjZmQxMDk1IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJKZWMyLXBhaWQtaWJtLWltYWdlcy1kYjIvaW5pdHJkLTIuNi4x +Ni42MC0wLjMwLXhlbi54ODZfNjQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1 +cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjQiDnJlcXVl +c3RJZCIpY2JiMjAwYmItMjMxYS00NGNmLWIzNzItN2FkYmRkZDAzMzhiIgp4 +bWxucyItaHR0cDovL2VjMi5hbWF6b25hd3MuY29tL2RvYy8yMDA5LTExLTMw +Lw== diff --git a/tests/ec2/support/ec2/create_describe_images.45eee35ec8f8243c05d85cf5486c54368be8207e b/tests/ec2/support/ec2/create_describe_images.45eee35ec8f8243c05d85cf5486c54368be8207e new file mode 100644 index 0000000..17a2950 --- /dev/null +++ b/tests/ec2/support/ec2/create_describe_images.45eee35ec8f8243c05d85cf5486c54368be8207e @@ -0,0 +1,11 @@ +BAh7CCIOaW1hZ2VzU2V0ewYiCWl0ZW1bBnsRIg5pbWFnZVR5cGUiDG1hY2hp +bmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNm +OWNjIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTcx +Y2Y5Y2UiDGltYWdlSWQiEWFtaS0xMWNhMmQ3OCITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iP2F3cy10b29sa2l0LWZvci1l +Y2xpcHNlLWFtaXMtdXMvdG9tY2F0LXYxLjAuMC5tYW5pZmVzdC54bWwiEWFy +Y2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3MTYi +DnJlcXVlc3RJZCIpZjhkNzljNGEtN2RiYi00Nzg0LWI0OTUtMDExYzllNDVi +ZGRmIgp4bWxucyItaHR0cDovL2VjMi5hbWF6b25hd3MuY29tL2RvYy8yMDA5 +LTExLTMwLw== diff --git a/tests/ec2/support/ec2/create_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 b/tests/ec2/support/ec2/create_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 new file mode 100644 index 0000000..60c1614 --- /dev/null +++ b/tests/ec2/support/ec2/create_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 @@ -0,0 +1,19 @@ +BAh7CCIOcmVxdWVzdElkIilmMzJmMWJkNi0zZGM2LTQ2MjMtYTg3MC01MWYy +Y2Q2NTdhNDQiE3Jlc2VydmF0aW9uU2V0ewYiCWl0ZW1bBnsJIhJyZXNlcnZh +dGlvbklkIg9yLTBkOWI2NDY2Ig1ncm91cFNldHsGIglpdGVtWwZ7BiIMZ3Jv +dXBJZCIMZGVmYXVsdCIRaW5zdGFuY2VzU2V0ewYiCWl0ZW1bBnsZIhVwcml2 +YXRlSXBBZGRyZXNzIhIxMC4yNTQuOTcuMTg4IgxrZXlOYW1lIgx0ZXN0aW5n +IhdibG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1hNTFjZjlj +YyIRcHJvZHVjdENvZGVzMCIOaXBBZGRyZXNzIhIxODQuNzMuODQuMTk1Ig1r +ZXJuZWxJZCIRYWtpLWE3MWNmOWNlIg9sYXVuY2hUaW1lIh0yMDEwLTA1LTE4 +VDExOjQ0OjM1LjAwMFoiE2FtaUxhdW5jaEluZGV4IgYwIgxpbWFnZUlkIhFh +bWktMTFjYTJkNzgiEWluc3RhbmNlVHlwZSINbTEuc21hbGwiC3JlYXNvbjAi +E3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIOcGxhY2VtZW50ewYi +FWF2YWlsYWJpbGl0eVpvbmUiD3VzLWVhc3QtMWEiD2luc3RhbmNlSWQiD2kt +ZTc0MjY2OGMiE3ByaXZhdGVEbnNOYW1lIi5kb21VLTEyLTMxLTM5LTAwLTVF +LTMyLmNvbXB1dGUtMS5pbnRlcm5hbCIMZG5zTmFtZSIuZWMyLTE4NC03My04 +NC0xOTUuY29tcHV0ZS0xLmFtYXpvbmF3cy5jb20iEWFyY2hpdGVjdHVyZSIJ +aTM4NiIPbW9uaXRvcmluZ3sGIgpzdGF0ZSIMZW5hYmxlZCISaW5zdGFuY2VT +dGF0ZXsHIgluYW1lIgxydW5uaW5nIgljb2RlIgcxNiIMb3duZXJJZCIRMjkz +Nzg3NzQ5ODg0Igp4bWxucyItaHR0cDovL2VjMi5hbWF6b25hd3MuY29tL2Rv +Yy8yMDA5LTExLTMwLw== diff --git a/tests/ec2/support/ec2/create_run_instances.698df7f7a613449c42d1bcea2ba275b2bc598db5 b/tests/ec2/support/ec2/create_run_instances.698df7f7a613449c42d1bcea2ba275b2bc598db5 new file mode 100644 index 0000000..d599c0e --- /dev/null +++ b/tests/ec2/support/ec2/create_run_instances.698df7f7a613449c42d1bcea2ba275b2bc598db5 @@ -0,0 +1,15 @@ +BAh7CyIScmVzZXJ2YXRpb25JZCIPci04N2ZmMDBlYyINZ3JvdXBTZXR7BiIJ +aXRlbVsGewYiDGdyb3VwSWQiDGRlZmF1bHQiDnJlcXVlc3RJZCIpYzMzYjZk +ZDctMDZhMC00ZGUzLTg1OTMtNWY4MTM2M2VmZTYzIhFpbnN0YW5jZXNTZXR7 +BiIJaXRlbVsGexYiEHN0YXRlUmVhc29uewciCWNvZGUiDHBlbmRpbmciDG1l +c3NhZ2UiDHBlbmRpbmciF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJ +ZCIRYXJpLWE1MWNmOWNjIhFwcm9kdWN0Q29kZXMwIg1rZXJuZWxJZCIRYWtp +LWE3MWNmOWNlIg9sYXVuY2hUaW1lIh0yMDEwLTA1LTE4VDEzOjIxOjU0LjAw +MFoiE2FtaUxhdW5jaEluZGV4IgYwIgxpbWFnZUlkIhFhbWktMTFjYTJkNzgi +EWluc3RhbmNlVHlwZSINbTEuc21hbGwiC3JlYXNvbjAiE3Jvb3REZXZpY2VU +eXBlIhNpbnN0YW5jZS1zdG9yZSIOcGxhY2VtZW50ewYiFWF2YWlsYWJpbGl0 +eVpvbmUiD3VzLWVhc3QtMWEiD2luc3RhbmNlSWQiD2ktOTMyODBjZjgiE3By +aXZhdGVEbnNOYW1lMCIMZG5zTmFtZTAiD21vbml0b3Jpbmd7BiIKc3RhdGUi +DHBlbmRpbmciEmluc3RhbmNlU3RhdGV7ByIJbmFtZSIMcGVuZGluZyIJY29k +ZSIGMCIMb3duZXJJZCIRMjkzNzg3NzQ5ODg0Igp4bWxucyItaHR0cDovL2Vj +Mi5hbWF6b25hd3MuY29tL2RvYy8yMDA5LTExLTMwLw== diff --git a/tests/ec2/support/ec2/describe_availability_zones.da39a3ee5e6b4b0d3255bfef95601890afd80709 b/tests/ec2/support/ec2/describe_availability_zones.da39a3ee5e6b4b0d3255bfef95601890afd80709 new file mode 100644 index 0000000..4ebc9f4 --- /dev/null +++ b/tests/ec2/support/ec2/describe_availability_zones.da39a3ee5e6b4b0d3255bfef95601890afd80709 @@ -0,0 +1,11 @@ +BAh7CCIZYXZhaWxhYmlsaXR5Wm9uZUluZm97BiIJaXRlbVsJewkiD21lc3Nh +Z2VTZXQwIg9yZWdpb25OYW1lIg51cy1lYXN0LTEiDXpvbmVOYW1lIg91cy1l +YXN0LTFhIg56b25lU3RhdGUiDmF2YWlsYWJsZXsJIg9tZXNzYWdlU2V0MCIP +cmVnaW9uTmFtZSIOdXMtZWFzdC0xIg16b25lTmFtZSIPdXMtZWFzdC0xYiIO +em9uZVN0YXRlIg5hdmFpbGFibGV7CSIPbWVzc2FnZVNldDAiD3JlZ2lvbk5h +bWUiDnVzLWVhc3QtMSINem9uZU5hbWUiD3VzLWVhc3QtMWMiDnpvbmVTdGF0 +ZSIOYXZhaWxhYmxlewkiD21lc3NhZ2VTZXQwIg9yZWdpb25OYW1lIg51cy1l +YXN0LTEiDXpvbmVOYW1lIg91cy1lYXN0LTFkIg56b25lU3RhdGUiDmF2YWls +YWJsZSIOcmVxdWVzdElkIikxZjQ0NWZlMy02OGYzLTRjOGYtYmM5Ny0zZTlh +NWRiZThmNjQiCnhtbG5zIi1odHRwOi8vZWMyLmFtYXpvbmF3cy5jb20vZG9j +LzIwMDktMTEtMzAv diff --git a/tests/ec2/support/ec2/describe_images.1d05fa88d294d07beed14334421b46d322385188 b/tests/ec2/support/ec2/describe_images.1d05fa88d294d07beed14334421b46d322385188 new file mode 100644 index 0000000..e9ca6b2 --- /dev/null +++ b/tests/ec2/support/ec2/describe_images.1d05fa88d294d07beed14334421b46d322385188 @@ -0,0 +1,1338 @@ +BAh7CCIOaW1hZ2VzU2V0ewYiCWl0ZW1bAax7ECIOaW1hZ2VUeXBlIgtrZXJu +ZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJs +ZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINQTk0 +MDhCNEIiDGltYWdlSWQiEWFraS0wMjUxYjM2YiITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iS2VjMi1wYWlkLWlibS1pbWFn +ZXMtaWRzL3ZtbGludXotMi42LjE2LjYwLTAuMzAteGVuLng4Nl82NC5tYW5p +ZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQi +ETQ3MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZp +Y2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFh +a2ktMGE0YWE4NjMiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIU +aW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFn +ZUxvY2F0aW9uIkdlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2 +LjYwLTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVy +ZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsPIg5pbWFn +ZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0 +ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFha2ktMTJmMDEyN2IiE3Jvb3REZXZp +Y2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6 +b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1p +Ym0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJ +ZCIRNDcwMjU0NTM0MDI0exAiCW5hbWUiOXZtbGludXotMi42LjE4LXhlblUt +ZWMyLXYxLjQueDg2XzY0LmFraS5tYW5pZmVzdC54bWwiDmltYWdlVHlwZSIL +a2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiDGltYWdlSWQiEWFraS0yYTQyYTA0MyITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iS2VjMi1wdWJsaWMtaW1hZ2Vz +L3ZtbGludXotMi42LjE4LXhlblUtZWMyLXYxLjQueDg2XzY0LmFraS5tYW5p +ZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQi +ETIwNjAyOTYyMTUzMnsQIg5pbWFnZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZp +Y2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29k +ZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg01NzhCRjVCQSIMaW1hZ2VJ +ZCIRYWtpLTJkZDMzMDQ0IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQtaWJtLWltYWdlcy92bWxpbnV6LTIu +Ni4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsPIg5p +bWFnZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VT +dGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFha2ktMzAzOGRhNTkiE3Jvb3RE +ZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgth +bWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFp +ZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkz +ODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3du +ZXJJZCIRNDcwMjU0NTM0MDI0ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9j +a0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdl +SWQiEWFraS00NmU3MDAyZiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0 +b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUi +EmltYWdlTG9jYXRpb24iOWFraS1saW51eC4yLjYuMjEuNy0yLmZjOHhlbi14 +ZnMvdm1saW51ei5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIR +aW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgtrZXJu +ZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJs +ZSIMaW1hZ2VJZCIRYWtpLTRkNThiOTI0IhNyb290RGV2aWNlVHlwZSITaW5z +dGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1Ymxp +YyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQtaWJtLWltYWdlcy92 +bWxpbnV6LTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0Lnht +bCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsPIg5pbWFnZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5n +MCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFha2ktNTRjZTJj +M2QiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25l +ckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9u +IlFlYzItcHVibGljLWltYWdlcy92bWxpbnV6LTIuNi4yMS43LTIuZWMyLnYx +LjIuZmM4eGVuLng4Nl82NC5ha2kubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1 +cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIJbmFt +ZSI3dm1saW51ei0yLjYuMTgteGVuVS1lYzItdjEuNC5pNjg2LmFraS5tYW5p +ZmVzdC54bWwiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBp +bmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS01NjQy +YTAzZiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iSWVjMi1wdWJsaWMtaW1hZ2VzL3ZtbGludXotMi42LjE4LXhlblUtZWMy +LXYxLjQuaTY4Ni5ha2kubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkz +ODYiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyexAiDmltYWdlVHlwZSIL +a2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUi +DUQ2RjYwNTJBIgxpbWFnZUlkIhFha2ktNjA1MWIzMDkiE3Jvb3REZXZpY2VU +eXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24i +DWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1pYm0t +aW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFu +aWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIR +NDcwMjU0NTM0MDI0ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0Rldmlj +ZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFr +aS02MjQ4YTgwYiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRp +bWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdl +TG9jYXRpb24iSGVjMi1wYWlkLWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYu +NjAtMC4yOS14ZW5wYWUuaTM4Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVy +ZSIJaTM4NiIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VU +eXBlIgtrZXJuZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUi +DmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0 +Q29kZSINNDlDQTczMDUiDGltYWdlSWQiEWFraS02ODQ4YTgwMSITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iSGVjMi1wYWlk +LWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYuNjAtMC4yOS14ZW5wYWUuaTM4 +Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVj +dENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRUE1RjA1QTMiDGlt +YWdlSWQiEWFraS02YmVjMGMwMiITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMvdm1saW51 +ei0yLjYuMTYuNjAtMC4zMC14ZW4ueDg2XzY0Lm1hbmlmZXN0LnhtbCIRYXJj +aGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0 +ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9p +bWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS02ZWFhNDkwNyIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iTWVj +Mi1wdWJsaWMtaW1hZ2VzL3ZtbGludXotMi42LjIxLTIuZmM4eGVuLWVjMi12 +MS4wLmkzODYuYWtpLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2 +IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsQIg5pbWFnZVR5cGUiC2tl +cm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxh +YmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg1E +NkZCMTExMyIMaW1hZ2VJZCIRYWtpLTZmNzc5NDA2IhNyb290RGV2aWNlVHlw +ZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1p +c1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQtaWJtLWlt +YWdlcy92bWxpbnV6LTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3 +MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VN +YXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFha2kt +NmY5MTcxMDYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIkhlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYw +LTAuMjkteGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUi +CWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAiDmltYWdlVHlw +ZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENv +ZGUiDUNDRUIzNjhCIgxpbWFnZUlkIhFha2ktN2M0OGE4MTUiE3Jvb3REZXZp +Y2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6 +b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1p +Ym0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJ +ZCIRNDcwMjU0NTM0MDI0exAiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0Rl +dmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RD +b2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDTgwRUQwMEI4IgxpbWFn +ZUlkIhFha2ktN2U0OGE4MTciE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1z +dG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVl +IhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXot +Mi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNo +aXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAi +DmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQ +cHJvZHVjdENvZGUiDUQ2RkIxMTEzIgxpbWFnZUlkIhFha2ktODA0OWFlZTki +E3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFs +aWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhl +YzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVu +cGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWlt +YWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAiDmltYWdlVHlwZSILa2VybmVs +IhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUi +EXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUE0ODE4 +OTVEIgxpbWFnZUlkIhFha2ktODE0OWFlZTgiE3Jvb3REZXZpY2VUeXBlIhNp +bnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVi +bGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1pYm0taW1hZ2Vz +L3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0 +NTM0MDI0exAiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBp +bmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglp +dGVtWwZ7BiIQcHJvZHVjdENvZGUiDThGQ0UzRUVCIgxpbWFnZUlkIhFha2kt +ODI0OWFlZWIiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIkdlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYw +LTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIL +eDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5 +cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RD +b2RlIg00NzZEMjlDQiIMaW1hZ2VJZCIRYWtpLTgzNDlhZWVhIhNyb290RGV2 +aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1h +em9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBhaWQt +aWJtLWltYWdlcy92bWxpbnV6LTIuNi4xNi42MC0wLjMwLXhlbi54ODZfNjQu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVj +dENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRUE1RjA1QTMiDGlt +YWdlSWQiEWFraS04NTQ5YWVlYyITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMvdm1saW51 +ei0yLjYuMTYuNjAtMC4zMC14ZW4ueDg2XzY0Lm1hbmlmZXN0LnhtbCIRYXJj +aGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0 +exAiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9p +bWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7 +BiIQcHJvZHVjdENvZGUiDUUzRDQ4Q0VFIgxpbWFnZUlkIhFha2ktODY3MDkw +ZWYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25l +ckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9u +IkhlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkt +eGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYi +EWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAiDmltYWdlVHlwZSILa2Vy +bmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFi +bGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDTU3 +OEJGNUJBIgxpbWFnZUlkIhFha2ktOGIzZmRlZTIiE3Jvb3REZXZpY2VUeXBl +IhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlz +UHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1pYm0taW1h +Z2VzL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZl +c3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcw +MjU0NTM0MDI0ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1h +cHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS05 +NGM1MjdmZCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFn +ZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9j +YXRpb24iT2VjMi1wdWJsaWMtaW1hZ2VzL3ZtbGludXotMi42LjIxLjctMi5l +YzIudjEuMi5mYzh4ZW4uaTY4Ni5ha2kubWFuaWZlc3QueG1sIhFhcmNoaXRl +Y3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyew8iDmlt +YWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS05NjQ1YTdmZiITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iSGVjMi1wYWlk +LWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYuNjAtMC4yOS14ZW5wYWUuaTM4 +Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJ +ZCIRYWtpLTk4MDBlNWYxIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJLZWMyLXB1YmxpYy1pbWFnZXMvdm1saW51ei0yLjYu +MTgteGVuVS1lYzItdjEuMC54ODZfNjQuYWtpLm1hbmlmZXN0LnhtbCIRYXJj +aGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMy +ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9p +bWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS05YjAwZTVmMiIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iSWVj +Mi1wdWJsaWMtaW1hZ2VzL3ZtbGludXotMi42LjE4LXhlblUtZWMyLXYxLjAu +aTM4Ni5ha2kubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWlt +YWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyexAiDmltYWdlVHlwZSILa2VybmVs +IhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUi +EXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUQ2NjJF +OTg5IgxpbWFnZUlkIhFha2ktOWIzZmRlZjIiE3Jvb3REZXZpY2VUeXBlIhNp +bnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVi +bGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkhlYzItcGFpZC1pYm0taW1hZ2Vz +L3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0 +NTM0MDI0exAiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBp +bmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglp +dGVtWwZ7BiIQcHJvZHVjdENvZGUiDUE0ODE4OTVEIgxpbWFnZUlkIhFha2kt +OWZlYjBiZjYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIkhlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYw +LTAuMjkteGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUi +CWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0ew8iDmltYWdlVHlw +ZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiDGltYWdlSWQiEWFraS1hM2Q3MzdjYSITcm9vdERldmljZVR5 +cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiIN +aXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iT2VjMi1wdWJsaWMtaW1h +Z2VzL3ZtbGludXotMi42LjIxLTIuZmM4eGVuLWVjMi12MS4wLng4Nl82NC5h +a2kubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VP +d25lcklkIhEyMDYwMjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Js +b2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1h +Z2VJZCIRYWtpLWE1M2FkZmNjIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Ut +c3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1 +ZSISaW1hZ2VMb2NhdGlvbiJEZWMyLXB1YmxpYy1pbWFnZXMvdm1saW51ei0y +LjYuMjAtMS4zMDAyLmZjNnhlbi5ha2kubWFuaWZlc3QueG1sIhFhcmNoaXRl +Y3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIO +aW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYWtpLWE2ZjIxMGNmIhNyb290 +RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyIL +YW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBh +aWQtaWJtLWltYWdlcy92bWxpbnV6LTIuNi4xNi42MC0wLjMwLXhlbi54ODZf +NjQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VP +d25lcklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Js +b2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1h +Z2VJZCIRYWtpLWE3MWNmOWNlIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Ut +c3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1 +ZSISaW1hZ2VMb2NhdGlvbiJGZWMyLXB1YmxpYy1pbWFnZXMvZWMyLXZtbGlu +dXotMi42LjIxLjctMi5mYzh4ZW4uaTM4Ni5tYW5pZmVzdC54bWwiEWFyY2hp +dGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIO +aW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBw +cm9kdWN0Q29kZSINRDZGNjA1MkEiDGltYWdlSWQiEWFraS1iMzRiYWNkYSIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iSGVj +Mi1wYWlkLWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYuNjAtMC4yOS14ZW5w +YWUuaTM4Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1h +Z2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1hZ2VUeXBlIgtrZXJuZWwi +F2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIM +aW1hZ2VJZCIRYWtpLWI1MWNmOWRjIhNyb290RGV2aWNlVHlwZSITaW5zdGFu +Y2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJ +dHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMyLXB1YmxpYy1pbWFnZXMvZWMyLXZt +bGludXotMi42LjIxLjctMi5mYzh4ZW4ueDg2XzY0Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIx +NTMyew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBpbmcw +Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFraS1iOWU3MDdk +MCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVy +QWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24i +SGVjMi1wYWlkLWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYuNjAtMC4yOS14 +ZW5wYWUuaTM4Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIR +aW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgtrZXJu +ZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJs +ZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINQTQ4 +MTg5NUQiDGltYWdlSWQiEWFraS1iY2U2MGJkNSITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iTGVjMi1wYWlkLWlibS1pbWFn +ZXMtZGIyL3ZtbGludXotMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFu +aWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIR +NDcwMjU0NTM0MDI0ew8iDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0Rldmlj +ZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFr +aS1kNGNhMmRiZCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRp +bWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdl +TG9jYXRpb24iWGFraS1saW51eC0yLjYuMTguOTItOTIuZWw1eGVuLXhmcy92 +bWxpbnV6LTIuNi4xOC45Mi05Mi5lbDV4ZW4uaTM4Ni5ha2kubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5 +NjIxNTMyexAiDmltYWdlVHlwZSILa2VybmVsIhdibG9ja0RldmljZU1hcHBp +bmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglp +dGVtWwZ7BiIQcHJvZHVjdENvZGUiDUE5NDA4QjRCIgxpbWFnZUlkIhFha2kt +ZGI0YmFjYjIiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIkdlYzItcGFpZC1pYm0taW1hZ2VzL3ZtbGludXotMi42LjE2LjYw +LTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIL +eDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsPIg5pbWFnZVR5 +cGUiC2tlcm5lbCIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIgxpbWFnZUlkIhFha2ktZTVjMTIxOGMiE3Jvb3REZXZpY2VU +eXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24i +DWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIktlYzItcHVibGljLWlt +YWdlcy92bWxpbnV6LTIuNi4xOC14ZW5VLWVjMi12MS4yLng4Nl82NC5ha2ku +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25l +cklkIhEyMDYwMjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJ +ZCIRYWtpLWY1YzEyMTljIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJJZWMyLXB1YmxpYy1pbWFnZXMvdm1saW51ei0yLjYu +MTgteGVuVS1lYzItdjEuMi5pMzg2LmFraS5tYW5pZmVzdC54bWwiEWFyY2hp +dGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIO +aW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBw +cm9kdWN0Q29kZSINMjFFOUVCQzkiDGltYWdlSWQiEWFraS1mODU4YmE5MSIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iUmVj +Mi1wYWlkLWlibS1pbWFnZXMtaW5mb3NwaGVyZS92bWxpbnV6LTIuNi4xNi42 +MC0wLjMwLXhlbi54ODZfNjQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUi +C3g4Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VU +eXBlIgtrZXJuZWwiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUi +DmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0 +Q29kZSINRDY2MkU5ODkiDGltYWdlSWQiEWFraS1mOGYwMTI5MSITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iSGVjMi1wYWlk +LWlibS1pbWFnZXMvdm1saW51ei0yLjYuMTYuNjAtMC4yOS14ZW5wYWUuaTM4 +Ni5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgtrZXJuZWwiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVj +dENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRUE1RjA1QTMiDGlt +YWdlSWQiEWFraS1mOGZkMTA5MSITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iS2VjMi1wYWlkLWlibS1pbWFnZXMtZGIyL3Zt +bGludXotMi42LjE2LjYwLTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwi +EWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsQIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGlu +ZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLTA1MzVk +NjZjIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3du +ZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlv +biJMZWMyLXB1YmxpYy13aW5kb3dzLWltYWdlcy9TcWxTdnJTdGQyMDAzcjIt +eDg2XzY0LVdpbi12MS4wNy5tYW5pZmVzdC54bWwiDXBsYXRmb3JtIgx3aW5k +b3dzIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYw +Mjk2MjE1MzJ7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1h +cHBpbmcwIg5yYW1kaXNrSWQiEWFyaS02NjQ4YTgwZiIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RD +b2RlIg04MEVEMDBCOCINa2VybmVsSWQiEWFraS03ZTQ4YTgxNyIMaW1hZ2VJ +ZCIRYW1pLTA2NGNhYzZmIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQtaWJtLWltYWdlcy9pYm0tdGl2b2xp +LWl0bS0wNi4yMS4wMy4wMC0zMmItNjAwLm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsTIg5p +bWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRp +c2tJZCIRYXJpLTMyMzhkYTViIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXBy +b2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUUzRDQ4Q0VF +Ig1rZXJuZWxJZCIRYWtpLTMwMzhkYTU5IgxpbWFnZUlkIhFhbWktMTAwMGUy +NzkiE3Jvb3REZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBl +IhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlz +UHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIlBlYzItcGFpZC1pYm0taW1h +Z2VzL3dlYnNwaGVyZS1hcHBsaWNhdGlvbi1zZXJ2ZXItNy4wLjAuNy0zMmJp +dC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7EyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9j +a0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS0wYzUxYjM2NSIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYi +EHByb2R1Y3RDb2RlIg1BOTQwOEI0QiINa2VybmVsSWQiEWFraS0wMjUxYjM2 +YiIMaW1hZ2VJZCIRYW1pLTEwNTFiMzc5IhNyb290RGV2aWNlTmFtZSIOL2Rl +di9zZGExIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdl +T3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2Nh +dGlvbiJHZWMyLXBhaWQtaWJtLWltYWdlcy1pZHMvaWJtLWlkcy13b3JrZ3Jv +dXAtMTEuNS12MjAyLTEubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4 +Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7ESIOaW1hZ2VUeXBl +IgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFy +aS1hNTFjZjljYyIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJuZWxJZCIR +YWtpLWE3MWNmOWNlIgxpbWFnZUlkIhFhbWktMTFjYTJkNzgiE3Jvb3REZXZp +Y2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6 +b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIj9hd3MtdG9vbGtp +dC1mb3ItZWNsaXBzZS1hbWlzLXVzL3RvbWNhdC12MS4wLjAubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA1NjA1 +ODE5NzE2exAiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBw +aW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLTli +MDBlNWYyIgxpbWFnZUlkIhFhbWktMjA1ZmJhNDkiE3Jvb3REZXZpY2VUeXBl +IhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlz +UHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkBlYzItcHVibGljLWltYWdl +cy9mZWRvcmEtY29yZTQtaTM4Ni1iYXNlLXYxLjA3Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUz +MnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAi +DnJhbWRpc2tJZCIRYXJpLWRiYzEyMWIyIg9pbWFnZVN0YXRlIg5hdmFpbGFi +bGUiDWtlcm5lbElkIhFha2ktZjVjMTIxOWMiDGltYWdlSWQiEWFtaS0yMGIw +NTM0OSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iRWF3cy1jb25zb2xlLXF1aWNrc3RhcnQtYW1pcy9wZXJsLzEuMy9wZXJs +cXVpY2tzdGFydC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIR +aW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3MTZ7DyIOaW1hZ2VUeXBlIgxtYWNo +aW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFi +bGUiDGltYWdlSWQiEWFtaS0yMGI2NTM0OSITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iNWVjMi1wdWJsaWMtaW1hZ2VzL2Zl +ZG9yYS1jb3JlNC1iYXNlLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglp +Mzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsPIg5pbWFnZVR5cGUi +DG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2 +YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLTIxNWZiYTQ4IhNyb290RGV2aWNlVHlw +ZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1p +c1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiI7ZWMyLXB1YmxpYy1pbWFn +ZXMvZmVkb3JhLWNvcmU0LWJhc2UtdjEuMDcubWFuaWZlc3QueG1sIhFhcmNo +aXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyew8i +DmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhbWktMjI1ZmJhNGIiE3Jv +b3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFz +IgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkNlYzIt +cHVibGljLWltYWdlcy9mZWRvcmEtY29yZTQtYXBhY2hlLW15c3FsLXYxLjA3 +Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVy +SWQiETIwNjAyOTYyMTUzMnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLWRiYzEyMWIyIg9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktZjVjMTIxOWMiDGlt +YWdlSWQiEWFtaS0yMmIwNTM0YiITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iRWF3cy1jb25zb2xlLXF1aWNrc3RhcnQtYW1p +cy9ydWJ5LzEuMi9ydWJ5cXVpY2tzdGFydC5tYW5pZmVzdC54bWwiEWFyY2hp +dGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3MTZ7DyIO +aW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS0yMmI2NTM0YiITcm9v +dERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMi +C2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iNmVjMi1w +dWJsaWMtaW1hZ2VzL2ZlZG9yYS1jb3JlNC1teXNxbC5tYW5pZmVzdC54bWwi +EWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1 +MzJ7DyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcw +Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS0yMzVmYmE0 +YSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVy +QWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24i +OWVjMi1wdWJsaWMtaW1hZ2VzL2dldHRpbmctc3RhcnRlZC12MS4wNy5tYW5p +ZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEy +MDYwMjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0Rldmlj +ZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFt +aS0yM2I2NTM0YSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRp +bWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdl +TG9jYXRpb24iN2VjMi1wdWJsaWMtaW1hZ2VzL2ZlZG9yYS1jb3JlNC1hcGFj +aGUubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3du +ZXJJZCIRMjA2MDI5NjIxNTMyexIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxv +Y2tEZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktYjI0YmFjZGIiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsG +IhBwcm9kdWN0Q29kZSINRDZGNjA1MkEiDWtlcm5lbElkIhFha2ktYjM0YmFj +ZGEiDGltYWdlSWQiEWFtaS0yNDRhYWQ0ZCITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iTGVjMi1wYWlkLWlibS1pbWFnZXMv +aW5mb3JtaXgtZHluYW1pYy1zZXJ2ZXItZXhwcmVzcy0zMi1iaXQubWFuaWZl +c3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcw +MjU0NTM0MDI0exEiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VN +YXBwaW5nMCIOcmFtZGlza0lkIhFhcmktYjMxY2Y5ZGEiD2ltYWdlU3RhdGUi +DmF2YWlsYWJsZSINa2VybmVsSWQiEWFraS1iNTFjZjlkYyIMaW1hZ2VJZCIR +YW1pLTI1NDdhMzRjIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUi +FGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1h +Z2VMb2NhdGlvbiI+ZWMyLXB1YmxpYy1pbWFnZXMvZmVkb3JhLTgteDg2XzY0 +LWJhc2UtdjEuMDgubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82 +NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgxt +YWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiDGltYWdlSWQiEWFtaS0yNTVmYmE0YyITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iPGVjMi1wdWJsaWMtaW1hZ2Vz +L2ZlZG9yYS1jb3JlNC1teXNxbC12MS4wNy5tYW5pZmVzdC54bWwiEWFyY2hp +dGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIO +aW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS0yNWI2NTM0YyITcm9v +dERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMi +C2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iPWVjMi1w +dWJsaWMtaW1hZ2VzL2ZlZG9yYS1jb3JlNC1hcGFjaGUtbXlzcWwubWFuaWZl +c3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2 +MDI5NjIxNTMyew8iDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VN +YXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhbWkt +MjZiNjUzNGYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIjNlYzItcHVibGljLWltYWdlcy9kZXZlbG9wZXItaW1hZ2UubWFu +aWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIR +MjA2MDI5NjIxNTMyexEiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZp +Y2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktYTUxY2Y5Y2MiD2ltYWdlU3Rh +dGUiDmF2YWlsYWJsZSINa2VybmVsSWQiEWFraS1hNzFjZjljZSIMaW1hZ2VJ +ZCIRYW1pLTI3ZTcwMDRlIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJGL2F3cy1jb25zb2xlLXF1aWNrc3RhcnQtYW1pcy9w +ZXJsLzEuMi9wZXJscXVpY2tzdGFydC5tYW5pZmVzdC54bWwiEWFyY2hpdGVj +dHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3MTZ7ESIOaW1h +Z2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNr +SWQiEWFyaS1iMzFjZjlkYSIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJu +ZWxJZCIRYWtpLWI1MWNmOWRjIgxpbWFnZUlkIhFhbWktMmE1ZmJhNDMiE3Jv +b3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFz +IgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIj5lYzIt +cHVibGljLWltYWdlcy9mZWRvcmEtOC14ODZfNjQtYmFzZS12MS4wNy5tYW5p +ZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQi +ETIwNjAyOTYyMTUzMnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2 +aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2UiDGltYWdl +SWQiEWFtaS0yYjVmYmE0MiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0 +b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUi +EmltYWdlTG9jYXRpb24iPGVjMi1wdWJsaWMtaW1hZ2VzL2ZlZG9yYS04LWkz +ODYtYmFzZS12MS4wNy5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4 +NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIOaW1hZ2VUeXBlIgxt +YWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUi +DUE3OUVDMERCIgxpbWFnZUlkIhFhbWktMmM1ZmJhNDUiE3Jvb3REZXZpY2VU +eXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24i +DWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIjdlYzItcHVibGljLWlt +YWdlcy9kZW1vLXBhaWQtQU1JLXYxLjA3Lm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsRIg5p +bWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRp +c2tJZCIRYXJpLWRiYzEyMWIyIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDWtl +cm5lbElkIhFha2ktZjVjMTIxOWMiDGltYWdlSWQiEWFtaS0yY2IwNTM0NSIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iQGF3 +cy1jb25zb2xlLXF1aWNrc3RhcnQtYW1pcy9waHBxdWlja3N0YXJ0LXYxLjUu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJ +ZCIRMjA1NjA1ODE5NzE2exEiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tE +ZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktYTIzYWRmY2IiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSINa2VybmVsSWQiEWFraS1hNTNhZGZjYyIMaW1h +Z2VJZCIRYW1pLTJkNWZiYTQ0IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Ut +c3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1 +ZSISaW1hZ2VMb2NhdGlvbiJDZWMyLXB1YmxpYy1pbWFnZXMvZmVkb3JhLWNv +cmUtNi14ODZfNjQtYmFzZS12MS4wNy5tYW5pZmVzdC54bWwiEWFyY2hpdGVj +dHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsPIg5p +bWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLTJlNWZiYTQ3IhNyb290 +RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyIL +YW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiI9ZWMyLXB1 +YmxpYy1pbWFnZXMvZmVkb3JhLWNvcmU0LWFwYWNoZS12MS4wNy5tYW5pZmVz +dC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYw +Mjk2MjE1MzJ7ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1h +cHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1kYmMxMjFiMiIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLWY1YzEyMTljIgxpbWFnZUlkIhFh +bWktMmViMDUzNDciE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIU +aW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFn +ZUxvY2F0aW9uIklhd3MtY29uc29sZS1xdWlja3N0YXJ0LWFtaXMvdG9tY2F0 +LzEuMi90b21jYXRxdWlja3N0YXJ0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0 +dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNTYwNTgxOTcxNnsPIg5pbWFn +ZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3Rh +dGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLTJmNWZiYTQ2IhNyb290RGV2 +aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1h +em9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiI+ZWMyLXB1Ymxp +Yy1pbWFnZXMvZGV2ZWxvcGVyLWltYWdlLWkzODYtdjEuMDcubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5 +NjIxNTMyexIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBw +aW5nMCIOcmFtZGlza0lkIhFhcmktMjFkMzMwNDgiD2ltYWdlU3RhdGUiDmF2 +YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29k +ZSINNTc4QkY1QkEiDWtlcm5lbElkIhFha2ktMmRkMzMwNDQiDGltYWdlSWQi +EWFtaS0zNWQzMzA1YyITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3Jl +IhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmlt +YWdlTG9jYXRpb24iSGVjMi1wYWlkLWlibS1pbWFnZXMvaWJtLWxvdHVzLWZv +cm1zLXR1cmJvLTMuNS4xLTMyLWJpdC5tYW5pZmVzdC54bWwiEWFyY2hpdGVj +dHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1h +Z2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS0zNmZmMWE1ZiITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iPGVjMi1wdWJs +aWMtaW1hZ2VzL2ZlZG9yYS1jb3JlNi1iYXNlLXg4Nl82NC5tYW5pZmVzdC54 +bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETIwNjAy +OTYyMTUzMnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFw +cGluZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2UiDGltYWdlSWQiEWFt +aS0zYzQ3YTM1NSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRp +bWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdl +TG9jYXRpb24iM2VjMi1wdWJsaWMtaW1hZ2VzL2dldHRpbmctc3RhcnRlZC5t +YW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklk +IhEyMDYwMjk2MjE1MzJ7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0Rl +dmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1kZDRiYWNiNCIPaW1hZ2VT +dGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHBy +b2R1Y3RDb2RlIg1BOTQwOEI0QiINa2VybmVsSWQiEWFraS1kYjRiYWNiMiIM +aW1hZ2VJZCIRYW1pLTQzNGFhZDJhIhNyb290RGV2aWNlVHlwZSITaW5zdGFu +Y2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJ +dHJ1ZSISaW1hZ2VMb2NhdGlvbiJWZWMyLXBhaWQtaWJtLWltYWdlcy9pbmZv +cm1peC1keW5hbWljLXNlcnZlci13b3JrZ3JvdXAtZWRpdGlvbi02NC1iaXQu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9j +a0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1hNTFjZjljYyIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLWE3MWNmOWNlIgxp +bWFnZUlkIhFhbWktNDVlNzAwMmMiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5j +ZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0 +cnVlIhJpbWFnZUxvY2F0aW9uIkovYXdzLWNvbnNvbGUtcXVpY2tzdGFydC1h +bWlzL3RvbWNhdC8xLjEvdG9tY2F0cXVpY2tzdGFydC5tYW5pZmVzdC54bWwi +EWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3 +MTZ7ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcw +Ig5yYW1kaXNrSWQiEWFyaS00MmI5NWEyYiIPaW1hZ2VTdGF0ZSIOYXZhaWxh +YmxlIg1rZXJuZWxJZCIRYWtpLTZlYWE0OTA3IgxpbWFnZUlkIhFhbWktNDhh +YTQ5MjEiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VP +d25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0 +aW9uIjxlYzItcHVibGljLWltYWdlcy9mZWRvcmEtOC1pMzg2LWJhc2UtdjEu +MTAubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3du +ZXJJZCIRMjA2MDI5NjIxNTMyexIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxv +Y2tEZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktNzY0OGFmMWYiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsG +IhBwcm9kdWN0Q29kZSINRUE1RjA1QTMiDWtlcm5lbElkIhFha2ktODU0OWFl +ZWMiDGltYWdlSWQiEWFtaS00YzQ4YWYyNSITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iOmVjMi1wYWlkLWlibS1pbWFnZXMv +ZGIyLXdvcmtncm91cC02NC1iaXQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1 +cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7EiIOaW1h +Z2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNr +SWQiEWFyaS03NzQ4YWYxZSIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9k +dWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg1BNDgxODk1RCIN +a2VybmVsSWQiEWFraS04MTQ5YWVlOCIMaW1hZ2VJZCIRYW1pLTRkNDhhZjI0 +IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJB +bGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiI4 +ZWMyLXBhaWQtaWJtLWltYWdlcy9kYjItZXhwcmVzcy0zMi1iaXQubWFuaWZl +c3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcw +MjU0NTM0MDI0exIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VN +YXBwaW5nMCIOcmFtZGlza0lkIhFhcmktODEzZmRlZTgiD2ltYWdlU3RhdGUi +DmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0 +Q29kZSINNTc4QkY1QkEiDWtlcm5lbElkIhFha2ktOGIzZmRlZTIiDGltYWdl +SWQiEWFtaS00ZDRmYWUyNCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0 +b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUi +EmltYWdlTG9jYXRpb24iPmVjMi1wYWlkLWlibS1pbWFnZXMvbG90dXMtZm9y +bXMtdHVyYm8tMzItYml0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglp +Mzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsSIg5pbWFnZVR5cGUi +DG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJp +LTZjNDhhODA1Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rl +c3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDTQ5Q0E3MzA1Ig1rZXJuZWxJ +ZCIRYWtpLTY4NDhhODAxIgxpbWFnZUlkIhFhbWktNTA0OGE4MzkiE3Jvb3RE +ZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgth +bWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkdlYzItcGFp +ZC1pYm0taW1hZ2VzL2libS10aXZvbGktaXRtLTA2LjIxLjAzLjAwLTMyYi01 +MC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9j +a0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS02NDQ4YTgwZCIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYi +EHByb2R1Y3RDb2RlIg1DQ0VCMzY4QiINa2VybmVsSWQiEWFraS03YzQ4YTgx +NSIMaW1hZ2VJZCIRYW1pLTUyNDhhODNiIhNyb290RGV2aWNlVHlwZSITaW5z +dGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1Ymxp +YyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQtaWJtLWltYWdlcy9p +Ym0tdGl2b2xpLWl0bS0wNi4yMS4wMy4wMC0zMmItMjAwLm1hbmlmZXN0Lnht +bCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGlu +ZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2UiDGltYWdlSWQiEWFtaS01 +NjQ3YTMzZiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFn +ZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9j +YXRpb24iPGVjMi1wdWJsaWMtaW1hZ2VzL2ZlZG9yYS04LWkzODYtYmFzZS12 +MS4wOC5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VP +d25lcklkIhEyMDYwMjk2MjE1MzJ7ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdi +bG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1hNTFjZjljYyIP +aW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLWE3MWNmOWNl +IgxpbWFnZUlkIhFhbWktNWVlNzAwMzciE3Jvb3REZXZpY2VUeXBlIhNpbnN0 +YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGlj +Igl0cnVlIhJpbWFnZUxvY2F0aW9uIkYvYXdzLWNvbnNvbGUtcXVpY2tzdGFy +dC1hbWlzL3J1YnkvMS4xL3J1YnlxdWlja3N0YXJ0Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNTYwNTgxOTcx +NnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAi +DnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9pbWFnZVN0YXRlIg5hdmFpbGFi +bGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2UiDGltYWdlSWQiEWFtaS02MGRh +M2QwOSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iQS9hd3MtY29uc29sZS1xdWlja3N0YXJ0LWFtaXMvcGhwcXVpY2tzdGFy +dC12MS40Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETIwNTYwNTgxOTcxNnsSIg5pbWFnZVR5cGUiDG1hY2hpbmUi +F2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLTlhNzA5MGYz +Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVt +WwZ7BiIQcHJvZHVjdENvZGUiDUUzRDQ4Q0VFIg1rZXJuZWxJZCIRYWtpLTg2 +NzA5MGVmIgxpbWFnZUlkIhFhbWktNjY3MTkxMGYiE3Jvb3REZXZpY2VUeXBl +IhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlz +UHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIlFlYzItcGFpZC1pYm0taW1h +Z2VzL3dlYnNwaGVyZS1hcHBsaWNhdGlvbi1zZXJ2ZXItNy4wLjAuMy0zMi1i +aXQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3du +ZXJJZCIRNDcwMjU0NTM0MDI0exIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxv +Y2tEZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktNjE3Nzk0MDgiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsG +IhBwcm9kdWN0Q29kZSINRDZGQjExMTMiDWtlcm5lbElkIhFha2ktNmY3Nzk0 +MDYiDGltYWdlSWQiEWFtaS02Nzc2OTUwZSITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iRGVjMi1wYWlkLWlibS1pbWFnZXMv +d2Vic3BoZXJlLXNtYXNoLTEuMS4xLjEtMzItYml0Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAy +NHsSIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAi +DnJhbWRpc2tJZCIRYXJpLTQ4NDhhZjIxIg9pbWFnZVN0YXRlIg5hdmFpbGFi +bGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDThG +Q0UzRUVCIg1rZXJuZWxJZCIRYWtpLTgyNDlhZWViIgxpbWFnZUlkIhFhbWkt +NmM1NWIyMDUiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIlplYzItcGFpZC1pYm0taW1hZ2VzL2xvdHVzLXdlYi1jb250ZW50 +LW1hbmFnZW1lbnQtc3RhbmRhcmQtZWRpdGlvbi02NC1iaXQubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAy +NTQ1MzQwMjR7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1h +cHBpbmcwIg5yYW1kaXNrSWQiEWFyaS00OTQ4YWYyMCIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RD +b2RlIg00NzZEMjlDQiINa2VybmVsSWQiEWFraS04MzQ5YWVlYSIMaW1hZ2VJ +ZCIRYW1pLTZmNTViMjA2IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJvZWMyLXBhaWQtaWJtLWltYWdlcy93ZWJzcGhlcmUt +cG9ydGFsLWFuZC1sb3R1cy13ZWItY29udGVudC1tYW5hZ2VtZW50LXN0YW5k +YXJkLWVkaXRpb24tNjQtYml0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJl +Igt4ODZfNjQiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exMiDmltYWdl +VHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lk +IhFhcmktNjQ1MWIzMGQiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVj +dENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRDZGNjA1MkEiDWtl +cm5lbElkIhFha2ktNjA1MWIzMDkiDGltYWdlSWQiEWFtaS03NDUxYjMxZCIT +cm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iRWVjMi1wYWlkLWlibS1pbWFnZXMt +aWRzL2libS1pZHMtZXhwcmVzcy0xMS41LXYyMDItMS5tYW5pZmVzdC54bWwi +EWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQw +MjR7EyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcw +Ig5yYW1kaXNrSWQiEWFyaS04OGU2MGJlMSIPaW1hZ2VTdGF0ZSIOYXZhaWxh +YmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg1B +NDgxODk1RCINa2VybmVsSWQiEWFraS1iY2U2MGJkNSIMaW1hZ2VJZCIRYW1p +LTc0ZTAwZDFkIhNyb290RGV2aWNlTmFtZSIOL2Rldi9zZGExIhNyb290RGV2 +aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1h +em9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMyLXBhaWQt +aWJtLWltYWdlcy1kYjIvaWJtLWRiMi1leHByZXNzLTkuNy5GUDEtMzItYml0 +Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVy +SWQiETQ3MDI1NDUzNDAyNHsUIgluYW1lIhxmZWRvcmEtOC1pMzg2LXYxLjE0 +LXN0ZCIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmd7 +BiIJaXRlbVsGewciCGVic3sIIg9zbmFwc2hvdElkIhJzbmFwLWI5YWEzNWQw +IhhkZWxldGVPblRlcm1pbmF0aW9uIgl0cnVlIg92b2x1bWVTaXplIgcxNSIP +ZGV2aWNlTmFtZSIOL2Rldi9zZGExIg5yYW1kaXNrSWQiEWFyaS05NmM1Mjdm +ZiIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLTk0YzUy +N2ZkIgxpbWFnZUlkIhFhbWktODRkYjM5ZWQiE3Jvb3REZXZpY2VOYW1lIg4v +ZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBlIghlYnMiEGRlc2NyaXB0aW9uIjZG +ZWRvcmEgOCB2MS4xNCBpMzg2IHN0ZC1yb290IGx2bS1zd2FwIGx2bS1zdG9y +YWdlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUi +EmltYWdlTG9jYXRpb24iI2FtYXpvbi9mZWRvcmEtOC1pMzg2LXYxLjE0LXN0 +ZCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYy +MTUzMnsUIgluYW1lIh5mZWRvcmEtOC14ODZfNjQtdjEuMTQtc3RkIg5pbWFn +ZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZ3sGIglpdGVtWwZ7 +ByIIZWJzewgiD3NuYXBzaG90SWQiEnNuYXAtYmJhYTM1ZDIiGGRlbGV0ZU9u +VGVybWluYXRpb24iCXRydWUiD3ZvbHVtZVNpemUiBzE1Ig9kZXZpY2VOYW1l +Ig4vZGV2L3NkYTEiDnJhbWRpc2tJZCIRYXJpLTU2Y2UyYzNmIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktNTRjZTJjM2QiDGltYWdl +SWQiEWFtaS04NmRiMzllZiITcm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSIT +cm9vdERldmljZVR5cGUiCGVicyIQZGVzY3JpcHRpb24iOEZlZG9yYSA4IHYx +LjE0IHg4Nl82NCBzdGQtcm9vdCBsdm0tc3dhcCBsdm0tc3RvcmFnZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIiVhbWF6b24vZmVkb3JhLTgteDg2XzY0LXYxLjE0LXN0ZCIRYXJj +aGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMy +exMiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBwaW5nMCIO +cmFtZGlza0lkIhFhcmktMzIzOGRhNWIiD2ltYWdlU3RhdGUiDmF2YWlsYWJs +ZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINN0E2 +M0Y5RkMiDWtlcm5lbElkIhFha2ktMzAzOGRhNTkiDGltYWdlSWQiEWFtaS1h +MDQ2YTRjOSITcm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSITcm9vdERldmlj +ZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpv +biINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iQGVjMi1wYWlkLWli +bS1pbWFnZXMvZXh0cmVtZXNjYWxlLTcwLTMyYml0LW5vaWQubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0 +NTM0MDI0exEiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBw +aW5nMCIOcmFtZGlza0lkIhFhcmktYTIzYWRmY2IiD2ltYWdlU3RhdGUiDmF2 +YWlsYWJsZSINa2VybmVsSWQiEWFraS1hNTNhZGZjYyIMaW1hZ2VJZCIRYW1p +LWEyMWFmZmNiIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJDZWMyLXB1YmxpYy1pbWFnZXMvZmVkb3JhLWNvcmUtNi14ODZf +NjQtYmFzZS12MS4wNi5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2 +XzY0IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsSIg5pbWFnZVR5cGUi +DG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJp +LTZkZWMwYzA0Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rl +c3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUVBNUYwNUEzIg1rZXJuZWxJ +ZCIRYWtpLTZiZWMwYzAyIgxpbWFnZUlkIhFhbWktYTIxY2ZjY2IiE3Jvb3RE +ZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgth +bWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIj5lYzItcGFp +ZC1pYm0taW1hZ2VzL2RiMi13b3JrZ3JvdXAtOS43LTY0LWJpdC5tYW5pZmVz +dC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3 +MDI1NDUzNDAyNHsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNl +TWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVz +ewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRUMxMjk3MDgiDGltYWdlSWQi +EWFtaS1hOGU3MDVjMSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3Jl +IhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmlt +YWdlTG9jYXRpb24iQWVjMi1wYWlkLWlibS1pbWFnZXMvaWJtLWluZm9zcGhl +cmUtaXMtd2luY2xpZW50Lm1hbmlmZXN0LnhtbCINcGxhdGZvcm0iDHdpbmRv +d3MiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1 +MzQwMjR7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBp +bmcwIg5yYW1kaXNrSWQiEWFyaS05MWViMGJmOCIPaW1hZ2VTdGF0ZSIOYXZh +aWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2Rl +Ig1BNDgxODk1RCINa2VybmVsSWQiEWFraS05ZmViMGJmNiIMaW1hZ2VJZCIR +YW1pLWFjMWNmY2M1IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUi +FGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1h +Z2VMb2NhdGlvbiI8ZWMyLXBhaWQtaWJtLWltYWdlcy9kYjItZXhwcmVzcy05 +LjctMzItYml0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFp +bWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsUIgluYW1lIiJnZXR0aW5nLXN0 +YXJ0ZWQtd2l0aC1lYnMtYm9vdCIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9j +a0RldmljZU1hcHBpbmd7BiIJaXRlbVsGewciCGVic3sIIg9zbmFwc2hvdElk +IhJzbmFwLWEwODkxMmM5IhhkZWxldGVPblRlcm1pbmF0aW9uIgl0cnVlIg92 +b2x1bWVTaXplIgcxNSIPZGV2aWNlTmFtZSIOL2Rldi9zZGExIg5yYW1kaXNr +SWQiEWFyaS05NmM1MjdmZiIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIg1rZXJu +ZWxJZCIRYWtpLTk0YzUyN2ZkIgxpbWFnZUlkIhFhbWktYjIzMmQwZGIiE3Jv +b3REZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBlIghlYnMi +EGRlc2NyaXB0aW9uIkxGZWRvcmEgOCB2MS4xNCBpMzg2IHN0ZC1yb290IGx2 +bS1zd2FwIGx2bS1zdG9yYWdlIGdldHRpbmctc3RhcnRlZC1ndWlkZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIilhbWF6b24vZ2V0dGluZy1zdGFydGVkLXdpdGgtZWJzLWJvb3Qi +EWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1 +MzJ7EiIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcw +Ig5yYW1kaXNrSWQiEWFyaS03NDQ4YWYxZCIPaW1hZ2VTdGF0ZSIOYXZhaWxh +YmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg1E +NkZCMTExMyINa2VybmVsSWQiEWFraS04MDQ5YWVlOSIMaW1hZ2VJZCIRYW1p +LWI0NTRiM2RkIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiI8ZWMyLXBhaWQtaWJtLWltYWdlcy93ZWJzcGhlcmUtc21hc2gt +MzItYml0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDG1hY2hpbmUi +F2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIR +cHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINQTc5RUMw +REIiDGltYWdlSWQiEWFtaS1iZDlkNzhkNCITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iMWVjMi1wdWJsaWMtaW1hZ2VzL2Rl +bW8tcGFpZC1BTUkubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYi +EWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyexMiCW5hbWUiJldpbmRvd3Mt +U2VydmVyMjAwOC1pMzg2LUJhc2UtdjEwMyIOaW1hZ2VUeXBlIgxtYWNoaW5l +IhdibG9ja0RldmljZU1hcHBpbmd7BiIJaXRlbVsGewciCGVic3sIIg9zbmFw +c2hvdElkIhJzbmFwLTRjOWMyNzI0IhhkZWxldGVPblRlcm1pbmF0aW9uIgl0 +cnVlIg92b2x1bWVTaXplIgczMCIPZGV2aWNlTmFtZSIOL2Rldi9zZGExIg9p +bWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS1jM2U0MGRhYSIT +cm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSITcm9vdERldmljZVR5cGUiCGVi +cyIQZGVzY3JpcHRpb24iN01pY3Jvc29mdCBXaW5kb3dzIDIwMDggRGF0YWNl +bnRlciAzMi1iaXQgQU1JIHYxLjAzIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpv +biINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iLWFtYXpvbi9XaW5k +b3dzLVNlcnZlcjIwMDgtaTM4Ni1CYXNlLXYxMDMiDXBsYXRmb3JtIgx3aW5k +b3dzIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5 +NjIxNTMyexMiCW5hbWUiLFdpbmRvd3MtU2VydmVyMjAwOC1pMzg2LVNxbEV4 +cHJlc3MtdjEwMyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1h +cHBpbmd7BiIJaXRlbVsGewciCGVic3sIIg9zbmFwc2hvdElkIhJzbmFwLTVj +OWMyNzM0IhhkZWxldGVPblRlcm1pbmF0aW9uIgl0cnVlIg92b2x1bWVTaXpl +IgczMCIPZGV2aWNlTmFtZSIOL2Rldi9zZGExIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiDGltYWdlSWQiEWFtaS1jNWU0MGRhYyITcm9vdERldmljZU5hbWUi +Di9kZXYvc2RhMSITcm9vdERldmljZVR5cGUiCGVicyIQZGVzY3JpcHRpb24i +RU1pY3Jvc29mdCBXaW5kb3dzIDIwMDggRGF0YWNlbnRlciAzMi1iaXQsIFNx +bCBFeHByZXNzLCBBTUkgdjEuMDMiFGltYWdlT3duZXJBbGlhcyILYW1hem9u +Ig1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiIzYW1hem9uL1dpbmRv +d3MtU2VydmVyMjAwOC1pMzg2LVNxbEV4cHJlc3MtdjEwMyINcGxhdGZvcm0i +DHdpbmRvd3MiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEy +MDYwMjk2MjE1MzJ7EyIJbmFtZSIxV2luZG93cy1TZXJ2ZXIyMDAzUjIteDg2 +XzY0LVNxbFN0YW5kYXJkLXYxMDkiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxv +Y2tEZXZpY2VNYXBwaW5newYiCWl0ZW1bBnsHIghlYnN7CCIPc25hcHNob3RJ +ZCISc25hcC00ZDVmNDkyNCIYZGVsZXRlT25UZXJtaW5hdGlvbiIJdHJ1ZSIP +dm9sdW1lU2l6ZSIHMzAiD2RldmljZU5hbWUiDi9kZXYvc2RhMSIPaW1hZ2VT +dGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhbWktYzkxZmYwYTAiE3Jvb3RE +ZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBlIghlYnMiEGRl +c2NyaXB0aW9uIktNaWNyb3NvZnQgV2luZG93cyAyMDAzIFIyIDY0LWJpdCwg +U3FsIDIwMDUgU3RhbmRhcmQsIEFNSSBSZWxlYXNlIHYxLjA5IhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iOGFtYXpvbi9XaW5kb3dzLVNlcnZlcjIwMDNSMi14ODZfNjQtU3FsU3Rh +bmRhcmQtdjEwOSINcGxhdGZvcm0iDHdpbmRvd3MiEWFyY2hpdGVjdHVyZSIL +eDg2XzY0IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsTIg5pbWFnZVR5 +cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIR +YXJpLWZjZmQxMDk1Ig9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RD +b2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUVBNUYwNUEzIg1rZXJu +ZWxJZCIRYWtpLWY4ZmQxMDkxIgxpbWFnZUlkIhFhbWktY2VmZDEwYTciE3Jv +b3REZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBlIhNpbnN0 +YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGlj +Igl0cnVlIhJpbWFnZUxvY2F0aW9uIkplYzItcGFpZC1pYm0taW1hZ2VzLWRi +Mi9pYm0tZGIyLXdvcmtncm91cC05LjcuRlAxLTY0LWJpdC5tYW5pZmVzdC54 +bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1 +NDUzNDAyNHsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFw +cGluZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2UiDGltYWdlSWQiEWFt +aS1kMWNhMmRiOCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRp +bWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdl +TG9jYXRpb24iQGF3cy10b29sa2l0LWZvci1lY2xpcHNlLWFtaXMtdXMvaGFw +cm94eS12MS4wLjIubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYi +EWltYWdlT3duZXJJZCIRMjA1NjA1ODE5NzE2exAiDmltYWdlVHlwZSIMbWFj +aGluZSIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxh +YmxlIgxpbWFnZUlkIhFhbWktZDkyMGMzYjAiE3Jvb3REZXZpY2VUeXBlIhNp +bnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVi +bGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkxlYzItcHVibGljLXdpbmRvd3Mt +aW1hZ2VzL1NxbFN2ckV4cDIwMDNyMi14ODZfNjQtV2luLXYxLjA3Lm1hbmlm +ZXN0LnhtbCINcGxhdGZvcm0iDHdpbmRvd3MiEWFyY2hpdGVjdHVyZSILeDg2 +XzY0IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsTIgluYW1lIihXaW5k +b3dzLVNlcnZlcjIwMDgteDg2XzY0LUJhc2UtdjEwMyIOaW1hZ2VUeXBlIgxt +YWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmd7BiIJaXRlbVsGewciCGVic3sI +Ig9zbmFwc2hvdElkIhJzbmFwLTI4OWMyNzQwIhhkZWxldGVPblRlcm1pbmF0 +aW9uIgl0cnVlIg92b2x1bWVTaXplIgczMCIPZGV2aWNlTmFtZSIOL2Rldi9z +ZGExIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS1kOWU0 +MGRiMCITcm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSITcm9vdERldmljZVR5 +cGUiCGVicyIQZGVzY3JpcHRpb24iN01pY3Jvc29mdCBXaW5kb3dzIDIwMDgg +RGF0YWNlbnRlciA2NC1iaXQgQU1JIHYxLjAzIhRpbWFnZU93bmVyQWxpYXMi +C2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iL2FtYXpv +bi9XaW5kb3dzLVNlcnZlcjIwMDgteDg2XzY0LUJhc2UtdjEwMyINcGxhdGZv +cm0iDHdpbmRvd3MiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVy +SWQiETIwNjAyOTYyMTUzMnsQIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJ +ZCIRYW1pLWRiMjBjM2IyIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJKZWMyLXB1YmxpYy13aW5kb3dzLWltYWdlcy9TcWxT +dnJFeHAyMDAzcjItaTM4Ni1XaW4tdjEuMDcubWFuaWZlc3QueG1sIg1wbGF0 +Zm9ybSIMd2luZG93cyIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVy +SWQiETIwNjAyOTYyMTUzMnsSIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLTlmM2ZkZWY2Ig9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQ +cHJvZHVjdENvZGUiDUQ2NjJFOTg5Ig1rZXJuZWxJZCIRYWtpLTliM2ZkZWYy +IgxpbWFnZUlkIhFhbWktZGI1Y2JkYjIiE3Jvb3REZXZpY2VUeXBlIhNpbnN0 +YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGlj +Igl0cnVlIhJpbWFnZUxvY2F0aW9uIkBlYzItcGFpZC1pYm0taW1hZ2VzL2xv +dHVzLW1hc2h1cC1jZW50ZXItMzItYml0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsTIglu +YW1lIi5XaW5kb3dzLVNlcnZlcjIwMDgteDg2XzY0LVNxbEV4cHJlc3MtdjEw +MyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmd7BiIJ +aXRlbVsGewciCGVic3sIIg9zbmFwc2hvdElkIhJzbmFwLTIyOWMyNzRhIhhk +ZWxldGVPblRlcm1pbmF0aW9uIgl0cnVlIg92b2x1bWVTaXplIgczMCIPZGV2 +aWNlTmFtZSIOL2Rldi9zZGExIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGlt +YWdlSWQiEWFtaS1kYmU0MGRiMiITcm9vdERldmljZU5hbWUiDi9kZXYvc2Rh +MSITcm9vdERldmljZVR5cGUiCGVicyIQZGVzY3JpcHRpb24iSU1pY3Jvc29m +dCBXaW5kb3dzIDIwMDggRGF0YWNlbnRlciA2NC1iaXQsIFNxbCAyMDA4IEV4 +cHJlc3MgQU1JIHYxLjAzIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iNWFtYXpvbi9XaW5kb3dzLVNl +cnZlcjIwMDgteDg2XzY0LVNxbEV4cHJlc3MtdjEwMyINcGxhdGZvcm0iDHdp +bmRvd3MiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETIw +NjAyOTYyMTUzMnsQIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNl +TWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1p +LWRkMjBjM2I0IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJJZWMyLXB1YmxpYy13aW5kb3dzLWltYWdlcy9TZXJ2ZXIyMDAz +cjIteDg2XzY0LVdpbi12MS4wNy5tYW5pZmVzdC54bWwiDXBsYXRmb3JtIgx3 +aW5kb3dzIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEy +MDYwMjk2MjE1MzJ7EyIJbmFtZSIvV2luZG93cy1TZXJ2ZXIyMDA4LXg4Nl82 +NC1TcWxTdGFuZGFyZC12MTAzIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2Nr +RGV2aWNlTWFwcGluZ3sGIglpdGVtWwZ7ByIIZWJzewgiD3NuYXBzaG90SWQi +EnNuYXAtMzQ5YzI3NWMiGGRlbGV0ZU9uVGVybWluYXRpb24iCXRydWUiD3Zv +bHVtZVNpemUiBzMwIg9kZXZpY2VOYW1lIg4vZGV2L3NkYTEiD2ltYWdlU3Rh +dGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLWRkZTQwZGI0IhNyb290RGV2 +aWNlTmFtZSIOL2Rldi9zZGExIhNyb290RGV2aWNlVHlwZSIIZWJzIhBkZXNj +cmlwdGlvbiJKTWljcm9zb2Z0IFdpbmRvd3MgMjAwOCBEYXRhY2VudGVyIDY0 +LWJpdCwgU3FsIDIwMDggU3RhbmRhcmQgQU1JIHYxLjAzIhRpbWFnZU93bmVy +QWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24i +NmFtYXpvbi9XaW5kb3dzLVNlcnZlcjIwMDgteDg2XzY0LVNxbFN0YW5kYXJk +LXYxMDMiDXBsYXRmb3JtIgx3aW5kb3dzIhFhcmNoaXRlY3R1cmUiC3g4Nl82 +NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIOaW1hZ2VUeXBlIgxt +YWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiDGltYWdlSWQiEWFtaS1kZjIwYzNiNiITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wdWJsaWMtd2luZG93 +cy1pbWFnZXMvU2VydmVyMjAwM3IyLWkzODYtV2luLXYxLjA3Lm1hbmlmZXN0 +LnhtbCINcGxhdGZvcm0iDHdpbmRvd3MiEWFyY2hpdGVjdHVyZSIJaTM4NiIR +aW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7EyIJbmFtZSIoV2luZG93cy1T +ZXJ2ZXIyMDAzUjItaTM4Ni1CYXNlLXYxMDkiDmltYWdlVHlwZSIMbWFjaGlu +ZSIXYmxvY2tEZXZpY2VNYXBwaW5newYiCWl0ZW1bBnsHIghlYnN7CCIPc25h +cHNob3RJZCISc25hcC03ZDVmNDkxNCIYZGVsZXRlT25UZXJtaW5hdGlvbiIJ +dHJ1ZSIPdm9sdW1lU2l6ZSIHMzAiD2RldmljZU5hbWUiDi9kZXYvc2RhMSIP +aW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhbWktZjExZmYwOTgi +E3Jvb3REZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3REZXZpY2VUeXBlIghl +YnMiEGRlc2NyaXB0aW9uIjZNaWNyb3NvZnQgV2luZG93cyAyMDAzIFIyIERh +dGFjZW50ZXIgMzItYml0IHYxLjA5IhRpbWFnZU93bmVyQWxpYXMiC2FtYXpv +biINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iL2FtYXpvbi9XaW5k +b3dzLVNlcnZlcjIwMDNSMi1pMzg2LUJhc2UtdjEwOSINcGxhdGZvcm0iDHdp +bmRvd3MiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDYw +Mjk2MjE1MzJ7ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1h +cHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1iMzFjZjlkYSIPaW1hZ2VTdGF0ZSIO +YXZhaWxhYmxlIg1rZXJuZWxJZCIRYWtpLWI1MWNmOWRjIgxpbWFnZUlkIhFh +bWktZjIxYWZmOWIiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIU +aW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFn +ZUxvY2F0aW9uIj5lYzItcHVibGljLWltYWdlcy9mZWRvcmEtOC14ODZfNjQt +YmFzZS12MS4wNi5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0 +IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsTIgluYW1lIi5XaW5kb3dz +LVNlcnZlcjIwMDNSMi1pMzg2LVNxbEV4cHJlc3MtdjEwOSIOaW1hZ2VUeXBl +IgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmd7BiIJaXRlbVsGewciCGVi +c3sIIg9zbmFwc2hvdElkIhJzbmFwLTczNWY0OTFhIhhkZWxldGVPblRlcm1p +bmF0aW9uIgl0cnVlIg92b2x1bWVTaXplIgczMCIPZGV2aWNlTmFtZSIOL2Rl +di9zZGExIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFtaS1m +MzFmZjA5YSITcm9vdERldmljZU5hbWUiDi9kZXYvc2RhMSITcm9vdERldmlj +ZVR5cGUiCGVicyIQZGVzY3JpcHRpb24iU01pY3Jvc29mdCBXaW5kb3dzIDIw +MDMgUjIgMzItYml0LCBJSVMgNi4wLCBTcWwgMjAwNSBFeHByZXNzLCBBTUkg +UmVsZWFzZSB2MS4wOSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVi +bGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIjVhbWF6b24vV2luZG93cy1TZXJ2 +ZXIyMDAzUjItaTM4Ni1TcWxFeHByZXNzLXYxMDkiDXBsYXRmb3JtIgx3aW5k +b3dzIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA2MDI5 +NjIxNTMyexEiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBw +aW5nMCIOcmFtZGlza0lkIhFhcmktYTUxY2Y5Y2MiD2ltYWdlU3RhdGUiDmF2 +YWlsYWJsZSINa2VybmVsSWQiEWFraS1hNzFjZjljZSIMaW1hZ2VJZCIRYW1p +LWY1MWFmZjljIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiI8ZWMyLXB1YmxpYy1pbWFnZXMvZmVkb3JhLTgtaTM4Ni1iYXNl +LXYxLjA2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETIwNjAyOTYyMTUzMnsTIgluYW1lIipXaW5kb3dzLVNlcnZl +cjIwMDNSMi14ODZfNjQtQmFzZS12MTA5Ig5pbWFnZVR5cGUiDG1hY2hpbmUi +F2Jsb2NrRGV2aWNlTWFwcGluZ3sGIglpdGVtWwZ7ByIIZWJzewgiD3NuYXBz +aG90SWQiEnNuYXAtNzU1ZjQ5MWMiGGRlbGV0ZU9uVGVybWluYXRpb24iCXRy +dWUiD3ZvbHVtZVNpemUiBzMwIg9kZXZpY2VOYW1lIg4vZGV2L3NkYTEiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYW1pLWY1MWZmMDljIhNy +b290RGV2aWNlTmFtZSIOL2Rldi9zZGExIhNyb290RGV2aWNlVHlwZSIIZWJz +IhBkZXNjcmlwdGlvbiI2TWljcm9zb2Z0IFdpbmRvd3MgMjAwMyBSMiBEYXRh +Y2VudGVyIDY0LWJpdCB2MS4wOSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24i +DWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIjFhbWF6b24vV2luZG93 +cy1TZXJ2ZXIyMDAzUjIteDg2XzY0LUJhc2UtdjEwOSINcGxhdGZvcm0iDHdp +bmRvd3MiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETIw +NjAyOTYyMTUzMnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNl +TWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLTdjYjk1YTE1Ig9pbWFnZVN0YXRl +Ig5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTNkNzM3Y2EiDGltYWdlSWQi +EWFtaS1mNjFkZmQ5ZiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3Jl +IhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmlt +YWdlTG9jYXRpb24iPmVjMi1wdWJsaWMtaW1hZ2VzL2ZlZG9yYS04LXg4Nl82 +NC1iYXNlLXYxLjEwLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIgt4ODZf +NjQiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyexMiCW5hbWUiMFdpbmRv +d3MtU2VydmVyMjAwM1IyLXg4Nl82NC1TcWxFeHByZXNzLXYxMDkiDmltYWdl +VHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBwaW5newYiCWl0ZW1bBnsH +IghlYnN7CCIPc25hcHNob3RJZCISc25hcC00OTVmNDkyMCIYZGVsZXRlT25U +ZXJtaW5hdGlvbiIJdHJ1ZSIPdm9sdW1lU2l6ZSIHMzAiD2RldmljZU5hbWUi +Di9kZXYvc2RhMSIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFh +bWktZjcxZmYwOWUiE3Jvb3REZXZpY2VOYW1lIg4vZGV2L3NkYTEiE3Jvb3RE +ZXZpY2VUeXBlIghlYnMiEGRlc2NyaXB0aW9uIlNNaWNyb3NvZnQgV2luZG93 +cyAyMDAzIFIyIDY0LWJpdCwgSUlTIDYuMCwgU3FsIDIwMDUgRXhwcmVzcywg +QU1JIFJlbGVhc2UgdjEuMDkiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1p +c1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiI3YW1hem9uL1dpbmRvd3Mt +U2VydmVyMjAwM1IyLXg4Nl82NC1TcWxFeHByZXNzLXYxMDkiDXBsYXRmb3Jt +Igx3aW5kb3dzIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklk +IhEyMDYwMjk2MjE1MzJ7EyIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0Rl +dmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1mNDU4YmE5ZCIPaW1hZ2VT +dGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHBy +b2R1Y3RDb2RlIg0yMUU5RUJDOSINa2VybmVsSWQiEWFraS1mODU4YmE5MSIM +aW1hZ2VJZCIRYW1pLWY4YWQ0MDkxIhNyb290RGV2aWNlTmFtZSIOL2Rldi9z +ZGExIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3du +ZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlv +biJjZWMyLXBhaWQtaWJtLWltYWdlcy1pbmZvc3BoZXJlL2libS1pbmZvc3Bo +ZXJlLWRhdGFzdGFnZS1xdWFsaXR5c3RhZ2Utc2VydmVyLTY0Yml0Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIR +NDcwMjU0NTM0MDI0exIiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZp +Y2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktZmFmMDEyOTMiD2ltYWdlU3Rh +dGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9k +dWN0Q29kZSINRDY2MkU5ODkiDWtlcm5lbElkIhFha2ktZjhmMDEyOTEiDGlt +YWdlSWQiEWFtaS1mZWYwMTI5NyITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iQmVjMi1wYWlkLWlibS1pbWFnZXMvaWJtLW1h +c2h1cC1jZW50ZXItMi4wLTMyLWJpdC5tYW5pZmVzdC54bWwiEWFyY2hpdGVj +dHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1h +Z2VUeXBlIgxyYW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFyaS0wMjRhYTg2YiITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iRmVjMi1wYWlk +LWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjMwLXhlbi54ODZfNjQu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgxyYW1kaXNrIhdibG9j +a0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1 +Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUE5NDA4QjRCIgxp +bWFnZUlkIhFhcmktMGM1MWIzNjUiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5j +ZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0 +cnVlIhJpbWFnZUxvY2F0aW9uIkplYzItcGFpZC1pYm0taW1hZ2VzLWlkcy9p +bml0cmQtMi42LjE2LjYwLTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwi +EWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGlu +ZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0 +ZW1bBnsGIhBwcm9kdWN0Q29kZSINNTc4QkY1QkEiDGltYWdlSWQiEWFyaS0y +MWQzMzA0OCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFn +ZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9j +YXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0w +LjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglp +Mzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIgluYW1lIjZpbml0 +cmQtMi42LjE4LXhlblUtZWMyLXYxLjQuaTY4Ni5hcmkubWFuaWZlc3QueG1s +Ig5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJpLTIyNDJhMDRiIhNy +b290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlh +cyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMy +LXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4xOC14ZW5VLWVjMi12MS40Lmk2 +ODYuYXJpLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETIwNjAyOTYyMTUzMnsQIgluYW1lIjhpbml0cmQtMi42LjE4 +LXhlblUtZWMyLXYxLjQueDg2XzY0LmFyaS5tYW5pZmVzdC54bWwiDmltYWdl +VHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0 +ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhcmktMmM0MmEwNDUiE3Jvb3REZXZp +Y2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6 +b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkplYzItcHVibGlj +LWltYWdlcy9pbml0cmQtMi42LjE4LXhlblUtZWMyLXYxLjQueDg2XzY0LmFy +aS5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93 +bmVySWQiETIwNjAyOTYyMTUzMnsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Js +b2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1h +Z2VJZCIRYXJpLTMyMzhkYTViIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Ut +c3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1 +ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBhaWQtaWJtLWltYWdlcy9pbml0cmQt +Mi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNo +aXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0ew8i +DmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhcmktNDJiOTVhMmIiE3Jv +b3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFz +IgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIlBlYzIt +cHVibGljLWltYWdlcy9pbml0cmQtMi42LjIxLjctMi5mYzh4ZW4tZWMyLXYx +LjAuMS5pMzg2LmFyaS5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4 +NiIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7ECIOaW1hZ2VUeXBlIgxy +YW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUi +DThGQ0UzRUVCIgxpbWFnZUlkIhFhcmktNDg0OGFmMjEiE3Jvb3REZXZpY2VU +eXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24i +DWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkZlYzItcGFpZC1pYm0t +aW1hZ2VzL2luaXRyZC0yLjYuMTYuNjAtMC4zMC14ZW4ueDg2XzY0Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIR +NDcwMjU0NTM0MDI0exAiDmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZp +Y2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29k +ZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg00NzZEMjlDQiIMaW1hZ2VJ +ZCIRYXJpLTQ5NDhhZjIwIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3Rv +cmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSIS +aW1hZ2VMb2NhdGlvbiJGZWMyLXBhaWQtaWJtLWltYWdlcy9pbml0cmQtMi42 +LjE2LjYwLTAuMzAteGVuLng4Nl82NC5tYW5pZmVzdC54bWwiEWFyY2hpdGVj +dHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsPIg5p +bWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJpLTRmNThiOTI2IhNyb290 +RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyIL +YW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBh +aWQtaWJtLWltYWdlcy9pbml0cmQtMi42LjE2LjYwLTAuMjkteGVucGFlLmkz +ODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3du +ZXJJZCIRNDcwMjU0NTM0MDI0ew8iDmltYWdlVHlwZSIMcmFtZGlzayIXYmxv +Y2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFn +ZUlkIhFhcmktNGZkZjNmMjYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1z +dG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVl +IhJpbWFnZUxvY2F0aW9uIlBlYzItcHVibGljLWltYWdlcy9pbml0cmQtMi42 +LjIxLjctMi5mYzh4ZW4tZWMyLXYxLjAueDg2XzY0LmFyaS5tYW5pZmVzdC54 +bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFpbWFnZU93bmVySWQiETIwNjAy +OTYyMTUzMnsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFw +cGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJpLTU2 +Y2UyYzNmIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdl +T3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2Nh +dGlvbiJQZWMyLXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4yMS43LTIuZWMy +LnYxLjIuZmM4eGVuLng4Nl82NC5hcmkubWFuaWZlc3QueG1sIhFhcmNoaXRl +Y3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIO +aW1hZ2VUeXBlIgxyYW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFn +ZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFyaS02MDRhYTgwOSITcm9v +dERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMi +C2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1w +YWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5p +Mzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93 +bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Js +b2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJv +ZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRDZGQjExMTMi +DGltYWdlSWQiEWFyaS02MTc3OTQwOCITcm9vdERldmljZVR5cGUiE2luc3Rh +bmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMi +CXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMvaW5p +dHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAy +NHsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAi +D2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1b +BnsGIhBwcm9kdWN0Q29kZSINQ0NFQjM2OEIiDGltYWdlSWQiEWFyaS02NDQ4 +YTgwZCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iR2VjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5 +LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2 +IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDHJh +bWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWls +YWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSIN +RDZGNjA1MkEiDGltYWdlSWQiEWFyaS02NDUxYjMwZCITcm9vdERldmljZVR5 +cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiIN +aXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1p +bWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3 +MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNl +TWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJp +LTY0Yjk1ZTBkIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJKZWMyLXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4xOC14ZW5V +LWVjMi12MS4wLng4Nl82NC5hcmkubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1 +cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYwMjk2MjE1MzJ7DyIOaW1h +Z2VUeXBlIgxyYW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0 +YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFyaS02NTkxNzEwYyITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlk +LWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2 +Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVy +SWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2Nr +RGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVj +dENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINODBFRDAwQjgiDGlt +YWdlSWQiEWFyaS02NjQ4YTgwZiITcm9vdERldmljZVR5cGUiE2luc3RhbmNl +LXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRy +dWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJk +LTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJj +aGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsP +Ig5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2lt +YWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJpLTY3Yjk1ZTBlIhNy +b290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlh +cyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJIZWMy +LXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4xOC14ZW5VLWVjMi12MS4wLmkz +ODYuYXJpLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETIwNjAyOTYyMTUzMnsQIg5pbWFnZVR5cGUiDHJhbWRpc2si +F2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIR +cHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINNDlDQTcz +MDUiDGltYWdlSWQiEWFyaS02YzQ4YTgwNSITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMv +aW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0Lnht +bCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGlu +ZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0 +ZW1bBnsGIhBwcm9kdWN0Q29kZSINRUE1RjA1QTMiDGltYWdlSWQiEWFyaS02 +ZGVjMGMwNCITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFn +ZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9j +YXRpb24iRmVjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0w +LjMwLXhlbi54ODZfNjQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4 +Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBl +IgxyYW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiEXByb2R1Y3RDb2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENv +ZGUiDUQ2RkIxMTEzIgxpbWFnZUlkIhFhcmktNzQ0OGFmMWQiE3Jvb3REZXZp +Y2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6 +b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIkdlYzItcGFpZC1p +Ym0taW1hZ2VzL2luaXRyZC0yLjYuMTYuNjAtMC4yOS14ZW5wYWUuaTM4Ni5t +YW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklk +IhE0NzAyNTQ1MzQwMjR7ECIOaW1hZ2VUeXBlIgxyYW1kaXNrIhdibG9ja0Rl +dmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiEXByb2R1Y3RD +b2Rlc3sGIglpdGVtWwZ7BiIQcHJvZHVjdENvZGUiDUVBNUYwNUEzIgxpbWFn +ZUlkIhFhcmktNzY0OGFmMWYiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1z +dG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVl +IhJpbWFnZUxvY2F0aW9uIkZlYzItcGFpZC1pYm0taW1hZ2VzL2luaXRyZC0y +LjYuMTYuNjAtMC4zMC14ZW4ueDg2XzY0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAi +DmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYi +EHByb2R1Y3RDb2RlIg1BNDgxODk1RCIMaW1hZ2VJZCIRYXJpLTc3NDhhZjFl +IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJB +bGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJH +ZWMyLXBhaWQtaWJtLWltYWdlcy9pbml0cmQtMi42LjE2LjYwLTAuMjkteGVu +cGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWlt +YWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0ew8iDmltYWdlVHlwZSIMcmFtZGlz +ayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxl +IgxpbWFnZUlkIhFhcmktN2NiOTVhMTUiE3Jvb3REZXZpY2VUeXBlIhNpbnN0 +YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGlj +Igl0cnVlIhJpbWFnZUxvY2F0aW9uIlJlYzItcHVibGljLWltYWdlcy9pbml0 +cmQtMi42LjIxLjctMi5mYzh4ZW4tZWMyLXYxLjAuMS54ODZfNjQuYXJpLm1h +bmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJ +ZCIRMjA2MDI5NjIxNTMyexAiDmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tE +ZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0 +Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg01NzhCRjVCQSIMaW1h +Z2VJZCIRYXJpLTgxM2ZkZWU4IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Ut +c3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1 +ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBhaWQtaWJtLWltYWdlcy9pbml0cmQt +Mi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3QueG1sIhFhcmNo +aXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAi +DmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1h +Z2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYi +EHByb2R1Y3RDb2RlIg1BNDgxODk1RCIMaW1hZ2VJZCIRYXJpLTg4ZTYwYmUx +IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJB +bGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJL +ZWMyLXBhaWQtaWJtLWltYWdlcy1kYjIvaW5pdHJkLTIuNi4xNi42MC0wLjI5 +LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2 +IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDHJh +bWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWls +YWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSIN +QTQ4MTg5NUQiDGltYWdlSWQiEWFyaS05MWViMGJmOCITcm9vdERldmljZVR5 +cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiIN +aXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1p +bWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3 +MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNl +TWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJp +LTk2YzUyN2ZmIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJOZWMyLXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4yMS43LTIu +ZWMyLnYxLjIuZmM4eGVuLmk2ODYuYXJpLm1hbmlmZXN0LnhtbCIRYXJjaGl0 +ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsQIg5p +bWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdl +U3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBw +cm9kdWN0Q29kZSINRTNENDhDRUUiDGltYWdlSWQiEWFyaS05YTcwOTBmMyIT +cm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxp +YXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2Vj +Mi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBh +ZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFn +ZU93bmVySWQiETQ3MDI1NDUzNDAyNHsQIg5pbWFnZVR5cGUiDHJhbWRpc2si +F2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIR +cHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0Q29kZSINRDY2MkU5 +ODkiDGltYWdlSWQiEWFyaS05ZjNmZGVmNiITcm9vdERldmljZVR5cGUiE2lu +c3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJs +aWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1pbWFnZXMv +aW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlmZXN0Lnht +bCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3MDI1NDUz +NDAyNHsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGlu +ZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJpLWEyM2Fk +ZmNiIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3du +ZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlv +biJDZWMyLXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4yMC0xLjMwMDIuZmM2 +eGVuLmFyaS5tYW5pZmVzdC54bWwiEWFyY2hpdGVjdHVyZSILeDg2XzY0IhFp +bWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsPIg5pbWFnZVR5cGUiDHJhbWRp +c2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJs +ZSIMaW1hZ2VJZCIRYXJpLWE1MWNmOWNjIhNyb290RGV2aWNlVHlwZSITaW5z +dGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1Ymxp +YyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJFZWMyLXB1YmxpYy1pbWFnZXMvZWMy +LWluaXRyZC0yLjYuMjEuNy0yLmZjOHhlbi5pMzg2Lm1hbmlmZXN0LnhtbCIR +YXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUz +MnsQIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAi +D2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1b +BnsGIhBwcm9kdWN0Q29kZSINRDZGNjA1MkEiDGltYWdlSWQiEWFyaS1iMjRi +YWNkYiITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93 +bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRp +b24iR2VjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5 +LXhlbnBhZS5pMzg2Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2 +IhFpbWFnZU93bmVySWQiETQ3MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiDHJh +bWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWls +YWJsZSIMaW1hZ2VJZCIRYXJpLWIzMWNmOWRhIhNyb290RGV2aWNlVHlwZSIT +aW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1 +YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXB1YmxpYy1pbWFnZXMv +ZWMyLWluaXRyZC0yLjYuMjEuNy0yLmZjOHhlbi54ODZfNjQubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhEyMDYw +Mjk2MjE1MzJ7DyIOaW1hZ2VUeXBlIgxyYW1kaXNrIhdibG9ja0RldmljZU1h +cHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdlSWQiEWFyaS1i +YWYyMTBkMyITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFn +ZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9j +YXRpb24iRmVjMi1wYWlkLWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0w +LjMwLXhlbi54ODZfNjQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4 +Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1hZ2VUeXBl +IgxyYW1kaXNrIhdibG9ja0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5h +dmFpbGFibGUiDGltYWdlSWQiEWFyaS1iZGU3MDdkNCITcm9vdERldmljZVR5 +cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiIN +aXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iR2VjMi1wYWlkLWlibS1p +bWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjI5LXhlbnBhZS5pMzg2Lm1hbmlm +ZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETQ3 +MDI1NDUzNDAyNHsPIg5pbWFnZVR5cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNl +TWFwcGluZzAiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSIMaW1hZ2VJZCIRYXJp +LWRiYzEyMWIyIhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJIZWMyLXB1YmxpYy1pbWFnZXMvaW5pdHJkLTIuNi4xOC14ZW5V +LWVjMi12MS4yLmkzODYuYXJpLm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJl +IglpMzg2IhFpbWFnZU93bmVySWQiETIwNjAyOTYyMTUzMnsQIg5pbWFnZVR5 +cGUiDHJhbWRpc2siF2Jsb2NrRGV2aWNlTWFwcGluZzAiD2ltYWdlU3RhdGUi +DmF2YWlsYWJsZSIRcHJvZHVjdENvZGVzewYiCWl0ZW1bBnsGIhBwcm9kdWN0 +Q29kZSINQTk0MDhCNEIiDGltYWdlSWQiEWFyaS1kZDRiYWNiNCITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iRmVjMi1wYWlk +LWlibS1pbWFnZXMvaW5pdHJkLTIuNi4xNi42MC0wLjMwLXhlbi54ODZfNjQu +bWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiC3g4Nl82NCIRaW1hZ2VPd25l +cklkIhE0NzAyNTQ1MzQwMjR7DyIOaW1hZ2VUeXBlIgxyYW1kaXNrIhdibG9j +a0RldmljZU1hcHBpbmcwIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDGltYWdl +SWQiEWFyaS1lM2MxMjE4YSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0 +b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUi +EmltYWdlTG9jYXRpb24iSmVjMi1wdWJsaWMtaW1hZ2VzL2luaXRyZC0yLjYu +MTgteGVuVS1lYzItdjEuMi54ODZfNjQuYXJpLm1hbmlmZXN0LnhtbCIRYXJj +aGl0ZWN0dXJlIgt4ODZfNjQiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMy +ew8iDmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIP +aW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIgxpbWFnZUlkIhFhcmktZTdkYzNjOGUi +E3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25lckFs +aWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9uIk5l +YzItcHVibGljLWltYWdlcy9pbml0cmQtMi42LjIxLjctMi5mYzh4ZW4tZWMy +LXYxLjAuaTM4Ni5hcmkubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkz +ODYiEWltYWdlT3duZXJJZCIRMjA2MDI5NjIxNTMyexAiDmltYWdlVHlwZSIM +cmFtZGlzayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZh +aWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2Rl +Ig0yMUU5RUJDOSIMaW1hZ2VJZCIRYXJpLWY0NThiYTlkIhNyb290RGV2aWNl +VHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9u +Ig1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJRZWMyLXBhaWQtaWJt +LWltYWdlcy1pbmZvc3BoZXJlL2luaXRyZC0yLjYuMTYuNjAtMC4zMC14ZW4u +eDg2XzY0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIgt4ODZfNjQiEWlt +YWdlT3duZXJJZCIRNDcwMjU0NTM0MDI0exAiDmltYWdlVHlwZSIMcmFtZGlz +ayIXYmxvY2tEZXZpY2VNYXBwaW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxl +IhFwcm9kdWN0Q29kZXN7BiIJaXRlbVsGewYiEHByb2R1Y3RDb2RlIg1ENjYy +RTk4OSIMaW1hZ2VJZCIRYXJpLWZhZjAxMjkzIhNyb290RGV2aWNlVHlwZSIT +aW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1 +YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJHZWMyLXBhaWQtaWJtLWltYWdl +cy9pbml0cmQtMi42LjE2LjYwLTAuMjkteGVucGFlLmkzODYubWFuaWZlc3Qu +eG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRNDcwMjU0 +NTM0MDI0exAiDmltYWdlVHlwZSIMcmFtZGlzayIXYmxvY2tEZXZpY2VNYXBw +aW5nMCIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxlIhFwcm9kdWN0Q29kZXN7BiIJ +aXRlbVsGewYiEHByb2R1Y3RDb2RlIg1FQTVGMDVBMyIMaW1hZ2VJZCIRYXJp +LWZjZmQxMDk1IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGlt +YWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VM +b2NhdGlvbiJKZWMyLXBhaWQtaWJtLWltYWdlcy1kYjIvaW5pdHJkLTIuNi4x +Ni42MC0wLjMwLXhlbi54ODZfNjQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1 +cmUiC3g4Nl82NCIRaW1hZ2VPd25lcklkIhE0NzAyNTQ1MzQwMjQiDnJlcXVl +c3RJZCIpZmViNzMxM2MtNGFlYi00OTJhLWJkZjAtNDMyYTU4MTkyNDdlIgp4 +bWxucyItaHR0cDovL2VjMi5hbWF6b25hd3MuY29tL2RvYy8yMDA5LTExLTMw +Lw== diff --git a/tests/ec2/support/ec2/describe_images.45eee35ec8f8243c05d85cf5486c54368be8207e b/tests/ec2/support/ec2/describe_images.45eee35ec8f8243c05d85cf5486c54368be8207e new file mode 100644 index 0000000..4df93e8 --- /dev/null +++ b/tests/ec2/support/ec2/describe_images.45eee35ec8f8243c05d85cf5486c54368be8207e @@ -0,0 +1,11 @@ +BAh7CCIOaW1hZ2VzU2V0ewYiCWl0ZW1bBnsRIg5pbWFnZVR5cGUiDG1hY2hp +bmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNm +OWNjIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTcx +Y2Y5Y2UiDGltYWdlSWQiEWFtaS0xMWNhMmQ3OCITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iP2F3cy10b29sa2l0LWZvci1l +Y2xpcHNlLWFtaXMtdXMvdG9tY2F0LXYxLjAuMC5tYW5pZmVzdC54bWwiEWFy +Y2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3MTYi +DnJlcXVlc3RJZCIpNGExMzAxN2EtZGZhOS00NjlhLTkwOGEtOGE2ZDhlODkw +ZGZkIgp4bWxucyItaHR0cDovL2VjMi5hbWF6b25hd3MuY29tL2RvYy8yMDA5 +LTExLTMwLw== diff --git a/tests/ec2/support/ec2/describe_images.491d1c515d961d5875891b26586ece2a2994be84 b/tests/ec2/support/ec2/describe_images.491d1c515d961d5875891b26586ece2a2994be84 new file mode 100644 index 0000000..a699726 --- /dev/null +++ b/tests/ec2/support/ec2/describe_images.491d1c515d961d5875891b26586ece2a2994be84 @@ -0,0 +1,79 @@ +BAh7CCIOaW1hZ2VzU2V0ewYiCWl0ZW1bD3sRIg5pbWFnZVR5cGUiDG1hY2hp +bmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNm +OWNjIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTcx +Y2Y5Y2UiDGltYWdlSWQiEWFtaS0xMWNhMmQ3OCITcm9vdERldmljZVR5cGUi +E2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQ +dWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iP2F3cy10b29sa2l0LWZvci1l +Y2xpcHNlLWFtaXMtdXMvdG9tY2F0LXYxLjAuMC5tYW5pZmVzdC54bWwiEWFy +Y2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3MTZ7 +ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBpbmcwIg5y +YW1kaXNrSWQiEWFyaS1kYmMxMjFiMiIPaW1hZ2VTdGF0ZSIOYXZhaWxhYmxl +Ig1rZXJuZWxJZCIRYWtpLWY1YzEyMTljIgxpbWFnZUlkIhFhbWktMjBiMDUz +NDkiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1hZ2VPd25l +ckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxvY2F0aW9u +IkVhd3MtY29uc29sZS1xdWlja3N0YXJ0LWFtaXMvcGVybC8xLjMvcGVybHF1 +aWNrc3RhcnQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWlt +YWdlT3duZXJJZCIRMjA1NjA1ODE5NzE2exEiDmltYWdlVHlwZSIMbWFjaGlu +ZSIXYmxvY2tEZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktZGJjMTIx +YjIiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSINa2VybmVsSWQiEWFraS1mNWMx +MjE5YyIMaW1hZ2VJZCIRYW1pLTIyYjA1MzRiIhNyb290RGV2aWNlVHlwZSIT +aW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1 +YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJFYXdzLWNvbnNvbGUtcXVpY2tz +dGFydC1hbWlzL3J1YnkvMS4yL3J1YnlxdWlja3N0YXJ0Lm1hbmlmZXN0Lnht +bCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93bmVySWQiETIwNTYwNTgx +OTcxNnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGlu +ZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9pbWFnZVN0YXRlIg5hdmFp +bGFibGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2UiDGltYWdlSWQiEWFtaS0y +N2U3MDA0ZSITcm9vdERldmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFn +ZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9j +YXRpb24iRi9hd3MtY29uc29sZS1xdWlja3N0YXJ0LWFtaXMvcGVybC8xLjIv +cGVybHF1aWNrc3RhcnQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkz +ODYiEWltYWdlT3duZXJJZCIRMjA1NjA1ODE5NzE2exEiDmltYWdlVHlwZSIM +bWFjaGluZSIXYmxvY2tEZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmkt +ZGJjMTIxYjIiD2ltYWdlU3RhdGUiDmF2YWlsYWJsZSINa2VybmVsSWQiEWFr +aS1mNWMxMjE5YyIMaW1hZ2VJZCIRYW1pLTJjYjA1MzQ1IhNyb290RGV2aWNl +VHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9u +Ig1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJAYXdzLWNvbnNvbGUt +cXVpY2tzdGFydC1hbWlzL3BocHF1aWNrc3RhcnQtdjEuNS5tYW5pZmVzdC54 +bWwiEWFyY2hpdGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDU2MDU4 +MTk3MTZ7ESIOaW1hZ2VUeXBlIgxtYWNoaW5lIhdibG9ja0RldmljZU1hcHBp +bmcwIg5yYW1kaXNrSWQiEWFyaS1kYmMxMjFiMiIPaW1hZ2VTdGF0ZSIOYXZh +aWxhYmxlIg1rZXJuZWxJZCIRYWtpLWY1YzEyMTljIgxpbWFnZUlkIhFhbWkt +MmViMDUzNDciE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIUaW1h +Z2VPd25lckFsaWFzIgthbWF6b24iDWlzUHVibGljIgl0cnVlIhJpbWFnZUxv +Y2F0aW9uIklhd3MtY29uc29sZS1xdWlja3N0YXJ0LWFtaXMvdG9tY2F0LzEu +Mi90b21jYXRxdWlja3N0YXJ0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJl +IglpMzg2IhFpbWFnZU93bmVySWQiETIwNTYwNTgxOTcxNnsRIg5pbWFnZVR5 +cGUiDG1hY2hpbmUiF2Jsb2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIR +YXJpLWE1MWNmOWNjIg9pbWFnZVN0YXRlIg5hdmFpbGFibGUiDWtlcm5lbElk +IhFha2ktYTcxY2Y5Y2UiDGltYWdlSWQiEWFtaS00NWU3MDAyYyITcm9vdERl +dmljZVR5cGUiE2luc3RhbmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2Ft +YXpvbiINaXNQdWJsaWMiCXRydWUiEmltYWdlTG9jYXRpb24iSi9hd3MtY29u +c29sZS1xdWlja3N0YXJ0LWFtaXMvdG9tY2F0LzEuMS90b21jYXRxdWlja3N0 +YXJ0Lm1hbmlmZXN0LnhtbCIRYXJjaGl0ZWN0dXJlIglpMzg2IhFpbWFnZU93 +bmVySWQiETIwNTYwNTgxOTcxNnsRIg5pbWFnZVR5cGUiDG1hY2hpbmUiF2Js +b2NrRGV2aWNlTWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIg9p +bWFnZVN0YXRlIg5hdmFpbGFibGUiDWtlcm5lbElkIhFha2ktYTcxY2Y5Y2Ui +DGltYWdlSWQiEWFtaS01ZWU3MDAzNyITcm9vdERldmljZVR5cGUiE2luc3Rh +bmNlLXN0b3JlIhRpbWFnZU93bmVyQWxpYXMiC2FtYXpvbiINaXNQdWJsaWMi +CXRydWUiEmltYWdlTG9jYXRpb24iRi9hd3MtY29uc29sZS1xdWlja3N0YXJ0 +LWFtaXMvcnVieS8xLjEvcnVieXF1aWNrc3RhcnQubWFuaWZlc3QueG1sIhFh +cmNoaXRlY3R1cmUiCWkzODYiEWltYWdlT3duZXJJZCIRMjA1NjA1ODE5NzE2 +exEiDmltYWdlVHlwZSIMbWFjaGluZSIXYmxvY2tEZXZpY2VNYXBwaW5nMCIO +cmFtZGlza0lkIhFhcmktYTUxY2Y5Y2MiD2ltYWdlU3RhdGUiDmF2YWlsYWJs +ZSINa2VybmVsSWQiEWFraS1hNzFjZjljZSIMaW1hZ2VJZCIRYW1pLTYwZGEz +ZDA5IhNyb290RGV2aWNlVHlwZSITaW5zdGFuY2Utc3RvcmUiFGltYWdlT3du +ZXJBbGlhcyILYW1hem9uIg1pc1B1YmxpYyIJdHJ1ZSISaW1hZ2VMb2NhdGlv +biJBL2F3cy1jb25zb2xlLXF1aWNrc3RhcnQtYW1pcy9waHBxdWlja3N0YXJ0 +LXYxLjQubWFuaWZlc3QueG1sIhFhcmNoaXRlY3R1cmUiCWkzODYiEWltYWdl +T3duZXJJZCIRMjA1NjA1ODE5NzE2exEiDmltYWdlVHlwZSIMbWFjaGluZSIX +YmxvY2tEZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktYTUxY2Y5Y2Mi +D2ltYWdlU3RhdGUiDmF2YWlsYWJsZSINa2VybmVsSWQiEWFraS1hNzFjZjlj +ZSIMaW1hZ2VJZCIRYW1pLWQxY2EyZGI4IhNyb290RGV2aWNlVHlwZSITaW5z +dGFuY2Utc3RvcmUiFGltYWdlT3duZXJBbGlhcyILYW1hem9uIg1pc1B1Ymxp +YyIJdHJ1ZSISaW1hZ2VMb2NhdGlvbiJAYXdzLXRvb2xraXQtZm9yLWVjbGlw +c2UtYW1pcy11cy9oYXByb3h5LXYxLjAuMi5tYW5pZmVzdC54bWwiEWFyY2hp +dGVjdHVyZSIJaTM4NiIRaW1hZ2VPd25lcklkIhEyMDU2MDU4MTk3MTYiDnJl +cXVlc3RJZCIpM2EyNGFmZWUtN2Y1Yi00ZTQ2LWJkOTQtMzFhYmYwNTk0N2Y4 +Igp4bWxucyItaHR0cDovL2VjMi5hbWF6b25hd3MuY29tL2RvYy8yMDA5LTEx +LTMwLw== diff --git a/tests/ec2/support/ec2/describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 b/tests/ec2/support/ec2/describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 new file mode 100644 index 0000000..8dae6dc --- /dev/null +++ b/tests/ec2/support/ec2/describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 @@ -0,0 +1,19 @@ +BAh7CCIOcmVxdWVzdElkIik3YzBmZjU3Ny05NzM3LTRmNmMtYWM4ZS0yOTZm +MWNmY2VjNzYiE3Jlc2VydmF0aW9uU2V0ewYiCWl0ZW1bBnsJIhJyZXNlcnZh +dGlvbklkIg9yLTRkOWQ2MjI2Ig1ncm91cFNldHsGIglpdGVtWwZ7BiIMZ3Jv +dXBJZCIMZGVmYXVsdCIRaW5zdGFuY2VzU2V0ewYiCWl0ZW1bBnsZIhVwcml2 +YXRlSXBBZGRyZXNzIhMxMC4xOTIuMTM5LjExNSIMa2V5TmFtZSIMdGVzdGlu +ZyIXYmxvY2tEZXZpY2VNYXBwaW5nMCIOcmFtZGlza0lkIhFhcmktYTUxY2Y5 +Y2MiEXByb2R1Y3RDb2RlczAiDmlwQWRkcmVzcyIRNzUuMTAxLjE5OC4zIg1r +ZXJuZWxJZCIRYWtpLWE3MWNmOWNlIg9sYXVuY2hUaW1lIh0yMDEwLTA1LTE4 +VDExOjMzOjM0LjAwMFoiE2FtaUxhdW5jaEluZGV4IgYwIgxpbWFnZUlkIhFh +bWktMTFjYTJkNzgiEWluc3RhbmNlVHlwZSINbTEuc21hbGwiC3JlYXNvbjAi +E3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIOcGxhY2VtZW50ewYi +FWF2YWlsYWJpbGl0eVpvbmUiD3VzLWVhc3QtMWEiD2luc3RhbmNlSWQiD2kt +Yzc0NzYzYWMiE3ByaXZhdGVEbnNOYW1lIi5kb21VLTEyLTMxLTM5LTBFLTg4 +LTg1LmNvbXB1dGUtMS5pbnRlcm5hbCIMZG5zTmFtZSItZWMyLTc1LTEwMS0x +OTgtMy5jb21wdXRlLTEuYW1hem9uYXdzLmNvbSIRYXJjaGl0ZWN0dXJlIglp +Mzg2Ig9tb25pdG9yaW5newYiCnN0YXRlIgxlbmFibGVkIhJpbnN0YW5jZVN0 +YXRlewciCW5hbWUiDHJ1bm5pbmciCWNvZGUiBzE2Igxvd25lcklkIhEyOTM3 +ODc3NDk4ODQiCnhtbG5zIi1odHRwOi8vZWMyLmFtYXpvbmF3cy5jb20vZG9j +LzIwMDktMTEtMzAv diff --git a/tests/ec2/support/ec2/reboot_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 b/tests/ec2/support/ec2/reboot_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 new file mode 100644 index 0000000..81d4cf3 --- /dev/null +++ b/tests/ec2/support/ec2/reboot_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 @@ -0,0 +1,19 @@ +BAh7CCIOcmVxdWVzdElkIilmNTRlZTliNC04MjIwLTQxZmMtYjQxNC0yNTdm +MjgzYTgyYzUiE3Jlc2VydmF0aW9uU2V0ewYiCWl0ZW1bBnsJIhJyZXNlcnZh +dGlvbklkIg9yLTBkOWI2NDY2Ig1ncm91cFNldHsGIglpdGVtWwZ7BiIMZ3Jv +dXBJZCIMZGVmYXVsdCIRaW5zdGFuY2VzU2V0ewYiCWl0ZW1bBnsZIhVwcml2 +YXRlSXBBZGRyZXNzIhIxMC4yNTQuOTcuMTg4IgxrZXlOYW1lIgx0ZXN0aW5n +IhdibG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1hNTFjZjlj +YyIRcHJvZHVjdENvZGVzMCIOaXBBZGRyZXNzIhIxODQuNzMuODQuMTk1Ig1r +ZXJuZWxJZCIRYWtpLWE3MWNmOWNlIg9sYXVuY2hUaW1lIh0yMDEwLTA1LTE4 +VDExOjQ0OjM1LjAwMFoiE2FtaUxhdW5jaEluZGV4IgYwIgxpbWFnZUlkIhFh +bWktMTFjYTJkNzgiEWluc3RhbmNlVHlwZSINbTEuc21hbGwiC3JlYXNvbjAi +E3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIOcGxhY2VtZW50ewYi +FWF2YWlsYWJpbGl0eVpvbmUiD3VzLWVhc3QtMWEiD2luc3RhbmNlSWQiD2kt +ZTc0MjY2OGMiE3ByaXZhdGVEbnNOYW1lIi5kb21VLTEyLTMxLTM5LTAwLTVF +LTMyLmNvbXB1dGUtMS5pbnRlcm5hbCIMZG5zTmFtZSIuZWMyLTE4NC03My04 +NC0xOTUuY29tcHV0ZS0xLmFtYXpvbmF3cy5jb20iEWFyY2hpdGVjdHVyZSIJ +aTM4NiIPbW9uaXRvcmluZ3sGIgpzdGF0ZSIMZW5hYmxlZCISaW5zdGFuY2VT +dGF0ZXsHIgluYW1lIgxydW5uaW5nIgljb2RlIgcxNiIMb3duZXJJZCIRMjkz +Nzg3NzQ5ODg0Igp4bWxucyItaHR0cDovL2VjMi5hbWF6b25hd3MuY29tL2Rv +Yy8yMDA5LTExLTMwLw== diff --git a/tests/ec2/support/ec2/reboot_instances.8db15ec3f117ce8070a0550fd99ac76ce508ade5 b/tests/ec2/support/ec2/reboot_instances.8db15ec3f117ce8070a0550fd99ac76ce508ade5 new file mode 100644 index 0000000..82c2986 --- /dev/null +++ b/tests/ec2/support/ec2/reboot_instances.8db15ec3f117ce8070a0550fd99ac76ce508ade5 @@ -0,0 +1,3 @@ +BAh7CCIOcmVxdWVzdElkIik5NWMxNTVmOS1iNjcyLTRkZTMtYmJmMC03M2I2 +MGNkZjdhODciC3JldHVybiIJdHJ1ZSIKeG1sbnMiLWh0dHA6Ly9lYzIuYW1h +em9uYXdzLmNvbS9kb2MvMjAwOS0xMS0zMC8= diff --git a/tests/ec2/support/ec2/reboot_reboot_instances.af7d3d510feb715a04fd18e586088975e2ab5a9f b/tests/ec2/support/ec2/reboot_reboot_instances.af7d3d510feb715a04fd18e586088975e2ab5a9f new file mode 100644 index 0000000..c8d2f31 --- /dev/null +++ b/tests/ec2/support/ec2/reboot_reboot_instances.af7d3d510feb715a04fd18e586088975e2ab5a9f @@ -0,0 +1,3 @@ +BAh7CCIOcmVxdWVzdElkIik4OGQxNjM2YS1hMjE0LTQyMjMtOThmMS0xNjZm +ZTIxMjU3YjEiC3JldHVybiIJdHJ1ZSIKeG1sbnMiLWh0dHA6Ly9lYzIuYW1h +em9uYXdzLmNvbS9kb2MvMjAwOS0xMS0zMC8= diff --git a/tests/ec2/support/ec2/run_instances.d42fd93b19e95a9b2eac3a1e16f1d82d5c242524 b/tests/ec2/support/ec2/run_instances.d42fd93b19e95a9b2eac3a1e16f1d82d5c242524 new file mode 100644 index 0000000..d71fc85 --- /dev/null +++ b/tests/ec2/support/ec2/run_instances.d42fd93b19e95a9b2eac3a1e16f1d82d5c242524 @@ -0,0 +1,16 @@ +BAh7CyIScmVzZXJ2YXRpb25JZCIPci0wZDliNjQ2NiINZ3JvdXBTZXR7BiIJ +aXRlbVsGewYiDGdyb3VwSWQiDGRlZmF1bHQiDnJlcXVlc3RJZCIpNTUyNmQ5 +ZmEtYzVlOS00MmE4LTk5MjYtNDQwM2M1Y2VhODJiIhFpbnN0YW5jZXNTZXR7 +BiIJaXRlbVsGexciEHN0YXRlUmVhc29uewciCWNvZGUiDHBlbmRpbmciDG1l +c3NhZ2UiDHBlbmRpbmciDGtleU5hbWUiDHRlc3RpbmciF2Jsb2NrRGV2aWNl +TWFwcGluZzAiDnJhbWRpc2tJZCIRYXJpLWE1MWNmOWNjIhFwcm9kdWN0Q29k +ZXMwIg1rZXJuZWxJZCIRYWtpLWE3MWNmOWNlIg9sYXVuY2hUaW1lIh0yMDEw +LTA1LTE4VDExOjQ0OjM1LjAwMFoiE2FtaUxhdW5jaEluZGV4IgYwIgxpbWFn +ZUlkIhFhbWktMTFjYTJkNzgiEWluc3RhbmNlVHlwZSINbTEuc21hbGwiC3Jl +YXNvbjAiE3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIOcGxhY2Vt +ZW50ewYiFWF2YWlsYWJpbGl0eVpvbmUiD3VzLWVhc3QtMWEiD2luc3RhbmNl +SWQiD2ktZTc0MjY2OGMiE3ByaXZhdGVEbnNOYW1lMCIMZG5zTmFtZTAiD21v +bml0b3Jpbmd7BiIKc3RhdGUiDHBlbmRpbmciEmluc3RhbmNlU3RhdGV7ByIJ +bmFtZSIMcGVuZGluZyIJY29kZSIGMCIMb3duZXJJZCIRMjkzNzg3NzQ5ODg0 +Igp4bWxucyItaHR0cDovL2VjMi5hbWF6b25hd3MuY29tL2RvYy8yMDA5LTEx +LTMwLw== diff --git a/tests/ec2/support/ec2/start_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 b/tests/ec2/support/ec2/start_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 new file mode 100644 index 0000000..c3db883 --- /dev/null +++ b/tests/ec2/support/ec2/start_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 @@ -0,0 +1,19 @@ +BAh7CCIOcmVxdWVzdElkIikzMDdkMjQzYi1kMWRhLTRkMDktYTE0Yi1lMzAx +ZjdlNTQwMzUiE3Jlc2VydmF0aW9uU2V0ewYiCWl0ZW1bBnsJIhJyZXNlcnZh +dGlvbklkIg9yLTBkOWI2NDY2Ig1ncm91cFNldHsGIglpdGVtWwZ7BiIMZ3Jv +dXBJZCIMZGVmYXVsdCIRaW5zdGFuY2VzU2V0ewYiCWl0ZW1bBnsZIhVwcml2 +YXRlSXBBZGRyZXNzIhIxMC4yNTQuOTcuMTg4IgxrZXlOYW1lIgx0ZXN0aW5n +IhdibG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1hNTFjZjlj +YyIRcHJvZHVjdENvZGVzMCIOaXBBZGRyZXNzIhIxODQuNzMuODQuMTk1Ig1r +ZXJuZWxJZCIRYWtpLWE3MWNmOWNlIg9sYXVuY2hUaW1lIh0yMDEwLTA1LTE4 +VDExOjQ0OjM1LjAwMFoiE2FtaUxhdW5jaEluZGV4IgYwIgxpbWFnZUlkIhFh +bWktMTFjYTJkNzgiEWluc3RhbmNlVHlwZSINbTEuc21hbGwiC3JlYXNvbjAi +E3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIOcGxhY2VtZW50ewYi +FWF2YWlsYWJpbGl0eVpvbmUiD3VzLWVhc3QtMWEiD2luc3RhbmNlSWQiD2kt +ZTc0MjY2OGMiE3ByaXZhdGVEbnNOYW1lIi5kb21VLTEyLTMxLTM5LTAwLTVF +LTMyLmNvbXB1dGUtMS5pbnRlcm5hbCIMZG5zTmFtZSIuZWMyLTE4NC03My04 +NC0xOTUuY29tcHV0ZS0xLmFtYXpvbmF3cy5jb20iEWFyY2hpdGVjdHVyZSIJ +aTM4NiIPbW9uaXRvcmluZ3sGIgpzdGF0ZSIMZW5hYmxlZCISaW5zdGFuY2VT +dGF0ZXsHIgluYW1lIgxydW5uaW5nIgljb2RlIgcxNiIMb3duZXJJZCIRMjkz +Nzg3NzQ5ODg0Igp4bWxucyItaHR0cDovL2VjMi5hbWF6b25hd3MuY29tL2Rv +Yy8yMDA5LTExLTMwLw== diff --git a/tests/ec2/support/ec2/stop_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 b/tests/ec2/support/ec2/stop_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 new file mode 100644 index 0000000..b8907bd --- /dev/null +++ b/tests/ec2/support/ec2/stop_describe_instances.da39a3ee5e6b4b0d3255bfef95601890afd80709 @@ -0,0 +1,19 @@ +BAh7CCIOcmVxdWVzdElkIilkMGY1NWM3ZC1hNzc4LTQ2M2UtYTY5MC0yNWVm +ZDkyNzQ1ZDUiE3Jlc2VydmF0aW9uU2V0ewYiCWl0ZW1bBnsJIhJyZXNlcnZh +dGlvbklkIg9yLTBkOWI2NDY2Ig1ncm91cFNldHsGIglpdGVtWwZ7BiIMZ3Jv +dXBJZCIMZGVmYXVsdCIRaW5zdGFuY2VzU2V0ewYiCWl0ZW1bBnsZIhVwcml2 +YXRlSXBBZGRyZXNzIhIxMC4yNTQuOTcuMTg4IgxrZXlOYW1lIgx0ZXN0aW5n +IhdibG9ja0RldmljZU1hcHBpbmcwIg5yYW1kaXNrSWQiEWFyaS1hNTFjZjlj +YyIRcHJvZHVjdENvZGVzMCIOaXBBZGRyZXNzIhIxODQuNzMuODQuMTk1Ig1r +ZXJuZWxJZCIRYWtpLWE3MWNmOWNlIg9sYXVuY2hUaW1lIh0yMDEwLTA1LTE4 +VDExOjQ0OjM1LjAwMFoiE2FtaUxhdW5jaEluZGV4IgYwIgxpbWFnZUlkIhFh +bWktMTFjYTJkNzgiEWluc3RhbmNlVHlwZSINbTEuc21hbGwiC3JlYXNvbjAi +E3Jvb3REZXZpY2VUeXBlIhNpbnN0YW5jZS1zdG9yZSIOcGxhY2VtZW50ewYi +FWF2YWlsYWJpbGl0eVpvbmUiD3VzLWVhc3QtMWEiD2luc3RhbmNlSWQiD2kt +ZTc0MjY2OGMiE3ByaXZhdGVEbnNOYW1lIi5kb21VLTEyLTMxLTM5LTAwLTVF +LTMyLmNvbXB1dGUtMS5pbnRlcm5hbCIMZG5zTmFtZSIuZWMyLTE4NC03My04 +NC0xOTUuY29tcHV0ZS0xLmFtYXpvbmF3cy5jb20iEWFyY2hpdGVjdHVyZSIJ +aTM4NiIPbW9uaXRvcmluZ3sGIgpzdGF0ZSIMZW5hYmxlZCISaW5zdGFuY2VT +dGF0ZXsHIgluYW1lIgxydW5uaW5nIgljb2RlIgcxNiIMb3duZXJJZCIRMjkz +Nzg3NzQ5ODg0Igp4bWxucyItaHR0cDovL2VjMi5hbWF6b25hd3MuY29tL2Rv +Yy8yMDA5LTExLTMwLw== diff --git a/tests/ec2/support/ec2/stop_terminate_instances.af7d3d510feb715a04fd18e586088975e2ab5a9f b/tests/ec2/support/ec2/stop_terminate_instances.af7d3d510feb715a04fd18e586088975e2ab5a9f new file mode 100644 index 0000000..297fac7 --- /dev/null +++ b/tests/ec2/support/ec2/stop_terminate_instances.af7d3d510feb715a04fd18e586088975e2ab5a9f @@ -0,0 +1,6 @@ +BAh7CCIOcmVxdWVzdElkIikzMWY5Yzg5NC0zODI1LTQ1NGQtOWQ4Ny0wZTZh +N2MxZDI2ZmQiEWluc3RhbmNlc1NldHsGIglpdGVtWwZ7CCIRY3VycmVudFN0 +YXRlewciCW5hbWUiEnNodXR0aW5nLWRvd24iCWNvZGUiBzMyIg9pbnN0YW5j +ZUlkIg9pLWU3NDI2NjhjIhJwcmV2aW91c1N0YXRlewciCW5hbWUiDHJ1bm5p +bmciCWNvZGUiBzE2Igp4bWxucyItaHR0cDovL2VjMi5hbWF6b25hd3MuY29t +L2RvYy8yMDA5LTExLTMwLw== diff --git a/tests/ec2/support/ec2/terminate_instances.8db15ec3f117ce8070a0550fd99ac76ce508ade5 b/tests/ec2/support/ec2/terminate_instances.8db15ec3f117ce8070a0550fd99ac76ce508ade5 new file mode 100644 index 0000000..c1f1781 --- /dev/null +++ b/tests/ec2/support/ec2/terminate_instances.8db15ec3f117ce8070a0550fd99ac76ce508ade5 @@ -0,0 +1,6 @@ +BAh7CCIOcmVxdWVzdElkIik2ZmJlODRhOC1mY2RlLTQ1MzAtYjM2Yi02ODAy +N2ZmODg5ZTAiEWluc3RhbmNlc1NldHsGIglpdGVtWwZ7CCIRY3VycmVudFN0 +YXRlewciCW5hbWUiEnNodXR0aW5nLWRvd24iCWNvZGUiBzMyIg9pbnN0YW5j +ZUlkIg9pLWM3NDc2M2FjIhJwcmV2aW91c1N0YXRlewciCW5hbWUiDHJ1bm5p +bmciCWNvZGUiBzE2Igp4bWxucyItaHR0cDovL2VjMi5hbWF6b25hd3MuY29t +L2RvYy8yMDA5LTExLTMwLw==
--- tests/ec2/hardware_profiles.feature | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/tests/ec2/hardware_profiles.feature b/tests/ec2/hardware_profiles.feature index 616ee4b..59accb7 100644 --- a/tests/ec2/hardware_profiles.feature +++ b/tests/ec2/hardware_profiles.feature @@ -16,8 +16,8 @@ Feature: Accessing hardware profiles And client should get this hardware-profile And it should have a href attribute And it should have a fixed property 'cpu' - And it should have a range property 'memory' - And it should have a enum property 'storage' + And it should have a fixed property 'memory' + And it should have a fixed property 'storage' And this URI should be available in XML, HTML, JSON format
Scenario: Filtering images by architecture
deltacloud-devel@lists.fedorahosted.org