diff --git a/assets/images/widget_showcase.png b/assets/images/widget_showcase.png
new file mode 100644
index 00000000..59507da5
Binary files /dev/null and b/assets/images/widget_showcase.png differ
diff --git a/ios/Runner/AppDelegate.swift b/ios/Runner/AppDelegate.swift
index bc560e66..03051ed2 100644
--- a/ios/Runner/AppDelegate.swift
+++ b/ios/Runner/AppDelegate.swift
@@ -9,10 +9,16 @@ import GoogleMaps
     _ application: UIApplication,
     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
   ) -> Bool {
-
     FirebaseApp.configure()
+
+    // Extra Stuff
     GMSServices.provideAPIKey("AIzaSyCzj49x2EaAt7T3G6fTQQU06m9bwAls2AA")
     GeneratedPluginRegistrant.register(with: self)
     return super.application(application, didFinishLaunchingWithOptions: launchOptions)
   }
+    
+    override func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
+            let firebaseAuth = Auth.auth()
+            firebaseAuth.setAPNSToken(deviceToken, type: AuthAPNSTokenType.unknown)
+    }
 }
diff --git a/ios/Runner/Runner.entitlements b/ios/Runner/Runner.entitlements
index 903def2a..98ff2408 100644
--- a/ios/Runner/Runner.entitlements
+++ b/ios/Runner/Runner.entitlements
@@ -3,6 +3,6 @@
 <plist version="1.0">
 <dict>
 	<key>aps-environment</key>
-	<string>development</string>
+	<string>unknown</string>
 </dict>
 </plist>
diff --git a/lib/models/user/user.model.dart b/lib/models/user/user.model.dart
index 91870742..349efa2f 100644
--- a/lib/models/user/user.model.dart
+++ b/lib/models/user/user.model.dart
@@ -28,6 +28,24 @@ class User {
     );
   }
 
+  User copyWith({
+    String? id,
+    String? name,
+    String? picturePath,
+    String? phone,
+    DateTime? joined,
+    int? credits,
+  }) {
+    return User(
+      id: id ?? this.id,
+      name: name ?? this.name,
+      phone: phone ?? this.phone,
+      picturePath: this.picturePath,
+      joined: joined ?? this.joined,
+      credits: credits ?? this.credits,
+    );
+  }
+
   Map<String, dynamic> toMap() => {
         "id": id,
         "name": name,
diff --git a/lib/neuances.dart b/lib/neuances.dart
index 7b448864..8f2fb34e 100644
--- a/lib/neuances.dart
+++ b/lib/neuances.dart
@@ -10,7 +10,7 @@ final Uri kRateAppUrl = Uri.parse("https://joinsafe.me");
 final Uri kGitHubUrl = Uri.parse("https://github.com/safedotme/safe");
 final Uri kEmailUrl = Uri.parse("mailto:mark@joinsafe.me");
 final Uri kStoryUrl = Uri.parse("https://docs.joinsafe.me/story");
-const String kAppVersion = "1.0.1";
+const String kAppVersion = "1.0.0";
 final Uri kMarcoCalzadaMemory = Uri.parse("https://youtu.be/GVdFoKvmMtU");
 final Uri kTermsOfService = Uri.parse(
   "https://docs.joinsafe.me/termsofservice",
@@ -18,7 +18,10 @@ final Uri kTermsOfService = Uri.parse(
 final Uri kPrivacyPolicy = Uri.parse("https://docs.joinsafe.me/privacy");
 final Uri kMediaKit = Uri.parse("https://docs.joinsafe.me/media-kit");
 final Uri kCollaborators = Uri.parse("https://docs.joinsafe.me/collaborators");
+final Uri kDeleteIncident =
+    Uri.parse("https://docs.joinsafe.me/deletion-policy");
 final Uri kHelpCenter = Uri.parse("https://docs.joinsafe.me");
 final Uri kGiveFeedback = Uri.parse(
   "https://docs.joinsafe.me/contributors",
 );
+final Uri kWidgetInfo = Uri.parse("https://docs.joinsafe.me/widget");
diff --git a/lib/screens/auth/local_widgets/legal_checkmark.widget.dart b/lib/screens/auth/local_widgets/legal_checkmark.widget.dart
new file mode 100644
index 00000000..ffc3095e
--- /dev/null
+++ b/lib/screens/auth/local_widgets/legal_checkmark.widget.dart
@@ -0,0 +1,60 @@
+import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+import 'package:safe/core.dart';
+import 'package:safe/utils/constants/constants.util.dart';
+import 'package:safe/utils/icon/icon.util.dart';
+import 'package:safe/widgets/mutable_icon/mutable_icon.widget.dart';
+
+class LegalCheckmark extends StatefulWidget {
+  final bool isAllowed;
+
+  LegalCheckmark(this.isAllowed);
+
+  @override
+  State<LegalCheckmark> createState() => _LegalCheckmarkState();
+}
+
+class _LegalCheckmarkState extends State<LegalCheckmark> {
+  late Core core;
+
+  @override
+  void initState() {
+    core = Provider.of<Core>(context, listen: false);
+    super.initState();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      height: 22,
+      width: 22,
+      decoration: BoxDecoration(
+        border: !widget.isAllowed
+            ? Border.all(
+                width: kBorderWidth,
+                color: kColorMap[MutableColor.neutral4]!,
+              )
+            : Border.all(
+                width: kBorderWidth,
+                color: Colors.white.withOpacity(0.3),
+              ),
+        boxShadow:
+            widget.isAllowed ? core.utils.color.applyGradientShadow(20) : null,
+        image: widget.isAllowed
+            ? DecorationImage(
+                image: AssetImage("assets/images/gradient.png"),
+              )
+            : null,
+        borderRadius: BorderRadius.circular(6),
+      ),
+      child: widget.isAllowed
+          ? Center(
+              child: MutableIcon(
+              MutableIcons.checkmark,
+              size: Size(12, 12),
+              color: kIconColorInGradientFill,
+            ))
+          : null,
+    );
+  }
+}
diff --git a/lib/screens/auth/local_widgets/legal_checkpoint.widget.dart b/lib/screens/auth/local_widgets/legal_checkpoint.widget.dart
new file mode 100644
index 00000000..5fa439f5
--- /dev/null
+++ b/lib/screens/auth/local_widgets/legal_checkpoint.widget.dart
@@ -0,0 +1,71 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_mobx/flutter_mobx.dart';
+import 'package:provider/provider.dart';
+import 'package:safe/core.dart';
+import 'package:safe/neuances.dart';
+import 'package:safe/screens/auth/local_widgets/legal_checkmark.widget.dart';
+import 'package:safe/utils/constants/constants.util.dart';
+import 'package:safe/widgets/mutable_button/mutable_button.widget.dart';
+import 'package:safe/widgets/mutable_text/mutable_text.widget.dart';
+import 'package:url_launcher/url_launcher.dart';
+
+class LegalCheckpoint extends StatefulWidget {
+  @override
+  State<LegalCheckpoint> createState() => _LegalCheckpointState();
+}
+
+class _LegalCheckpointState extends State<LegalCheckpoint> {
+  late Core core;
+
+  @override
+  void initState() {
+    core = Provider.of<Core>(context, listen: false);
+    super.initState();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      margin: EdgeInsets.only(bottom: 12),
+      padding: EdgeInsets.all(10),
+      decoration: BoxDecoration(
+        color: kColorMap[MutableColor.neutral8]!.withOpacity(0.15),
+        border: Border.all(
+          width: kBorderWidth,
+          color: kColorMap[MutableColor.neutral8]!,
+        ),
+        borderRadius: BorderRadius.circular(12),
+      ),
+      child: Row(
+        children: [
+          MutableButton(
+            scale: 0.9,
+            onTap: () {
+              core.state.auth.setAcceptedLegal(
+                !core.state.auth.acceptedLegal,
+              );
+            },
+            child: Observer(
+              builder: (_) => LegalCheckmark(core.state.auth.acceptedLegal),
+            ),
+          ),
+          SizedBox(width: 10),
+          Expanded(
+              child: MutableButton(
+            onTap: () {
+              launchUrl(kTermsOfService);
+            },
+            child: MutableText(
+              core.utils.language
+                      .langMap[core.state.preferences.language]!["auth"]
+                  ["phone_verification"]["terms"],
+              size: 12,
+              weight: TypeWeight.medium,
+              color: MutableColor.neutral2,
+            ),
+          )),
+        ],
+      ),
+    );
+  }
+}
diff --git a/lib/screens/auth/phone_verification.screen.dart b/lib/screens/auth/phone_verification.screen.dart
index 1dce339f..e01da9f2 100644
--- a/lib/screens/auth/phone_verification.screen.dart
+++ b/lib/screens/auth/phone_verification.screen.dart
@@ -2,7 +2,7 @@ import 'package:flutter/material.dart';
 import 'package:flutter_mobx/flutter_mobx.dart';
 import 'package:provider/provider.dart';
 import 'package:safe/core.dart';
-import 'package:safe/neuances.dart';
+import 'package:safe/screens/auth/local_widgets/legal_checkpoint.widget.dart';
 import 'package:safe/utils/constants/constants.util.dart';
 import 'package:safe/utils/icon/icon.util.dart';
 import 'package:safe/widgets/mutable_banner/mutable_banner.widget.dart';
@@ -11,7 +11,6 @@ import 'package:safe/widgets/mutable_popup/mutable_popup.widget.dart';
 import 'package:safe/widgets/mutable_submit_textfield_button/mutable_submit_textfield_button.widget.dart';
 import 'package:safe/widgets/mutable_text_field/local_widgets/phone_extention_display.widget.dart';
 import 'package:safe/widgets/mutable_text_field/mutable_text_field.widget.dart';
-import 'package:url_launcher/url_launcher.dart';
 
 class PhoneVerificationScreen extends StatefulWidget {
   @override
@@ -88,6 +87,11 @@ class _PhoneVerificationScreenState extends State<PhoneVerificationScreen>
   }
 
   void submit() async {
+    if (!core.state.auth.acceptedLegal) {
+      handleError("not-accepted-legal");
+      return;
+    }
+
     if (core.state.auth.authType == AuthType.login) {
       bool userExists = await checkUserExists(
           "${core.state.auth.countryDialCode} ${core.state.auth.phoneNumber}");
@@ -237,12 +241,7 @@ class _PhoneVerificationScreenState extends State<PhoneVerificationScreen>
             ],
           ),
         ),
-        aboveButtonText: core.utils.language
-                .langMap[core.state.preferences.language]!["auth"]
-            ["phone_verification"]["terms"],
-        aboveButtonOnTap: () {
-          launchUrl(kTermsOfService);
-        },
+        aboveButtonWidget: LegalCheckpoint(),
         resizeToAvoidBottomInsets: true,
         // Display related properties
         title: core.utils.language
diff --git a/lib/screens/home/home.screen.dart b/lib/screens/home/home.screen.dart
index 2d9083f9..cf879d57 100644
--- a/lib/screens/home/home.screen.dart
+++ b/lib/screens/home/home.screen.dart
@@ -1,6 +1,5 @@
 import 'package:connectivity_plus/connectivity_plus.dart';
 import 'package:flutter/material.dart' hide BoxShadow;
-import 'package:flutter/services.dart';
 import 'package:flutter_mobx/flutter_mobx.dart';
 import 'package:provider/provider.dart';
 import 'package:safe/core.dart';
@@ -15,6 +14,7 @@ import 'package:safe/screens/home/local_widgets/incident_limit_home_banner.widge
 import 'package:safe/screens/home/local_widgets/event_home_banner.widget.dart.dart';
 import 'package:safe/screens/home/local_widgets/tutorial_banner.widget.dart';
 import 'package:safe/screens/incident/incident.screen.dart';
+import 'package:safe/screens/incident/local_widgets/widget_showcase_popup.widget.dart';
 import 'package:safe/screens/incident_log/incident_log.screen.dart';
 import 'package:safe/screens/play/play.screen.dart';
 import 'package:safe/screens/settings/settings.screen.dart';
@@ -153,6 +153,7 @@ class _HomeScreenState extends State<HomeScreen> {
         ContactScreen(),
         ContactEditorScreen(),
         ImportContactPopup(),
+        WidgetShowcasePopup(),
         CustomCupertinoContactPopup(),
         ContactCountryCodeSelector(),
         CaptureScreen(),
@@ -201,8 +202,6 @@ class _HomeScreenState extends State<HomeScreen> {
                 duration: kFadeInDuration,
                 child: MutableSafeButton(
                   onTap: () async {
-                    HapticFeedback.heavyImpact();
-
                     bool shouldCapture = await core.utils.credit.shouldCapture(
                       TriggerIdentifier.primary,
                       core,
diff --git a/lib/screens/home/local_widgets/incident_limit_home_banner.widget.dart b/lib/screens/home/local_widgets/incident_limit_home_banner.widget.dart
index 0cfdf74e..b79ae62b 100644
--- a/lib/screens/home/local_widgets/incident_limit_home_banner.widget.dart
+++ b/lib/screens/home/local_widgets/incident_limit_home_banner.widget.dart
@@ -5,8 +5,10 @@ import 'package:flutter_mobx/flutter_mobx.dart';
 import 'package:permission_handler/permission_handler.dart';
 import 'package:provider/provider.dart';
 import 'package:safe/core.dart';
+import 'package:safe/services/analytics/helper_classes/analytics_log_model.service.dart';
 import 'package:safe/utils/constants/constants.util.dart';
 import 'package:safe/utils/credit/credit.util.dart';
+import 'package:safe/widgets/mutable_banner/mutable_banner.widget.dart';
 import 'package:safe/widgets/mutable_home_message.widget.dart/mutable_home_banner.widget.dart';
 import 'package:safe/widgets/mutable_pill/mutable_pill.widget.dart';
 import 'package:safe/widgets/mutable_text/mutable_text.widget.dart';
@@ -110,7 +112,23 @@ class _IncidentLimitHomeBannerState extends State<IncidentLimitHomeBanner> {
           }
 
           if (core.state.capture.limErrState == LimitErrorState.maxed) {
-            core.state.incidentLog.controller.open();
+            core.services.analytics.log(
+              AnalyticsLog(
+                channel: "request-credits",
+                event: "maxed-credit-request",
+                description: "User has requested incident credits.",
+                tags: {
+                  "userid": core.services.auth.currentUser!.uid,
+                },
+                icon: "💰",
+              ),
+            );
+
+            core.state.preferences.actionController.trigger(
+              core.utils.language.langMap[core.state.preferences.language]![
+                  "credit_request"]["notification"]!,
+              MessageType.success,
+            );
             return;
           }
         },
diff --git a/lib/screens/incident/local_widgets/widget_showcase_popup.widget.dart b/lib/screens/incident/local_widgets/widget_showcase_popup.widget.dart
new file mode 100644
index 00000000..62dde9e5
--- /dev/null
+++ b/lib/screens/incident/local_widgets/widget_showcase_popup.widget.dart
@@ -0,0 +1,139 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:provider/provider.dart';
+import 'package:safe/core.dart';
+import 'package:safe/neuances.dart';
+import 'package:safe/utils/constants/constants.util.dart';
+import 'package:safe/widgets/mutable_divider/mutable_divider.widget.dart';
+import 'package:safe/widgets/mutable_input_popup_action/mutable_input_popup_action.widget.dart';
+import 'package:safe/widgets/mutable_popup/local_widgets/mutable_popup_style.widget.dart';
+import 'package:safe/widgets/mutable_popup/mutable_popup.widget.dart';
+import 'package:safe/widgets/mutable_shimmer/mutable_shimmer.widget.dart';
+import 'package:safe/widgets/mutable_text/mutable_text.widget.dart';
+import 'package:url_launcher/url_launcher.dart';
+
+class WidgetShowcasePopup extends StatefulWidget {
+  const WidgetShowcasePopup({super.key});
+
+  @override
+  State<WidgetShowcasePopup> createState() => _WidgetShowcasePopupState();
+}
+
+class _WidgetShowcasePopupState extends State<WidgetShowcasePopup> {
+  late Core core;
+  double panelState = 0;
+
+  @override
+  void initState() {
+    core = Provider.of<Core>(context, listen: false);
+    super.initState();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Stack(
+      children: [
+        Visibility(
+          visible: panelState != 0,
+          child: Opacity(
+            opacity: panelState,
+            child: Container(
+              decoration: BoxDecoration(
+                gradient: LinearGradient(
+                  begin: Alignment.topCenter,
+                  end: Alignment.bottomCenter,
+                  colors: [
+                    Color.alphaBlend(
+                      kColorMap[MutableColor.primaryRed]!.withOpacity(0),
+                      kColorMap[MutableColor.neutral10]!.withOpacity(0.8),
+                    ),
+                    Color.alphaBlend(
+                      kColorMap[MutableColor.primaryRed]!.withOpacity(0.2),
+                      kColorMap[MutableColor.neutral10]!.withOpacity(0.8),
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ),
+        ),
+        MutablePopup(
+          type: PopupType.input,
+          isExcited: true,
+          style: MutablePopupStyle(
+            backdropColor: Colors.transparent,
+            backdropOpacity: 0,
+          ),
+          onClosed: () {
+            core.utils.tutorial.handleOnLeave(core);
+          },
+          onSlide: (state) {
+            setState(() {
+              panelState = state;
+            });
+          },
+          height: 390,
+          controller: core.state.incident.widgetShowcasePopupController,
+          body: Padding(
+            padding: EdgeInsets.fromLTRB(
+              kSideScreenMargin,
+              27,
+              kSideScreenMargin,
+              0,
+            ),
+            child: Column(
+              children: [
+                MutableShimmer(
+                  animateToColor:
+                      kColorMap[MutableColor.primaryRed]!.withOpacity(0.3),
+                  speed: Speed.slow,
+                  child: Image.asset(
+                    "assets/images/widget_showcase.png",
+                    height: 134,
+                  ),
+                ),
+                SizedBox(height: 12),
+                MutableText(
+                  core.utils.language.langMap[core.state.preferences.language]![
+                      "incident_log"]["widget_showcase"]["header"],
+                  size: 20,
+                  weight: TypeWeight.heavy,
+                ),
+                SizedBox(height: 5),
+                MutableText(
+                  core.utils.language.langMap[core.state.preferences.language]![
+                      "incident_log"]["widget_showcase"]["desc"],
+                  size: 14,
+                  align: TextAlign.center,
+                  color: MutableColor.neutral2,
+                ),
+                SizedBox(height: 30),
+                MutableDivider(color: MutableColor.excitedBorder),
+                MutableInputPopupAction(
+                  text: core.utils.language.langMap[core.state.preferences
+                      .language]!["incident_log"]["widget_showcase"]["confirm"],
+                  active: true,
+                  onTap: () {
+                    HapticFeedback.lightImpact();
+                    core.state.incident.widgetShowcasePopupController.close();
+                  },
+                ),
+                MutableDivider(color: MutableColor.excitedBorder),
+                MutableInputPopupAction(
+                  text: core.utils.language.langMap[
+                          core.state.preferences.language]!["incident_log"]
+                      ["widget_showcase"]["learn_more"],
+                  secondaryColor: MutableColor.excitedGrey,
+                  onTap: () {
+                    HapticFeedback.lightImpact();
+                    launchUrl(kWidgetInfo);
+                  },
+                ),
+              ],
+            ),
+          ),
+        ),
+      ],
+    );
+  }
+}
diff --git a/lib/screens/incident_log/local_widgets/incident_log_body.widget.dart b/lib/screens/incident_log/local_widgets/incident_log_body.widget.dart
index e349e00f..83e0c6dd 100644
--- a/lib/screens/incident_log/local_widgets/incident_log_body.widget.dart
+++ b/lib/screens/incident_log/local_widgets/incident_log_body.widget.dart
@@ -81,9 +81,11 @@ class _IncidentLogBodyState extends State<IncidentLogBody> {
         sortedIncidents.length,
         (i) => Padding(
               padding: EdgeInsets.only(
-                bottom: i + 1 == sortedIncidents.length
-                    ? 0
-                    : kIncidentLogCardSpacing,
+                bottom: !(i + 1 == sortedIncidents.length)
+                    ? kIncidentLogCardSpacing
+                    : sortedIncidents.length > 1
+                        ? 50
+                        : 0,
               ),
               child: MutableIncidentCard(sortedIncidents[i]),
             ) // Add spacing between incidents,
diff --git a/lib/screens/play/local_widgets/player_progress_indicator.widget.dart b/lib/screens/play/local_widgets/player_progress_indicator.widget.dart
index 881c135c..f2b93eb3 100644
--- a/lib/screens/play/local_widgets/player_progress_indicator.widget.dart
+++ b/lib/screens/play/local_widgets/player_progress_indicator.widget.dart
@@ -157,7 +157,7 @@ class _PlayerProgressIndicatorState extends State<PlayerProgressIndicator> {
                   ),
                   SizedBox(width: 3),
                   SizedBox(
-                    width: 85,
+                    width: 95,
                     child: MutableText(
                       core.state.incident.playDate,
                       size: 12,
diff --git a/lib/screens/settings/local_widgets/danger_zone_block.widget.dart b/lib/screens/settings/local_widgets/danger_zone_block.widget.dart
index b21db112..4bb33053 100644
--- a/lib/screens/settings/local_widgets/danger_zone_block.widget.dart
+++ b/lib/screens/settings/local_widgets/danger_zone_block.widget.dart
@@ -1,8 +1,9 @@
 import 'package:flutter/cupertino.dart';
 import 'package:provider/provider.dart';
 import 'package:safe/core.dart';
-import 'package:safe/screens/settings/local_widgets/delete_account_alert_dialog.widget.dart';
+import 'package:safe/services/server/erase.service.dart';
 import 'package:safe/utils/constants/constants.util.dart';
+import 'package:safe/widgets/mutable_banner/mutable_banner.widget.dart';
 import 'package:safe/widgets/mutable_settings_block/local_widgets/settings_block_item.widget.dart';
 import 'package:safe/widgets/mutable_settings_block/mutable_settings_block.widget.dart';
 
@@ -96,10 +97,99 @@ class _DangerZoneBlockState extends State<DangerZoneBlock> {
                   .langMap[core.state.preferences.language]!["settings"]
               ["danger"]["delete_acc"]["header"],
           onTap: () {
-            showCupertinoDialog(
+            showCupertinoModalPopup(
               context: context,
-              barrierDismissible: true,
-              builder: (_) => DeleteAccountAlertDialog(),
+              builder: (_) => CupertinoActionSheet(
+                title: Column(
+                  mainAxisSize: MainAxisSize.min,
+                  children: [
+                    Text(
+                      core.utils.language.langMap[
+                              core.state.preferences.language]!["settings"]
+                          ["danger"]["delete_acc"]["modal"]["header"],
+                      style: TextStyle(
+                        fontWeight: FontWeight.w600,
+                      ),
+                    ),
+                    SizedBox(height: 6),
+                    Text(
+                      core.utils.language.langMap[
+                              core.state.preferences.language]!["settings"]
+                          ["danger"]["delete_acc"]["modal"]["desc"],
+                    ),
+                    SizedBox(height: 10),
+                  ], //
+                ),
+                actions: [
+                  CupertinoActionSheetAction(
+                    isDestructiveAction: true,
+                    onPressed: () async {
+                      bool shouldAuth =
+                          await core.services.localAuth.isAvailable();
+
+                      if (shouldAuth) {
+                        bool authed =
+                            await core.services.localAuth.authenticate(
+                          "Authenticate to delete account",
+                        );
+
+                        if (!authed) {
+                          core.state.preferences.actionController.trigger(
+                            "Failed to authenticate",
+                            MessageType.error,
+                          );
+                          return;
+                        }
+                      }
+
+                      // ignore: use_build_context_synchronously
+                      Navigator.pop(context);
+                      core.state.preferences.setOverlayText(
+                        core.utils.language.langMap[
+                                core.state.preferences.language]!["settings"]
+                            ["danger"]["delete_acc"]["loader"],
+                      );
+
+                      await core.state.preferences.overlayController.show();
+
+                      // Delete account
+
+                      bool erased = await EraseServer.eraseUserContents(core);
+
+                      await core.state.incidentLog.controller.close();
+                      core.state.preferences.overlayController.hide();
+
+                      if (!erased) {
+                        core.state.preferences.actionController.open(
+                          core.utils.language.langMap[
+                                  core.state.preferences.language]!["settings"]
+                              ["danger"]["delete_acc"]["failed"],
+                          MessageType.error,
+                        );
+                        return;
+                      }
+
+                      core.services.auth.signOut();
+                    },
+                    child: Text(
+                      core.utils.language.langMap[
+                              core.state.preferences.language]!["settings"]
+                          ["danger"]["delete_acc"]["modal"]["button"],
+                    ),
+                  )
+                ],
+                cancelButton: CupertinoActionSheetAction(
+                  isDefaultAction: true,
+                  onPressed: () {
+                    Navigator.pop(context);
+                  },
+                  child: Text(
+                    core.utils.language.langMap[
+                            core.state.preferences.language]!["settings"]
+                        ["danger"]["delete_acc"]["modal"]["cancel"],
+                  ),
+                ),
+              ),
             );
           },
           textColor: MutableColor.secondaryRed,
diff --git a/lib/screens/settings/local_widgets/support_block.widget.dart b/lib/screens/settings/local_widgets/support_block.widget.dart
index ebc49552..ad7a8363 100644
--- a/lib/screens/settings/local_widgets/support_block.widget.dart
+++ b/lib/screens/settings/local_widgets/support_block.widget.dart
@@ -70,6 +70,14 @@ class _SupportBlockState extends State<SupportBlock> {
                 launchUrl(kHelpCenter);
               },
             ),
+            SettingsBlockItem(
+              text: core.utils.language
+                      .langMap[core.state.preferences.language]!["settings"]
+                  ["support"]["deletion_policy"],
+              onTap: () {
+                launchUrl(kDeleteIncident);
+              },
+            ),
             SettingsBlockItem(
               text: core.utils.language
                       .langMap[core.state.preferences.language]!["settings"]
diff --git a/lib/screens/settings/local_widgets/user_preferences_block.widget.dart b/lib/screens/settings/local_widgets/user_preferences_block.widget.dart
index 271f1936..67245eef 100644
--- a/lib/screens/settings/local_widgets/user_preferences_block.widget.dart
+++ b/lib/screens/settings/local_widgets/user_preferences_block.widget.dart
@@ -125,6 +125,15 @@ class _UserPreferencesBlockState extends State<UserPreferencesBlock> {
               );
             },
           ),
+          SettingsBlockItem(
+            text: core.utils.language
+                    .langMap[core.state.preferences.language]!["settings"]
+                ["preferences"]["widget"]["header"],
+            onTap: () {
+              HapticFeedback.lightImpact();
+              core.state.incident.widgetShowcasePopupController.open();
+            },
+          ),
           SettingsBlockItem(
             text: core.utils.language
                     .langMap[core.state.preferences.language]!["settings"]
diff --git a/lib/services/auth/auth.service.dart b/lib/services/auth/auth.service.dart
index 2d41e792..6dcc214f 100644
--- a/lib/services/auth/auth.service.dart
+++ b/lib/services/auth/auth.service.dart
@@ -94,6 +94,10 @@ class AuthService {
         return core.utils.language
                 .langMap[core.state.preferences.language]!["auth"]
             ["firebase_errors"][error];
+      case "not-accepted-legal":
+        return core.utils.language
+                .langMap[core.state.preferences.language]!["auth"]
+            ["firebase_errors"][error];
       case "invalid-verification-code":
         return core.utils.language
                 .langMap[core.state.preferences.language]!["auth"]
diff --git a/lib/services/permissions/permissions.service.dart b/lib/services/permissions/permissions.service.dart
index 3357105e..9a802d68 100644
--- a/lib/services/permissions/permissions.service.dart
+++ b/lib/services/permissions/permissions.service.dart
@@ -89,7 +89,7 @@ class PermissionsService {
     core.state.auth.setBannerTitle(response["header"]);
     core.state.auth.setBannerMessage(response["desc"]);
     core.state.auth.setOnBannerTap(() {
-      // Opens app settings when clicked
+      // Opens app settings when tapped
       openAppSettings();
     });
     core.state.auth.bannerController.show();
diff --git a/lib/services/server/erase.service.dart b/lib/services/server/erase.service.dart
new file mode 100644
index 00000000..68a992c1
--- /dev/null
+++ b/lib/services/server/erase.service.dart
@@ -0,0 +1,40 @@
+import 'package:safe/core.dart';
+import 'package:safe/models/contact/contact.model.dart';
+import 'package:safe/models/incident/incident.model.dart';
+import 'package:safe/models/user/user.model.dart';
+
+class EraseServer {
+  static Future<bool> eraseUserContents(Core core) async {
+    // Fetch & delete incidents
+    List<Incident> incidents = core.state.incidentLog.incidents ?? [];
+
+    for (Incident i in incidents) {
+      await core.services.server.incidents.delete(i.id);
+    }
+
+    // Fetch  & delete contacts
+    List<Contact> contacts = core.state.contact.contacts ?? [];
+
+    for (Contact c in contacts) {
+      await core.services.server.contacts.delete(c.id); 
+    }
+
+    // Erase user
+    String? id = core.services.auth.currentUser?.uid;
+
+    if (id == null) return false;
+
+    User? user = await core.services.server.user.readFromIdOnce(id: id);
+
+    if (user == null) return false;
+
+    user = user.copyWith(
+      name: "",
+      phone: "",
+    );
+
+    await core.services.server.user.upsert(user);
+
+    return true;
+  }
+}
diff --git a/lib/state/auth/auth.store.dart b/lib/state/auth/auth.store.dart
index 3492f539..e190d101 100644
--- a/lib/state/auth/auth.store.dart
+++ b/lib/state/auth/auth.store.dart
@@ -32,6 +32,12 @@ abstract class _AuthStore with Store {
   @action
   void setBannerState(MessageType t) => bannerState = t;
 
+  @observable
+  bool acceptedLegal = false;
+
+  @action
+  void setAcceptedLegal(bool v) => acceptedLegal = v;
+
   @observable
   String bannerTitle = "";
 
diff --git a/lib/state/auth/auth.store.g.dart b/lib/state/auth/auth.store.g.dart
index cdf94909..581cc4ed 100644
--- a/lib/state/auth/auth.store.g.dart
+++ b/lib/state/auth/auth.store.g.dart
@@ -73,6 +73,22 @@ mixin _$AuthStore on _AuthStore, Store {
     });
   }
 
+  late final _$acceptedLegalAtom =
+      Atom(name: '_AuthStore.acceptedLegal', context: context);
+
+  @override
+  bool get acceptedLegal {
+    _$acceptedLegalAtom.reportRead();
+    return super.acceptedLegal;
+  }
+
+  @override
+  set acceptedLegal(bool value) {
+    _$acceptedLegalAtom.reportWrite(value, super.acceptedLegal, () {
+      super.acceptedLegal = value;
+    });
+  }
+
   late final _$bannerTitleAtom =
       Atom(name: '_AuthStore.bannerTitle', context: context);
 
@@ -483,6 +499,17 @@ mixin _$AuthStore on _AuthStore, Store {
     }
   }
 
+  @override
+  void setAcceptedLegal(bool v) {
+    final _$actionInfo = _$_AuthStoreActionController.startAction(
+        name: '_AuthStore.setAcceptedLegal');
+    try {
+      return super.setAcceptedLegal(v);
+    } finally {
+      _$_AuthStoreActionController.endAction(_$actionInfo);
+    }
+  }
+
   @override
   void setBannerTitle(String t) {
     final _$actionInfo = _$_AuthStoreActionController.startAction(
@@ -677,6 +704,7 @@ authType: ${authType},
 actionController: ${actionController},
 bannerController: ${bannerController},
 bannerState: ${bannerState},
+acceptedLegal: ${acceptedLegal},
 bannerTitle: ${bannerTitle},
 bannerMessage: ${bannerMessage},
 onBannerTap: ${onBannerTap},
diff --git a/lib/state/incident/incident.store.dart b/lib/state/incident/incident.store.dart
index dcc1bf97..e9161094 100644
--- a/lib/state/incident/incident.store.dart
+++ b/lib/state/incident/incident.store.dart
@@ -25,6 +25,9 @@ abstract class _IncidentStore with Store {
   @action
   void setContacts(List<NotifiedContact> c) => contacts = c;
 
+  @observable
+  PanelController widgetShowcasePopupController = PanelController();
+
   @observable
   PanelController contactPopupController = PanelController();
 
diff --git a/lib/state/incident/incident.store.g.dart b/lib/state/incident/incident.store.g.dart
index 2ff26820..ecbd64a2 100644
--- a/lib/state/incident/incident.store.g.dart
+++ b/lib/state/incident/incident.store.g.dart
@@ -57,6 +57,23 @@ mixin _$IncidentStore on _IncidentStore, Store {
     });
   }
 
+  late final _$widgetShowcasePopupControllerAtom = Atom(
+      name: '_IncidentStore.widgetShowcasePopupController', context: context);
+
+  @override
+  PanelController get widgetShowcasePopupController {
+    _$widgetShowcasePopupControllerAtom.reportRead();
+    return super.widgetShowcasePopupController;
+  }
+
+  @override
+  set widgetShowcasePopupController(PanelController value) {
+    _$widgetShowcasePopupControllerAtom
+        .reportWrite(value, super.widgetShowcasePopupController, () {
+      super.widgetShowcasePopupController = value;
+    });
+  }
+
   late final _$contactPopupControllerAtom =
       Atom(name: '_IncidentStore.contactPopupController', context: context);
 
@@ -467,6 +484,7 @@ mixin _$IncidentStore on _IncidentStore, Store {
 scrollController: ${scrollController},
 overlayController: ${overlayController},
 contacts: ${contacts},
+widgetShowcasePopupController: ${widgetShowcasePopupController},
 contactPopupController: ${contactPopupController},
 contactPopupValuesController: ${contactPopupValuesController},
 incidentId: ${incidentId},
diff --git a/lib/state/preferences/preferences.store.dart b/lib/state/preferences/preferences.store.dart
index 7b47519b..34e3ec06 100644
--- a/lib/state/preferences/preferences.store.dart
+++ b/lib/state/preferences/preferences.store.dart
@@ -33,6 +33,18 @@ abstract class _PreferencesStore with Store {
     duration: kConfettiDuration,
   );
 
+  @observable
+  bool seenWidgetPreview = false;
+
+  @action
+  void setSeenWidgetPreview(bool v) => seenWidgetPreview = v;
+
+  @observable
+  bool tutorialCalled = false;
+
+  @action
+  void setTutorialCalled(bool v) => tutorialCalled = v;
+
   @observable
   PanelController tutorialBannerController = PanelController();
 
diff --git a/lib/state/preferences/preferences.store.g.dart b/lib/state/preferences/preferences.store.g.dart
index 5f668aea..2b7683b0 100644
--- a/lib/state/preferences/preferences.store.g.dart
+++ b/lib/state/preferences/preferences.store.g.dart
@@ -57,6 +57,38 @@ mixin _$PreferencesStore on _PreferencesStore, Store {
     });
   }
 
+  late final _$seenWidgetPreviewAtom =
+      Atom(name: '_PreferencesStore.seenWidgetPreview', context: context);
+
+  @override
+  bool get seenWidgetPreview {
+    _$seenWidgetPreviewAtom.reportRead();
+    return super.seenWidgetPreview;
+  }
+
+  @override
+  set seenWidgetPreview(bool value) {
+    _$seenWidgetPreviewAtom.reportWrite(value, super.seenWidgetPreview, () {
+      super.seenWidgetPreview = value;
+    });
+  }
+
+  late final _$tutorialCalledAtom =
+      Atom(name: '_PreferencesStore.tutorialCalled', context: context);
+
+  @override
+  bool get tutorialCalled {
+    _$tutorialCalledAtom.reportRead();
+    return super.tutorialCalled;
+  }
+
+  @override
+  set tutorialCalled(bool value) {
+    _$tutorialCalledAtom.reportWrite(value, super.tutorialCalled, () {
+      super.tutorialCalled = value;
+    });
+  }
+
   late final _$tutorialBannerControllerAtom = Atom(
       name: '_PreferencesStore.tutorialBannerController', context: context);
 
@@ -260,6 +292,28 @@ mixin _$PreferencesStore on _PreferencesStore, Store {
     }
   }
 
+  @override
+  void setSeenWidgetPreview(bool v) {
+    final _$actionInfo = _$_PreferencesStoreActionController.startAction(
+        name: '_PreferencesStore.setSeenWidgetPreview');
+    try {
+      return super.setSeenWidgetPreview(v);
+    } finally {
+      _$_PreferencesStoreActionController.endAction(_$actionInfo);
+    }
+  }
+
+  @override
+  void setTutorialCalled(bool v) {
+    final _$actionInfo = _$_PreferencesStoreActionController.startAction(
+        name: '_PreferencesStore.setTutorialCalled');
+    try {
+      return super.setTutorialCalled(v);
+    } finally {
+      _$_PreferencesStoreActionController.endAction(_$actionInfo);
+    }
+  }
+
   @override
   void setDisabledPermissions(List<Permission> p) {
     final _$actionInfo = _$_PreferencesStoreActionController.startAction(
@@ -321,6 +375,8 @@ mixin _$PreferencesStore on _PreferencesStore, Store {
 language: ${language},
 isFirstTime: ${isFirstTime},
 confettiController: ${confettiController},
+seenWidgetPreview: ${seenWidgetPreview},
+tutorialCalled: ${tutorialCalled},
 tutorialBannerController: ${tutorialBannerController},
 disabledPermissions: ${disabledPermissions},
 actionController: ${actionController},
diff --git a/lib/utils/capture/capture.util.dart b/lib/utils/capture/capture.util.dart
index 4b8c60c6..1a16f3c0 100644
--- a/lib/utils/capture/capture.util.dart
+++ b/lib/utils/capture/capture.util.dart
@@ -562,6 +562,8 @@ USER ID: ${_core!.state.capture.incident!.userId}
       "{NAME_POSESSIVE}": _core!.utils.name.genFirstName(user.name, true),
       "{BATTERY}": battery.toString(),
       "{LINK}": "https://live.joinsafe.me/${incident.id}",
+      "{LINK_END}":
+          "https://download.joinsafe.me/${incident.stream.channelName}",
     };
 
     for (String key in replacementMap.keys) {
diff --git a/lib/utils/capture/messages.capture.dart b/lib/utils/capture/messages.capture.dart
index 05986da6..629fb516 100644
--- a/lib/utils/capture/messages.capture.dart
+++ b/lib/utils/capture/messages.capture.dart
@@ -83,7 +83,7 @@ The app continues to record {NAME_POSESSIVE} camera and track {NAME_POSESSIVE} e
 This message was sent by the Safe app. Learn more about Safe at joinsafe dot me.
 """;
 
-  static const String contactMessageTemplateStart = """
+  static const String contactLongMessageTemplateStart = """
 {FULL_NAME} is actively in an emergency.
 
 {NAME} listed you, {FULL_CONTACT_NAME}, as an emergency contact.
@@ -97,15 +97,17 @@ The app continues to record {NAME_POSESSIVE} camera and track {NAME_POSESSIVE} e
 This message was sent by the Safe app. Learn more about Safe at https://joinsafe.me.
 """;
 
-  static const String contactMessageTemplateEnd = """
+  static const String contactLongMessageTemplateEnd = """
 {NAME} has stopped capturing the incident at {TIME_END}.
 
 The emergency began at {TIME} and is listed as a {TYPE}.
 {LOCATION}
+Tap on this link to view the camera recording of the incident: {LINK_END}
+
 This message was sent by the Safe app. Learn more about Safe at https://joinsafe.me.
 """;
 
-  static const String contactMessageBatteryTemplate = """
+  static const String contactLongMessageBatteryTemplate = """
 {NAME_POSESSIVE} battery is at {BATTERY}%, which is dangerously low.
 
 When it runs out, the app will stop capturing the incident.
@@ -116,4 +118,24 @@ You will receive a message when {NAME} stops capturing the incident.
 
 This message was sent by the Safe app. Learn more about Safe at https://joinsafe.me.
 """;
+
+// SHORT
+
+  static const String contactMessageTemplateStart = """
+{FULL_NAME} is actively in an emergency. 
+
+Watch a livestream of the incident here: {LINK}
+""";
+
+  static const String contactMessageBatteryTemplate = """
+{NAME_POSESSIVE} battery is at {BATTERY}%, which is dangerously low.
+
+When it runs out, the app will stop capturing the incident.
+""";
+
+  static const String contactMessageTemplateEnd = """
+{NAME} has stopped capturing the incident at {TIME_END}.
+
+View the incident here: {LINK_END}
+""";
 }
diff --git a/lib/utils/constants/constants.util.dart b/lib/utils/constants/constants.util.dart
index b801b32d..830f4ed5 100644
--- a/lib/utils/constants/constants.util.dart
+++ b/lib/utils/constants/constants.util.dart
@@ -123,6 +123,11 @@ enum MutableColor {
   overlaySecondaryRed,
   overlaySecondaryYellow,
 
+  excitedPrimary,
+  excitedBackground,
+  excitedBorder,
+  excitedGrey,
+
   iosGrey,
   iosDarkGrey,
   mapBackground,
@@ -145,6 +150,12 @@ const Map<MutableColor, Color> kColorMap = {
   MutableColor.iosGrey: Color(0xff1E1920),
   MutableColor.iosDarkGrey: Color(0xff252525),
 
+  // -> EXCITED STATE COLORS
+  MutableColor.excitedPrimary: Color(0XFFE53872),
+  MutableColor.excitedBackground: Color(0xff0C0A0A),
+  MutableColor.excitedBorder: Color(0xff27141C),
+  MutableColor.excitedGrey: Color(0xff7A6066),
+
   // -> MAP SPECIFIC
   MutableColor.mapBackground: Color(0xff1e1e1e),
 
@@ -261,6 +272,9 @@ const double kBorderWidth = 1.5;
 const double kLargeButtonHeight = 50;
 const double kLargeButtonBorderRadius = kLargeButtonHeight / 2;
 
+// EXCITED STATE VALUES
+const double kExcitedBorderWidth = 2.5;
+
 // BUTTONS
 const double kScaleDownButtonPercentage = 0.97;
 const Duration kScaleDownButtonTime = Duration(milliseconds: 125);
diff --git a/lib/utils/language/language.util.dart b/lib/utils/language/language.util.dart
index 9f635f11..ade5e9ee 100644
--- a/lib/utils/language/language.util.dart
+++ b/lib/utils/language/language.util.dart
@@ -28,6 +28,10 @@ class LanguageUtil {
           "header": "This account does not exist",
           "desc": "Don't have an account? Try creating one instead.",
         },
+        "not-accepted-legal": {
+          "header": "Hold up! You forgot to accept the terms of service",
+          "desc": "Check the box below and resubmit the form",
+        },
         "invalid-phone-number": {
           "header": "Hold up! You're phone number is invalid",
           "desc": "Check your phone number before continuing",
@@ -124,7 +128,7 @@ class LanguageUtil {
         "desc": "We'll send you a SMS code to verify your\n account",
         "buttonText": "Send SMS",
         "terms":
-            "By creating an account, you agree to Safe's terms of service. Click here to read them.",
+            "By checking this checkbox, you agree to Safe's terms of service. Tap here to read them.",
         "smsSentMsg": {
           "header": "SMS sent to {PHONE}",
           "body": "Check your SMS messages.",
@@ -184,7 +188,7 @@ class LanguageUtil {
           LimitErrorState.noConnection:
               "We cannot capture an incident without an internet connection. Try checking your connection.",
           LimitErrorState.maxed:
-              "No worries, simply delete a previous incident to gain back the ability to capture one.",
+              "For more incidents, tap here to request more incidents from the Safe team.",
           LimitErrorState.missingContacts:
               "Without contacts, no one will be notified when you activate Safe.",
           LimitErrorState.permissions:
@@ -193,7 +197,7 @@ class LanguageUtil {
         },
         "button": {
           LimitErrorState.emergency: "Emergency Activate",
-          LimitErrorState.maxed: "Delete an Incident",
+          LimitErrorState.maxed: "Request More",
           LimitErrorState.missingContacts: "Add Contacts",
           LimitErrorState.permissions: "Go to Settings",
           LimitErrorState.noConnection: "Go to Settings",
@@ -201,6 +205,9 @@ class LanguageUtil {
         },
       }
     },
+    "credit_request": {
+      "notification": "The team has been notified",
+    },
     "contacts": {
       "types": {
         MessageType.start: "Incident Started ✅",
@@ -212,6 +219,12 @@ class LanguageUtil {
     "tutorial": {"button": "Add a Contact"},
     "incident_log": {
       "header": "Incident Log",
+      "widget_showcase": {
+        "header": "Add the Safe Widget",
+        "desc": "Seamlessly activate Safe from\nyour lock-screen",
+        "confirm": "Got it!",
+        "learn_more": "How to add →",
+      },
       "counter": "{count} Incidents",
       "subheader": "All Incidents",
       "contacts_button": "Contacts",
@@ -264,6 +277,9 @@ class LanguageUtil {
             "notify": "Notify",
           }
         },
+        "widget": {
+          "header": "Add Lock Screen Widget",
+        },
         "quality": {
           "header": "Capped Video Quality",
           "loading": "Loading quality...",
@@ -286,6 +302,7 @@ class LanguageUtil {
           "collaborators": "Collaborators",
           "media_kit": "Media Kit",
         },
+        "deletion_policy": "Delete an Incident",
         "help": "Help",
         "feedback": "Give feedback"
       },
@@ -306,15 +323,18 @@ class LanguageUtil {
           "modal": {
             "header": "Delete Account",
             "desc":
-                "Deleting an account is currently unavailable due to the highly sensitive nature of Safe accounts and the information they store. We're actively working on finding a secure way make this possible.",
-            "button": "Ok",
+                "All data tied to this account will be lost. This action is irreversable.",
+            "button": "Delete",
+            "cancel": "Cancel",
           },
+          "loader": "Deleting account",
+          "failed": "Failed to delete account",
         },
       },
       "story": {
         "header": "The Safe Story",
         "body":
-            "The Safe App is a social impact venture developed by Mark Music. Tap here to view his story.",
+            "The Safe App is a social impact venture developed by a teenager in Costa Rica. Tap here to view Mark's story.",
       },
       "reach_out": {
         "header": "Reach Out",
diff --git a/lib/utils/tutorial/tutorial.util.dart b/lib/utils/tutorial/tutorial.util.dart
index ed47dcca..e52371d1 100644
--- a/lib/utils/tutorial/tutorial.util.dart
+++ b/lib/utils/tutorial/tutorial.util.dart
@@ -20,6 +20,14 @@ class TutorialUtil {
   Future<void> handleOnLeave(Core core) async {
     if (!core.state.preferences.isFirstTime) return;
 
+    if (core.state.preferences.tutorialCalled) return;
+
+    if (!core.state.preferences.seenWidgetPreview) {
+      core.state.incident.widgetShowcasePopupController.open();
+      core.state.preferences.setSeenWidgetPreview(true);
+      return;
+    }
+
     await core.state.incidentLog.controller.close();
 
     if (core.state.capture.limErrState != null) {
@@ -31,6 +39,8 @@ class TutorialUtil {
     // Trigger fireworks and success message
     core.state.preferences.confettiController.play();
     core.state.preferences.tutorialBannerController.open();
+
+    core.state.preferences.setTutorialCalled(true);
   }
 
   void handleCaptureTutorial(Core core) {
diff --git a/lib/widgets/mutable_auth_wrapper/mutable_auth_wrapper.widget.dart b/lib/widgets/mutable_auth_wrapper/mutable_auth_wrapper.widget.dart
index 756d52c8..97e7e8a2 100644
--- a/lib/widgets/mutable_auth_wrapper/mutable_auth_wrapper.widget.dart
+++ b/lib/widgets/mutable_auth_wrapper/mutable_auth_wrapper.widget.dart
@@ -77,6 +77,16 @@ class _MutableAuthWrapperState extends State<MutableAuthWrapper> {
         id: fbUser.uid,
       );
 
+      if (user == null) {
+        genUser(null, fbUser);
+        return;
+      }
+
+      if (user.name.isEmpty) {
+        genUser(null, fbUser);
+        return;
+      }
+
       genUser(user, fbUser);
     } catch (e) {
       genUser(null, fbUser);
diff --git a/lib/widgets/mutable_gradient_border/local_widgets/gradient_border_painter.widget.dart b/lib/widgets/mutable_gradient_border/local_widgets/gradient_border_painter.widget.dart
index 18970bfd..634374c6 100644
--- a/lib/widgets/mutable_gradient_border/local_widgets/gradient_border_painter.widget.dart
+++ b/lib/widgets/mutable_gradient_border/local_widgets/gradient_border_painter.widget.dart
@@ -6,11 +6,13 @@ class GradientBorderPainter extends CustomPainter {
   final Alignment? begin;
   final Alignment? end;
   final double borderRadius;
+  final List<Color>? colors;
 
   GradientBorderPainter({
     required this.width,
     required this.borderRadius,
     this.begin,
+    this.colors,
     this.end,
   });
 
@@ -23,7 +25,7 @@ class GradientBorderPainter extends CustomPainter {
 
     Paint paint = Paint()
       ..shader = LinearGradient(
-        colors: kPrimaryGradientColors,
+        colors: colors ?? kPrimaryGradientColors,
         begin: begin ?? kPrimaryGradientAlignmentBegin,
         end: end ?? kPrimaryGradientAlignmentEnd,
       ).createShader(rect)
diff --git a/lib/widgets/mutable_input_panel/mutable_input_panel.widget.dart b/lib/widgets/mutable_input_panel/mutable_input_panel.widget.dart
index e2f98cb0..11c3a864 100644
--- a/lib/widgets/mutable_input_panel/mutable_input_panel.widget.dart
+++ b/lib/widgets/mutable_input_panel/mutable_input_panel.widget.dart
@@ -1,7 +1,6 @@
 import 'package:flutter/material.dart';
 import 'package:safe/utils/constants/constants.util.dart';
 import 'package:safe/utils/icon/icon.util.dart';
-import 'package:safe/widgets/mutable_button/mutable_button.widget.dart';
 import 'package:safe/widgets/mutable_handle/mutable_handle.dart';
 import 'package:safe/widgets/mutable_icon_sphere/mutable_icon_sphere.widget.dart';
 import 'package:safe/widgets/mutable_large_button/mutable_large_button.widget.dart';
@@ -13,9 +12,8 @@ class MutableInputPanel extends StatefulWidget {
   final void Function()? onTap;
   final Size? iconSize;
   final bool isActive;
+  final Widget? aboveButtonWidget;
   final String buttonText;
-  final String? aboveButtonText;
-  final void Function()? aboveButtonOnTap;
   final String title;
   final bool shimmer;
   final bool accomodateBottomInsets;
@@ -27,8 +25,7 @@ class MutableInputPanel extends StatefulWidget {
     this.accomodateBottomInsets = false,
     required this.body,
     this.onTap,
-    this.aboveButtonText,
-    this.aboveButtonOnTap,
+    this.aboveButtonWidget,
     required this.icon,
     this.shimmer = false,
     this.iconSize,
@@ -133,21 +130,9 @@ class _MutableInputPanelState extends State<MutableInputPanel> {
                           },
                         )
                       : Spacer(),
-                  widget.aboveButtonText == null
+                  widget.aboveButtonWidget == null
                       ? SizedBox()
-                      : MutableButton(
-                          scale: 0.9,
-                          onTap: widget.aboveButtonOnTap,
-                          child: Padding(
-                            padding: EdgeInsets.fromLTRB(18, 0, 18, 18),
-                            child: MutableText(
-                              widget.aboveButtonText!,
-                              size: 12,
-                              color: MutableColor.neutral3,
-                              align: TextAlign.center,
-                            ),
-                          ),
-                        ),
+                      : widget.aboveButtonWidget!,
                   MutableLargeButton(
                     onTap: widget.onTap,
                     text: widget.buttonText,
diff --git a/lib/widgets/mutable_input_popup_action/mutable_input_popup_action.widget.dart b/lib/widgets/mutable_input_popup_action/mutable_input_popup_action.widget.dart
index 10da401c..fc015450 100644
--- a/lib/widgets/mutable_input_popup_action/mutable_input_popup_action.widget.dart
+++ b/lib/widgets/mutable_input_popup_action/mutable_input_popup_action.widget.dart
@@ -9,10 +9,12 @@ class MutableInputPopupAction extends StatelessWidget {
   final void Function()? onTap;
   final String text;
   final MutableIcon? icon;
+  final MutableColor secondaryColor;
 
   MutableInputPopupAction({
     required this.text,
     this.onTap,
+    this.secondaryColor = MutableColor.neutral3,
     this.icon,
     this.active = false,
   });
@@ -34,8 +36,8 @@ class MutableInputPopupAction extends StatelessWidget {
                       kPrimaryGradientColors.length - 1,
                     )
                   : [
-                      kColorMap[MutableColor.neutral3]!,
-                      kColorMap[MutableColor.neutral3]!,
+                      kColorMap[secondaryColor]!,
+                      kColorMap[secondaryColor]!,
                     ],
             ).createShader(rect),
             child: Row(
diff --git a/lib/widgets/mutable_popup/local_widgets/non_pannel_body.widget.dart b/lib/widgets/mutable_popup/local_widgets/non_pannel_body.widget.dart
index c3d86d76..6963d212 100644
--- a/lib/widgets/mutable_popup/local_widgets/non_pannel_body.widget.dart
+++ b/lib/widgets/mutable_popup/local_widgets/non_pannel_body.widget.dart
@@ -1,30 +1,80 @@
 import 'package:flutter/material.dart';
+import 'package:provider/provider.dart';
+import 'package:safe/core.dart';
+import 'package:safe/utils/constants/constants.util.dart';
+import 'package:safe/widgets/mutable_gradient_border/local_widgets/gradient_border_painter.widget.dart';
 import 'package:safe/widgets/mutable_popup/local_widgets/mutable_popup_style.widget.dart';
 
-class NonPannelBody extends StatelessWidget {
+class NonPannelBody extends StatefulWidget {
   final Size size;
   final MutablePopupStyle style;
   final Widget? body;
+  final bool isExcited;
 
   NonPannelBody({
     required this.size,
     required this.style,
+    required this.isExcited,
     this.body,
   });
 
+  @override
+  State<NonPannelBody> createState() => _NonPannelBodyState();
+}
+
+class _NonPannelBodyState extends State<NonPannelBody> {
+  late Core core;
+
+  @override
+  void initState() {
+    core = Provider.of<Core>(context, listen: false);
+
+    super.initState();
+  }
+
   @override
   Widget build(BuildContext context) {
     return Align(
       alignment: Alignment.topCenter,
       child: Container(
-        height: size.height,
-        width: size.width,
+        height: widget.size.height,
+        width: widget.size.width,
         decoration: BoxDecoration(
-          color: style.backgroundColor,
-          border: style.border,
-          borderRadius: style.borderRadius,
+          color: widget.style.backgroundColor,
+          gradient: !widget.isExcited
+              ? null
+              : LinearGradient(
+                  begin: Alignment.topCenter,
+                  end: Alignment.bottomCenter,
+                  colors: [
+                    Color.alphaBlend(
+                      kColorMap[MutableColor.excitedPrimary]!.withOpacity(0.1),
+                      kColorMap[MutableColor.excitedBackground]!,
+                    ),
+                    Color.alphaBlend(
+                      kColorMap[MutableColor.excitedPrimary]!.withOpacity(0.03),
+                      kColorMap[MutableColor.excitedBackground]!,
+                    ),
+                  ],
+                ),
+          border: !widget.isExcited ? widget.style.border : null,
+          borderRadius: widget.style.borderRadius,
         ),
-        child: body,
+        child: !widget.isExcited
+            ? widget.body
+            : CustomPaint(
+                painter: GradientBorderPainter(
+                    width: kExcitedBorderWidth,
+                    borderRadius: widget.style.borderRadius!.topRight.y,
+                    begin: Alignment.topCenter,
+                    end: Alignment.bottomCenter,
+                    colors: [
+                      kColorMap[MutableColor.excitedPrimary]!,
+                      kColorMap[MutableColor.excitedPrimary]!.withOpacity(0.2),
+                      kColorMap[MutableColor.excitedPrimary]!.withOpacity(0.1),
+                    ]),
+                child: widget.body,
+              ),
       ),
     );
   }
diff --git a/lib/widgets/mutable_popup/mutable_popup.widget.dart b/lib/widgets/mutable_popup/mutable_popup.widget.dart
index 346b8b8c..95582f84 100644
--- a/lib/widgets/mutable_popup/mutable_popup.widget.dart
+++ b/lib/widgets/mutable_popup/mutable_popup.widget.dart
@@ -26,6 +26,7 @@ class MutablePopup extends StatefulWidget {
   final bool enableBorder;
   final double bottomInsets;
   final double maxHeight;
+  final bool isExcited;
 
   final MutablePopupStyle? style;
   final Widget? body;
@@ -37,6 +38,7 @@ class MutablePopup extends StatefulWidget {
   MutablePopup({
     this.type = PopupType.pannel,
     this.enableBorder = true,
+    this.isExcited = false,
     this.onOpened,
     this.bottomInsets = 0,
     this.scrollBuilder,
@@ -148,6 +150,7 @@ class _MutablePopupState extends State<MutablePopup> {
                       ? widget.body
                       : NonPannelBody(
                           size: size,
+                          isExcited: widget.isExcited,
                           style: style,
                           body: widget.body,
                         ),
diff --git a/shaders.json b/shaders.json
index 0957fd2c..1cd49906 100644
--- a/shaders.json
+++ b/shaders.json
@@ -1 +1 @@
-{"platform":"ios","name":"Mark’s iPhone","engineRevision":"b24591ed328a2d4ce6505819e2f5898a78132f7f","data":{"GCAAAAAADAAAEAABBYAAAAYXBAAAAAAAAAAAAAAA2AAQAAAACAAAAAEASAAQAAAAIYAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"CgAAAExTS1PRAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7CglsYXlvdXQob2Zmc2V0PTI0KSBoYWxmIHVDb3ZlcmFnZV9TMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBpblBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBoYWxmNCBpbkhhaXJRdWFkRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGhhbGY0IHZIYWlyUXVhZEVkZ2VfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWQKCXZIYWlyUXVhZEVkZ2VfUzAgPSBpbkhhaXJRdWFkRWRnZTsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247Cglza19Qb3NpdGlvbiA9IF90bXBfMV9pblBvc2l0aW9uLnh5MDE7Cn0KAAAAAAAAAGYDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGhhbGY0IHVDb2xvcl9TMDsKCWxheW91dChvZmZzZXQ9MjQpIGhhbGYgdUNvdmVyYWdlX1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdkhhaXJRdWFkRWRnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWQKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB1Q29sb3JfUzA7CgloYWxmIGVkZ2VBbHBoYTsKCWhhbGYyIGR1dmR4ID0gaGFsZjIoZEZkeCh2SGFpclF1YWRFZGdlX1MwLnh5KSk7CgloYWxmMiBkdXZkeSA9IGhhbGYyKGRGZHkodkhhaXJRdWFkRWRnZV9TMC54eSkpOwoJaGFsZjIgZ0YgPSBoYWxmMigyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeC54IC0gZHV2ZHgueSwgICAgICAgICAgICAgICAyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeS54IC0gZHV2ZHkueSk7CgllZGdlQWxwaGEgPSBoYWxmKHZIYWlyUXVhZEVkZ2VfUzAueCAqIHZIYWlyUXVhZEVkZ2VfUzAueCAtIHZIYWlyUXVhZEVkZ2VfUzAueSk7CgllZGdlQWxwaGEgPSBzcXJ0KGVkZ2VBbHBoYSAqIGVkZ2VBbHBoYSAvIGRvdChnRiwgZ0YpKTsKCWVkZ2VBbHBoYSA9IG1heCgxLjAgLSBlZGdlQWxwaGEsIDAuMCk7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KHVDb3ZlcmFnZV9TMCAqIGVkZ2VBbHBoYSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAfAAAACAAAAAEAAAAYAAAAAAAAAEYAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAMWAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAABYCMNGFQIAAAAHADEHC6BAAAAAAAABAAAAAAIBDBL6DGOQAAAAAAEAAAAABALL354SAAAAABQAAAAHAJRUIUBIBAAAMAMY4LYEAAAAAEAAAAABAIMQAAAAAEBNPNXSJAAAAAGAAAAAMBGOQCQFQEAAAQBTTRPAQAAAAAQAAAAAIBDCAWTWL3EYAAAADAAAAACADHIJJCYCAAAAAZ5YHQIIAAAAAAAIAAAABTZCMNCFAKAIAAAAAAAAAMBCTZQ7BQUAAAAAAAIAAAADEZAZRYXQIAAAAAAAAAAAGABIBAABAAAAANAEIQCAAAAAAAAAAABQAAGQAAAAKFIDMVQUAAAAABIAAAAAQAAAABEERFAUBWKYKAAAIAAQAAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEADZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAIAAAAAAAA":"CgAAAExTS1OpAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgb3V0IGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgl2Y29sb3JfUzAgPSBjb2xvcjsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAAAAAJwMAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQ0IHVpbm5lclJlY3RfUzE7CglsYXlvdXQob2Zmc2V0PTMyKSBoYWxmMiB1cmFkaXVzUGx1c0hhbGZfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKaGFsZjQgQ2lyY3VsYXJSUmVjdF9TMShoYWxmNCBfaW5wdXQpIAp7CglmbG9hdDIgZHh5MCA9IHVpbm5lclJlY3RfUzEuTFQgLSBza19GcmFnQ29vcmQueHk7CglmbG9hdDIgZHh5MSA9IHNrX0ZyYWdDb29yZC54eSAtIHVpbm5lclJlY3RfUzEuUkI7CglmbG9hdDIgZHh5ID0gbWF4KG1heChkeHkwLCBkeHkxKSwgMC4wKTsKCWhhbGYgYWxwaGEgPSBoYWxmKHNhdHVyYXRlKHVyYWRpdXNQbHVzSGFsZl9TMS54IC0gbGVuZ3RoKGR4eSkpKTsKCXJldHVybiBfaW5wdXQgKiBhbHBoYTsKfQp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmNvbG9yX1MwOwoJY29uc3QgaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNCgxKTsKCWhhbGY0IG91dHB1dF9TMTsKCW91dHB1dF9TMSA9IENpcmN1bGFyUlJlY3RfUzEob3V0cHV0Q292ZXJhZ2VfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0X1MxOwoJfQp9CgABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAMGAICAAAAAAAA":"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","AYAA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1MrAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQ0IGluQ2lyY2xlRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0NCB2aW5DaXJjbGVFZGdlX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCgl2aW5DaXJjbGVFZGdlX1MwID0gaW5DaXJjbGVFZGdlOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCWZsb2F0MiBfdG1wXzJfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247Cglza19Qb3NpdGlvbiA9IF90bXBfMF9pblBvc2l0aW9uLnh5MDE7Cn0KAAAAAABwAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJZmxvYXQ0IGNpcmNsZUVkZ2U7CgljaXJjbGVFZGdlID0gdmluQ2lyY2xlRWRnZV9TMDsKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2aW5Db2xvcl9TMDsKCWZsb2F0IGQgPSBsZW5ndGgoY2lyY2xlRWRnZS54eSk7CgloYWxmIGRpc3RhbmNlVG9PdXRlckVkZ2UgPSBoYWxmKGNpcmNsZUVkZ2UueiAqICgxLjAgLSBkKSk7CgloYWxmIGVkZ2VBbHBoYSA9IHNhdHVyYXRlKGRpc3RhbmNlVG9PdXRlckVkZ2UpOwoJaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNChlZGdlQWxwaGEpOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0Q292ZXJhZ2VfUzA7Cgl9Cn0KAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAEAAAAAAAAAAwAAAB0AAAAAAAAAAQAAAAkAAAAIAAAAAQAAAB8AAAAMAAAAAQAAABwAAAAAAAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","HTQAAGAABBYAAAEIXBAAAGEAMAAAAAAAAAAAAAAAQAHAAAAAQAAAAAAAQQGAAAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABZQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDCQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQHAAAAAAAAAEAAAABJOQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAAAAEAAAABJYQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAIAAEAAAABJYQAAAAAQAAIAAAAAWCBACAABAAAAANAECAZAAEAAAAAAAAFAAMAAAABAAAAAAABBANDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADIAANAAAAALHCKLMRAAAAAAAAABAAAAAGJBCFLQVBWAQAAAAAAQAAAAAMACQCAACAAAAA2AIBAEIAAAAAAAAAAAAMAAPEAEAAABAAAAAAB2AAAAAAACAAAAAEBSAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAASLEYTYIIBAAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAAEQZCFOCCIJAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAEAIRLQYTSIAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAITLAYT2IAAAAA5B3UTQIDAAAAAEAAAAAJBQKEKYGE6SAAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAMGAIAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAACQAAAAAABQIQCAAAAUAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAAGAAAAAAAAAAA":"CgAAAExTS1OAAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGluUG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGluQ29sb3I7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0NCBpbkNpcmNsZUVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJdmluQ2lyY2xlRWRnZV9TMCA9IGluQ2lyY2xlRWRnZTsKCXZpbkNvbG9yX1MwID0gaW5Db2xvcjsKCWZsb2F0MiBfdG1wXzBfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSB1bG9jYWxNYXRyaXhfUzAueHogKiBpblBvc2l0aW9uICsgdWxvY2FsTWF0cml4X1MwLnl3OwoJc2tfUG9zaXRpb24gPSBfdG1wXzBfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAACyAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogQ292ZXJhZ2UgU2V0IE9wCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q292ZXJhZ2VfUzA7CgkJc2tfRnJhZ0NvbG9yID0gc2tfRnJhZ0NvbG9yLmEwMDA7Cgl9Cn0KAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIAAAAAQAAAAAAAAADAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAAHwAAAAwAAAABAAAAHAAAAAAAAAAKAAAAAAAAAAEAAAAAAAAA","FAAQMYAAMAAAEADAAABAEYAAAICIAB5AABQAAAQAMAAAEATAAABAIIGAAEDCBYQCA4AAAAAAAA5AAAAAAABAAAAACAZAAAAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQKAAAAAAABAEAAAABJUQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAAAQAAAAGQCEIBAACAAAAAAAACQAGAAAAAQAAAAAGBCAIAAAAAFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABZQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDCQAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEAAAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEADZAAAAAGIAAAAACAAAAADZEAIAAAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"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","CIAAAAAAQAARQAAYQAAAAGFYQAABRAAAAEEAAAAAAARAEAGIAHSACAAAAQAAAAAA5AAAAAAABAAAAACAZAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HVJAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAABAAAAAABBAMABSAAGQAAAAKFIDMVQUAAAAABIAAAAGIAMAAAEAAAAAJBEJIFANSWCQAACAAEAAAAAAAAAAABYSA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQJAAAAAAABAEAAAABJSQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQHAAAAAAAAAEAAAABJOQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQFAAAAAAAAAEAAAABJKQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAABYCMNGFQIAAAAHADEHC6BAAAAAAAABAAAAAAIBDBL6DGOQAAAAAAEAAAAABALL354SAAAAABQAAAAHAJRUIUBIBAAAMAMY4LYEAAAAAEAAAAABAIMQAAAAAEBNPNXSJAAAAAGAAAAAMBGOQCQFQEAAAQBTTRPAQAAAAAQAAAAAIBDCAWTWL3EYAAAADAAAAACADHIJJCYCAAAAAZ5YHQIIAAAAAAAIAAAABTZCMNCFAKAIAAAAAAAAAMBCTZQ7BQUAAAAAAAIAAAADEZAZRYXQIAAAAAAAAAAAGABIBAABAAAAANAEIQCAAAAAAAAAAABAAOAAAABAAAAAAABBAMRQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAB3QA6AAAEAAAAAAAMAAPEAEAAABAAAAAAB2AAAAAAACAAAAAEBSAAABDAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQJAAAAAAAAAEAAAABJSQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGACQAGAAAAAQAAAAAAAQQGAAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"CgAAAExTS1NkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGZsb2F0MiBsb2NhbENvb3JkOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgZmxvYXQyIHZsb2NhbENvb3JkX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZsb2NhbENvb3JkX1MwID0gbG9jYWxDb29yZDsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAKQIAAGxheW91dChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHNhbXBsZXIyRCB1VGV4dHVyZVNhbXBsZXJfMF9TMDsKbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgdmxvY2FsQ29vcmRfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gaGFsZjQoMSk7CglmbG9hdDIgdGV4Q29vcmQ7Cgl0ZXhDb29yZCA9IHZsb2NhbENvb3JkX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSAoKHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMCwgdGV4Q29vcmQpICogaGFsZjQoMSkpKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHQAAAAgAAAABAAAAEAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","DAQAAAAAAABGAABAYAAQAIHCAIAYAQUBAEAAAAAAEAAAAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"CgAAAExTS1PfAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDIgdUF0bGFzU2l6ZUludl9TMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBpblBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBoYWxmNCBpbkNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiB1c2hvcnQyIGluVGV4dHVyZUNvb3JkczsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2VGV4dHVyZUNvb3Jkc19TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgZmxhdCBvdXQgZmxvYXQgdlRleEluZGV4X1MwOwpsYXlvdXQobG9jYXRpb24gPSAyKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIEJpdG1hcFRleHQKCWludCB0ZXhJZHggPSAwOwoJZmxvYXQyIHVub3JtVGV4Q29vcmRzID0gZmxvYXQyKGluVGV4dHVyZUNvb3Jkcy54LCBpblRleHR1cmVDb29yZHMueSk7Cgl2VGV4dHVyZUNvb3Jkc19TMCA9IHVub3JtVGV4Q29vcmRzICogdUF0bGFzU2l6ZUludl9TMDsKCXZUZXhJbmRleF9TMCA9IGZsb2F0KHRleElkeCk7Cgl2aW5Db2xvcl9TMCA9IGluQ29sb3I7CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJc2tfUG9zaXRpb24gPSBpblBvc2l0aW9uLnh5MDE7Cn0KAAAAAACRAgAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MwOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0MiB1QXRsYXNTaXplSW52X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHZUZXh0dXJlQ29vcmRzX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBmbGF0IGluIGZsb2F0IHZUZXhJbmRleF9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBCaXRtYXBUZXh0CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CgloYWxmNCB0ZXhDb2xvcjsKCXsKCQl0ZXhDb2xvciA9IHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMCwgdlRleHR1cmVDb29yZHNfUzApLnJycnI7Cgl9CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IHRleENvbG9yOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0Q292ZXJhZ2VfUzA7Cgl9Cn0KAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAEAAAAAAAAAAwAAAB0AAAAAAAAAAQAAAAkAAAAIAAAAAQAAAA0AAAAMAAAAAQAAABAAAAAAAAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADEAANAAAAALHCKLMRAAAAAAAAABAAAAAGJBCFLQVBWAQAAAAAAQAAAAAMACQCAACAAAAA2AIBAEIAAAAAAAAAAAAIADQAAAAIAAAAAAAIIDAAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBQU7BTXIAAAAAACAWXW3ZEQAAAADAAAAAGATHIBICYCAAAEBP2LBIPAAAAAIAAAAAEARRALJ3F5SMAAAABQAAAABABTUEURMBAAACAH5FYUHQAAAAAAAEAAAAAZ4RGGRCQFAEAAAAAAAAAGARP2LVJPAAAAAAAAEAAAABSKRXZFAUHQAAAAAAAAAACAA4AAAACAAAAAAACCAYAEMAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAICAACAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAAAHUAAAAABABLFMNCQCAAAKAAAAAEAAAAABAEMIRA5SWCRAAAAAFAAAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAMGAICAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQFAAAAAAAAAEAAAABJKQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","GCAAAAAADAAAEAABBYAAAAYXBAAAAAAAAAAAAAAA2AAQAAAACAAAAAEASAAQAAAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"CgAAAExTS1PRAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7CglsYXlvdXQob2Zmc2V0PTI0KSBoYWxmIHVDb3ZlcmFnZV9TMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBpblBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBoYWxmNCBpbkhhaXJRdWFkRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGhhbGY0IHZIYWlyUXVhZEVkZ2VfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWQKCXZIYWlyUXVhZEVkZ2VfUzAgPSBpbkhhaXJRdWFkRWRnZTsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247Cglza19Qb3NpdGlvbiA9IF90bXBfMV9pblBvc2l0aW9uLnh5MDE7Cn0KAAAAAAAAAGYDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGhhbGY0IHVDb2xvcl9TMDsKCWxheW91dChvZmZzZXQ9MjQpIGhhbGYgdUNvdmVyYWdlX1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdkhhaXJRdWFkRWRnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWQKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB1Q29sb3JfUzA7CgloYWxmIGVkZ2VBbHBoYTsKCWhhbGYyIGR1dmR4ID0gaGFsZjIoZEZkeCh2SGFpclF1YWRFZGdlX1MwLnh5KSk7CgloYWxmMiBkdXZkeSA9IGhhbGYyKGRGZHkodkhhaXJRdWFkRWRnZV9TMC54eSkpOwoJaGFsZjIgZ0YgPSBoYWxmMigyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeC54IC0gZHV2ZHgueSwgICAgICAgICAgICAgICAyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeS54IC0gZHV2ZHkueSk7CgllZGdlQWxwaGEgPSBoYWxmKHZIYWlyUXVhZEVkZ2VfUzAueCAqIHZIYWlyUXVhZEVkZ2VfUzAueCAtIHZIYWlyUXVhZEVkZ2VfUzAueSk7CgllZGdlQWxwaGEgPSBzcXJ0KGVkZ2VBbHBoYSAqIGVkZ2VBbHBoYSAvIGRvdChnRiwgZ0YpKTsKCWVkZ2VBbHBoYSA9IG1heCgxLjAgLSBlZGdlQWxwaGEsIDAuMCk7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KHVDb3ZlcmFnZV9TMCAqIGVkZ2VBbHBoYSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAfAAAACAAAAAEAAAAYAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HVJAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAABAAAAAABBAMABAAOAAAABAAAAAAABBAMAAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"CgAAAExTS1PMAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgZmxhdCBvdXQgaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgZmxvYXQyIHZsb2NhbENvb3JkX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJdmxvY2FsQ29vcmRfUzAgPSBsb2NhbENvb3JkOwoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwp9CgAAAABvAgAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MwOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgaW4gaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgdmxvY2FsQ29vcmRfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2Y29sb3JfUzA7CglmbG9hdDIgdGV4Q29vcmQ7Cgl0ZXhDb29yZCA9IHZsb2NhbENvb3JkX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSAoKHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMCwgdGV4Q29vcmQpICogb3V0cHV0Q29sb3JfUzApKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAEAAAAAAAAAAwAAAB0AAAAAAAAAAQAAAAkAAAAIAAAAAQAAAB0AAAAMAAAAAQAAABQAAAAAAAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAAAHUAAAAABABLFMNCQCAAAKAAAAACADYAABAAAAAAIBDCEIHMVQUIAAAABIAAAAAAAAAAAOAQHSAAAAAAQAAAAAA5AAAAAAABAAAAACAZAAACQAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEBAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQLAAAAAAAAAEAAAABJWQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","AZAA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"CgAAAExTS1N4AgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bG9jYWxNYXRyaXhfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQ0IGluQ2lyY2xlRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0NCB2aW5DaXJjbGVFZGdlX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCgl2aW5DaXJjbGVFZGdlX1MwID0gaW5DaXJjbGVFZGdlOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGZsb2F0M3gyKHVsb2NhbE1hdHJpeF9TMCkgKiBpblBvc2l0aW9uLnh5MTsKCXNrX1Bvc2l0aW9uID0gX3RtcF8wX2luUG9zaXRpb24ueHkwMTsKfQoAAAAAnQIAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQzeDMgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAABAAAAAAAAAAMAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAfAAAADAAAAAEAAAAcAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEADZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAIAAAAAAAA":"CgAAAExTS1OpAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgb3V0IGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgl2Y29sb3JfUzAgPSBjb2xvcjsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAAAAAJwMAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQ0IHVpbm5lclJlY3RfUzE7CglsYXlvdXQob2Zmc2V0PTMyKSBoYWxmMiB1cmFkaXVzUGx1c0hhbGZfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKaGFsZjQgQ2lyY3VsYXJSUmVjdF9TMShoYWxmNCBfaW5wdXQpIAp7CglmbG9hdDIgZHh5MCA9IHVpbm5lclJlY3RfUzEuTFQgLSBza19GcmFnQ29vcmQueHk7CglmbG9hdDIgZHh5MSA9IHNrX0ZyYWdDb29yZC54eSAtIHVpbm5lclJlY3RfUzEuUkI7CglmbG9hdDIgZHh5ID0gbWF4KG1heChkeHkwLCBkeHkxKSwgMC4wKTsKCWhhbGYgYWxwaGEgPSBoYWxmKHNhdHVyYXRlKHVyYWRpdXNQbHVzSGFsZl9TMS54IC0gbGVuZ3RoKGR4eSkpKTsKCXJldHVybiBfaW5wdXQgKiBhbHBoYTsKfQp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmNvbG9yX1MwOwoJY29uc3QgaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNCgxKTsKCWhhbGY0IG91dHB1dF9TMTsKCW91dHB1dF9TMSA9IENpcmN1bGFyUlJlY3RfUzEob3V0cHV0Q292ZXJhZ2VfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0X1MxOwoJfQp9CgABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBQU7BTXIAAAAAACAWXW3ZEQAAAADAAAAAGATHIBICYCAAAEBP2LBIPAAAAAIAAAAAEARRALJ3F5SMAAAABQAAAABABTUEURMBAAACAH5FYUHQAAAAAAAEAAAAAZ4RGGRCQFAEAAAAAAAAAGARP2LVJPAAAAAAAAEAAAABSKRXZFAUHQAAAAAAAAAACAA4AAAACAAAAAAACCAYAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAICAACAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGAAZAADIAAAACU53QJEKAAAAAAMAAAAAIAAAAAAGIRDFB2XASAUAABQAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAIYAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAOAAHSAAAAAAQAAAAAA5AAAAAAABAAAAACAZAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABZQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDCGAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","AZAA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1N4AgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bG9jYWxNYXRyaXhfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQ0IGluQ2lyY2xlRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0NCB2aW5DaXJjbGVFZGdlX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCgl2aW5DaXJjbGVFZGdlX1MwID0gaW5DaXJjbGVFZGdlOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGZsb2F0M3gyKHVsb2NhbE1hdHJpeF9TMCkgKiBpblBvc2l0aW9uLnh5MTsKCXNrX1Bvc2l0aW9uID0gX3RtcF8wX2luUG9zaXRpb24ueHkwMTsKfQoAAAAAnQIAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQzeDMgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAABAAAAAAAAAAMAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAfAAAADAAAAAEAAAAcAAAAAAAAAEYAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGABZAA6IAAAAACAAAAAADUAAAAAAAEAAAAAIDEAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEAAZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAIMDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1aW5uZXJSZWN0X1MxOwoJbGF5b3V0KG9mZnNldD0zMikgaGFsZjIgdXJhZGl1c1BsdXNIYWxmX1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdmNvbG9yX1MwOwpoYWxmNCBDaXJjdWxhclJSZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCWZsb2F0MiBkeHkwID0gdWlubmVyUmVjdF9TMS5MVCAtIHNrX0ZyYWdDb29yZC54eTsKCWZsb2F0IGR4MSA9IHNrX0ZyYWdDb29yZC54IC0gdWlubmVyUmVjdF9TMS5SOwoJZmxvYXQyIGR4eSA9IG1heChmbG9hdDIobWF4KGR4eTAueCwgZHgxKSwgZHh5MC55KSwgMC4wKTsKCWhhbGYgYm90dG9tQWxwaGEgPSBoYWxmKHNhdHVyYXRlKHVpbm5lclJlY3RfUzEuQiAtIHNrX0ZyYWdDb29yZC55KSk7CgloYWxmIGFscGhhID0gYm90dG9tQWxwaGEgKiBoYWxmKHNhdHVyYXRlKHVyYWRpdXNQbHVzSGFsZl9TMS54IC0gbGVuZ3RoKGR4eSkpKTsKCXJldHVybiBfaW5wdXQgKiBhbHBoYTsKfQp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmNvbG9yX1MwOwoJY29uc3QgaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNCgxKTsKCWhhbGY0IG91dHB1dF9TMTsKCW91dHB1dF9TMSA9IENpcmN1bGFyUlJlY3RfUzEob3V0cHV0Q292ZXJhZ2VfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0X1MxOwoJfQp9CgABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","AY7SRAADQAAAOAEARAFQJAABBADAAAILBYAACCYUAAAQWGUAAEECAAAAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"CgAAAExTS1PwBAAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGluUG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGluQ29sb3I7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0NCBpbkNpcmNsZUVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDMpIGluIGhhbGYzIGluQ2xpcFBsYW5lOwpsYXlvdXQobG9jYXRpb24gPSA0KSBpbiBoYWxmMyBpbklzZWN0UGxhbmU7CmxheW91dChsb2NhdGlvbiA9IDUpIGluIGhhbGYzIGluVW5pb25QbGFuZTsKbGF5b3V0KGxvY2F0aW9uID0gNikgaW4gZmxvYXQ0IGluUm91bmRDYXBDZW50ZXJzOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIG91dCBoYWxmMyB2aW5DbGlwUGxhbmVfUzA7CmxheW91dChsb2NhdGlvbiA9IDIpIG91dCBoYWxmMyB2aW5Jc2VjdFBsYW5lX1MwOwpsYXlvdXQobG9jYXRpb24gPSAzKSBvdXQgaGFsZjMgdmluVW5pb25QbGFuZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gNCkgb3V0IGZsb2F0NCB2aW5Sb3VuZENhcENlbnRlcnNfUzA7CmxheW91dChsb2NhdGlvbiA9IDUpIGZsYXQgb3V0IGZsb2F0IHZjYXBSYWRpdXNfUzA7CmxheW91dChsb2NhdGlvbiA9IDYpIG91dCBoYWxmNCB2aW5Db2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCXZpbkNpcmNsZUVkZ2VfUzAgPSBpbkNpcmNsZUVkZ2U7Cgl2aW5DbGlwUGxhbmVfUzAgPSBpbkNsaXBQbGFuZTsKCXZpbklzZWN0UGxhbmVfUzAgPSBpbklzZWN0UGxhbmU7Cgl2aW5VbmlvblBsYW5lX1MwID0gaW5VbmlvblBsYW5lOwoJdmluUm91bmRDYXBDZW50ZXJzX1MwID0gaW5Sb3VuZENhcENlbnRlcnM7Cgl2Y2FwUmFkaXVzX1MwID0gKDEuMCAtIGluQ2lyY2xlRWRnZS53KSAvIDIuMDsKCXZpbkNvbG9yX1MwID0gaW5Db2xvcjsKCWZsb2F0MiBfdG1wXzBfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSB1bG9jYWxNYXRyaXhfUzAueHogKiBpblBvc2l0aW9uICsgdWxvY2FsTWF0cml4X1MwLnl3OwoJc2tfUG9zaXRpb24gPSBfdG1wXzBfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAABeBwAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGYzIHZpbkNsaXBQbGFuZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gaGFsZjMgdmluSXNlY3RQbGFuZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMykgaW4gaGFsZjMgdmluVW5pb25QbGFuZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gNCkgaW4gZmxvYXQ0IHZpblJvdW5kQ2FwQ2VudGVyc19TMDsKbGF5b3V0KGxvY2F0aW9uID0gNSkgZmxhdCBpbiBmbG9hdCB2Y2FwUmFkaXVzX1MwOwpsYXlvdXQobG9jYXRpb24gPSA2KSBpbiBoYWxmNCB2aW5Db2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCglmbG9hdDQgY2lyY2xlRWRnZTsKCWNpcmNsZUVkZ2UgPSB2aW5DaXJjbGVFZGdlX1MwOwoJaGFsZjMgY2xpcFBsYW5lOwoJY2xpcFBsYW5lID0gdmluQ2xpcFBsYW5lX1MwOwoJaGFsZjMgaXNlY3RQbGFuZTsKCWlzZWN0UGxhbmUgPSB2aW5Jc2VjdFBsYW5lX1MwOwoJaGFsZjMgdW5pb25QbGFuZTsKCXVuaW9uUGxhbmUgPSB2aW5VbmlvblBsYW5lX1MwOwoJZmxvYXQ0IHJvdW5kQ2FwQ2VudGVyczsKCXJvdW5kQ2FwQ2VudGVycyA9IHZpblJvdW5kQ2FwQ2VudGVyc19TMDsKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2aW5Db2xvcl9TMDsKCWZsb2F0IGQgPSBsZW5ndGgoY2lyY2xlRWRnZS54eSk7CgloYWxmIGRpc3RhbmNlVG9PdXRlckVkZ2UgPSBoYWxmKGNpcmNsZUVkZ2UueiAqICgxLjAgLSBkKSk7CgloYWxmIGVkZ2VBbHBoYSA9IHNhdHVyYXRlKGRpc3RhbmNlVG9PdXRlckVkZ2UpOwoJaGFsZiBkaXN0YW5jZVRvSW5uZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoZCAtIGNpcmNsZUVkZ2UudykpOwoJaGFsZiBpbm5lckFscGhhID0gc2F0dXJhdGUoZGlzdGFuY2VUb0lubmVyRWRnZSk7CgllZGdlQWxwaGEgKj0gaW5uZXJBbHBoYTsKCWhhbGYgY2xpcCA9IGhhbGYoc2F0dXJhdGUoY2lyY2xlRWRnZS56ICogZG90KGNpcmNsZUVkZ2UueHksIGNsaXBQbGFuZS54eSkgKyBjbGlwUGxhbmUueikpOwoJY2xpcCAqPSBoYWxmKHNhdHVyYXRlKGNpcmNsZUVkZ2UueiAqIGRvdChjaXJjbGVFZGdlLnh5LCBpc2VjdFBsYW5lLnh5KSArIGlzZWN0UGxhbmUueikpOwoJY2xpcCA9IHNhdHVyYXRlKGNsaXAgKyBoYWxmKHNhdHVyYXRlKGNpcmNsZUVkZ2UueiAqIGRvdChjaXJjbGVFZGdlLnh5LCB1bmlvblBsYW5lLnh5KSArIHVuaW9uUGxhbmUueikpKTsKCWVkZ2VBbHBoYSAqPSBjbGlwOwoJaGFsZiBkY2FwMSA9IGhhbGYoY2lyY2xlRWRnZS56ICogKHZjYXBSYWRpdXNfUzAgLSBsZW5ndGgoY2lyY2xlRWRnZS54eSAtIHJvdW5kQ2FwQ2VudGVycy54eSkpKTsKCWhhbGYgZGNhcDIgPSBoYWxmKGNpcmNsZUVkZ2UueiAqICh2Y2FwUmFkaXVzX1MwIC0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkgLSByb3VuZENhcENlbnRlcnMuencpKSk7CgloYWxmIGNhcEFscGhhID0gKDEgLSBjbGlwKSAqIChtYXgoZGNhcDEsIDApICsgbWF4KGRjYXAyLCAwKSk7CgllZGdlQWxwaGEgPSBtaW4oZWRnZUFscGhhICsgY2FwQWxwaGEsIDEuMCk7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGVkZ2VBbHBoYSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAAAAABAAAAAAAAAAcAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAfAAAADAAAAAEAAAAeAAAAHAAAAAEAAAAeAAAAKAAAAAEAAAAeAAAANAAAAAEAAAAfAAAAQAAAAAEAAABQAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAAHJXMYEEAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZ5G5DCQYAAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAEABYAAAAEAAAAAAAEEBQAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAAYQADAAAEAFEURUKQKAAAIAAQAAAAAIAAAABSCICWKY2FAEAAAUAAAAAAAAAAAAAIADQAAAAIAAAAAAAIIDAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","B2ABSAAABQAAIAABBYAAB7777777777774ABICAAAAAAAAAAAAAABUABAAAAAEAAAAAIBEABAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"CgAAAExTS1MCAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZiBpbkNvdmVyYWdlOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZjQgdmNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBEZWZhdWx0R2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IGNvbG9yID0gdUNvbG9yX1MwOwoJY29sb3IgPSBjb2xvciAqIGluQ292ZXJhZ2U7Cgl2Y29sb3JfUzAgPSBjb2xvcjsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8zX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJc2tfUG9zaXRpb24gPSBfdG1wXzFfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAAJsBAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGhhbGY0IHVDb2xvcl9TMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIERlZmF1bHRHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVAAAAAEAAAAAAAAAAgAAAB0AAAAAAAAAAQAAABwAAAAIAAAAAQAAAAwAAAAAAAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAGIBIAAABAAAAANAEAAAAAAAAAAAAAABAAOAAAABAAAAAAABBAMAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAQAAAAAAAA":"CgAAAExTS1MoAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBoYWxmNCBjb2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQyIGxvY2FsQ29vcmQ7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgb3V0IGhhbGY0IHZjb2xvcl9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfMl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgl2Y29sb3JfUzAgPSBjb2xvcjsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKCXsKCQl2VHJhbnNmb3JtZWRDb29yZHNfMl9TMCA9IGZsb2F0M3gyKHVtYXRyaXhfUzEpICogbG9jYWxDb29yZC54eTE7Cgl9Cn0KAAAAAB0DAABsYXlvdXQobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSBzYW1wbGVyMkQgdVRleHR1cmVTYW1wbGVyXzBfUzE7CmxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQzeDMgdW1hdHJpeF9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgaW4gaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CmhhbGY0IFRleHR1cmVFZmZlY3RfUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJcmV0dXJuIHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMSwgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzApLnJycnI7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBUZXh0dXJlRWZmZWN0X1MxX2MwKF9pbnB1dCk7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBNYXRyaXhFZmZlY3RfUzEob3V0cHV0Q292ZXJhZ2VfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0X1MxOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAABAAAAAAAAAAMAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAdAAAADAAAAAEAAAAUAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAABAEAAAABJYQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAACJMTCPBBAEAAAUDPSKBIPAAAAAAAAIAAAAACAIYKPQZ3UAAAAAABALL3N4SIAAAABQAAAACIMRCXBBEEQAAEAP2LRIPAAAAAIAAAAAAABTALI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAIAAAABSDBEIVYMJREAAAAAAAAAAAFPJO7EUCA4AAAAAQAAAAAICD7UXCS6AAAAAAAAAAAAACWCAACAAAAACAINAEIAAAAAAAAAAAAA5AAAAAAABAAAAACAZAAACQAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAIAAEAAAABJYQAAAAAQAAIAAAAAWCBACAABAAAAANAEIQCAAEAAAAAAAAFAAMAAAABAAAAAAMCEAQFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HTQAAGAABBYAAAEIXBAAAGEAMAAAAAAAAAAAAAAAQAHAAAAAQAAAAAAAQQGAAAAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAAHAJRUYWBAAAAA2DXZFAQHAAAAAAAAEAAAAABAEMFPYMZ2AAAAAAAQFV566JAAAAAAYAAAADQEY2EKAUAQAAFA34SQKDYAAAACAAAAABAEMIC263PESAAAAAMAAAAAYCM5AFALAIAAAQF7JMFB4AAAACAAAAAAQAGHEJRUYWBAAAAAAAAAAAFQEL6S4KLYAAAAAAABAAAAAMWU56JIEBYAAAAAAAAAACYIEAAAAEAAAABUARCAIAAAAAAAAAAAUABQAAAAEAAAAAAAEEBQAACGAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAASLEYTYIIBAAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAAEQZCFOCCIJAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAEAIRLQYTSIAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAITLAYT2IAAAAA5B3UTQIDAAAAAEAAAAAJBQKEKYGE6SAAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAASLEYTYIIBAAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAAEQZCFOCCIJAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAEAIRLQYTSIAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAITLAYT2IAAAAA5B3UTQIDAAAAAEAAAAAJBQKEKYGE6SAAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","CIAAAAAAQAARQAAYQAAAAGFYQAABRAAAAEEAAAAAAARAEAEABYAAAAEAAAAAAAEEBQAAAACQAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEBAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADEAANAAAAAUKQGZLBIAAAAACQAAAA4QAQAAAIAAAABSCICSKI2FIFAAAEAAIAAAAAAAAAAADZEBYAAAIAAAAAACQAGAAAAAQAAAAAAAQQGUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAIAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQDAAAAAAAAAEAAAABJGQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADIAANAAAAALHCKLMRAAAAAAAAABAAAAAGJBCFLQVBWAQAAAAAAQAAAAAMACQCAACAAAAA2AIBAEIAAAAAAAAAAAAMAAPEAEAAABAAAAAAB2AAAAAAACAAAAAEBSAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAGQBIAAABAAAAANAEAAAAAAAAAAAAAADQAB4QAAAAAEAAAAAAHIAAAAAAAIAAAAAQGIACQAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEBAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABYQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDCGAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEAAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"CgAAAExTS1OAAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGluUG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGluQ29sb3I7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0NCBpbkNpcmNsZUVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJdmluQ2lyY2xlRWRnZV9TMCA9IGluQ2lyY2xlRWRnZTsKCXZpbkNvbG9yX1MwID0gaW5Db2xvcjsKCWZsb2F0MiBfdG1wXzBfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSB1bG9jYWxNYXRyaXhfUzAueHogKiBpblBvc2l0aW9uICsgdWxvY2FsTWF0cml4X1MwLnl3OwoJc2tfUG9zaXRpb24gPSBfdG1wXzBfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAACbAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAQAAAAAAAAADAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAAHwAAAAwAAAABAAAAHAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAAAAAAAAIAAAABSEIAL7YYDQAAAAAAACAAAAABQEKAAAAIAAAADIBAQGIAAAAAAAAAAAMACQCAACAAAAA2AIBAEIAAAAAAAAAACAA4AAAACAAAAAAACCAYAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQAAAAQAAAAGQCEIBAAAAAAAAAAACQAGAAAAAQAAAAAGBCAIAAAAAFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"CgAAAExTS1PAAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfMl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxKSAqIGxvY2FsQ29vcmQueHkxOwoJfQp9CgAAAAABAwAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0M3gzIHVtYXRyaXhfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CmhhbGY0IFRleHR1cmVFZmZlY3RfUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJcmV0dXJuIHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMSwgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzApLjAwMHI7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBUZXh0dXJlRWZmZWN0X1MxX2MwKF9pbnB1dCk7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzAgPSBoYWxmNCgxKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBNYXRyaXhFZmZlY3RfUzEob3V0cHV0Q29sb3JfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dF9TMSAqIG91dHB1dENvdmVyYWdlX1MwOwoJCXNrX0ZyYWdDb2xvciA9IHNrX0ZyYWdDb2xvci5hMDAwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAdAAAACAAAAAEAAAAQAAAAAAAAAAoAAAAAAAAAAQAAAAAAAAA=","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQLAAAAAAIBAEAAAABJWQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGABZAA6IAAAAACAAAAAADUAAAAAAAEAAAAAIDEAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAMGAICAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQAAEAQAAAAGQCBAMQAAAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQEAAAAAAAAAEAAAABJIQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQAAEAQAAAAGQCEIBAAAAIAAAAAACQAGAAAAAQAAAAAGBCAIAAAAAFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAIBAEAAAABJYQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQDAAAAAAAAAEAAAABJGQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEAAZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAIAAAAAAAA":"CgAAAExTS1OpAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgb3V0IGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgl2Y29sb3JfUzAgPSBjb2xvcjsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAAAAAiAMAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQ0IHVpbm5lclJlY3RfUzE7CglsYXlvdXQob2Zmc2V0PTMyKSBoYWxmMiB1cmFkaXVzUGx1c0hhbGZfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKaGFsZjQgQ2lyY3VsYXJSUmVjdF9TMShoYWxmNCBfaW5wdXQpIAp7CglmbG9hdDIgZHh5MCA9IHVpbm5lclJlY3RfUzEuTFQgLSBza19GcmFnQ29vcmQueHk7CglmbG9hdCBkeDEgPSBza19GcmFnQ29vcmQueCAtIHVpbm5lclJlY3RfUzEuUjsKCWZsb2F0MiBkeHkgPSBtYXgoZmxvYXQyKG1heChkeHkwLngsIGR4MSksIGR4eTAueSksIDAuMCk7CgloYWxmIGJvdHRvbUFscGhhID0gaGFsZihzYXR1cmF0ZSh1aW5uZXJSZWN0X1MxLkIgLSBza19GcmFnQ29vcmQueSkpOwoJaGFsZiBhbHBoYSA9IGJvdHRvbUFscGhhICogaGFsZihzYXR1cmF0ZSh1cmFkaXVzUGx1c0hhbGZfUzEueCAtIGxlbmd0aChkeHkpKSk7CglyZXR1cm4gX2lucHV0ICogYWxwaGE7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBDaXJjdWxhclJSZWN0X1MxKG91dHB1dENvdmVyYWdlX1MwKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dF9TMTsKCX0KfQoBAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADEAANAAAAALHCKLMRAAAAAAAAABAAAAAGJBCFLQVBWAQAAAAAAQAAAAAMACQCAACAAAAA2AIBAEIAAAAAAAAAAAAIADQAAAAIAAAAAAAIIDAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAMGAICAAAAAAAA":"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","DASAAAAAQAAWAABAYAAQBYH7777Z6QQBAEAAAAAAEAAAAAAAEBSAAAB2AAAAAAACAAAAAEBSAAAAARQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","CMRQCIAABBYAAAEIXBAAACDQMAABRAFAAAAAAAAAAAAAAAEABYAAAAEAAAAAAAEEBQAAAACQAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQGAAAAAAIBAEAAAABJMQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","B3IBQAAADAAAIAABBYAAAEIXBAAACDQMAAABIFAAAAAAAAAAAAAABFIBBYSAO7ICAAAAACX4GM5AAAAAAAIAAAAACAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAAAAAAQAAAAAEARQUPBT7IAAAAAACAAAAAAQFU5S6ZGAAAAAYAAAAAYCEOGAEGBAAAAAH5FYUXQAAAAAAACAAAAAMQEAIAAAANDMXXJYBAAAGAAAAAAABDRYBRQIQAAAAPJO5E4AAQAAAAAQAAAAGIBBCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAABAAAAAAIEDIYOAOMCEAAAAAAAAAAAFREL6S4KDYAAAACAAAAAAAAM6U52JYEBQAAAAAAAAAACYIEAIAAAAAAABUARCAIAAAAAAAAAABUABAAAAAEAAAAAIBEABIYAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","DAQAAAAAAABGAABAYAAQAIHCAIAYAQUBAEAAAAAAEAAAAAAAAAAAAIAD2AAAAAAQAVSWGRIBAAADAAAAACAAAAAAQCGEIQOZLBIQAAAABQAAAAAAAAAAAAFAAMAAAABAAAAAAABBAMAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"CgAAAExTS1MNAwAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDIgdUF0bGFzU2l6ZUludl9TMDsKCWxheW91dChvZmZzZXQ9MzIpIGZsb2F0NCB1cmVjdFVuaWZvcm1fUzFfYzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gdXNob3J0MiBpblRleHR1cmVDb29yZHM7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDIgdlRleHR1cmVDb29yZHNfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGZsYXQgb3V0IGZsb2F0IHZUZXhJbmRleF9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMikgb3V0IGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBCaXRtYXBUZXh0CglpbnQgdGV4SWR4ID0gMDsKCWZsb2F0MiB1bm9ybVRleENvb3JkcyA9IGZsb2F0MihpblRleHR1cmVDb29yZHMueCwgaW5UZXh0dXJlQ29vcmRzLnkpOwoJdlRleHR1cmVDb29yZHNfUzAgPSB1bm9ybVRleENvb3JkcyAqIHVBdGxhc1NpemVJbnZfUzA7Cgl2VGV4SW5kZXhfUzAgPSBmbG9hdCh0ZXhJZHgpOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMV9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCXNrX1Bvc2l0aW9uID0gaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAAAAwBgAAY29uc3QgaW50IGtGaWxsQldfUzFfYzAgPSAwOwpjb25zdCBpbnQga0ludmVyc2VGaWxsQldfUzFfYzAgPSAyOwpjb25zdCBpbnQga0ludmVyc2VGaWxsQUFfUzFfYzAgPSAzOwpsYXlvdXQobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSBzYW1wbGVyMkQgdVRleHR1cmVTYW1wbGVyXzBfUzA7CmxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQyIHVBdGxhc1NpemVJbnZfUzA7CglsYXlvdXQob2Zmc2V0PTMyKSBmbG9hdDQgdXJlY3RVbmlmb3JtX1MxX2MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHZUZXh0dXJlQ29vcmRzX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBmbGF0IGluIGZsb2F0IHZUZXhJbmRleF9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gaGFsZjQgdmluQ29sb3JfUzA7CmhhbGY0IFJlY3RfUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgX3RtcF8wX2luQ29sb3IgPSBfaW5wdXQ7CgloYWxmIGNvdmVyYWdlOwoJaWYgKGludCgxKSA9PSBrRmlsbEJXX1MxX2MwIHx8IGludCgxKSA9PSBrSW52ZXJzZUZpbGxCV19TMV9jMCkgCgl7CgkJY292ZXJhZ2UgPSBoYWxmKGFsbChncmVhdGVyVGhhbihmbG9hdDQoc2tfRnJhZ0Nvb3JkLnh5LCB1cmVjdFVuaWZvcm1fUzFfYzAuencpLCBmbG9hdDQodXJlY3RVbmlmb3JtX1MxX2MwLnh5LCBza19GcmFnQ29vcmQueHkpKSkpOwoJfQoJZWxzZSAKCXsKCQloYWxmNCBkaXN0czQgPSBzYXR1cmF0ZShoYWxmNCgxLjAsIDEuMCwgLTEuMCwgLTEuMCkgKiBoYWxmNChza19GcmFnQ29vcmQueHl4eSAtIHVyZWN0VW5pZm9ybV9TMV9jMCkpOwoJCWhhbGYyIGRpc3RzMiA9IChkaXN0czQueHkgKyBkaXN0czQuencpIC0gMS4wOwoJCWNvdmVyYWdlID0gZGlzdHMyLnggKiBkaXN0czIueTsKCX0KCWlmIChpbnQoMSkgPT0ga0ludmVyc2VGaWxsQldfUzFfYzAgfHwgaW50KDEpID09IGtJbnZlcnNlRmlsbEFBX1MxX2MwKSAKCXsKCQljb3ZlcmFnZSA9IDEuMCAtIGNvdmVyYWdlOwoJfQoJcmV0dXJuIGhhbGY0KGhhbGY0KGNvdmVyYWdlKSk7Cn0KaGFsZjQgQmxlbmRfUzEoaGFsZjQgX3NyYywgaGFsZjQgX2RzdCkgCnsKCXJldHVybiBibGVuZF9tb2R1bGF0ZShSZWN0X1MxX2MwKF9zcmMpLCBfc3JjKTsKfQp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQml0bWFwVGV4dAoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZpbkNvbG9yX1MwOwoJaGFsZjQgdGV4Q29sb3I7Cgl7CgkJdGV4Q29sb3IgPSBzYW1wbGUodVRleHR1cmVTYW1wbGVyXzBfUzAsIHZUZXh0dXJlQ29vcmRzX1MwKS5ycnJyOwoJfQoJaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSB0ZXhDb2xvcjsKCWhhbGY0IG91dHB1dF9TMTsKCW91dHB1dF9TMSA9IEJsZW5kX1MxKG91dHB1dENvdmVyYWdlX1MwLCBoYWxmNCgxKSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRfUzE7Cgl9Cn0KAQAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAEAAAAAAAAAAwAAAB0AAAAAAAAAAQAAAAkAAAAIAAAAAQAAAA0AAAAMAAAAAQAAABAAAAAAAAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","CMRQCIAABBYAAAEIXBAAACDQMAABRAFAAAAAAAAAAAAAAAGIAHSACAAAAQAAAAAA5AAAAAAABAAAAACAZAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","HVJAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAABAAAAAABBAMABAAOAAAABAAAAAAABBAMAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"CgAAAExTS1PMAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgZmxhdCBvdXQgaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgZmxvYXQyIHZsb2NhbENvb3JkX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJdmxvY2FsQ29vcmRfUzAgPSBsb2NhbENvb3JkOwoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwp9CgAAAABvAgAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MwOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgaW4gaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgdmxvY2FsQ29vcmRfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2Y29sb3JfUzA7CglmbG9hdDIgdGV4Q29vcmQ7Cgl0ZXhDb29yZCA9IHZsb2NhbENvb3JkX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSAoKHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMCwgdGV4Q29vcmQpICogb3V0cHV0Q29sb3JfUzApKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAEAAAAAAAAAAwAAAB0AAAAAAAAAAQAAAAkAAAAIAAAAAQAAAB0AAAAMAAAAAQAAABQAAAAAAAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABYQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDCQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","GCAAAAAADAAAEAABBYAAAAYXBAAAAAAAAAAAAAAA2AAQAAAACAAAAAEASAAQAAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"CgAAAExTS1PRAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7CglsYXlvdXQob2Zmc2V0PTI0KSBoYWxmIHVDb3ZlcmFnZV9TMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBpblBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBoYWxmNCBpbkhhaXJRdWFkRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGhhbGY0IHZIYWlyUXVhZEVkZ2VfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWQKCXZIYWlyUXVhZEVkZ2VfUzAgPSBpbkhhaXJRdWFkRWRnZTsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247Cglza19Qb3NpdGlvbiA9IF90bXBfMV9pblBvc2l0aW9uLnh5MDE7Cn0KAAAAAAAAAGYDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGhhbGY0IHVDb2xvcl9TMDsKCWxheW91dChvZmZzZXQ9MjQpIGhhbGYgdUNvdmVyYWdlX1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdkhhaXJRdWFkRWRnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWQKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB1Q29sb3JfUzA7CgloYWxmIGVkZ2VBbHBoYTsKCWhhbGYyIGR1dmR4ID0gaGFsZjIoZEZkeCh2SGFpclF1YWRFZGdlX1MwLnh5KSk7CgloYWxmMiBkdXZkeSA9IGhhbGYyKGRGZHkodkhhaXJRdWFkRWRnZV9TMC54eSkpOwoJaGFsZjIgZ0YgPSBoYWxmMigyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeC54IC0gZHV2ZHgueSwgICAgICAgICAgICAgICAyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeS54IC0gZHV2ZHkueSk7CgllZGdlQWxwaGEgPSBoYWxmKHZIYWlyUXVhZEVkZ2VfUzAueCAqIHZIYWlyUXVhZEVkZ2VfUzAueCAtIHZIYWlyUXVhZEVkZ2VfUzAueSk7CgllZGdlQWxwaGEgPSBzcXJ0KGVkZ2VBbHBoYSAqIGVkZ2VBbHBoYSAvIGRvdChnRiwgZ0YpKTsKCWVkZ2VBbHBoYSA9IG1heCgxLjAgLSBlZGdlQWxwaGEsIDAuMCk7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KHVDb3ZlcmFnZV9TMCAqIGVkZ2VBbHBoYSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAfAAAACAAAAAEAAAAYAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQJAAAAAAIBAEAAAABJSQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","B2AAQAAABQAAIAABBYAAB7777777777774ABICAAAAAAAAAAAAAAAOMAHQAABAAAAAAAAAA5AAAAAAABAAAAACAZABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1NOAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZjQgdmNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwp9CgAAAAAAAH0BAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAEAQAAAAGQCBAMQACAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABDAAAAAAEAAAAAAAAAAAAAAAAACAAAAAABQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAEAQAAAAGQCBAMQACAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGABZAA6IAAAAACAAAAAADUAAAAAAAEAAAAAIDEAAAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAMGAICAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABYQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDCQAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEAAAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQHAAAAAAIBAEAAAABJOQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQEAAAAAAAAAEAAAABJIQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAQAAAAAAAA":"CgAAAExTS1NTAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAACCAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAMAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADEAANAAAAAUKQGZLBIAAAAACQAAAA4QAQAAAIAAAABSCICSKI2FIFAAAEAAIAAAAAAAAAAADZEBYAAAIAAAAAACQAGAAAAAQAAAAAAAQQGUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","FAAQMYAAMAAAEADAAABAEYAAAICIAB5AABQAAAQAMAAAEATAAABAIIGAAEDCBYQCA4AAAAAAEADZABYAAAIAAAAAACQAGAAAAAQAAAAAAAQQGRQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAAAQAAAAGQCBAMQACAAAAAAAACQAGAAAAAQAAAAAAAQQGAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADEAANAAAAAUKQGZLBIAAAAACQAAAA4QAQAAAIAAAABSCICSKI2FIFAAAEAAIAAAAAAAAAAADZEBYAAAIAAAAAACQAGAAAAAQAAAAAAAQQGUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAIAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGAAZAADIAAAACU53QJEKAAAAAAMAAAAAIAAAAAAGIRDFB2XASAUAABQAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAB3QA6AAAEAAAAAAAMAAPEAEAAABAAAAAAB2AAAAAAACAAAAAEBSAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1MsAwAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwoJbGF5b3V0KG9mZnNldD0zMikgZmxvYXQ0IHVpbm5lclJlY3RfUzE7CglsYXlvdXQob2Zmc2V0PTQ4KSBoYWxmMiB1cmFkaXVzUGx1c0hhbGZfUzE7CglsYXlvdXQob2Zmc2V0PTY0KSBmbG9hdDQgdWlubmVyUmVjdF9TMjsKCWxheW91dChvZmZzZXQ9ODApIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMjsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBpblBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBoYWxmNCBpbkNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiBmbG9hdDQgaW5DaXJjbGVFZGdlOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIG91dCBoYWxmNCB2aW5Db2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCXZpbkNpcmNsZUVkZ2VfUzAgPSBpbkNpcmNsZUVkZ2U7Cgl2aW5Db2xvcl9TMCA9IGluQ29sb3I7CglmbG9hdDIgX3RtcF8wX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJZmxvYXQyIF90bXBfMV9pblBvc2l0aW9uID0gdWxvY2FsTWF0cml4X1MwLnh6ICogaW5Qb3NpdGlvbiArIHVsb2NhbE1hdHJpeF9TMC55dzsKCXNrX1Bvc2l0aW9uID0gX3RtcF8wX2luUG9zaXRpb24ueHkwMTsKfQoAAAAA+wUAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQ0IHVsb2NhbE1hdHJpeF9TMDsKCWxheW91dChvZmZzZXQ9MzIpIGZsb2F0NCB1aW5uZXJSZWN0X1MxOwoJbGF5b3V0KG9mZnNldD00OCkgaGFsZjIgdXJhZGl1c1BsdXNIYWxmX1MxOwoJbGF5b3V0KG9mZnNldD02NCkgZmxvYXQ0IHVpbm5lclJlY3RfUzI7CglsYXlvdXQob2Zmc2V0PTgwKSBoYWxmMiB1cmFkaXVzUGx1c0hhbGZfUzI7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgdmluQ29sb3JfUzA7CmhhbGY0IENpcmN1bGFyUlJlY3RfUzEoaGFsZjQgX2lucHV0KSAKewoJZmxvYXQyIGR4eTAgPSB1aW5uZXJSZWN0X1MxLkxUIC0gc2tfRnJhZ0Nvb3JkLnh5OwoJZmxvYXQyIGR4eTEgPSBza19GcmFnQ29vcmQueHkgLSB1aW5uZXJSZWN0X1MxLlJCOwoJZmxvYXQyIGR4eSA9IG1heChtYXgoZHh5MCwgZHh5MSksIDAuMCk7CgloYWxmIGFscGhhID0gaGFsZihzYXR1cmF0ZSh1cmFkaXVzUGx1c0hhbGZfUzEueCAtIGxlbmd0aChkeHkpKSk7CglhbHBoYSA9IDEuMCAtIGFscGhhOwoJcmV0dXJuIF9pbnB1dCAqIGFscGhhOwp9CmhhbGY0IENpcmN1bGFyUlJlY3RfUzIoaGFsZjQgX2lucHV0KSAKewoJZmxvYXQyIGR4eTAgPSB1aW5uZXJSZWN0X1MyLkxUIC0gc2tfRnJhZ0Nvb3JkLnh5OwoJZmxvYXQyIGR4eTEgPSBza19GcmFnQ29vcmQueHkgLSB1aW5uZXJSZWN0X1MyLlJCOwoJZmxvYXQyIGR4eSA9IG1heChtYXgoZHh5MCwgZHh5MSksIDAuMCk7CgloYWxmIGFscGhhID0gaGFsZihzYXR1cmF0ZSh1cmFkaXVzUGx1c0hhbGZfUzIueCAtIGxlbmd0aChkeHkpKSk7CglyZXR1cm4gX2lucHV0ICogYWxwaGE7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCglmbG9hdDQgY2lyY2xlRWRnZTsKCWNpcmNsZUVkZ2UgPSB2aW5DaXJjbGVFZGdlX1MwOwoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZpbkNvbG9yX1MwOwoJZmxvYXQgZCA9IGxlbmd0aChjaXJjbGVFZGdlLnh5KTsKCWhhbGYgZGlzdGFuY2VUb091dGVyRWRnZSA9IGhhbGYoY2lyY2xlRWRnZS56ICogKDEuMCAtIGQpKTsKCWhhbGYgZWRnZUFscGhhID0gc2F0dXJhdGUoZGlzdGFuY2VUb091dGVyRWRnZSk7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGVkZ2VBbHBoYSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBDaXJjdWxhclJSZWN0X1MxKG91dHB1dENvdmVyYWdlX1MwKTsKCWhhbGY0IG91dHB1dF9TMjsKCW91dHB1dF9TMiA9IENpcmN1bGFyUlJlY3RfUzIob3V0cHV0X1MxKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dF9TMjsKCX0KfQoAAQAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAEAAAAAAAAAAwAAAB0AAAAAAAAAAQAAAAkAAAAIAAAAAQAAAB8AAAAMAAAAAQAAABwAAAAAAAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQKAAAAAAIBAEAAAABJUQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HTRQAGAABBYAAAEIXBAAAGEAMAAAAAAAAAAAAAAAWAGHAIBZ5AJQAAAA5C5DCQYAAAAABADI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAAAAEAAAAAZFE5PDAYAIAAAAABITF56OQIAAAQAAQAAAARGWBRHUQAAAAB2DXJHAQGAAAAAEAAAAASAIYRFV5O4JAAAAAAYAAAABEWJRHQQQCAAAKBXZFAUHQAAAAIAAAAACAAYJVSMJ4EEAQAAAAAAAABMBC7UXCS6AAAAAAAAIAAAADFVHPSKBAOAAAAAAAAAAAWCBAAAABAAAAANAEIQCAAAAAAAAAAABQAAGQAAAAKFIDMVQUAAAAAAYAAAAAQAAAADEEQFEURUKQKAAAYAAAAAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQHAAAAAAABAEAAAABJOQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","CMRQCIAABBYAAAEIXBAAACDQMAABRAFAAAAAAAAAAAAAAAEABYAAAAEAAAAAAAEEBQAAAACQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"CgAAAExTS1MQAwAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGluUG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGluQ29sb3I7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0MiBpbkVsbGlwc2VPZmZzZXQ7CmxheW91dChsb2NhdGlvbiA9IDMpIGluIGZsb2F0NCBpbkVsbGlwc2VSYWRpaTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2RWxsaXBzZU9mZnNldHNfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIG91dCBmbG9hdDQgdkVsbGlwc2VSYWRpaV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMikgb3V0IGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBFbGxpcHNlR2VvbWV0cnlQcm9jZXNzb3IKCXZFbGxpcHNlT2Zmc2V0c19TMCA9IGluRWxsaXBzZU9mZnNldDsKCXZFbGxpcHNlUmFkaWlfUzAgPSBpbkVsbGlwc2VSYWRpaTsKCXZpbkNvbG9yX1MwID0gaW5Db2xvcjsKCWZsb2F0MiBfdG1wXzBfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSB1bG9jYWxNYXRyaXhfUzAueHogKiBpblBvc2l0aW9uICsgdWxvY2FsTWF0cml4X1MwLnl3OwoJc2tfUG9zaXRpb24gPSBfdG1wXzBfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAA4BAAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHZFbGxpcHNlT2Zmc2V0c19TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gZmxvYXQ0IHZFbGxpcHNlUmFkaWlfUzA7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgRWxsaXBzZUdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdDIgb2Zmc2V0ID0gdkVsbGlwc2VPZmZzZXRzX1MwLnh5OwoJb2Zmc2V0ICo9IHZFbGxpcHNlUmFkaWlfUzAueHk7CglmbG9hdCB0ZXN0ID0gZG90KG9mZnNldCwgb2Zmc2V0KSAtIDEuMDsKCWZsb2F0MiBncmFkID0gMi4wKm9mZnNldCp2RWxsaXBzZVJhZGlpX1MwLnh5OwoJZmxvYXQgZ3JhZF9kb3QgPSBkb3QoZ3JhZCwgZ3JhZCk7CglncmFkX2RvdCA9IG1heChncmFkX2RvdCwgMS4xNzU1ZS0zOCk7CglmbG9hdCBpbnZsZW4gPSBpbnZlcnNlc3FydChncmFkX2RvdCk7CglmbG9hdCBlZGdlQWxwaGEgPSBzYXR1cmF0ZSgwLjUtdGVzdCppbnZsZW4pOwoJb2Zmc2V0ID0gdkVsbGlwc2VPZmZzZXRzX1MwLnh5KnZFbGxpcHNlUmFkaWlfUzAuenc7Cgl0ZXN0ID0gZG90KG9mZnNldCwgb2Zmc2V0KSAtIDEuMDsKCWdyYWQgPSAyLjAqb2Zmc2V0KnZFbGxpcHNlUmFkaWlfUzAuenc7CglncmFkX2RvdCA9IGRvdChncmFkLCBncmFkKTsKCWludmxlbiA9IGludmVyc2VzcXJ0KGdyYWRfZG90KTsKCWVkZ2VBbHBoYSAqPSBzYXR1cmF0ZSgwLjUrdGVzdCppbnZsZW4pOwoJaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNChoYWxmKGVkZ2VBbHBoYSkpOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0Q292ZXJhZ2VfUzA7Cgl9Cn0KAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbAAAAAEAAAAAAAAABAAAAB0AAAAAAAAAAQAAAAkAAAAIAAAAAQAAAB0AAAAMAAAAAQAAAB8AAAAUAAAAAQAAACQAAAAAAAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","B2AAQAAABQAAIAABBYAAB7777777777774ABICAAAAAAAAAAAAAABUABAAAAAEAAAAAIBEABAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OxAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZiBpbkNvdmVyYWdlOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZiB2aW5Db3ZlcmFnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgRGVmYXVsdEdlb21ldHJ5UHJvY2Vzc29yCglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJdmluQ292ZXJhZ2VfUzAgPSBpbkNvdmVyYWdlOwoJc2tfUG9zaXRpb24gPSBfdG1wXzFfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAAADJAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBoYWxmIHZpbkNvdmVyYWdlX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgRGVmYXVsdEdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdUNvbG9yX1MwOwoJaGFsZiBhbHBoYSA9IDEuMDsKCWFscGhhID0gdmluQ292ZXJhZ2VfUzA7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAcAAAACAAAAAEAAAAMAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGABBACUIAAAAABAAOAAAABAAAAAAABBAMAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAIAAAAAAAA":"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","B2ABSAAABQAAIAABBYAAB7777777777774ABICAAAAAAAAAAAAAABUABAAAAAEAAAAAIBEABAAAAARQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"CgAAAExTS1MCAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZiBpbkNvdmVyYWdlOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZjQgdmNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBEZWZhdWx0R2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IGNvbG9yID0gdUNvbG9yX1MwOwoJY29sb3IgPSBjb2xvciAqIGluQ292ZXJhZ2U7Cgl2Y29sb3JfUzAgPSBjb2xvcjsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8zX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJc2tfUG9zaXRpb24gPSBfdG1wXzFfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAAJsBAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGhhbGY0IHVDb2xvcl9TMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIERlZmF1bHRHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVAAAAAEAAAAAAAAAAgAAAB0AAAAAAAAAAQAAABwAAAAIAAAAAQAAAAwAAAAAAAAARgAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAAKUAQFAACYAAAAAIAAAABLBAABAAAAABAEGABBAMAAAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAAAAYAAIAAAAAAAA":"
   LSKS)  layout (metal, binding=0) uniform uniformBuffer
{
	layout(offset=0) float4 sk_RTAdjust;
	layout(offset=16) float3x3 umatrix_S1_c0;
	layout(offset=64) half4 uKernel_S1[7];
	layout(offset=120) half2 uKernelOffset_S1;
	layout(offset=124) half uGain_S1;
	layout(offset=126) half uBias_S1;
}
;
layout(location = 0) in float2 position;
layout(location = 1) in float2 localCoord;
layout(location = 0) out float2 vLocalCoord_S0;
void main() 
{
	// Primitive Processor QuadPerEdgeAAGeometryProcessor
	vLocalCoord_S0 = localCoord;
	sk_Position = position.xy01;
}
       O  layout(metal, binding=0) uniform sampler2D uTextureSampler_0_S1;
layout (metal, binding=0) uniform uniformBuffer
{
	layout(offset=0) float4 sk_RTAdjust;
	layout(offset=16) float3x3 umatrix_S1_c0;
	layout(offset=64) half4 uKernel_S1[7];
	layout(offset=120) half2 uKernelOffset_S1;
	layout(offset=124) half uGain_S1;
	layout(offset=126) half uBias_S1;
}
;
layout(location = 0) in float2 vLocalCoord_S0;
half4 TextureEffect_S1_c0_c0(half4 _input, float2 _coords) 
{
	return sample(uTextureSampler_0_S1, _coords);
}
half4 MatrixEffect_S1_c0(half4 _input, float2 _coords) 
{
	return TextureEffect_S1_c0_c0(_input, float3x2(umatrix_S1_c0) * _coords.xy1);
}
half4 MatrixConvolution_S1(half4 _input) 
{
	half4 sum = half4(0);
	float2 coord = vLocalCoord_S0 - uKernelOffset_S1;
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(0, 0);
		k = uKernel_S1[0][0];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(0, 1);
		k = uKernel_S1[1][1];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(0, 2);
		k = uKernel_S1[2][2];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(0, 3);
		k = uKernel_S1[3][3];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(0, 4);
		k = uKernel_S1[5][0];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(1, 0);
		k = uKernel_S1[0][1];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(1, 1);
		k = uKernel_S1[1][2];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(1, 2);
		k = uKernel_S1[2][3];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(1, 3);
		k = uKernel_S1[4][0];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(1, 4);
		k = uKernel_S1[5][1];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(2, 0);
		k = uKernel_S1[0][2];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(2, 1);
		k = uKernel_S1[1][3];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(2, 2);
		k = uKernel_S1[3][0];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(2, 3);
		k = uKernel_S1[4][1];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(2, 4);
		k = uKernel_S1[5][2];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(3, 0);
		k = uKernel_S1[0][3];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(3, 1);
		k = uKernel_S1[2][0];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(3, 2);
		k = uKernel_S1[3][1];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(3, 3);
		k = uKernel_S1[4][2];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(3, 4);
		k = uKernel_S1[5][3];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(4, 0);
		k = uKernel_S1[1][0];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(4, 1);
		k = uKernel_S1[2][1];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(4, 2);
		k = uKernel_S1[3][2];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(4, 3);
		k = uKernel_S1[4][3];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(4, 4);
		k = uKernel_S1[6][0];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	half4 color;
	color = sum * uGain_S1 + uBias_S1;
	color.a = saturate(color.a);
	color.rgb = clamp(color.rgb, 0.0, color.a);
	return color;
}
void main() 
{
	// Stage 0, QuadPerEdgeAAGeometryProcessor
	half4 outputColor_S0 = half4(1);
	const half4 outputCoverage_S0 = half4(1);
	half4 output_S1;
	output_S1 = MatrixConvolution_S1(outputColor_S0);
	{
		// Xfer Processor: Porter Duff
		sk_FragColor = output_S1 * outputCoverage_S0;
	}
}
                                   <                                       P              ","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAMWAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAAHAJRUYWBAAAAA2DXZFAQHAAAAAAAAEAAAAABAEMFPYMZ2AAAAAAAQFV566JAAAAAAYAAAADQEY2EKAUAQAAFA34SQKDYAAAACAAAAABAEMIC263PESAAAAAMAAAAAYCM5AFALAIAAAQF7JMFB4AAAACAAAAAAQAGHEJRUYWBAAAAAAAAAAAFQEL6S4KLYAAAAAAABAAAAAMWU56JIEBYAAAAAAAAAACYIEAAAAEAAAABUARCAIAAAAAAAAAAAOAAHSAAAAAAQAAAAAA5AAAAAAABAAAAACAZAAAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADIAANAAAAALHCKLMRAAAAAAAAABAAAAAGJBCFLQVBWAQAAAAAAQAAAAAMACQCAACAAAAA2AIBAEIAAAAAAAAAAAAMAAPEAEAAABAAAAAAB2AAAAAAACAAAAAEBSAAIYAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"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","HVJAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAABAAAAAABBAMADSAB4QAAAAAEAAAAAAHIAAAAAAAIAAAAAQGIAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGACQAGAAAAAQAAAAAAAQQGAAAIYAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"CgAAAExTS1NkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGZsb2F0MiBsb2NhbENvb3JkOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgZmxvYXQyIHZsb2NhbENvb3JkX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZsb2NhbENvb3JkX1MwID0gbG9jYWxDb29yZDsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAKQIAAGxheW91dChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHNhbXBsZXIyRCB1VGV4dHVyZVNhbXBsZXJfMF9TMDsKbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgdmxvY2FsQ29vcmRfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gaGFsZjQoMSk7CglmbG9hdDIgdGV4Q29vcmQ7Cgl0ZXhDb29yZCA9IHZsb2NhbENvb3JkX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSAoKHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMCwgdGV4Q29vcmQpICogaGFsZjQoMSkpKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHQAAAAgAAAABAAAAEAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQFAAAAAAIBAEAAAABJKQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABDAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAQAAAAAAAA":"CgAAAExTS1NTAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAACCAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAMAAAAAAAAAEYAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAABYCMNGFQIAAAAGQ56JIEBYAAAAAAABAAAAAAIBDBL6DGOQAAAAAAEAAAAABALL354SAAAAABQAAAAHAJRUIUBIBAAAKBXZFAUHQAAAAEAAAAABAIMQAAAAAEBNPNXSJAAAAAGAAAAAMBGOQCQFQEAAAIC7UWCQ6AAAAAQAAAAAIBDCAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAIAAAABTZCMNCFAKAIAAAAAAAAAMBC7UXKS6AAAAAAAAIAAAADEVDPSKBIPAAAAAAAAAAAGABIBAABAAAAANAEIQCAAAAAAAAAAABAAOAAAABAAAAAAABBAMRQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAAAAEAAAABJYQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAADUAANAAAAAAAAAIAAAABLAIABAAAAABAEGQCEAAAAAAAAAAAAAAB2AAAAAAACAAAAAQ2EAAAAACQAAAAACAAAAAAAAAAAAAAAAABAAAAAAAYAAAAAAAAAAA":"CgAAAExTS1PGAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfM19TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzNfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxX2MwKSAqIGxvY2FsQ29vcmQueHkxOwoJfQp9CgAAAAAAAHQDAABsYXlvdXQobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSBzYW1wbGVyMkQgdVRleHR1cmVTYW1wbGVyXzBfUzE7CmxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfM19TMDsKaGFsZjQgVGV4dHVyZUVmZmVjdF9TMV9jMF9jMChoYWxmNCBfaW5wdXQpIAp7CglyZXR1cm4gc2FtcGxlKHVUZXh0dXJlU2FtcGxlcl8wX1MxLCB2VHJhbnNmb3JtZWRDb29yZHNfM19TMCkuMDAwcjsKfQpoYWxmNCBNYXRyaXhFZmZlY3RfUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJcmV0dXJuIFRleHR1cmVFZmZlY3RfUzFfYzBfYzAoX2lucHV0KTsKfQpoYWxmNCBCbGVuZF9TMShoYWxmNCBfc3JjLCBoYWxmNCBfZHN0KSAKewoJcmV0dXJuIGJsZW5kX21vZHVsYXRlKE1hdHJpeEVmZmVjdF9TMV9jMChfc3JjKSwgX3NyYyk7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzAgPSBoYWxmNCgxKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBCbGVuZF9TMShvdXRwdXRDb2xvcl9TMCwgaGFsZjQoMSkpOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dF9TMSAqIG91dHB1dENvdmVyYWdlX1MwOwoJCXNrX0ZyYWdDb2xvciA9IHNrX0ZyYWdDb2xvci5hMDAwOwoJfQp9CgAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAdAAAACAAAAAEAAAAQAAAAAAAAAAoAAAAAAAAAAQAAAAAAAAA=","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABDAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"CgAAAExTS1NOAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZjQgdmNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwp9CgAAAAAAAH0BAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADEAAGAAAAAAAAAIAAAAAPAIABAAAAACYGEAAAAEAAAABUARCAIAAAAAAAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","GEMAAAYAAEHAAAARC4EAAAQWBQAAAAAAAAAQAAAAIBCAAAGQAEAAAAAQAAAABAEQAEAAAACGAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"CgAAAExTS1P9AQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gaGFsZjMgaW5TaGFkb3dQYXJhbXM7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmMyB2aW5TaGFkb3dQYXJhbXNfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIG91dCBoYWxmNCB2aW5Db2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUlJlY3RTaGFkb3cKCXZpblNoYWRvd1BhcmFtc19TMCA9IGluU2hhZG93UGFyYW1zOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCXNrX1Bvc2l0aW9uID0gX3RtcF8wX2luUG9zaXRpb24ueHkwMTsKfQoAAAAAAAAAqgIAAGxheW91dChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHNhbXBsZXIyRCB1VGV4dHVyZVNhbXBsZXJfMF9TMDsKbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBoYWxmMyB2aW5TaGFkb3dQYXJhbXNfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgUlJlY3RTaGFkb3cKCWhhbGYzIHNoYWRvd1BhcmFtczsKCXNoYWRvd1BhcmFtcyA9IHZpblNoYWRvd1BhcmFtc19TMDsKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2aW5Db2xvcl9TMDsKCWhhbGYgZCA9IGxlbmd0aChzaGFkb3dQYXJhbXMueHkpOwoJZmxvYXQyIHV2ID0gZmxvYXQyKHNoYWRvd1BhcmFtcy56ICogKDEuMCAtIGQpLCAwLjUpOwoJaGFsZiBmYWN0b3IgPSBzYW1wbGUodVRleHR1cmVTYW1wbGVyXzBfUzAsIHV2KS4wMDByLmE7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGZhY3Rvcik7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAABAAAAAAAAAAMAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAeAAAADAAAAAEAAAAYAAAAAAAAAEYAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAQAAAAAAAA":"CgAAAExTS1NTAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAACCAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAMAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQJAAAAAAAAAEAAAABJSQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGAAZAADIAAAACU53QJEKAAAAAAMAAAAAIAAAAAAGIRDFB2XASAUAABQAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAIYAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAACJMTCPBBAEAAAUDPSKBIPAAAAAAAAIAAAAACAIYKPQZ3UAAAAAABALL3N4SIAAAABQAAAACIMRCXBBEEQAAEAP2LRIPAAAAAIAAAAAAABTALI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAIAAAABSDBEIVYMJREAAAAAAAAAAAFPJO7EUCA4AAAAAQAAAAAICD7UXCS6AAAAAAAAAAAAACWCAACAAAAACAINAEIAAAAAAAAAAAAA5AAAAAAABAAAAACAZAAACQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQAAAAQAAAAGQCBAMQAAAAAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"CgAAAExTS1PAAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfMl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxKSAqIGxvY2FsQ29vcmQueHkxOwoJfQp9CgAAAADYAgAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0M3gzIHVtYXRyaXhfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CmhhbGY0IFRleHR1cmVFZmZlY3RfUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJcmV0dXJuIHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMSwgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzApOwp9CmhhbGY0IE1hdHJpeEVmZmVjdF9TMShoYWxmNCBfaW5wdXQpIAp7CglyZXR1cm4gVGV4dHVyZUVmZmVjdF9TMV9jMChfaW5wdXQpOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gaGFsZjQoMSk7Cgljb25zdCBoYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KDEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gTWF0cml4RWZmZWN0X1MxKG91dHB1dENvbG9yX1MwKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRfUzEgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHQAAAAgAAAABAAAAEAAAAAAAAABQAAAAAAAAAAEAAAAAAAAA","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQKAAAAAAAAAEAAAABJUQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","B2AAQAAABQAAIAABBYAAB7777777777774ABICAAAAAAAAAAAAAABUABAAAAAEAAAAAIBEABAAAAARQAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OxAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZiBpbkNvdmVyYWdlOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZiB2aW5Db3ZlcmFnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgRGVmYXVsdEdlb21ldHJ5UHJvY2Vzc29yCglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJdmluQ292ZXJhZ2VfUzAgPSBpbkNvdmVyYWdlOwoJc2tfUG9zaXRpb24gPSBfdG1wXzFfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAAADJAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBoYWxmIHZpbkNvdmVyYWdlX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgRGVmYXVsdEdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdUNvbG9yX1MwOwoJaGFsZiBhbHBoYSA9IDEuMDsKCWFscGhhID0gdmluQ292ZXJhZ2VfUzA7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAcAAAACAAAAAEAAAAMAAAAAAAAAEYAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGAAZAADIAAAAFCUBWKYKAAAAAAUAAAAHEAEAAACAAAAAMQSAUSSGRKBIAABAACAAAAAAAAAAAA6JAOAAACAAAAAAAUABQAAAAEAAAAAAAEEBVAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABYQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDCQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBQU7BTXIAAAAAACAWXW3ZEQAAAADAAAAAEQZCFOCCIJAAAIA7UXCQ6AAAAAQAAAAAAADGAWRWL3E4AQAADAAAAAAQBCFODCOJAAAAAPUXKS6AAAAAAAAQAAAADEGCIRLQYTCIAAAAAAAAAAAK6S56JIEBYAAAABAAAAAAQEH7JOFF4AAAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAICAACAAAAAAAA":"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","CMRQCIAABBYAAAEIXBAAACDQMAABRAFAAAAAAAAAAAAAAAEABYAAAAEAAAAAAAEEBQAAAACGAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","B2AAQAAABQAAIAABBYAAB7777777777774ABICAAAAAAAAAAAAAABUABAAAAAEAAAAAIBEABAAAAARQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OxAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZiBpbkNvdmVyYWdlOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZiB2aW5Db3ZlcmFnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgRGVmYXVsdEdlb21ldHJ5UHJvY2Vzc29yCglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJdmluQ292ZXJhZ2VfUzAgPSBpbkNvdmVyYWdlOwoJc2tfUG9zaXRpb24gPSBfdG1wXzFfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAAADJAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBoYWxmIHZpbkNvdmVyYWdlX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgRGVmYXVsdEdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdUNvbG9yX1MwOwoJaGFsZiBhbHBoYSA9IDEuMDsKCWFscGhhID0gdmluQ292ZXJhZ2VfUzA7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAcAAAACAAAAAEAAAAMAAAAAAAAAEYAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAAAPEAHAAABAAAAAAAKAAYAAAACAAAAAAACCAYAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"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","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAAAPEAHAAABAAAAAAAKAAYAAAACAAAAAAACCAYAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAADUAANAAAAAAIBAIAAAABLCIIBAAAAABAEGABBAMAACAIAAAAAAAB2AAAAAAACAAAAAEBSAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAAAAYAAAAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEAAZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAIMDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1aW5uZXJSZWN0X1MxOwoJbGF5b3V0KG9mZnNldD0zMikgaGFsZjIgdXJhZGl1c1BsdXNIYWxmX1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdmNvbG9yX1MwOwpoYWxmNCBDaXJjdWxhclJSZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCWZsb2F0MiBkeHkwID0gdWlubmVyUmVjdF9TMS5MVCAtIHNrX0ZyYWdDb29yZC54eTsKCWZsb2F0IGR4MSA9IHNrX0ZyYWdDb29yZC54IC0gdWlubmVyUmVjdF9TMS5SOwoJZmxvYXQyIGR4eSA9IG1heChmbG9hdDIobWF4KGR4eTAueCwgZHgxKSwgZHh5MC55KSwgMC4wKTsKCWhhbGYgYm90dG9tQWxwaGEgPSBoYWxmKHNhdHVyYXRlKHVpbm5lclJlY3RfUzEuQiAtIHNrX0ZyYWdDb29yZC55KSk7CgloYWxmIGFscGhhID0gYm90dG9tQWxwaGEgKiBoYWxmKHNhdHVyYXRlKHVyYWRpdXNQbHVzSGFsZl9TMS54IC0gbGVuZ3RoKGR4eSkpKTsKCXJldHVybiBfaW5wdXQgKiBhbHBoYTsKfQp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmNvbG9yX1MwOwoJY29uc3QgaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNCgxKTsKCWhhbGY0IG91dHB1dF9TMTsKCW91dHB1dF9TMSA9IENpcmN1bGFyUlJlY3RfUzEob3V0cHV0Q292ZXJhZ2VfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0X1MxOwoJfQp9CgABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","FAAQMYAAMAAAEADAAABAEYAAAICIAB5AABQAAAQAMAAAEATAAABAIIGAAEDCBYQCA4AAAAAAAAFAAAAAACDIQAAAAAFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAADUAANAAAAAAAAAIAAAABLAIABAAAAABAEGABBAMAAAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAARQAAAAACAAAAAAAAAAAAAAAAABAAAAAAAYAAAAAAAAAAA":"CgAAAExTS1PGAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfM19TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzNfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxX2MwKSAqIGxvY2FsQ29vcmQueHkxOwoJfQp9CgAAAAAAAEsDAABsYXlvdXQobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSBzYW1wbGVyMkQgdVRleHR1cmVTYW1wbGVyXzBfUzE7CmxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfM19TMDsKaGFsZjQgVGV4dHVyZUVmZmVjdF9TMV9jMF9jMChoYWxmNCBfaW5wdXQpIAp7CglyZXR1cm4gc2FtcGxlKHVUZXh0dXJlU2FtcGxlcl8wX1MxLCB2VHJhbnNmb3JtZWRDb29yZHNfM19TMCk7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxX2MwKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBUZXh0dXJlRWZmZWN0X1MxX2MwX2MwKF9pbnB1dCk7Cn0KaGFsZjQgQmxlbmRfUzEoaGFsZjQgX3NyYywgaGFsZjQgX2RzdCkgCnsKCXJldHVybiBibGVuZF9tb2R1bGF0ZShNYXRyaXhFZmZlY3RfUzFfYzAoX3NyYyksIF9zcmMpOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gaGFsZjQoMSk7Cgljb25zdCBoYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KDEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gQmxlbmRfUzEob3V0cHV0Q29sb3JfUzAsIGhhbGY0KDEpKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRfUzEgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAAAAAEAAAAAAAAAAgAAAB0AAAAAAAAAAQAAAB0AAAAIAAAAAQAAABAAAAAAAAAARgAAAAAAAAABAAAAAAAAAA==","IYBAAAAABAAACAABBYAAAKAAAMAAGEAAAABRAEAAAEHCAAAAAAAABCAAAAAABAEQAEAAAAAKAAAAABAAAAAP2AAAAAAQAAAAAAAAAAACAAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQKAAAAAAAAAEAAAABJUQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","GEMAAAYAAEHAAAARC4EAAAQWBQAAAAAAAAAQAAAAIBCAAAGQAEAAAAAQAAAABAEQAEAAAACQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"CgAAAExTS1P9AQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gaGFsZjMgaW5TaGFkb3dQYXJhbXM7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmMyB2aW5TaGFkb3dQYXJhbXNfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIG91dCBoYWxmNCB2aW5Db2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUlJlY3RTaGFkb3cKCXZpblNoYWRvd1BhcmFtc19TMCA9IGluU2hhZG93UGFyYW1zOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCXNrX1Bvc2l0aW9uID0gX3RtcF8wX2luUG9zaXRpb24ueHkwMTsKfQoAAAAAAAAAqgIAAGxheW91dChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHNhbXBsZXIyRCB1VGV4dHVyZVNhbXBsZXJfMF9TMDsKbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBoYWxmMyB2aW5TaGFkb3dQYXJhbXNfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgUlJlY3RTaGFkb3cKCWhhbGYzIHNoYWRvd1BhcmFtczsKCXNoYWRvd1BhcmFtcyA9IHZpblNoYWRvd1BhcmFtc19TMDsKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2aW5Db2xvcl9TMDsKCWhhbGYgZCA9IGxlbmd0aChzaGFkb3dQYXJhbXMueHkpOwoJZmxvYXQyIHV2ID0gZmxvYXQyKHNoYWRvd1BhcmFtcy56ICogKDEuMCAtIGQpLCAwLjUpOwoJaGFsZiBmYWN0b3IgPSBzYW1wbGUodVRleHR1cmVTYW1wbGVyXzBfUzAsIHV2KS4wMDByLmE7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGZhY3Rvcik7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAABAAAAAAAAAAMAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAeAAAADAAAAAEAAAAYAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAAAQAAAAGQCBAMQACAAAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAAABQAAQAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAYEIBAAAAFAAAAAAQAAAAH5AAAAAAIAAAAAAAAAAABQAAQAAAAAAAA":"CgAAAExTS1NTAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAACmAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCQlza19GcmFnQ29sb3IgPSBza19GcmFnQ29sb3IuYTAwMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAMAAAAAAAAAAoAAAAAAAAAAQAAAP0AAAA=","HTRQAGAABBYAAAEIXBAAAGEAMAAAAAAAAAAAAAAAWAGHAIBZ5AJQAAAA5C5DCQYAAAAABAAAAAAIA2GZPMTQCAAAMAAAAAEACHDQCDARAAAAAPGD4GCQAAAAAAAAABAAAAAGJJHLYYGACAAAAAAAEAAAACRGL345AQAABAABAAAAARQ4A4YEIAAAADYAZBYXAIAAAAAIAAAABSAQBAAAAAEIS26XOEQAAAAAMAAAAAMHCHGACAAQAAGAGMOF4CAAAAACAAAAABAEMIC263PESAAAAAMAAAAAMDCHCACDAQAAAAGPOB4CCAAAAAAACAAAAAMTJYRYQAQQEAAAAAAAAAGARJ4INQYLAEAAAAAEAAAABSEQM44LYEAAAAAAAAAAADAAUAQAAQAAAAGQCAIBCAAAAAAAAAAAYAADIAAAABCEDWKYKEAAAAAMAAAAAIAAAAACAI2RKA3FMFAAAAAAGAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAMWAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAASLEYTYIIBAAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAAEQZCFOCCIJAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAEAIRLQYTSIAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAITLAYT2IAAAAA5B3UTQIDAAAAAEAAAAAJBQKEKYGE6SAAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAABYQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1OAAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGluUG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGluQ29sb3I7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0NCBpbkNpcmNsZUVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJdmluQ2lyY2xlRWRnZV9TMCA9IGluQ2lyY2xlRWRnZTsKCXZpbkNvbG9yX1MwID0gaW5Db2xvcjsKCWZsb2F0MiBfdG1wXzBfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSB1bG9jYWxNYXRyaXhfUzAueHogKiBpblBvc2l0aW9uICsgdWxvY2FsTWF0cml4X1MwLnl3OwoJc2tfUG9zaXRpb24gPSBfdG1wXzBfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAACbAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAQAAAAAAAAADAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAAHwAAAAwAAAABAAAAHAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"CgAAAExTS1NTAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAACCAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAMAAAAAAAAAFAAAAAAAAAAAQAAAAAAAAA=","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQGAAAAAAABAEAAAABJMQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","IYAAAAAABAAACAABBYAAAIAAAIAAGEAAAABRAEAAAAAAAAEIAAAAAAEASAAQAAAABIAAAAAEAAAAB7IAAAAACAAAAAAAAAAAAIAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAADUAANAAAAAAAAAIAAAABLAIABAAAAABAEGABBAMAAAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAAAAYAAAAAAAAAAA":"CgAAAExTS1PGAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfM19TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzNfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxX2MwKSAqIGxvY2FsQ29vcmQueHkxOwoJfQp9CgAAAAAAAEsDAABsYXlvdXQobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSBzYW1wbGVyMkQgdVRleHR1cmVTYW1wbGVyXzBfUzE7CmxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfM19TMDsKaGFsZjQgVGV4dHVyZUVmZmVjdF9TMV9jMF9jMChoYWxmNCBfaW5wdXQpIAp7CglyZXR1cm4gc2FtcGxlKHVUZXh0dXJlU2FtcGxlcl8wX1MxLCB2VHJhbnNmb3JtZWRDb29yZHNfM19TMCk7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxX2MwKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBUZXh0dXJlRWZmZWN0X1MxX2MwX2MwKF9pbnB1dCk7Cn0KaGFsZjQgQmxlbmRfUzEoaGFsZjQgX3NyYywgaGFsZjQgX2RzdCkgCnsKCXJldHVybiBibGVuZF9tb2R1bGF0ZShNYXRyaXhFZmZlY3RfUzFfYzAoX3NyYyksIF9zcmMpOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gaGFsZjQoMSk7Cgljb25zdCBoYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KDEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gQmxlbmRfUzEob3V0cHV0Q29sb3JfUzAsIGhhbGY0KDEpKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRfUzEgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAAAAAEAAAAAAAAAAgAAAB0AAAAAAAAAAQAAAB0AAAAIAAAAAQAAABAAAAAAAAAAUAAAAAAAAAABAAAAAAAAAA==","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAAMHCHGACAAQAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAADAYRYQAQYEAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAIAEOHAEGBCAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAEMHAHGBCAAAAA5B3UTQIDAAAAAEAAAAAJAQJDRYBRQIQAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","DASAAAAAQAAWAABAYAAQBYH7777Z6QQBAEAAAAAAEAAAAAAAEBSAAAB2AAAAAAACAAAAAEBSAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","HTQAAGAABBYAAAEIXBAAAGEAMAAAAAAAAAAAAAAAQAHAAAAAQAAAAAAAQQGAAAAAIYAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","FAAQMYAAMAAAEADAAABAEYAAAICIAB5AABQAAAQAMAAAEATAAABAIIGAAEDCBYQCA4AAAAAAEADZABYAAAIAAAAAACQAGAAAAAQAAAAAAAQQGUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQAAEAQAAAAGQCBAMQAAAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAAABQAAQAAAAAAAA":"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","FAAQMYAAMAAAEADAAABAEYAAAICIAB5AABQAAAQAMAAAEATAAABAIIGAAEDCBYQCA4AAAAAAAA5AAAAAAABAAAAACAZAAAAAIYAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAGIBIAAABAAAAANAEAAAAAAAAAAAAAABAAOAAAABAAAAAAABBAMAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAQAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEAAZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAIAAAAAAAA":"CgAAAExTS1OpAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgb3V0IGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgl2Y29sb3JfUzAgPSBjb2xvcjsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAAAAAiAMAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQ0IHVpbm5lclJlY3RfUzE7CglsYXlvdXQob2Zmc2V0PTMyKSBoYWxmMiB1cmFkaXVzUGx1c0hhbGZfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKaGFsZjQgQ2lyY3VsYXJSUmVjdF9TMShoYWxmNCBfaW5wdXQpIAp7CglmbG9hdDIgZHh5MCA9IHVpbm5lclJlY3RfUzEuTFQgLSBza19GcmFnQ29vcmQueHk7CglmbG9hdCBkeDEgPSBza19GcmFnQ29vcmQueCAtIHVpbm5lclJlY3RfUzEuUjsKCWZsb2F0MiBkeHkgPSBtYXgoZmxvYXQyKG1heChkeHkwLngsIGR4MSksIGR4eTAueSksIDAuMCk7CgloYWxmIGJvdHRvbUFscGhhID0gaGFsZihzYXR1cmF0ZSh1aW5uZXJSZWN0X1MxLkIgLSBza19GcmFnQ29vcmQueSkpOwoJaGFsZiBhbHBoYSA9IGJvdHRvbUFscGhhICogaGFsZihzYXR1cmF0ZSh1cmFkaXVzUGx1c0hhbGZfUzEueCAtIGxlbmd0aChkeHkpKSk7CglyZXR1cm4gX2lucHV0ICogYWxwaGE7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBDaXJjdWxhclJSZWN0X1MxKG91dHB1dENvdmVyYWdlX1MwKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dF9TMTsKCX0KfQoBAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HVJAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAABAAAAAABBAMABSAAGQAAAAKFIDMVQUAAAAABIAAAAAQAAAABEERFAUBWKYKAAAIAAQAAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQGAAAAAAAAAEAAAABJMQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGABZAAGIAAAAACAAAAAADUAAAAAAAEAAAAAIDEAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQEAAAAAAABAEAAAABJIQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAEAQAAAAGQCEIBAACAIAAAAAACQAGAAAAAQAAAAAGBCAIAAAAAFAAAAAAEAAAAAAAAAAAAAAAAACAAAAAABQAAQAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABDAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"CgAAAExTS1OAAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGluUG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGluQ29sb3I7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0NCBpbkNpcmNsZUVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJdmluQ2lyY2xlRWRnZV9TMCA9IGluQ2lyY2xlRWRnZTsKCXZpbkNvbG9yX1MwID0gaW5Db2xvcjsKCWZsb2F0MiBfdG1wXzBfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSB1bG9jYWxNYXRyaXhfUzAueHogKiBpblBvc2l0aW9uICsgdWxvY2FsTWF0cml4X1MwLnl3OwoJc2tfUG9zaXRpb24gPSBfdG1wXzBfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAACbAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAQAAAAAAAAADAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAAHwAAAAwAAAABAAAAHAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAOAAHSAAAAAAQAAAAAA5AAAAAAABAAAAACAZAAIYAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"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","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAAAPEAHAAABAAAAAAAKAAYAAAACAAAAAAACCAYAIYAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"CgAAAExTS1NDBAAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1c3RhcnRfUzFfYzBfYzBfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTI0KSBoYWxmNCB1ZW5kX1MxX2MwX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD0zMikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMF9jMF9jMF9jMTsKCWxheW91dChvZmZzZXQ9ODApIGhhbGY0IHVsZWZ0Qm9yZGVyQ29sb3JfUzFfYzBfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTg4KSBoYWxmNCB1cmlnaHRCb3JkZXJDb2xvcl9TMV9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9OTYpIGZsb2F0M3gzIHVtYXRyaXhfUzFfYzE7CglsYXlvdXQob2Zmc2V0PTE0NCkgaGFsZiB1cmFuZ2VfUzE7CglsYXlvdXQob2Zmc2V0PTE2MCkgZmxvYXQ0IHVpbm5lclJlY3RfUzI7CglsYXlvdXQob2Zmc2V0PTE3NikgaGFsZjIgdXJhZGl1c1BsdXNIYWxmX1MyOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdCBjb3ZlcmFnZTsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDMpIGluIGZsb2F0MiBsb2NhbENvb3JkOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IG91dCBoYWxmNCB2Y29sb3JfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIG91dCBmbG9hdCB2Y292ZXJhZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDIpIG91dCBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzdfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJZmxvYXQyIHBvc2l0aW9uID0gcG9zaXRpb24ueHk7Cgl2Y29sb3JfUzAgPSBjb2xvcjsKCXZjb3ZlcmFnZV9TMCA9IGNvdmVyYWdlOwoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwoJewoJCXZUcmFuc2Zvcm1lZENvb3Jkc183X1MwID0gZmxvYXQzeDIodW1hdHJpeF9TMV9jMF9jMF9jMF9jMSkgKiBsb2NhbENvb3JkLnh5MTsKCX0KfQoAAAAAAAsNAABsYXlvdXQobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSBzYW1wbGVyMkQgdVRleHR1cmVTYW1wbGVyXzBfUzE7CmxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgaGFsZjQgdXN0YXJ0X1MxX2MwX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD0yNCkgaGFsZjQgdWVuZF9TMV9jMF9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9MzIpIGZsb2F0M3gzIHVtYXRyaXhfUzFfYzBfYzBfYzBfYzE7CglsYXlvdXQob2Zmc2V0PTgwKSBoYWxmNCB1bGVmdEJvcmRlckNvbG9yX1MxX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD04OCkgaGFsZjQgdXJpZ2h0Qm9yZGVyQ29sb3JfUzFfYzBfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTk2KSBmbG9hdDN4MyB1bWF0cml4X1MxX2MxOwoJbGF5b3V0KG9mZnNldD0xNDQpIGhhbGYgdXJhbmdlX1MxOwoJbGF5b3V0KG9mZnNldD0xNjApIGZsb2F0NCB1aW5uZXJSZWN0X1MyOwoJbGF5b3V0KG9mZnNldD0xNzYpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMjsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgaW4gaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdCB2Y292ZXJhZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfN19TMDsKaGFsZjQgU2luZ2xlSW50ZXJ2YWxDb2xvcml6ZXJfUzFfYzBfYzBfYzBfYzAoaGFsZjQgX2lucHV0LCBmbG9hdDIgX2Nvb3JkcykgCnsKCWhhbGY0IF90bXBfMF9pbkNvbG9yID0gX2lucHV0OwoJZmxvYXQyIF90bXBfMV9jb29yZHMgPSBfY29vcmRzOwoJcmV0dXJuIGhhbGY0KG1peCh1c3RhcnRfUzFfYzBfYzBfYzBfYzAsIHVlbmRfUzFfYzBfYzBfYzBfYzAsIGhhbGYoX3RtcF8xX2Nvb3Jkcy54KSkpOwp9CmhhbGY0IExpbmVhckxheW91dF9TMV9jMF9jMF9jMF9jMV9jMChoYWxmNCBfaW5wdXQpIAp7CgloYWxmNCBfdG1wXzJfaW5Db2xvciA9IF9pbnB1dDsKCWZsb2F0MiBfdG1wXzNfY29vcmRzID0gdlRyYW5zZm9ybWVkQ29vcmRzXzdfUzA7CglyZXR1cm4gaGFsZjQoaGFsZjQoaGFsZihfdG1wXzNfY29vcmRzLngpICsgMWUtMDUsIDEuMCwgMC4wLCAwLjApKTsKfQpoYWxmNCBNYXRyaXhFZmZlY3RfUzFfYzBfYzBfYzBfYzEoaGFsZjQgX2lucHV0KSAKewoJcmV0dXJuIExpbmVhckxheW91dF9TMV9jMF9jMF9jMF9jMV9jMChfaW5wdXQpOwp9CmhhbGY0IENsYW1wZWRHcmFkaWVudF9TMV9jMF9jMF9jMChoYWxmNCBfaW5wdXQpIAp7CgloYWxmNCBfdG1wXzRfaW5Db2xvciA9IF9pbnB1dDsKCWhhbGY0IHQgPSBNYXRyaXhFZmZlY3RfUzFfYzBfYzBfYzBfYzEoX3RtcF80X2luQ29sb3IpOwoJaGFsZjQgb3V0Q29sb3I7CglpZiAoIWJvb2woaW50KDEpKSAmJiB0LnkgPCAwLjApIAoJewoJCW91dENvbG9yID0gaGFsZjQoMC4wKTsKCX0KCWVsc2UgaWYgKHQueCA8IDAuMCkgCgl7CgkJb3V0Q29sb3IgPSB1bGVmdEJvcmRlckNvbG9yX1MxX2MwX2MwX2MwOwoJfQoJZWxzZSBpZiAodC54ID4gMS4wKSAKCXsKCQlvdXRDb2xvciA9IHVyaWdodEJvcmRlckNvbG9yX1MxX2MwX2MwX2MwOwoJfQoJZWxzZSAKCXsKCQlvdXRDb2xvciA9IFNpbmdsZUludGVydmFsQ29sb3JpemVyX1MxX2MwX2MwX2MwX2MwKF90bXBfNF9pbkNvbG9yLCBmbG9hdDIoaGFsZjIodC54LCAwLjApKSk7Cgl9CglyZXR1cm4gaGFsZjQob3V0Q29sb3IpOwp9CmhhbGY0IGNvbG9yX3hmb3JtX1MxX2MwX2MwKGhhbGY0IGNvbG9yKSAKewoJY29sb3IucmdiICo9IGNvbG9yLmE7CglyZXR1cm4gaGFsZjQoY29sb3IpOwp9CmhhbGY0IENvbG9yU3BhY2VYZm9ybV9TMV9jMF9jMChoYWxmNCBfaW5wdXQpIAp7CglyZXR1cm4gY29sb3JfeGZvcm1fUzFfYzBfYzAoQ2xhbXBlZEdyYWRpZW50X1MxX2MwX2MwX2MwKF9pbnB1dCkpOwp9CmhhbGY0IERpc2FibGVDb3ZlcmFnZUFzQWxwaGFfUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJX2lucHV0ID0gQ29sb3JTcGFjZVhmb3JtX1MxX2MwX2MwKF9pbnB1dCk7CgloYWxmNCBfdG1wXzVfaW5Db2xvciA9IF9pbnB1dDsKCXJldHVybiBoYWxmNChfaW5wdXQpOwp9CmhhbGY0IFRleHR1cmVFZmZlY3RfUzFfYzFfYzAoaGFsZjQgX2lucHV0LCBmbG9hdDIgX2Nvb3JkcykgCnsKCXJldHVybiBzYW1wbGUodVRleHR1cmVTYW1wbGVyXzBfUzEsIF9jb29yZHMpLjAwMHI7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxX2MxKGhhbGY0IF9pbnB1dCwgZmxvYXQyIF9jb29yZHMpIAp7CglyZXR1cm4gVGV4dHVyZUVmZmVjdF9TMV9jMV9jMChfaW5wdXQsIGZsb2F0M3gyKHVtYXRyaXhfUzFfYzEpICogX2Nvb3Jkcy54eTEpOwp9CmhhbGY0IERpdGhlcl9TMShoYWxmNCBfaW5wdXQpIAp7CgloYWxmNCBfdG1wXzZfaW5Db2xvciA9IF9pbnB1dDsKCWhhbGY0IGNvbG9yID0gRGlzYWJsZUNvdmVyYWdlQXNBbHBoYV9TMV9jMChfdG1wXzZfaW5Db2xvcik7CgloYWxmIHZhbHVlID0gTWF0cml4RWZmZWN0X1MxX2MxKF90bXBfNl9pbkNvbG9yLCBza19GcmFnQ29vcmQueHkpLncgLSAwLjU7CglyZXR1cm4gaGFsZjQoaGFsZjQoY2xhbXAoY29sb3IueHl6ICsgdmFsdWUgKiB1cmFuZ2VfUzEsIDAuMCwgY29sb3IudyksIGNvbG9yLncpKTsKfQpoYWxmNCBDaXJjdWxhclJSZWN0X1MyKGhhbGY0IF9pbnB1dCkgCnsKCWZsb2F0MiBkeHkwID0gdWlubmVyUmVjdF9TMi5MVCAtIHNrX0ZyYWdDb29yZC54eTsKCWZsb2F0MiBkeHkxID0gc2tfRnJhZ0Nvb3JkLnh5IC0gdWlubmVyUmVjdF9TMi5SQjsKCWZsb2F0MiBkeHkgPSBtYXgobWF4KGR4eTAsIGR4eTEpLCAwLjApOwoJaGFsZiBhbHBoYSA9IGhhbGYoc2F0dXJhdGUodXJhZGl1c1BsdXNIYWxmX1MyLnggLSBsZW5ndGgoZHh5KSkpOwoJcmV0dXJuIF9pbnB1dCAqIGFscGhhOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2Y29sb3JfUzA7CglmbG9hdCBjb3ZlcmFnZSA9IHZjb3ZlcmFnZV9TMDsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoaGFsZihjb3ZlcmFnZSkpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gRGl0aGVyX1MxKG91dHB1dENvbG9yX1MwKTsKCWhhbGY0IG91dHB1dF9TMjsKCW91dHB1dF9TMiA9IENpcmN1bGFyUlJlY3RfUzIob3V0cHV0Q292ZXJhZ2VfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dF9TMSAqIG91dHB1dF9TMjsKCX0KfQoAAQAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbAAAAAEAAAAAAAAABAAAAB0AAAAAAAAAAQAAABwAAAAIAAAAAQAAAAkAAAAMAAAAAQAAAB0AAAAQAAAAAQAAABgAAAAAAAAARgAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAEAQAAAAGQCBAMQACAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAAABQAAQAAAAAAAA":"CgAAAExTS1PoAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWNsYW1wX1MxX2MwOwoJbGF5b3V0KG9mZnNldD0zMikgZmxvYXQzeDMgdW1hdHJpeF9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gZmxvYXQyIGxvY2FsQ29vcmQ7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwoJewoJCXZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwID0gZmxvYXQzeDIodW1hdHJpeF9TMSkgKiBsb2NhbENvb3JkLnh5MTsKCX0KfQoAAAAA7QMAAGxheW91dChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHNhbXBsZXIyRCB1VGV4dHVyZVNhbXBsZXJfMF9TMTsKbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWNsYW1wX1MxX2MwOwoJbGF5b3V0KG9mZnNldD0zMikgZmxvYXQzeDMgdW1hdHJpeF9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfMl9TMDsKaGFsZjQgVGV4dHVyZUVmZmVjdF9TMV9jMChoYWxmNCBfaW5wdXQpIAp7CglmbG9hdDIgaW5Db29yZCA9IHZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwOwoJZmxvYXQyIHN1YnNldENvb3JkOwoJc3Vic2V0Q29vcmQueCA9IGluQ29vcmQueDsKCXN1YnNldENvb3JkLnkgPSBpbkNvb3JkLnk7CglmbG9hdDIgY2xhbXBlZENvb3JkOwoJY2xhbXBlZENvb3JkID0gY2xhbXAoc3Vic2V0Q29vcmQsIHVjbGFtcF9TMV9jMC54eSwgdWNsYW1wX1MxX2MwLnp3KTsKCWhhbGY0IHRleHR1cmVDb2xvciA9IHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMSwgY2xhbXBlZENvb3JkKTsKCXJldHVybiB0ZXh0dXJlQ29sb3I7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBUZXh0dXJlRWZmZWN0X1MxX2MwKF9pbnB1dCk7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzAgPSBoYWxmNCgxKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBNYXRyaXhFZmZlY3RfUzEob3V0cHV0Q29sb3JfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dF9TMSAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAdAAAACAAAAAEAAAAQAAAAAAAAAFAAAAAAAAAAAQAAAAAAAAA=","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQDAAAAAAABAEAAAABJGQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","B2AAQAAABQAAIAABBYAAB7777777777774ABICAAAAAAAAAAAAAABUABAAAAAEAAAAAIBEABAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OxAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZiBpbkNvdmVyYWdlOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZiB2aW5Db3ZlcmFnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgRGVmYXVsdEdlb21ldHJ5UHJvY2Vzc29yCglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJdmluQ292ZXJhZ2VfUzAgPSBpbkNvdmVyYWdlOwoJc2tfUG9zaXRpb24gPSBfdG1wXzFfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAAADJAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBoYWxmIHZpbkNvdmVyYWdlX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgRGVmYXVsdEdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdUNvbG9yX1MwOwoJaGFsZiBhbHBoYSA9IDEuMDsKCWFscGhhID0gdmluQ292ZXJhZ2VfUzA7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAcAAAACAAAAAEAAAAMAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAGIBIAAABAAAAANAEAAAAAAAAAAAAAABAAOAAAABAAAAAAABBAMAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAQAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGACQAGAAAAAQAAAAAAAQQGAAAIYAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"CgAAAExTS1NkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGZsb2F0MiBsb2NhbENvb3JkOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgZmxvYXQyIHZsb2NhbENvb3JkX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZsb2NhbENvb3JkX1MwID0gbG9jYWxDb29yZDsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAKQIAAGxheW91dChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHNhbXBsZXIyRCB1VGV4dHVyZVNhbXBsZXJfMF9TMDsKbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgdmxvY2FsQ29vcmRfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gaGFsZjQoMSk7CglmbG9hdDIgdGV4Q29vcmQ7Cgl0ZXhDb29yZCA9IHZsb2NhbENvb3JkX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSAoKHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMCwgdGV4Q29vcmQpICogaGFsZjQoMSkpKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHQAAAAgAAAABAAAAEAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","CIAAAAAAQAARQAAYQAAAAGFYQAABRAAAAEEAAAAAAARAEAEABYAAAAEAAAAAAAEEBQAAAACQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEBAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBQU7BTXIAAAAAACAAAAAAQFV5W6JEAAAAAYAAAABEGIRLQQSCIAACAH5FYUHQAAAAEAAAAABAAMQEAAAAEANDMXWJYBAAAGAAAAABACEK4GE4SAAAAA7JOVF4AAAAAAAAQAAAAGIBFCMXXZ2BAAACAACAAAACE2YGE6SAAAAAHIO5E4CAYAAAABAAAAACIMCRCWBRHUQAAAAAAAAAAAVREL6SYKDYAAAACAAAAABAAM6W52JYABAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAAAIQAAQAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGACQAGAAAAAQAAAAAAAQQGAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"CgAAAExTS1NkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGZsb2F0MiBsb2NhbENvb3JkOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgZmxvYXQyIHZsb2NhbENvb3JkX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZsb2NhbENvb3JkX1MwID0gbG9jYWxDb29yZDsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAKQIAAGxheW91dChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHNhbXBsZXIyRCB1VGV4dHVyZVNhbXBsZXJfMF9TMDsKbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgdmxvY2FsQ29vcmRfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gaGFsZjQoMSk7CglmbG9hdDIgdGV4Q29vcmQ7Cgl0ZXhDb29yZCA9IHZsb2NhbENvb3JkX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSAoKHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMCwgdGV4Q29vcmQpICogaGFsZjQoMSkpKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHQAAAAgAAAABAAAAEAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","B3IBQAAADAAAIAABBYAAAEIXBAAACDQMAAABIFAAAAAAAAAAAAAABFIBBYSAO7ICAAAAACX4GM5AAAAAAAIAAAAACAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAAAAAAQAAAAAEARQUPBT7IAAAAAACAAAAAAQFU5S6ZGAAAAAYAAAAAYCEOGAEGBAAAAAH5FYUXQAAAAAAACAAAAAMQEAIAAAANDMXXJYBAAAGAAAAAAABDRYBRQIQAAAAPJO5E4AAQAAAAAQAAAAGIBBCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAABAAAAAAIEDIYOAOMCEAAAAAAAAAAAFREL6S4KDYAAAACAAAAAAAAM6U52JYEBQAAAAAAAAAACYIEAIAAAAAAABUARCAIAAAAAAAAAABUABAAAAAEAAAAAIBEABKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAAAPEAHAAABAAAAAAAKAAYAAAACAAAAAAACCAYAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAAAAAAAAIAAAABSEIAL7YYDQAAAAAAACAAAAABQEKAAAAIAAAADIBAQGIAAAAAAAAAAAMACQCAACAAAAA2AIBAEIAAAAAAAAAACAA4AAAACAAAAAAACCAYAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAQAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBQU7BTXIAAAAAACAWXW3ZEQAAAADAAAAADAYRYQAQYEAAAIA7UXCQ6AAAAAQAAAAAAADGAWRWL3E4AQAADAAAAABAARY4AQYEIAAAAPUXKS6AAAAAAAAQAAAADE2CEOGAEGBAAAAAAAAAAAAK6S56JIEBYAAAABAAAAAAQEH7JOFF4AAAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAEMAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAICAACAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBQU7BTXIAAAAAACAAAAAAQFV5W6JEAAAAAYAAAABEGIRLQQSCIAACAH5FYUHQAAAAEAAAAABAAMQEAAAAEANDMXWJYBAAAGAAAAABACEK4GE4SAAAAA7JOVF4AAAAAAAAQAAAAGIBFCMXXZ2BAAACAACAAAACE2YGE6SAAAAAHIO5E4CAYAAAABAAAAACIMCRCWBRHUQAAAAAAAAAAAVREL6SYKDYAAAACAAAAABAAM6W52JYABAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABDAAAAAAEAAAAAAAAAAAAAAAAACAAAAAAIQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAAAAEAAAABJYQAAAAAAAAIAAAAAWCBAAAABAAAAANAEIQCAAAAAAAAAAAFAAMAAAABAAAAAAMCEAQFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"CgAAAExTS1NQAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwX2MwOwoJbGF5b3V0KG9mZnNldD02NCkgaGFsZjIgdUluY3JlbWVudF9TMV9jMDsKCWxheW91dChvZmZzZXQ9NjgpIGhhbGYyIHVPZmZzZXRzQW5kS2VybmVsX1MxX2MwWzEzXTsKCWxheW91dChvZmZzZXQ9MTI4KSBmbG9hdDN4MyB1bWF0cml4X1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfMl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxKSAqIGxvY2FsQ29vcmQueHkxOwoJfQp9CgAAAADQBQAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0M3gzIHVtYXRyaXhfUzFfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTY0KSBoYWxmMiB1SW5jcmVtZW50X1MxX2MwOwoJbGF5b3V0KG9mZnNldD02OCkgaGFsZjIgdU9mZnNldHNBbmRLZXJuZWxfUzFfYzBbMTNdOwoJbGF5b3V0KG9mZnNldD0xMjgpIGZsb2F0M3gzIHVtYXRyaXhfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CmhhbGY0IFRleHR1cmVFZmZlY3RfUzFfYzBfYzBfYzAoaGFsZjQgX2lucHV0LCBmbG9hdDIgX2Nvb3JkcykgCnsKCXJldHVybiBzYW1wbGUodVRleHR1cmVTYW1wbGVyXzBfUzEsIF9jb29yZHMpLjAwMHI7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxX2MwX2MwKGhhbGY0IF9pbnB1dCwgZmxvYXQyIF9jb29yZHMpIAp7CglyZXR1cm4gVGV4dHVyZUVmZmVjdF9TMV9jMF9jMF9jMChfaW5wdXQsIGZsb2F0M3gyKHVtYXRyaXhfUzFfYzBfYzApICogX2Nvb3Jkcy54eTEpOwp9CmhhbGY0IFNtb290aF9TMV9jMChoYWxmNCBfaW5wdXQsIGZsb2F0MiBjb29yZCwgaGFsZjIgb2Zmc2V0QW5kS2VybmVsKSAKewoJcmV0dXJuIE1hdHJpeEVmZmVjdF9TMV9jMF9jMChfaW5wdXQsIChjb29yZCArIG9mZnNldEFuZEtlcm5lbC54ICogdUluY3JlbWVudF9TMV9jMCkpICogb2Zmc2V0QW5kS2VybmVsLnk7Cn0KaGFsZjQgR2F1c3NpYW5Db252b2x1dGlvbl9TMV9jMChoYWxmNCBfaW5wdXQpIAp7CgloYWxmNCBjb2xvciA9IGhhbGY0KDApOwoJZmxvYXQyIGNvb3JkID0gdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7Cglmb3IgKGludCBpPTA7IGk8MTM7ICsraSkgCgl7CgkJY29sb3IgKz0gU21vb3RoX1MxX2MwKF9pbnB1dCwgY29vcmQsIHVPZmZzZXRzQW5kS2VybmVsX1MxX2MwW2ldKTsKCX0KCXJldHVybiBjb2xvcjsKfQpoYWxmNCBNYXRyaXhFZmZlY3RfUzEoaGFsZjQgX2lucHV0KSAKewoJcmV0dXJuIEdhdXNzaWFuQ29udm9sdXRpb25fUzFfYzAoX2lucHV0KTsKfQp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMCA9IGhhbGY0KDEpOwoJY29uc3QgaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNCgxKTsKCWhhbGY0IG91dHB1dF9TMTsKCW91dHB1dF9TMSA9IE1hdHJpeEVmZmVjdF9TMShvdXRwdXRDb2xvcl9TMCk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0X1MxICogb3V0cHV0Q292ZXJhZ2VfUzA7CgkJc2tfRnJhZ0NvbG9yID0gc2tfRnJhZ0NvbG9yLmEwMDA7Cgl9Cn0KAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAAAAAEAAAAAAAAAAgAAAB0AAAAAAAAAAQAAAB0AAAAIAAAAAQAAABAAAAAAAAAACgAAAAAAAAABAAAAAAAAAA==","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"CgAAAExTS1NOAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZjQgdmNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwp9CgAAAAAAAH0BAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAABYCMNGFQIAAAAHADEHC6BAAAAAAAABAAAAAAIBDBL6DGOQAAAAAAEAAAAABALL354SAAAAABQAAAAHAJRUIUBIBAAAMAMY4LYEAAAAAEAAAAABAIMQAAAAAEBNPNXSJAAAAAGAAAAAMBGOQCQFQEAAAQBTTRPAQAAAAAQAAAAAIBDCAWTWL3EYAAAADAAAAACADHIJJCYCAAAAAZ5YHQIIAAAAAAAIAAAABTZCMNCFAKAIAAAAAAAAAMBCTZQ7BQUAAAAAAAIAAAADEZAZRYXQIAAAAAAAAAAAGABIBAABAAAAANAEIQCAAAAAAAAAAABAAOAAAABAAAAAAABBAMUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"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","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1OAAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGluUG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGluQ29sb3I7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0NCBpbkNpcmNsZUVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJdmluQ2lyY2xlRWRnZV9TMCA9IGluQ2lyY2xlRWRnZTsKCXZpbkNvbG9yX1MwID0gaW5Db2xvcjsKCWZsb2F0MiBfdG1wXzBfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSB1bG9jYWxNYXRyaXhfUzAueHogKiBpblBvc2l0aW9uICsgdWxvY2FsTWF0cml4X1MwLnl3OwoJc2tfUG9zaXRpb24gPSBfdG1wXzBfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAACbAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAQAAAAAAAAADAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAAHwAAAAwAAAABAAAAHAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAEABYAAAAEAAAAAAAEEBQAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAMGAICAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAABAEAAAABJYQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAMWAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAASLEYTYIIBAAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAAEQZCFOCCIJAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAEAIRLQYTSIAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAITLAYT2IAAAAA5B3UTQIDAAAAAEAAAAAJBQKEKYGE6SAAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAAAYQADAAAEAFEURUKQKAAAIAAQAAAAAIAAAABSCICWKY2FAEAAAUAAAAAAAAAAAAAIADQAAAAIAAAAAAAIIDAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAAAQAAAAGQCBAMQACAAAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","GCAAAAAADAAAEAABBYAAAAYXBAAAAAAAAAAAAAAAHGADYAAAQAAAAAAAAAOQAAAAAAAQAAAABAMQAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAB3QA6AAAEAAAAAAAMAABUAAAAARCB3FMFCAAAAAKAAAAAEAAAAABAENIVANSWCQAAAAAFAAAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQLAAAAAAABAEAAAABJWQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"CgAAAExTS1NTAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAACCAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAMAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAOAAHSAAAAAAQAAAAAA5AAAAAAABAAAAACAZAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAMWAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAAMHCHGACAAQAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAADAYRYQAQYEAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAIAEOHAEGBCAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAEMHAHGBCAAAAA5B3UTQIDAAAAAEAAAAAJAQJDRYBRQIQAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAABYQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAACJMTCPBBAEAAAUDPSKBIPAAAAAAAAIAAAAACAIYKPQZ3UAAAAAABALL3N4SIAAAABQAAAACIMRCXBBEEQAAEAP2LRIPAAAAAIAAAAAAABTALI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAIAAAABSDBEIVYMJREAAAAAAAAAAAFPJO7EUCA4AAAAAQAAAAAICD7UXCS6AAAAAAAAAAAAACWCAACAAAAACAINAEIAAAAAAAAAAAAA5AAAAAAABAAAAACAZAAACGAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","HTRQAGAABBYAAAEIXBAAAGEAMAAAAAAAAAAAAAAAWAGHAIBZ5AJQAAAA5C5DCQYAAAAABAAAAAAIA2GZPMTQCAAAMAAAAAEACHDQCDARAAAAAPGD4GCQAAAAAAAAABAAAAAGJJHLYYGACAAAAAAAEAAAACRGL345AQAABAABAAAAARQ4A4YEIAAAADYAZBYXAIAAAAAIAAAABSAQBAAAAAEIS26XOEQAAAAAMAAAAAMHCHGACAAQAAGAGMOF4CAAAAACAAAAABAEMIC263PESAAAAAMAAAAAMDCHCACDAQAAAAGPOB4CCAAAAAAACAAAAAMTJYRYQAQQEAAAAAAAAAGARJ4INQYLAEAAAAAEAAAABSEQM44LYEAAAAAAAAAAADAAUAQAAQAAAAGQCAIBCAAAAAAAAAAAYAADIAAAABCEDWKYKEAAAAAMAAAAAIAAAAACAI2RKA3FMFAAAAAAGAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAABAEAAAABJYQAAAAAACAIAAAAAWCBAAAIBAAAAANAEIQCAAAAQAAAAAAFAAMAAAABAAAAAAMCEAQFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAEAQAAAAGQCBAMQACAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAACQAAAAAABQIQCAAAAUAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAA":"CgAAAExTS1OAAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGluUG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGluQ29sb3I7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0NCBpbkNpcmNsZUVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJdmluQ2lyY2xlRWRnZV9TMCA9IGluQ2lyY2xlRWRnZTsKCXZpbkNvbG9yX1MwID0gaW5Db2xvcjsKCWZsb2F0MiBfdG1wXzBfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSB1bG9jYWxNYXRyaXhfUzAueHogKiBpblBvc2l0aW9uICsgdWxvY2FsTWF0cml4X1MwLnl3OwoJc2tfUG9zaXRpb24gPSBfdG1wXzBfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAACyAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogQ292ZXJhZ2UgU2V0IE9wCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q292ZXJhZ2VfUzA7CgkJc2tfRnJhZ0NvbG9yID0gc2tfRnJhZ0NvbG9yLmEwMDA7Cgl9Cn0KAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIAAAAAQAAAAAAAAADAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAAHwAAAAwAAAABAAAAHAAAAAAAAAAKAAAAAAAAAAEAAAAAAAAA","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQDAAAAAAIBAEAAAABJGQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGABZAA6IAAAAACAAAAAADUAAAAAAAEAAAAAIDEAAAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAQAAAAAAAA":"CgAAAExTS1NTAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAACCAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAMAAAAAAAAAEYAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAAHAJRUYWBAAAAA2DXZFAQHAAAAAAAAEAAAAABAEMFPYMZ2AAAAAAAQFV566JAAAAAAYAAAADQEY2EKAUAQAAFA34SQKDYAAAACAAAAABAEMIC263PESAAAAAMAAAAAYCM5AFALAIAAAQF7JMFB4AAAACAAAAAAQAGHEJRUYWBAAAAAAAAAAAFQEL6S4KLYAAAAAAABAAAAAMWU56JIEBYAAAAAAAAAACYIEAAAAEAAAABUARCAIAAAAAAAAAAAUABQAAAAEAAAAAAAEEBQAACQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAB3QA6AAAEAAAAAAAMAAPEAEAAABAAAAAAB2AAAAAAACAAAAAEBSAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"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","DAQAAAAAAABGAABAYAAQAIHCAIAYAQUBAEAAAAAAEAAAAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAARQAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"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","GAAAAAAADAAAEAABBYAAAAYXBAAAAAAAAAAAAAAA2AAQAAAACAAAAAEASAAQAAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"CgAAAExTS1OrAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5IYWlyUXVhZEVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmNCB2SGFpclF1YWRFZGdlX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkCgl2SGFpclF1YWRFZGdlX1MwID0gaW5IYWlyUXVhZEVkZ2U7CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJc2tfUG9zaXRpb24gPSBfdG1wXzFfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAMQMAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgaGFsZjQgdUNvbG9yX1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdkhhaXJRdWFkRWRnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWQKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB1Q29sb3JfUzA7CgloYWxmIGVkZ2VBbHBoYTsKCWhhbGYyIGR1dmR4ID0gaGFsZjIoZEZkeCh2SGFpclF1YWRFZGdlX1MwLnh5KSk7CgloYWxmMiBkdXZkeSA9IGhhbGYyKGRGZHkodkhhaXJRdWFkRWRnZV9TMC54eSkpOwoJaGFsZjIgZ0YgPSBoYWxmMigyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeC54IC0gZHV2ZHgueSwgICAgICAgICAgICAgICAyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeS54IC0gZHV2ZHkueSk7CgllZGdlQWxwaGEgPSBoYWxmKHZIYWlyUXVhZEVkZ2VfUzAueCAqIHZIYWlyUXVhZEVkZ2VfUzAueCAtIHZIYWlyUXVhZEVkZ2VfUzAueSk7CgllZGdlQWxwaGEgPSBzcXJ0KGVkZ2VBbHBoYSAqIGVkZ2VBbHBoYSAvIGRvdChnRiwgZ0YpKTsKCWVkZ2VBbHBoYSA9IG1heCgxLjAgLSBlZGdlQWxwaGEsIDAuMCk7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGVkZ2VBbHBoYSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHwAAAAgAAAABAAAAGAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQEAAAAAAIBAEAAAABJIQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAAKUAQDAABYAAABAIAAAABLBAIBAAAAABAEGABBAMAAAAIAAAAAAAB2AAAAAAACAAAAAEBSAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAAAAYAAIAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAIAAEAAAABJYQAAAAAQAAIAAAAAWCBACAABAAAAANAECAZAAEAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"CgAAAExTS1N+AgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWNsYW1wX1MxX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD0zMikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMF9jMDsKCWxheW91dChvZmZzZXQ9ODApIGhhbGYyIHVJbmNyZW1lbnRfUzFfYzA7CglsYXlvdXQob2Zmc2V0PTg0KSBoYWxmMiB1T2Zmc2V0c0FuZEtlcm5lbF9TMV9jMFsxM107CglsYXlvdXQob2Zmc2V0PTE0NCkgZmxvYXQzeDMgdW1hdHJpeF9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gZmxvYXQyIGxvY2FsQ29vcmQ7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwoJewoJCXZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwID0gZmxvYXQzeDIodW1hdHJpeF9TMSkgKiBsb2NhbENvb3JkLnh5MTsKCX0KfQoAAAAAAADxBgAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1Y2xhbXBfUzFfYzBfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTMyKSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwX2MwOwoJbGF5b3V0KG9mZnNldD04MCkgaGFsZjIgdUluY3JlbWVudF9TMV9jMDsKCWxheW91dChvZmZzZXQ9ODQpIGhhbGYyIHVPZmZzZXRzQW5kS2VybmVsX1MxX2MwWzEzXTsKCWxheW91dChvZmZzZXQ9MTQ0KSBmbG9hdDN4MyB1bWF0cml4X1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwOwpoYWxmNCBUZXh0dXJlRWZmZWN0X1MxX2MwX2MwX2MwKGhhbGY0IF9pbnB1dCwgZmxvYXQyIF9jb29yZHMpIAp7CglmbG9hdDIgaW5Db29yZCA9IF9jb29yZHM7CglmbG9hdDIgc3Vic2V0Q29vcmQ7CglzdWJzZXRDb29yZC54ID0gaW5Db29yZC54OwoJc3Vic2V0Q29vcmQueSA9IGluQ29vcmQueTsKCWZsb2F0MiBjbGFtcGVkQ29vcmQ7CgljbGFtcGVkQ29vcmQueCA9IGNsYW1wKHN1YnNldENvb3JkLngsIHVjbGFtcF9TMV9jMF9jMF9jMC54LCB1Y2xhbXBfUzFfYzBfYzBfYzAueik7CgljbGFtcGVkQ29vcmQueSA9IHN1YnNldENvb3JkLnk7CgloYWxmNCB0ZXh0dXJlQ29sb3IgPSBzYW1wbGUodVRleHR1cmVTYW1wbGVyXzBfUzEsIGNsYW1wZWRDb29yZCk7CglyZXR1cm4gdGV4dHVyZUNvbG9yOwp9CmhhbGY0IE1hdHJpeEVmZmVjdF9TMV9jMF9jMChoYWxmNCBfaW5wdXQsIGZsb2F0MiBfY29vcmRzKSAKewoJcmV0dXJuIFRleHR1cmVFZmZlY3RfUzFfYzBfYzBfYzAoX2lucHV0LCBmbG9hdDN4Mih1bWF0cml4X1MxX2MwX2MwKSAqIF9jb29yZHMueHkxKTsKfQpoYWxmNCBTbW9vdGhfUzFfYzAoaGFsZjQgX2lucHV0LCBmbG9hdDIgY29vcmQsIGhhbGYyIG9mZnNldEFuZEtlcm5lbCkgCnsKCXJldHVybiBNYXRyaXhFZmZlY3RfUzFfYzBfYzAoX2lucHV0LCAoY29vcmQgKyBvZmZzZXRBbmRLZXJuZWwueCAqIHVJbmNyZW1lbnRfUzFfYzApKSAqIG9mZnNldEFuZEtlcm5lbC55Owp9CmhhbGY0IEdhdXNzaWFuQ29udm9sdXRpb25fUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgY29sb3IgPSBoYWxmNCgwKTsKCWZsb2F0MiBjb29yZCA9IHZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwOwoJZm9yIChpbnQgaT0wOyBpPDEzOyArK2kpIAoJewoJCWNvbG9yICs9IFNtb290aF9TMV9jMChfaW5wdXQsIGNvb3JkLCB1T2Zmc2V0c0FuZEtlcm5lbF9TMV9jMFtpXSk7Cgl9CglyZXR1cm4gY29sb3I7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBHYXVzc2lhbkNvbnZvbHV0aW9uX1MxX2MwKF9pbnB1dCk7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzAgPSBoYWxmNCgxKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBNYXRyaXhFZmZlY3RfUzEob3V0cHV0Q29sb3JfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dF9TMSAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAdAAAACAAAAAEAAAAQAAAAAAAAAFAAAAAAAAAAAQAAAAAAAAA=","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBQU7BTXIAAAAAACAWXW3ZEQAAAADAAAAAEQZCFOCCIJAAAIA7UXCQ6AAAAAQAAAAAAADGAWRWL3E4AQAADAAAAAAQBCFODCOJAAAAAPUXKS6AAAAAAAAQAAAADEGCIRLQYTCIAAAAAAAAAAAK6S56JIEBYAAAABAAAAAAQEH7JOFF4AAAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAEMAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAICAACAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAABAEAAAABJYQAAAAAACAIAAAAAWCBAAAIBAAAAANAEIQCAAAAQAAAAAAFAAMAAAABAAAAAAMCEAQFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADEAANAAAAAUKQGZLBIAAAAACQAAAABAAAAAGIJAKJJDIVAUAAAQABAAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAQAAAAAAAA":"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","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAOAAHSAAAAAAQAAAAAA5AAAAAAABAAAAACAZAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAAMHCHGACAAQAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAADAYRYQAQYEAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAIAEOHAEGBCAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAEMHAHGBCAAAAA5B3UTQIDAAAAAEAAAAAJAQJDRYBRQIQAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","DASAAAAAQAAWAABAYAAQBYH7777Z6QQBAEAAAAAAEAAAAAAAEBSAAAB2AAAAAAACAAAAAEBSAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"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","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAAAPEAHAAABAAAAAAAKAAYAAAACAAAAAAACCAYAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGAAZAADIAAAACU53QJEKAAAAAAMAAAAAIAAAAAAGIRDFB2XASAUAABQAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"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","B3IBQAAADAAAIAABBYAAAEIXBAAACDQMAAABIFAAAAAAAAAAAAAABFIBBYSAO7ICAAAAACX4GM5AAAAAAAIAAAAACAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAAAAAAQAAAAAEARQUPBT7IAAAAAACAAAAAAQFU5S6ZGAAAAAYAAAAAYCEOGAEGBAAAAAH5FYUXQAAAAAAACAAAAAMQEAIAAAANDMXXJYBAAAGAAAAAAABDRYBRQIQAAAAPJO5E4AAQAAAAAQAAAAGIBBCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAABAAAAAAIEDIYOAOMCEAAAAAAAAAAAFREL6S4KDYAAAACAAAAAAAAM6U52JYEBQAAAAAAAAAACYIEAIAAAAAAABUARCAIAAAAAAAAAABUABAAAAAEAAAAAIBEABKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAMWAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAACJMTCPBBAEAAAUDPSKBIPAAAAAAAAIAAAAACAIYKPQZ3UAAAAAABALL3N4SIAAAABQAAAACIMRCXBBEEQAAEAP2LRIPAAAAAIAAAAAAABTALI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAIAAAABSDBEIVYMJREAAAAAAAAAAAFPJO7EUCA4AAAAAQAAAAAICD7UXCS6AAAAAAAAAAAAACWCAACAAAAACAINAEIAAAAAAAAAAAAADZABYAAAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","CIAAAAAAQAARQAAYQAAAAGFYQAABRAAAAEEAAAAAAARAEAEABYAAAAEAAAAAAAEEBQAAAACGAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEBAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQLAAAAAAAAAEAAAABJWQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAEABYAAAAEAAAAAAAEEBQAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","HVJAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAABAAAAAABBAMADSAB4QAAAAAEAAAAAAHIAAAAAAAIAAAAAQGIAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAMGAICAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEADZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAACIDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1aW5uZXJSZWN0X1MxOwoJbGF5b3V0KG9mZnNldD0zMikgaGFsZjIgdXJhZGl1c1BsdXNIYWxmX1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdmNvbG9yX1MwOwpoYWxmNCBDaXJjdWxhclJSZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCWZsb2F0MiBkeHkwID0gdWlubmVyUmVjdF9TMS5MVCAtIHNrX0ZyYWdDb29yZC54eTsKCWZsb2F0MiBkeHkxID0gc2tfRnJhZ0Nvb3JkLnh5IC0gdWlubmVyUmVjdF9TMS5SQjsKCWZsb2F0MiBkeHkgPSBtYXgobWF4KGR4eTAsIGR4eTEpLCAwLjApOwoJaGFsZiBhbHBoYSA9IGhhbGYoc2F0dXJhdGUodXJhZGl1c1BsdXNIYWxmX1MxLnggLSBsZW5ndGgoZHh5KSkpOwoJcmV0dXJuIF9pbnB1dCAqIGFscGhhOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2Y29sb3JfUzA7Cgljb25zdCBoYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KDEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gQ2lyY3VsYXJSUmVjdF9TMShvdXRwdXRDb3ZlcmFnZV9TMCk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRfUzE7Cgl9Cn0KAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEADZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAACIDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1aW5uZXJSZWN0X1MxOwoJbGF5b3V0KG9mZnNldD0zMikgaGFsZjIgdXJhZGl1c1BsdXNIYWxmX1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdmNvbG9yX1MwOwpoYWxmNCBDaXJjdWxhclJSZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCWZsb2F0MiBkeHkwID0gdWlubmVyUmVjdF9TMS5MVCAtIHNrX0ZyYWdDb29yZC54eTsKCWZsb2F0MiBkeHkxID0gc2tfRnJhZ0Nvb3JkLnh5IC0gdWlubmVyUmVjdF9TMS5SQjsKCWZsb2F0MiBkeHkgPSBtYXgobWF4KGR4eTAsIGR4eTEpLCAwLjApOwoJaGFsZiBhbHBoYSA9IGhhbGYoc2F0dXJhdGUodXJhZGl1c1BsdXNIYWxmX1MxLnggLSBsZW5ndGgoZHh5KSkpOwoJcmV0dXJuIF9pbnB1dCAqIGFscGhhOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2Y29sb3JfUzA7Cgljb25zdCBoYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KDEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gQ2lyY3VsYXJSUmVjdF9TMShvdXRwdXRDb3ZlcmFnZV9TMCk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRfUzE7Cgl9Cn0KAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","AYAA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"CgAAAExTS1MrAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQ0IGluQ2lyY2xlRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0NCB2aW5DaXJjbGVFZGdlX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCgl2aW5DaXJjbGVFZGdlX1MwID0gaW5DaXJjbGVFZGdlOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCWZsb2F0MiBfdG1wXzJfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247Cglza19Qb3NpdGlvbiA9IF90bXBfMF9pblBvc2l0aW9uLnh5MDE7Cn0KAAAAAABwAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJZmxvYXQ0IGNpcmNsZUVkZ2U7CgljaXJjbGVFZGdlID0gdmluQ2lyY2xlRWRnZV9TMDsKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2aW5Db2xvcl9TMDsKCWZsb2F0IGQgPSBsZW5ndGgoY2lyY2xlRWRnZS54eSk7CgloYWxmIGRpc3RhbmNlVG9PdXRlckVkZ2UgPSBoYWxmKGNpcmNsZUVkZ2UueiAqICgxLjAgLSBkKSk7CgloYWxmIGVkZ2VBbHBoYSA9IHNhdHVyYXRlKGRpc3RhbmNlVG9PdXRlckVkZ2UpOwoJaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNChlZGdlQWxwaGEpOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0Q292ZXJhZ2VfUzA7Cgl9Cn0KAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAEAAAAAAAAAAwAAAB0AAAAAAAAAAQAAAAkAAAAIAAAAAQAAAB8AAAAMAAAAAQAAABwAAAAAAAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","GCAAAAAADAAAEAABBYAAAAYXBAAAAAAAAAAAAAAA2AAQAAAACAAAAAEASAAQAAAAIYAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"CgAAAExTS1PRAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7CglsYXlvdXQob2Zmc2V0PTI0KSBoYWxmIHVDb3ZlcmFnZV9TMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBpblBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBoYWxmNCBpbkhhaXJRdWFkRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGhhbGY0IHZIYWlyUXVhZEVkZ2VfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWQKCXZIYWlyUXVhZEVkZ2VfUzAgPSBpbkhhaXJRdWFkRWRnZTsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247Cglza19Qb3NpdGlvbiA9IF90bXBfMV9pblBvc2l0aW9uLnh5MDE7Cn0KAAAAAAAAAGYDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGhhbGY0IHVDb2xvcl9TMDsKCWxheW91dChvZmZzZXQ9MjQpIGhhbGYgdUNvdmVyYWdlX1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdkhhaXJRdWFkRWRnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWQKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB1Q29sb3JfUzA7CgloYWxmIGVkZ2VBbHBoYTsKCWhhbGYyIGR1dmR4ID0gaGFsZjIoZEZkeCh2SGFpclF1YWRFZGdlX1MwLnh5KSk7CgloYWxmMiBkdXZkeSA9IGhhbGYyKGRGZHkodkhhaXJRdWFkRWRnZV9TMC54eSkpOwoJaGFsZjIgZ0YgPSBoYWxmMigyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeC54IC0gZHV2ZHgueSwgICAgICAgICAgICAgICAyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeS54IC0gZHV2ZHkueSk7CgllZGdlQWxwaGEgPSBoYWxmKHZIYWlyUXVhZEVkZ2VfUzAueCAqIHZIYWlyUXVhZEVkZ2VfUzAueCAtIHZIYWlyUXVhZEVkZ2VfUzAueSk7CgllZGdlQWxwaGEgPSBzcXJ0KGVkZ2VBbHBoYSAqIGVkZ2VBbHBoYSAvIGRvdChnRiwgZ0YpKTsKCWVkZ2VBbHBoYSA9IG1heCgxLjAgLSBlZGdlQWxwaGEsIDAuMCk7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KHVDb3ZlcmFnZV9TMCAqIGVkZ2VBbHBoYSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAfAAAACAAAAAEAAAAYAAAAAAAAAEYAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","GAAAAAAADAAAEAABBYAAAAYXBAAAAAAAAAAAAAAA2AAQAAAACAAAAAEASAAQAAAAIYAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"CgAAAExTS1OrAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5IYWlyUXVhZEVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmNCB2SGFpclF1YWRFZGdlX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkCgl2SGFpclF1YWRFZGdlX1MwID0gaW5IYWlyUXVhZEVkZ2U7CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJc2tfUG9zaXRpb24gPSBfdG1wXzFfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAMQMAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgaGFsZjQgdUNvbG9yX1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdkhhaXJRdWFkRWRnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWQKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB1Q29sb3JfUzA7CgloYWxmIGVkZ2VBbHBoYTsKCWhhbGYyIGR1dmR4ID0gaGFsZjIoZEZkeCh2SGFpclF1YWRFZGdlX1MwLnh5KSk7CgloYWxmMiBkdXZkeSA9IGhhbGYyKGRGZHkodkhhaXJRdWFkRWRnZV9TMC54eSkpOwoJaGFsZjIgZ0YgPSBoYWxmMigyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeC54IC0gZHV2ZHgueSwgICAgICAgICAgICAgICAyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeS54IC0gZHV2ZHkueSk7CgllZGdlQWxwaGEgPSBoYWxmKHZIYWlyUXVhZEVkZ2VfUzAueCAqIHZIYWlyUXVhZEVkZ2VfUzAueCAtIHZIYWlyUXVhZEVkZ2VfUzAueSk7CgllZGdlQWxwaGEgPSBzcXJ0KGVkZ2VBbHBoYSAqIGVkZ2VBbHBoYSAvIGRvdChnRiwgZ0YpKTsKCWVkZ2VBbHBoYSA9IG1heCgxLjAgLSBlZGdlQWxwaGEsIDAuMCk7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGVkZ2VBbHBoYSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHwAAAAgAAAABAAAAGAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAADUAANAAAAAAIBAIAAAABLCIIBAAAAABAEGABBAMAACAIAAAAAAAB2AAAAAAACAAAAAEBSAAAAARQAAAAACAAAAAAAAAAAAAAAAABAAAAAAAYAAAAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEADZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAARQAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAACIDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1aW5uZXJSZWN0X1MxOwoJbGF5b3V0KG9mZnNldD0zMikgaGFsZjIgdXJhZGl1c1BsdXNIYWxmX1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdmNvbG9yX1MwOwpoYWxmNCBDaXJjdWxhclJSZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCWZsb2F0MiBkeHkwID0gdWlubmVyUmVjdF9TMS5MVCAtIHNrX0ZyYWdDb29yZC54eTsKCWZsb2F0MiBkeHkxID0gc2tfRnJhZ0Nvb3JkLnh5IC0gdWlubmVyUmVjdF9TMS5SQjsKCWZsb2F0MiBkeHkgPSBtYXgobWF4KGR4eTAsIGR4eTEpLCAwLjApOwoJaGFsZiBhbHBoYSA9IGhhbGYoc2F0dXJhdGUodXJhZGl1c1BsdXNIYWxmX1MxLnggLSBsZW5ndGgoZHh5KSkpOwoJcmV0dXJuIF9pbnB1dCAqIGFscGhhOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2Y29sb3JfUzA7Cgljb25zdCBoYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KDEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gQ2lyY3VsYXJSUmVjdF9TMShvdXRwdXRDb3ZlcmFnZV9TMCk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRfUzE7Cgl9Cn0KAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQAAEAQAAAAGQCBAMQAAAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAACJMTCPBBAEAAAUDPSKBIPAAAAAAAAIAAAAACAIYKPQZ3UAAAAAABALL3N4SIAAAABQAAAACIMRCXBBEEQAAEAP2LRIPAAAAAIAAAAAAABTALI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAIAAAABSDBEIVYMJREAAAAAAAAAAAFPJO7EUCA4AAAAAQAAAAAICD7UXCS6AAAAAAAAAAAAACWCAACAAAAACAINAEIAAAAAAAAAAAAA5AAAAAAABAAAAACAZAAACGAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","AYAA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1MrAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQ0IGluQ2lyY2xlRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0NCB2aW5DaXJjbGVFZGdlX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCgl2aW5DaXJjbGVFZGdlX1MwID0gaW5DaXJjbGVFZGdlOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCWZsb2F0MiBfdG1wXzJfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247Cglza19Qb3NpdGlvbiA9IF90bXBfMF9pblBvc2l0aW9uLnh5MDE7Cn0KAAAAAABwAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJZmxvYXQ0IGNpcmNsZUVkZ2U7CgljaXJjbGVFZGdlID0gdmluQ2lyY2xlRWRnZV9TMDsKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2aW5Db2xvcl9TMDsKCWZsb2F0IGQgPSBsZW5ndGgoY2lyY2xlRWRnZS54eSk7CgloYWxmIGRpc3RhbmNlVG9PdXRlckVkZ2UgPSBoYWxmKGNpcmNsZUVkZ2UueiAqICgxLjAgLSBkKSk7CgloYWxmIGVkZ2VBbHBoYSA9IHNhdHVyYXRlKGRpc3RhbmNlVG9PdXRlckVkZ2UpOwoJaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNChlZGdlQWxwaGEpOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0Q292ZXJhZ2VfUzA7Cgl9Cn0KAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAEAAAAAAAAAAwAAAB0AAAAAAAAAAQAAAAkAAAAIAAAAAQAAAB8AAAAMAAAAAQAAABwAAAAAAAAARgAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","AY7SRAADQAAAOAEARAFQJAABBADAAAILBYAACCYUAAAQWGUAAEECAAAAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAACJMTCPBBAEAAAUDPSKBIPAAAAAAAAIAAAAACAIYKPQZ3UAAAAAABALL3N4SIAAAABQAAAACIMRCXBBEEQAAEAP2LRIPAAAAAIAAAAAAABTALI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAIAAAABSDBEIVYMJREAAAAAAAAAAAFPJO7EUCA4AAAAAQAAAAAICD7UXCS6AAAAAAAAAAAAACWCAACAAAAACAINAEIAAAAAAAAAAAAA5AAAAAAABAAAAACAZAAACQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAAAHUAAAAABABLFMNCQCAAAKAAAAAEAAAAABAEMIRA5SWCRAAAAAFAAAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","FAAQMYAAMAAAEADAAABAEYAAAICIAB5AABQAAAQAMAAAEATAAABAIIGAAEDCBYQCA4AAAAAAAA5AAAAAAABAAAAACAZAAAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"CgAAAExTS1PmDAAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDQgcmFkaWlfc2VsZWN0b3I7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGZsb2F0NCBjb3JuZXJfYW5kX3JhZGl1c19vdXRzZXRzOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiBmbG9hdDQgYWFfYmxvYXRfYW5kX2NvdmVyYWdlOwpsYXlvdXQobG9jYXRpb24gPSAzKSBpbiBmbG9hdDQgcmFkaWlfeDsKbGF5b3V0KGxvY2F0aW9uID0gNCkgaW4gZmxvYXQ0IHJhZGlpX3k7CmxheW91dChsb2NhdGlvbiA9IDUpIGluIGZsb2F0NCBza2V3OwpsYXlvdXQobG9jYXRpb24gPSA2KSBpbiBmbG9hdDIgdHJhbnNsYXRlX2FuZF9sb2NhbHJvdGF0ZTsKbGF5b3V0KGxvY2F0aW9uID0gNykgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgb3V0IGhhbGY0IHZjb2xvcl9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGZsb2F0MiB2YXJjY29vcmRfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIEZpbGxSUmVjdE9wOjpQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJZmxvYXQgYWFfYmxvYXRfbXVsdGlwbGllciA9IDE7CglmbG9hdDIgY29ybmVyID0gY29ybmVyX2FuZF9yYWRpdXNfb3V0c2V0cy54eTsKCWZsb2F0MiByYWRpdXNfb3V0c2V0ID0gY29ybmVyX2FuZF9yYWRpdXNfb3V0c2V0cy56dzsKCWZsb2F0MiBhYV9ibG9hdF9kaXJlY3Rpb24gPSBhYV9ibG9hdF9hbmRfY292ZXJhZ2UueHk7CglmbG9hdCBpc19saW5lYXJfY292ZXJhZ2UgPSBhYV9ibG9hdF9hbmRfY292ZXJhZ2UudzsKCWZsb2F0MiBwaXhlbGxlbmd0aCA9IGludmVyc2VzcXJ0KGZsb2F0Mihkb3Qoc2tldy54eiwgc2tldy54eiksIGRvdChza2V3Lnl3LCBza2V3Lnl3KSkpOwoJZmxvYXQ0IG5vcm1hbGl6ZWRfYXhpc19kaXJzID0gc2tldyAqIHBpeGVsbGVuZ3RoLnh5eHk7CglmbG9hdDIgYXhpc3dpZHRocyA9IChhYnMobm9ybWFsaXplZF9heGlzX2RpcnMueHkpICsgYWJzKG5vcm1hbGl6ZWRfYXhpc19kaXJzLnp3KSk7CglmbG9hdDIgYWFfYmxvYXRyYWRpdXMgPSBheGlzd2lkdGhzICogcGl4ZWxsZW5ndGggKiAuNTsKCWZsb2F0NCByYWRpaV9hbmRfbmVpZ2hib3JzID0gcmFkaWlfc2VsZWN0b3IqIGZsb2F0NHg0KHJhZGlpX3gsIHJhZGlpX3ksIHJhZGlpX3gueXh3eiwgcmFkaWlfeS53enl4KTsKCWZsb2F0MiByYWRpaSA9IHJhZGlpX2FuZF9uZWlnaGJvcnMueHk7CglmbG9hdDIgbmVpZ2hib3JfcmFkaWkgPSByYWRpaV9hbmRfbmVpZ2hib3JzLnp3OwoJZmxvYXQgY292ZXJhZ2VfbXVsdGlwbGllciA9IDE7CglpZiAoYW55KGdyZWF0ZXJUaGFuKGFhX2Jsb2F0cmFkaXVzLCBmbG9hdDIoMSkpKSkgCgl7CgkJY29ybmVyID0gbWF4KGFicyhjb3JuZXIpLCBhYV9ibG9hdHJhZGl1cykgKiBzaWduKGNvcm5lcik7CgkJY292ZXJhZ2VfbXVsdGlwbGllciA9IDEgLyAobWF4KGFhX2Jsb2F0cmFkaXVzLngsIDEpICogbWF4KGFhX2Jsb2F0cmFkaXVzLnksIDEpKTsKCQlyYWRpaSA9IGZsb2F0MigwKTsKCX0KCWZsb2F0IGNvdmVyYWdlID0gYWFfYmxvYXRfYW5kX2NvdmVyYWdlLno7CglpZiAoYW55KGxlc3NUaGFuKHJhZGlpLCBhYV9ibG9hdHJhZGl1cyAqIDEuNSkpKSAKCXsKCQlyYWRpaSA9IGZsb2F0MigwKTsKCQlhYV9ibG9hdF9kaXJlY3Rpb24gPSBzaWduKGNvcm5lcik7CgkJaWYgKGNvdmVyYWdlID4gLjUpIAoJCXsKCQkJYWFfYmxvYXRfZGlyZWN0aW9uID0gLWFhX2Jsb2F0X2RpcmVjdGlvbjsKCQl9CgkJaXNfbGluZWFyX2NvdmVyYWdlID0gMTsKCX0KCWVsc2UgCgl7CgkJcmFkaWkgPSBjbGFtcChyYWRpaSwgcGl4ZWxsZW5ndGggKiAxLjUsIDIgLSBwaXhlbGxlbmd0aCAqIDEuNSk7CgkJbmVpZ2hib3JfcmFkaWkgPSBjbGFtcChuZWlnaGJvcl9yYWRpaSwgcGl4ZWxsZW5ndGggKiAxLjUsIDIgLSBwaXhlbGxlbmd0aCAqIDEuNSk7CgkJZmxvYXQyIHNwYWNpbmcgPSAyIC0gcmFkaWkgLSBuZWlnaGJvcl9yYWRpaTsKCQlmbG9hdDIgZXh0cmFfcGFkID0gbWF4KHBpeGVsbGVuZ3RoICogLjA2MjUgLSBzcGFjaW5nLCBmbG9hdDIoMCkpOwoJCXJhZGlpIC09IGV4dHJhX3BhZCAqIC41OwoJfQoJZmxvYXQyIGFhX291dHNldCA9IGFhX2Jsb2F0X2RpcmVjdGlvbiAqIGFhX2Jsb2F0cmFkaXVzICogYWFfYmxvYXRfbXVsdGlwbGllcjsKCWZsb2F0MiB2ZXJ0ZXhwb3MgPSBjb3JuZXIgKyByYWRpdXNfb3V0c2V0ICogcmFkaWkgKyBhYV9vdXRzZXQ7CglpZiAoY292ZXJhZ2UgPiAuNSkgCgl7CgkJaWYgKGFhX2Jsb2F0X2RpcmVjdGlvbi54ICE9IDAgJiYgdmVydGV4cG9zLnggKiBjb3JuZXIueCA8IDApIAoJCXsKCQkJZmxvYXQgYmFja3NldCA9IGFicyh2ZXJ0ZXhwb3MueCk7CgkJCXZlcnRleHBvcy54ID0gMDsKCQkJdmVydGV4cG9zLnkgKz0gYmFja3NldCAqIHNpZ24oY29ybmVyLnkpICogcGl4ZWxsZW5ndGgueS9waXhlbGxlbmd0aC54OwoJCQljb3ZlcmFnZSA9IChjb3ZlcmFnZSAtIC41KSAqIGFicyhjb3JuZXIueCkgLyAoYWJzKGNvcm5lci54KSArIGJhY2tzZXQpICsgLjU7CgkJfQoJCWlmIChhYV9ibG9hdF9kaXJlY3Rpb24ueSAhPSAwICYmIHZlcnRleHBvcy55ICogY29ybmVyLnkgPCAwKSAKCQl7CgkJCWZsb2F0IGJhY2tzZXQgPSBhYnModmVydGV4cG9zLnkpOwoJCQl2ZXJ0ZXhwb3MueSA9IDA7CgkJCXZlcnRleHBvcy54ICs9IGJhY2tzZXQgKiBzaWduKGNvcm5lci54KSAqIHBpeGVsbGVuZ3RoLngvcGl4ZWxsZW5ndGgueTsKCQkJY292ZXJhZ2UgPSAoY292ZXJhZ2UgLSAuNSkgKiBhYnMoY29ybmVyLnkpIC8gKGFicyhjb3JuZXIueSkgKyBiYWNrc2V0KSArIC41OwoJCX0KCX0KCWZsb2F0MngyIHNrZXdtYXRyaXggPSBmbG9hdDJ4Mihza2V3Lnh5LCBza2V3Lnp3KTsKCWZsb2F0MiBkZXZjb29yZCA9IHZlcnRleHBvcyAqIHNrZXdtYXRyaXggKyB0cmFuc2xhdGVfYW5kX2xvY2Fscm90YXRlLnh5OwoJaWYgKDAgIT0gaXNfbGluZWFyX2NvdmVyYWdlKSAKCXsKCQl2YXJjY29vcmRfUzAueHkgPSBmbG9hdDIoMCwgY292ZXJhZ2UgKiBjb3ZlcmFnZV9tdWx0aXBsaWVyKTsKCX0KCWVsc2UgCgl7CgkJZmxvYXQyIGFyY2Nvb3JkID0gMSAtIGFicyhyYWRpdXNfb3V0c2V0KSArIGFhX291dHNldC9yYWRpaSAqIGNvcm5lcjsKCQl2YXJjY29vcmRfUzAueHkgPSBmbG9hdDIoYXJjY29vcmQueCsxLCBhcmNjb29yZC55KTsKCX0KCXNrX1Bvc2l0aW9uID0gZGV2Y29vcmQueHkwMTsKfQoAAAAAAADLAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gZmxvYXQyIHZhcmNjb29yZF9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIEZpbGxSUmVjdE9wOjpQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2Y29sb3JfUzA7CglmbG9hdCB4X3BsdXNfMT12YXJjY29vcmRfUzAueCwgeT12YXJjY29vcmRfUzAueTsKCWhhbGYgY292ZXJhZ2U7CglpZiAoMCA9PSB4X3BsdXNfMSkgCgl7CgkJY292ZXJhZ2UgPSBoYWxmKHkpOwoJfQoJZWxzZSAKCXsKCQlmbG9hdCBmbiA9IHhfcGx1c18xICogKHhfcGx1c18xIC0gMik7CgkJZm4gPSBmbWEoeSx5LCBmbik7CgkJZmxvYXQgZm53aWR0aCA9IGZ3aWR0aChmbik7CgkJY292ZXJhZ2UgPSAuNSAtIGhhbGYoZm4vZm53aWR0aCk7CgkJY292ZXJhZ2UgPSBjbGFtcChjb3ZlcmFnZSwgMCwgMSk7Cgl9CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGNvdmVyYWdlKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAQAAAAIAAAADAAAAHwAAAAAAAAABAAAAHwAAABAAAAABAAAAHwAAACAAAAABAAAAMAAAAAUAAAAfAAAAAAAAAAIAAAAfAAAAEAAAAAIAAAAfAAAAIAAAAAIAAAAdAAAAMAAAAAIAAAAJAAAAOAAAAAIAAAA8AAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","FABQMYAAMAAAEADAAABAEYAAAICIACWAABQAAAQAMAAAEATAAABAIYAAAIDGAAACBAQOEAQKAAAAAAFAGLAIDZFAJ4AAAACAQF7UMBYAAAAABITF56OQIAAAQAAQAAAATQEU3MJAAAAAB5F3UTQACAAAAAAAACAAAAAMRCAC76GA4AAAAAAEJS66HMEQAAAAAMAAAABYCONGEQIAAAAOQ52JYEBQAAAABAAAAAEQCGEJNPLXCIAAAAAGAAAAA4BGGTCYEAAAADIO7EUCA4AAAABAAAAAAIEDTQEU3MJAAAAAAAAAAAAKYSF7JMFB4AAAABAAAAAAQAGPLO5E4AAQAAAAAAAAAAFMEAAEAAAAAAAA2AIRAEAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"CgAAAExTS1NjDwAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1c3RhcnRfUzFfYzBfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTI0KSBoYWxmNCB1ZW5kX1MxX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD0zMikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMF9jMF9jMTsKCWxheW91dChvZmZzZXQ9ODApIGhhbGY0IHVsZWZ0Qm9yZGVyQ29sb3JfUzFfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTg4KSBoYWxmNCB1cmlnaHRCb3JkZXJDb2xvcl9TMV9jMF9jMDsKCWxheW91dChvZmZzZXQ9OTYpIGZsb2F0M3gzIHVtYXRyaXhfUzFfYzE7CglsYXlvdXQob2Zmc2V0PTE0NCkgaGFsZiB1cmFuZ2VfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDQgcmFkaWlfc2VsZWN0b3I7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGZsb2F0NCBjb3JuZXJfYW5kX3JhZGl1c19vdXRzZXRzOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiBmbG9hdDQgYWFfYmxvYXRfYW5kX2NvdmVyYWdlOwpsYXlvdXQobG9jYXRpb24gPSAzKSBpbiBmbG9hdDQgcmFkaWlfeDsKbGF5b3V0KGxvY2F0aW9uID0gNCkgaW4gZmxvYXQ0IHJhZGlpX3k7CmxheW91dChsb2NhdGlvbiA9IDUpIGluIGZsb2F0NCBza2V3OwpsYXlvdXQobG9jYXRpb24gPSA2KSBpbiBmbG9hdDQgdHJhbnNsYXRlX2FuZF9sb2NhbHJvdGF0ZTsKbGF5b3V0KGxvY2F0aW9uID0gNykgaW4gZmxvYXQ0IGxvY2FscmVjdDsKbGF5b3V0KGxvY2F0aW9uID0gOCkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgb3V0IGhhbGY0IHZjb2xvcl9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGZsb2F0MiB2YXJjY29vcmRfUzA7CmxheW91dChsb2NhdGlvbiA9IDIpIG91dCBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzZfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIEZpbGxSUmVjdE9wOjpQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJZmxvYXQgYWFfYmxvYXRfbXVsdGlwbGllciA9IDE7CglmbG9hdDIgY29ybmVyID0gY29ybmVyX2FuZF9yYWRpdXNfb3V0c2V0cy54eTsKCWZsb2F0MiByYWRpdXNfb3V0c2V0ID0gY29ybmVyX2FuZF9yYWRpdXNfb3V0c2V0cy56dzsKCWZsb2F0MiBhYV9ibG9hdF9kaXJlY3Rpb24gPSBhYV9ibG9hdF9hbmRfY292ZXJhZ2UueHk7CglmbG9hdCBpc19saW5lYXJfY292ZXJhZ2UgPSBhYV9ibG9hdF9hbmRfY292ZXJhZ2UudzsKCWZsb2F0MiBwaXhlbGxlbmd0aCA9IGludmVyc2VzcXJ0KGZsb2F0Mihkb3Qoc2tldy54eiwgc2tldy54eiksIGRvdChza2V3Lnl3LCBza2V3Lnl3KSkpOwoJZmxvYXQ0IG5vcm1hbGl6ZWRfYXhpc19kaXJzID0gc2tldyAqIHBpeGVsbGVuZ3RoLnh5eHk7CglmbG9hdDIgYXhpc3dpZHRocyA9IChhYnMobm9ybWFsaXplZF9heGlzX2RpcnMueHkpICsgYWJzKG5vcm1hbGl6ZWRfYXhpc19kaXJzLnp3KSk7CglmbG9hdDIgYWFfYmxvYXRyYWRpdXMgPSBheGlzd2lkdGhzICogcGl4ZWxsZW5ndGggKiAuNTsKCWZsb2F0NCByYWRpaV9hbmRfbmVpZ2hib3JzID0gcmFkaWlfc2VsZWN0b3IqIGZsb2F0NHg0KHJhZGlpX3gsIHJhZGlpX3ksIHJhZGlpX3gueXh3eiwgcmFkaWlfeS53enl4KTsKCWZsb2F0MiByYWRpaSA9IHJhZGlpX2FuZF9uZWlnaGJvcnMueHk7CglmbG9hdDIgbmVpZ2hib3JfcmFkaWkgPSByYWRpaV9hbmRfbmVpZ2hib3JzLnp3OwoJZmxvYXQgY292ZXJhZ2VfbXVsdGlwbGllciA9IDE7CglpZiAoYW55KGdyZWF0ZXJUaGFuKGFhX2Jsb2F0cmFkaXVzLCBmbG9hdDIoMSkpKSkgCgl7CgkJY29ybmVyID0gbWF4KGFicyhjb3JuZXIpLCBhYV9ibG9hdHJhZGl1cykgKiBzaWduKGNvcm5lcik7CgkJY292ZXJhZ2VfbXVsdGlwbGllciA9IDEgLyAobWF4KGFhX2Jsb2F0cmFkaXVzLngsIDEpICogbWF4KGFhX2Jsb2F0cmFkaXVzLnksIDEpKTsKCQlyYWRpaSA9IGZsb2F0MigwKTsKCX0KCWZsb2F0IGNvdmVyYWdlID0gYWFfYmxvYXRfYW5kX2NvdmVyYWdlLno7CglpZiAoYW55KGxlc3NUaGFuKHJhZGlpLCBhYV9ibG9hdHJhZGl1cyAqIDEuNSkpKSAKCXsKCQlyYWRpaSA9IGZsb2F0MigwKTsKCQlhYV9ibG9hdF9kaXJlY3Rpb24gPSBzaWduKGNvcm5lcik7CgkJaWYgKGNvdmVyYWdlID4gLjUpIAoJCXsKCQkJYWFfYmxvYXRfZGlyZWN0aW9uID0gLWFhX2Jsb2F0X2RpcmVjdGlvbjsKCQl9CgkJaXNfbGluZWFyX2NvdmVyYWdlID0gMTsKCX0KCWVsc2UgCgl7CgkJcmFkaWkgPSBjbGFtcChyYWRpaSwgcGl4ZWxsZW5ndGggKiAxLjUsIDIgLSBwaXhlbGxlbmd0aCAqIDEuNSk7CgkJbmVpZ2hib3JfcmFkaWkgPSBjbGFtcChuZWlnaGJvcl9yYWRpaSwgcGl4ZWxsZW5ndGggKiAxLjUsIDIgLSBwaXhlbGxlbmd0aCAqIDEuNSk7CgkJZmxvYXQyIHNwYWNpbmcgPSAyIC0gcmFkaWkgLSBuZWlnaGJvcl9yYWRpaTsKCQlmbG9hdDIgZXh0cmFfcGFkID0gbWF4KHBpeGVsbGVuZ3RoICogLjA2MjUgLSBzcGFjaW5nLCBmbG9hdDIoMCkpOwoJCXJhZGlpIC09IGV4dHJhX3BhZCAqIC41OwoJfQoJZmxvYXQyIGFhX291dHNldCA9IGFhX2Jsb2F0X2RpcmVjdGlvbiAqIGFhX2Jsb2F0cmFkaXVzICogYWFfYmxvYXRfbXVsdGlwbGllcjsKCWZsb2F0MiB2ZXJ0ZXhwb3MgPSBjb3JuZXIgKyByYWRpdXNfb3V0c2V0ICogcmFkaWkgKyBhYV9vdXRzZXQ7CglpZiAoY292ZXJhZ2UgPiAuNSkgCgl7CgkJaWYgKGFhX2Jsb2F0X2RpcmVjdGlvbi54ICE9IDAgJiYgdmVydGV4cG9zLnggKiBjb3JuZXIueCA8IDApIAoJCXsKCQkJZmxvYXQgYmFja3NldCA9IGFicyh2ZXJ0ZXhwb3MueCk7CgkJCXZlcnRleHBvcy54ID0gMDsKCQkJdmVydGV4cG9zLnkgKz0gYmFja3NldCAqIHNpZ24oY29ybmVyLnkpICogcGl4ZWxsZW5ndGgueS9waXhlbGxlbmd0aC54OwoJCQljb3ZlcmFnZSA9IChjb3ZlcmFnZSAtIC41KSAqIGFicyhjb3JuZXIueCkgLyAoYWJzKGNvcm5lci54KSArIGJhY2tzZXQpICsgLjU7CgkJfQoJCWlmIChhYV9ibG9hdF9kaXJlY3Rpb24ueSAhPSAwICYmIHZlcnRleHBvcy55ICogY29ybmVyLnkgPCAwKSAKCQl7CgkJCWZsb2F0IGJhY2tzZXQgPSBhYnModmVydGV4cG9zLnkpOwoJCQl2ZXJ0ZXhwb3MueSA9IDA7CgkJCXZlcnRleHBvcy54ICs9IGJhY2tzZXQgKiBzaWduKGNvcm5lci54KSAqIHBpeGVsbGVuZ3RoLngvcGl4ZWxsZW5ndGgueTsKCQkJY292ZXJhZ2UgPSAoY292ZXJhZ2UgLSAuNSkgKiBhYnMoY29ybmVyLnkpIC8gKGFicyhjb3JuZXIueSkgKyBiYWNrc2V0KSArIC41OwoJCX0KCX0KCWZsb2F0MngyIHNrZXdtYXRyaXggPSBmbG9hdDJ4Mihza2V3Lnh5LCBza2V3Lnp3KTsKCWZsb2F0MiBkZXZjb29yZCA9IHZlcnRleHBvcyAqIHNrZXdtYXRyaXggKyB0cmFuc2xhdGVfYW5kX2xvY2Fscm90YXRlLnh5OwoJZmxvYXQyIFQgPSB2ZXJ0ZXhwb3MgKiAuNSArIC41OwoJZmxvYXQyIGxvY2FsY29vcmQgPSBsb2NhbHJlY3QueHkgKiAoMSAtIFQpICsgbG9jYWxyZWN0Lnp3ICogVCArIHRyYW5zbGF0ZV9hbmRfbG9jYWxyb3RhdGUuencgKiBULnl4OwoJaWYgKDAgIT0gaXNfbGluZWFyX2NvdmVyYWdlKSAKCXsKCQl2YXJjY29vcmRfUzAueHkgPSBmbG9hdDIoMCwgY292ZXJhZ2UgKiBjb3ZlcmFnZV9tdWx0aXBsaWVyKTsKCX0KCWVsc2UgCgl7CgkJZmxvYXQyIGFyY2Nvb3JkID0gMSAtIGFicyhyYWRpdXNfb3V0c2V0KSArIGFhX291dHNldC9yYWRpaSAqIGNvcm5lcjsKCQl2YXJjY29vcmRfUzAueHkgPSBmbG9hdDIoYXJjY29vcmQueCsxLCBhcmNjb29yZC55KTsKCX0KCXNrX1Bvc2l0aW9uID0gZGV2Y29vcmQueHkwMTsKCXsKCQl2VHJhbnNmb3JtZWRDb29yZHNfNl9TMCA9IGZsb2F0M3gyKHVtYXRyaXhfUzFfYzBfYzBfYzEpICogbG9jYWxjb29yZC54eTE7Cgl9Cn0KAAAAAABbCwAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGhhbGY0IHVzdGFydF9TMV9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9MjQpIGhhbGY0IHVlbmRfUzFfYzBfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTMyKSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwX2MwX2MxOwoJbGF5b3V0KG9mZnNldD04MCkgaGFsZjQgdWxlZnRCb3JkZXJDb2xvcl9TMV9jMF9jMDsKCWxheW91dChvZmZzZXQ9ODgpIGhhbGY0IHVyaWdodEJvcmRlckNvbG9yX1MxX2MwX2MwOwoJbGF5b3V0KG9mZnNldD05NikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMTsKCWxheW91dChvZmZzZXQ9MTQ0KSBoYWxmIHVyYW5nZV9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgaW4gaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgdmFyY2Nvb3JkX1MwOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzZfUzA7CmhhbGY0IFNpbmdsZUludGVydmFsQ29sb3JpemVyX1MxX2MwX2MwX2MwKGhhbGY0IF9pbnB1dCwgZmxvYXQyIF9jb29yZHMpIAp7CgloYWxmNCBfdG1wXzBfaW5Db2xvciA9IF9pbnB1dDsKCWZsb2F0MiBfdG1wXzFfY29vcmRzID0gX2Nvb3JkczsKCXJldHVybiBoYWxmNChtaXgodXN0YXJ0X1MxX2MwX2MwX2MwLCB1ZW5kX1MxX2MwX2MwX2MwLCBoYWxmKF90bXBfMV9jb29yZHMueCkpKTsKfQpoYWxmNCBMaW5lYXJMYXlvdXRfUzFfYzBfYzBfYzFfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgX3RtcF8yX2luQ29sb3IgPSBfaW5wdXQ7CglmbG9hdDIgX3RtcF8zX2Nvb3JkcyA9IHZUcmFuc2Zvcm1lZENvb3Jkc182X1MwOwoJcmV0dXJuIGhhbGY0KGhhbGY0KGhhbGYoX3RtcF8zX2Nvb3Jkcy54KSArIDFlLTA1LCAxLjAsIDAuMCwgMC4wKSk7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxX2MwX2MwX2MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBMaW5lYXJMYXlvdXRfUzFfYzBfYzBfYzFfYzAoX2lucHV0KTsKfQpoYWxmNCBDbGFtcGVkR3JhZGllbnRfUzFfYzBfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgX3RtcF80X2luQ29sb3IgPSBfaW5wdXQ7CgloYWxmNCB0ID0gTWF0cml4RWZmZWN0X1MxX2MwX2MwX2MxKF90bXBfNF9pbkNvbG9yKTsKCWhhbGY0IG91dENvbG9yOwoJaWYgKCFib29sKGludCgxKSkgJiYgdC55IDwgMC4wKSAKCXsKCQlvdXRDb2xvciA9IGhhbGY0KDAuMCk7Cgl9CgllbHNlIGlmICh0LnggPCAwLjApIAoJewoJCW91dENvbG9yID0gdWxlZnRCb3JkZXJDb2xvcl9TMV9jMF9jMDsKCX0KCWVsc2UgaWYgKHQueCA+IDEuMCkgCgl7CgkJb3V0Q29sb3IgPSB1cmlnaHRCb3JkZXJDb2xvcl9TMV9jMF9jMDsKCX0KCWVsc2UgCgl7CgkJb3V0Q29sb3IgPSBTaW5nbGVJbnRlcnZhbENvbG9yaXplcl9TMV9jMF9jMF9jMChfdG1wXzRfaW5Db2xvciwgZmxvYXQyKGhhbGYyKHQueCwgMC4wKSkpOwoJfQoJcmV0dXJuIGhhbGY0KG91dENvbG9yKTsKfQpoYWxmNCBEaXNhYmxlQ292ZXJhZ2VBc0FscGhhX1MxX2MwKGhhbGY0IF9pbnB1dCkgCnsKCV9pbnB1dCA9IENsYW1wZWRHcmFkaWVudF9TMV9jMF9jMChfaW5wdXQpOwoJaGFsZjQgX3RtcF81X2luQ29sb3IgPSBfaW5wdXQ7CglyZXR1cm4gaGFsZjQoX2lucHV0KTsKfQpoYWxmNCBUZXh0dXJlRWZmZWN0X1MxX2MxX2MwKGhhbGY0IF9pbnB1dCwgZmxvYXQyIF9jb29yZHMpIAp7CglyZXR1cm4gc2FtcGxlKHVUZXh0dXJlU2FtcGxlcl8wX1MxLCBfY29vcmRzKS4wMDByOwp9CmhhbGY0IE1hdHJpeEVmZmVjdF9TMV9jMShoYWxmNCBfaW5wdXQsIGZsb2F0MiBfY29vcmRzKSAKewoJcmV0dXJuIFRleHR1cmVFZmZlY3RfUzFfYzFfYzAoX2lucHV0LCBmbG9hdDN4Mih1bWF0cml4X1MxX2MxKSAqIF9jb29yZHMueHkxKTsKfQpoYWxmNCBEaXRoZXJfUzEoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgX3RtcF82X2luQ29sb3IgPSBfaW5wdXQ7CgloYWxmNCBjb2xvciA9IERpc2FibGVDb3ZlcmFnZUFzQWxwaGFfUzFfYzAoX3RtcF82X2luQ29sb3IpOwoJaGFsZiB2YWx1ZSA9IE1hdHJpeEVmZmVjdF9TMV9jMShfdG1wXzZfaW5Db2xvciwgc2tfRnJhZ0Nvb3JkLnh5KS53IC0gMC41OwoJcmV0dXJuIGhhbGY0KGhhbGY0KGNsYW1wKGNvbG9yLnh5eiArIHZhbHVlICogdXJhbmdlX1MxLCAwLjAsIGNvbG9yLncpLCBjb2xvci53KSk7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIEZpbGxSUmVjdE9wOjpQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2Y29sb3JfUzA7CglmbG9hdCB4X3BsdXNfMT12YXJjY29vcmRfUzAueCwgeT12YXJjY29vcmRfUzAueTsKCWhhbGYgY292ZXJhZ2U7CglpZiAoMCA9PSB4X3BsdXNfMSkgCgl7CgkJY292ZXJhZ2UgPSBoYWxmKHkpOwoJfQoJZWxzZSAKCXsKCQlmbG9hdCBmbiA9IHhfcGx1c18xICogKHhfcGx1c18xIC0gMik7CgkJZm4gPSBmbWEoeSx5LCBmbik7CgkJZmxvYXQgZm53aWR0aCA9IGZ3aWR0aChmbik7CgkJY292ZXJhZ2UgPSAuNSAtIGhhbGYoZm4vZm53aWR0aCk7CgkJY292ZXJhZ2UgPSBjbGFtcChjb3ZlcmFnZSwgMCwgMSk7Cgl9CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGNvdmVyYWdlKTsKCWhhbGY0IG91dHB1dF9TMTsKCW91dHB1dF9TMSA9IERpdGhlcl9TMShvdXRwdXRDb2xvcl9TMCk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0X1MxICogb3V0cHV0Q292ZXJhZ2VfUzA7Cgl9Cn0KAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKwAAAABAAAAAgAAAAMAAAAfAAAAAAAAAAEAAAAfAAAAEAAAAAEAAAAfAAAAIAAAAAEAAAAwAAAABgAAAB8AAAAAAAAAAgAAAB8AAAAQAAAAAgAAAB8AAAAgAAAAAgAAAB8AAAAwAAAAAgAAAB8AAABAAAAAAgAAAAkAAABQAAAAAgAAAFQAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","B3IBQAAADAAAIAABBYAAAEIXBAAACDQMAAABIFAAAAAAAAAAAAAABFQBBYSAO7ICAAAAACX4GM5AAAAAAAIAAAAACAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAAAAAAQAAAAAEARQUPBT7IAAAAAACAAAAAAQFU5S6ZGAAAAAYAAAAAYCEOGAEGBAAAAAH5FYUXQAAAAAAACAAAAAMQEAIAAAANDMXXJYBAAAGAAAAAAABDRYBRQIQAAAAPJO5E4AAQAAAAAQAAAAGIBBCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAABAAAAAAIEDIYOAOMCEAAAAAAAAAAAFREL6S4KDYAAAACAAAAAAAAM6U52JYEBQAAAAAAAAAACYIEAIAAAAAAABUARCAIAAAAAAAAAAAGEAAYAABABIFANSWCQAACAAAAAAAACAAAAAMQSAVSWGRIBAAABAAAAAAAAAAAAAAAA5AAAAAAABAAAAACAZAAAAAACQAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEAAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAAAHUAAAAABABLFMNCQCAAAKAAAAACADYAABAAAAAAIBDCEIHMVQUIAAAABIAAAAAAAAAAAOAQHSAAAAAAQAAAAAA5AAAAAAABAAAAACAZAAACQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEBAAAAAAAAA":"CgAAAExTS1PpAwAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1c3RhcnRfUzFfYzBfYzBfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTI0KSBoYWxmNCB1ZW5kX1MxX2MwX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD0zMikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMF9jMF9jMF9jMTsKCWxheW91dChvZmZzZXQ9ODApIGhhbGY0IHVsZWZ0Qm9yZGVyQ29sb3JfUzFfYzBfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTg4KSBoYWxmNCB1cmlnaHRCb3JkZXJDb2xvcl9TMV9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9OTYpIGZsb2F0M3gzIHVtYXRyaXhfUzFfYzE7CglsYXlvdXQob2Zmc2V0PTE0NCkgaGFsZiB1cmFuZ2VfUzE7CglsYXlvdXQob2Zmc2V0PTE2MCkgZmxvYXQ0IHVyZWN0VW5pZm9ybV9TMl9jMDsKCWxheW91dChvZmZzZXQ9MTc2KSBmbG9hdDQgdWlubmVyUmVjdF9TMl9jMTsKCWxheW91dChvZmZzZXQ9MTkyKSBoYWxmMiB1cmFkaXVzUGx1c0hhbGZfUzJfYzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgZmxhdCBvdXQgaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgZmxvYXQyIHZUcmFuc2Zvcm1lZENvb3Jkc183X1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwoJewoJCXZUcmFuc2Zvcm1lZENvb3Jkc183X1MwID0gZmxvYXQzeDIodW1hdHJpeF9TMV9jMF9jMF9jMF9jMSkgKiBsb2NhbENvb3JkLnh5MTsKCX0KfQoAAAAAAAAAQxAAAGNvbnN0IGludCBrRmlsbEJXX1MyX2MwID0gMDsKY29uc3QgaW50IGtJbnZlcnNlRmlsbEJXX1MyX2MwID0gMjsKY29uc3QgaW50IGtJbnZlcnNlRmlsbEFBX1MyX2MwID0gMzsKbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGhhbGY0IHVzdGFydF9TMV9jMF9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9MjQpIGhhbGY0IHVlbmRfUzFfYzBfYzBfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTMyKSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwX2MwX2MwX2MxOwoJbGF5b3V0KG9mZnNldD04MCkgaGFsZjQgdWxlZnRCb3JkZXJDb2xvcl9TMV9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9ODgpIGhhbGY0IHVyaWdodEJvcmRlckNvbG9yX1MxX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD05NikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMTsKCWxheW91dChvZmZzZXQ9MTQ0KSBoYWxmIHVyYW5nZV9TMTsKCWxheW91dChvZmZzZXQ9MTYwKSBmbG9hdDQgdXJlY3RVbmlmb3JtX1MyX2MwOwoJbGF5b3V0KG9mZnNldD0xNzYpIGZsb2F0NCB1aW5uZXJSZWN0X1MyX2MxOwoJbGF5b3V0KG9mZnNldD0xOTIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMl9jMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgaW4gaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzdfUzA7CmhhbGY0IFNpbmdsZUludGVydmFsQ29sb3JpemVyX1MxX2MwX2MwX2MwX2MwKGhhbGY0IF9pbnB1dCwgZmxvYXQyIF9jb29yZHMpIAp7CgloYWxmNCBfdG1wXzBfaW5Db2xvciA9IF9pbnB1dDsKCWZsb2F0MiBfdG1wXzFfY29vcmRzID0gX2Nvb3JkczsKCXJldHVybiBoYWxmNChtaXgodXN0YXJ0X1MxX2MwX2MwX2MwX2MwLCB1ZW5kX1MxX2MwX2MwX2MwX2MwLCBoYWxmKF90bXBfMV9jb29yZHMueCkpKTsKfQpoYWxmNCBMaW5lYXJMYXlvdXRfUzFfYzBfYzBfYzBfYzFfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgX3RtcF8yX2luQ29sb3IgPSBfaW5wdXQ7CglmbG9hdDIgX3RtcF8zX2Nvb3JkcyA9IHZUcmFuc2Zvcm1lZENvb3Jkc183X1MwOwoJcmV0dXJuIGhhbGY0KGhhbGY0KGhhbGYoX3RtcF8zX2Nvb3Jkcy54KSArIDFlLTA1LCAxLjAsIDAuMCwgMC4wKSk7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxX2MwX2MwX2MwX2MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBMaW5lYXJMYXlvdXRfUzFfYzBfYzBfYzBfYzFfYzAoX2lucHV0KTsKfQpoYWxmNCBDbGFtcGVkR3JhZGllbnRfUzFfYzBfYzBfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgX3RtcF80X2luQ29sb3IgPSBfaW5wdXQ7CgloYWxmNCB0ID0gTWF0cml4RWZmZWN0X1MxX2MwX2MwX2MwX2MxKF90bXBfNF9pbkNvbG9yKTsKCWhhbGY0IG91dENvbG9yOwoJaWYgKCFib29sKGludCgxKSkgJiYgdC55IDwgMC4wKSAKCXsKCQlvdXRDb2xvciA9IGhhbGY0KDAuMCk7Cgl9CgllbHNlIGlmICh0LnggPCAwLjApIAoJewoJCW91dENvbG9yID0gdWxlZnRCb3JkZXJDb2xvcl9TMV9jMF9jMF9jMDsKCX0KCWVsc2UgaWYgKHQueCA+IDEuMCkgCgl7CgkJb3V0Q29sb3IgPSB1cmlnaHRCb3JkZXJDb2xvcl9TMV9jMF9jMF9jMDsKCX0KCWVsc2UgCgl7CgkJb3V0Q29sb3IgPSBTaW5nbGVJbnRlcnZhbENvbG9yaXplcl9TMV9jMF9jMF9jMF9jMChfdG1wXzRfaW5Db2xvciwgZmxvYXQyKGhhbGYyKHQueCwgMC4wKSkpOwoJfQoJcmV0dXJuIGhhbGY0KG91dENvbG9yKTsKfQpoYWxmNCBjb2xvcl94Zm9ybV9TMV9jMF9jMChoYWxmNCBjb2xvcikgCnsKCWNvbG9yLnJnYiAqPSBjb2xvci5hOwoJcmV0dXJuIGhhbGY0KGNvbG9yKTsKfQpoYWxmNCBDb2xvclNwYWNlWGZvcm1fUzFfYzBfYzAoaGFsZjQgX2lucHV0KSAKewoJcmV0dXJuIGNvbG9yX3hmb3JtX1MxX2MwX2MwKENsYW1wZWRHcmFkaWVudF9TMV9jMF9jMF9jMChfaW5wdXQpKTsKfQpoYWxmNCBEaXNhYmxlQ292ZXJhZ2VBc0FscGhhX1MxX2MwKGhhbGY0IF9pbnB1dCkgCnsKCV9pbnB1dCA9IENvbG9yU3BhY2VYZm9ybV9TMV9jMF9jMChfaW5wdXQpOwoJaGFsZjQgX3RtcF81X2luQ29sb3IgPSBfaW5wdXQ7CglyZXR1cm4gaGFsZjQoX2lucHV0KTsKfQpoYWxmNCBUZXh0dXJlRWZmZWN0X1MxX2MxX2MwKGhhbGY0IF9pbnB1dCwgZmxvYXQyIF9jb29yZHMpIAp7CglyZXR1cm4gc2FtcGxlKHVUZXh0dXJlU2FtcGxlcl8wX1MxLCBfY29vcmRzKS4wMDByOwp9CmhhbGY0IE1hdHJpeEVmZmVjdF9TMV9jMShoYWxmNCBfaW5wdXQsIGZsb2F0MiBfY29vcmRzKSAKewoJcmV0dXJuIFRleHR1cmVFZmZlY3RfUzFfYzFfYzAoX2lucHV0LCBmbG9hdDN4Mih1bWF0cml4X1MxX2MxKSAqIF9jb29yZHMueHkxKTsKfQpoYWxmNCBEaXRoZXJfUzEoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgX3RtcF82X2luQ29sb3IgPSBfaW5wdXQ7CgloYWxmNCBjb2xvciA9IERpc2FibGVDb3ZlcmFnZUFzQWxwaGFfUzFfYzAoX3RtcF82X2luQ29sb3IpOwoJaGFsZiB2YWx1ZSA9IE1hdHJpeEVmZmVjdF9TMV9jMShfdG1wXzZfaW5Db2xvciwgc2tfRnJhZ0Nvb3JkLnh5KS53IC0gMC41OwoJcmV0dXJuIGhhbGY0KGhhbGY0KGNsYW1wKGNvbG9yLnh5eiArIHZhbHVlICogdXJhbmdlX1MxLCAwLjAsIGNvbG9yLncpLCBjb2xvci53KSk7Cn0KaGFsZjQgUmVjdF9TMl9jMChoYWxmNCBfaW5wdXQpIAp7CgloYWxmNCBfdG1wXzdfaW5Db2xvciA9IF9pbnB1dDsKCWhhbGYgY292ZXJhZ2U7CglpZiAoaW50KDIpID09IGtGaWxsQldfUzJfYzAgfHwgaW50KDIpID09IGtJbnZlcnNlRmlsbEJXX1MyX2MwKSAKCXsKCQljb3ZlcmFnZSA9IGhhbGYoYWxsKGdyZWF0ZXJUaGFuKGZsb2F0NChza19GcmFnQ29vcmQueHksIHVyZWN0VW5pZm9ybV9TMl9jMC56dyksIGZsb2F0NCh1cmVjdFVuaWZvcm1fUzJfYzAueHksIHNrX0ZyYWdDb29yZC54eSkpKSk7Cgl9CgllbHNlIAoJewoJCWhhbGY0IGRpc3RzNCA9IHNhdHVyYXRlKGhhbGY0KDEuMCwgMS4wLCAtMS4wLCAtMS4wKSAqIGhhbGY0KHNrX0ZyYWdDb29yZC54eXh5IC0gdXJlY3RVbmlmb3JtX1MyX2MwKSk7CgkJaGFsZjIgZGlzdHMyID0gKGRpc3RzNC54eSArIGRpc3RzNC56dykgLSAxLjA7CgkJY292ZXJhZ2UgPSBkaXN0czIueCAqIGRpc3RzMi55OwoJfQoJaWYgKGludCgyKSA9PSBrSW52ZXJzZUZpbGxCV19TMl9jMCB8fCBpbnQoMikgPT0ga0ludmVyc2VGaWxsQUFfUzJfYzApIAoJewoJCWNvdmVyYWdlID0gMS4wIC0gY292ZXJhZ2U7Cgl9CglyZXR1cm4gaGFsZjQoaGFsZjQoY292ZXJhZ2UpKTsKfQpoYWxmNCBDaXJjdWxhclJSZWN0X1MyX2MxKGhhbGY0IF9pbnB1dCkgCnsKCWZsb2F0MiBkeHkwID0gdWlubmVyUmVjdF9TMl9jMS5MVCAtIHNrX0ZyYWdDb29yZC54eTsKCWZsb2F0MiBkeHkxID0gc2tfRnJhZ0Nvb3JkLnh5IC0gdWlubmVyUmVjdF9TMl9jMS5SQjsKCWZsb2F0MiBkeHkgPSBtYXgobWF4KGR4eTAsIGR4eTEpLCAwLjApOwoJaGFsZiBhbHBoYSA9IGhhbGYoc2F0dXJhdGUodXJhZGl1c1BsdXNIYWxmX1MyX2MxLnggLSBsZW5ndGgoZHh5KSkpOwoJcmV0dXJuIF9pbnB1dCAqIGFscGhhOwp9CmhhbGY0IEJsZW5kX1MyKGhhbGY0IF9zcmMsIGhhbGY0IF9kc3QpIAp7CglyZXR1cm4gYmxlbmRfbW9kdWxhdGUoUmVjdF9TMl9jMChfc3JjKSwgQ2lyY3VsYXJSUmVjdF9TMl9jMShfc3JjKSk7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBEaXRoZXJfUzEob3V0cHV0Q29sb3JfUzApOwoJaGFsZjQgb3V0cHV0X1MyOwoJb3V0cHV0X1MyID0gQmxlbmRfUzIob3V0cHV0Q292ZXJhZ2VfUzAsIGhhbGY0KDEpKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRfUzEgKiBvdXRwdXRfUzI7Cgl9Cn0KAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAABAAAAAAAAAAMAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAdAAAADAAAAAEAAAAUAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HTRQAGAABBYAAAEIXBAAAGEAMAAAAAAAAAAAAAAAWAGHAIBZ5AJQAAAA5C5DCQYAAAAABADI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAAAAEAAAAAZFE5PDAYAIAAAAABITF56OQIAAAQAAQAAAARGWBRHUQAAAAB2DXJHAQGAAAAAEAAAAASAIYRFV5O4JAAAAAAYAAAABEWJRHQQQCAAAKBXZFAUHQAAAAIAAAAACAAYJVSMJ4EEAQAAAAAAAABMBC7UXCS6AAAAAAAAIAAAADFVHPSKBAOAAAAAAAAAAAWCBAAAABAAAAANAEIQCAAAAAAAAAAABQAAGQAAAAKFIDMVQUAAAAAAYAAAAAQAAAADEEQFEURUKQKAAAYAAAAAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAAARQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABZQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDCGAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEAAAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGAAZAADIAAAAFCUBWKYKAAAAAAUAAAAAIAAAABSCICSKI2FIFAAAEAAIAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"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","DAQAAAAAAABGAABAYAAQAIHCAIAYAQUBAEAAAAAAEAAAAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAARQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAABAEAAAABJYQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","AZAA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1N4AgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bG9jYWxNYXRyaXhfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQ0IGluQ2lyY2xlRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0NCB2aW5DaXJjbGVFZGdlX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCgl2aW5DaXJjbGVFZGdlX1MwID0gaW5DaXJjbGVFZGdlOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGZsb2F0M3gyKHVsb2NhbE1hdHJpeF9TMCkgKiBpblBvc2l0aW9uLnh5MTsKCXNrX1Bvc2l0aW9uID0gX3RtcF8wX2luUG9zaXRpb24ueHkwMTsKfQoAAAAAnQIAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQzeDMgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAABAAAAAAAAAAMAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAfAAAADAAAAAEAAAAcAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","DAQAAAAAAABGAABAYAAQAIHCAIAYAQUBAEAAAAAAEAAAAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"CgAAAExTS1PfAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDIgdUF0bGFzU2l6ZUludl9TMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBpblBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBoYWxmNCBpbkNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiB1c2hvcnQyIGluVGV4dHVyZUNvb3JkczsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2VGV4dHVyZUNvb3Jkc19TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgZmxhdCBvdXQgZmxvYXQgdlRleEluZGV4X1MwOwpsYXlvdXQobG9jYXRpb24gPSAyKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIEJpdG1hcFRleHQKCWludCB0ZXhJZHggPSAwOwoJZmxvYXQyIHVub3JtVGV4Q29vcmRzID0gZmxvYXQyKGluVGV4dHVyZUNvb3Jkcy54LCBpblRleHR1cmVDb29yZHMueSk7Cgl2VGV4dHVyZUNvb3Jkc19TMCA9IHVub3JtVGV4Q29vcmRzICogdUF0bGFzU2l6ZUludl9TMDsKCXZUZXhJbmRleF9TMCA9IGZsb2F0KHRleElkeCk7Cgl2aW5Db2xvcl9TMCA9IGluQ29sb3I7CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJc2tfUG9zaXRpb24gPSBpblBvc2l0aW9uLnh5MDE7Cn0KAAAAAACRAgAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MwOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0MiB1QXRsYXNTaXplSW52X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHZUZXh0dXJlQ29vcmRzX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBmbGF0IGluIGZsb2F0IHZUZXhJbmRleF9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBCaXRtYXBUZXh0CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CgloYWxmNCB0ZXhDb2xvcjsKCXsKCQl0ZXhDb2xvciA9IHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMCwgdlRleHR1cmVDb29yZHNfUzApLnJycnI7Cgl9CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IHRleENvbG9yOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0Q292ZXJhZ2VfUzA7Cgl9Cn0KAAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAEAAAAAAAAAAwAAAB0AAAAAAAAAAQAAAAkAAAAIAAAAAQAAAA0AAAAMAAAAAQAAABAAAAAAAAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADEAANAAAAALHCKLMRAAAAAAAAABAAAAAGJBCFLQVBWAQAAAAAAQAAAAAMACQCAACAAAAA2AIBAEIAAAAAAAAAAAAIADQAAAAIAAAAAAAIIDAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAIBAEAAAABJYQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQFAAAAAAABAEAAAABJKQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","FAAQMYAAMAAAEADAAABAEYAAAICIAB5AABQAAAQAMAAAEATAAABAIIGAAEDCBYQCA4AAAAAAEADZABYAAAIAAAAAACQAGAAAAAQAAAAAAAQQGUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAIAAEAAAABJYQAAAAAQAAIAAAAAWCBACAABAAAAANAECAZAAEAAAAAAAAFAAMAAAABAAAAAAABBANDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAABAEAAAABJYQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAEAQAAAAGQCEIBAACAIAAAAAACQAGAAAAAQAAAAAGBCAIAAAAAFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBQU7BTXIAAAAAACAWXW3ZEQAAAADAAAAADAYRYQAQYEAAAIA7UXCQ6AAAAAQAAAAAAADGAWRWL3E4AQAADAAAAABAARY4AQYEIAAAAPUXKS6AAAAAAAAQAAAADE2CEOGAEGBAAAAAAAAAAAAK6S56JIEBYAAAABAAAAAAQEH7JOFF4AAAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAICAACAAAAAAAA":"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","CIAAAAAAQAARQAAYQAAAAGFYQAABRAAAAEEAAAAAAARAEAEABYAAAAEAAAAAAAEEBQAAAACGAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEBAAAAAAAAA":"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","AY7SRAADQAAAOAEARAFQJAABBADAAAILBYAACCYUAAAQWGUAAEECAAAAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1NOAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZjQgdmNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwp9CgAAAAAAAH0BAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAEABYAAAAEAAAAAAAEEBQAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAEABYAAAAEAAAAAAAEEBQAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAIAAEAAAABJYQAAAAAQAAIAAAAAWCBACAABAAAAANAECAZAAEAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","I4EAAAIAAEHAAAAAAAAAAAAAAAAIQAAAAAAIBEABAAAAACQAAAAAIAAAAD6QAAAAAEAAAAAAAAAAAAQAAAAAAAAAAA":"CgAAAExTS1M2AgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWFmZmluZU1hdHJpeF9TMDsKCWxheW91dChvZmZzZXQ9MzIpIGZsb2F0MiB1dHJhbnNsYXRlX1MwOwoJbGF5b3V0KG9mZnNldD00MCkgaGFsZjQgdWNvbG9yX1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGlucHV0UG9pbnQ7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIHRlc3NlbGxhdGVfU2ltcGxlVHJpYW5nbGVTaGFkZXIKCWZsb2F0MngyIEFGRklORV9NQVRSSVggPSBmbG9hdDJ4Mih1YWZmaW5lTWF0cml4X1MwLnh5LCB1YWZmaW5lTWF0cml4X1MwLnp3KTsKCWZsb2F0MiBUUkFOU0xBVEUgPSB1dHJhbnNsYXRlX1MwOwoJZmxvYXQyIGxvY2FsY29vcmQgPSBpbnB1dFBvaW50OwoJZmxvYXQyIHZlcnRleHBvcyA9IEFGRklORV9NQVRSSVggKiBsb2NhbGNvb3JkICsgVFJBTlNMQVRFOwoJc2tfUG9zaXRpb24gPSB2ZXJ0ZXhwb3MueHkwMTsKfQoAAAAAAACKAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWFmZmluZU1hdHJpeF9TMDsKCWxheW91dChvZmZzZXQ9MzIpIGZsb2F0MiB1dHJhbnNsYXRlX1MwOwoJbGF5b3V0KG9mZnNldD00MCkgaGFsZjQgdWNvbG9yX1MwOwp9CjsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIHRlc3NlbGxhdGVfU2ltcGxlVHJpYW5nbGVTaGFkZXIKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gdWNvbG9yX1MwOwoJY29uc3QgaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNCgxKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogRGlzYWJsZSBDb2xvcgoJfQp9CgAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAEAAAAAAAAAAQAAAB0AAAAAAAAAAQAAAAgAAAAAAAAACgAAAAAAAAAAAAAA/QAAAA=="}}
\ No newline at end of file
+{"platform":"ios","name":"Mark’s iPhone","engineRevision":"b24591ed328a2d4ce6505819e2f5898a78132f7f","data":{"GCAAAAAADAAAEAABBYAAAAYXBAAAAAAAAAAAAAAA2AAQAAAACAAAAAEASAAQAAAAIYAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"CgAAAExTS1PRAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7CglsYXlvdXQob2Zmc2V0PTI0KSBoYWxmIHVDb3ZlcmFnZV9TMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBpblBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBoYWxmNCBpbkhhaXJRdWFkRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGhhbGY0IHZIYWlyUXVhZEVkZ2VfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWQKCXZIYWlyUXVhZEVkZ2VfUzAgPSBpbkhhaXJRdWFkRWRnZTsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247Cglza19Qb3NpdGlvbiA9IF90bXBfMV9pblBvc2l0aW9uLnh5MDE7Cn0KAAAAAAAAAGYDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGhhbGY0IHVDb2xvcl9TMDsKCWxheW91dChvZmZzZXQ9MjQpIGhhbGYgdUNvdmVyYWdlX1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdkhhaXJRdWFkRWRnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWQKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB1Q29sb3JfUzA7CgloYWxmIGVkZ2VBbHBoYTsKCWhhbGYyIGR1dmR4ID0gaGFsZjIoZEZkeCh2SGFpclF1YWRFZGdlX1MwLnh5KSk7CgloYWxmMiBkdXZkeSA9IGhhbGYyKGRGZHkodkhhaXJRdWFkRWRnZV9TMC54eSkpOwoJaGFsZjIgZ0YgPSBoYWxmMigyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeC54IC0gZHV2ZHgueSwgICAgICAgICAgICAgICAyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeS54IC0gZHV2ZHkueSk7CgllZGdlQWxwaGEgPSBoYWxmKHZIYWlyUXVhZEVkZ2VfUzAueCAqIHZIYWlyUXVhZEVkZ2VfUzAueCAtIHZIYWlyUXVhZEVkZ2VfUzAueSk7CgllZGdlQWxwaGEgPSBzcXJ0KGVkZ2VBbHBoYSAqIGVkZ2VBbHBoYSAvIGRvdChnRiwgZ0YpKTsKCWVkZ2VBbHBoYSA9IG1heCgxLjAgLSBlZGdlQWxwaGEsIDAuMCk7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KHVDb3ZlcmFnZV9TMCAqIGVkZ2VBbHBoYSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAfAAAACAAAAAEAAAAYAAAAAAAAAEYAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQKAAAAAAABAEAAAABJUQAAAAAACAIAAAAAWCBAAAIBAAAAANAEIQCAAAAQAAAAAAFAAMAAAABAAAAAAMCEAQFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAMWAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAABYCMNGFQIAAAAHADEHC6BAAAAAAAABAAAAAAIBDBL6DGOQAAAAAAEAAAAABALL354SAAAAABQAAAAHAJRUIUBIBAAAMAMY4LYEAAAAAEAAAAABAIMQAAAAAEBNPNXSJAAAAAGAAAAAMBGOQCQFQEAAAQBTTRPAQAAAAAQAAAAAIBDCAWTWL3EYAAAADAAAAACADHIJJCYCAAAAAZ5YHQIIAAAAAAAIAAAABTZCMNCFAKAIAAAAAAAAAMBCTZQ7BQUAAAAAAAIAAAADEZAZRYXQIAAAAAAAAAAAGABIBAABAAAAANAEIQCAAAAAAAAAAABQAAGQAAAAKFIDMVQUAAAAABIAAAAAQAAAABEERFAUBWKYKAAAIAAQAAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEADZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAIAAAAAAAA":"CgAAAExTS1OpAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgb3V0IGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgl2Y29sb3JfUzAgPSBjb2xvcjsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAAAAAJwMAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQ0IHVpbm5lclJlY3RfUzE7CglsYXlvdXQob2Zmc2V0PTMyKSBoYWxmMiB1cmFkaXVzUGx1c0hhbGZfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKaGFsZjQgQ2lyY3VsYXJSUmVjdF9TMShoYWxmNCBfaW5wdXQpIAp7CglmbG9hdDIgZHh5MCA9IHVpbm5lclJlY3RfUzEuTFQgLSBza19GcmFnQ29vcmQueHk7CglmbG9hdDIgZHh5MSA9IHNrX0ZyYWdDb29yZC54eSAtIHVpbm5lclJlY3RfUzEuUkI7CglmbG9hdDIgZHh5ID0gbWF4KG1heChkeHkwLCBkeHkxKSwgMC4wKTsKCWhhbGYgYWxwaGEgPSBoYWxmKHNhdHVyYXRlKHVyYWRpdXNQbHVzSGFsZl9TMS54IC0gbGVuZ3RoKGR4eSkpKTsKCXJldHVybiBfaW5wdXQgKiBhbHBoYTsKfQp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmNvbG9yX1MwOwoJY29uc3QgaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNCgxKTsKCWhhbGY0IG91dHB1dF9TMTsKCW91dHB1dF9TMSA9IENpcmN1bGFyUlJlY3RfUzEob3V0cHV0Q292ZXJhZ2VfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0X1MxOwoJfQp9CgABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAMGAICAAAAAAAA":"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","AYAA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1MrAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQ0IGluQ2lyY2xlRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0NCB2aW5DaXJjbGVFZGdlX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCgl2aW5DaXJjbGVFZGdlX1MwID0gaW5DaXJjbGVFZGdlOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCWZsb2F0MiBfdG1wXzJfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247Cglza19Qb3NpdGlvbiA9IF90bXBfMF9pblBvc2l0aW9uLnh5MDE7Cn0KAAAAAABwAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJZmxvYXQ0IGNpcmNsZUVkZ2U7CgljaXJjbGVFZGdlID0gdmluQ2lyY2xlRWRnZV9TMDsKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2aW5Db2xvcl9TMDsKCWZsb2F0IGQgPSBsZW5ndGgoY2lyY2xlRWRnZS54eSk7CgloYWxmIGRpc3RhbmNlVG9PdXRlckVkZ2UgPSBoYWxmKGNpcmNsZUVkZ2UueiAqICgxLjAgLSBkKSk7CgloYWxmIGVkZ2VBbHBoYSA9IHNhdHVyYXRlKGRpc3RhbmNlVG9PdXRlckVkZ2UpOwoJaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNChlZGdlQWxwaGEpOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0Q292ZXJhZ2VfUzA7Cgl9Cn0KAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAEAAAAAAAAAAwAAAB0AAAAAAAAAAQAAAAkAAAAIAAAAAQAAAB8AAAAMAAAAAQAAABwAAAAAAAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAGQBIAAABAAAAANAEAAAAAAAAAAAAAABQAAGQAAAAFJ3XASIUAAAAAAYAAAAAQAAAAAAEQCGKTXOBEBIAABAABAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAQAAAAAAAA":"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","HTQAAGAABBYAAAEIXBAAAGEAMAAAAAAAAAAAAAAAQAHAAAAAQAAAAAAAQQGAAAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABZQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDCQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAAAAEAAAABJYQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAIAAEAAAABJYQAAAAAQAAIAAAAAWCBACAABAAAAANAECAZAAEAAAAAAAAFAAMAAAABAAAAAAABBANDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADIAANAAAAALHCKLMRAAAAAAAAABAAAAAGJBCFLQVBWAQAAAAAAQAAAAAMACQCAACAAAAA2AIBAEIAAAAAAAAAAAAMAAPEAEAAABAAAAAAB2AAAAAAACAAAAAEBSAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAASLEYTYIIBAAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAAEQZCFOCCIJAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAEAIRLQYTSIAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAITLAYT2IAAAAA5B3UTQIDAAAAAEAAAAAJBQKEKYGE6SAAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAMGAIAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAACQAAAAAABQIQCAAAAUAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAAGAAAAAAAAAAA":"CgAAAExTS1OAAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGluUG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGluQ29sb3I7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0NCBpbkNpcmNsZUVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJdmluQ2lyY2xlRWRnZV9TMCA9IGluQ2lyY2xlRWRnZTsKCXZpbkNvbG9yX1MwID0gaW5Db2xvcjsKCWZsb2F0MiBfdG1wXzBfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSB1bG9jYWxNYXRyaXhfUzAueHogKiBpblBvc2l0aW9uICsgdWxvY2FsTWF0cml4X1MwLnl3OwoJc2tfUG9zaXRpb24gPSBfdG1wXzBfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAACyAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogQ292ZXJhZ2UgU2V0IE9wCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q292ZXJhZ2VfUzA7CgkJc2tfRnJhZ0NvbG9yID0gc2tfRnJhZ0NvbG9yLmEwMDA7Cgl9Cn0KAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIAAAAAQAAAAAAAAADAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAAHwAAAAwAAAABAAAAHAAAAAAAAAAKAAAAAAAAAAEAAAAAAAAA","FAAQMYAAMAAAEADAAABAEYAAAICIAB5AABQAAAQAMAAAEATAAABAIIGAAEDCBYQCA4AAAAAAAA5AAAAAAABAAAAACAZAAAAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAAAQAAAAGQCEIBAACAAAAAAAACQAGAAAAAQAAAAAGBCAIAAAAAFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQIAAAAAAAAAEAAAABJQQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABZQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDCQAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEAAAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEADZAAAAAGIAAAAACAAAAADZEAIAAAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"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","CIAAAAAAQAARQAAYQAAAAGFYQAABRAAAAEEAAAAAAARAEAGIAHSACAAAAQAAAAAA5AAAAAAABAAAAACAZAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQKAAAAAAAAAEAAAABJUQAAAAAAAAIAAAAAWCBAAAABAAAAANAEIQCAAAAAAAAAAAFAAMAAAABAAAAAAMCEAQFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HVJAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAABAAAAAABBAMABSAAGQAAAAKFIDMVQUAAAAABIAAAAGIAMAAAEAAAAAJBEJIFANSWCQAACAAEAAAAAAAAAAABYSA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQJAAAAAAABAEAAAABJSQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQFAAAAAAAAAEAAAABJKQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAABYCMNGFQIAAAAHADEHC6BAAAAAAAABAAAAAAIBDBL6DGOQAAAAAAEAAAAABALL354SAAAAABQAAAAHAJRUIUBIBAAAMAMY4LYEAAAAAEAAAAABAIMQAAAAAEBNPNXSJAAAAAGAAAAAMBGOQCQFQEAAAQBTTRPAQAAAAAQAAAAAIBDCAWTWL3EYAAAADAAAAACADHIJJCYCAAAAAZ5YHQIIAAAAAAAIAAAABTZCMNCFAKAIAAAAAAAAAMBCTZQ7BQUAAAAAAAIAAAADEZAZRYXQIAAAAAAAAAAAGABIBAABAAAAANAEIQCAAAAAAAAAAABAAOAAAABAAAAAAABBAMRQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAB3QA6AAAEAAAAAAAMAAPEAEAAABAAAAAAB2AAAAAAACAAAAAEBSAAABDAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQJAAAAAAAAAEAAAABJSQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAABYCMNGFQIAAAAGQ56JIEBYAAAAAAABAAAAAAIBDBL6DGOQAAAAAAEAAAAABALL354SAAAAABQAAAAHAJRUIUBIBAAAKBXZFAUHQAAAAEAAAAABAIMQAAAAAEBNPNXSJAAAAAGAAAAAMBGOQCQFQEAAAIC7UWCQ6AAAAAQAAAAAIBDCAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAIAAAABTZCMNCFAKAIAAAAAAAAAMBC7UXKS6AAAAAAAAIAAAADEVDPSKBIPAAAAAAAAAAAGABIBAABAAAAANAEIQCAAAAAAAAAAABAAOAAAABAAAAAAABBAMUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"CgAAAExTS1NnBAAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwoJbGF5b3V0KG9mZnNldD0zMikgaGFsZjQgdXN0YXJ0X1MxX2MwX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD00MCkgaGFsZjQgdWVuZF9TMV9jMF9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9NDgpIGZsb2F0M3gzIHVtYXRyaXhfUzFfYzBfYzBfYzBfYzE7CglsYXlvdXQob2Zmc2V0PTk2KSBoYWxmNCB1bGVmdEJvcmRlckNvbG9yX1MxX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD0xMDQpIGhhbGY0IHVyaWdodEJvcmRlckNvbG9yX1MxX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD0xMTIpIGZsb2F0M3gzIHVtYXRyaXhfUzFfYzE7CglsYXlvdXQob2Zmc2V0PTE2MCkgaGFsZiB1cmFuZ2VfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQ0IGluQ2lyY2xlRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0NCB2aW5DaXJjbGVFZGdlX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CmxheW91dChsb2NhdGlvbiA9IDIpIG91dCBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzdfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCgl2aW5DaXJjbGVFZGdlX1MwID0gaW5DaXJjbGVFZGdlOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IHVsb2NhbE1hdHJpeF9TMC54eiAqIGluUG9zaXRpb24gKyB1bG9jYWxNYXRyaXhfUzAueXc7Cglza19Qb3NpdGlvbiA9IF90bXBfMF9pblBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzdfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxX2MwX2MwX2MwX2MxKSAqIF90bXBfMV9pblBvc2l0aW9uLnh5MTsKCX0KfQoAAAAAACwMAABsYXlvdXQobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSBzYW1wbGVyMkQgdVRleHR1cmVTYW1wbGVyXzBfUzE7CmxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQ0IHVsb2NhbE1hdHJpeF9TMDsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGY0IHVzdGFydF9TMV9jMF9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9NDApIGhhbGY0IHVlbmRfUzFfYzBfYzBfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTQ4KSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwX2MwX2MwX2MxOwoJbGF5b3V0KG9mZnNldD05NikgaGFsZjQgdWxlZnRCb3JkZXJDb2xvcl9TMV9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9MTA0KSBoYWxmNCB1cmlnaHRCb3JkZXJDb2xvcl9TMV9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9MTEyKSBmbG9hdDN4MyB1bWF0cml4X1MxX2MxOwoJbGF5b3V0KG9mZnNldD0xNjApIGhhbGYgdXJhbmdlX1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzdfUzA7CmhhbGY0IFNpbmdsZUludGVydmFsQ29sb3JpemVyX1MxX2MwX2MwX2MwX2MwKGhhbGY0IF9pbnB1dCwgZmxvYXQyIF9jb29yZHMpIAp7CgloYWxmNCBfdG1wXzBfaW5Db2xvciA9IF9pbnB1dDsKCWZsb2F0MiBfdG1wXzFfY29vcmRzID0gX2Nvb3JkczsKCXJldHVybiBoYWxmNChtaXgodXN0YXJ0X1MxX2MwX2MwX2MwX2MwLCB1ZW5kX1MxX2MwX2MwX2MwX2MwLCBoYWxmKF90bXBfMV9jb29yZHMueCkpKTsKfQpoYWxmNCBMaW5lYXJMYXlvdXRfUzFfYzBfYzBfYzBfYzFfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgX3RtcF8yX2luQ29sb3IgPSBfaW5wdXQ7CglmbG9hdDIgX3RtcF8zX2Nvb3JkcyA9IHZUcmFuc2Zvcm1lZENvb3Jkc183X1MwOwoJcmV0dXJuIGhhbGY0KGhhbGY0KGhhbGYoX3RtcF8zX2Nvb3Jkcy54KSArIDFlLTA1LCAxLjAsIDAuMCwgMC4wKSk7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxX2MwX2MwX2MwX2MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBMaW5lYXJMYXlvdXRfUzFfYzBfYzBfYzBfYzFfYzAoX2lucHV0KTsKfQpoYWxmNCBDbGFtcGVkR3JhZGllbnRfUzFfYzBfYzBfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgX3RtcF80X2luQ29sb3IgPSBfaW5wdXQ7CgloYWxmNCB0ID0gTWF0cml4RWZmZWN0X1MxX2MwX2MwX2MwX2MxKF90bXBfNF9pbkNvbG9yKTsKCWhhbGY0IG91dENvbG9yOwoJaWYgKCFib29sKGludCgxKSkgJiYgdC55IDwgMC4wKSAKCXsKCQlvdXRDb2xvciA9IGhhbGY0KDAuMCk7Cgl9CgllbHNlIGlmICh0LnggPCAwLjApIAoJewoJCW91dENvbG9yID0gdWxlZnRCb3JkZXJDb2xvcl9TMV9jMF9jMF9jMDsKCX0KCWVsc2UgaWYgKHQueCA+IDEuMCkgCgl7CgkJb3V0Q29sb3IgPSB1cmlnaHRCb3JkZXJDb2xvcl9TMV9jMF9jMF9jMDsKCX0KCWVsc2UgCgl7CgkJb3V0Q29sb3IgPSBTaW5nbGVJbnRlcnZhbENvbG9yaXplcl9TMV9jMF9jMF9jMF9jMChfdG1wXzRfaW5Db2xvciwgZmxvYXQyKGhhbGYyKHQueCwgMC4wKSkpOwoJfQoJcmV0dXJuIGhhbGY0KG91dENvbG9yKTsKfQpoYWxmNCBjb2xvcl94Zm9ybV9TMV9jMF9jMChoYWxmNCBjb2xvcikgCnsKCWNvbG9yLnJnYiAqPSBjb2xvci5hOwoJcmV0dXJuIGhhbGY0KGNvbG9yKTsKfQpoYWxmNCBDb2xvclNwYWNlWGZvcm1fUzFfYzBfYzAoaGFsZjQgX2lucHV0KSAKewoJcmV0dXJuIGNvbG9yX3hmb3JtX1MxX2MwX2MwKENsYW1wZWRHcmFkaWVudF9TMV9jMF9jMF9jMChfaW5wdXQpKTsKfQpoYWxmNCBEaXNhYmxlQ292ZXJhZ2VBc0FscGhhX1MxX2MwKGhhbGY0IF9pbnB1dCkgCnsKCV9pbnB1dCA9IENvbG9yU3BhY2VYZm9ybV9TMV9jMF9jMChfaW5wdXQpOwoJaGFsZjQgX3RtcF81X2luQ29sb3IgPSBfaW5wdXQ7CglyZXR1cm4gaGFsZjQoX2lucHV0KTsKfQpoYWxmNCBUZXh0dXJlRWZmZWN0X1MxX2MxX2MwKGhhbGY0IF9pbnB1dCwgZmxvYXQyIF9jb29yZHMpIAp7CglyZXR1cm4gc2FtcGxlKHVUZXh0dXJlU2FtcGxlcl8wX1MxLCBfY29vcmRzKS4wMDByOwp9CmhhbGY0IE1hdHJpeEVmZmVjdF9TMV9jMShoYWxmNCBfaW5wdXQsIGZsb2F0MiBfY29vcmRzKSAKewoJcmV0dXJuIFRleHR1cmVFZmZlY3RfUzFfYzFfYzAoX2lucHV0LCBmbG9hdDN4Mih1bWF0cml4X1MxX2MxKSAqIF9jb29yZHMueHkxKTsKfQpoYWxmNCBEaXRoZXJfUzEoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgX3RtcF82X2luQ29sb3IgPSBfaW5wdXQ7CgloYWxmNCBjb2xvciA9IERpc2FibGVDb3ZlcmFnZUFzQWxwaGFfUzFfYzAoX3RtcF82X2luQ29sb3IpOwoJaGFsZiB2YWx1ZSA9IE1hdHJpeEVmZmVjdF9TMV9jMShfdG1wXzZfaW5Db2xvciwgc2tfRnJhZ0Nvb3JkLnh5KS53IC0gMC41OwoJcmV0dXJuIGhhbGY0KGhhbGY0KGNsYW1wKGNvbG9yLnh5eiArIHZhbHVlICogdXJhbmdlX1MxLCAwLjAsIGNvbG9yLncpLCBjb2xvci53KSk7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCglmbG9hdDQgY2lyY2xlRWRnZTsKCWNpcmNsZUVkZ2UgPSB2aW5DaXJjbGVFZGdlX1MwOwoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZpbkNvbG9yX1MwOwoJZmxvYXQgZCA9IGxlbmd0aChjaXJjbGVFZGdlLnh5KTsKCWhhbGYgZGlzdGFuY2VUb091dGVyRWRnZSA9IGhhbGYoY2lyY2xlRWRnZS56ICogKDEuMCAtIGQpKTsKCWhhbGYgZWRnZUFscGhhID0gc2F0dXJhdGUoZGlzdGFuY2VUb091dGVyRWRnZSk7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGVkZ2VBbHBoYSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBEaXRoZXJfUzEob3V0cHV0Q29sb3JfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dF9TMSAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAABAAAAAAAAAAMAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAfAAAADAAAAAEAAAAcAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGACQAGAAAAAQAAAAAAAQQGAAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"CgAAAExTS1NkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGZsb2F0MiBsb2NhbENvb3JkOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgZmxvYXQyIHZsb2NhbENvb3JkX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZsb2NhbENvb3JkX1MwID0gbG9jYWxDb29yZDsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAKQIAAGxheW91dChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHNhbXBsZXIyRCB1VGV4dHVyZVNhbXBsZXJfMF9TMDsKbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgdmxvY2FsQ29vcmRfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gaGFsZjQoMSk7CglmbG9hdDIgdGV4Q29vcmQ7Cgl0ZXhDb29yZCA9IHZsb2NhbENvb3JkX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSAoKHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMCwgdGV4Q29vcmQpICogaGFsZjQoMSkpKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHQAAAAgAAAABAAAAEAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","DAQAAAAAAABGAABAYAAQAIHCAIAYAQUBAEAAAAAAEAAAAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADEAANAAAAALHCKLMRAAAAAAAAABAAAAAGJBCFLQVBWAQAAAAAAQAAAAAMACQCAACAAAAA2AIBAEIAAAAAAAAAAAAIADQAAAAIAAAAAAAIIDAAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQFAAAAAAAAAEAAAABJKQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","GCAAAAAADAAAEAABBYAAAAYXBAAAAAAAAAAAAAAA2AAQAAAACAAAAAEASAAQAAAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"CgAAAExTS1PRAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7CglsYXlvdXQob2Zmc2V0PTI0KSBoYWxmIHVDb3ZlcmFnZV9TMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBpblBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBoYWxmNCBpbkhhaXJRdWFkRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGhhbGY0IHZIYWlyUXVhZEVkZ2VfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWQKCXZIYWlyUXVhZEVkZ2VfUzAgPSBpbkhhaXJRdWFkRWRnZTsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247Cglza19Qb3NpdGlvbiA9IF90bXBfMV9pblBvc2l0aW9uLnh5MDE7Cn0KAAAAAAAAAGYDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGhhbGY0IHVDb2xvcl9TMDsKCWxheW91dChvZmZzZXQ9MjQpIGhhbGYgdUNvdmVyYWdlX1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdkhhaXJRdWFkRWRnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWQKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB1Q29sb3JfUzA7CgloYWxmIGVkZ2VBbHBoYTsKCWhhbGYyIGR1dmR4ID0gaGFsZjIoZEZkeCh2SGFpclF1YWRFZGdlX1MwLnh5KSk7CgloYWxmMiBkdXZkeSA9IGhhbGYyKGRGZHkodkhhaXJRdWFkRWRnZV9TMC54eSkpOwoJaGFsZjIgZ0YgPSBoYWxmMigyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeC54IC0gZHV2ZHgueSwgICAgICAgICAgICAgICAyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeS54IC0gZHV2ZHkueSk7CgllZGdlQWxwaGEgPSBoYWxmKHZIYWlyUXVhZEVkZ2VfUzAueCAqIHZIYWlyUXVhZEVkZ2VfUzAueCAtIHZIYWlyUXVhZEVkZ2VfUzAueSk7CgllZGdlQWxwaGEgPSBzcXJ0KGVkZ2VBbHBoYSAqIGVkZ2VBbHBoYSAvIGRvdChnRiwgZ0YpKTsKCWVkZ2VBbHBoYSA9IG1heCgxLjAgLSBlZGdlQWxwaGEsIDAuMCk7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KHVDb3ZlcmFnZV9TMCAqIGVkZ2VBbHBoYSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAfAAAACAAAAAEAAAAYAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HVJAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAABAAAAAABBAMABAAOAAAABAAAAAAABBAMAAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"CgAAAExTS1PMAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgZmxhdCBvdXQgaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgZmxvYXQyIHZsb2NhbENvb3JkX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJdmxvY2FsQ29vcmRfUzAgPSBsb2NhbENvb3JkOwoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwp9CgAAAABvAgAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MwOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgaW4gaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgdmxvY2FsQ29vcmRfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2Y29sb3JfUzA7CglmbG9hdDIgdGV4Q29vcmQ7Cgl0ZXhDb29yZCA9IHZsb2NhbENvb3JkX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSAoKHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMCwgdGV4Q29vcmQpICogb3V0cHV0Q29sb3JfUzApKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAEAAAAAAAAAAwAAAB0AAAAAAAAAAQAAAAkAAAAIAAAAAQAAAB0AAAAMAAAAAQAAABQAAAAAAAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQLAAAAAAAAAEAAAABJWQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"CgAAAExTS1NQAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwX2MwOwoJbGF5b3V0KG9mZnNldD02NCkgaGFsZjIgdUluY3JlbWVudF9TMV9jMDsKCWxheW91dChvZmZzZXQ9NjgpIGhhbGYyIHVPZmZzZXRzQW5kS2VybmVsX1MxX2MwWzEyXTsKCWxheW91dChvZmZzZXQ9MTI4KSBmbG9hdDN4MyB1bWF0cml4X1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfMl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxKSAqIGxvY2FsQ29vcmQueHkxOwoJfQp9CgAAAACnBQAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0M3gzIHVtYXRyaXhfUzFfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTY0KSBoYWxmMiB1SW5jcmVtZW50X1MxX2MwOwoJbGF5b3V0KG9mZnNldD02OCkgaGFsZjIgdU9mZnNldHNBbmRLZXJuZWxfUzFfYzBbMTJdOwoJbGF5b3V0KG9mZnNldD0xMjgpIGZsb2F0M3gzIHVtYXRyaXhfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CmhhbGY0IFRleHR1cmVFZmZlY3RfUzFfYzBfYzBfYzAoaGFsZjQgX2lucHV0LCBmbG9hdDIgX2Nvb3JkcykgCnsKCXJldHVybiBzYW1wbGUodVRleHR1cmVTYW1wbGVyXzBfUzEsIF9jb29yZHMpOwp9CmhhbGY0IE1hdHJpeEVmZmVjdF9TMV9jMF9jMChoYWxmNCBfaW5wdXQsIGZsb2F0MiBfY29vcmRzKSAKewoJcmV0dXJuIFRleHR1cmVFZmZlY3RfUzFfYzBfYzBfYzAoX2lucHV0LCBmbG9hdDN4Mih1bWF0cml4X1MxX2MwX2MwKSAqIF9jb29yZHMueHkxKTsKfQpoYWxmNCBTbW9vdGhfUzFfYzAoaGFsZjQgX2lucHV0LCBmbG9hdDIgY29vcmQsIGhhbGYyIG9mZnNldEFuZEtlcm5lbCkgCnsKCXJldHVybiBNYXRyaXhFZmZlY3RfUzFfYzBfYzAoX2lucHV0LCAoY29vcmQgKyBvZmZzZXRBbmRLZXJuZWwueCAqIHVJbmNyZW1lbnRfUzFfYzApKSAqIG9mZnNldEFuZEtlcm5lbC55Owp9CmhhbGY0IEdhdXNzaWFuQ29udm9sdXRpb25fUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgY29sb3IgPSBoYWxmNCgwKTsKCWZsb2F0MiBjb29yZCA9IHZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwOwoJZm9yIChpbnQgaT0wOyBpPDEyOyArK2kpIAoJewoJCWNvbG9yICs9IFNtb290aF9TMV9jMChfaW5wdXQsIGNvb3JkLCB1T2Zmc2V0c0FuZEtlcm5lbF9TMV9jMFtpXSk7Cgl9CglyZXR1cm4gY29sb3I7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBHYXVzc2lhbkNvbnZvbHV0aW9uX1MxX2MwKF9pbnB1dCk7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzAgPSBoYWxmNCgxKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBNYXRyaXhFZmZlY3RfUzEob3V0cHV0Q29sb3JfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dF9TMSAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHQAAAAgAAAABAAAAEAAAAAAAAABQAAAAAAAAAAEAAAAAAAAA","AZAA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"CgAAAExTS1N4AgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bG9jYWxNYXRyaXhfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQ0IGluQ2lyY2xlRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0NCB2aW5DaXJjbGVFZGdlX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCgl2aW5DaXJjbGVFZGdlX1MwID0gaW5DaXJjbGVFZGdlOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGZsb2F0M3gyKHVsb2NhbE1hdHJpeF9TMCkgKiBpblBvc2l0aW9uLnh5MTsKCXNrX1Bvc2l0aW9uID0gX3RtcF8wX2luUG9zaXRpb24ueHkwMTsKfQoAAAAAnQIAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQzeDMgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAABAAAAAAAAAAMAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAfAAAADAAAAAEAAAAcAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEADZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAIAAAAAAAA":"CgAAAExTS1OpAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgb3V0IGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgl2Y29sb3JfUzAgPSBjb2xvcjsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAAAAAJwMAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQ0IHVpbm5lclJlY3RfUzE7CglsYXlvdXQob2Zmc2V0PTMyKSBoYWxmMiB1cmFkaXVzUGx1c0hhbGZfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKaGFsZjQgQ2lyY3VsYXJSUmVjdF9TMShoYWxmNCBfaW5wdXQpIAp7CglmbG9hdDIgZHh5MCA9IHVpbm5lclJlY3RfUzEuTFQgLSBza19GcmFnQ29vcmQueHk7CglmbG9hdDIgZHh5MSA9IHNrX0ZyYWdDb29yZC54eSAtIHVpbm5lclJlY3RfUzEuUkI7CglmbG9hdDIgZHh5ID0gbWF4KG1heChkeHkwLCBkeHkxKSwgMC4wKTsKCWhhbGYgYWxwaGEgPSBoYWxmKHNhdHVyYXRlKHVyYWRpdXNQbHVzSGFsZl9TMS54IC0gbGVuZ3RoKGR4eSkpKTsKCXJldHVybiBfaW5wdXQgKiBhbHBoYTsKfQp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmNvbG9yX1MwOwoJY29uc3QgaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNCgxKTsKCWhhbGY0IG91dHB1dF9TMTsKCW91dHB1dF9TMSA9IENpcmN1bGFyUlJlY3RfUzEob3V0cHV0Q292ZXJhZ2VfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0X1MxOwoJfQp9CgABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBQU7BTXIAAAAAACAWXW3ZEQAAAADAAAAAGATHIBICYCAAAEBP2LBIPAAAAAIAAAAAEARRALJ3F5SMAAAABQAAAABABTUEURMBAAACAH5FYUHQAAAAAAAEAAAAAZ4RGGRCQFAEAAAAAAAAAGARP2LVJPAAAAAAAAEAAAABSKRXZFAUHQAAAAAAAAAACAA4AAAACAAAAAAACCAYAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAICAACAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGAAZAADIAAAACU53QJEKAAAAAAMAAAAAIAAAAAAGIRDFB2XASAUAABQAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAIYAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAOAAHSAAAAAAQAAAAAA5AAAAAAABAAAAACAZAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAAHAJRUYWBAAAAA2DXZFAQHAAAAAAAAEAAAAABAEMFPYMZ2AAAAAAAQFV566JAAAAAAYAAAADQEY2EKAUAQAAFA34SQKDYAAAACAAAAABAEMIC263PESAAAAAMAAAAAYCM5AFALAIAAAQF7JMFB4AAAACAAAAAAQAGHEJRUYWBAAAAAAAAAAAFQEL6S4KLYAAAAAAABAAAAAMWU56JIEBYAAAAAAAAAACYIEAAAAEAAAABUARCAIAAAAAAAAAAAUABQAAAAEAAAAAAAEEBQAACQAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEAAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABZQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDCGAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","AZAA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1N4AgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bG9jYWxNYXRyaXhfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQ0IGluQ2lyY2xlRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0NCB2aW5DaXJjbGVFZGdlX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCgl2aW5DaXJjbGVFZGdlX1MwID0gaW5DaXJjbGVFZGdlOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGZsb2F0M3gyKHVsb2NhbE1hdHJpeF9TMCkgKiBpblBvc2l0aW9uLnh5MTsKCXNrX1Bvc2l0aW9uID0gX3RtcF8wX2luUG9zaXRpb24ueHkwMTsKfQoAAAAAnQIAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQzeDMgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAABAAAAAAAAAAMAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAfAAAADAAAAAEAAAAcAAAAAAAAAEYAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGABZAA6IAAAAACAAAAAADUAAAAAAAEAAAAAIDEAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEAAZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAIMDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1aW5uZXJSZWN0X1MxOwoJbGF5b3V0KG9mZnNldD0zMikgaGFsZjIgdXJhZGl1c1BsdXNIYWxmX1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdmNvbG9yX1MwOwpoYWxmNCBDaXJjdWxhclJSZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCWZsb2F0MiBkeHkwID0gdWlubmVyUmVjdF9TMS5MVCAtIHNrX0ZyYWdDb29yZC54eTsKCWZsb2F0IGR4MSA9IHNrX0ZyYWdDb29yZC54IC0gdWlubmVyUmVjdF9TMS5SOwoJZmxvYXQyIGR4eSA9IG1heChmbG9hdDIobWF4KGR4eTAueCwgZHgxKSwgZHh5MC55KSwgMC4wKTsKCWhhbGYgYm90dG9tQWxwaGEgPSBoYWxmKHNhdHVyYXRlKHVpbm5lclJlY3RfUzEuQiAtIHNrX0ZyYWdDb29yZC55KSk7CgloYWxmIGFscGhhID0gYm90dG9tQWxwaGEgKiBoYWxmKHNhdHVyYXRlKHVyYWRpdXNQbHVzSGFsZl9TMS54IC0gbGVuZ3RoKGR4eSkpKTsKCXJldHVybiBfaW5wdXQgKiBhbHBoYTsKfQp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmNvbG9yX1MwOwoJY29uc3QgaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNCgxKTsKCWhhbGY0IG91dHB1dF9TMTsKCW91dHB1dF9TMSA9IENpcmN1bGFyUlJlY3RfUzEob3V0cHV0Q292ZXJhZ2VfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0X1MxOwoJfQp9CgABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1NTAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAACCAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAMAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","AY7SRAADQAAAOAEARAFQJAABBADAAAILBYAACCYUAAAQWGUAAEECAAAAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAAHJXMYEEAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZ5G5DCQYAAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAEABYAAAAEAAAAAAAEEBQAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"CgAAAExTS1MqBAAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdXNjYWxlX1MxX2MwX2MwX2MwX2MwWzJdOwoJbGF5b3V0KG9mZnNldD00OCkgZmxvYXQ0IHViaWFzX1MxX2MwX2MwX2MwX2MwWzJdOwoJbGF5b3V0KG9mZnNldD04MCkgaGFsZiB1dGhyZXNob2xkX1MxX2MwX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD05NikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMF9jMF9jMF9jMTsKCWxheW91dChvZmZzZXQ9MTQ0KSBoYWxmNCB1bGVmdEJvcmRlckNvbG9yX1MxX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD0xNTIpIGhhbGY0IHVyaWdodEJvcmRlckNvbG9yX1MxX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD0xNjApIGZsb2F0M3gzIHVtYXRyaXhfUzFfYzE7CglsYXlvdXQob2Zmc2V0PTIwOCkgaGFsZiB1cmFuZ2VfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGZsb2F0IGNvdmVyYWdlOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiBoYWxmNCBjb2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMykgaW4gZmxvYXQyIGxvY2FsQ29vcmQ7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgb3V0IGhhbGY0IHZjb2xvcl9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGZsb2F0IHZjb3ZlcmFnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMikgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfN19TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCglmbG9hdDIgcG9zaXRpb24gPSBwb3NpdGlvbi54eTsKCXZjb2xvcl9TMCA9IGNvbG9yOwoJdmNvdmVyYWdlX1MwID0gY292ZXJhZ2U7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzdfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxX2MwX2MwX2MwX2MxKSAqIGxvY2FsQ29vcmQueHkxOwoJfQp9CgAAAAAAAF0MAABsYXlvdXQobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSBzYW1wbGVyMkQgdVRleHR1cmVTYW1wbGVyXzBfUzE7CmxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQ0IHVzY2FsZV9TMV9jMF9jMF9jMF9jMFsyXTsKCWxheW91dChvZmZzZXQ9NDgpIGZsb2F0NCB1Ymlhc19TMV9jMF9jMF9jMF9jMFsyXTsKCWxheW91dChvZmZzZXQ9ODApIGhhbGYgdXRocmVzaG9sZF9TMV9jMF9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9OTYpIGZsb2F0M3gzIHVtYXRyaXhfUzFfYzBfYzBfYzBfYzE7CglsYXlvdXQob2Zmc2V0PTE0NCkgaGFsZjQgdWxlZnRCb3JkZXJDb2xvcl9TMV9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9MTUyKSBoYWxmNCB1cmlnaHRCb3JkZXJDb2xvcl9TMV9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9MTYwKSBmbG9hdDN4MyB1bWF0cml4X1MxX2MxOwoJbGF5b3V0KG9mZnNldD0yMDgpIGhhbGYgdXJhbmdlX1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgZmxhdCBpbiBoYWxmNCB2Y29sb3JfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGZsb2F0IHZjb3ZlcmFnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQyIHZUcmFuc2Zvcm1lZENvb3Jkc183X1MwOwpoYWxmNCBEdWFsSW50ZXJ2YWxDb2xvcml6ZXJfUzFfYzBfYzBfYzBfYzAoaGFsZjQgX2lucHV0LCBmbG9hdDIgX2Nvb3JkcykgCnsKCWhhbGY0IF90bXBfMF9pbkNvbG9yID0gX2lucHV0OwoJZmxvYXQyIF90bXBfMV9jb29yZHMgPSBfY29vcmRzOwoJaGFsZiB0ID0gaGFsZihfdG1wXzFfY29vcmRzLngpOwoJZmxvYXQ0IHM7CglmbG9hdDQgYjsKCWlmICh0IDwgdXRocmVzaG9sZF9TMV9jMF9jMF9jMF9jMCkgCgl7CgkJcyA9IHVzY2FsZV9TMV9jMF9jMF9jMF9jMFswXTsKCQliID0gdWJpYXNfUzFfYzBfYzBfYzBfYzBbMF07Cgl9CgllbHNlIAoJewoJCXMgPSB1c2NhbGVfUzFfYzBfYzBfYzBfYzBbMV07CgkJYiA9IHViaWFzX1MxX2MwX2MwX2MwX2MwWzFdOwoJfQoJcmV0dXJuIGhhbGY0KGhhbGY0KGZsb2F0KHQpICogcyArIGIpKTsKfQpoYWxmNCBMaW5lYXJMYXlvdXRfUzFfYzBfYzBfYzBfYzFfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgX3RtcF8yX2luQ29sb3IgPSBfaW5wdXQ7CglmbG9hdDIgX3RtcF8zX2Nvb3JkcyA9IHZUcmFuc2Zvcm1lZENvb3Jkc183X1MwOwoJcmV0dXJuIGhhbGY0KGhhbGY0KGhhbGYoX3RtcF8zX2Nvb3Jkcy54KSArIDFlLTA1LCAxLjAsIDAuMCwgMC4wKSk7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxX2MwX2MwX2MwX2MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBMaW5lYXJMYXlvdXRfUzFfYzBfYzBfYzBfYzFfYzAoX2lucHV0KTsKfQpoYWxmNCBDbGFtcGVkR3JhZGllbnRfUzFfYzBfYzBfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgX3RtcF80X2luQ29sb3IgPSBfaW5wdXQ7CgloYWxmNCB0ID0gTWF0cml4RWZmZWN0X1MxX2MwX2MwX2MwX2MxKF90bXBfNF9pbkNvbG9yKTsKCWhhbGY0IG91dENvbG9yOwoJaWYgKCFib29sKGludCgxKSkgJiYgdC55IDwgMC4wKSAKCXsKCQlvdXRDb2xvciA9IGhhbGY0KDAuMCk7Cgl9CgllbHNlIGlmICh0LnggPCAwLjApIAoJewoJCW91dENvbG9yID0gdWxlZnRCb3JkZXJDb2xvcl9TMV9jMF9jMF9jMDsKCX0KCWVsc2UgaWYgKHQueCA+IDEuMCkgCgl7CgkJb3V0Q29sb3IgPSB1cmlnaHRCb3JkZXJDb2xvcl9TMV9jMF9jMF9jMDsKCX0KCWVsc2UgCgl7CgkJb3V0Q29sb3IgPSBEdWFsSW50ZXJ2YWxDb2xvcml6ZXJfUzFfYzBfYzBfYzBfYzAoX3RtcF80X2luQ29sb3IsIGZsb2F0MihoYWxmMih0LngsIDAuMCkpKTsKCX0KCXJldHVybiBoYWxmNChvdXRDb2xvcik7Cn0KaGFsZjQgY29sb3JfeGZvcm1fUzFfYzBfYzAoaGFsZjQgY29sb3IpIAp7Cgljb2xvci5yZ2IgKj0gY29sb3IuYTsKCXJldHVybiBoYWxmNChjb2xvcik7Cn0KaGFsZjQgQ29sb3JTcGFjZVhmb3JtX1MxX2MwX2MwKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBjb2xvcl94Zm9ybV9TMV9jMF9jMChDbGFtcGVkR3JhZGllbnRfUzFfYzBfYzBfYzAoX2lucHV0KSk7Cn0KaGFsZjQgRGlzYWJsZUNvdmVyYWdlQXNBbHBoYV9TMV9jMChoYWxmNCBfaW5wdXQpIAp7CglfaW5wdXQgPSBDb2xvclNwYWNlWGZvcm1fUzFfYzBfYzAoX2lucHV0KTsKCWhhbGY0IF90bXBfNV9pbkNvbG9yID0gX2lucHV0OwoJcmV0dXJuIGhhbGY0KF9pbnB1dCk7Cn0KaGFsZjQgVGV4dHVyZUVmZmVjdF9TMV9jMV9jMChoYWxmNCBfaW5wdXQsIGZsb2F0MiBfY29vcmRzKSAKewoJcmV0dXJuIHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMSwgX2Nvb3JkcykuMDAwcjsKfQpoYWxmNCBNYXRyaXhFZmZlY3RfUzFfYzEoaGFsZjQgX2lucHV0LCBmbG9hdDIgX2Nvb3JkcykgCnsKCXJldHVybiBUZXh0dXJlRWZmZWN0X1MxX2MxX2MwKF9pbnB1dCwgZmxvYXQzeDIodW1hdHJpeF9TMV9jMSkgKiBfY29vcmRzLnh5MSk7Cn0KaGFsZjQgRGl0aGVyX1MxKGhhbGY0IF9pbnB1dCkgCnsKCWhhbGY0IF90bXBfNl9pbkNvbG9yID0gX2lucHV0OwoJaGFsZjQgY29sb3IgPSBEaXNhYmxlQ292ZXJhZ2VBc0FscGhhX1MxX2MwKF90bXBfNl9pbkNvbG9yKTsKCWhhbGYgdmFsdWUgPSBNYXRyaXhFZmZlY3RfUzFfYzEoX3RtcF82X2luQ29sb3IsIHNrX0ZyYWdDb29yZC54eSkudyAtIDAuNTsKCXJldHVybiBoYWxmNChoYWxmNChjbGFtcChjb2xvci54eXogKyB2YWx1ZSAqIHVyYW5nZV9TMSwgMC4wLCBjb2xvci53KSwgY29sb3IudykpOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2Y29sb3JfUzA7CglmbG9hdCBjb3ZlcmFnZSA9IHZjb3ZlcmFnZV9TMDsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoaGFsZihjb3ZlcmFnZSkpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gRGl0aGVyX1MxKG91dHB1dENvbG9yX1MwKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRfUzEgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsAAAAAQAAAAAAAAAEAAAAHQAAAAAAAAABAAAAHAAAAAgAAAABAAAACQAAAAwAAAABAAAAHQAAABAAAAABAAAAGAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAAYQADAAAEAFEURUKQKAAAIAAQAAAAAIAAAABSCICWKY2FAEAAAUAAAAAAAAAAAAAIADQAAAAIAAAAAAAIIDAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1OuAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwoJbGF5b3V0KG9mZnNldD0zMikgZmxvYXQ0IHVyZWN0VW5pZm9ybV9TMV9jMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBpblBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBoYWxmNCBpbkNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiBmbG9hdDQgaW5DaXJjbGVFZGdlOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIG91dCBoYWxmNCB2aW5Db2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCXZpbkNpcmNsZUVkZ2VfUzAgPSBpbkNpcmNsZUVkZ2U7Cgl2aW5Db2xvcl9TMCA9IGluQ29sb3I7CglmbG9hdDIgX3RtcF8wX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJZmxvYXQyIF90bXBfMV9pblBvc2l0aW9uID0gdWxvY2FsTWF0cml4X1MwLnh6ICogaW5Qb3NpdGlvbiArIHVsb2NhbE1hdHJpeF9TMC55dzsKCXNrX1Bvc2l0aW9uID0gX3RtcF8wX2luUG9zaXRpb24ueHkwMTsKfQoAAAAAAAA6BgAAY29uc3QgaW50IGtGaWxsQldfUzFfYzAgPSAwOwpjb25zdCBpbnQga0ludmVyc2VGaWxsQldfUzFfYzAgPSAyOwpjb25zdCBpbnQga0ludmVyc2VGaWxsQUFfUzFfYzAgPSAzOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1bG9jYWxNYXRyaXhfUzA7CglsYXlvdXQob2Zmc2V0PTMyKSBmbG9hdDQgdXJlY3RVbmlmb3JtX1MxX2MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwpoYWxmNCBSZWN0X1MxX2MwKGhhbGY0IF9pbnB1dCkgCnsKCWhhbGY0IF90bXBfMF9pbkNvbG9yID0gX2lucHV0OwoJaGFsZiBjb3ZlcmFnZTsKCWlmIChpbnQoMikgPT0ga0ZpbGxCV19TMV9jMCB8fCBpbnQoMikgPT0ga0ludmVyc2VGaWxsQldfUzFfYzApIAoJewoJCWNvdmVyYWdlID0gaGFsZihhbGwoZ3JlYXRlclRoYW4oZmxvYXQ0KHNrX0ZyYWdDb29yZC54eSwgdXJlY3RVbmlmb3JtX1MxX2MwLnp3KSwgZmxvYXQ0KHVyZWN0VW5pZm9ybV9TMV9jMC54eSwgc2tfRnJhZ0Nvb3JkLnh5KSkpKTsKCX0KCWVsc2UgCgl7CgkJaGFsZjQgZGlzdHM0ID0gc2F0dXJhdGUoaGFsZjQoMS4wLCAxLjAsIC0xLjAsIC0xLjApICogaGFsZjQoc2tfRnJhZ0Nvb3JkLnh5eHkgLSB1cmVjdFVuaWZvcm1fUzFfYzApKTsKCQloYWxmMiBkaXN0czIgPSAoZGlzdHM0Lnh5ICsgZGlzdHM0Lnp3KSAtIDEuMDsKCQljb3ZlcmFnZSA9IGRpc3RzMi54ICogZGlzdHMyLnk7Cgl9CglpZiAoaW50KDIpID09IGtJbnZlcnNlRmlsbEJXX1MxX2MwIHx8IGludCgyKSA9PSBrSW52ZXJzZUZpbGxBQV9TMV9jMCkgCgl7CgkJY292ZXJhZ2UgPSAxLjAgLSBjb3ZlcmFnZTsKCX0KCXJldHVybiBoYWxmNChoYWxmNChjb3ZlcmFnZSkpOwp9CmhhbGY0IEJsZW5kX1MxKGhhbGY0IF9zcmMsIGhhbGY0IF9kc3QpIAp7CglyZXR1cm4gYmxlbmRfbW9kdWxhdGUoUmVjdF9TMV9jMChfc3JjKSwgX3NyYyk7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCglmbG9hdDQgY2lyY2xlRWRnZTsKCWNpcmNsZUVkZ2UgPSB2aW5DaXJjbGVFZGdlX1MwOwoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZpbkNvbG9yX1MwOwoJZmxvYXQgZCA9IGxlbmd0aChjaXJjbGVFZGdlLnh5KTsKCWhhbGYgZGlzdGFuY2VUb091dGVyRWRnZSA9IGhhbGYoY2lyY2xlRWRnZS56ICogKDEuMCAtIGQpKTsKCWhhbGYgZWRnZUFscGhhID0gc2F0dXJhdGUoZGlzdGFuY2VUb091dGVyRWRnZSk7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGVkZ2VBbHBoYSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBCbGVuZF9TMShvdXRwdXRDb3ZlcmFnZV9TMCwgaGFsZjQoMSkpOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0X1MxOwoJfQp9CgAAAQAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAEAAAAAAAAAAwAAAB0AAAAAAAAAAQAAAAkAAAAIAAAAAQAAAB8AAAAMAAAAAQAAABwAAAAAAAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAMWAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAACJMTCPBBAEAAAUDPSKBIPAAAAAAAAIAAAAACAIYKPQZ3UAAAAAABALL3N4SIAAAABQAAAACIMRCXBBEEQAAEAP2LRIPAAAAAIAAAAAAABTALI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAIAAAABSDBEIVYMJREAAAAAAAAAAAFPJO7EUCA4AAAAAQAAAAAICD7UXCS6AAAAAAAAAAAAACWCAACAAAAACAINAEIAAAAAAAAAAAAADZABYAAAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","B2ABSAAABQAAIAABBYAAB7777777777774ABICAAAAAAAAAAAAAABUABAAAAAEAAAAAIBEABAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"CgAAAExTS1MCAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZiBpbkNvdmVyYWdlOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZjQgdmNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBEZWZhdWx0R2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IGNvbG9yID0gdUNvbG9yX1MwOwoJY29sb3IgPSBjb2xvciAqIGluQ292ZXJhZ2U7Cgl2Y29sb3JfUzAgPSBjb2xvcjsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8zX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJc2tfUG9zaXRpb24gPSBfdG1wXzFfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAAJsBAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGhhbGY0IHVDb2xvcl9TMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIERlZmF1bHRHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVAAAAAEAAAAAAAAAAgAAAB0AAAAAAAAAAQAAABwAAAAIAAAAAQAAAAwAAAAAAAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAGIBIAAABAAAAANAEAAAAAAAAAAAAAABAAOAAAABAAAAAAABBAMAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQIAAAAAAABAEAAAABJQQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAABAEAAAABJYQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAACJMTCPBBAEAAAUDPSKBIPAAAAAAAAIAAAAACAIYKPQZ3UAAAAAABALL3N4SIAAAABQAAAACIMRCXBBEEQAAEAP2LRIPAAAAAIAAAAAAABTALI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAIAAAABSDBEIVYMJREAAAAAAAAAAAFPJO7EUCA4AAAAAQAAAAAICD7UXCS6AAAAAAAAAAAAACWCAACAAAAACAINAEIAAAAAAAAAAAAA5AAAAAAABAAAAACAZAAACQAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAIAAEAAAABJYQAAAAAQAAIAAAAAWCBACAABAAAAANAEIQCAAEAAAAAAAAFAAMAAAABAAAAAAMCEAQFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HTQAAGAABBYAAAEIXBAAAGEAMAAAAAAAAAAAAAAAQAHAAAAAQAAAAAAAQQGAAAAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQGAAAAAAAAAEAAAABJMQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"CgAAAExTS1NOAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwX2MwOwoJbGF5b3V0KG9mZnNldD02NCkgaGFsZjIgdUluY3JlbWVudF9TMV9jMDsKCWxheW91dChvZmZzZXQ9NjgpIGhhbGYyIHVPZmZzZXRzQW5kS2VybmVsX1MxX2MwWzddOwoJbGF5b3V0KG9mZnNldD05NikgZmxvYXQzeDMgdW1hdHJpeF9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gZmxvYXQyIGxvY2FsQ29vcmQ7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwoJewoJCXZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwID0gZmxvYXQzeDIodW1hdHJpeF9TMSkgKiBsb2NhbENvb3JkLnh5MTsKCX0KfQoAAAAAAACkBQAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0M3gzIHVtYXRyaXhfUzFfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTY0KSBoYWxmMiB1SW5jcmVtZW50X1MxX2MwOwoJbGF5b3V0KG9mZnNldD02OCkgaGFsZjIgdU9mZnNldHNBbmRLZXJuZWxfUzFfYzBbN107CglsYXlvdXQob2Zmc2V0PTk2KSBmbG9hdDN4MyB1bWF0cml4X1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwOwpoYWxmNCBUZXh0dXJlRWZmZWN0X1MxX2MwX2MwX2MwKGhhbGY0IF9pbnB1dCwgZmxvYXQyIF9jb29yZHMpIAp7CglyZXR1cm4gc2FtcGxlKHVUZXh0dXJlU2FtcGxlcl8wX1MxLCBfY29vcmRzKTsKfQpoYWxmNCBNYXRyaXhFZmZlY3RfUzFfYzBfYzAoaGFsZjQgX2lucHV0LCBmbG9hdDIgX2Nvb3JkcykgCnsKCXJldHVybiBUZXh0dXJlRWZmZWN0X1MxX2MwX2MwX2MwKF9pbnB1dCwgZmxvYXQzeDIodW1hdHJpeF9TMV9jMF9jMCkgKiBfY29vcmRzLnh5MSk7Cn0KaGFsZjQgU21vb3RoX1MxX2MwKGhhbGY0IF9pbnB1dCwgZmxvYXQyIGNvb3JkLCBoYWxmMiBvZmZzZXRBbmRLZXJuZWwpIAp7CglyZXR1cm4gTWF0cml4RWZmZWN0X1MxX2MwX2MwKF9pbnB1dCwgKGNvb3JkICsgb2Zmc2V0QW5kS2VybmVsLnggKiB1SW5jcmVtZW50X1MxX2MwKSkgKiBvZmZzZXRBbmRLZXJuZWwueTsKfQpoYWxmNCBHYXVzc2lhbkNvbnZvbHV0aW9uX1MxX2MwKGhhbGY0IF9pbnB1dCkgCnsKCWhhbGY0IGNvbG9yID0gaGFsZjQoMCk7CglmbG9hdDIgY29vcmQgPSB2VHJhbnNmb3JtZWRDb29yZHNfMl9TMDsKCWZvciAoaW50IGk9MDsgaTw3OyArK2kpIAoJewoJCWNvbG9yICs9IFNtb290aF9TMV9jMChfaW5wdXQsIGNvb3JkLCB1T2Zmc2V0c0FuZEtlcm5lbF9TMV9jMFtpXSk7Cgl9CglyZXR1cm4gY29sb3I7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBHYXVzc2lhbkNvbnZvbHV0aW9uX1MxX2MwKF9pbnB1dCk7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzAgPSBoYWxmNCgxKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBNYXRyaXhFZmZlY3RfUzEob3V0cHV0Q29sb3JfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dF9TMSAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAdAAAACAAAAAEAAAAQAAAAAAAAAFAAAAAAAAAAAQAAAAAAAAA=","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAAHAJRUYWBAAAAA2DXZFAQHAAAAAAAAEAAAAABAEMFPYMZ2AAAAAAAQFV566JAAAAAAYAAAADQEY2EKAUAQAAFA34SQKDYAAAACAAAAABAEMIC263PESAAAAAMAAAAAYCM5AFALAIAAAQF7JMFB4AAAACAAAAAAQAGHEJRUYWBAAAAAAAAAAAFQEL6S4KLYAAAAAAABAAAAAMWU56JIEBYAAAAAAAAAACYIEAAAAEAAAABUARCAIAAAAAAAAAAAUABQAAAAEAAAAAAAEEBQAACGAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAASLEYTYIIBAAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAAEQZCFOCCIJAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAEAIRLQYTSIAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAITLAYT2IAAAAA5B3UTQIDAAAAAEAAAAAJBQKEKYGE6SAAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAASLEYTYIIBAAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAAEQZCFOCCIJAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAEAIRLQYTSIAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAITLAYT2IAAAAA5B3UTQIDAAAAAEAAAAAJBQKEKYGE6SAAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","CIAAAAAAQAARQAAYQAAAAGFYQAABRAAAAEEAAAAAAARAEAEABYAAAAEAAAAAAAEEBQAAAACQAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEBAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADEAANAAAAAUKQGZLBIAAAAACQAAAA4QAQAAAIAAAABSCICSKI2FIFAAAEAAIAAAAAAAAAAADZEBYAAAIAAAAAACQAGAAAAAQAAAAAAAQQGUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAIAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"CgAAAExTS1OAAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGluUG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGluQ29sb3I7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0NCBpbkNpcmNsZUVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJdmluQ2lyY2xlRWRnZV9TMCA9IGluQ2lyY2xlRWRnZTsKCXZpbkNvbG9yX1MwID0gaW5Db2xvcjsKCWZsb2F0MiBfdG1wXzBfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSB1bG9jYWxNYXRyaXhfUzAueHogKiBpblBvc2l0aW9uICsgdWxvY2FsTWF0cml4X1MwLnl3OwoJc2tfUG9zaXRpb24gPSBfdG1wXzBfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAsAwAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGYgZGlzdGFuY2VUb0lubmVyRWRnZSA9IGhhbGYoY2lyY2xlRWRnZS56ICogKGQgLSBjaXJjbGVFZGdlLncpKTsKCWhhbGYgaW5uZXJBbHBoYSA9IHNhdHVyYXRlKGRpc3RhbmNlVG9Jbm5lckVkZ2UpOwoJZWRnZUFscGhhICo9IGlubmVyQWxwaGE7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGVkZ2VBbHBoYSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAQAAAAAAAAADAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAAHwAAAAwAAAABAAAAHAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAGQBIAAABAAAAANAEAAAAAAAAAAAAAADQAB4QAAAAAEAAAAAAHIAAAAAAAIAAAAAQGIACGAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEBAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAAKUAQFAACYAAABAIAAAABLBAIBAAAAABAEGABBAMAAAAIAAAAAAAB2AAAAAAACAAAAAEBSAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAAAAYAAIAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADIAANAAAAALHCKLMRAAAAAAAAABAAAAAGJBCFLQVBWAQAAAAAAQAAAAAMACQCAACAAAAA2AIBAEIAAAAAAAAAAAAMAAPEAEAAABAAAAAAB2AAAAAAACAAAAAEBSAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"CgAAAExTS1MDAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwX2MwOwoJbGF5b3V0KG9mZnNldD02NCkgaGFsZjQgdWNpcmNsZURhdGFfUzFfYzA7CglsYXlvdXQob2Zmc2V0PTgwKSBmbG9hdDQgdWlubmVyUmVjdF9TMjsKCWxheW91dChvZmZzZXQ9OTYpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMjsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgb3V0IGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgl2Y29sb3JfUzAgPSBjb2xvcjsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAAL0GAABsYXlvdXQobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSBzYW1wbGVyMkQgdVRleHR1cmVTYW1wbGVyXzBfUzE7CmxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMF9jMDsKCWxheW91dChvZmZzZXQ9NjQpIGhhbGY0IHVjaXJjbGVEYXRhX1MxX2MwOwoJbGF5b3V0KG9mZnNldD04MCkgZmxvYXQ0IHVpbm5lclJlY3RfUzI7CglsYXlvdXQob2Zmc2V0PTk2KSBoYWxmMiB1cmFkaXVzUGx1c0hhbGZfUzI7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKaGFsZjQgVGV4dHVyZUVmZmVjdF9TMV9jMF9jMF9jMChoYWxmNCBfaW5wdXQsIGZsb2F0MiBfY29vcmRzKSAKewoJcmV0dXJuIHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMSwgX2Nvb3JkcykuMDAwcjsKfQpoYWxmNCBNYXRyaXhFZmZlY3RfUzFfYzBfYzAoaGFsZjQgX2lucHV0LCBmbG9hdDIgX2Nvb3JkcykgCnsKCXJldHVybiBUZXh0dXJlRWZmZWN0X1MxX2MwX2MwX2MwKF9pbnB1dCwgZmxvYXQzeDIodW1hdHJpeF9TMV9jMF9jMCkgKiBfY29vcmRzLnh5MSk7Cn0KaGFsZjQgQ2lyY2xlQmx1cl9TMV9jMChoYWxmNCBfaW5wdXQpIAp7CgloYWxmNCBfdG1wXzBfaW5Db2xvciA9IF9pbnB1dDsKCWhhbGYyIHZlYyA9IGhhbGYyKChza19GcmFnQ29vcmQueHkgLSBmbG9hdDIodWNpcmNsZURhdGFfUzFfYzAueHkpKSAqIGZsb2F0KHVjaXJjbGVEYXRhX1MxX2MwLncpKTsKCWhhbGYgZGlzdCA9IGxlbmd0aCh2ZWMpICsgKDAuNSAtIHVjaXJjbGVEYXRhX1MxX2MwLnopICogdWNpcmNsZURhdGFfUzFfYzAudzsKCXJldHVybiBoYWxmNChNYXRyaXhFZmZlY3RfUzFfYzBfYzAoX3RtcF8wX2luQ29sb3IsIGZsb2F0MihoYWxmMihkaXN0LCAwLjUpKSkud3d3dyk7Cn0KaGFsZjQgQmxlbmRfUzEoaGFsZjQgX3NyYywgaGFsZjQgX2RzdCkgCnsKCXJldHVybiBibGVuZF9tb2R1bGF0ZShDaXJjbGVCbHVyX1MxX2MwKF9zcmMpLCBfc3JjKTsKfQpoYWxmNCBDaXJjdWxhclJSZWN0X1MyKGhhbGY0IF9pbnB1dCkgCnsKCWZsb2F0MiBkeHkwID0gdWlubmVyUmVjdF9TMi5MVCAtIHNrX0ZyYWdDb29yZC54eTsKCWZsb2F0MiBkeHkxID0gc2tfRnJhZ0Nvb3JkLnh5IC0gdWlubmVyUmVjdF9TMi5SQjsKCWZsb2F0MiBkeHkgPSBtYXgobWF4KGR4eTAsIGR4eTEpLCAwLjApOwoJaGFsZiBhbHBoYSA9IGhhbGYoc2F0dXJhdGUodXJhZGl1c1BsdXNIYWxmX1MyLnggLSBsZW5ndGgoZHh5KSkpOwoJcmV0dXJuIF9pbnB1dCAqIGFscGhhOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2Y29sb3JfUzA7Cgljb25zdCBoYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KDEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gQmxlbmRfUzEob3V0cHV0Q292ZXJhZ2VfUzAsIGhhbGY0KDEpKTsKCWhhbGY0IG91dHB1dF9TMjsKCW91dHB1dF9TMiA9IENpcmN1bGFyUlJlY3RfUzIob3V0cHV0X1MxKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dF9TMjsKCX0KfQoAAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQIAAAAAAAAAEAAAABJQQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAGQBIAAABAAAAANAEAAAAAAAAAAAAAADQAB4QAAAAAEAAAAAAHIAAAAAAAIAAAAAQGIACQAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEBAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABYQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDCGAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEAAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"CgAAAExTS1OAAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGluUG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGluQ29sb3I7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0NCBpbkNpcmNsZUVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJdmluQ2lyY2xlRWRnZV9TMCA9IGluQ2lyY2xlRWRnZTsKCXZpbkNvbG9yX1MwID0gaW5Db2xvcjsKCWZsb2F0MiBfdG1wXzBfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSB1bG9jYWxNYXRyaXhfUzAueHogKiBpblBvc2l0aW9uICsgdWxvY2FsTWF0cml4X1MwLnl3OwoJc2tfUG9zaXRpb24gPSBfdG1wXzBfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAACbAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAQAAAAAAAAADAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAAHwAAAAwAAAABAAAAHAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAAAAAAAAIAAAABSEIAL7YYDQAAAAAAACAAAAABQEKAAAAIAAAADIBAQGIAAAAAAAAAAAMACQCAACAAAAA2AIBAEIAAAAAAAAAACAA4AAAACAAAAAAACCAYAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQAAAAQAAAAGQCEIBAAAAAAAAAAACQAGAAAAAQAAAAAGBCAIAAAAAFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"CgAAAExTS1PAAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfMl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxKSAqIGxvY2FsQ29vcmQueHkxOwoJfQp9CgAAAAABAwAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0M3gzIHVtYXRyaXhfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CmhhbGY0IFRleHR1cmVFZmZlY3RfUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJcmV0dXJuIHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMSwgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzApLjAwMHI7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBUZXh0dXJlRWZmZWN0X1MxX2MwKF9pbnB1dCk7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzAgPSBoYWxmNCgxKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBNYXRyaXhFZmZlY3RfUzEob3V0cHV0Q29sb3JfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dF9TMSAqIG91dHB1dENvdmVyYWdlX1MwOwoJCXNrX0ZyYWdDb2xvciA9IHNrX0ZyYWdDb2xvci5hMDAwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAdAAAACAAAAAEAAAAQAAAAAAAAAAoAAAAAAAAAAQAAAAAAAAA=","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQLAAAAAAIBAEAAAABJWQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGABZAA6IAAAAACAAAAAADUAAAAAAAEAAAAAIDEAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAMGAICAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQAAEAQAAAAGQCBAMQAAAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQEAAAAAAAAAEAAAABJIQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQAAEAQAAAAGQCEIBAAAAIAAAAAACQAGAAAAAQAAAAAGBCAIAAAAAFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"CgAAAExTS1PoAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWNsYW1wX1MxX2MwOwoJbGF5b3V0KG9mZnNldD0zMikgZmxvYXQzeDMgdW1hdHJpeF9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gZmxvYXQyIGxvY2FsQ29vcmQ7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwoJewoJCXZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwID0gZmxvYXQzeDIodW1hdHJpeF9TMSkgKiBsb2NhbENvb3JkLnh5MTsKCX0KfQoAAAAAOQQAAGxheW91dChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHNhbXBsZXIyRCB1VGV4dHVyZVNhbXBsZXJfMF9TMTsKbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWNsYW1wX1MxX2MwOwoJbGF5b3V0KG9mZnNldD0zMikgZmxvYXQzeDMgdW1hdHJpeF9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfMl9TMDsKaGFsZjQgVGV4dHVyZUVmZmVjdF9TMV9jMChoYWxmNCBfaW5wdXQpIAp7CglmbG9hdDIgaW5Db29yZCA9IHZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwOwoJZmxvYXQyIHN1YnNldENvb3JkOwoJc3Vic2V0Q29vcmQueCA9IGluQ29vcmQueDsKCXN1YnNldENvb3JkLnkgPSBpbkNvb3JkLnk7CglmbG9hdDIgY2xhbXBlZENvb3JkOwoJY2xhbXBlZENvb3JkLnggPSBzdWJzZXRDb29yZC54OwoJY2xhbXBlZENvb3JkLnkgPSBjbGFtcChzdWJzZXRDb29yZC55LCB1Y2xhbXBfUzFfYzAueSwgdWNsYW1wX1MxX2MwLncpOwoJaGFsZjQgdGV4dHVyZUNvbG9yID0gc2FtcGxlKHVUZXh0dXJlU2FtcGxlcl8wX1MxLCBjbGFtcGVkQ29vcmQpLjAwMHI7CglyZXR1cm4gdGV4dHVyZUNvbG9yOwp9CmhhbGY0IE1hdHJpeEVmZmVjdF9TMShoYWxmNCBfaW5wdXQpIAp7CglyZXR1cm4gVGV4dHVyZUVmZmVjdF9TMV9jMChfaW5wdXQpOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gaGFsZjQoMSk7Cgljb25zdCBoYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KDEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gTWF0cml4RWZmZWN0X1MxKG91dHB1dENvbG9yX1MwKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRfUzEgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCQlza19GcmFnQ29sb3IgPSBza19GcmFnQ29sb3IuYTAwMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHQAAAAgAAAABAAAAEAAAAAAAAAAKAAAAAAAAAAEAAAAAAAAA","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAIBAEAAAABJYQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEAAZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAIAAAAAAAA":"CgAAAExTS1OpAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgb3V0IGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgl2Y29sb3JfUzAgPSBjb2xvcjsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAAAAAiAMAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQ0IHVpbm5lclJlY3RfUzE7CglsYXlvdXQob2Zmc2V0PTMyKSBoYWxmMiB1cmFkaXVzUGx1c0hhbGZfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKaGFsZjQgQ2lyY3VsYXJSUmVjdF9TMShoYWxmNCBfaW5wdXQpIAp7CglmbG9hdDIgZHh5MCA9IHVpbm5lclJlY3RfUzEuTFQgLSBza19GcmFnQ29vcmQueHk7CglmbG9hdCBkeDEgPSBza19GcmFnQ29vcmQueCAtIHVpbm5lclJlY3RfUzEuUjsKCWZsb2F0MiBkeHkgPSBtYXgoZmxvYXQyKG1heChkeHkwLngsIGR4MSksIGR4eTAueSksIDAuMCk7CgloYWxmIGJvdHRvbUFscGhhID0gaGFsZihzYXR1cmF0ZSh1aW5uZXJSZWN0X1MxLkIgLSBza19GcmFnQ29vcmQueSkpOwoJaGFsZiBhbHBoYSA9IGJvdHRvbUFscGhhICogaGFsZihzYXR1cmF0ZSh1cmFkaXVzUGx1c0hhbGZfUzEueCAtIGxlbmd0aChkeHkpKSk7CglyZXR1cm4gX2lucHV0ICogYWxwaGE7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBDaXJjdWxhclJSZWN0X1MxKG91dHB1dENvdmVyYWdlX1MwKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dF9TMTsKCX0KfQoBAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADEAANAAAAALHCKLMRAAAAAAAAABAAAAAGJBCFLQVBWAQAAAAAAQAAAAAMACQCAACAAAAA2AIBAEIAAAAAAAAAAAAIADQAAAAIAAAAAAAIIDAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAMGAICAAAAAAAA":"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","DASAAAAAQAAWAABAYAAQBYH7777Z6QQBAEAAAAAAEAAAAAAAEBSAAAB2AAAAAAACAAAAAEBSAAAAARQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","CMRQCIAABBYAAAEIXBAAACDQMAABRAFAAAAAAAAAAAAAAAEABYAAAAEAAAAAAAEEBQAAAACQAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQGAAAAAAIBAEAAAABJMQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAAAAEAAAABJYQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABYQAGAAAEAAAAAAAIADQAAAAIAAAAAAAIIDCQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","DAQAAAAAAABGAABAYAAQAIHCAIAYAQUBAEAAAAAAEAAAAAAAAAAAAIAD2AAAAAAQAVSWGRIBAAADAAAAACAAAAAAQCGEIQOZLBIQAAAABQAAAAAAAAAAAAFAAMAAAABAAAAAAABBAMAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"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","CMRQCIAABBYAAAEIXBAAACDQMAABRAFAAAAAAAAAAAAAAAGIAHSACAAAAQAAAAAA5AAAAAAABAAAAACAZAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","HVJAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAABAAAAAABBAMABAAOAAAABAAAAAAABBAMAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"CgAAAExTS1PMAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgZmxhdCBvdXQgaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgZmxvYXQyIHZsb2NhbENvb3JkX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJdmxvY2FsQ29vcmRfUzAgPSBsb2NhbENvb3JkOwoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwp9CgAAAABvAgAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MwOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgaW4gaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgdmxvY2FsQ29vcmRfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2Y29sb3JfUzA7CglmbG9hdDIgdGV4Q29vcmQ7Cgl0ZXhDb29yZCA9IHZsb2NhbENvb3JkX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSAoKHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMCwgdGV4Q29vcmQpICogb3V0cHV0Q29sb3JfUzApKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAEAAAAAAAAAAwAAAB0AAAAAAAAAAQAAAAkAAAAIAAAAAQAAAB0AAAAMAAAAAQAAABQAAAAAAAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABYQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDCQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","GCAAAAAADAAAEAABBYAAAAYXBAAAAAAAAAAAAAAA2AAQAAAACAAAAAEASAAQAAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"CgAAAExTS1PRAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7CglsYXlvdXQob2Zmc2V0PTI0KSBoYWxmIHVDb3ZlcmFnZV9TMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBpblBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBoYWxmNCBpbkhhaXJRdWFkRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGhhbGY0IHZIYWlyUXVhZEVkZ2VfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWQKCXZIYWlyUXVhZEVkZ2VfUzAgPSBpbkhhaXJRdWFkRWRnZTsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247Cglza19Qb3NpdGlvbiA9IF90bXBfMV9pblBvc2l0aW9uLnh5MDE7Cn0KAAAAAAAAAGYDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGhhbGY0IHVDb2xvcl9TMDsKCWxheW91dChvZmZzZXQ9MjQpIGhhbGYgdUNvdmVyYWdlX1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdkhhaXJRdWFkRWRnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWQKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB1Q29sb3JfUzA7CgloYWxmIGVkZ2VBbHBoYTsKCWhhbGYyIGR1dmR4ID0gaGFsZjIoZEZkeCh2SGFpclF1YWRFZGdlX1MwLnh5KSk7CgloYWxmMiBkdXZkeSA9IGhhbGYyKGRGZHkodkhhaXJRdWFkRWRnZV9TMC54eSkpOwoJaGFsZjIgZ0YgPSBoYWxmMigyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeC54IC0gZHV2ZHgueSwgICAgICAgICAgICAgICAyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeS54IC0gZHV2ZHkueSk7CgllZGdlQWxwaGEgPSBoYWxmKHZIYWlyUXVhZEVkZ2VfUzAueCAqIHZIYWlyUXVhZEVkZ2VfUzAueCAtIHZIYWlyUXVhZEVkZ2VfUzAueSk7CgllZGdlQWxwaGEgPSBzcXJ0KGVkZ2VBbHBoYSAqIGVkZ2VBbHBoYSAvIGRvdChnRiwgZ0YpKTsKCWVkZ2VBbHBoYSA9IG1heCgxLjAgLSBlZGdlQWxwaGEsIDAuMCk7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KHVDb3ZlcmFnZV9TMCAqIGVkZ2VBbHBoYSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAfAAAACAAAAAEAAAAYAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQJAAAAAAIBAEAAAABJSQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","B2AAQAAABQAAIAABBYAAB7777777777774ABICAAAAAAAAAAAAAAAOMAHQAABAAAAAAAAAA5AAAAAAABAAAAACAZABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1NOAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZjQgdmNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwp9CgAAAAAAAH0BAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAEAQAAAAGQCBAMQACAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABDAAAAAAEAAAAAAAAAAAAAAAAACAAAAAABQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAEAQAAAAGQCBAMQACAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGABZAA6IAAAAACAAAAAADUAAAAAAAEAAAAAIDEAAAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAMGAICAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABYQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDCQAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEAAAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAAMHCHGACAAQAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAADAYRYQAQYEAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAIAEOHAEGBCAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAEMHAHGBCAAAAA5B3UTQIDAAAAAEAAAAAJAQJDRYBRQIQAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAMGAIAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQEAAAAAAAAAEAAAABJIQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAQAAAAAAAA":"CgAAAExTS1NTAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAACCAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAMAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADEAANAAAAAUKQGZLBIAAAAACQAAAA4QAQAAAIAAAABSCICSKI2FIFAAAEAAIAAAAAAAAAAADZEBYAAAIAAAAAACQAGAAAAAQAAAAAAAQQGUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","FAAQMYAAMAAAEADAAABAEYAAAICIAB5AABQAAAQAMAAAEATAAABAIIGAAEDCBYQCA4AAAAAAEADZABYAAAIAAAAAACQAGAAAAAQAAAAAAAQQGRQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAAAQAAAAGQCBAMQACAAAAAAAACQAGAAAAAQAAAAAAAQQGAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGAAZAADIAAAACU53QJEKAAAAAAMAAAAAIAAAAAAGIRDFB2XASAUAABQAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAB3QA6AAAEAAAAAAAMAAPEAEAAABAAAAAAB2AAAAAAACAAAAAEBSAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","HTRQAGAABBYAAAEIXBAAAGEAMAAAAAAAAAAAAAAAWAGHAIBZ5AJQAAAA5C5DCQYAAAAABADI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAAAAEAAAAAZFE5PDAYAIAAAAABITF56OQIAAAQAAQAAAARGWBRHUQAAAAB2DXJHAQGAAAAAEAAAAASAIYRFV5O4JAAAAAAYAAAABEWJRHQQQCAAAKBXZFAUHQAAAAIAAAAACAAYJVSMJ4EEAQAAAAAAAABMBC7UXCS6AAAAAAAAIAAAADFVHPSKBAOAAAAAAAAAAAWCBAAAABAAAAANAEIQCAAAAAAAAAAABQAAGQAAAAKFIDMVQUAAAAAAYAAAAAQAAAADEEQFEURUKQKAAAYAAAAAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEADZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAARQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAACIDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1aW5uZXJSZWN0X1MxOwoJbGF5b3V0KG9mZnNldD0zMikgaGFsZjIgdXJhZGl1c1BsdXNIYWxmX1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdmNvbG9yX1MwOwpoYWxmNCBDaXJjdWxhclJSZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCWZsb2F0MiBkeHkwID0gdWlubmVyUmVjdF9TMS5MVCAtIHNrX0ZyYWdDb29yZC54eTsKCWZsb2F0MiBkeHkxID0gc2tfRnJhZ0Nvb3JkLnh5IC0gdWlubmVyUmVjdF9TMS5SQjsKCWZsb2F0MiBkeHkgPSBtYXgobWF4KGR4eTAsIGR4eTEpLCAwLjApOwoJaGFsZiBhbHBoYSA9IGhhbGYoc2F0dXJhdGUodXJhZGl1c1BsdXNIYWxmX1MxLnggLSBsZW5ndGgoZHh5KSkpOwoJcmV0dXJuIF9pbnB1dCAqIGFscGhhOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2Y29sb3JfUzA7Cgljb25zdCBoYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KDEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gQ2lyY3VsYXJSUmVjdF9TMShvdXRwdXRDb3ZlcmFnZV9TMCk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRfUzE7Cgl9Cn0KAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","CMRQCIAABBYAAAEIXBAAACDQMAABRAFAAAAAAAAAAAAAAAEABYAAAAEAAAAAAAEEBQAAAACQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","B2AAQAAABQAAIAABBYAAB7777777777774ABICAAAAAAAAAAAAAABUABAAAAAEAAAAAIBEABAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OxAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZiBpbkNvdmVyYWdlOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZiB2aW5Db3ZlcmFnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgRGVmYXVsdEdlb21ldHJ5UHJvY2Vzc29yCglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJdmluQ292ZXJhZ2VfUzAgPSBpbkNvdmVyYWdlOwoJc2tfUG9zaXRpb24gPSBfdG1wXzFfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAAADJAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBoYWxmIHZpbkNvdmVyYWdlX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgRGVmYXVsdEdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdUNvbG9yX1MwOwoJaGFsZiBhbHBoYSA9IDEuMDsKCWFscGhhID0gdmluQ292ZXJhZ2VfUzA7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAcAAAACAAAAAEAAAAMAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGABBACUIAAAAABAAOAAAABAAAAAAABBAMAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAIAAAAAAAA":"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","B2ABSAAABQAAIAABBYAAB7777777777774ABICAAAAAAAAAAAAAABUABAAAAAEAAAAAIBEABAAAAARQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"CgAAAExTS1MCAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZiBpbkNvdmVyYWdlOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZjQgdmNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBEZWZhdWx0R2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IGNvbG9yID0gdUNvbG9yX1MwOwoJY29sb3IgPSBjb2xvciAqIGluQ292ZXJhZ2U7Cgl2Y29sb3JfUzAgPSBjb2xvcjsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8zX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJc2tfUG9zaXRpb24gPSBfdG1wXzFfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAAJsBAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGhhbGY0IHVDb2xvcl9TMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIERlZmF1bHRHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVAAAAAEAAAAAAAAAAgAAAB0AAAAAAAAAAQAAABwAAAAIAAAAAQAAAAwAAAAAAAAARgAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGAAZAIAAAAAAAAAACAAAAAABLBAABAAAAABAEGQCEAAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEAAZAAAAA6IAAAAACAAAAADZEBYAAAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAAKUAQFAACYAAAAAIAAAABLBAABAAAAABAEGABBAMAAAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAAAAYAAIAAAAAAAA":"
   LSKS)  layout (metal, binding=0) uniform uniformBuffer
{
	layout(offset=0) float4 sk_RTAdjust;
	layout(offset=16) float3x3 umatrix_S1_c0;
	layout(offset=64) half4 uKernel_S1[7];
	layout(offset=120) half2 uKernelOffset_S1;
	layout(offset=124) half uGain_S1;
	layout(offset=126) half uBias_S1;
}
;
layout(location = 0) in float2 position;
layout(location = 1) in float2 localCoord;
layout(location = 0) out float2 vLocalCoord_S0;
void main() 
{
	// Primitive Processor QuadPerEdgeAAGeometryProcessor
	vLocalCoord_S0 = localCoord;
	sk_Position = position.xy01;
}
       O  layout(metal, binding=0) uniform sampler2D uTextureSampler_0_S1;
layout (metal, binding=0) uniform uniformBuffer
{
	layout(offset=0) float4 sk_RTAdjust;
	layout(offset=16) float3x3 umatrix_S1_c0;
	layout(offset=64) half4 uKernel_S1[7];
	layout(offset=120) half2 uKernelOffset_S1;
	layout(offset=124) half uGain_S1;
	layout(offset=126) half uBias_S1;
}
;
layout(location = 0) in float2 vLocalCoord_S0;
half4 TextureEffect_S1_c0_c0(half4 _input, float2 _coords) 
{
	return sample(uTextureSampler_0_S1, _coords);
}
half4 MatrixEffect_S1_c0(half4 _input, float2 _coords) 
{
	return TextureEffect_S1_c0_c0(_input, float3x2(umatrix_S1_c0) * _coords.xy1);
}
half4 MatrixConvolution_S1(half4 _input) 
{
	half4 sum = half4(0);
	float2 coord = vLocalCoord_S0 - uKernelOffset_S1;
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(0, 0);
		k = uKernel_S1[0][0];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(0, 1);
		k = uKernel_S1[1][1];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(0, 2);
		k = uKernel_S1[2][2];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(0, 3);
		k = uKernel_S1[3][3];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(0, 4);
		k = uKernel_S1[5][0];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(1, 0);
		k = uKernel_S1[0][1];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(1, 1);
		k = uKernel_S1[1][2];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(1, 2);
		k = uKernel_S1[2][3];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(1, 3);
		k = uKernel_S1[4][0];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(1, 4);
		k = uKernel_S1[5][1];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(2, 0);
		k = uKernel_S1[0][2];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(2, 1);
		k = uKernel_S1[1][3];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(2, 2);
		k = uKernel_S1[3][0];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(2, 3);
		k = uKernel_S1[4][1];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(2, 4);
		k = uKernel_S1[5][2];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(3, 0);
		k = uKernel_S1[0][3];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(3, 1);
		k = uKernel_S1[2][0];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(3, 2);
		k = uKernel_S1[3][1];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(3, 3);
		k = uKernel_S1[4][2];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(3, 4);
		k = uKernel_S1[5][3];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(4, 0);
		k = uKernel_S1[1][0];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(4, 1);
		k = uKernel_S1[2][1];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(4, 2);
		k = uKernel_S1[3][2];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(4, 3);
		k = uKernel_S1[4][3];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	{
		half k;
		half2 sourceOffset;
		sourceOffset = half2(4, 4);
		k = uKernel_S1[6][0];
		half4 c = MatrixEffect_S1_c0(_input, coord + sourceOffset);
		sum += c * k;
	}
	half4 color;
	color = sum * uGain_S1 + uBias_S1;
	color.a = saturate(color.a);
	color.rgb = clamp(color.rgb, 0.0, color.a);
	return color;
}
void main() 
{
	// Stage 0, QuadPerEdgeAAGeometryProcessor
	half4 outputColor_S0 = half4(1);
	const half4 outputCoverage_S0 = half4(1);
	half4 output_S1;
	output_S1 = MatrixConvolution_S1(outputColor_S0);
	{
		// Xfer Processor: Porter Duff
		sk_FragColor = output_S1 * outputCoverage_S0;
	}
}
                                   <                                       P              ","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAMWAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAAHAJRUYWBAAAAA2DXZFAQHAAAAAAAAEAAAAABAEMFPYMZ2AAAAAAAQFV566JAAAAAAYAAAADQEY2EKAUAQAAFA34SQKDYAAAACAAAAABAEMIC263PESAAAAAMAAAAAYCM5AFALAIAAAQF7JMFB4AAAACAAAAAAQAGHEJRUYWBAAAAAAAAAAAFQEL6S4KLYAAAAAAABAAAAAMWU56JIEBYAAAAAAAAAACYIEAAAAEAAAABUARCAIAAAAAAAAAAAOAAHSAAAAAAQAAAAAA5AAAAAAABAAAAACAZAAAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADIAANAAAAALHCKLMRAAAAAAAAABAAAAAGJBCFLQVBWAQAAAAAAQAAAAAMACQCAACAAAAA2AIBAEIAAAAAAAAAAAAMAAPEAEAAABAAAAAAB2AAAAAAACAAAAAEBSAAIYAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"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","HVJAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAABAAAAAABBAMADSAB4QAAAAAEAAAAAAHIAAAAAAAIAAAAAQGIAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGACQAGAAAAAQAAAAAAAQQGAAAIYAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"CgAAAExTS1NkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGZsb2F0MiBsb2NhbENvb3JkOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgZmxvYXQyIHZsb2NhbENvb3JkX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZsb2NhbENvb3JkX1MwID0gbG9jYWxDb29yZDsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAKQIAAGxheW91dChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHNhbXBsZXIyRCB1VGV4dHVyZVNhbXBsZXJfMF9TMDsKbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgdmxvY2FsQ29vcmRfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gaGFsZjQoMSk7CglmbG9hdDIgdGV4Q29vcmQ7Cgl0ZXhDb29yZCA9IHZsb2NhbENvb3JkX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSAoKHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMCwgdGV4Q29vcmQpICogaGFsZjQoMSkpKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHQAAAAgAAAABAAAAEAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQFAAAAAAIBAEAAAABJKQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABDAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAQAAAAAAAA":"CgAAAExTS1NTAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAACCAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAMAAAAAAAAAEYAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAABYCMNGFQIAAAAGQ56JIEBYAAAAAAABAAAAAAIBDBL6DGOQAAAAAAEAAAAABALL354SAAAAABQAAAAHAJRUIUBIBAAAKBXZFAUHQAAAAEAAAAABAIMQAAAAAEBNPNXSJAAAAAGAAAAAMBGOQCQFQEAAAIC7UWCQ6AAAAAQAAAAAIBDCAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAIAAAABTZCMNCFAKAIAAAAAAAAAMBC7UXKS6AAAAAAAAIAAAADEVDPSKBIPAAAAAAAAAAAGABIBAABAAAAANAEIQCAAAAAAAAAAABAAOAAAABAAAAAAABBAMRQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAAAAEAAAABJYQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAADUAANAAAAAAAAAIAAAABLAIABAAAAABAEGQCEAAAAAAAAAAAAAAB2AAAAAAACAAAAAQ2EAAAAACQAAAAACAAAAAAAAAAAAAAAAABAAAAAAAYAAAAAAAAAAA":"CgAAAExTS1PGAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfM19TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzNfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxX2MwKSAqIGxvY2FsQ29vcmQueHkxOwoJfQp9CgAAAAAAAHQDAABsYXlvdXQobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSBzYW1wbGVyMkQgdVRleHR1cmVTYW1wbGVyXzBfUzE7CmxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfM19TMDsKaGFsZjQgVGV4dHVyZUVmZmVjdF9TMV9jMF9jMChoYWxmNCBfaW5wdXQpIAp7CglyZXR1cm4gc2FtcGxlKHVUZXh0dXJlU2FtcGxlcl8wX1MxLCB2VHJhbnNmb3JtZWRDb29yZHNfM19TMCkuMDAwcjsKfQpoYWxmNCBNYXRyaXhFZmZlY3RfUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJcmV0dXJuIFRleHR1cmVFZmZlY3RfUzFfYzBfYzAoX2lucHV0KTsKfQpoYWxmNCBCbGVuZF9TMShoYWxmNCBfc3JjLCBoYWxmNCBfZHN0KSAKewoJcmV0dXJuIGJsZW5kX21vZHVsYXRlKE1hdHJpeEVmZmVjdF9TMV9jMChfc3JjKSwgX3NyYyk7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzAgPSBoYWxmNCgxKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBCbGVuZF9TMShvdXRwdXRDb2xvcl9TMCwgaGFsZjQoMSkpOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dF9TMSAqIG91dHB1dENvdmVyYWdlX1MwOwoJCXNrX0ZyYWdDb2xvciA9IHNrX0ZyYWdDb2xvci5hMDAwOwoJfQp9CgAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAdAAAACAAAAAEAAAAQAAAAAAAAAAoAAAAAAAAAAQAAAAAAAAA=","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABDAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"CgAAAExTS1NOAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZjQgdmNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwp9CgAAAAAAAH0BAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADEAAGAAAAAAAAAIAAAAAPAIABAAAAACYGEAAAAEAAAABUARCAIAAAAAAAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","GEMAAAYAAEHAAAARC4EAAAQWBQAAAAAAAAAQAAAAIBCAAAGQAEAAAAAQAAAABAEQAEAAAACGAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"CgAAAExTS1P9AQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gaGFsZjMgaW5TaGFkb3dQYXJhbXM7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmMyB2aW5TaGFkb3dQYXJhbXNfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIG91dCBoYWxmNCB2aW5Db2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUlJlY3RTaGFkb3cKCXZpblNoYWRvd1BhcmFtc19TMCA9IGluU2hhZG93UGFyYW1zOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCXNrX1Bvc2l0aW9uID0gX3RtcF8wX2luUG9zaXRpb24ueHkwMTsKfQoAAAAAAAAAqgIAAGxheW91dChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHNhbXBsZXIyRCB1VGV4dHVyZVNhbXBsZXJfMF9TMDsKbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBoYWxmMyB2aW5TaGFkb3dQYXJhbXNfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgUlJlY3RTaGFkb3cKCWhhbGYzIHNoYWRvd1BhcmFtczsKCXNoYWRvd1BhcmFtcyA9IHZpblNoYWRvd1BhcmFtc19TMDsKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2aW5Db2xvcl9TMDsKCWhhbGYgZCA9IGxlbmd0aChzaGFkb3dQYXJhbXMueHkpOwoJZmxvYXQyIHV2ID0gZmxvYXQyKHNoYWRvd1BhcmFtcy56ICogKDEuMCAtIGQpLCAwLjUpOwoJaGFsZiBmYWN0b3IgPSBzYW1wbGUodVRleHR1cmVTYW1wbGVyXzBfUzAsIHV2KS4wMDByLmE7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGZhY3Rvcik7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAABAAAAAAAAAAMAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAeAAAADAAAAAEAAAAYAAAAAAAAAEYAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAQAAAAAAAA":"CgAAAExTS1NTAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAACCAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAMAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQJAAAAAAAAAEAAAABJSQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"CgAAAExTS1NQAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwX2MwOwoJbGF5b3V0KG9mZnNldD02NCkgaGFsZjIgdUluY3JlbWVudF9TMV9jMDsKCWxheW91dChvZmZzZXQ9NjgpIGhhbGYyIHVPZmZzZXRzQW5kS2VybmVsX1MxX2MwWzEwXTsKCWxheW91dChvZmZzZXQ9MTEyKSBmbG9hdDN4MyB1bWF0cml4X1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfMl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxKSAqIGxvY2FsQ29vcmQueHkxOwoJfQp9CgAAAACnBQAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0M3gzIHVtYXRyaXhfUzFfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTY0KSBoYWxmMiB1SW5jcmVtZW50X1MxX2MwOwoJbGF5b3V0KG9mZnNldD02OCkgaGFsZjIgdU9mZnNldHNBbmRLZXJuZWxfUzFfYzBbMTBdOwoJbGF5b3V0KG9mZnNldD0xMTIpIGZsb2F0M3gzIHVtYXRyaXhfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CmhhbGY0IFRleHR1cmVFZmZlY3RfUzFfYzBfYzBfYzAoaGFsZjQgX2lucHV0LCBmbG9hdDIgX2Nvb3JkcykgCnsKCXJldHVybiBzYW1wbGUodVRleHR1cmVTYW1wbGVyXzBfUzEsIF9jb29yZHMpOwp9CmhhbGY0IE1hdHJpeEVmZmVjdF9TMV9jMF9jMChoYWxmNCBfaW5wdXQsIGZsb2F0MiBfY29vcmRzKSAKewoJcmV0dXJuIFRleHR1cmVFZmZlY3RfUzFfYzBfYzBfYzAoX2lucHV0LCBmbG9hdDN4Mih1bWF0cml4X1MxX2MwX2MwKSAqIF9jb29yZHMueHkxKTsKfQpoYWxmNCBTbW9vdGhfUzFfYzAoaGFsZjQgX2lucHV0LCBmbG9hdDIgY29vcmQsIGhhbGYyIG9mZnNldEFuZEtlcm5lbCkgCnsKCXJldHVybiBNYXRyaXhFZmZlY3RfUzFfYzBfYzAoX2lucHV0LCAoY29vcmQgKyBvZmZzZXRBbmRLZXJuZWwueCAqIHVJbmNyZW1lbnRfUzFfYzApKSAqIG9mZnNldEFuZEtlcm5lbC55Owp9CmhhbGY0IEdhdXNzaWFuQ29udm9sdXRpb25fUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgY29sb3IgPSBoYWxmNCgwKTsKCWZsb2F0MiBjb29yZCA9IHZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwOwoJZm9yIChpbnQgaT0wOyBpPDEwOyArK2kpIAoJewoJCWNvbG9yICs9IFNtb290aF9TMV9jMChfaW5wdXQsIGNvb3JkLCB1T2Zmc2V0c0FuZEtlcm5lbF9TMV9jMFtpXSk7Cgl9CglyZXR1cm4gY29sb3I7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBHYXVzc2lhbkNvbnZvbHV0aW9uX1MxX2MwKF9pbnB1dCk7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzAgPSBoYWxmNCgxKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBNYXRyaXhFZmZlY3RfUzEob3V0cHV0Q29sb3JfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dF9TMSAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHQAAAAgAAAABAAAAEAAAAAAAAABQAAAAAAAAAAEAAAAAAAAA","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGAAZAADIAAAACU53QJEKAAAAAAMAAAAAIAAAAAAGIRDFB2XASAUAABQAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAIYAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAACJMTCPBBAEAAAUDPSKBIPAAAAAAAAIAAAAACAIYKPQZ3UAAAAAABALL3N4SIAAAABQAAAACIMRCXBBEEQAAEAP2LRIPAAAAAIAAAAAAABTALI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAIAAAABSDBEIVYMJREAAAAAAAAAAAFPJO7EUCA4AAAAAQAAAAAICD7UXCS6AAAAAAAAAAAAACWCAACAAAAACAINAEIAAAAAAAAAAAAA5AAAAAAABAAAAACAZAAACQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQAAAAQAAAAGQCBAMQAAAAAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"CgAAAExTS1PAAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfMl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxKSAqIGxvY2FsQ29vcmQueHkxOwoJfQp9CgAAAADYAgAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0M3gzIHVtYXRyaXhfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CmhhbGY0IFRleHR1cmVFZmZlY3RfUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJcmV0dXJuIHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMSwgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzApOwp9CmhhbGY0IE1hdHJpeEVmZmVjdF9TMShoYWxmNCBfaW5wdXQpIAp7CglyZXR1cm4gVGV4dHVyZUVmZmVjdF9TMV9jMChfaW5wdXQpOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gaGFsZjQoMSk7Cgljb25zdCBoYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KDEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gTWF0cml4RWZmZWN0X1MxKG91dHB1dENvbG9yX1MwKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRfUzEgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHQAAAAgAAAABAAAAEAAAAAAAAABQAAAAAAAAAAEAAAAAAAAA","B2AAQAAABQAAIAABBYAAB7777777777774ABICAAAAAAAAAAAAAABUABAAAAAEAAAAAIBEABAAAAARQAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OxAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZiBpbkNvdmVyYWdlOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZiB2aW5Db3ZlcmFnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgRGVmYXVsdEdlb21ldHJ5UHJvY2Vzc29yCglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJdmluQ292ZXJhZ2VfUzAgPSBpbkNvdmVyYWdlOwoJc2tfUG9zaXRpb24gPSBfdG1wXzFfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAAADJAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBoYWxmIHZpbkNvdmVyYWdlX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgRGVmYXVsdEdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdUNvbG9yX1MwOwoJaGFsZiBhbHBoYSA9IDEuMDsKCWFscGhhID0gdmluQ292ZXJhZ2VfUzA7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAcAAAACAAAAAEAAAAMAAAAAAAAAEYAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGAAZAADIAAAAFCUBWKYKAAAAAAUAAAAHEAEAAACAAAAAMQSAUSSGRKBIAABAACAAAAAAAAAAAA6JAOAAACAAAAAAAUABQAAAAEAAAAAAAEEBVAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABYQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDCQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBQU7BTXIAAAAAACAWXW3ZEQAAAADAAAAAEQZCFOCCIJAAAIA7UXCQ6AAAAAQAAAAAAADGAWRWL3E4AQAADAAAAAAQBCFODCOJAAAAAPUXKS6AAAAAAAAQAAAADEGCIRLQYTCIAAAAAAAAAAAK6S56JIEBYAAAABAAAAAAQEH7JOFF4AAAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAICAACAAAAAAAA":"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","CMRQCIAABBYAAAEIXBAAACDQMAABRAFAAAAAAAAAAAAAAAEABYAAAAEAAAAAAAEEBQAAAACGAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGABZAAYIAAAAACAAAAAADUAAAAAAAEAAAAAIDEAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","B2AAQAAABQAAIAABBYAAB7777777777774ABICAAAAAAAAAAAAAABUABAAAAAEAAAAAIBEABAAAAARQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OxAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZiBpbkNvdmVyYWdlOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZiB2aW5Db3ZlcmFnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgRGVmYXVsdEdlb21ldHJ5UHJvY2Vzc29yCglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJdmluQ292ZXJhZ2VfUzAgPSBpbkNvdmVyYWdlOwoJc2tfUG9zaXRpb24gPSBfdG1wXzFfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAAADJAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBoYWxmIHZpbkNvdmVyYWdlX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgRGVmYXVsdEdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdUNvbG9yX1MwOwoJaGFsZiBhbHBoYSA9IDEuMDsKCWFscGhhID0gdmluQ292ZXJhZ2VfUzA7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAcAAAACAAAAAEAAAAMAAAAAAAAAEYAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAAAPEAHAAABAAAAAAAKAAYAAAACAAAAAAACCAYAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"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","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAAAPEAHAAABAAAAAAAKAAYAAAACAAAAAAACCAYAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAADUAANAAAAAAIBAIAAAABLCIIBAAAAABAEGABBAMAACAIAAAAAAAB2AAAAAAACAAAAAEBSAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAAAAYAAAAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEAAZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAIMDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1aW5uZXJSZWN0X1MxOwoJbGF5b3V0KG9mZnNldD0zMikgaGFsZjIgdXJhZGl1c1BsdXNIYWxmX1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdmNvbG9yX1MwOwpoYWxmNCBDaXJjdWxhclJSZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCWZsb2F0MiBkeHkwID0gdWlubmVyUmVjdF9TMS5MVCAtIHNrX0ZyYWdDb29yZC54eTsKCWZsb2F0IGR4MSA9IHNrX0ZyYWdDb29yZC54IC0gdWlubmVyUmVjdF9TMS5SOwoJZmxvYXQyIGR4eSA9IG1heChmbG9hdDIobWF4KGR4eTAueCwgZHgxKSwgZHh5MC55KSwgMC4wKTsKCWhhbGYgYm90dG9tQWxwaGEgPSBoYWxmKHNhdHVyYXRlKHVpbm5lclJlY3RfUzEuQiAtIHNrX0ZyYWdDb29yZC55KSk7CgloYWxmIGFscGhhID0gYm90dG9tQWxwaGEgKiBoYWxmKHNhdHVyYXRlKHVyYWRpdXNQbHVzSGFsZl9TMS54IC0gbGVuZ3RoKGR4eSkpKTsKCXJldHVybiBfaW5wdXQgKiBhbHBoYTsKfQp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmNvbG9yX1MwOwoJY29uc3QgaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNCgxKTsKCWhhbGY0IG91dHB1dF9TMTsKCW91dHB1dF9TMSA9IENpcmN1bGFyUlJlY3RfUzEob3V0cHV0Q292ZXJhZ2VfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0X1MxOwoJfQp9CgABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","FAAQMYAAMAAAEADAAABAEYAAAICIAB5AABQAAAQAMAAAEATAAABAIIGAAEDCBYQCA4AAAAAAAAFAAAAAACDIQAAAAAFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAADUAANAAAAAAAAAIAAAABLAIABAAAAABAEGABBAMAAAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAARQAAAAACAAAAAAAAAAAAAAAAABAAAAAAAYAAAAAAAAAAA":"CgAAAExTS1PGAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfM19TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzNfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxX2MwKSAqIGxvY2FsQ29vcmQueHkxOwoJfQp9CgAAAAAAAEsDAABsYXlvdXQobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSBzYW1wbGVyMkQgdVRleHR1cmVTYW1wbGVyXzBfUzE7CmxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfM19TMDsKaGFsZjQgVGV4dHVyZUVmZmVjdF9TMV9jMF9jMChoYWxmNCBfaW5wdXQpIAp7CglyZXR1cm4gc2FtcGxlKHVUZXh0dXJlU2FtcGxlcl8wX1MxLCB2VHJhbnNmb3JtZWRDb29yZHNfM19TMCk7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxX2MwKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBUZXh0dXJlRWZmZWN0X1MxX2MwX2MwKF9pbnB1dCk7Cn0KaGFsZjQgQmxlbmRfUzEoaGFsZjQgX3NyYywgaGFsZjQgX2RzdCkgCnsKCXJldHVybiBibGVuZF9tb2R1bGF0ZShNYXRyaXhFZmZlY3RfUzFfYzAoX3NyYyksIF9zcmMpOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gaGFsZjQoMSk7Cgljb25zdCBoYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KDEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gQmxlbmRfUzEob3V0cHV0Q29sb3JfUzAsIGhhbGY0KDEpKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRfUzEgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAAAAAEAAAAAAAAAAgAAAB0AAAAAAAAAAQAAAB0AAAAIAAAAAQAAABAAAAAAAAAARgAAAAAAAAABAAAAAAAAAA==","CIAAAAAAQAARQAAYQAAAAGFYQAABRAAAAEEAAAAAAARAEAGIAGCACAAAAQAAAAAA5AAAAAAABAAAAACAZAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","IYBAAAAABAAACAABBYAAAKAAAMAAGEAAAABRAEAAAEHCAAAAAAAABCAAAAAABAEQAEAAAAAKAAAAABAAAAAP2AAAAAAQAAAAAAAAAAACAAAAAAAAAAAA":"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","GEMAAAYAAEHAAAARC4EAAAQWBQAAAAAAAAAQAAAAIBCAAAGQAEAAAAAQAAAABAEQAEAAAACQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"CgAAAExTS1P9AQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gaGFsZjMgaW5TaGFkb3dQYXJhbXM7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmMyB2aW5TaGFkb3dQYXJhbXNfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIG91dCBoYWxmNCB2aW5Db2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUlJlY3RTaGFkb3cKCXZpblNoYWRvd1BhcmFtc19TMCA9IGluU2hhZG93UGFyYW1zOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCXNrX1Bvc2l0aW9uID0gX3RtcF8wX2luUG9zaXRpb24ueHkwMTsKfQoAAAAAAAAAqgIAAGxheW91dChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHNhbXBsZXIyRCB1VGV4dHVyZVNhbXBsZXJfMF9TMDsKbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBoYWxmMyB2aW5TaGFkb3dQYXJhbXNfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgUlJlY3RTaGFkb3cKCWhhbGYzIHNoYWRvd1BhcmFtczsKCXNoYWRvd1BhcmFtcyA9IHZpblNoYWRvd1BhcmFtc19TMDsKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2aW5Db2xvcl9TMDsKCWhhbGYgZCA9IGxlbmd0aChzaGFkb3dQYXJhbXMueHkpOwoJZmxvYXQyIHV2ID0gZmxvYXQyKHNoYWRvd1BhcmFtcy56ICogKDEuMCAtIGQpLCAwLjUpOwoJaGFsZiBmYWN0b3IgPSBzYW1wbGUodVRleHR1cmVTYW1wbGVyXzBfUzAsIHV2KS4wMDByLmE7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGZhY3Rvcik7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAABAAAAAAAAAAMAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAeAAAADAAAAAEAAAAYAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAAAQAAAAGQCBAMQACAAAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAAABQAAQAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAYEIBAAAAFAAAAAAQAAAAH5AAAAAAIAAAAAAAAAAABQAAQAAAAAAAA":"CgAAAExTS1NTAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAACmAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCQlza19GcmFnQ29sb3IgPSBza19GcmFnQ29sb3IuYTAwMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAMAAAAAAAAAAoAAAAAAAAAAQAAAP0AAAA=","HTRQAGAABBYAAAEIXBAAAGEAMAAAAAAAAAAAAAAAWAGHAIBZ5AJQAAAA5C5DCQYAAAAABAAAAAAIA2GZPMTQCAAAMAAAAAEACHDQCDARAAAAAPGD4GCQAAAAAAAAABAAAAAGJJHLYYGACAAAAAAAEAAAACRGL345AQAABAABAAAAARQ4A4YEIAAAADYAZBYXAIAAAAAIAAAABSAQBAAAAAEIS26XOEQAAAAAMAAAAAMHCHGACAAQAAGAGMOF4CAAAAACAAAAABAEMIC263PESAAAAAMAAAAAMDCHCACDAQAAAAGPOB4CCAAAAAAACAAAAAMTJYRYQAQQEAAAAAAAAAGARJ4INQYLAEAAAAAEAAAABSEQM44LYEAAAAAAAAAAADAAUAQAAQAAAAGQCAIBCAAAAAAAAAAAYAADIAAAABCEDWKYKEAAAAAMAAAAAIAAAAACAI2RKA3FMFAAAAAAGAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAMWAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAASLEYTYIIBAAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAAEQZCFOCCIJAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAEAIRLQYTSIAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAITLAYT2IAAAAA5B3UTQIDAAAAAEAAAAAJBQKEKYGE6SAAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAABYQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1OAAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGluUG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGluQ29sb3I7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0NCBpbkNpcmNsZUVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJdmluQ2lyY2xlRWRnZV9TMCA9IGluQ2lyY2xlRWRnZTsKCXZpbkNvbG9yX1MwID0gaW5Db2xvcjsKCWZsb2F0MiBfdG1wXzBfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSB1bG9jYWxNYXRyaXhfUzAueHogKiBpblBvc2l0aW9uICsgdWxvY2FsTWF0cml4X1MwLnl3OwoJc2tfUG9zaXRpb24gPSBfdG1wXzBfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAACbAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAQAAAAAAAAADAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAAHwAAAAwAAAABAAAAHAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"CgAAAExTS1NTAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAACCAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAMAAAAAAAAAFAAAAAAAAAAAQAAAAAAAAA=","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQGAAAAAAABAEAAAABJMQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"CgAAAExTS1N9AgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWNsYW1wX1MxX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD0zMikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMF9jMDsKCWxheW91dChvZmZzZXQ9ODApIGhhbGYyIHVJbmNyZW1lbnRfUzFfYzA7CglsYXlvdXQob2Zmc2V0PTg0KSBoYWxmMiB1T2Zmc2V0c0FuZEtlcm5lbF9TMV9jMFs3XTsKCWxheW91dChvZmZzZXQ9MTEyKSBmbG9hdDN4MyB1bWF0cml4X1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfMl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxKSAqIGxvY2FsQ29vcmQueHkxOwoJfQp9CgAAAAAAAADvBgAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1Y2xhbXBfUzFfYzBfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTMyKSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwX2MwOwoJbGF5b3V0KG9mZnNldD04MCkgaGFsZjIgdUluY3JlbWVudF9TMV9jMDsKCWxheW91dChvZmZzZXQ9ODQpIGhhbGYyIHVPZmZzZXRzQW5kS2VybmVsX1MxX2MwWzddOwoJbGF5b3V0KG9mZnNldD0xMTIpIGZsb2F0M3gzIHVtYXRyaXhfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CmhhbGY0IFRleHR1cmVFZmZlY3RfUzFfYzBfYzBfYzAoaGFsZjQgX2lucHV0LCBmbG9hdDIgX2Nvb3JkcykgCnsKCWZsb2F0MiBpbkNvb3JkID0gX2Nvb3JkczsKCWZsb2F0MiBzdWJzZXRDb29yZDsKCXN1YnNldENvb3JkLnggPSBpbkNvb3JkLng7CglzdWJzZXRDb29yZC55ID0gaW5Db29yZC55OwoJZmxvYXQyIGNsYW1wZWRDb29yZDsKCWNsYW1wZWRDb29yZC54ID0gc3Vic2V0Q29vcmQueDsKCWNsYW1wZWRDb29yZC55ID0gY2xhbXAoc3Vic2V0Q29vcmQueSwgdWNsYW1wX1MxX2MwX2MwX2MwLnksIHVjbGFtcF9TMV9jMF9jMF9jMC53KTsKCWhhbGY0IHRleHR1cmVDb2xvciA9IHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMSwgY2xhbXBlZENvb3JkKTsKCXJldHVybiB0ZXh0dXJlQ29sb3I7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxX2MwX2MwKGhhbGY0IF9pbnB1dCwgZmxvYXQyIF9jb29yZHMpIAp7CglyZXR1cm4gVGV4dHVyZUVmZmVjdF9TMV9jMF9jMF9jMChfaW5wdXQsIGZsb2F0M3gyKHVtYXRyaXhfUzFfYzBfYzApICogX2Nvb3Jkcy54eTEpOwp9CmhhbGY0IFNtb290aF9TMV9jMChoYWxmNCBfaW5wdXQsIGZsb2F0MiBjb29yZCwgaGFsZjIgb2Zmc2V0QW5kS2VybmVsKSAKewoJcmV0dXJuIE1hdHJpeEVmZmVjdF9TMV9jMF9jMChfaW5wdXQsIChjb29yZCArIG9mZnNldEFuZEtlcm5lbC54ICogdUluY3JlbWVudF9TMV9jMCkpICogb2Zmc2V0QW5kS2VybmVsLnk7Cn0KaGFsZjQgR2F1c3NpYW5Db252b2x1dGlvbl9TMV9jMChoYWxmNCBfaW5wdXQpIAp7CgloYWxmNCBjb2xvciA9IGhhbGY0KDApOwoJZmxvYXQyIGNvb3JkID0gdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7Cglmb3IgKGludCBpPTA7IGk8NzsgKytpKSAKCXsKCQljb2xvciArPSBTbW9vdGhfUzFfYzAoX2lucHV0LCBjb29yZCwgdU9mZnNldHNBbmRLZXJuZWxfUzFfYzBbaV0pOwoJfQoJcmV0dXJuIGNvbG9yOwp9CmhhbGY0IE1hdHJpeEVmZmVjdF9TMShoYWxmNCBfaW5wdXQpIAp7CglyZXR1cm4gR2F1c3NpYW5Db252b2x1dGlvbl9TMV9jMChfaW5wdXQpOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gaGFsZjQoMSk7Cgljb25zdCBoYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KDEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gTWF0cml4RWZmZWN0X1MxKG91dHB1dENvbG9yX1MwKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRfUzEgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAAAAAEAAAAAAAAAAgAAAB0AAAAAAAAAAQAAAB0AAAAIAAAAAQAAABAAAAAAAAAAUAAAAAAAAAABAAAAAAAAAA==","IYAAAAAABAAACAABBYAAAIAAAIAAGEAAAABRAEAAAAAAAAEIAAAAAAEASAAQAAAABIAAAAAEAAAAB7IAAAAACAAAAAAAAAAAAIAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAADUAANAAAAAAAAAIAAAABLAIABAAAAABAEGABBAMAAAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAAAAYAAAAAAAAAAA":"CgAAAExTS1PGAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfM19TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzNfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxX2MwKSAqIGxvY2FsQ29vcmQueHkxOwoJfQp9CgAAAAAAAEsDAABsYXlvdXQobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSBzYW1wbGVyMkQgdVRleHR1cmVTYW1wbGVyXzBfUzE7CmxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfM19TMDsKaGFsZjQgVGV4dHVyZUVmZmVjdF9TMV9jMF9jMChoYWxmNCBfaW5wdXQpIAp7CglyZXR1cm4gc2FtcGxlKHVUZXh0dXJlU2FtcGxlcl8wX1MxLCB2VHJhbnNmb3JtZWRDb29yZHNfM19TMCk7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxX2MwKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBUZXh0dXJlRWZmZWN0X1MxX2MwX2MwKF9pbnB1dCk7Cn0KaGFsZjQgQmxlbmRfUzEoaGFsZjQgX3NyYywgaGFsZjQgX2RzdCkgCnsKCXJldHVybiBibGVuZF9tb2R1bGF0ZShNYXRyaXhFZmZlY3RfUzFfYzAoX3NyYyksIF9zcmMpOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gaGFsZjQoMSk7Cgljb25zdCBoYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KDEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gQmxlbmRfUzEob3V0cHV0Q29sb3JfUzAsIGhhbGY0KDEpKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRfUzEgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAAAAAEAAAAAAAAAAgAAAB0AAAAAAAAAAQAAAB0AAAAIAAAAAQAAABAAAAAAAAAAUAAAAAAAAAABAAAAAAAAAA==","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAAMHCHGACAAQAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAADAYRYQAQYEAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAIAEOHAEGBCAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAEMHAHGBCAAAAA5B3UTQIDAAAAAEAAAAAJAQJDRYBRQIQAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAGQBIAAABAAAAANAEAAAAAAAAAAAAAABQAAGQAAAAFJ3XASIUAAAAAAYAAAAAQAAAAAAEQCGKTXOBEBIAABAABAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAQAAAAAAAA":"CgAAAExTS1NRAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxOwoJbGF5b3V0KG9mZnNldD02NCkgZmxvYXQ0IHVjaXJjbGVfUzJfYzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgZmxhdCBvdXQgaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgZmxvYXQyIHZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwoJewoJCXZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwID0gZmxvYXQzeDIodW1hdHJpeF9TMSkgKiBsb2NhbENvb3JkLnh5MTsKCX0KfQoAAAAAAAAANAYAAGNvbnN0IGludCBrRmlsbEFBX1MyX2MwID0gMTsKY29uc3QgaW50IGtJbnZlcnNlRmlsbEJXX1MyX2MwID0gMjsKY29uc3QgaW50IGtJbnZlcnNlRmlsbEFBX1MyX2MwID0gMzsKbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0M3gzIHVtYXRyaXhfUzE7CglsYXlvdXQob2Zmc2V0PTY0KSBmbG9hdDQgdWNpcmNsZV9TMl9jMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgaW4gaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CmhhbGY0IFRleHR1cmVFZmZlY3RfUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJcmV0dXJuIHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMSwgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzApLnJycnI7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBUZXh0dXJlRWZmZWN0X1MxX2MwKF9pbnB1dCk7Cn0KaGFsZjQgQ2lyY2xlX1MyX2MwKGhhbGY0IF9pbnB1dCkgCnsKCWhhbGY0IF90bXBfMF9pbkNvbG9yID0gX2lucHV0OwoJaGFsZiBkOwoJaWYgKGludCgxKSA9PSBrSW52ZXJzZUZpbGxCV19TMl9jMCB8fCBpbnQoMSkgPT0ga0ludmVyc2VGaWxsQUFfUzJfYzApIAoJewoJCWQgPSBoYWxmKChsZW5ndGgoKHVjaXJjbGVfUzJfYzAueHkgLSBza19GcmFnQ29vcmQueHkpICogdWNpcmNsZV9TMl9jMC53KSAtIDEuMCkgKiB1Y2lyY2xlX1MyX2MwLnopOwoJfQoJZWxzZSAKCXsKCQlkID0gaGFsZigoMS4wIC0gbGVuZ3RoKCh1Y2lyY2xlX1MyX2MwLnh5IC0gc2tfRnJhZ0Nvb3JkLnh5KSAqIHVjaXJjbGVfUzJfYzAudykpICogdWNpcmNsZV9TMl9jMC56KTsKCX0KCXJldHVybiBoYWxmNChoYWxmNChpbnQoMSkgPT0ga0ZpbGxBQV9TMl9jMCB8fCBpbnQoMSkgPT0ga0ludmVyc2VGaWxsQUFfUzJfYzAgPyBzYXR1cmF0ZShkKSA6IGhhbGYoZCA+IDAuNSA/IDEgOiAwKSkpOwp9CmhhbGY0IEJsZW5kX1MyKGhhbGY0IF9zcmMsIGhhbGY0IF9kc3QpIAp7CglyZXR1cm4gYmxlbmRfbW9kdWxhdGUoX3NyYywgQ2lyY2xlX1MyX2MwKF9zcmMpKTsKfQp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmNvbG9yX1MwOwoJY29uc3QgaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNCgxKTsKCWhhbGY0IG91dHB1dF9TMTsKCW91dHB1dF9TMSA9IE1hdHJpeEVmZmVjdF9TMShvdXRwdXRDb3ZlcmFnZV9TMCk7CgloYWxmNCBvdXRwdXRfUzI7CglvdXRwdXRfUzIgPSBCbGVuZF9TMihvdXRwdXRfUzEsIGhhbGY0KDEpKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dF9TMjsKCX0KfQoBAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAQAAAAAAAAADAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAAHQAAAAwAAAABAAAAFAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","DASAAAAAQAAWAABAYAAQBYH7777Z6QQBAEAAAAAAEAAAAAAAEBSAAAB2AAAAAAACAAAAAEBSAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","HTQAAGAABBYAAAEIXBAAAGEAMAAAAAAAAAAAAAAAQAHAAAAAQAAAAAAAQQGAAAAAIYAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","FAAQMYAAMAAAEADAAABAEYAAAICIAB5AABQAAAQAMAAAEATAAABAIIGAAEDCBYQCA4AAAAAAEADZABYAAAIAAAAAACQAGAAAAAQAAAAAAAQQGUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"CgAAAExTS1M8DQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0NCByYWRpaV9zZWxlY3RvcjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gZmxvYXQ0IGNvcm5lcl9hbmRfcmFkaXVzX291dHNldHM7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0NCBhYV9ibG9hdF9hbmRfY292ZXJhZ2U7CmxheW91dChsb2NhdGlvbiA9IDMpIGluIGZsb2F0NCByYWRpaV94OwpsYXlvdXQobG9jYXRpb24gPSA0KSBpbiBmbG9hdDQgcmFkaWlfeTsKbGF5b3V0KGxvY2F0aW9uID0gNSkgaW4gZmxvYXQ0IHNrZXc7CmxheW91dChsb2NhdGlvbiA9IDYpIGluIGZsb2F0MiB0cmFuc2xhdGVfYW5kX2xvY2Fscm90YXRlOwpsYXlvdXQobG9jYXRpb24gPSA3KSBpbiBoYWxmNCBjb2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgZmxhdCBvdXQgaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgZmxvYXQyIHZhcmNjb29yZF9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgRmlsbFJSZWN0T3A6OlByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7CglmbG9hdCBhYV9ibG9hdF9tdWx0aXBsaWVyID0gMTsKCWZsb2F0MiBjb3JuZXIgPSBjb3JuZXJfYW5kX3JhZGl1c19vdXRzZXRzLnh5OwoJZmxvYXQyIHJhZGl1c19vdXRzZXQgPSBjb3JuZXJfYW5kX3JhZGl1c19vdXRzZXRzLnp3OwoJZmxvYXQyIGFhX2Jsb2F0X2RpcmVjdGlvbiA9IGFhX2Jsb2F0X2FuZF9jb3ZlcmFnZS54eTsKCWZsb2F0IGlzX2xpbmVhcl9jb3ZlcmFnZSA9IGFhX2Jsb2F0X2FuZF9jb3ZlcmFnZS53OwoJZmxvYXQyIHBpeGVsbGVuZ3RoID0gaW52ZXJzZXNxcnQoZmxvYXQyKGRvdChza2V3Lnh6LCBza2V3Lnh6KSwgZG90KHNrZXcueXcsIHNrZXcueXcpKSk7CglmbG9hdDQgbm9ybWFsaXplZF9heGlzX2RpcnMgPSBza2V3ICogcGl4ZWxsZW5ndGgueHl4eTsKCWZsb2F0MiBheGlzd2lkdGhzID0gKGFicyhub3JtYWxpemVkX2F4aXNfZGlycy54eSkgKyBhYnMobm9ybWFsaXplZF9heGlzX2RpcnMuencpKTsKCWZsb2F0MiBhYV9ibG9hdHJhZGl1cyA9IGF4aXN3aWR0aHMgKiBwaXhlbGxlbmd0aCAqIC41OwoJZmxvYXQ0IHJhZGlpX2FuZF9uZWlnaGJvcnMgPSByYWRpaV9zZWxlY3RvciogZmxvYXQ0eDQocmFkaWlfeCwgcmFkaWlfeSwgcmFkaWlfeC55eHd6LCByYWRpaV95Lnd6eXgpOwoJZmxvYXQyIHJhZGlpID0gcmFkaWlfYW5kX25laWdoYm9ycy54eTsKCWZsb2F0MiBuZWlnaGJvcl9yYWRpaSA9IHJhZGlpX2FuZF9uZWlnaGJvcnMuenc7CglmbG9hdCBjb3ZlcmFnZV9tdWx0aXBsaWVyID0gMTsKCWlmIChhbnkoZ3JlYXRlclRoYW4oYWFfYmxvYXRyYWRpdXMsIGZsb2F0MigxKSkpKSAKCXsKCQljb3JuZXIgPSBtYXgoYWJzKGNvcm5lciksIGFhX2Jsb2F0cmFkaXVzKSAqIHNpZ24oY29ybmVyKTsKCQljb3ZlcmFnZV9tdWx0aXBsaWVyID0gMSAvIChtYXgoYWFfYmxvYXRyYWRpdXMueCwgMSkgKiBtYXgoYWFfYmxvYXRyYWRpdXMueSwgMSkpOwoJCXJhZGlpID0gZmxvYXQyKDApOwoJfQoJZmxvYXQgY292ZXJhZ2UgPSBhYV9ibG9hdF9hbmRfY292ZXJhZ2UuejsKCWlmIChhbnkobGVzc1RoYW4ocmFkaWksIGFhX2Jsb2F0cmFkaXVzICogMS41KSkpIAoJewoJCXJhZGlpID0gZmxvYXQyKDApOwoJCWFhX2Jsb2F0X2RpcmVjdGlvbiA9IHNpZ24oY29ybmVyKTsKCQlpZiAoY292ZXJhZ2UgPiAuNSkgCgkJewoJCQlhYV9ibG9hdF9kaXJlY3Rpb24gPSAtYWFfYmxvYXRfZGlyZWN0aW9uOwoJCX0KCQlpc19saW5lYXJfY292ZXJhZ2UgPSAxOwoJfQoJZWxzZSAKCXsKCQlyYWRpaSA9IGNsYW1wKHJhZGlpLCBwaXhlbGxlbmd0aCAqIDEuNSwgMiAtIHBpeGVsbGVuZ3RoICogMS41KTsKCQluZWlnaGJvcl9yYWRpaSA9IGNsYW1wKG5laWdoYm9yX3JhZGlpLCBwaXhlbGxlbmd0aCAqIDEuNSwgMiAtIHBpeGVsbGVuZ3RoICogMS41KTsKCQlmbG9hdDIgc3BhY2luZyA9IDIgLSByYWRpaSAtIG5laWdoYm9yX3JhZGlpOwoJCWZsb2F0MiBleHRyYV9wYWQgPSBtYXgocGl4ZWxsZW5ndGggKiAuMDYyNSAtIHNwYWNpbmcsIGZsb2F0MigwKSk7CgkJcmFkaWkgLT0gZXh0cmFfcGFkICogLjU7Cgl9CglmbG9hdDIgYWFfb3V0c2V0ID0gYWFfYmxvYXRfZGlyZWN0aW9uICogYWFfYmxvYXRyYWRpdXMgKiBhYV9ibG9hdF9tdWx0aXBsaWVyOwoJZmxvYXQyIHZlcnRleHBvcyA9IGNvcm5lciArIHJhZGl1c19vdXRzZXQgKiByYWRpaSArIGFhX291dHNldDsKCWlmIChjb3ZlcmFnZSA+IC41KSAKCXsKCQlpZiAoYWFfYmxvYXRfZGlyZWN0aW9uLnggIT0gMCAmJiB2ZXJ0ZXhwb3MueCAqIGNvcm5lci54IDwgMCkgCgkJewoJCQlmbG9hdCBiYWNrc2V0ID0gYWJzKHZlcnRleHBvcy54KTsKCQkJdmVydGV4cG9zLnggPSAwOwoJCQl2ZXJ0ZXhwb3MueSArPSBiYWNrc2V0ICogc2lnbihjb3JuZXIueSkgKiBwaXhlbGxlbmd0aC55L3BpeGVsbGVuZ3RoLng7CgkJCWNvdmVyYWdlID0gKGNvdmVyYWdlIC0gLjUpICogYWJzKGNvcm5lci54KSAvIChhYnMoY29ybmVyLngpICsgYmFja3NldCkgKyAuNTsKCQl9CgkJaWYgKGFhX2Jsb2F0X2RpcmVjdGlvbi55ICE9IDAgJiYgdmVydGV4cG9zLnkgKiBjb3JuZXIueSA8IDApIAoJCXsKCQkJZmxvYXQgYmFja3NldCA9IGFicyh2ZXJ0ZXhwb3MueSk7CgkJCXZlcnRleHBvcy55ID0gMDsKCQkJdmVydGV4cG9zLnggKz0gYmFja3NldCAqIHNpZ24oY29ybmVyLngpICogcGl4ZWxsZW5ndGgueC9waXhlbGxlbmd0aC55OwoJCQljb3ZlcmFnZSA9IChjb3ZlcmFnZSAtIC41KSAqIGFicyhjb3JuZXIueSkgLyAoYWJzKGNvcm5lci55KSArIGJhY2tzZXQpICsgLjU7CgkJfQoJfQoJZmxvYXQyeDIgc2tld21hdHJpeCA9IGZsb2F0MngyKHNrZXcueHksIHNrZXcuencpOwoJZmxvYXQyIGRldmNvb3JkID0gdmVydGV4cG9zICogc2tld21hdHJpeCArIHRyYW5zbGF0ZV9hbmRfbG9jYWxyb3RhdGUueHk7CglpZiAoMCAhPSBpc19saW5lYXJfY292ZXJhZ2UpIAoJewoJCXZhcmNjb29yZF9TMC54eSA9IGZsb2F0MigwLCBjb3ZlcmFnZSAqIGNvdmVyYWdlX211bHRpcGxpZXIpOwoJfQoJZWxzZSAKCXsKCQlmbG9hdDIgYXJjY29vcmQgPSAxIC0gYWJzKHJhZGl1c19vdXRzZXQpICsgYWFfb3V0c2V0L3JhZGlpICogY29ybmVyOwoJCXZhcmNjb29yZF9TMC54eSA9IGZsb2F0MihhcmNjb29yZC54KzEsIGFyY2Nvb3JkLnkpOwoJfQoJc2tfUG9zaXRpb24gPSBkZXZjb29yZC54eTAxOwp9CgAAAABwBAAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgaW4gaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgdmFyY2Nvb3JkX1MwOwpoYWxmNCBDaXJjdWxhclJSZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCWZsb2F0MiBkeHkwID0gdWlubmVyUmVjdF9TMS5MVCAtIHNrX0ZyYWdDb29yZC54eTsKCWZsb2F0MiBkeHkxID0gc2tfRnJhZ0Nvb3JkLnh5IC0gdWlubmVyUmVjdF9TMS5SQjsKCWZsb2F0MiBkeHkgPSBtYXgobWF4KGR4eTAsIGR4eTEpLCAwLjApOwoJaGFsZiBhbHBoYSA9IGhhbGYoc2F0dXJhdGUodXJhZGl1c1BsdXNIYWxmX1MxLnggLSBsZW5ndGgoZHh5KSkpOwoJcmV0dXJuIF9pbnB1dCAqIGFscGhhOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBGaWxsUlJlY3RPcDo6UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmNvbG9yX1MwOwoJZmxvYXQgeF9wbHVzXzE9dmFyY2Nvb3JkX1MwLngsIHk9dmFyY2Nvb3JkX1MwLnk7CgloYWxmIGNvdmVyYWdlOwoJaWYgKDAgPT0geF9wbHVzXzEpIAoJewoJCWNvdmVyYWdlID0gaGFsZih5KTsKCX0KCWVsc2UgCgl7CgkJZmxvYXQgZm4gPSB4X3BsdXNfMSAqICh4X3BsdXNfMSAtIDIpOwoJCWZuID0gZm1hKHkseSwgZm4pOwoJCWZsb2F0IGZud2lkdGggPSBmd2lkdGgoZm4pOwoJCWNvdmVyYWdlID0gLjUgLSBoYWxmKGZuL2Zud2lkdGgpOwoJCWNvdmVyYWdlID0gY2xhbXAoY292ZXJhZ2UsIDAsIDEpOwoJfQoJaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNChjb3ZlcmFnZSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBDaXJjdWxhclJSZWN0X1MxKG91dHB1dENvdmVyYWdlX1MwKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dF9TMTsKCX0KfQoBAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgAAAAAQAAAAIAAAADAAAAHwAAAAAAAAABAAAAHwAAABAAAAABAAAAHwAAACAAAAABAAAAMAAAAAUAAAAfAAAAAAAAAAIAAAAfAAAAEAAAAAIAAAAfAAAAIAAAAAIAAAAdAAAAMAAAAAIAAAAJAAAAOAAAAAIAAAA8AAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQAAEAQAAAAGQCBAMQAAAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAAABQAAQAAAAAAAA":"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","FAAQMYAAMAAAEADAAABAEYAAAICIAB5AABQAAAQAMAAAEATAAABAIIGAAEDCBYQCA4AAAAAAAA5AAAAAAABAAAAACAZAAAAAIYAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAGIBIAAABAAAAANAEAAAAAAAAAAAAAABAAOAAAABAAAAAAABBAMAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAQAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEAAZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAIAAAAAAAA":"CgAAAExTS1OpAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgb3V0IGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgUXVhZFBlckVkZ2VBQUdlb21ldHJ5UHJvY2Vzc29yCgl2Y29sb3JfUzAgPSBjb2xvcjsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAAAAAiAMAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQ0IHVpbm5lclJlY3RfUzE7CglsYXlvdXQob2Zmc2V0PTMyKSBoYWxmMiB1cmFkaXVzUGx1c0hhbGZfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKaGFsZjQgQ2lyY3VsYXJSUmVjdF9TMShoYWxmNCBfaW5wdXQpIAp7CglmbG9hdDIgZHh5MCA9IHVpbm5lclJlY3RfUzEuTFQgLSBza19GcmFnQ29vcmQueHk7CglmbG9hdCBkeDEgPSBza19GcmFnQ29vcmQueCAtIHVpbm5lclJlY3RfUzEuUjsKCWZsb2F0MiBkeHkgPSBtYXgoZmxvYXQyKG1heChkeHkwLngsIGR4MSksIGR4eTAueSksIDAuMCk7CgloYWxmIGJvdHRvbUFscGhhID0gaGFsZihzYXR1cmF0ZSh1aW5uZXJSZWN0X1MxLkIgLSBza19GcmFnQ29vcmQueSkpOwoJaGFsZiBhbHBoYSA9IGJvdHRvbUFscGhhICogaGFsZihzYXR1cmF0ZSh1cmFkaXVzUGx1c0hhbGZfUzEueCAtIGxlbmd0aChkeHkpKSk7CglyZXR1cm4gX2lucHV0ICogYWxwaGE7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBDaXJjdWxhclJSZWN0X1MxKG91dHB1dENvdmVyYWdlX1MwKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dF9TMTsKCX0KfQoBAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HVJAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAABAAAAAABBAMABSAAGQAAAAKFIDMVQUAAAAABIAAAAAQAAAABEERFAUBWKYKAAAIAAQAAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQEAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQGAAAAAAAAAEAAAABJMQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGABZAAGIAAAAACAAAAAADUAAAAAAAEAAAAAIDEAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQEAAAAAAABAEAAAABJIQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAEAQAAAAGQCEIBAACAIAAAAAACQAGAAAAAQAAAAAGBCAIAAAAAFAAAAAAEAAAAAAAAAAAAAAAAACAAAAAABQAAQAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABDAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"CgAAAExTS1OAAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGluUG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGluQ29sb3I7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0NCBpbkNpcmNsZUVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJdmluQ2lyY2xlRWRnZV9TMCA9IGluQ2lyY2xlRWRnZTsKCXZpbkNvbG9yX1MwID0gaW5Db2xvcjsKCWZsb2F0MiBfdG1wXzBfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSB1bG9jYWxNYXRyaXhfUzAueHogKiBpblBvc2l0aW9uICsgdWxvY2FsTWF0cml4X1MwLnl3OwoJc2tfUG9zaXRpb24gPSBfdG1wXzBfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAACbAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAQAAAAAAAAADAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAAHwAAAAwAAAABAAAAHAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAOAAHSAAAAAAQAAAAAA5AAAAAAABAAAAACAZAAIYAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"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","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAAAPEAHAAABAAAAAAAKAAYAAAACAAAAAAACCAYAIYAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAEAQAAAAGQCBAMQACAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAAABQAAQAAAAAAAA":"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","B2AAQAAABQAAIAABBYAAB7777777777774ABICAAAAAAAAAAAAAABUABAAAAAEAAAAAIBEABAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OxAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZiBpbkNvdmVyYWdlOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZiB2aW5Db3ZlcmFnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgRGVmYXVsdEdlb21ldHJ5UHJvY2Vzc29yCglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJdmluQ292ZXJhZ2VfUzAgPSBpbkNvdmVyYWdlOwoJc2tfUG9zaXRpb24gPSBfdG1wXzFfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAAADJAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBoYWxmIHZpbkNvdmVyYWdlX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgRGVmYXVsdEdlb21ldHJ5UHJvY2Vzc29yCgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdUNvbG9yX1MwOwoJaGFsZiBhbHBoYSA9IDEuMDsKCWFscGhhID0gdmluQ292ZXJhZ2VfUzA7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAcAAAACAAAAAEAAAAMAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAGIBIAAABAAAAANAEAAAAAAAAAAAAAABAAOAAAABAAAAAAABBAMAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAQAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGACQAGAAAAAQAAAAAAAQQGAAAIYAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"CgAAAExTS1NkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGZsb2F0MiBsb2NhbENvb3JkOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgZmxvYXQyIHZsb2NhbENvb3JkX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZsb2NhbENvb3JkX1MwID0gbG9jYWxDb29yZDsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAKQIAAGxheW91dChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHNhbXBsZXIyRCB1VGV4dHVyZVNhbXBsZXJfMF9TMDsKbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgdmxvY2FsQ29vcmRfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gaGFsZjQoMSk7CglmbG9hdDIgdGV4Q29vcmQ7Cgl0ZXhDb29yZCA9IHZsb2NhbENvb3JkX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSAoKHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMCwgdGV4Q29vcmQpICogaGFsZjQoMSkpKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHQAAAAgAAAABAAAAEAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","CIAAAAAAQAARQAAYQAAAAGFYQAABRAAAAEEAAAAAAARAEAEABYAAAAEAAAAAAAEEBQAAAACQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEBAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBQU7BTXIAAAAAACAAAAAAQFV5W6JEAAAAAYAAAABEGIRLQQSCIAACAH5FYUHQAAAAEAAAAABAAMQEAAAAEANDMXWJYBAAAGAAAAABACEK4GE4SAAAAA7JOVF4AAAAAAAAQAAAAGIBFCMXXZ2BAAACAACAAAACE2YGE6SAAAAAHIO5E4CAYAAAABAAAAACIMCRCWBRHUQAAAAAAAAAAAVREL6SYKDYAAAACAAAAABAAM6W52JYABAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAAAIQAAQAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAB3QA6AAAEAAAAAAAMAALEAAAAABAAAAAAB2AAAAAAACAAAAAEBSAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGACQAGAAAAAQAAAAAAAQQGAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"CgAAAExTS1NkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGZsb2F0MiBsb2NhbENvb3JkOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgZmxvYXQyIHZsb2NhbENvb3JkX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZsb2NhbENvb3JkX1MwID0gbG9jYWxDb29yZDsKCXNrX1Bvc2l0aW9uID0gcG9zaXRpb24ueHkwMTsKfQoAAAAAKQIAAGxheW91dChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHNhbXBsZXIyRCB1VGV4dHVyZVNhbXBsZXJfMF9TMDsKbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgdmxvY2FsQ29vcmRfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gaGFsZjQoMSk7CglmbG9hdDIgdGV4Q29vcmQ7Cgl0ZXhDb29yZCA9IHZsb2NhbENvb3JkX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSAoKHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMCwgdGV4Q29vcmQpICogaGFsZjQoMSkpKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHQAAAAgAAAABAAAAEAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","B3IBQAAADAAAIAABBYAAAEIXBAAACDQMAAABIFAAAAAAAAAAAAAABFIBBYSAO7ICAAAAACX4GM5AAAAAAAIAAAAACAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAAAAAAQAAAAAEARQUPBT7IAAAAAACAAAAAAQFU5S6ZGAAAAAYAAAAAYCEOGAEGBAAAAAH5FYUXQAAAAAAACAAAAAMQEAIAAAANDMXXJYBAAAGAAAAAAABDRYBRQIQAAAAPJO5E4AAQAAAAAQAAAAGIBBCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAABAAAAAAIEDIYOAOMCEAAAAAAAAAAAFREL6S4KDYAAAACAAAAAAAAM6U52JYEBQAAAAAAAAAACYIEAIAAAAAAABUARCAIAAAAAAAAAABUABAAAAAEAAAAAIBEABKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAAAPEAHAAABAAAAAAAKAAYAAAACAAAAAAACCAYAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAAAAAAAAIAAAABSEIAL7YYDQAAAAAAACAAAAABQEKAAAAIAAAADIBAQGIAAAAAAAAAAAMACQCAACAAAAA2AIBAEIAAAAAAAAAACAA4AAAACAAAAAAACCAYAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAQAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBQU7BTXIAAAAAACAWXW3ZEQAAAADAAAAADAYRYQAQYEAAAIA7UXCQ6AAAAAQAAAAAAADGAWRWL3E4AQAADAAAAABAARY4AQYEIAAAAPUXKS6AAAAAAAAQAAAADE2CEOGAEGBAAAAAAAAAAAAK6S56JIEBYAAAABAAAAAAQEH7JOFF4AAAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAEMAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAICAACAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBQU7BTXIAAAAAACAAAAAAQFV5W6JEAAAAAYAAAABEGIRLQQSCIAACAH5FYUHQAAAAEAAAAABAAMQEAAAAEANDMXWJYBAAAGAAAAABACEK4GE4SAAAAA7JOVF4AAAAAAAAQAAAAGIBFCMXXZ2BAAACAACAAAACE2YGE6SAAAAAHIO5E4CAYAAAABAAAAACIMCRCWBRHUQAAAAAAAAAAAVREL6SYKDYAAAACAAAAABAAM6W52JYABAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABDAAAAAAEAAAAAAAAAAAAAAAAACAAAAAAIQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAAAAEAAAABJYQAAAAAAAAIAAAAAWCBAAAABAAAAANAEIQCAAAAAAAAAAAFAAMAAAABAAAAAAMCEAQFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"CgAAAExTS1NOAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZjQgdmNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwp9CgAAAAAAAH0BAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQIAAAAAAIBAEAAAABJQQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAABYCMNGFQIAAAAHADEHC6BAAAAAAAABAAAAAAIBDBL6DGOQAAAAAAEAAAAABALL354SAAAAABQAAAAHAJRUIUBIBAAAMAMY4LYEAAAAAEAAAAABAIMQAAAAAEBNPNXSJAAAAAGAAAAAMBGOQCQFQEAAAQBTTRPAQAAAAAQAAAAAIBDCAWTWL3EYAAAADAAAAACADHIJJCYCAAAAAZ5YHQIIAAAAAAAIAAAABTZCMNCFAKAIAAAAAAAAAMBCTZQ7BQUAAAAAAAIAAAADEZAZRYXQIAAAAAAAAAAAGABIBAABAAAAANAEIQCAAAAAAAAAAABAAOAAAABAAAAAAABBAMUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"CgAAAExTS1NnBAAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwoJbGF5b3V0KG9mZnNldD0zMikgaGFsZjQgdXN0YXJ0X1MxX2MwX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD00MCkgaGFsZjQgdWVuZF9TMV9jMF9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9NDgpIGZsb2F0M3gzIHVtYXRyaXhfUzFfYzBfYzBfYzBfYzE7CglsYXlvdXQob2Zmc2V0PTk2KSBoYWxmNCB1bGVmdEJvcmRlckNvbG9yX1MxX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD0xMDQpIGhhbGY0IHVyaWdodEJvcmRlckNvbG9yX1MxX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD0xMTIpIGZsb2F0M3gzIHVtYXRyaXhfUzFfYzE7CglsYXlvdXQob2Zmc2V0PTE2MCkgaGFsZiB1cmFuZ2VfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQ0IGluQ2lyY2xlRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0NCB2aW5DaXJjbGVFZGdlX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CmxheW91dChsb2NhdGlvbiA9IDIpIG91dCBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzdfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCgl2aW5DaXJjbGVFZGdlX1MwID0gaW5DaXJjbGVFZGdlOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IHVsb2NhbE1hdHJpeF9TMC54eiAqIGluUG9zaXRpb24gKyB1bG9jYWxNYXRyaXhfUzAueXc7Cglza19Qb3NpdGlvbiA9IF90bXBfMF9pblBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzdfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxX2MwX2MwX2MwX2MxKSAqIF90bXBfMV9pblBvc2l0aW9uLnh5MTsKCX0KfQoAAAAAACoMAABsYXlvdXQobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSBzYW1wbGVyMkQgdVRleHR1cmVTYW1wbGVyXzBfUzE7CmxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQ0IHVsb2NhbE1hdHJpeF9TMDsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGY0IHVzdGFydF9TMV9jMF9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9NDApIGhhbGY0IHVlbmRfUzFfYzBfYzBfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTQ4KSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwX2MwX2MwX2MxOwoJbGF5b3V0KG9mZnNldD05NikgaGFsZjQgdWxlZnRCb3JkZXJDb2xvcl9TMV9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9MTA0KSBoYWxmNCB1cmlnaHRCb3JkZXJDb2xvcl9TMV9jMF9jMF9jMDsKCWxheW91dChvZmZzZXQ9MTEyKSBmbG9hdDN4MyB1bWF0cml4X1MxX2MxOwoJbGF5b3V0KG9mZnNldD0xNjApIGhhbGYgdXJhbmdlX1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzdfUzA7CmhhbGY0IFNpbmdsZUludGVydmFsQ29sb3JpemVyX1MxX2MwX2MwX2MwX2MwKGhhbGY0IF9pbnB1dCwgZmxvYXQyIF9jb29yZHMpIAp7CgloYWxmNCBfdG1wXzBfaW5Db2xvciA9IF9pbnB1dDsKCWZsb2F0MiBfdG1wXzFfY29vcmRzID0gX2Nvb3JkczsKCXJldHVybiBoYWxmNChtaXgodXN0YXJ0X1MxX2MwX2MwX2MwX2MwLCB1ZW5kX1MxX2MwX2MwX2MwX2MwLCBoYWxmKF90bXBfMV9jb29yZHMueCkpKTsKfQpoYWxmNCBSYWRpYWxMYXlvdXRfUzFfYzBfYzBfYzBfYzFfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgX3RtcF8yX2luQ29sb3IgPSBfaW5wdXQ7CglmbG9hdDIgX3RtcF8zX2Nvb3JkcyA9IHZUcmFuc2Zvcm1lZENvb3Jkc183X1MwOwoJcmV0dXJuIGhhbGY0KGhhbGY0KGhhbGYobGVuZ3RoKF90bXBfM19jb29yZHMpKSwgMS4wLCAwLjAsIDAuMCkpOwp9CmhhbGY0IE1hdHJpeEVmZmVjdF9TMV9jMF9jMF9jMF9jMShoYWxmNCBfaW5wdXQpIAp7CglyZXR1cm4gUmFkaWFsTGF5b3V0X1MxX2MwX2MwX2MwX2MxX2MwKF9pbnB1dCk7Cn0KaGFsZjQgQ2xhbXBlZEdyYWRpZW50X1MxX2MwX2MwX2MwKGhhbGY0IF9pbnB1dCkgCnsKCWhhbGY0IF90bXBfNF9pbkNvbG9yID0gX2lucHV0OwoJaGFsZjQgdCA9IE1hdHJpeEVmZmVjdF9TMV9jMF9jMF9jMF9jMShfdG1wXzRfaW5Db2xvcik7CgloYWxmNCBvdXRDb2xvcjsKCWlmICghYm9vbChpbnQoMSkpICYmIHQueSA8IDAuMCkgCgl7CgkJb3V0Q29sb3IgPSBoYWxmNCgwLjApOwoJfQoJZWxzZSBpZiAodC54IDwgMC4wKSAKCXsKCQlvdXRDb2xvciA9IHVsZWZ0Qm9yZGVyQ29sb3JfUzFfYzBfYzBfYzA7Cgl9CgllbHNlIGlmICh0LnggPiAxLjApIAoJewoJCW91dENvbG9yID0gdXJpZ2h0Qm9yZGVyQ29sb3JfUzFfYzBfYzBfYzA7Cgl9CgllbHNlIAoJewoJCW91dENvbG9yID0gU2luZ2xlSW50ZXJ2YWxDb2xvcml6ZXJfUzFfYzBfYzBfYzBfYzAoX3RtcF80X2luQ29sb3IsIGZsb2F0MihoYWxmMih0LngsIDAuMCkpKTsKCX0KCXJldHVybiBoYWxmNChvdXRDb2xvcik7Cn0KaGFsZjQgY29sb3JfeGZvcm1fUzFfYzBfYzAoaGFsZjQgY29sb3IpIAp7Cgljb2xvci5yZ2IgKj0gY29sb3IuYTsKCXJldHVybiBoYWxmNChjb2xvcik7Cn0KaGFsZjQgQ29sb3JTcGFjZVhmb3JtX1MxX2MwX2MwKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBjb2xvcl94Zm9ybV9TMV9jMF9jMChDbGFtcGVkR3JhZGllbnRfUzFfYzBfYzBfYzAoX2lucHV0KSk7Cn0KaGFsZjQgRGlzYWJsZUNvdmVyYWdlQXNBbHBoYV9TMV9jMChoYWxmNCBfaW5wdXQpIAp7CglfaW5wdXQgPSBDb2xvclNwYWNlWGZvcm1fUzFfYzBfYzAoX2lucHV0KTsKCWhhbGY0IF90bXBfNV9pbkNvbG9yID0gX2lucHV0OwoJcmV0dXJuIGhhbGY0KF9pbnB1dCk7Cn0KaGFsZjQgVGV4dHVyZUVmZmVjdF9TMV9jMV9jMChoYWxmNCBfaW5wdXQsIGZsb2F0MiBfY29vcmRzKSAKewoJcmV0dXJuIHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMSwgX2Nvb3JkcykuMDAwcjsKfQpoYWxmNCBNYXRyaXhFZmZlY3RfUzFfYzEoaGFsZjQgX2lucHV0LCBmbG9hdDIgX2Nvb3JkcykgCnsKCXJldHVybiBUZXh0dXJlRWZmZWN0X1MxX2MxX2MwKF9pbnB1dCwgZmxvYXQzeDIodW1hdHJpeF9TMV9jMSkgKiBfY29vcmRzLnh5MSk7Cn0KaGFsZjQgRGl0aGVyX1MxKGhhbGY0IF9pbnB1dCkgCnsKCWhhbGY0IF90bXBfNl9pbkNvbG9yID0gX2lucHV0OwoJaGFsZjQgY29sb3IgPSBEaXNhYmxlQ292ZXJhZ2VBc0FscGhhX1MxX2MwKF90bXBfNl9pbkNvbG9yKTsKCWhhbGYgdmFsdWUgPSBNYXRyaXhFZmZlY3RfUzFfYzEoX3RtcF82X2luQ29sb3IsIHNrX0ZyYWdDb29yZC54eSkudyAtIDAuNTsKCXJldHVybiBoYWxmNChoYWxmNChjbGFtcChjb2xvci54eXogKyB2YWx1ZSAqIHVyYW5nZV9TMSwgMC4wLCBjb2xvci53KSwgY29sb3IudykpOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJZmxvYXQ0IGNpcmNsZUVkZ2U7CgljaXJjbGVFZGdlID0gdmluQ2lyY2xlRWRnZV9TMDsKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2aW5Db2xvcl9TMDsKCWZsb2F0IGQgPSBsZW5ndGgoY2lyY2xlRWRnZS54eSk7CgloYWxmIGRpc3RhbmNlVG9PdXRlckVkZ2UgPSBoYWxmKGNpcmNsZUVkZ2UueiAqICgxLjAgLSBkKSk7CgloYWxmIGVkZ2VBbHBoYSA9IHNhdHVyYXRlKGRpc3RhbmNlVG9PdXRlckVkZ2UpOwoJaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNChlZGdlQWxwaGEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gRGl0aGVyX1MxKG91dHB1dENvbG9yX1MwKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRfUzEgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAABAAAAAAAAAAMAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAfAAAADAAAAAEAAAAcAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1OAAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGluUG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGluQ29sb3I7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0NCBpbkNpcmNsZUVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJdmluQ2lyY2xlRWRnZV9TMCA9IGluQ2lyY2xlRWRnZTsKCXZpbkNvbG9yX1MwID0gaW5Db2xvcjsKCWZsb2F0MiBfdG1wXzBfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSB1bG9jYWxNYXRyaXhfUzAueHogKiBpblBvc2l0aW9uICsgdWxvY2FsTWF0cml4X1MwLnl3OwoJc2tfUG9zaXRpb24gPSBfdG1wXzBfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAACbAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAQAAAAAAAAADAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAAHwAAAAwAAAABAAAAHAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAEABYAAAAEAAAAAAAEEBQAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAMGAICAAAAAAAA":"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","DAQAAAAAAABGAABAYAAQAIHCAIAYAQUBAEAAAAAAEAAAAAAAAAAAAIAD2AAAAAAQAVSWGRIBAAAFAAAAACAAAAAAQCGEIQOZLBIQAAAACQAAAAAAAAAAAAFAAMAAAABAAAAAAABBAMAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAABAEAAAABJYQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAMWAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAASLEYTYIIBAAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAAEQZCFOCCIJAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAEAIRLQYTSIAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAITLAYT2IAAAAA5B3UTQIDAAAAAEAAAAAJBQKEKYGE6SAAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAAAYQADAAAEAFEURUKQKAAAIAAQAAAAAIAAAABSCICWKY2FAEAAAUAAAAAAAAAAAAAIADQAAAAIAAAAAAAIIDAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAAAQAAAAGQCBAMQACAAAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAGQBIAAABAAAAANAEAAAAAAAAAAAAAADQABQQAAAAAEAAAAAAHIAAAAAAAIAAAAAQGIACQAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEBAAAAAAAAA":"CgAAAExTS1N+AgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bWF0cml4X1MxOwoJbGF5b3V0KG9mZnNldD02NCkgZmxvYXQ0IHVpbm5lclJlY3RfUzI7CglsYXlvdXQob2Zmc2V0PTgwKSBoYWxmMiB1cmFkaXVzUGx1c0hhbGZfUzI7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiBmbG9hdDIgbG9jYWxDb29yZDsKbGF5b3V0KGxvY2F0aW9uID0gMCkgZmxhdCBvdXQgaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgZmxvYXQyIHZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwoJewoJCXZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwID0gZmxvYXQzeDIodW1hdHJpeF9TMSkgKiBsb2NhbENvb3JkLnh5MTsKCX0KfQoAAAAAAAAdBQAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0M3gzIHVtYXRyaXhfUzE7CglsYXlvdXQob2Zmc2V0PTY0KSBmbG9hdDQgdWlubmVyUmVjdF9TMjsKCWxheW91dChvZmZzZXQ9ODApIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMjsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGZsYXQgaW4gaGFsZjQgdmNvbG9yX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CmhhbGY0IFRleHR1cmVFZmZlY3RfUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJcmV0dXJuIHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMSwgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzApLnJycnI7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBUZXh0dXJlRWZmZWN0X1MxX2MwKF9pbnB1dCk7Cn0KaGFsZjQgQ2lyY3VsYXJSUmVjdF9TMihoYWxmNCBfaW5wdXQpIAp7CglmbG9hdCBkeDAgPSB1aW5uZXJSZWN0X1MyLkwgLSBza19GcmFnQ29vcmQueDsKCWZsb2F0MiBkeHkxID0gc2tfRnJhZ0Nvb3JkLnh5IC0gdWlubmVyUmVjdF9TMi5SQjsKCWZsb2F0MiBkeHkgPSBtYXgoZmxvYXQyKG1heChkeDAsIGR4eTEueCksIGR4eTEueSksIDAuMCk7CgloYWxmIHRvcEFscGhhID0gaGFsZihzYXR1cmF0ZShza19GcmFnQ29vcmQueSAtIHVpbm5lclJlY3RfUzIuVCkpOwoJaGFsZiBhbHBoYSA9IHRvcEFscGhhICogaGFsZihzYXR1cmF0ZSh1cmFkaXVzUGx1c0hhbGZfUzIueCAtIGxlbmd0aChkeHkpKSk7CglyZXR1cm4gX2lucHV0ICogYWxwaGE7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBNYXRyaXhFZmZlY3RfUzEob3V0cHV0Q292ZXJhZ2VfUzApOwoJaGFsZjQgb3V0cHV0X1MyOwoJb3V0cHV0X1MyID0gQ2lyY3VsYXJSUmVjdF9TMihvdXRwdXRfUzEpOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0X1MyOwoJfQp9CgAAAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAABAAAAAAAAAAMAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAdAAAADAAAAAEAAAAUAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","GCAAAAAADAAAEAABBYAAAAYXBAAAAAAAAAAAAAAAHGADYAAAQAAAAAAAAAOQAAAAAAAQAAAABAMQAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAGIBIAAABAAAAANAEAAAAAAAAAAAAAABAACAAAADABAEIAAAAAUAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAGAACAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAB3QA6AAAEAAAAAAAMAABUAAAAARCB3FMFCAAAAAKAAAAAEAAAAABAENIVANSWCQAAAAAFAAAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQLAAAAAAABAEAAAABJWQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"CgAAAExTS1NTAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAACCAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAMAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQKAAAAAAIAAEAAAABJUQAAAAAQAAIAAAAAWCBACAABAAAAANAEIQCAAEAAAAAAAAFAAMAAAABAAAAAAMCEAQFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAOAAHSAAAAAAQAAAAAA5AAAAAAABAAAAACAZAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAMWAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAAMHCHGACAAQAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAADAYRYQAQYEAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAIAEOHAEGBCAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAEMHAHGBCAAAAA5B3UTQIDAAAAAEAAAAAJAQJDRYBRQIQAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAABYQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAACJMTCPBBAEAAAUDPSKBIPAAAAAAAAIAAAAACAIYKPQZ3UAAAAAABALL3N4SIAAAABQAAAACIMRCXBBEEQAAEAP2LRIPAAAAAIAAAAAAABTALI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAIAAAABSDBEIVYMJREAAAAAAAAAAAFPJO7EUCA4AAAAAQAAAAAICD7UXCS6AAAAAAAAAAAAACWCAACAAAAACAINAEIAAAAAAAAAAAAA5AAAAAAABAAAAACAZAAACGAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","HTRQAGAABBYAAAEIXBAAAGEAMAAAAAAAAAAAAAAAWAGHAIBZ5AJQAAAA5C5DCQYAAAAABAAAAAAIA2GZPMTQCAAAMAAAAAEACHDQCDARAAAAAPGD4GCQAAAAAAAAABAAAAAGJJHLYYGACAAAAAAAEAAAACRGL345AQAABAABAAAAARQ4A4YEIAAAADYAZBYXAIAAAAAIAAAABSAQBAAAAAEIS26XOEQAAAAAMAAAAAMHCHGACAAQAAGAGMOF4CAAAAACAAAAABAEMIC263PESAAAAAMAAAAAMDCHCACDAQAAAAGPOB4CCAAAAAAACAAAAAMTJYRYQAQQEAAAAAAAAAGARJ4INQYLAEAAAAAEAAAABSEQM44LYEAAAAAAAAAAADAAUAQAAQAAAAGQCAIBCAAAAAAAAAAAYAADIAAAABCEDWKYKEAAAAAMAAAAAIAAAAACAI2RKA3FMFAAAAAAGAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAEAQAAAAGQCBAMQACAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAACQAAAAAABQIQCAAAAUAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAA":"CgAAAExTS1OAAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGluUG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGluQ29sb3I7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0NCBpbkNpcmNsZUVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgb3V0IGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJdmluQ2lyY2xlRWRnZV9TMCA9IGluQ2lyY2xlRWRnZTsKCXZpbkNvbG9yX1MwID0gaW5Db2xvcjsKCWZsb2F0MiBfdG1wXzBfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSB1bG9jYWxNYXRyaXhfUzAueHogKiBpblBvc2l0aW9uICsgdWxvY2FsTWF0cml4X1MwLnl3OwoJc2tfUG9zaXRpb24gPSBfdG1wXzBfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAACyAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogQ292ZXJhZ2UgU2V0IE9wCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q292ZXJhZ2VfUzA7CgkJc2tfRnJhZ0NvbG9yID0gc2tfRnJhZ0NvbG9yLmEwMDA7Cgl9Cn0KAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIAAAAAQAAAAAAAAADAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAAHwAAAAwAAAABAAAAHAAAAAAAAAAKAAAAAAAAAAEAAAAAAAAA","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGABZAA6IAAAAACAAAAAADUAAAAAAAEAAAAAIDEAAAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAQAAAAAAAA":"CgAAAExTS1NTAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAAACCAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBmbGF0IGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAMAAAAAAAAAEYAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAAHAJRUYWBAAAAA2DXZFAQHAAAAAAAAEAAAAABAEMFPYMZ2AAAAAAAQFV566JAAAAAAYAAAADQEY2EKAUAQAAFA34SQKDYAAAACAAAAABAEMIC263PESAAAAAMAAAAAYCM5AFALAIAAAQF7JMFB4AAAACAAAAAAQAGHEJRUYWBAAAAAAAAAAAFQEL6S4KLYAAAAAAABAAAAAMWU56JIEBYAAAAAAAAAACYIEAAAAEAAAABUARCAIAAAAAAAAAAAUABQAAAAEAAAAAAAEEBQAACQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAB3QA6AAAEAAAAAAAMAAPEAEAAABAAAAAAB2AAAAAAACAAAAAEBSAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"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","DAQAAAAAAABGAABAYAAQAIHCAIAYAQUBAEAAAAAAEAAAAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAARQAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"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","GAAAAAAADAAAEAABBYAAAAYXBAAAAAAAAAAAAAAA2AAQAAAACAAAAAEASAAQAAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"CgAAAExTS1OrAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5IYWlyUXVhZEVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmNCB2SGFpclF1YWRFZGdlX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkCgl2SGFpclF1YWRFZGdlX1MwID0gaW5IYWlyUXVhZEVkZ2U7CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJc2tfUG9zaXRpb24gPSBfdG1wXzFfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAMQMAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgaGFsZjQgdUNvbG9yX1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdkhhaXJRdWFkRWRnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWQKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB1Q29sb3JfUzA7CgloYWxmIGVkZ2VBbHBoYTsKCWhhbGYyIGR1dmR4ID0gaGFsZjIoZEZkeCh2SGFpclF1YWRFZGdlX1MwLnh5KSk7CgloYWxmMiBkdXZkeSA9IGhhbGYyKGRGZHkodkhhaXJRdWFkRWRnZV9TMC54eSkpOwoJaGFsZjIgZ0YgPSBoYWxmMigyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeC54IC0gZHV2ZHgueSwgICAgICAgICAgICAgICAyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeS54IC0gZHV2ZHkueSk7CgllZGdlQWxwaGEgPSBoYWxmKHZIYWlyUXVhZEVkZ2VfUzAueCAqIHZIYWlyUXVhZEVkZ2VfUzAueCAtIHZIYWlyUXVhZEVkZ2VfUzAueSk7CgllZGdlQWxwaGEgPSBzcXJ0KGVkZ2VBbHBoYSAqIGVkZ2VBbHBoYSAvIGRvdChnRiwgZ0YpKTsKCWVkZ2VBbHBoYSA9IG1heCgxLjAgLSBlZGdlQWxwaGEsIDAuMCk7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGVkZ2VBbHBoYSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHwAAAAgAAAABAAAAGAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQEAAAAAAIBAEAAAABJIQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","CIAAAAAAQAARQAAYQAAAAGFYQAABRAAAAEEAAAAAAARAEAGIAFSAAAAAAQAAAAAA5AAAAAAABAAAAACAZAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAIAAEAAAABJYQAAAAAQAAIAAAAAWCBACAABAAAAANAECAZAAEAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"CgAAAExTS1N+AgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWNsYW1wX1MxX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD0zMikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMF9jMDsKCWxheW91dChvZmZzZXQ9ODApIGhhbGYyIHVJbmNyZW1lbnRfUzFfYzA7CglsYXlvdXQob2Zmc2V0PTg0KSBoYWxmMiB1T2Zmc2V0c0FuZEtlcm5lbF9TMV9jMFsxM107CglsYXlvdXQob2Zmc2V0PTE0NCkgZmxvYXQzeDMgdW1hdHJpeF9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gZmxvYXQyIGxvY2FsQ29vcmQ7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwoJewoJCXZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwID0gZmxvYXQzeDIodW1hdHJpeF9TMSkgKiBsb2NhbENvb3JkLnh5MTsKCX0KfQoAAAAAAADxBgAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1Y2xhbXBfUzFfYzBfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTMyKSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwX2MwOwoJbGF5b3V0KG9mZnNldD04MCkgaGFsZjIgdUluY3JlbWVudF9TMV9jMDsKCWxheW91dChvZmZzZXQ9ODQpIGhhbGYyIHVPZmZzZXRzQW5kS2VybmVsX1MxX2MwWzEzXTsKCWxheW91dChvZmZzZXQ9MTQ0KSBmbG9hdDN4MyB1bWF0cml4X1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwOwpoYWxmNCBUZXh0dXJlRWZmZWN0X1MxX2MwX2MwX2MwKGhhbGY0IF9pbnB1dCwgZmxvYXQyIF9jb29yZHMpIAp7CglmbG9hdDIgaW5Db29yZCA9IF9jb29yZHM7CglmbG9hdDIgc3Vic2V0Q29vcmQ7CglzdWJzZXRDb29yZC54ID0gaW5Db29yZC54OwoJc3Vic2V0Q29vcmQueSA9IGluQ29vcmQueTsKCWZsb2F0MiBjbGFtcGVkQ29vcmQ7CgljbGFtcGVkQ29vcmQueCA9IGNsYW1wKHN1YnNldENvb3JkLngsIHVjbGFtcF9TMV9jMF9jMF9jMC54LCB1Y2xhbXBfUzFfYzBfYzBfYzAueik7CgljbGFtcGVkQ29vcmQueSA9IHN1YnNldENvb3JkLnk7CgloYWxmNCB0ZXh0dXJlQ29sb3IgPSBzYW1wbGUodVRleHR1cmVTYW1wbGVyXzBfUzEsIGNsYW1wZWRDb29yZCk7CglyZXR1cm4gdGV4dHVyZUNvbG9yOwp9CmhhbGY0IE1hdHJpeEVmZmVjdF9TMV9jMF9jMChoYWxmNCBfaW5wdXQsIGZsb2F0MiBfY29vcmRzKSAKewoJcmV0dXJuIFRleHR1cmVFZmZlY3RfUzFfYzBfYzBfYzAoX2lucHV0LCBmbG9hdDN4Mih1bWF0cml4X1MxX2MwX2MwKSAqIF9jb29yZHMueHkxKTsKfQpoYWxmNCBTbW9vdGhfUzFfYzAoaGFsZjQgX2lucHV0LCBmbG9hdDIgY29vcmQsIGhhbGYyIG9mZnNldEFuZEtlcm5lbCkgCnsKCXJldHVybiBNYXRyaXhFZmZlY3RfUzFfYzBfYzAoX2lucHV0LCAoY29vcmQgKyBvZmZzZXRBbmRLZXJuZWwueCAqIHVJbmNyZW1lbnRfUzFfYzApKSAqIG9mZnNldEFuZEtlcm5lbC55Owp9CmhhbGY0IEdhdXNzaWFuQ29udm9sdXRpb25fUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgY29sb3IgPSBoYWxmNCgwKTsKCWZsb2F0MiBjb29yZCA9IHZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwOwoJZm9yIChpbnQgaT0wOyBpPDEzOyArK2kpIAoJewoJCWNvbG9yICs9IFNtb290aF9TMV9jMChfaW5wdXQsIGNvb3JkLCB1T2Zmc2V0c0FuZEtlcm5lbF9TMV9jMFtpXSk7Cgl9CglyZXR1cm4gY29sb3I7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBHYXVzc2lhbkNvbnZvbHV0aW9uX1MxX2MwKF9pbnB1dCk7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzAgPSBoYWxmNCgxKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBNYXRyaXhFZmZlY3RfUzEob3V0cHV0Q29sb3JfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dF9TMSAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAdAAAACAAAAAEAAAAQAAAAAAAAAFAAAAAAAAAAAQAAAAAAAAA=","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBQU7BTXIAAAAAACAWXW3ZEQAAAADAAAAAEQZCFOCCIJAAAIA7UXCQ6AAAAAQAAAAAAADGAWRWL3E4AQAADAAAAAAQBCFODCOJAAAAAPUXKS6AAAAAAAAQAAAADEGCIRLQYTCIAAAAAAAAAAAK6S56JIEBYAAAABAAAAAAQEH7JOFF4AAAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAEMAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAICAACAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAABAEAAAABJYQAAAAAACAIAAAAAWCBAAAIBAAAAANAEIQCAAAAQAAAAAAFAAMAAAABAAAAAAMCEAQFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADEAANAAAAAUKQGZLBIAAAAACQAAAABAAAAAGIJAKJJDIVAUAAAQABAAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAQAAAAAAAA":"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","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAOAAHSAAAAAAQAAAAAA5AAAAAAABAAAAACAZAAKAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAAMHCHGACAAQAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAADAYRYQAQYEAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAIAEOHAEGBCAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAEMHAHGBCAAAAA5B3UTQIDAAAAAEAAAAAJAQJDRYBRQIQAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","DASAAAAAQAAWAABAYAAQBYH7777Z6QQBAEAAAAAAEAAAAAAAEBSAAAB2AAAAAAACAAAAAEBSAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"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","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAAAPEAHAAABAAAAAAAKAAYAAAACAAAAAAACCAYAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGAAZAADIAAAACU53QJEKAAAAAAMAAAAAIAAAAAAGIRDFB2XASAUAABQAAAAAAAAAAAAADUAAAAAAAEAAAAAIDEAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQEAAAAAAAA":"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","B3IBQAAADAAAIAABBYAAAEIXBAAACDQMAAABIFAAAAAAAAAAAAAABFIBBYSAO7ICAAAAACX4GM5AAAAAAAIAAAAACAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAAAAAAQAAAAAEARQUPBT7IAAAAAACAAAAAAQFU5S6ZGAAAAAYAAAAAYCEOGAEGBAAAAAH5FYUXQAAAAAAACAAAAAMQEAIAAAANDMXXJYBAAAGAAAAAAABDRYBRQIQAAAAPJO5E4AAQAAAAAQAAAAGIBBCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAABAAAAAAIEDIYOAOMCEAAAAAAAAAAAFREL6S4KDYAAAACAAAAAAAAM6U52JYEBQAAAAAAAAAACYIEAIAAAAAAABUARCAIAAAAAAAAAABUABAAAAAEAAAAAIBEABKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAMWAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAACJMTCPBBAEAAAUDPSKBIPAAAAAAAAIAAAAACAIYKPQZ3UAAAAAABALL3N4SIAAAABQAAAACIMRCXBBEEQAAEAP2LRIPAAAAAIAAAAAAABTALI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAIAAAABSDBEIVYMJREAAAAAAAAAAAFPJO7EUCA4AAAAAQAAAAAICD7UXCS6AAAAAAAAAAAAACWCAACAAAAACAINAEIAAAAAAAAAAAAADZABYAAAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1PuBAAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwoJbGF5b3V0KG9mZnNldD0zMikgaGFsZjQgdXRocmVzaG9sZHNfUzFfYzBfYzBfYzBbMV07CglsYXlvdXQob2Zmc2V0PTQ4KSBmbG9hdDQgdXNjYWxlX1MxX2MwX2MwX2MwWzRdOwoJbGF5b3V0KG9mZnNldD0xMTIpIGZsb2F0NCB1Ymlhc19TMV9jMF9jMF9jMFs0XTsKCWxheW91dChvZmZzZXQ9MTc2KSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwX2MwX2MxOwoJbGF5b3V0KG9mZnNldD0yMjQpIGhhbGY0IHVsZWZ0Qm9yZGVyQ29sb3JfUzFfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTIzMikgaGFsZjQgdXJpZ2h0Qm9yZGVyQ29sb3JfUzFfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTI0MCkgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMTsKCWxheW91dChvZmZzZXQ9Mjg4KSBoYWxmIHVyYW5nZV9TMTsKCWxheW91dChvZmZzZXQ9MzA0KSBmbG9hdDQgdWlubmVyUmVjdF9TMjsKCWxheW91dChvZmZzZXQ9MzIwKSBoYWxmMiB1cmFkaXVzUGx1c0hhbGZfUzI7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQ0IGluQ2lyY2xlRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0NCB2aW5DaXJjbGVFZGdlX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CmxheW91dChsb2NhdGlvbiA9IDIpIG91dCBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzZfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCgl2aW5DaXJjbGVFZGdlX1MwID0gaW5DaXJjbGVFZGdlOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IHVsb2NhbE1hdHJpeF9TMC54eiAqIGluUG9zaXRpb24gKyB1bG9jYWxNYXRyaXhfUzAueXc7Cglza19Qb3NpdGlvbiA9IF90bXBfMF9pblBvc2l0aW9uLnh5MDE7Cgl7CgkJdlRyYW5zZm9ybWVkQ29vcmRzXzZfUzAgPSBmbG9hdDN4Mih1bWF0cml4X1MxX2MwX2MwX2MxKSAqIF90bXBfMV9pblBvc2l0aW9uLnh5MTsKCX0KfQoAAAAAAACiDgAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1bG9jYWxNYXRyaXhfUzA7CglsYXlvdXQob2Zmc2V0PTMyKSBoYWxmNCB1dGhyZXNob2xkc19TMV9jMF9jMF9jMFsxXTsKCWxheW91dChvZmZzZXQ9NDgpIGZsb2F0NCB1c2NhbGVfUzFfYzBfYzBfYzBbNF07CglsYXlvdXQob2Zmc2V0PTExMikgZmxvYXQ0IHViaWFzX1MxX2MwX2MwX2MwWzRdOwoJbGF5b3V0KG9mZnNldD0xNzYpIGZsb2F0M3gzIHVtYXRyaXhfUzFfYzBfYzBfYzE7CglsYXlvdXQob2Zmc2V0PTIyNCkgaGFsZjQgdWxlZnRCb3JkZXJDb2xvcl9TMV9jMF9jMDsKCWxheW91dChvZmZzZXQ9MjMyKSBoYWxmNCB1cmlnaHRCb3JkZXJDb2xvcl9TMV9jMF9jMDsKCWxheW91dChvZmZzZXQ9MjQwKSBmbG9hdDN4MyB1bWF0cml4X1MxX2MxOwoJbGF5b3V0KG9mZnNldD0yODgpIGhhbGYgdXJhbmdlX1MxOwoJbGF5b3V0KG9mZnNldD0zMDQpIGZsb2F0NCB1aW5uZXJSZWN0X1MyOwoJbGF5b3V0KG9mZnNldD0zMjApIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMjsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0NCB2aW5DaXJjbGVFZGdlX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBoYWxmNCB2aW5Db2xvcl9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQyIHZUcmFuc2Zvcm1lZENvb3Jkc182X1MwOwpoYWxmNCBMb29waW5nQmluYXJ5Q29sb3JpemVyX1MxX2MwX2MwX2MwKGhhbGY0IF9pbnB1dCwgZmxvYXQyIF9jb29yZHMpIAp7CgloYWxmNCBfdG1wXzBfaW5Db2xvciA9IF9pbnB1dDsKCWZsb2F0MiBfdG1wXzFfY29vcmRzID0gX2Nvb3JkczsKCWhhbGYgdCA9IGhhbGYoX3RtcF8xX2Nvb3Jkcy54KTsKCTsKCTsKCWludCBjaHVuayA9IDA7Cgk7CglpbnQgcG9zOwoJaWYgKHQgPCB1dGhyZXNob2xkc19TMV9jMF9jMF9jMFtjaHVua10ueSkgCgl7CgkJcG9zID0gaW50KHQgPCB1dGhyZXNob2xkc19TMV9jMF9jMF9jMFtjaHVua10ueCA/IDAgOiAxKTsKCX0KCWVsc2UgCgl7CgkJcG9zID0gaW50KHQgPCB1dGhyZXNob2xkc19TMV9jMF9jMF9jMFtjaHVua10ueiA/IDIgOiAzKTsKCX0KCTsKCXJldHVybiBoYWxmNChoYWxmNChmbG9hdCh0KSAqIHVzY2FsZV9TMV9jMF9jMF9jMFtwb3NdICsgdWJpYXNfUzFfYzBfYzBfYzBbcG9zXSkpOwp9CmhhbGY0IExpbmVhckxheW91dF9TMV9jMF9jMF9jMV9jMChoYWxmNCBfaW5wdXQpIAp7CgloYWxmNCBfdG1wXzJfaW5Db2xvciA9IF9pbnB1dDsKCWZsb2F0MiBfdG1wXzNfY29vcmRzID0gdlRyYW5zZm9ybWVkQ29vcmRzXzZfUzA7CglyZXR1cm4gaGFsZjQoaGFsZjQoaGFsZihfdG1wXzNfY29vcmRzLngpICsgMWUtMDUsIDEuMCwgMC4wLCAwLjApKTsKfQpoYWxmNCBNYXRyaXhFZmZlY3RfUzFfYzBfYzBfYzEoaGFsZjQgX2lucHV0KSAKewoJcmV0dXJuIExpbmVhckxheW91dF9TMV9jMF9jMF9jMV9jMChfaW5wdXQpOwp9CmhhbGY0IENsYW1wZWRHcmFkaWVudF9TMV9jMF9jMChoYWxmNCBfaW5wdXQpIAp7CgloYWxmNCBfdG1wXzRfaW5Db2xvciA9IF9pbnB1dDsKCWhhbGY0IHQgPSBNYXRyaXhFZmZlY3RfUzFfYzBfYzBfYzEoX3RtcF80X2luQ29sb3IpOwoJaGFsZjQgb3V0Q29sb3I7CglpZiAoIWJvb2woaW50KDEpKSAmJiB0LnkgPCAwLjApIAoJewoJCW91dENvbG9yID0gaGFsZjQoMC4wKTsKCX0KCWVsc2UgaWYgKHQueCA8IDAuMCkgCgl7CgkJb3V0Q29sb3IgPSB1bGVmdEJvcmRlckNvbG9yX1MxX2MwX2MwOwoJfQoJZWxzZSBpZiAodC54ID4gMS4wKSAKCXsKCQlvdXRDb2xvciA9IHVyaWdodEJvcmRlckNvbG9yX1MxX2MwX2MwOwoJfQoJZWxzZSAKCXsKCQlvdXRDb2xvciA9IExvb3BpbmdCaW5hcnlDb2xvcml6ZXJfUzFfYzBfYzBfYzAoX3RtcF80X2luQ29sb3IsIGZsb2F0MihoYWxmMih0LngsIDAuMCkpKTsKCX0KCXJldHVybiBoYWxmNChvdXRDb2xvcik7Cn0KaGFsZjQgRGlzYWJsZUNvdmVyYWdlQXNBbHBoYV9TMV9jMChoYWxmNCBfaW5wdXQpIAp7CglfaW5wdXQgPSBDbGFtcGVkR3JhZGllbnRfUzFfYzBfYzAoX2lucHV0KTsKCWhhbGY0IF90bXBfNV9pbkNvbG9yID0gX2lucHV0OwoJcmV0dXJuIGhhbGY0KF9pbnB1dCk7Cn0KaGFsZjQgVGV4dHVyZUVmZmVjdF9TMV9jMV9jMChoYWxmNCBfaW5wdXQsIGZsb2F0MiBfY29vcmRzKSAKewoJcmV0dXJuIHNhbXBsZSh1VGV4dHVyZVNhbXBsZXJfMF9TMSwgX2Nvb3JkcykuMDAwcjsKfQpoYWxmNCBNYXRyaXhFZmZlY3RfUzFfYzEoaGFsZjQgX2lucHV0LCBmbG9hdDIgX2Nvb3JkcykgCnsKCXJldHVybiBUZXh0dXJlRWZmZWN0X1MxX2MxX2MwKF9pbnB1dCwgZmxvYXQzeDIodW1hdHJpeF9TMV9jMSkgKiBfY29vcmRzLnh5MSk7Cn0KaGFsZjQgRGl0aGVyX1MxKGhhbGY0IF9pbnB1dCkgCnsKCWhhbGY0IF90bXBfNl9pbkNvbG9yID0gX2lucHV0OwoJaGFsZjQgY29sb3IgPSBEaXNhYmxlQ292ZXJhZ2VBc0FscGhhX1MxX2MwKF90bXBfNl9pbkNvbG9yKTsKCWhhbGYgdmFsdWUgPSBNYXRyaXhFZmZlY3RfUzFfYzEoX3RtcF82X2luQ29sb3IsIHNrX0ZyYWdDb29yZC54eSkudyAtIDAuNTsKCXJldHVybiBoYWxmNChoYWxmNChjbGFtcChjb2xvci54eXogKyB2YWx1ZSAqIHVyYW5nZV9TMSwgMC4wLCBjb2xvci53KSwgY29sb3IudykpOwp9CmhhbGY0IENpcmN1bGFyUlJlY3RfUzIoaGFsZjQgX2lucHV0KSAKewoJZmxvYXQyIGR4eTAgPSB1aW5uZXJSZWN0X1MyLkxUIC0gc2tfRnJhZ0Nvb3JkLnh5OwoJZmxvYXQyIGR4eTEgPSBza19GcmFnQ29vcmQueHkgLSB1aW5uZXJSZWN0X1MyLlJCOwoJZmxvYXQyIGR4eSA9IG1heChtYXgoZHh5MCwgZHh5MSksIDAuMCk7CgloYWxmIGFscGhhID0gaGFsZihzYXR1cmF0ZSh1cmFkaXVzUGx1c0hhbGZfUzIueCAtIGxlbmd0aChkeHkpKSk7CglyZXR1cm4gX2lucHV0ICogYWxwaGE7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCglmbG9hdDQgY2lyY2xlRWRnZTsKCWNpcmNsZUVkZ2UgPSB2aW5DaXJjbGVFZGdlX1MwOwoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZpbkNvbG9yX1MwOwoJZmxvYXQgZCA9IGxlbmd0aChjaXJjbGVFZGdlLnh5KTsKCWhhbGYgZGlzdGFuY2VUb091dGVyRWRnZSA9IGhhbGYoY2lyY2xlRWRnZS56ICogKDEuMCAtIGQpKTsKCWhhbGYgZWRnZUFscGhhID0gc2F0dXJhdGUoZGlzdGFuY2VUb091dGVyRWRnZSk7CgloYWxmIGRpc3RhbmNlVG9Jbm5lckVkZ2UgPSBoYWxmKGNpcmNsZUVkZ2UueiAqIChkIC0gY2lyY2xlRWRnZS53KSk7CgloYWxmIGlubmVyQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvSW5uZXJFZGdlKTsKCWVkZ2VBbHBoYSAqPSBpbm5lckFscGhhOwoJaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNChlZGdlQWxwaGEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gRGl0aGVyX1MxKG91dHB1dENvbG9yX1MwKTsKCWhhbGY0IG91dHB1dF9TMjsKCW91dHB1dF9TMiA9IENpcmN1bGFyUlJlY3RfUzIob3V0cHV0Q292ZXJhZ2VfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dF9TMSAqIG91dHB1dF9TMjsKCX0KfQoAAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAABAAAAAAAAAAMAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAfAAAADAAAAAEAAAAcAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","CIAAAAAAQAARQAAYQAAAAGFYQAABRAAAAEEAAAAAAARAEAEABYAAAAEAAAAAAAEEBQAAAACGAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEBAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQLAAAAAAAAAEAAAABJWQAAAAAAAAIAAAAAWCBAAAABAAAAANAECAZAAAAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HVIACAAAABQAAGAAAQ4AAAAAGQQAARC4GAAAIOCAAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAEABYAAAAEAAAAAAAEEBQAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","HVJAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAABAAAAAABBAMADSAB4QAAAAAEAAAAAAHIAAAAAAAIAAAAAQGIAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAMGAICAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEADZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAACIDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1aW5uZXJSZWN0X1MxOwoJbGF5b3V0KG9mZnNldD0zMikgaGFsZjIgdXJhZGl1c1BsdXNIYWxmX1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdmNvbG9yX1MwOwpoYWxmNCBDaXJjdWxhclJSZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCWZsb2F0MiBkeHkwID0gdWlubmVyUmVjdF9TMS5MVCAtIHNrX0ZyYWdDb29yZC54eTsKCWZsb2F0MiBkeHkxID0gc2tfRnJhZ0Nvb3JkLnh5IC0gdWlubmVyUmVjdF9TMS5SQjsKCWZsb2F0MiBkeHkgPSBtYXgobWF4KGR4eTAsIGR4eTEpLCAwLjApOwoJaGFsZiBhbHBoYSA9IGhhbGYoc2F0dXJhdGUodXJhZGl1c1BsdXNIYWxmX1MxLnggLSBsZW5ndGgoZHh5KSkpOwoJcmV0dXJuIF9pbnB1dCAqIGFscGhhOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2Y29sb3JfUzA7Cgljb25zdCBoYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KDEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gQ2lyY3VsYXJSUmVjdF9TMShvdXRwdXRDb3ZlcmFnZV9TMCk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRfUzE7Cgl9Cn0KAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEADZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAAUAAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAACIDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1aW5uZXJSZWN0X1MxOwoJbGF5b3V0KG9mZnNldD0zMikgaGFsZjIgdXJhZGl1c1BsdXNIYWxmX1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdmNvbG9yX1MwOwpoYWxmNCBDaXJjdWxhclJSZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCWZsb2F0MiBkeHkwID0gdWlubmVyUmVjdF9TMS5MVCAtIHNrX0ZyYWdDb29yZC54eTsKCWZsb2F0MiBkeHkxID0gc2tfRnJhZ0Nvb3JkLnh5IC0gdWlubmVyUmVjdF9TMS5SQjsKCWZsb2F0MiBkeHkgPSBtYXgobWF4KGR4eTAsIGR4eTEpLCAwLjApOwoJaGFsZiBhbHBoYSA9IGhhbGYoc2F0dXJhdGUodXJhZGl1c1BsdXNIYWxmX1MxLnggLSBsZW5ndGgoZHh5KSkpOwoJcmV0dXJuIF9pbnB1dCAqIGFscGhhOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2Y29sb3JfUzA7Cgljb25zdCBoYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KDEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gQ2lyY3VsYXJSUmVjdF9TMShvdXRwdXRDb3ZlcmFnZV9TMCk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRfUzE7Cgl9Cn0KAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","AYAA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAACAAAAADBQCAAAAAAAAAA":"CgAAAExTS1MrAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQ0IGluQ2lyY2xlRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0NCB2aW5DaXJjbGVFZGdlX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCgl2aW5DaXJjbGVFZGdlX1MwID0gaW5DaXJjbGVFZGdlOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCWZsb2F0MiBfdG1wXzJfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247Cglza19Qb3NpdGlvbiA9IF90bXBfMF9pblBvc2l0aW9uLnh5MDE7Cn0KAAAAAABwAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJZmxvYXQ0IGNpcmNsZUVkZ2U7CgljaXJjbGVFZGdlID0gdmluQ2lyY2xlRWRnZV9TMDsKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2aW5Db2xvcl9TMDsKCWZsb2F0IGQgPSBsZW5ndGgoY2lyY2xlRWRnZS54eSk7CgloYWxmIGRpc3RhbmNlVG9PdXRlckVkZ2UgPSBoYWxmKGNpcmNsZUVkZ2UueiAqICgxLjAgLSBkKSk7CgloYWxmIGVkZ2VBbHBoYSA9IHNhdHVyYXRlKGRpc3RhbmNlVG9PdXRlckVkZ2UpOwoJaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNChlZGdlQWxwaGEpOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0Q292ZXJhZ2VfUzA7Cgl9Cn0KAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAEAAAAAAAAAAwAAAB0AAAAAAAAAAQAAAAkAAAAIAAAAAQAAAB8AAAAMAAAAAQAAABwAAAAAAAAAUAAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","GCAAAAAADAAAEAABBYAAAAYXBAAAAAAAAAAAAAAA2AAQAAAACAAAAAEASAAQAAAAIYAAAAABAAAAAAAAAAAAAAAAAAAAAAAAYMAQAAAAAAAAA":"CgAAAExTS1PRAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7CglsYXlvdXQob2Zmc2V0PTI0KSBoYWxmIHVDb3ZlcmFnZV9TMDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBpblBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBoYWxmNCBpbkhhaXJRdWFkRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGhhbGY0IHZIYWlyUXVhZEVkZ2VfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWQKCXZIYWlyUXVhZEVkZ2VfUzAgPSBpbkhhaXJRdWFkRWRnZTsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247Cglza19Qb3NpdGlvbiA9IF90bXBfMV9pblBvc2l0aW9uLnh5MDE7Cn0KAAAAAAAAAGYDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGhhbGY0IHVDb2xvcl9TMDsKCWxheW91dChvZmZzZXQ9MjQpIGhhbGYgdUNvdmVyYWdlX1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdkhhaXJRdWFkRWRnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWQKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB1Q29sb3JfUzA7CgloYWxmIGVkZ2VBbHBoYTsKCWhhbGYyIGR1dmR4ID0gaGFsZjIoZEZkeCh2SGFpclF1YWRFZGdlX1MwLnh5KSk7CgloYWxmMiBkdXZkeSA9IGhhbGYyKGRGZHkodkhhaXJRdWFkRWRnZV9TMC54eSkpOwoJaGFsZjIgZ0YgPSBoYWxmMigyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeC54IC0gZHV2ZHgueSwgICAgICAgICAgICAgICAyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeS54IC0gZHV2ZHkueSk7CgllZGdlQWxwaGEgPSBoYWxmKHZIYWlyUXVhZEVkZ2VfUzAueCAqIHZIYWlyUXVhZEVkZ2VfUzAueCAtIHZIYWlyUXVhZEVkZ2VfUzAueSk7CgllZGdlQWxwaGEgPSBzcXJ0KGVkZ2VBbHBoYSAqIGVkZ2VBbHBoYSAvIGRvdChnRiwgZ0YpKTsKCWVkZ2VBbHBoYSA9IG1heCgxLjAgLSBlZGdlQWxwaGEsIDAuMCk7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KHVDb3ZlcmFnZV9TMCAqIGVkZ2VBbHBoYSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAfAAAACAAAAAEAAAAYAAAAAAAAAEYAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","GAAAAAAADAAAEAABBYAAAAYXBAAAAAAAAAAAAAAA2AAQAAAACAAAAAEASAAQAAAAIYAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"CgAAAExTS1OrAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBoYWxmNCB1Q29sb3JfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5IYWlyUXVhZEVkZ2U7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmNCB2SGFpclF1YWRFZGdlX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkCgl2SGFpclF1YWRFZGdlX1MwID0gaW5IYWlyUXVhZEVkZ2U7CglmbG9hdDIgX3RtcF8xX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJc2tfUG9zaXRpb24gPSBfdG1wXzFfaW5Qb3NpdGlvbi54eTAxOwp9CgAAAAAAMQMAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgaGFsZjQgdUNvbG9yX1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdkhhaXJRdWFkRWRnZV9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWQKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB1Q29sb3JfUzA7CgloYWxmIGVkZ2VBbHBoYTsKCWhhbGYyIGR1dmR4ID0gaGFsZjIoZEZkeCh2SGFpclF1YWRFZGdlX1MwLnh5KSk7CgloYWxmMiBkdXZkeSA9IGhhbGYyKGRGZHkodkhhaXJRdWFkRWRnZV9TMC54eSkpOwoJaGFsZjIgZ0YgPSBoYWxmMigyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeC54IC0gZHV2ZHgueSwgICAgICAgICAgICAgICAyLjAgKiB2SGFpclF1YWRFZGdlX1MwLnggKiBkdXZkeS54IC0gZHV2ZHkueSk7CgllZGdlQWxwaGEgPSBoYWxmKHZIYWlyUXVhZEVkZ2VfUzAueCAqIHZIYWlyUXVhZEVkZ2VfUzAueCAtIHZIYWlyUXVhZEVkZ2VfUzAueSk7CgllZGdlQWxwaGEgPSBzcXJ0KGVkZ2VBbHBoYSAqIGVkZ2VBbHBoYSAvIGRvdChnRiwgZ0YpKTsKCWVkZ2VBbHBoYSA9IG1heCgxLjAgLSBlZGdlQWxwaGEsIDAuMCk7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGVkZ2VBbHBoYSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAAHwAAAAgAAAABAAAAGAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAADUAANAAAAAAIBAIAAAABLCIIBAAAAABAEGABBAMAACAIAAAAAAAB2AAAAAAACAAAAAEBSAAAAARQAAAAACAAAAAAAAAAAAAAAAABAAAAAAAYAAAAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAHEADZAAAAAAIAAAAAAOQAAAAAAAQAAAABAMQAAAAAARQAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"CgAAAExTS1OkAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWlubmVyUmVjdF9TMTsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGYyIHVyYWRpdXNQbHVzSGFsZl9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgY29sb3I7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBoYWxmNCB2Y29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJdmNvbG9yX1MwID0gY29sb3I7Cglza19Qb3NpdGlvbiA9IHBvc2l0aW9uLnh5MDE7Cn0KAAAAACIDAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1aW5uZXJSZWN0X1MxOwoJbGF5b3V0KG9mZnNldD0zMikgaGFsZjIgdXJhZGl1c1BsdXNIYWxmX1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gaGFsZjQgdmNvbG9yX1MwOwpoYWxmNCBDaXJjdWxhclJSZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCWZsb2F0MiBkeHkwID0gdWlubmVyUmVjdF9TMS5MVCAtIHNrX0ZyYWdDb29yZC54eTsKCWZsb2F0MiBkeHkxID0gc2tfRnJhZ0Nvb3JkLnh5IC0gdWlubmVyUmVjdF9TMS5SQjsKCWZsb2F0MiBkeHkgPSBtYXgobWF4KGR4eTAsIGR4eTEpLCAwLjApOwoJaGFsZiBhbHBoYSA9IGhhbGYoc2F0dXJhdGUodXJhZGl1c1BsdXNIYWxmX1MxLnggLSBsZW5ndGgoZHh5KSkpOwoJcmV0dXJuIF9pbnB1dCAqIGFscGhhOwp9CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2Y29sb3JfUzA7Cgljb25zdCBoYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KDEpOwoJaGFsZjQgb3V0cHV0X1MxOwoJb3V0cHV0X1MxID0gQ2lyY3VsYXJSUmVjdF9TMShvdXRwdXRDb3ZlcmFnZV9TMCk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRfUzE7Cgl9Cn0KAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQAAEAQAAAAGQCBAMQAAAIAAAAAACQAGAAAAAQAAAAAAAQQGAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAACJMTCPBBAEAAAUDPSKBIPAAAAAAAAIAAAAACAIYKPQZ3UAAAAAABALL3N4SIAAAABQAAAACIMRCXBBEEQAAEAP2LRIPAAAAAIAAAAAAABTALI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAIAAAABSDBEIVYMJREAAAAAAAAAAAFPJO7EUCA4AAAAAQAAAAAICD7UXCS6AAAAAAAAAAAAACWCAACAAAAACAINAEIAAAAAAAAAAAAA5AAAAAAABAAAAACAZAAACGAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"CgAAAExTS1OWBAAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWxvY2FsTWF0cml4X1MwOwoJbGF5b3V0KG9mZnNldD0zMikgaGFsZjQgdXRocmVzaG9sZHNfUzFfYzBfYzBfYzBbMV07CglsYXlvdXQob2Zmc2V0PTQ4KSBmbG9hdDQgdXNjYWxlX1MxX2MwX2MwX2MwWzRdOwoJbGF5b3V0KG9mZnNldD0xMTIpIGZsb2F0NCB1Ymlhc19TMV9jMF9jMF9jMFs0XTsKCWxheW91dChvZmZzZXQ9MTc2KSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwX2MwX2MxOwoJbGF5b3V0KG9mZnNldD0yMjQpIGhhbGY0IHVsZWZ0Qm9yZGVyQ29sb3JfUzFfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTIzMikgaGFsZjQgdXJpZ2h0Qm9yZGVyQ29sb3JfUzFfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTI0MCkgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMTsKCWxheW91dChvZmZzZXQ9Mjg4KSBoYWxmIHVyYW5nZV9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBpblBvc2l0aW9uOwpsYXlvdXQobG9jYXRpb24gPSAxKSBpbiBoYWxmNCBpbkNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAyKSBpbiBmbG9hdDQgaW5DaXJjbGVFZGdlOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIG91dCBoYWxmNCB2aW5Db2xvcl9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMikgb3V0IGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfNl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFByaW1pdGl2ZSBQcm9jZXNzb3IgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCXZpbkNpcmNsZUVkZ2VfUzAgPSBpbkNpcmNsZUVkZ2U7Cgl2aW5Db2xvcl9TMCA9IGluQ29sb3I7CglmbG9hdDIgX3RtcF8wX2luUG9zaXRpb24gPSBpblBvc2l0aW9uOwoJZmxvYXQyIF90bXBfMV9pblBvc2l0aW9uID0gdWxvY2FsTWF0cml4X1MwLnh6ICogaW5Qb3NpdGlvbiArIHVsb2NhbE1hdHJpeF9TMC55dzsKCXNrX1Bvc2l0aW9uID0gX3RtcF8wX2luUG9zaXRpb24ueHkwMTsKCXsKCQl2VHJhbnNmb3JtZWRDb29yZHNfNl9TMCA9IGZsb2F0M3gyKHVtYXRyaXhfUzFfYzBfYzBfYzEpICogX3RtcF8xX2luUG9zaXRpb24ueHkxOwoJfQp9CgAAAAAAAPsMAABsYXlvdXQobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSBzYW1wbGVyMkQgdVRleHR1cmVTYW1wbGVyXzBfUzE7CmxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQ0IHVsb2NhbE1hdHJpeF9TMDsKCWxheW91dChvZmZzZXQ9MzIpIGhhbGY0IHV0aHJlc2hvbGRzX1MxX2MwX2MwX2MwWzFdOwoJbGF5b3V0KG9mZnNldD00OCkgZmxvYXQ0IHVzY2FsZV9TMV9jMF9jMF9jMFs0XTsKCWxheW91dChvZmZzZXQ9MTEyKSBmbG9hdDQgdWJpYXNfUzFfYzBfYzBfYzBbNF07CglsYXlvdXQob2Zmc2V0PTE3NikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMF9jMF9jMTsKCWxheW91dChvZmZzZXQ9MjI0KSBoYWxmNCB1bGVmdEJvcmRlckNvbG9yX1MxX2MwX2MwOwoJbGF5b3V0KG9mZnNldD0yMzIpIGhhbGY0IHVyaWdodEJvcmRlckNvbG9yX1MxX2MwX2MwOwoJbGF5b3V0KG9mZnNldD0yNDApIGZsb2F0M3gzIHVtYXRyaXhfUzFfYzE7CglsYXlvdXQob2Zmc2V0PTI4OCkgaGFsZiB1cmFuZ2VfUzE7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgdmluQ29sb3JfUzA7CmxheW91dChsb2NhdGlvbiA9IDIpIGluIGZsb2F0MiB2VHJhbnNmb3JtZWRDb29yZHNfNl9TMDsKaGFsZjQgTG9vcGluZ0JpbmFyeUNvbG9yaXplcl9TMV9jMF9jMF9jMChoYWxmNCBfaW5wdXQsIGZsb2F0MiBfY29vcmRzKSAKewoJaGFsZjQgX3RtcF8wX2luQ29sb3IgPSBfaW5wdXQ7CglmbG9hdDIgX3RtcF8xX2Nvb3JkcyA9IF9jb29yZHM7CgloYWxmIHQgPSBoYWxmKF90bXBfMV9jb29yZHMueCk7Cgk7Cgk7CglpbnQgY2h1bmsgPSAwOwoJOwoJaW50IHBvczsKCWlmICh0IDwgdXRocmVzaG9sZHNfUzFfYzBfYzBfYzBbY2h1bmtdLnkpIAoJewoJCXBvcyA9IGludCh0IDwgdXRocmVzaG9sZHNfUzFfYzBfYzBfYzBbY2h1bmtdLnggPyAwIDogMSk7Cgl9CgllbHNlIAoJewoJCXBvcyA9IGludCh0IDwgdXRocmVzaG9sZHNfUzFfYzBfYzBfYzBbY2h1bmtdLnogPyAyIDogMyk7Cgl9Cgk7CglyZXR1cm4gaGFsZjQoaGFsZjQoZmxvYXQodCkgKiB1c2NhbGVfUzFfYzBfYzBfYzBbcG9zXSArIHViaWFzX1MxX2MwX2MwX2MwW3Bvc10pKTsKfQpoYWxmNCBMaW5lYXJMYXlvdXRfUzFfYzBfYzBfYzFfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgX3RtcF8yX2luQ29sb3IgPSBfaW5wdXQ7CglmbG9hdDIgX3RtcF8zX2Nvb3JkcyA9IHZUcmFuc2Zvcm1lZENvb3Jkc182X1MwOwoJcmV0dXJuIGhhbGY0KGhhbGY0KGhhbGYoX3RtcF8zX2Nvb3Jkcy54KSArIDFlLTA1LCAxLjAsIDAuMCwgMC4wKSk7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxX2MwX2MwX2MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBMaW5lYXJMYXlvdXRfUzFfYzBfYzBfYzFfYzAoX2lucHV0KTsKfQpoYWxmNCBDbGFtcGVkR3JhZGllbnRfUzFfYzBfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgX3RtcF80X2luQ29sb3IgPSBfaW5wdXQ7CgloYWxmNCB0ID0gTWF0cml4RWZmZWN0X1MxX2MwX2MwX2MxKF90bXBfNF9pbkNvbG9yKTsKCWhhbGY0IG91dENvbG9yOwoJaWYgKCFib29sKGludCgxKSkgJiYgdC55IDwgMC4wKSAKCXsKCQlvdXRDb2xvciA9IGhhbGY0KDAuMCk7Cgl9CgllbHNlIGlmICh0LnggPCAwLjApIAoJewoJCW91dENvbG9yID0gdWxlZnRCb3JkZXJDb2xvcl9TMV9jMF9jMDsKCX0KCWVsc2UgaWYgKHQueCA+IDEuMCkgCgl7CgkJb3V0Q29sb3IgPSB1cmlnaHRCb3JkZXJDb2xvcl9TMV9jMF9jMDsKCX0KCWVsc2UgCgl7CgkJb3V0Q29sb3IgPSBMb29waW5nQmluYXJ5Q29sb3JpemVyX1MxX2MwX2MwX2MwKF90bXBfNF9pbkNvbG9yLCBmbG9hdDIoaGFsZjIodC54LCAwLjApKSk7Cgl9CglyZXR1cm4gaGFsZjQob3V0Q29sb3IpOwp9CmhhbGY0IERpc2FibGVDb3ZlcmFnZUFzQWxwaGFfUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJX2lucHV0ID0gQ2xhbXBlZEdyYWRpZW50X1MxX2MwX2MwKF9pbnB1dCk7CgloYWxmNCBfdG1wXzVfaW5Db2xvciA9IF9pbnB1dDsKCXJldHVybiBoYWxmNChfaW5wdXQpOwp9CmhhbGY0IFRleHR1cmVFZmZlY3RfUzFfYzFfYzAoaGFsZjQgX2lucHV0LCBmbG9hdDIgX2Nvb3JkcykgCnsKCXJldHVybiBzYW1wbGUodVRleHR1cmVTYW1wbGVyXzBfUzEsIF9jb29yZHMpLjAwMHI7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxX2MxKGhhbGY0IF9pbnB1dCwgZmxvYXQyIF9jb29yZHMpIAp7CglyZXR1cm4gVGV4dHVyZUVmZmVjdF9TMV9jMV9jMChfaW5wdXQsIGZsb2F0M3gyKHVtYXRyaXhfUzFfYzEpICogX2Nvb3Jkcy54eTEpOwp9CmhhbGY0IERpdGhlcl9TMShoYWxmNCBfaW5wdXQpIAp7CgloYWxmNCBfdG1wXzZfaW5Db2xvciA9IF9pbnB1dDsKCWhhbGY0IGNvbG9yID0gRGlzYWJsZUNvdmVyYWdlQXNBbHBoYV9TMV9jMChfdG1wXzZfaW5Db2xvcik7CgloYWxmIHZhbHVlID0gTWF0cml4RWZmZWN0X1MxX2MxKF90bXBfNl9pbkNvbG9yLCBza19GcmFnQ29vcmQueHkpLncgLSAwLjU7CglyZXR1cm4gaGFsZjQoaGFsZjQoY2xhbXAoY29sb3IueHl6ICsgdmFsdWUgKiB1cmFuZ2VfUzEsIDAuMCwgY29sb3IudyksIGNvbG9yLncpKTsKfQp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGYgZGlzdGFuY2VUb0lubmVyRWRnZSA9IGhhbGYoY2lyY2xlRWRnZS56ICogKGQgLSBjaXJjbGVFZGdlLncpKTsKCWhhbGYgaW5uZXJBbHBoYSA9IHNhdHVyYXRlKGRpc3RhbmNlVG9Jbm5lckVkZ2UpOwoJZWRnZUFscGhhICo9IGlubmVyQWxwaGE7CgloYWxmNCBvdXRwdXRDb3ZlcmFnZV9TMCA9IGhhbGY0KGVkZ2VBbHBoYSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBEaXRoZXJfUzEob3V0cHV0Q29sb3JfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dF9TMSAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAQAAAAAAAAADAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAAHwAAAAwAAAABAAAAHAAAAAAAAABGAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","AYAA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1MrAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQ0IGluQ2lyY2xlRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0NCB2aW5DaXJjbGVFZGdlX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCgl2aW5DaXJjbGVFZGdlX1MwID0gaW5DaXJjbGVFZGdlOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCWZsb2F0MiBfdG1wXzJfaW5Qb3NpdGlvbiA9IGluUG9zaXRpb247Cglza19Qb3NpdGlvbiA9IF90bXBfMF9pblBvc2l0aW9uLnh5MDE7Cn0KAAAAAABwAgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDQgdmluQ2lyY2xlRWRnZV9TMDsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBTdGFnZSAwLCBDaXJjbGVHZW9tZXRyeVByb2Nlc3NvcgoJZmxvYXQ0IGNpcmNsZUVkZ2U7CgljaXJjbGVFZGdlID0gdmluQ2lyY2xlRWRnZV9TMDsKCWhhbGY0IG91dHB1dENvbG9yX1MwOwoJb3V0cHV0Q29sb3JfUzAgPSB2aW5Db2xvcl9TMDsKCWZsb2F0IGQgPSBsZW5ndGgoY2lyY2xlRWRnZS54eSk7CgloYWxmIGRpc3RhbmNlVG9PdXRlckVkZ2UgPSBoYWxmKGNpcmNsZUVkZ2UueiAqICgxLjAgLSBkKSk7CgloYWxmIGVkZ2VBbHBoYSA9IHNhdHVyYXRlKGRpc3RhbmNlVG9PdXRlckVkZ2UpOwoJaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNChlZGdlQWxwaGEpOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dENvbG9yX1MwICogb3V0cHV0Q292ZXJhZ2VfUzA7Cgl9Cn0KAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAAAAAEAAAAAAAAAAwAAAB0AAAAAAAAAAQAAAAkAAAAIAAAAAQAAAB8AAAAMAAAAAQAAABwAAAAAAAAARgAAAAEAAAABAAAABQAAAAAAAAABAAAABQAAAAAAAAABAAAAAAAAAA==","AY7SRAADQAAAOAEARAFQJAABBADAAAILBYAACCYUAAAQWGUAAEECAAAAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAARCLL25YSAAAAABQAAAACJMTCPBBAEAAAUDPSKBIPAAAAAAAAIAAAAACAIYKPQZ3UAAAAAABALL3N4SIAAAABQAAAACIMRCXBBEEQAAEAP2LRIPAAAAAIAAAAAAABTALI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAIAAAABSDBEIVYMJREAAAAAAAAAAAFPJO7EUCA4AAAAAQAAAAAICD7UXCS6AAAAAAAAAAAAACWCAACAAAAACAINAEIAAAAAAAAAAAAA5AAAAAAABAAAAACAZAAACQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEAAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAAAHUAAAAABABLFMNCQCAAAKAAAAAEAAAAABAEMIRA5SWCRAAAAAFAAAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","FAAQMYAAMAAAEADAAABAEYAAAICIAB5AABQAAAQAMAAAEATAAABAIIGAAEDCBYQCA4AAAAAAAA5AAAAAAABAAAAACAZAAAAAKAAAAAABAAAAAAAAAAAAAAAAAAQAAAAAYMAQAAAAAAAAA":"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","FABQMYAAMAAAEADAAABAEYAAAICIACWAABQAAAQAMAAAEATAAABAIYAAAIDGAAACBAQOEAQKAAAAAAFAGLAIDZFAJ4AAAACAQF7UMBYAAAAABITF56OQIAAAQAAQAAAATQEU3MJAAAAAB5F3UTQACAAAAAAAACAAAAAMRCAC76GA4AAAAAAEJS66HMEQAAAAAMAAAABYCONGEQIAAAAOQ52JYEBQAAAABAAAAAEQCGEJNPLXCIAAAAAGAAAAA4BGGTCYEAAAADIO7EUCA4AAAABAAAAAAIEDTQEU3MJAAAAAAAAAAAAKYSF7JMFB4AAAABAAAAAAQAGPLO5E4AAQAAAAAAAAAAFMEAAEAAAAAAAA2AIRAEAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAB3QA6AAAEAAAAAAAMAAMEAEAAABAAAAAAB2AAAAAAACAAAAAEBSAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFQBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAACADHIJJCYCAAAEAP2LRIPAAAAAAAAAAAEAAAAAZKHQJ7UIBAAAABAAAAAAIA2GZPMTQCAAAMAAAAAAAM5BFGLAIAAAAB7JOFF4AAAAAAAAQAAAADEBACAAAADI3F52OAIAABQAAAAAABTUEUZMBAAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAJYCKNWEQAAAAA6S52JYABAAAAACAAAAAMQIDHIJJSYCAAAAAAAAAAAAV5F34SQIDQAAAACAAAAABAIP6S4KLYAAAAAAAAAAAAAKYIAAIAAAAAIBBUARAAAAAAAAAAAAAAHUAAAAABABLFMNCQCAAAKAAAAACADYAABAAAAAAIBDCEIHMVQUIAAAABIAAAAAAAAAAAOAQHSAAAAAAQAAAAAA5AAAAAAABAAAAACAZAAACQAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAGDAEBAAAAAAAAA":"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","HTRQAGAABBYAAAEIXBAAAGEAMAAAAAAAAAAAAAAAWAGHAIBZ5AJQAAAA5C5DCQYAAAAABADI3F5SOAIAABQAAAAAIARCXBRHEQAAAAH2LVJPAAAAAAAAAAAEAAAAAZFE5PDAYAIAAAAABITF56OQIAAAQAAQAAAARGWBRHUQAAAAB2DXJHAQGAAAAAEAAAAASAIYRFV5O4JAAAAAAYAAAABEWJRHQQQCAAAKBXZFAUHQAAAAIAAAAACAAYJVSMJ4EEAQAAAAAAAABMBC7UXCS6AAAAAAAAIAAAADFVHPSKBAOAAAAAAAAAAAWCBAAAABAAAAANAEIQCAAAAAAAAAAABQAAGQAAAAKFIDMVQUAAAAAAYAAAAAQAAAADEEQFEURUKQKAAAYAAAAAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAAARQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","AYQA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACABZQA6AAAEAAAAAAAIADQAAAAIAAAAAAAIIDCGAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEAAAAAAAAAA":"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","DAQAAAAAAABGAABAYAAQAIHCAIAYAQUBAEAAAAAAEAAAAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAARQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAABAEAAAABJYQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"CgAAAExTS1N+AgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWNsYW1wX1MxX2MwX2MwX2MwOwoJbGF5b3V0KG9mZnNldD0zMikgZmxvYXQzeDMgdW1hdHJpeF9TMV9jMF9jMDsKCWxheW91dChvZmZzZXQ9ODApIGhhbGYyIHVJbmNyZW1lbnRfUzFfYzA7CglsYXlvdXQob2Zmc2V0PTg0KSBoYWxmMiB1T2Zmc2V0c0FuZEtlcm5lbF9TMV9jMFsxM107CglsYXlvdXQob2Zmc2V0PTE0NCkgZmxvYXQzeDMgdW1hdHJpeF9TMTsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGZsb2F0MiBwb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gZmxvYXQyIGxvY2FsQ29vcmQ7CmxheW91dChsb2NhdGlvbiA9IDApIG91dCBmbG9hdDIgdlRyYW5zZm9ybWVkQ29vcmRzXzJfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwoJewoJCXZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwID0gZmxvYXQzeDIodW1hdHJpeF9TMSkgKiBsb2NhbENvb3JkLnh5MTsKCX0KfQoAAAAAAADxBgAAbGF5b3V0KG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gc2FtcGxlcjJEIHVUZXh0dXJlU2FtcGxlcl8wX1MxOwpsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKCWxheW91dChvZmZzZXQ9MTYpIGZsb2F0NCB1Y2xhbXBfUzFfYzBfYzBfYzA7CglsYXlvdXQob2Zmc2V0PTMyKSBmbG9hdDN4MyB1bWF0cml4X1MxX2MwX2MwOwoJbGF5b3V0KG9mZnNldD04MCkgaGFsZjIgdUluY3JlbWVudF9TMV9jMDsKCWxheW91dChvZmZzZXQ9ODQpIGhhbGYyIHVPZmZzZXRzQW5kS2VybmVsX1MxX2MwWzEzXTsKCWxheW91dChvZmZzZXQ9MTQ0KSBmbG9hdDN4MyB1bWF0cml4X1MxOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIHZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwOwpoYWxmNCBUZXh0dXJlRWZmZWN0X1MxX2MwX2MwX2MwKGhhbGY0IF9pbnB1dCwgZmxvYXQyIF9jb29yZHMpIAp7CglmbG9hdDIgaW5Db29yZCA9IF9jb29yZHM7CglmbG9hdDIgc3Vic2V0Q29vcmQ7CglzdWJzZXRDb29yZC54ID0gaW5Db29yZC54OwoJc3Vic2V0Q29vcmQueSA9IGluQ29vcmQueTsKCWZsb2F0MiBjbGFtcGVkQ29vcmQ7CgljbGFtcGVkQ29vcmQueCA9IHN1YnNldENvb3JkLng7CgljbGFtcGVkQ29vcmQueSA9IGNsYW1wKHN1YnNldENvb3JkLnksIHVjbGFtcF9TMV9jMF9jMF9jMC55LCB1Y2xhbXBfUzFfYzBfYzBfYzAudyk7CgloYWxmNCB0ZXh0dXJlQ29sb3IgPSBzYW1wbGUodVRleHR1cmVTYW1wbGVyXzBfUzEsIGNsYW1wZWRDb29yZCk7CglyZXR1cm4gdGV4dHVyZUNvbG9yOwp9CmhhbGY0IE1hdHJpeEVmZmVjdF9TMV9jMF9jMChoYWxmNCBfaW5wdXQsIGZsb2F0MiBfY29vcmRzKSAKewoJcmV0dXJuIFRleHR1cmVFZmZlY3RfUzFfYzBfYzBfYzAoX2lucHV0LCBmbG9hdDN4Mih1bWF0cml4X1MxX2MwX2MwKSAqIF9jb29yZHMueHkxKTsKfQpoYWxmNCBTbW9vdGhfUzFfYzAoaGFsZjQgX2lucHV0LCBmbG9hdDIgY29vcmQsIGhhbGYyIG9mZnNldEFuZEtlcm5lbCkgCnsKCXJldHVybiBNYXRyaXhFZmZlY3RfUzFfYzBfYzAoX2lucHV0LCAoY29vcmQgKyBvZmZzZXRBbmRLZXJuZWwueCAqIHVJbmNyZW1lbnRfUzFfYzApKSAqIG9mZnNldEFuZEtlcm5lbC55Owp9CmhhbGY0IEdhdXNzaWFuQ29udm9sdXRpb25fUzFfYzAoaGFsZjQgX2lucHV0KSAKewoJaGFsZjQgY29sb3IgPSBoYWxmNCgwKTsKCWZsb2F0MiBjb29yZCA9IHZUcmFuc2Zvcm1lZENvb3Jkc18yX1MwOwoJZm9yIChpbnQgaT0wOyBpPDEzOyArK2kpIAoJewoJCWNvbG9yICs9IFNtb290aF9TMV9jMChfaW5wdXQsIGNvb3JkLCB1T2Zmc2V0c0FuZEtlcm5lbF9TMV9jMFtpXSk7Cgl9CglyZXR1cm4gY29sb3I7Cn0KaGFsZjQgTWF0cml4RWZmZWN0X1MxKGhhbGY0IF9pbnB1dCkgCnsKCXJldHVybiBHYXVzc2lhbkNvbnZvbHV0aW9uX1MxX2MwKF9pbnB1dCk7Cn0Kdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzAgPSBoYWxmNCgxKTsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7CgloYWxmNCBvdXRwdXRfUzE7CglvdXRwdXRfUzEgPSBNYXRyaXhFZmZlY3RfUzEob3V0cHV0Q29sb3JfUzApOwoJewoJCS8vIFhmZXIgUHJvY2Vzc29yOiBQb3J0ZXIgRHVmZgoJCXNrX0ZyYWdDb2xvciA9IG91dHB1dF9TMSAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwAAAABAAAAAAAAAAIAAAAdAAAAAAAAAAEAAAAdAAAACAAAAAEAAAAQAAAAAAAAAEYAAAAAAAAAAQAAAAAAAAA=","AZAA5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1N4AgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDN4MyB1bG9jYWxNYXRyaXhfUzA7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgaW5Qb3NpdGlvbjsKbGF5b3V0KGxvY2F0aW9uID0gMSkgaW4gaGFsZjQgaW5Db2xvcjsKbGF5b3V0KGxvY2F0aW9uID0gMikgaW4gZmxvYXQ0IGluQ2lyY2xlRWRnZTsKbGF5b3V0KGxvY2F0aW9uID0gMCkgb3V0IGZsb2F0NCB2aW5DaXJjbGVFZGdlX1MwOwpsYXlvdXQobG9jYXRpb24gPSAxKSBvdXQgaGFsZjQgdmluQ29sb3JfUzA7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIENpcmNsZUdlb21ldHJ5UHJvY2Vzc29yCgl2aW5DaXJjbGVFZGdlX1MwID0gaW5DaXJjbGVFZGdlOwoJdmluQ29sb3JfUzAgPSBpbkNvbG9yOwoJZmxvYXQyIF90bXBfMF9pblBvc2l0aW9uID0gaW5Qb3NpdGlvbjsKCWZsb2F0MiBfdG1wXzFfaW5Qb3NpdGlvbiA9IGZsb2F0M3gyKHVsb2NhbE1hdHJpeF9TMCkgKiBpblBvc2l0aW9uLnh5MTsKCXNrX1Bvc2l0aW9uID0gX3RtcF8wX2luUG9zaXRpb24ueHkwMTsKfQoAAAAAnQIAAGxheW91dCAobWV0YWwsIGJpbmRpbmc9MCkgdW5pZm9ybSB1bmlmb3JtQnVmZmVyCnsKCWxheW91dChvZmZzZXQ9MCkgZmxvYXQ0IHNrX1JUQWRqdXN0OwoJbGF5b3V0KG9mZnNldD0xNikgZmxvYXQzeDMgdWxvY2FsTWF0cml4X1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQ0IHZpbkNpcmNsZUVkZ2VfUzA7CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IHZpbkNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gU3RhZ2UgMCwgQ2lyY2xlR2VvbWV0cnlQcm9jZXNzb3IKCWZsb2F0NCBjaXJjbGVFZGdlOwoJY2lyY2xlRWRnZSA9IHZpbkNpcmNsZUVkZ2VfUzA7CgloYWxmNCBvdXRwdXRDb2xvcl9TMDsKCW91dHB1dENvbG9yX1MwID0gdmluQ29sb3JfUzA7CglmbG9hdCBkID0gbGVuZ3RoKGNpcmNsZUVkZ2UueHkpOwoJaGFsZiBkaXN0YW5jZVRvT3V0ZXJFZGdlID0gaGFsZihjaXJjbGVFZGdlLnogKiAoMS4wIC0gZCkpOwoJaGFsZiBlZGdlQWxwaGEgPSBzYXR1cmF0ZShkaXN0YW5jZVRvT3V0ZXJFZGdlKTsKCWhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoZWRnZUFscGhhKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogUG9ydGVyIER1ZmYKCQlza19GcmFnQ29sb3IgPSBvdXRwdXRDb2xvcl9TMCAqIG91dHB1dENvdmVyYWdlX1MwOwoJfQp9CgAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAABAAAAAAAAAAMAAAAdAAAAAAAAAAEAAAAJAAAACAAAAAEAAAAfAAAADAAAAAEAAAAcAAAAAAAAAFAAAAABAAAAAQAAAAUAAAAAAAAAAQAAAAUAAAAAAAAAAQAAAAAAAAA=","DAQAAAAAAABGAABAYAAQAIHCAIAYAQUBAEAAAAAAEAAAAAAAAAAAAAB2AAAAAAACAAAAAEBSAAAAAUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"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","HUQAAAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAADEAANAAAAALHCKLMRAAAAAAAAABAAAAAGJBCFLQVBWAQAAAAAAQAAAAAMACQCAACAAAAA2AIBAEIAAAAAAAAAAAAIADQAAAAIAAAAAAAIIDAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUJAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAQAAAAAAQQGABBACUIAAAAABAAOAAAABAAAAAAABBAMAAAAARQAAAAACAAAAAAAAAAAAAAAAAAAAAAABQYBAIAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAIBAEAAAABJYQAAAAAQCAIAAAAAWCBACAIBAAAAANAECAZAAEAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQFAAAAAAABAEAAAABJKQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","FAAQMYAAMAAAEADAAABAEYAAAICIAB5AABQAAAQAMAAAEATAAABAIIGAAEDCBYQCA4AAAAAAEADZABYAAAIAAAAAACQAGAAAAAQAAAAAAAQQGUAAAAAACAAAAAAAAAAAAAAAAABAAAAABQYBAAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAIAAEAAAABJYQAAAAAQAAIAAAAAWCBACAABAAAAANAECAZAAEAAAAAAAAFAAMAAAABAAAAAAABBANDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAABAEAAAABJYQAAAAAACAIAAAAAWCBAAAIBAAAAANAECAZAAAAQAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","AYQQ5AADQAAAOAEARAFQJAABBADIB7777777777777777777777767YAAAAAAAAAACAMUAAHSKBT4AIAAAAAL7QZDUAAAAAABAAAAAEIS26XOEQAAAAAMAAAAAMHCHGACAAQAAFA34SQKDYAAAAAAACAAAAAAQCGCT4GO5AAAAAAAIAAAAACAWXW3ZEQAAAADAAAAADAYRYQAQYEAAAIA7UXCQ6AAAAAQAAAAAEABSAQAAAAQBUNS6ZHAEAAAYAAAAAIAEOHAEGBCAAAAD5F2UXQAAAAAAACAAAAAZAEUJS67HIEAAAIAAIAAAAEMHAHGBCAAAAA5B3UTQIDAAAAAEAAAAAJAQJDRYBRQIQAAAAAAAAAACWERP2LBIPAAAAAIAAAAAEABT23XJHAAEAAAAAAAAAABLBAABAAAAAAAAGQCEIBAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAIAAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQBAEAQAAAAGQCEIBAACAIAAAAAACQAGAAAAAQAAAAAGBCAIAAAAAFAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAQAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBQU7BTXIAAAAAACAWXW3ZEQAAAADAAAAADAYRYQAQYEAAAIA7UXCQ6AAAAAQAAAAAAADGAWRWL3E4AQAADAAAAABAARY4AQYEIAAAAPUXKS6AAAAAAAAQAAAADE2CEOGAEGBAAAAAAAAAAAAK6S56JIEBYAAAABAAAAAAQEH7JOFF4AAAAAAAAAAAAAHIAAAAAAAIAAAAAQGIAFAAAAAAAQAAAAAAAAAAAAAAAAAIAAAAAICAACAAAAAAAA":"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","CIAAAAAAQAARQAAYQAAAAGFYQAABRAAAAEEAAAAAAARAEAEABYAAAAEAAAAAAAEEBQAAAACGAAAAAAIAAAAAAAAAAAAAAAAAEAAAAAGDAEBAAAAAAAAA":"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","AY7SRAADQAAAOAEARAFQJAABBADAAAILBYAACCYUAAAQWGUAAEECAAAAAAAAAAAAAAAOQAAAAAAAQAAAABAMQAAAABDAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"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","HUQACAAAAAMAADAAAIOAAAH677776IZOCAAP577777777777777777YBAAAAAAAAAAAKAAYAAAACAAAAAAACCAYAABIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAADBQCAAAAAAAAAA":"CgAAAExTS1NOAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7Cn0KOwpsYXlvdXQobG9jYXRpb24gPSAwKSBpbiBmbG9hdDIgcG9zaXRpb247CmxheW91dChsb2NhdGlvbiA9IDEpIGluIGhhbGY0IGNvbG9yOwpsYXlvdXQobG9jYXRpb24gPSAwKSBvdXQgaGFsZjQgdmNvbG9yX1MwOwp2b2lkIG1haW4oKSAKewoJLy8gUHJpbWl0aXZlIFByb2Nlc3NvciBRdWFkUGVyRWRnZUFBR2VvbWV0cnlQcm9jZXNzb3IKCXZjb2xvcl9TMCA9IGNvbG9yOwoJc2tfUG9zaXRpb24gPSBwb3NpdGlvbi54eTAxOwp9CgAAAAAAAH0BAABsYXlvdXQgKG1ldGFsLCBiaW5kaW5nPTApIHVuaWZvcm0gdW5pZm9ybUJ1ZmZlcgp7CglsYXlvdXQob2Zmc2V0PTApIGZsb2F0NCBza19SVEFkanVzdDsKfQo7CmxheW91dChsb2NhdGlvbiA9IDApIGluIGhhbGY0IHZjb2xvcl9TMDsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIFF1YWRQZXJFZGdlQUFHZW9tZXRyeVByb2Nlc3NvcgoJaGFsZjQgb3V0cHV0Q29sb3JfUzA7CglvdXRwdXRDb2xvcl9TMCA9IHZjb2xvcl9TMDsKCWNvbnN0IGhhbGY0IG91dHB1dENvdmVyYWdlX1MwID0gaGFsZjQoMSk7Cgl7CgkJLy8gWGZlciBQcm9jZXNzb3I6IFBvcnRlciBEdWZmCgkJc2tfRnJhZ0NvbG9yID0gb3V0cHV0Q29sb3JfUzAgKiBvdXRwdXRDb3ZlcmFnZV9TMDsKCX0KfQoAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUAAAAAQAAAAAAAAACAAAAHQAAAAAAAAABAAAACQAAAAgAAAABAAAADAAAAAAAAABQAAAAAQAAAAEAAAAFAAAAAAAAAAEAAAAFAAAAAAAAAAEAAAAAAAAA","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAEABYAAAAEAAAAAAAEEBQAAAAEMAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HVIAAAAAABIAAGAAAQ4AAAH477776R24EAAAIOBQAD6P7777777777YDAAAAAAAAAAAFIBRYSAOPICIAAAACR4GP5AAAAAAAIAAAAACAWTWL3EYAAAADAAAAADAIRYYAQYEAAAAA7UXCS6AAAAAAAAAAAIAAAABSULAD7IYDAAAAAAABAAAABUNS65HAEAAAYAAAAAAAEOHAGGBCAAAAB5F3UTQACAAAAACAAAAAMQEAIAAAABCMXXR3BEAAAAADAAAABDBYBZQIQAAAADIO7EUCA4AAAAAQAAAAAIBDCAWXX3ZEAAAAADAAAAADBYRYQAQQEAAAIC7UWCQ6AAAABAAAAAAIADA2OEOMAEABAAAAAAAAABQEL6S5KLYAAAAAAABAAAAAMSUN6JIFB4AAAAAAAAAAAYAFAEAAEAAAABUARCAIAAAAAAAAAAAEABYAAAAEAAAAAAAEEBQAAAAFAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAMGAICAAAAAAAA":"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","HUIAAAAAAAQAADAAAIOAAAH677777777777QGHAQAD7P7777777777YBAAAAAAAAAAALUAQMAAAAAAIAAEAAAABJYQAAAAAQAAIAAAAAWCBACAABAAAAANAECAZAAEAAAAAAAAFAAMAAAABAAAAAAABBANIAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAA":"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","I4EAAAIAAEHAAAAAAAAAAAAAAAAIQAAAAAAIBEABAAAAACQAAAAAIAAAAD6QAAAAAEAAAAAAAAAAAAQAAAAAAAAAAA":"CgAAAExTS1M2AgAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWFmZmluZU1hdHJpeF9TMDsKCWxheW91dChvZmZzZXQ9MzIpIGZsb2F0MiB1dHJhbnNsYXRlX1MwOwoJbGF5b3V0KG9mZnNldD00MCkgaGFsZjQgdWNvbG9yX1MwOwp9CjsKbGF5b3V0KGxvY2F0aW9uID0gMCkgaW4gZmxvYXQyIGlucHV0UG9pbnQ7CnZvaWQgbWFpbigpIAp7CgkvLyBQcmltaXRpdmUgUHJvY2Vzc29yIHRlc3NlbGxhdGVfU2ltcGxlVHJpYW5nbGVTaGFkZXIKCWZsb2F0MngyIEFGRklORV9NQVRSSVggPSBmbG9hdDJ4Mih1YWZmaW5lTWF0cml4X1MwLnh5LCB1YWZmaW5lTWF0cml4X1MwLnp3KTsKCWZsb2F0MiBUUkFOU0xBVEUgPSB1dHJhbnNsYXRlX1MwOwoJZmxvYXQyIGxvY2FsY29vcmQgPSBpbnB1dFBvaW50OwoJZmxvYXQyIHZlcnRleHBvcyA9IEFGRklORV9NQVRSSVggKiBsb2NhbGNvb3JkICsgVFJBTlNMQVRFOwoJc2tfUG9zaXRpb24gPSB2ZXJ0ZXhwb3MueHkwMTsKfQoAAAAAAACKAQAAbGF5b3V0IChtZXRhbCwgYmluZGluZz0wKSB1bmlmb3JtIHVuaWZvcm1CdWZmZXIKewoJbGF5b3V0KG9mZnNldD0wKSBmbG9hdDQgc2tfUlRBZGp1c3Q7CglsYXlvdXQob2Zmc2V0PTE2KSBmbG9hdDQgdWFmZmluZU1hdHJpeF9TMDsKCWxheW91dChvZmZzZXQ9MzIpIGZsb2F0MiB1dHJhbnNsYXRlX1MwOwoJbGF5b3V0KG9mZnNldD00MCkgaGFsZjQgdWNvbG9yX1MwOwp9CjsKdm9pZCBtYWluKCkgCnsKCS8vIFN0YWdlIDAsIHRlc3NlbGxhdGVfU2ltcGxlVHJpYW5nbGVTaGFkZXIKCWhhbGY0IG91dHB1dENvbG9yX1MwID0gdWNvbG9yX1MwOwoJY29uc3QgaGFsZjQgb3V0cHV0Q292ZXJhZ2VfUzAgPSBoYWxmNCgxKTsKCXsKCQkvLyBYZmVyIFByb2Nlc3NvcjogRGlzYWJsZSBDb2xvcgoJfQp9CgAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAEAAAAAAAAAAQAAAB0AAAAAAAAAAQAAAAgAAAAAAAAACgAAAAAAAAAAAAAA/QAAAA=="}}
\ No newline at end of file