From a06ac3a0d8f5e9da99107803586533503a11f60a Mon Sep 17 00:00:00 2001
From: Joe Fernandez
Date: Fri, 15 May 2015 15:42:17 -0700
Subject: [PATCH] docs: M Preview Content Sync #1
This change list is a snapshot of work in progress on other change
lists. If you have conflicts with this change, you should prefer your
own changes over what is contained in this change.
Change-Id: Ied44713d5078c938fab10d29a3b6e720559144b4
---
docs/html/preview/api-changes.jd | 338 ++++++++++++++++
docs/html/preview/api-overview.jd | 364 +++++++++++++++---
docs/html/preview/backup/index.jd | 300 +++++++++++++++
.../preview/features/runtime-permissions.jd | 352 +++++++++++++++++
.../preview/images/direct-share-screen.png | Bin 0 -> 57902 bytes
.../preview/images/direct-share-screen_2x.png | Bin 0 -> 180763 bytes
.../preview/images/fingerprint-screen.png | Bin 0 -> 250462 bytes
.../preview/images/fingerprint-screen_2x.png | Bin 0 -> 1073873 bytes
docs/html/preview/images/text-selection.gif | Bin 0 -> 212462 bytes
docs/html/preview/preview_toc.cs | 24 ++
docs/html/preview/samples.jd | 69 +++-
docs/html/preview/setup-sdk.jd | 60 ++-
12 files changed, 1417 insertions(+), 90 deletions(-)
create mode 100644 docs/html/preview/api-changes.jd
create mode 100644 docs/html/preview/backup/index.jd
create mode 100644 docs/html/preview/features/runtime-permissions.jd
create mode 100644 docs/html/preview/images/direct-share-screen.png
create mode 100644 docs/html/preview/images/direct-share-screen_2x.png
create mode 100644 docs/html/preview/images/fingerprint-screen.png
create mode 100644 docs/html/preview/images/fingerprint-screen_2x.png
create mode 100644 docs/html/preview/images/text-selection.gif
diff --git a/docs/html/preview/api-changes.jd b/docs/html/preview/api-changes.jd
new file mode 100644
index 0000000000000..e4be2a1d2d3b2
--- /dev/null
+++ b/docs/html/preview/api-changes.jd
@@ -0,0 +1,338 @@
+page.title=Behavior Changes
+page.keywords=preview,sdk,compatibility
+sdk.platform.apiLevel=23
+@jd:body
+
+
+
+API Level: M
+Along with new features and capabilities, M includes a variety of
+system changes and API behavior changes. This document highlights
+some of the key changes that you should be understand and account for in your apps.
+
+If you have previously published an app for Android, be aware that your app
+ might be affected by these changes in M.
+
+Runtime Permissions
+
This release introduces a new runtime permissions model, where users can now directly manage
+their app permissions at runtime. This model gives users improved visibility and control over
+permissions, while streamlining the installation and auto-update processes for app developers.
+Users can set permissions on or off for all apps running on Android M. However, apps that don’t
+target M cannot request permissions at runtime.
+
+On your apps that target M, make sure to check and request for permissions at
+runtime. To determine if your app has been granted a permission, call the
+new {@code Context.checkSelfPermission()} method. To request for a permission, call the new
+{@code Activity.requestPermission()} method.
+
+For more information on supporting the new permissions model in your app, see the
+
+Android M Runtime Permissions guide.
+
+OpenSSL
+Android is moving away from OpenSSL to the
+BoringSSL
+library. If you’re using the Android NDK in your app, don't link against cryptographic libraries
+that are not a part of the NDK API, such as {@code libcrypto.so} and {@code libssl.so}. These
+libraries are not public APIs, and may change or break without notice across releases and devices.
+In addition, you may expose yourself to security vulnerabilities. Instead, modify your
+native code to call the Java cryptography APIs via JNI or to statically link against a
+cryptography library of your choice.
+
+Project Volta
+This release introduces new power-saving optimizations for idle devices and apps.
+
+Doze mode
+If a device is unplugged and not used for up to an hour, it goes into doze mode where
+it attempts to keep the system in a sleep state. In this mode, devices may briefly resume normal
+operations for up to 5 minutes every few hours so that app syncing can occur and the system can
+perform any pending operations.
+
+The following restrictions apply to your apps while in device doze mode:
+
+- Network access is disabled
+- Alarms scheduled with the {@link android.app.AlarmManager} class are disabled, except for
+alarms that you've set with the
+{@link android.app.AlarmManager#setAlarmClock(android.app.AlarmManager.AlarmClockInfo,android.app.PendingIntent) setAlarmClock()}
+method
+- WiFi scans are not performed
+- Syncs and jobs for your sync adapters and {@link android.app.job.JobScheduler} are not
+permitted to run
+
+
+When the system comes out of doze mode, it executes jobs and syncs that are pending.
+
+App standby mode
+In M, the system may determine that apps are idle when they are not in active use by the user.
+Your app goes into app standby mode after two days unless the system detects any of these
+signals:
+
+
+- The app has a process currently in the foreground (either as an activity or foreground service,
+or in use by another activity or foreground service)
+- The app generates a notification that the user can see
+- The user explicitly asks for the app to remain running
+
+
+If the system is running on battery power, apps that are in standby mode will have their
+network access disabled and their syncs and jobs suspended. When the system is plugged into a power
+supply, it brings an app out of standby mode and executes any jobs and syncs that are pending.
+
+Apps that use Google Cloud Messaging will
+continue to receive messages even if they are idle. When the system is plugged into a power
+supply, apps resume normal operations and can run any pending syncs and jobs.
+
+You can test this feature by connecting a device running M to your development machine and
+calling the following commands:
+
+
+$ adb shell am broadcast -a android.os.action.DISCHARGING
+$ adb shell am set-idle <packageName> true
+$ adb shell am set-idle <packageName> false
+$ adb shell am get-idle <packageName>
+
+
+Adoptable Storage Devices
+
+In M, users can adopt external storage devices such as SD cards. Adopting an external storage
+device encrypts and formats the device to behave like internal storage. This feature allows users
+to move both apps and private data of those apps between storage devices. When moving apps, the
+system respects the
+{@code android:installLocation} preference in the manifest.
+
+If your app accesses the following APIs or fields, be aware that the file paths they return
+will dynamically change when the app is moved between internal and external storage devices.
+When building file paths, it is strongly recommended that you always call these APIs dynamically.
+Don’t use hardcoded file paths or persist fully-qualified file paths that were built previously.
+
+
+- {@link android.content.Context} methods:
+
+ - {@link android.content.Context#getFilesDir() getFilesDir()}
+ - {@link android.content.Context#getCacheDir() getCacheDir()}
+ - {@link android.content.Context#getCodeCacheDir() getCodeCacheDir()}
+ - {@link android.content.Context#getDatabasePath(java.lang.String) getDatabasePath()}
+ - {@link android.content.Context#getDir(java.lang.String,int) getDir()}
+ - {@link android.content.Context#getNoBackupFilesDir() getNoBackupFilesDir()}
+ - {@link android.content.Context#getFileStreamPath(java.lang.String) getFileStreamPath()}
+ - {@link android.content.Context#getPackageCodePath() getPackageCodePath()}
+ - {@link android.content.Context#getPackageResourcePath() getPackageResourcePath()}
+
+
+- {@link android.content.pm.ApplicationInfo} fields:
+
+ - {@link android.content.pm.ApplicationInfo#dataDir dataDir}
+ - {@link android.content.pm.ApplicationInfo#sourceDir sourceDir}
+ - {@link android.content.pm.ApplicationInfo#nativeLibraryDir nativeLibraryDir}
+ - {@link android.content.pm.ApplicationInfo#publicSourceDir publicSourceDir}
+ - {@link android.content.pm.ApplicationInfo#splitSourceDirs splitSourceDirs}
+ - {@link android.content.pm.ApplicationInfo#splitPublicSourceDirs splitPublicSourceDirs}
+
+
+
+
+To debug this feature in the developer preview, you can enable adoption of a USB drive that is
+connected to an Android device through a USB On-The-Go (OTG) cable, by running these
+commands:
+
+
+$ adb root
+$ sleep 2
+$ adb shell setprop persist.fw.force_adoptable 1
+$ adb reboot
+
+
+Apache HTTP Client Removal
+This release removes support for the Apache HTTP client. If your app is using this client and
+targets Android 2.3 (API level 9) or higher, use the {@link java.net.HttpURLConnection} class
+instead. This API is more efficient because it reduces network use through transparent compression
+and response caching, and minimizes power consumption. To continue using the Apache HTTP APIs, you
+must first declare the following compile-time dependency in your {@code build.gradle} file:
+
+
+android {
+ compileSdkVersion M
+ useLibrary 'org.apache.http.legacy'
+}
+
+
+AudioManager Changes
+Setting the volume directly or muting specific streams via the {@link android.media.AudioManager}
+class is no longer supported. The {@link android.media.AudioManager#setStreamSolo(int,boolean)
+setStreamSolo()} method is deprecated, and you should call the
+{@code AudioManager.requestAudioFocus()} method instead. Similarly, the
+{@link android.media.AudioManager#setStreamMute(int,boolean) setStreamMute()} method is
+deprecated; instead, call the {@code AudioManager.adjustStreamVolume()} method
+and pass in the direction value {@code ADJUST_MUTE} or {@code ADJUST_UNMUTE}.
+
+Text Selection
+
+
+
+When users selects text in your app, you can now display text selection actions such as
+Cut, Copy, and Paste in a
+floating toolbar. The user interaction implementation is similar to that
+for the contextual action bar, as described in
+
+Enabling the contextual action mode for individual views.
+
+To implement a floating toolbar for text selection, make the following changes in your existing
+apps:
+
+- In your {@link android.view.View} or {@link android.app.Activity} object, change your
+{@link android.view.ActionMode} calls from
+{@code startActionMode(Callback)} to {@code startActionMode(Callback, ActionMode.TYPE_FLOATING)}.
+- Take your existing implementation of ActionMode.Callback and make it extend
+{@code ActionMode.Callback2} instead.
+- Override the {@code Callback2.onGetContentRect()} method to provide the coordinates of the
+content {@link android.graphics.Rect} object (such as a text selection rectangle) in the view.
+- If the rectangle positioning is no longer valid, and this is the only element to be invalidated,
+call the {@code ActionMode.invalidateContentRect()} method.
+
+
+If you are using
+Android Support Library revision 22.2, be aware that floating toolbars are not
+backward-compatible and appcompat takes control over {@link android.view.ActionMode} objects by
+default. This prevents floating toolbars from being displayed in M. To enable
+{@link android.view.ActionMode} support in an
+{@link android.support.v7.app.AppCompatActivity}, call
+{@code android.support.v7.app.AppCompatActivity.getDelegate()}, then call
+{@code android.support.v7.app.AppCompatDelegate.setHandleNativeActionModesEnabled()} on the returned
+{@link android.support.v7.app.AppCompatDelegate} object and set the input
+parameter to {@code false}. This call returns control of {@link android.view.ActionMode} objects to
+the framework. In devices running M, that allows the framework to support
+{@link android.support.v7.app.ActionBar} or floating toolbar modes, while on pre-M devices, only the
+{@link android.support.v7.app.ActionBar} modes are supported.
+
+Android Keystore Changes
+Starting this release, the
+Android Keystore provider no longer supports
+DSA. ECDSA is still supported.
+
+Keys which do not require encryption at rest will no longer be deleted when secure lock screen
+is disabled or reset (for example, by the user or a Device Administrator). Keys which require
+encryption at rest will be deleted during these events.
+
+Themeable ColorStateLists
+Theme attributes are now supported in
+{@link android.content.res.ColorStateList} for devices running M. The
+{@link android.content.res.Resources#getColorStateList(int) getColorStateList()} and
+{@link android.content.res.Resources#getColor(int) getColor()} methods have been deprecated. If
+you are calling these APIs, call the new {@code Context.getColorStateList()} or
+{@code Context.getColor()} methods instead. These methods are also available in the
+v4 appcompat library via {@link android.support.v4.content.ContextCompat}.
+
+Night Mode (User-configurable Dark Theme)
+
+Support for the {@code -night} resource qualifier has been updated in M. Previously, night mode was
+only available when a device was docked and in car mode. Starting in M, night mode is available on
+all devices and is user-configurable via Settings > Display > Theme. You can adjust this
+setting globally using {@link android.app.UiModeManager#setNightMode(int) setNightMode()}. The
+Dark theme corresponds to {@link android.app.UiModeManager#MODE_NIGHT_YES}. When the device is in
+night mode, the resource framework will prefer resources that have the -night qualifier. To
+take advantage of user-configurable Dark mode in your app, extend from the
+{@code Theme.Material.DayNight} set of themes rather than {@code Theme.Material} or
+{@code Theme.Material.Light}.
+
+
+ART Runtime
+The ART runtime now properly implements access rules for the
+{@link java.lang.reflect.Constructor#newInstance(java.lang.Object...) newInstance()} method. This
+change fixes a problem where Dalvik was checking access rules incorrectly in previous versions.
+If your app uses the
+{@link java.lang.reflect.Constructor#newInstance(java.lang.Object...) newInstance()} method and you
+want to override access checks, call the
+{@link java.lang.reflect.Constructor#setAccessible(boolean) setAccessible()} method with the input
+parameter set to {@code true}. If your app uses the
+v7 appcompat library or the
+v7 recyclerview library,
+you must update your app to use to the latest versions of these libraries. Otherwise, make sure that
+any custom classes referenced from XML are updated so that their class constructors are accessible.
+
+The M release updates the behavior of the dynamic linker. The dynamic linker now understands the
+difference between a library’s {@code soname} and its path
+(
+public bug 6670), and search by {@code soname} is now
+implemented. Apps which previously worked that have bad {@code DT_NEEDED} entries
+(usually absolute paths on the build machine’s file system) may fail when loaded on M.
+
+The {@code dlopen(3) RTLD_LOCAL} flag is now correctly implemented in M. Note that
+{@code RTLD_LOCAL} is the default, so calls to {@code dlopen(3)} that didn’t explicitly use
+{@code RTLD_LOCAL} will be affected (unless your app explicitly used {@code RTLD_GLOBAL}). With
+{@code RTLD_LOCAL}, symbols will not be made available to libraries loaded by later calls to
+{@code dlopen(3)} (as opposed to being referenced by {@code DT_NEEDED} entries).
+
+
+Android for Work Changes
+This release includes the following behavior changes for Android for Work:
+
+- Work contacts in personal contexts. Google Messenger and the Google Dialer
+Call Log now display work contacts when the user views past messages or calls. Furthermore, both
+work and personal contacts are now available to devices over Bluetooth, but you can hide work
+profile contacts through a device policy by calling the new
+{@code DevicePolicyManager.setBluetoothContactSharingDisabled()} method. Initiating a call or
+creating a new message will only show personal contacts, as consistent with the experience in
+Android 5.0.
+
+- WiFi configuration removal: WiFi configurations added by a Profile Owner
+(for example, through calls to the
+{@link android.net.wifi.WifiManager#addNetwork(android.net.wifi.WifiConfiguration)
+addNetwork()} method) are now removed if that work profile is deleted.
+- WiFi configuration lockdown: Any WiFi configuration created by an active Device
+Owner can no longer be modified or deleted by the user. The user can still create and
+modify their own WiFi configurations, so long as the {@link android.os.UserManager} constant
+{@link android.os.UserManager#DISALLOW_CONFIG_WIFI} has not been set for that user.
+- VPN in Settings: VPN apps are now visible in Settings > More > VPN.
+Additionally, the notifications that accompany VPN usage are now specific to whether that VPN is
+configured for a managed profile or the entire device.
+- Work status notification: A status bar briefcase icon now appears whenever
+an app from the managed profile has an activity in the foreground. Furthermore, if the device is
+unlocked directly to the activity of an app in the managed profile, a toast is displayed notifying
+the user that they are within the work profile.
+
+- Download Work Policy Controller via Google account addition: When a Google
+account that requires management via a Work Policy Controller (WPC) app is added to a device
+outside of a managed context, the add account flow now prompts the user to install the
+appropriate WPC. This behavior also applies to accounts added via
+Settings > Accounts in the initial device setup wizard.
+
diff --git a/docs/html/preview/api-overview.jd b/docs/html/preview/api-overview.jd
index dde3c7be149d0..b207e35d22d5f 100644
--- a/docs/html/preview/api-overview.jd
+++ b/docs/html/preview/api-overview.jd
@@ -1,6 +1,6 @@
page.title=API Overview
page.keywords=preview,sdk,compatibility
-sdk.platform.apiLevel=22
+sdk.platform.apiLevel=23
@jd:body
@@ -13,24 +13,24 @@ sdk.platform.apiLevel=22
show less
- - Important Behavior Changes
-
- - change 1
- - change 2
-
-
- - Feature Group 1
-
- - change 1
- - change 2
-
-
- - Feature Group 2
-
- - change 1
- - change 2
-
+ - Auto Backup for Apps
+ - Notifications
+ - Authentication
+
+ - Direct Share
+ - Voice Interactions
+ - Bluetooth Stylus Support
+ - New Audio Features
+ - New Android for Work Features
+
+
+API Differences
+
+- API level 22 to M »
@@ -54,65 +54,313 @@ methods that do not yet have reference material available on developer.android.com. These API elements are
formatted in {@code code style} in this document (without hyperlinks). For the
preliminary API documentation for these elements, download the preview
-reference.
+href="http://storage.googleapis.com/androiddevelopers/preview/m-developer-preview-reference.zip">
+preview reference.
-Important Behavior Changes
+Important behavior changes
-If you have previously published an app for Android, be aware that your app
- might be affected by changes in the upcoming release.
+If you have previously published an app for Android, be aware that your app might be affected
+by changes in M.
-Behavior Change 1
+Please see Behavior Changes for complete information.
-
- Bacon ipsum dolor amet biltong picanha t-bone, jowl salami tri-tip jerky kielbasa sirloin boudin
- porchetta fatback cow meatloaf capicola. Short ribs kielbasa pig drumstick rump boudin jowl chuck
- beef ribs doner tenderloin biltong swine.
+
Auto Backup for Apps
+The system now performs automatic full data backup and restore for apps. This behavior is
+enabled by default for apps targeting M; you do not need to add any additional code. If users
+delete their Google account, their backup data is deleted as well.
+To learn how this feature works and how to configure what to back up on the file system,
+see the App Backup for Apps guide.
+
+Notifications
+M adds the following API changes for notifications:
+
+ - New {@code NotificationListenerService.INTERRUPTION_FILTER_ALARMS} filter level that
+ corresponds to the new Alarms only do not disturb mode.
+ - New {@code Notification.CATEGORY_REMINDER} category value that is used to distinguish
+ user-scheduled reminders from other events
+ ({@link android.app.Notification#CATEGORY_EVENT}) and alarms
+ ({@link android.app.Notification#CATEGORY_ALARM}).
+ - New {@code android.graphics.drawable.Icon} class which can be attached to your notifications
+ via the Notification.Builder.setIcon() and Notification.Builder.setLargeIcon() methods.
+ - New {@code NotificationManager.getActiveNotifications()} method that allows your apps to
+ find out which of their notifications are currently alive.
+
+
+Authentication
+The M release offers new APIs to let you authenticate users by using their fingerprint scans on
+supported devices, and check how recently the user was last authenticated using a device unlocking
+mechanism (such as a lockscreen password). Use these APIs in conjunction with
+the Android Keystore system.
+
+Fingerprint Authentication
+
+To authenticate users via fingerprint scan, get an instance of the new
+{@code android.hardware.fingerprint.FingerprintManager} class and call the
+{@code FingerprintManager.authenticate()} method. Your app must be running on a device with a
+fingerprint sensor. You must implement the user interface for the fingerprint
+authentication flow on your app, and use the standard fingerprint Android icon in your UI.
+If you are developing multiple apps that use fingerprint authentication, note that each app must
+authenticate the user’s fingerprint independently.
+
+To use this feature in your app, first add the {@code USE_FINGERPRINT} permission in your
+manifest.
-Feature Group 1
+
+<uses-permission
+ android:name="android.permission.USE_FINGERPRINT" />
+
-Feature item 1
+The following snippet shows how you might listen for fingerprint events in your
+{@code FingerprintManager.AuthenticationCallback} implementation.
-
- Bacon ipsum dolor amet landjaeger capicola tail sausage shank swine biltong pork andouille t-bone
- alcatra chicken. Strip steak bacon tongue beef bresaola landjaeger. Shankle boudin pork belly
- jowl pig. Rump swine ham hock frankfurter pork shankle. Shank corned beef alcatra doner flank
- turducken. Tongue brisket ham shoulder:
+
+// Call this to start listening for fingerprint events
+public void startListening(FingerprintManager.CryptoObject cryptoObject) {
+ if (!isFingerprintAuthAvailable()) {
+ return;
+ }
+ mCancellationSignal = new CancellationSignal();
+ mSelfCancelled = false;
+ mFingerprintManager.authenticate(cryptoObject,
+ mCancellationSignal, this, 0 /* flags */);
+ // Icon to display when prompting users to start a fingerprint scan
+ mIcon.setImageResource(R.drawable.ic_fp_40px);
+}
+
+// Helper method to check if the device supports fingerprint
+// scanning and if the user has enrolled at least one fingerprint.
+public boolean isFingerprintAuthAvailable() {
+ return mFingerprintManager.isHardwareDetected()
+ && mFingerprintManager.hasEnrolledFingerprints();
+}
+
+
+Confirm Credentials
+Your app can authenticate users based on how recently they last unlocked their device. You can
+use the same public or secret key to authenticate users into multiple apps. This feature frees
+users from having to remember additional app-specific passwords, and avoids the need for you to
+implement your own authentication user interface.
+
+You can set your own authentication policy by setting constraints against the key that you are
+generating or importing. To set the constraints for using a key, use the
+{@code android.security.KeyPairGeneratorSpec.Builder} and
+{@code android.security.KeyGeneratorSpec.Builder} classes for public key pairs and secret keys
+respectively. If you are importing keys, use the {@link android.security.KeyStoreParameter.Builder}
+class to set your constraints.
+
+The following example shows how you might create a symmetric key in the Keystore which can only be
+used if the user has successfully unlocked the device within the last 5 minutes.
+
+
+private void createKey() {
+ // Generate a key to decrypt payment credentials, tokens, etc.
+ // This will most likely be a registration step for the user when
+ // they are setting up your app.
+ try {
+ KeyStore ks = KeyStore.getInstance("AndroidKeyStore");
+ ks.load(null);
+ KeyGenerator keyGenerator = KeyGenerator.getInstance("AES",
+ "AndroidKeyStore");
+ keyGenerator.init(new KeyGeneratorSpec.Builder(this)
+ // Alias of the entry in Android KeyStore where the key will appear
+ .setAlias(KEY_NAME)
+ // Key use constraints
+ .setPurposes(KeyStoreKeyProperties.Purpose.ENCRYPT
+ | KeyStoreKeyProperties.Purpose.DECRYPT)
+ .setBlockModes("CBC")
+ .setUserAuthenticationRequired(true)
+ // Require that the user has unlocked in the last 5 minutes
+ .setUserAuthenticationValidityDurationSeconds(5 * 60)
+ .setEncryptionPaddings("PKCS7Padding")
+ .build());
+ keyGenerator.generateKey();
+ } catch (NoSuchAlgorithmException | NoSuchProviderException
+ | InvalidAlgorithmParameterException | KeyStoreException
+ | CertificateException | IOException e) {
+ throw new RuntimeException(e);
+ }
+}
+
+
+To determine the last time users logged into their account, call the
+{@code android.accounts.AccountManager.confirmCredentials()} method. If the call is successful, the
+method returns an bundle that includes a {@code KEY_LAST_AUTHENTICATED_TIME} value which indicates
+the last time, in milliseconds, that the credential for that account was validated or created.
+
+Direct Share
+
+
+
+This release provides you with APIs to makes sharing intuitive and quick for users. You can now
+define deep links that target a specific activity in your app. These deep links are
+exposed to users via the Share menu. This feature allows users to share content to
+targets, such as contacts, within other apps. For example, the deep link might launch an
+activity in another social network app, which lets the user share content directly to a specific
+friend or community in that app.
+
+To enable sharing via deep links, you must define a class that extends the
+{@code android.service.}
+{@code chooser.ChooserTargetService} class. Declare your
+{@code ChooserTargetService} in the manifest. Within that declaration, specify the
+{@code BIND_CHOOSER_TARGET_SERVICE} permission and an intent filter with the
+{@code SERVICE_INTERFACE} action.
+The following example shows how you might declare the {@code ChooserTargetService} in your
+manifest.
+
+
+
+
+<service android:name=".ChooserTargetService"
+ android:label="@string/service_name"
+ android:permission="android.permission.BIND_CHOOSER_TARGET_SERVICE">
+ <intent-filter>
+ <action android:name="android.service.chooser.ChooserTargetService" />
+ </intent-filter>
+</service>
+
+
+For each activity that you want to expose to the {@code ChooserTargetService}, add a
+{@code <meta-data>} element with the name
+{@code "android.service.chooser.chooser_target_service"} in your app manifest.
-Feature item 2
+
+<activity android:name=".MyShareActivity”
+ android:label="@string/share_activity_label">
+ <intent-filter>
+ <action android:name="android.intent.action.SEND" />
+ </intent-filter>
+<meta-data
+ android:name="android.service.chooser.chooser_target_service"
+ android:value=".ChooserTargetService" />
+</activity>
+
+Voice Interactions
- Bacon ipsum dolor amet landjaeger capicola tail sausage shank swine biltong pork andouille t-bone
- alcatra chicken. Strip steak bacon tongue beef bresaola landjaeger. Shankle boudin pork belly
- jowl pig. Rump swine ham hock frankfurter pork shankle. Shank corned beef alcatra doner flank
- turducken. Tongue brisket ham shoulder:
+This release provides a new voice interaction API which, together with
+Voice Actions,
+allows you to build conversational voice experiences into your apps. Call the
+{@code android.app.Activity.isVoiceInteraction()} method to determine if your activity was
+started in response to a voice action. If so, your app can use the
+{@code android.app.VoiceInteractor} class to request a voice confirmation from the user, select
+from a list of options, and more.
+To learn more about implementing voice actions, see the voice interaction API
+guide.
-Feature Group 2
+Bluetooth Stylus Support
+The M release provides improved support for user input using a Bluetooth stylus. If the user
+touches a stylus with a button on the screen of your app, the
+{@link android.view.MotionEvent#getToolType(int) getTooltype()} method now returns
+{@code TOOL_TYPE_STYLUS}. The {@link android.view.MotionEvent#getButtonState() getButtonState()}
+method returns {@link android.view.MotionEvent#BUTTON_SECONDARY} when the user
+presses the primary stylus button. If the stylus has a second button, the same method returns
+{@link android.view.MotionEvent#BUTTON_TERTIARY} when the user presses it. If the user presses
+both buttons simultaneously, the method returns both these values. In addition, the system reports
+the user button-press action to the new {@code View.onStylusButtonPressListener} and
+{@code GestureDetector.OnStylusButtonPressListener} callbacks in your activity, if you have
+registered these listeners in your app.
-Feature item 1
-
-
- Bacon ipsum dolor amet landjaeger capicola tail sausage shank swine biltong pork andouille t-bone
- alcatra chicken. Strip steak bacon tongue beef bresaola landjaeger. Shankle boudin pork belly
- jowl pig. Rump swine ham hock frankfurter pork shankle. Shank corned beef alcatra doner flank
- turducken. Tongue brisket ham shoulder:
-
-
-Feature item 2
-
-
- Bacon ipsum dolor amet landjaeger capicola tail sausage shank swine biltong pork andouille t-bone
- alcatra chicken. Strip steak bacon tongue beef bresaola landjaeger. Shankle boudin pork belly
- jowl pig. Rump swine ham hock frankfurter pork shankle. Shank corned beef alcatra doner flank
- turducken. Tongue brisket ham shoulder:
-
+New Audio Features
+This release adds enhancements to audio processing on Android, including:
+
+ - Support for the MIDI
+protocol, with the new {@code android.media.midi} APIs. Use these APIs to send and receive MIDI
+events.
+ - New {@code android.media.AudioRecord.Builder} and {@code android.media.AudioTrack.Builder}
+classes to create digital audio capture and playback objects respectively, and configure audio
+source and sink properties to override the system defaults.
+ - API hooks for associating audio and input devices. This is particularly useful if your app
+allows users to start a voice search from a game controller or remote control connected to Android
+TV. The system invokes the new {@code android.app.Activity.onSearchRequested()} callback when the
+user starts a search. To determine if the user's input device has a built-in microphone, retrieve
+the {@link android.view.InputDevice} object from that callback, then call the new
+{@code InputDevice.hasMic()} method.
+ - New {@code android.media.AudioDevicesManager} class which lets you retrieve a list of all
+attached source and sink audio devices. You can also specify an
+{@code android.media.OnAudioDeviceConnectionListener} object if you want your app to be notified
+when an audio device is connected or disconnected.
+
+New Android for Work Features
+This release includes the following new APIs for Android for Work:
+
+ - Enhanced controls for Corporate-Owned, Single-Use devices: The Device Owner
+can now control the following settings to improve management of
+Corporate-Owned, Single-Use (COSU) devices:
+
+ - Disable or re-enable the keyguard with the
+{@code DevicePolicyManager.setKeyguardEnabledState()} method.
+ - Disable or re-enable the status bar (including quick settings, notifications, and the
+navigation swipe-up gesture that launches Google Now) with the
+{@code DevicePolicyManager.setStatusBarEnabledState()} method.
+ - Disable or re-enable safe boot with the {@link android.os.UserManager} constant
+{@code DISALLOW_SAFE_BOOT}.
+ - Prevent the screen from turning off while plugged in with the
+ {@link android.provider.Settings.Global} constant {@code STAY_ON_WHILE_PLUGGED_IN}.
+
+
+ - Silent install and uninstall of apps by Device Owner: A Device Owner can now
+silently install and uninstall applications using the {@link android.content.pm.PackageInstaller}
+APIs, independent of Google Play for Work. You can now provision devices through a Device Owner that
+fetches and installs apps without user interaction. This feature is useful for enabling one-touch
+provisioning of kiosks or other such devices without activating a Google account.
+- Silent enterprise certificate access: When an app calls
+{@link android.security.KeyChain#choosePrivateKeyAlias(android.app.Activity,android.security.KeyChainAliasCallback,java.lang.String[],java.security.Principal[],java.lang.String,int,java.lang.String) choosePrivateKeyAlias()},
+prior to the user being prompted to select a certificate, the Profile or Device Owner can now call
+the {@code DeviceAdminReceiver.onChoosePrivateKeyAlias()} method to provide the alias silently to
+the requesting application. This feature lets you grant managed apps access to certificates
+without user interaction.
+- Auto-acceptance of system updates. By setting a system update policy with
+{@code DevicePolicyManager.setSystemUpdatePolicy()}, a Device Owner can now auto-accept a system
+update, for instance in the case of a kiosk device, or postpone the update and prevent it being
+taken by the user for up to 30 days. Furthermore, an administrator can set a time window in which an
+update must be taken, for example during the hours when a kiosk device is not in use. When a
+system update is available, the system checks if the Work Policy Controller app has set a system
+update policy, and behaves accordingly.
+
+-
+Delegated certificate installation. A Profile or Device Owner can now grant a
+third-party app the ability to call these {@link android.app.admin.DevicePolicyManager} certificate
+management APIs:
+
+ - {@link android.app.admin.DevicePolicyManager#getInstalledCaCerts(android.content.ComponentName)
+getInstalledCaCerts()}
+ - {@link android.app.admin.DevicePolicyManager#hasCaCertInstalled(android.content.ComponentName,byte[])
+hasCaCertInstalled()}
+ - {@link android.app.admin.DevicePolicyManager#installCaCert(android.content.ComponentName,byte[])
+installCaCert()}
+ - {@link android.app.admin.DevicePolicyManager#uninstallCaCert(android.content.ComponentName,byte[])
+uninstallCaCert()}
+ - {@link android.app.admin.DevicePolicyManager#uninstallAllUserCaCerts(android.content.ComponentName)
+uninstallAllUserCaCerts()}
+ - {@link android.app.admin.DevicePolicyManager#installKeyPair(android.content.ComponentName,java.security.PrivateKey,java.security.cert.Certificate,java.lang.String)
+installKeyPair()}
+
+
+- Enterprise factory reset protection. When provisioning a Device Owner, you can
+now configure parameters for bypassing Factory Reset Protection (FRP), by setting the
+{@code DeviceManagerPolicy.EXTRA_PROVISIONING_RESET_PROTECTION_PARAMETERS} bundle. An NFC Programmer
+app can provide these parameters after a device has been reset to bypass FRP and provision the device,
+without requiring the previously configured Google account. If you don't modify these parameters,
+FRP remains in-place and prevents the device from being activated without the previously activated
+Google credentials.
+- Data usage tracking. A Profile or Device Owner can now query for the data
+usage statistics visible in Settings > Data usage by using the new
+{@code android.app.usage.NetworkStatsManager} methods. Profile Owners are automatically granted
+permission to query data on the profile they manage, while Device Owners get access to usage data
+of the managed primary user.
+
For a detailed view of all API changes in the M Developer Preview, see the
+ Users often invest significant time and effort collecting data and setting preferences within
+ apps. Preserving that data for users if they replace a broken device or upgrade to a new one is
+ an important part of ensuring a great user experience. The Android M Preview system helps ensure
+ a good experience for users in this circumstances by automatically backing up app data to the
+ cloud.
+
+
+
+ This behavior is enabled by default for all apps installed on devices running Android M or
+ higher. No additional app code is required. The system provides users with the ability opt out of
+ automatic data backups for individual apps. You can also choose to limit what data from your app
+ is backed up.
+
+
+
+ This document describes the new system behavior and how to specify what data is backed up for
+ your app.
+
+
+Overview
+
+
+ The automatic backup feature preserves the data your app creates on a user device by uploading to
+ the user’s Google Drive account and encrypting it. There is no charge to you or the user for data
+ storage and the saved data does not count towards the user's personal Drive quota. During the M
+ Preview period, users can store up to 25MB per Android app.
+
+
+
+ Automatic backups occur every 24 hours, when the device is idle, charging, and connected to a
+ Wi-Fi network. When these conditions are met, the Backup Manager service uploads all available
+ backup data to the cloud. When the user transitions to a new device, or uninstalls and reinstalls
+ the backed up application, a restore operation will take place, copying the backed up data into
+ the newly installed application’s data directory.
+
+
+
+Automatically Excluded Data Files
+
+
+ Not all app data should be backed up, such as temporary files and caches, so the automatic backup
+ service excludes certain data files by default:
+
+
+
+
+Configuring Data Backup
+
+
+ The data created by any app installed on an M device is backed up, except for the automatically
+ excluded files listed in the previous section. You can further limit and configure what data gets
+ backed up from your app using settings in your app manifest.
+
+
+Including or Excluding Data
+
+
+ Depending on what data your application needs and how you save it, you may need to set specific
+ rules for including or excluding certain files or directories. The automatic backup service
+ supports setting these backup rules through use of an XML configuration file and the app
+ manifest. In the app manifest, you can specify a backup scheme configuration file as shown in the
+ following example:
+
+
+
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ xmlns:tools="http://schemas.android.com/tools"
+ package="com.my.appexample">
+ <uses-sdk android:minSdkVersion="9"/>
+ <uses-sdk android:targetSdkVersion="android-MNC"/>
+ <application ...
+ android:fullBackupContent="@xml/mybackupscheme">
+ </application>
+ ...
+</manifest>
+
+
+
+ In this example code, the android:fullBackupContent attribute specifies an XML file, located in
+ the res/xml/ directory of your app development project, named
+ mybackupscheme.xml. This configuration file can include rules for what files are
+ backed up. The following example code shows a configuration file that excludes a specific file
+ from backups:
+
+
+
+<?xml version="1.0" encoding="utf-8"?>
+ <full-backup-content>
+ <exclude domain="database" path="device_info.db"/>
+</full-backup-content>
+
+
+
+ This backup configuration only excludes a specific database file from being backed up. All other
+ files are backed up.
+
+
+Backup Configuration Syntax
+
+
+ The backup service configuration allows you to specify what files to include or exclude from
+ backup. The syntax for the data backup configuration xml file is as follows:
+
+
+
+<full-backup-content>
+ <include domain=["file" | "database" | "sharedpref" | "external" | "root"] path="string" />
+ <exclude domain=["file" | "database" | "sharedpref" | "external" | "root"] path="string" />
+</full-backup-content>
+
+
+
+ The following elements and attributes allow you to specify the files to include and exclude from
+ backup:
+
+
+
+ -
+
<include>. Use this element if you want to specify a set of resources to
+ back up, instead of having the system back up all data in your app by default. When you specify
+ an <include> tag, the system backs up only the resources specified with this
+ element.
+
+
+ -
+
<exclude>. Use this element to specify a set of resources to exclude from
+ backup. The system backs up all data in your app, except for resources specified with this
+ element.
+
+
+ -
+
domain. The type of resource you want to include or exclude from backup. The valid
+ values you can specify for this attribute include:
+
+
+ -
+
+ -
+
root. Specifies that the resource is in the app’s root directory.
+
+
+ -
+
file. Corresponds to a resource in the directory returned by the
+ getFilesDir()
+ method.
+
+
+ -
+
database. Corresponds to a database returned by the getDatabasePath()
+ method or by using the SQLiteOpenHelper
+ class.
+
+
+ -
+
sharedpref. Corresponds to a SharedPreferences
+ object returned by the
+ getSharedPreferences() method.
+
+
+ -
+
external. Specifies that the resource is in external storage, and corresponds
+ to a file in the directory returned by the getExternalFilesDir()
+ method.
+
+
+ -
+
path. The file path to a resource that you want to include or exclude from
+ backup.
+
+
+
+
+
+
+Prohibiting Data Backups
+
+
+ You can choose to prevent automatic backups of any of your app data by setting the
+ android:allowBackup attribute to false in the application element of
+ your manifest. This setting is illustrated in the following example code:
+
+
+
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ xmlns:tools="http://schemas.android.com/tools"
+ package="com.my.appexample">
+ <uses-sdk android:minSdkVersion="9"/>
+ <uses-sdk android:targetSdkVersion="android-MNC"/>
+ <application ...
+ android:allowBackup="false">
+ </application>
+ ...
+</manifest>
+
+
+
+Testing Backup Configuration
+
+
+ Once you have created a backup configuration, you should test it to make sure your app saves data
+ and can be restored properly.
+
+
+
+Enabling Backup Logging
+
+
+ To help determine how the backup feature is parsing your XML file, enable logging before
+ performing a test backup:
+
+
+$ adb shell setprop log.tag.BackupXmlParserLogging VERBOSE
+
+Testing Backup
+
+
+ To manually enable a backup, call the following command, specifying the package name for your app
+ as the <PACKAGE> parameter:
+
+
+$ adb shell bmgr fullbackup <PACKAGE>
+
+Testing Restore
+
+ To manually initiate a restore after your app data is backed-up, call the following command,
+ specifying the package name for your app as the <PACKAGE> parameter:
+
+
+$ adb shell bmgr restore <PACKAGE>
+
+
+ Warning: This action stops your app and wipes its data before performing the restore
+ operation.
+
+
+
+ You initiate the restore process for your app by uninstalling and reinstalling your app. The app
+ data is automatically restored from the cloud once the app installation is complete.
+
+
+
+Troubleshooting Backups
+
+
+ If you run into issues, clear the backup data and associated metadata by calling this command.
+
+
+$ adb shell bmgr wipe <TRANSPORT> <PACKAGE>
+
+
+ The <TRANSPORT> value must be prefixed by com.google.android.gms.
+ To get the list of transports, call the following command:
+
+
+$ adb shell bmgr list transports
+
+Known Issues
+
+The following are known issues with the automatic backup service:
+
+
+ - For apps that use Google Cloud Messaging for push notifications, there is a known issue where
+ backing up the registration id returned by Google Cloud Messaging registration can break push
+ notifications for the restored application. It is important to query the API for a new
+ registration id after being installed on a new device - which will not be the case if the old
+ registration id was backed up. To avoid this, exclude the registration id from the set of backed
+ up files.
+
+
\ No newline at end of file
diff --git a/docs/html/preview/features/runtime-permissions.jd b/docs/html/preview/features/runtime-permissions.jd
new file mode 100644
index 0000000000000..4a0101089d4db
--- /dev/null
+++ b/docs/html/preview/features/runtime-permissions.jd
@@ -0,0 +1,352 @@
+page.title=Android M Preview Runtime Permissions
+
+@jd:body
+
+
+
+ The M Developer Preview introduces a new app permissions model which makes it
+ less frustrating for users to install and upgrade apps. If an app running on
+ M supports the new permissions model, the user does not have to grant any
+ permissions when they install or upgrade the app. Instead, the app requests
+ permissions as they are needed, and the system shows a dialog to the user
+ asking for the permission.
+
+
+
+ If an app supports the new permissions model, it can still be installed and
+ run on devices running older versions of Android, using the old permissions
+ model on those devices.
+
+
+
+ Overview
+
+
+
+ If an app's target SDK version is the M developer preview, that indicates
+ that the app uses the new permissions model:
+
+
+
+ - Permissions are divided into permission groups, based on their
+ functionality. For example, all permissions relating to the camera and photo
+ roll are grouped in the Camera permission group,
+ [link]android.permission-group.CAMERA[/link].
+
+
+ - The app declares all the permissions it needs in the manifest, as in
+ earlier Android platforms.
+
+
+ - When the user installs or updates the app, the app is granted just those
+ permissions it requests that fall under
+
PROTECTION_NORMAL, as well as signature and system permissions, as
+ described below. The user is not prompted to grant any permissions
+ at this time.
+
+
+ - When the app needs to perform any action that requires a permission, it
+ first checks whether it has that permission already. If it does not, it
+ requests to be granted that permission.
+
+
+ - When the app requests a permission, the system shows a dialog box to the
+ user, then calls the app's callback function to notify it whether the
+ permission was granted. If a user grants a permission, the app is given all
+ permissions in that permission's functional area that were declared in the
+ app manifest.
+
+
+ - If the app is not granted an appropriate permission, it should handle the
+ failure cleanly. For example, if the permission is just needed for an added
+ feature, the app can disable that feature. If the permission is essential for
+ the app to function, the app might disable all its functionality and inform
+ the user that they need to grant that permission.
+
+
+ - Users can always go to the app's Settings screen and turn on or
+ off any of the app's permissions.
+
+ If a user turns off an app's permissions, the app is
+ not notified.
+
+
+
+
+ System Apps and Signature Permissions
+
+
+
+ Ordinarily, an app is just granted the
+ PROTECTION_NORMAL permissions when it is installed. However,
+ under some circumstances the app is granted more permissions:
+
+
+
+ - If an app is part of the system image, it is automatically granted all
+ the permissions listed in its manifest.
+
+
+ - Apps are granted all permissions listed in the manifest that fall under
+
+ PROTECTION_SIGNATURE, if the app's signature matches the signature of
+ the app that declares the permissions.
+
+
+
+
+ In both cases, the user can still revoke permissions at any time by going to
+ the app's Settings screen, so the app should continue to check for
+ permissions at run time and request them if necessary.
+
+
+
+ Forwards and Backwards Compatibility
+
+
+
+ If an app does not target the M developer preview, it continues to use the
+ old permissions model even on M devices. When the app is installed, the
+ system asks the user to grant all permissions listed in the app's manifest.
+
+
+
+ If an app using the new permissions model is run on a pre-M device, the
+ system treats it the same as any other app. Once again, the system asks the
+ user to grant all declared permissions at install time.
+
+
+Coding for Runtime Permissions
+
+
+ If your app targets the new M Developer Preview, you must use the new
+ permissions model. This means that in addition to declaring your needed
+ permissions in the manifest, you must also check to see if you have the
+ permissions at run time, and request the permissions if you do not already
+ have them.
+
+
+
+ Enabling the New Permissions Model
+
+
+
+ To enable the new M Developer Preview permissions model, set the app's
+
+ targetSdkVersion attribute to "M". Doing this enables all the new
+ permissions features.
+
+
+
+
+
+ Designating a Permission for M Only
+
+
+
+ You can use the new <uses-permission-sdk-m> element in the
+ app manifest to indicate that a permission is only needed on the M platform.
+ If you declare a permission this way, then whenever the app is installed on
+ an older device, the user is not prompted to grant the permission and the
+ permission is not granted to the app. This allows you to add new permissions
+ to updated versions of your app without forcing users to grant permissions
+ when they install the update.
+
+
+
+ If the app is running on a device with the M developer preview,
+ <uses-permission-sdk-m> behaves the same as
+ <uses-permission>. The user is not prompted to grant any
+ permissions when the app is installed, and the app requests permissions as
+ they are needed.
+
+
+
+ Prompting for Permissions on the M Preview
+
+
+
+ If your app uses the new M Developer Preview permissions model, the user is
+ not asked to grant all permissions when the app is first launched on a device
+ running the M Preview. Instead, your app requests permissions as they are
+ needed. When your app requests a permission, the system shows a dialog to the
+ user.
+
+
+
+ An app should follow this workflow to request permissions on an Android M
+ device. The device can check what platform it's running on by checking the
+ value of {@link android.os.Build.VERSION#SDK_INT Build.VERSION.SDK_INT}. If
+ the device is running the M Developer Preview, {@link
+ android.os.Build.VERSION#SDK_INT SDK_INT} is 23.
+
+
+
+ - When the user tries to do something that requires a permission, the app
+ checks to see if it currently has permission to perform this operation. To do
+ this, the app calls
+
Context.CheckSelfPermission(permission_name) . The
+ app should do this even if it knows the user has already granted that
+ permission, since the user can revoke an app's permissions at any time. For
+ example, if a user wants to use an app to take a picture, the app calls
+ Context.CheckSelfPermission(Manifest.permission.CAMERA).
+
+
+
+
+ - If the permission is not already granted to the app, the app calls
+
+
requestPermissions() to request the
+ appropriate permission or permissions. This method functions
+ asynchronously.
+
+
+
+ - The system presents a dialog box to the user.
+
+ When the user responds, the system calls
+
Activity.onRequestPermissionsResult() with the
+ results; your app needs to override that method. The callback is passed the
+ same request code you passed to
+ requestPermissions().
+
+
+
+ - If the user grants a permission, the app is given all permissions
+ in that functional area that are listed in the app manifest.
+ If the request is denied, you should take appropriate action. For
+ example, you might disable any menu actions that depend on this permission.
+
+
+
+
+ When the system asks the user to grant a permission, the user has the option
+ of telling the system not to ask for that permission again. In that case,
+ when an app asks for that permission with
+ requestPermissions(), the
+ system immediately denies the request. For this reason, your app cannot
+ assume that any direct interaction with the user has taken place.
+
+
+
+ If your app runs on a device that has SDK 22 or lower, the app uses the old
+ permissions model. When the user installs the app, they are prompted to grant
+ all the permissions your app requests in its manifest, except for those
+ permissions which are labeled with <uses-permission-sdk-m>.
+
+
+Best Practices
+
+
+ The new permissions model gives users a smoother experience, and makes it
+ easier for them to install apps and feel comfortable with what the apps are
+ doing. We recommend the following best practices to take full advantage of
+ the new model.
+
+
+
+ Don't Overwhelm the User
+
+
+
+ If you confront the user with a lot of permissions requests at once, you may
+ overwhelm the user and cause them to quit your app. Instead, you should ask
+ for permissions as you need them.
+
+
+
+ In some cases, one or more permissions might be absolutely essential to your
+ app. In that case, it might make sense to ask for all the permissions as soon
+ as the app launches.
+
+ For example, if you make a photography app, the app would
+ need access to the device camera. When the user launches the app for the
+ first time, they won't be surprised to be asked to give permission to use the
+ camera. But if the same app also had a feature to share photos with the
+ user's contacts, you probably should not ask for that permission at
+ first launch. Instead, wait until the user tries to use the "sharing" feature
+ and ask for the permission then.
+
+
+
+ If your app provides a tutorial, it may make sense to request app's essential
+ permissions at the end of the tutorial sequence.
+
+
+
+ Explain Why You Need Permissions
+
+
+
+ The permissions screen shown by the system when you call
+ requestPermissions() says what permission your app wants,
+ but doesn't say why you want it. In some cases, the user may find that
+ puzzling. It's a good idea to explain to the user why your app wants the
+ permissions before you call
+ requestPermissions().
+
+
+
+ For example, a photography app might want to use location services, so it can
+ geotag the photos. A typical user might not understand that a photo can
+ contain location information, and would be puzzled why their photography app
+ wanted to know the location. So in this case, it's a good idea for the app to
+ tell the user about this feature before calling
+
+ requestPermissions().
+
+
+
+ As noted, one way to do this is to incorporate these requests into an app
+ tutorial. The tutorial can show each of the app's features in turn, and as it
+ does this, it can explain what permissions are needed. For example, the
+ photography app's tutorial demonstrate its "share photos with your contacts"
+ feature, then tell the user that they'll need to give permission for the app
+ to see the user's contacts, and then call
+ requestPermissions()
+ to get that access. Of course, some users will want to skip the tutorial, so
+ you'll still need to check for and request permissions during the app's
+ normal operation.
+
+
+
+ Opt Out If Necessary
+
+
+
+ Until you are ready to use the new permissions model, you can opt out simply
+ by setting your app's
+ targetSdkVersion to 22 or less. If you do this, the system will use the
+ old permissions model. When the user downloads the app, they will be prompted
+ to grant all the permissions listed in the manifest.
+
+
+
+ With the M Developer Preview, users can turn off permissions for any
+ app from the app's Settings page, regardless of what SDK version the app
+ targets. For this reason, it's a good idea to follow the steps described in
+ "Prompting for Permissions on the M Preview" even if
+ your app doesn't fully support the new permissions model.
+
+
+
+ Note: If a user turns off permissions for a legacy app, the system
+ silently disables the appropriate functionality. When the app attempts to
+ perform an operation that requires that permission, the operation will not
+ necessarily cause an exception. Instead, it might return an empty data set or
+ otherwise signal an error.
+
diff --git a/docs/html/preview/images/direct-share-screen.png b/docs/html/preview/images/direct-share-screen.png
new file mode 100644
index 0000000000000000000000000000000000000000..9e879e03f4b73ea834bace511e00261171f51272
GIT binary patch
literal 57902
zcmXt;18`(bw18vV=EkT+JwQ)AKZEcJ<`@i=pH8qo4U42iVKK!~P
zl@z29;qc%|HWeyHLX=A3YW$QY7izAQYWgU#*Jt1jh`WXdAmW?t7
z1`Cmdg4XD6Vd!(+Bdeb4vL$r3ba|#gF3&Y5|LgcZaHI5f$^DFH=K7tpALV(n<%`|p
zRJFQwlFwW)o72wJXM&Spv>zv!#k@kO|K4{x;JzIrnkbDTQDvutCIkgShV-W}9R!#x
zjLIo{ni*-SxO5~2TCmXpOuTH00bPxfh%gGov&c^syqSBMQS^e;5ga8QP^gKTptbu)bS>-6Tffo@1>gc
zlZz8c9W+@uN_I|_#HoZSjh|+J8cm@6{2-g>p8bDbLu2?Mm%i0?vp~i4!+?&Eh1V>FAA^YmeAO`8$#}!m>88Kgi)M?JjoIxw3neESaurgmma_SnG6j7Vl>o*7y
zrJidMlmeM;T$2Qt5{9vo`4SZ?z2(cVmX#N&nMlyNQ}*rNk8o4gQ_y`)o6UgUW=WX9
z{guf)f%H#ex>I^G#&Ihgm+uD9j5|p%k(NQ6*{&=99ZPc`GAvz7&wNYq<*xe%xgQ`
zNIlo&r9+MM%}bUwV~5VWu~=vmNzZwTBEpo(!;K6Cqh;?or#BnLfwZOcm#ROQcS)9^
zCIHMbsLz7XkAwvYGpdG~!O70w%T*RM787L3xfhm17!Ac~0*~pueclG7)^Sph>H;DG
zC@}0KuFn|O;7N|zC;mnQ;dEq2cL!>C_oSLQD7!o2IL)BCGHNJjy(ws<5HjaCJWPp&
zoGf<*L$rsW1V{$WBD_h$FT25TZME={ChMi&3!4K>iq0)&*9z2rreFoa)zfQ}8DJ{p
z#l`;Nl}w**dI*>ol0+oE#X(oFy!|eNulmU}Tj17qJ=a8()RR(*N;AH^mGZd+
z$0YsI&RiyLEt!&!PGdUsvCGZU5fB5PFh^@=!%WE!wVt+nJ8{!mQr`!3rHRJzgCNlD
zdz7?qH-60v+yf%Tj<(r98X}lAG6RGAq;%Z5mp;G?lD3WTg7~lIw
z@A;bxzoAeIy{YJ|05Apd(-5d6X&MNDyYotgIWNQmM+&Q^)MGDs?ikNH&O{tpazDZPBT^%y1c!jC>b3KMY
zys!-YIwi%%+)p2~-}2~4rs&x`wz6dPs44|up~uh|0(I}R5^&_X3gKL;Hn!`M`081;
z6n^c3B^2M=8Ef}{Xn!D^7GMA{kwm{+p=94=wPzyqXwnN2V5Vw2zra=5SpPPiV`pba
z@dOnR=yrAUm|xc{XzIilQZfUJTo8W9z(uFUZjLUZzurLgt+CCneMQj*ES?0-UtNs4SVDOYbgWa;?J3tT66!4aWi%~mZjjo{&H
zFe_c*RI?&NVKBXvREBi$LuQ}z;?FxuBfqD8XCYH29eBbK(|jY%DwBgWF(E4@ob$Fk
z#EGS);Vcb8Qw-auQ*$O$+bk+EU^yHUPs_WuEOOJw1_s_Isr0(cZ080$pFRjZKp2$v
zw>9w}bOdzdl-v_bIxr_whmk|VtL$`BC#cDiQ6l3?w^lXZOI2VXWS~hP{QUfOK^hpk
zevq;&hLYIm?t+ul%sE7&W|#l*WaG`5ie<6H%o>uRNtr9vHU!6`fea)LffJF539PNP
zCs?PPt+JgSkuNJiNtiiwB7hzRd@om}nC~ydf!LkIT5~W<-G6CMda+QFNp_xNU*ZbH
zoZj+lC*Ym6-RvMV#9!mc)RIMXyN)H&01ak|$_Ar>r__Y#&=4NpOfMG6?m
zKyykl*TT&*6om@`ojB7Z0#oI56KyguAzQ>2vvgPPK~lj{8&gXKCX$gxprPwZtL=o+
zE+>5`_P|=rTgKXHQ`0ERq^T7$R+Ez*YIUTqg&=3J?zTw6g(Q@I*Lh$PppIpQs$tiG
z@in_?VHDV)z-Qy!ghQ1v?PVtdE0rlLrp|UH>)JI76*I+4le00A!ESN|DytbPhq%abTYaCPjn8kBz|mGKa@mi9S-u#hbbO=tsf2&<3H
z#h_X&M?fGE3r=1Ke38JSeUrX%CJ8BMXt;%0G+%eO6rolpo4WB~x@oA{jU?qM32Mse
z!wEK9$0?qGk3=mVnJRb&{U)72(r-D&*ogMF%=xyQ*rHLg;rQV@1fluht9$CmVvtS%
zjT$(d3-9yd<4OBnX0>0wB$eXb?@uG=x)c+uFs+=L~tgqNTD&rw*5&0Pap;v5=uj
z-YyH22M3i5TBBsE$ZhF&KUOF^WFU4}`H*Oo0cU@vaA9guBP*Y9C#Bo9m*jH`bf{IpjUci?=;&>ypbs_$N$kBwhfa2m3<+DwM%n
zpyCenU{M?Cpm>nVx3+7{dU~Iq+PoRRp?r9OdQ8|kB+ExfO(lJU{nPT2VVVN2eivs^_u~Jx%Kr4D#2S=fc@t9W$X5|-_s_v
zu&gY+;rkx8m6g?Q{?|+XYP*XCYa>t|Xq+5EOyoNTJ|YC^by2v;{W7WA9a=qnD{Tk^
zlr#z!f=+jHY|BRY6Z=yKmrvhmywp-+fs0jb)508L|DsknsG7HnIJqbFOS^c;dnY%
zE|<6E-G6r=^kTC!J({s2;-3!NkMPpywUd4=Q%Ez%VQlP7hLVfT%9QqgJLGjECu{R<
zh`=zeq13N^`vz5FI-IFN!?B0%LJ;mU%@ck<%@@Di`}vot{liE!_BUf(SXdb7nJw^5
zz*JsuHi5<1dBNKAap^F>urQSCv6UI~3j%folB!_aPixS+tZ!TuIxaB{j7)
z+Uh9hP=y-YdMNC%v51S$jR=K@y9uV_vTXakNwyi&)kZTt|Cd8yt#!YtEDm5gN%iR3
zCwxB+_@uh_9ObjLvoo73`L3p+(P%M41YFVpu0>9N7$QCzWI9Pdw~AwM&7kE=H9>=N
z6@Wk^jCiZ#D*@sd8@`mbO(Y;VR!d^r^J3j{K%9PJug1aeJYk#AW5damHS^9LTh9>`
z#3J91bG}U8pu6|^k^~@B*%Tt>f!ORsHLp3GIA#1^Zu7sLr^B0#a-T07xYhf
zrmh4Ym!sLWwQ;ZG+|eLN_@u;Cpd@`eo@<`;dK=c!Y6b;C#;Fg4&g69qUeKmqh>UAi
z{Ky=%Ec|nB+!Kx5*IoBv@Ag|=Uf=+}w~MBUYm4a|ZAt+5)c8m+b}VBmyxYt|?GTG7xkL&;gH(L~|N(qOK{Sq`Zq7iV^clnnaHh0Z+e~9&}{iJ-qRJT*f+J!->|MDSl)u;a@OT
zep4V7&)nE+a0E%SOP7xO>}ew>ZR=4X>ozH$AgtQMg?CDdPB#266hnOIH@WhdezRwh
z>^2fhQZ*jDH#Yjs!L12bVrH^x{MOROMoNU0grW-^Z2*fpz)VEl)gPGO4(osjLbfC^-J>4>FRp%T3t7uO+9sxvrD
zX_9C0wy}S4qGs#B%yM1Sr4^-LiLMgD0=SNPFq0Og3=1
zG&3F~c4qM{dyQvoo4-^DZZ5XE4_pm`B+j>wE8P=h*hoG+G<1%Cil%6*2yz(Wx-D&p
zc(7d;u?p>v>7o)Vt3n%f0yb3Wbdeb8u}&`;|5RKo!cWM4B@r7Qi(@h?S)3w@l8mW&`M
zH_r=+k79ai+XXgUQLY0YueGz4R#npIWT`Is6-oao!|{%s0{G^2sYw?>pV9!ZiS
znVugQaE!U%Ng43BpT@`SZeDfY3;tziBlZYZ%ssPl==&H9FicA@A)Lo+q|E3wO?so4
z5x|DC#P)A`LcNVUjs~do9VR##nl(ONgS$ZMiaO*@c8YXcy^7ZU8q^}SS?57I6BLaT
zTbx=G7wMqt6dK$0BBe>vAC+jg5qr-@GPJL8LKl3F3Hh5Z6GE#f6<&MdTW__paaH#{
zhXCT6;W~f9QLoclS(;_D^DOl-BV1^l4LQNRR8J})69h?oy=4g_#Aw&BZ`{>nnC^*b
zoV+7N!9bJaCvCe82Zu(!t@-LkTy`^b%|^#&;6H=8`Xj_xTGrv+XOVZTOpR4pSxZ!3
zqVmAM#NV2ijKv@aHObAaygv;AY$9tQpt*AYtcl@s+{uMaKPsSr(LlgzXqxP~QP6^v=X^i$QoFu!ru9pCH%NI!X5lt#~4#V{W5d(%fO
zQ}Fy7KV~VdX^=5RL(6`^2RPM9^1pg^6%{u{ulql!+EVc^`U=kc&41^f$kQ4-~)_rjR#OUiWd5o$$4xu^*N?a(?Qt3@P0;Z=VcRE9=-Uegj?hWG
zTN6}R=+Gx3tYV^buCWJzIBCZ_h+lL~8aAnZP=I0;r{xaMmMdOr<2_gR{5TDavxux3IXWj|YDQ!^YXavNzmS
zeoK}iLqkt<;~QEpS-A5aBng8KKxT(hU9;*^O9IxWcr9^U`~X`X!>^H6&(UG*+uX07
z+lcG0new{*FW=XWySLbE&iku?XA+0ri)-z_C&6{A+BX}~pJf{a9^4@-=@W@BA7U8M
z616WoZ}E5>j#JQed-KGd<|L-1l0v)wJ(xM@aC`?X1Y
z1);wZt++F^jCoji9-LZfm}S=A>q|JCgC@91N+kr-nMUV_b76y#P5A+c@5A~Y^Gb$>
zl&v4oNO$vm0ikxtUCbODi|>Pn*JhtxCeLTR{(;E;7sR0U<@vk#ts8KCd&{|f+I2#?b??hlrfgOvDW*-U
z#d~_&0rHlyz6Z(qW~28r&O3b~aYC2$)>YMQN5pkUY{Z>M5q7_vq#aS?#Ty*|bof6A
z{vs(-7WsJ$Iao`{dQe;tQ{N2dsKU8+0_x1Nb{h@(8HWutT;_l+mcu8X$IIjGulq8U
z_I>}!9G2LCw)bur(hMO7MoF7TV(#axZ`?Ig6FO|$OLGH|0r#!VEv;-WBM-&n2ii~X
zP)h>6prjDQZFkq)=YPxZ4YxZ&Upv+u(Pm0$ytiyV`MDfc!_2gw{e`8Zply}}r2O<5
z;`V1dOpX)Q**V!`CR`$QLvHCSKXLQ|_sgXDj9o_~V5hObNC#h!!B`49j*N~)yW-|O
z2j0C#ZwB+XMHus`k`^v57|9JE`k#lXm+f56c%i-bUwVf~=-#;|jtab(nEeD+KyB-43$Pjxu!S1#ptKK~VXx(%eO;|@YGsJ`*bcX%I7_ZqY+C%WAX
zz4qj);qxH;NHIsKUjB8Mz5PLyDR)%C*Bc6dbRVqS!?V-$^){35J!Ut8zlZp1&n#JV
zqGa0|K~15Hthh^Kf(n8OEQjKeFnA
zkFA<`c*1S`79tEO4R5=SmzK%#tsmDaAx*v^0U2E{5nPKiDF(Ikv(mKy!X&sy4@p*M
zZ#3@b|m5ZKhgO>>Kjk)sr8{
zUo@-Wo@7<6k>OLX}>AQTXF-s=hO^LXVqW*40of9*2{f@={GU1~Wc^vN5OJg=of7Ba*P
z2bn&lVXV!WcTFA|ngWIbe#SN|oAC`I-H0BjC;F?`UAwVRZkY&1q61xkbTebJJ_-a5
zTU1n!PMGrGsT!Wi>qIKD!iECIe^sEBDo5TqkvcjqK``HB9vg5w3orrA)I((5`+m54
zSL@vSzygV+Um6Ab`=1Vc<^rM|mW~Y&UYw(juUY+;S7*zCZ$81evmtJdWdU>QbpI+Z
z2}}1Z);e)Lbhm5xNckc)kO(1ds0#|%+N#<{p=e?#cEi}NYWK1Ef1Md{v>MAd0}obb
zb0o&b>K57;NJ(i&gXz&Ejg^uKgp`Eayb7^Y7R7&Mb9!`t`xR>4Q1*;vjjUPHz(6`V
zWm{h&4!aEa07AtK1`qyTT{6di%m7LZ^C6<{uhjX+_zAVComQZum;(kY{u%}grRlUM
zc|==C4At2GEld$SHvLC5SFnamDs9{fO#kmr>(ZKpdV+PtPV3Z*&3=mUea1~7i1>y>
zvzNAG6mD+HB17Y33mwqxGO0|+S2k@(f~+thH^7cO?W9j2_lJBZm!0
zli9(7n;{02YR~YI;UiPlt24(EW{zJ5uzUK%kOhW%KhJyPPPh!Bavm?&H7VQH?eTee
z{l}6h_MH!~Nbr>E!cZN~4)
z<(JOiHM<{#+TqI8eGwZ)hYg=kq}$wa0?t9zzbb);V%Kjt1NL)HX|YSYWI;YHXZ@Q#
z*WJE1!Ndna@QgcM_tPe)bEVDA&Gk
zcQ8y{Hv^D4^)+K3DDK@2dh&8>&5{P8Vw}(ZkW$O+ZXT
z-UDpm->y32fzauW1MKAN><6&9{kJk;*Y5wezMVF@sPyL9!fZA74TxXH?hb(GL*p~M
zz@CK!|ZZWb?v6G)Rpd${`q@K=YN
zmhD`X>dY-_f}xRFf%Ao+blt`}99%Tbm;;Fo|NG70!t$~U5RJ@kY{)fenF3Y(ej+9G
z0om8VQMLooO+8S_
zRvYS(u_-ObUfgkmuYb>1+nmT(ZPTQPydZua=lR4j=mH8-_Wno_n_X?RFDxyosH(D=
zk9ON{^47NPMX|oT--HX5w6|vhwNEfg3KMka7a>iJ7d&6CXyINNKBC!khpE7Gh>^yq
z?+pP8oGhlgt|!YP&+91SqZi0<=ncBseyx#nV4!YH=kjT{SYx^zPahT&e^A3?GagV0
zy^Lk(*M-7kr_GqW+#Tllzn+5FZgpjj5(ng{D)59d1-wjvykA%d0nbs2Q}+0_Uyy)8
zGjeUZ&bN`bMVOF5V%OZBYpLHVDZz%|K=$**HOpIVGFYe4l@2-OfYz>Cj@B*VZ5Va(
zlNB{h^G1J9rfdN2ClUd-Fk`w25X|>&TRtu
zAiZjtTw!f(E&s%Z_j!$;+oJlubplY8Q(W7V7J~PvhL-ztupOv46`Ug+I()W
zi&z4+r{(C=$2WY!**N@M6sAor0=BaqjGZ3WL`IZiTIc5}stTm(6UxfU{dTRJBNEv9
z;)aIAd>&T>H@dfWhE<^(JNNhe@yQCjk+Jw(jYj=JYZd!F|9=+%=>ERj#~tUjCVNAX
z0e8>EGb7Q1#=y|<@bKWcZr7?zk7d|A`8sjB$LYCxu+tw5L)vx;SXYv1uw7+U;Ja)#
z&Q@S@6EL*HG2sSMNY9&o=uCbu)=<$xIZLrjKh#L^p)SimMNXJom}cLH<9YG~Fr(=D
zU{a7^!n7rPr6DyF6?Ru>n&Ad~7gh#QELJpq5U<|vXO5S29n8KyKYW3Vvb?9~6Q;Dq
zYM%1-^>wA&hwH@`2owLoH5I`l5}4nI&Xf5G=0Cko|rS#l(ka)pbX6vP@<`I+Mlq
zR=3m!(>h>6A?!!P?>qsYHlPD=AEu~6{kqi$)-`&5e;4(9E?a<6(z%a&tHX`X=ka29
zj4I#sY@t#vhdc4#l$dlH1gLPB`46LLE=QBQTRzu^z&OP~Jn@|>cWBdNTOXjXm%-&g
zbiQ0il{|KHkgOP2jZ)`1nE4EW$))-RyGj!7bs=W&wh^>{j@&~0sim&YL6}PjBz-9!
zcwQWPh!!y{2hQ!NKAhpvYil}X3c2H195!tSNwO6TsT;M`)x}j+Q4-Nu4M4r|^73-;
z$FOO2d9o<--$GdAx?utA{^8Jv(|IcghhupMZ&j~#wi$kxzR=pLsv-aY=#xN>I|8uF
z%FdoR7Z8OppUxQr0(M{nOElk7-5*>6gpIDh+M`f{XjIEm1l0Z|fg5e!TytQ+eC|;+
zGo!%7#H@RDvZ=}BaiIi>jg7t7?#+*8>dE-097uR9C3W@TlJChG95z@$6&wR~Q(9SB
z`Hmu&FPMvn&slHO4>m3MW=jIF;{3T|#3zzD`)tyy=}wjWnqSQt1mGIGZq9UlyfPPxN9ow0F#I$sW4v>Jfy?CdN9
z=$(s;i@$VR|;kJ)G>|QMc!6*z}J@(=K
zJ>VH}MQ!cyeUuNtZv8b$0wjE)Leucp!)4iFv!k@3Fp`i@ceOWQ8^k@951-7<bh
z%NRE|E+>&!&VMx?X?vS@bY0yjybm>DL9=W+npq%dWPeieO_2c7
zUnubNK|5TgO7pzh>$#hG>ObQ{oX2}s{>a*TbsKP6B~ODy5+(2hlP+rgZ-nSnVnFpt
zR__!Qr6rC&M6~H5=mhV#9l#I5TM{Qhkw<38ScpQk&_@iH3=tv*FYo`y;Yz+?JIQP$
z0$Qhp`4aZWiPweOdyr0|`|}x20riUJZUmb95(%C?Btef*9;zls)mBFSu>J1QU=2__EVfw0zt
z{NMYbG{uPYPFNNEY4`9F12;Y!u&e|0Mh&Zn(zB&
zNqdR-Yd8cx7zPU|cBHoOx@*$ay=`VgRZgO^q7uN3y^$g9nHFjj&qguQ#ZrN3#x)4)
zpFK=sHs)erKOv9)Grao0E01owcXk}R`=nqFL`8uhT01dTUnQIqZ)px+Dl8U3cTb9Q
z$D-^n}9H95k=E&tQBOp$7qRfm
zlVaP`Z2N!b>qlHXrmzUChQrcdO3-@HJ&RK_uuy{&J;L@*UIc{kB0+x!8h?QfGsd$k%3Bs8p^H(i
zr@u0Wtipd>;39Vfe>O*%68?8Q)2{?{+9S4G1lkDztYq;{ln!Y`RYU}6Ba4dTZSeR1
zHn3P^1C4-y2+gl9Ra83i8oET~>No5(4!m7o%3aUi*1Y8u!&WlsnB{+G`Y3Ma(I}XU
zu~{=XCc-cfyB#@1vDk}?f+}$I6G*CnALf>NqLOunE(%bjV#wo$J0!0Y{KviZ_i3!}
z*Bq|B`&A5k>7EhN7jbBw{xk#or7Wfeb&jeq5F#iDI0Uyloz7=NZ8P6fNeJa;npQd@
zu1eC1tRs3SI)mbenf#TeNh0Q0rz{rFR}hx)>#f
zUYBfcA>~I_)eQe$%AA_|jBOaB1ZQBf=ns`*fli@V#Q+KfrdvvhT($AV
zE>jr+<~LdctkSMRB^llwEo!}+E3
znz!h7*v5*vgbg=u`x)Wu{xaY=EZ~dS+xwB!jLKk}v_yAi8gR_ARz?-@6R`O-pXlJlGA={n7KhS-M^-v`7jBOx&bHqjNyzjsoPXNcXqz(^`@+dJ3K~BZZ
zM`%Dz7!pk0vxAM?MaOpj+;I=H8JQh`VCJoqn=9QKW>@WgKLpQk;V=Qp`E^q(!LC?6
zV0|eJn_bPwABepDEGy``C=Xn0b=&DkeDXxMJBB`I_ThH#D}@GsXHX?N-7TNb%YO0G
z{l!^%rpE<4r=8%?G$F$Y$TY7RBevlk(X{^{frj8G^y9^bfsK$Gid(=C+M=L#cf)
z;oGrL_}LjY6@VMpyy>^yy0qVYc3bZ=OzE&19X?-j1Q#L3iroJbGan
z4~u<>SzmoZu{Vm(nw86sMnb}qcwo|#R-1WyM|G(a@e=PQz$0m9F
zIp-}DN5sft5g5>nMJnseN!Tl0DMIrIF}SWq?08ep)?RPB?adI1I*>XP_)ZlA@V*4D`+M(XejktaHyQ`Pa*jHUBS8amek7y}G&Q=pCT@+Sg5x;+)Ql@F
zWJA(Ha5NB8x?R*Iz~cwR{w4@If(p?Mo+av!yQJr~!;1c*1+SfW?B-zwGDV@kdj2i0
z$i!_jyt1IXT5
z-DgiZzH1T{efZ@EM~%lX;Ww{HCgpnGkAz44`5W?-`eOa}C!5=YkLCIMC9U0g=-ZCG
zSYUSSqB<~`M)Z!(M7nwYc^zd?kF6J`$4%RZmxdpPv}bsuRAacoCnqHLiSa+r<368Q
zadUvzOWN)5Lj&GgS-7ooP)l+w5uZq$c?(7|Ns-c(xP7U{btvfteZ@clWgxj9Vbpf}Pf^w%a$
z=n-Pwd$;DAKXox2DG`26xhK4SplsQmbFfQwdvtd&cYhj#YsB&7Mnv#E(uUjrk0@i?
zb6urf#o75Wb45+1S^qC>0yZ-=RVsyV=UOm!4Hnn_1hOjBP`+OyOv?QA
znGCX5V!XHp0Y_s5yloVE&BP8GmCZcQ1H`v)NIP0!Tz2;>4p-%CV|#ePCh%a%hDrwtJRGmw;W*>v`4d<(WO;vFX?09CE8&S+L6rdDsCK`&BP+}9nj9>9*hFp~Qr?f|-
zUV44r6t%pzKe~3Gt#URA90#&3e&E?83Uu>(&$#!rmgTDHvt57QthZAy_op4h^S@Rf
z^0&2Sd)+r}xb744?8ZQS0vo>fHhZcn#bSm~3i^$hK^ljyFhAYvq5B{wHW_8=VizDpRUFbyl?fH}rv;hz3&dl7wWss^R->YHAwB
znEdo~eOy5!G4e)WRr8E~;g7pzw0{hKrUJ&aklr5MSS~Y8AME|(AmNW1toGsAXL5(~
zmNrY|v%){ON81nZg(z;|_K!Fb+{13YAF*gU-EP5)!T@bC
zyIKV0C&c!>BZ0>O#4#^`8Hb)mEWQX1+ZOF>A0z!br4)PuehZn
z?e#n3upTj&(EP+`?TgJcp95!gs~c2w`b}Z{_R!b+@@P0=!2K~HOp=4&6F&dV%09iGD+1x=r7KK)(aOw~
zzE8#PGOst9=(d{!NcKfFWtKwF%rWNk3=?I`vdN60VGH6Jwi(;q^Cw0VXris*d9Q23
z?&Pg4u+F^gF?w4GJ2`-ei0rlbSqJUnqSeP*87v
zBFu1eysOm^c3-3gKG5g9CcprF4&c=LVHe~w4QgR~72YuO1#
zjx4k=9{zR6NtyrPCHQsvb$DI(<{?f0+Y%k2*iyG#B3Jst-ezM=Ve!M+v;q2N~eI^&t14>e5<)^007Nf>L|YHoKG
zbQKtSzEBE%TdGhv3>8^sw8ZI~j`<^}vyDmu`|~oKgT#^(>+6!z($wv(M?dqKykHcG
z5vhV-1+%UADvMgDI$-pD3CO1OJD&kAo;q!_Qg0Ihy$VfWsgD4-VLl
z?+27=9|zivx!oK7`x5+KGjA_KU)TD2cdx6z^jh<4X6*Od#*oIjq(!Vgl*#n)%R8c&
zHlD$MvBbThi{3oXK__CWPYUjXQJP2RIE`54xR3mR%Nw{CPyrOMUM74mbyBg~aD^I`
zC#8obRpr)zo2coN?th2<+ZOk2JJ;gALuht&v43xVrqpkS)Ent)Z|p6A?P5(gU@M!@
z$Qio96=a~Gw2uUJZD71?%+!vS_M19l(koBuq}GD){(}tOkph)EdH+32hqS~}S;vx@
zwF#k3{>EV7ab9r|rI?tDfSW4b?-ERObM~f>-Tc_@CJ~sN{LhEs?$SJHt__g;qwWWX
zzmEf4y|Bqtz0}%k0ngwMu~T>lJEgV#+K9J9KBepc0wPpot0L?5VI28!L<_%C^~q#X
zDA#O&9llMBR>0sIh3|v>6v0`o@fa~@G9o`7@4c<3FZs6j#YdZ`@87|?{c5fnv!bg~
zhkJWLk5_~vb=@3mx5U#+)8%n2g^YuG=en6v2ZP_baru*GW!P#QX@^CrpjLg2UaqGy
zddp;nIDBl2076b%uQ=e%$OPWbq|(WqxoF12^4<^9`?9GLrO9MB{k$!=pBz3&EbTpU
z=tl|`YblX!ne=aKd@GG_Aa8uUvulITM1Fo=*4B8L+=rgPulD1f?YkRtkLDXgyo$GvI`Q_n{p^n3M
zT{LD|PwcrfOb8;{hpyNciajvJ6>Qi09G~mY%m4MBPkDJ}owNOc^re4|mmJBbV0vra
zbBiWpkxRC_wZ
zaCk0DusjSvh_tFO7tRUseHU^nxAx8YI%Xeonw1n1Vq;
zpi+(WXuk~435M~TxMq<6F=;dtrLQ68FRv?Y9i1mt-OWiu!#DrWdUwPL4TfU|2R|;M
zwhxUnJj!}&8+h6L0MJq}`qMdfFS76_;*v%{RL>PrNn*|ipmlbEJ<*LWUv!E6=E4P^
z+r6-`V^>Ac`K5gWm`gF5M;nFs2h#LApVtsuciv1eILYW!JW!UM{tQUUz!L|f1zpMO
zayJ{Z3COri=Flu?mRVYIx1i5pm9T2F(p1zq(LB2EyhahOb2`suS|lU}
z3DhtwELw~m!a+bvbg+skp1YW4AIEH(K3+5#E1c$wx^Y}=!k@B3F#Q0$2y?7vpf^
z5?Ix|@}2fSoNk#@oq6MJ*T5T*E@5KSR!%V#B;ZUS3*_<7CRw{sNHnosfk;UYgwIWG-l^H`)%GgAv{g
zk;m^9RaRD&)t&tLle(|8EK2nL2YIE(jP2`o+t9rK{Y6bf)9JG`y=a8_MpJsM(2Z_v
zL8CBs$lW$1#S%I1V^d5xs;qG2w>o+)ix!4Iq@lr1o|HOiz12$&RzdLV{RZnJ;8pc`Wpu}98(*hTUA@0n
zf4A4pF2FlKo6}f^@UMYg5dH?dn`3e{vp0B1z2k+k!63F9YlezZt{F13EP1&o|9*fR
zlwSk-1fTHh`>+-|?bvi(>Ddsk|MNMb?`gHeFa#Fwb+Mh+bBDR0+b%)RV_m#+#Y`A1
zqE@C1(Z{}q;On*x>ZYHZ-J}x##xz$z4>lJaN?h>eiY4eAEI54r=RT+4U1YxTx`{~=
zJn2o0@z#JBz27?x7GVIGj#b%o#(0_Cy5(wD>g$=zHxgO>K07YNfn5QMuDqGg%k6^H
z0W>gl2vb(f1q}_B!j7nF#hg*8+7BuJ&wE2=pDVc@@B13xr`^R3@6ll2qmKAuT)v=l
zo@VSwSw#!t;VUvf0fFBj{%^sC^P9>g>*>@r8G^-OaR8*Kb}&zY1GwBA$H(=RrZ1G$
zW_iGXNW{;cAH?l?i3+{(w(1OTfEtSJb$JgDVi6W$XgqXF??*t0SG-BnS=>gqPun>b
zX@l3+Y+M9gT?pS5&Xz-|%I~x^O~d-3tjVEb_PzHX+E_4=EZ!@B5X3Ye+z3NZG2lZ%
z-O{15i-XZk3^%m};yJ#=f4!O{pdTq!Z}KfA4>n_b0dY)8eb{yt-SwD8j6
z`)E>E-g)Ba`2xS;b&hr>Fy>LKJvlsTrUa7%i{5^`%TUoA>q^*6?nJ8>!jLddq8~nG
z;}Nr(Rcxkx;3uJKLdXl#b_lp`^t<+VzuuYv)U5NYtV`(wzyeEXvq=w25>%9uTeO&6
z(3&V08XWJ$2__`rM0R{!9}l%>^+uPvJGpP&sOEFeOKetgC2gy>_lBPKsn}TceN4=;JPD-MOVm>nf|=Sy;pIANEXD
zm4q@M^@QW6*$R8YU^y0do}8DwMp=v>5z3gjq3saX*iMS#=fEE?yl8v=Xtf}n_dXH8e^udH1W>gG913nd
zowh1l(m79Bp_6b#%5EQ!-$Tmz5SI|n`GKbU8)IrnU?nz?kT=k&z>E%1e^0m<#&>S#
zPvelRQir({$Su(ipN>O{2^6jUy+E7p#X*Dg;`m$MWKkF69YpA+Qn5T!$d45fvE`t2
z@8dXUoJm7aG5p%tBttd(uqogJO5^&}WZ%Wcs-k9h%&fYeKDu`MD~?X^##kj5b7g>t
zEy%?-dTkuRMuXmBm#19C@qA^zF}+HTV$luJa$D))O}aG8(z5nAuWoxN^SUP`DvQ>4
zepvVO=#tv7p~;O3`D4dFCHu$t#p
z<--c;B&yraUfpOFR~0IwJbFB+Vv<02CQZ34n4$3-X#XRpg6Fav7-oSD-Aku~LEOe4
zd2305s&f27l>%QiLnQC}lc3RlgTX;MUDQ>bU$%JVbCAm;DhcbkgRa;t(p6P-;Q~JI
zJm&3HS#W3gjgyAV;j#FDeavXN%(M(6oGf;tI54)+*5)&|58RY$tg#?H-dCKoe7|K(V8b^XiQ&mgK?SYIK{bFtY3%|u;q
zGa-o=F93Pj5pm}2tN@7*aBnK;VY2((zz-iSj^a#^&A0TYS9UZN6F8C#(S*T`7Z1Gg?;%!<`f2V&=SusU-#dS)b54k
z)|ifTQ6A;<=8t4q1Nd7*^R9l@Zt;UcCCVgf!jX#DWG6Fm2fG4(=PkznSkw7q$Ct6e
zAF3{!2fTSr6eTFaveRxysHKWk$b#X1O~qXw|Jb5PYMQq&1hvr-nbA;{SdQU65R(4H
zRjtv#YVlMzoEsp>|9Ub3zl8`U=l6l5edzpC0;dkkfbpUbQ3vw3F(V-Y|IYN&|KA1J
zT-~~t6;LLOS%P_8_Za5eh$&4L$(DiG{n5SvRnoVDHfL2*-`}F7%W{O_LMA^n%Y>
zfQ*qKftBy8
zj2q8_E0fQUBWEy|%j(M;^dtBRdupgPgI2E<#=Sv#!1Bx6cFXvVj$c_-SGLUA?E2JD
zSsL4QcMEGmU=yD`y2plfKlSy3rdZ>f(Q4p{#rH^HbPgco?>XSN=d(Y
zUGzG;qZ@sEef6kftAjHL>L`9Au7vhgJIqB*!f)L2=$QDAuVsTvgL=c#lE}5y+>)i$
z>Yuz4WP}KEtsrL1L?|+^Os7+q=NIlh!4)1JbBc7Q*-KA;_qd(Rot5oYy?L)L3K>KD
z1AR^W3|v-Yw6_@FLtKL>@{gz%B?9Ap3f0x(2L50x@c)G-_Pp~Y_IM)x({W1^srMpqa#C8i
zVJ$}OwnNA(M{?3iIOg~nS~i|JNM35;ceS;#L}A68@n8&ZK&Q7R{xS_AdlJ#|5{oD?
zIT89-)!usYk{;pSyc$>3U>=V#LAa-zx&?uu!T
zP+wK$YyQkY($eq6ZX6gQJbxn*_9e!k
z6IHFD44z+Gj<%s!_P3(IT8u1sn5uO=zZsVJg!uDnjNI(2UQ8xGZ=u1D;Y4bc1}l;_
zS5;P{X?xBJo$i>5<#Q|F&yT2*V-r*bTE{l##f%uH-s|MB@0^A?0^N~OEyYcRedA7&
zA1zAk#73BUFdosjpb}<3PuhLdXuu^RQZGUslH!VtFPMF|Y%^-Sb$mah%S2fi$Sm(~
zkS@-EDPV{(B~cHj6@y*O#o@)A;-P@3C24
zw=7>yMkjl`d(^^AyqZ|KyW)n89_oZ<2L=SZ7VEnFjbKq>NBgQxye+YBZ9KBZP+Y!`
zk#hWIGW~Cm9ZAN56I}^0WTx3os1S2xe?M$v;zB-aeW-4mYCP@iZrpE#mgnIf35OLDaHbNa7e;kdAYu>vT@OoeO{1AkQb
z4%80!g@uk7K%j5tm@1c&|H(Yh|9mHr*~PNHdOkWbc2Fz*H^QKlajaC!Dd-u`eO=4MDN$ZpNnmI
zgH#9<8e2Y^3k6a%G{{QK3?%3*Qv@H8$Hum8IzI5k1vByrCn698wCBUIeN>Nflj6I(
zq&?INqixtmg$YaJ%nege^Nl;x<3!E1Scs0M(dbTUW)g*myEMf{n9kerJ;19sW?(Vw&IeSLnYs5YA`^4uK9
zEFSu}`ZcnzL@x$sV|7i?Mz+l_b(e=MUj&*w
zj38mP4?(tUR^3x_I*rk-He=3dtd{WujXGWymyc;lsbU4HQlmHD<1E7WcRcyEeYaUM
zAGg=ZVn{^)!3jykh=*B>kq={}m>A*1UJG?*-z1OXy_|-o(bn#MRsEZ^t&n%n;aDWk
zxV@OFmY}6BCzAv1ED%5y_)Uc+NZdy&hznGs%-0PYXXo-fzAm{W9)_3}y+2hv@_)u6
zVTsw+)fQK}*5_L+TQGZvg<7Zkg4Z_jid2>~vY8r?FkJj^eDqa>i-A8PfI@>N9fRn^
zB+zzY0o{BmBWxdA^S6|i4~M22+UPVw!;yJ9j?CMj)O$0+&^b5ufitd)@sDPt+izer
z6$GU!z40s-e$KLGR${iic(#XH7QNO_WHY-Da;5z0(33hamr~7x)#pwVTWjBZI;)WU
z#G9XHUvP_QF>EZe+P)nobkrKtl;L!g05=g7T}Cq%xtD&w`{dO0g`(E_te3Q}M*0go
zHgzfDz#YTsDIe5?N8mqgK|GW0uT;>GEO;wkDJbZ8G_P5Ytad7d7;$E8Er#*;Hj-hfE|w579!K1BQ3-fsjDB~FcTemuhsE_PPh$Ag3jNKSk^w0SWqS|l@$hCZe+45h9$9_=
z!!1(yA@1u-mci*QO_KBZb;X)pCb!6xB>C}ZLA5P5_Wf*KM_GE=2whP$-tfN!QPIa6
zXt>}9%sFl2hOs1&~FBdjeoy^Ad`deYrXzS?UIcAHvT@(+^i
zt4GIJ=;@hsK_2ZnyZjlNUPE4Sb&?}CnZJn&%MwItxCo!iYHW|*`9ya7u-$>&aS)0N
zcc{VP!+A9E2s@+pf-{#mHlDK@Q&7-7bR!)!#MngY=;S5thN@9A*>d+qG6p|HD!lQ}!6x&Y*w{Dsi%D3fiK)qfQs-z0!7QQ%useHBPxaxM
zj(s%zZ-RHF;Uu}~2G!=5hGKk3{26NUE7Lm|ui+62;=*%}4ssc&V5G8~p}C%R71Gm>
zYEY2yk_U=hz5StjSk2kwvEDtsK*d*wOC|jCdMn<8ZY_akX=60`o4iMhKK^|Aw#UhQ
zvD!aT^cr5ylGrDreUZ)F!|$VJYgkQCZ_vvX_3_qLZ$q>>-MGds}q&J4EBJ(
znqvSl1HzMO*cN)fdeJ*kv`O|I9%>~aPr`04U6Ia>FA;CwU}+2_QDRL?fgpl&z3T$;
z<>hLIfk`i1C@pwRSuy3CiSxSP@omFL8H|sx*evx0Vb!@aOiZcmD^MxScQnT)`qFv4
zZQ(dae+>3vKevq`J+2RKUsrpdnOaL2N>0&`t9hCiYNqthwouy-Ccf%#a?BenLdWJ!
zPUH6!Kg3(VNs(wK;>DNi+4M=P#Tl-Tk5d*9d_ZLoA0L4>*8Ef6yWT`H7yCqn5FWrY
zSbd4pMdkJopA{lsuqMTY00YHK8kLx$yKZncHR8S^(#
zjhXVHw_h1ta69qvN80wLFY3<4vw8e|QOEi((&5Q+*}2HPS!?OYlFMrBXW@R
z%&JGbB4JGvs!|`h^0+iF|24Rc^s@xf=HvvXmLFG?dKz7n%UNz%INpRpm1?pI6`#sc
z=$)Mix>n`Go9>TPacmakiLbZp9Da|~rdE8EINAR3R1VE|Z1Yq8z9$VqIG_4X=b4tw
zmTWMgtn*G3a=#B0)si=&-l%YMgyvNxlmGP;7Pmt568LY&QEJs`V()RE-8eR+(~P8(0Z*nj
zP7M99*8uTZY{BNoITAiR%$6SCOcbS=TCFtG7q{}GT(J=Q?dx@e<;pB;-G(S1f>Au}
zG>Jrmx?h!V2r{O-Db0C^m+v;Rlo%ZZkrr7QrwAl9A&j}jq)$(CD#QVfQ;GZOP
zpPA`I>s^yhpA=Ar+e^XiX?vmIc;E6d_#DbKwl~1gQsmNoXHaHtPU~T4@88+^t#z+@1>*294t
zX8wSki3#f@OVO;CX!35f@!Xk>wTP-Ih>>^>keM18F}d&AXOA;W483J#izCk%(y9l=rux72e;u4g
zZ8cyna3&R-=z=-f`o)Z#br>-=d-kh)Z;poH6M0(+mYprS3dN)gQ7`-O^*dUj?fLSu
zwVsFv)E1MIM5rhG|K^*0w=9CDzy4iY)W4PvG8*U2;K5;lqUe!tP_N)fV!t*KRwL`q
zB$P~+7rA_x?9JUzZ(!UJdCOhdnXt>XM*dooe~wBb+Pz|Q;AE1Xpe1_Ijn4vYwIfYF
zuN#T=KEGTeP+J3!vay~2zmGA$iTQCEkZO1WYIG(C=~*cCB;!e~iH}XfTB}cg`ke)5
zXW~Wb)D}&aGK|&A2|Kru@E_o5yS}_jZ2b1E3ia;o?A%FlYZ0$4B{%X>TGIIZvOe0v;x}^aVF9Y6jA}^)Nh?PR=X+0{stM|AAZ6@!_V|ZiBD5h
zJ}nxGWsR4;XX@AGZOQF1sYMW$#!zWTm&Epdv9$CThLTC3QIO82Xtd%HB49PfrSyrY
z3GTQ|{-%51=W#L2*qj!T!r=C)-AS;Ig(Ojxz%QQ6FeQECS9FXt+(1JWT1|8na?6|Z
zo)e~zEpO!LZkS88erZjPDU?jiBDz&}@L3)1rqS%F?}vm-9qHaHT(F{#g<7P+Kx<4{
z`tFne{Y&^e)rG}-E_d1VvsNAJoh6yWS^*!$E^!dvHQ`@(hVyFp_XZ#7S#y=(->CPT
zPCp$oml@#xXiF4<#k)$|Si$rrLY*Q?jJz4lfH%k=5+LOsmW(h(GcneH&QOTHv90?u
zQy=vq74mEN@a2-30n3E_(Z;D>F0M^hO#MISmc3Be?&(}1D*Q@$5NeFRLQIv
zX7+D*6)K1If1K;<8cvBDl33c6SeBN3R#p7~;4klqWB1rzA3^WqL!T43{f6+0Wkpq0
z?0Qf{1fr#tm5OD5V|{&}QErIA`O1^oER6S|i|rn4=|wd*%Z*I4MPI*t3$-Br&)m(~d2;1x80EY)quJ-~
zQ<+oyX{XzsHiZT`uWSL_jJP!)og}$6TF;>~n!@29ov>Sv^_5gT-yfh8(P){IYu%ge
zCHA0OmcK|b{TsCm#@N^x=nW*gu%n6S=|vTa%A*;o{V!2bFx(>DJY5p>)sy&Kp{ExW
zTAz2_ELnkWyn*43U?6d&L%bRwuww?DJ?>-5TRn>Na0Z|+h(V_nOMXVZ-W;8SgF`x@
zPw3@5R$;NRTe%`jER@CPADA%MdhBij$**CX@H~Z3nJI{KTjbYSS-6F$NQj-GkyB
z)AOzVP%J;kaSPC5X1&sU9=Dfr=n-?eZLdh{hz!pqB1KIoLsJ_;?q_wM5HIVm;O>2}o(6EXOoX9qh6M~%m&DQE=x?Bv7-_nuJy
zYJZ9!5PJZQ%JE{DdZx)v57IXaRyDoI0rboLJmRfoP|?*LkHTXE>k4IKV`H8kGPrF3
zoWTXe(sHo~ShVP^Z9bh0meV`)=tWV<0^P|%UZE=CBt2cN=
z28~)6`581(C1quQo8>4XK5SK0kC*#B2qp`3MHLkk1Qp7ret~R8NegT1ow;v%l(@(P
zRjQE70!29O*8T(id+`+E
zpj9da883iB#v631wLjl1|Ch!R7>-F@>w2PTX=#be=gM%_`S_`*4JMrt+um3hfNmvd0;6JtQlV|(fXt2v~gDtTO+Il|{
zzOMt&s3%{c^rETB$={%P)8p}^X^Ne(^H&WORACVYX;z%5(UGOoY
z&t77MUbrD>C=(NtcCd+QbqFEvP}OmRZ`W~+9g&9?E?!bvx(V8uH$azKL3MT9W^bs|
z?hiBaQPx<&2O0=ejeyHmTvZkHl#VoYUNeGEVQy_LM~^hHcR4jZEegIqb&fYH=;@lB
zon?03S4v^hQvm&WEl(Gt9>+C<;Kw`QbnT4LSM@O?V@W`|;dY|f#`SxG5YDgLJg+Uu
z7b`4Z_!*d@G!fO3IcF?n}zc
z0X)^lUQU-``uP5<%c#HG{;Xd}r;wBgyoT?GB}?sw$Vk
z84b>Sk=zea(9Tz6@#V{xfG|o#l-{4UwFv;)hRvuc4wk32(#=!wi_ZknMDHq#NxCWZ
zb!Q0<9z8tvs#UVwCtf3UQp}84Dwi+KZW}L)dqBFaeH8C4
zq9I^4hoSp!xmH<~5<8R+x87MYl`nG8qgjY4sMlbe?~LE~GGqPU!%>wAuz%}kW}ssb
zLJoi!ZYZn|AI?D|>^UGI47?rPwC5HK{(aC2HjX{F9O(C5S#l`n2t6ir;+cxD2iCl`
z(&=hSst(e_=yl4I!l;!}+i!p?S)47<%RDqTX7YG*!vB0V<8a&S@Wxw^1kwsBoBAnw
z@aU_m3AmCV)-Y?FLxj{Gn?%SH^fpv
zwl(N}ZLMVUd2ohM2y{Vf_g!G#k>`_U%UKm#0Hth-lCEyH8pWPJJ
z?SUG@enhoOZ5a;_9;3mSlX{E2-Q8NyW-l2_JVs#G-VM4kM>=lTGOq5WL!%j#>8fRu
zL&A1pTdlOII|7l$?;p@rA8#s0$H#Mviqe;s(m!QA+ZHw0@SSq{63>WdPJpYTKru%U
zT*O~h3qdz%US1wIUa%;cx1e5q;m4G}?DBQ8P%0@V*`9~Ax3(-#(tO?}a-)Faj+sflS9{j{NXX}a%4lJ#e+vo1)=H_9E
z(yiSxjxA<^JoC%p{n%JoU_Hvprh)17^%ZQb%%?#FrptKHSv1QM>Q>;J>W5xtc-TN-
zOd;1Lv_BLkm7H|srCZFzIq}Ng#;g;H0l@;Z<
zbyOPGO}UKVe@CuBVXZSiJUZIT9L0@pYGzhU*}`+%=i|3Bzub7@PB<(>4ingY*TTKt
zHX(GL&1btV^m?zTsi_GXW_N)rC6{sOc4|=Tf*USQLqiiLL=b*9JU%W7FG7J4Zl@m#
zYzRWrZsc}ttBiX52MP(%lsVhTGeXftV(ZbKe2;CU5fA;$tQj4@#6$h^!EG{(jLpI_
zOPt&3#Wz{UXUB_mz-+muhAtjm4~*UPb!Bv?k~G=?KIC3sMS(NrBhyEWxw@5%wB_bn
zMuJh+f1W-9Vcjy&TJYqXN>Q|Jtwpx7#Z3qxn07r~3D2V`DI3uPYGQYUAxuU7slt7=
z1d5mEGrvK%;HGuo3}Ar=6DbrBh5((hJAqQx9Jnflsk&P+e5d*V5DCF-5b?Qsf6~Fq
z*-5$Dm8R23IluR|5ZMoxsZe}u8!3)^bgIIkp2>W_1M-?K9VUftKpu8}?WdH;vt(d`
zFQC+zDvzn5s?70$_NChykMcPCcsb(^m;rFNMWwz6sESJfrDOy5FdZG8J8+h^sqR7J
ze-K)LJ@d_NKhE8&Z8AE29=|9lq3PW{KU{yLr;nu0
zb`Q9m5bF8{uha7kefob|fE1I{u2+xE1v
zVlAM^;t5;~27p9)bu=FfuCmMPD!(jnPeM=xwq4Jz5YqvHT=wJW$pJSUm^8o|O)ga_
zb{ylFw|_bxbh=qIb2@35hX6o8d-wKt&9c!m^x1cVW!j=4PJx_
zJ^4dC1h=y_vCbwg*NcY-PjJsYowr~R+THWZohM8hpe2AcAWtva
zynUQQR!QT|3{PAoC;uemY>J^qtk^(X<1%
zP&xst3)Wwl^z;kgIUO}yw)^qv(QYH!%%=CMrDk|5vV(6t1-oiLI|^1ITx&@RG1XGp
z2h8j@;!y@!-}Ukk73^9+g%=W?b-fCL`(b-lMe#52-NX|pfPhXOT<@2=V@7jjs@m?G
z!Tf;xa`)^DkO1eN9pDw(b(vCiT=75i2Z9S65L!J#!RZ0PWFLsb
zhEx;<`aw`X3~uSIzfj{x5Zvwa<1JjC#MD{GEinXU3vpjlOu#OvEjT-oZ-03>g8Xm6
z2FWj@gJ4rZh(rR}g%wR}hJZWk4R8UwX+|*y-~_DL_oAG8F^#g)f2)MRV0N$P^&nR;
z#K~N77$gFv)=L0$onBZN0?42KGv8Z2NDKu|l_-1+&n_-33VvTtFwze`w@;9#X=)OzcnPx7@CI(K0epa&e{R$MBZT
z)U3NM+dSPgbw%qn0Y@y+ZQX~JfYV?_IZwLwm3xkZ$PV*_M29RTP`R0p?sB}FKC?Vkx
zSJ%C~Ac*VkL_x@Dz1$eR9m5yX;B|?4rZpVEcmXSo
z_?xk5r3WmhqJ{<@AV%W@ukKM>3?@hX;+u}k2T061ku7iz_X?tvpFe*>NhrHtj&bqa
zt~lZGI8t=o^)schnJE+-!SU*F&9Kj$darIW4dyvLtZl18B?zbFIW+gic6+?5E!W3a
zTfvgE_H^;xed*+iQ&-p4(UEs`P@>@ha23cc4Qv!7a?KK)
zXP0l+wJY|j0X`E5GZ0_{v9Pe1JuZv^35o^an807$em+2urR%2j?b{%L;P8Ox#bd)C
z4wuDHoWJwO-P&46+nW5m3lJFRTvqu#M|ODKUd-gYuy=Oznh2eu%ug+N@8^c5F&jVw
z*CmTMudn+1BipJ=e8+tp-_eBsjN0GZ$9R(;H#ax#i;M<8g4NEK>{
z6*zA#?7gSbeeKIlJ)Qo!&?X$Az|VV(n`yIft^j)*O4(T5Y{mrw)QE@@kWoqv;-;#v
zJj!&QmH~^Yj|&S~qk$;AEMGUk*wF^y6$q{c*n5XXlT?R3bSY9948Zh;1n?l5xj9`O
z{V5X24N^}(m<>c%@XakP^MC``(FjF|;|(@Qxn={M?(Zc~BQ3H3w;J%D{U`SFD=JVV
zl-0X@1-@xJyaSf$y!k5#tv^b|^wpMss^U{`uvGOfcH4>#KWnhb0EY);b->04ER(Kz
z66n~$UI6wU{F|z$psPzlAB^*9}<+W!!xF#l7
zrdJBjW)T#4*Fj><{-~nK_Y_A)RaLEAy&G5}MZhEnBq38^sv+(_#4bblEWkgX0`|Ao
zWHb$&M;8|t5UZ$F>5c(j8pPoTAt!`z4ahQ*QMla@g!n;0A|xpW;7GiSi;ED0L+Eog
z#SczXQgU*Q@h}FULoZtu*aAfh9IENYZ+{2?3KCTSW)_5$Eg6m954cUh>oo!FA#gNU
zfdvDJnjT>OKe)AAUR(etTOS~bj7>~f>^FWZRN-J_Lo*xnzyLcYpzHVS0=fJ_5(t-B
zU%2@8uyy=&wXL+gTzrNd@&n)!-ToNV&vH=%u1{?6?(QxIVlXbdIT}dLK!{xaZ{Z;M
z9!OF{ULFN(cR&;p%64|}WkQ381ogmj_5quHu-wGt^Kca&O2;m51a1kCI17Pb(&RHZ
z9X5k;21q^?U-&Il8{~M2G#TJV5%MIw0++?TLl;7@fqW_uFx`Wk7&rJX;Cv=~Gk
zz;|jok;#(?@|PePrvSnQN=nMC7$5NW0}nxAo{?z$+YCDdJrA}-+gIae0jj~)|Hg*9
zkFK|_J+wgb%XOW)vd~!QX@D|SZmHI1@ZqUlwCops>1tb(iV~ADsVMw;OQR*FA-Ku`
z5q>ECBXC9`uGA)=>5%jB@#!9JYLm{egNUh*IjVq#qBvq*Mi=ZIuvbIT0z?8~K@hkt
zGA>2plQjCNt$aR#E}W{(D=(7IG`Eb-@2-~wlIz=AXe%om)eHrvE%V1&}niH2>Ta{Do8;lO0%F`R#;z*I1`n$R&
zkS+pQhaRx8wt8V(osNf3&FCiPSIhpct*o4ADmbbnP=Je9&Q|x0NLSP0-`7rW_X^Fj
z3er);6dOsllAhD8lvW&ZyCzxy{)gDd+S*!X`9wg8YnpkV#*p&2uUv3kJcS~BWkuW3
z$%(JSG@UAg%WfAyzYgZ2YP|egw01DojWnObo78_03~+
zDZ0v)HWQy>{{nk>AY)Hx80GVg&lV5mBOl~Vj9f%1#wVucp7G>pcmgApH0`6%9m
zxS0T(=sYT}ip3yHD*HJ#udS~@Op=p15Seu!ArsoQcw*J2pJ)e%Z>h)xKNP;wWhOx7
zt73c2+`y^vC#nI%FFX<-!Ef&zNm)))aB-qAvaU+K))O`DYnf||DvP(IT`1xIqxjhN
zzomy>f4-EnSyn2?F%hJy$G1$0^L#@J_DuNm_AtaNM!~Bb^mxW`BCt8Z8He@}n9FBL
zlN6k;x(PosDl}ylX)#!ojqzf4PxAD0?p%1st0qVTkvrA@Wc0E*7)DTH^P((9$C}l(
ztyDpKXG1xV(fiC{)XwzUeM~feNvO!f0HbGp@I3o8fPkBhrS&GoDmA
z8apAPLe!S1;6)gXdH?3%ls$eY3z>W*F2#b3p0x*CCJ}i!An^Zx29CYct`K#CBDA!W
z=)swe!)P%IygW^q2s(*2JY(8VA;%PigtbmdYiyvbgX}44X&XB!@L#V^3ig}~dW~PG
zj6M2tL=4ThyhNW9ibVJ?Eb`=#*Scseu~nR`sQinTLm`uvf;T6X?5W@FVS=Zj%q;&4
zGqUw>8^+)rWFhdbl6F=yw}|mRkOWyQ)es8bhR{>w?9T0#b#d&EufftwNo#jL@6_eJcz5A1oB6y8KEi06KWStQr-kD_gzf8_T!`Tn
zyva26a=V#5$#d0QkZzV;5aj6g;5hjiOMt1}U^EPK8(Qpw6Nom{O=`m=C}#YO&x_p^
zR&7loFZLzL+^@nUz$QQG>ZAKW3ydNk5+xJK`MYe!qLE3$fK)E{Y^}GCn!+i<;SK*5
z8-<(l&iE{#lTZ@4t?&ze>^i{ei5xNh*pSbIjfykGC=yVfOF*kpUaJY<)sS@j5vlOa
zuho@h$REmP;w5qb4qGx-Q8~`rU!h?l0lF{g=;RN!W{!JMN|#{R*~0cv+olvvaR0w|
zP8}Iy_Une-5jM(4DDPj+-hXyCbo1#~Q@_dG$bRi^+UvPzqu}lN5y}`ii(5;--CSaFnvDgk)}v+v=WLNK8oAXFZ&U;{805O5%44a)460WcCxAY
zU1PES>4fRHYm>l2(eVwF_v2ZBP#5jc&9yOHaH|^kYivM-&nj^mI5atU-8|35F_OPB
zR<{0N&35qE46hqY82T}*eZl$2;f6e}bDVMU!(LSXc&WS7PW$`LYZSap%2bo@
z?@l|Nr^V;7iS!lke-%)iG_j&4
zBfPwSFcVUv-}|Le4c+Eb77;6&%MFuB*$I2-REnFT)^#&2wWe(v83YBDxf0`_MDiUi
zZ~d}X(`V;@5Bo#8%=^6^-g{gT%zvIsh41QMwFyvxcDLi=e|;%-qvRtGu;~4OO?YC^
zJw+TtST>nU-LzBbBZv0Sgt!ygb1)#1FAkx#;@@wpySDhI6V!<)otKT*gNZw1uj{;SQ
zvAUQ)>wo)Hu)EGLYTq`Y#ly%f?!I?-{E&J6PLH*))Lzw39_HZ@|%Mj*KWN
zOv$PoF%^!lq&T(dXXPm~KL5TI-jdS#jUD0dyAr4rlw55c(d9<5QWy8ApWHQywx8z~
zawm(M2IK-8i(f_lT{(T}#Ld=uYp|Wj#X|P8R7@#>UU{9){TNOJc1N~Gp5cKw7Evt1
zL5*L2eVc)gb!<>U;*hA;8t>s?XvA
zsZ&st0O&=ie~-_=k;2fK?_#Fd+r>3gaZD}XF;p*_3v`g#TyUo_Kqu13-pD4#GL(<5
z^;vQ8KKW36@~M!tr*{AK2yQ6dNA%m)k-6FY{bfx?MnbbM^x~21IAMbLQP+#Y%{`7$
zaWx(1MzCK8yeoL1D@L8j-jx@EZNEswqFJVZ$7CJ!j8A-~Ye=
zl<5fQ_||2$e*enYSeQD<(fA-bxwbYA8A5}Ih`7JrC4>ohC>Y_Bpo+Kt`r<~VnEhY8
z6!CpwLR%6AOvsVr0Kk(l%5l+wLlkd7S?6DIpsN7
z_V?WV{hz#{JXzrDw=wJHPcP$$DI;{;TTb(GO-+ex3>}14KLj9qy}10>>O&z|n@~3W
zG|k5T)Fnjb(FU7SzGNA-+NSi7RA7z%m8)mG)tsF4p4>mrI-I%^sgLcKmD{rSWl)LG
zGCuZG-3loen!qi!+M%{fyJVxH;Sv=OAj9HD
zUITpRFKTK7YaL!)&YGRT;{rAEB#=Vw19+!1f~xyF3!&XKp^7S{SIfcN>2#6
zcmHdT$ucLT;_35vV**&fSv|4`ux?`+TAOQQTtybSbgWn6iQUYir2QkJSS>TwRK=et
zRr|0}!#QSeOGI?js8C`*<=waVx%o_@s$!7K;PTN6s=D==AxH#7bSVF#!?S*~&Nml{
z&(}Wsim}yA$(s(HAsC^#>hUHV$<*B(1xd3vAkx%x%b`i0WKrfQl7YbTXy#F5z0-#e
z)a)REgQ|ZX4G3u?fCIX9pT+s*9Pg?Wad>tZu3g#<{d6;HsEeHX`Fsb^Ck;FkZ(;5x&^L;!Uokgsq(Ug%Du
zRhhmZPA^)t;B8+1=|~k#6A@v2YoAwTtd*AXhBGZ?F<53baDPSUOx0~{vP}nR=C50?
z!Hu>n@nW$rid^85-b?*so2-_V^B<+p*l)bG_YHb}2R2={a7Y%9CjL#l+Z7`#BRJ-+
z;n`7BwYwY(6_ptt3-9G9c9^PS7zF}}gyiJwWb!5ut%D@ew9Q9I%@oX$nsp;4>ald1
zZ)+*WZb?23wlR`b)|lyS+~7qP_#B5pQ?~T?E#};b%2pZTd%lXM+wlzL$cP$zf?+`q
z!HTNa*a5%itfxz+mz~hzy+~7Am7v(R>HF?LoPx$Fs*MwGe{!nK*T?s!(P}(~O3wb}
zt2WBI20qsES!h%Et(lVshpu+(1+!A
zj+}h6U~xu)i<~P*y~(bsw>FmssgY>wdf+DTwnVQ}&PnPU@0A6{*-1Uky6F@lMkc><
zA&qPvqoes@{X64A2PrTO59A!{+|G0(A|tz4VTvvA!Mqp$|_re
z-uiibFEY!?yYDv>j9-bPn4K1(B?z-v1T2Jolztfss7wx3z8wrS=t_a9-jKH1yAugP
z%XC5C?j|XH?boZy00It6ETAzO3yULx)~!kf(K(Czzm0lEXV;`hjMcAh{UHp)3we(Q
zEca+PY9_<$QqvwdOlZ{&gIUe~i+va5Zk$xSKuKZ!wcpJ|+V{H#`-1OxHm
zT(+iz0Da~mfSgrtcRwFA#p;T{NUde4^L_SYmzP~;sI#ZNrA!HJ<{7AEoK-}Rk$!;L
z4vn>DJfBRY2{!3WVXP>WGYOl&MQ05U1RCE2y}+S
z5qy%MNO)rVXz)}QBYPmq?b+-s9gtXPo*LkEmeV{w@wZOE{Bym@=S-MlqpXI+!+k
zY>eGLRr@(G1CTcSko}zHZ6M`N74M;9
z&~1|CBFOl9rZ~jYl0|Z*9|ultQl3>Ojy$6CE%`6R3cJn_Wu4%ibC=GrTJep7d-#tH
zCh+K(3R$>BT-jG6NX=IhWW;TMVkx>Q>)1d2D5UIsw;VG1f-#`_HWSOnfZM3{DmV?r
z3>OyQoavSuZMOYhA4x(Cl+@Lw!Kgq`4~rt;g5;`w4|wt3O8}|Q@z3`5%!C9CFc>fH
zPv0q+TUyJDa&A8&mA8WVQBX@dRNlUp!tl9RnOr7wqgQwzrNtRP|IcX~6~_Iic5ZADMS
zW1HF^US@nk>1QUs8uMCD>n>DCdQm@V^~o?BDH3iBWb6Uuo)KzQE&qIhec~&~s#Y8H
z;({IBS_$CA;>@@dK>S3KSp~e_EdWiXq^GApky%|WN(Qg*wCy8DAemC%OVun*5kLt8
z|4YSkQRml|ch*S!U(xyD*WrrUOc!WJSA}_kV}bS;a#`gxu8O3Sz%txy@W`38g1oTE
za*;pm`xos!7jrAP(Vf2eJvs(0=R`7>$I4lBikk$Eown|$QF72Vbzl8yy4M{ifbnx=
z6Yt5YJ0pK^g^z$d_%kwt`QTUMeMEFf%o$wAl;_*Mk
zp`#MAqJmcHC<4np;?T^~sWokP{}WTBK|&WT@ZKD1Y1z?zUY+=_R>`{CW-uwvOq|PM9C$d!;6kgr!jv#**wtK-g_>o&63mLCA(h<13MDK_V@#ZsrJPT0okI4@EA6pOwc
zC5hr6a;M^fk9wcSe94A7whqlDui5OAe_g(PGE#?nV?Eegr}g)4U6mkPg!Q(#KcM;@
zL#t?BL+B-!s=*BIP##NH+@Bn6#Y>Viv5^tUk?|szskiK__U{<)gO7)XC6Za`Q1HAv
zVfJ3uHgSsO=_^Okv|hnpOJB#4r%}g_U~ogcqr`qHVui)=Tj1l}zufp(5*T{5e`Xvi
zZ_Difwdm=*_piQ@*>3+Vk9-Qs5qmAxR${0WCpZ547NPq-0fx;caRtK#d+?K%Z*TU!
zUh#HxKVkFJ5#imyyZVkN!fT{T(zEeL+M#jL@qb#dIrE+h`zel}#jI0_oifcR@KjH9
zPi&^$N@Kd{WgT$lPUsUi8jHj>)POMaw(7Ny>lrtQ`2MO3wVl5)4bg7)FK6)Bvr|_n
zhcArhu$#Ynx6{7Z?4J(>fxAgCQTuOW^%(n;k5JuiuZCFzcXNi*X-pyyl{qbnW{)p&aEfs=Nq8%!@~dgCI-zzb=d?7LWt7%+!@q#sG
zG*uIJ9fL#$>P~jp_=2NcWH&21LVt%X{U?VqX-#cXok1=e*uuzB3y&>y%^Xj{wp`-j
zSC$}S4ffzAgi;LRTykSfrxR<1wLipdzfVX7J`{V82H
z^lqZuU;B0Ns4xUM3^y;)DlRoO)I=jlG#9spR=Sojde}7S3)>xGc*V@s8U@O`MjInd
z*v8QzUWR}fc}$svDRw*W8CPno71n@*rAIS2=Qx*}cgA|o@BVaZF6p}CI}`alavrBp
zQAkJ-@e)!}neKR
zsF9-mW*-ZT{6zTh8EeQi4u5`jN>7^b#}4r!`d=&!tf$ei0?F79Vp}3Q3}kTJDJByys-IFzf=F7EM_vfdz{}K
z#*ZrZjPvmi#4{nwHT>5T%g!sRhioNDepvCVhIXO{w%66;EFxev>xPI-seLU81%GH`
zG+dbUJB7?SE%WjgD3Amm9zksExEP^d3^nPtD1(!Q|0)qP;@lGP4@2Vy
ziK9a#EcQg%W}eU8;6b!3lxE1%x;XBdrUeOs3?byhXnklO4i!FS*qW<+CsW(}
ze+#%xZxX1g8iv0TCx!2$v*8zGC_982e~N08q+~Pxe+gg0NJeF)wJiIvm;VOp87Za$
zS<$gj5d3YlYW~aJ-=c04y8Fe6Bm_w!9>*^nWe>3_->QnLs4_r$S5;N5mw^J*SVJUX
zpPcF_8$C6KP5>k_yK&&g%Vh?MT-u6ke<{EdjMgf*mRhH-NT5g=n!v!xj0t>MxZiO8
z!s;0DrA@X`Z+2>qIJS6s@Wo`=-4o*|*#xg^{WW+w&damiU%1{*bEdvtP|*!8(90R9
z)`@8~W9dd$Nq(odFX|@e7m~3!z)`R58nX}{jp?u^97_BHg_MiO_1A1jUEh?R{m11pxJQ64Q5K(%(6t(Hjir{Z!fc
zU`gzIXTUBWNmA@oIZm#I6|B?d>hOF$@0O5qIS}%l_spqlefzwx3ndf$HHj7;i#~78ZHIJuf#??|%Ea?9`za
zVbj*vA++C+$KSSvMP|K#j;;rrCH(h(wCgu)z9OU6dP^Sa$|GJN4gtDye0==7#R=a5
zi{h*SP_Tt4LV%Wn@01%-!2>0qW}x3_fv6{d6dU5iK_>444XpsEia~@`BrpF$f$kkh
zJAiga=HRXEGN`mG>**;fD7;^PT)SNWbC@B@XfWa9Z?VubElA2#LCUPSLcaVsI?m`?
zO}2%do!Li~Z87%TQ9vN!z8wt_^+Mz)U?`5`UY6TMFUd<>7M~j^e_{(h{S)iFuCRlQ
z(Et+WMw?48x2MKx{!`~|$62AAfZ!tUGAMaNbd>A!K%MP-9;v4U(jj0N$sLf2PGs11
z4udJ!%2>gm*aVS|fV2F{VbQFZzBFvc^#C(jB9Z#U8Ogib;S`h5J#k
zBPdN=41+^i51xgHW*7hBQKwhMDDkH*g-bPX32$0G>L>2(VF9BfQGkjfLUFh-4
zz=d+#8-<@qm5jO6feyrz!U>$M_hIa01j34!KmNv9ciF8ALWZok1IYrUf}T5bu#xI}
zkZKQP>sydvMxWaMi9!JaqHfrp;BAXJXGSwn)Hr~VOj}@x)!_5(I_e%FP-(`3t%M30
zi(KP%YugTF9RnaMM-Gh$<7w>!>!n1IBw
z28`Hhzeuj?(_R$10WncGz3w?8WMa}nqm347K2m4Qi~=7DM5=Szy#2oYNaw6a==D-)
z8}uyPe3Yo!|YOswf69*$q?weAabOs1LuE`30)A$)XR?I%T8R5
z-cWGS%QJCl*dO~(p$GH-L(^48MfJU18fitk!J%^qX^>`UhHeFE1f)Afq+#gJp+ic#
zOOTROB!*6DC589S@4w!){NRV--g8ep=bZiQ{cIxcAjnKe7zeFiyCd%O<&&lCH=?oM
zziW3M=+*TD)a;m9P3bPyTiM(ul8j%!U(yAf${^jDfQ&b~jg3va;6H#>g*0SIpBN+z
z&0G7ovNnYLE2QZe-iO4T19z>-2K*ZRs`KtH1SW4UK<|wi9fjcI<0DbSIgv0AJ@c%sngSv=8xVA81pu{;n=O6
zW}QFN-nI9?E%Zy--Uu!xXTy-$8=SbH85kJ&(P&Eqd=j6S*b;$Kop~2kczC!Ez#EHC
z?>e%kpracG((cnvFVB9v1XBatE{jDjkvaU@?{U<|0+ugtXbh5OuDK&YhaF96v`T}_Lx7ybL
zd5?mMsvm)1Kytvuk6Y2@z54QqX07(7;l0fr{JwmTae?1hN?p5PYz`;yH
zd;f<;m!A+|Y`28jE!Xu?E~Xc;Sw{WEosh0lnNjbbLfVk{1F<=l|x42bay$^v+$9
z0P7^t`X^c$J!WfWCMA+67+GC^G(L_G1oc+BzZ*G74>V-_4EXJ6G4Q)(Eq?7fZVd$m
z8S{JqT0=ZgM<0RIg|M))A{QJG6HyJ!eVKs?ZvJqdZsp@cf#l-82P8u@ZuH9l?KFh5
zu9Fx^?f-9jTUw$4L463hoB)>FGvsXRK)kI{D4XqDYIf`(yr{1S17)y^TY;^VPgFDt
z5PwkuX9ht)N}yus_l+nl>^Y$SF?r}~gBvx*nRvbY&Dn09VKN|OL0A{j7=
zH#aw3CxPq+K}J><;8KFeH%Q3ha*q-rX0pIe_;WGQ^gam7M|3ZPY*z
z5COip1GGKF8w9Rx+o1x;k(kH{#tAeo-|64QE*E;KjW}JlUl{lbSPNG)q=24h3`?bi9H4s_y}?
z9l2VLvFPovixYzHH(L>5c@o`z;NxqfOB0eeOsK**^BwI+iiOcvm$?v
zz$R8E%~}LlCSa*jqbjR?A%de>yr%JEnKgn=P#1?~$Sp-(Cq3{=*!rLR$g{w)S~vBJKX
zPFl2&(0IUcXJ>>qrMs>~06oy@d|eP}S&kd-LY+mAQ^5Nf-wRRIMwH4O%zS#lF0OSu
z%>;SOTn9Fu6GlgLmE_-ee-s-KhH>D}ZRm)?JCeX}+pwi~zy7&yqrwppQM#V!X^qK$
z0rq5ov8PDc)xPMIFX78~OC&2#%`c0{*Z0MM!$t()zsGryBTW<8Ooj}O=>(s2tg&o8
z6iD>?_AV;%0*u_E-srQ`P(g#;zzWe5xb
z$dCe-P|PF`>T|G#YWz(Jah02nJHm5vVzPE4R;r@Ywen5a9A)J$BQ5(VtWN6_0`Y+}
z)r;;+IPZFvV{NEAA&?5Y^3U4f+8M#A%goLm0K7QobRbO!fq%-CB=b6-z2f>R$CkWV
z%ePD8v`WA8mBqoblb>qA_k$gm9+hfRyc~D|kSYszpT*e;QuzSRa0vpFBE@*d()a5`
zNa;}8%j-(gx6d@B|9JpJZDL^bfar{DA6?+3
zwjdQjj_*$9k7h^m+OEIGNUA0UHT6IgYo1|af#2LF#Kx(~lz2jkU_aT|F{1&c4w9y&
z4jL6Bob;CdAm;4*AzoY{c$Eto|AD{R``+RyMtcu9E%y1ZUeK8a-E1R6J`gF8LxS9|
zJJ$a305LZD_pg>sU2nbVEL$q>SE+2c1Zk5$gJ%xPG(b0W|1@b~Q0}pgoMu08!BLVeis}Vw{m3Gnzo995_J7M9O1xrZ8
z+B8O;oxS%tsRuBAAUqK+EXk2sS1L&o?t(2~68q7CqM00ABSmAa2aO+etLbvC%nQFO
zuWMsa+368xxoS321+7{ER6Y?v$8?s~(uw)v#Rcu)7ne1p`z1p1#Fq%LXS-bzt>lp)
z7g{W)`{Q%|)5OqG0yAmhgFxw?!&+U8@>|z|s^RKiuos7Kr^hZow@6HNJez;bLRSf#
zWXLY+Mo+HBXg{3t5>`}=q+=bo!PY^BJN)9d5hAAf(m)P4nd_E+mI
zzo8>Jijxo5)P*zC`zO&DuS@5IMfk(VL7l>UdT>|NGT}kvbt}xs>o|rm>0uU$0kq4Ua((Ku(yAF%2W63
z>Vl5gA3q^N_S5})_H*jI;u8WE5fr5G5V>;!5=klKAyue#zL-w){0Ty_j|)LKl&84#
z#HqGUfekH3Blgdv9OsKt|7jZm&9>ve*kBEbGkIhONbWdF9%v`9E=p{-m0g}Oycm6_
zpQ6V9Z$3O3buznuAtL-cWHAvQFP-NU+-h-8^#k~E{>qc;cioQ_W{E%{g%CX>#UAPL
zXT{~lsS1p#SSjKC{WE=nss+a}#tD9NR_x&oFCDU=|7tkgH-4ic;+8#zIZUQy@oFy7
zE>apq4w9>Yj@M2If8!!Zn_?W(xt0DBuByfz+Si=L7*?3{%lv7vHUSkf3?P3++37?&
z{cAgKBc}PntvMX4Ri3C9+n=IxD~B
zM)K=b(fuhOSr;hR%vb$h{&a0elz7%6QurByh4t683UJ>!Z7NUPx5zI4FHqrMq+G>5
z$#{npsQGLw;+d-%Oq`#@QM;(*No`NeQFnhEoQQjRI7Qw4=q;Apz=71!rvn#!(Ejx>-`
zg#<`HqX$+ymH;FF$FMSL>|3hNtY_Yey@+G_Lh>7DKWUN>fOT8+mpDMPUH-K@5ASxG{_PvE^QFF+rjv+{+?c`hz
zf;oGq`ou5iS!FOdOSuz@Yiw_r{zq9>
zRvMkkwcN<$zllOC@zdOaQaR8=VYKAII5iq2UE>ShjZzvfTe|#ggHOc?vax?e3=@G-
z?o7aC*0G1lvggtY_Pz<|?Pxe_gm(G9SywGTXti-gj%<+rcs#!dTg39t=^l}Xe2Dn_
zfirVo!fkcMZktJn{vB~c5DYPNWoer_Hfma;%y*DkX~Q)Jil28Rr2#rd}iNm3TrD$%ddj6_1HmXVK?pnQSA!K_7b
zYWiFYMG5H1EPoba(&aViQ1eC&O|!fJbX0Q(Mt+D7KgF`drwX3z;mL>sUMv2KE@Ht0NK@}
zeA*pqadQPnXIBI0+mGqvh#dEjD>$9=n-OY1zW>6-`_JJUDrwe|r4Cbv1qCFCG?)_+
z#za(PI9kR)g4g_pM(_XT07VF%4ae^}rED2ac>6z#Ihfe5bPGEeNw1)3<^+A^^~@NP
zCx)kQ!l6t4;FlH3hUI~qqV=WdXWJdLG_C8-ThJlK7Kd2}l)JqI|pJeqL)cuMvInGpcAZgOpvi6I)3h|`N
z9e-0`f4XK44s|#0AP%1>Q!LmUo*>#BrkA=DkbUyn?sMo>PT;u??p%)h*NaY*s-#Mq
z{x$ooeu@{k4(S7ko8N+uT~|Jmf`ZkJf#52UaQ7}ds#oI_;Sy8+0dAg>t=nL_z|L@@
zU>oW$$4&zj5q+h{WT|J?g!xc9Mf94FAKmFJZm%S-kLD9LbL)&E*8FD=tb^lE9(o=z
zIY+RAOGCi?bA!L8?uV>{xz8n(%4S2G$?UT%U0wMqb$)w@W#r~YfU)8ft$w1Kp*U2I
zBVq;TBHdT}_uksG97x1vONWG1OCYqeDEh8*O8G)nzdca
zFW|OJL34z8Pp`ff{qM#+mYMVPs4ux7MYi#$Jn%1X7igG5}CWjdhTShTm3f+M9t9F$OFyj
z9>qf7b@4a1{@~+-mFqH>-@~s)e@Mvip5XTUs?u~=zZZ_PS`3PLe2Ah&eegTJvhwH8
zxk^|~Zx$Ye7zL@_0_c7<0d^a`0
z$_IVS+5Og+A15fxTMoFdr41gjV4%L!Q@+yDQbdki@pr?Q3`(l0*pE`So{%h*)juSt
zq9V`d(O1PO;Ok?h0&}`>Y|^7`Iq;X@J)(jv^`nk0-f5BjA&R?!1e68K3ITngEW0(o
z=XtFNbgc=prI#bCw(t4}jaK54yihET%$yDmfA48hf>H$>Ha
zqV&HA>&U_kJ2p?#q=QimEbhk#2!E88ii_;3^Y*Idd6O*EP<_3LSGvG2*XfyZr|b;puW8HIs1KIeQ-p2
zZ2rgf^)~=YCdVG3SX|H5%l#T}h$2e{-mF-*()Zf&smgwLMr>`?Q#zECkNP&DGZ|j_
zQYkD4%j3Fl;+feS#DhPL1Yg8`rEewTfDn3-p&D;S^;|#AyKW?s70M2|njU`bcXDhk
zwC?@;+o?gii_(ii1lf;Y_xmUpQ$o&Jb!kr;VMu
z2f|6|-So4We|NHGU>5vvG_gumq
zF{7a#Lft&X=2g&>$BWP&EG>`TLk}^t{UJ9L(ItN)6)wKvUe2|aD5@52)mg>;B0(I?
zmc$!+ryV)Uw?7s~6EO#`==gB{KJ3$5uEFWisniiDy#~xU4RePL=j_^Od+QncyUZ)cOqVBf8n*7J4Vep}q%ULQ5m3UjUP
zyel8u@LO$u>9yV$ersn~bZ#MPqcZ6<96I5gD4#EZhdsjc)
zgo(+5=2)+rUnki^T|`r!2?AOoCz3(?qTB(8MSm!i$-8;qQFQ*+bm@y9u>~84<@CuW
zItmH$v{{b4L3QPoc#jUu#eK$o4++u`-l>b)ajRcP`lfzU7JbGEUU^mu?N~j2gFk&1
zrZ4!?o5AVc91qrCYX-_r?m)-c%V>HpJ*DTk;tfvVw~}K!4b|u;5=~&$eT%>|+J1Cs?3Hez%x{zE7`
zOJo+;y~drJ8zX$l6G{W?sPFJ=Zyq*%t}>N2Kc%wgHT%&Y`#Dvkc<~>%29t^Bf33HX
z@Er@whW7GG?S3*}kQR+Gc(i!@r;W->Koc8_ij8PL%)JjlWNkD2iDF)x5)-<8~LTMVD?Iuf@qc
zL^u^)-`3;B)sKr+Z&ag&m8FYJdkMEC$91XmbVIP%$2aJLDI;!fvjG>SfoAKqtW2w+
zANxC`>+y(A_E1i*H|Xg@`v$$=cjX#&ZW`o=UaVf@H$mgvrEk&iPrD(llRVL(r*ssQ
zbJyvQ%XcZZt~rJOei2B^G``_`In)0`+0iJR+Uy8Gsj^l=saq@(eriy=8-1Kj@IhCj
z@w)?=y;S4>RgwEA{)~%uNceaGS?}yeGZrnz02!
zODIjD1|b>-1Dx}ilN~JtJlPRa58izWeNDt$lrrLIUD3{wH0wp;O!?As_Mq#0aP<1Kfpy
z6E4kHWQqV#-3@xwfFQ4HeoM7DuRNomrye;yo#r;MaQ~x9xGMi=ReTq9%_Kc)QJE-d
zPK>_!zYEOmT3D2tPLmzF9b8wrL7HJ(vGc7cN$dif*z&hPN|B9)|L!@Vgwc$hfvAEOUqg_~T+1KHd%x^m2O`Q(ER20bY$-WS@gUQwihsZiI|z8$>A+kuPWjAM5QY|gt9
z**;XFC^#lPwK^U*0ET?}FyjC)SeYpG7~g^LoZkAq>XWJs$44Gi32iXca4@3vIX7z1
zSTX3k+haCnF~y=
zM{OmZtD%j$0QycA>N$FjJlCpH%IuPvn(L;e?fNDVP5PQ#D*m3`w|Mr}RmBnAQ8J`;
zQk~=7|L$!6;!*4bKljEQ?D(!WgPIk!{e#(2%2GZq;2Lupit|<%d#;E536HAiv1_!Z_)e-utaY5?SpP;J+h2K7fJ
z?%rQ4QB<}b`RAnFN={0T5hLXj0U`+}0lVVJdEU5sCuHY`zJ6Ggc2E+~ecpTw*OqFcPQ-K(jEBOXl&}HdwW~Ha|%>
z-~~b=g&$9B=|bz+t(@b$kp_Ur!mjAZEdsz;SXf1M$gHgSpGpH{Wirjf2yrkt)Wo?B
z6VMd*tv&u*+eGH+P*ISGY|!IXFg+lzCNw_{BYzDPdDA>R^Z?{`g)7dRNW2}u4=Dpz
zV$3g@I{!A;Nmkckdb(>zV6{+%f2+1oA$1W$x9);!jq!fPD^8U!r$2V3Mb;?j27Zey
zEpd&+;{#U!QDm6J)Y+(J(7An=t4r%T7JyKC0)<;`Y`TwbgceN!woLnz|Ekvk$^^XZ
zm+$#}FL-gBHW@HXv&{9Wl%xiRo658IiV``xv(==Ly`5H(
zVSlwBQCi;oC8kn0$Geqx8Q`6px{We#T%?=(u?GQ(&2@m{;Abq{AB03RkqJ%!U^TcD
z0+M0F27s${j^~1rQ2V@h3&Gny_{u+H#fS4psBWuDBMF!
zaQ#8ctL4#m^^^3!S?M95+*Gtd=LRWCh-UEZ?AHeT6aTflgUo2A>GK`o9^dbaT{jah
z!&d;0;5KZ&81LIah!Ticp2<;q06H0qJ{mB!G&<
zZbg8U=xO_67h&*)aIj8el3T!ea{eF?aASZ(FYj%Zch{lWe@UZ#c=`f)HJzjl+u}U*
zv0EQ^m2nU&&5&pGM&j@-0D-R-vv%Ycak`A(dQkKMb@AhbErAt!eLW&=J~iWZe_19y
zge)wh8L;sjnV%t(cq}9ee1aU|hrce5WPpOFg4a-z?D|)~)qU9v)e=dcX3d@IeDnb#
z=Ull-##z8;?N>LaJk&mVXf|rdEcoA_>pr5O5M&zFXGDCp{#C}c2R*V#2VL;}d*CJc
zy*Io02|yhX+Essv6W^(Uy*)Om^Q45iY&0V!+gwkwpquny(c51cd|)D-H7$AO-Hh9A0BoR|
zXWaa;;Oky&DP%GZ9R>M*YB){cYJUiwwJ0VrspU_eb`3Eo1JQv&JjJwq}Lj@N+zSUyvVzP&g7gs@F|yT!>z|
zt!`FWvnCGs?AzU>hE)^C9pF-VH#A4K!&Qp~WGa9sIu_03r_7`7E#&E1N4z+ZOj%H^
z#8kOgIoLvQb%#Uu)-T$2ll-ATZ1-)4MRCp-a
zUlD~sk?ms$zu+PIc}I8AX1TEBOvjad)wRTl4%%r
zf6`JWJj=Bp$4{jOYv8Vb(>L!01V;C)K$ju`orl*~ttxMNbHhtYsAb?x?@mnbe%juKCU70#+
z+V$%OuIJRSY0+1^)ROwgFG@#P=LPUnB`qKFBT8X)PU(<{%9$=i{%AT~y6UO_+bqv2D^umQ$!UDZ%?|gV|nOL8cSV>m2|9fz1bQl
zou-PgH!6&qYQ?0Dme69yRL>jAZD1ftVbOb9GF|QL+E(rL((j}FF0R*ftBZOLbkuZ2
z;#iV4>~3lbQ30|atqKc>`ocT4Tt3)E7O8KHE0I8RS)IP#jxnF|@TC*-6kyYp2;x@91P
zjN|Hl>I0JNj%G`HL3ZcTewVf@0P^7;b#GzP#^^kw|c|O^w;*d@mqUysMVdohG1*i=SeB
zHbw@EU=T9f7_#tn33Zj+&)LeRb7}9d$;VVT{1o#E{e|tO>He!8xh(q2_kQC!o->YW
zC$!cHDMs!)qctQ!nts*da8w_=Jvb(16TgB3MrTIeP^gC3O~_129E3bi^R=`7cRV$3
zHnH!ZF?up`3*8)cWx}b?d;PN0##el@&S?=B@I@8=4(8;Xtfn_bkr9(q$>;)8>%}o2
zzZfUqm)wg1Z$#CyeBO;11iX{yw|p44$p8-+b(5^MTF9F1D
z<6Nu!p#E?}OmWf1^6o>9!VrZ7wgHadp6~FE6sBSK4YunRf*q69G8->Hd0pzguuKwW
zBJU}YTPZhYo5+ud8@Ye`>lu6Z@Qd)
z!5fhYe|C9YrN%lcQM@}6SV^q26BBc%!#pBrn+TQBb!JlO!yHW~dC4|4&eI;>5qV_jhfgnkPyq!t7&H36YbIQt2Ww1O)?u!#Ogl*&XtH*I51BMD2g=
zrz6d&53;wflq@Uf-v!rdYY>N3(^XH`p-P7@9YW4LWJ1PeHWarq-9KRBC-5t
z;vWO})w+|MrQVF}?p3%8?A~}LqOT69D|+!7L(<$qV|d)nSycIfQ7UraM#nXYtcs)>
zmU9fVFtSu!PG|M}lwQIL{>@=)J#(chBhhU?@)CD!64aRMTmt)5;ZqBGuS$IDN5sbU
zsX;mF^GsOTy8VGWjHU#<3vL;?fvBDo#>ljX5-Wc{fqCh*yML$6Y}D$;Q#lHuCl_`B
z)Otf?QKmTzPVoy
z%ZKJECRr`b%dTjf>qIguYB#%ub`7C0?m3CXB!Zs%=JB4UyE^cW()hGyojlF)J&mC$
z{t4v^3#$+`Y9oRjOo`N_|Hx@7)@F2%UHM=Yt&rj45tpZvY7S9}D?Ex+5^3{_;vN2s
z>RLnRDeS7`H!fJx%Uw_Ie10A=6mAJ)pD?06*^`ghfYHag=!3m6EvRAhO#8c_1)my8$dLU$7VU-12%4uycx>k7vJxlGEVE<6Dyvjk|I$Xbw#Y6Bl9my3(CKN-FXzOl
zt<+xP6F(|he#4+`58)kB2)_JxFAHT+2oz4ic~5WT)Sw~;8r39aAzNdtfXL@>b{L6h
zIA;x&O9>_U2T#Yb$(oD&Rb8n%7
zZMgTABZIk{useA%o8yrf`##HVT|(KpGx{*GW$bYa6VJH)KO3+D3Or{BMDX
zIo5ADa#}Ch;IDJdvZ4S3rc`~t*dQHx^eb&h{MR2CsUB}lIb^(PoFBAp1{*m_P_X0n
z^dKZ9bkCPtUgYu$3AI%`mwLfRIfljDyK^3kX{ppF!xcBL(K+OqA&+>WyJkam$=%4mPm)29-PbS-AP2a6&de`zND`3g
zT1P(Zb=*q$mBSk6G`XllM{QYECS2Ttxmju@P*x