twilivery 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fce793f487a9f15b642f5688d66fc8c5115d989b
-  data.tar.gz: 8af0518d18c91568ad1b8e82c4c4d01bbcd035b8
+  metadata.gz: 146c2971744b6c2ed43a06588215311061f0f79e
+  data.tar.gz: 52482682de70e733ef23301438fe3f51b676e91b
 SHA512:
-  metadata.gz: 1c74e28ac5f2a0ee66d9b13add6c011ed9a900690bd80ffd63dd3c39ca3c6a8c475219c9b8aea7463fadc62f61bd0d33584ed69afeaadbfff97c53793718d2fe
-  data.tar.gz: b61d6ca0eea6bd37206510b0fa7481c2a2e30be13cedda912baec067c3d5f8686ee082f13b4ee53fac055b361b4f94167f73a14a5eccc23433a821861972177a
+  metadata.gz: 4a5edca806157742350d546a7b98907b5e13aec0ce93b9654e0afcb386e3b7ed51b58b8e2160811867bc28abbe1df9543472b57cca762c67a08e330d7dd68cdb
+  data.tar.gz: bbb990b55cb494926a038556b8b389ccf2c6cc0cc67b8eff5ae9f72a52024c4f3dcb1c1e687b64aacc3294c787e865087a339115035f7c3c6985a91fac81ae78

data/lib/twilivery.rb

@@ -16,6 +16,7 @@ module Twilivery
     attr_accessor :account_sid
     attr_accessor :auth_token
     attr_accessor :default_sms_sender
+    attr_accessor :default_country_code
 
     def initialize
       set_defaults
@@ -25,6 +26,7 @@ module Twilivery
       @account_sid = ENV.fetch('TWILIO_ACCOUNT_SID') { '' }
       @auth_token = ENV.fetch('TWILIO_AUTH_TOKEN') { nil }
       @default_sms_sender = ENV.fetch('TWILIO_SMS_SENDER') { nil }
+      @default_country_code = ENV.fetch('TWILIO_COUNTRY_CODE') { nil }
     end
   end
 end

data/lib/twilivery/delivery_method.rb

@@ -1,20 +1,21 @@
 module Twilivery
   class DeliveryMethod
     require 'twilio-ruby'
+    require 'phony_rails'
 
-    attr_accessor :settings, :data, :response, :headers
+    attr_accessor :settings, :message, :response, :headers
 
     def initialize(options = {})
       @settings = options
     end
 
     def deliver!(mail)
-      message = prepare_message_from mail
+      @message = prepare_message_from mail
 
-      if message[:to].empty?
+      if @message[:to].empty?
         raise Twilivery::DeliveryException, {}
       else
-        post_sms_message message
+        post_sms_message @message
       end
     end
 
@@ -60,12 +61,19 @@ module Twilivery
 
     def prepare_recipients recipients
       recipients = [recipients] unless recipients.is_a?(Array)
-      recipients
+      recipients.map { |r| convert_to_e164(r) }
     end
 
     def cleanse_encoding content
       ::JSON.parse({c: content}.to_json)["c"]
     end
 
+    def convert_to_e164 raw_phone
+      puts "Raw: #{raw_phone}"
+      PhonyRails.normalize_number(
+        raw_phone.gsub(/\D/, ''),
+        country_code: Twilivery.configuration.default_country_code || 'US')
+    end
+
   end
 end

data/lib/twilivery/version.rb

@@ -1,4 +1,4 @@
 module Twilivery
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end
 

data/spec/bcc_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Twilivery::DeliveryMethod do
+
+  before(:each) do
+    @delivery_method = Twilivery::DeliveryMethod.new
+  end
+
+  context "BCC" do
+    it "handles one recipient" do
+      test_email = Mailer.test_email(bcc: '+18131234567')
+      @delivery_method.deliver!(test_email)
+
+      expect(@delivery_method.message[:to]).to include('+18131234567')
+    end
+
+    it "handles multiple recipients" do
+      test_email = Mailer.test_email(bcc: ['+18131234567', '+18131234568'])
+      @delivery_method.deliver!(test_email)
+
+      expect(@delivery_method.message[:to]).to include('+18131234567')
+      expect(@delivery_method.message[:to]).to include('+18131234568')
+    end
+  end
+end

data/spec/cc_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Twilivery::DeliveryMethod do
+
+  before(:each) do
+    @delivery_method = Twilivery::DeliveryMethod.new
+  end
+
+  context "CC" do
+    it "handles one recipient" do
+      test_email = Mailer.test_email(cc: '+18131234567')
+      @delivery_method.deliver!(test_email)
+
+      expect(@delivery_method.message[:to]).to include('+18131234567')
+    end
+
+    it "handles multiple recipients" do
+      test_email = Mailer.test_email(cc: ['+18131234567', '+18131234568'])
+      @delivery_method.deliver!(test_email)
+
+      expect(@delivery_method.message[:to]).to include('+18131234567')
+      expect(@delivery_method.message[:to]).to include('+18131234568')
+    end
+  end
+end

data/spec/from_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Twilivery::DeliveryMethod do
+
+  before(:each) do
+    @delivery_method = Twilivery::DeliveryMethod.new
+  end
+
+  context "From" do
+    it "handles sender" do
+      test_email = Mailer.test_email(from: '+18131234567')
+      @delivery_method.deliver!(test_email)
+
+      expect(@delivery_method.message[:from]).to eq('+18131234567')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,86 @@
+require 'rails'
+require 'action_mailer'
+require 'twilivery'
+require 'support/fake_sms'
+
+RSpec.configure do |config|
+
+  config.before(:all) do
+    Twilivery.configure do |c|
+      c.account_sid = 'fake-account-id'
+      c.auth_token = 'not-a-real-token'
+      c.default_sms_sender = '+18131112222'
+    end
+  end
+
+  config.before(:each) do
+    stub_const('Twilio::REST::Client', FakeSMS)
+  end
+
+end
+
+#A default mailer to generate the mail object
+class Mailer < ActionMailer::Base
+  def test_email options = {}
+    data = {
+      from: "+18133580000",
+      to: options[:to] || "+18134780000",
+      subject: "Test Message",
+      text_part: "Testing, testing... 1, 2, 3"
+    }
+
+    if options.has_key?(:attachments)
+      options[:attachments].times do |i|
+        attachments["file_#{i}.txt"] = "This is file #{i}"
+      end
+
+      options.delete(:attachments)
+    end
+
+    if options.has_key?(:images)
+      options[:images].times do |i|
+        attachments["image_#{i}.png"] = encoded_image_contents
+      end
+
+      options.delete(:images)
+    end
+
+    if options.has_key?(:inline_attachments)
+      options[:inline_attachments].times do |i|
+        attachments.inline["image_#{i}.png"] = encoded_image_contents
+      end
+
+      options.delete(:inline_attachments)
+    end
+
+    if options.has_key?(:headers)
+      if options[:headers].class == Hash
+        headers options[:headers]
+      end
+
+      options.delete(:headers)
+    end
+
+    data.merge! options
+
+    if data.has_key?(:html_part)
+
+      mail(data) do |format|
+        format.text {render text: data[:text_part]}
+        format.html {render text: data[:html_part]}
+      end
+
+    else
+
+      mail(data) do |format|
+        format.text {render text: data[:text_part]}
+      end
+
+    end
+  end
+
+  def encoded_image_contents
+    encoded_contents = "/9j/4QAYRXhpZgAASUkqAAgAAAAAAAAAAAAAAP/sABFEdWNreQABAAQAAABQAAD/4QOBaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLwA8P3hwYWNrZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCI/PiA8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJBZG9iZSBYTVAgQ29yZSA1LjYtYzExMSA3OS4xNTgzMjUsIDIwMTUvMDkvMTAtMDE6MTA6MjAgICAgICAgICI+IDxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+IDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiIHhtbG5zOnhtcE1NPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvbW0vIiB4bWxuczpzdFJlZj0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL3NUeXBlL1Jlc291cmNlUmVmIyIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bXBNTTpPcmlnaW5hbERvY3VtZW50SUQ9InhtcC5kaWQ6ZmJmNmFkYzEtMTAyYS00Yzg4LTk4NTYtNDM1NWQ2NDRlYjI2IiB4bXBNTTpEb2N1bWVudElEPSJ4bXAuZGlkOjVCMjEwRTcwMTZCQTExRTY5MjY5RjYwODRGQzU3NjU2IiB4bXBNTTpJbnN0YW5jZUlEPSJ4bXAuaWlkOjVCMjEwRTZGMTZCQTExRTY5MjY5RjYwODRGQzU3NjU2IiB4bXA6Q3JlYXRvclRvb2w9IkFkb2JlIFBob3Rvc2hvcCBDQyAyMDE1IChNYWNpbnRvc2gpIj4gPHhtcE1NOkRlcml2ZWRGcm9tIHN0UmVmOmluc3RhbmNlSUQ9InhtcC5paWQ6ZmJmNmFkYzEtMTAyYS00Yzg4LTk4NTYtNDM1NWQ2NDRlYjI2IiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOmZiZjZhZGMxLTEwMmEtNGM4OC05ODU2LTQzNTVkNjQ0ZWIyNiIvPiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gPD94cGFja2V0IGVuZD0iciI/Pv/uAA5BZG9iZQBkwAAAAAH/2wCEAAICAgICAgICAgIDAgICAwQDAgIDBAUEBAQEBAUGBQUFBQUFBgYHBwgHBwYJCQoKCQkMDAwMDAwMDAwMDAwMDAwBAwMDBQQFCQYGCQ0LCQsNDw4ODg4PDwwMDAwMDw8MDAwMDAwPDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDP/AABEIAwAEAAMBEQACEQEDEQH/xAGiAAAABwEBAQEBAAAAAAAAAAAEBQMCBgEABwgJCgsBAAICAwEBAQEBAAAAAAAAAAEAAgMEBQYHCAkKCxAAAgEDAwIEAgYHAwQCBgJzAQIDEQQABSESMUFRBhNhInGBFDKRoQcVsUIjwVLR4TMWYvAkcoLxJUM0U5KismNzwjVEJ5OjszYXVGR0w9LiCCaDCQoYGYSURUaktFbTVSga8uPzxNTk9GV1hZWltcXV5fVmdoaWprbG1ub2N0dXZ3eHl6e3x9fn9zhIWGh4iJiouMjY6PgpOUlZaXmJmam5ydnp+So6SlpqeoqaqrrK2ur6EQACAgECAwUFBAUGBAgDA20BAAIRAwQhEjFBBVETYSIGcYGRMqGx8BTB0eEjQhVSYnLxMyQ0Q4IWklMlomOywgdz0jXiRIMXVJMICQoYGSY2RRonZHRVN/Kjs8MoKdPj84SUpLTE1OT0ZXWFlaW1xdXl9UZWZnaGlqa2xtbm9kdXZ3eHl6e3x9fn9zhIWGh4iJiouMjY6Pg5SVlpeYmZqbnJ2en5KjpKWmp6ipqqusra6vr/2gAMAwEAAhEDEQA/APz/AOKuxV2KuxV2KuxV2KuxV2KuxV2FXYq7FXYq7FW8VXYodgV2KuySHYq7FXYq7FW8KuxV2KuxV2KuwhV46YlW8Cuw2q7FDeKuxV2FXYq7FXYbVo42rWFLsVdihsYq3TArsUOxV2Kt4VdirsVdirsVdirsCtjClUwJXg4ErwcCV4ORUKoORZLwcFJbxS3ittE0xVbyxpDi2Gltrl740q0tjSreWNIXA4aW14OIii14yQijiX1GHhRa0nGltrEhbWHpkaZWpE40ttVOCk27l740q3ljS23y98aVvkcFK0Wwoa5YVXVxpbdyxVaWxVYThQs5Yq1U4qtJwKsJwqpk1xQ1ih2KuxV2KtYFdirRxS1hS7FXYq7FXYFdirWBXYq7FDq4Vt2KtYCrRxVbil2KuxV2KuwK7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7CrsVdirsVbxVumKG8Cuwq7GldhQ7FXYq7FW8KuxV2KuxVsDFXUwq1TFV46YFbxV1MKrsUN4q7FXYVdirsVdirsVW5JLsULsCuxQ7FW8VdirsKuwq7FXYq7FXYq7ArsVXDFK7Aq4dcCV+BLYNDilVByKVwbBSW64rbfLBS2tLYaVquGlaJxVquKLaLYq0DhpCouEBBKqMlTG2+WGlar74rbVcC23XCrRwUtqZGClBUzgplazBSbdjSuxpbbxpbdQ40i2wMlSLXUOPCtt0OCltYRjSbUzjS2twLa0nGlW4pWt4YoWYq7FDsVdirsVawK7FLRxVrCl2KuxV2KuwK7FWsCuxVxwoLWKHYq7AUtHFWsUtYq7FXYq7ArsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsKuxV2Kt4q2BihvArsVdhV2FDsVdirsVbwq7FXYquwIdhV2Kt4VaxVvAkNjriq6mFDsVbxV2Kuwq7FXYq7FXYq1TJK3gV2KHYq7FW8IV2FXYq7FXYq7FXYq7FXYq7FVwwJbwIbxZLwcCrsCVwOClXVxS6uBbbrim2i2FFreWKuJxVbirsVbGSCCrL2yQYFfhQ7FXYCrWKt4VdhpVp3wUi1hGRIZArKYKTbqYaW3YKW14GHhRbfHDSCW6ZKkW3gW3Y0trCMCbUmGNJtTOCk2sOBNrcCVpxVbgQ7FXYq7FXYq1gV2KuOKVuFLsVdirsVdirsVdirsCtHFBaxQ7FXYq7AlqmKrcUuxV2KuxV2BXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7CrsVdiq4YoLeBXYVdjSG6HCrqHFWsVdireFVwGKLXBCegxpFqghc9sNI4l31d/A4aRxKZjYdsFMrWUpil2KuxV2BIbxVvrhVdih2KuxV2FXYq7FXYq0cVbHTCrsUOxV2Kt4VdirsKuwK3TFW8UOxV1MVapil1MVdTFK6mBXYobxS3ilcDXAq6uBNuxVvFXYpaxQ7FWsFLbq4aV2KFwyQQVQZIMVTCh2KuxpXY0h2FLsUNVxW2jgUFTORZAtYquGGkWvGFFt4UNYUW3gKWq4ErCcCqZ3xSpnAyCw4EhbkSlZilrAh2KuxV2KuxVrArsVccUrcKXYq7FXYq7FXYq7FXYFaONILWKHYq7FXYCl2BWqYVW4pdirsVdgV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kuwq7FXYquGKFwFcaQqLHXCi1ZYsUWqiIYULjCMVtSaCnTFNqBjI7YptUSFmPTDTEyTGHTy1KjFgZJxDpyADkMHEw3R62MIH2Rg4kNtYoRsuESVATaeprtkwVtJ57ErUgYaZiaWPEymhGRpsBtSpiybwJdirYxVdih2KuxV2FXYq7FXYq7FXYVdih2Kt4VdhV2BV1MUOxV2KuxV2KuxV2KuxVvAl2KuxV2Kt4slwwIXYEuxV2KuxV2KtVwq6uKtYpbGKFwyQYlUGSDFcMULsUOwq7FXYpt2KHYaW1pwKCtORZNDFSuGFja7JUi3YVdgQ1gS7AqzEpWHAlTOJSCtyLJZgLJYcCWsCHYq7FXYq7FXYq7GlaOKVuKXYq7FXYq2BihUWMnoMaRastuxxpjxKotDhRxLTaEYrxKDQMO2KeJQKkYKZWtwK7FLdDirfHAruOKrSuKraYq1gS7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYVdirYGKF4FcUKyrhQrquKFUYqqDFBXDChdSv04oXrb8jWmK2j4rUDtjbFM40C02yJKopR0wIV16YFVMIQ20asMIKEBNbrvtlgKEkurVTXbJMgUgmi4EjItwKgBtiydilrAq7FDeKuwq7FXYq7FXYVdirsUOxVvCrsKuwKupih2KuxpXY0reFXYq7FXYq7BSW8aV2NK7FXYq2BgKVwGBW8NK7Al2BXYq44VW0xQ44pawquHTAhsYQheDkkL8kxXYobxV2FDsCXZJDsULTgKVh6ZEsrdiFK8YWLeEK7ChxNcUNYEtE4FC0nAyU8Vb4E4ptd6R74KW2jDkWVqLRHBTISUCCMU21gV2NK7ArsVdirsVaOKVuGldgS7FCoqV6YotGRW9euFiSjkgA7YsCVcKowIcSMUrKVxVa0YPbG1QskA7DFNoJ4SO2LIFS40wMrbpih2BWsVaIxSsIxSsIxVbgS7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7CrsVXgYoVlGFCuoxQqAdsCFQDCrYxVdihExJUjFimsMQ2yJKEwSIUyNqv4UxtC4VwoVFriquCMUKophQ28YIrhBQlVzCu+WAoY1ewjcgYS2xKSkUOBtdilbTAldhQ7FXYq7FXYq7FXYhXYUOxVvCrsKuwKupih2Kt4VdirsVdirsVp2Kt0OKuxS7FXYFbpirqYquwK7FXYq3il2BLsVccUFrFXYq0RirhireIVcDkkFUByTFeDhQ3ihrCh2BLskh2BVhOApWnAlwxUrwcKF2FDWFi7FWsCrcWTgK4FVkixRarxAwKFpGBksPXIlkFjYqh2UHAlQZKYsrU8CXYFdirsVdirRxStwq7AVXAYqjoU6YWBTOJOmLAokLtixUmGBKymKW8CtE0xSpk1xVDOCe2KUI6YpUaUxS1irVcCVuKtHFKw4qtOKWsCuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2FW8VVFxYq64oV1xQuHXCqoO2BV1MKGwKnFUfAvTAWKcQjpkCqOUbDIq3TCgrlAxQqUGFC6mFCoqnFCoehwhCW3HQ5ZFDHrtag5NnFj0goxwN4WYEuxV2KuxV2KuxV2FXYodirsVdireSVumBW8UOxVvCrsVdirdMCuphRa7Al2NK3hpWsFK7Glbwq7GldTAlvFWsCuxVvFLeKXYq0cCHYq1irsVdirsVbwoXA5JC8HChdXCimia4opsYpbxQVpOKrCcCWsCXYVbBxRS6uEMS3XJIdXFDROBLQFcUohIz1pgQrUI7Yoto4CkLDkWSmRgSpsDgZKeKtEVxShnFDikKeApdgV2KuxV2KtYq6mKrh1GKphD2wsCmkRxYFFDFCxlGBVFlGBIUyO2KVtMUuC4qsZRiqEkAwpQbDAyCngS1TFWiMVaxSsOKrTiq3Al2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kuwq2OuKqq4sVdcKFYdMCFQYVXYFXYULl64oTGDtgKE4h7ZWVRoOwwKuxQ4HCheMKFwNMKFQSAY0hr1a5IBCDnatcsiqRXRFDkmUWOzGrHA3BQxZOwK7CrsAV2FXYodirsVdirsVbwq2MVbxQ7FXYhW8KuxVsDFC7BSWsKG8Ut4q7FXYq7FXYq7FW8UuxVwwKvoMUtUwK1TFXYpaxV2KHYpaxQ7FXYodireKt1w2tLg2G0U3yxtFOrhtadywWtLa1xtNNY2h2KtVxWnVxWmwcK03XDbGmxvhQvC1wKrxoK4oRqgAYsW6DFVJ1wJCgwyLMKZwMlM4ErDvirqYqoSDFIQ+Bk1irsVdgV2KuxV2Ktr1GKphCRthYlMozi1lFdsUNHAqmQTilrhgSt44q6mBVNxhSg5BilBON8WQUsUuwKtxVbilacVWHFVuBLsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdhVsdcVVVxYq64UKw6YELwcKrxgVdhQ2DviqYQHpgLFOIjsMgVRgOwyKu5YUNhgMNIVOYw0hcDXChulRhQ0aAYUICeUAHLAtJBdTCh3wlsiEkY1JOBsCzFLsVdirsVbpiq6mKLbpitupittUwrbVMUupireKHYq7FW8KuxV1MVX4EOwq7FW8UuxV2KuxV2KtgVxVdQYq7ArdMUuwK7FXYq7FLqYq0RirWKXYq1irsVdirqYop1MVp2KtYodireFXYFdirWG1p2FDsVawWrsbVcN8KCrKNsLFUFMUKqYqiwajFgV1cVWMciyAUGFemBkospwMlMjCqnTAlumKqbjbFQgz1xZBrAl2KuwK7FXYq7FXYqjYThYlM4jiwKMXcYsXUwK3gS0cVUzilYT1xVTbFKGkxVAyYsgo0xZNYq0cCrMUtHpiqzFVmBLsVdirsVdirsVdirsVdirsVdirsVdirsVdirsKuxVvFV64sVdTihXU4UL8VXjFC6mKt0xVGQtTEoTOOTpvkaQjkeoyNIX1xQuArTCqsqjChVG2KGiRhCELM9Ad8mFSS5mpXfJMgEimk5HFsCH64pDWKW6Yq6mKtgYotcBii11MCt0xVuntirVMVWlcNpWnFWsKuxV2Kt4VbAxVdgVvCrsVdirsVdirdMKLbpgV1MKtjAobxS7FW8CXYq3il2BLsVaxV2KGsUOxV1MUtUxW3UxW3UxW2qYq7FLWKGsUOxV2KXYq6uKra4op1cVprFXYqqrjaCq1w2xpuuK0qI1DgtNIpW2w2xIXk4opYTilbXAq1htilDnAlbTFLfbFCk42xSEG2BksxS7FXY0rsCuxV2KuxVVjehwqUxikxYEJjG1RiwIVtsCGq4paJwKsJxVTJxSpMcUoVzilBucUhZgStOKVpxVZilacVWHFVuBLsVdirsVdirsVdirsVdirsVdirsVdirsVdirsKuxV2Kr8UKqnFCupwoVcULgcVXA4oXVGKr1fieuKoyOb3xY0j45um+CkItXrgpCsr4aQqiTGkLxJjSFN5gAckAqVXF0BXfJhkAkM85YnfFmAgia4pcMUupilvAhsDCq6mKF4GBW6YVXYEOxVqmKtUxSsK4UreOFXUxQ3TFLVMKtjAhvFLeFXYq7FXYq2BhQuwK7FXYpbxV2Kt4pbpgVsDFLdMCtUxW2sUuxV2KtYop2KW8VaxV2KHUxWnUxWmqYq1TArWFWsUtYENHFWsKXUOKHUxtW6DArqDFCsq4UFvFDsUtg4FRCN2xQVU1phYrNziq4DFWjXFVJ8WSmcCtb4pU5DioQhBJ6YGS3icUtUxVrFXYq7ArsVdirhtiqJjkpighMI5cLAhGLJUYsaX8q4FbxVo4EqbUGFUK7YpQcj4GQQxbFlTVcCuOFVpwKsxSsOKrDirWBLsVdirsVdirsVdirsVdirsVdirsVdirsVdirsKuxV2Kr8CGwaYVVVbFCsrjCilTkMUN8h44rTuYxWlhfFaXpMR3wrSPjuAKb4sSEdHcr44KY0iVuU8caRS/wCtRjvivCovfoK0OEBeFL5r/lWhyTLhSySZnJ3xTSjucKrhGTii13pnwxTa0oR2xW2qYpXquKFUIcCF3A4q7icVdTFLWBWsKG6Yq0RhVTwsmsVbwq6mKupirsVdirsVdTCq4DFDeBW8UuxV2KtgYULqYEupgVvFLsCuxV2KuxS6mKtUxW3UxW26DFWqYq3TFXUwK1TG0upjatYVdiq0jAhbhS0cCtYocBirdMKtYFdirh1xQrr0woK4iuKFhFMVdiq5WpgSiVauFiVQAnoMUK6QlsUEokWg74o4lKS0GKiSCe3I6DFkCpei/hgTa4WjN1xXiX/U1HXFHEovbL2xZAoR4CMWVodkI7YEqZFMUtYFdirsVdirgaYqiI5aYoIR0cwxYkIpZAcWNKgbFDiwxVRd8UoKR8WQCCdq4GVLAcUrq4q6uKrScVWnAlTOKrMUuwK7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7CrsVdiq/Ah2KuySG6nFVwY4qv5HFXV8cVbxQ7FV4YjCqoJGHfFC71m8cKtGVj3xQsLE98Va3OFVRUwotWVAMUKoAxQuxVvgD2xVaYAe2FbXCLj2yK2vC+2Kt0GKuKjFVNkxVSI8cUtUxVvFWiMVUiMkl1MVdirsVdhV2KtUxW3UxW28VdireKrqHFLuJxVumFDeBW8UuxVvFLsCtYFdirsVbxS7FadTFV1DgS4KcUKgiZui4ra76u4/ZOK2sMbDqDilaVxVaQcCrSMKrcKrSMCrSMVcBihdirWKC1TCrqYq1TAqopxVUwsXHpiqnU1xSuAwIRMSEnFbTWKNaCowtZRIUDpihfXFFLD8RxSvW3DdRgRao1sijYYraDdCvbFKHYYsgosuBKkUrim0PJCKYptASRUwsgUKRTAydgV2KuxV2KuxVcHIxVVWdh3xWlcXRxRwrvrRwI4VNp64ppDs9cU0pYq7FLVcVp1cVa5YFWk4qtxS1gKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2FXYq7FV+BDsVdhCuwobxVdireKrhhUt4EOwq3XFC7CrsVbxQqKuFBVwKYoXYVXDFC8DFVdVxQqgDFC4qMCqDCmKWsUuxV2KrGXFVEimKVuKt4VU2xSswq7FXYVbxV1MUOpirqHFW6HClcEwJVAmKaXgAYE06mK01xBwopaVxtDVMKuwFLsVdirYHjgVugwJdTFW6Yq3TArgMUouG1klICqTgtBLIbLy/NMRyWgyEsgDWZMrtfLUSAFxlMs7GyUc+gWpGyjI+MVSu48txkHgMmMy2WMXuhSw1IXbLozBZCbHpbZ4yQQRTJNgNoYriyUyMULSMKrcVbphVrFDWKHYFaxV2KHYqqA4quxQ1TFKtGlcUFMYosLAlFAEdMWNrq0wK2WxSujqTiqYINsDErmxQhZV64pS6RTXFkEOR44srUycVapXFKGljFMU2lsqUOFkCh8iydirsVdirsVaril2BDeFXVOKuxVrArsVaOKVuBLsKFpwK1ilrFXYCrsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdhV2KuxVfgQ7FXYQrsKG8VXYobxS2MKrsCHYVbwq7FWxhQvXFCIUYoVMUNjCq8YFVkGFCuMULh1xQqAVwKpsuKqJGKVuFXYq4jFVJxgZKWFXYqVh74UrKUwq7FWwMVXUxV2KuxQ3Q4Ur1XAoVgAMDJ1MUupirqYrbqYq6mKFpXCtLKYodTFWxgS3jSuwJbxS7FWwK4qmtjYtcOABtkCaYk09C0zSI41BZd8x55Gq7ZPHCsYooAzHMrWlUtxG+BLlIbbEqvKYLVDS2scqkMAckJELTFNT0RCGZVzIhltRswK9sWgY1GXg22xNpSy02yTJYRihYRhQ7FXYqsIphQ1gS1ih2KHYq2DiqqMVd3xVGwjpixKYoaDC1lV64q6mKrDkUomMYUFGLWmBiqUxVTdRQ4pQEqjFKBcYsgoFTilsDbFVKQbYpS2ZcWQQJ64s2sCuxV2KuxVacCXDFV2IQ7CrWBXYq7FWjikLcCXHCgrTgULcUuxV2Aq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYVdirsVX4EOxV2EK7Ch2Kr8VbxVvCrYxQ3gVvCrsKtjFBVFGFCJXpihdihsYqqDriquuKFUVwobGKqoOKFrb4FCkQcUrOJwqtxVcOmKqbCuKVEqa4pWnFVmFLsVdhpXYq3hQ3xxVsDFVwFcUqwWmRZN0xV1MVtumKGqYpt1MVtumKWiMVUiKYWJaxV2Kt4GTeKXYFcBXFUbawerIq065ElBL0nSNMVFU03OY2SbUd2UpFwpmMTaohVORVzID1xtLaKFOJKq9KjIqplRhtUPMqspByQKsE1izrzoMy4SUGmAzxlGIOXtwQpGKqZFMKFuFDsVaOKFhwq1TArdMKGqYFdQ4quBIxSvDVOKo6EjbFgUwSlMLAriwHemKFhevTAlyk1xSjoqbVwMSjgVAxQ7c9MVWN3xVByDFIQbLiyUyMVU8UqbjbFUunHXCyCWsN8DYFuBLsUOxV2KrTgS0MVXYodirsVdirsUrTirWBLjigrTioW4pdirsBV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kuwq7FXYqvwIdirsIV2FDsVXjFW8Vbwq2MVbwIdhVvCrYxQVVcKEQp2xQuxQuAxVUUYqiFxYqgwq3iqoq4oK8qMULCBilbTFWvTritu9OmGkWtZRilQYDFKkV8MLJSK4qtocVbphVumKt0xVvFXYVVEGApVcCWsFK3hV2KuxVvAlaRhQ2MCVJxhClZhQ7FW8CW8CXYpXLgKGQaRGGlUkZXNjJ6hY0Cj2GYc2CZMw8cqVejA9cBCUSApGRStoMVboabYqsNe+KoCYkHbLIhCQ6kKrUjL4Iec6goEhoMyQ2xSkjCzUmGFiVPCh2KuxQVtMK26gxRbsUOwJbpirqYq1ilFRNixKYI+2FgQ4gnFVwU4qvG2BUTGTgQjUFcWKsNsUWtYVrilCyDFKCfrilRbFKnila3TFUvm74WQStuuBsCzAkuxQ7FWsBVo4pawpXYEOxQ1XFLq4q1XFXYpawK44oWnFVuKXYq7AVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsKuxV2Kr8CHYq7JIdirsVXDFV2Kt4hXYVXYEN4VdhVwxVVXFirjphQuGFVVemKFRcVVl6YoVBihUVcUK4FMULScVU61xSuAwqu6Yq3XbFCi+FIQrYGQW4VaIBwqsK0xSp4oXY0l1MKt0xVumKqqjAUhfTAtupituphW2+OKu44EuIpim1uKHYqtfCFUcVdireKW8FJDsVVFG+RVleiR1YHKZljJ6PaR0SuYkywRgXemQVELHUZElVb0myNsmxEe+C1U5nMS18MIFqlv1xnfjxyzgVEFQ4rgQkepxfuzl2Mq831JCHOZUWcUkOSZqbd8KqBwsXA4odTCgleEJxprlNVEWFqOV3o4o8RaYyMFMxkW8aY0zE1pwMgVuLK16GmKo2JsWJRi0wsFSgwIa74UqqGmBUdG/TFiUTXbAhaSMUoWRhilAuanClSOKVPAlSc7YVCWTv1xZgJeeuBsDWBWsVLsUOxVacCWsKW/DAhvFVuFLsVdgKtYFdirsVWnFAW4pdirsBV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kuwq7FXYqvwIdirsIV2FDsVXDriq7FXYq3hVsHFW8UN4VdiFXqcKFdTihUxQqr0woXjriqqpxQrpihEDChxbFVInFW1GKlWpTFCw4q0ThVTbpilDkYpW4Ut4ENEYUqJG+KXUxVdTChcBirdMVVFGBIX8cUu44q3TFbdQ4q1ilxxVYRihrFK1umKFIjCrqYpbocCWwMCVwQnBbIBWSM13yJLIQZfoq0pTKZsJRegWrHgMxJc2shHLvkCxpEptkClX5HtgpLRY4EoeVS43yQQhPQC703ydoVNwMVSjUWHptl0Fea6qw5GmZUWcWPnJM1I4VUiMLFwUnDTVKdK6R4XHlNErH7YtRkrCI4sDJv0jivGtMR8MU8Si8WLOM0K0ZHbA3RmpFSMWwSdgpkJK8bUxZI1HxYkKwauFFLsCHVIxSrxyUxQQjFlxYtPJiqDkcnFkoE4paOKrDiqDmegOLIBKJH5E4GwBQxZOwFXYq1ih2KrTgS1hS7FV3bAhbhS7FXYCrWBXYq7FVpxQFuKXYq7AVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsKuxV2Kr8CHYq7CrsKHYquHXFV2KuxVvCrhiq7FDeFXYhWxhQqKcUK4OKFdemKF4woXg4qrqcUK/LbChYWxVbiqsmKleThQsJxVTJ8MUrcVU2GFKmeuKWxireKFMjFLQGKrqYVXAYq3iheuKQq0wJbpihumKVtMKtYq1TFNtYqtIrgStK4UFZww0hvhjShcIycgWwC0QkHjlZk3RxqwjAyBLaIgLwowWmk90uQI4FcrkWEo29Bs3UqN8x5NBCZLtvkCwpVDjI0xIVQ+ClcWBOCltxNBhCFBia9MmFUWbrUYaVjWqzqFYeGX4wrza+l9SQ0zKAbAlxFcNJa44qs4iuSDVOVIiOKvbJOHOaNWEYtBmrCMDoMDAyVFjPhgtiZKgi9sFseJoxe2NqJKLQnww2zE0M8PtjbZGaCeE+GFvjNDlCMabRJobZEhtBVkamLJFI4OK0rA4sXE4q0GocUqnrgdTiilpuAe+BPCt9QHvitLeWFWi2K0oSTAVxSAlk0ta4GYCCJxZhbirsBV2KXYoawLS04q1hS7FWxgQ1hS7FXYCrWBXYq7FVpxQtxS7FXYlXYFdirsVdirsVdirsVdirsVdirsVdirsVdirsVdhV2KuxVfgQ7FXZJDsVdirY64pX4odireFXDFV2KG8KuxCuwquGKCqK1MUK6viilUOMKKXBxitLxJitKgfCil4auKF4IxVVU4obJwoWk4qtpirqYpWkYqpEYUuxV2FWjikLRgQFwGFK7ChsCuKrwMVVQK0wJXhcCaXcfbFNNcPbFFNFcKqZGKraYq3xw0traYaRbqe2FVVI65EllEIlYwO2VFyIil5XKyG0FbxyLK3AYEomFyjAg0yKCyrT79vhUnK5Ra5BlsE/MDfKSGohFFttsFNa+Nm74CxKvkVp1a4rS0kYVpBXMyojHpk4hDz/WLuvIA9czIRSAwpyWYnLmxaMUNNigltFqcmA4mWSYRJi4UiilTA1kohIxkSWsyVwgwNdt8RgW13DFFqbR1xZCSHeL2wgtgkgZUpkg3Rkg3jrhbhJCslMW6M1nTAQ3xlbgxGRbAqCYjFNL/AFxitLTcYrwod5ie+KaUfVPjhSuE5HfAtKguTijhWtcmmK8KEeUt3xZAKJOKVpxULcVdgKuxS7FXYFWtiFW4VdirsUOxS7FWsirsVdirsVWtiFW4q7FXYlXYFdirsVdirsVdirsVdirsVdirsVdirsVdirsVdhV2KuxVfgQ7FXZJDsVdirYwpX4EOxVvCrsVXYobwq7EK7Cq7FDeKF46DFVQHCq4HFVVcLFUxQvBOFV4wIVlOFCpihqm+Kt4q7FWjilSYYUrcKuwq0cCrQMUrsKF4GKFwFcUqoXAqoBiyVVWuNJtXCDBSLVBHXoMNK00HtiqFeEjChRK0w0i1pGFFtYquVa4CyARKrlZLfEKmRbg3TAUuIyBZBbTtkCyX0wLSIhlaMgg9MBCkMls9UC0DHKzBqlFkUF/G4HxDKzFpMUzjlUioOQIQYKvrCmRpacGwrTUk0cYJY4gWvCxXVNSShVTl8Ip4GAXkzSscyop4aS0jLGJW4oWnEMJFExLUjJuvyy3TJFyJcWRRCjA1kokDbItZXAYELgMCLXYodSuK2pOu2FlEpfKmTDkQKBdcLcChXGFtiUMRgbYmllMBDfGS0jA3BaemKVmBVhwqsOKWsCtE4qtxVbQ4pb4HFVhXFVhBxVrAVdil2KuwKtbFVuFXYq7FXYq7FWsirsVdirsVWtiFW4q7FXYlXYFdirsVdirsVdirsVdirsVdirsVdirsVdirsVdhV2KuxVfgQ7FXZJDsVdirYwpX4FdihvCrhiq7FDeFXYhWxhQuxQ7FK8dMKF4xVeMVXr1woVhixXjCoXjFCqvbFVXFi7CrsVdiq04pWnFVpGFVpFMKuxS7FWwMULwMVVlXFICqFriyRCRE9sNMbRaWzt0GKLR8ViaVbI2m0YlsgHTAttmFOlMKLQ0lmrCowgraUz2jLXbbJhil7oVxSspgSqIN8iWcUQBlZb4r6ZFtDqUxS7IlkHAZAsgF/HbIswHUOKaVEDVGArwWjo5ZI6UJyPNJwppDqkqAVORMWJxItdZPfI8DHwVQ63tscfDXwksudUkkBAPXJiFL4YSCeR5CanLQxMKS9xvvkgwIUHXJhpkFA7ZJg0OowhrnyRsPbJOtyJgmRcYohMi1lXwMF6jAgqlMWLVMC2vAxQpuMLIIGVeuSDdEpe4yTkRKFdcLbEoVhi2gqZGBtgVNsi5MVuLJaVwK1xxVYRiq0jFLXEnFW+GKu4jFXYqtpXFVhTFbUmU4EqeKuxS7FVrYqtxV2KuxV2KuxVrIq7FXYq7FVpxVrFWsVdgKuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2FXYq7FV+BDsVdkkOxV2KtjFK/FXYobwq7FV2KG8KtjFDeKt4VbGKr8IQvGKrhipXYUKwxQqqMKF+KF4xVVGLEt4UOxVxxStwpdiq2mFVM4q7FK4DCq8DFCoBiqJSMnGmVoyOEYUJtb2vIgkbYCWKbJbgUouQJSi1t6jcZHiVxtq9MeJaQzWzKemG1W+kRhtCnJCGFCMIKCkl3Z0qQMsBRaSslDTFkF8YyEm2KIXKy3RbpgbA3TIlkG+ORLYA2FyJbQFZUOQJbIwtUEOQMm0YlZYciZNoxLzGaYAWXhrSmTtBxrChw21GC0qQMNsOFTIwsTFRahyQayEMyVyQLXKKhIm2SDRKKDZe2TaSHKlTha5R2Rca0w267NCkcnTGnDkiUyJDWVcYGBVQMDAqgGBi1TAlsDFDTDCkIGUZIN8UvcZJvCGcbYWwFBuMW4KJwNsVMjIlyoNAYs2jiq04FCmcVaArilVApihxFcKqRwJawK7FVpGFCwiuKVFlwJU8UuxVacVDWBLWKC7CrsVdgVrArsVdirsVaOBK3ChrFXYCrsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdhV2KuxVfgQ7FXZJDsVdildildih2KG8KuGKr8UOwq2MUFdilvCrYHfFC8YUL8VXDFC4DCqoMUFUU4oVQcKFwwIXA0wqv5DCh3IYqtLYq2MKuJpilYWxVbhSuCk9sU0rLGT2wWnhKsIT4Y8TIYyiY7ZjvTDxBfDKMWBh0XDxBfDKY2lo8jj4ciZBiYFlltpzkKAmUmaOFPYNEdqVFMrORPCjzoYA675HxE8KFl0h4xVRXJiaDFLZLRhUMuTtigXtjXpkrYod4SOoyQKCgpoAykUyYLEsVvLco52yaQUIi5CTdEqwGQIbYldTItwbArkS2RVFQnIkt0Y2qcaUyslyIxRCgZWXIjFUAyJbYhFKmVSLkQgq+lXIcdNwxW70Bh8RBwLTAMIm0ywId4PbLYzceWKkK8RGWCTjyghXWmTBaTFSphYEKTpXJAtUooR48mC0GKxVphapBEIMk4eWFopBkrdbkgQrrgLjlELkWBVlyLAqu2AsFpwJbBxVa52xTEJfK3XJhyIhBN3yTaFCTauFsignxbooc4G2K05EuVBbWmBsWnFKw4oC04pcNsVVBvihsimKqZGKVpGBVuKtDFK0jFCmw2xVDnFLsUrTioawJdirWFDsVdkVaxV2KuxV2KtHAkLcKGsVdiVdgV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2FXYq3iq7Ah2FXYUOxVvFIbGKrsUOxCt4VXDFDeFXDFWx1xUr8QrsKr8WK5cUrsKF+KF4GKrhhQuxQvBxVcDhQ3XFDdTirYrhRYXb+GK2Gt8LJ25xVsKTjaQFdIScBkzjG0WkI8MgZNwgjI4K0oMgZNsYWj4rStKjKjkciOFNY7VFAqMichbRiCOgtElYKF64OMpOOLLtO0VFo7rkTlLjTgGSR28UVKLvkeIlxzBFAEYbayF/XChckTPtxrjaoj9CCcVK0rkhNjw2onyzGNzkvERwIC58sqVJTrhGVBgxK80SeAn4CRl0cltRiw/UrBt6rTL4Sazsx425U9MmQzjNaYyO2QIbhJoLXIEN0ZWvCZWXKgFQCmVlyYim+uQLfAWrKMqJcqMUXGlcrlJyMeO0ckYA3zGlNzoYqXU9sDbwt0xBRTfGoyQLGUFpjByQk48saHeEeGWRk408KVzwkE0y+EnByY6QZWmW20GKwjCGBCHdRkwXGkFIpkrajFeu2NtM4q4NcILg5cdrgaZO3XThSJRsBceQRIOBrK6uRRTsCurTFKhI+2EM4hASNXJBviEOxwswhZGwtsQhnxbQoHA3QDRyLkxC04s1mKVhwK1iq4DFC+m2KtEYqtOKrDgS0R3xULcVaPTFKw9MVQzdcVW4paOKhbgS7FWsKHYq7ArWBXYq7FXYq0cCVuFDWKuxKuwK7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYVdirsVbGKF2BXYVdhQ7FW8UhsYquxQ3iFdhVcMUN4VbxS2MVXYhDYGKF2FC8CmKrhhVUAxQuGKrsKGxhQvAxQuAxQSqLGzdBXFrlkATO302WX9nbIGYDh5NWIpvFoo6vkDlcOeuPRe+kJ2xGREdaQgJtLZKkDJDI5+HWRlzS5rZlO4yfE58ZCXJpY8bbhFFImQtvEaRsUVcrlJtjG0ziiA7ZTKTlwhSORaZBtRaKWIGSQy3SrEACRhlci1TkyyJPhHtkWklVA3+WFgXAM5oMlbWQmltYu9CemG2ohO4baOOm1SMbRSLHttjaVxAK4UIVkNcCELLbxS/C6g4QaQRbEdY8uxyozxLl8MlNM8byfUtPktpGVlpQ5mwnbjmNJMUHQjJsgVghqdhkJBvxyb9Jh1GUyDsMRtayUykuZFao6ZVJy8YRKLlMi5uOKMjAGY8i52OKKHTKS5MYrqVwsjFcFx4l8NUCjBamC0imTDTKKiwrlgLRKCEkjByyMnEyY0smjocvjJwMkKQbDLQ40gokZIOPIKZGFgQsoa5K2mUVVcbcecF3XJAuFkxKqA4bcOWFXDUGLjSx0uEgxprMV/MY0iljSYKSIoV3w02xihWbC2gKDvizAQrHFtAUW3wtkQpHIlyIRawOQAtOKVmBVh64q1iq9cVVMShbXbFVpxSsIxVqmBVmFWsCrTilDuMVU8UtHFVuBLsVdirWFDsCtYFdirsVdirRwJC3ChrFXYlXYFdirsVdirsVdirsVdirsVdirsVdirsVdirsKuxV2KrhihvArsKuwodireBkuGFDeKG8QrsKrhihdil2EKuxQuGKF2FVwGKrsKF4xQvGKr6YoXAYULwuKF4XFBRUFu0rAU64k04uXLwsptNPjRQWFT4ZjymS6nNqCSm6KqCirlZ3cORJVDWmLEKO4ws3MRTfvhSEHLaRyAkDfJCTl4dVKBSuSzKEmm2Hiei0uojkCmke+JLsBG0xhT2ymRcvHFMFXKTJyAESkZJ6YONlwWmtnal5FqO+JyIOIs/t4OEKgDtlfE48oIuMEbZLia5QV1WuStpITOytQ7A02wtZZEkaotBkmst0pvhYuxVsDFWnXbphQUIVJO+BDTJUUO4xQwbzPpCyxNIib5kYp01ZIPKJLEq5qOhzN43HpWitl8MgZN0EUbRCu4yolzsRpK7i0p9nIFzYFLzGymlMqkHPxFWTMeTsMaJXbMeTnQVVNcgQ5EVZcgW0BfXFNNlsQxKwmuTDRILSMlbWQpMMkC40wgpo+WXxk4OWCBaEk0plvHThyha9bJm7ZWdQAwGnJRC6YW7ZRLWgN0dCSq/oYnemVHtEM/5PaOk0xHaIaZ9nIZ9OZegzKx6wFwMuhIQrRNH1GZUcoLgZNNSi5y0ScHLhUeVMsBcGWGm/UoMLUcamZa4qIqLPizEUO0mLYIodmri2CKmTizEVhwW3RioscBcmIaBwM2jiq09MVWYpaxQ2pxVVGKHHpiq3FKngVo4qswq1gVadsUodu+KqeKXYqtOBLWKuxV2KtYENYq7FXYq7FWjgSFuFDWKuwFXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYQrsVbxVdgQ7FXYQrsKHYpbwJXDCgt4obwhXYqvA2xWm8VdhCrsULxiVXYUL8UNgYVVAMCF4GFV4xYqgGFVwGKERDGZHC+OPJoyz4Qyq2sxFEGpvmPKVl0uTNxSR8IbvkS48yEVyoaZGmulUUpgYIdt2yQbAt4EnDabVVSmC2JKq0AkQim+RJcrSZpQklLW3ByKYDN7fSnjiCjIYRtmPPI7THjTBIRttmNLK5UcSLjjAORE2ZhSeadHWRdsmC05NgzFNkyYcE81yMC1MkEEI6NQaDJguPKLIbKLiladcmHHkjSMkwK4DbCxdihsYVXsARiqFagwIUsCELeQCeFkIrthiaUh5VqmnGGVyF75lwm4sopKECnpkyUxRACsMrLmwKFmg2qMDlQklkkI3qMiXNwyQDJxbbKJh2uE2uGY8g58FRdsrLlRVlOQIbQqZFLqYhiXUyTVJacIaitK1yQNNEw2IKjfIHLTRLHa0QCvTAcrWMG6Mit69swsuob44gEYsarmDLIS2iNLicglTYA5IFiQhZE9syMeWnHniBQMsCsDUZn49QQ67NpQk1xbFakZssWe3U59LSUuGUmuZsZW62eFRY5MFx5YLUSTXrh4mH5dYTjxMhgUWwcTIYVM4bZDGsJxtkIKTHBbYIqOLN2Kt4pLWKFuKVpxVaDTFVUGuKF1cVaxVTxVo4ErcKtYEKbHFKHOKQswK7CrWRVo4UtYq7FWjgQWsVdirsVdirRwJC3CrWKHYlXYFdirsVdirsVdirsVdirsVdirsVdirsVdirsIV2Kt4quwIdirsIV2FDeBk7FVwwobxQ3iFdhVeMVbxVsYVXYoX4quGFBXYoXjtiq/CheMUKgGKFQYULwMWJTXTY+co2yGQ0HX6uVBl1NgMxg6a1wNNsUFVWhNcWJWk7nFLQ64VVKVGBip8jypTJMwLTKEVA98pk344G1C5hHKtMoMntOyzcQGoo6Zjzm9LjgjlXbMUybwFYCmEFSnumU5jMiJcXMNmUVPTLQ4JC9AAa5IMCmVv8TDJBpkyqBQIx8stDiy5qmFgVwyTEt8K4oapTFXdsVQ564EKLkDArYAIPviFYjqsCmRgR1ycTTVIMKvbPgSy9MvjK2NUlq7bZIuRjKo1KZEuTAoKZVIO2Qc3EUseHrkJB2WGaGK8TTMaQdpjNrhlRcqJVBkGwFUB2yJDK2640gl2GmmRawtZVkUdcpnJgQrccoMkCK9I65j5crLhRQWgzDJtFLWBOEIWcThtgVJlau2SBCKbCMR0wWtKEkDeGWwyU1ShaDktWYGozLhqKcLLgtIruzZammbTT6kF1ebT0kcilagjNgJW4UoUhjU5JhwN8ScFshjWMhw2g4lFlIw2wMKUGw2w4VE4VprFXUxV2KtYocRilYe+KrKYq2DTFVQHFWq4q0cVWnAq3Cq07YFUGNcUrDiqzEpdgRTWKrTirWKXYq0cUFrArsVdirsVaOBIW4VaxQ7Eq7ArsVdirsVdirsVdirsVdirsVdirsVdirsVdhCuxV2Kr8CHYq7CFdhVvAl2KrhhQ3ihvCrsVXjAreFVwwoLYxSqYoXDChsb4qqDFC/ChUUYoVAMUKgGKF+EMSyDSVAqxynK6jWlkAJJyqnXELqMTsMULwrA74liS09a0GISFRU6HBbElUdgoriGIFqasrb5KmdUmMG9KZRN2GnkCr3CfCDTMWReq7L2KFQZjTerhyRI6ZQ2KgwhCaWEnGRd8uiWvINmXoeQXMgOukKRNAFyQaSibV/jGSDVNl0Lfu175aHElzVKjJMCvUiuSYlVwoaIriqi5oMCqI33wIU2UNgVsCgxVi2rfb2whhJjk6eohBGWA0xYtMhjkIy7mzgaWMcDkxKHJqTkS5mOTTIKVyEnNxTSudaNmPIO3wyUhlJDmRkqCmRZiS4HI0zEm64aQZN1wtRLl3OCTAlFqNsxJlCsq1pmNOdMwjY4tswJzsqq+nkOJFNGLDxIpr0/bHiRTYgr2x41pVEKr2yPEtKUqgDpkolaQL06AZaGqYS+4jBBqMysOQguBlhbHrmzVmNBm6xZ9nAnprOyWSWTJvTMqOYFpOlIQ5jYdss4keEVnpse2HiXwitaAkdMHGg6clBy27DtkxJonpyEEyFeoyYLjSgQsphthTfHG1poqcbRTXE+GNrS7hgtNNFMbWlMrhtaUiKYUNcqdMVbDYFpdXFaW4rS0mmNrSkTXFaU8UtYFWEYVawK7Eq1TAhqmFVuKXYq1gQ1irsVdirsCrcKVuKHYlXYFdirsVdirsVdirsVdirsVdirsVdirsVdirsIV2KtjFV2BDsVdhCt4VdgS7FVwwobxQ3hV2Kr8VbxVcMKFwxSvxCFwwoXriq8CuFCqqk9sVRkVtI/RcFopHppkpH2cHEtLjp0wP2Th4kEKiaZMx+ycNsCyfS9JnpTid8pySDptXAkspt9FYUMm2UGYccacnmmqaTAANt8gchZHAFsukRkfD1xE2qWn7kmutNeLfjUZMStoljlFLSrKaHtkmBWOOQphCxNKapTDbIlMrVhWmU5A5WlO6Onp6eYcnruzTugVIzHmHrMZ2RA6ZRTauGSCCrxOUYHJhiWW2E4kAqemXxLg5Y0m5NfllocQr4nCsKZNrkyqzl5RjJhxZhG1yYaiujJrhDFEHChaWoN8KqDmuBCn2wK1TAq1q7+GKsfvIPVck4Qwkg/qKnDaAx3UNLPIsoy2MkMbngeOtRTLLb4SS6tCcBcqEm+VQcgQ5cJpfcUrlMw7XT5EMDlJDnxmurkabBNcDgpPGurgpicjq4aY8atEKnKchpAkjlXMCcmQKtHucxcpbQj0G2YZSqgZFiuxVeqA4CWK6lOmBKw4QlQkFRk4sUCy7nLQWBFoaVNjlkJbsDitKJVAJ2zZ4pWGvhAUvT5jcZZ4nCzGHiQclqFO4y6Ga2yOjiOagYk7DLOMsvysFF4x4ZMTaZ6YBCPHU7jLBJw8mFCS24I2GWxm4ObSgpdJAynLhK3V5MJiocT4ZK2imwvjgJSA2QKYE0twoWGuKrcVUmWuG0UoFaZIFjTWKtgHtgJZAKixsciZNkcRK/6ux7ZHxA5A0kljW7DthEwwlppBRaMjJcTScZCzjjaOFaUJ7Y2kYy70jgMgy8ErDGRjxMTiIWEUwtZC04oWYVdirRwILWKuxV2KuwKtOFK3FDsVdgV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuwhXYq2MULsCuxVwwq3il2KuxVcMKG8UN4hW6YUr8UOxVeNsVXDrhVdiheBhVeBihHQWzSEUGAlU7hso4wC/XI8S0nEESGnBciSlOIYKULDbIEqmcMEbbcQciSmkxi0xT8XGmR8RBhad2cAj245CUrcTPjTURhtm6ZVbi05ogOmNtcsaHIPLpi1GK10V9mFcILHgtKbvTFcExjfLIzaMmnvkxi5t3gJDCmWg24coGJpLy1MmkC0RBJ8Va5CYczDCiiprjYLXMSUXruzYdVON65jzi9HCSLVhmNKLkiSsCMCVw7ZMMSm1lMYiN8ui0ZBbIobkOOuWguDONIheVdt8mGiTJtNLkAHpkw402QpFUA5aA45KIWKmSpi0ykYoWMNsVQxBGBXKMCruPU40qFnk4CgxQUnkYk1xYFam/XCqhcqKYQpSO5tIplIIAOSEkhht/YvCxKjbLYm26M0sGwNcSHJjNKbuUB6VyEouwwZaUEkBygxdlDKrBgRlfC3DI2DjS8a7lgpeNoGpwEMeJGwkDMTKLZCSKD5iSg2RmiIzvmHlDkApih2zEKSVXIoXAYCquAAMgxdxxtbWMKZIMgVBhUZIJpDlQMmCzAQko2OWRYkJVJGK5m48lBEcNrOIGEyJcqMBFQnWq1y7DLdZBLCKZnAsRGlhxtNWoMo8MmC4uTGoMuWCTh5MaFdAeoy6MnW5cYKAlh4nLRJ1mbFSH40yVuMpkYqswlWiMCFPJIW4lK0rXEFaaSEsemJnTdjwGaOjtadRlE8ztsHZxPNGLbgdsxZZi7fF2fGKp6S06ZWchcoaaICm8IOSjkLTk0sSg5LevbL45nW5tBfJDG3NemWeK4X5AgtiCmROVvhowF4iGVmZbxp4rHhBwjI1z0wKDkgp2y6OR1+XSUhGQjLhJ188RiolclbUVuFDsCtYoaxV2KuwK0emKrcKtYq7ArsVbxS1ih2KuxV2KuxV2KuxV2KuxV2KuxV2FXYq2OuKF2BXYq2MKuxS7FXYquGFDeKG8Kt4sl+LFsYpX4oXDCldiheB0woR9tbmUjbbAStMjt4ViAFN8gSmkWsfNgMbVPLa3VFBIyslaTALXIJTrT7cMwJ6ZCZUBkgjAoBlVslaMAYCwnGwilHKhwOvnjotGtcWMhs4xA70wW1cNoZlFck1kUtO22KgJFq9srxl1G4yzGWnNhBFsDlqGI98yw4YFLlfgKk5CTlaYGUqUWn5N1ykxey0Y4Qio5conB2cZo5JcxpQb45EQsoyHA2jIrq4JwiCmSYRN0y2MWmU0ztvUZlC1OWU405s1sbMlVaXJAODkmyGNVjA4jJhxiUwhmqKHLAWBRysKZJi4muFVpWuKFF0wKtC0wKpSOFB3xVJp5eROBiUFyqcWK8bYqhLptsIUpUzE1wraGmgEqEEVrhBTbC9Rg+rs3YZdHdtjJhF1LykO+SIcrHOlNJad8rMXMhlRaS7ZWYuVHMq+qMjwtnjO9UYOFPihesmRMUeKiY5MonBRkRqNmJOLfCaMiOYGaDmxkmCNtmBINlq6nIFKqnXIlUTkGLsVU3whkEOxyYbAoNkwyQkm1csioCWSHfMiIb4BT65O2dKcg+E5PGd1pKX6kZsY8kUpZJeFYwxBYzhsokZMFwpRUXXLolwM+OkLKlQcsiXWZoWEtcUrl4dXIUVA4WBaOKrMVWHrhCFpGFQvjXkRkJGm/FDiNJpDAAK0zCyZXqtFogBZRPHMfidqMYHJxFMimQpb2wsVhwtZdSuK1awoPDJWwMAh3WmSBcbJGlHJtCwnCwJWkA4WJFoaSIEbZZGdOHmwCQS+ROJzJjK3T5sXCUO2WBxluJVo4EFrFXYq7ArsVWnCq3FXYFbxS7FWsUOxV2KuxV2KuxV2KuxV2KuxV2Kuwq7FWxihdgV2Kt4pdhV2Kt4VXYobxVvClsYEL8Ktjriq7FV4wquGKhVQVIGKGTafGFWtMhJQmFd8CUwtI+ZGAlCeLsAPDK0oqMcqAdcilkthEUUHxyqRSAnAyCW13xWkWGCqMDVkhbQYE0xcCYIV1oemBiAhLhaVIwhpyRQak13yTWLCHulDxuvtjFsJsPOb5BFK1fHMyJcIYTKSRT3J3AOTp3ek0nBuVKOUk5Eh28DSZRSHbKJBzYStHo5ykxbQVYSHI8LLjpVSU1GHgQcqc2xaUqo75LgapZXoekaeERZHG5wEOJky2ygJQAAdMNOMSrrWmSDElcpp0OLEoqOYg0OEFUUJB45K1XeoPHG1dzU98VQk03E0GKClsru+BjaGMTHtihSMLLvTFCkzFa1xVLZ5C1aYQgoEE13woVQRhTbEPMtFiJHXLcbISeWSNVzXxy4hvjJby98jTaMiqsvTfIGLaMqp6uDhbPGbEtceFIy2iYmrlUg2xnaPRWNMx5FyccDJMok6VzDyF2OLAUai0zCnu5YxIuPMHJBNUilzHIQqocgU2iOWQpadXFVNjkgyCGc5MNgWHphSl87Uy+AZBLWO+XgN8Wq7VxZ0pvupyceaaSeQ/Ec2cOTBTwpWt0wLLkok75aHCnzWtuMlEuNmFhDNuDlwLqMgSqUUJzIiXU5RRQ+SaFpxVZiqw9cKFmKQjrZKmuY+aVB2/Z2HikmvQZribevgOENjAzDR3whEt1tMWNKZFTkrajGy3SmKapacWJUnFRkg0zFoQjfLHEI3UmG+SDTIbuxQsOFiUJMmxOXY5OBqcVi0tcZlB00hRU8JYOwK1ihrFXYq7ArRxVbhS7ArsCXYUNYodirsVdirsVdirsVdirsVdirsVdhV2KtjFV2BDeKXYQrsVdirsVX4UNjFQ3hSuXAVXYVbGKF+KVwxQuwqiYBVxihltuoWIfLKyyCqBvihObIUGQkqaICTU5BKKiHxqB44CrMLZaRL8soLMI0D9WBVREoK4qrcfh3wIpBklX9snTTOAKLjkyNNBxIO4ulVqNhEWBxFQEqncHDTA4SVCaRSpwiLdj03e841nl6ze5zJi5uPTRix0pU75O3KEF6JTIksuFHR7ZVJtgaR6HplZDeCiVFcjSSUSkW4yYayWV6Jac5EqO+JaMhep28XCNQOwyDiko1ENN8kwVOGFiS0Epvih2KF4Y4pbLEYqqJVsIVqWGu5w0gqJRQOmKGhQdsVaKqe2KoC4twwNMUFI5oGjrUYsUGQK4UKTyKu2FWL68vqW7HrluPmh5NOKOw98yGYKhXAWXE2Gpgplxrw2CmQmrJVjtkTs347knNtDsCcxcknb6fT9SmagL0GYx3djACKqrHKpQb+NGxvUZjSxtgmjI2G2Y8sbMFFKcxMmJmQqA0OYsoUwpWByohNLidsCFFmyYDMBDk5MBsCi8lBlkcZKhLZTyJy+MabQLQjDJtsQsJ2xZKUjUQ5OAsqlDtVjmyiNkLK4StNE5FJCixy2LhZNitrtkg42TkoN3y0OqmEsuOuZEHU5xugmyxxVuKuxVTOKFo64UhNrUbZg6gvUdk40dTMN6Gm6bYppTJ3wtZO7sVawsVpxYlYcLAqZyTWUO3XJhxpc1NhhDVIKRyTUVhwsCpyCqnJR5tWQWEqkG5zMidnQZhRQ5ybQ7Aq3FDsVdiVdgV2KrcKWsBV2BLsVawsXYq7FXYq7FXYq7FXYq7FXYq7FXYVdireKr8CHYpdhCuxV2KuxVfhQ3gVvJJXDAq7Cq4YFXYVXDFC7CqLtvtrihlsZ/drlZZKq9cCp5ZCoyElCbIoyCURAv7wfPAUMvg3iX2GUlkiFrXrgVGIRTAq9+gxVASGjZMIK5DTfFFJfexhviycSnhQCMVHXJJEWmflXFmAwvV6GU5ZFvikfEHEtgdxpgSvU0phpbRkRJpkeFPHSPjfcDHgXxU2tk5kV6Y8LXLK9A0GFQw2yuQaJTtncY6DAA1EogYUWuwsXYqsIxV1aYqqKOWKUVGoGSCtydMKlBMdsDFSqPHAq0uMVUmbvihQljWRTtvihjt5H6JPhhDEpHKWY1ByYQk+qtS1cN1pk4c0PKbneRqeOZLIIU1wJawJVEUkgYlnAWU4tregBIzGnJ3elwACymibbZjyDs4lEDfKykFUGQbVVDTImLKJRaORlUoNsSiUlyiWJtElX1cxZ4G0BVWceOYstMWEjS4zDxyI0xY8QUWmHjmRHTMTkQ5mr0y8aYMhktDOxJy0YgFEt0OxyEsblQKgxrlBjTlR5LPnkUJfcyj7IzLwwSl5OZdIW1wFLRONIJUid8ti4OQqZbJhxMh2UGbvloDq8h3SyZqk5fEOpzysoZsk463CrVcUKZxVaDvhZR5pxaHb6M1+oes7JOyNzFd42emKStpixpYThYEtYUNHFiVhwsCsOSayhn65MONPmp4WpTbJBqmpVyTVaw9DhYFLZh8WZUOTpdUN0KeuWOG1irWKGsVdiVdgV2KtHFktxQ7FXYq1iguxV2KuxV2KuxV2KuxV2KuxV2Kuwq7FW8VX4FdirsVdhV2Kt4qvxV2Kt5JV4wK3hVeMCt4VXDFC7CqIgNGU4qyyBuUS5WUohdsUJ5YyL0yEglM1ap2yFLaKjfiRgIVlVjKJI6DwyqQZBHk8RkVbjkJNO2NLaKB2wKgnYFskELCxrTCqDun+GlclFmAloY5NkFGZ/TUtWgpiyAYXfS+rKTkw2BA/RizDjiFty7nJgMTJGr02w0wMkdbxFiCcNNMpMggXiBgpoMizvQG6ZTMKCzJGNcrDJFA1wqqDpirYphV3TFVM7nbAqugouEKvRiDhVUlPwnCpSuRyK4GKFLse9MUWtLHFbaL++BWw2KpbqEfOMtkggsWf4a5JixLXrmkZQHrluMJp5668iT45dbMRUyg75G2fC708bXhRNvFVxkZHZyNPjuSeLHQADMUl6CEKC8KRkSyARKZTJuAVaCmRbOFeopiyApWByJDNUGQIZQ5riTkOFyOSxmI3riIAuPmLvV264PCcbiUzJXYnJCC20GphMWUZU0z5HhbQVAtXISi5UJKRzHnFy8ckPNIEHXfIQx2WySTySciTmfCFBhxKVclSbW8jgS4tiAwySACkTvlgDgTkou1K5ZEOHlkhZJOIIy6MXV550EtZiTlwdTI2VpNcLFacULScVUicKFtdxiyimlq9BmFni9F2XlrZMVauYZD0kZWvPTAzLQOKAVp64WJaxQtOFgVhwsCsOSYFDPkw4uRTwtSm2SDXJSpkmmmj0OKCls/2sysfJ0ur5oRu2XBwVuJVrAhrFXYlXYFbxStOIStxQ7FXYq1ih2KuxV2KuxV2KuxV2KuxV2KuxV2FXYq3iq/ArsVdiFdhV2Ktjriq/FXYq2OuFV+BW8Kr8VbwqvHTFW8KFRDSmKsl0+cMvAnIEKmmBUZbPRhgKsgjoVBGVqqgVxVONPuPRIBOxyEgkMkEiyKCD1yqkqkYA3xKtySccACoTlU5OkOevEt4Ysgk88pJIOTAZhSiqTv0wlkEo1W5CqUU4YtgDFGNSTkmbWBLdMIUq0SVOWRapIxU3GSaynFvHQDIlrkm0a7DFpLK9Gk4uoyqaIs4QE0PjlTNGAGg2wqqL0wq1XfFLia4q0MUIlemFLq0xVbJKOOFBSqRzXAxUCfDChcprgVplxVZWmBLUoDRsMKsM1CkIdulMmGIDy/Vbr1pWFdq5kRDYAkTZJmpHrgZLwMCE0s0qa5TkLstFCym3DbbMe3d8K2lMUAOBORIbArBshws7VQ2NJBVARkaZqinIkNmNfXIU3lSkIpkohozckA0tD1y8QdaZbrfXHjj4a8bfrADrkeBeNozAjrg8NuhkWeqB1OVyx25WPIoSXFOhyAw25cciXSylu+TjiptOXZCE5IhgJrCciz4ncsHCnxFNnyyMXCzZbKzlkqaDLZDyP75bGLr8uRK55anbMiMXT58tlDhvfDTi23y98aV1cCqbHCELa7YUrcCoiGWjAVyvJGw7DRZuGSdxtUA5rZii9jhnYtVJyFN5k7FVpOFgStrii3HFBWHCwKm2SDXJCsd8mHEkVhOSayVM4WorMLBTc0ByUQ15JUErlNScy4jZ0OeVlQbLA463ArRxQWsVdiVdgVvFK04pW4odirsVaxQXYq7FXYq7FXYq7FXYq7FXYq7FXYQreKtjFK7Ah2KuxV2FXYquGKrsVdiq4YVX4q3ildihvCq8dMVbwoXDFUXBMY2BrirJbe5WVQK75AhUepIoRgQmtrc0oGyJCU3jYNuOmQKogNx740qYWl6VYKx2yJioLIo7iMpUMK+GVUlQkmDbA4QFtYJFTcnDSGpLgMtBhAZhKXZSSSck2BK7nUUhBVTvhpsAYxPcNM5JNa5Lk2UojAl2KVwwoKNiG2WBpki4hVhkmsp3FGSBTIMJJ9a2EswFFNMiS0lmGmaUUKs21MiTahmUMKUA8MjTJFCJcNJWtDsaY0hClSD0yKrOmKtqd8VRQNBkkqMjgbnAhKp7oV2OLElD+uHwotymuBQrrQYVWsRXAqi7Yqu5Dga+GKQ8x8y6gqM8anfLscWQDzWZyzFsyAlDHAyCzvgSrIOmAsgE5tKDMfI7bRbJjXKadsJKT4hhIrR1xLZFfkWxcDhpIVC9MHCyJXrJtgMWeMt+pTBwN3EoSSbHLIwaM0tkuZ6nLuF1Rlupljh4WJKg7tTY5IRYSKj6rjvhMQiMyG/VPjlRg5MMrXOuVmLmQzKEhoMRFlPLQQ/OuRlBGPUWsLgZDgbvzACwyDCINUtRamXHjkuFpOUKEtwF75OONxc2qAS+W5rsMvjCnVZtRaCLE5OnCJtbyOGkW3zwUttc8FJtotjS20XGNLamXJw0i20Yg1wENmOdFObaeoAJzBzY3p9Bq7FFHhq5iEO6jK13LBTLiarii1lclTXxNg4KSC44qUO7ZMBxskkOTk3GJUyck1krThYlYThYEoSZ6bZdji67VZaS9jU5kB1EjZWHJMFuApaxQWsVdiVdgVvFIWHCktYEOOKlrFDsVdirsVdirsVdirsVdirsVdirsVdhCtjFV1MCt4q7FXYq7CreKaXDFDeKt4quGFLeBC7CldihvCq8dMVbxQuGFSuriqKgnaMgg40hO4NRBoGwcKpilyp3DYKVMYdQ4UFciYqmiX0bLUsAcjwqtfUI13DCuSEUNQ6uwb+82wnGEWmA1yNRu1TkDjZBDyeYEbYHEY2Tv08gSg648DKKXTaw71APXHhbgEsedpDUnA2BareOLIKtcilsHFVRThQUdGdhlgaZI63QvIoAyRay9A0rSGlCuy7ZSS1ks3t7aKFVQKK5C2CYqONKYqjY3pTCqLVg2KVXlhS0yq3bAqClTjgIQhgQGrgQieYpUnJJSa9uwtQp3wMSUjM5b55KmFtCUg9caW0WlwAMFJtUF0OlcU221yvjgVRa6U7Yqg7m74xOa0FMQGQePa1cercOa13zLgNmTHmOTZKRwJWjrilER5As4plbtQ9cqmHP00qKZg1yh20d2z0wNtKR64pC4HAzBbyQVxwhZNrgLPG49cQ3qExoMsiHG1M6CAPXLnUktY0trSK4oKi6YsVEimRKQaU2JGCmfiEIKecqKZIQac2pI2QBuSK4mDjx1RCk1ycjwMvzRKmbojHw0fmyFBrlj3yQg1S1RKHaQnqcnVOPLIZKRbDTW1U4qtrii2q4otxNMUreRxVquBXYq3WmLIK0cnE1rlco25WDMYFNIrioG+Yc8T0Om1vEKRIkqcoMXPjltWDCmQpvEllanDTWZbtFwvfCBaJZBFRe4XoMmMZceerihzJU5PhpoOW265FNqbHfJBrkXEgDGkE0h5JKZbGFuLmzCKXyPU5kxjTps2TiKgck45axQtwlLWBDWKuwFXYq6uKVuFWsCtHFS7FDsVdirsVdirsVdirsVdirsVdirsVdiq4YUrsCHYq7FXYq3hVvFLYwIbwq3iq8Yq7FVwwquxVvFV4wq3irYwoXYobwqqK1MUK6zuOhxVVF1IO+NKq/XJaU5HDS2t+tSH9o4aQuW6f+Y4oV0nZurZEswq8j45FK9WPjizirqa5Et4VlyJZhWXIlkqjpkUhfthVcDvhAYlGxHplgapMw0CzFxOhIqAcEi0yL123hEMaqoptlBayrIPirgQiARhVVXpihVVyuFNqyzVxTaoJRiq2Qh1OKsfvL1LatcACCUtXWVlqqtvkuFjxIWWUyGteuGmBKFqVOFC0yb40qrzIG2CkrTIR1NMVt3qFu+K2uoKVwJDHdcvhBCyKdyMnCNtoeXXExkdmJ6nMkBkhCcUqZxS1gSiEOQLZFEI/EjIkN+OVFNYpQwGY8ou4w5LCIB2yDlgqTHfFBbBxTHddypiza55JiZODb40mElxI64gOSZbIGV6nL4h1GoyWVLJOPa4YpCm+2LGRpSJqMSgG1BhkUqL7KThCJGgks5LMctAdZlnZQbA4tagwORVRYd8KlSOFgsJxVrFXYFpqmKKaxVbhV2BLsVdiq3vikOrgSCrJIV75Axtvx5TFFpP75RLE7LDra5q31r3yvwXLHaAaNz74+CxPaAQ8lyT3y2OIBw82uMuSH9U165bwuF45JVVlyuUHJx6pV9YeOV+G5X5oLTMPHD4aDqgpPPk443Hy6u+SFaQnLRGnAnlMlEnJNJLWBDR6YVW4EtYoaxV2BXYqtwpdirWBWjipdih2KuxV2KuxV2KuxV2KuxV2KuxV2KtjFW8KV2BDsVdirsVbwpbxVsYEN4VbGKhfirsVbGFV+BW8KrhihvCreFVwOFW8ULhihdhVsHCq6uIYtg4UrgcUKyPQ4CEhGo1cgQzVQcCQVVWwNsZK6tgIbgVdTkCytVBpgTa+tcCXVyQYlGwGpAywNEnrPlO1+EOcrm0yL0Dpt2ypgqLiheKYqqjYYq2DXCq9UJxVWWIjc4UrqAbYqxvVLVJa174gsJMReweGTkh28Ms4ra0YpNBy2ORStkYDfCEKQZSQcVRIIwJQsxNdsKtxk0wEKG5rhYYmZjSgwVbIPL9b1D15WAbbMmEabQxhnrk2S2tcCWq4CkOriypWU0GRLOK7lgplavFMVOQlG3JxZuEplHPyHXKTGna4s4KoXrkKbjK3K2JZxk2WwMiWq4bRw2t5Be9MkGP0oeW6C7A5ZCFuNn1dbBQEwbLqcHxbVOQOBlxLg22BmJKTmuLGSlgYxC0jAzJpBTHsMsiHDzZOiCaOvXJ24lWotD4ZAllwoV4sFp4UG6UrhBYkIYjC1ELeGNpAVVir2yJk2CCoIcjxMxjaMOPEpxqLRkZIFrlBQK0yVtdLcVdirsVWnFLWBW64pt3I40nidyOCl4i7kcC8RarhRbWKLbrim3cjgpeIrSxrjS8RWk4UWtxQ0cUNYFaOFVpxS1gQ7FXYFdiq3ClrFXYFaxQ7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq3hVcMCW8UOxV2KuxVvClvFWx0wIbwquxSuGKHYq2MKrxgVvCFdhQvxVvCreFV2KG8KrsUNjFQuwoLeFVwxUrsUK6PSmAhIKLVwchTK1UHFkCqK+CmyM0Qr5EhsElUP75HhZcTfqDHhTxLg4Jw0glMrU1dfnkw1SL3DywoW1U+2UycclldRkGK5aHAlecVXgnYDFUXFFUVwpRKLTamFVb0ycaTTjCDhWksvbPmCRgYkMbmtmjO4ri1kIR0B7UOFCRX0npHfYZZEIKGhuoz+0MJCESblOzDI0lcssZFWYYKVA3GqW9uCeYqMkIEqwjVvMLTco0bbLo46TbEWmMhJJrk6bolbXAzdywJaxS6uBIVFbIlmF1cWTuRwJtUWYr3yJi2xy8Kul345AwcqGqRK3CnvkDBy4agLjOvjkeAtn5gLWuVA64RBJ1UQEFLdE1plkYOFl1RkgXlJPXLgHXzna5JSMkxE6RaTDIkN8cqv6o8cjTd4oWmQeONIOQOMg7YOFByhTZycIDXLJaHZe+TceW6mQMCAosKYGSky5FkhJIq4rVoU2+/TG2Phu9EDBbIQb40wMuTYGAsg1gZLWAOEFiQh3i75LiapQQjpTJg20SjSnhYuxVacVawJaxV1cUW1gV2KuxV2KuxVrChaeuKWsCuxQ1iVawK0cKrcCtYq7FXYFccVWYUlrEodgV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVwxVdhS4YquwIdirsVcMVXYUuxVsYEN4VXYpXDFDsVbGFVwxVdiFdhVeOgxVvFDsKr8KG8KrhihvFVwwqV2KF2KFwFcKr8VVASMaRaoJDjSbVBJgpPEvEuPCkTXCY48KfEXhyceFPioiMk4RBBypxZo5daDvkuBqOS3t/ldZPq6g+GYuQbqDbLQjVyukryjDpgpKpQ03wUqIgSpxSE1RNqYWSICgYUuJxVvFCHmG2AqUvkiR9iMDGkourGgLIMLAxYfq9ozwPtRgMtgd2BeS3WoXFpKyciKHM2MAQ1GVKC69OP2jhOELxNyeYJ2UjmcHhBlxJPPqM0pNXO+HhAW0vaQsdzgZBcj5EhtgUQDXIFuBXYEra4parirYamApBVA2RbAW64pUXbCGJKnyxpAK8SnxOCmYmV3qnxwUyGQu9QnvjTLjWFsUEqda4WorgckhVVqYra/mcaUyXAk4aY8RVlGRLZFfTAzWHFiVOmAqpkYpUyMCVPhXAWcQsZKZAtwCg698QghDnrha2sCQ1TFQ0RgStxVQlSoqMkC1TigGFDlocUrMULTilrFXYq7FWsCuwK7FXYoarhV2KrMUuwItrCrsCtYFWnCq3ArsVdirsCtHpiq04UlrEodgV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KrsKXDriq7Ah2KuxV2KrsKXYq2MCG8KrsUtjFS3ihsYUrhiq7FDsKrhiq7FXYULhhVdihsYUFdiq8dMULhhVcMKFQYquxQ7FW8KrhiVXgE4UWiUjw0xtFJCSRQZIBiSnVnp7SEVGS5MCWY2mnxxhSRvlMppAekaBIqKI8xptsWV5Bm3gVVoCKYqjraHvgAZBH0phZN4odiq0nFKElappkShQ74sVr0oQcVSHUrUPE5A6jJAsZB8++Zrcw3Um1N82GKWzjSDDmahy7iRwqZc5EllS2vvkbZBquBk2DgSrpJTIkNkZK4YEZFsBargTbq4parilsNTBTIFsyCmCk8SgzVyTAlquBbdXFbb5UwMgW+YwUy4lMvhpTJsNixtdyGFHE4PhpjxKqmuK2iF64pCKXpkCW4Nk4ErDihaQMVUyK4qpNiyDlGQLbENOuRbQhXGBShSN8k1F1Biq2mBLWBKwjFCxhUHCEFLpRQ5bFxJhQOFrWnFWsUtYodXFbawK7FXYq7FWjirVcUra4odirsBVrArsVWHCrWBXYq7FXYFaOKrcKtYlXYFdirsVdirsVdirsVdirsVdirsVdirsVdiq7Cl2KrsCHYq7FXYquwpdirYxVvEIXYpcMVXYobGKW8KrsUN4VbGKr8VdhQ3iq4dMKGxhVfigKgxQuwoXgUxVcMKrsUN4q7FaXqMKEdFHt0yQYEoxEyQYkp3YWnqsNsmTTBmUFqsKjbfKJStkAjoxWg8MrKQnNjcGCRTXauVkMgWe2lys0YNd8rbAixtgS2CeQxVO7cUQYQzV2xVT74EtnFVJ2AwFUKxqa4EKZr4YEKT4qh505RMPbCgvBfOkPGdjTMzCdmiTzB9icyEBSrimmxgV1MVaocCVwOBKoHIwFkJLvU98FMxJ3qY0y4mvUwUvEsaTDSDNZzxpjxO54KTxLuYxplxO5jGl4lNpPDGl4lPmcNLxLg2BNrgcCbXcsULwcUKiHfCqMjNTkSzijF6ZAt4ccVW4VWnAhYcWSkepxSFy5Et8HMNsgzQrjqMCShGG+SDSWwBiq0jAUrCMCrTipWEYoQEy75bFxsgQhybStwIW4UtYFLWBDsUuxV2Kra4rTROKtYq7FXYq7Iq1iqwnCrWBXYq7FXYFdirRxVbhVrAVdirsVdirsVdirsVdirsVdirsVdirsVdirsVbwpbxVdgQ7FXYq7FW8Ut4Vdiq7AhvClvFVwxQuxS3TCreBDeFVwGKrsKuwq3TFC4DFV4GFC7CqouLFeBhVfihcBiq8DChdxwK6mFFq0aVIwhBTWNaAZNgrxpVhTJRYlmukW9FDUyOQoAT8rXKWS9EI3yJSrLUEYFTyxvWhIFdsgQzBZZBexyqPiFcrZWjY3BYUNcUsgh+wPlhZrya4qsOBKxmAwEqhWblgQsIIwK1XFCFkrXbFWudVII7YQh4f56oJmHzzLwtUnkUnU5ksFqxsx2GKko+HT55aUQ40wOQJkuhTsK8TgYeKoTaPPGK8DhSMoSuSB4zQqRgIbRK1E5FkFtcLK2q4EW0ScUrCcCWqnCrdcCu5Yq1U4pWmuKtYlLYOBkCuBwJXVGKrgcVVVbAqMjfEsolFhxkG4FdWuKXVxStJwKsJxSpE4VXIcgW6BXnIlsQ75Fl0QbdclTSXYVdgVYRgVYcCbWkYoQM4yyLj5EERljjrMCrTilbihrFXYEtHFXVxVbXErbWKuxV2C1axV1cVWVxVrArsVdirsVdgV2KrThCrcVdgV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVsYUt4quwIdirsVdirYxS3hV2KrhgQuwpbAxVdiq8DFDdMUrqYoXUxV1MKt4pX4odhVcBhVdTFC4CmFC8YoVAMKrxiheBhQvAxVdih1MKEXbrVsIYlMgMkxRlutWXJhgWdafRIhtlM0hMxvvkGSsmRVVpgVwJB2wJRcNxJGag4CEhPbHUG5qGOQIZAs7trgNGMFtoRHq42qm0prgtVF3JwKtGBDeKqbHqcVUOdWpirUpVUZvbCh4F53l53LgHMzC1SYBb2Ulw9ANjmQ0SnTL7HQ4kAaShOC3GllT+O3ghFFQYGoyJVaeAwLbfpIwIZQa4raUXmjw3FeK0OG2yOQhh1/pEtsSQpph5uTDLaQOhU0OBuBWYGSw4qp4pbGKrgpOK2iEtnftitotdPcjpitttp0g6DEsgLQklnInVcjbYIFDGNl7YLTwFYQRjbGi1yxV3LFKqrHFaRaVNDgtkIlGoGpkCW8QKpQjBaeEtE4VWFsULC2K2sJxW1yHAWyBVScrLeFCQ4EkoMnfJNJK4dMCbbPTFNrD0xVYRgVYdgcUEoCY1yyIcXIbQhGTalhGKrMCrSMVW4q7FVpwJawq1gV2KuwK1gVo4VaxS1ihrArsVdirsCuxV2KrThVbirsCuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVvClcDgQ3irsVdirYxSG8KuxVcMCF2FK8YENjCleMVXjFV2KrgMUN0xV1MU03TChdTFVwGFVwGKFw64VXYUKoGKF2EKqAYoX4obHXCq7FCMteuSDGSPpvkmCPtaclyTBnlkqmEHKZHdkEWGANMiVVlrXbIpRIBpgS4LviqqBTAldC3CQHwOAqGe6dcBolIPTKi2hOY2DDFK4mhxVax74Fa5bYqtJrgVSJ8cVWhRucUJRql2LeGQk9AckAgl4RqhbUb5qbryzOxig4uSdJnaafFAgIA5ZO3CnO0WKg0BxYKlDSuBXVY02xVUJIGBViuScUtyxRzqVcA1GEJBp55rOnG3kZlHwnpk+blYp2xkihyLkhYRgVbSuKURFAz9BhRab29kNqjFCcw2a7bZEyZxjaPS1XwyBk3xxK31VadMhxN8YBDy2Ubj7Ix4m0RCR3OnUqVGNsuEJHLblSRTDbCWO0G0RGG2k4lojOAlRiRCR5Hibo4kbEANsFtwxhGpQZEltjEKhAPbBaTAKTJXCC1yxoZlIOTBaJQpROStqLVcUW2DTAyiVXlUZWXJiUM7VOICJFTOGmBcMaUOwJccCraYFtQlOSi1zlSXvvlgcWRUSMKFMjFVhGKVh6YFWYq7FWiMCVpwq1gV2KuwK1gVaeuFWsVawK7FXYq7FXYFdirRxStwoaxV2BXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq2MUt4VXYEOxV2KtjFIbwq4YqvGBVwxVdhVeBgVcBiqoBiq4DFVwGFV1MVbpirdMVbphVcBihcBhVcB7YoXAYVVAMKF4GKFwGKF9MVXAUwobwqirY0bCGMkxJybWUTbtRhkgxLOtMflEBXtlU0hMgu9cgqKWm2RSigRTIpaBxpLY3xVa5pirINIuwtEY5XIM4llsctACDtkGav6yt33xtXcqnAq+oxVYzAdMVUS46nFCi9yqqaHFXmHmvVygaJW67ZkYoW1yLD9NUMDK/U5lU4GWSalt6DphcdcqnliqpIxUDAkKiMrLXvgSqGhGBCgdsKqiYqlOtQCa3ZqVIGTizgaLy+deLsPA4lz4lQwMkRBCZGG22Ksjt7UKBtgtimsNrWlBkDJuhFNoLNiOmVmTeBSOSyPfI2zElc2YptgteNBy2rKCaYWyM0tkh6gjFsBSO9shQsBhbY7pC8NCdsjbZ4dqXpDG18NbwIwWvDS4VGKq6PilEBgcDIFdiyU2UYQWqUUO65MFx5wUDtknHU2amKhT9WmRIZjJS3mDgpPE3XFbXDAyBbOBLRwKsYgYaYk0g5GqcmA485WhiMk1KRGKrDilTOBVhGKrDirWKWsBVacVW4VdgS7AVawKsPXCrsKtZFXYq7FXYq7ArsVWnClrFDWKuwK7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FWxireFK7Ah2KuxVvFIbwquGBV2Krxiq4DFV2KrxiqoBiq8DFV4GKrqYobpilumFWwMVXUxQuAwquG+FV1MULgMKF4GKF2KrxihvCh2FVSNuLZIIKaI3IDJtRCsjUOEIZPpd2FIUnY5GQtDLVIdQwylKshwFKtywKqLTAUtk8cVQ7SVOGlXx3BiYEGlMBCQWS2OsxkCN23yoxbAU5E6tRlatcgqqtwR3xW1YXOKbU2ua9MUWhpJyR1pihj+q6vFaQv8Y5UycIWgl4zqWoNfXRJNQWzOhGmmZZLZRKtuvjTJOBM7rm2NO2LAIlAQK4Ertm+1gVvgANjilfGa7HArci7bb4QhYtQN8VUbhecLg+GEJDy3UY+E7j3yRc7GdkuAqcDanmnxVIJGKCym3ty5FBkCVintvbqtKjKiXICZxqFHTIFkF9RWmBmqKARiqx1HQjFIQb2quDQb4bZiSUXVoQrAjG3IxyYjPBxcgjvgLnQ3CEaL2wJkFBo8k1lSK0xYNdMCr1bFKsH8cCXFhTFBUWYZINMkDI9DlgcSeyEeTJU0maHLnFha8PgZCSsJMjTYJrxIPHBTITbL++Ck8az1caR4iizk4QGszUTvXJMFuKFMjFQpkYEqZFcVWHFVpGKrCMCWqYVW4FWkYq1il2KtYFWYVdgVrArsVdirsSrsCuxVacKVuKHYlXYFdirsVdirsVdirsVdirsVdirsVdirsVdirsVdireKW8KtjAhvFXYq3ilsYVX4FXDFSuGKqgxULhiq8YqvGKrxiq8DFV2KrhihvFVwxSuAwoXAYqvAwquAwobxQ2MVK6mFC7FDeFDsVbGSCoqKWm2TBYEI5WrhYEI2GUxsCDhQy3T9QBARjlcoqyFHVgCDlaqgNTgSrA7YFcSCMVQ7CmFUFPOEB3wMkkfUHR6oxFMmILab2fmOWOgdqgZA4l4mT23mOBwObAHvlRxllxI39N2rD+8ArkeAraxtetI1J5gnDwFbYzqPmtQGWI5bHExMnn2o6vNdMeTmhzIjABiSlFs3KZa+OWNc+T0G3NIUB8MXAlzWyMa7YoCLhc8d8iVVKjrirXKvTAyXR7nfFVVjSlMULSRSpxVDs6sGFe2FIeb6uoFw/wA8mXMxFJ0FWGQb2W6XByA2wEsZM1tYVRRtvlcisEeqjKy5MQvUb0yLYAu41OLJWRaYFWOMUhauKVs0QkU7b4tkDTBtRi4SNtknZ4d0mcYGyYQ5GFoKmVwtZUWTAkLKUwMnVOBXFjigqLE5INMkFMcsiXDyhAk5JxitrihsHFK4NgVuuBNt1OK21irsVaxQtOKrGwKpnFkpnFVhxVYcVWHFLRwKtxStI3xQtxS7FVp6YFW4VdirWRV2KuxV2Aq7FXHFVmFWsVdiVdgV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kt4pbwq2MCG8VbGKQ3iq7FDeKV4xVcMVX4qvGKF4xSuxVUGKrxiq4YquxVvFV9MULgMKr8VXDFC7CErsUOphCC2MVbrhQ7CghvCh2EKuBpkkIqOSmEMSEasmFjSOgnZSCDgKGRWuostATkCFTuK/QgVOVkJRX1uMj7WBaW/W0A64rSAn1EDYHCIqktxdtJ3ywRW0uZickhZzI74UONw69GpjSrDeSj9s48K2pPeSnq5x4VtBPKzdTkqQhXauFKyGTjIpr3xYyGz0Cyk5wIeXbFwJiiiCTXbCxRETbb9cihW5ClDgS2OI6YpXg+GBVzCuKqMwPDY74QqXOxijZm8MlzZBgGoy+rMxwlzMYoIGIfEMi2s60iOqqRkCwmWWw7jKyyxogdcgXJiqLkW0LzWtcUhWQ1wKpy7UxSGkNOuKVxpX54sgWH60gDkjJdHZacsXfA5MkOeuFxytOFgVNsLFQbIkJBW5EsmjigqTYWqSCl6HJhxcqBOWOGVhGKtjFW8CV+Bi7FXYq3ilrFVpwKFhxVTOKVhGKVpxVYcVWHFK3AhaRilbiq04qGsUtHAhacVaxS1gV2KuxV2BXYq0emKrMKuxV2JV2BXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq3ilvCq7Ah2Kt4pXDFC7FK4YquxVcBiq8YqvxVcuKrx1xVfiqoMVXDFV2KtjFV4GKrxihcBhVdireEKuGKHYhDeFW6YULqYVbCk9BhQvELnthQ36TDthtDYBBwoRUQJOFiUyiWnXFijFamRVWE7DvjSqouH8caVU9dj1OCltTarb1wqosCDhQpHvhVSY4VUCcKCpGu+KqRrhVRbFUO5xShedGxVl+j3asojZsLiZYskXfFxiqA0OBC71BiyVAw64Fa9Xia4KSqiTkPfFVw+LriqQa1dpHGY12OSAbccbLAJG5EnAXNAdF1GKWf6GR6YrkJNU2URkVyss8ZVxscg5MVReuRbQr4FCqoFMUqMmKQpDCyc1RviyixbWDXcZJzsBYlIcFOXIqNcLQStOFgVpxYqDjAlTyJSFrHApUGOENcihJTscnFxMpQeTcUtYodhVvAq7Ah2KuxVrAl2KtHCq04FU8UrDiq04pWEYoW4ErSMVW4qsxStOBVuFLsBVacULcSlrArsVdirsCuxVacIVbirsVdgV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVvFLYxVdihwxSFwxVdihvFK8YobxSqYqGwMVX4qvHTFVQYFXDEqvxVcMUrsULgO+FVQDFV4xUrsUN4VbHfFWxhQ3iFbHXJBCqqFjQDChMrfT5JCPh2wsSU5h0lRTngtjaOWwhA6DBaLUpNOjboMIktpbLppB2GSBW1q2pjG46ZK0FVUUxQvwKuGFC4HFVQYoVBiriKjFCGfauFKmEZjsMbVGQ6ZPN9lCa+2RMwE0mkflq6kFfTOR8UJ4VO48s3Uak+mcRlC8LHLrT54CQyEU9stEgUUk8qsOoySEC3XFKtbztDICD0whhKNs5sNRjlQBjvhcKcKTVpBSowNTS1emKUYkJIyNppU+rk9MFsqXC3ZeuNqUNcyiCNiTuBhAUC3n2oXTTytvUVyRcvHGkrORbm12IxVmmiTALSuAhpmy+E7jfKimBRVd8g5USvU7jIltBRQNRkUtB6YWSm7VxSCpA0xW1OeUKmSAZRLFNSkDAmuTpzcJYw7bnIU5JkpE4tZK2uFhbROKLUWOKbUsiUqbHIqSouaDJNMygZWrlgDhTlahhamsUF2Kt4q3gQ3irsSrWBLROFWsCtYqsxStOBKw4ULcCVM4q1iqwimKtHFIWYqtOBWsKWsCFpxVrFLWBXYq7ArsVWHrhVrFXYq7ArsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdireKVwxQ3ireKVwxUrsVDYxUr8VbAxVfiq5cVXjrgVfiFXjFK4YquGKrxiVXYqqDtihUxVeMKG8VXUrhVwFMVb74UNgVwhUTFCXIAGSYksksdNGzOMBLAlP0hVAAq5G0KnEkdMCFhU4bVaARhQqJHzO4xtVk9spBoMRJUnlhKE5YChDk0ySthsULsVVAcVVRigrsCERBYS3LgIpNcBlTMC2daT5SZ+LSrlEsrYIs/svL1rAoqg2yuyWVJylhbrsEGBNLJNOt5AQUG/titMZ1PyvbXCtSMAnJCZDExeVa55RlgLNGhpmRDKwMXm93Zy27EMpFMvBtjSWNscKERBcPGwKkjCCxlC2X2OpgqFkwuLLEyCC6gPQjIFhwUj1uI+zDI0tKq3UYBJYYKTSEuNWjSoBqcIikQYtf3b3NaHbJjZtjCmNyowJJxbgoEYGTQ64qnmmXHBgK4WnIzW2uQab5CUWuMk1WT3yohyYTVVbfIEOQCjEIoMDK1xpgZKLbVwpQ7sBv4YQqV3E3IHfplgDIFiWoXG5WuSpyITSf1K5AhuGRuuCk20cUErTihRJxTakTkSm1J2wAMZSQzvXJAONPIg2NTljikraYEW6mKtYq7FW64quwIaOBLVcKtYqtxQ7AlbilacCrMKrcUtEYFWYqtIxVbiq0jAlbiULDilrFVpxVrFLWBXYq7ArsVWYVaxV2KuwK7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYpC4YquxQ7FW8Ur8UN4pXAYquxVUGBW8VXAUxVcMUrxiq8YquGKrxiq4YqvAxVUUYoVBiq8YVbxVdhQ7FVwFckEWiI4ySMkxJZNplgXo3GuCRpgSy2DT5aABTlRkhNY9JkIqRkTJXPphXtjxKhJLIjthEkJe8BU5O0LohTFKoV5YoS67gABOTiVSCQUY5aGKwHCqqDgVeDiqoDihN9OsHu5FVVqK5XOVMgLevaJoEUCKzp8WY0pW3AUzGOFIwAABTIpVqgYq7FVlTiruvXCqAu7OK4QhlBrgRTybzV5aTg8sSU6nbL8eRgQ8QvLZoZGUilDmWCwU4YSd8kglHrVcLAopJ3XocWJiri7mH7RwI4QvF1Kf2jvgpPCFhdmNScU04HArToGGFQlUqcScDNRpilEQSem4OEMJC2T2t0OIIOSq3GkKKcw3hFKnIGCYzpHLeLUb5WYORDKj47pTTfIGLcJhVNwo75HhbRJQku1HfCIsrQEt0CCK5MRZWklzdhFbffLBFgZsRubgyOTXCQy8SkL62+RMUjKqrMMiYt0cqsHU98jTcJhouMjTLiUWYY0vEoM4GCmBmhnfDTTOaGJyQDjkrcLB2Aq7Aq04UtYq7FV2RVonCq3FbdXFWsCtHCrWApWnFVuJVojAq3FKw4q1iqw4qtwKsOFLRwKtxStOKFuKWsCuxV2BWjiqzCrsVdirsCuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KhcMUrsUOxSFwGKrsULsCVwwqFwwKvwquAwKuxSuGKr8VXjAq8DCq7FK8DAhcMKqoxVeMULsKr8UN4VbArhCouCBpCABWuSDAllmmaI8rKWXbAZUwJelabo8UCLVRlEpWrIY7WNeijIWqIES+GBVr2yMOmKpXPZjegwgqkU9mamoyYkhLWg4npk7Qp0phQgrrdDkoqxe42Y5eGKGDYVVQ2NKqcsCFeEc3A8TiVew+U9MQRrIy1JzDnKy3xD0lECKABkWS8b4EuoMVXUxVqg8MVWsKYqs64oSjU7NZ4XUitRhGyCHzv5o0v6vcuQuxOZuKVhqkxQLxFMvay4V74ELhhUqwIwIX4qqYFbocCr8VQdxH3xSEvIpiyW4qi4LgxkVO2SBa5wtOoboMBQ5NxpRpWM7A9caQDSKS8ZR1wcKRkKr9dPc4OBsGYtNdE98eBl45QE93xBPLDwJ8Ylj11eM5IrhqmyMiUrZyciz4lhbBSQWudMFMxJeJyO+RpmMhb9c+OCmfjKZmJyJCfFKkZD44KRxlYWxpjbsWLsVdirsCrTilrFXYEuxV2KC1iho4ErcKXYFaxQ7FVmKWsCtEYqtxVaRilacCrMVWkYpWYoaOKVpxUrSMVW4EuxV2JVo4ELaYUtYq7FXYFdirsVdirsVdirsVdirsVdirsVdirsVdirsVdireKV+KHYq3ilcMVK7FQuGBV2FV4wKuGKVwwKuwpXDAtLwMU0vGK0vGK0uxWl4xRS4dcU0qDFFLxhWl+KKbrhVsYVRlvCZGAp1yQDAlnOk6UKB2XIyk1lntnDHGAAAKZUSxT+I7ZWyRSnFVcdsUUqAYpWPGCOmKEruLYMCQMbVjs8PFjtlgKEqmXicmEICUAqRkwhjF4ACcuihLa75NC8HFCqGxVNNMjMtxGOu+Qmdkh9B6Bb+nbR7U2GYR5t4ZJiydTArsCtjrilsjChYRXAlYRTCgqco5IRTCh4150tKlnpmRhLVMPJJVCkjMtpUcVX4ULlwFKoMCqy4EL8VccVUpRVd8UpYwocWSmRgSpnFV6Tsh2OTBYShaLW9PfJAtJxIhbxT1OStrOMua9WvXphtj4ZU5NRFKDG2QxFK5btnJ3yJk3xx0hS9e+RtspbXFNNE4FWnFkFuApWkk5FK0nIlkGsCWwK4quwK7FXYq7ArsCuxVqmFLVMC20cVaxQtOKQ1ilrFDWBXYqtOKXYq0cCrMVaxKrcUrDgVbiqwimKtYpWHFWsULcDJrFXYlWsCGjhVbil2KuwK7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FW8Ur8UOxVcBXAleBgtNLgpx4k0vCHBxLwrghwcSeFfwOPEvC3xOHiTwrgpx4mQgqBciZNow2vC4ONmMCoEwcbL8uqiKuDxFOnVRAfDI+KGBwqgtmPbB4wY+EqC0fwwfmAnwSqCzfwwfmAvglWWyfwwfmQnwCqfUm8MH5oJ/Lla1qwyyOoBYHCQoNEy9svjMFqMCGkQk5aC1EMj0uANIu2SJaZPSLSMJGoAyglinMC9MiVTqKlBkUotBiqIXFV4xS31wIUpEBBwqxy+QKTkgxLHZwCCcsCEqlIAOWBDFr1hyOXRQlVd8mheDihcGOFWVeXVDXUfzGU5eTKL6F0wAQJTwzDbwmdcUuWpxVUpirXHFLZG2KrMCrDhVaehwsXm3nGIGFjTLcR3a5vCbkUkb55nBoKGpviq8U74ULsCqgpiqsuRVcMVX4FUZRscKUsfqcDIKRxVYwxSot3wqp4qtJI6YbWlhY42vCsLE42mluC007G1p3L3w2incsbWltcBKaawWmmsiyapgKt0wK3il2KuxV2KuxV2BXY0rsVdgVacUrcVdihaRilacVLsCtYqtxS7FWsCrDirWKrTilo4FWHFVpGKrMVWkYEtYVWnAq3FLsVawIWnCrWKXYlXYFdirsVdirsVdirsVdirsVdirsVdirsVdirsVdiq6mBK4Y2tLwMjaaVAMBLKlUDpkUqgXBaqgUZG2S8KMFpX8RgtkG+ONsgHEY23RC3fDbfFcoORJbAUQik5ElNoyNMqkVtHxxDvlMpMCQjkhXwyoyRsikgXwysySKRC26+GQM0ikQtuPDIGbMUri2U9sichZ0FrWSkdMIzELwAoGXTx4ZlYtVTRPBaCNnxPTNrhziTgZcNMh0m2owJHTMkycKUaZtAuwytgmcWBCZxnpkVRyNtgSrqcUK3TCl1cVaY1GLFj2orsTkgpYnOxFRloYJFdTBFO++WxCGJ3EvJzlwCELy3ySrw304oVARirJvL8oS6jqe4ynKNmUX0NpcgeBKHsMw24JpXFKqpxSvPTFXCuKt4qpnpilS5DFDiRxOFXmXnG5VYmWuW4hu0zLw25asjH3zODSha4VXYoXb4qqrgVVB8Miq4HFWi2KrZH+HFIS5j1xZBTIwJWYqosMVU8UrDiqlilZhS7Iq0cUrcVdirsCXYq6hxVuhwK7FLWCldirsVdirsVdirsVdirsVdgVaRilbgQ1iq3FLRxVacCtYUuwFWsVWnAhrFLRGKrMVWnFK3AqwimKtHFKw4FWnFVuKXYq7Aq04ULcUuxV2BXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FW8UrxgVeuRKVQYCleMBVUGRKVUDIqqDAlUHjkUqgwMg3TFmC6mLaC1xxttBVFTIks+JFImVkrxI2NcrkUcSOjGVFbRsYykotGoBlZW0Wq5WSyBV1UZAlmCrrQZAswVYAZFsBcYwwxEqbAh2tlJ6ZnafPRacuOwmNjDwPTNxDJYdTmx0nkbUplrhkJhG3Q4WKPhfAhMUbAlFIcVVuQxVaW8MULXO3vihKL6nA1whWFXjheR7ZfFgwTUrz4mAOZEQqQm4qdzk1pwlB74opcJRXriil/rDthWkx0279OdGr0ORkLCh9D+W75ZraP4uwzBmKLdEsxG9DXIslVSOlcUqnLbFWw2KrWYYqplsVUupwIQ15OsELEnoMkEEvB/N2qiWV1DdCcy8UWmRedeqHJ8cyGt2FDYOKrgcVX1OBC9ScUqwyKtnxxVBSvuRiyCHrgZNYqpnFVNu+BKieuFVpxVSIwJWkYUtUwJprFWiMVaocVbpgSu4+2FFr+GKu4YFtrjiqwrgStIwJaxV2KuxV2KuxVvFW+2BWiMVW4qtOKtYFWnFK04qWsCrcKXYFaxQ1gVbilrFVhxVo4FWYpWtiq3FVpwJW4lVpxS1irsCtYULMUuxKuwK7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FW8UhsYFXjAkLxgVeMCV4wKqDIlKoMBVVGRKqgwFkvGRKQv/AI4GYbxZgrgMDYCqqMiWVolO2QKbRaZUVtFIcgUo6PKpIRsZyoqi0NRlRSiVyBZAqy5EtgKqMi2AqgyJbQVQAZKBosjujoABm4089nBzwRYObGJdTkjRR0TZNpRsbe+BCOjk8cVRiSdsCVbl74q4PihY7jFCSajOqRmpycQgvN9V1AKGCnMmEWLA7iYyMSTXLkoMmmKVvL3xQuDYquDYUImJyrAg7jCh6d5W130GSN2oOmY+WDIGnt1hfx3EakMDUZi8mwFNKjxwpbD4ErwQcVabfFVOhwK0zBQSe2FDAvM+rrDDIobehyzHGy1yL581W9aeZyTWpzOAoNSSrKVbrhVHpKGHXJMSvrihegJO2Ko+K2kkpRScgZLSd22hXEwBCHKjlAZAI5vLlworxOR8YLwpPd6fPbggodsmJgrTH5EYHcZO0hSxStOKrcCVM9MVUmxStOKFM4pW4pWmmKWsVdirgMVVAuKFQLiq/jih3HFWiuKVMrgVSZcWSmdsilqoxV1RirqjFXVxV2BXY2rsVdgVacVW4q1ilZirWBWjiq3FLWKGjgVrClrIqsPXCrWBVmKVpxVbiq04ErcVaOKrcUuwK1ihZhS7Eq7ArsVdirsVdirsVdirsVdirsVdirsVdirsVbGKQuGBV464ErsCrxgVUHTIqvGApXjrgKVQYCqoDkUqgwJC8fqyLMLxgZBeMDMFVXIlkCrpkSytEocrKUVGcgUo2M9MqkhGocqIVFIcrKUWh7ZWUq6nIFmCqA4G0FepwFtBVlORZhFRPQ0zP002rLGwjOQPTNzjLp88aV45PfLnDKPR9hviquslO+KFdZTjSFb6waYKW2xPhpbUpboKpNcQEWwbWNSLFgG2zIhFiS88vrguxFcvCgJOzdcLJRJwJaBwoXjFCoMQhVBphQj7a4aFgymlMSLV6d5e8ymLjHI+3vmPkxsgXq1jrEE6j94N8xyKZgp1HKj7hq4GSLUDxxZKo4+OFVN3jUVqMCpNe3S8GCnfAi3j3mWK4uGcrUjMjFIBgY28mvLeWN25A5lAtZilTAjJIXxyFTixITS35TEKBXHiRTNdK0CS44sy0ByieWkgM/sfL8EQHJQSMxzkJTTI4bSGEABRQZXaVYpGduIxVL7vS7a5U8kG+ESIVguqeVhRnhGXRyoefXlhLbMQykUzIErVLCKYUrDiqw4qpnFKzFVhxVZilaRilrFXYqqKuKFdVxQqhMKrwmNIXcMaVaY8VUmTAm1BlxSEOwyJZBRwJaxV2Kt4pbrgV1cVdXFWicCGsVdirWKVhxQ1gS0cVW4q1iq3AlrFWj0wKswlXYFWYpWnpihbilo4ErMVaOKrcUuwK1ihacKWsSrsCuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KqgwJbwJX4FXjpgVeOmAqvGAqvGBKoD3yKVQHAkLwdq5FK8HAyC8HAyCoMDMKqnIlkFZTTIFkiFPTIlKJQ9MrKUZG2VSCEYjZWQqLRsrISikbKyEhXDZCmYVQ2CmyJXhsFNoKorZEhmFQSUy7DKimQsKi3IHU5vMBsOq1MUXDOGPXMunWlMUnHSuNMVdZK4oKuJPfFC8SeONK5pQB1xVItR1BY0Yct8sjFDzy/v8Amzb1zJiKRTHZJCxJwskOT2xSpnFXDFV4xQV4woVAcUKqnphVGQzPGQVNDiUM10W+vC6BWPGuUZAGcQ9a0++kWNeZ3pmKWxORqtB1wWm2zqtRscbW0FLqLMTQ4oS2admrviqXSxpMCGANcIKGJ6toUcqO6Lvvl0clJ5vKdQsmt5GUilDmTGVtRCCghMjhQOpyRLF6X5f0GoSWRduuY+TItPTrSCOJAqACmY5KpkDTpgVcXoN8UrFauBVStRTCqmVDVBFa4qxXW9HhuIndVHKmWQnSCHjl/bNbzMhFKHMoG0BLSckyUycVUycCrDhStOKFmBLRwpW1xW1wFcVRKLihFJGThYogR4qv4EYoWEYqsIpiqwjClQdK4FtAyCmRLMIU5FmFuBXYq3XFW64q6uBXVxV1cVp1cVarirROKtYoawJWk4pW4oWk4EtYq0TihaTilrArjiqw4pWnFQtxVacCVuKtHFVuKXYFaxQtOFWsSl2BXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FVQZFIbxSuGAqvHXAVXg0wKvwKvwJXg9sBSqA5EqvB/HAyXg4ErxgZBeDgZhVByJZKqnIlIV1OQIZIlDkCqMjbfKiFRatlZCopGyBCUUjZWQlXVsgQyCoGwU2BdzwU2hVV8iQ2BpnoMMRuyQE1xxB3zdaU26/Uh1tqHE0J2zacLqJc09hvkanxZEhij0u18cFIRSXSE/aGNIbkv4kG7YgKkV7riKpCtlkYKwu91OSYn4sujGlpI3kLHc4U0oE1wqtOBVmKWxihcDhQuBxVUGKFVThQi7dObqvicSUh6todgqQq5G/XMPJKy2hk6twoOmVqq8qjrgVsMR32wKtLHFVpauFVgYDbFWpKFSOtcKHnPmXTx8Uir1zIxSQQxrRrP1btBTvlszQYU9usoEigRQKGmYZKCjF+HAhWSTxxZNk8sCtA0IxVWJ2xVS9Qg4VQ0x5AjqDih5Z5oshHIZAKVzKxFiwBjQkZcyUycCrDiqwmmKVpOKrCaYqtxV2KVaNanFUfGmFijUSmKEQExQvCCmC00pNEfDDaaUGjIxtPCoMpGG0UotihBzrsSMBZBLWNDkC2BTrgTTYPvirq4q3XFW64FbwLTdMU06mNrTWNoaxVrFC3FLRxQsJwK1ilo4oWk4pawK7FVhOKWsULTilrAlacQq3Eq0cVW4pdgVrFC04VaxKXYFdirsVdirsVdirsVdirsVdirsVdirsVdirsVXrgKV2BLYNMVXYFXjAqoDXIq2DileDgKVQHvkVXg4CleD3wMl4OBkFwOBkFQNgIZBWByJZKynIFKJRsgQlFRtlZCEWjZWQqJRsrISiUbIEJVg+RpmFQPgpsDYfBTaFVZNsiQzClLLQZKMUkpHd3FK75uNJF12oklq3BBrXNqHWyRkd+yftYaYEItNVcftY8LFU/S8n82PAikNLqcr1+I4RFaSyW4Z+pySaQjPXFKmTXFWq4FWk4VW4q6uKFwOKrhhVUBxQqqcUJ1pUXqToPfIzOyYvYrFfTgRfbMMtiuzZFV6Ntilr1DywKq8q4pUy2+KFjeOFW+VRhQkWuRCS2Y07ZZA7qWMeX7f8A0utOhyzIdmt6iCFUDwGUIcj8iRgULyaYFaDnxxSuEm4wKrc9sKqRbChTLYqwzzRCWgLU6ZdiLEvI5dmYZkpCiTilYTiqwnFVuKrD1xVrFVyjFKKjGKEyiXCxRyjAquq1wWyEbVliOQMm6OIqyw16jIGbkRwNNbA9sHiNv5dBS2nWgyYm1y06Vywla5YJOPLFSXzA0yVtXDSUSbMcgWQUsDJ2C1dirYxWlVVJyJLOMbRKxe2Q4m6OJVEPtg420YXGA+GPGg4EO0ZHbJCTRLFSgwIyTSYrMKGsCrScULcUtE4oW1xS1gV2KrCa4q1irROKVuKuwJWHCrWBWjiq3EpdgVrFC04VaxKXYFdirsVdirsVdirsVdirsVdirsVdirsVdirsVbBwJVMCuxSuBwKvB7YFXg4FXYFXA4pVAcilcDgKV4OBkG64sguDYKZBeGwUyCsrZEhkrq2QIVXVsgQlFI2QIVFo2VkKiEbKyFRCvkSGQVA+RpmF/qYKbA2HwU2hf6lB1wcKbQc9xQHfLseOywnJj9xNyY75usEKDq807KGDZlBxi4ydq4QxLYc+OSQvDnxxQ0X98VWFsVW8hirVcUtVxQ1irROKtVxRTYOFV1cVXg+GKqqnChlfl9Q06V8cryckxepo3FVHtmKzbrXvgSqoduuBLVRirgxHfArRavfFVoc9MKHcsKoLUCGt2B8MlHmgpJoaATuffJzYM25bUyti5GocCqhavfAlTqelcVbUmu+KVflt1xVQaQ9jhQp+pXvihI9eIe1f5Zbj5oLxi52lb55lKEKTgSsJxVYThStqcCrScVaHXFVZcKoqLqMUJpF0xQjUUnIksoxtHxRVAyqUnNxYkasW2UmTnQwqgSmRMnIjiboMjbaIKToDhEkHECl1xbhgSMtjNx56dILmClcujNwMmCmOzoVbJW4xjSEJOLFqpxVcDgUBWRakZElthG0dHHlcpOZjxIxUGUmTlwxKwUZAybhjXccHEnwwovHXtk4zaJ4EDJDlom4OTDSCdSMtBcSUKUTha1uKtE4qtxVrArROKVpxVrFDROKVuKuwJWk4qtxV2BVpwq1gS7FWsULThS1gV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxVeDgVdgS2OuKV2BV4wKvBwK2DgSvBwJXg4Et1xZBvlgpkGueGmYbD4KZ0ro+RIWkSre+VkKrq2RIVEK/vkCEolHyshUSrjIEKqiTI8LILxJ74OFsC71R44OFmG/WAHXHhZWoPcjxyQgxM0tuLrYgHM3BhcbLkStpamtc2MRThSNrPUybAuD4WKoHwoXcsVb5Yoarirq4rTeFDROKra4q1irVRirdcVXA4oXA4VVFOKGU6DLxnT55DJySHqKvVFNe2YrY4SYFVkkwJcZN8Vb5DAq0sBhVS9ShxVv1K4UIS8kAhavhko80FItJnAuGFepycgwLM1m2ytDhJuMVVfU2wJa9TvgVsSjFWzNXbCqmXxQpM2/hhVjmvz8LdhXtluMMS8mnarsffMhIQ5OKVtcVWnFVtcVpbgS4HCqsuKEXF1woTSI4CoCZQCpGVSLlYYWmkaimY8i7XFjpEA0yslyohxOBspYWxVaW2wpUHIIwrVpRcoDXJCTXkxWGMXsVCcvjJ1ebFSTttlgcEhbXCxVFFcjbOIR8SdMqkXMxQR6KMolJ2EMasKDKy3xC6oyLNquKLcWxQVJhXtkwWicAUDNH1y+MnAy40uYUOXAuBONKZOFgtxVquBVtcUtYq1ihaTilrFXYFaJxSswodgS0Tiq3FLsCuxVrFDRwqtwJdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVbGKrq4Et1wKuBxSuBwJXVwKurgSur740q7lgpLfLGmQWlsaZhqtcNNgbBwMgqK1MBDJEI+QIRSJVxlZCFdZB45ExW1QTgd8jwLaoLkDvg4E2vF0PHB4aRILvrQ8cHhp4m/rQHfHw08ak95QdclHExORBSXhNRXL4YWmWRBtOWzLjGnHlK1PmTk2LYbCxVA2FCoDhQuDYoXVOFDYOKrq4q7FbaxQ6uKrScVW4Vbriq4YoXA4qvBwqm+m3HpTKa98jLkr1G1ufVgUg9sxZCmYRKvkUqwenfAloyb9cVXept1xVSMtO+KrDJt1rhVYkprucUJVrF6EiKhstgGJLFtNvuFzUnqcskGD0i3nWWNWB6jKCFVeZrSuBVT1PfFLXqe+BWhJTvirQl364obMwUVJ2wqoSXC05BsNKwHX9R9QlA1RmRAMGEs1ScsZLa4E0sJxVaTilrFVpOKtqcVVlOFCLjPTFCZQGtMjItkI2U5hFAMokXZYMaPRqZQXYRC4vgbWi/vilby98UlaW264otQZvfFkEBM3XAW0bpDditcshJwtRBIJRQ5lRLpckaKhha0VEOmQJbscUxiA2yiZdjhgiwRTKCXOAcWwKdm64FtbUYqXVwsbWljhDAlSfcZOJaMgtLZh1zIiXW5YoQ5Nxitriq3FWsUNVxStxV2KuwJWk4oW4VdgS7FVpxS1gV2KtYodhVbilrArsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirdcUt1wK3XGlXcvfBSbbDY0tt8jjS27kcaTbuRxpbbDYaZCS7ljTIZG+WDhZeIuDY8KfFXh6YOBHirhKRg8NByLhMfHB4aON3rHxx8NeNr1m8cPAjjbEreOPAF413rt44PDCeN3rt44+GF4ysMhPfJiAYmSzkclTG3VwoXA4ULgcKF4OFCoDiqoDhYrgcVXYqurhQ3ihquKVtcVarihquKuriq6uFWwcULgaYqrRuVYEYqzjR9UAURucpnFILLFlDAFTlNMwv9XArQmBOKV/q4qoSPirSy7b4qpyTKiFq0wgIJYNqt6ZHYV2zIiKaykkcxVwwOTQzjSNXoojZsplFWWRzq45A1ytVxm3pgS16uKuMoxpVgkpihBahM/p/B1GTigsdOpSLG6u1DlnChh15cGWRiTXLQkIAnFLRbAlbXFWq4VpaTgStrihtTvhSqqd8UI1DsMKEwtzuMrkXIxRTuJhQZjyLtcQ2RIfK3JDfPAztYXxS1zxW1rPhQCos+BmCl874C2RKVzGoOCHNrziwklwN8zIOjzjdC98m44RsI2GVyLl4gj0zHkXZYwrchlTeCsLYWJLgcCLdyxW2uWKCWi2FgVhbJBrkgpt8vi4OUIBuuWuGVuLFaTihquKWsVdgtWicUrSa4q1jauxVrFWsUtYFdirWKHYq0cKrcCXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FLeKt1xVsHFDeKt1xTbsVbwq6uKbbBxVfXFXYrbeBXYpdirsVbqcVdU4obrirq4UN4q2DhVeDhQvBxVeDhQqA4oX4ULgcUN1xVuuKtVxVquKra4VaxQ7G1bBpiq6uKrq4quBxQiYLho2BBpirMNO1jYK7ZVKKQU/FysgqGG+VUyBXiSnfAlcJvfFW2kqOuKoKW6WLcthAUlIr3VaqVU5bGLAli00xdiScsQh+WFUVBctGwINKYFplun6zxAV2yuUUJ/HqEcu/IZAxVFCZSNmyKqL3ABpXGkqv1hFWpYYgKlV5qkSowBBOWCDEsGu7wu7FTscuAUBLGap3OLJbX3xVquKtVwJWk4VarirWKtVxVUU4VRaNihMrdsqm5mAJtG9BlBdnBXEnvkW0N+p75FmGi2KWue2FiVNpMKAVB5NuuBlaXyyVJ3yMmyJQkh2wR5oynZKbjrmVB02dBA75Y4wR8JplU3Nwo0NtlBdhFdXIs7UycLAlwOAqC0Tigl3LGkW1yxpja0tkgwKGlOWxcTKgXO+Whw5KeFg1irsCVpOKtVOFDWBXYpdgVquFWsUtYFdirWKHYq7FVpOKtYpdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVbxS7FW8Ktg4EN4q7FW8Kt4pdirYxSvxQ7FW8CXYq1irsUOwq7FXYpXA4obriq8YULgaYULwcVVAcKF4OKrq4obxV2FXYq1XFDVcVarirq4q3UYq3XChuuKt8sVb5YqqpMyGoOBUzg1SSOg5YDFU1i1io+I5AwW1b9LgdDg4FtY+s/DQHDwraUXGoPJXfJAKlrTFupwqo88KtFsVa5YqqrMy9DhRSNi1CRP2jgpaTOPWXUfayPCha2sOTWuPCqjJq8jCgY4RFaSuS6dyatklpDlq98U01XFNOrgV1cUNE4paxVquKVhOKtVxVcrYoV1emFUyt5MhJycJTRJNsxy7OBVQ+RLaC36mBkC2JMV4lplHjhQSomXCgFQkkyLYEGWqciWQKk7bHGIa8ktkqnbc5lRdXlKE75NxgjYjsMqk5mIowNlBDnRk4vgplxLS2GmJLuWAhILRbBSCVvLDTC3chhQStLDDTAlDyNlkXGyFBtlriyW4sVpOKtVwq1gV2KuwK0ThVrFLWBXYq7FWsUOxV2KrScVaxS7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq3il2Kt4VbBwIbxV2Kt4VbxS7FV4wK7FXYpbwK1hQ7FXYq6uFW8Vdiq4YUN4qvGKF4wqqA4oXA4VXVxQuriruWKtcsVarirsVWk4odXCrq4q3XFDfLFW+WKXcsVdyxQ7lirYkI74qu9U+OBLRlPjirXP3xVaXwq1yxVrlitOritO5Yq7lihvmcVdz98Vb5e+K01XG1pvkcVb5YEurirq4rTq4rTVcUrScUNVxWmq4parhQvDYqioZaHrgLZA0U1imqMokHYY5IgSZCnIBb9T3xZWsaXEMZFSMxPfDTESaMmBmCos+RLYCpF8FJMkNJJlkYuLlml8rVOXBwJlQrvkmpERNkJBycUkWG2ykhzYyaLY0xM2g1cFKJLq5FmC1ywKS1XJUwMltcUWtLZIMJSQ7tlgcaZQ5OTaCtwoaxQ7Al2BWq4VarilrArsVdirWKLdirsVdiq0nFWsUuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2EK3ilcDgVvFDsVbxS3hV1cUt1wK3XFW64q6uKtVxVbXCh1cVXYEOwq2Diq/Cq4YoXg4VXg4oX4quBxVuoxQ6oxVquKtcsKtVxV2KtVxVuuKHVxV1cVdXFXVxV1cVdXFWq++Ktchil3IYq7liruWKtcsVdXFFOritOritOritOritOritN1xVuuKt1xVuuK06uKt8sCXcsULa4VaxS6oxVaTirWNq6uKrw1MUhGRTU75CQcjHNGrNXvlRDmRmqep74Gy1heuKlYWxtiAtL4GYKmXyLLiU2fCA1ymhJHy4Bw5zQrHJuOSpYUKiNTIkM4mkUsgplZDlQmuJrkWZaBxKQ3XIllbROBSWuR8ckGJLXLDTElTZ8kA1SkoMcm0SKyuFraxV2KtVxVquKWsbV2BXYq1ih2KuxVquFWq4rTq4EtYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYVbxSuHTAhvFXYpbxV2Kt4q6uKW8UuxQ0cVLsKHYq7FVwxQ7FVwOFC/FK6uKF4OKFwOFVwOKt1xVquKurihqoxWnVxVqpxVrCrsVdXFXVOKurirqnFXYq1X3xVrlgVrlirq4q6pxV1Tirq4q6pxV1TirqnFXcjhV3I4q3yxVuoxVvFXVOKt8sCrq4q6uKurirROKra4q1irq4q1XFLVcKHVxSvDUwJBpEJL75AhvhNECXIEOTHIu5++RplxrS4xpPEtL40vGpGTGkGaiz5MBonNDs2TDRIqZNcLBbXFDq4ra9XyJDZGVK4fIkN4mu5ZGmfE7lkaTxO5Y0pkt5ZIBgZLS2GmJkpM2SAajJSLZKmstVxQ6uKuxS1jauwK7FWsUW7FXYq7FWq4VW4pdgV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2FVwOKrsCuxV2Kt4pdirsVdgS7Ch2KuxV2Kuwq2Diq7FDeKrgcKFwOKrsULwcVbrirq4q6uKtVxV1cKtVxQ6uKaar74q1XFDq4q6uKuqcVdXFWq4q6uKtVxTTVcVdirsVdirsVdXFXVOKt1xVuuKHVxV2Nq7FW6nFV1cUt1wIdhV2BXYq7FWq4UtVxVrFWq4oarimmqnFW+WKrg2BIK8SUwU2CS/1cFMxN3qYKTxrTJ740vGsMmGmJmpFicLAlbhYrScULa4q7G0uxVsMRgZCS/mfHBTISXB8FMuJ3PGl4mi5xpBksLHDTElbXCxtrG0OxtXYFdirsVdii2sVdirsVarhVrFLWKuwK7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq3ilvFW64rTeKHYq7FW8UuxV2KuxV2KtYodirsKrge2KrsVbxVcDhQuBxVdXFXYodirsVdirq4q1UYq6uKtVxWnVwq1XAtOrhV1cVdXArVcVarirXLFWq4rTq4VdXFXVxVuuKuriq6uBXYq3htXY2rsVbrirq4EN4q3ilvFXVOKuxVrFXYqtqMVdXFaaxtWsbV2Nq6uKuril1cVa5YpdU4q1XAttYq6uKFtcVaxS1irsVdirsVdgtW64VdXAm2q4odirsVdirsVdirVcUW7FXYq7FWq4VarirWKXYFdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVbxS3XFW64q3ih2KuxVvFLWKHYq7FXYq7FXYVXg4obxS3irYOKG8Kt4q6uKuqcVdirWKHYq7FXYq7FXVHjirq4q1XFWqnFWq4q1irsVdil1cVdih2KuxV2Kt1xVsHFW8UOxTbeKuxV2Kt1xV1cVpuuKu5Yq6uKuqcVarirWKuxV2KrS3hirVcVdirsUuriturituxW2icCra4q7FLWKuxV1cUNVxV2BXYq7FXYrbsVt2KuxV2KuxW3Yq7FXYq7FWq4VarirWKXYFdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVbxS7FXYq3irdcVpvFDsVdirsVdirsVdirsKt4q7FC6uKt1xVuuKW64op1cVp1cVpquKurirVcKurgVrCrsUOxV2KuxV2KuwJarirVcUtYq7FW8Ktg4EN4UOxV2KuxVeK4rTdMVpdxPhgV3E4VW4q7FXYq7Al2KuxV2KuxVquKtVxVomuFWsUOxV2KurgS1UYq6uKtVxV2KWsVdirsVawIdirsVdhVrFW8Cuwq1UYq7FXVxVvFWq4q3gV2FWq4q1ilrG1dgV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kt4pdirsVdirsVbritOwq2K4FbxQ2ATiq7jiruOKtUwqtxVvFW64obrirdcVaxtXY2rsVdirsbV2Nq7FXY2rsVdjaurirROKtYpaxV2KuxV2KuxV2Ktg4oXYq7Cq9VrgVEJFXrgtUQsQwWlf6a4q4xrTFUO8XhhtCHKkYVWE0xVquKurirq4q1il2KtYodhQ7FXYLS0TirVcVdilrFXYq7FXYq6uBDWKuxV2KtVwq6uKtbeGKXVxV1cVaxV2KuxVvFXYq1irdcVaxV2BXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq3XFNuxV2KtYodXFbbwpXgYELwKYqvBHhirdR44q3gVaRhVYRiqzFXYq7DauxV2Kt4q6uKurirsVaxVvFXYq6pxV1cUNYpdirsVdjauxtXYq7G1dirsVdiq4YoVUWpxVFIgGBKsNumBV9ffFXV98UOr74paPzxVRdQcKoR1phQpYq7FXYq7FXYq7FWq4q1U4pdXFWsVdirsVdjauxQ1XFXYFdirsVarhVquKuxS1irsVdirsVdirsVdirsVdjauwWrsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVXgYquA74FX4q2CMVbqMVbpirRqMKrcVWHFWsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirWKHYq7FXYq7FW8UuwquXFUWm2BVYH3wK3y98NK7l74q7l74q7n74q7l74q0W98CqD74VQx2woaqMVarirq4pdXFXYq1irsVdirq4ENYVdirsCuxV2KuxVo4VaxS1irsVdirsVdirsVdgV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2KuxV2Kqg98VX1GBW8VdirsVdirqnxxV2KrT8sKrcVaqMKGqjFW8CuxV2KuxV2KuxV2Kuritt4pdirsVaxQ7FXYq7FXYq7FXYq7FW8Ur0xVEqfbAq7l7YVdy9sVdy9sVdy9sVdy9sVdy9sVdy9sVWsfbFUM2KFmG0uxtXYFdirsVdirVcUW6uK27FXYq7FXYq1UYVaOKtYpdirsbV2Nq7ArsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVcOuKqmKuxV3TFV3L2wUruXtjSurjSt1rireKtHpiqzCqzCrWKuxtXYFdhVupxV1TirqnFXVxQ3XFadXFadXFadXFadUYq6oxV22BVuFLsVb28cVbxQ3gV2Kqi4pVqnFXVOKuqcVdU4q6pxV1TirqnFXVOKtEnFVFq4qtxVrFDsVdirsVdirsVdiq04UtYq7FXYq7FXY2rsbV2Nq7ArsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVbHXFV+KuxV2KuxV2KuxV2KuxV2KtE0xVZirsVdirsVdirsKuxV2KuxV2KuxV2KuxV2KuxKuwK7FXYq7CFbxVrFWx1xVUHUYFX4q7FXYq7FXYq7FXYq7FXYqsPU4qtxQtOFXYpdirsVdirWBXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq3yOKt8sVbrirqjxxV1R44q6o8cVbxV2KrWxVbirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsNq7G1djar1P4YFX8sVdyOKu5HFXcsVdyOKu5e2Ku5Yq7liruWKrCcVW1xRTWNpdhtXY2rsbV2BXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXdMVb5HFWsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVdirsVbHXFV+KuxV2KuxV2KuxV2KuxV2KrD1xVrFXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FXYq7FX//2Q=="
+    Base64.decode64(encoded_contents)
+  end
+end

data/spec/support/fake_sms.rb

@@ -0,0 +1,18 @@
+# Fake Twilio
+class FakeSMS
+  Message = Struct.new(:from, :to, :body)
+
+  cattr_accessor :messages
+  self.messages = []
+
+  def initialize(_account_sid = ENV['TWILIO_ACCOUNT_SID'], _auth_token = ENV['TWILIO_AUTH_TOKEN'])
+  end
+
+  def messages
+    self
+  end
+
+  def create(from:, to:, body:)
+    self.class.messages << Message.new(from: from, to: to, body: body)
+  end
+end

data/spec/to_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Twilivery::DeliveryMethod do
+
+  before(:each) do
+    @delivery_method = Twilivery::DeliveryMethod.new
+  end
+
+  context "To" do
+    it "handles one recipient" do
+      test_email = Mailer.test_email(to: '+18131234567')
+      @delivery_method.deliver!(test_email)
+
+      expect(@delivery_method.message[:to]).to eq(['+18131234567'])
+    end
+
+    it "handles multiple recipients" do
+      test_email = Mailer.test_email(to: ['+18131234567', '+18131234568'])
+      @delivery_method.deliver!(test_email)
+
+      expect(@delivery_method.message[:to]).to eq(['+18131234567', '+18131234568'])
+    end
+
+    it "transforms numbers to E.164 format" do
+      test_email = Mailer.test_email(to: '813478-4567')
+      @delivery_method.deliver!(test_email)
+
+      expect(@delivery_method.message[:to]).to eq(['+18134784567'])
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: twilivery
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Jesse Curry
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-05 00:00:00.000000000 Z
+date: 2016-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -45,33 +45,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 4.11.1
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: phony_rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.4.0
-  type: :development
+        version: '0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.4.0
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: webmock
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.24.2
+        version: 3.4.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.24.2
+        version: 3.4.0
 description: Delivery Method for Rails ActionMailer to send SMS messages using the
   Twilio API
 email:
@@ -87,6 +87,12 @@ files:
 - lib/twilivery/exceptions.rb
 - lib/twilivery/railtie.rb
 - lib/twilivery/version.rb
+- spec/bcc_spec.rb
+- spec/cc_spec.rb
+- spec/from_spec.rb
+- spec/spec_helper.rb
+- spec/support/fake_sms.rb
+- spec/to_spec.rb
 homepage: https://github.com/jessecurry/twilivery
 licenses:
 - MIT
@@ -107,8 +113,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Twilivery for Rails
-test_files: []
+test_files:
+- spec/bcc_spec.rb
+- spec/cc_spec.rb
+- spec/from_spec.rb
+- spec/spec_helper.rb
+- spec/support/fake_sms.rb
+- spec/to_spec.rb