From 09ff1ca5df4e5b77af01b28d19f992bf4a8e2093 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?And=C5=BEej=20Maciusovi=C4=8D?= Date: Tue, 3 Dec 2019 16:52:54 +0200 Subject: [PATCH] Rewrite in native Android (#175) --- .gitlab-ci.yml | 23 -- Gemfile.lock | 2 +- android/app/build.gradle | 167 +++------ .../network.mysterium.db.AppDatabase/1.json | 54 +++ android/app/src/debug/AndroidManifest.xml | 2 +- android/app/src/main/AndroidManifest.xml | 77 +++-- .../java/network/mysterium/AppContainer.kt | 61 ++++ .../java/network/mysterium/MainActivity.kt | 151 ++++++++ .../java/network/mysterium/MainApplication.kt | 54 +++ .../java/network/mysterium/db/AppDatabase.kt | 10 + .../mysterium/db/FavoriteProposalDao.kt | 20 ++ .../java/network/mysterium/db/TermsDao.kt | 20 ++ .../network/mysterium/logging/BugReporter.kt | 23 +- .../mysterium/service/core/DeferredNode.kt | 35 ++ .../core/MysteriumAndroidCoreService.kt | 165 ++++++--- .../service/core/MysteriumCoreService.kt | 9 +- .../mysterium/service/core/NodeRepository.kt | 147 ++++++++ .../core/Openvpn3AndroidTunnelSetupBridge.kt | 254 +++++++------- .../core/WireguardAndroidTunnelSetup.kt | 3 +- .../java/network/mysterium/ui/Countries.kt | 313 +++++++++++++++++ .../EditText.kt} | 29 +- .../network/mysterium/ui/FeedbackFragment.kt | 103 ++++++ .../network/mysterium/ui/FeedbackViewModel.kt | 61 ++++ .../java/network/mysterium/ui/Keyboard.kt | 27 ++ .../network/mysterium/ui/MainVpnFragment.kt | 260 ++++++++++++++ .../MaterialSpinner.kt} | 25 +- .../java/network/mysterium/ui/Navigation.kt | 42 +++ .../network/mysterium/ui/ProposalViewItem.kt | 89 +++++ .../network/mysterium/ui/ProposalsFragment.kt | 251 ++++++++++++++ .../mysterium/ui/ProposalsViewModel.kt | 243 +++++++++++++ .../network/mysterium/ui/SharedViewModel.kt | 247 +++++++++++++ .../network/mysterium/ui/TermsFragment.kt | 64 ++++ .../network/mysterium/ui/TermsViewModel.kt | 182 ++++++++++ .../main/java/network/mysterium/ui/Toast.kt | 26 ++ .../network/mysterium/ui/UnitFormatter.kt | 62 ++++ .../network/mysterium/vpn/MainActivity.kt | 159 --------- .../mysterium/vpn/MainApplication.java | 118 ------- .../vpn/connection/ConnectionChecker.kt | 79 ----- .../src/main/res/drawable/background_logo.png | Bin 0 -> 143919 bytes .../main/res/drawable/background_splash.xml | 12 + .../main/res/drawable/bordered_input_bg.xml | 8 + .../main/res/drawable/ic_arrow_back_24dp.xml | 5 + .../drawable/ic_arrow_downward_black_24dp.xml | 5 + .../res/drawable/ic_help_outline_34dp.xml | 5 + .../drawable/ic_help_outline_black_24dp.xml | 5 + .../res/drawable/ic_public_black_24dp.xml | 5 + .../res/drawable/ic_search_white_34dp.xml | 5 + .../main/res/drawable/ic_star_black_24dp.xml | 5 + .../drawable/ic_star_border_black_24dp.xml | 5 + .../main/res/drawable/notification_icon.png | Bin 0 -> 3209 bytes .../main/res/drawable/proposal_picker_bg.xml | 7 + .../main/res/drawable/proposals_filter_bg.xml | 24 ++ .../src/main/res/drawable/quality_high.png | Bin 0 -> 1636 bytes .../app/src/main/res/drawable/quality_low.png | Bin 0 -> 1654 bytes .../src/main/res/drawable/quality_medium.png | Bin 0 -> 1640 bytes .../src/main/res/drawable/quality_unknown.png | Bin 0 -> 1628 bytes .../main/res/drawable/round_icon_button.xml | 10 + .../app/src/main/res/drawable/selector.xml | 5 + .../src/main/res/drawable/service_openvpn.png | Bin 0 -> 4717 bytes .../main/res/drawable/service_wireguard.png | Bin 0 -> 19549 bytes .../main/res/drawable/spinner_input_arrow.png | Bin 0 -> 1326 bytes .../main/res/drawable/spinner_input_bg.xml | 17 + .../app/src/main/res/drawable/splash_logo.png | Bin 0 -> 22654 bytes .../app/src/main/res/layout/activity_main.xml | 20 ++ .../src/main/res/layout/fragment_feedback.xml | 109 ++++++ .../src/main/res/layout/fragment_main_vpn.xml | 325 ++++++++++++++++++ .../main/res/layout/fragment_proposals.xml | 173 ++++++++++ .../src/main/res/layout/fragment_terms.xml | 46 +++ .../main/res/layout/proposal_list_item.xml | 75 ++++ .../app/src/main/res/navigation/nav_graph.xml | 40 +++ android/app/src/main/res/values/arrays.xml | 13 + android/app/src/main/res/values/strings.xml | 24 ++ android/app/src/main/res/values/styles.xml | 39 ++- .../main/res/xml/network_security_config.xml | 7 - .../res/xml/network_security_config_debug.xml | 4 - .../app/src/test/java/UnitFormatterTest.kt | 40 +++ android/build.gradle | 18 +- android/gradle.properties | 3 +- android/settings.gradle | 5 - fastlane/Fastfile | 26 +- fastlane/README.md | 5 + 81 files changed, 3953 insertions(+), 799 deletions(-) create mode 100644 android/app/schemas/network.mysterium.db.AppDatabase/1.json create mode 100644 android/app/src/main/java/network/mysterium/AppContainer.kt create mode 100644 android/app/src/main/java/network/mysterium/MainActivity.kt create mode 100644 android/app/src/main/java/network/mysterium/MainApplication.kt create mode 100644 android/app/src/main/java/network/mysterium/db/AppDatabase.kt create mode 100644 android/app/src/main/java/network/mysterium/db/FavoriteProposalDao.kt create mode 100644 android/app/src/main/java/network/mysterium/db/TermsDao.kt create mode 100644 android/app/src/main/java/network/mysterium/service/core/DeferredNode.kt create mode 100644 android/app/src/main/java/network/mysterium/service/core/NodeRepository.kt create mode 100644 android/app/src/main/java/network/mysterium/ui/Countries.kt rename android/app/src/main/java/network/mysterium/{vpn/connection/ConnectionCheckerService.kt => ui/EditText.kt} (50%) create mode 100644 android/app/src/main/java/network/mysterium/ui/FeedbackFragment.kt create mode 100644 android/app/src/main/java/network/mysterium/ui/FeedbackViewModel.kt create mode 100644 android/app/src/main/java/network/mysterium/ui/Keyboard.kt create mode 100644 android/app/src/main/java/network/mysterium/ui/MainVpnFragment.kt rename android/app/src/main/java/network/mysterium/{logging/BugReporterPackage.kt => ui/MaterialSpinner.kt} (55%) create mode 100644 android/app/src/main/java/network/mysterium/ui/Navigation.kt create mode 100644 android/app/src/main/java/network/mysterium/ui/ProposalViewItem.kt create mode 100644 android/app/src/main/java/network/mysterium/ui/ProposalsFragment.kt create mode 100644 android/app/src/main/java/network/mysterium/ui/ProposalsViewModel.kt create mode 100644 android/app/src/main/java/network/mysterium/ui/SharedViewModel.kt create mode 100644 android/app/src/main/java/network/mysterium/ui/TermsFragment.kt create mode 100644 android/app/src/main/java/network/mysterium/ui/TermsViewModel.kt create mode 100644 android/app/src/main/java/network/mysterium/ui/Toast.kt create mode 100644 android/app/src/main/java/network/mysterium/ui/UnitFormatter.kt delete mode 100644 android/app/src/main/java/network/mysterium/vpn/MainActivity.kt delete mode 100644 android/app/src/main/java/network/mysterium/vpn/MainApplication.java delete mode 100644 android/app/src/main/java/network/mysterium/vpn/connection/ConnectionChecker.kt create mode 100644 android/app/src/main/res/drawable/background_logo.png create mode 100644 android/app/src/main/res/drawable/background_splash.xml create mode 100644 android/app/src/main/res/drawable/bordered_input_bg.xml create mode 100644 android/app/src/main/res/drawable/ic_arrow_back_24dp.xml create mode 100644 android/app/src/main/res/drawable/ic_arrow_downward_black_24dp.xml create mode 100644 android/app/src/main/res/drawable/ic_help_outline_34dp.xml create mode 100644 android/app/src/main/res/drawable/ic_help_outline_black_24dp.xml create mode 100644 android/app/src/main/res/drawable/ic_public_black_24dp.xml create mode 100644 android/app/src/main/res/drawable/ic_search_white_34dp.xml create mode 100644 android/app/src/main/res/drawable/ic_star_black_24dp.xml create mode 100644 android/app/src/main/res/drawable/ic_star_border_black_24dp.xml create mode 100644 android/app/src/main/res/drawable/notification_icon.png create mode 100644 android/app/src/main/res/drawable/proposal_picker_bg.xml create mode 100644 android/app/src/main/res/drawable/proposals_filter_bg.xml create mode 100644 android/app/src/main/res/drawable/quality_high.png create mode 100644 android/app/src/main/res/drawable/quality_low.png create mode 100644 android/app/src/main/res/drawable/quality_medium.png create mode 100644 android/app/src/main/res/drawable/quality_unknown.png create mode 100644 android/app/src/main/res/drawable/round_icon_button.xml create mode 100644 android/app/src/main/res/drawable/selector.xml create mode 100644 android/app/src/main/res/drawable/service_openvpn.png create mode 100644 android/app/src/main/res/drawable/service_wireguard.png create mode 100644 android/app/src/main/res/drawable/spinner_input_arrow.png create mode 100644 android/app/src/main/res/drawable/spinner_input_bg.xml create mode 100644 android/app/src/main/res/drawable/splash_logo.png create mode 100644 android/app/src/main/res/layout/activity_main.xml create mode 100644 android/app/src/main/res/layout/fragment_feedback.xml create mode 100644 android/app/src/main/res/layout/fragment_main_vpn.xml create mode 100644 android/app/src/main/res/layout/fragment_proposals.xml create mode 100644 android/app/src/main/res/layout/fragment_terms.xml create mode 100644 android/app/src/main/res/layout/proposal_list_item.xml create mode 100644 android/app/src/main/res/navigation/nav_graph.xml create mode 100644 android/app/src/main/res/values/arrays.xml delete mode 100644 android/app/src/main/res/xml/network_security_config.xml delete mode 100644 android/app/src/main/res/xml/network_security_config_debug.xml create mode 100644 android/app/src/test/java/UnitFormatterTest.kt diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 8f2797f07..7606c0ac6 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -1,33 +1,10 @@ image: mysteriumnetwork/mobile-ci:0.1.0 stages: - - install - - test - deploy -install-packages: - stage: install - script: - - yarn install - cache: - paths: - - node_modules/ - artifacts: - when: on_success - paths: - - node_modules/ - -lint-and-test: - stage: test - dependencies: - - install-packages - script: - - yarn ci - push-beta: stage: deploy - dependencies: - - install-packages when: manual only: - master diff --git a/Gemfile.lock b/Gemfile.lock index d834a7f7a..bc54b7310 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -145,4 +145,4 @@ DEPENDENCIES fastlane BUNDLED WITH - 1.16.5 + 2.0.2 diff --git a/android/app/build.gradle b/android/app/build.gradle index c9627371a..e02560d15 100644 --- a/android/app/build.gradle +++ b/android/app/build.gradle @@ -1,86 +1,11 @@ -apply plugin: "com.android.application" +apply plugin: 'com.android.application' apply plugin: 'kotlin-android' apply plugin: 'io.fabric' +apply plugin: 'kotlin-android-extensions' +apply plugin: 'kotlin-kapt' import com.android.build.OutputFile -/** - * The react.gradle file registers a task for each build variant (e.g. bundleDebugJsAndAssets - * and bundleReleaseJsAndAssets). - * These basically call `react-native bundle` with the correct arguments during the Android build - * cycle. By default, bundleDebugJsAndAssets is skipped, as in debug/dev mode we prefer to load the - * bundle directly from the development server. Below you can see all the possible configurations - * and their defaults. If you decide to add a configuration block, make sure to add it before the - * `apply from: "../../node_modules/react-native/react.gradle"` line. - * - * project.ext.react = [ - * // the name of the generated asset file containing your JS bundle - * bundleAssetName: "index.android.bundle", - * - * // the entry file for bundle generation - * entryFile: "index.android.js", - * - * // whether to bundle JS and assets in debug mode - * bundleInDebug: false, - * - * // whether to bundle JS and assets in release mode - * bundleInRelease: true, - * - * // whether to bundle JS and assets in another build variant (if configured). - * // See http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Build-Variants - * // The configuration property can be in the following formats - * // 'bundleIn${productFlavor}${buildType}' - * // 'bundleIn${buildType}' - * // bundleInFreeDebug: true, - * // bundleInPaidRelease: true, - * // bundleInBeta: true, - * - * // whether to disable dev mode in custom build variants (by default only disabled in release) - * // for example: to disable dev mode in the staging build type (if configured) - * devDisabledInStaging: true, - * // The configuration property can be in the following formats - * // 'devDisabledIn${productFlavor}${buildType}' - * // 'devDisabledIn${buildType}' - * - * // the root of your project, i.e. where "package.json" lives - * root: "../../", - * - * // where to put the JS bundle asset in debug mode - * jsBundleDirDebug: "$buildDir/intermediates/assets/debug", - * - * // where to put the JS bundle asset in release mode - * jsBundleDirRelease: "$buildDir/intermediates/assets/release", - * - * // where to put drawable resources / React Native assets, e.g. the ones you use via - * // require('./image.png')), in debug mode - * resourcesDirDebug: "$buildDir/intermediates/res/merged/debug", - * - * // where to put drawable resources / React Native assets, e.g. the ones you use via - * // require('./image.png')), in release mode - * resourcesDirRelease: "$buildDir/intermediates/res/merged/release", - * - * // by default the gradle tasks are skipped if none of the JS files or assets change; this means - * // that we don't look at files in android/ or ios/ to determine whether the tasks are up to - * // date; if you have any other folders that you want to ignore for performance reasons (gradle - * // indexes the entire tree), add them here. Alternatively, if you have JS files in android/ - * // for example, you might want to remove it from here. - * inputExcludes: ["android/**", "ios/**"], - * - * // override which node gets called and with what additional arguments - * nodeExecutableAndArgs: ["node"], - * - * // supply additional arguments to the packager - * extraPackagerArgs: [] - * ] - */ - -project.ext.react = [ - entryFile: "index.js", - enableHermes: false, // clean and rebuild if changing -] - -apply from: "../../node_modules/react-native/react.gradle" - /** * Get the version code from command line param * @@ -125,27 +50,6 @@ def enableSeparateBuildPerCPUArchitecture = false */ def enableProguardInReleaseBuilds = false -/** - * The preferred build flavor of JavaScriptCore. - * - * For example, to use the international variant, you can use: - * `def jscFlavor = 'org.webkit:android-jsc-intl:+'` - * - * The international variant includes ICU i18n library and necessary data - * allowing to use e.g. `Date.toLocaleString` and `String.localeCompare` that - * give correct results when using with locales other than en-US. Note that - * this variant is about 6MiB larger per architecture than default. - */ -def jscFlavor = 'org.webkit:android-jsc:+' -/** - * Whether to enable the Hermes VM. - * - * This should be set on project.ext.react and mirrored here. If it is not set - * on project.ext.react, JavaScript will not be compiled to Hermes Bytecode - * and the benefits of using Hermes will therefore be sharply reduced. - */ -def enableHermes = project.ext.react.get("enableHermes", false); - android { compileSdkVersion rootProject.ext.compileSdkVersion @@ -154,12 +58,23 @@ android { targetCompatibility JavaVersion.VERSION_1_8 } + testOptions { + unitTests.includeAndroidResources = true + } + defaultConfig { applicationId "network.mysterium.vpn" minSdkVersion rootProject.ext.minSdkVersion targetSdkVersion rootProject.ext.targetSdkVersion versionCode getVersionCode() versionName getVersionName() + multiDexEnabled true + + javaCompileOptions { + annotationProcessorOptions { + arguments = ["room.schemaLocation": "$projectDir/schemas".toString()] + } + } } splits { abi { @@ -179,7 +94,6 @@ android { } buildTypes { release { - // signingConfig signingConfigs.debug // TODO(am): check if this is needed minifyEnabled enableProguardInReleaseBuilds proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro" } @@ -205,28 +119,41 @@ android { } dependencies { - implementation project(':react-native-push-notification') - implementation project(':react-native-vector-icons') + def nav_version = "2.1.0" + implementation "androidx.navigation:navigation-fragment-ktx:$nav_version" + implementation "androidx.navigation:navigation-ui-ktx:$nav_version" + implementation('com.crashlytics.sdk.android:crashlytics:2.9.6@aar') { - transitive = true - } - if (enableHermes) { - def hermesPath = "../../node_modules/hermes-engine/android/"; - debugImplementation files(hermesPath + "hermes-debug.aar") - releaseImplementation files(hermesPath + "hermes-release.aar") - } else { - implementation jscFlavor + transitive = true } - implementation "androidx.appcompat:appcompat:1.0.0" - implementation 'com.facebook.react:react-native:+' - implementation 'cat.ereza:logcatreporter:1.2.0' - // From node_modules - implementation 'com.google.firebase:firebase-core:16.0.1' + implementation 'androidx.multidex:multidex:2.0.1' + implementation 'com.google.firebase:firebase-core:17.2.1' implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version" - - implementation 'network.mysterium:mobile-node:0.14.1' - // implementation files('libs/Mysterium.aar') + implementation 'androidx.constraintlayout:constraintlayout:1.1.3' + implementation 'androidx.legacy:legacy-support-v4:1.0.0' + implementation 'androidx.appcompat:appcompat:1.1.0' + implementation 'androidx.core:core-ktx:1.1.0' + implementation 'androidx.constraintlayout:constraintlayout:1.1.3' + implementation 'androidx.lifecycle:lifecycle-extensions:2.1.0' + implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.1.0' + implementation 'com.google.android.material:material:1.0.0' + implementation 'androidx.recyclerview:recyclerview:1.1.0' + implementation 'com.makeramen:roundedimageview:2.3.0' + implementation 'com.beust:klaxon:5.0.1' + implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.0' + implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.0" + implementation "org.jetbrains.kotlin:kotlin-reflect:1.3.50" + implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.1.0" + implementation 'androidx.room:room-runtime:2.2.2' + implementation 'androidx.room:room-ktx:2.2.2' + kapt 'androidx.room:room-compiler:2.2.2' + + testImplementation 'junit:junit:4.12' + + implementation 'network.mysterium:mobile-node:0.15.0' + // Comment network.mysterium:mobile-node and replace with your local path to use local node build. + // compile files('/Users/anjmao/go/src/github.com/mysteriumnetwork/node/build/package/Mysterium.aar') } // Run this once to be able to run the application with BUCK @@ -241,12 +168,10 @@ gradle.projectsEvaluated { } task applyGoogleServicesIfNeeded { - if(project.hasProperty('applyGoogleServices')) { + if (project.hasProperty('applyGoogleServices')) { apply plugin: 'com.google.gms.google-services' } } repositories { mavenCentral() } - -apply from: file("../../node_modules/@react-native-community/cli-platform-android/native_modules.gradle"); applyNativeModulesAppBuildGradle(project) \ No newline at end of file diff --git a/android/app/schemas/network.mysterium.db.AppDatabase/1.json b/android/app/schemas/network.mysterium.db.AppDatabase/1.json new file mode 100644 index 000000000..e4e9a108b --- /dev/null +++ b/android/app/schemas/network.mysterium.db.AppDatabase/1.json @@ -0,0 +1,54 @@ +{ + "formatVersion": 1, + "database": { + "version": 1, + "identityHash": "e51f75311548ddc3e5a322d3d572711d", + "entities": [ + { + "tableName": "FavoriteProposal", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, PRIMARY KEY(`id`))", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + } + ], + "primaryKey": { + "columnNames": [ + "id" + ], + "autoGenerate": false + }, + "indices": [], + "foreignKeys": [] + }, + { + "tableName": "Terms", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`version` TEXT NOT NULL, PRIMARY KEY(`version`))", + "fields": [ + { + "fieldPath": "version", + "columnName": "version", + "affinity": "TEXT", + "notNull": true + } + ], + "primaryKey": { + "columnNames": [ + "version" + ], + "autoGenerate": false + }, + "indices": [], + "foreignKeys": [] + } + ], + "views": [], + "setupQueries": [ + "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)", + "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'e51f75311548ddc3e5a322d3d572711d')" + ] + } +} \ No newline at end of file diff --git a/android/app/src/debug/AndroidManifest.xml b/android/app/src/debug/AndroidManifest.xml index b4ee49a4e..46f2eb736 100644 --- a/android/app/src/debug/AndroidManifest.xml +++ b/android/app/src/debug/AndroidManifest.xml @@ -2,5 +2,5 @@ - + diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml index 15a1a6e39..17da84094 100644 --- a/android/app/src/main/AndroidManifest.xml +++ b/android/app/src/main/AndroidManifest.xml @@ -1,47 +1,48 @@ + + - - - - - - - - - - - - - - + android:theme="@style/AppTheme" + tools:ignore="GoogleAppIndexingWarning"> - - - + + + + + + + + + + + + + + + - + + \ No newline at end of file diff --git a/android/app/src/main/java/network/mysterium/AppContainer.kt b/android/app/src/main/java/network/mysterium/AppContainer.kt new file mode 100644 index 000000000..d2eb717ab --- /dev/null +++ b/android/app/src/main/java/network/mysterium/AppContainer.kt @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package network.mysterium + +import android.content.Context +import androidx.fragment.app.FragmentActivity +import androidx.room.Room +import kotlinx.coroutines.CompletableDeferred +import network.mysterium.db.AppDatabase +import network.mysterium.logging.BugReporter +import network.mysterium.service.core.DeferredNode +import network.mysterium.service.core.MysteriumCoreService +import network.mysterium.service.core.NodeRepository +import network.mysterium.ui.ProposalsViewModel +import network.mysterium.ui.SharedViewModel +import network.mysterium.ui.TermsViewModel + +class AppContainer { + lateinit var appDatabase: AppDatabase + lateinit var nodeRepository: NodeRepository + lateinit var sharedViewModel: SharedViewModel + lateinit var proposalsViewModel: ProposalsViewModel + lateinit var termsViewModel: TermsViewModel + lateinit var bugReporter: BugReporter + lateinit var deferredMysteriumCoreService: CompletableDeferred + + fun init(ctx: Context, deferredNode: DeferredNode, mysteriumCoreService: CompletableDeferred) { + appDatabase = Room.databaseBuilder( + ctx, + AppDatabase::class.java, "mysteriumvpn" + ).build() + + deferredMysteriumCoreService = mysteriumCoreService + bugReporter = BugReporter() + nodeRepository = NodeRepository(deferredNode) + sharedViewModel = SharedViewModel(nodeRepository, bugReporter, deferredMysteriumCoreService) + proposalsViewModel = ProposalsViewModel(sharedViewModel, nodeRepository, appDatabase) + termsViewModel = TermsViewModel(appDatabase) + } + + companion object { + fun from(activity: FragmentActivity?): AppContainer { + return (activity!!.application as MainApplication).appContainer + } + } +} diff --git a/android/app/src/main/java/network/mysterium/MainActivity.kt b/android/app/src/main/java/network/mysterium/MainActivity.kt new file mode 100644 index 000000000..62c6c7ecb --- /dev/null +++ b/android/app/src/main/java/network/mysterium/MainActivity.kt @@ -0,0 +1,151 @@ +/* + * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package network.mysterium + +import android.app.Activity +import android.content.ComponentName +import android.content.Context +import android.content.Intent +import android.content.ServiceConnection +import android.net.VpnService +import android.os.Bundle +import android.os.IBinder +import android.util.Log +import android.widget.Toast +import androidx.appcompat.app.AppCompatActivity +import androidx.navigation.Navigation +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import network.mysterium.service.core.DeferredNode +import network.mysterium.service.core.MysteriumAndroidCoreService +import network.mysterium.service.core.MysteriumCoreService +import network.mysterium.vpn.R + +class MainActivity : AppCompatActivity() { + private lateinit var appContainer: AppContainer + private var deferredNode = DeferredNode() + private var deferredMysteriumCoreService = CompletableDeferred() + + private val serviceConnection = object : ServiceConnection { + override fun onServiceDisconnected(name: ComponentName?) { + Log.i(TAG, "Service disconnected") + } + + override fun onServiceConnected(name: ComponentName?, service: IBinder?) { + Log.i(TAG, "Service connected") + deferredMysteriumCoreService.complete(service as MysteriumCoreService) + deferredNode.start(service) {err -> + if (err != null) { + showNodeStarError() + } + } + } + } + + override fun onCreate(savedInstanceState: Bundle?) { + setTheme(R.style.AppTheme) + super.onCreate(savedInstanceState) + setContentView(R.layout.activity_main) + + // Initialize app DI container. + appContainer = (application as MainApplication).appContainer + appContainer.init(applicationContext, deferredNode, deferredMysteriumCoreService) + + // Bind VPN service. + ensureVpnServicePermission() + bindMysteriumService() + + // Load initial state without blocking main UI thread. + CoroutineScope(Dispatchers.Main).launch { + // Load favorite proposals from local database. + val favoriteProposals = appContainer.proposalsViewModel.loadFavoriteProposals() + + // Load initial data like current location, statistics, active proposal (if any). + appContainer.sharedViewModel.load(favoriteProposals) + + // Load initial proposals. + appContainer.proposalsViewModel.load() + } + + // Navigate to main vpn screen and check if terms are accepted in separate coroutine + // so it does not block main thread. + navigate(R.id.main_vpn_fragment) + CoroutineScope(Dispatchers.Main).launch { + val termsAccepted = appContainer.termsViewModel.checkTermsAccepted() + if (!termsAccepted) { + navigate(R.id.terms_fragment) + } + } + } + + override fun onDestroy() { + unbindMysteriumService() + super.onDestroy() + } + + override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { + super.onActivityResult(requestCode, resultCode, data) + + when (requestCode) { + VPN_SERVICE_REQUEST -> { + if (resultCode != Activity.RESULT_OK) { + Log.w(TAG, "User forbidden VPN service") + Toast.makeText(this, "VPN connection has to be granted for MysteriumVPN to work.", Toast.LENGTH_LONG).show() + finish() + return + } + Log.i(TAG, "User allowed VPN service") + } + } + } + + private fun showNodeStarError() { + Toast.makeText(this, "Failed to initialize. Please relaunch app.", Toast.LENGTH_LONG).show() + } + + private fun bindMysteriumService() { + Log.i(TAG, "Binding service") + Intent(this, MysteriumAndroidCoreService::class.java).also { intent -> + bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE) + } + } + + private fun unbindMysteriumService() { + Log.i(TAG, "Unbinding service") + unbindService(serviceConnection) + } + + private fun ensureVpnServicePermission() { + val intent: Intent = VpnService.prepare(this) ?: return + startActivityForResult(intent, VPN_SERVICE_REQUEST) + } + + private fun navigate(destination: Int) { + val navController = Navigation.findNavController(this, R.id.nav_host_fragment) + val navGraph = navController.navInflater.inflate(R.navigation.nav_graph) + navGraph.startDestination = destination + navController.graph = navGraph + } + + companion object { + private const val VPN_SERVICE_REQUEST = 1 + private const val TAG = "MainActivity" + } +} diff --git a/android/app/src/main/java/network/mysterium/MainApplication.kt b/android/app/src/main/java/network/mysterium/MainApplication.kt new file mode 100644 index 000000000..52f2bb375 --- /dev/null +++ b/android/app/src/main/java/network/mysterium/MainApplication.kt @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package network.mysterium + +import android.util.Log +import androidx.multidex.MultiDexApplication +import com.crashlytics.android.Crashlytics +import com.crashlytics.android.core.CrashlyticsCore +import io.fabric.sdk.android.Fabric +import network.mysterium.ui.Countries +import network.mysterium.vpn.BuildConfig + +class MainApplication : MultiDexApplication() { + val appContainer = AppContainer() + + override fun onCreate() { + setupLogging() + super.onCreate() + Countries.loadBitmaps() + Log.i(TAG, "Application started") + } + + private fun setupLogging() { + // https://docs.fabric.io/android/crashlytics/build-tools.html?highlight=crashlyticscore + // Set up Crashlytics, disabled for debug builds + val crashlyticsKit = Crashlytics.Builder() + .core(CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build()) + .build() + + // Initialize Fabric with the debug-disabled crashlytics. + Fabric.with(this, crashlyticsKit) + + Crashlytics.setInt("android_sdk_int", android.os.Build.VERSION.SDK_INT) + } + + companion object { + private const val TAG = "MainApplication" + } +} diff --git a/android/app/src/main/java/network/mysterium/db/AppDatabase.kt b/android/app/src/main/java/network/mysterium/db/AppDatabase.kt new file mode 100644 index 000000000..ed7362f80 --- /dev/null +++ b/android/app/src/main/java/network/mysterium/db/AppDatabase.kt @@ -0,0 +1,10 @@ +package network.mysterium.db + +import androidx.room.Database +import androidx.room.RoomDatabase + +@Database(entities = [FavoriteProposal::class, Terms::class], version = 1) +abstract class AppDatabase : RoomDatabase() { + abstract fun favoriteProposalDao(): FavoriteProposalDao + abstract fun termsDao(): TermsDao +} diff --git a/android/app/src/main/java/network/mysterium/db/FavoriteProposalDao.kt b/android/app/src/main/java/network/mysterium/db/FavoriteProposalDao.kt new file mode 100644 index 000000000..e1a4742da --- /dev/null +++ b/android/app/src/main/java/network/mysterium/db/FavoriteProposalDao.kt @@ -0,0 +1,20 @@ +package network.mysterium.db + +import androidx.room.* + +@Entity +data class FavoriteProposal( + @PrimaryKey val id: String +) + +@Dao +interface FavoriteProposalDao { + @Query("SELECT * FROM favoriteproposal") + suspend fun getAll(): List + + @Insert + suspend fun insert(favoriteProposal: FavoriteProposal) + + @Delete + suspend fun delete(favoriteProposal: FavoriteProposal) +} diff --git a/android/app/src/main/java/network/mysterium/db/TermsDao.kt b/android/app/src/main/java/network/mysterium/db/TermsDao.kt new file mode 100644 index 000000000..f79aac705 --- /dev/null +++ b/android/app/src/main/java/network/mysterium/db/TermsDao.kt @@ -0,0 +1,20 @@ +package network.mysterium.db + +import androidx.room.* + +@Entity +data class Terms( + @PrimaryKey val version: String +) + +@Dao +interface TermsDao { + @Query("SELECT * FROM terms LIMIT 1") + suspend fun get(): Terms? + + @Insert + suspend fun insert(terms: Terms) + + @Query("DELETE FROM terms") + suspend fun delete() +} diff --git a/android/app/src/main/java/network/mysterium/logging/BugReporter.kt b/android/app/src/main/java/network/mysterium/logging/BugReporter.kt index 62b94d88b..2cf2e5bf0 100644 --- a/android/app/src/main/java/network/mysterium/logging/BugReporter.kt +++ b/android/app/src/main/java/network/mysterium/logging/BugReporter.kt @@ -17,31 +17,10 @@ package network.mysterium.logging -import cat.ereza.logcatreporter.LogcatReporter import com.crashlytics.android.Crashlytics -import com.facebook.react.bridge.ReactApplicationContext -import com.facebook.react.bridge.ReactContextBaseJavaModule -import com.facebook.react.bridge.ReactMethod -class FeedbackException(message: String) : Exception(message) - -class BugReporter(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) { - override fun getName(): String { - return "BugReporter" - } - - @ReactMethod - fun logException(value: String) { - LogcatReporter.reportExceptionWithLogcat(RuntimeException(value)) - } - - @ReactMethod +class BugReporter { fun setUserIdentifier(userIdentifier: String) { Crashlytics.setUserIdentifier(userIdentifier) } - - @ReactMethod - fun sendFeedback(type: String, message: String) { - LogcatReporter.reportExceptionWithLogcat(FeedbackException(type + ":" + message)) - } } diff --git a/android/app/src/main/java/network/mysterium/service/core/DeferredNode.kt b/android/app/src/main/java/network/mysterium/service/core/DeferredNode.kt new file mode 100644 index 000000000..8564669e4 --- /dev/null +++ b/android/app/src/main/java/network/mysterium/service/core/DeferredNode.kt @@ -0,0 +1,35 @@ +package network.mysterium.service.core + +import android.util.Log +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import mysterium.MobileNode + +// DeferredNode is a wrapper class which holds MobileNode instance promise. +// This allows to load UI without waiting for node to start. +class DeferredNode { + private var deferredNode = CompletableDeferred() + + suspend fun await(): MobileNode { + return deferredNode.await() + } + + fun start(service: MysteriumCoreService, done: (err: Exception?) -> Unit) { + CoroutineScope(Dispatchers.Main).launch { + try { + val node = service.startNode() + deferredNode.complete(node) + done(null) + } catch (err: Exception) { + Log.e(TAG, "Failed to start node", err) + done(err) + } + } + } + + companion object { + const val TAG = "DeferredNode" + } +} diff --git a/android/app/src/main/java/network/mysterium/service/core/MysteriumAndroidCoreService.kt b/android/app/src/main/java/network/mysterium/service/core/MysteriumAndroidCoreService.kt index 5c0024459..29c0fd113 100644 --- a/android/app/src/main/java/network/mysterium/service/core/MysteriumAndroidCoreService.kt +++ b/android/app/src/main/java/network/mysterium/service/core/MysteriumAndroidCoreService.kt @@ -17,64 +17,147 @@ package network.mysterium.service.core +import android.app.NotificationChannel +import android.app.NotificationManager +import android.app.PendingIntent +import android.content.Context import android.content.Intent import android.net.VpnService import android.os.Binder +import android.os.Build import android.os.IBinder import android.util.Log +import androidx.core.app.NotificationCompat import mysterium.MobileNode import mysterium.Mysterium +import network.mysterium.MainActivity +import network.mysterium.vpn.BuildConfig +import network.mysterium.vpn.R class MysteriumAndroidCoreService : VpnService() { - private var mobileNode: MobileNode? = null - - fun startMobileNode(filesPath: String) { - val openvpnBridge = Openvpn3AndroidTunnelSetupBridge(this) - val wireguardBridge = WireguardAndroidTunnelSetup(this) - - val logOptions = Mysterium.defaultLogOptions() - val options = Mysterium.defaultNetworkOptions() - - mobileNode = Mysterium.newNode(filesPath, logOptions, options) - mobileNode?.overrideOpenvpnConnection(openvpnBridge) - mobileNode?.overrideWireguardConnection(wireguardBridge) - Log.i(TAG, "started") - } - - fun stopMobileNode() { - val node = mobileNode - if (node == null) { - Log.w(TAG, "Trying to stop node when instance is not set") - return + private var mobileNode: MobileNode? = null + private val notificationsChannelId = BuildConfig.APPLICATION_ID + + // pendingAppIntent is used to navigate back to MainActivity + // when user taps on notification. + private lateinit var pendingAppIntent: PendingIntent + + fun startMobileNode(filesPath: String): MobileNode { + if (mobileNode != null) { + return mobileNode!! + } + + val openvpnBridge = Openvpn3AndroidTunnelSetupBridge(this) + val wireguardBridge = WireguardAndroidTunnelSetup(this) + + val logOptions = Mysterium.defaultLogOptions() + logOptions.filepath = filesPath + logOptions.logHTTP = false + val options = Mysterium.defaultNetworkOptions() + + mobileNode = Mysterium.newNode(filesPath, logOptions, options) + mobileNode?.overrideOpenvpnConnection(openvpnBridge) + mobileNode?.overrideWireguardConnection(wireguardBridge) + + Log.i(TAG, "started") + return mobileNode!! } - node.shutdown() - try { - node.waitUntilDies() - } catch (e: Exception) { - Log.i(TAG, "Got exception, safe to ignore: " + e.message) + fun stopMobileNode() { + val node = mobileNode + if (node == null) { + Log.w(TAG, "Trying to stop node when instance is not set") + return + } + + node.shutdown() + try { + node.waitUntilDies() + } catch (e: Exception) { + Log.i(TAG, "Got exception, safe to ignore: " + e.message) + } finally { + stopForeground(true) + } } - } - override fun onRevoke() { - Log.w(TAG, "VPN service revoked!") - } + override fun onCreate() { + super.onCreate() - inner class MysteriumCoreServiceBridge : Binder(), MysteriumCoreService { - override fun StartTequila() { - startMobileNode(filesDir.canonicalPath) + val intent = Intent(this, MainActivity::class.java).apply { + flags = Intent.FLAG_ACTIVITY_SINGLE_TOP + } + pendingAppIntent = PendingIntent.getActivity(this, 0, intent, 0) + + createNotificationChannel() + } + + override fun onDestroy() { + super.onDestroy() + stopMobileNode() + // TODO: Check if node is destroyed correctly. } - override fun StopTequila() { - stopMobileNode() + private fun createNotificationChannel() { + if (Build.VERSION.SDK_INT < 26) { + return + } + val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager + val channel = NotificationChannel(notificationsChannelId, notificationsChannelId, NotificationManager.IMPORTANCE_DEFAULT) + channel.enableVibration(false) + notificationManager.createNotificationChannel(channel) } - } - override fun onBind(intent: Intent?): IBinder? { - return MysteriumCoreServiceBridge() - } + // startForeground starts service with given notifications in foreground. + fun startForeground(title: String, content: String = "") { + if (Build.VERSION.SDK_INT < 26) { + return + } + val notification = NotificationCompat.Builder(this, notificationsChannelId) + .setSmallIcon(R.drawable.notification_icon) + .setContentTitle(title) + .setPriority(NotificationCompat.PRIORITY_DEFAULT) + .setVibrate(LongArray(0)) + .setContentIntent(pendingAppIntent) + .setOnlyAlertOnce(true) + + if (content != "") { + notification.setContentText(content) + } + + startForeground(1, notification.build()) + } - companion object { - private const val TAG = "Mysterium vpn service" - } + fun stopForeground() { + stopForeground(true) + } + + override fun onRevoke() { + Log.w(TAG, "VPN service revoked!") + } + + inner class MysteriumCoreServiceBridge : Binder(), MysteriumCoreService { + override fun startNode(): MobileNode { + return startMobileNode(filesDir.canonicalPath) + } + + override fun stopNode() { + stopMobileNode() + } + + override fun showNotification(title: String, content: String) { + startForeground(title, content) + } + + override fun hideNotifications() { + stopForeground() + } + } + + override fun onBind(intent: Intent?): IBinder? { + return MysteriumCoreServiceBridge() + } + + companion object { + private const val TAG = "MysteriumVPNService" + } } diff --git a/android/app/src/main/java/network/mysterium/service/core/MysteriumCoreService.kt b/android/app/src/main/java/network/mysterium/service/core/MysteriumCoreService.kt index ccd6ed0db..3580b2b11 100644 --- a/android/app/src/main/java/network/mysterium/service/core/MysteriumCoreService.kt +++ b/android/app/src/main/java/network/mysterium/service/core/MysteriumCoreService.kt @@ -18,9 +18,14 @@ package network.mysterium.service.core import android.os.IBinder +import mysterium.MobileNode interface MysteriumCoreService : IBinder { - fun StartTequila() + fun startNode(): MobileNode - fun StopTequila() + fun stopNode() + + fun showNotification(title: String, content: String = "") + + fun hideNotifications() } diff --git a/android/app/src/main/java/network/mysterium/service/core/NodeRepository.kt b/android/app/src/main/java/network/mysterium/service/core/NodeRepository.kt new file mode 100644 index 000000000..3fc61ba19 --- /dev/null +++ b/android/app/src/main/java/network/mysterium/service/core/NodeRepository.kt @@ -0,0 +1,147 @@ +package network.mysterium.service.core + +import android.util.Log +import com.beust.klaxon.Json +import com.beust.klaxon.Klaxon +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext +import mysterium.ConnectRequest +import mysterium.GetProposalRequest +import mysterium.GetProposalsRequest +import mysterium.SendFeedbackRequest + +class ProposalItem( + @Json(name = "providerId") + val providerID: String, + + @Json(name = "serviceType") + val serviceType: String, + + @Json(name = "countryCode") + val countryCode: String, + + @Json(name = "qualityLevel") + val qualityLevel: Int +) + +class ProposalsResponse( + @Json(name = "proposals") + val proposals: List? +) + +class ProposalResponse( + @Json(name = "proposal") + val proposal: ProposalItem? +) + +class Statistics( + val duration: Long, + val bytesReceived: Long, + val bytesSent: Long +) + +class Location( + val ip: String, + val countryCode: String +) + +class Status( + val state: String, + val providerID: String, + val serviceType: String +) + +class NodeRepository(private val deferredNode: DeferredNode) { + + suspend fun getProposals(refresh: Boolean): List { + val req = GetProposalsRequest() + req.showOpenvpnProposals = true + req.showWireguardProposals = true + req.refresh = refresh + + val bytes = getProposals(req) + val proposalsResponse = parseProposals(bytes) + if (proposalsResponse?.proposals == null) { + return listOf() + } + + return proposalsResponse.proposals + } + + suspend fun getProposal(providerID: String, serviceType: String): ProposalItem? { + val req = GetProposalRequest() + req.providerID = providerID + req.serviceType = serviceType + + val bytes = getProposal(req) + val proposalsResponse = parseProposal(bytes) + return proposalsResponse?.proposal + } + + suspend fun registerConnectionStatusChangeCallback(cb: (status: String) -> Unit) { + deferredNode.await().registerConnectionStatusChangeCallback { status -> cb(status) } + } + + suspend fun registerStatisticsChangeCallback(cb: (stats: Statistics) -> Unit) { + deferredNode.await().registerStatisticsChangeCallback { duration, bytesReceived, bytesSent -> + cb(Statistics(duration, bytesReceived, bytesSent)) + } + } + + suspend fun connect(req: ConnectRequest) = withContext(Dispatchers.IO) { + deferredNode.await().connect(req) + } + + suspend fun disconnect() = withContext(Dispatchers.IO) { + deferredNode.await().disconnect() + } + + suspend fun unlockIdentity(): String = withContext(Dispatchers.IO) { + deferredNode.await().unlockIdentity() + } + + suspend fun getLocation(): Location { + val location = getLocationAsync() + return Location( + ip = location.ip, + countryCode = location.country + ) + } + + suspend fun getStatus(): Status { + val status = getStatusAsync() + return Status( + state = status.state, + providerID = status.providerID, + serviceType = status.serviceType + ) + } + + suspend fun sendFeedback(req: SendFeedbackRequest) = withContext(Dispatchers.IO) { + deferredNode.await().sendFeedback(req) + } + + private suspend fun getProposals(req: GetProposalsRequest) = withContext(Dispatchers.IO) { + deferredNode.await().getProposals(req) + } + + private suspend fun getProposal(req: GetProposalRequest) = withContext(Dispatchers.IO) { + deferredNode.await().getProposal(req) + } + + private suspend fun parseProposals(bytes: ByteArray) = withContext(Dispatchers.Default) { + Klaxon().parse(bytes.inputStream()) + } + + private suspend fun parseProposal(bytes: ByteArray) = withContext(Dispatchers.Default) { + Klaxon().parse(bytes.inputStream()) + } + + private suspend fun getLocationAsync() = withContext(Dispatchers.IO) { + deferredNode.await().location + } + + private suspend fun getStatusAsync() = withContext(Dispatchers.IO) { + deferredNode.await().status + } +} diff --git a/android/app/src/main/java/network/mysterium/service/core/Openvpn3AndroidTunnelSetupBridge.kt b/android/app/src/main/java/network/mysterium/service/core/Openvpn3AndroidTunnelSetupBridge.kt index 08f9035cf..bd468bd08 100644 --- a/android/app/src/main/java/network/mysterium/service/core/Openvpn3AndroidTunnelSetupBridge.kt +++ b/android/app/src/main/java/network/mysterium/service/core/Openvpn3AndroidTunnelSetupBridge.kt @@ -23,131 +23,131 @@ import android.util.Log import mysterium.Openvpn3TunnelSetup class Openvpn3AndroidTunnelSetupBridge(private val vpnService: VpnService) : Openvpn3TunnelSetup { - override fun socketProtect(socket: Long): Boolean { - val succeeded = vpnService.protect(socket.toInt()) - Log.i(TAG, "Protecting socket: ${socket.toInt()} res: $succeeded") - return succeeded - } - - private var builder: VpnService.Builder? = null - - private var tunnelFd: Int? = null - - override fun addAddress( - address: String, - prefixLength: Long, - gateway: String, - ipv6: Boolean, - net30: Boolean - ): Boolean { - - builder?.addAddress(address, prefixLength.toInt()) - return builder != null - } - - override fun addDnsServer(address: String, ipv6: Boolean): Boolean { - builder?.addDnsServer(address) - return builder != null - } - - override fun addProxyBypass(bypassHost: String): Boolean { - return false - } - - override fun addRoute(address: String, prefixLength: Long, metric: Long, ipv6: Boolean): Boolean { - builder?.addRoute(address, prefixLength.toInt()) - return builder != null - } - - override fun addSearchDomain(domain: String): Boolean { - builder?.addSearchDomain(domain) - return builder != null - } - - override fun addWinsServer(address: String): Boolean { - return false - } - - @Throws(Exception::class) - override fun establish(): Long { - tunnelFd = builder?.establish()?.detachFd() - return tunnelFd?.toLong() ?: -1 - } - - override fun establishLite() { - //whatever that means - } - - override fun excludeRoute(address: String, prefixLength: Long, metric: Long, ipv6: Boolean): Boolean { - return false - } - - override fun newBuilder(): Boolean { - builder = vpnService.Builder() - return true - } - - override fun persist(): Boolean { - return false - } - - override fun rerouteGw(ipv4: Boolean, ipv6: Boolean, flags: Long): Boolean { - Log.i(TAG, "Flags for gw reroute: " + flags.toString(16)) - builder?.addRoute("0.0.0.0", 1) - builder?.addRoute("128.0.0.0", 1) - return builder != null - } - - override fun setAdapterDomainSuffix(name: String): Boolean { - return false - } - - override fun setBlockIpv6(ipv6Block: Boolean): Boolean { - return false - } - - override fun setLayer(layer: Long): Boolean { - return layer == 3L - } - - override fun setMtu(mtu: Long): Boolean { - builder?.setMtu(mtu.toInt()) - return builder != null - } - - override fun setProxyAutoConfigUrl(url: String): Boolean { - return false - } - - override fun setProxyHttp(host: String, port: Long): Boolean { - return false - } - - override fun setProxyHttps(host: String, port: Long): Boolean { - return false - } - - override fun setRemoteAddress(ipAddress: String, ipv6: Boolean): Boolean { - //look into internet - return true - } - - override fun setRouteMetricDefault(metric: Long): Boolean { - return false - } - - override fun setSessionName(name: String): Boolean { - builder?.setSession(name) - return builder != null - } - - override fun teardown(disconnect: Boolean) { - tunnelFd?.let { - ParcelFileDescriptor.adoptFd(it).close() - } - } - - companion object { - private const val TAG = "Openvpn3 setup bridge" - } + override fun socketProtect(socket: Long): Boolean { + val succeeded = vpnService.protect(socket.toInt()) + Log.i(TAG, "Protecting socket: ${socket.toInt()} res: $succeeded") + return succeeded + } + + private var builder: VpnService.Builder? = null + + private var tunnelFd: Int? = null + + override fun addAddress( + address: String, + prefixLength: Long, + gateway: String, + ipv6: Boolean, + net30: Boolean + ): Boolean { + + builder?.addAddress(address, prefixLength.toInt()) + return builder != null + } + + override fun addDnsServer(address: String, ipv6: Boolean): Boolean { + builder?.addDnsServer(address) + return builder != null + } + + override fun addProxyBypass(bypassHost: String): Boolean { + return false + } + + override fun addRoute(address: String, prefixLength: Long, metric: Long, ipv6: Boolean): Boolean { + builder?.addRoute(address, prefixLength.toInt()) + return builder != null + } + + override fun addSearchDomain(domain: String): Boolean { + builder?.addSearchDomain(domain) + return builder != null + } + + override fun addWinsServer(address: String): Boolean { + return false + } + + @Throws(Exception::class) + override fun establish(): Long { + tunnelFd = builder?.establish()?.detachFd() + return tunnelFd?.toLong() ?: -1 + } + + override fun establishLite() { + //whatever that means + } + + override fun excludeRoute(address: String, prefixLength: Long, metric: Long, ipv6: Boolean): Boolean { + return false + } + + override fun newBuilder(): Boolean { + builder = vpnService.Builder() + return true + } + + override fun persist(): Boolean { + return false + } + + override fun rerouteGw(ipv4: Boolean, ipv6: Boolean, flags: Long): Boolean { + Log.i(TAG, "Flags for gw reroute: " + flags.toString(16)) + builder?.addRoute("0.0.0.0", 1) + builder?.addRoute("128.0.0.0", 1) + return builder != null + } + + override fun setAdapterDomainSuffix(name: String): Boolean { + return false + } + + override fun setBlockIpv6(ipv6Block: Boolean): Boolean { + return false + } + + override fun setLayer(layer: Long): Boolean { + return layer == 3L + } + + override fun setMtu(mtu: Long): Boolean { + builder?.setMtu(mtu.toInt()) + return builder != null + } + + override fun setProxyAutoConfigUrl(url: String): Boolean { + return false + } + + override fun setProxyHttp(host: String, port: Long): Boolean { + return false + } + + override fun setProxyHttps(host: String, port: Long): Boolean { + return false + } + + override fun setRemoteAddress(ipAddress: String, ipv6: Boolean): Boolean { + //look into internet + return true + } + + override fun setRouteMetricDefault(metric: Long): Boolean { + return false + } + + override fun setSessionName(name: String): Boolean { + builder?.setSession(name) + return builder != null + } + + override fun teardown(disconnect: Boolean) { + tunnelFd?.let { + ParcelFileDescriptor.adoptFd(it).close() + } + } + + companion object { + private const val TAG = "Openvpn3 setup bridge" + } } diff --git a/android/app/src/main/java/network/mysterium/service/core/WireguardAndroidTunnelSetup.kt b/android/app/src/main/java/network/mysterium/service/core/WireguardAndroidTunnelSetup.kt index 9129c798a..62c13ea30 100644 --- a/android/app/src/main/java/network/mysterium/service/core/WireguardAndroidTunnelSetup.kt +++ b/android/app/src/main/java/network/mysterium/service/core/WireguardAndroidTunnelSetup.kt @@ -22,7 +22,6 @@ import android.os.Build import android.util.Log import mysterium.WireguardTunnelSetup - class WireguardAndroidTunnelSetup(val vpnService: VpnService) : WireguardTunnelSetup { var tunBuilder: VpnService.Builder? = null @@ -42,7 +41,7 @@ class WireguardAndroidTunnelSetup(val vpnService: VpnService) : WireguardTunnelS } override fun addTunnelAddress(ip: String, prefixLength: Long) { - tunBuilder?.addAddress(ip , prefixLength.toInt()) + tunBuilder?.addAddress(ip, prefixLength.toInt()) } override fun protect(socket: Long) { diff --git a/android/app/src/main/java/network/mysterium/ui/Countries.kt b/android/app/src/main/java/network/mysterium/ui/Countries.kt new file mode 100644 index 000000000..9c6928d06 --- /dev/null +++ b/android/app/src/main/java/network/mysterium/ui/Countries.kt @@ -0,0 +1,313 @@ +/* + * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package network.mysterium.ui + +import android.util.Base64 +import android.graphics.* +import android.graphics.Bitmap + +class CountryFlag constructor(val name: String, val image: String) {} + +class Countries { + companion object { + fun loadBitmaps() { + for (v in values) { + val base64Image = v.value.image.split(",")[1] + val decodedString = Base64.decode(base64Image, Base64.DEFAULT) + val bitmap = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.size) + + // Issue https://github.com/vinc3m1/RoundedImageView/issues/222 + val width = bitmap.width + val height = bitmap.height + var dstBmp: Bitmap + if (bitmap.width >= bitmap.height) { + dstBmp = Bitmap.createBitmap( + bitmap, + width / 2 - height / 2, + 0, + height, + height + ) + } else { + dstBmp = Bitmap.createBitmap( + bitmap, + 0, + height / 2 - width / 2, + width, + width + ) + } + + bitmaps[v.key] = dstBmp + } + } + + var bitmaps: MutableMap = mutableMapOf() + + val values: Map = mapOf( + "af" to CountryFlag("Afghanistan", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAIAAADRv8uKAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAABJ1JREFUSMfll19oU1ccx3+/c29yc2PaJG2TGFvTuljRdnViWx9sxSmlutmhFl+GCBvCQPBhyAR92VDwcb74IJTucQo+zVFQJs6/9M/AlqrB2cZqbbLYJrRNanL/5J7z20McbA/rbevci+fhcC/nz+d8fz/u73wvgl2TADjAdwBdAFkA6V+mcQZeAX1b4czXIOWBM5tt7cbfWXv/wPJKFiH+45XofwEjlkgIQKW+dA4EgGWcYHlgBCDGoLwcXC5DVaVsFnWdEUGhUCK/AzAiAnCHg2prcds2i3M5FOIjI8Q5hsNyIgFPn8Bcbum67cFUohJZTqfR1OSKRPjYmJzNOhTF8ngQQLjdptdr7d/v+flXtBKASEtg24MREYisSASiUUmWpVhMGhsDr7fg88HsrDI3Jw8NUUODjgTr15tqDqwcINrqlm2pnEiW5bpjx6RoVL13T9y4oUSjxsxMoLNTFAra1auOmhqIxSo/65LqPwznR0D7nqT/QjEAfHrgwMaqqvzEhDQ6KgBcXV08nY5euKBPT8cNQ6mo0Ht65Hh8QVEb123arnzcP3cbmU3AFysgiEhEq9xuYZovBwbcr14V794FAF8k4nW7zQcP+MOHXr+/LBwGALOvr7wokg9uqMIlk2SbZmmRMcYYEe3etautra19z575vj5aWGCqKlpaPLt3o89HLhdFIrnxcXN0lDwe8vqDRw9rEhQNc6o4xZAtgrdRDAB1dXWesjJ/fb2aTEZ7e9Xm5nw2+/vFi4+am2M7dz6/di2fSnn37l179qw78dK7oaGy6Kv3bADxZvlKwEQEAE6nkwsxfOmS/9AhT03N64mJ4szMms2b15486SwWnY8fc84LyWSwo0Pt7Hx6/ToyWZZkQHirHAOAqqodHR2NO3Zwzqd6e9n4eNqysLnZf+6c9/z5hYWF+bKy4uBg6qerksezoWlre8OOomyCAFy0lkmLg4lIEFWvXp1LJNZUV6dOn0aA6u5uPj2dHRhw1tdLDkcVY8bQUGFk2P/F0ZeTo0kwLicvpymNgCvMcSnU8Xj8ta6n+vsTuZxRVaU0NdUcObK6rc1tmvKLF8HW1tDBg3IwaFQF4pOTqftDf1iZZ1rcNtQ2lZ0xJoTo6u4+1d7u0HVfa6s+OGgND4OiQCCAhoHz80Qkbdni2r597tYtHgp9U3llYPYOk5gAscjONgWkJPq3+/fVEyc2hkLPbt7MFIv67dssHAafD2WZJ5OkaeVtbcqL5x99+VX/1OBwbBAksP2O7e8yCZETfVtb+8nhwxkhVgWDDNGIxRzT00KSnOvWOVta8pmM+TrnT2vXYj1nPs8wEwW+Xa1+I5oxnJyEK1cqjx+v2LdvLJWiTZv8FRUzmYzpcpUFAmGAuV+uix8u4AcZcDAwhK2iJdxOACAEMOaIx3OnTulPngQaG+c1LW9ZKgCWl69SVfPOHe3yjz6LyIFAYimWYMlGQAhCFLqe7ulBRFVRSNclRFCUWcMgImRAACCW6n6W4zKJANHBmExEmgaMEQBpmkzkYAyI3qHnAiLiHAAAEf56IADgfLlGeUX2Fv5maVfkbeF9/JP4E60nG6TGip3CAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjQwKzAyOjAwHXwFzwAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo0MCswMjowMGwhvXMAAAAASUVORK5CYII="), + "al" to CountryFlag("Albania", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAgdQTFRF3iEQ3CEQ3SEQ2iAQ2yEQ3yEQ5iIR4iIQ5SIQ5yIR7iMR7yMR6SMR7SMR7CMR4yIQ4CEQuBsNxR0OvRwOtxsNahAIcREIrxoN5SIRnBcLkRYKYw8HhhQK4SEQxh0O1CAPsxsNGgQClhYLoxgMZQ8HCwIBAAAAIgUC0B8PvxwOEAIBZw8HqRkMexIJJwYDZA8HIwUD0x8PkxYLQgoFXA4HTAsFcxEIVg0GYA4HrRoMAQAAjhUK6yMRTgwGHgQCRgoFKQYDeBIJNwgEJgYDFQMCPQkEYQ4HPAkESgsFLQcDKwYDWg0GIAUCaxAIdxIJAwAATAsGLgcDeRIJ1iAPUwwGOgkEOwkEEwMBFgMCDAIBHAQCUAwGwh0O5CIQdBEIHQQCbhAIgxMJPgkESwsFCAEBAgAADQIBNQgE1SAPPwkFUQwGSAsFJQUDFwMCGwQCRwsFUgwGYg8H1yAQRAoFVAwGmxcLDgIBRwoFyh4PWA0GjRUKWw0HMQcE2CAQoBgMMgcETQwGvBwOQwoFRQoFcBEIyR4OJAUDwx0OmRcLfRMJBwEBQQoFBAEAKAYDjxUKpBgMFAMB2SAQtRsNzx8PbRAI6iMRxx4OJQYDLAYDOAgEHwUCIQUCNggE4SIQrhoNgBMJyB4ONAgE0R8PmBcLqBkMphkMrBoM9iUS2yAQTwwGfxMJ6CMR////lzGo6AAAAAFiS0dErFdl8osAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAHtSURBVDjLY2AYWoCRiYmBkZmZkYGBhYWZhYGJiRG7OlY2dg4mTi5uNkYmHl5uPgZ+AU7s6lgEhYTZRUTFxCWYJaWkZWTl5BVYsahjYmVSVFJWUVVTU9fQ1FJTU9XW0dXjZMKikoVP38DQyNjEVE3STM3cwkTB0srahgWbicy2dvYOamqOTs4urm5qau4enioS2ExkYHXz8vZRU/PVV1PzM1XzdwgIDMKmjEkgOCQ0LFxNLSJSTS0KSPtEe5vGxGI1Ms4jOl7NSg0MrKwczBISsatj8k5KdkpRSwUqtUpVSwuzTxfDppBJICM6Mys7JxdkppVaXk5+gVOhAFY3FkkXJ5eU2pcBrVVLszXKL/eIw6qQv8LVo9JIpjATaJ6/hWhVUHVNMRO2qGGtrROt125ojFJLTVVrYmjW1mspxRqF/K1teu0dnYpd3Wo92Va9ff3KE9wnCmD1DU/HpMldVpXOamrFU9T0piqL22BNPUzs07rVpms3zQAF0ExplVlqlcGsWMORZarK7DlzjRwmqKkp9s6rUJ89n48Fh5GCspMnL/BdqOgSNn9RzIKJ0/ixGghUycEky8C3eEmu89JlfALsrOw41AFVAuHE5f1qXdN4mYFZBqc6CFjBv3LVamYGwoBJgD+WCGUglYTspBIAAL5eaGbLfsJqAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjQ3KzAyOjAw2Ns7QQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo0NyswMjowMKmGg/0AAAAASUVORK5CYII="), + "dz" to CountryFlag("Algeria", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAgFQTFRFAL8TAL8RH8cv4Pfi////AMATAMARH8gv4PjiAMETDLYUIKcWR6Uv5NDD/+jr//r7AcATKaMYe2oiuz8p2Sot5CQw8Sk+9DlN9mJy+qy0/vDxC7gUbXQg1ywt9Rcw9Bcw9hYw8xox8yU78yk+8yg+9VZn/MbM//7+DbcUjF8k7xsw9Bgw8hkw5yAutFM266im/dHW/dre/MzR+p6o929++73EAr4TeG0h8Row8xgw0i8sT4cbJsIw/vDy+7i//eLkOZga4CUuP5QbAMER/vX2/u/xA70TllglbXUgH8Uu4PDc+7zD92t6//j5HqoX0y4syzQrG64WH8Is25qO+5ai/dba/dzf9EVX9lpqAMITQJMb6h4vmFclAb8TH8kx3s++9j1R8ytA9DxP8hYt9lhp/vP0AMISVYQdeWwh4Pnk/bO88yM58hgv9Vdo+ZSe/NHWVYUd4Prl/sfO8yo/8hcu8hsx8y5D9l9v+q62/vb3AL4RH8gx393L90xg8hsy8yU68hUt9VBh/dve//r6HqsX0y8szDMrH8Ms25GH+XCA+7O78y1C9mFx//z84OTS//z++Zeh9mZ1Opga+7C4/uvt+7rB/ePm/dHX+Z6n93OB/MLI8yk/9llq/MrQKqMYfGoivD4p8So+9DpO9mR0+q63/vHyDbYVIacW5NDE/+js//v71zhLzwAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFFSURBVDjLY2DAAIxMzCyYgGEwKWRlY+cgQiEnKxc3Dy8fPwGFrAKCQsIiomLiEpJS+BSySsvIysnJKygqKauoqqnjVMiqoamlraOtq6dvYGhkbGKKU6GZuYWljryVtQ3YM7Z29jgUcjo4As0TcXIGBw+/kYurOnaFbu4KOjoWHpyMnl5ACW8fXxxWs/r5a+vIBwSyMgYFh4SGhUfw41AYGRWto6MQE8vAGBefkJiUnJKKQ2FauoWOjlwGJzAKM7Oyk3Oyc/Py+bEqLIArLCwqLtEpLSuvqMRrdVV1TW1dfUNjUzMOz7S0Aj3TBvRMe0dnl113Ty+uAIcHT3tfPwvLhIk4FXJOQg5w28mVuAIcLQqnTJ1GOFFMNzSaMXMWUcls9py5+BPuvPkLREQXLlq8ZCmhrCCwbDnPipWrqJe5SMiudFMIADEdVRLXGs/+AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjAwKzAyOjAwdvRgCwAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNTowMCswMjowMAep2LcAAAAASUVORK5CYII="), + "as" to CountryFlag("American Samoa", "data:image/png;base64,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"), + "ad" to CountryFlag("Andorra", "data:image/png;base64,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"), + "ao" to CountryFlag("Angola", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAbZQTFRF/wAA/wEA/wIA/wMA/wwA/x0A/wQA/20A/7sA/+gA/ycA/0MA/60A//IA/6UA/4EA/zMA/woA/x8A/yMA/8AA//8A/18A/xwA/2oA/6YA/zcA/wgA/7YA/6IA/zgA/AAA/AEA/QAA/BkA/MsA/P8A/GsA/B4A/fIA/98A/QwA/2kA/zoA/wYA/6kA/nkA/gAAwwAAwQAAxggAxAoAxQkAwwwAxAQAvwAA3HMA/9QA3C0AxAIAAAAAAwIAjIkAOzsAAgcAAAEABAQAc2kAXmAAAgAAy8gA39UALyoAAgEABAIABgQAsaQAiH0ABQMAZl4A3c8AcGcADQwAEg8A8OkA1csACQcAAQEAAgIAQTwAzsEA//EAuKwAPDgAmZEA49UAhnsAGBYAEhEAYVsA280A4dIAgHcA2soAWVIABQQAAwMAdm0A388AZV4AKicACgkAWlMA0MIA798AzL4AYFkAAQAA0s8A/vgA5NIA8uAA7tsA7+MA+e8AVk8Ar6MA8OAAf3cAGRcAUkwASUMAGxkA9eMAbGQAcWgADAwAU00AsKQAaWIABQUAOjYAwrUASUQAFBIA////QnDRNwAAAAFiS0dEkQ8NvpoAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFDSURBVDjLY2AYxoCRiTh1TMzEmsjCysTGSNg8BnYOTi4GwrYzM3Dz8PLxCzAQNFNQiEFYRFSMgQ2/hxnEJSSlpBlkZOWwGSkPBwqKSsoqqvLyauoamvIK8mgAxUhmLX5tBh0GXT19LKFkAAeGRsYmBqYGZuYWllbm1gZogMEGBmxt7OxtHBxtnGycRV2AJBpgcIUBWxs3dw8bTy9vGx9fGz9XdIAw0cnGXzQgMMjGJjgkNMwmHMNEBDPCJjIqOibWJi4+AUMZQmG4TWISUG1ySmpaeoZNJm6FWTbZObl5+TYFhUXFJTYRWTitLrWxKSuvqKyqrqmtq29oxOPGcJum5pbWtsb2DpvOuq7ufHSlDMic8J4IoDuzbGx6+/qBjsGlMAvosPAIp3CbrAibCVk4rYbaDwspG/wKMXQQVEi0iRQoBADlxK8dqvctggAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo1MCswMjowMNHWBVEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NTArMDI6MDCgi73tAAAAAElFTkSuQmCC"), + "ai" to CountryFlag("Anguilla", "data:image/png;base64,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"), + "aq" to CountryFlag("Antarctica", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAVBQTFRFOn3OPH7OO37OO33ONHnMM3nMN3vNPH7POXzOM3jMXJPWWZHWRYTRMHfMNnrNOX3OOHzOutHu+fv9+/z+8/f8z9/zTorTPH/PMnjMs83s/////P3++vz++vv+hq/hUo3UMXfMP4DPNXrNR4bR7PP6/f7//v7//f7+/f3+xNjwX5XXNHnNMHbLap3aj7XjKHHKP4HPQIHPZprZ+/3+mr3mK3PKPX/POHvNQoLQ6/L6xdnxUIvTJ3HJrMjqwtfwW5PW9/r9krfkirLiytzy6fH6RIPQy93y/v//3Oj2L3bLydzy+Pr9p8XpSYfSPoDP1uT1gKvfLXXLYpjYcqLceqfe9Pf8ocHoLXTLL3XLa57afqrfLnXL0eH07/X7nb7njrTjtM3skLbjt9Dt4+z44uz4LHTL9fj8bp/bPn/PMnfMr8rrpMPoKnLK1eP1e6jeMHbMsWd+rAAAAAFiS0dEGnVn5DIAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFxSURBVDjLzZPZW4JAFMUZUBwsREuDLlqkgZq2mEll+2JppVmWtu/7+v+/BVp9Kig+9XWef3POuXdmCOI/CSGyE4wibXaacFiyJGacXd2YdSHU3o9ze3p6vT5nH8Pw5iiuhiGhH0QA8AcGBiXGLB8PBSnEUXRoGGRQwgpExOhIzEii+OjYeGwiIU2CAroUJQlTKdXYbXpmNj2nsvML1WRdIixKJi2RsLQMK6trAfiRAusZbLIWOrQBm/AdrEuGbM5lMg6Jg1vgF3857dT2Tp42khRX2NVc6iVCcU81KbkPTQpDKc4bQJ49ONRLNjiWK7oj5hpIx9FxWGlyPDnVQFxQG0kknWnTaJJrfATStUU2XzqyFc/r1qMlX+Sqs3DNNUk2c3lVvr65vdP5CPiEVq/SQVfuKymBLUFSTsLDo73lmyRVVX0qPL9odjK8vqlEO1E44cl636MfQcvv4P6k80QuTllx2vyEi+B5a04v2xH1R/oCqT03XvcrJGcAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NDMrMDI6MDAslB9SAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjQzKzAyOjAwXcmn7gAAAABJRU5ErkJggg=="), + "ag" to CountryFlag("Antigua and Barbuda", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAr5QTFRFBgYGBQYGBQUGAAAABgUADQsAAQAABwYAKCEAAgIALCUAWkwAJyEAFBEANgAABAMAg24ANi0AY1QAqY8AAwIAHRgAmIAAGRUALwAAuAAAJgAACggAGhYAAQEAg28AuZwAFREAnoUA3boAIx0Aup0ACAcAIQAAsgAA5QAAmgAADgAAemcAalkAW00A+9QAmoIA1bMA9s8ApYoA99EAmYAACgkAXE0AHhkACwAAkwAA4gAA4QAAbwAAAgAAMysA37sAspYAdmMA9M0A/NUA/dQA/9YA/dYA/9gAqo8Aq5AA8swAZlYAZwAA3wAA4wAA1AAARQAAGBQAemYA/tcA9c4A/NQA/9oADgsAFhMAEg8APgAA0AAA5AAAuwAAIwAAYlMAnoQAkHkA78gA/9cA/dUAsJQAupwAmYEAHgAAtgAAlwAADQAA+dMAn4UAHxoACgAAkAAA4AAAbQAACwgAXEwA6MMAm4EAGRQAZQAA3gAA0wAAQwYRABEtAxMsJjAsXl8sk4wsuawsz74s08Is0sEsvrAsmpIsZ2csLzgsBhYsABEuPAcTzwAAug4kIUzHAFvuAlvrD2brGG3rFmvrFGrrFWvrF23rEmjrBFzrAFruHU7MtBAqlSJZDF3yAGL/AGH/AGD/CV71jSVh4AIEajSIAWH+YjeQ3gIG0ggUQUa2Oki+zgkYuBMxIFTbG1bgshU4kiJaC1zzAF//AF7/CF32iyZj3QEFikuKbKT+bqX/bKX/hlGT3AIH5xYV+Lq5////+cHA5xoa6DMz+93d/OLi6Do67V1d/vT0/vb27mZm4gUF8o2N//7+85aW4wgI5BcX97u7+MPD5Rsb6DU1+9/f/OTk6Tw87WBg/vX1/vf37mlp4wYG8pCQ85mZ4wkJ5RgY+L6++MXF5R0d6Dc3/OHh/Obm6T4+7mxs73R04gEBlK46QQAAAAFiS0dEv9Pbs1UAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAHtSURBVDjLY2DABIxMWAQZmDEBCyuQYEMTRFfIzsHJzMXNzMzDi66QD5XPLyDILCQsIiomjiouwSApheBJy8gyy8krKCopi6moMosjqVVTZ9DQ1ELYq60jraunb2BoZGxiaqZoDpewsNRgsLK2sYUL2Nk7ODo5u7i6uXt4ennDhdl8fP0YrPz8A6DmBZoyBwWHhLqCQGiYQzhLRCREJio6xorBykojNg7MVY13SEhMSnaFgJRUsbR0HrBERqaGFUihlUZWNiT8dJXcXeHAPSc3DyycXxBjBVFoVVgEdiZbcUmpezIMuJWVQxxYUekHU+hXVV1TU1tX39DY1AwHLa1t7R2dNV3dPSADIQqtNHr7+idMnDRp8hQkMHXapOkzZs6arWGFUGilMWfuvPkLMMD8eQsXxVghK7RavGTpfGxg2XI/VIV+K1bOw1Q2b9VqqIFwhVYaa9ZiqJy3br2GFbpCq5gNGzdtRgGbtmyNscJUaLVt+46dKGDX7j1+2BRa7d23HwUcOIgkiazQ6tBhZHVHjlrhUmh17DhC3YmTVrgVnjp9Bq7w7Dk8Cq3OX4Cpu3jJCp9Cq8tXIOquXrPCr9Dq+g2Qupu3rAgpvH0HpPDuPYIKre4/2L//4SMrwgqtHj95+syKGIVWz1+8xBQEANFbahfUdCzxAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjI4KzAyOjAw6PxCLwAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDoyOCswMjowMJmh+pMAAAAASUVORK5CYII="), + "ar" to CountryFlag("Argentina", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAexQTFRFAMT/AMT+BcP4FsPlFcPnFcPmFsPmBcP5Icz/JMz7OsjUXsiqa8icacidasicbcmbOsjVI8z84vj/4vj83+zH6Oag6eF959505NdW5dhW6N906Oim3+3L///////++/PM+uuh995c9txV9tc38tQ19NU19tg59t1X+N9g+uqd/PTP/frs+OmZ9+R+9dpG89Ux8dZF8tY/89Y/8tdG89Uw9+SA+Oqd/fvv+/TR9+aM9+Fo9dc08NZN8s8c88sA88sB89Ae8NVJ9NY09+Fp9uaN+vTU+vPP9+WJ9NpN8tU47tE76cIA6cMA79I98dQ589pU9uaQ9+WI9NlH8dU+79E1/NMA+NAA+dEA/dQA8NM68tU99NhD9uSE+vPO9+eS9+Fr9NUv7tNF+NIN8skA9csA+dMP79ZO9dYw9+Bn9+eP/frr+OiT9+N29dlD8NRB9NQr9dUv8dZJ8tU39dpH9+N3+OiR/Pnp//79+/HA+uqa99xR9tpK8dQ88dQ79dUw9tlE99xQ+uqb+/C+//783Pf/2/X41+e25OWa5uB85dxo49VL5NVL5dxn5+B65OSV1+e42/X5G8r/G8r+Hcn4RsjHasibc8iRc8eMcseNc8iQbsmXSsnDAcT+DcPvJMPVJcPVJMPWJ8PSEMPtAcT96IDw8AAAAAFiS0dEHesDcZEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADxSURBVDjLY2AYBTQBjEzMLKxs7IwYEhyogJOLm4eXj59bQBBNgkEIBQiLiIqJS0hKiUnLCKPKMMgiAzl5BUUlZRVVNXUNTS0UGVlUhdo6unr6BoZGxiZ6pmbmeBRaWFpZ29ja2Ts4Ojm7uOJR6Obu4enl7ePj4+vnH4BXYWBQcEhoWHhEZFR0TCwehbFx8QmJSckpqWnpGZn4FGZl5+R65uUXFBYVl5SW4VFYXlFZVV1QU1tX39DY1IyqsAUFtLa1d3R2dff09vVPQJVhmIgCJk2eMnXa9BkzZ82ejCoxESPu58ydN3/BwkWLBzpxDlcAAHiob+kULOLoAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjIwKzAyOjAwNNFndgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNToyMCswMjowMEWM38oAAAAASUVORK5CYII="), + "am" to CountryFlag("Armenia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABtQTFRF/wAA4AAfHwDgAAD/HxTg4JEf/6YA/6UA////f9mp/QAAAAFiS0dECIbelXoAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAApSURBVCjPY2AYykAQC2BQwgIYjLGAwSjoggUwhGIBDGlYAEM5FjAIBQFxsYIpc0RtnwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNTowNyswMjowMLNTXoUAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MDcrMDI6MDDCDuY5AAAAAElFTkSuQmCC"), + "aw" to CountryFlag("Aruba", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAASxQTFRFM5nMOZzON5vNMZjMaavPVqTOM5zPmoWbe5CuMJrOMpnMP5/PuFFbnm2ANJ3QMJnMV5vEyigruUdQQp/OMJrNMpzQOaDSg4unzw0NyiMmapu/N5/RMZzPMJnNOJzNTJ3KaZK2jXuUrllmyCotzQAAzQUFxDY7qWBvhoCbZJW6SJ/MNpvNUajUlqG5v11l0CUm0gYGzgAAzAAAzwAA0gsLzTAzt215h6rHQ6LROJvNR53LZJa8h4OduU9YzQICzQwNrWJwfommW5rCQZ3MNZrNL53RcZO1zxMTxi8zVaDKL5vPMZnNMZnMUJ3JxjM3slNfPZ/QO57QsWBtk3iPMprOjZewcJq8VqnTSaPQMpjMNJnMMZjOTKWz6vUVuNtHNZrKudxG6vQVS6W0////79jqOwAAAAFiS0dEY1y+LaoAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAC5SURBVDjLxdDVbgJRFIXhXQaH4t4O7lpcirtLKa7l/R+CPsHMIiHhu/6zss8hetSbAOsYoYiBQrFEKkM6uUL5rkJCtUar08t55wxGk9litX18spyt3eF0uT1enz8QDIUjHHvRWDzxlUyl0plsLl/g2iyWvsuVaq3eaLbaPEeynW6vPxiOeJ9D48l0NufP/i1+lkako9/VmoVCZrPdQSHtseyZDiA6gugEojOILiC6gugPRDcQ/o+vcwdMtZUvzqE+HgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNTowNiswMjowMBUkVTEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MDYrMDI6MDBkee2NAAAAAElFTkSuQmCC"), + "au" to CountryFlag("Australia", "data:image/png;base64,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"), + "at" to CountryFlag("Austria", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABtQTFRF3wEB3wAA3gAA4RAQ/ezs//////7+/e7u4RERPLHzTAAAAAFiS0dEBfhv6ccAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAA5SURBVCjPY2DABgSxAPoJYgVKWACDMRbA4IIFMIRiAQxpWAB2lRQKEm9RORbA0IEFYA+QQRib2AQBXQZrlUZGX0YAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MTYrMDI6MDDZjlWvAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjE2KzAyOjAwqNPtEwAAAABJRU5ErkJggg=="), + "az" to CountryFlag("Azerbaijan", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAitQTFRFAJnMAJjMAJjLB5zNFKHQGKLRDp/PApnMAZjMJajTd8jktuLx1O/42fP7yez3m9ntTLreC5/QAJrNAJnNB5vNZcLg3PH4/v////7++uTk77a16JiX6ZaV4qqsnrjKJabSGY26GIy5GY+8fcnj9vv9/////PT056Cg005OzDQ0yzAwzTMz1UhHrHmEMZC4F426sz9Fsz1DxoOJ9vj5/fX14YeHzDExzDMzzDIyvUBEtkhPtkpQzjIyzTEx0kJC9dLS6aenzTU1zTc30D09zC0t3nRz4Hx80D08zzc23HJy/vr6+uvr1VZWyzExzjk55pub4oyM78DA8cjI4YiIzj09556e8MXFzTg4yy4u3np6/fn5/v39/vv74YaG7LS06qyszjs73Xl58MTE/vz8//398snJ335+zz097LOz662tzjo6225u7bi4776+zjw8339//ff34oqK/fj4++7u1ltb5JWV3n198MHB3nl55pmZzz4+zjIzzTEy0T9A88vM67CwzTY2zzk53G5v3nZ3zzg5zjY2sz8zsz0xw3tv9PXx5JKSvEI5sz8ytUY6tUc7GY0zGIwzGI40b8KJ8Pnz666u1VhYzjY31lBRo4JnK5I/GI0yAJozAJkyBJo1Vbt3z+zZ/f79/e3u88TF7aep7KWm3ravkLuRHaVKAJkzAJgxGqNIZMGDpdu3xenSy+3YuebKiNKjPLRmBpw4AJgyAJgwA5o1DJ49D58/B5w5hA1wTgAAAAFiS0dEJcMByQ8AAAAJcEhZcwAAAEgAAABIAEbJaz4AAAF/SURBVDjLY2AY3oCRkShVTMwsrGzsTITUcXBycfPw8vELCGIYK4QEhEVExcQlJKWkZWTl5IVQAYMCAigqKauoqqlraGppaevo6ukrKiJJMhgggKGRsaqJqaaZORBYaFsaWFkjSTLYwIGtnb2qqoOjhTkYODm7uLq5uHvAZBnM4UDL00vV28cXyvPzDwgMClYPgeozR1LoG6qqGhYO5VhEREZFR8fERmBRaB6nqhoPFbdISExKVlVNSU1Lt8BUmKGqmgkzICs7J0ZVNTrXMw9Toa+/qmpQFowXkV/gFRNViM1qrewi1eISLZiRpWU55RWVVXCF1XBQU1unqlofDpVpaHRpanZpaYXJMrQhQHtHp2pRlxPYTDPH7p7ePiRJhn4EmDBx0mTVoilTw818p02fMXPWhAlIkgyzkcCcufPmL1BduGjxkqXLls+ZjQIYVqCAlatWr1m7bv2GjZs2o0qsQFO4YvOWrdu271i5ZcUKAgqBYM6cFVgAwwoiwVBQCAA1lnoBhKT9DQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNToyMiswMjowMKNOdl8AAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MjIrMDI6MDDSE87jAAAAAElFTkSuQmCC"), + "bs" to CountryFlag("Bahamas", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAYlQTFRFAyorCJCVCs3VCtHZCs7WAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0hKARESBF5iB7S7CNDZCM/XCM7WAAAAAAEBASMkBX+ECMXMCNHZAAUFAj5BBp6kCM3VCNDYARERBGBjB7a9ASUnBYKHCMbOAAYGA0JFBqGnARMUBGRoB7nAAikqBYeMCMjPB87XAAgIA0dKCaapHNHGHtLFHNDFBhYSWnMkv9Ak2egk1uUk1eQkAwIAOzMAsZ8A+eQA/+wA/+kACwoAX1cA0sAA/usA/+oAHxwAi38A69cAAgIAQTsA1sMA/+sAHhsAiHwA7dgACgkAW1MA0L4AAQEAMi4AqJkA9uIAFhMAe28A5dAAAAQFM0IUqq8W5eYW6OgW5uYWAR8gBXp+H8a3LtW4K9K4AAsMA1RXB7C2B8/YBs7YAAICAjEyBpGXCMvTARYXBGxwB73FAAcHA0ZJBqasASYnBYSKCMfPAQ8QAAQEAjk8BpqgAR0eBXd8CMLKBqeu////BjZAKQAAABF0Uk5T5O3t7e309fb3+Pn6+/z9/v4TFSGkAAAAAWJLR0SCi7P/RAAAAAlwSFlzAAAASAAAAEgARslrPgAAASBJREFUOMuN1GVTw0AQgOHFi0ObZAMECZS2uLsUioVixd3d3f2fE2DKNOw1d+/nZ+buZm4XICY2Ll4gSMh2uiRZ4QaJqObk5mkiEDG/oLBI58Ek/K64xK3JIhDVUo9XE4GIvrJyxeZ8cOBfFZVV0c+PhKhW19RKdewsELG+obGpuYUVJKO11rb2js4uGoHY7e/pDfSRIAVJ/QODQ4YIRBwOjhhCEEfHxif+wVQmDE1OGQJwemaWXBLSCJubX1ikz6ZwaXklQN5M4era+sbmFiNIt7jtnd29fWYWeHB4pB+fsIuAp2fnF9E/JGSE3eXVtd0XD8Ob2zvZdmh+oXr/8ChxpjDTdE9O3gz+wOeXV+5UmxDf3j/4e8KEWZ+6wOZRlC+yuq3di27g4AAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo1MCswMjowMNHWBVEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NTArMDI6MDCgi73tAAAAAElFTkSuQmCC"), + "bh" to CountryFlag("Bahrain", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAP9QTFRF//////7+/Obo85Wc6D5M4QUR3gAA4AAH4QAS4QAR/Onr9KOp5zZD4QAN4QES/fHy97i97nF75SMy4QAP+c3Q6klX4QQP3gAB4AAK/fDx97u/73V+5i484QMS4AAM+tLV6UdT/e7v7nJ75zJA4gsc4QAQ//39+MfL5zVD3gAC3QEA3wAB97m97m125iw64ggZ+tTX6UhU/e/w73iB4gYV4QAO+c3R4QMO4AAL9rK37Wlz5R8u/vP09a6z6DpH+9zf8H2G4QUT4AAJ+93f5zA+4QMQ3wAA9ait5zdE97e87nF65SMx//7/9rO49auw6DlG//z9/Onq85qh6URR4QcV6RryvgAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADHSURBVDjL7ZTFEsJgDITzI8Xdi5biRYt7cXfe/1koXDhBcuDInr/ZzczuBEAVY6DR6vScwWj6KHjLbLHa7ATQ4XS5PRjIwOvzc4EgITrEhyPRmAkHn67xRAy/kQl8UkylMccMZHP5gkSKFoqlcoV4Y7VGuFHm62KjiToyaPnanNQhVSh0e320mZfpYDhCu2YwVsSJNEWjGcyU+WKJgy9WXq1JMwtttjvizKT/zD6Bv5/ZHuQDbWYqeTx965qpypzhcr3dvz6pB+eQNNljOxxrAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjUzKzAyOjAw4D4fzAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo1MyswMjowMJFjp3AAAAAASUVORK5CYII="), + "bd" to CountryFlag("Bangladesh", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAKtQTFRFClwSC1sSDVsSDlsSDFsSBF4SAGESAGISBF8SIVMSUkERbTYRUUERL04Sqx8Q8wQP/wAPqR8QLk8SZzkR+AIP/QAP+QEP+AEP9wIPZDoR+wEP+wAP/AAPAV8SMU0S9wMP+gEP9QMPAl8SqSAQpSIQI1MS8AUP/gAP7gYPIFQSBV4SC1wSTkIRbjYRajgRMU4S9gMP9QQPZjkRYzoRqh8Q8gQPLU8SIFMS////SO84FQAAAAFiS0dEOKAHpdYAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADSSURBVDjL1ZPJEoIwEEQhLAMoMqIQhai47/v2/39mtCzNIcRUedE+v5qu6ekxjH+TSSyLmB8xmzgugOsQW80RD/ygUqn64BElB2EtQq6oHgNRcY0mJimlaYKtdjnJOcxozrhymmEpaXe6PVawp4qkHw/kGxF3iJS9RHHkSkeazngyzd9gjrP5YikdGGDKBBW4ko60YC063703YH0DaltrL6MdDw98uxMD35cFzk94EE94VB378C7FUV2f8PSo2Xl4AXUhn8W9fiiu/isY2s/1q7oBVsgdRZ6IiLwAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MjErMDI6MDCSpmzCAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjIxKzAyOjAw4/vUfgAAAABJRU5ErkJggg=="), + "bb" to CountryFlag("Barbados", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAATtQTFRFpYo3poo3pYo4poo4mH8sExAtZ1Y4aFY4noQ3n4U3qY03p4s3AACdAQGc/9gA/9QA/9UAAACeAQGf78cAAACLAQBs/9cA/9YAwKEAAACRAAArHhkBd2MA3rkA+c8A17MATD8AAACfAABwAAAIAAAAMCgAv58A068AXk4AAgKZCQgAqYwAwqEADgsAqIwABASdFREABgUAtpgA/9oA1bIAFBEAAgGcV0kAdmIA1bEAWEkArJAAAgEAPDIA9cwA1rIArZAA6MIAJiAAFBAA2LMAXk8ArpEA2bUA/9sAlX0Ah3AA2bQABQQAZ1cA1rUABQUA2LQAFRIAMSkAfGcADAoAFhIA/9kA5b8AJR8A7sYATUAAIBsAAgIA/dMA7MUA68MAvZ0ADwwA0a8AEQ4AEg8AHBcA9MsAwKAA////G06DPgAAAAx0Uk5T/v7+/v7+/v7+/v7+1swwKwAAAAFiS0dEaMts9CIAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFESURBVDjLzdRHW8JAEAZgULBQ4oaSpdclAQSpi6BAJHQQREB6r///HwgefDgkgSPfdd/LzM6MRHUStYR4+g8hVZ++Sa4LAnAGkpqbIwRa7VEStxqSH5I6vYyCB2EwHDykZHodyQ+NJrPFCm12h8Nug1aL2WTkhyqny408NONFyMvQHuR2OYWK8cmR/xkGgsEAfPEjuU+w6tBdOBKNxTGOx6KR8H1IECYeXlGSSGGcIpLo7TEh3EfFezqTZTFms5n0h0Kk4cocl2cLGBfYPJdTikApVUSlMsblEipSol9YqaJaHeN6DVUr4pD+bDQxbja+aHEYa323O91up/3TionCXn+A/jLo98ThcMSNJ5MxNxqKQ2I6my+Wy8V8Nj03uIBYrdcrApyfcMhsNgy8YBUgu92yl0Cw2+934JLlAhQFrv4A8MJfphFdqP62DCgAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NDQrMDI6MDDpMyHcAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjQ0KzAyOjAwmG6ZYAAAAABJRU5ErkJggg=="), + "by" to CountryFlag("Belarus", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAXdQTFRFoR0DoBoATJUDS5IA8tXV2YKC7MHB9+Tk35WV5amp3IqKsgEBsgAA5aur3Y+P7sjI2YOD2oaG2YCAswIC1XJy8dHR4Zyczlxc7sbG6LKyxkJC2oWF67293pKS6LGx46Ghzl1d7L+/0mtr4JiY1XV13pOT24iI3IuL3I2Nz19fyU1NzVtbx0VF2Hx80mpqwzg45aio4Jqa5q6u021t6LOzvCAg0mxs8M3NwDAwy1JS2oSExDs7xDw8wzc3xkFBx0REvicnswMDwTMzvyws13p6ux4eyUtL8MzM0GRk67u75q2t1XR035aW+evr1G9v7cLC+OjozltbsQAA2H5+5KWlylBQ6rq60Who6ri46bW14p6e2oOD4JaWswEBswAAyU5OwlVLwCUnnnI8zU9SsMCEQqAAQaAA4ZKVqahtQp8A1GdqmXM4Q6EC3oqNpZpfQ6AB3oeKr7uAQp4A5Z+hpJhd6q+ynH1C7sfH3IOG56apssWKQqAB////fb2DowAAAAR0Uk5T/v7+/rpKSvwAAAABYktHRHzRtiBfAAAACXBIWXMAAABIAAAASABGyWs+AAABAUlEQVQ4y2NgYWVj5+Dk4uYhABh4Wfn4BQSFhAkqFBEVE5eQlCKsUFpGVkhOXoGwQkUlZVEVLiFC6ngYuFTV1Pk0NAl7RktNW0dXT5+w1QaChkZcHMaErTYxNTO3sLQirNDaxtbO3sHGkbAbnUScXVzdCCt09/AU8vL2IexrE19DP/+AwCCCCoNDZNm45EMJB09YeERklEs0YV8TrZBoq4n2DCR4YmLjCACGeHCAJzAwEgCQKExMYmImACCJIjklNY0AgCSz9IxMQgCScLOycwgqBGeF3Lx8ggrBmaugsIigQnB2LS4hbDW4ACgtI6wQWKSUC1QUElYILqQqq6oJKQQA5hHNdDF/qqcAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MDUrMDI6MDAkzE+sAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjA1KzAyOjAwVZH3EAAAAABJRU5ErkJggg=="), + "be" to CountryFlag("Belgium", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAB5QTFRFpY0I+5QZAAAAAQEA/90M/9kM/9wL8xkw8xgw////QjDoUwAAAAJ0Uk5T/v6mqd4QAAAAAWJLR0QJ8dml7AAAAAlwSFlzAAAASAAAAEgARslrPgAAABxJREFUKM9jUAIDA9dQIAgT7wADhlHBUUFaCgIA0Ka53YIT3pMAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MjYrMDI6MDC4wzlyAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjI2KzAyOjAwyZ6BzgAAAABJRU5ErkJggg=="), + "bz" to CountryFlag("Belize", "data:image/png;base64,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"), + "bj" to CountryFlag("Benin", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAFRQTFRFMZQAL5MAUZ4A7dAA/9YAUZ8A7dEA/9gA/9cAL5QAUZsA6bwC/MAC+8ACL5UATYUC0j8N4zYO4jcOTIIDzioP3x8Q3iAQTIICzysP3yAQ3iEQ////MA4+ywAAAAFiS0dEGwJg1KQAAAAJcEhZcwAAAEgAAABIAEbJaz4AAABDSURBVDjLY2BAAYxMzCzYAcOowhGrkJWNnQMrQFPIycXNw4sVoCnk4xcQFMIK0BUKi4iKYQXoCsUlJKWwglGFI0chAFSNLGheco2sAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjEwKzAyOjAwul5glQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNToxMCswMjowMMsD2CkAAAAASUVORK5CYII="), + "bm" to CountryFlag("Bermuda", "data:image/png;base64,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"), + "bt" to CountryFlag("Bhutan", "data:image/png;base64,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"), + "bo" to CountryFlag("Bolivia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABtQTFRF/7YAP7MA/wAA/wUA//8A9vsAAJkAAJoA////tCvPzgAAAAJ0Uk5T/v6mqd4QAAAAAWJLR0QIht6VegAAAAlwSFlzAAAASAAAAEgARslrPgAAACtJREFUKM9jUMICGIaKoDEWwIAVuGABg1EwFAtgEMQCGNKwAIZyLGAQCgIAwqugtTXBw2MAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NTArMDI6MDDR1gVRAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjUwKzAyOjAwoIu97QAAAABJRU5ErkJggg=="), + "ba" to CountryFlag("Bosnia and Herzegovina", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAsFQTFRFTTpX5LcX/99R/MMA/8sC/8wAMTO3lpG8//fH/uRU/NEg/soA/80C/8wBLSyp1dTs////yL22+tQG/9IA/soD/8wCAwOXlpXSrKzcY2O+TThU8cAA/9kv/cwR/8kADg6fFxegAACSHR2kBAevYleH7+K2/+Rg/NEi/ssDAACYAQGYBASbAACWEA+clpjb8O70+N9J/9AA/coEAACZAQGZBQWbAACRV1e33NzvsrLhZ1BW8sQC/9UK/s8c/8oAMzOuCAiYKCinDxGyOi953L5a/+yN+8oF/s0OAgKZAgKXAACTVljF4OH4///8+/Gf/tMR/ckAAgKaAwOWysnm8/X/oo9+6LsA/9kA/swP/80EAACXHR2lQUGzIB+jOTu+Jh6BzqIP/+qC/M4e/80BAACVAQGXGh2xsa/V//7w/PXG/d9P/cgAb2/D39bK6b8J/9oA/ssF/8wG/80DXFy9QUGwX2DFODCGxZgK/9cy/ttV/sUAAQGaBQWYAACUBQSUAACkcm60/fC+/PXT/OJ0/c4UAwOaJyer6On59dpT/9QAJCOkhIPKd3jLeW6SwJUU/80A/tpR/8oHCwueBgaXAgKTAgOlNDKl7dNu//bO/OB0/dQz/8sAAQGVCguho6Xj+/TC/9gU/8wDAwObfXzEo6Tht62yzqIQ/c8h/9Ii/8gAHh6lAACPERKpFhSiyqs+/++D++WP/tIj/84LAgKWAACaZ2nO/v7+/uZ1/coCJiWiy8vr0tLo8Mor/s8A/9EgJyepGhmfEhOiKSipp4g6/90V++ql/9AU/88ONTW25+Lb+/HG/NMxBgaalpXT9fj/+ueE/9EA/swD/80M/80JBwecT0+2EhKhVFOzoYJA/88A/d5o/9lHAQGWDA2mzL+o///k/PXb/eN7BQWaLi+0+fr//Pjj/9gVSEiyVFS6YWG9za1OtDXQrwAAAAFiS0dEEJWyDSwAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAG/SURBVDjLY2BgZGJmYSUMGNjYOTi5uHl4CSrk4xcQFBIWERUlpFBMXEJSSlpGVo6AmQzyCopKyiqqauoarHiVMmhqaevo6gnoGxga8eJTyWBsYmxqZm5haWVtY2vHi0+hsbGJpr2Do5Ozi6ubO27rQQqNjXU8PL28fXz9/ANEefEqDDQJNA4KDgkNC4+IxKsQaH1UdExsXHxCYhJ3Ml6FxsZaKalmaekZmVnZWKMJodA4MNDULEcgNy+/oLAIr0KgUp3iktKy8orKqiL8Co2ra2rr6hsam5pbWEXxKjT2aG1NaWsX6OgsZCkSxacQZH1Xd09vX/+EiXb4FRprTpo8Zeq06TNmzpqNHPqYCo01W7XnzJ0nMH8B90IWHnwKgWCR2eIlS5cZLl+xkhe/QmPtVavXrF23fsPGTTDv41BoHKW9ecvWbQLbd/Cy8OJVaGLcWrtz1+49ezX2zZ6NTyFQqc7+AwcPHT5y9NhxUCrFrRBovZaYzomTAqdOz17Ii1ehiUn1mdVnz52/cPHSZbwKQWF65eq16zdu3rq9koBCY+M5d6Lu3rv/4CFBhYHVj7weP3n6jKBCoNLa5y9evgIAadzd4Wn8vlkAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MzIrMDI6MDCAJh3/AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjMyKzAyOjAw8XulQwAAAABJRU5ErkJggg=="), + "bw" to CountryFlag("Botswana", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABhQTFRFAMv/Acv/AMr/Dsv7////o6CfAAAABAQEhk2unAAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAA5SURBVCjPY2AYfEAQC2BQwgIYjLEABhcsgCEUC2BIwwIYyrEA7Cop1I7VSVgdj9WbWAMEa9ANPgAAKWdaUey6wNYAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MDErMDI6MDDQg2u/AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjAxKzAyOjAwod7TAwAAAABJRU5ErkJggg=="), + "bv" to CountryFlag("Bouvet Island", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAATtQTFRF1ygo2Csr1Boa7rCx////S3CzACyRBz2arsHf2UFC1iIi1ykp2C4u1R4e7rGy2URF1iUl2C0t0xkZ1Bwc0QoK7KqrSm+yBj2aACyQrcDf1TM10hIS8quq8qyr8aWk99/fS3K0rcDe8LOz8ain+P//9Pj7SXG1AC2Rp7rb9Pv9GUmeGkugG06iCD6aADeWATmXEkaeHE6iGUmfADSVADiXADWWADaWADeXD0OcD0KcD0OdD0SdBDuZCkCbEESdDkOd6/P66/P76O729/j8RW6zBj2ZAC6SoLXY+fr96O326/D3//Ty/Pv7S3O2rb/e+/z+2DY22TY22TY32DIz9NXXS3G0rL3c4XV32kBA3UxM3ElK1iQk1iAg9NLTrb3c3VdY0xQU1iMj1yoq9NPU3l5f2Cws3l1e1R0d1ysrhhJo8AAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAD3SURBVDjL7dLJUsJAFIXhG7h2kAhGUIKKOCENqEElEkUBZ3DCAXACAXHA938CU0UnRVV3sXSj3/qvszoAjORy4wiRiQdHvQoM8R/+UigxYz4/C8fVCYkHASY4OYUhooWncWbWFeBBhJmLzuOCtbiIS8sRAYg5VjBONZrAZEwEUo7VtXU9rW9sbqVEIDNANwxjOyMG2QGmFepZMdix7eb29k3DzBeKORE4sB0eHZ/Q07NS+fxCBC4dV3hNZFrBGxSB2767+2oN60SjD/j49PzCg0afqjZfrVCmLWx33po8UJiu+s7CD99nl+ecQ2nY4Vfve9jN/lT4AwuzdojtfpIUAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjU4KzAyOjAw4jlLNgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo1OCswMjowMJNk84oAAAAASUVORK5CYII="), + "br" to CountryFlag("Brazil", "data:image/png;base64,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"), + "io" to CountryFlag("British Indian Ocean Territory", "data:image/png;base64,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"), + "vg" to CountryFlag("British Virgin Islands", "data:image/png;base64,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"), + "bn" to CountryFlag("Brunei", "data:image/png;base64,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"), + "bg" to CountryFlag("Bulgaria", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAB5QTFRF////5vLgSqEfL5MAMZQAMJUARoYCyS8O3yAQ3iEQJE7QjgAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAxSURBVCjPY2AYykAQC2BQwgIYjLEABhcsgH6CoVgAQxoWwFCOBTB0YAEMM7GAQSgIAPGQqgHN6gB8AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjA1KzAyOjAwJMxPrAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNTowNSswMjowMFWR9xAAAAAASUVORK5CYII="), + "bf" to CountryFlag("Burkina Faso", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAThQTFRF3gAA3wAAyxMASo0A3gAA4BMA618A3wYA9asA9aoA4ykA/N0A7GcA//MA3wgA9a0A//cA9awA3QAA5C4A/N8A//QA5C0A4h0A6EkA6EgA50UA8YsA6EcA4hwA3wAA4hQA8YAA/eAA//AA/u4A//EA8X8AyxIAyxEAyxUA1V0A6tIA/vUAS4wASooAVqIAq9EA9vAAS40ATYoANKIAM6EAOaIAer0A3eUAM6IANqAANaEAMZ8Ad7wA+vEAdrsAN58AM6AAnMsAm8oANKEAQqYA1OIA+/IA0+EAMqAAarYA5+kAi8QA5+oA9u8AabYAo84A//UA/PIAwtoAXbEAw9sAos4ARqgA2uUA7uwAkscAQKYAQaYAk8cA2eUARagAb7gAxNsAZLQAZbQAbrgAVa4AR6gAVK4A////1Ljd9gAAAAR0Uk5T+/v8/rlpGqcAAAABYktHRGdb0+mzAAAACXBIWXMAAABIAAAASABGyWs+AAABIklEQVQ4y2NgYCEOMAxRhaysRCpkYyNOITsHJztRCrm4ubmIUsjDy8tDjEI+fgEBQT58CoUgQFhEVFREDMrBplBcQkISCKSkeYFAWkoGyJaQkEUoZJSDAnkFRSVlIFABKVQBsZQUVeVhsnIMTGpQoK6hqaUtygsHotpamhrqMFk1BmYdONDV0zeAqxQ10NfThUsZGjEYIwETUzNzmEJzM1MThIyFJYMVCrC2sYWos7WzRpGwR1Po4Ai1W9TJAZ9CZxdXUV5RNzcg4e7ijEehh6cBr6iXt7ePKK+vnwc+E/0DAoOCHRyCQwIDQvGY6BwWHhEZBXScQ3RMRGycM06FHvEJic5gaWfnpIRkD9xWp4TBJT1S0/C50Rk7GzMccYKBVAgAeBqY4SGl3bgAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NTcrMDI6MDAUcTvfAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjU3KzAyOjAwZSyDYwAAAABJRU5ErkJggg=="), + "bi" to CountryFlag("Burundi", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAeZQTFRF/3R0/wcH/wAA/wQE/wIC/////8/P/z09/wEB/wMD/z4+//39/6am/xsb/v////z9//z8//Hx/3Nz/wUF/f/9/P78/9TU/0ND9/73//7+//v7/6mp/x0dMNgwuvK6/v/++/77//Pz/3d3/wYG/wwM/09P/4yM/qinAM0AWOBY4/rj/9fX/0dH/2ho/+bm/f7+A9ADA88DAMwADdENiumK+f75/6Gh/vz7//7/5/zp5vzpAM8AAs4CAMsAKtcqzu7Dt4dLzu/DAc8BBNAEAc0BVN9U4PngurR+9AAAAs8CDNAMhuiG+P74ssmF1SkJ1CkIs8mGJdYlxPTE/f78xN+yxOCzB9EHAMoAh+eH/v7+/v39/f7//v79hueGqe+p/v3///3/+/762e/UtdWZ/P///f37/f77u9mj0OnG+v75wuaxw0gX4RcErKdf9P/9//3++///rrZv3B4FyjsRu9ygx+Cz3RAAt4BJ+P////v9//v8t5Ze5wUAwc+eh+mH/f791/XSuqFnt2wxxeCt9v73+v/7yOa2t3U6uZVa0vLLVd9V4fnh/vv78f703Pvh4Pvk7f3wu/K7/f/+/vr6/vr7i+mL/6ioWeBZ/9bW/0ZG/2dn/+Xl//Ly/3Z2/wsL/4uL/0JC/87O4JBTPgAAAAFiS0dEBfhv6ccAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAJ6SURBVDjLjVQHV9pQGI3Bq6FojAhqRAQHGjfgShuxFidKh9pqFVQ67N7bDruX2qGtuNc/7ZcE7GkLPbzzTt57+W7ezbvf/R7DpLGGdPa/Ld3ApjEMMjJZzsglh6nBQxlgTEBWNms0JsNRJDsLMDF8joBccx5rTMifbmTzzLkQcnjGYoVgQn4Byxk4nclgpK7P6VVBPkwCrBamkB5iEWAr1vjjf8sZNdZiG1Ak0maFjL0EDqeDPiotK1dDFa7KqqpKV4U6Ly8rJToKo8TOSFJ1Dawaf20dy9U3oJHnG9FQz7F1tRqrFTXVksS4Pd6m5haNX0SrDWKbfPiI3CbC1gpRY21pbvJ63IyiuNt9HTo/SSUI/NHOzmOqFjDprB2+dreiEFDxd3VLPb20KcHQhr7+/j4aaE7b9fZI3V1+RQcqSsDjHRgMwgHaBsdPnDxFA2gZHBzwegIaRAcSf8A3NAwLhUdw+gw/QhMLhod8AXcMEAcq/tGxs3BifAJyKCRjIkyLybFRv/I3UHFLU3DK06EIwmFEQtOyE1OSW0kMPIfzFy7OAJf4y1dwNTGQqCeBa9dv3LwVuX3n7r37D5CQWj8MHj5iHz+Zfco/Y5+/gPzvYVR55oJ4iVev37x9B/n9h4+fPiOM4Nwf8qiCzy+ogi9GvnxV1XTg23d5URV8Yf634GoKl2IpXP4xS2cBZmZ/LsdSuBRLoWqKlQNTRDEuFFETxvnogSlWNFNI0mrcZmvrLLexCRHUNzc4dn0tbrNVspldYyWzbG1rxt1x7Uaju64dzbjbW1QuGr899VKIFddesuLaixcXL6RSrgKf+gWA/RSulMx9MObULinzL4qXnyvu2DYjAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjI1KzAyOjAwiSsj7wAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDoyNSswMjowMPh2m1MAAAAASUVORK5CYII="), + "kh" to CountryFlag("Cambodia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAhNQTFRFGwBzHgBxHgByDAB7DAF7DAF6gQA8gQA9gQE+gAA7gQk/gQlA9QAA9AEA9QMD9AAA+3Nu+3Br4wAI5R4i4wEI4wML4QAA73t97nh74wAH5gAG5gAF5wgN8nx95gEH5gAD6BEU96mp5gEI5QAA6B0f96+w6R4g5gQK5gAC71td/N3d71tc6Bwe96+v6Bse5QAB5QED72Fi+9TU8GRm5gQG5QEB5AAA8G5u+cXF+9nZ5QIC71pc+9nY7lVX7UVJ+cDA/OTk8GNm6icr6iQp96ut+9jY+9fY6SQp6ics8GFl+9ra+cHB+s/P7URH5gII9qCh/N7e+b/A/OHh/evr/e7u+s7O+Li4+9XV/evq+b+//N/f8XV2//r6+cjI/e3t/OPj/ebm/OLi/enp/efn/e/v/vj48XR2+cPD/ODg+sjI+tHR+srK+9LS+9PT+cbG+cfH/ejo8XV35gYL4wAA8XBw+Ly8+sfH+snJ+szM+b29+Lu78W9w5gYK5gAH5gMI5QAC8nZ4+cLC+9fX+9vb+9bW8Gpt5gQJ5QIE8n1//vT0/Nzc+tDQ/err/efo/Nzd/vPz4wEJ4gAD73h8/f//+/3+/P//+vHx+NPT/P7+++zt+uvr+vHy4gAC/V1Z/2hj/2Ne/2Zh/l9b/VRQ/2Rg/2Vg/2Vh/l1Y/lxYgAA8fwAsfwAqfwArfwAufwAtDAN+DQR/////x3+KlQAAAAFiS0dEsENkrsQAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAHFSURBVDjLY2AYToAREzAxYRFkYMYELKxYBBnYEICdgx1EcnJxc7Kzw7gwwMCDBHhBBB+/gCA/H5wLAwxCSEBYBEiIiolLiIkCGZJgLgwwSMGBtIysjLSUnLyCoqKCvByUCwcIhUrKKqpqyurqGppaWtoa6urKOrp6+kpYFEobGBoZm5iamVtYWlqYm1kZWNvYKsthKpRTtrO0d3B0cnaxdHWzdHH38PTy9vFFqIQr9FP2Dwg0CgoOCQ0zCg/zCYkIcouM8lf2w1CobhYdExsXH5+QmBQQlQykHFJiU9PM1LEoTEtK18rIzMzKzsnNy8nMz8jwLihUxlAoV1RcEl6a7VOWXW5fEVpZnp3nk12VW21WI4eqsLauviG3vDG7ybK5KbelKaep2bKpPD0zt1W5rRZZoZx0e0dnXFe3Vk9CQm9BVFRyQUJCj1Z3X1x/R7s0xExIFE6YOGnylKnTpk+bOmPq1KkzZwGJGUDu7KlTJk+aMwEShdA4nztv/oKFixYuWLxkydJly5csWbIYzJ0/by4sUbADwYoV7CtXrVy9cs3K1SCwdi2YAnGBwiBZIIAl3HXrgQBMIABEDJZwGYkEA51lqQoAC02qK305p84AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NTkrMDI6MDBETkCCAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjU5KzAyOjAwNRP4PgAAAABJRU5ErkJggg=="), + "cm" to CountryFlag("Cameroon", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAQVQTFRFAJgRBJURiiwFxQAAwgAAwQAA1EUA/usB//ABxQwAyBcA0TwA3m4A33QA8r0Bxg8AwwcA7asB/egB0TsA00UABJQRiy4FyhAAxxYAyBYA0DYA+NcB//QB44QByBgAyRwAyh4AyR0A11IA/uoBizAF3FcA8rwB9s4B/+8B//EB/OQB99AB+NMB5YkB2l4A/ekBiisFxgMA1UoA88IB//IB++QB4XsBxQ4A00QAyRsA5o0B/uwB9s0BwgMA0kAA/ecB66MBwwUA4XwB/u4B+dcByyUA8b0B4XkBzCYA5YgB22YA0DgA8LQB1EcAwwYA2mAA5o8BxAkAzCcAyiAAwgEAxQ0A////kwE6UwAAAAFiS0dEVgoN6YkAAAAJcEhZcwAAAEgAAABIAEbJaz4AAACxSURBVDjLY2BAAoxMzCxwwMrGzoEEGEYVkqqQk4s4hazcPEQq5OXjJ0Yhq4CgkDArkBbBrVBUTFxCUlJKWkZWTl5BUUkZt0IVVTV1dWkNTS1tHR1dPX3cVhsYGhnLmHBwaMqYmplb4HUjq6WVNQeHiY2RLSHPsNrZa5rIODgS9DWrk4yzi6a0KyshheZuWu4enkJehBSyevv42rL6+QcEEjIxKBgY2CwhrqGDOz0Of4UAVDUip2lhZrwAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MjYrMDI6MDC4wzlyAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjI2KzAyOjAwyZ6BzgAAAABJRU5ErkJggg=="), + "ca" to CountryFlag("Canada", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAATtQTFRF5Zysvwowvwkv/////vr7//7+/vz85Jmo9drg//3+9NTbxiNF34OX/v3978HL6rC82nOJvgYsyC1O67G95Jen/PP17LbBwxg7wRE2vwkwvwsxwBA11Ft09djexR9CvwguvgYt4Iea+u3w/ff47bnE89LZ4Y2f2WyD9+HmzDpZvgcuwA4067K+67O/1Fx189HY7bvF9tvh12Z9wxg8wRM4vwwx23eM0Etnvgctwxs+4Y6gxylKxB1A8MfQ56KwwRI3wA0zwhU5yjNT+urt2nCGvgguxSNF/fj5whY60VBr56OxwA4z2W2E+ert7LfCyCxM4Iqc/PX345KjvgUswA0yvQMqzT9c/PL045Sl6q262GmA5p+u34OW34aZ+/Dz//393oGV9tzh/vz923aL9NXc/vv88s/W8MTN+uvuEtZ6YwAAAAF0Uk5T/YPqVscAAAABYktHRAMRDEzyAAAACXBIWXMAAABIAAAASABGyWs+AAAA60lEQVQ4y2NghAImBmYsgIEJJs8wRBWysBKnkI2dgxiFnMxc3DzMvKwEFfLxCwgKCYuIElQoJi4hKSUtw0ZAoaiorJw8I6OCIrMSHoXKKqpq6hqaWoyM2jq6evoGhrgUshkZm5iamVswMllaWTPayNnitNpOkolJ2x7IcXBkYlRwcsalUNQFLgxkuLrhNNFdzcOVEc5n8uTAaTWbl5wWjOvt44sneFj9/CEyTI4BgfgDPCjYNUTbWzI0LJxAzPCbRURGRUfHxMYRUBjPzMybkAh0BCvhZJaUnEJcekxVTyNOYXx6xuDPhXRSCABQTCDtFbfICAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNToxNyswMjowMH/5XhsAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MTcrMDI6MDAOpOanAAAAAElFTkSuQmCC"), + "cv" to CountryFlag("Cape Verde", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAihQTFRFCBhzCRlzDh52CBhzCBhzBxdzBhZ0EyBuDhxxBhd0ChlyBxhzJS1mg3M+amBJGCRsCRhzFCFuVVFSKjFkLzVi1K4bsJQqFyNsChpyNDlgOz1dDBtxUE1U4LgVloE1FiJtR0ZYQUJaCxpyKDBlt5onwqIiMTZhBxd0BhZyBBV0KjFji3g5XFZNBhdyBBVzBRVzDx1ugnE9inc5FSFsBRZzJzWEIS+BITCCIzGBJjJ7JjSBIzGAJzR+IjCBJDKAKTZ+KTV+JTOCJjJ83d/s3N7r3N7s3N3j3dKq4Mp33NjM3N7q297r3NnR38t83dGh3Nzg///////4/+h0/9gk//bB//jN/9ks/+Vl//709cXA9cO+9beC9bJs9b6k9cO/9b+p9bNt9bZ99cK830Iz3jsr3jss3jwv3jwu4lJE4Us94Uw94Uw+4Uw/4k834Us+5Fgy4lE5+uLg+uHf+uLf+uDZ+ten+8xk+tm2+uHd+ter+8g8+t3M///9/+2M/9ce//Ou//rd/99I/+l9///8n6XIm6LGm6LHnKLIn5uXnJN4np6lmqHJm6HHmqHIm5+6m5yrm6HEDx93BxdyBxh1HCZpFCFtBhdzDBtwIitnBRZ0ESB4LjRjnocyiHc7IClpBRV0ER9vFSFtbmNHrpMrQEJbCRlyJS1nwqEip40uISpoemxCYVpMFiNthHM91a8aQEFbEiBuLTNj17AZs5YpGSVsKTBlGyZrSEdXc/d3NwAAAAR0Uk5T+fv89h27Wh4AAAABYktHRFDjbky8AAAACXBIWXMAAABIAAAASABGyWs+AAABdUlEQVQ4y2NgYCEOMIwqJFEhK5EK2dg5OAkqZOVi4ebh5eNnJaBQQFBImEtEVExcQlJKGq+JMrJygvIKikrKKqpq6mgKGTUQQFNLW0dDV09fw8DQyNhEAwUwmJrBgLmFpZW1jS2IaWfv4OhkbW6GBBicXaDA1c3dw9MLyvF28fH183d1QQCGADgIDAoOQfBCw8IjApAAQ2QUHETHxMbB2HHxCYlJUUiAITkFDlLTUpBAeioyL4UhIzMLCrJzcnOy4CAvvyAzCwkwFBZBQXFJaVl5BYxXVFlVVg2XAwIkz9TU1tUjeA2NTc0onmlpbYOA1vaOzq7uHiivt6+/f0IbEmCYOAkOWCabTJlqMmka66Rp02fMVFdnnYQEGGZxIyWe2XPmzpu/QJpt4aLFS5aixTUTEkd92fIVgitXrV6zdO269WxoCpmRONwbZm9UUtu0eQvL1o3bWPEoZGHh5GQVl9kuzcLJhp520RSC84I6CxaARSF2AADWZMJ/dOCgpQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo0NSswMjowME9EKmgAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NDUrMDI6MDA+GZLUAAAAAElFTkSuQmCC"), + "ky" to CountryFlag("Cayman Islands", "data:image/png;base64,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"), + "cf" to CountryFlag("Central African Republic", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAMNQTFRFj4//jY3/jo7/kYz62/Hb3OzWGaQZHqAZhM4AhsoAAAD/Dw/wBQD6sgBN/gAB+gAFV1eotQBK/wAABQX6LS3SPDzDtbVKPj7BMDDPAwP8W1uk2dkm/f0C2tolWlqldnaJ//8AeXmGAQH+jY1ymppll5dokJBvAgL9Bwf4MjLLBwf3Bgb4MDDNCAj33ylK//////r6/0pK9UU/9UY/vS8HvC8HAJkAAJoABZYAtSwABZcAtS0ABZUA2zsA2zwA//oA/0oAWGHrOAAAAAp0Uk5T/v7+/v7+/v7+/iz0QYUAAAABYktHRC8j1CARAAAACXBIWXMAAABIAAAASABGyWs+AAAAwElEQVQ4y+XPRw+CQBCG4cHOYgFRFCv2XrBhl///q0RHYmY8wM1E38NevifZXRBeiiL80plsziubSQsaPA5VfUMt/0z7hHqhaBilsh4IzUq1Vqs3zEAoRNOyWiGuFu1Ot9cfhIDD0XgynQVCLykSkeBVdI5wHgXWgra0EdpLNvwWjNHiK4TrOBsgQUtuEG6TbIAdydkfEB72Dl3AoR1PCE9HNnwT0ifvzv5nzmyAFE2+ILzKbACLdnMRujc2/Ce8AwJCj6qxb9w/AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjE0KzAyOjAwThFEhgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNToxNCswMjowMD9M/DoAAAAASUVORK5CYII="), + "td" to CountryFlag("Chad", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABJQTFRFAABnnJwo//8A/5wA/wAA////tPKynwAAAAFiS0dEBfhv6ccAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAaSURBVCjPY2AAA0YlMDBxAQOGUcFRQVoKAgCIN03vQD/YJgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo1NiswMjowMLIGMGsAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NTYrMDI6MDDDW4jXAAAAAElFTkSuQmCC"), + "cl" to CountryFlag("Chile", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAMlQTFRFVVCpVE+oaWWz6ejz/v7+/f39W1asXFesl5PKW1esU06oUEunb2u2bmq2iobDmZbLm5jMjIjEVlGqhYHBg3/AUk2nfHi8fHm9Uk2oiobEjYrFmpfMWVSrnJnNVlGpX1quVE+pXlmuVFCqUk+qaGW16er1/v///f//Z0uVZkqUeV2e6dHW/OTf++Pe2ywU3S4W7D4d70Ef7icA7SUA7ScA2tnsubfb+fn73t3u/f39/Pz9/f3+3dzt8fH3////8vH47ez1ycjj7Oz15wJcQwAAADV0Uk5T/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v70ZoPgAAAAAWJLR0Q+SWQA4wAAAAlwSFlzAAAASAAAAEgARslrPgAAAJNJREFUOMtjYEAGjEzMLKzYAQPNFLIRqZCdg5MYhVzcPKa83FwEFXLy8ZuZmwkIshNSKCRsYWllbSMiRNBqUTFbO3txUcJulJB0cHSSkiDC19JSMpKycoQVCskrKDAqChFhogIU41OohAyUVVTV1LEDBg1koKmlraOLHTDooQB9A0McgMEIFRjjAgwmRIJRhSNHIQCeJpKdP7BkTgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNToxNSswMjowMOhmTzIAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MTUrMDI6MDCZO/eOAAAAAElFTkSuQmCC"), + "cn" to CountryFlag("China", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAVZQTFRF/zMA/zQA/zIA/y4A/y8A/zEA/zUA/zcA/0YA/08A/2kA/yIA/zYA/zkA/yoA/4UA//wA/8AA/0oA/50A/ykA/4cA//8A/8sA/1gA/ywA/04A//gA/1MA/ysA/2MA/3EA/x4A/yUA/4wA/y0A/8YA/80A/zAA/zwA//cA/1cA/0AA/3wA/+YA/+IA/9wA/98A/+gA/+sA/+AA/+cA/+0A/4IA/3YA//IA//4A/z0A/zsA/0kA/yQA/0EA/8UA//0A/8kA/0MA/9IA/7AA/7wA/ycA/3QA//UA//sA/7UA//oA/8cA/z8A/4MA/5EA/+4A/9sA/zgA/28A/4kA/3kA//AA/4QA/7oA/+kA/9cA/9EA/5gA/0sA/1YA/ygA/0QA/8gA/0gA/7MA/70A/zoA/30A/68A/4YA/1AA/20A/yAA/5MA/9QA/2UA/4AA/64A/2EA////WzUIRwAAAAFiS0dEca8HXOIAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAGtSURBVDjLjZJpV9NAFIbnTjIzEUMbJVxIYYRYTQDZESglWBbjUitQNmVVFhVw4/9/IvVgM7Q5J7nzZc7MM+97lyGkGUCUoJrOOEkOqu6F8aDjoZkMdip7nstbjx5TSNLjXSLW5HY39vSyBBCcQl+/bGZFReHJwGCStXDz+NQV8YFTNNuKYQ3F3DN87hBKqXdn0W4LPmNcKwyhNawJ4CMxAaDioL0YHRufmETEqbHpmZez2v9L8BjTVWFnbh5LEYelEs7PyaaCZyyUF1WSB0uv0IrACi6vBM0SQF9YXjUcVVLo7hpaFQtfh5pQcnrz9l3eu1eUCN9jNVofpNIgwmsf1331IMpmaQMrm1XsKxRVAVn3pcoRM9zCoW17Zxf3AnUaQFuGaLqfPvcH3DX2D6R6Ay1dB692WLcFEU5x/Sj2Bq7xlvFQU3oNS07teL6gh8cnWit59xQ4jW2+DHzdOfWSvuT9fGj9DM8vaCoYVfjt+4/QTOUa/Q58k2YACTNZCsfhH5CaHs155SyOtHw5e3WdoQouf+Kv33p6X7j9Z+Nvhv5FpFG+kVlAorNiG3cLqPQrR7LSmnIAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MDcrMDI6MDCzU16FAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjA3KzAyOjAwwg7mOQAAAABJRU5ErkJggg=="), + "cx" to CountryFlag("Christmas Island", "data:image/png;base64,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"), + "cc" to CountryFlag("Cocos (Keeling) Islands", "data:image/png;base64,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"), + "co" to CountryFlag("Colombia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAC1QTFRF/+gA/ucB/+wA7toKESKEABCQARWNABSOBBSMABWXbQpP6gAH1gAS2gAQ////+isIvAAAAAFiS0dEDm+9ME8AAAAJcEhZcwAAAEgAAABIAEbJaz4AAAA/SURBVCjP5cgxAQAQAADBr6CCCiqooIIKKqigggoqqKCLAr+a3HjwsSCIgiTIgiKogiY8u2AIpmAJtuCIF3kBsZjHOdeRgOYAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MzMrMDI6MDAmURZLAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjMzKzAyOjAwVwyu9wAAAABJRU5ErkJggg=="), + "km" to CountryFlag("Comoros", "data:image/png;base64,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"), + "ck" to CountryFlag("Cook Islands", "data:image/png;base64,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"), + "cr" to CountryFlag("Costa Rica", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAC1QTFRFAAC0AwO1AACwSkrK/////Pz+//39+dTU2QAA2QMD1wAA5EpK//z8/f3+1NTyOWQfkwAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAABKSURBVCjPY2AgGghiAQxKWACDMRbA4IIFMIRiAQxpWAB27eVYAEMHFjDAgjOxAIZVWADDbiwAu9/PYAEMd7EA7NrfYQHEpwUKAQB++dslvrN5NQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNTowOCswMjowMEUbLmwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MDgrMDI6MDA0RpbQAAAAAElFTkSuQmCC"), + "hr" to CountryFlag("Croatia", "data:image/png;base64,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"), + "cu" to CountryFlag("Cuba", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAoJQTFRFsBQ9LEHEAFf/AlHzA0/sAVDwAFDw9wAA6QMIfyVuD0zkAFb/AlDvA0/t6gEC7gEC/wAA2gcWXDCRAlL2AFT8Ak/u7QAA7AAB6QED8gAB/gAAvBAxOD22AFX/AVL3A07sAVDvAVHw6wEC+AAA9gAAmRxTHEfVAU7xAEnsAE3w6gED6wED/QAA5wQLcid6E1nsEmz/ElrvEVnuEVzx8AEC/AAA4xgg5p6q7/z/7vz/7e/77vH87vP+8AEB8QAA9kRB/9LQ//////79//78///+7QIC7AEC7AMD6wAA82do/enq/vz8/vv8/v7/7QEB7QMD7AAA7hMT95KS//r6//z8//398To67QQE8Cws+rq6//7+///87QUF7QoK+r6+7xsb7AEB9E9P+Njb3/v/6vP98vL77AIC8DIy8k5O7AgIkTJxGlnoAWH/E1vwFFvu8kRE9oOD9GNj+aqq+r299Gdn94iI81VV+gAA0QYZUS+XAFH5AFH6AEzu7xkZ+rm5+8nJ7yMj6gID8gEB+wAAxw4oOD65AFP3A1Du9Xd3//j495GR9AAB+QAAvBEyM0C+AFP282Fh/vX19oWF7QYGygggRzOiAFL7AVH5+8HB/NHR8Ccn+bCw/eHh7QID6goMhjZ9FFvtAmH/FFvv7xoa9oGB7QcH9XR08DAw9Vtb99/i3vv/6/P88fL78TY2+8XF+J+f7AID7AcH9HR1/fDw8AAB91BN/9zZ7QAB8gEC4iEq6Ku37///7vr+7vL94AYRZSuHEF3yE2v+EVrv8gEDjCBgFEreAU3wsRQ8LUHCAlL10AoeTzWfAFP6AFT64wQNcSl8CU/rA0/uAk/tohlMIUXPAlHy6vewcQAAAAFiS0dEQYnebE4AAAAJcEhZcwAAAEgAAABIAEbJaz4AAAHgSURBVDjLY2BgZGJmYWUjCBjYOTi5uHl4CSvk4xcQFBIWYRElpFBMXEJSSlpGVk5eQREfYBATE1OSUFZRVeNW19DEA0AKxcS0tHV09fQNDI2McQKIQjExCRNTM3MLSytrGxwAplBMXMvWzt7B0cnZxRErgCt0FXNz93D39HL09vHFBuAK/YDY3z8gMCjYMSQUn8KwcJDqcNeAiEjHqGgX7Fa7xrjGxsWLxbgCmf4JAYlJySmpWD0TkOaR7pjh4R4gBrE/Mys7JzcPI3j8xPILCosci0tKy8AuFfN3La+orKquQQ9wP7HaOsfQqBDH+gaIQjG/xqbmlta2dvQoFHP16HDsdOwKSICFQGN3T29fP6bCmIAJjhMdJwVMhqjz5y+fMnXa9BrMuHYNmDFz1uw5/pDAnBswb/6ChYsWYca1n9jiJUsDApYtD3AFBk9AwIqVq1avwR7X4e5+/q5pMcAA9wtYuw53gAPtA1rqDwyXgNr1UQSiUExsg7vHxk2bCSYKca0tdlu3AZOZI95ktl1iR/POXbv3WO3Fn3C13KT27T9w0OgQ/qygpFV++MhR7mMEMpe4RLfp8RPcJ1lY8WdXPhOBU6fPnGXhIVQA9Jw7f0H24iXCRcrlK0xXWQiXUWwAJhP4Hi78yG8AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MjkrMDI6MDBOi0mbAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjI5KzAyOjAwP9bxJwAAAABJRU5ErkJggg=="), + "cw" to CountryFlag("Curaçao", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAALFQTFRFACt/ASx/ACx/ASp+ACl+DzSEACp/BjGDABx2YXmuCzSEip7E6OzzASyAAi2AACN6KEuS9/n7ASp/ASt/ACJ6PV2dVHGpCC6BBS2AASF5BSyAAid8ABhzUmymAyd8Ay2AJkuSBzGDrLrVACd9Z4Gz8PL3+fr8ABZyY32w////BC6BAB53mqvMpbTSACp+BjCCQ2ShAiJ5Ay1+ACGFQFxj//AQ8+MX//YMfYlKAB2HBC59XgHWQwAAAAFiS0dEKcq3hSQAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAC2SURBVDjLzdFJEoJADEDRMAkINiAgomIDyqDMznr/g0l5gWTBwle9/JWqpAFGggAkoiSJpFBWFJmQzVRN1zV1hnWCPDdM05jLC6xklu04tsWWLhZ6/mrlWywIRGzoOgw3210U7fZI6HLG4yRNk5hhKy0OxyzPs+MB3YgX5elUFhw95rmqm6auzmjYdv0w9F2LhgAe5x4hG8/5e1O4EMGVCG5EcCeCBxE8ieBFBG8i+BBN82t/4gtP7VYkdbck8AAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo1OCswMjowMOI5SzYAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NTgrMDI6MDCTZPOKAAAAAElFTkSuQmCC"), + "cy" to CountryFlag("Cyprus", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAltQTFRF//////78///9//77///+/+yc//K6//Cz/+2i//74//zy/+2h/95V/+yd/95U/91Q//nh//Cx/8oA/9tD//TI//zv//PC//K9//XL/+mL/9IV/8gA/9k5//G0//O+/+Fh/++s/+eH/8sA/9AH/8wA/9Yo/+Bc/+Jq/+Z9/8wB/80A/8wD/9xF//PD//O9/9Qr/+eA/84G/9EO/9EP/84A/88D/84C/88E/9Uv//jX/+V3/84B/9o8/9k4/88H/+Rz///8/9Yq/80B/84D/9IS//bO/9xU/8kA/88F/9Qh/+Ff/9AT//PB/fK+/tg0/ssA/ssB/88C/80G//fV/v///vTI/u+s/fK9/v34/vXH/+BX/dcv/tEY/+Z//+Nv/+R0/9o+/9MZ/uV5/f///v76/f79yenG5PThoNupvOXA++2m/M4F/tMe//zu/P32/P36v+a/otqi6PbmzOrJ/f7+yOnIR7ZHmtaYPa88oNqg/v/+/vri/v79ptylPrA+mtaaSLdIxejF+v36ZMJkitGKveW9PK88UblQvOW/6/jy/f/+/v7+7vjuwufBVLtUPK48ueO5jNKM+/37+Pz4seCxQbRBgM2A4/Tje8p7Oa04LqsswObAwufCMa0xOKw4eMh44PPghc+FQrRCrN6s9/z3uOO4csdyYMBghs+Gj9OPdch1dsh2i9GLr9+viNCIZsJmbsZus+Gz2PDYlNWUYsFieMp4VbxVmNaYfMt8ZcJlQLNAjtKO1u/W+/774fPhhM6El9aX2/Hb0e3RzevN2O/YktSSf8x/3PHc/P78Kb+E8wAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAHXSURBVDjLY2AYLoCRCasoMwsSj4WRkRmrMgagKiZGmBpGZrAIKxua+YzMQIKdg5OBhZmZmRGshoubh5ePXwDFJBagdkYGQSEhYRFmEF9UTFxCUkpaSEaWgQlZHa84g5y8AoOikrKKiqqaugaflIqmlpC2ji4DCxPC1YwMetL6BoZCmkbGJiamZipKSkJKWmbmQhaWQDlGJIuZGaxUDIXMzM20tEyAwMwcCKyttWzkGJgZ0fzKaatiB1RibW0CAUC1SvYMjA4YgcLsqGVmggDWTkLO1i6uDBhhyMjg5u5h6gw0zxRoq6mplqeXt5KQDwMjA4aRvn7+ASpOgdZAjyhpqgQFh4SGhXNijZOIyKjoGBUzmdi4+ITEpOSUkBBsqlIZ0tIzMhmysnNygaaH5OUzFBQWFTOUYFFYWlZeUZlaVR3ByJhSk8pSW1ff0AgURgdVDE3NLa1t7R2dXQwM3T29ff0TJjZPAgpjgslTpk6bPmPmrNkMDHPmzpu/YOGixUuw+qWKYemy5SumrFzFwLB6zdp16zdsxGoeEDQxbNo8dcvWbZu39+3YuWv3HqAADrC3qmnf/gMHDx0+cvTY8aaqvQw4QeoJBPtEKgM+0H3iRCoQAAmGoQcAg35zKD2gjyEAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MTUrMDI6MDDoZk8yAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjE1KzAyOjAwmTv3jgAAAABJRU5ErkJggg=="), + "cz" to CountryFlag("Czech Republic", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAARFQTFRFT0+c5OTw////+/v9/f3+AABnGBh7rKzR/Pz9AgJxAgJrAABlVlag6urzAABvAgJwBARxFhZ5q6vQAwNyAgJsAABmV1eh6+vzFxd6WFii6+v0ra3RWVmi7Oz0GBh6rq7SWlqjr6/SW1uj7e31/v39//7+GRl7sLDS/v7+AgFqUF2r7ubs/+/u/O3t/e7uAwBtAQJ0AAN2UAA43AsO7BMS6RER6hERAgBuAwBuAAB3HQBiqQAe/AMA6wEB5gAA6AAAAQByAAB0XABC4QAG9gAA5AAC5wEB6AEBqAAe+QAA6wAB5AAB5wABHABiHABjpwAeWwBC+AAA4AAGpwAfAgBtAQBzAAB1WgBDHgBiVQBG3AAIE5FEqAAAAAFiS0dEAmYLfGQAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAEBSURBVDjLjc5nUwIxFIXhGKqUFVCQqlIUFRWlW3ClY6WoiP7/H+LeDAwku8nlfH7nmUPIFrXZKT7icLqo3b1BuO3x+vwboETbCXiDIRwlmqbt7oUj+xgKIaBR7CkLGRqLK9FFyNCECl2GDE2m5OgqBPTgUIquhYA6jmQoFwLqTFujfMjQTJbacsfixBDQkzw9RUVAz8LnhYvLK34WYfH6plSuVGv8TGG9cXt3/9B81IWJYfGp1e50e/2BOGLihs8vr7p5xIJ709Whwb1LOC5UcWuhwX2MpNwqNLixgluGjJsouEUI3FTJsRC4T4SD8Ot79oNyEM7mQ5yD8PdvgnPG/gE0npRdY58b+QAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo0OSswMjowMIjkQBwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NDkrMDI6MDD5ufigAAAAAElFTkSuQmCC"), + "cd" to CountryFlag("DR Congo", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAe9QTFRFAH//AX/+AoD9BIH8AHr/AXn+a6ab8eQg8rcY2EQfAn/+BX/6A4H8An79AHf/M4/Pws5M/9gM5XYazhUhzAchAH3/GYfoYKClAHv/A4D8AHj/E4Htlrp0/uQQ9Z4O0SkjygAizg4hzhIhBID7SJe70Mk6AYD+AoD+AXr+YqOj6N8m/8EJ2kwfyQQkzQkhzxQhzhEhzhAhAHz/BH/7hq2B/90HJovbAX//NI/OxdBJ/9kI53QYyhElywQizxMhHonjEYXvD4TxyMZC/98AdKiSEIXwGIjoFYfrAH7/lrp1/eMR9Z4Q0CkkyQEjzg8hzAkhygckcaeV89Ub6tEk5tAo99YX+NYX8tUc4s4s9tUZ0sk7L5DT6N8nyQAj0Swj9JsRUZu07dQd/toP9tUa99YY9tYZ/9wHu8FPzxIh6HUY/9kJJIrd488q+dcW79Mf/9oNnLdtAn39/8IJ6d8mYKKmHIfl6NAm/9oM/NoNnbVtBYH70Cok9Z4Plbp1A3/9AHn/YaGi/+QAs75XYqGk89YZ7NUbEIPx53UY/9oIxM9JtsBRm7ZuJ4zb280wWZ+qYqOkSZm6GYXnRZi/A4D9AX7+AXz+BIH7BYD7AXr9YaKl6eAm85sRygYk/eQQzhYh5nYawc5M2EUf8OMhaqac////DOZeaAAAAAFiS0dEpFm+erkAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAGhSURBVDjLY2CAAEYGHICJmYWVjZ2DE8rl4sahjoeXj19AUEhYBGKcqJi4BBMWZZKSUtIysnLyCopKIGWMyiwqqqJqXIxo9qtLSmhoamnr6OrpGxgC+UaixnwmpmYsvKKiyMrMgbZaWFpZ29jaKRkqAU2UtHdwdHRydmF0dXP3QLXV08vbx9fPztBA3z+AgdEjMCg4JDQsPCIyKlqUCdnWGKitdn6xcfFAJ7IkJCYlp6SmpYtJqGGzNcPWJjPLEmSJVHZObl5+AUshEzZb9XR1iopLNEC+9igtK68wrWSpwmarb3WNV620VB1QRrm+obGpuaW1zYMRi63tHZ0WfLw85qBIkujqLuTr6e2rl8Ria0w/q4SkOjhaPFwnsPBWsUycZCSJHMJwWyUl4WEmMZmRgWnKVOZCrLYipxAQMW06Vlu50KJfnZCtOEIY01YcIUyJrYxE2spQR5StQDBj5iyCtoKBZRZhW8FgdlwsQVvBYI4/YVvBQIkIW8GAGFshJioqyMvNlcFrKxiIzJsvuICfj5eAMgaGhRyLFrOyMDMRUgcAjPCYa9vcYiMAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MjIrMDI6MDCjTnZfAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjIyKzAyOjAw0hPO4wAAAABJRU5ErkJggg=="), + "dk" to CountryFlag("Denmark", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAADBQTFRF+xsi+xgf/EpQ//Dx//39+xsi+xgf/EpQ//Lz////+xUc/EhO//Ly/HB0//X1//7+C2BCZQAAAAV0Uk5TtbW2t7cPsqOPAAAAAWJLR0QJ8dml7AAAAAlwSFlzAAAASAAAAEgARslrPgAAAFBJREFUKM9jCAWBsIqZ7amhMBDAMPwE00Aga8/M08vSYCCRoRwEqu/NfLu9HAaKGDpAoOf9zH8nOmCgmWEmJpiCXRCrdqwWYXXSIAw6GggCAFkM9x0CLLn8AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjMxKzAyOjAwsc4HYgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDozMSswMjowMMCTv94AAAAASUVORK5CYII="), + "dj" to CountryFlag("Djibouti", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAWVQTFRF0N/+dKL/WpH/aJv/Z5r/Zpn////+8fX+mLr/XZP/Y5f/aZv//v3+/v7+zNz+cKD/XJL/aJr///7+/f3+8vX+mbv/XJP/y9z+cJ//y9v+b5//ytv+//39l7r/ydv+//v7/+rq//r68PX+l7n//////2lp//Hxydr+bp7/Zpr+ZZn+Zpn+//Ly/6Wl/5CQ/w0N/4OD/6Cg8PT+lrn+WZL8ZJf/aZn/aJj//52d/w4O/wAA/wcH/46O/v78///81tz/bKHzXZztYJ3uX5zu//z8/0ZG/zAw+/36oO+WEc0WBcgRCMkSB8kR/93d/3R0//X1/39//8rK/f78+/773/jfRdpFAMcAAcwBAM0A//j4//f3/v/+meqYDc0NAMkABM0EAcwCAMwB4PjfRtpFAMgAAssCA80DAMwARtpGDc4N+/37muqZDs4N4PjgR9pGDs4O4fjgR9pH/f38m+ub3vjeoOygE88TFak2pQAAAAFiS0dEJLQG+ZkAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFISURBVDjLjdH3P8NAHMbxUNKiIVKzQlq+9t7UqBFqj1JFqVVqb/5+NxJpIr3z/Px5vS+XE4SCQk9RMX+C6PWVlJb9I/RLYnmFXMlFBcUfEKuqa7iooChKQBJr63goDjHq9XFQEhK0PshEjZCiMgM1Q4I2MFAzVCnamBfNCQnaFJTdH4qGmhYKaxRtbnFHaQhqaxuYX9reIXs6u7odQ6EKPb19/QODIVDp9YeGR0bHxh3DogoTk5Gp6d/rz8xG5+YXFu0jR+uwFFlWCIgWk2BldW19wz4qbm5t7+yCjrP4HuwnDpKHzhERjsKgH5PbxFJwcpo+O79wzviPuq4Z3OVV5vom+3fWE1pcMssOMXfrztlCzN3l4XLC+D2Ls0LEPTzm58wQcU/PLM4IMffC5EiIuNc3DofD9xR8cDkcwmcizeVw+PWd4XNoP36z6HdatyBvAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjI3KzAyOjAwHrQyxgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDoyNyswMjowMG/pinoAAAAASUVORK5CYII="), + "dm" to CountryFlag("Dominica", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAIAAADRv8uKAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAABFJJREFUSMftVltsFVUUXfucM4/7aC1tsSnyhhSEhvIKYEuNBGNADRIiaIIBMdEEIij8EI1fRmJMRH8A/VGCRiMhgiAkiMFHQgMKNgZEhKA8mwLtvbS9vffOnZlzth+K+MPcqeCX7uyPSWZmrey99ouq3kQcU4RuH+vGYOMkIIElz2HHFwDQ/mP7lKYp2UJm+taGrkLWksTMcQBFLNp/wf4nHogRARRL0DtCzID584kBJgCA1gOFUQOLkYEEUAEpyAINgpFaA2ApBxp9XOI/QIsJ4BfZs9d5pUOtajWKuPbFZfmZs3new54lfAnbQFM8wNqNMT4CfEJgsLk9seiYkylStcL2VTkRYtFmu48KjuseaFAvz873uJzWMDG4Ca+XZ2WG4+KT3emRlfzlvOKT76etnMjUGYYYfFV4g/DBqt7HdjreJbXgidxVZjI3tI9I9ZZJ5YgN/DRGfJh46JR9YkZpxK+KAyKmusu+UH4gK6nAU9qsMC8mXlMftyWPr84n/Bv1F6Xd6cj3DDjAeZlZl74uuKpXgtkIYar6j1a9FGarZxXXK+1SQJAoWZzwUL0hj9YAuTIdI2AjwlkBlcjtsT9v9vY9ndeSAxchoJJib9OBTUNbvrPXk+jxk4I1/9TsbV3R37nfggQ7iEZW85dFqQtGKLGhW00bzj1dggEyJCzf6xiiUmvaG9eezM5rLVRCaCKq6BJj07KvXT2/hPrBEojoL4rICAEMtkCHxlbca0QpQFDBYGFx4Yozbm/d0TcmTZ7a+/NnX9fkbE2A9MgJkE1x69n+jlALUITSAjCRziAjtcnW6WsjAzYgsCHLDa/ZJmy+PPerYTheZZKaoNEzOLwyOiRmAX1jwt3S1aG2Q5HFxXCdoetf+Hbi4XONavlbKQAh2XV+5+jc27vuTqKI39Jmcp/wAzrRHJwe5y3fNmrHO7uChEva4NZNpVqaW6KIdQipcnMeGL/98JhzaWYQgVh3uRXV9Nq5MYIYJQqJ7cDiCe3u0GOe2zht5pw5MAYiqqxFmUxDAEg+vnSEVzvsJNgCMwRwIRFgCO9sKi7O0MSMKBHY4epO0XDWvWvxCgBsOBqZWraVmSDCcF9SPvvpxaUngk1r8/cfdCccddgBfMDCD7Xh5E51aYK/b2Fx5ebUkUHi1WeGJwNiMChqepEdY2RqQlLQeweTNcN0xSU56rzlCfTWagpR321pKTrqg+7xnjxlLZ9buOgYR5efXCptl1/JguELs+LB/LZvUlPP2H0aaYU9Cwt2iRa8a0oo1J+xLgTuyvm5bIprQmFkWUhQzCvTAroCrGzEFqjsHrvriLpeYxTzPaX69LRZpUcfabq8OtPbnWbS8dZy3H3MBDBSBWBWWH1fuOYp2r1fVJHe9/1H9dNn+IWMu9XYGkZFjqt/QAwABENAHjDwmfuh+xnasgCQ1jfPoHg28JtL/PXT3449GUPV2yW+aTzQKO8U8W3Zf4/4dx1H/6K/wN0DAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjIyKzAyOjAwo052XwAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNToyMiswMjowMNITzuMAAAAASUVORK5CYII="), + "do" to CountryFlag("Dominican Republic", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAR1QTFRFzNbr////+NjV2Tgp1igX1ikY1ikY1igX2Tcn99bT0NntEj+jADCcADGcADGcADCcED6iET6iztjs////99fU2Tgo1igX1ikYAC6aAC2aETuhztfs2DUl1SUT1SYUSWy4SGy4VXa93OPx+/z95+vx6+/0/f//+uPh5HFm4mZa+fr9+/z+3uXyorXQrbzSxMDKysvV7vH3//v7/vr6ydnUfJqunqi53JiJy6yp3Ojqxt2xlaaaw6y0wKevrracz+fDwtyvvpdp1oyLmYejdqN9x+O53eLKwqh72qCHv6GWpqh26O3d8LOt8LKs8biz+NfU+dnU8+Pa9uTb+dLN7ODmq7zfpLXcpLbc1ioZ99bT0NntE0CjATKc2TcnEj+jqOAFTAAAAA50Uk5T9/Xz7e3t/Pz8/v79/Pw+trfuAAAAAWJLR0QB/wIt3gAAAAlwSFlzAAAASAAAAEgARslrPgAAALFJREFUOMvt0bUWwlAQRdGHewKEENzd3d3d3f7/MyBQzUtDwaLKLmedqS4iIFKLBC9CkVgCITzU6akXA21kID78d2iCzBbrO7TZHRByQi63x+vzB4KhMAZFMNFYPJFMpTNZDKJwuXyhWCpzztywUq3VG80vwla70+31vwgHw9F4MuWGM2i+WK7Wm+1ufzhC6AQx9Jn9v1yJG4SwAYz3T/ggscn48EehFJLJFWyoVKk10BOl7H44XRu8uAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo1NCswMjowMCWZIUIAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NTQrMDI6MDBUxJn+AAAAAElFTkSuQmCC"), + "ec" to CountryFlag("Ecuador", "data:image/png;base64,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"), + "eg" to CountryFlag("Egypt", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAQ5QTFRF/zQ0/zQz/jIu/jMw//Hx//Dv+ujQ+ufP/u7o1tbW1dXS09HG09DD0tDB0tDA0tDC09DC09HE1dTRFRUVFRUWFRUU/wAA///////+/Prq+vfg/Pvv///97N2F7uKV8eak8+qx8eaj7+Oa692C/Prs+/fj4Mk83cQo4cpA9e2/3sYt3cMn38g4+vbe+vbc4Mg438Yx5dFZ9u/G4s1I3cQq38c0+fTX+PTW38Yy4sxH7eCN7N6I7d+L4Mg53sUu9/LO59Rj8+mw7d+M4ctE8eal8+mv5dJa/Pnq+fXa9/DK69x/4co+7uGS+PPV+fXZ+/jl/fvv/Pje+vXS+PDC9u23+PHD+/bY/fni/fvsAAAAZyyrpQAAABZ0Uk5T/v7+/v7+/v7+/v7+/v7+/v7+/v7+/sBIbWkAAAABYktHRBcL1piPAAAACXBIWXMAAABIAAAASABGyWs+AAAAo0lEQVQ4y2MQIxIwjCqkjkIMwMjEzIANsKADVjZ2DhZMwCCOBiTEJaWkxWXQhcXRFUrLyskrKCopqxBSqKqmrqGppa2jS0ihnr6BoZGxiakZIYXmFpZW1ja2dvaEFNo7ODo5u7i6GRFS6O7h6eXt4+vnT0hhQGBQcEhoWHgEhkJOVMDFzcPLxy8gKIQmzskgjAZEhEVFRYEkOmCIJBKMKqSOQgDjLcbGnZDVKQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNToxMiswMjowMC3BcbwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MTIrMDI6MDBcnMkAAAAAAElFTkSuQmCC"), + "sv" to CountryFlag("El Salvador", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAYAAABe3VzdAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAABCFJREFUWMPtl9trXFUUh799zpn7mWvGSS/TNEmNNCSVRFOsaMWoFaEPaisKPojV/8EXfVbwrYIgKIWCliK1hQrFikhRKCShJmnLtBJTe0vGmSSTmc7tzLns7UNLH8WTtFiwC/bbZu1vr7X3Wr8l9n/SUDzApv3XAA8BHwLeW3fizrp3ZtwbKNCwEcoBQIoQ6q7r9RWJdQAKQBJQVWJynghlJDoaDjVtB7pq45DA0jawnqgaao0XNKgTk/Noqo0UIWriMRySKAwkAeLyMknmEQzRFnkU+trOScWEP0QhCMhV4s4U6HFq2jBKS2IgiFDHEA0s1YVgDFc1yMorCDlDPTCKVP4hxc1lT/rYjvQckG281nX0WA9GMEm5ViYWiqGcJlZzmWiql45rkTYzSKeG3biKLU2iiTyaHsTPuxRK/fskK+lRKf6GbkQIx0wWFyY5v9JkbmmBN556i46VptmuY8bbnDx3gqHNA+zIRMmkt1KvlIiYOZLdj/uKoK8yo1AEgiaxxGau1lt8cOobTvx6kb1DL9HX3ctsa5bT9iz9uS3s3THOsTOTfHjqKH85Ecz0NlaKM9hW7f4B1ivzOI4FgSiFi1/j3rpBvvt1SqtZ5go/of3yLdkfT3L53HFsq4t0ch+LxQIXzh8iGMsQiefptFbuH6DbqaHcFrbncmh2EiM8Tk8qi66qHCm2OZ3eRTHXy2e3slQbZUY2ZzCMFzh8YRpPCxEMJ3A7/iLoqw4msoOAomo1iXhBnh1+GkkfVmCaY72PwFA/Nxt5JqJPsLN0kWiwh9GBEa6X5rDs9p0P4s98AVqNEtKz8UJdLHsNkmYbo1NlcuoPhqOHsIVJpz3AaKXFlJtn5+BNNmU7TNyo4ngOumcTimZ9AfpKsaaHsK0aybBJf3wL309/x9DGS0j3CvlGir5bgu3WIkNcIGzX2RIv8HPhONvT20hFk0TMboKR9P2LYCiaplX7E8+qMDq4i89/OMiZhUneffUdigsvUnczKAWmXiG3Mc/JwlEKi5cYf+VlnGYJt1MjEt/kC9B3oa6XZ5Dta8j0GAe+elOUrSJvj73Gc9mUygWzSKWx7FY5W6mKwxNHyce28uWBI8pbmUGPbCK5YcRXZxbvHWz6AhSyRsqZEJaeU7/XbVFunOVq4wv6k/sZyX2khNA4X/5UzK0eocd8n25zF8NxTQVUg4qxG7QIvjrJvo99Dk1CI6RKpL0ppIizRB9LnWsoTxIVPegiTEvdwGOFDeFH6dLKBGWRkjaOo2XApzoxhG8lJLFFjhX9GTJqmjTLiNjzSNnGdZoIdDKBJwmKNgk5i43Jqr4HVyQQKN/Ka416UOGKFEtiNwKJUg5CGASCybs7HKJUtDEUAW5TrU3XrUOwKhT6P+q823CsGQ7+f0PTQ8AHzx54wL8BjGG8sZiqLygAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NDgrMDI6MDAuk0uoAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjQ4KzAyOjAwX87zFAAAAABJRU5ErkJggg=="), + "gq" to CountryFlag("Equatorial Guinea", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAYBQTFRFTKAYT6MWT6MXT6MYjaTM3OvW4fDX4O/X3+3S3OfA2eOy2uOzppLP99fZ+9za+tvZ+drY9NXT2bm427y69tbV+trZ4jIt5jQr5TMr5zUsSoFyP5gKPpoAVGncSoByP5kHVWflVGjfVWfkPpkHPZoAPZkASoFzVWbkW2vnrLT0+/v/////+/fn7+Gq6t2l7uK17+O37N+r7+Ks+/jqVGbkWWrlqrPx+vr+/vz25eLS0M7PvMi9scOzysvJ5+LP/vz15ubmnLWcNZEzFI0TX6Jf5eblWGrlrLXy/f3/5OXkkLKQeJFrb5NjhrGH5ufm/v7+5+fnzs3Ou7Owtqypzs3P6enpWWvlqrPy+vv+/Pz84uLi39/fzM3NqZuSnYp+4+Pj/f3919fX1dXVysvLtq6pq5+Yy8vL0tLS3NzcVGfkWW3nq7b0+vv/6OnpxsjIwsTEyMvLx8rKycvL7e7uVGflWGXfnEV+nER+4CMd5CAW4yAX5CEX4yEYWmXdnER93iMfXpYxpgAAABp0Uk5T/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v6NeBQ9AAAAAWJLR0QrJLnkCAAAAAlwSFlzAAAASAAAAEgARslrPgAAAR5JREFUOMuNz2dTQjEQQNEFVMCCXcRu7MaCihV779gb2LA37D3qXzcJvDA4k+feT8nOmWQWiopLUEFpWTkOVlTiJBCkBIKUHOKkgCgpIUZGoZBV1TVmxSCXtWAxstpsVsufDMhlUnKKXeZwpqY5HfbEFCR19Q2NVNTU3NLqbWvvoAnFIfF1dnWLUU9vn79/YHBIC5UcHhkdG5+gekh8k1PTfDYzOze/sPg/DCwtr6yurQdMvt7Y3KJ0eycY2t0LBfcPtMtIR+lh+Oj45PTsXPfixeXVtRzdRG7v7iMPjxr49Jye4coUubKyc3Lz8qMXFSj3UuAujOX2eNTZCAz3+vb+YRYo98lMA6STEOMERDkOcY4B0jH4wjkG3z8ox34BWwca6rCG5yYAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MzcrMDI6MDDSHjJYAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjM3KzAyOjAwo0OK5AAAAABJRU5ErkJggg=="), + "er" to CountryFlag("Eritrea", "data:image/png;base64,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"), + "ee" to CountryFlag("Estonia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAACFQTFRFAAD/AAD+AADmAAALAAAAAAABAQEBCwsL5ubm/////v7+G0fY8QAAAAFiS0dECfHZpewAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAA7SURBVCjPY2AYfEAQC8CuUgkLYDDGAhhcsACGUCwAu0oKBdOwAOwqy7EAhg4sgGEmFsCwCgvArnJABQESX7dJCCjvGwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo0OCswMjowMC6TS6gAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NDgrMDI6MDBfzvMUAAAAAElFTkSuQmCC"), + "et" to CountryFlag("Ethiopia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAqxQTFRFKYwIKIwLKYwJKIwKLI0ILY0IK4wKLI4AK44AK40CGogGF4cIH4oDKo0GHIFFD3eDBnCiB3GfD3eAHoM+K40DHYkEGIcIiqYTh6UVk6oOcJ0hCnOWBmjVAGbYLHizInW6AGfWAWfWC3SQeaEakakQiKYV/8oj/sok/8sg9ccpMXu0F3K+b5N9AGHWZJCCdJZ3AF/aV4mOJHe3PoCr/soj/8si/MUh+8Uh+MQj/8sWaI+CAF/ZAGTRWImPPH+iip1rjJ1rInW1bZJ/AGnHAF7bfJd0/8sV/8Yh/sYi/8gd6L4vEW++L3ynNn6jL3uofJh0k6FknqZae5h1NX6kGHS2LHuqHXO39cMn/8cf/MUj/8sYu61PAGbQToeTvK5MnqNgsKxRdJV6jJ1slqFloaVexrJGRoSYAGfOzrRC/8oa/cUj+8Uj/8wWqaZbAGXQAGDaH3O4laFlmqNhCmjMFGnKu69Kh5xtF2+/AGLXAGjMvK1O/8sXuaxQAGrIZpCEZY+FRoOavrJFcZN9g5lypKhXTIaVX42JOX+hAGnK/8Uh/sUi/8ceLnuoZo+Fl6Jjp6ZasqtToKReUYaUGXS2SoWWJHWy9cIm/8Yf/sUh/8ch/MYk/84Wb5OBAGDbA2rEoKZad5Z5P4GfKHivmqJijp5qAGXMAF/dg5ty/84V/8Eh/sEh/8If8b4lLHmtDHPGU4ePAF3bWYyHM32jAGDUVYmOB3LKPH6g+sEg/8Ig8TQZ7zMb+DUU4DQkP1WYAG3WAG3XPIakIXy3AG7WAGvXTFGP6TMe9jUW7zMa7x0Y7x0X7Bwa9BwU9x8SqzdKW0+ENVifOFidYE6AszVE+h4Q8hwV7BwZ7yIY7SIZ7iEZ/B0O/hwM+B8S+B4R/xwM+x0P7iIZ7yEY7CIa6yIb////ZbFmDQAAAAFiS0dE47EGrooAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFqSURBVDjLY2AYBaQARkYmJkZmLBIsyICVjYGdg5OTg4OJjZUFFTBwIQNuHl4+fgFBIWERUTEuVMAgjgQkJKWkZWTl5BUUlZRVVMVRAIMaAqhraGpp6+jq6RsYGhmbmJqoIQMGMzgwt7C0sraxtbN3cHRydnF1szA3QwIM7nDg4enl7ePr5x8QGBQcEhoWHuHhjgSQFEZGRcfExsUnJCYlp6SmpWdkZuFQmJ2Tm5dfUFhUXFJaVl5RWRUVicvE6prauvqGxqbmlta29g50EzvhoKvbK6wnvbevf8LESZOnTJ02fUYnEmCYiQCzZs+ZO2/+goWLFi9Zumz5ilkzkQHDSgRYtXrN2nXrN2zctHnL1m3bd6xaiQwYdiKBXbv37N23/8DBQ4ePHD12fCcKYDiBBE6eOn3m7LnzFy5eunzl6skTKIDhGgq4fuPmrdt37t67fv8aGmB4gAYePrp+/dHDBxiA4QGRYFgpBAAoZOePTU0n9wAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNToxMyswMjowMIu2eggAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MTMrMDI6MDD668K0AAAAAElFTkSuQmCC"), + "fk" to CountryFlag("Falkland Islands", "data:image/png;base64,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"), + "fo" to CountryFlag("Faroe Islands", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAMNQTFRF/////P3+v8riADCagzBW4yci4CcjnjBJACyVoLPW+/z9/Pz++/z++Pr8vMjhADGani9JACyWnbHV+Pn8tMLeq7varbzbrLzbqrratcPeg5nHADOagzBVnS5IADCWbom/uMXfF0ChACmWAS6YAC2XACyXAzCXADumgC9X4ychmi1JADukAjGZAC2YnENfkCxMkzFPkjBPki9Oii5Quio32ygm2igmwyoziy1P5Ds34SQf4igj4icj4Scj4ici1igo1ygoNxdWNQAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAACaSURBVDjLY2CAAUYGJmYWVjZ2Dk4GLgZ8YFQhRQq5uXgggJeBjx+oUEBQiEGYBxOgmMiPz0QRUTFxMJCQlJKWYWWTlZNXkBDHBAyKSsoqEKCqpq6hyaalraOqq4IJGPT0DQyhwMjYxNTM3MLIEBtgsLSytoECWztTewczO1sbbIB4hURbTbRnRETFiQseogOcrCgcrOlxOCkEAAHTPL4sSadeAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjU5KzAyOjAwRE5AggAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo1OSswMjowMDUT+D4AAAAASUVORK5CYII="), + "fj" to CountryFlag("Fiji", "data:image/png;base64,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"), + "fi" to CountryFlag("Finland", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAADlQTFRF////jrnvAGHaAGLaAWPapsjy1eX52ej6dqvri7juFm/dDGncDmvcFW/dC2nc1OX52Of5dKnrAGDaX9TlqQAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAABXSURBVDjL7dG7EoAwCETRFTQx8e3/f6wzDqRiDFVscurbsABqIH6NE771sE0YRJw1TDEYkNXCYs2bAaS0YzKBnf4M3ceU+/fKPIc4r8rgRbqdv+5hk/ABSuILPw2ihQEAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NTMrMDI6MDDgPh/MAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjUzKzAyOjAwkWOncAAAAABJRU5ErkJggg=="), + "fr" to CountryFlag("France", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAACFQTFRFACZ/AymBABl3qbbU////+/z9//z8+7G58gok8xsz8xgwxtlaVAAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAeSURBVCjPY2AAAUZlVxcgSKmYtQoEGEYFRwVpKQgAg3q7n/McyNsAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NDcrMDI6MDDY2ztBAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjQ3KzAyOjAwqYaD/QAAAABJRU5ErkJggg=="), + "gf" to CountryFlag("French Guiana", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAACFQTFRFACZ/AymBABl3qbbU////+/z9//z8+7G58gok8xsz8xgwxtlaVAAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAeSURBVCjPY2AAAUZlVxcgSKmYtQoEGEYFRwVpKQgAg3q7n/McyNsAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MTQrMDI6MDBOEUSGAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjE0KzAyOjAwP0z8OgAAAABJRU5ErkJggg=="), + "pf" to CountryFlag("French Polynesia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAnZQTFRF3iAQ3yQU3BAA2w4A2gwA2g0A2w8A3A8A7pCI7o+H75CI7o+G75iX8JWR86CX9ZyT8JSP75eX75CJ/////Nqs9+XD27K3wrC18eDA/t+1//78/vv7/vr4+tOt9LZ69ZU72XU40QAF283S+KZV7n8g86pi98GM/vn3///+/ObO9bRy9H8J/b902IhZ7QAA1nd46KJU+Kxf9YMN9Kld/e7e//7+8I0y959Fw4Ze5pQ+3qSI8wAB7wAA1pN27ZpBwnhJ85k78Ysq//79/OjT9bBr9qA+ok1F14dE3ZZo8gAE9wAD2oRW4ZRIn0M78po59q9o/OXO//37+MWS73gA8q1awD896IpF6LSJ4Ccu7AAC3oxh76lovjY27qJO8HoD9Khb+daz9KZZ77NpyEE/yIlrzcWxwsvMrpOTuaOS0KiOxTcz6qdc9alc98mZ+8CE9HEA+Z8xz0pDinKAcHyGdniBfYmSd4GJkIWSzT409ZMi9XMA+rp5/v7+6uXi6821qa6ysS00rJisRoTJkqPIl6bJQnrArazCsSQopKOm68206ODb/f7/3+j1SnTAXZXaplhq6AYCwTUyXXChYHyvuzs56AkFqUZWXZXZSHPA2+X0/f7+/v7/7PD2gZrJSW+0aY/Fznx/bUh1XIbFYYrIcleDzHJ2bI3BRm617O/23+byaIjCPWaxOnbDWYrLTnO3THG2VYXHK2u+OWSxZIXA//z7/Pn6///95+v0gJjIVXOzO1+qUXS2V3i4OF2pR2iueZLF5urzzuP2Wo3PUobKUITJZZXT2ev67o+I6oyG9JSK/56P5omE4YWC2g4A2A0A3REA3hIA3iMUzvqPKwAAAAFiS0dEEwy7XJYAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFlSURBVDjLY2AYToCRSMDAhA6YmVlY2ZjZ0YUZOJABJxc3Nw8vH7+AoBAnJxeKFIMwOhARFROXkBSWQhNmkEYGMsKycvIKikrKKqpqwuooUigmaghramnr6OrpGxgaGZsAucgmInNMhc3MLSytrG1s7ewdHIVRVCIrdBJ2dnF1c/fw9PL28fXzDwAKYFcYKBwUHBIaFh4RGRUdExsXj+IhVBMTEpOSU1LT0jMys7JzcoFOwWViXn5BYVFxSWlZeUVlVTVQALvCGuHauvqGxqbmlta29o7OLqAAdoXdwj29ff0TJk6aPGXqtOkzZgrPwqFwtvCcufPmL1i4aPGSpcuWz10BFMARjjXCK1etXrN23foNGzdtXoliIGoUbtm6bfuOnbt279m7b/8Bp61bcEYh2J0HDx0+cvQYkIGWKI4jA04uzhMnT50+c+rkCSATRQoz4Z49d/7CubMYwtiywsWL2LLCcAIAa8yUOqaO+7AAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MTkrMDI6MDAvxiVGAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjE5KzAyOjAwXpud+gAAAABJRU5ErkJggg=="), + "tf" to CountryFlag("French Southern and Antarctic Lands", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAACFQTFRFACZ/AymBABl3qbbU////+/z9//z8+7G58gok8xsz8xgwxtlaVAAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAeSURBVCjPY2AAAUZlVxcgSKmYtQoEGEYFRwVpKQgAg3q7n/McyNsAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MDcrMDI6MDCzU16FAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjA3KzAyOjAwwg7mOQAAAABJRU5ErkJggg=="), + "ga" to CountryFlag("Gabon", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAADBQTFRFNqEAN6EAMqAARKYA8eIA/+gA/ucA/+cA/uYB/+kA7t8NEXWvAGu/AW67AG28////LJeFrAAAAAFiS0dEDxi6ANkAAAAJcEhZcwAAAEgAAABIAEbJaz4AAABESURBVCjPY2AYfEAQC2BQwgIYjLEABhcsgCEUC2BIwwIYyrEASgU7sACGmVgAwyosgGE3FsBwBgtguIsFMLzDAgZWEADDTRb4erT7RQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDozNCswMjowMOP2KMUAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MzQrMDI6MDCSq5B5AAAAAElFTkSuQmCC"), + "gm" to CountryFlag("Gambia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAACFQTFRF/6amjIzRjY3RpNuk/wAA/wEB////AACYAACZAZkBAJkAYwm0MwAAAAR0Uk5T/v7+/rpKSvwAAAABYktHRAZhZrh9AAAACXBIWXMAAABIAAAASABGyWs+AAAAOklEQVQoz2NwwQIYBlYwFAtgwArSsAAGQSyAoRwLYOjAAugniNVJSlgAdm8aYwEMM7EAhlVYwMAKAgBVI/8BRz5IwQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo0NCswMjowMOkzIdwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NDQrMDI6MDCYbplgAAAAAElFTkSuQmCC"), + "ge" to CountryFlag("Georgia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAMBQTFRF/////7u7/3h4/3l5/35+/wAA/+/v/+Xl//n5/5OT/zc3/+Dg/+rq/62t/2ho/xoa/5yc/8DA//7+/8/P/x8f/w8P/wUF/xAQ/2Bg//Hx/83N/x0d/7i4/9bW/52d/05O/+Li/01N//j4//X1//39//r6/6Cg/4CA/4KC/z8///T0/0BA/3p6/3x8/z09//b2/5+f/1FR/9jY/7q6/+np/6qq/2Zm/5mZ/729/5KS/zU1/+7u/+Pj/7m5/3R0/3Z2xZZBSQAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADwSURBVDjLxdNrF4EwHAbwLsOoFIUSIRVyySWXSvX9vxXe2f45p47jeF5uv9Pa9oxhfh+W43mOLQFR7Rn0eb7ewBDiRh3AZkuAUGg1KSZKbVnpdEnY7ShyWxIJqGq9/kCnoT7o9zSVgMaQM0djGo5HJjc0qMWtyRT+43Rmgc3YcwdCZ25XP0fXQ4v3LFcvuFoSg8hzGX9dK5G1/0+Irc32PWj3mtghYnBj4eo1w0HRgQfwS/tD0RUe9hQzVN5kj3QpjieTV8lSlK5ZeL7I1xsNb1f5cg6pxaO46CnEEdhMci96XPekes1A0izPs7QE/DYPxwQhkdcwJgAAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NTgrMDI6MDDiOUs2AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjU4KzAyOjAwk2TzigAAAABJRU5ErkJggg=="), + "de" to CountryFlag("Germany", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAACdQTFRFAAAAAQAAEQAA7gAA/wAA/gAA/wEA/xAA/9YA/+oA/+UA/+YA////X5h2TAAAAAFiS0dEDIGzUWMAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAA9SURBVCjPY2AYfEAQC8CuUgkLYDDGAhhcsACGUCwAu0oKBdOwAOwqy7EAhg4sgGEmFsCwCgtg2I0FDKwgAGlOyeEHSqKvAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjIwKzAyOjAwNNFndgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNToyMCswMjowMEWM38oAAAAASUVORK5CYII="), + "gh" to CountryFlag("Ghana", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAbBQTFRF6AAG5wAG7AAG6wAG6AEG5wEG7wEGyAAFzwAF7gEG5AAF+wAGbAADgAAD6hEI6REI6RAI8hIIJgIBPAMC9xII5xAI/eMc++Ec/+sd074YAAAADAkB4swZ/+kd//ge//kf//of+/Qe//8hiogRnJoT+/Ue//ke//wf//Me//Qe/PAe+Owd//ce//Ue/vQeOzgHSkYJ/vIe8uYc/vMefXcPHRwDMC4GMS8GLSsFKScFBQUBBwYBJyYFKCYFLCoFJiUEFxYDiYMQ//Ye/PMee3UOAQEAk4wR/vUe/fUeycEYJCIEBAMABAQAMC0G1s8a//8g+/Ad//4g8uwdV1IKAgIAZF4M+PMe+O0dnp0UBAQBAgMBAwMBpqQV//Yd/fQd//8fS0kJAwQBUE4K/PMd8Owh7+oh9fAi3NgeEREDAAABcXISbnASExMD3tof9PAhLoBFLn9EMYlKIlkvAw4IGFk1PJBIPI9IAw4JG3ZJG3VIHHxNCCQWCB4SHnNFIX9MGHJICSATIHlIIHhIIHpJHnJEFU4uIHxLIHtKH3ZHIH1LFlAwH3hIIH5LH3dHH3dI////gfZjOgAAAAFiS0dEj/UCg/kAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFUSURBVDjLY2AY5oCRkUh1TMzYVLKgA1Y2dg5OVgxhTJ1c3Dy83FyY4nxogF9AUEhYRJQfXZxBDA2IS0hKScvIiqOLM8ghgLwCkFBUUpaSUlFSVVNTU1dDkmTQgANNLW0FHV09eX0pKQN1LUNNXSMthKQGgyYCGJuYmplbWFpJSVnb2NrZOzjqGCMkkRQaOzm7SAGBKwi5Slm5KbhrYFWoqeGh5Okl5Q1S7CPl6+fvjKQORaGmXkBgULBUiBQQhYapByBLaTIYIwO9cKUIqcioqGipGP9wPRQphlgUEBefIJUoJRUplRSfjCrDkIIMUtPSM6Qys7IzpXJy81JRpBjykUFBYZFUcUlpWUm5VFFhAYoUQwUyqKyqrqmtq6+vq22orqpEkWJoRAJNzS2tbe0djY0d7Z1dLc1NyHIM3aigp7sXRPX29aBJoCvsxWDgUIgTDAWFADjaJV+3MAkgAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjQ4KzAyOjAwLpNLqAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo0OCswMjowMF/O8xQAAAAASUVORK5CYII="), + "gi" to CountryFlag("Gibraltar", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAIAAADRv8uKAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAABKFJREFUSMfFV02LXFUQPafuu69fz/SMnYnRSIwgAYXRjEQxoBJ0o6ioEAVFRMGPlaAb3SmSv6DuA7pU0FVcKQZ1o4gYMzHBJIZ8OcaEGae7X3+8e2+Vi04U40xPehSsxePxePecqnOr6talmeH/MPlfWAFk61hjKcEMJIDhC50bF4RrS21mZiTNjABEVvvtojfD59Ctf0V8GTr52wcfhuXfXaOBGC2pq9eveerJvzT4r6Q+/OJLqNd7R49OzM6WBw7c9O47i/v2nXn/PT/ZMDXtlTMPPjTz2KOHn34mv2Fr58cfG3Nz5fz87N69xfVbRngzMmJViMw//sTCxx8VU9Ox23MbN+787ttUlt/fs6vmHET63e6tn+xr3n3XN3O3dQ7+4KemQ7s1teOOHV/szxqNEcSjstpUAczcd99UXuTNZpHnmx+4v9iyJZy/IP2+qaom6fcG584BmLpzpy/qWbOZ5cWGhx/KGg2LcYT4a5dT7/DhpCoxUdg/fhxA/9hR6/XoRCgIsTc/D6A6NO9dVoupRoafjgLgyC0fRTwskt6x4857qpr3YeFXBcLJU7mZgDTzzqXjP1ftdv/0aea5aopZ1j9z2swwssbcnj17Vt5dsnvixJFnnxscOkRAiCgOZScs/Nr+fH9cXqZzaprEcXm5c+TI4PsD8JlTM+fY7S5++unk7TvyTZtMdcXQV04uU6VI98SJI7vuRVky96ZGwAComiq9x6WFZiZCmAE0gKSlpCHc/NWXU3Pbh1BXKjVFLMaJG2/c+uYbodNRkYyMAM02vPpK1mhoSkIIGWLwMzMbXn45Dao+KUAQie32xheen5rbbilxlYazRnJVnY4zcyCAjIRpvnmz5Z5mBgJwoAG1664TkRwgkBEEYr8/GnkN4l6rRSADKrOCTEkH/X6kFMNMgBXCEEIY9ANZJ7owDxjZb7VGI6/RuYp2e4n83ZRmyawwk6WlOtAzq0wJJLCWoi4uFSKLqmZoq3kRX5YYWVGrR0wCCJ2OkQJMiyRYAqqFBY2xIgrQgwmwmHpnzxpgwDRJGESqTmmXQMaMOCU4F9ptiNTAHJaBJlKeOqUxCKVGJiCRUVM8eTIBHizIACZhVZYWI0mIrEi/asTMMgAyGOTeJ+fUuSRSq9XCmbO5gT5LlASBzwpxdvrMhPfqnGZOnWQ+r4egKY3oIf+oYzOQsdU6+9rrWnZbn32Wzp8PWebMEuCBivRASoqGN6G0qsxJZZaTlZkHIikpyeTkzO7dpnrtnrcmtm0bnjd/k9pivIyY3luMamaw5uO7/5wuhg2EgMGYXGq26VQuNDWLBA2QYYcZwqhpu5WqYClhOLSojoz4SswM5KB1zHRQNG+BKTj27MYLb7+zMnhKqy8ylN5mzyNLPLgZEwG2avbSuYtaXfb9YJaP6SoswM+CW3Oq6bkQfgD9CtCjLcs2bRqbeAC3gcXkIKqrGj7bqKyNT3x5cl2JeYSvTR+pWV30mz6vpoWxMdYzV0PBSQx6Obvmi4tT77g2/k1CKAPt3DwTHr3KMa2PdV3EBohZicGSt4zjbu2fNr7UZurd9C+L1Qe9RLgc67v1/QETyouHxE7rGgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNToyMyswMjowMAU5fesAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MjMrMDI6MDB0ZMVXAAAAAElFTkSuQmCC"), + "gr" to CountryFlag("Greece", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAK5QTFRFO4X2pcf7psj7o8b7pMb7H3T0WZj3Wpn3V5f3lL36/f7/////6vL+baX4WJj3W5r3AGHzAF7zWpn3/v7/////4Oz+H3T0AGDzAWLzAF/zW5n3AFvzWpf3H3L0AF3zW5f3WJf3lb36/v//6/P+bqX4WZj3dKn4pMf7AmLzAWHzpMb7AWDz+/3/5O7+nML6IHX1G3L0OoX2HXP0ZJ/44ez+Wpj3H3P0W5j3/f7/HnT0fFGBNwAAABB0Uk5T/v39/v7+/f7+/v7+/v7+/vURJdcAAAABYktHRAsf18TAAAAACXBIWXMAAABIAAAASABGyWs+AAAAzElEQVQ4y53R1xKCMBQE0LV3BRKMvXfFXv//x0wy+hIvesfzwOzDApMsPMMPhAzryvsC/xcbNLfYRCJJcot+S0gSfKPd0cVuz6R+XDEwBsORHE+mOk1nqTQJwhrpd2yQ88WSBPcXq7UiIbTGUm4iE6Ltrk6Cfe4nQkaHo0mn8EyC/W7vok99bZp0izu1e4/BXZDcospkaR9bK5/mLhMLOSNfKJbKlarNNdprGfFeRo9Eg2R6LfMbHkxQTGgwIcnEPzW7mGbCkgkeE7v4BBtYYvXw4HRMAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjQ3KzAyOjAw2Ns7QQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo0NyswMjowMKmGg/0AAAAASUVORK5CYII="), + "gl" to CountryFlag("Greenland", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAQJQTFRF//////7+//39//z8//v7/vv7+97e+MvL+c7O/Ofn+93d7XFx5CQk4AUF3gAA4AoK5TQ08Y6O/fHx8YuL3wcH3QAA3gEB3wAA3wEB4hwc9rm57GZm3AAA3wMD4AQE3wIC85+f74KC4AYG9729+c/P3wUF5C0t/vn56mBg86Ki/e/v4hkZ6E9P+MjI4h4e/vj4/fLy9a6u4AkJ4hcX4hUV4RIS4yAg/vb2/fDw4hYW6lhY/e7u/vT0/OXl5Ckp4RER5TY2++Dg4Q8P8pyc6lpa7nl5/vr65j4+8ZOT6ltb7W1t/vX150BA8IiI+tbW+MbG7Gpq4AsL4xwc5TAw5S0t4hQUVuhhJwAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFRSURBVDjLzdLZVsIwEAbgSdLiHhWZJippXMAFFAq4UBX3fV/f/1UM9JyeFEq58cL/pjff+SedBOB/hFBGyWhGnUi7IywDcHNj4xMECMuaymByanqG89m5+TxkSAoLBfSElMLDxaXhksJyUflaCiGVz/nKMMlgtbhmVBSlvfV0SaFUlrEzkm9sAkkt3EJfWPFxe6CSEEKhUhVKWvFxBxySSFS4i5Lb0Vir988OgqACjWZrL5H9g9xhO7ADYRhWm0fsOG+nfdI5PWuFdsAMUnjeN4fCRYF7idOAOboWlx2g9sldaKAvE4He3vAKHLvRgWtUIpEe1GbBhNh7LZWFTIGm8gZuY8kIu0Mt0qDQeA/M7T5vwlwgD/2DY2g6H5+iXyeQex50MZQKay+vdXMBb+8fKS6GptND9fn1/cNRpjgLCu33Ltx8RDbsWq1T1QDMyN/DX8xHSUJAyGAPAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjI0KzAyOjAwwJ5DZQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNToyNCswMjowMLHD+9kAAAAASUVORK5CYII="), + "gd" to CountryFlag("Grenada", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAIAAADRv8uKAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAABFhJREFUSMedl12IVVUUx39r73PuOHnHvDmjmSjiqEUmlvTQx9g3pGVRmNVTJIEi9hA9CGn0UCBE9RBEGCQhaR9EPpQTFaVPYxYkYRLazbK0sfHbHOfOvefsvXo490x3uufccVps7j13r3XWf33ttdcVJZ9CMFDN4Qq0wXD+6+1QBZ/NNNkagTa4Dx6DYsPmCFlYAE/B9CZWIjwVVsGNYHPM0uYlKGg72ov+gF7VsNko8Bx6Br0fBTUN3OS5Bx1AX256N11Bti1AFfcKtg3ONXlswMHnUIYDKfc/fh9GV6P9mSEFkNwcC4BTTFYs6wKafjZRklkjDZ5cIvAQ9K7nkUXoUF3FKEkFk7reZI9TLJwr8vVOVmxHDdJUYhmhTty4TFhf4ovpvD0Nr3hNzR+LnGItlYhlJyiVWAE+q8KCXAVKscaWMmePs62bdsF57FjYsRJYjlZ5qMw+eDTOlczLPQqxQBs7znFHmb88NiSWNMJZKxKCAt9XuKnMvgoUyMfNB06wUQoh3w1y80EOVAgCYs2WjJQwZOdZbv+Z/hptQZqzcQOnnFixAUeq9Bzkq/MEIVFyEh048PXHMGTzAA/8QsVjLHFL1JbASUbTQ2Utf3uWltl6kjDAG5gMnfW+Flg2HmXtEawBwStjFmJTcSXnsgsm4obB1VW4tKqfPMzvMS90wXvoIeQ2hntYXWbbSYIQp+hYkDkeCwI6C9nBq0tYXkRT432StYAX+/lxDbxEdAie5oNNbLtIwY4DNTfUojCBZSU+XczjV4CrHyTxaDv37Gfhr/hnCDfBCh7cxdTT1ALGAZvpMcBUdDLxOviY66/8N+ACCKUIzqMz4VYo0nGKiQ7M2HltCZxYvR85hSxm7/v0DYJBFcALVNk9lzNF7HbcvdDHnnn81kkQ4ceD3ATsQaAflvP63SxfwydHkAAHkjT9YVYuYPKbUMHsh1kseoNlk4gjQhmH01m9WhFBj7LlJ053Yyu4BFKJPa/N5tkudAZ8iLmITqJUo7fEWuGtAYIAd2m5zunVihhsAA4FKzhPm/DuHFZ2EsfYIRAIkQt4UMPm2cws8PwxrK3f/OMM9Qi0xylAIDhHV8Cu+azsJIoIQJJb2oHBGAzEMRtnsHUOKJo0H/1fwHUSajHXTGDP1dzSUU9kI3fkOxCiiCe6+HIel1tilzsjjA0cAjXuLNI3n7kF4hqBgs9doRJXuauDvnl0hxC1uHTzWSJcsDw8i4+mYwWvrbQ0qnPKtVP45gZ6Bhg0rSSbowswpGwYZlUNc5BYsJkDclYwDUTKFGF3O59VcqMqrSrA4jyi+cNeQjnDnggmaygbsS9XqZ+G7caASH1+HbVCZCGiWVzBglyHn5DvVe5APwV9B+1F54we2SX9uQ79Fl2absrogX4JuhfdgIbZM33+QH8a/oAKHB8dTwULDgbgRMqVphL4E45BP0Sp/KXmOIACJOcn839bB9QghMEs7kSIoQAXstX/A5wl0MI5RvbRAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjM2KzAyOjAwdGk57AAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDozNiswMjowMAU0gVAAAAAASUVORK5CYII="), + "gp" to CountryFlag("Guadeloupe", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAACFQTFRFACZ/AymBABl3qbbU////+/z9//z8+7G58gok8xsz8xgwxtlaVAAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAeSURBVCjPY2AAAUZlVxcgSKmYtQoEGEYFRwVpKQgAg3q7n/McyNsAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NDcrMDI6MDDY2ztBAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjQ3KzAyOjAwqYaD/QAAAABJRU5ErkJggg=="), + "gu" to CountryFlag("Guam", "data:image/png;base64,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"), + "gt" to CountryFlag("Guatemala", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAvRQTFRFAGb/AWf/pcn/////7e3t+Pj4pMj////9/Pz8bW1utLO0///+o8j+AWb4dKXMtcm28/f09fTyVVlKQU1FxcbG0NvPdqXEBGj3A2PDPn5wZo1s0dfT+vr7/f38/Pr3s5N/SE4xPFRFv8C/+/v76Ojogp+HTohxCGW6AWXpBWKxdaK03ebczMzNsa6duK6A5tiT5NCIvalfpKlugIJ8oaGhysrK0d7SV4+UB2KnAWXnAWXrBF2lQIB91ePV//7/zsWYoZJKw7FcxLNeyLZg1MmUra2slJSU8/Ly7fPtTomBA12dAmTQAWXqA12rhbC9/v778+3N3cpv4c1s4s5t489t2ch38Ozdr6+wyMjI/v/9eKagBFuJAmTSAGb+AmTXBmCWpcfm/v357eCh49Bt5NFv5NBu8+eswcC/n5+fh7G0BltpBGK4A2PGpsfb/f399ff59vDc3MNy07Nez6xb0K5c5tJ+rauekJGSl7uyCFxQBWGjAGb5A2LDBV2ipMTJ/v//6erls6l/t5pV0a5b2bxi4c50iod1qamqpcbSBV+kBWCYAWXxA2PLBl2Gkbex6N7Vm4tYuKtl4tOC4dSL59mWwqh0eXRv09PU9vr2a56YCFxqBWGZA2TPCV5sYpZ94+3k9Pj4zMC/4dbO8vDlx83K0NbX/v79xrOxcWlo9Pb2ssy2KnJcCF1wAmTRAWXyBmTFaZuomLGWu6ej6Ozs5urt3OHl1dvg6OzunZ2emZiZvq+oqsOtU4qCB2CGAmTWAmj8Y5SzbEw2hG1b4+re2N7a3eLm/f3++/z8sbe7cHh1pLWgdUU2jXlnQYGBAmXlAmj/V1WCdz8ve5h2s7uJhqBx2ubd4ODgjZGNf49lg59kXWhHZh4OS2R9Amj4hJXJtrOjo76gmLCHhqqMzdrQ6urqx8bHnaefdJp2iKJwcptxqZGDkafc/v76vNLAkraay9rP+fj46+vr4N/f2+Hchq2PgquLqsaw/v75+vz68fby8PXx8fXyWpUoygAAAAFiS0dEAxEMTPIAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFqSURBVDjLY2BAAoxMzEiAiZEBFxiOCllYCSpkYwcq4ODkAqnj5sGtkJePX4CZWVBIWASoUFRMHKdCCUkpaRlZOXkFRSVlFVU1dVzqNDS1tHV09fQNDI2MTUzNzC0scSi0sraxtbN3cHRydnF1c/fw9PLGodDH18+fOSAwKDgkNCw8IjIqOga7uti4+ARm5sSk5JSU1LT0DObMrGwcJubE5zLn5RcUFhWXlJaVM1dUVsViVVddU1vHXN/Q2NRc1NLa1s7c0dnVjd3qnt4+Zub+CRMnTZ4yddr0GTNnza7GrnDO3HnzFyxctHjJ0mXLV6xctXrNWhxuXLd+w8ZNm5m3bN22fcfOXbv37N2HK8T3Hzh46PCRo8eOnzh56vSZs+dwRuH5CxcvXb5ylfna9Rs3b92+cxe3wnv3Hzx89PjJ02fPX7x89fo8ToWMTG/evnv/4eOnz1++fvuOP+H++JkHSoy/fg/yzEUnhQD28oLfgbT3NgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo0MiswMjowMIrjFOYAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NDIrMDI6MDD7vqxaAAAAAElFTkSuQmCC"), + "gg" to CountryFlag("Guernsey", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAKVQTFRF//////7+/e/x6iI85wQq5wgv5wku6SA86i8l6zkq6zMp/vHx6Ro97U8i+d8X+d8W6iU75gAs8Xoi+ugV5gAr8G0k8HEj8HAj//39/e7w/vP0/ODk6iQ66iU86Rkt5wYu8HEi6A0p6A4p5wUq5gEr5QAx72cj+ukV6BIu6BQu5wkv6zoq+d4X8Xsi8G4k9KId+uMV6BEt6BMt+d4W+dwW7U4i6zIpl5NLTgAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAETSURBVDjLxZRZj4IwEIBrUUAOBYZDFIUVBS8Uz///07bHYjC7hkl82O+hybRfOpmmM4S06RGq9AeqOugrlAXvYaKmDw1jqGtdomnZo/F4ZFtm142O6wF4rtOZ2vEDgMDHiCFAiBIjgOgTsddmQuJGjMnk5Qh/I5WYYo2ns0SKyWwatw4oJYpAsxzBPFmkGUCWLpK53LE0aZAvxjLXbXflC9J1UZbFOpXRyrX1fMkdsmFsd/tDdQwjTlac6vpUZCIIj9Vhv9tyh5wZF9W4QkNZ3251+QyvhnrhDl5sUnvBX6kD75n6p5j7u2LuTTHo50E/+D9+ig9EdCtgm8utAKrudsUPADZSHg/ESKFKzodU/mtIfQOArTGdPqeFsAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDozNSswMjowMEWBI3EAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MzUrMDI6MDA03JvNAAAAAElFTkSuQmCC"), + "gn" to CountryFlag("Guinea", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABhQTFRF/6UApNsA/wAA/wEA//8AAZkAAJkA////MYVkGwAAAAJ0Uk5T/v6mqd4QAAAAAWJLR0QHFmGI6wAAAAlwSFlzAAAASAAAAEgARslrPgAAABpJREFUKM9jUAIDAxcwEE0DA4ZRwVFBWgoCADuSl4cKLQ/UAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjQ3KzAyOjAw2Ns7QQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo0NyswMjowMKmGg/0AAAAASUVORK5CYII="), + "gw" to CountryFlag("Guinea-Bissau", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAQtQTFRFfD8pfkAp6AAG9IIT//ge//Qe6QAG2QAGtAAF6wAGrQAEUAAC4AAG6gAGcgADEgAAvwAF3AAGNwABAAAAhAAD7AAG5AAG5QAG5wAGsgAFDgAAQwAC3QAG4gAGsAAFVgACSQACSgACLgABCwAAPwACRQACbwAD0wAF9YIT4QAGkgAEHgABAwAASwACwgAFRgACEwAAfAAD2gAGTAACBgAAkQAE6QAFrVogdqw4eKk3RAACAQAAiwAE6gAFGHhKG3ZJwAAFFQABGwABQAACCQAA4wAGHHpJH3hIiQAEAgAAOgAB3wAGGgABGAABxAAFVQACZAAD1AAFuQAFQgACjwAE2wAG1QAGtgAF////yn7lywAAAAJ0Uk5T/v6mqd4QAAAAAWJLR0RY7bXEjgAAAAlwSFlzAAAASAAAAEgARslrPgAAANdJREFUOMtjYEIDzCysWAHDMFTIxs7BRpRCTi5uHqIU8vLxC3ASoZBNUEhYRJSAQjFxcXEJSSlhaRkxMTFZcZwK2eTkFRQVlYSFlVVUVaXV1DVwmqippS0MBTq6enisZuMU0NcBqzMwlOHF6xlOI2OQOhNTXjYmM3MLS6wA7GtZK5BCaxugv20Z7OyxApBCXgdHYSdnF2EFV6BCRjd3rACkUNTD04vD28bH148Xv0JZ/4BATjbeoOAQTrwK2ULlXHlBfgoLl8BvIhMvNAmxEXAjMhhVSGOFALoCgvS7rw2DAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjE5KzAyOjAwL8YlRgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNToxOSswMjowMF6bnfoAAAAASUVORK5CYII="), + "gy" to CountryFlag("Guyana", "data:image/png;base64,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"), + "ht" to CountryFlag("Haiti", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABVQTFRFJChtpwYgEyx3Eix4wgAQwAAR////GpZHgQAAAAJ0Uk5T/v6mqd4QAAAAAWJLR0QGYWa4fQAAAAlwSFlzAAAASAAAAEgARslrPgAAACFJREFUKM9jUMICGEayoDEWwIAVCGIBDC5YAEMoFjCSBQF914N9eJyLmwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNTowOSswMjowMONsJdgAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MDkrMDI6MDCSMZ1kAAAAAElFTkSuQmCC"), + "hm" to CountryFlag("Heard Island and McDonald Islands", "data:image/png;base64,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"), + "hn" to CountryFlag("Honduras", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAOdQTFRFCHvOCnzOAHbMM5LXM5LWMpLW/////f7//v7//v///P7++/3+q9Lu1Oj24O/5o87t/P3+qdLuCHXMP5XY4/D66/X7TZ7bAnHKm8rr1+n3TqDcfLnl1+r34vD5hr7nSp7bzeT18Pf8+v3+8vj8+fz+xuH0UqDc7/f83u348ff84O75HYXSPZXY9vr92uv4x+H0Tp/be7jl5fH66/T74/D53u759fr96vT7isDoRpravNzywd3yAHHKRpjZ/P7/VKDcAG7JtNXw5PD61en30eb20ef21un34e/52Or33+752+z4B3vOBnrOQDK1/wAAAAFiS0dEBmFmuH0AAAAJcEhZcwAAAEgAAABIAEbJaz4AAAD1SURBVDjL7ZJZU8IwFIWD0HMT6lJEETGoVHBBRYWKsom7LP3/v8eGhmDLjMMbD/A9JGfunHtPMnMZW/MfiQVhGwvCklNSlpWMYVkpoxkMxBFDpGfaGG1sbgmtedhC2zuOHTMKQmY3uweaGCgd3IT93EEeXEQnEg4LR5hM4pBFpQjHJ6dh699olNyzcuirZM+lcrol52L+jRyXV1pUr2/KUIm3NfA5o7i7f6irukDDe2yqhqfnVtsxRgqx0en23OAXCiGC48VB//UNtjYwk/z+8Wnade3r+8dks4FG1opVOYggh97IlGbbMfb9+ML4/njZO7u6/AJNHh7awTqMIgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNToxMiswMjowMC3BcbwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MTIrMDI6MDBcnMkAAAAAAElFTkSuQmCC"), + "hk" to CountryFlag("Hong Kong", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAadQTFRFugAAugICuwQEuwICuQEBtQAAuAMDuwMDuwEBtwAAvxkZ4Y6O5qGhvAcHuQAAugEBuAAAwiMj9+Hh////9dnZuwYG6rKy8c3Nz01NxCMj/vv7+Ofn8MfH12xssQAAtgQEtgAAvQ4OxSkpvQoKswAAyj8/9dvb+u7u4pOT3oWFuQYGxCUl+uvr9dzc++/v5Z6eyTs7+enp+u3t8MbGyjw867S0//7+//3978TEvRMT/PX19t7e3oqK5qWluggI5J2d+uzs7b299NfX6a2t9NXV/fb27b6+7sXFvyAg34eHxi0t1mlpyDMz67e389LSvQ0NzEdH/PT01GFhxSgoxi4u1F5eyTY29tzc5Z2dvhQUtAAAzEND+OXl9draxCYm7Li4/v3934iIuQICtwEByDQ02nd3yTg4wRwc7Le3xjQ03IeH+/Dw3H5+uwUFvAsL67a2/vr6/PPz0FJS9+Li13Jy+OTk0FFR9+Pj9NbW7sDA7bu72XZ2vAoKxCQkzUVF2XJyuAEBzUlJ+ejo8cvLwBgY0FNTzktLvxMTvhUV89DQy0FBuQMDvhYWXZk81wAAAAFiS0dEEwy7XJYAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFPSURBVDjL1ZPpOwJRFIfvdEsNmnt1LKMs16CsIWQZOyERyRpC9l32fd/5o/E8fZyZ+tr5/D6/85zffS9CSTmcjkuIw3pDijEBzsSnpqWbBRI3j2ZYIDMLaYMcIpjPhhwQebPOqM4KFHFCrtWWB/kFhQbGqZFCkSQUl5SCHRySWFYuVlCT8l5aWVXtrKmtc9U3NIK7CZpbqGIm5iVolaGt3dLRCV227h7opVgJJIj0efphYNA75BseAQ/4faPKLRnZGATsnvFgcGJyyjs9MxtSuwazOdk9vyCGpcWlZcoiOvW2V/Sra+sbm1vbO7DL9tQLJ2T/AA6jziO/1XGs9Yy60AmcuizyGZxfQFj55ljiJVwF4Pom6pDhVh3E/F0AIHr/wD8+wTPSEIPQl9e3dwOH2cfnF6+++Z9kTPizFn//UG3RSMwuEknsOyAU1/Cknl9sPTONe9hDGAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDoyOSswMjowME6LSZsAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MjkrMDI6MDA/1vEnAAAAAElFTkSuQmCC"), + "hu" to CountryFlag("Hungary", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAACdQTFRF1DYX1DUW0zIS10Il/PDu//////7+/v7+8ffuRpURNYsAOY4BOI0Atgdb1QAAAAFiS0dEBfhv6ccAAAAJcEhZcwAAAEgAAABIAEbJaz4AAABCSURBVCjPY2DABgSxAPoJYgVKWACDMRbA4IIFMIRiAQxpWAB2lRQKlmMB2FV2YAEMM7EAhlVYAMNuLIDhDBYwsIIArGfvEVFLwBQAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MzUrMDI6MDBFgSNxAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjM1KzAyOjAwNNybzQAAAABJRU5ErkJggg=="), + "is" to CountryFlag("Iceland", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAFFQTFRFADiXBDuYACuQVXi3////4W5v1R0dBz6aAC6SV3q4WHq4BC6SAB6JVXCz4W1vSnCzjaLL4m1u1R4e4m5u/vz85HBw5XV120BA1iQk1ykpjqLMkEWlzwAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAACQSURBVDjL7dLRCoQgEAXQUccprTR1K9v//9ANwgqURdinYs/LvFy4zChAwrhASSRRcAbf/IM/BVnStGoP6rZhOeBJ1w9oiAwOfcdzIBJlR3TeBxytEjnA0wsnomkbJSAPxs1LjMvsjCwAOnmK6xq3UVIfvFSHvTqUq6uXOfbX6Txvq0vnqT549RPe4T8+KfgBgwQOT3egtFcAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MzIrMDI6MDCAJh3/AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjMyKzAyOjAw8XulQwAAAABJRU5ErkJggg=="), + "in" to CountryFlag("India", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAqZQTFRF53MA5HIC43ID53MB9XcA+3oA9ngA53QB83cA6XMCpV8oX0hPR0RkSUVlXkdPpF8o53EA428B9ncArmIkL0OAG02vZo3TfJ3agqLcZYzTJFSzLkJ/6X0R6X0S5XsS+IQOl2E+BDqjgJ7X5eny5enz5uv05er05OjyjancCD6llmE+/fXu+/Ps///zvMPUCDefqbre8fP32ODwyNPpwMzmwc3mxNDo1N3u8fL3v8znEj+kucHS/////v//NVuwf5bK9/n7vcrkma3WgZnMf5fLlKnUusjjzdfr+Pn7iZ/OOmCz/f7///7+/Pz9tcPgGUWh4efz2eDwvMrkf5nMXH2+aojDa4jEW3y9gJnMuMbi6u/3Jk+ms8Hf+/z9aofDXn2+9ff70Nrsm6/XXHy+jKPRxNDnxdHol6vVWXq8kqfTz9ns9vj7co3Ga4fD/P3+UHK5dZDI8fT5w8/ngpvNaIbDxM/nvMnku8jkcIzGfZfLws7m8/b6iaDQU3W6dI/H8vT6aIbCu8nkucfjydTpepXK9Pb6UnS67vL4ztfrmKzWWnu9kKbTmK3WW3u9kqjTy9Xq8PP5cY3GbIjD/v/+GEWh4ujz1t7ugZrNbInEfJbL7fH4JlCns8LgOVuxfpbKzNbqlqrUfpbLe5TKytTqj6XRPWCz/v7/8fju7vXt/v/zssXUCTigs8Hi8fT309zuxtHo0Nns7vL2wMznFECkr8LT///0QJkUQJoUPpcVSKIRKHVADDqki6DY4+ny4ujy4Oby4ejyl6ndEj+mJ3Q/LpAAL5AALI4BNZgAJHomD0iAJk6xd47Uip7bjqHceI7VLlW0LY4BM5IEM5MEMZEFNZcAMpMDIXUqDFZQDE9lDlBmDFVQMpIDNpgAOJsANpkAOZsAMZEGMpEFwJ5XlQAAAAFiS0dEPKdqYc8AAAAJcEhZcwAAAEgAAABIAEbJaz4AAAGtSURBVDjLY2AY1oCRiRGICCtjZmFlY2NlYcZQyo4CGDk4ubh5ePn4OTkYUWUYBJCBoJCwiKiYuISklLSwkCCKFIMMAsjKySsoKimrqKqpq2toasnLySJJMmgjgI6unr6BoZGxiamZuYWllbWuDpIkgw0c2NrY2tk7mDk6Obu4url7eHp5A4XggMEHDnxt/PwDAoOCQ0LDwiMi3aOiY2x8EbJIJsbaxMUnJCYlp6SmpWdkZmXn5AKFECYimHk2+QWFRcUlpWXlxhWVVdU1tUAhHArr6k0jGooam5orWkxaa9pwKIy1yY1v7+js6k4t6unt658wcRKK1ZPhINbGb8rUaeXTw0NndM1sMp81e45NLEIWJXhs5s5zmF+2YOGivsjFDkuWLkMJnuUIsGLlqtVr1q5bXxZUumHjps1btq5AkmTYhgDbd+zctXvP3n1T9x/Ye/DQ4Z07tiNJMhxBAkePHT9x8tTpM2fPnT954viFo8hyDBeRwKVLl69cvXb9xs1b125fuXzpErIcw21UcPn2nbv37t2/A2SgAnSFQKUPHj58cBlDGFMhDjAUFAIALMfjyKVz+egAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MzQrMDI6MDDj9ijFAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjM0KzAyOjAwkquQeQAAAABJRU5ErkJggg=="), + "id" to CountryFlag("Indonesia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAA9QTFRF5wAR5wAP6h8u/ODi////32xIVQAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAfSURBVCjPY2AYBahAEAtgUMICGIyxAAYXLGBUEA0AAKSuUllCEXddAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjQ4KzAyOjAwLpNLqAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo0OCswMjowMF/O8xQAAAAASUVORK5CYII="), + "ir" to CountryFlag("Iran", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAnxQTFRFI59AJJ9BJaBBJKBBIJ49Hp08HJw6H508Hp07HZw7H509HZ07HZw6IJ09XbhyX7l0V7ZtVLRrYbp2X7l1XLhyVbVsW7dwU7RqXrlzYLp1Xrl0WLZuUrRpYLl1X7hzXbdxVrVsYrp3VLRqWbdvWrdwUrNpUbNoYbp1WbZvg8mTesWMm9OodsOIicuYfcaOhsqWltGkdcOHjs6dk9ChecWLjM2be8OKhMuWhNKcf8+Ym9Wqcb+Ce8WMiMuYks+gdMKGj86eldGjh8qXesWLisyZeMSKnNSpeMSJhMmUg8mU9fr27/jx+fz56/bu/P787vjx9vv39Pr17vfw7Pfv+fz6+Pz57ffv+vv57f32+PDu7dTO7NPN9vLu/Pz79fv38/r08Pjy+/387Pfu+v369Pr29vv47vjw+v378vnz/////vn5/Nja/ezt62Zn7Glr/e/w/NjZ/v/+/v///v7+7o2N6319/fDw6Wxs6Wtr6359//z89La26GZm7omJ6Who7oqK/vv77YSE75CQ6W1t6mxs75GR75KS8Z+f5ldX63Jy//7+8aCg//39+M3N6nBw75eX7Hx875aW+MzM9LCw+NDQ5U1N4TQ04S4u5U5O+NHR/fPz86mp3BAQ3A8P8qam/e/v/e7u/vj4/Ovr/vr6/O3t/fX1/vf3/Ozs++Hh+djY+dbW/fLy/vX1/fHx6GFh51xc6F5e5UtL6m9v51tb5lVV5lZW6m5u51hY6GNj6Wlp51lZ6WZm6GBg5lJS5UxM6GJi51pa5EhI5lBQ6GRk5U9P6WVl5lNT5EdH5lFR5EZG511d5UlJ2gIC2gAA2gQE2gEB2gUF2QEB2QAA2gMDJB6gxgAAAAFiS0dEabxrxLQAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAIBSURBVDjLY2AYkYCRkYmRkZGZGUYwAQlmJmQeWAEjAwsrGys7CwcnKxcXJzcrCzuIx8oDJDhBQjwcECFedgY+fgFBIWERUTEhfjFxCUkpaRlZOXkFcUV+ESVlIX4VVQlJCWk1SXUNBk0tbR1dPX0DQyMdY10TUx1tM3MLSytrUxtbO3sHQ0cnZxdXN3cPT2cGL28fXz//gMAgv+AQ78DQsPCIyKjomIjYoLj4hMSkZO+U1LR03/SMDIZMNJCVnZObl1+QhS7OUFiYCYJFYKqwOLOktKy8oqyyJLMYIlMIlUE1sSqzuqY2s6Ius76mGshBMRGF15DZ2NSc2VKX2dzaCOTgU9jW3pHZ2dLV0d2GV2FPZm9TX3/jhIl9TZOAHBSFXV2ZQNgFpXoyJ0+ZOm36jJmTM3tQZTCCp2rW7Dlz582vQhdnmLVg4aLFS5bOWrJ40cIFs5YtX7xi+cpVS1Y0LFm6en7Woqz5s9YsyVq0sGwtw7r1GzZu2rxuy9Zt23dMXbdz17qN23bv2DCjb/OevR1AoX37dx9Yd7Blz3aGQzMOH5mxd+/RjcemHthwcMu+/Xs37p1x+PiJQ1v2n9yy79SB41un7pixb8tphjNnz505f/7shYtnzp45dwnIu3z+/KUL54HgwiWYEEgBw1mQGJw4exaZdx6Jx3CWSDCsFAIAhAz8FIr+BqwAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MjkrMDI6MDBOi0mbAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjI5KzAyOjAwP9bxJwAAAABJRU5ErkJggg=="), + "iq" to CountryFlag("Iraq", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAhxQTFRF8wAA8wMD8gAA+6mp+qmp/////f////v7/vv7/fr6//z8/fr5/vz8/P38+/n4//3+7/Hu5+vn/vv6/v/+/v7+/v//8vb0nb6r8/f1+/381+TcvdPG/f7+6vHtydvR/f793OjhMndOg62UydzR0eHYzN3T9/r40+LZ3eji3+rj+vv6wdbK9Pj1r8m4UYhl6vHs/P39OntTvtTHssy81uTcU4pmrMe2+fv6udHDXZBvtcu7n7+shauRbZt9vdHD7/Xy2ubfPHpS7vTw6/Luapx+D14uBFYjMHZNwNXJ/f394+zmcp6Bcp+CyNnOM3dPBVckDl4tZJl6fqqQOndOW5JxvNPFlbeilLehZJZ3yNvQhq+XGWY3A1UiH2o9ocGu8vbzHmIzAEIJlrWe+vz7+/z7gKuSSIZhxtnNlLagc6GFytvQnbqlAEMKGl8v7PLtzdzSKmk8V5BvYpd4xNjMmLmjpsKvaJt80uHXSH5YAD4EY5Fw+/z8ydvQf6qQudDCgKuRdKOHU41rlLiiBVknr8q6eaSI0eDXhK2VtM2+ha6WwNXI5+/qosKvRH5X3ejhP3xUgqmQa56A2OXdZpZ23eni5+/rcqKFxdnN9vn39Pj2Z5t8P4BZz9/W4Ovk9Pf14+zn8/f0o8KwP4Bam7yots7A0uHY5O3n7/Tx+/v7+vr6/Pz8/Pv7+fr5+fr6+Pn59/n4/Pv8qampAAAAAwMDi7pPdgAAAAFiS0dEBfhv6ccAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAGcSURBVDjL5dDnUxNBGMfxVfmagifibUiixhOEqLEFW6KABUEJRbELdgEb2JWiVAvYsCIGFcGeKPZ/kL1zmNEXzNxr/czszvObfXZn5xHivzTBJjHRJjFpfCkpfwTBXyYzHuFwOF1uh8WdOkWb6na4XU4zOdOmpaeluqarQ5eKAl1K6bEuSTK8PqRJJT8zZjJLFWaDjtAJzLYyBnMys5AGcwPoGJLsnOC8+QsgtBAPYpF/8RKWqr6w1HKXLV9BgJWrIj6CUVavycsvWMu69RsKNxrCV1S8aXMJRkxSWkZ5BSVbtlZuy2D7Dnbu2r1nbxXV+/YfOIjg0OEjR6mppe7Y8ROcPAX1DafPcPbceS5cvHS5sQmaW65wVdDa1t6hft7Zde36DW52Q8+t23e4e6/3/oOHjx4/6eNp/7P+uHpxoAZfjOcvXkYHXzHkxxjGP0CY12/eZr3jvSQYJB5RjYS1GB+8HzF0/feUtLC5maVHWuPQDDXwhCVGbTKUTHwKJcZ8Hvny9dvI96RVqyWwSfywSfy0Sfyyyf6L/1LjKG2PV8Pr5h+8AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjE1KzAyOjAw6GZPMgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNToxNSswMjowMJk7944AAAAASUVORK5CYII="), + "ie" to CountryFlag("Ireland", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAACFQTFRFMZQANJUDJY4Autup/////P37//3898uv5loC52UT52MQGbSutQAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAeSURBVCjPY2AAAUZlVxcgSKmYtQoEGEYFRwVpKQgAg3q7n/McyNsAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MzArMDI6MDAXuQzWAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjMwKzAyOjAwZuS0agAAAABJRU5ErkJggg=="), + "im" to CountryFlag("Isle of Man", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAIAAADRv8uKAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAABMdJREFUSMfN11tsVEUYB/D/N3P22gvdLbaUBiiEAqbcqlwCKCVGfYCgxgAGjFFDEDDyRmwsJmh88YnLkxoTUB64tCposBFiwKoQmoBE0srNXijd3rbtXtrt7p5zZj4fKhrolu4WDH7PZ+Y333dmvjOHTuPRhHhE7v8QZqJRRggphJACqR7gB4QJMACIf6dmIjIMQwjSOsIUVxAjFAIcAiQlC8FEkBKjrR6Qr6VSbSlD+fmeWIykZEBIKZlNIKJ1YkmF54MN4RK/oyFoWPG7RgEhQGp2MxMIrMXoNUgBCyDJnNi3t7/nj+zb/U4hElpH8/Jo48bC93dN27rNndcy9aUdLed/z25tYinBDAEwknORs8cTppfDQwMD+Tq57FmllCMUolR5p4BZCCdzKHAz+6OVg+GpZkeb562ti48effLVTaavONh1qrNx/+PzdruLfYHDR7Lu5MSguB8RM2vKO5/nbd0Wndma8E/W3TqrrYWEAN+buZGiClqzlIW/Xe88NLf8s0+dZhJZnraOjlvXr7dduGDXfOXbvMNhJMrWrP2zokLV1UFKKEWC8q7xbWO6f7f/RmWls/rEBLLdzABY65FIKhjQWruA3J/rexvqW/fu9d1s18mEo68v27IspXzbt0dig7le76RNG3vr6rKJFGAwh4Diqp12NKqPHy+AZQmDWSOVOuquBjMRzEBABdZPnFznaW56rCuQm0h4pBSA3RsUDheAaavXxr1ZDtuGy6WYZUVF8apnnIODsCybSCt7NBX3OU42YyJ4qMo2vpEGCZtJAYq1E2hvPBsOXzOHdDRebT03IwgSyraBxFPLS4qKrGCQABJi1JN0v4zv8BO62RtRgjU0kxCw7PCMWbO2bEn2VF+5tCLY2rnm8MU5p38YWrQ4AvItXNYXjbSdO+cCNN3fHatlaoImAGAhpNY9RUVLar97YuW6gkmVsWTeomXvxnu6fQsXLj59xvXxTh3bPzRoJ3866xplQ2UAgwEGEzm17jWM+TU102fPvtF4xVdYAMeCgXiwuGRKod+f73Yt3fy2xzdBJa+yhTGSBZDyHI8MQ8oQs/e9qhVvvN7W1l5UWtry46kbb37Y8XVtV6AzYVnCZZhxw1O8vOHsHjpyyZuMj9m0aczvMUmplIq/sqFs3/5oSx1Z3r4DJ/q/PFBApBgJsAkoIuUwjHkLuL07r/s2iEZ2jHuTSSNhZiDk7orHTkZ6azrrDVldP0nAJEHMHiG9zFCKTEtduiiIVBpqWqVmwAD0rXBy6qrpK6sK5z8fXDAn8cuvWbGYBsCaNfOwJwT/vc6H8Y4JYCDLsge+P9nZH5y1fl1ZeXl7Tk6stjZbSICZAAalTaYLD4cGsh0O6/LlQHNzyerVonRmd+st1dgYLpTewQy8fyLdqw8xm5aVYxiOY8dqy8vthobSyl3NS2aUHFKRYhLDlfkv4OGZbdt2GkZBU1PjCy9q03z68JmbX5TJLkaK+8gYkc6uvsvWti2J3MlkIHg1evAT/5FGjyANndE8GcMAIIg1J0t90ehx98FvcwhJ5gzLPC6YSNhQaukax/lcn4IpJSmVuZtG50oxBhjw+VyxQZdpZVzicWcMgIHcUIiJxq1i3H8SiogzaRcPDaYHUwH8BdRgRJpEqsB3AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjUxKzAyOjAwd6EO5QAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo1MSswMjowMAb8tlkAAAAASUVORK5CYII="), + "il" to CountryFlag("Israel", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAUdQTFRF/Pz+////y8v1AADLBATNAADJQkLZQUHZR0fa5+f6/f3//f3++/v+GxvPzc31+vr+/v7/b2/hRUXZXFzexcXzPj7YYGDfoaHsenrkMjLWS0vbTU3bGBjQNDTWXFzfRETZFBTPT0/cTk7cRkbaTEzb9/f9x8f0JSXS9vb+i4vnUVHb+fn+3Nz4aGjgYmLeMTHUfn7kamrgfX3kT0/bzs716Oj6Q0PYkJDoNzfV9PT9ERHOeHjjoqLsAADIxMTz7e37CwvNd3fjnJzrYGDef3/lSUnZysr03t74NDTVkpLpOzvWvb3yIyPRg4PlRETY8PD81tb39fX9T0/aXl7dNjbVeHjkOzvYUVHcVVXdHR3RJyfTXV3fFhbOV1feUlLc0dH2NTXWUFDbe3vkJyfSWVnd7e38JCTRzMz17u78WVneWFjeBgbNtLTwwIVfVwAAAAFiS0dEAf8CLd4AAAAJcEhZcwAAAEgAAABIAEbJaz4AAAEhSURBVDjLjZRXVwMhEIXnWlJGdDEae40tutbYNbH33o3G3hP9/8/yCsvm8L1wuNwzMAwDkStwhCocoUpHqMoRqnaEIgGisWhQjNiyjrMta9aoYYF4bR08NjEiShDqEw1gKaURUbMJSWhMoqlZ6cyhRkJLa1t7R2dXd09vqq9/ADLEyBgcSg+P+KNibBwTk/puxmQqMz2jhtm5+QXWAhpnxOLSMjwpkM2t6EumcXVtXRk9bJQ3Eja3tncgsLu3f1Bma8LhUfr45PTs/OISV5nwZBjXN7f5u/tC8uHxKZX3Q68HkpX5+QWvWaUbpdFPrAon8Pb+AZJGYUDCwMPn1zd8Uxa2Z/YjLSIVA5QKpaBYtLVCztoKv464N9efI+5finDkH3lxVt+dR1YsAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjMzKzAyOjAwJlEWSwAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDozMyswMjowMFcMrvcAAAAASUVORK5CYII="), + "it" to CountryFlag("Italy", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABVQTFRFAFcAAVgBpcOl/////qSk/AEB/AAA2/OHLwAAAAFiS0dEAxEMTPIAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAaSURBVCjPY2AAAyFjMHBNAwOGUcFRQVoKAgDqd3XHPs6NlAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo0MyswMjowMCyUH1IAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NDMrMDI6MDBdyafuAAAAAElFTkSuQmCC"), + "ci" to CountryFlag("Ivory Coast", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABVQTFRF/96rqO6o/5oA/5sC////As0CAM0AN4JbVAAAAAJ0Uk5T/v6mqd4QAAAAAWJLR0QEj2jZUQAAAAlwSFlzAAAASAAAAEgARslrPgAAABpJREFUKM9jUAIDAxcwEE0DA4ZRwVFBWgoCADuSl4cKLQ/UAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjA4KzAyOjAwRRsubAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNTowOCswMjowMDRGltAAAAAASUVORK5CYII="), + "jm" to CountryFlag("Jamaica", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAANJQTFRF/ssA/8wAdbEAAJYAApgAA5oAAJkA/cwA/coA/swA/88AproADpoABJoA9swA/9QA/MgA/MsA/9AA3MYANaMAAJUAAZkANKMANywA164A/9sA+8kA/84A+s0AbK8AAAAADQsAqYcA/M0A/MwAqbsAAwIAAgIAa1UA+s4A+8sA28YAAQEABAMANCkA27IA/9oADgsAqIYAAJcA3cYALqIA+s8AbFUA8ssA/90A/c4A/8sAX0wA/80AYE0AqLsAbK4A28UAqocAOCwA2K8ADZoA////0PowCQAAAAFiS0dERY6zqFcAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFkSURBVDjLjdRnk4IwEAbgRfQgKip4NlDXhhUVe+/+/990wXKERO/kW4Z35pnsbhZAkqSQHI58vfkiYTlEIwCKKpFoLC5rr3OaHI9FiaQqkEimiG6kvzNaVoxltUwubegklUxAvmBaoBdL5Rc8Zculog6WWcgDVqpmTVXqRkPgKdsw6opaM6sVBLuJrTblO0Y3F+A9tmt0KNtuYdMG7DnYHwwF/pcdDvro9BAQ0UF3xPM+O3JpAG9BFHiOxWeQ53nWDwb58Zhj2SDDT6bTyY2dzR9sIMjwiwXHBoMeX6kuV2uFEGW9WtIiO8xPNoi2jRtrC4TA1tp4pz+Cu2dw90eQ3pyl3Tf0p5eh5ZnPPiiPx94LvvcKvn+MF19wpoWHewsPL1vos0d/KI5BHjiWGbMgDzzLDG6AB4FlnwLDA7onnmUe142vmycX4XwxBVbgzcv5uQBy/y6A+0q5vl8p18dK+XRJ/QCDP20F6i/G2gAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDozNCswMjowMOP2KMUAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MzQrMDI6MDCSq5B5AAAAAElFTkSuQmCC"), + "jp" to CountryFlag("Japan", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAGlQTFRF//////7+//z8/vz8/PDw9cfH8a6u98/P4lpa1hIS0gAA0QAA41pa//396Hp60gEB0AAA0wEB1AMDzwAA0wQE1AQE0wAA41tb1AYG9svL0gMD0wIC4l1d/O/v1hcX9cjI8a+v6Ht799DQeS2ujAAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADRSURBVDjLzZPZDoMgEEUH0FrBBdz37f8/sqBJqynqPDW9LyTk5A7M3AH4IxHKGCW3GGXbyei1m8Yc9/FwHY2SS857+lwI7gfeBUlCiGLJVZIoLuMIwjOSQJBmuSq0VJ6lJZyADKK0WrEVrdIImI0LoW7aN6fJtqn1pc2wk3mxUy47myWBfuBqDyo+9JZnUhiPnCFHoJbKk0iOYCImS200iC6N/gy6PfiGf49wto/QPLNEhcLEbP7EbD6PmQnuEmzBLZe7iKNWAdDLtbri1vWHegEoyhjkyVR7IwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDoyNSswMjowMIkrI+8AAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MjUrMDI6MDD4dptTAAAAAElFTkSuQmCC"), + "je" to CountryFlag("Jersey", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAeNQTFRF//7+//////z8///+//78+/nr62d5++Hl//39//z9/f36///78OOI3QAe4Bcy8JOf/vr6//798uu08eWW8/Li8ed/8Od/8eSW8+u04BYy3xEt3QAd5DhQ98HI+/jo9OND8dpI8sw088o08t5I8udE3gsn3gck4Bk03gkm3gYj6mR2++Xo//3836Fh4T8M4hsn2S8j3DAP65Bf98PK5kFY3AAc3xAs4Bcz3QEf8ZWh/vr7/v7/0GdZxYgX4IEj3Ise13sU31lU/v//8Zqm4R033QEe5TpR/vn81UVM218a3EQsz1sm1kUj2GJC/ff74Rw3/Ojr62l73ggl6mZ4/Obp//z/2FJSzGgY31sk2W8f2ksa5zZQ/f//98bN5T5U4Bs28Zej/vv722ty02UV3GAq1mwl1FMZ4Xlq/vr58Zml4Bw35TxT98XM8ai5zjoY2mUn12ok3BwZ8ae3/Ojq62h6/Ojp2oJj3EUT2UIT3H9h/Ofq98bM5T1U8p2n/fb76ktr6Utr/Pb78p2o//v84Bw25kRY9s7S9s7R3QYi3ggk3QQh3w8r+dLX5UFX4BUx3xIu3QUi8Zik+MvR62l63gcl8Zek/vv85TtS98LK5UFY4Bo18ZWi3gon/OXo5DlQ8JOg62h5r2l5ugAAAAFiS0dEAf8CLd4AAAAJcEhZcwAAAEgAAABIAEbJaz4AAAJcSURBVDjLfZRnX9tADIdPNiMGYtyWDmxCZxJGd0gw6YZCdwOB7rK6HdJJugKdhBYIO+z9Uau7C8H2L+Ve2SedntNf0hECAgHTEnMgNxdyRPMeEYCQvHxwSKbNgkIoKoLCAtOW5ID8POKUixUQHOm9HbBzV8nuPSV79+EnXw4BlGLZSUpVrcyFwTlfhPL9Bw4eOnykHMQ0lYCrTFNLidvjraisqgZJYIajcOz4iZOnTuMHXYIE1VWVFV6Pm/hq/IFa3VsX5HzxzNlz5y9cvFQvcmqwzqvXBvw1Pky64XKjrGpNPs6/cvXa9Rs3b93mVF+TpsqNoQZMG4M3t4TD3rCntY3y79y9d//Bw0ePKbWt1YOGcEszGgg72N6hBWS9s6sbFHjy9NnzFy/hFXR3depyQOtoZy6EX0UwIjrye6IAr9+8fff+A0C0B6l6xBD45bkqkgS9nB/7WP/p85evEI9xai+1QcaRBe/rZ/xv33/8/PWbUfv7MgJDps7IHzASaPYP/vk76McjCWNgq2RgaghkxGNDw/JIMjkiDw/F4ptUuyPDjI65x1V13D02ukX9r+PExPaOm+jJZHJyGzRNZirBcp2eZvknprIkQzFRZo5gXbH+EXYkapeHCp6aoYKnqMLslwo+k7IIbikhC8EA9hKypuBFmZ3LXAoPz83y8qSbwtpmkkUEa5sJRohS53024XjjzlN+CPlkYZGOwtJy0CSFSbLg8hIdhcUFssKGa9VCtfBX2XCt0HFdc9mpVr5rjY6rU15XslAtfGUdH4AN25OSjY9PygaxP1LZ+UD+Ab9qjS2/1AnJAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjI1KzAyOjAwiSsj7wAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDoyNSswMjowMPh2m1MAAAAASUVORK5CYII="), + "jo" to CountryFlag("Jordan", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAP9QTFRFwwAAWAAADAAAAAAA/wAA8wAAsgAATAAACgAA9QAAswAACwAATQEBHxUVHyIiHyAgHx8f4S4u4JSU4NfX4OTk4OHh4ODg/wwM/05O/7W1//b2/////wEB/wQE/woK/0xM/7Oz//T0/wsL/yYm/0FB/xYW/wIC/6Oj/9jY/1pa/0hI/7u7//7+/yIi/5+f/9ra/1xc/wkJ/0lJ/zEx/zw8//X1/wsM/01O/7S1//X29QYA4UAu4KaU4OnX4Pbk4PPh4PPg9AYAsy4ATWwBH5wWH6kiH6YgH6UfTGsACpMAAJsAAJkAAJgA8wcAsS8ATGwAwyQAWGQADJIAAJwAAJoAhntwuAAAAAFiS0dEGwJg1KQAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADhSURBVDjLjdBrWwFBGMbxKaONSEIHll2bXWcdHQopVFhC+v6fpd1rr23nZGb+r38vnvsB4OAwJBOA4SPlWApCGIkqJ1JQinpQgvpQSAMooCjkUhxyKAldGoufJs7IaOjQ5HkqnbnAY0EIL6+uszm8f6jmMVrQ9CITGjcl0+JRH5rlSpU8oFCrNyjYbN3e3ZPwgQHh45OJM0PT26wxlqpyGAKxOt3e8773IL30B8PX0RseDd/Hk+nH5xcZoNhsvrCXdIDBmAE5hkIuC6CA+VDIPCjBXLj6XouZAzfbn92v2Nl/FnWA7KnSQygAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MjMrMDI6MDAFOX3rAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjIzKzAyOjAwdGTFVwAAAABJRU5ErkJggg=="), + "kz" to CountryFlag("Kazakhstan", "data:image/png;base64,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"), + "ke" to CountryFlag("Kenya", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAsRQTFRFAAAABAQEBQUFMDAwFBQUAgEBQ0NDDw8PPz8/hoaGCwsLHwkLcyIpNxATXFxch4eHAgICGBgYz8/Pf39/AgMDJAgLoktS02hxuFliPBAUQEBA4+PjYGBgmZmZz9DQLBwdlCgx3pWc2oaN4qSpqzZAJggLb3Bw0tLSJSUlAQEBGxsbYV9fhjY9wztH57u+68bJyU1XjikyXVVVKCgopKWloqWlnHx/vDpGxD9K68XJ2oWM79DTyVVfwDZCqXZ6oqSk+uXn9uPlwnd9wTRAwjxI57y/7czPyFFbwjM/xF1m7tna++XnyElUyUpVrUFKWx4jvDVBwjZC3Jmf5bS4xEJNxTdDgzM6ykpViSYuIAkLrDE7wzVCy15n0nF60nd/wjdDxDhEWxofRRMXwTZCxThEcCAnCgMDmSs1wjhExkhTPxIWKgwOuTRAwzdDYRshjCgw7cPD13yCwjVBMQ4RHQgKsTI9XRoghyYvxTZCzVtk+/Pz4qCluzVALg0QGAcIrjE8ZBwjiycwxTdExUBM35Waz2JqMg4RGggJsDI9dyIpCgMEmCs0wDdCQBIWJQoNtzQ/xDVBkCcwIwkMqzE7wzVBzGJr03R9ylpjWxogPRAUvjM/35ed4Jieyo2SazM3vDRA36Cm3I6U3Zqgwz9Kiigwh2Bj4pmf/////P7+y4iO6sPH3I2U6Lm9x05ZvUZR5dfZbbxtbb5ubJRUsztAxD9L3IyT68LGyVdgwzNBiVxAabdoAIcAAIYALZMtk2FOwjlF6cDD6bzAyVBbtD1DXoVHAokDAIkACYsJXKddKIAalUAx4Jqh4KGnwEFLUl0cUKFRKZUpAIgAPJs8Qp1CKm4NrWVd1nJ9yGJqZlUjBYQBGZAaXKZcBooGAokCPpk+DowOK3IQi0w1Vl0eB4QCAIoAQZtBHZAdAogCCIIDAocBBIkEA4kDbtigRwAAAAFiS0dEp8C3KwMAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAGhSURBVDjLY2AYJIARic3EiEchMwuIZAXrYWPHo5CDk4uBgZuHF8jk4xfAo1BQSFhEVExcQpJBSloGnxsFZOXkFRSVlFVU1dQ10OQ0kQGDlraOrp6SvoGhkbGAJqqUCQowNTO3sLSytrG1s0eVMGFwQAGOTs4urkpu7h6eXt6oMgw+yMDXzz8gMEgpOCTUMCwcRcaHIRAZhEZERkXHxMbFJyQmJaPIBDLEI4OU1LT0lIxMi0DbrOycXBQpNIV5rPmhPgWFRQHFJaX4FCaUMZRXVFZVF9XU1tXjNbGBtbGpuaW1KKCtvQOvws6u7pQMl+T4nt6+fjSFzshgwsRJk6dMnTY9PmHGzFkoMs4Ms5HBnLnz5icvWLhocdOSpctQZGYzLEcBK1Y6u6xavWZt0br1qBLLGTaggI2bNm9x27pt+46du1AlNjDsRgF79u7bf2D1wUOHjxxFldjNcAwFHD9x8tTp1WfOnjt/4SKqDKrCi5cuH7ty9dr1Gzdv3b6DT+Hde/ePHXvw8NHjJxefPsOn8NhzEPHiJZB49RqvQtyA+goBOCjWcpsYznAAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NDArMDI6MDAdfAXPAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjQwKzAyOjAwbCG9cwAAAABJRU5ErkJggg=="), + "ki" to CountryFlag("Kiribati", "data:image/png;base64,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"), + "xk" to CountryFlag("Kosovo", "data:image/png;base64,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"), + "kw" to CountryFlag("Kuwait", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAANVQTFRFAEcVALI1ANxCANpBANlBAAAAACIKAIkpANM/ANtCAAcCAFAYALg3ACEKAIgpALc3AE8YAIcpANI/ANlAACAJBIosG9lUH95YGyIdxd7N4vzq4ProHx8f4eHh////ICAg4uLiISEh4+PjIiIiIyMj5OTkKCAh5cvO/+Xn/uPmKAQIoBQj8TFG9TRJ9DRJCQECXgkT0RUp9hgw8xYv8xYunA8f7Rcv9Rgw8xgwXQkS0BUp9hgx9BgwJwQIXAkS0BQpJgQImw8fWwkSzxQp7BcvUAgQyBQnyHXz5QAAAAFiS0dEHnIKICsAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAC9SURBVDjLrczVEoJAFIBhjKOC3d2NsbbYYr3/I7nCwADDsufC//qbXxB8/kAQkQChcEREQZCiMZE/pRAgnuBPNUinSd5Uh4ipAUFKeU9NSKfpjIiC2jTLygoBcvlCkZEdQqlcqbrngLV6g5EDNtGwhYRtNOwgYffvsNdHwsFwNHbPDuXJdDZ3zwrJYrlabxhZoLzd7RVmJiSH4+ms8OHFc2dCcr157gx4Vzk7HZLHk7fT4EV9cXc/+P4gdrQvhL13AQCkBv4AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MTgrMDI6MDCJsS7yAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjE4KzAyOjAw+OyWTgAAAABJRU5ErkJggg=="), + "kg" to CountryFlag("Kyrgyzstan", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAmpQTFRFvgAnvgEnvQEovQEnvgYnwA4mxR0jwxckxyUixBwjwQ8lvQAnvgMnwhUlyzYf0U0c1Fga0U8b1l8Z01ca0VMbyjYgwhclvgInvwYmxRoj0Uwb2GcY2XAX3X8U4YgS5JQQ3oIU23IW2WkX0lAbxiYivwQnxBcj1Fca3HUV4YsS78IJ9dgG8swI8s0I9NUG8cgI5JYQ34MT1mAYxiAivwUnwQol0Ukc2m8W5ZgQ+OIE5psP1VoZ1VsZ0k0b45IR+OQE6KcO3nwUwxQkySwg23QV998F3XkU2m0W/fcB//8A/vwA3XsU+ekD5p0P23AWz0QdwQsl3XoU6KUOtgAszDYf7r0K12QYzToe5JgQ9NQH34ATwxYkvQAoxBck1l4Z45ER9+AF0lQb4IcT3noUxSQjuwApvAEoxCAk3nsU45QR0VIb9t0F4YoS1VwZxyMi2GUY5ZcQ8s8I/PQC12IYwA0mvwom1FQa+ecE8MYJ558P2WgXySoh4IQT0EYc2m4W0Ecc12MY12YY8MUJ5ZoP1l8Yyi0g1VgZ9toG1F4a8cgJ2W8X67MM78EK1mQY7r4K1WIZ5JUQxiEi0k4b3HgV56EOzDkf3HsV8ssI994F0VAc3oEUyjUg01Iawg8lzDcf4o4R+eYEyC4h8ckIz0gd1lwZ+OME5JMQ2WsXzDgevwIn1FUa3HcV5pwPzTse0k8b1VkZ9+EF56IO01Eb2GQY3n0U8ccJ1l0Zvwkn01Ya2WoX3n8U4IoS2GkXxyQhvwYnwhYlzDwf01ka23QW1FsazDofwxgkvwgmvQMnwRElxSEjyi4gxiIiwhMk////x9Cy4wAAAAFiS0dEzW3Qo0UAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAGASURBVDjLY2AYkoARBIhRxsTMxExYJSMLKxs7BycXCzNepdw8vHz8AoJCwiKiYuIMuJVyS0hKScvIyskrKCopq6hy41QorqauoamlraOrp29gaGRsglOhqZm5haWVlLWNrZ29g6OQEy5/cDu7WLi6uXt4enp5m/v4+vnjUMcQYBaoExQcYh2qExYeHBEZpR4dw4jVwNi4+ITEpOSU1LT0jMys7JxcNm6sCmPy8gsKbTyLiktKy8o9wyoqq6pxmJhXbKdj41lTW2de3+DZ2NTc0sqNw+o2w/aOzi7h7h713r7+9gnFE7GbyBAwabLulKnThKfPmDlr9gRdjTlzuXFEzry6+QuqFoosslwsumTpsuUrVuIKcKdVq4Ms16xdtz7EYMPG1ZuiccYhS97mLXKLshdtnTF9guO2PB6cUci9nWPHzl12Oc27FfbE7S3FnSgYuPftP3AwLPdQ7uEjR4/F4EuRjOLHT5w0PnX6DIs4oUTOyMwMzApMRGUa4jLXIAQAnghpBAww9t8AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MDQrMDI6MDCCu0QYAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjA0KzAyOjAw8+b8pAAAAABJRU5ErkJggg=="), + "la" to CountryFlag("Laos", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAKhQTFRF6QAS5QEV+gAE+wAE/QAF/gAFaiF7biR8Zx96WxZ4VxN4AEHgAELgAEPgADXdBEriOXvtYZj0BDzPBD3PBTzPADTNb47i7e74///+/v7/AD3SAT7SADXQmbHt/////f3//P3/+/z+A0DTADDPbY7l+fv+/f7/ADvRDkbU4un6Az/TADLPSXTfBEDTAC/Pb5LmDkXUDUXUbY3lmLHtbo3i7O34BEniOHrtO5umIAAAAAFiS0dEHnIKICsAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADVSURBVDjL3ZPZDoIwEEXrgooiigKChQFkExRcWPz/PxOMJLSkSRPfPI8zJ2nmzhShf2LECRrTTKaCMJ0MymhGMV+Iy6W4mNN1tCKQ1vJmqyjbjbyWyA7a9dmrmn4wTNM46Jq6J1ro2AdbNjiu57kO2BYmWoR48gMII2iIQgj8E0vE8TmBj9eYkJxjzBDTyxVc+OLC9ZIyxCy/gdeJHtzy7FeR+2kc3/vDPJjDkPE82fG0gRdd4AUdOL3CsmpXWJWDFQ6Oon4pyqseHgX3mXEfLvdX+Cfe4LY7+JthuCEAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MTcrMDI6MDB/+V4bAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjE3KzAyOjAwDqTmpwAAAABJRU5ErkJggg=="), + "lv" to CountryFlag("Latvia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABVQTFRFqyMdqyQeqh8ZsTIs+fDw//////7+uszw1AAAAAFiS0dEBfhv6ccAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAySURBVCjPY2AYykAQC2BQwgIYjLEABhcsgCEUC2BIwwKwC2LVjtUirE7C6nis3hzKAACpijfJ8lhDKwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo1OCswMjowMOI5SzYAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NTgrMDI6MDCTZPOKAAAAAElFTkSuQmCC"), + "lb" to CountryFlag("Lebanon", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAcVQTFRF/wAA/39//4CA/4GD3G5d4XBi////z+nSO5s+PJw/zOjP/P/91+rXLJAsAHYAAHcAGYUZWKdYstey+v368/nzbrNuHIgcIIogKI4oHYgdA3kDIosi0ObQ+/37r9WvMZIxYaxhSqBKK5ArbbJtttm2/f795fHlcbRxLZEtTqJOQpxCNJU0TKFMT6NPQJtALZAtnMuc3e3dkcWRcLRwUaRRDoAOEIEQCH0IKY8pK48rzeXNX6tfC38LBnsGKo4qR55HA3oDIYohRJ1ElMeU9/v3L5Eva7FrHYcdBXsFCX0JJ40nA3sDBHoEOJc4pM+kw9/DdbZ1KY4pFIMUHIccGYYZDH8MAHgANpU2c7VzXKlcJIwkP5o/x+HH/P78vNy8TaFNGIYYWqhaLpEuDYANUqRSZa5lmcqZ9fr1jMKMS6BLJo0mFoUWBXwFAHkACX4JT6JPOpg6I4wjG4cbqdKp6fTpgr6ClceV1OnUu9u74O7g9Pn06PPozuXOgb2BzOTM/v7+hL6E/v/+8vjy0OnTebx8c7l2ud68t927RKBIJ5ErRqFJut69+358yGNJ2mxb/H9+/4KD/4KE6HRp2GtY0GdRtVk1+Xx5fVEv1gAAAAFiS0dEBmFmuH0AAAAJcEhZcwAAAEgAAABIAEbJaz4AAAEJSURBVDjLY2AYBfgAIzpgYmZhZWbCEGZgwwDsHJxc3BiimAp5ePn4BQSFhAkpFBEVE5eQlJKWIaBQVk5eQVFJWkBZRRWvQjV1DU0tbR1dPX0DEbwKDY2MTUzNzMUkLCwVZPAoVLWytrG1s9dx4LdxdHJ2wa3QgNfVzd3D08vB29zH1w+PQv+AwCDX4JDQsPCIyKjoGFwKY+PiE0L47RMTk/h9kp1SUtNkcShMz9DKzMqWzHHIzcsvKCwqKMalkK2kVL2svMIsLEy8sqq6pja+Dqcb69nYXBpCPfk95YCcxiYXnArZ2JpbWtvaOzq7utGjFjWZMfX09vVPmDhp8pSp09BS2kBnh0EOAPCzPedbmSFsAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjA2KzAyOjAwFSRVMQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNTowNiswMjowMGR57Y0AAAAASUVORK5CYII="), + "ls" to CountryFlag("Lesotho", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAUFQTFRFACCfASGfABydABmaES+mEi+mES+lEjCmIj+27vD47e/47/L67/H2lpihlpmh7/D2/////f39nJyaUFBOVlZUnZya/v7//f3+4ODhmpqaiIiJjIyMmJiZ5OTk/v7+lpaWU1NTTU1NlJSU5+fnUVFRREREl5eX+/v7mJiYAAAA+vr67OzsJSUlGhoa4+Pj/Pz8VlZWBQUFBAQER0dH8vLyampqAQEBAgICYWFh7e3t/v/++vv7eXp5HyAfTk9PJSYmKCkoISIiKioqSElIMTExb3BvnpydQD0/SEVHS0lKXVtcYF1fUU9QR0VGnZuc7vjy7ffx+//96PDsrrmzh5GLcnx2eIJ9iJKMsLu15/Dr7ffyEZxQEpxQDplNE55RH6pdI65hI65iIq1hHqldE55SAJNAAJM/AJE9AI88AZVEAJVDDeuuPAAAAAFiS0dEEJWyDSwAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAD3SURBVDjLY2AYkYCRSMDAhAmYmbEIMrCgAVY2dg4OdjZWdHEGTjTAxc3Dy8fPzYUuziCABgQFhIRFRIEUGmAQQwXiAhKSUtIysgLiaBLoJsoJyMorKCopAxloJqJbISAnr6KqhqEOU6G6gIampryAFiGFggLaOpqaunoC+gQVGmgaGmkaC8jJ4VMoJ2BiqmmmqWmuaWGJ5kwGKyQgZy1gY2tn7+Do5OziKqAuhyzHgGaxm7uHp5e3j4evH7qJ/iggIDAoOCQ0LDwiMjAKVYYhGgXExMbFJyQmJSanxMagyjCkooG09AwgSE9DF2fIJBIwZBEJhpVCAJSCyGJG8LK4AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTExLTA5VDE3OjI4OjAwKzAxOjAwP4Q+MQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMS0wOVQxNzoyODowMCswMTowME7Zho0AAAAASUVORK5CYII="), + "lr" to CountryFlag("Liberia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAP9QTFRFAABmAABoTwFAzAEAzAAAAABlTwE/ywAAEhJwBgZpVR5d3E5OAgJnfn6xNTWFAABkAABjYV+e/vv7AABiHx9329vpgICyYWGg////OzuKbW2obW2nmJjB/f3+2NjodXWsc3OrYmKhGBh1WC5t5Hl5Hx94jIy67e30yMjeTk6VBgZqAQFm+fn8HBx3UAVDzgoKenqvwcHa3d3q4eHtJiZ8XUmI88HB8sHBEBBwn5/FaWmlDg5uKSl+m5vDX1+fDAxtHR13AQFlCQlqHh54AQFnXlCP9tLSAABnUQhH0BMTTwE+XmGhkmGI319f32Fh9tHR88XFzgwM5Hh4/vn52kdHTxH0QAAAAAFiS0dEGJtphR4AAAAJcEhZcwAAAEgAAABIAEbJaz4AAADiSURBVDjLjdHZVsIwEAbgKTStipIgIlUsUBQoiAuLFXBhX6qisrz/s5DanmNvBua7yNz8mZz/BCBEiURVTBBhflBTdUwQPDj8G0cxlJ87PolzOUTiFOU9K5JnqfOk4CDSBkpuu7jMXJnZXN4qsOsblNxYLJXlDdOuVBVN31WG3Vo1w7DvOCj3DyivCn+s1RvNFgP+5DjPCG9ju9N9eX1731cGoNcfMD4cjYFPpqj/f5HHbO6iQISwjx2t0yGfXwsUGET04DcR6ETgEsEPEb3MLxEsieitV0T0Mmsi2BDRy6hEWzLks2qStJ6PAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjM2KzAyOjAwdGk57AAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDozNiswMjowMAU0gVAAAAAASUVORK5CYII="), + "ly" to CountryFlag("Libya", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAI1QTFRF5wAT6gATcwAKcwAJAAAABQUFBwcHAQEBFRUVbm5ujIyMZ2dnNjY2CAgIFBQUq6uroqKiKSkpCwsLDg4OGxsbFhYWcHBwy8vLGhoaSUlJj4+PREREPj4+AwMDrq6ukpKSOTk5pKSk+vr61tbWMTExb29vjo6OQ0NDKioqbW1tNTU1EU8jI6BHI55G////DXIq7AAAAAFiS0dELlTTEIcAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAB3SURBVDjLY2AYkYCRSMDAxEwcYGAhElCkkJWNnRiFHJxc3Dy8hBXy8QsICgmziYgSUigmLgGiJKWkZdjxKZSVkweRCopKyiosVFHIogq1Wk0dv9Ugz2gQ5RkWPk0ubi0igof4AMcBiFeoTSRg0CESMOgSCYaVQgBCOkYGjUbqbwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNTowNiswMjowMBUkVTEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MDYrMDI6MDBkee2NAAAAAElFTkSuQmCC"), + "li" to CountryFlag("Liechtenstein", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAActQTFRFlXfplnjsl3jslXbpknTkkHLgj3HfkHLfkXPilHXnlnjrl3ntlXfq2h5iioX/i4b9lI/zqKPaj4r4iYT/m5brtrHKl5LvlZDzo57VoZzKnprYmpXvko3nlpKokYzxnprVoZzJop7Zko33k473paGWYmA8U1EyWFc7amhWV1VRPj0pXVtZZWNQVFI3T00vZmRBqaWpj4r7oZzlfXpRPDsePz4gPDsfMzMaGBcMMjEaFxcLNTQbOzocjIlmmpXxnZjtenhbMC8XU1IrUE8pPz4hXFoveXc+UVAqQUAhWFctUU8pMDAXjIl1l5L2l5Lgn5tzSkknp6RWsa9bkY9Lwb5jyMRnt7Rek5FMtrNelpRNRkUmpqKFkYztlZDmvLh4xsNlubZfq6lY9PB+3dpykpBL7el68e18o6BUvLhhvrthwr98k47sjIf/nZmnz8xp5eF2y8ho6eV44Nxzzcpp4d505uJ2w8Bk5eJ2x8Rjsa2ejYj+mZTqop5tZmQxRkQhNTQYLCsUKikTKioTMDAWPj0dVlQphoRJoZ3NiYb/iob/bWvIQUCALy9eJSVLICBBHh49Hx8/IiNGKipVODhwWFemhYH05Q9M5BBN////IjDadQAAAA50Uk5T/v7+/v7+/v7+/v7+/v7BShreAAAAAWJLR0SYdtEGPgAAAAlwSFlzAAAASAAAAEgARslrPgAAAOJJREFUOMtj4CMSMJCukJ9IhQKCQgQVCoOAiKgYiMKrUFxCUkpaRlZORF5BUQmPQmUVVTV1DU0tbR1dPX0DQ5wKhY2MTUzNzC0sraxNTG1s7YRxKrR3cHRydnF1c/fw9PL28cWpkM/PPyAwKDgkNCw8IjIqOga31bFx8QmJSckpqWnpGZlZ2bhNzMnNyy8oLCouKS0rr6iswu1r4eqa2rr6hsam5pbWtnZcIcnQ0dHR2dXd09vXP2HipMlTpnZ2YAcMIMDIxMzCysbOwcnFzcOAC/ASCRimEQkYphMJRhWOHIUA+L2cEmYnwtMAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MzArMDI6MDAXuQzWAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjMwKzAyOjAwZuS0agAAAABJRU5ErkJggg=="), + "lt" to CountryFlag("Lithuania", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAC1QTFRF/7MA/rMA/7UA5q0BC3YIAHIIAXMIAHMIAHQICG4IrQsBxAAAvgEAvwAA////KWO2egAAAAFiS0dEDm+9ME8AAAAJcEhZcwAAAEgAAABIAEbJaz4AAABCSURBVCjPY2AYfEAQC2BQwgIYjLEABhcsgCEUC2BIwwIYyrEASgWxWtSBBTDMxAIYVmEBDLuxAIYzWADDXSxgYAUBMVMEYE0sp5IAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MDcrMDI6MDCzU16FAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjA3KzAyOjAwwg7mOQAAAABJRU5ErkJggg=="), + "lu" to CountryFlag("Luxembourg", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABhQTFRF/xkZ/9vb/wAA////7Pf/Lar/AJf/AJj/BnHklQAAAAJ0Uk5T/v6mqd4QAAAAAWJLR0QDEQxM8gAAAAlwSFlzAAAASAAAAEgARslrPgAAACtJREFUKM9jUMICGIaKIFYgiAUwGGMBg1HQBQtgCMUCGNKwAIZyLGAQCgIAGo+XaSlY34MAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NDErMDI6MDC7Cw57AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjQxKzAyOjAwyla2xwAAAABJRU5ErkJggg=="), + "mo" to CountryFlag("Macau", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAj1QTFRFGZ0AGp0AF50AFJwAFZwAGJ0AIZ4AG50ADZwAjasDhqoDH54AkKsAMaAAFZ0BFp4CSp8AR58AFZ0CEZwBRKIAh6kAEJwAJZ4AHJ0AF5wDCJUAX75bWbtTCpYAGJ0DHp4AEpwAGZ4DDJgAW7lLldKL7vjs5/Xkm9WRUbVAGZ4CEZwAOKAAg6kAF54DIaAIDZgAk9GH6/fp+/78+f356fbnhMp2DJcAHaAIK6ADJJ4AQKIDDpkAD5gEApMAkNCF8vry/f/+/f796/brf8hyAZMADpkEF5oARaMDG54BEJoAGZ8SkdCFgcp0OKojWbhK+/77////5fTjTbM8OqslfshwfchwD5sJFZsAGp0BGJwAIKAIbcFcx+jC3fHa1+7UodeY4/ThyunGn9aW0uzO3PDZweW7Zb1THJ4DKqQT/P79+v37/v/+9vz2+f36/f7+2/DYF5wAG54DesZs3/Lc4vPg6Pbn5vXkdcRnFJsAGp4BKqQSntaUu+O15PTiueGypdibndWS+v363PHav+S5rNykhMt3HJ4EEZkAUbVCmNONl9OMl9OLZ75WdMRljs+Ci85/i81+hsx5gsp0QK4vEpoASLE1otiYn9aUpNialNGIV7dFXrtNn9aVnNWRpdmbmtSPOasjXrtOxea/xea+vuO3wOS5zerHzOnGv+S4w+W8zOnHweW6RrA1G54CMqgdgcl0qNqfp9qeqdqfqtuhoNeWdsVnIqEOD5kAFZsBM6gcfMdue8dtY71TMKcZFpwB1MAcYAAAAAFiS0dEUONuTLwAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFVSURBVDjLY2AY5oCRkQhFTEDMzMLAwMpEQCEbOzsHJxcHOzs3K36FPLx8/AKCQsIiomLs+FzHIC4hKSUtIysnL86KWyEjkwKDopKyiqqauoaSJqsWTnUK2jq6evoGhkbGJqZm5haiEricyWRpZW1ja2fv4Ojk7OLq5o4zlDw8vbx9fP38HQICg4JDQsPCI7Cri4iMio6JjYtPCAhITEpOSU1Lx2F1RHhGYIBjZpZxQHZObp5jQH5UAQ4jGQqLigOyswNKSgOyAwLKyisqcZlYVR1fU2tcV9+Q2tjU3NLahsvXHu0dBp1d3t09vX39EyZOmjzFgwGXkVOnTW+YMXPW7IY5c+fNX4DL10AjlRYuWrxk6bLlK1auWr1GaS3OOGRYq79uvfqGjZs2b9m6bTsedUCVOyp29uzavWfvlH141QHdGVGhDwQVlREMhEBEOhAQVjakAQCN/F7SFaUfOgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNTowOCswMjowMEUbLmwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MDgrMDI6MDA0RpbQAAAAAElFTkSuQmCC"), + "mk" to CountryFlag("Macedonia", "data:image/png;base64,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"), + "mg" to CountryFlag("Madagascar", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAD9QTFRF/3xr/3tr64hsb9J0W991W951//////7+/y8V/zMZ/y4V/zIZ4EIX4EUb/v/+G7giH7omAMwkAM0oAMskAMwoimvg7wAAAAZ0Uk5T/v7+/v7+v+O9ogAAAAFiS0dEBmFmuH0AAAAJcEhZcwAAAEgAAABIAEbJaz4AAAA6SURBVDjL7cq3AQAgDAOw0Hvn/1tZyeALQLPIXhz5gNCPj0YRE8KjzAVhsarWER71mAiPZm3kx3fiAVAbNgcW0kZ2AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjE0KzAyOjAwThFEhgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNToxNCswMjowMD9M/DoAAAAASUVORK5CYII="), + "mw" to CountryFlag("Malawi", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAZ5QTFRFAAAAAQAAAwAACQEAHQMBMQQCOQUCMgQCGQIBBgEAAgAAHQIBVwgDggsFkQ0Flw0Gkw0GlQ0Gnw4GjgwFeQoETwcDFgIBDgEBWwgDkw0Fmg0Glg0GhwwFfAsFdQoEeAoEgwwFgwsFlA0FkAwFSgYDBwEAfQsFoQ4GiwwFcQoEYQgESwYDNQUCKQQCKwQCOgUCTAcDZQkEdwoEjAwFDAEAFwIBjQwFmw0GYwkENgUCEQEBPgUCZwkEgAsFegsFdgoEGwIBvBAH1RII0xIIthAHbQkEEAEBJAMBXQgDpQ4GZgkEnA0GewsFVwcDGAIBWggD6hQJ/xYK/BYJ+BUJ4BMISAYDaAkELQQCCAEAigwFLAQCbAkE/xgK/RYK+xYJ/RYJ/xcKUQcDOAUCJwMBiAwFYAgEBAAAwREHuxAHvhAHvRAHuRAHxhEHow4GDwEBQgYCbgoEEwIBCgEADQEACwEADgEADwEAFQIBFAIB4xMH4RIH4hMH5RMI5BMH+BQI+RQI8xQI9BQI8xUI+BIH5hwLL384HYk8IoY7IYc7////Gt7rFwAAAAFiS0dEiRxhJswAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAE/SURBVDjLY2BAAoxMjAzMLKxsbOwcnAyMXAy4ABcjIzcPLx+/gKCQsIioGJCPXR0jg7iEpJS0jKycvIKikpCyiioDVpVcDBxq6hqaWto6unr6BoZGxkKaJthUMjKYmpmLWFhaMTEwAZGYtY2tuZ0JNnWc9kpqPA4MHHaOTs4urm4M7h6Knl6YRnIxqHj7+Pox+AcEBgUHBwWGhDK4h/HyhTPA/c4IBlwMEZHe9lEM0TGxcUHx8UFxCQmJDElGQnKgoAADuIHJKamWaSYu6RmZWUCQmZ2Ty5CXX6DoBrfcCgrcTAuL3AqLi0xKwMCkqLSwrKi8wg0mz1AJA1XVNbWVlbVwAGTXVFfXwqQZ6mCgvh5MIABMDAIYGogEDI1EgoFU2EQkYGgmEjC0EAkYWokEDG1EAoZ2IgFDB5FgZCoEANGsy4VJsnfVAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjUzKzAyOjAw4D4fzAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo1MyswMjowMJFjp3AAAAAASUVORK5CYII="), + "my" to CountryFlag("Malaysia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAbBQTFRFMgVt3AAK8FBV//7++srL6QwU6x4l/ODh/vLy7TU76AAI+K6x8m905wAA/vDxAAaJAAWKAQSKERaAFRl+BAqHAAWJAQaImAI07AAF6AAHDhKCbWlPfXdGQUFmERSBDhGCGBp9EhWABwuGmQs+7Q4U6Q4WAwmIiIFAl484EhaAAASKFxt9TUxgfHdHaWZRLC5xBwyFAgeJpIa1/87N+srMKixzyr8cLCxyAAKLPT5otKoo9OUG39IRcm5MAgiKp6nW////AAOLREVlxrofBw2FUVBd2c0U//IA+uwDkos7HiJ5AQaJnDdo81JV71BWLC5yysAcKSp0BQqHNTdsopoy5tgNzsIaZWJTExd/lwIx6wAA5wACBAmHjYY9k4w6DxOBEBSBPDxpYV5VUlFdICN4BQqGoGCQ+ZKT9ZCTAAaLAAWLDxSCcXBMeXdIOz9pDxWCBgyHDxODCQ6GBAmJAgiMp6nXNAVsMgRtMwRtRRVjSBdiOAlqMwRsMwVsNQZtsmCG+JKU3AAK2wAL5AAF6AAC8FBW6QwU6x4l/OHi/vPz7TU76AAI+K+x8m905wAA/vHx2P3g2gAAAA90Uk5T/fb29/b29vb39vb29vb3/hPHdAAAAAFiS0dEQP7ZXNgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAEWSURBVDjLjdFFUwNBEAXgxp1eJMElOBskgeCW4Brc3Vlcl8VJcP/LzIELVbNV7zvNoevV6x5iZiUuPiFRYYt4WpOSU+RIzKWmpWdkZmXbcsRgbl6+nBgsKCwqVu0lpWXlDouzotIlR6xWVdfUOurqGxqb7Nzc4jZB7GltsyntHZ1d3T293Nc/4JUTiYNDw56R0bHxickptk7PzMqJjnPzC4vq0vLK6to6Ozc2t+RI07Z3dvf2Dw6Pjk807fTMtCPp+rlxcXllGMa1fnN7d2+WGOAT/H7fn4dHs46BT/94zVCQG0PBLgyFPGMo9AVDYa8YCn/DUMQ7hiI/MBT1icEPHv2FoZhvDJ4Id4S3hu8I/0zsDwZe5hctVdOZL0tejwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNTowNSswMjowMCTMT6wAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MDUrMDI6MDBVkfcQAAAAAElFTkSuQmCC"), + "mv" to CountryFlag("Maldives", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAblQTFRFtxQBtRYCuRIBvwwAvg0AuRIArh0GkjkVlDcUkzcUlDcVlTgWljgWljkXIahRKKBNJ6JOKqNQKqNRJaFMH55HG5xDFppAGpxDKKJOL5pKLptKMJtLMJxMJJZBIZQ/Np9RUatoa7d+hcSVdbyHPKFWLJpJL5tLLZxLMJ1NKZpIIpdBYLR2tdy/6PTr/v/+/v7+tNy/WbFxMZ5OJZhEOKFVvN/F/////f792+7gUK1pGpM6I5dDLJxKL51NJplFQaZc4fHl+v370OnXMp5PIpdCMZ5PL51MLpxM0+rZ+fz66fXsO6NXMJ5OH5U/j8qfdb6IHpU+K5tJM59R5PLo/P782+7hLJtKYbV4/f7++/38m9Cph8aY/P38/P79cLuEIJZAmM6nXbN0I5dCksuhXrN1MJ1Odb6Jcr2GSqpk+vz6n9KtxOPN+/374PDkLp1MYrV5e8GOHZQ9pdWy7vfwQqZdKZpHu9/E2O3eJ5lFms+o5fPpZLZ6T6xoq9e35vPq1Ovag8WVMZxNJpdEIJQ+NZ5QU6xqa7h/gsOTgMGQXLBxM51OLZpKLptLKaNQJaFNF5pAHp1GJqFNljgXHZ2dQAAAAAFiS0dENke/iNEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAGBSURBVDjLY2AgBTASADB1TMwseAEzE0QdKxs7BycK4OLm4eXhgvE42NlYwfYys/PxCyABQSFhEVExcWEJKJ+fj50ZZDsjCwe/pBQcSMvIyskrKCopq6iqQUQk+TlYIAo5BaTUYUBDU0tbR1dP38DQCCYkJcCJqVDD2MTUzNzMwtLK2gafQls7ewczRzMnZxdXN3U8Ct1t3D3MPM28vI1d1dXxKfTx9TNzNDfzD3BWx6vQPTAo2CzELDRMXR2/QluXcLOISLOoACMCCn0Cos1iYs3i4jUIKkwwi9Q3S0yyJagwGaQwhaDC1Pg0s9hYs3SCVrvZZWSaRZplEfSMuptxtlmOWW4eoeBR13DJB9ldUEggwIEq44uAUVhckuRMQKG7emkZMFGUe/um+uThU6ieF1hRGatnVlXtW2hsg0+hep66b01tnblZfUONEYZClKyg1tjU3NLa1t7R2dXdg5oV0DNXr1CfiGh//4SJaJkLa3adxMvLzYGWXYkvAIgvUogCAHK1ht/GJTH9AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjA0KzAyOjAwgrtEGAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNTowNCswMjowMPPm/KQAAAAASUVORK5CYII="), + "ml" to CountryFlag("Mali", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABhQTFRFq94AAJoAApsA//8A/6cA/wIA/wAA////biEhSgAAAAF0Uk5T/hrjB30AAAABYktHRAcWYYjrAAAACXBIWXMAAABIAAAASABGyWs+AAAAGklEQVQoz2MQBAMFYzBwTQMDhlHBUUFaCgIA/uiDX6UlVGoAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NTUrMDI6MDCD7ir2AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjU1KzAyOjAw8rOSSgAAAABJRU5ErkJggg=="), + "mt" to CountryFlag("Malta", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAXdQTFRF//////7+/O7u0RERzQAAzgEBzgAA/v////79//772LSTvKOFvqaMy6aC//Xx///+wKeLlJmcl56krJmC//Lp/v7/xKmMnJ2dn6KlsZyD/f////z6xKuTm52dnaCjsp+K/u/n/v7+//38//v3/vv3//36vqysoJ+fo6Ojo6Skrp6e+/Hu//76//v2t5+CvaSIo6KgoKCfoKCgnp+guqaRvaOGuaKIyqWB//bz/O3txauPlJqcnZ+hnJ6gpqams7OzsLCwpKSknJ+gsZyE//TtxqyQlZuenqCjnJ+ioKGhrKyrurq6tbW1oaGhnaChmJ+lsZ2F1rGQs5x/uaGGuaKKpKOhmpuboqKiqqmpnZ2dnJ6ft6SQuaCDtJ+Gx6J9//by//v5//jy/vjz//r1uqionp6eoKKiqpyc++/q//v1//jx//r3//r5xKyUsqCL/Ozl/f7/xKiMsZuCwKeMlJqemJ+mrJqD1bCOuJ+CuqOJyKN+//Xw//378+OKIgAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAD3SURBVDjLY2BAB4wMTMwsrGzoAC7PDgREKeTg5OQgQiE7Axc3Dy8fUBUhhfwCgkLCIoQVivKLiUtIElII9IaUtIysnLwCuyI7Ox6FSsoqqmrqGuqaWto6utI4FSoycOnp8xiIGxoZGZuYmplbMFhiVyjKYGVtY2tkZ++g7mjrJOTsgluhq5u7h6eXt4+vuo2ffwBOhYoMgUHBIaFh4RGRUdExsXHxuBQyMCQkJiWnpGr4pqVnZGZl4wtHYPjk5MrK5eUz4A8eBn7GAv5CcYkiYIDzE4zC4pLSMiKikJ2hvKKyqpqwQgaGGl1daeomXKKzwqjCQaYQAKkSMZESNvARAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjM2KzAyOjAwdGk57AAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDozNiswMjowMAU0gVAAAAAASUVORK5CYII="), + "mh" to CountryFlag("Marshall Islands", "data:image/png;base64,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"), + "mq" to CountryFlag("Martinique", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAACFQTFRFACZ/AymBABl3qbbU////+/z9//z8+7G68gok8xsz8xgwLe7hVwAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAeSURBVCjPY2AAAUZlVxcgSKmYtQoEGEYFRwVpKQgAg3q7n/McyNsAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NDkrMDI6MDCI5EAcAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjQ5KzAyOjAw+bn4oAAAAABJRU5ErkJggg=="), + "mr" to CountryFlag("Mauritania", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAa1QTFRFLZxLLJxLLJtMLpxLMJ1KJppNV6s8aLI2IphPK5tMDZBWksInwtQWF5RTNp9IM55JNJ5JUak+KZpMjr8oytUT6OEI9ucD3t0MscwcN6BHKZtMPaJFTqg/J5pNmMUlOKBHq8se/+0A/+8AMp5JKptMHpZRgrwtaLM2IJdPL51KHJZRsM4cg7wsHJVRMZ1KMZ5KGZVScLUz+OgD5N8Kv9MXH5dQMp1J2t0NTahAJZlOLp1LHZZRhL0s8eYFnMUjXa46msQkRqVCG5VSnsYj7eQHsc0cHpZQI5hPHpdQ//AAKJpNztgS//EAksEnG5VRTadA7OQHarM1IZdPe7kv/+4A/+wAW6066+MH1tsPLJtL1dsPyNUUJJlOk8Em+uoC/OoBbbQ0I5lO++oB/OkB+ukCt84abbM0RKRDNJ9JO6FGWKw8lcIm5eAJ+ecCqcofdLYy/eoB++gB+OcC5N8J8eQF/+sA/uoA+ucCvdEXaLE27+QG/ekB/egB/+oA/+kA++cB/OgBpMchLp1KIZhPp8kf8+UE/u4AX645KZpNn8Yits4auM8ZqMkfIJdQ////k/cqxgAAAAFiS0dEjoIFs28AAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFvSURBVDjLY2AYBTQAjEzM+KRhkiysbOwcDIy4FXJC1XNycfPw8vFDVDJyYigTEBSCmCksIiomLiHJCeQxS0nLyKI7g1OOjxNsoLyCohKPsgpInkVVTV1DE1Udi5a2jq4ekKFvYGhkbGLKAtZkZm5haYWm0NrGVk8FqJuZ1c5e1sERZKOyk7MLAyOa1ZqWFkqubizMDIwsmpaM7ixAvyh72Hu6go1GDR0vbx9fP00WBkZGTWZNRgZmZQ//AKXAIAyFLKbBIaF27pZ6LJrMzMyaeox+YeFKEVgDMjIqVDFaxjTIizNSKsZaLzYuXjEB00CgKxPZkpJDU1LT0jOUM7Oyc0JylfKwqQNZnh9aUBiiWCRaXFKqVFbuWSHEiD3SWUwrq5Sqy2tqa+vqGxRDG704m3BEN0uzdEtrSJuiYkhIdXS7KQMudUCVHR7S+Z1d3T06MjEcLPgSGzOLUK9br4aHh6WmJgN+wMwCBoSUDV4AACIxPKtk5SdLAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjAwKzAyOjAwdvRgCwAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNTowMCswMjowMAep2LcAAAAASUVORK5CYII="), + "mu" to CountryFlag("Mauritius", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAADBQTFRF/wAA+wAEfwCAAAD/BAD7AQH+ERHu7u4R//8A/v4B+/0Af80AAJMABJwAAJoA////llr3LAAAAAFiS0dEDxi6ANkAAAAJcEhZcwAAAEgAAABIAEbJaz4AAABJSURBVCjPvcrRFIQAAADBVUghhRRSSCGFFFJIIYVTOIUUYkhgfms+9219ZQCfIzRBM/hkXMDnCm3QDh3gk/EEnz/oD13QDW/EB2rFAbh2CSgfAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjA0KzAyOjAwgrtEGAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNTowNCswMjowMPPm/KQAAAAASUVORK5CYII="), + "yt" to CountryFlag("Mayotte", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABVQTFRFACZ/ASeApbLS////+6228xkx8xgw8anT+QAAAAFiS0dEAxEMTPIAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAaSURBVCjPY2AAAyFjMHBNAwOGUcFRQVoKAgDqd3XHPs6NlAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDoyNiswMjowMLjDOXIAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MjYrMDI6MDDJnoHOAAAAAElFTkSuQmCC"), + "mx" to CountryFlag("Mexico", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAp1QTFRFC3ImD3QpAGgXn8ep////+/38/vv76a2tuAAAvQMDvAAA/v38/vz8/fz7/v39+/z7/f79/v79//7+///+1L+0q3RWu5aC6uHc/fr56q2tnsep8fTxz9vT18jEkF5Gi1IziDQHfSsBfzQMuZB7ncaozdzSYX1Ns384iUsagTQPlEQZjT8WhzsShy0AvYty6ayrn8iq9/n71de9bHU3p3pigjIHhDoThTkRiz4Viz0UhzMI6+rj7rW2twAAAGcVptCz69zalqCHiqyGu9K9mFI1gzMIgDgSfzcSgzAFjz4Siy4Au5yF77q8tgAADnQpAGcYmcGiiKeJYnNGv6illGpXhjcPiDcMkFo9wamciksphjIHvZyE87m8vQAAvAMDD3MrAGsMesKD6aq2sZ2PiaRzeVgoiGM0cS0HgDAGgDgQya2e39/ei1tBz6ecmsmYXS0AyAADugIADHQqCmUOp7mT6c/TPWwoja+DyqGL1q+Js3pml1xDeDESeyUAsnZYwLKl4MXEjsCMbCMAugEAC3QoDmofVZJM6vbub7R2LIYrWFMrfLOGhsSTwKqHmHAauZh6oXxjuXx12ebaUok+rAQAwAABuwEADXMqCXkQnLyN/+TthZN3ZKl1RI04E4QaI3oWHn8AVZhJG3sb4q+1o8qlJl8CvwQFAGoZor6jnK2DdrBwz8/ecbzuc4+oiEU5YDYLZ2Zajaipw7ymldOgdKxz4ZybuwICp8yx5/HmJ4snpa+FsK+mdIuUfTwsgzsyiHV3ncfAxMWuJYQgsua+9rS6tQAAAGkXnsao+vTzmbGKNJAxaaxibIpqd3VnbbBvHYkXs8it//X36Kyrn8eq+vz77fPs2OvdvLKntKac1+fb8vby/fv6/v7+/fv7/f38XwR2EQAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFNSURBVDjLY2BAAEYmZhZWFihgY2Hn4ORCAIbhrpCbh5ePoEJ+AUE+IaBiQYImCvOxiIiKibNIsEjiUSjFIi0jKyevoKikzIfXRBUWVTV1DU0tbR1dPRZ9PAoNWAyNjE1MzcwtLK2sbWxxKrSzd3B0cnZxdXP38PTy9vHFpdDPP4AlMCg4JDQsPCIyKjomNg6HwviExKTklNS09IzMrOyc3Lz8gkLsCouKS0rLyisqq6prauvqGxqbCpqxK2xpbWvv6Ozq7unt658wcdLkKVOnYVfIMH3GzFmz58ydN3/BwkWLlyxdxoXLM8tXrFy1es3ades3bNy0ecvW2G04g2f7jp27du/Zu2//gYOHDh85ijMcjx1nOXHy1OkzZ8+dv3CR5RKemLnMcoXl6rXrN27eYrmNN1EAk5kgJN3euUsw4d65c+/enTuDPXPRSSEA9OV48ySYOO4AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NDYrMDI6MDB+rDD1AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjQ2KzAyOjAwD/GISQAAAABJRU5ErkJggg=="), + "fm" to CountryFlag("Micronesia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAR1QTFRFZ5fWaJfWaJjWZZbVZpbWX5LUhazeg6rec5/ZXpHUwtXuvtLtZJXVnr3l6O/5+Pr95+/5nLvkY5XVW4/To8Dm////oL7laZjXvNHtuc/sZpfWaZnXgKjdgajdaZjWYpTVZZbWapnXjbHgdaDaWY3SYJLUd6LajLDgTobPqcToz97yr8jpsMnqi7Dg0uDzpMHmdKDZpMDm4er3+vv+iq/gYZPUjrLg/P3+3+n2or/mdaHaq8bo6fD5f6jdYZPVgqrdTYXPxtjwmLjjrsfpZZXVr8nqlrfjytvxtczrbZvYWY7Sb5zYY5TVe6XbXpHTfKXcvdLts8vrts3ru9DtX5HUn77l6/H6+vz+6vD5mrrkxdjvwtXvXZDTiK7fh63fGEKQlgAAAAFiS0dEFeXY+aMAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAEzSURBVDjLY2CgADAyEqeOiZmZiRh1LKxs7KwsRNjLwcnFzclB2F4eXj5+fgFBIYK2MwmLiIqKCRN2pTinhAS3JKc4QYVS0jKcrLJyxHhbXk5OHq/jYMHMBEaQIMAS9IxCCopoPmBSZObBUCnHo6SsooqikklVRU1dCMO1Gppa6tpyUggBFkUdXT19DTR7FQwMjUSNTUyRjGQyNTMXtbDkUEBVaGVtI8pvK4+s0M7eWFRA00ABzZkOko5Ozi7IIgqubu4eDhiBo+Dm6SWP4nI5eRVvNxeMuGT0YcEMHhYfLAHJhMSABzjetOEjLufDQBhIKfr6cfqLSxFUKMcaEBgUHEI4+ch5hYqKCnoRVMjEIxgWbhwRSTgrMKjxREXzqBHhG+aY2LgYZiIUAiNJgagCgFIAACGpHL8Jj431AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjAyKzAyOjAw4WtxIgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNTowMiswMjowMJA2yZ4AAAAASUVORK5CYII="), + "md" to CountryFlag("Moldova", "data:image/png;base64,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"), + "mc" to CountryFlag("Monaco", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABVQTFRF8xgw8xkx8xQs9Cg+/u/x//////7+xfBoaAAAAAFiS0dEBfhv6ccAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAmSURBVCjPY2AYwUAQC2BQwgIYjLEABhcsgCEUC2BIwwKwqxwZggCotWuVLjeL7gAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDozMCswMjowMBe5DNYAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MzArMDI6MDBm5LRqAAAAAElFTkSuQmCC"), + "mn" to CountryFlag("Mongolia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAY9QTFRF1hUX0xca4w4LSGWcAJbsBIzcAY7fSWWc1hYX1hcX1RIX1AwY2SUV5VsP2ywU1REX1A0Y3TgT+8ID2y4U1Q8Y1RAY2ysU63oL3C8U1hQX9aQG/s8B+bcE2CAW1xkX1RMX74sJ97AF8ZQI3TUT1hMX1BgZ0wgZ2SEW41MQ52YN5FgP2igV0g8b4w8L4kwR6W0N2ioV5mAO7H0L5mIO3DIU6W8M3UYU4gkMSWec/98A4UcR2B0W6W4M9qoF6GoN1xsW5VoP/+QA6oQN4AIMSWic74kJ/tAB3jsS5V0P8pgI854H5V0O4kwQ/9QA6XsO4AMM/tEB4EUR0wgY52MO6nMM3TcT0wUZ/9UA6XwO3joT4UoR/c0B63gL7ocK2B4W41IQ/9YA3jkT4k4Q8pkH/MYC2y0U4k8Q/9cA/tIB4EQR0gQZ41UQ63YL0QAa5FcP4EMS52cN7ocJ7oMK5FUP8JAI/9kA4UkR7HsL7HwL/90A6oAN1A4Y+LME3j0S0wkY4lAQ0wYZ+LcE5WwQ4QQM////bDwefAAAAAFiS0dEhGLQWnEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAD/SURBVDjLY2BAAEYmZhZWNihgZWFnYmTADkYVDj6FHJwcRCnk4OLm4iBCIQcXDy8fPwdhhZwCgkLCIkQo5BAVE5cQJUIhg6SUtIwsFwcBhZxy8nwKikrKKnKqeBVycKuJqGtoamkLqOno4lPIr6dvIGdoZMxhYmpmboFHIbeSpZW1ja2dvYOjk7MLHoUCrm7uHp4KXt4+vn7++BRyKwQEBgWHhIZphUcQUOgbGRUdExsXn0BQYWJSckxKalo6IYUZmVnZOYa5eQSsFlBwyy8oVCjSLPYlYGJJaWZZuU2FVV5lFd7gqY6pqa2LV6hv0GtsasanEJy6q4GQgxNvogAAwKY43gNfgNYAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NTkrMDI6MDBETkCCAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjU5KzAyOjAwNRP4PgAAAABJRU5ErkJggg=="), + "me" to CountryFlag("Montenegro", "data:image/png;base64,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"), + "ms" to CountryFlag("Montserrat", "data:image/png;base64,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"), + "ma" to CountryFlag("Morocco", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAn9QTFRF6wAT6gAT7wAS7AAT5wIUzA0Y7gAT8gASzwsXUDgr6AET+gARnR0fAFQ30AsX6QET+AARWTUpAFo5jSMh+wAR5wEU2wcVHEoyAFY4Qz0t8wAS6QAT+QARnxwfGkszDk81zgwXUzcqC1A1kCIhjiIh/AAQ7QAT3wYVEE80OUAu6wITDlA1MkQw8AAS7gAS9wER/wAQpBoeAFo6gicj/wANTjgr6QQT9wAR6gET8QASqBgdTTkrWzMpXTMpWTQpUTcqQjwtXzMophsdUzYqUjcqVDYqSDosSzkrTDkrSTosVTYqvxAa6AEUeygkBFY4AFg5GUszHUoyBFI2figkH0kyOkAuhiUiAFg4BVI2GEszCFE1Ek00G0szqhcd7AETxA4ZMEMvAFc4Rzos0AoXnhwfeColzAsY2wYViyIiygwYuxEaLkQwXjIo5wQU9gAR6AMUXzEoAFk5GUwzuBIbthQb+wAQ7AITliAgAF47ohoeAVY3DlE1lx0g7gET7QETmxwfEFA1aS4nmR4f6AQT2wgVBlI2by4mJ0Yx0goXzQwYQD0tAFw6Oz8u6wET8wESRjwsCFE2whAZ9AAS5gEUxw8YbSwmA1c4bS0mNUIviSQinB8f5QIUJUcxbi0mqxcdRjsslB8gMUMwuxIaBFM2UTgq9QASbi8moxkeH0ozZS8n1wkW/wAPN0EvE0404gQUvREaaS4mAFs6E1A1phgdkiAhDk80kiEhsBYcFE00L0QwrxUcIUkyai8nDE81A1Q3CVM2hyMi5QEU5gQUWDQpA1M2MUMv/QAQfygjNkEvww4ZkCAhC1E1AVQ3xQ8ZMUQw9QARdysl0gkXrBYcjiEh////1mO7jgAAAAFiS0dE1Am7C4UAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAHMSURBVDjLY2CgBDASq5CJOJXMLKxsxKhkZOfgJMpILm4eXj52fiIUCggKCYuIEraZSUxcQlJKmrCBMrK8cvIKhO3mklFUUpZQUcVpNyMXGIiqqWtoamnr6IpC+BgGM+qpcsvIcMvoGxgaGZsYm5qpmgsImJtzm1ugqrOwtLK2sbWzt3dQceR1cnZxdXP38HS39/L08LZEMZSRwcfXz583IDAoOCQ0LDxCPlI+KjKaVygmFj3sGeMM4hMSk5INUoRSWdLSYzMydbOyJXJyuTHjSDQvv6CwqFhFqKS0zKC8QriyqrpGphab57nquOsbChubmhlF1VpaPdraO0S4sMc5I5dIZ1d3T7xAb596/4SJZZNwx+PkvClTp4WriEyfMVNoVulsPPHCPGfuvPkL5lcsXLR4iQAXTmX8Syf6LzNZvkJo5arVa9auw518RVVTJdZv2Lhp85atVtsKt+MxUi9hx87u+R0Gu3aHJ/HuwZko+SdN3Ltv/4FJ7AdlDh32P3K0F6fNx453nzipasHP7FMrc+r0mbOTcCRKZoZzK2vPi0KCVDU+5sIx7HYzWl68pBoH84CoQMtlZlx2q51HijMupj7cGQc16RGRZbEAAARidfCTzzjjAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjAyKzAyOjAw4WtxIgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNTowMiswMjowMJA2yZ4AAAAASUVORK5CYII="), + "mz" to CountryFlag("Mozambique", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAeNQTFRFnjsAH4gAAJwAAJoA/gEAwCYAN3kAAJsA/wAA4RIAYGAABpcA9AYAjUUAFY4A/QEAuSoAMH0A2xYAV2UABJkA8QgAhEoAEZAA/AIAsS8AKoEA1RkAT2sAA5oCAJsB7AoAqGItmcmMmNabmtaa/wEA/yAA/wYA/wYI6UBDf1hbV1daWlda+AAA8AgA/3kA/QAA6QAA6gAAywAAQgAAAQAAAAAA4wAAZQAAaBkA7a4A2UcAigAAugAAcgAACwAA/wUA+iUAZwkARRsAtU8Cdl4Ab0YDtTAB+jIA/zAA/w0A+QAAoAAAHwAA/wMA9DoAe0UAs5MpiXM8UU5Dk4dl6MFZ/LMB/18A/woAygAANgAA9iMAfE4nSExRcXFzmZugoZaH8UYV/wIA8QAAjAIDYkhArqyaubmt0s2xmYpztxQUnwAAHgAAdgYC5pAW8LEc7Wkp9aAW8bAPsxkC7wAA/AAA+B4A/4UA/zIA/xsA/30A/D8A/xIA/xQA/wsA/xkA50BDe1hcU1dbVldb/3It/dyM++ma/eia/yEA/4wA/8oC/8sB/8oA/z4A/6kA/8wA/2EA/70A/xwA/8gA/8sA/zgA/6QA/wkA/1oA/7oA/xgA/34A/8cA/58A/00A/7IA/80A////7pRuwgAAAAFiS0dEoF7TvqAAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAE8SURBVDjLY2BgZGImBjCwsLKxE6WQg4OTi5sIpUCFHDy8fIStBynk4BcQJKgSrJCDQ0hYhJ0ohRyiYuJMRCnkkJCUYiJKIQeHtIysHFEKOeQVFJWUcQGYQhVVNQ4OdQ1NLW0cAKpQR1dPVd/AkMPI2MQUO4AoNDO3sLSyttHh4DC0tcOt0N7B0cnZxdXN3cOTg8PL2wenQl8//4DAoOCQ0LBwkPERkbitjoqOiY2LT0jkIKAwKTklNS09IxPE9srKxu0Zo5zcvPyCwqJiAp7hKCktK+eoqKzSJxg81TVAorZOvb6hsQkHQI5Cz+aW1jZcAElhe0dnVzdOAFeY2NPb191NWGFt/wS86mAKJ5ZNmtxNWKHKlKn4jYMqnDZ9BkF1IIUzZ82eTFBdN4NK+Zw+ItR1M8ydN58IZd3dAGl4IBF3SitoAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjExKzAyOjAwHClrIQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNToxMSswMjowMG10050AAAAASUVORK5CYII="), + "mm" to CountryFlag("Myanmar", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAXFQTFRF/ssA/ssB/soB/ssC/skA/tUz/swE/sYA/+eO/csA/csB//bU/8sA/8wC/8oA/9Mr///98MkD8coH78UA9+J2////QrQwQrQvRbUyRbUzRrU0PrIq1O3MMLI0MbI0LrExIawkIqwlI60nI6wmJa0oG6ofRrpK/P78NbIzNrI0MrEvRrlEidKIgs+AfM16f859gc9/dst0r+Ct/f79NLIzNbI0j9WPIqshTrxN0+7T+v36+/37OLM3LK8rMbEwpd2lNrM1JawkcMlv7vju/v/+NbEzObM4I6ohW8FaMbQzNLU2JbEofs9+//z8QKkzQakzQqo2N6QpxOXB/P37//393jE53jM63S0030RK+/Tz96mw7SY57Sk87Bgs9HJ///7+/vX28nmD6Ros6Sk56Sw86Bst97a7+s/T7UVU6Bgr6is86ig56ik66SM07DxL/vT19qGp6iM16SAy6iw96io76R4v8GFt8XJ96BUn6is76ik5/9r9PgAAAAFiS0dEFeXY+aMAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAGWSURBVDjLzYzpNwJRGMavZAtZ30SkFKO9NFTaFCpLthKlDVFmsrQhf70ZJt1GndMHH/w+3HPf5/mdB6F/RU9Pl6JA0JXWK+zrE/Z2IfYPDA4O9P/Oh3iIRMLhYaFIxM/RCI9R8dj4+Jh4lJ+jCR6TU9MA01OT/BxJOGYk0lmWOdk8wLxs7uuQMjEHWuCQLyqUSyqVenmFACBWltUq1ZJSsShv9Gj1G41WpzcYTSazZQ2sVlizmE0mo0Gv02o4AZEN1jeYqVaIjfWfuimSNrsDNp2ElVWshHMTHHYb2U50uT1efM/rcbvaiuQW6fNvww4r7cC238cEmLiLoQkEQ429UDCgwTu0h7N/cAgEhMPMc3iw31KhI4zjk9MziEQBohE4Oz05xjt0jhG7uIxDGBIJ5olfXsTwDl1hJFNpyGSvb26usxlIp5J4h24xcnf3kC88UNRDIQ/3dzm8Q3ST4uPT80upXKHpSrn08vz0WMRKXKzWXt/e6Tr7rdPvb6+1ageR/qBrFLdSpGrM2UlkRtt+24id+XvxE+JR8JVjkHRbAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjQ5KzAyOjAwiORAHAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo0OSswMjowMPm5+KAAAAAASUVORK5CYII="), + "na" to CountryFlag("Namibia", "data:image/png;base64,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"), + "nr" to CountryFlag("Nauru", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAUdQTFRFACFwAyNvABl2SUtU/7gJ/7gK/7cJ/7oK/rUI/7cISUtTSktUS0xVPUBMZmRkZGJjTk9WTE1VAhh1AAhrR2GkHzeKWWWlV2SkJz6PSmKlAARoBCNvASBtEzB3GDV6KD2AzNHgwMfZxczcz9TiKkGCKEOEACBtACBwgZG4tL7V5urx////7O70xMvefY62ABtsASFwASJwByd0LEeJ3ODr/Pz95OjwRl6YGDZ9AB5uQ1uWpLDM3+Pt/f7+6Ovym6jHRl6XACBvAiNxABRoITmA4ebv/f3+/v7+8vT4RVuVABBlAB9vCSl1gJC4YHWm09jm9fb56+70VWugeImzHTqAAB1tASJxBSd0M0GEmKbGdYaxlaLDdYiyY3CjAANdBSVzABxtLEiJDCRyLkSGU2adABFlL0qKACJxAR5uBiVzCSZzACJwASBvvmnAZAAAAAFiS0dEKyS55AgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADYSURBVDjLY2AYBUMdMBIJGJiIBAzMRAIGFhhgZWXBB2AK2dg5ONg58Snk4uJi5uLm4eHl4+cVEOQGcrADiGeEhEVExcQlJKWEcHsG6HNpGVk5eQVFJWUVVTk1aVzBAwbqGppa2to6unr6BngD3dDI2ETb1FTbzNzCEK86SytrG21bW207ewdHvCY6Obu4aru5m3p4ejnhNdHbx9fP3zQgMCg4JDQMn0rHcK+IyKjomNi4eAJJyCAhMSk5JTXNwICAQob0hIzMLAP9bMLJMixMPSc7jLA6KgIA2H8hEx4mkdgAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MzIrMDI6MDCAJh3/AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjMyKzAyOjAw8XulQwAAAABJRU5ErkJggg=="), + "np" to CountryFlag("Nepal", "data:image/png;base64,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"), + "nl" to CountryFlag("Netherlands", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAACdQTFRFrhworh0prBcjtjI9/PX2//////7+/v7/9ff6NliWHEKIIkeMIUaL9LL7PgAAAAFiS0dEBfhv6ccAAAAJcEhZcwAAAEgAAABIAEbJaz4AAABASURBVCjPY2AYfEAQC2BQwgIYjLEABhcsgCEUC2BIwwKwq6RQsBwLwK6yAwtgmIkFMKzCAhh2YwEMZ7CAgRUEACAv6G1C11PvAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjIxKzAyOjAwkqZswgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNToyMSswMjowMOP71H4AAAAASUVORK5CYII="), + "nc" to CountryFlag("New Caledonia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABVQTFRFACZ/ASeApbLS////+6228xkx8xgw8anT+QAAAAFiS0dEAxEMTPIAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAaSURBVCjPY2AAAyFjMHBNAwOGUcFRQVoKAgDqd3XHPs6NlAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDoyNyswMjowMB60MsYAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MjcrMDI6MDBv6Yp6AAAAAElFTkSuQmCC"), + "nz" to CountryFlag("New Zealand", "data:image/png;base64,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"), + "ni" to CountryFlag("Nicaragua", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAqBQTFRFYpH1YZH1dZTGZJHuYZH2YpD1YpD2ZpLrbJHVcpHAZpHn5Oz95Oz+3+by1NCs39zC5Ov65Oz/3ubZ4Oji5Oz7393J1dK04ej03+bx1NGz5OHI6O765u7/5u7+6O773+DV1dO23+XuZ4/cgpemeJW8ZpHpYpH2YZH3Z5LmfJa4f5WpZI3eU4f0Uof2U4f1VofsYYrUYYnSVYfuVIfyV4fnXIjaZovIW4njc46vdY2lVobpY4nMZYnGWIfoUob0Uob1WojhcY6yXYbTXYfWVIbvXYnhXIniUobxW4fccY2ub422V4blaJDac5PCgrCofqyzW+q5Zum5///////+9fDZ8erM/Pv0///57s13rIZNr4lM8tSG///9+/nx8enH+vbo/Pr07eO09/Ph8ujHjo54cneElJR79u7T8+7X8OjB/v78+PXo6uK5+ffs//3upd2rKcTnLMfiLMTiK8TlseGv//70+ffr7ua/+fft+fbn7uW6+/rz3vW7MvfRCP71GPHkGuziA//6OPjQ5vfG/Pv17ubB9/Tl9/Ti7uW3/Pv3//jih82yQMqQZ8thVM99Ws5yXM1vO8+6lc+2//vq+/r17ObK+ffv//7+/Prv///81dCvWHupXY9TdJU7c5Q9c5Q6dpY3bI1eZICl3di48+zP/fz2+vTa/v35+/PQipixSG/nSnPlSnDlSnLjS3DjSnPiS3LgSm/jlp6u/ffb/fvw+vXc+vjw8+3T+fHL3NvE19jN2NfM19jM19fM19bN39vD+vTS+fTf+vfrXIjbbIq0do6kZYrJV4flU4fxVYbsWofdY4nKaIm7aYvBXYjbUof0WIjnaIvDZYjBaYzEZ4vHbYu0Z4i6YYnTVIfwVYftWIfiXIneXIjfWIflVYfsUof1JwACHgAAACx0Uk5T/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v4R0Yc9AAAAAWJLR0RSDWAtkAAAAAlwSFlzAAAASAAAAEgARslrPgAAAXhJREFUOMtj0CESMAxRhbq6RCjU09HRNzA0MgYx8Co0MTUzt7C0sraxRVdohwzsHRydnF1c3dw9PL28UWTsGJABo48vEzMLq58/Gws7BycXI4okNwLw8PLxC/AICgUECgvyiIiKifMgSTIEIUBwSGhYUFB4RGRUdExQUGxcPJJcELLChMQkIJmckpqalg5kZGRm4VCYnZMbFJSXX1BYVFxSGhRUVl6BQ2FlVXVQUE1tXX1DY1NzUFBLaxsOhe0dnUFd3T29ff0TJk6aHDRl6jQcCqfPyJo5a/acufPmL1i4aHFQ9ZKlOBQGLVu+YuWq1WvWrlu/YeOmzVu24vJ10LbtO3bu2r1n997du/ftP3DwEIpC5ACXkJSSlpEFAxk5eQVFlABHBixKyiqqLCwMaizqGppa2iwokqiJ4vCRo8eOnzh56vSZs+fOoyYKtOR44aLjpctXrl67fkMPf3rU07l56/adu/fuE5EV9O7r6enpEKGQBrmQTgoB+l4eQVzTJI0AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MjgrMDI6MDDo/EIvAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjI4KzAyOjAwmaH6kwAAAABJRU5ErkJggg=="), + "ne" to CountryFlag("Niger", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAQJQTFRF/3AA/3EB/20A/3oR/3oS/3kQ/3cN/3gO/3gP//Xu//bu//Tr//fx//////79//r3///+//bv/76L/6FX/69x/+jV//7+//78//Hm/4Qm/2IA/2cC/2UA/24D/9Sx//37//38/6dn/2MA/3UH/3IE/3QG/2oA/38k//v3/4Uq/2wA/3EC/+LN/4ky/2sA/3ID/24C/+bU/7mE/2EA/3MF/3QF/2QA/489/v/+/v79/v///vz6/qJY/mgA/mYD/mYA/oUm/urZ/v78/+DJ/8OW/9Oz//r28fnu8fjt8fjs8f768f//8f/98frv8ffrRKcRRKYPRKUNRKUOMp8AN6EBNqEAvQnPDgAAAAFiS0dEDfa0YfUAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADISURBVDjLY2AYBfgAI5GAgYlIwMCMACysbOxsHCzMWAEDJxxwcfPw8vHyc3NiBQy8cCDAKygkLCLKK8aLDTCIwYA4r4SklLSMrByvvBgWgDBRgVdRSVlFVU1dA2g2FhMRFvNqamkzMGgz6QBdikchEOjq6QMVGhgSUCjPa2RsomJqZo7VL7wMFjBgaWVtY2tn7+Bo5WSBBTCgaHN2cXXD6hWgie4I4OHp5e3j6+eOFTD4I4OAwCB/HIAhmEjAEEIkYAglEoxMhQD8ha3yJTdg0gAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDoyOSswMjowME6LSZsAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MjkrMDI6MDA/1vEnAAAAAElFTkSuQmCC"), + "ng" to CountryFlag("Nigeria", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABVQTFRFNqEAOaIDKpsAvN+p/////P77u9+patqPNQAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAdSURBVCjPY2AAAUZlVxcgCEkSYECAUcFRQRoJAgDKtUNjjeTzkwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNTowMCswMjowMHb0YAsAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MDArMDI6MDAHqdi3AAAAAElFTkSuQmCC"), + "nu" to CountryFlag("Niue", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAYAAABe3VzdAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAACCBJREFUWMPtl2t0VNUZhp99zsllJkCYXAZCigkiKQpEhECCia0IWdxCLMaAJqYqRGpYyx9aS6223lpbLK21lsvEBUG5CIjWIEW0lshFTAIGrOUaUDCYBJhM0jC5TWbO3v0xEzIxCau2P/zDu9Ze57L3/vZ73u97915HnEhNVfZHHiEyOxt94ECOHqvj9y9+QGnpEdzudkCjb0gyM8eyY3sRdYsewLV5MyLQo4CYggKGFK8hK2slZWXH0TQdACFE4ApKgVKKhOvt/HjBLeSP8sL6YlqrqrCmpGAvXIRhRERQ+9ijuDZsIPbhh7kpMxPHqwXkzk9h9ao97Nlzkvb2zqsQDUIwwyvwP0ipgp79bWh8NPPm3MT8G3Xiy9+k3fF3jKFxxD/7LFEL5tMUMgjjrfQl3DGjAcuH26hZ+CCWiSnEFhWRNXMGd0wbza73jrJq5UccOHCGzk5vv0SFgIG36aCBe5/Zzxd0E8uZO5YFYwziy/9G6wu76Iy1E/fUU0Tdey8XxQBe2XKINzZWYDzz4m7WJMaSN3cRd06bh+V9P9HwiSnYi4rImTWTzBlj2FH6GatX7+HgwbP4fL5vyoQWBtH5IQgdWivNPlSUxMVHc1f2OO4ZF0J8+U5anttJe3QMQ5/4BVF5eVxgAK9s+ZR1JR9z7FgtUkoM01R8UV3Pb/50gS1Jw8if+xPmTr+EeP9NvnrwQSwpKdiXFJE/bzazs5J5e9unOBx7OXz4HCC7K7ID6pd3IgDZ3p1uhSJ2SBQLcsazIDmM+IqdtD6zgzZbFEOWLiU6P596BvLy5kO8tu5jjh+vQ0oZyJSGoZR/ESUVp0+e57lTtWxKGkb+nCXMnlpHyK6tnL3/AayTJmFfvJjC+bPJzk5m48ZKamoarwglAN8Z2aMUNU2jIG8yI31OEg5/gPv5d2m1DiDm0cew5eVRLwZRsvEQr5UcoLq6Dj+XrhIKxFrp2K9MU+JvCtOUeL0+FILRNw1j2vhoKN+H5+xZhGFgTUlhQHo6hITQ2ubFGqZTU3Af/9pcykmGAvB9LpBccDeJ69ej2ttoq6jA83UtwmIlInUyocOH09ru5cPdpzh2tA7TlAF3qyvO7rqKtrLdSvW2HgCm6R8oDD2QL4Uyuw0gBCAVbyzbygsfuRHxYei6orOmk6em27jvZzkoIRC6HhgMSImSXUoLdF10S97T+CAEoiosrDezrn4dtAiB2ax6BwE0FOew8bh2B+fMgRQtPE1EhI8//OVGEowWlptlXE8jsq/JgB4pkC0KZfa3vo6hPJ6+e3UYPMcgcoZB/XIvnjOyz2GHsTF4vI+1RRVMm3oRXZckj/k3K4qTqKq0cT0X6EuB8CSNoY+H0rzTpGmHL9hvQRz0q+y+JqgOMC8rVEe/IuNFo+qzKD7YHUd0bAcxsR72fGyn/GAMXvR+58kOhXlZIT2qb3IBGJrF4j9z+oB7v8C9D5QKRwvvPUagGIubyA4fIHAUJ+HzCaQUDMLHuHA3gjC0PlLscwnqngVEaJ+xuxQUbXs/Ul3LBUOhkKZCBZPXNITmF11JCVIiFbz02x28efxrvmyKRkkYGe0iNzmBn/58DlpwgoMNoxRKSoRSaLpA9FWnAow/HvAghP8Q72pSSayWUDIyRjFx/PeuGNBbV0dnbS0oRfjw4RhxcaAkBWtLiCvbyxGuA2D8hfNkZs4icurt3e4FzOZmWisr8blcaBYL1kmTONqos29vNR3tHjS9t9bGr558K7gy0HWdCRNGULTkh4xMjEII6Dx/nsYNG2hYtw5d17Ddcy/VqTM5truGu3NuQUeSipM0nAH1wUDi9Um2bv2UpKQhTJh4HYbVimaxcHnXLprfew8jNpaI+fdhtdzIpndOc7jqS6Rp9sim4d+5JZqmkZycwOLFt5GbO5GYmAH4Ll7k0suv4iwuxmxowJZzF+7MHByfd1Dy8LskJtqY96ObuzyFESkCSgV2VqXYvLmSiopz5OZOZOGidCbcmk5iWhotFeU4HcW4V7zE7YkJZMzLZ9eM6ZSUnuTEsa9RUgECQwhIShpGYWEGefmTGRYXiely4SzehHPVKnznaxiclYUnO48tXwhKni7n1IlalJIkJkR117MV4p4IRWhQ+7wnaN8XNDZeprh4D2+/fZg777yZRYUZpEzJYETaFFoqKnA6HHS88iLZo25g6vwF/NX1AzZuP8FX5y5hLFt2F7m5KYwYEY3Z3Ixr/XqcK1bgOXWKyMzpyCd/zY6LVtb87iCf//MrpNl1XvasFtkGntMSNP99z24BaDQ0uFm7dj+lpZ+RlZVM4UO3MTktnRFT0mipqMTpcBC6ahn3jx7NzAdyeKd+FMbSpTOQ7haatm7j0sqVtB05wqCMdMJXLKWsNYbiP1dRdegMps8MENODFg12PThf8wZS+01yXVf/vcvVyuuvf8L27Z8ze/Y4Ch/KYMqttzIiNY2WgwdpcDiwrV3OQyOTMFo/2YarZB2Xd5cRGj+MBMcvqY4dQ/GmI+zf+y4dHV7i7b3d5TMlQ6Ob0MzzhNjaCYsDoQe2IFNiDG5D+Gqw2xqJt7dgGL3PBKVa2PuPeo4eOcCsWWNZuCidG1KHM3z807RVVtC0aSOi80CYku0ehAZ6dBRaZCSX6ptpbelA1zX6OUZBQXh4CHb7QMymRmRbW49uzRqBHmXD6Wyhva2z/zgBxaUpGRRpYfBgK5om0AwD5fMiVDWqx7+E6pGNq+Nq479trOA5QTD6etnnu28Z+H+O9Q38F79q3y2uEbxG8LvGNYL/L/4DbvNy7iZmTA4AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MDIrMDI6MDDha3EiAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjAyKzAyOjAwkDbJngAAAABJRU5ErkJggg=="), + "nf" to CountryFlag("Norfolk Island", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAf5QTFRFI4cLyuLEy+PFzOPGzOTGGYIAGIIA/////f39+vr66/Dq2uPYwta9mbyR5+zmhq59dqZr4Ofe/P37ucq1V41KQoQzkK+J/Pz72+bYaZldRIM1QoUyaJ5b6vHp/Pz8kbmHRIczRoc2PYYsWZBM3ObZ7vLtb6RjU5RET45ATI88UI1CjbaD8PTvzNzIRI4zWpNMO4koTJI7QY8ulb2L+/z7n7+XSI04Y5ZXXpRRK4MXJ4ERJIIOfKxx6fDn5+/lWptLHoAHM4cfQIsvMYMdK4AXHIEEQY8vvNO2bqJhOYomU5ZDP4stLYIZJ4IRJoUPVJdEo8Kc9/n32OPVeaduYZtTQo8vMocePossVJRFNIggW5dMnL6U+vv6vNG3d6VsTo8+N4kkLogZMoQfT41AM4gfQIoucqNm2+XZp8Kha51fP4otKIUSNogjJ4MSOIolLIMYXZZPbp5jwdS9ydrFbaNgSZE4I4MMJ4QRMogeKIMTJIMOIoEMQ44xYpxUk7mK9/n25e3iZaRWPY4qLYgXL4UaIoMLQI4uLIUWJIMQJYMRRoo2Z5pbc6Fo4urgtM+tXptQUJVASpI5Oo0mJ4cRKokUT5o9da5oosKbl7uPnr+W6vHowtm9w9u+3OnZ4uzghLZ4XqJO8vXx/v7+lsGLWqBJmMKOS5c48/by3+vc+fv5XViUGwAAAAV0Uk5T/v7+/v48tsTrAAAAAWJLR0QHFmGI6wAAAAlwSFlzAAAASAAAAEgARslrPgAAAQRJREFUOMtjYIUDNgZGdhTAyMCGkGUYXAo5OIlUyMVNpEIeXuIU8vELCBKjUEhYRFRMnAiFEpJS0jKyhBXKySsoKimrEFaoqqauoamlrUNQoa6evqaBoZExBwGFJqZm5haWVtY2tgQU2tk7ODo5u7i6uRNQqOPh6eXt4+vnHxCIX2FQcEhoWHhEZFR0DH6FsXHxCYlJySmpael4FQZmZGZl5+Tm5RcUFuFVWFxSWlZeUVlVXVNbV8+EUyFzQ2NTc0trW3tHZ1d3Ty8LHhP7+idMnDR5ytRp02fM1GHCo3DW7Dlz581fsDCGfdEiwgl38ZIY4lL40mXLiVO4YvbKQV8AYFUIAO64TwOh9tA5AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjU0KzAyOjAwJZkhQgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo1NCswMjowMFTEmf4AAAAASUVORK5CYII="), + "kp" to CountryFlag("North Korea", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAASBQTFRFPVWVPlaYPFSXqbfV766txwMDxgICxgAAxgEBxwYGxQAAyRAQ2E9P5o6O7a2t7a6u0zs78Lu7/fj4/////ff3/PHx/vj48Ly80zw81UND+N/f8cLC55iY+ODg1UREzB0d9MzM4Hp600RE/fb29M3NzB4e33Jy++/v0Tc3yBIS9NDQ//7+4HR0yAgI77i4/fX155mZ33R04Hd322JixgoKxAEB1k1N3nJy3Wxs44SE+ebm77q6yxUV9dTU88rK1EdHwwICwwAAxAAA0DY29tXV++7u4Xx8xQYG22Rk77e36JmZxAIC11NT2mBg11RU/vr6+ujo1EZG5IqK/PLy6J2d0z8/9tnZ+eTk8snJ//399dLS997e+OHh8K+u8K+tqLfVj+46eQAAAAFiS0dEEwy7XJYAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAEESURBVDjLY2AgFjASCWigkIlIwMBMJGBgIRIwsEIBGzsHJycHOxsrDsDADgFc3Dy8fPy8PNxc7NgBTKGAoJCwiKiwmLgEXoVcklLCwsLSMkBCVo4Lj0J5BaASYUUlZSCpoopbIZcaSJ26hqYWkNLW4cKpUFdP38DQyNjE1MzcwtLKWhenQhtbYTt7B0cnJ0dHZ2ttFxt8CoVd3dydnEw9rISF8SjU9QS6zdrE0dHUC8jQw2012DPm3j6+7n7+wsJ4PAMKnoDAoGChkNAwvMEDDHDZ8IhIoLFR0TF4AxwUhf6gsPQnEIXQRMGHL1EQncxiESAuLhY3YIgnEhCfuQawACAWAACoS0iV+rowZQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDoyNSswMjowMIkrI+8AAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MjUrMDI6MDD4dptTAAAAAElFTkSuQmCC"), + "mp" to CountryFlag("Northern Mariana Islands", "data:image/png;base64,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"), + "no" to CountryFlag("Norway", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAARdQTFRF1ygo1ysr1Rwc3mBh////qbraACyRBz2aT3K05omK1BgY2Cws1yoq2C0t1R8f32JjT3O054uM1Rsb2C4u1R0d1iAg0xER3Vha5YSF0g0N1iEh3FdZ3Vlb205Q4YKEprjZTnK06KGk2ktN3Vpc+/z+qbzcUHa4/P3+bYzCa4vCdJPGSHC0ADOUAzqYIlKlc5LGbIvCACqPACqQACmPAC+SADmXADiXADSVCD6aCD+aBTyZAjqYACuQmq3Tmq3SmK3TpbnaZ4jBADGTBDuZMF6ro7jama7U5oyN546P7Ly+TnS28trd6qOk7Kqr66iq0QgI5H1/qLjY7Kao0QoK1Boa2C8v5oiJqLnZ7a2u2Csr1BkZ5YaH7aytF4hs4AAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADjSURBVDjL7dLZcgFREIDhzuggBhFGbCGWxBISDCbEFmIn9sSW93+OqHNmXHUpVW591391VZ/TANyVoMNrvUFvxBuTCEdcQjo0cxbrLQtteGd3mAkgcc57lzrR7fFKBPBxD/4APu7DIIbCER8BUPOEz/swijEkQVyTeEmmXlNv6UycBFmNnMsXlMJ7Ts6SoHhQ+lAUpVwq0qByILOJcoUGVVWt/tlofjVb7U6VdPrWXa7n7rN3HOBw9D0mgIkTJlOcsS+cL6QlAUTuR/jFFQvXkmND0G5D3O7UiX/LzbEzu4Tnhf+7jWdEJBC/LQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNToyMyswMjowMAU5fesAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MjMrMDI6MDB0ZMVXAAAAAElFTkSuQmCC"), + "om" to CountryFlag("Oman", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAASNQTFRF7y0p7y4q7ygj7ysn7ykl7ycj8UhE//v7//////7+7yom8lhU7iYh811a9oqH7h4a8lJP8DYy7iUh8UhF7y8r7iIe9HFu9Xl38UNA9Gto8UpG95WT7ykk7iAc95OR95aU+KWj8D057hsW7ygk7iQg9HRx+KOi9Xd0+8rI/N3c95WS95qY95ya8UdE81xZ+sLB95KQ+ba17zAs9Ghl82Zj7yci7ywo7zIu81tY+8fG+bCu9oaD9oaE7RUQ82hl9oyK7h0Y9Xt595iW8DUy/vj4//39//z882Fe7zEt7h0Z82Rh9X177iMf8D47+ba0+rm4+ri37iEc7S4p8Cwp+Skp6S8pwz8owkAo9iop0DooBZAlAJIlAZElAJElBY4lAJAlAZAl6Dk6bwAAAAFiS0dECIbelXoAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADQSURBVDjLY2BgZGJgZmFkZWRlY+fg5MAJGBi5uHl4+fgFBIWE8SsUERUTl5CUkmaVIWQiq6ycvIK0opIyAYUqqmrqGppa2jqsuvgVCunpGxgaGhmbmBIw0czcwtLK2sZWlpDVjEJ29lwOjk7OQsIuruxuOAGDkLsNK7OHp5e3D4HgYfAQZWBkMPJhYPb18w/ADRgYzEQYgABIMAfK4gEMSMAIH2AYriAIH0BSFxyCDyCpCw0LxwMQ9kZERkXHxOIEyArj4hPicQLyFMaOKkQDAKnWwb8cLwtuAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjAyKzAyOjAw4WtxIgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNTowMiswMjowMJA2yZ4AAAAASUVORK5CYII="), + "pk" to CountryFlag("Pakistan", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAVBQTFRF/////P38x9nGBFQDDloNDFkLDlsNDVoMDVkMAlACDloMCVcIBVMFYJJfK24qB1UGCFYHD1sOClcJC1cKu9G7fKZ8AFAAJmsmAE4ADFkMtMy00uDSEFwPAEUAdp52aZhoNHQzAE8AVotWY5RjClgJNXU1u9C6BFMDwNTAN3Y3AlIBC1gKRoFGr8mv+/37zNzMOHc3BVQEBlUFI2kj8/fzMHEvAEcAPnc+g6qCO3k7Q35CAVEAGGEXElwROXg4/f79faZ8AE0AEVwQClgKC1gLB1YGHmUd6/Lr3OfcEFsQC1kKAFEAs8uym7uaAEwABFIDRYBF+vv6m7ubAlICBVUEAk8BWY5YJmsliK2I+fv52+bbdqJ2Ong5W49by9vKe6V6AlEChKuD/v/+gamApsKl4Org8vby9Pj04ergnr2eLnAtEV0QJmolJGkjBVMEEFsPgPUI7AAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAE1SURBVDjL3ZPZN8NAFMYvmY1WGNoYxFJCSWyNXVGpXWnttdS+7///myR9wTGRR8d9mXPu/M7c+935LoAfFVCpIBwU8L9BEg6krKp8/gJWR6I1aq1L1SEeBNL6hlhc84o3RkVTAIi05hbhZvXWtnh7h0JlIE90QpfQMTW6Y9CjIemLKNkLfSbCzOofGBwaTiEJiOyRURhLutdkfGJSVyNMAnJzCmA67cudmU3ZVFaamHMZmHeyXn5hkVKparq0vAKra4b/NwyjdakYktsA2MxbWYKQTgtcCvLcFmzDDnN29xRn/6D4ucuvA+eJQziC45NSUT09O0/LxuN54eKynLiCayFV7UmgonRze3f/8PiURzgAdKsXxPPLK3HeAt3jG/fdsG1L/+73n1aBUcowDgGGWoW/CH4A9ssuKRJ51VEAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MDErMDI6MDDQg2u/AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjAxKzAyOjAwod7TAwAAAABJRU5ErkJggg=="), + "pw" to CountryFlag("Palau", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAATVQTFRFSq3WS63VTK7TTa7STa7TTK7USKzYP6rjPanmPqrkPqrlQavhS63UParlUa/NgbyUqMZnuctSt8tVoMRwdrmjSK3YSq3VRqzancN079oT/+EA/uIB/+IB/+AA4dYkgryUP6riRqzbUa/O0tI1/+IA/t8B/d0C/N0E/N0D/t4C/uABsclcQ6veSa3X09M0+90F/t4B/94A+90E/+MArMhipMZserqdQKrhR6zaWLHG8NsR/98A/d0D0NI4RKvdP6rkib6M+t4FY7S5PanlgLyWi7+JgbyVib+L+94FY7S4WLHF8dwQ0NM3pcZq/94Be7qcQKri1NMzrshgTK3UUq/N1NIz/t0Cs8laR6zZn8Ry8NoS4tYihL2RU6/MhL2SqsdkvMxPustSo8Vtd7mgSKzZQarh////G2crvwAAAAFiS0dEZizU2SUAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAEZSURBVDjLY2AYaoCRiZmFhZmVoDoWNnYOTi4ObgYmvMp4GHj5+AUEhYRFRNmZxHCrYxUXl5CUkpaSkpGVk1dgYMRpnqKSsoqqmrqGhrqmlpS2Di51Yrq6eir6BoZgoGZkbMKOw50snKYq+oYwYKAhZWaOVSWjhaWVtQFcoaGNlK0dVley2DtI2RgiA0cnOx5sCp1NpDSQ1alJuWB1JQunEKpCGylXThbiTHTDYaI7mhs9PLG6kVHcyxvF17I+2H0NNNIXKRz9NKT8A7CHOKMuQyByzAThihmGYMWQUGhch2lJhesw4Ew/rIoRkVGg1CMtGx0TgDv1gNNjbFx8QmJSsi47Kx51IB+lAFM4J0cqAwsDAUBsnhnqAACZWDZBbLPFFQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDozOCswMjowMCRWQrEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MzgrMDI6MDBVC/oNAAAAAElFTkSuQmCC"), + "ps" to CountryFlag("Palestine", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAMBQTFRFAAAAHQAAAgAA1wAAgQAAIwAAAQAA/wAA/gAA3AAAgAAAfwAALAgIHiAgHyEhHx8f/QAA6Q0N4GBg4L294OLi4OPj4ODg/wIC/yUl/4GB/97e//7+/////wEB/yMj/39//9zc/yEh/+rq/4CA/wEC/yQl/4CC/93e//7/6RoN4HNg4NC94PTi4PXj4PPg/gEA3BUAf0wALIcIHqcgH6ghH6Uff00AI4QAAZoAAJoAAJgAAJkA1xgAgEwAHYgAApoAZyEukgAAAAFiS0dEHJwEQQcAAAAJcEhZcwAAAEgAAABIAEbJaz4AAACnSURBVDjLxdDHDoJAAIThtY5d7AUBe++9+/5v5XoBVFbnYOJ//pJJRoj/5fOTMBAMhSmISDRGUYCkAEkBkgI2jSeSqbQqBwJaJpvLF4reuSFQKleqes2zZwgYplXXGaik71DShtX8JTTMFjOtYK+w3en2+t/v0QbD0Xgy9c6Bs/liuVpvVAmbbXf7w1GdcLHTpwTHHpBiEp4vDJPwemOYhByTkHQ8vAPna3mr2AmzewAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDozNiswMjowMHRpOewAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MzYrMDI6MDAFNIFQAAAAAElFTkSuQmCC"), + "pa" to CountryFlag("Panama", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAY9QTFRF//////7+6Fpa4CUl4jEx4i8v/v7/4jU12AAA2gMD2gAA4zY23AQE2wIC/f3+0tLw7e352QAA2wMD2wAA+vr9V1fGs7Pl+/v+/Pz+8/P7BwesbW3O8fH6ZGTMLy+7NDS7AACpEhKwOTm+LS26paXh6Oj4UFDFAACnBgatAQGqDAytm5vf8PD6GBiyAAClAACibW3Pra3ihYXXRkbCGBiv9/f8h4fYtrbngYHWxcXs+vr+9/f9/v7+/v3+4jU22wEB+fn9+fj8+v//4jg53AgI3AYGQ0PBGRmzISG2Hx+1ICC1ICC2Ghu0zbfX/+jh+N3f+9/fKCi2AACmAQGpysrtKiq5AwOsAgKsAACqysns/Pv8//39//z8KSm4AQGrAACr+t/f/vn5/vz85FNT+dnZ+t3d1gAA75mZ/vv7+uDg5VVV4Tg43zEx1wAA3B0d4Tw84To69Lq6+djY4kFB2QYG3B8f9La2+NDQ1gQE1AAA7YiI6HBw2xYW9bq65E9P3Scn75iY/Ozs8aOj+dvbAgKr9Hz2CgAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFPSURBVDjLjZFXU8JAFEa/tawaNSqiYI8VK1bsvfeGgpqAioqxYO+9/XAjo4EsknCedmfOnL1zF4iAIC4+IZElTKD0T0xKTuFY/hVTubR0FlXjkZEJ+lvMMmWzqDkzcnJhMRStVuTlF8BiproiRWFRcYlQWlZeoZz1ihSVVbbqmto6UIOnKeob7I1NwSH1Z0SzvaW1zWFY5NHeAXR2KYdoIg0C3oFunu9Rrr196OdMAyyaf6HQ2aN5kGVoeIQbHWPB+MTklIbpmdm5+YVFFiwtOwUtTtuKsoUIVgWXW4trbR0bYhBJVIFH8G5q8QpqkZBQUUck2NqORRR92NmFZChKEvb8+5BlfZHg4PDoOHByenYOUbdIcHHpvwpc34AYPY3bwN39A2SjGWU8Pj2/vIqGRfje3oGPT2ORECKrvR/xK9rCJYLQGvW/MByP4I5J/AZBtblUjIAx0gAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo1MSswMjowMHehDuUAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NTErMDI6MDAG/LZZAAAAAElFTkSuQmCC"), + "pg" to CountryFlag("Papua New Guinea", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAhNQTFRFWgAAAAAAAAAAAAAAAAAAAAAAAAAA1wAA/wAANAAAvAAA/QAAAAAAFgAAjgAA9AAA/xYA/z0A/wcABgAAXgAA3wAA/woA/4kA/7IA/x8A/zkA/8YA/8oA/00A/1sA/84A/80A/3MA/0kA/1AA/wwA/xoA/xcA/8wA/8UA/8kA/3UA/w8A/gAA/wgA/1MA/6YA/8sAjwAA/wEA/zAA/1kA/5IA/9AA/7EA/xwAAgICAQIC/ygA/7UA/6kA/74A/0cABAQERUVFRkZGBgYG/wMA/3cA/9IA/88A/8IA/7QA/4IA/2wAPj4+2dnZ3NzcQUFBFwAA/wsA/2IA/4YA/2cA/zsA/58A/50A/yYA/4wA/5gA/xIAGBgYtra2ubm5HBwcXwAA/wIA/zIA/6UA/8EA/64A/xQA/2EAAQEBBwcHGRkZFhYWCAgINQAAvQAA/xUA/y8A/2YA/1IA/5MA/3EA/4gA/wkAJSUlSUlJBQUFDAwMISEh/ysA/04A/ywA/30A/wUAIiIis7Oz4ODgWVlZCQkJgYGBx8fHOzs74AAA/yMA/1gA/38A/y0AmJiYyMjINTU1fX19Ly8v/x4A/zEAAwMDGxsbDw8PEhISFRUVkAAA9QAAEBAQYAAAX19fKysrCgoKFxcXY2NjNgAAvgAASEhI7e3t19fXkQAAh4eHd3d3BwAAGAAAYQAAHQAAmAAA////z7dyKwAAAAd0Uk5T7e7v8PHy84GHKKoAAAABYktHRLBDZK7EAAAACXBIWXMAAABIAAAASABGyWs+AAABtklEQVQ4y2NgYOcgCjAwcnJxE6eQh5ePH5uMgKAQmkIeYRFRTHVi4hKS6Ap5eLBYLyUtI4upEIv1cvIKikrKKgiFTGCFaNYLqarJKahryGhqaaMrBFmvA1eoq6evb6Curq6gLoepkIfXEGa9kbGJqbw6CJiZW2AotLSCW29to6CpAFKnYWtnj67QwdHJGWq9i6ubu7wH0GoFTy9bb5hCZqhCH18/fx6eAJD1gUHBXiGhYWby7uERkVHRaApjYuPiQb5PAFmfmMjBkZQskZKaZqKZjqwww5InMys7B6wjNw/q+3yLgsKi4pLSMoTCjPKKSrCiqmoeqPVgkFhTWxda34BQ2NjU3JIBpFvb2jvA1nfCwqmru6cXajULUMa5r38C2MSJ7ZNQrDeaPCWaA0nh1Gkx08EKZsyEuJMnYNZs9PTIwoMAczLhTOG5nbgVZsybj6QL7nssJlZVInHQrEcoXODMgwZQrGdghYounLhoBrpKnsVLdDAULl22vBxDIU/AitnoCrNWrqrCVMizGmY9XOHUqVMzeLABqPVwhbjBGrD1DGwEFfKsXttJnEKg9XncxCnkWbceAHS+f+1YQ5uiAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjAxKzAyOjAw0INrvwAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNTowMSswMjowMKHe0wMAAAAASUVORK5CYII="), + "py" to CountryFlag("Paraguay", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAORQTFRF2RUV2hUV2hYW+NbW+dbW9NPT7c3O39z24Nz329n01NTuTTfOTTfPTjjP1gAA/////f7+5+rq2MLB2Kea2KOa4uLi2ZuN32JJ4n9m5n5r4WRK2ZyN4uHi8/X217Oq22Y+joZokJyusrfRq6OF3GZA1rCp6Orr3Y94uHVRV3V2f2eDjHF4cpGSxIRd24d33Ip3w3ddWXp1d2OReWaFYYl9xn5h24V38/b21aqp20ZFnYx3g56ZeZuRlY9v2kdE1aup1o2N3UtL1GRc0mNa3EpK/f796ero2cC/2JmY2JqYPCTKPSXKNU1p8gAAAA50Uk5T/v7+/v7+/v7+/v7+/v7BShreAAAAAWJLR0QPGLoA2QAAAAlwSFlzAAAASAAAAEgARslrPgAAAKJJREFUOMtj4CMSMIwqpI5CTMDIxMSIRZgZHbCwsrGxsmAIM/CjAQFBIWERIUEBdHEMhaJi4hKSUtIyhBTKyskrKCopq6jKElCopq6hqaWto6unRkihvoGhkbGJqRkhheYWllbWNrZ29uYEPePg6OTs4iBK0Neubu4enu5urhgK2dEABwcnFxcnBwe6OAM3BuDh5eXBFGXwIhIweBMJRhXiBQBnBptBvd+qpgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDoyNyswMjowMB60MsYAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MjcrMDI6MDBv6Yp6AAAAAElFTkSuQmCC"), + "pe" to CountryFlag("Peru", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAA9QTFRF/6qq/wAA/wIC/////5CQg6lnGgAAAAF0Uk5T/hrjB30AAAABYktHRAMRDEzyAAAACXBIWXMAAABIAAAASABGyWs+AAAAGUlEQVQoz2MQBAMFYzBwhPAYRgVHBWkpCACA3EcjIZL0PQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo1NSswMjowMIPuKvYAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NTUrMDI6MDDys5JKAAAAAElFTkSuQmCC"), + "ph" to CountryFlag("Philippines", "data:image/png;base64,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"), + "pn" to CountryFlag("Pitcairn Islands", "data:image/png;base64,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"), + "pl" to CountryFlag("Poland", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABVQTFRF//////7+/e7u4RER3gAA3wEB3wAA/OBH4QAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAlSURBVCjPY2AYwUAQC8CuUgkLYDDGAhhcsACGUCyAIQ0LGCGCAM5zc403UJE7AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjE2KzAyOjAw2Y5VrwAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNToxNiswMjowMKjT7RMAAAAASUVORK5CYII="), + "pt" to CountryFlag("Portugal", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAYAAABe3VzdAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAAA9hJREFUWMPt2ElsVVUYB/Dfve+1pa/vQaG0SGmLtEDQCI4QA6JGY0gc4hAwBhNjInGhLnShC2WhOCW6MTEuXKlRExOjJgTBhUNUVESFqAytDC2UQlsohba0b74uqi5IqJbyNDH8tzc355dz7jn3+04QvB5ExpuAKOD5j3hy4/hfH0/ikbMYIPoDWVLaaMJ/YYzzwPPAcwoMUInJGUZCBpIU4qUDBl7/Z5sxRHOMG1IsmUbhGJUjTM8ya4Dkl1zwLYn+/2AGq7A6xasXcfdsBrEnQ20dlZ2EszjxFLtfpuvK0TPyXOVvF6cKD09nzdwGHUem+rA3sjfLBRmmJmnYzPTP6F3K8J2RnhfbZdYNm7N59HMoKbACdxRYEgsM7prj2kSPpa1Z4XsEKyhrGEWEaRoXFg3tb7S9vlbHfQfE+pm9s8TA5jSrmqlMBIITIyoaD4iHGfn9yFCYSbGf8CjlTcQGyhz5OVKs58DN1P9GWa6EwGW1yHP4CC19eLaobUqDoUdX6o+V6X03Mu+WUGH/Hgsf/EhiJou7Ob6M7L30r6eurUTAyohFCTrzfHGAi0/Ssr/I8maLXnzeL78mtG1hwf30f7VB7v31oopI3+0cizM8RGYRNW3ESgFMFajKUJ1g5aVUd+Me0jG+/45Mjskpdu1koIPFdxG1MLyCfJ6yAsVmigGxCVQVYy5xscihw5xIM68FL5D+mB+3kqwmm2XbNoIuFj+EGqIPyHVRdSvJNPEJljxnBGbjTKmjs4KXDkZSuwNXvRWYEgy6Ze2I4VzCjh0su45jm46LrSsIm0ItW1gwQPc9VKQnftSc8aA+hdZ+ZuRZFEamFbApofbbXXK/vC2bHTE4HMkd22PS1jekNpPuSmhfm/XTGtr7CXdPUDfWDObw9Qkeq+eZeYQn+wwtn61u1a/y0VqDz23QMlwrt2WbeQ/8JlaVcHRGtb6aVvFrmNRDaoI7eEwgbM3zQw8Lqnhrz0Ff37TE4+Xz1bftNfPTz8gQzMeKpOMNlztY7FA5klVWQ/gBdb0TB8bc5ukzPcwEDITcNodZ9UVv5np9k200pX2upMnKZ9QwaY6w9UKFL9qldSq/keR3XPYO5emJA/+2mgmwrJwnmqks58PuwPaRpKZT0zxSG1f72inV+hxfkZNZjs+Z+wqpnonj/hHwz8yNsbqG62dQHqejk5oEhqhrJDpE6n2aNjJp8NzgxgWEMjSFXFJJcogrDrJ0Lw3dVO+iqo+zaGLHzLhq4Rz2Fdl3CgHzt3H1J+cWdHrOvicJif0LHc3/r2k6Dzwt8eBsfufBX9czSn1D8zt5hVO5+XSEIgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDozNSswMjowMEWBI3EAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MzUrMDI6MDA03JvNAAAAAElFTkSuQmCC"), + "pr" to CountryFlag("Puerto Rico", "data:image/png;base64,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"), + "qa" to CountryFlag("Qatar", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAQ5QTFRF//////7//v7+/fz93MTYpmyeeBxqXABMWgFJZABVZgBX/fv94s7fq3Kibg1gZQBWZgFY//7+6drnwZi7lEyJawldZgFX/Pr8u4+1eB5rWwBKVgFGXQBNw5y+l1KNchRkYgBT+/j6wJa6cRJjZwFYwpq8l1GMdx1qaANZ/Pr7tIGsaw1dUQBAVAFDXwBP6Nnmk0uIdBdmZwJY+/n7xJ2+mlaQdRhnvI+1eB1rWgBJVgFFXgBO/v3+5tbkvJC2j0WFagdc6drmsHuobw9hZQBV0LDLmleQYABQ0LHMmVaQcxVlXgBP5dTjrHWkbg5gwZe759fkvZG2kEWF5tXkrnmnbw5h3sjbqnGheyFuWgBKSus3HwAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADMSURBVDjLY2BgYGRkYmRmYWVj5+Dkwg0Y4ICbh5ePX4CwQkEhYRFRfjH8ChkZxCUkpaRl+AlbzSQkKyevQIRCkKmKSsqcKgQVigupqqlrEDKRkUFTS1tHV48Yq8X1lQwMjYhzo7EwEW5k0jcxNeMkaDUwHM0tLK2siQoeG1s7ewd+IhQyMDg6ObsQdCOzq5uZOzFRyOzh6eVNjEIQ8PH1cyEimTHp+48mM3xuHLBkxhQQGERcMmMKDgnFF9eMTExMNjbMYeER1pH4CikAXrE6beIEaK0AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MTMrMDI6MDCLtnoIAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjEzKzAyOjAw+uvCtAAAAABJRU5ErkJggg=="), + "cg" to CountryFlag("Republic of the Congo", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAGxQTFRFAMoABMsAAMcAJdAA5voA//8A/v8A//0AA8sAAMgAIdAA2/gA/f8A//4AItAA3vgA/P4A//wA/+AA/9oA/yQA/98A/yEA/wAA/94A/wQA/wMA3/kAJNEA2vcA4fkA/9sA/yAA/+UA/yUA////3y6slQAAAAFiS0dEIypibDoAAAAJcEhZcwAAAEgAAABIAEbJaz4AAACFSURBVDjLjdQ5EoJAFADRDzooKOJKi7ve/5BGigZT1R2/uCMyFeVkmqr0aZZz87pZpOXo2pwrV11af90mbXOu+Xe7vXOHHuWOPYN0J6zDOqzDOqzDOqzDOqzDOqzDOqzDOqzDOqwjilo5omzOxhGXq3LEzTmi+vlGuj9yjhhdm54vhozjDTVWMskJsLmPAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjEyKzAyOjAwLcFxvAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNToxMiswMjowMFycyQAAAAAASUVORK5CYII="), + "ro" to CountryFlag("Romania", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABtQTFRFpaE385sGADGcATKb/+EA/94A3iIQ3iEQ////bEiZPQAAAAJ0Uk5T/v6mqd4QAAAAAWJLR0QIht6VegAAAAlwSFlzAAAASAAAAEgARslrPgAAABxJREFUKM9jUAIDA9dQIAgRKwcDhlHBUUFaCgIAAIWtj9wIsGoAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MDYrMDI6MDAVJFUxAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjA2KzAyOjAwZHntjQAAAABJRU5ErkJggg=="), + "ru" to CountryFlag("Russia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAACpQTFRF/////v7+7u72EhKHAAB8AgJ/AQF+AgF9AAGAEgF17QEK/wEA/QEC/gEBEp+r8wAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAABBSURBVCjPY2AYfEAQC8CuUgkLYDDGAhhcsACGUCyAIQ0LoFSwHAtg6MACGGZiAQyrsACG3VgAwxksgOEuFjCwggAMe/hdiobzpAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo1MiswMjowMEZJFHgAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NTIrMDI6MDA3FKzEAAAAAElFTkSuQmCC"), + "rw" to CountryFlag("Rwanda", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAT5QTFRFAJr0AZr0AZrzApr1A5r0BZryAZr1Dp3qKKLTNaXHM6XJJKHWC5ztAJrzAJr1EZ7kP6q3d7iCo8VYoMRbbrWLNqjADJ3qBpvvN6i/kr9p4NIdushDwso729Ejfrp7LKXKApryAJr2Ep/iXbGb2dAlpMJYzcwwvcg/scZLy80yS62sC53pGKDdeLiB0M0uqcRV/+EA/94AosFc088qXrKaEJ7kE5/iYrKW2NEln8Fc2c8kyMs1q8RRz84uTa2qDJ3oB5ztO6m8msFh3NIhs8ZKuchD39Ifh7xzL6bHA5vyFZ/hRauyhLt1schLq8dQPKm7Dp3nEp7mLaTOO6fBOqfCKaPRDZzqAprzApr0CJvvBZrzAJn4AJj4EKDjEaDj3+kR8/AA7u8B7+8A7O0B/vYAhr8ZDYg1H5EwHI8x////6TFM6gAAAAFiS0dEabxrxLQAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADVSURBVDjLY2CgDmBkZGQiRh0zCysrCxsjYXXsHJxc3DxsvATU8fELCAoJi4iK8eFXyScuISklLSMrJ6+AVx2TopKyiqqauoamljYffoU6unr6BoZGxiamivi8zsRnZm5haWVtY2tnz4fX43wOjk7OLq5u7h6e+D3Ny+fl7ePrp+sfwEcofJgDg4JDQsPYIE7BA8IjWCMjoyLAbIZo/CAmBspgiMUP4uKgDIZ4IgFDApGAIZFIwJBEJCBeYTKRgCGFSMCQSiRgSCMSMKQTCRgyiARDQSEAQ8kawOxSOVcAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MzMrMDI6MDAmURZLAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjMzKzAyOjAwVwyu9wAAAABJRU5ErkJggg=="), + "re" to CountryFlag("Réunion", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABVQTFRFACZ/ASeApbLS////+6228xkx8xgw8anT+QAAAAFiS0dEAxEMTPIAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAaSURBVCjPY2AAAyFjMHBNAwOGUcFRQVoKAgDqd3XHPs6NlAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo1MSswMjowMHehDuUAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NTErMDI6MDAG/LZZAAAAAElFTkSuQmCC"), + "bl" to CountryFlag("Saint Barthélemy", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABVQTFRFACZ/ASeApbLS////+6228xkx8xgw8anT+QAAAAFiS0dEAxEMTPIAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAaSURBVCjPY2AAAyFjMHBNAwOGUcFRQVoKAgDqd3XHPs6NlAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo1NCswMjowMCWZIUIAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NTQrMDI6MDBUxJn+AAAAAElFTkSuQmCC"), + "kn" to CountryFlag("Saint Kitts and Nevis", "data:image/png;base64,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"), + "lc" to CountryFlag("Saint Lucia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAApRQTFRFZc//ZM//adD/aND/Z9D/Wcv/q+X/m+D/Wsz/YM7/6Pf+1fH+XMz/Xc3/idr////++/3+e9b/YM3/Zs//Wcr90Pn/xb+9083Kv/P/WMr9Ys7/cND8////S0pJZ2VjZs37rur/7OXiBQYHFhgY+fPwneP/Wsv+YMv78v//j4qIAAAApaCd5v//XMr8XMz+jdz///37KissOzs7gdf+Xs3/Wcn81fv/v7i1AgICAQEBz8jEyfb/WMn9Yc7/ctH8VVRUAwMDBAQEZmNia8/8suz/5t/bBwgJAwMBDhAR7+jkqOj/Wcr+Ycv79P//h4OBBQUEAQEAk4+M7///Xsr7kN7//vr3JSUmAAACf2cAaFQALC0u//38itv/Xcz+2P3/t7GuTT4A/9oA9s4ANywA0/v/WMn8dNL9UU9NLCQD7scA/88A/9MA4LsAHhgDVlRSctH9tu7/4trWAQMGDQkA0q4B/9cA/MsAwqEBBAIABQYI5N3Ys+3/Ysz79///gX16sJEE/9wA+8oA/84A/90AoYUEhIB89v//Ysv7W8v+k9///vn0ExYhemIA/98C+8sAblgA3///n5ynRzgA/9sD/MwA/s0A/c0A/9kDPzEAnpul4P//edX9+P3/b2VG5b0A/9QD/swA47wAZ15DfNb9Wcr8tu3/7ODQ0rAC/cwB/csAz60A59zMuu//ZM/+Z8/96Pj//91L/M8A/s0D/9xJ7Pn/adD9ZM7+W8v9keH//+d5/M4H/c4E/+Zzl+P/Wsv9Zs/8YM//1d+S/c4C/80A29+JYtD/Zc/9adD+n8+jos6Zoc+eoc+doM+doM+en8+en8+fn8+gns+gns+hnc+jnc6gnM+matD9W8//Ws//Z8/8aM/7Z8/7jewN2gAAAAFiS0dEHJwEQQcAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAGtSURBVDjLY2CgADAyEqmOiZkolSysbOwcLMSo5OTi5iFCIQsvH7+AoJAwYYUiomLiEpLMhNQJS0nLyMrJyBP0DouIgqKSsoqqGkFXqmtoamlp6+gScCSLnr6BoZaWkYyxCX6VLKZm5loWllpW1jZ47Ra2tZOx13Jw1HKScZbCZySzpIurm5a7u5aHp5c3XiN9fP20/AMC/LUCg4LxmMiiFxIaphUeERmuFRUdE4vbSBbTuHit8ITEpORwLfOUVJwKhW3TZNK1MjKzsnNytfJk8m1xWc4sWVBYVFxSWlaWWF5RWVWNO8Jrauu06hsam5oam1u0Wtvacbmwo7Oru6cXqK6pqa+3v7urswO7K1lMJ0ycNHkKSF3T1GnTZ8ycZYpVobDQ7Dlz582fClbYtGD+wkVzFmNNv8xLli5bXrqiCQpWlq5avWYJNu+sXbd+w8ZNTXCwaePmLVu3YXHh9h07G3ftRgK7Gvfs3Yfpyv0HDjYdakIBhw4fOXoMQyHj8RMnT50+c/bsufPnz1+4ePHSpUuXr1y9hiXvMF6/cR0DYM1jN2/BwG0ouHUTIQsAhaG2QzAXjm0AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MzErMDI6MDCxzgdiAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjMxKzAyOjAwwJO/3gAAAABJRU5ErkJggg=="), + "mf" to CountryFlag("Saint Martin", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAkxQTFRF+LC270RS+83R8Vtn/enr9ICK+Kmv7z9N+87S+Kmw/+vr73yI5er1aXm8xMznO1aumKbUGzqg5ej3aHzAxMzjPFaumabV5ej1aH3C5ej0w8vmO1atoK3YIT6i7SY27Sk5//7+7Sg4////7S8+7Sc3/vj5///8/v/v///5/fv88unZ7eB/59JR5Mx58OXK+/j4/vn6/+Hh+9XQ7rZP3ogq0Hg/13sz6qo288ez/tzc//v795KSxFxOzWRBxmRWzl1Ly2NY02FL02Vl8XV3//j496ytgo1eWrRdaLKziJWbe7LAisLSmKm16JGU///+/ry9oI6Rab20oL/ExMTEq7/DirzGmqGs8Zia7yk4/v7y/P/Z/La0ppKemre+vLu7s7OzuLe3pbW5k6i18ZSX/f7g/f3n0ipF0ChE+vmu9PZb85qVlaOxnK2xp6amoaGhoKCgpausirPB4YKJ9+549veCHSWLHCSKHSSK8vaB6u5+8IOHj6i2nq+ywMHB6+vrx8nIqbCwh7nF2nF57d6e4O9h/v74/v//ASKVACOW6/Wo3PFu/JiTylZduYyQtJ+kqre+r6SqupSZvmZt9Wxw5+yM4PF69/j8ACCUACOV+fvi1e1T6up+/KyT+IiG8nN54mBo7m929oOE+5qM8dyQ2e9F9fq+CCmYACGU9fnE2+9a6vc8+PtX+PiW8+Of+PSe9/ps3vNK1+9P7/ekASGUACKV/P3x9fag9/dC8fcy1e5D6fU2+fk38fWD9Pbh/v73/f3q/P3i///1/v7/ACCTlZF16QAAAB50Uk5T/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+RRzUyQAAAAFiS0dEIl1lXKwAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFlSURBVDjLjdBjcwNhFIbhrc3Uzlvbtp3aRmrbbmpra9u2/1izadJ2muy++3y+Zu45B0H4tLTJDNHhF6BSyUAABIV09UhBoC8sAs9jEABReP4bksizITzPgdA8GxoYGkHyLGhsYmpmbmFpJUaQx6C1ja2dvYOjk7MLQR6Drm7uHp5e3j6+fgR5DPoHBAYFh4SGhdMIrsdgRGRUdExsXHwC5/pEHkNAUnJKalp6RmZWdk4uHZPiEnn53ENAQWFRcUlpWXlFZVV1DQYlpWrr6rmGgIbGpuaW1rb2js6u7p5ewJCW6evnMQQMDA4Nj4yOjU9MTk3P0GZl5eZQXkPA/MLi0vLK6tr6xubWtjxlZxfFgWBv/+Dw6Pjk9Oz8QkHx8grFheD65vbu/uHx6VkJJ8uBALy8vtHflVXwsr+QOYY0fvYvxL32H1SlEGV/IPPJhFkOhGbZEJ5lwQ81dWiWBTU0P0kwFP0C9tSUbH0o9ugAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MzIrMDI6MDCAJh3/AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjMyKzAyOjAw8XulQwAAAABJRU5ErkJggg=="), + "pm" to CountryFlag("Saint Pierre and Miquelon", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABVQTFRFACZ/ASeApbLS////+6228xkx8xgw8anT+QAAAAFiS0dEAxEMTPIAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAaSURBVCjPY2AAAyFjMHBNAwOGUcFRQVoKAgDqd3XHPs6NlAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo0OSswMjowMIjkQBwAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NDkrMDI6MDD5ufigAAAAAElFTkSuQmCC"), + "vc" to CountryFlag("Saint Vincent and the Grenadines", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAW5QTFRFAFiqBFqnAE61mLhA//sA8O8D9PEA8fAA//cAotAAC5QAHJsAGZoA8/EA8vAA8/AA9/IA+/QA+/UA9vIA/fUA0OMApNEA//YAn9AA1uUAWbMAF5kA5uwA+PMA/PQA1+YAcL0A//gA8PAAqNMAD5YADJUAcb0A/PUAULAADZUAGJkAyOAA//UA7+4D4uoAKqEAFJgAG5sAFZgAxt8A+vQAmM0ACpQAIJ0AT7AA+vMA7e0DfMEABpIAHpwA5+wAKaAAGpoAHZwAttgA7u8A7u4DGJoADpYAptIAdL4AH5wAEpcAN6YA6u0A8O8AfcIAEJcAU7EAutoAzuIAK6EAFpkAsNYA7e4AL6MAEJYA1OQATa8A//wAAI4AXLUAnc8A//8Ae8EAEZcAsdYA//kAV7MA/vUAx98AOqcA8vEASa0AB5MAk8sAjcgAyuAA9fEA9/MAQKkAgMMAvtwACJMAMqQA7e8AYbcA7O4A9fIA////84ExSQAAAAFiS0dEeaHc1NAAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAEqSURBVDjLY2CAAEYmZhZWNjTAzsHJxc0DAQzDWSEvH0QNHy9+hfwCgmCVfELCvPgU8omIiomzA1WIS0gK8uJRyC4uJS0jy8snJ8+loKiEWyE7h7KKqpqiEq+6hqaWtg4fLoW6snr6BoZGxiY6pmbmmhaWvEo4FFpxWNvYcnNJidvZGzg4cjmJO+NQ6CKnzePK7ebOIe5h5unl7SPsi9ONin6q/gEsgUFswSFuoRzsOD3DKxwWHhEpoh8V7R4TK86HL3gU4zziE7gSk5JTtFP58EYhu2CakWFiOl8Gobjmk8vU5LbNyubwJaCQXTyHy9HVMBcc5XhTT15+gQFXoSI7wfTILl5UXFIKSjuEEi47R1kcxEACCnmFy9nziMoKvBXE5hneQZ5dcSoEAMJHPXcKhncRAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjMxKzAyOjAwsc4HYgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDozMSswMjowMMCTv94AAAAASUVORK5CYII="), + "ws" to CountryFlag("Samoa", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAPBQTFRFAABrAABsAABoBgZmAABpAQFrBABpAAByWgBF/wAA+wABBQVuAABnLS2Ft7fVFRV3AgJrAABqAgJjAABjICB+ioq7DQ1zCwttBARtcnKtJyeCAABlBARjAABiVFScsLDRBgZutbXUPT2OAABkBwdwISF9RUWTAgJmAQFpbGyqLy+DAABeAgJsAgJoDw9sEhJzCgpxAgBqBQJrS0mUz83iJyV+BAJrBgBoAABxWwBF/AABAABwAgJxNDqRq7jaFxyAAQFwBABuAAB3WQBI+wACMQBWMgBWMAJVJQJPMgJXNABVJABcegA4/wMA/gAA////43SQlwAAAAFiS0dET25mQUkAAAAJcEhZcwAAAEgAAABIAEbJaz4AAACnSURBVDjLY2CAAEYmZhZGVhCLjZ2Dk4sTA0DVcfPw8vEzCRBUKCgkLCIqxiIuiF8hq6CEpJS0jKycPBMhhQqKSsoqPKpqLATdqK4hIayppa1DUKEAg66evgFeXxuCgZG0sYmptBmIaW5hyWmFRaE1GNiw2NrZMzqAmI5OzpwuWBS6QoCbu4cnhOXl7YPVRDjLlxMvYPCDAU4EC6tCTiLBqMJRhUNSIQD8STwfK4h9AgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNToyNCswMjowMMCeQ2UAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MjQrMDI6MDCxw/vZAAAAAElFTkSuQmCC"), + "sm" to CountryFlag("San Marino", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAIAAADRv8uKAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAABFtJREFUSMftlltsFGUUx8/5Zmane9/tWpbtIi1tKbfSBKmpNIRLAom+KBhFDTEGNSZqjAkmxj7ZxBjffdCEeIkvBtRoAKWCAQtiMDUFhZRq7YW2u5Xt3juzc585PpSQ+MBMKxge9GTe5vvO//ud+c85HxIR3I1gd0X1f+Elxm2Zg1+yGhEAIQABAyCEBXMiIv67xIiIQICsNP2hUhkCZIiwVNWlEhMAZmYmpPKwP9kmSod1yhY0US9mkvf2RKNRIlr8CZZEjOWKlJ892dLaGj7XX5p8QDtfTVybSTXFp8dPEQCAc+dLTUREdigSFgzMb3/c2PcaDQ06Xx2Vex4uvNobSjQhABHQoh2Hi+5cZDv2mcvfty/r0I5tFxJ/gD+NnOXkcnrgmerut2raRFf9ppgYISAE74JzfX19nqyIWJGqX/z8+VOHntsdKybDP5bBlPiAbNuCqPCoflqZeVceEAx7fbhN5MXFaPMevAQEgACvfPTSl4PHNzRhWvlgInRgNrRNZgIAS1qT66zj+6uHJefAEemYBc7BNc/Swh53YY8FCIqu6EptWpvavnLLm5tr1yJ1avuhkmKtCsCoDBDkf6g9uTOzdqeSn8L6/rmz+9IPrQilPB3OV0x3ZuJZsPfkO+VKbl71j+TG7OhBs6RWjdqcVMubkWWaPGHFNurpUXFMCmxO2f4/tXysLmUSuSPxPWfnXSsNPGBuSjWqmWBgxRW2tdvIYtAPnNkg8hWFTwTjaU11NHVY2BPPjxgh6eUr56vWGg4V91+GLxiuxOQAF9AT99P86uWs9dSsuadx9OylI2aiQ9dmpUDzULbQzC4WKfSr2boiOqlwHVllnwE63jj2rYUF94ogAppccEOOddYHZy4Vp85fT21K9l3Wn2Dst3i1TeML6zKH32vc2670Mx1nEp0EPh86nu5iBOD6IDk2RtLBePtQpbirpelo+HUyoFXqF3gtalzcmj32bXRX0V9XHwtmY90N9JMIGQcEAnLP7NG5CMjhfKSV9LGvy7NXTw8PNlx5/2PnReLLAVXhI4ULka4T8oNpeWQ8JPvDAzreo1ILoelJzIX3v+H2mihgqRWsW5vq3NsUzwgd6fXPv9CSHB1llAFTbpzjdjy6cc1n8n1bQvzGupWD5W6Z4hFHMZjP4xumTpRvjQsc0Or81S3J4Pp4qKu5uVgoLI+wzOTE2xdyj4S/scLNv5Q29O5olsQGxYJgIPDdeDZTkwZqgUKihTkm3ZrbfSyiQPa4r2GbnzKm8/Tp610xcoCrqI2P9Zy7jN1N3O+CUto93rMqbEwqIJvzn7TyZ5S4KvqQbHKtthvxQtiM5yzDAhQFXrWJCHyck6DCtLUqyOQEN5ejlO3YIkNEsE2D4wQbGUe2e1pvYQRygDEEutGMiAAt4EXQbeAsEgQ0blqJEIEW7kNeQwK8ggARbgzPhesVAAhg2sABgIDG3zSIFrZ4pv2Ht8ybqRejcSeFbz/+e8J/AeDSLKySWtQHAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjI2KzAyOjAwuMM5cgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDoyNiswMjowMMmegc4AAAAASUVORK5CYII="), + "sa" to CountryFlag("Saudi Arabia", "data:image/png;base64,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"), + "sn" to CountryFlag("Senegal", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAM9QTFRFqs4N56QA6KQAC3ImDHMm//8AvAEAvAAA6PIE4e0Fp8wOksAR/f4AY6UYT5kb+PsB5O8ELYYhI4Ai2+oG4u4Fqs4NrdANgbYUEHUlDnQme7MVqM0O1OoH7vUDdK8WFHclDHImDnQlXqIZ3/AFncYPJIEiCnEmCnImGnskhrkT8fcCnscPDnMmCXEmf7UUB3AnBW8nZ6cY8/gCRJMdHHwjkcARoMgPJYEi5fAEzuMIUZobv9oK/v4AyeAITJcct9UL4O0F4u4Ez+MH/v8A////g18ZmAAAAAN0Uk5T/f7+l1A3dQAAAAFiS0dERPm0mMEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAACOSURBVDjLY2BGAiwMrEiAkY0dCTCMKqSZQg5OIhVycROnkIeXj58ohQKCQsIEFYqIioqJS0hKiYlKy+BVKCsnz6wAYioqKTPhtZpfRVWNmVldQ1OLoBu1ddSZdfV4CHtGU19SwsCQsEIjYxNTM3NBC4IKLa2sbVht7ewJKnQQAYWhoxOxicJ5kKfHIasQALWVHsM/YfmTAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjAzKzAyOjAwRxx6lgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNTowMyswMjowMDZBwioAAAAASUVORK5CYII="), + "rs" to CountryFlag("Serbia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAIAAADRv8uKAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAABFhJREFUSMe9ll1sFFUUx8+5987O7sxOu91lC8uq9IuS0ihpJRqlBQNWjQajLwY1+ABoDCYajTEmvsiDr774wJMx8cHwZIxRHwgiImBEHviKfKwSKdCPbbs7ne7OzM7MvccH0Zhti3UK/nOf7tyZX/5nzv/k4okHhmCJQgBa6tl/FVsikhRShID/GxgRGFJE3ApFNqCQgCGw28C/JRgBfJ+8QOfJKxn9fDaR0JLUCKHuAxDgsvBi0SdEIIF6e1Rnu6t8ZQHTeL0Yct1kozNYugpRBIIDxfztizkmYFxu7m8MtcPdER04sh7swWwDDhzB1GyweWW0pQ9MA6S8E6UWkCf21cmgMQEdqyqzdnniOiuu9lM2fvEjWD6IRGy7AIDHF4wTIo/IyZHTv0KJq62Ql4EjwU9pxRkcFao7dbmSu0GRFj9gQiz4KpHiZI5hVLzeNiyFO9ZATRFL0VXLZJXTo+nfDZUiQfH7S9ioNbsFUEQpXbO4vHFNMF+0lMv2CrNBvFCteixXvY75pPJSiboXYNzexsKWt5q2OJCN2pvJ6RfNOX9NZwAnxeBz7Ogpcmsw8mhY+jzh9OiV2uFy4z25xowaKtZYWcAxB6pxveb5HR+8/duhn8rHPlmzM2UUdgflKfGQefngmWyuv3vfG9/sfd8mEaKKB2YCqHkhgOeZa3v0wUGzfy0/m5378Ou2gb7C9hFn/5fwrZZev17r6mkZHEC3Lhgu8IWlrPmtRYggI766UJ+eth7bVnh1tzPnVhs+RmFjZW/+hR35l56v2TOsWCB1DQApVmcvlmMkUoTgVqu4Zag6eaP63fdzJ09Nnz+D2x5x3bpSkm6GOGaeFh+ZkdS4SGiJyJ5FzzcMQzdNFkbRTEVL6BpEGMnljOtFwIxFruu6dSmU2d3V98qeto4Oput9e3YFuaz0PB9lUKshYuzRJeYHEQGAM3A9nXG0WuZKpakfjnEhNNMcP3bCGNjQ1tWVbNShXkfGECBelEUYNQ96BQTEw6lp6ThRMj1X+tWenMyNT1AmY4+PyUxLsGFDgqtgfEIBC0Op4jnOZ8zmMgMkmCaUwwEr5y5m7h8IPc8ZHU0FjUQ2u+qJkZnT51o33suCIJdrT0NMMFYct3lPKZ42naNH7Ytn7SuHo/aieQmSu3Zga4v30cd+p5DlX3Ldj1vFruxT22W9BozHcdxmpZr3iADBHNh46dN3k0VbP3Ee0sP5detQ18atdHDos8Sm1rHj+4f3HTQEkGUgW9rFramuNF8ASkqeMfqefse/oPjDYD45zLnGQmluHdK2GfWS07PpdaPnHiUlIFIsMVxIjHMiWv3sM11bX7OPcKuzX0vpQtOs7l7nlFG8b2f3y3sBgHGOsUWL3yKIFCKzj/9cKV2QSqGmccEzd3W2bXoQcLmXvVuBAYCUQsZIysieBcZEi4Wck1KIeGfBN9l/Y4iIKF43/WfwX3wCgGW6/KfEUg/ePuSfug1Fi6c/ADM9TeJi4wSsAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjUzKzAyOjAw4D4fzAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo1MyswMjowMJFjp3AAAAAASUVORK5CYII="), + "sc" to CountryFlag("Seychelles", "data:image/png;base64,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"), + "sl" to CountryFlag("Sierra Leone", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABVQTFRFGNIY2vja5OT6IiLUAM0A////AADNWt8AqwAAAAR0Uk5T/v7+/rpKSvwAAAABYktHRAX4b+nHAAAACXBIWXMAAABIAAAASABGyWs+AAAAJ0lEQVQoz2NwwQIYhoogViCIBTCEYgGDUVAJC2AwxgIY0rCAoSIIAG33tKEi+b2bAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjM0KzAyOjAw4/YoxQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDozNCswMjowMJKrkHkAAAAASUVORK5CYII="), + "sg" to CountryFlag("Singapore", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAARFQTFRF3wAA3wMD4AUF3wEB3wIC3gAA3AAA3QAA5jc38piY9rW16U1N3gEB3wUF85yc/////OPj6EVF5TQ04hcX8pub/OXl4h4e4hYW/Onp74CA5j097XJy4yUl4A0N3wQE6U9P5Cws4AgI4AQE8IuL/vj44yMj4AkJ+tfX8IeH3gQE5Cgo/Ofn62Fh9Kur/Obm4A4O7W5u50VF4AYG4RIS7nh45S8v852d/e7u4hkZ3gsL3wcH3xAQ3AEB615e6FBQ4QwM86Oj74KC5S4u+MfH+dDQ97+/856e7nt75CUl5jU15C0t86Gh3QIC4AMD8ZKS/fHx+MbG6ERE4x8f4hoa4RER4RMT4hUV4RAQ4AoK/e/v//7+yK8ssAAAAAFiS0dEDxi6ANkAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADkSURBVDjL7dDHUgNBDEXR16jfCEyQTQ5mwASDyXlMNDlnTDD//yFAsZ72bKnirG9JKgE/XItDBuIZKeClaaetbbl2dLBJh84uyxe8dPfAh0KvvdbXH3FgcEhdYLvjsNlIVByNx8ZZLKWHEzppU9PlmVlWdG5+ganbnS7a0jJWVrmG9Y3N9DDWLUuq0O0dcHcvcGOs+2YHWjs84vFJgemloHRqZ+T5hV7mrhh4kOd13m5cVIG/Df1R5I7V+4fHJxGJJR1IgpE8vzAM9W+vb+/lj3oYkl+NRhIGywifGWWf+B/+9fALahtTyExnkYkAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MDcrMDI6MDCzU16FAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjA3KzAyOjAwwg7mOQAAAABJRU5ErkJggg=="), + "sx" to CountryFlag("Sint Maarten", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAk9QTFRF+LC270RS+83R8Vtn/enr9ICK+Kmv7z9N+87S+Kmw/+vr73yI5er1aXm8xMznO1aumKbUGzqg5ej3aHzAxMzjPFaumKbV5ej1aH3C5ej0w8vmO1atoK3YIT6i7SY27Sk5//7+7Sg4////7S8+7Sc3/vj5///8/v/v///5/fv88unZ7N9/59JR48x58OXK+/j4/vn6/+Hh+9XQ7bZP3ogq0Hg/13sz6qo188ez/tzc//v795KSxFxOzWRBxmRWzVxKy2NY02BL02Vl8XV3//j496ytgo1eW7VdZrCxgo+VebC9iMHQlqiz6JGU///+/ry9oI6RabyznbvBwcDAqLzAiLnEmKCr8Zia7yk4/v7y/P/Z/La0ppKelrO6uLe3rq6utLOzobG0k6e18ZSX/f7g/f3n0ipF0ChE+fmu9PVb85qVlKKwl6isoaCgm5ubmpqaoKanibK/4YKJ9u149vaCHSWLHCSKHSSK8faB6u5+8IOHjqe1maqtvL296urqxMXFpaurhrfD2nF57d2e3+5h/v74/v//ASKVACOW6vWo2/Fu/JiTyVVct4mOsZyiqLW8raGnuJKWvWRr9Wxw5+yM4PF69/j8ACCUACOV+fvi1e1T6ep9/KyT+IiG8nN54mBo7m929oOE+5qM8NuP2e9E9Pq+CCmYACGU9fnE2u9a6vc8+PpX+PeW8+Of+PSe9/ps3vJK1+9P7/ejASGUACKV/P3x9Paf9/ZC8Pcy1e5D6fQ1+Pg38fSD9Pbh/v73/f3q/Pzi/Pzn///1/v7/ACCTZ/3rWQAAAB50Uk5T/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+RRzUyQAAAAFiS0dEIl1lXKwAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFkSURBVDjLjdBjcwNhFIbhrc3Uzlvbtp3atm07tbW1bdv9Yc2mSdtpsvvu8/maueccBOHR0CQzRIuXj0olAwHgF9DWIQWBrqAQPI9BAITh+W9IIs+C8DwbQvMsqKdvAMkzoaGRsYmpmbmFCEEeg5ZW1ja2dvYOjk4EeQw6u7i6uXt4enn7EOQx6OvnHxAYFBwSSiO4HoNh4RGRUdExsXHs6+O5DAEJiUnJKalp6RmZWdk5mBQVy83jHALyCwqLiktKy8orKquqMSguUVNbxzEE1Dc0NjW3tLa1d3R2dfcAuqRUbx+XIaB/YHBoeGR0bHxicmqaNiMtM4tyGwLm5hcWl5ZXVtfWNza3ZCnbOygOBLt7+weHR8cnp2fncvIXlyguBFfXN7d39w+PTwo4WTYE4Pnl9e1dUQkv+wsZo0viZ/9C3Gv/QWUKUfYHMp5MmGVDaJYF4Vkm/FBRhWaZUE39kwRD0S96IZTLS03RjwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo0MSswMjowMLsLDnsAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NDErMDI6MDDKVrbHAAAAAElFTkSuQmCC"), + "sk" to CountryFlag("Slovakia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAr5QTFRF//////7+//v7//z8//39/v7+/v39/v///+7u/3t7/nh4/nl5/nd3/4aG/4+P/4mJ/np6/nBw/87O/vz8/97e/gUF/gAA/gEB/gMD/kVF//f3/nx8/gQE/6Gh7u727uz17fT9+dnc/wsL/gYG/goK/iUl/mlp/ggI/aKj7///7eryEhKHFRSHBAyHr4+2/xUO+wAA/5WV/7q6/7e3/6en/8PD/iAg/QAA/wAA6o2XHy+eDwuBExOHAAB8AwJ8AAB7qYiy/xYO+gAA/6mp//T0/+fn/+zs//Ly/iEh6YyWDR6TAAB2AQF8AgJ/BgR/AAB+qYmz/xcP/hMT/i0t/mpq/h4e/hkZ/QEC6YyXDyCWAAB5AwN/AQF+BAN+qIiz/xoS/mJi/+/v//Dw/+Li6IyXDh+VAAB4AgJ+qIm0/xsT/mBg//X1/9nZ/eTl+/7//ezt/9vb/6Sk6I2YBQR/mY/B/y4m+w4P+gkL/ikp/25u/AAA+gUH+gsN+wEC/wEA252vBRKNAAB6BQWAAABzYm+7/2Fa/wQD/gIC4yAtrcLrzVBo/wMD/wIB/ycgqprDBAN/AgF9AAB3IS+b9ZufqAQvnQIypgItDwF3AAF/ggI/tgIlmAU46QAA/3BmXGu5AAByAAGAAwOBsKHGfTxzAACABASIAAGDAQGABAR/AgKAAAGCAwKEAAGKOwti27LAChaOAAB9AQKBEgF1FAN3BwBwPzONp7LeAAJ3BQJ6AgF+BAJ+CQZ/AABseYnLcmyuAQBrFgR47QEK7QEJ7gQN5gAA/2ddlqDVAQB1BQSAAwJ5AABxYnfG/peR6AAA7QMM/wQC/2Nbta7RHSycAAB0AgJzDRiPk5vR/4qF/gIA/zAp86GkkY/GOkyteX/B5qq2/0tD/QQE/QIC/QEB+wEB/zwz/4N+/05G/gUC/QMD/AICh3PFowAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAHCSURBVDjLY2AYdoCRCQyYmcEUC2WGsbKysrFzcHJxc/Pw8vEDKQFBIXZhVgwAUsvCICIqJi4hJiklLSYhJiMmy8CExUQ5OTl5BUUlCWUVMVUGNTFlZXUxDU0tOQzAoK2traOrp28gZmhkzCBkYmpmbmFpZW2jjQ4YbG1t7ewdHJ3EnF1cGVzc3D3MLTy9vH1s0QGDr6+vn39AoFOQh1gwQ4hYaFi4RURkVLQvOmCIiYmJ9Y+Ld0pgdE1kSEp2NzG3SElNS49BBxCFGZlOWdk5uXn5BUmF5hZFuBQWp5WUOpWVG1QwVFZV19TW1Tc0YlfY1NzS6tTWbtHR2WXR3ePU22ffH4OpcMKECbETJ002nzJ12vS0GTNnzZ4zd958vwkYgGEBECy0XbR4ydJly1esXLV6zdp16zdsXIABGDYBweYtW7dt3+E3IWbnrt179u7bf2ATJmA4CASHDh85eqzx+IkVJ06eOn3m7LmDWABDHRicN7hw8dLlK81Xr12vulGHDTCEQ4CMwc1bt+/cvXff4MHDR+FYAIM4FMg8Fnvy9NlzA5l2cawArlBc4oVTldNLGXFxQgqBSkVxKkNViBcMoEIAB2QRibuKCK0AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MTgrMDI6MDCJsS7yAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjE4KzAyOjAw+OyWTgAAAABJRU5ErkJggg=="), + "si" to CountryFlag("Slovenia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAbBQTFRF/////v///f3+/Pz9+/z9/P3+/f7+/v7+/v7///7++vv80drut8PXpLTTq7nSvMje4Obz/f391LbBKE2hADKiNVFwGTeJMUl2HEKCAjmlUV+g+t/d/v3+/Pv8x5CdACKICz+fAjalOliBI0qQBjiiADqhJSd5+c7J/v3916atDiyKCD2gAjScIUeIFUCQBTSbADujPDh//93X/fz9/vz85ra3FCmDCz6jDzycdpLOSW25FT+dADSgTT59/+nh/f//7vL47u/28Pz/68HBGCJ6eJrR5ur07PD34Oby5urzL2C1WD54/+vn6/T97vH3GUejGkaiE0qqMTeEfWmW+/////792+j4YT91IESbF0elGUajBDaaAjedCjCQd055ssvroLDWq7vcobLXqb/iqK/QVjNsADaeBjaaCTqcCzqbAz2jNSt0bFmMyN/3wdHrzt/0rMHjXDdtHzOKBDyhCjqcCDmcCTmcBTuhPjF3j2mN29HcyLfJdk14JzOFAzuiCTmbATuiDyyKOClwLSh0BjKVCjmbBjygATyjAjyjCDueBDmeFziTzyoh4ikW3SkZ3ikYRVLwSwAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAEFSURBVDjLY2CgEWBkYmZhYWUjqI6dA0pzElLJxc3Dy8cvQECVIIOQsIiomLiEpJQ0gwwehbIMcvIKikrKKqpq6gwauFRxcHDIMmhqaevo6ukbGBoxGnNgByC1JgymZuYWllbWNrZ29ji94+Dg4Ojk7OLq5u7h6eXt4+vngB0w+Pv7BwQGBYeEMrAxhIVHREb5YwcM0UAQExsXn5CYlJySmpYejQMwZABBZlZ2Tm5efkFhUXFJBg7AUAoCZeUVlVXVNbV19aW4AERhaVlDY1NzS11rKSGFpa1t7R2deNTBFZaWteJTBlRYTyRg6CISMHQTCRh6iAQMvUQChj4iAUM/kWBkKgQAEhil/zRkdXwAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MDMrMDI6MDBHHHqWAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjAzKzAyOjAwNkHCKgAAAABJRU5ErkJggg=="), + "sb" to CountryFlag("Solomon Islands", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAexQTFRFAADWCgrXFRXZBATXGRnaAADVOzvfcnLoHx/ahITrCAjXKirdbW3or6/y2Nj5eXnqSkriBQXXGxvaZWXmmZnv5OT7WFjkDQ3YDg7Yd3fp9vb9////sbHzJyfcBwfXWVnk5+f7zs73OzvgAgLWQEDgx8f2iIjsBgbXAwPWISHbxcX2wsL1q6vxCQnXOjrfLi7dExPZTEziCgrYVFTjKSncPT3gDAzYFhbaAQHWLCzdvr71hYXrOTnfRUXh/v7/9fX9mprvHx/bAADXAADZgoLr7u78ODjfEw/HVkWObm7oW1vlS0viEg7IX0yHxJ0x+cgFERHZHBzabGznHBzbv7/1EQ7IXkuHxJwy+skF/88A/84AKSndpKTw7Oz8+fn+xsb2GBjajIzt4+P6/Pz+1dX4w5wy+ckF+coAz7cA6+v8+/v+Hh7b1NT4/f3/ra3y+ssAx7QAYokAFmkAT0/jfHzqf3/qMjLeiYnsi4vsXUuIw5wzY4oAE2gAAF8ABQXWXUqIwpszYooAAGAAEQ3IXEqJEA3Jwps0XEmJwZs0W0mJwZo0W0mKxrQAwJo0WkiKwJo1wJk1EAzJWkiL+MgFDwzKWUiLv5k1+MgGWUeLv5k2WEeMYYkAx58v98cG/80AxbMA/8wA3r4Ab48AAF4AdyFA2wAAAAFiS0dEGwJg1KQAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAGjSURBVDjLhdEFV8MwEADgwAgwdMN1MBgwpLgMhw0fMpzh7u42pLi7O/xRrmVY13T3+l6uyffu2gtCCFlYou8QWSFyYGsb/J3aiu2Izt7B0clZImVSF1c3d7GHJwF6efv4+vmzqSwg0FceFEzqrJCHhMIapkQoPCIyiiL2jo6JjYvHOCERY/ukZEkKEargEaUq0tIzXJhUhYQiODMkKzsnl3iu1rAl4fNxXr57AUxJyc8Ki5i/yVVgRBUXlGhhBFolDystK69ASFdZFRVuJZUhlV1ytbYmpjKMw2rr6hv0jQg1Nbe0tiWwhdo7Oru6i+M5rKdX39jXD52DBgbFxv2h4ZFRypSNjU9MwuvUdMmM7Otkdm5qPuUPW1hk2dKywQAbuhWskxqvk8Je1A9bXWPZOjCaJs5tY3Wt4pcRILDN/4wXqjVbm9scxgOB7eyaMBMIbG+fh3EgsAOWHU5w2D/IsCMC+wOBHZ8Q2Q9k2KkAM0K15uz89EKIsVCtuby6vhFmAIHd3pllAGvvv9iDIAP4+KR/7nsxxwDqX1/f3ic/zDCa/gQIahql9QdxMQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNToxMCswMjowMLpeYJUAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MTArMDI6MDDLA9gpAAAAAElFTkSuQmCC"), + "so" to CountryFlag("Somalia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAQJQTFRFQKb/Qab/PqX/P6b/Qqf/NaH/gMT/YbX/OKL/Qaf/1+z/nNH/MJ//Q6f/O6T/V7H/////1ez/PKT/PaX/L57/lc7//f7/Yrb/NKD/PaT/OqP/UK3/Tqz/Rqn/S6v/TKv/Sar/2O3/q9j/Ua7/Taz/Sqv/brz/4PH/+/3/7fb/7vf/8vn/8Pj/8/r/xOT/U6//w+P//v//+v3/mtD/M6D/fsP/6/b/0ur/XbP/MZ//RKj/K5z/dr///P7/9/v/NKH/rdn/gsX/NqH/P6X/5fP/lM3/rNj/wuL/db//zuj/W7P/Mp//cb3//P3/VK//O6P/N6L/s9v/ntL/OaP/tt3/ksz/0MjB+QAAAAFiS0dEEJWyDSwAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADzSURBVDjLY2AYBSQCRmIVMjETpYyFlY2dg5MohVzcPLwEHAcELHz8AoJ8LJxAJm6FQkJMwgwiogJi4hJMkpJSwrjUMUvLyMrJKygKCCixKKuo8qswYVfHyaemrqGppS0mIKChraMroKcvjMN2Tg5lAwFDIAQhI2NhPpx+Z+EzMTWDKDS3sGTAE0acVtY2Ara2tgJ28vZWeAOIl9VBQAPoRgFHJ7xByehs5SJg5+omIODuxILfQA8BTy9vCR8XXz9/fNHIEhAY5BRsxcvKHBJqgs9uZitlE0agnbzCTsp4/cLALAQxh5FFCL9CRKIlOvUORQAA7TsXFkeDmckAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MTMrMDI6MDCLtnoIAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjEzKzAyOjAw+uvCtAAAAABJRU5ErkJggg=="), + "za" to CountryFlag("South Africa", "data:image/png;base64,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"), + "gs" to CountryFlag("South Georgia", "data:image/png;base64,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"), + "kr" to CountryFlag("South Korea", "data:image/png;base64,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"), + "ss" to CountryFlag("South Sudan", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAArJQTFRFCzWDAw0hAAAAAAEBAAEDEEq3D0atCCdfAQUMAAECD0ewEE29DkKiBhxGD0evD0asD0izEEy7DDmNBBIsAAABD0euCi91AgkXEEy6CCRaAQQJEEy8DT+cBRk+AQEBD0m0DDeHAw8mEEiuD0auEEu4EEm1CCttCA4ZIR0VExMTDQ4PEQ4OEQ0ODkawC0SyD0u6E0mtepTG6+vt/v337v7+7v//8P/+DUawFUurJlafCUOzEUitEUiuEkmtAj2tNWrDsJ7B+ouK+oqK7o6U8I2S8Y2RsK89JVSgB0K1ATy7EEeuEkmvBkCrADelQSd2sQkk5QAA2gAF0gAL1gAIEUmtFEqsB0G12ckftrM4BUC2OWGSjZZXOGGSB0K0EUivEkqxBE67DEy1YzV1zBop6hIT2xYe2BcgBUC3ADm+CkSy08Mm/+UB1cQl/+oApqpDBkG1EkatAEu6G0Smgilb3hEX5w8Q2RIb2hIaR2uIoKNK3soe/N0J+NsL/+cAyb0tCkOzEkasDUixBEq3KECdmyNJ3xEXR2qIn6JKyb0sKECcmyNI1MMlpqtDHESmgila2coftrI5jJZYDUy1ZDV1sK49EEevBkCsADimsQok2gAG0wEL1gAJJlWfD0itDkavAjqsNWjDsJzA+oiJ+YiK7YuT8IuR8YuQD0ivD0K3E0yue5/J7PTw/v/67/7/7///8f//D0S1EEWzC19+D4ZCKJ5CGpI/FI08F407F406D0WyEEO3DVaSCXtMB44oBYorAIQsAoYsA4csEEK5Dk6hCnFeB4ssB4wqB4gyB4kxCIoxD0iuC2dxB4c0Bo0nB4kwD0S0DF2FCIBABo4mB4ovD0ayEEK4DVSWCXhQB40oDkylCm5jB4otB40pB4gxC2V1B4U3Bo4nDViPCH1IBo8lB4ou////wjbOagAAAAFiS0dE5VhlC78AAAAJcEhZcwAAAEgAAABIAEbJaz4AAAHTSURBVDjLY2BgZGJmYSIMGFjZ2DmYODkJK2Tj4ubh5SSslIGPj19AUEiYSYRThJBCPlF+VlYxcSZmTkIK+fjY2CT4JaXw2g9RCLSfS1pGlgmoVA4HgCkE2i8vqKDIJELIRCU+PmV+FVU1dQ1NLW0dLACqUFdPCeRUPn0DQyNjE1MzTABRaG5haWVtYwtUqmtn7+Do5Oziig4gCnVt3dw9PDy9gExvH18//4DAoGA0AFYYEhoWHhEZFR0Ta8PHFxefkJiUnJKalooCwArTMzKzsnNy8/JtwOYX8BUWFZeUlpUjA5BC3YrKquqa2rp6cyVoGDQ0NjW3tJZhKGxrBynsQFHY2YWpEGJ1d24PwurePmxWgzzTPyEyZiLMM5Mm4/AMMHimgIJnKih4pk33mxEwc9ZsbMEDDPA5kACfO2/+goWLFi9ZugwdoETh3OUrVq5avWbtuvWYAClRiM7dsHHT5i1bt23fgQXAkxnf3J27du/Zu2//gYNYAUzhXK5Dh48cPXb8xEkcAKLw1Kldc0+fOXvi+DmcAJy55m44f+Hipct4lIEVzr1y9dr1G0fxKgMqPMV16Oat23eO3z1HQOGGuffuPzhHwDiQwoePHj8hrOzcOQAzcawWKKBwzgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNTowMCswMjowMHb0YAsAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MDArMDI6MDAHqdi3AAAAAElFTkSuQmCC"), + "es" to CountryFlag("Spain", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAYAAABe3VzdAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAABTVJREFUWMPtl0uMHNUVhr9bdevR7+55eWY6Y49tbCe2AQHhJYUVBBDIEk8hlGChKJGyyC7eAs4CsgLxWEQRm4gNCyyBQKCIh4gsoRiBeYn3jNv2MD09HnfPo6erqruq7r0shihEAbkYIsUSHKk2VefU/c9/z3/vOeJtMJzHZv2/AfwI8OuW5iHNnUcAxVcPQmCEzfz2Mq1tJYywAbHx7Xua3GygEYKo6BP7Dv2CRNuKxe0VbGWQiYWV2vhhghcl+MEAzOa0KDcr4fZkmcRXKNdGuSmT73eJ97hYsWa4sUbzkgqpb9NT4AUuI63upo4LWT88ifkO2QlAWZIzy4byU/PYicPSXhsk2EmEUAYjQTgxw3MJcUnRv2eK8VIZy6jvBFIIgZx4YHITeQmC4yGNjxaxZ0FV+7Qv8kitCFzoXOihKxHBFod0j2TXwTL1i3Js5sgVxlyWKcoow+pCTBprhrf6IGHm6DIfPt2mx4BBXpJLYgBC6eKHKSXhceGvRrjgF0NoBavtFOkIyjWJyCjPzCqOllNefOQ0Rx46SftEH6EF2y+tMX1blTXPpjOjSN815D528ZsOYqTAjoN1tl01AdgsnRzwzH2nePHhecKuysxgZhVrz+DtTtDrCaqsWHq1S/O+BRKtmYoSvFMKUaxiHzpEbXKUxAnpdPu8d3wLW6f/Dv675HYEuBUHYynA/t8CdDyH6tbrEKsCv9gi6nRIjgec2QfBPiitQjFxCce2oY2PPy9QtkvvJ6OoqRKFYpHqzluQzjqO187MYOYttm3J+PSdDNcP4npFAJQL3vWw5XowV4AGLFdir0WU1sEtjiDLG+Lw/DKTO39LdfwAtp39+M3maSBoREQvvYCZDTn9+gzxJwFWAlGcI1eDNEgppgoRD1ATQ6S6SzEVhAjOvrRKd/4z+mt/gTFDMBRS2e2R5arJxGC8ppj542mit5qYUh5yDmpZkZZADhtOdcZhSHG0OM6xIy/Tb8wS+BaBinHyOdIVBXkHUS7Rf7/FzOE54rVsQsnEoFOyqNwwxKD2a8LYR3U+ZOQ3wzTeWcd6NsWP11mgxss3X4VSmqFjb/Kzu+8iXOnC2SWmbi3Qey6P3n+AdHI/Ff1XnFK26soEUNiCiQMVVp58He+1OQq3R6R7BL0rQeiUUd3m80adyPhoy2Iw8wbW345StG1Uz2B+VyIn++jHHqVw9QgTf6gg7GytRCaAKjY0HlxgsFLH3H0tY/e+Qbs5h1Nl43IQsN1d5KZjr2Ih2Fs8gesp0KAtkINtDP1+mqXydQTP/4PGQwvse2IK2zs3yEwALQnlA0PE1dtQVBHyn2A2GpR/LeFXFJeKzyitgD8Cp7fUGD+7jhOmGzlIG+eyyxHjBcr6CywnE4HZRCIsQf3GMngdBr0mRqv/VqABfIHwBULA8GqITBU4GyVidErY/QIrv0L9hjLCyrzF2RyDXszCicfph4qVzjCFSh7hOJAmG0kAA38nAxf8aJZSd4CRoG1J/oIcnaVlFmfvx/EEQTBK1c1GoWz9aeHcDBrNK/mfc1TciDGGuWcWuWPtNXItmxWZYo0WSMd2sF67hihQmA8K5NIG6akenrTpvtDlSO1aPlXjCCFYf/Jjfhm+hcnQMcjm4QwAAbN1luk6GMsm317gzOctCmjwLPo/HUNecjGtXoDRmlJtP+JYgHsyQOoBZ/7cIr/rE6ZH1hBaYZqzNOcWMzVfIutc/E0l9/X3GsDaaACEVv9O7Bzx52Qwo9+3/vA/AGj1rTGbHS1+WHPxjwDPR/sS4H8kv3ZHqwcAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NTYrMDI6MDCyBjBrAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjU2KzAyOjAww1uI1wAAAABJRU5ErkJggg=="), + "lk" to CountryFlag("Sri Lanka", "data:image/png;base64,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"), + "sd" to CountryFlag("Sudan", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAMlQTFRFYGAA3hQA/wAAAZoAPHYAxCQA/gAAAJoAAJwAG4oAmD4A9wUAAJsACJYAZ1wA5BAAAZsAO3YAZ1sA5B8P/x8h/x8fO5kjxMik/uHi/+Dh/+DgG6YdmNia9/34////AJkACJ0IZ8Nn5PTkAZkBO7E7xOfE/v/+GaQZnNic/f79PLI8xOjEaMNoHaYdmtia+P34I5kjpcil4uHi4eHh4ODgAJYAAFsADx8PIR8hHx8fAIoAAD4AAAUAAAAAAHYAACQAABAAAGAAABQAPQknRwAAAAFiS0dEHnIKICsAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAC6SURBVDjLrdLXDoJQFERRFPVYsPcKir33fm3//1ESIIgGcubBeV7Jzi2SFAhCk+RQOAJBisbiCQiSkkylIUiUyfJ5EyJ5CwJ5G/J5B3L5DzTyuXyh6DcXJJJL5Uq15r0vSFRvNFve+4Gq1u5AkEjv9voQJHUwHP0V6uMJkla1KXaY2XwBXc9ytd5sved+wt3+cDz5zfUpzper8J8DldtdCB4a2YcAIJN1IJe1IZ+1IJC1IJA14fMFOfEGHmN+xeZewuYAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NDYrMDI6MDB+rDD1AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjQ2KzAyOjAwD/GISQAAAABJRU5ErkJggg=="), + "sr" to CountryFlag("Suriname", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAPxQTFRFAJkAAZkBAJcAEaAR7vfs/////uvq/ujq/uzq/xAQ/w8Q/yIQ/wAA/wEA/xEA/58A/wMA/wEB/wMB/wQB/wcB/wAB/0YB//8B/zAB/wIB/5YA//8A/4EA/wQA/ygA/1MA/0AA/0EA/0oA/+MA/9kA/0cA/1sA/yQA/xoA/7EA//4A/6AA/1IA/+gA//0A/98A/0IA/wUA/ywA//sA//wA//QA/yAA/1QA/0sA/6wB/6EB/ygB/6YB/6QB/wUB/x4A/9gA/1EA/wIA/9UA/xkA/xYW/xgW/xAW/zoW/zUW/wIW/xoW/zcW/vLx/vPx/uzx/vbx/u3x7/fuEqASQPZ3DwAAAAFiS0dEBfhv6ccAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAD3SURBVDjLY2AYOMBIJGBgIhIwMBMJGFiIBAysRAIGNkzAzoFFkIETDXBxcXJzcXKhC3My8KABXh4+fgEeTMAgiAyEhIVFRMXEJURFhIUlUWQEMUwU4JGSluGRxTQRxVY5eQVFJWVpFVVVVTV1IB+nQg1NaS0o1ObDrRCkVEdXWg8I9Q1QlWEoNOQxMtYzkTY145HFqxDoFXNpE2M9aQse9CBCDR5BYVFLcStrG3FbUTtBfMHDy2Pv4MjjxGPu7ILhRldk4Obu4enl7e3t5enj7oYi48rgiwL8/P0DgFSAf6AfqoQv8cksiEjAEEwkID5zEZ1dBw4AAEpqU4Ui4NrQAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjU3KzAyOjAwFHE73wAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo1NyswMjowMGUsg2MAAAAASUVORK5CYII="), + "sj" to CountryFlag("Svalbard and Jan Mayen", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAASBQTFRF1ygo2Csr1Rwc4WVm////2N/tATmYADeXBDuZACqQmazS43h61BkZ2Cws2C4u1R8f4Who43p81R0d2C8v1BgY1Rsb0gsL31pbmKzS4W9w0QkJ5oqM5oyN5YSF6qqs1d7tACuQl6zT6rO25YKE/f3+2eHwAjmYmbDW+/z9YYC7YIG8ZYfAU3m5ATiXADiXADOUOmavaInCX4G8AC2RADmXADCTACqPBj2aBz2aBTyZAC+SADGTMV6rMV6qMF2rMl+sKVioATmXADWWHU+jNGGsMF2q2eHvmbDV///+2OHvma/V3lFR31RU3ERE7KWm2N7smK3T772+4mNj5G9v5G1t1iMj0g8P6IyM6Zmb1R4e1yoq1Boa6ZGS6qCi6ZCR6p+gJDeP5AAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAD0SURBVDjL7dLZUsJQDIDhtEYFhSJaFgG1oiKLHtwqiCwqiAvuyuL+/m9hO+F0mDnBJ+C7/iczyQSAaPoUTs/M+vxzOB/QYLxJyIdBYoQWZBheXAqqwCSRaIzCOC4ndFMFSZJaWcU1J7TWMb2RSqoApU3cyjgTtzGLHMhJ+cLOrsgU9/YPchywPP5DIcSRfWyxoOQpnzih8JVLLLA9lVN3YrFis6A6VKs3zoQ4v2i2Lquc0a3b7h2vMHvNGQ1v3PB23Hk65O7+AR/d8AmfX17fVBAi3V6fwjgOou8RFXwQ4/NLht+6oam8JzJ/ZPj77z9OQjb8AwhfWkSfb+ooAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjEyKzAyOjAwLcFxvAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNToxMiswMjowMFycyQAAAAAASUVORK5CYII="), + "sz" to CountryFlag("Swaziland", "data:image/png;base64,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"), + "se" to CountryFlag("Sweden", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAJxQTFRFAEBzAD90I1NjG05nAD50AD9zHVBmG09nPGFYM1tcGk5nHE5m37sO37oO5L0M4bsN3bkP3roP5L0M/80A/8wA3LkQAEBzAD90I1Nj3LgQGk5nAD50AD9zAD51I1JkGk1oAD11578L4LsO/MoC+skC4rwN4bwN5r4L/MoB+8oC470MIFFkHlBlP2JXNl1bHU9mH1BlI1FkI1Jj////hM0NagAAABJ0Uk5T/Pz9/Pz8/v7+/v7+/v7+/v7+yMbBHgAAAAFiS0dEMzfVfF4AAAAJcEhZcwAAAEgAAABIAEbJaz4AAACNSURBVDjL7dHJDoJAEEXRh+KE4tQlqC2COA/g8P8fp0AKNxXSC+OKs75JJa8AZjWmikjNmnZLAo/58zxcLPVKUoc/Cn0WrIswjLQEbdbpbrIw7jl9CQbMHW7pYzcaTyRQX5RTMpAh89D49J4djqesO19iEa7slhTzpPeHBOWi0bN68PJH+lX9wjr8b/gGzuNz038exeMAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NTYrMDI6MDCyBjBrAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjU2KzAyOjAww1uI1wAAAABJRU5ErkJggg=="), + "ch" to CountryFlag("Switzerland", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAFFQTFRF+gAL+gMO+gQP+gAC+gAA+gAJ+0xU/GRr/F9m+gEM+gAG/svN//////z9/sjK//n5+gIN+gAH+gAF+gEH/svM/tja/srM//T1//7//GBn//v7oSjeMQAAAAFiS0dEDIGzUWMAAAAJcEhZcwAAAEgAAABIAEbJaz4AAACkSURBVDjLzZPdDoMgDIUFK1Io4L/o+z/oILswy9yo2bLsXLXJF0hPe6rqjyRkkmCANSTVZa5RrdatakocGkvOkTVYBD2FQJ4B8l7EA8R3FGLX38G+y92LeQdjzAhTBicYUzOczS5Azd5au6wUI61LKv2s4Nl5CRvt9KCdNpAnoKbgkmJmYq4C6c9A5tfsYdj2XDCcv8IrR/H9M+NHgR8uflx/phvpaw7xytebpwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDozOCswMjowMCRWQrEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MzgrMDI6MDBVC/oNAAAAAElFTkSuQmCC"), + "sy" to CountryFlag("Syria", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAMxQTFRF/wAA/wEB/xkZ/xgY/xkY//T0/vTz/vT0/////v///f/+//7+/f79tuG13/Lf/v7+zerMxefF7fjtRLJEn9ef7vjudsd2Zb9l6/frmNaYHqUeCZsJDp4OOrA61e7VvuW+LKssDJ0MC5wLJqgmsuCy/P78f8p/AIsACJcI0u3Ss+CzAJEAAI4AotmiX79fc8dzSrZKrN6s+/77jtKOV7xXZMFkesp69vv2zuvO8Pnw+Pz4/v/+/f39//7/9PT08vPy8/TzGRkZAAAAAQEBn8Z0IQAAAAFiS0dECIbelXoAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADOSURBVDjL7cxpU8IwGATgV1rKpgSKIMqhXF6oeHAXq63C//9P1DZJD2acfIdnMpNkZ2eJTv5zpkl/saAYZiHPNNSTiopVKuZZlnoSBMZsxpDF7CSjssBRqcIpp3HUzsHFRy46dTQu0MwM1nF5hZZcFD20O93rmx64qnH0B8PR7Z2I5OI9Hh7HT6neX/T8MnkNr1zx7f1jKtPIDPPFchVecdGJYe1iEy46KXA/PffrO/5QsuDhgJdk5EuB/xP4WUF0YvSribaaaKdJf/Eoi3sV+oSvKztrfwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDozMCswMjowMBe5DNYAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MzArMDI6MDBm5LRqAAAAAElFTkSuQmCC"), + "st" to CountryFlag("São Tomé and Príncipe", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAdFQTFRFgUwAAaMAAp0AAZwAAJ0A+gEAi0YAAKcAA50A6AwA/wAAjUQAAKYA6woA7ggAj0MAAKUA8gUA7QkAkUIA6wkA8QYAk0EA7AkAlEAAAKQABZ0ABJ8AlT8AAJYAAJQA7goAokMAZc8Ab8gAbcUAbccA8QsA8QUA7gkA+wAA/2oA//8A//4A8QoA7AAA8mAA/P8A+/wA+fsA+v0A+/4A+/0A+vwA8AAA9mEA/v4A8goA7QAA+2gAw8QA6ekA7e0AwMAA/PwA7wYA9ggA/wUASQcAuMUAw8MAREQA/f0A8AYA8gYA7gYAdwMARAUADAAAMDIAU1IAxcUAzMwAVVUAMzMACwsAR0cAeHgA+PgA8QkA9AYA2wYAPQUAAAAABAEAnZ0ApqYABwcAOTkA4+MA7QcA/wgAWQAAITEAGBQAz88A2NgAGhoAIiIAUVEA8AcA9QcA4AAAhnQAu7kAra0As7MAiIgA5+cA8QcA8QAA954A/f8A/vwA+/sA8QgA7QYA9ZoA+fkA/P4A/gAA/6AA//0A8AgA+AAAhWwAadgAbsMA7wcAZ14AApIAaVwAAKkABZsABJ4Aa1oABJsAblkAcFcAAKgAclYAdVQAd1MAA5wA////YmTFYgAAAAFiS0dEmpjfZxIAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAGJSURBVDjLY2BgZGJmIQIwsLKxcxCjkoGTi5uHGJUMvHxc/AJEqGTgFRTiEiZCJYOIoKgQlxhhlQzigqJAlRKSHFLSeAFYIVCljKSsnCw+wCAPUghUqaCopKyCBzCoqoEUiqpraGppa+EBDDoQhaLqunr6BoZGxiYQYGxiCmNCAFyhqI6ZuZaFBdwEJCaqiaKillbWNrZaEHkLLTt7LQccCh2dnF1cobIOWm7uWh4W2BR6enn7+Pr5BwRqeQBhUHBIaFh4hBZCKUMkzETPqOiY2Lh4sJyFVkJibFIykjokhaIpqWnpGZlA47SAOCs7JxfFkQiFefkFhVpFCWCFDlrFJVqlZVhNLC+vqKyqtqiBitdYWHig+roWqq5Ot76qwcjQxBga3oZGho0oAQ5RmJfX1KzVgjcKW8HqytvaOzpV8CaKLrB5XN3sPbL4k1keUF0XV29f/wQCCTcPpG5i3ySCeSbPs4trMmF1LAxdXVxTphJWB1TINY0YdSwMTdOJsBekcAbPTGLUsQAAE1aYJc9tpZgAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NDkrMDI6MDCI5EAcAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjQ5KzAyOjAw+bn4oAAAAABJRU5ErkJggg=="), + "tw" to CountryFlag("Taiwan", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAdFQTFRFCDmcCjqdCTqcBzebCzmaADumXi9k7R8G2yES3iEQAzKZBzicDDydGEOhBjWaCzudPmWyAzKYLlWsobPaACeUKlOoLVerBDaaCjudCDqcBzSaAB2OgZrNqrrdOGSpsMjaK1am4OX0JU+nACSSAjSaR2y1Sm23OGOsa564apu4gKnDYJazapa6L1esZIPBJ1KoK1Wq2+LwTIaqutDf/////f3+ZZa3lbjMr7zgATSZDz2gG1OcjbLH+Pr8+vz9+Pr7RX6nJVKnDDyeCTqdAzWaIk+mzNTsk7PJpcHU/P3+aJW12ePsjKPSCzydCTmcET6hGFKbj7TI/v7/+fv8SIGoHk2kKFKp1t/uwNTiapm5jbLJvMflBzmbRWu0TG+4M1+qZ5u2cJ+7hq3GY5e0aJe5Vni7CDqde5TKqbrcLlylq8XYIU+i2+HyLlirCTmbDDucCDibPWOwBzWZKE+oorPaACqVIkukLVaqBTaaCzucDDmZADulXi9jBDmeBTqfAjObBzufFEKjBDqeBDadAzWcADuoXDBlFzeSFjeSGDmTFziTFDWRGDiTGjeQZy5e7B8HzyMa0CMa0CMZziMa1SIW3yEP4iEO4iEN4CEP3SER3SEQW/bs6wAAAAFiS0dENKmx6f0AAAAJcEhZcwAAAEgAAABIAEbJaz4AAAEdSURBVDjLY2CAAkYmBmYQAQIsrGzsHJyoAKaOiYubh5eBj4+JgEJ+BgFBIWERUTFxCbwKJaWkZWTl5BUUlZSZJfEoZFJRVVPX0NTS1tHV01dhwq2QUcXA0MjYxNTEzNzCEr/VVtY2JrZ2JvYOjk5MuBU6u7i6uXuYeAKhl7ePL7cfbhOZ/AMCgSYGBYeEuuAxEejGsHCjCKCBkVHRMQx++HwdGxefkJiUnBKWitfXDGlS0ukZmVnZObnKzLiszgOD/ILCouKS0rLyikogr6q6BlNhLQTU1dc2NDY1t9SBOAytbZgK2yGgo7Oro7urp6cDxOnN6+vHUDgBDiZOhLEmTZ4ylRNd4TRsYPoMTgyFM7GCWZgKOYkEowqHvEIA5+WDvzAavScAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NTkrMDI6MDBETkCCAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjU5KzAyOjAwNRP4PgAAAABJRU5ErkJggg=="), + "tj" to CountryFlag("Tajikistan", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAWhQTFRFzRc4zRU2zRU0zRU1zRU39tbc9tba9tbb9tbo9tbl///////+//+7///P///9//39//37//3///2E//3L//2G//2o//2v//2Y//36//+V///V///8//+9//+m///3///d///c///l///6///f///U//9O///4///D//9a//9d///i///e//9L///x///u///o//9Z//9w///5///7///s///k//+E//+r//9V///H//+B//+q//+f//9v///p//+T//+g//+y//9W//9l//+///+P//+u///q//+v//9x//9i//9+//+d//+h//9z//93/f79/f78/f7//f7W/f5o/f5N/f6Q/f46/f5P/f6N/f5B/f6C/f7j/f77//+x//+W///C///X///B///A//+L///K1OzZ1Oza1OzY1Ozk1Ozt1Ozo1Ozl1OzgH508H509H506H504H507H505JJ9BI59AIp8/J6FD5kCDSwAAAAFiS0dECmjQ9FYAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAEdSURBVDjL7ZDHV8JAGMQ/G9GJrsauEURUUBRRsCEqKvYu9t6lRCXE9u+bI7t55OXmxd9hDzPzZt5+RP/YUWalvKLSKlKVgEuSqmskySXqBBEZtXVgFpnqORqUxialuUVpbVPaecfS2NEJpqLLLZbyQU+3bE57e8zH18tKBhn6+v0qAgODQWBoOGTGSzX6RmQZ4dGxCBAdZzbTEx4wPyanEGEIhW2C0zGwKGbiUFXMznH/ERrnkVhYXEour6wiuFa6Ucb6xuZWfHvHvZvci/EHov1iDlKHR8cnp2fnF5dXqWvO4qcZbm7vAt77h8enZ+Hi9FJMOpPNaVr2VdNyb5k0Z9E7R14v6Lph6B8FI8879OkQ+nLIXwa/HUI/DvkFp7PQDyhhj5YAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MzMrMDI6MDAmURZLAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjMzKzAyOjAwVwyu9wAAAABJRU5ErkJggg=="), + "tz" to CountryFlag("Tanzania", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAPxQTFRFAJkAA5oABJkAAJEALqoA0OoA//8A9fYAZ2cAAAAAAQEAAZkABJsAAJUAApcAc8YA9PkAxMQAKioAApoAA5kAKqkAxeYA9PYAcHEAAgIAApYAdccA9vkAwMIAJicAAwMAxOUA9PUABAQAKCgBc3UD9fYCJygBwcMD8vgKcXID9PYDwOQ7LarRwcME9fkHdceHApb9AJT/xOU4KqnUAJH/A5n8A5r8dMaIAJX/BJv7AZn+AJn/Apr9cHIDAJQAdscALaoAweQA8/kAcnQA9vkHJycAxOU3dceIcXIC9PYCxeY2KysAxcUB8/kJcsaKaGgA0OorLqrQBJn7////k/P2mwAAAAFiS0dEU3pnHQYAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADxSURBVDjLjcx5WwFRGIZxjN56TrK00BDTKEubKGsnVEqFtHz/D9OcsV0xJ+/99339fD59/oAR3KDNLQgA+m07tBOORCm26376cW/fOIhT4lDAxD+jwyVTR5TOwJp80HPHZDtcVkw+k8cJCzzOwgmHywKnORaXL1CRwYmzc7q4ZHBXVLouVzjczW21VmdwjXKzdSdZ3L2UksfNRm+uveCm43rOHTmcGv0cTo2dZHc9p8aHRwanxicOp0a7hyXueZVT48sy1/fg1AjrL/fqxamRxbkih5uPJsTbOw203GwUGI7oY6znpqPAZ46+vqs/danvF4pIe3odrT25AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjM3KzAyOjAw0h4yWAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDozNyswMjowMKNDiuQAAAAASUVORK5CYII="), + "th" to CountryFlag("Thailand", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAACpQTFRF5wAA+9HR/////vz9LkSsABKWAh2bABuaABiZ0dbt/fz9/e7u6RER5wEBg9UTbwAAAAFiS0dEAmYLfGQAAAAJcEhZcwAAAEgAAABIAEbJaz4AAABISURBVCjPY2CgFxDEAhiUsAAGYywAu0qsgi5YAEMoFsCQhgUwlGMB9BPswAIYZmIB2P2+CgvArnI3FsBwBgvAHpt3sQDi0wIAVyKx+Q1baa0AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NDYrMDI6MDB+rDD1AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjQ2KzAyOjAwD/GISQAAAABJRU5ErkJggg=="), + "tl" to CountryFlag("Timor-Leste", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAmRQTFRFShsF0DQO1wgQwwAPywIPzAMPywAPAAAAKSMCwW8L6kMPxgAPxwAPzAIPAgEACAwAlHwH/qEN2zkOyQAPAgIAAwIAWk0E88cM950N0zIOyAAPAQEABAMAJhwCzacK/9gN6pEN1jUOygAPBwQAlnEH/9YN+ssM65EN2DUOXEQE8rwM/9IM9sYM7ZMN1zQOKiACz58K/8wN98cM+cgM7ZIN1zMOAQEBCQcAnHgI/8sN+L8M+skM7ZAN1zIOAgICBAMBAwMBYksF9cEM/cUN87oM+soM7Y8N1zAOEBAQDQ0NAwMDBAQELyQC1KUK/84N9LoM9r0M+8oM+sgM7I4N1i8OOjo6paWlGRkZFhYWBQQBDAkBon0I98AM9bsM+L4M7I0N1i4OIyMj////kZGRERERjIyMzc3NaVAF+MMM/ccM9LwM7IwN1i0OGhoa8/Pz/v7+8fHxampqNCgC2qoL/88N974M+MAM+8sM+scM64oN1SsOyAEPU1NTv7+/+/v71NTUBgYGCwgBnnsI/8YM9r8M970M+cQMywEPcnJy5+fn/f39V1dXkHAH/8cM9r4M8aEM2TsOFBQUurq6ysrK3t7e/Pz8RkZGKR8CzqEK7pUN2DcOl5eX8vLyDAwMMjIyR0dHXEcE8r4M/8kN7pQNiYmJCAYAmHUH/80N+MIM9LsM2DYOLi4uBAMCKSACzaAK7pMN/sYNCAcAzZ4KXEUE/9MM9sUMCAUAmHQH/9cN+csM6o4NKh8C0KoK1jIOX1IE9ccM9pkN0y4OCg8AmoAH/p0O2TQOLSYCxW8L6T4PTxwF0jIO1gcQblB1CQAAAAFiS0dEYiu5HTwAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAIISURBVDjLY2BgZGJmYWUjCBjYOTi5uHl4eQkq5GPnFxAU4hYmZCoDu4gou5i4hKSwFAsvfoXs0jLssnLyCopKeJUCFbKzy7Arq6iqqWvgMxWsEGS9ppa2jq4ebqUQhSDr9Q0MjYxNTIWFsSsFKzQzA1lvbmFpZWRtY4tdKcREO6BKewd2RydnF1drN3dsSoEKzdg9PNm9vEHW+/j6+QcEBgWHYCoFKrRjDw0Dqg6PYI9kj4r2i4mNcw2KTxAWRo0tsMLEpOSU1LQUdjNREfb0jMysuDi1oOwcoFIWNKtz8/ILkgrZvcG+LyouKS0rjSuvqKySqkZR6FlTm1SXVN9gxg4J/Mam5paystY46zZdW6V2hEKzjs6k/K78pG52L4hC6Z7evrKy0tIK6/4JyArZ2b0mTkqaPGXqNKBrgVZPnwGyutTadeYsYSlUN3qzz54zl33efHZ2UVH2BQsXZcWVurounoWaSEAmerMv6QD5BGjt0mXLV6yMAypbBYx1VrTgAXp7tQe7md0aGfa16/xWBgS6rsdQBk8UZuAUtGDhBhdXV10NTGUwhcBUIcO+cZllmVGgCVZlyMls7SZQMtPDrgwp4W7W2rLVhFDClWHftn3Hzl2mBLIC0Nrde3bs2itMIHMBrd23/8BBXFkArpCP/dDhI0e5CSgDmXjs+AmiipSTp04TVUgBALXfkEz9cz3PAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjI0KzAyOjAwwJ5DZQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNToyNCswMjowMLHD+9kAAAAASUVORK5CYII="), + "tg" to CountryFlag("Togo", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAZtQTFRF1wIA1gIA3AAAxQ4AHIEAEYkAFIYAE4cA2AAA1wEA3QAAxQ0AGYAADocAEYUAEYYA2AEBGoAAD4gAEoYAG4AAE4YA1wAA2xUV2hMTxQwAF38ADIYAD4QADoUA2QQE2QgI1QAA6nd352dn1gAA2QMDxg0AJIQAGowAHYoAHIoA1QEB1AAA+M/P87S00wAA1QMD2AEA2hUA6NEA6d0A6doA2g0N6nNz63l57ICA/vv7/e/v7IGB7YeH6XBw2AIB3BYA/dsA/+gA/+QA/+UA5VVV/fHx//////z8++Xl4kFB3BUA/NgA/uUA/uIA2xgY+t/f+NHR2AsL/dkA/+YA/+IA/+MA2AIC2x4e/vb2/vX1/vn5/O3t2hUV/uMA3igo3zAw5VNT2xkZ52Fh2wAAyg4ASpMAQpwARJkAQ5oA1gEB1wEB1wICxAwAEHwABIMAB4EABoIAxg4AG4EAEIgA1gEAwwwAEn0AB4UACoIACYMA9q4A9a4A960A8bEAyswAx84AyM0A/+4A/+cA/+EA/+AA/uEA/OIA69sAHosA5rKH+QAAAAFiS0dERhe6+e0AAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFHSURBVDjLrdLXUgIxFIDhI7aIhQiyYgEWF+wFe0VFdMHe14LYsPfee39sQ0Bn1qxOLvyu/znJnARALU4Xn5CYlMwCpJaiT01LzzCwvkOMv8JMo4kvzDKaTaxYiIVsi4BpmJObl29lRUObXXQUSHYnCXWuwqLiElY0FEvLyisqq0SE3Ki6prZOAwkxqm9obGpuaW3z2FG70NHp7fKxgF6wu0f2++VAr4DdQl//wKAGejQWh4ZleWRUxIiEY+MTkywaKsLU9MxscA7RkEwMsWhoEx2B+YWgR7SR8I87EosWSVpajuwxvLK6tr7BioWbWHFubePIwnd29/YPWLFQIQ1W6Mu4uH/PL5/CrQb6w6Njs9ZEQe0kfHp2fnHJgiu165vbu/sHDfDI8D55NcDzDy+vb5ogxAl8nOCdE3xwAisnMHECA6f/Dz8Bhgr8J1Oa6VUAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NTErMDI6MDB3oQ7lAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjUxKzAyOjAwBvy2WQAAAABJRU5ErkJggg=="), + "tk" to CountryFlag("Tokelau", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAvdQTFRF6lpU+7Cq4uj0ZnW1BgZkAABXBQRnAABkp5q82xkUAABjBQNiCBZ9XEOCwUpW72Jb7cjJERV1AABiAQFnAABmX0WCvFFi9m9k/8O51djqX2yuCAhnAABWppm62xkVppm5AABeChV6Vj5/uEtc9G5k/8S6297tYGenAQt1RjN7qj9W6GFd/8O829noUFifq5+/2xgTq6HCSjd+wFZk72li+bm1x9DnT2GrAAFfAABVqpy9pZW3lY64rbLU6MDE6I2O+9/c///+9dvczwwMzw0M9d3e/L249aai+/Lz8/X5qJq8k4OtqZy9n5O4CwpsAQFm3BoV3xwW2hUQ0RYW0h8fzAsMywcIzw0NzAEBzhYXzxsczgkJzwkJ3h0X3xoTzBgaDwJgAABnAQBm3x0X3hwW3xsTqp2+ppm7qZu89PX59drc++Dc6cDErbPUqJe4n5G3CwtsAQFlAABUAAFgT2Krx8/n+Li07mhiv1VkSTZ+2hgU2hkVqp+/T1ee2djn/8K752FdRjN6AQt2AABfAABlAQJmBQhranKu3N7t/8i893BkvExcVz9/p5q63xkV3hkVCAhmYG2v2Nzs/8e7xFRhW0KBAANpAgNoJBlvVzZ2BQZrAwJn8cjJ21pctUVYVT+ABxR7BANim4+2AABYBQZkX22w0dfq7qeny05WDQNjEBd3oDRQ4R4aUjV3AABoAQBlCABSDAZZCBN7AQBhBARoBgdlFCODDhJyAQBjAgBlZzJpmTVUJx1xAgFnAAJqAAJpAQBiAABgCwxvAwZvDAtsAQBkAgBkAQNoAgBjAwFlAwRpQidvKxtuAAJoHh15CgpsGx140C4xnDFOAAxzAQJoMiV2mi9NaS1jEhRzCQprVCpqQCRtAgFmOyd05SUcnjFNAAtyAQFoHRhxPCd0Nyh2AAJnAwFmAQFkBQVpEhNxPRxneDBfFRBsBwVpGxp1ryY65w4GZS9nAARsAANqcS1flipJNB9tBQRoDw1vAgRuEQ5sAwBk////z9KtAgAAAAFiS0dE/DwOo38AAAAJcEhZcwAAAEgAAABIAEbJaz4AAAIRSURBVDjLY2BgZGJmYWVj5+Dk5ODi5uLh5eMXEBQSFkEHDKJi4hKSUtIysnJy8gqKSsoqqmrq7CKYgEFBQ1NLW0dXT5/TwNDI2MTUzNzCUgSbQitrG1s7ewdHJ2cXVzd3D08vbx9fP3Z/TIWcAYFBwSGhYeEREc6RUdExnLFx8QmJSdgUJnNGR0dFOkdEhIeFhgQHpaRiV5iW7p2R6eHu5urinOWYbZ+Ta5OXXwCz2r8QobCouKS0rLyi0rCquqa2rr5Bq7GpuQUq2dLaBg8AhvaOzq7uHkWF3r7+XpkJEydN7poydRpU5fQZM2fNhimcM3fe/AVcC7kWxccvYmdbvGTpsuUrVoLd6M+1avWatevWQxVu2LiJa/NsfxG/hAQ/Ef8trYu3btu+IxEst3Pdrt172PdCFe7bf2A2yOktiYkgC/23+B/kSoRaN/vQ4SNAwUKQPENSEsSH/nCGMIiGsI8eA6pjP94KJBlEsIK9J06C0gU4OE+dPnMWl0J/oXPnoQ7w57pw8dJldn+sCluuXL12/QY01Ftu3roNDAWsCu+I3L13/wE7NB7vPNzrj8NqYfZHj588hXOf3RHB6Rn/lkK0lIZDYdKdOyJEKcQE1FLoT5xC/8LnwkQpZH/xEp7N8ChMEjny6vWbty0EFfqzv3v/4eMnwgpF1n/+8vVbyx0i3Pj9x89fLUQFz9Hf8FwIAJ4c7JVGOu4bAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjA4KzAyOjAwRRsubAAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNTowOCswMjowMDRGltAAAAAASUVORK5CYII="), + "to" to CountryFlag("Tonga", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAANJQTFRF/////vv76J6evQAAwgQEwQAA/PHx+OTk+urq//7+/vr63XR0zCsr/fn53G9vugAAySMj/vn5/PPz22xsuwAAyiMj/PLy/ff3/vz82mdnxhMTyiYmxA4OwAAAwgUFySEhyB4e+uvr0FFRtwAAuwMDvgAAwgAAuwEBvgwM+ejo//396J+f2mho33x8zTIyxRAQ3HBw3XFx3nl5vAAAyicn2W1txiMj/fX1/v39/fj45pqa0D8/55yc4YWF4YOD4IGB4YKC446O1VJSvwAAwQICwgMDuoAxsAAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAACySURBVDjL7dHHDoJAEIDhWQF1VxSxsKBiQ2zYEHuv7/9KGmIMJrJLPPtf5vJlkskABEMQE0Tpay8RTyQxH2ICKUFOA+ZuRJBRsiofkhzkC0VNpZgJdTBK5YpZrdXlBrBh02rZbbOjdHtM2AdnMBzZ44k71TD3GNebRThGpzC3FssVYUL0bA2brUF1gijsOJ95v9AJhXu/w/Hkj/PleguBXjDBs6WQQPzsHgqliP3hH/4OH2kvI7hBH2EDAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjM5KzAyOjAwgiFJBQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDozOSswMjowMPN88bkAAAAASUVORK5CYII="), + "tt" to CountryFlag("Trinidad and Tobago", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAjRQTFRF8pKS/v//SkdHAAAABwcHAgICBQUFXFpa////7oeH3QAA4QUF4AEB4AIC4AMD3gAA9ZiY9P//Ozg4BAQEbGtr7HV14QQE4AAA9qGh8/7+NzQ0bm1t63Fx3AAA96en7/r6Mi4uBAUFdHJy6mlp+K6u6/b2LCkpeXd36WJi+ra25/LyJyQkBAMDfnx86Ftb3AIC+7294+3tIx8fAwMDAQEBg4KC51RU3QUF/cTE3+joHhsbiIiI5k5O3QgI/srK2uPjGhYWjY2N5UdH3wAA3QsL/9HR1d3dFhISAwQEkpOT5EFB3g8P/9fXz9fXEg8Pl5mZ4zs73hIS/93dytHRDwsLnJ6e4jU13hYW/+PjxMvLCwgIoaSk//v74S8v3xsb/+jovsTECAUFpqqq//j44Soq4QMD3x8f/+7uuL6+BgMDAQAAq6+v//T04CUl4CQk//Lysre3AwAAAQICAgEBAgAAsLW1/+/v3yAg4Skp//f3rLCwBAEBtLu7/+rqpaioAgMDucDA/+Xl3hcX//7+n6GhvcXF/+DgmJqaCgcHwsvL/9ra3Q8PDAkJxtDQ/9TUi4uLy9XV/87O3AgIhISEAwICEg4Oz9ra/8jI3AUFfX19FBER097e/sHBd3V1FxQU1+Pj/bu7cG5uGhcX2ufn/LS02wAA6mpqaWdnHhoa3uvr+62t7HFxYmFhIR4e4u/v+qen7XZ2X15eIyAg4vDw+J2d74iITkxMCAgICQkJLy0t8fj49ZWVDCFcogAAAAFiS0dECIbelXoAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAICSURBVDjLddT5Ww1hFAfw4ZjrmDvvXAzz2kaFCCnckS2iCRVRJFtFuOjay74nRPZ932Xf9+Wfc17vczXde9/vz5/nPOc5z3O+mtatO/TQ9RD0xF5G2AyGJWJRtEjvPn3BBtChH/Y3HK6KZhkDBg4S0obBOMQIKyGz3KEZmUJmwTAcrpQaN5k7InuknDkKc1RS40KOHjMWcoUch3kKSZAzM3/8hIkQBc+GSViQXgrIGZ88Zeo0KadjYVr5D5KcMbNolpSzsTidlJAzv2TO3HlClkIZlkccFSQ5f0HFQjq7F4VFWJkqE5BbftXiJdVSLsWaFPkfkly2fMVKKVfV1iXLTkiyfvWaBiF1WLtufZIMQB7zN2zc1OgJGd+8ZWtXGYQ8Ftm2fcfOpmZobtq1e89eP6aC3Ins238grnugewcPHa4Pyq6QZF3tETgqZOOxluO+pYIka1pPQJQkNJw8VdUpkyHJSmyT8vSZ9rM+U0GS5VgGpUKeO3+hJCFTIXeMYrwItpDVly5f4UwFedgoxKtgx+EaXL9x85aU6SDJArwtniMKd+7eyzeZCpLMw/v0bSQfPHzkMlMFSebgYwgJ+eTpsw6SCkjyOb6Q8uWr1x0WU0GSb/Ct2DMX3r3/4FpKyB33I36iE9HMz1++Ghr1T6KLAv1E0HTcb/gdfoRCP+HX7z9/Ac3knLPtY9BvAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjA2KzAyOjAwFSRVMQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNTowNiswMjowMGR57Y0AAAAASUVORK5CYII="), + "tn" to CountryFlag("Tunisia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAa1QTFRF5wAT5wIV5wQX5wMW5gAK5QAC5gAJ5wIW5gEM5gAH6yk68Wx39I6W9I+Y8nB77C8/5gEK5wMX6iEu+LG3//z8////+bvB6yo35gAF7DtG/e7w//7+/ezt/Nzf/vHy/vb37klU5gAM6iEt/ers96yz7DRD6AcZ7kVT//r6/vT26y865gAG96es8neD5QAA5wwT96qy//v8//v7+Lm95gAL5wEV6iUz/vX1962z5QAD5gAN9660+svP9pui7DRB8F9q7UhQ7UBN+s3P6BQf96208W558nN984CJ/vHx6iAu84GK9I2W7DhH5wIT8Wpz/vr69ZWd83+J84SN96et7T9O5wAO5AAA9ZWb/vj49ZSc5wQW5QAE8F5p7UpS7k1a97K16Rok9Zih7ktZ/ODj8nF76iMx/vT05wIS+b3B+LG2/vT17DI/9qSp836I5w8X96mx//39+La66R4q/efp+LO57DpI6Akb7UJR+LK4/vn6/vHz6ys27DZB/ert/vDx/OLl/vP0/vL07URP6R0p96mw+LS66iUy5gEN6iM18GVw9IeQ9ImR8Wl05gEL5wMVuLb+ywAAAAFiS0dEFeXY+aMAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFCSURBVDjL3ZNXW8JAEEUTEojBiuEqGgWxKxoVQQ2i2BUbVuy9d+y99/qbXd7ZwKuefT3fzO7MXYb517A6Ahtd43g9wcBGUYU40RifkJiUbEgRtDyTmCqZESYt3cJp1BMzMiEjK9sqw5ZDN1l7bh6QX1BYJKEYJaU87Z6CowwoVyoqYTZXOVHtctMK1tSiTvXUw9tAVBmNhsgldaoPaFKagZbWtnYv0KHXRRb1nejyK93o6e1T+hHAgEoTB2H1K0MYHhkNjmEcExRxcmoamAnOAnPzC4tLwDKlNWtfWYWkrq1jQ4JtE9iiPIaMZxvYUXb3nCFysM9TxsO4PQeHwNHxyekZznFx6aIGQxCvrskKb27vZNw/ODSWzYmPT4FwJkLPLw4To4Hwanl7//j8MorfmjELB9elkuDyPzFkPLav8Kf5BfpyNUN31ky0AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjAzKzAyOjAwRxx6lgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNTowMyswMjowMDZBwioAAAAASUVORK5CYII="), + "tr" to CountryFlag("Turkey", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAActQTFRF8xkw8xox8xwz8xcv8xQs8xUs8x0z8xsy8gwk8gsk8x409Co/9CU68xIq8gQe8g8n9lpr+7O7/eDj//n6//7+/ufp+qiw9UNV8goj8xgv8xMq8yM5+7nA//////3+/eHk+qSu+Y+a+qGr/L3E+HyJ8xYt8yE3/dLX/vLz+HGA8xYu8gch8gYf8gMd8g4n9lFj9lRl8xcu8xwy8g0l+6my//v7//b39ktd8xkx8xw08gsl8x418xQr8xsx9UdZ//r7+HqH8x828xgw8xoy8xIp9T5S9llq8gkh+ZOe/ujq8yA38xYv8gwl9ThM/uXo9CtA9CM5911t/MDH+7jA8xsz8x00915u/dvf/vT1+YyY8xAo8xMr/M3S+qew8gkj8xMs9TtP/LzD+7a98gEa/L7F+7vC9259/vP1/vHz9UNW8xEp+Y6a/uzu9CM68gki/d/i9CxB92R0+HF/9UFU//39+YOQ8gId9UZZ8goi8xEo+qCp//r69ldp8gIc8gok9CI58x818xUt/MfN//f4+IGO8gUf91xt9lNk+6qz/u3v+7a++qCq+7G5/MPJ+HOB9kxe+qSt/dTY/u7v/drd+pei9TZK8g4m8yE48gUemlBhbQAAAAFiS0dEHesDcZEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFvSURBVDjLY2AYzoCRkZEYZUxMzCysDGzshExj5+Dk4ubh5eNnwquOnZVfQFBIWERUTFxCEo8D2KWkZWTlZOUVFJWUVSRxq2RUVVOXldPQ1NLW0dXTNzAEimBXaGRsImtqZq5rwcRkyWhlbS0paWPLiMVX7Px2svayDrqOTiDgzOzk4urGKckhiaGQzd1DVtbTy9vCCQKcfXz9/AMCAwwxTQySlQ32CYGqcwoJDZMNj4iMwrCcMTpGVjY2DqrQIj4hUVZYNimZHYsbU2RlUxEmOlmkyaZnZGaxY7oxW1Y2J1cL5saQPPP8gsIiKYwwYo8qLjGVLS1zBKt01mLIKhev8KnEEj5MnFWy1fY1tcwhTExOdfUNDI02Rka22GLGkL1JtqS5xTqvla+xrV2VAWd6Y2cx6pAVke3s6u7p7WOVZMAN2A05+idMnBQxecrUCga8gNFoWp7hdCbjGbz40yPIUDYGLUNbNqJyA3F5ZlACAKV7S8gA90V0AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjMxKzAyOjAwsc4HYgAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDozMSswMjowMMCTv94AAAAASUVORK5CYII="), + "tm" to CountryFlag("Turkmenistan", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAIAAADRv8uKAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAABKNJREFUSMe1lktoXFUYx//fuffO3HncyTySdB7JJC1N0mdIbTRtpbYNtKGKi6LdFLGVbqSga0FdFQTpwo0UESkI3YgLFUSK1bZEqFAhBftw0klqk2aSySSZTOZ578y953ORuBGK0Ml8cHYHfud3zv8759AnI9gxh6cZCED3eF0Nq2Q7EtQe5upWvBuFrQIMAETEzNikUutlyme4c/il3kMvWoqVmv9hj1nJTpprKbYMUGKDCgmWTBqxZCJiYjS3BlHMsMswdrwxOp765eaNnybygc8amn80Fknoa/NYNwXD7/UnY0k2WVM1N7khmzUWQgM3amvTX//ly012KslVuSuvR7vOSCNJAJEAM+ogQcwwgoaqqKP7Rt3C3axxIA6nbs/8nD1XqZ2MlQaHh94cPfv017uFyalQL6QjFUVNxBKChKaqvVt6a7VaIpI4/cppVKAI5fnP2OVBpBczj/Fw1tTJyirX5p3vTeZYnCrB9Z0WhsdfqBaqVvXx3GOYqFQqpw6fuvrjVQI9v7GUaJShg6tCNJKkb60VVeGBcErs2CDAdhqp9GTAE2jztkEAFRwbOiZIgNEEF6qZx2KOZJRnhgLdQdnmmPf2Bg9N5BZmFXXBQTfArPiV5bXlhewCNFx458L5sfNHPzgKF5rpLtUpIKeLmcP+IwsFMQeh4QjlUgd9FcsZyDtMAMixnf0D+0cHR0f6RxKRxNjHY+MT48InHOk8N5gu7kYgLarbxHKfHtcQa5i39MDOdKGcEu1R+/1BNAAwwAgaQRK0mlsFQD5i2VSsVdVAb0wupaQzUw/thMst46mqb1UmOmS5HYIBAhFAVCgWAAivIKJmXDfAzHBs1ADRqN+YoYYqBmqWCdg2wOB/E8RgKCAiybLJDt4AW2vIz2M6hFkXkqEwwUxxJRjAYA4yB06sUzdqE+9qUc9jRaCym7arOJ6IntjbP+iQswtZA/WVTXF7hrE7jNAyXI/4bwF6MqWvdEwp7EqjowzqaqZR/w/sakN7DAMZBHRM645TmO8yqSfHW8IodwISECBsvrpKBFLhAfpNJOdtSfBZsAEo62FumbFZQukpHvUg60YlrpIg91wjoGB/CjUfEANaoAtAWCso6bg8guIOV7odD8Lc6Hd9sQ+zcdg5sAK0RlvVIzCWcO4uFdz2tqhGQqqZ+tsqurOwkiAHoJYYq24DgW56IY0qZCllAWTY5AUbnShFNia1JFxg2CYXdCV55tTLY6+aDy7NTaTn//C5amvrV3SL8iVqiyiIxJFvPz/54XtmPrOyVD/wWs/Ri/3VAIpzRArQonCVl6AGrUj9TunOlaufXvrqy2nTe7Jr++uRAyPFRQaJFhmrnhCFfMv3f/t9cEg7f9av7fyoY/Dgoz9vi0oxFIdtAnpLlFVWuG+Ybl5JZ6IcGzZ8ypP739zKfHft2FsyH4W0m/7HPgtcXYFk7tnjTN/G7FRR8mVidLRTWw+tXWelE05rHgrBEk/G0XMYXg9IskYKoPSd4OUUl3MQWouEoWoeLDxEeBh9x7F4D0JzPGEEunD3MtSWUQGI9TF9HfUyjDg8YbgDSF+DVYZQsXkP/3/rHyDlCfbydKOTAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjM4KzAyOjAwJFZCsQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDozOCswMjowMFUL+g0AAAAASUVORK5CYII="), + "tc" to CountryFlag("Turks and Caicos Islands", "data:image/png;base64,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"), + "tv" to CountryFlag("Tuvalu", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAIAAADRv8uKAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAACApJREFUSMellntwlcUZxp939/vONTknJ4QkJCDkhtKAQkBqwTKIKGItF7XY4tii4KXOiO3gFQerrYIiWDuO1hFREFSwELTgdNqCWGvRQSPILYFcICCBk5Sck3P/Lrtv/whUHKwF3L++P77d3z67z/vuQx0Txvpv+6X35ptffOWzJ+5fGY93ChE2TY9ldd9465S3ppufTrlRAn2G1NhrNtfWLZIA4LrKMiLl0ybV3B1s7Lt1/dCfz3j+mllzdyUMD7mMsxliY9WUrjfeyEyd9OuB0b1tS+c9frvfbzhOHICUAqdWYQBEROyqFAcjk6eOXfMj/Uz7S6Pl8er16+prZ764Zh8ChtZnhwXEnctbJn85bpVv9J6HH5fXj19yWaZp/8K7770BUK6bBJ9ciEDsWhA0+eqR784wX+5cNkm0hRctXT95/ojZf7/hJ/P372uGx3P2YKr83u/i8Yztzx8zpuquQbEh/1ybP7C8fPETO+N5u1ri16e2771ppgDyqysi//pi7/sNIz5+247H8+c9/ImncuFj73z4XoPH7wmbRnJcdXLacKRtCDorcOdftxCBlYrFMhQpLCsO5pqalObCwRWysLBjxeqOJ58UgFFSWrNurUc5ie6kp7JSMLfvaZNShCJBW3GE1bNZ/2OpoEHsfsvxEms+uS1qAHo/JQGAzSAhCHC1ZsA4bZoGGJCABgjwCjCgNZSUhUq9NGnm4tmPykRMSfkN+sCStFI+KS0N0kwiB2SBDJBiZBkacLV2tGaAAX0GWAEaUEBaI6ORBtJACrC/7VyZtenmCieUNJCTp10fwMbFS58igmFIy3ITPRnBWobDCATdWMzr9/Rs+yRWX0+ADBeU/2quMIxc1ja8HrMwopRCPBYO+ZQ08lyrzF+JTJakOFMra7MqdHhC35131mxYXdD8t+ioffEq47bGCtfV8e50WVl43n0TR1QVpJpbnT+vL/7x1elLLqXiVSfq6wVgFhaEH5jvmp5ik9Lbt3etfD1v4lUbqqZs2LgbiXix37P7ggiqlXIIp3lLEAOAdI6kSy4ftmNk2RedTvjVg9dCKLlvh9W0s/n7dYMfXXRjdfbosbn3uK++cDQycO6Kw+9uPfLTocaxt9cDyC/tG5swbexlTynHrbuqrrg0HH16cUH9csM0Nu2z/7H5g+MejdG1sGwQnax8Fqy8AEhLVwVKvbGPo5cciFd8EB1N0haz7vhZc+eqNcunFy+5P/aLm5L9Kp794SNXvuNbt3WHrTQMs/dqNZHweDui8fseXH3RxQt/35hfvGXrqLXL50Ta36/86Lnpg8srquHYBClJG6ShPQXexKii3WEzOapoD4zsm4evXLjz7pdbpxpmilmK1/5wXemyRc1D66Jx9crlD11R71+yZEPycAtggmGA/YAP8DELMJgEAsc7js+7fXFV4T1Pb86pl9f1f+jhe7277vA1Av4CM0muH64/5I3Hs0W/Hba8Y+r06ryjsEJZbRq+7rQ2XW0CTHVL6rN79/a5YtyXgX6HtuwkL4l8P2vWttunrPCiIpHatZukNIIBDBnW8PkRZhaChBQqY3N3qrS2bMjlQ3Uidahpf3tgwJD8tllVGwV4Wcu0foHOF0YtvbCgbUXztPl7ZnflIkSKT1mA8PoOBAJIpqBsGQpozdzbJolgu3CBgB/M0BrZLIKe04xDQgo3ayOVgxTk97KD6/p/VD/+AUF6xgdP1X85vjbcNmPA1t/snuM301nlI+j/gg2pbO6xSBBLqZK5r1UCkSBwOtm7QxhCZ74qV93bSQSJgBdg5Sqv4STsvDdbr5XQJ+ywV1qNiYFLm2aCOKt8gAYEner+hNe2n2Vb///tF8y5PjWRA4L0/u6LhO8Eg8DEpMECQMiwksrLDBCL74w7rT+BpL+rNVPcnC6V/i4NAkBCA8IrbVO4j9SuKDBTpnQAfGcwC0laEvdqUiyZFJNSLImYANICLAYGo38a89h9ta/Xj10wLHQQ2vyOYMo30+zkCdcbNNNg6tXd6yB2fT7iUl8M2jjQNWxHTxWUpzHZ//POOilzEtNuPz+mIM1u4JKC1jsHrxtf2nCgpzJuhUm4va8dgYv83RNKPr218r2GeI0000knOG/nPZ1W5JiT57JpnB8VADNBOFWh9gUj/pi08zdHRx5MlxAxGESstTk83Pr8qOfKw0cc5X1w95xt0ZEk7Y+iIyEtgM8TTACzCHpSMTv0zsGruq0QgQ0j57o+QRrMYPFhdOS26PBB6eItxy/NZvuavm5XS2G4mgXOr5xOPQIQYJ0pGV7yWcrJa4nXwBu7IHgsZYcA8pvJHidYYFjHM8WDQodakgOIvpbHzlkx9RIBgtYsiyL793QPMaXVJ9x6It3Pw2LTuAeIeNYnC45mi7JGjoXdkhgEYTO+lsXODUwAa0++mdYs0soL5R3ki8+uXalYPNN4ywlS15RvG1G0V5C+pt+2/ekS3RuLz6CeK5g8wrKAWyr+0uME3zp8JYQ7rLDprto303Zw07EfHLHCq9onGsKRpF9rn+SVtqW8wDcH3nMCs8PGgxeuXXDxMlt78mRuVfvEpsTA1Qem/tsKd1kFEtyTLVrZdh2ARK6AjNz/op4bWJDWTnBTx5g5VRuzyrOpY2zGDn3cMaY72yfj+o8kB5A3TmYm7vgBkJll/raAfQ6u7o1tNeFDCSvkEY6UzqFkf8PIaeUFNAlXscRJ9+HMSz1/xQyCcJp7Kog0mBiAcFxtELkANMuvfjuL8R8dveX2nx36eAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo1MiswMjowMEZJFHgAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NTIrMDI6MDA3FKzEAAAAAElFTkSuQmCC"), + "ug" to CountryFlag("Uganda", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAASxQTFRFAAAAHxwA4MsA/+kA/+cA/+gA+9IB+9EA+tAA+tME+tIC+s8A4k4H4kwF32Eg341c0pJG4bBy5Jlp32Af3jgI3TYG3F888NHL4NjbalUyvaGC/fn978/K3jkI3jgG20sg79DI////zsfHXFNS29nb4DkI3zYE4YRp/fz+//3/nJybdHVz8e/x//7//fz9wzIHwjEG3qiZ+/n7a2xrSU1Jur2618nG9+7tGwcBGQYAn5eWwL7AR0hHT01Kn0Ms3XVe/vf4n5iXZWRl7uzusbCxS0xNpnlv0lI19eflZWVmGhoax8bH9/f3paOlsa+xp6ep2cO/47ClxsTFNTU3xMPG8vDzs7K1sbCz+ff6xMTHHBkAODUagHxhjIhtn5uBgn5j38oA3cgA4cwC4MsBYexgUAAAAAFiS0dEIcRsDRYAAAAJcEhZcwAAAEgAAABIAEbJaz4AAADaSURBVDjLY2AYAoCRSMDARCRgYCYSMLAQCRhYiQQMbOiAnYOTi5sdQ5iBBw3w8vELCAoJ86KLM4igAlExcQlJKWkZMVE0CQZZFCAnr6CopKyiqKggL4cqw6CKAtTUNTS1tHV0dfXU1VBlGPRRgIGhopGxiamZuaKhAaoMgwUKsLRSVLS2sbWzd3C0RJVBj3onPU1nF1c3dw9PAmnEy9vH188/IDDIi1BqCg4JDQuPiAwmmMyiomNi4+Kjowgns4TEpOTEhMGdzHAAjGSGC6AnM5wALZnhBtRXCAA5O0ad99aTXAAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDoyNyswMjowMB60MsYAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MjcrMDI6MDBv6Yp6AAAAAElFTkSuQmCC"), + "ua" to CountryFlag("Ukraine", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABtQTFRFJoz/J43+Ior/NZTu8Pcc//8H/v4M//8L////WTbNKwAAAAFiS0dECIbelXoAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAoSURBVCjPY2AYwUAQC2BQwgIYjLEABhcsgCEUC2BIwwIYyrGAESIIAFnli3Xgo9d8AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjU2KzAyOjAwsgYwawAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo1NiswMjowMMNbiNcAAAAASUVORK5CYII="), + "ae" to CountryFlag("United Arab Emirates", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAFFQTFRFDqIQEKAQ1M+1zu3QzuzO/wAA4BMAH4cAAJsAAJoA4hMCLY0O+RwZ/x8f/+Dg/////Bwc6szM6Onp6Ojo5QUFQSIiJigoJycn4AAAHwAAAAAA/OpXXAAAAAV0Uk5T/v7+/v48tsTrAAAAAWJLR0QPGLoA2QAAAAlwSFlzAAAASAAAAEgARslrPgAAAElJREFUOMtjYEUBbOwcnNgBw6hCWijk4mZgxA7QFPIwMbNgB2gKefn4cYBRhaQoFBAUEsYO0BSKiIqJYwdoCiUkpXCAUYXUUQgAR6I4y2fbQp8AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MTArMDI6MDC6XmCVAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjEwKzAyOjAwywPYKQAAAABJRU5ErkJggg=="), + "gb" to CountryFlag("United Kingdom", "data:image/png;base64,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"), + "us" to CountryFlag("United States", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAj1QTFRF4bm96r/B6b/B3a6y5bO15bK1wltjyF1j8unr+vDx+vDwyHB2z3J31ZSZ3JicGS9dJTplITdjGjBdKDxnHjNhGzFfKT1oHzZjQjJXtzxFvT1EGjBedYKdXWyNFStaIDVih5OrRFV7FCpZLkJsjpmvdYKeGC5cWmyNQDFWuD5Hvj9GM0dwRlh9NEdwOEtzLEBqTF2BLUFrOUx0M0dvPVB2KT9pTFJ1HDJfeIWgFy1bJjpmhI+oNklxFi1bS12BY3KRFixbUmOF9/f5////aHaUVGSGIjdjPlF3Gi9dfYqkU2SGaHeVUGKFSk5ySlt/PlB3MkZvMUVuKz9qV2eJKz9pO093QDFVtjpCvDpBFSxbgo6nUWKEEilYJjtmj5qwOUxzEihYFCtaa3mXFCxbRDpfRFZ7KDxoJzxnXW2NKT5pYXCQQFJ5UF6BTl+DHjNgcH6aO051HjRhYnGQS1yAUGCD9fT1/vv8/vv7Fy1cfYmjT1+DiZSsZ3aUFS1cRkBkO011M0ZvMERtQVN5QlR6LEBrQ1V7Ok10N0pyL0VvQTBVtTc/uzc+coCcW2qLhJCpLkJri5atc4CcWGmLR0drHzRhITZiaXiWRVd8c4GdIDZiWGiKJTpmPE92YG+PL0NtKj5pJztnIDZjTlh76c/S8dbX8dXXdoOfXm2NiZWsEylZL0JskJuxd4SfFy5cW22OQDNXukZOwUZNwEZNJDllPVB3P1F4MkdwSzxfu0ZOzdLczNHbzdHbzNDb1tPb8NXXWNrergAAAA90Uk5T/v7+/v7+/v7+/v7+/v7+6a2FXwAAAAFiS0dEQ2fQDWIAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAITSURBVDjLY+AXEOQXEhbhFxUT5RcRFuIXFODnFxCXkJRCAwzSMrJy8gqKSsoqykqKCvJysqpqaqrqGppaaICBX1tZR1dP38DQyNBAX09XR9nYxMTY1IyBkQkVMPDzm1sYWFpZ29jaWFtZ2lmYq9nbqzk4OjmjAQZpF1dpNwt3D0NPQw93CzdpL29zc28fX2YWVlTAwO/nryzmFRAYFBwUGOAlpuzvFxLiFxoWHoEGGPgjpaOiY2Lj4hPi42JjoqOkE5OS5JJT2NjRAIOQY2paeoZNpn6WfqZNRnpaqmNsrGN2DgcnFypg4M/KzXPLLyjUV9UvLMh3y8stKiwsKi4pLStHBQz8FaKVVYmx1XpKetWxiVWVog41Nba1ddw8aICBv77Bv7HJsLmltaXZsKnRv6Gtvb2to7OrGw0w8Pf0ysn3NSf2T+hPbO6Tl+udqKY2cdJkXj40wMA/Zeq06XnpM7TztGek502fNjNv1qxCaSwBzp8+e9YcMeG58+bPmyssNmfW7AXFxQsWLlq8ZCkqYOBftlxJfkXqylWrV61MXSGvtHzN2rVr1q3fsHETKmAQMNLdHLtFefP8rfM3K2+J3axrJCBgtG37DgyFO3ft2rlz1+6dO/fs3LkbxATjvfuWolvtTCRg4CMSMHQTCRh4iAQM5UQCBi4iAQM7kYAhgkjAwEokID7AmYgEDFpEAgYpIgEA2hc6qEvsr/QAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MTUrMDI6MDDoZk8yAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjE1KzAyOjAwmTv3jgAAAABJRU5ErkJggg=="), + "um" to CountryFlag("United States Minor Outlying Islands", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAj1QTFRF4bm96r/B6b/B3a6y5bO15bK1wltjyF1j8unr+vDx+vDwyHB2z3J31ZSZ3JicGS9dJTplITdjGjBdKDxnHjNhGzFfKT1oHzZjQjJXtzxFvT1EGjBedYKdXWyNFStaIDVih5OrRFV7FCpZLkJsjpmvdYKeGC5cWmyNQDFWuD5Hvj9GM0dwRlh9NEdwOEtzLEBqTF2BLUFrOUx0M0dvPVB2KT9pTFJ1HDJfeIWgFy1bJjpmhI+oNklxFi1bS12BY3KRFixbUmOF9/f5////aHaUVGSGIjdjPlF3Gi9dfYqkU2SGaHeVUGKFSk5ySlt/PlB3MkZvMUVuKz9qV2eJKz9pO093QDFVtjpCvDpBFSxbgo6nUWKEEilYJjtmj5qwOUxzEihYFCtaa3mXFCxbRDpfRFZ7KDxoJzxnXW2NKT5pYXCQQFJ5UF6BTl+DHjNgcH6aO051HjRhYnGQS1yAUGCD9fT1/vv8/vv7Fy1cfYmjT1+DiZSsZ3aUFS1cRkBkO011M0ZvMERtQVN5QlR6LEBrQ1V7Ok10N0pyL0VvQTBVtTc/uzc+coCcW2qLhJCpLkJri5atc4CcWGmLR0drHzRhITZiaXiWRVd8c4GdIDZiWGiKJTpmPE92YG+PL0NtKj5pJztnIDZjTlh76c/S8dbX8dXXdoOfXm2NiZWsEylZL0JskJuxd4SfFy5cW22OQDNXukZOwUZNwEZNJDllPVB3P1F4MkdwSzxfu0ZOzdLczNHbzdHbzNDb1tPb8NXXWNrergAAAA90Uk5T/v7+/v7+/v7+/v7+/v7+6a2FXwAAAAFiS0dEQ2fQDWIAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAITSURBVDjLY+AXEOQXEhbhFxUT5RcRFuIXFODnFxCXkJRCAwzSMrJy8gqKSsoqykqKCvJysqpqaqrqGppaaICBX1tZR1dP38DQyNBAX09XR9nYxMTY1IyBkQkVMPDzm1sYWFpZ29jaWFtZ2lmYq9nbqzk4OjmjAQZpF1dpNwt3D0NPQw93CzdpL29zc28fX2YWVlTAwO/nryzmFRAYFBwUGOAlpuzvFxLiFxoWHoEGGPgjpaOiY2Lj4hPi42JjoqOkE5OS5JJT2NjRAIOQY2paeoZNpn6WfqZNRnpaqmNsrGN2DgcnFypg4M/KzXPLLyjUV9UvLMh3y8stKiwsKi4pLStHBQz8FaKVVYmx1XpKetWxiVWVog41Nba1ddw8aICBv77Bv7HJsLmltaXZsKnRv6Gtvb2to7OrGw0w8Pf0ysn3NSf2T+hPbO6Tl+udqKY2cdJkXj40wMA/Zeq06XnpM7TztGek502fNjNv1qxCaSwBzp8+e9YcMeG58+bPmyssNmfW7AXFxQsWLlq8ZCkqYOBftlxJfkXqylWrV61MXSGvtHzN2rVr1q3fsHETKmAQMNLdHLtFefP8rfM3K2+J3axrJCBgtG37DgyFO3ft2rlz1+6dO/fs3LkbxATjvfuWolvtTCRg4CMSMHQTCRh4iAQM5UQCBi4iAQM7kYAhgkjAwEokID7AmYgEDFpEAgYpIgEA2hc6qEvsr/QAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTU6MDIrMDI6MDDha3EiAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE1OjAyKzAyOjAwkDbJngAAAABJRU5ErkJggg=="), + "vi" to CountryFlag("United States Virgin Islands", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAIAAADRv8uKAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAAB65JREFUSMetlHtwFeUZxt/3+3b33HJuuZ1cTk4SKuGSIHeIEgRLoA4zglFA5Fodp8gISJV2BlJn7FRtEaqVMNCpHQhTdGqKigEtnVowBQUJNJAi94QEcr+c+9lzds9+39c/EtCOnbGEPLN/7c7ub5/vfd4Heyrm255aaSxcuvOdU9t+8V4w2E2IAwUhKSlnqufDE+WWrPTWtz+a++R+mQqDJQRYvcUFz49LPtL5eeFYX/fS50fN2QOGjkiEgP9f5Ld05qWaT6V1K7aMj1xq3rblN2sdThsTYQAGgAOfQkSAZJKT7NGjKh/Lqi08vSH9xoSq19XXf7/9/SYwEoj0rqgAIG09cO4th3fJWLrspe0lnt+9tv65F85Xvvn2sT++e4YlNQqACIaecLjtG2fYFvGv8pxWZcWay7kTt77xWU31mwAJgCxxt1gAfGbDhwlVi3B5RLFvVTFk/fOjlOnTHQsW9ugADQ1tpZNkp93TcEVvbU0/+amY+6hlytT6pvDuHUe7OwOZ2e5ISP1gX93dUgEAg5vWIyIlEI9pKpqozZrs9xsJLcVtT3R29f3lAEpy5vKl1Jaiy2ZKCQv4AcDptkmyZCK8sZtP26PftV8APAYAAAKAAsgAfOAugAEgAZgAACABwAEowACAACQBDEAziOvg+jEsGQJYmvhKJSFIKYnFtGhYVcwmdLuNSMwqiXhHV/eevSjLI9aukZyOaCAqKZKcnq5HVSvXTFaTWUKlMwlV/iEctfTszXGqqof80eKJBZteKS9Mk9XDtXD2VGv5MrfCyJ69is3C1/5Mz/UW2knw3T/FGi+0lC7c28iaG2+6FK4ldAGnEYEQ/L6ECUAUHAaSSC82xDtvBJ9cPXvj6gnZRw8Ef/nyv+uvv3ol/cWdZxaVptEP3jO7HFfGzX6gbHs8ok1ZPCfbTug7b2Weq7sVxdovu66ca0RUhOBCMCGEEPw717fFATgAAQDcveerVcsnWY8fjuzb3xC27GMlNQ3xaHurbHee3bdAenyOJSutacfH5UuqAVSXO2Pd5ooNzz2YcaFO21fdEqW7wkU7DrXked1FJa6okZQ4UuADQUlQSgSXOTMkpEyA4Caz3HxRbW3pR5SkCl+i8UeP+tH6Ycr0P59VYx1XCQoCshCkqy8GYDFza29/DIDIkjMUir36891Vrx1YX7l4ZeVu8yc1c/d/vAPSCkc7AtOORq/36JmKn0kK4VyI4lBf0GK9pljSArrqJj068aVa8xJzWlsACSDA47JkIY4Czd+FwAgxcTE4BpNCQdcBQciKrjMAQERKCWO6EDFZdijpHkONaqHAjIcLrhXVlrdfHV8ujt6wfNbvZCgfLJxysv7QVkfG6nj/yNnGP5qVr43cgksLTtd1EUIJ0Kwkt+v+TkokQBPj4k4NabqhgaQJSdeNwXgIYRgMQJIkV9IQsc62ZDQCQAkAM8l1GalMpy16CpPNwDWj4H4sngmEf+lxWYXoSFo0SaG3k0aQGcg5oPRt5OCOIyIIBIGI/5VOIQyDIyCigkABgCFYkmzardiJcIoAAkl1et7EB+cte3Z91Wirp6Q1eDTojDNiQsZuE4gAEAD/cxOEgO95evtXqRARStqLpHWFvQXmJKjxJePKFMWWL/iMvKKm+2D9iH6voumc4GAJgTSE3f+uDAQHY9JlqFRyzgfI+Oy8ySZHMBpqCfUWganhMt2o5FyJ0FTXN2dKhgVMQISReEfp20rbV2Ybk+y5h/w3C3z5qQC1PU3FE7Q/TGubZQ8Y/JuRDY9jIUCWRE3U01hjzkz9QQjb546cQAmcbDz+Re81NZ72U8M4E7aluuGO5eFxDEIQFIBo0+QVBfUPeevvT/dCwqD2dJAskz3hzZP6K9J7CON30jI8YEbRqrK8bvWi1/zXhONGxJ2fN9ogonTKD32pWUdClpqrjsOBNIMSHN4ZcwBkYlVuX9WUjqsd+PdeX4bLFY1FnTb7WGfurGRfSbZRmhJW+GCbDgtYAKAZWMCMtcJ96pa5CeyaCLX1ddgdDpfdUTqh7JjdKmusSbPpICRkA2/dKxiRAGgdnSnFiZyijv6AbPFKGkEqS2ZKKMj04dziqe38i7DLYIFCU74azgTQEMk9pRoRGdNsDu+GJa1x2+x2b2By+skLN3PMpkyt68LhYO8ol/Xg+bqeEsu6nBa3PmvmiHlS7qUNv8qNBLsR4CdDpYIQzOlOfXld70uLq9s6c/ae2nyw+9Y57RDXox4iepkyQhFtajBh8ZSlVjxdMm2+b1NWWtPOT9Zs2WqnAJOHBqYUhMDH5ttefGJ/JEI6OvxOOP6AZ1IOViRNynXVL0D4ubXYM3d55lNPj4n3X9tSmNneH3GO8X7dmyi9R8fc5bKtXQWtXfZl805Mz//82Bkw2cZwy+Iei/z+v/62qGRqkWRQ/Uhvz7WS++DY5VkNzeW5GeFd1Wzo4NviiIoQydFjfC88E5haeLDzVnO+Bzp60EjCI2XiyEkcWSiCuq+xbeGvd6U1N7UjKkJo9wpGhIHOYkyncupDMzLKJncW+y66rDfVRNxhVYJq9qlLY+ov5NWdCAAPUKIACC7IvTseFCEIwuCCITrMNrsnA60WEQrz3n6hx+MAYYIEUOK3S/M/RDXGpn3SjzAAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NTIrMDI6MDBGSRR4AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjUyKzAyOjAwNxSsxAAAAABJRU5ErkJggg=="), + "uy" to CountryFlag("Uruguay", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAiVQTFRF/////v35///+/v36/v789uis/Pfj9vDN+vXg/v76+Oy8/Pnr/Prx//7+9+mi+Oup8+iP9+y2+vLI9eOH/Pru//790NjrcYjDb4bC/v378uip9+24+O+u9+uJ8uVT8t1l+OuA+O+y9Oyk9Ou+q7jbAyiSACWR+fDN+e6++fTM8eFS8ddH9ehe8eQd8dUs9e1k8uZM8d1o/Pnt/Pnp/fnsAyiTACaRACaS+/Xd9uaY9+iJ9e5+8eAR8eES9fQH9O8M8ekP8NMc9uh7+OuP9eOK+O/IvsjjOlmrOFir/Pjo9ueR9OJW8ugj+f0A+v8A9/YC8ugv9e5o9++j+vTR/v34+/v98vT69OzE8eOB8N5H8NkV8+kH+f4B8eEJ79gc8N5U8eSQ9vHU/fvx+fHB9u2W9e9g8uUk+PoA9vgC8ug09uli9+6m/fvz+Pn86u32/v779umx9uWN+O2a9OJr8NUP8uwY9OwJ9PIO8NsV8eMc9vGR9+uH9+mb/PjmucThLE6mKkyl/fru/vz2+vXd8NxR8+ti9vBk8NQc8uw49u5l8NlN8eRn+vbX+fHF+/biAymTACeS8uiu9/G6+O+f9++K8dtR9Ox++PCF+fTB9uy49Oy//fz2+/bb9uaE/Pjj8+aY9/C3+O2d+O+w/fv11t3ug5fLgpbK+/fh+fLO9/HU+vfl+/ff+O++///9oK/XACmTACiSFz2d2N7u+fr9SmeyWnW5/v7/+P+5hQAAAAFiS0dEAIgFHUgAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFASURBVDjLldRFV0MxEAXg4bV4ixd3SnGH4u4W3N2d4u7u7u7u9vt4hW0K02+Xk7u5czIBkI8Cw+FichxFJWUVVTX1/2I8voamlraOrh5PAKBvYEgjDRoZm5iamVtYWlnbsCehrYiGvbGzd3B0cnZxdXP38PTyBqGP2JeCDfr5BwQGBYeEhoVHREZFQ0xsHA0b5MYnJCYlE5KSmpaekQlZ2VRslZzcvPwCQkhhUXFJaRkju3R5RWVVdQ0htXX1DY0ATc1UAJKW1rb2js6u7p7evv6BQRgaHqEBYEbHxicmp6ZnZufmFxaXQLi8QvMzx9W19Y3Nre2d3T3pHGWOByT7B4dHxyenZ3DOB7i4vKL57XN9A7d39w+o9yN4BObPwBMSPCPBCxK8IsEbEn6t3pHgAwnESCBCgk8k+EKS8+tB+Ab8+Iwkca/RVwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo1NCswMjowMCWZIUIAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NTQrMDI6MDBUxJn+AAAAAElFTkSuQmCC"), + "uz" to CountryFlag("Uzbekistan", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAYxQTFRFlKzUjafRo7jaw9DnxNHnqLvckqrTkKnSj6jSkqvTkanTkarTlazUyNXp////8fT5zNjrucnjnLLXk6vTnbPYqbzcqr3dmrHXpLjaorfalq3Vv83l2+PxiqTQjqjSlq7Vs8Tg1+Hv2uPwqb3dxtPow9Hnla3Vla3U8PP5/P3+mrHWl67Vk6vUjqfRn7XY5ev1mbDWztrsydbqprrbusnjm7HX+/z+7vL4mK/Wwc/mmK/VpbnbvMzkvczlsMLfscPg3OTxscLgiKPPk6zUnLPXlavSkajQo7XX9/j6/Pz9usfgma7TkafQ19/stsXfk6nQ4+jxoLPWr7/c3OPu3+XvqLrZxdDlytTnjaXOlqvSlKrRk7bllLflj7Pjnr/q1er96/v/z+X8qcjukrbknL7ol7rmk7bknr/plLjllrnmnb7onb7plbjmmbvnmrznk7flmniCm3mCl3aBknJ+lnWAmXeBmHaBmXiBmHeB5aiR5KiR5amR5qmS/vz7/f38vnhNB5UAAK4DAagAAKkAcIAQIwAAAAFiS0dEDm+9ME8AAAAJcEhZcwAAAEgAAABIAEbJaz4AAAElSURBVDjLY2BgYGBkYmZhZQADNnYGDk4ubgZsgIedl49fQFBIGMjmFBHlFBOXkGTDok6KUZpPhltWDsSW51BQ5FBSVlFlVMOiUl1DU4tdWx3I0tHV4ZZjkGNjZ8dmM7cenz47yAB1HQNDAzFeDiNjQRMOdUyFbKZm5mwgcU42C0sraxt2W0k7e3YsCtU5HPgcnRicdVwsdLR5eOQZtBnUpLBZ7erm7uHp5e3t4+vnHxAYFOwTEhoWHhEZhQ4YomNi4+ITEpOSU1LT0jMys5Kzc3LzkvMxAENBQWFRcUlpWUFZaUFRAYgur6gowAQMlZVV1TXVlZWV1VAEYmMBDHxEAoZaIgHxJg4FhXVEAuJNrCcSMDQQCRgaiQQMTUQChmYiwbBSCACCMlF7L3AvtgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDoyNyswMjowMB60MsYAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MjcrMDI6MDBv6Yp6AAAAAElFTkSuQmCC"), + "vu" to CountryFlag("Vanuatu", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAApFQTFRFQgQAFTcUMYYzogAA0AAAzwAAzgAAiosAPyQAdQAAwwAA0QAA+/sA1dcAYV4ARQoAnQAAYmIAz88A+PgApacAQS4AZwEAvAAAAAAAHBwAiIgA7u4A4eMAb28AQA8AkgAAzAAAAwMAPT0At7cAtbgARzoAWwIAtQAADg4AaGgA3d0A6usAf4AAPBYAhQAAyQAAJiYAmJgA8vIAxMcAUEkAUQQArAAABQUASkoAxcUA7/AAj5IAPB8AeAAAxAAAFBQAeHgA5eUA0tQAXFkASAgAoQAAAQEAMDAAqakAoKMAPyoAbAAAvwAAIiIAVlYAZGQAS0sAEhIACQkAWVkA0dEA3N0AamkAQQ0AlgAAzQAAjIwAVVUAQkIAh4cAICAAiYkA5+cAsLMARTYAYAEAtgAAywAACwsAjY0ANDQAVFQADAwARUUAe3sAuLgA4eIAenoAOBMAQAAAQQAAUlIArKwAkJAADw8ADQ0A4+MAyMoAoKQAoaQAFRUAGBgAIyMAUFAAMzMAaWkA5OQAycgAoqAAo6EAY2MAjo4ANzcAUVEAfX0AX18APj4AubkA4eEAeXkAHzIMFDYUQUEAf38AmpoAi4sAHR0AiooAsrAAOkIFHU8eOJc5P6g/Hh4AMTEAWloA0tIA3NsAaWoBHDgRLXwwQKlAQKtAQKpAqqoAoaAAMDsHIFkjO548QaxB09IAWVsCGz0VMIUzBgYAxsYA7+8AkI8AKDcJI2MnPaI9mZkAxsQAS08DG0QZNI426+oAf34AITYMJ24rPqY/trUAPkUEHEwdN5U54uEAbm4BHTcQK3guP6lAQatB0NAApqQAMz0GH1UhOps71tUAXmABGzsTL4IyiokALDoJImAlPKE9////Sn83tQAAAAN0Uk5T/v7+lRaJLAAAAAFiS0dE2u4DJoIAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAGuSURBVDjLY2BgZmFlIwIwsHNwcnETo5CHl49fgI2woQyCQsIiomLiBA1lkJCUkpaRlZNXYCGkUEJRSVlYRVVNnZuVgEIJCQ1NLW0dXT19FkIKJSQMDI2MTUzN8IQUVKGEuYWllbWNrR03IYUSEvYOjk7OLq6srIQUSri5e0h7enn7cONW6OvnHxAIpIOCQ0LDwiMiWXAoVIqKjvGPjQNpkYxPSExKTlFIxQBAhWnpBhmZWdk5biCVikq5efkFhUUYAKgwLkqxuEQjsLQM4tRyzYrKqmoMAFRYY1hbVy/ZkB4EVdjY1NzSigFAbmxrV+ro7OoGK1Ps6e3rnzARE4AUmk+aPGWqbBZI3bTpCTNmzpo9BxNAwnGu3zxzUPDMX7Bw0eIlS5ctxwTIAT5vhfTKVavXrF2+HK/Cmn7Hdes3bFy2bDlehZsCNm/Zum37DuzGIRQa7DTatXvP3rXLluNVqNGotW//gYOHcBoHUQjKCoePHD2GTxlI4bR46eMnTp46fWY5foVtZ4XPnb9wEb9xIIU8ly5fubp8GSF1yxmuXb9xk6BxIIWMTGsJGwcEAK2Qk7NAptKcAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE0OjQwKzAyOjAwHXwFzwAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNDo0MCswMjowMGwhvXMAAAAASUVORK5CYII="), + "va" to CountryFlag("Vatican City", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAnlQTFRF/+AA/+AB/98A/+IR//3u///////++vfC/v75/v7//Pvx/v7+///9//7+/fzz+/nm/PjD+/ne/Pvw+fjg9/Go+PCI9/GZ+PTG//3t/fzv/v789fTu+fr++fbS9++p9+2M9++f9/K8/P3/9/by/v79+/v5/Pz7//zs9vLB3dmn6unf8fH59PPW/f7G/f+j/f+6+PbH8fH16+vn5uTG4N6++Pj4//zt8/Pyt7au2da8+fv67ufS4Z5d3IVC4ZRL7dqu9vr/8O/k6Nw39e6D3t7ivLy6xsbLv72v1dO29PH168S44K2s4rev9Ozz6urN59tF8Odu9ulB9etm+/ng///vzs/TsrKxz8/P1dTN0M662Ne36O7Q/P/97/bY7eqb49+t6eOG9OyA8udR8eQt/PnS4ODfubm45eXg8/Pz9vbyxcbU18XK9+dh9O+h9vf/8PH+7eNY9OlQ/Pzz/v//7+/x9fb+9vb7+fn/+frKrlocyKaG9/3/9/f8+vjb/v3q+Pn9/Pzy+PS/9/Xd9fCk+Okqv2dBtZKjx8zG8e/k5+fn7/D1///0/v73/vzs4+G/6uBY7+dy7uNl5d5L3reUxHV+15ydy8GjwcGryMfKxMTHzsue/fzp//3r8Ohw9vK86txm58mqz5Ka7MrJvqyu5+vuwsLH7Ozv7OR79/K09OHf3sNL/f/ny4eO9+jozdHJzrCt+/HxxMTC7e3s4eDZ3ddw7d5hz5EtyLF77+r0yHx568/W6NiUs4Rrsn6Ew8jG2tSJ//71/f3+/Pz6/Prg8+Pa687U7tTTvmlp4ba28NbX9ufn9PX19/f3///6vXBw7djY/v39+fPz/Pn5CdrmUAAAAAFiS0dEBfhv6ccAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAFWSURBVDjLY2BAB4xMzCysbKzogGGEKGRjZecgzkROLm6CCnlYeVn5+AUEheCOwGUiGxursIiomDiYhVOhBKuklLSMrJy8gqKSsoqqGk6F6qwamlraOrp6+gaGRsYmpjgVmrGaW1haWdvY2tk7ODo5g92J3Y0urm7uHp5e3j6+fv4BgUHBQKVYFYaEhoVHREZFx8TGxSckJiWnAEMBh2dS09IzMrOyc3Lz8gsKi0B2Y1dYzFZSWlZeUVlVnVFTWwc0D2c41jc0NjW3tLa1d3R2dffg9HUva1//hImTJk+ZOm36jJmzZuO0eg7r3HmsrPMXLFy0eAkr69JlrNw4FS5fwbpy1eo1a9et38C6cRNOhb2sm7ds3bZ9x85du/fs3bf/AJ5EcfDQ4SNHjx0/cfLU6TNn2fAlM6AkL+u586zcBBMum8qFCxcv8XJzE5HCic9cvIMjXwMAtnNhztqhnUkAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6NDgrMDI6MDAuk0uoAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjQ4KzAyOjAwX87zFAAAAABJRU5ErkJggg=="), + "ve" to CountryFlag("Venezuela", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAANVQTFRF/8sA/80A4LMWHxikHhijHRejHxijAAC7AgK8EBDAAAC8AQG8LS7IMTHJDw/AAwO8AAC6OzvKoKDlIyPEAgK7hobejo7gBAS7Hh7Cnp7lQkLMBga8EhK/JyfFcHDYFhbAHR3CHx/Cbm7YLCzGAAC5ERG/Bwe8UVHQFxfAAQG6ExO/mprkWVnSMjLHY2PVDAy9CQm8YGDUNzfJGRnBBQW7MTHHr6/pMzPILS3GODjJGBjCW1zUGRnCFRbBWlzUGxzDGgCkGAGjGwCkwQAW3gAA3AAA////C5QEIwAAAAFiS0dERhe6+e0AAAAJcEhZcwAAAEgAAABIAEbJaz4AAACvSURBVDjLY2AYBVQBjEQCBiYiAQMzGmBhZmZlZQNRqICBHRVwcHJx8/BysPPxo0kwCKACQSFhEVExcQlJKTQJFIXSMgKycvICCooCMkrKKqpqOBWqS2oIaGqCWEBSS1sHl0IVXT19BM/A0EgFu0JxYxNNZDM0xY3FsSlUMTUzRzZCQMXCzBIhgBQ8VtY2qCFia2ePFDwOCODogAqckAUYnIkEDC5EAgZXIsGoQrwAAMoOjbEqrfOHAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEzLTEwLTA3VDEzOjE1OjE3KzAyOjAwf/leGwAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMy0xMC0wN1QxMzoxNToxNyswMjowMA6k5qcAAAAASUVORK5CYII="), + "vn" to CountryFlag("Vietnam", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAPZQTFRF7AAV7AEV7AkV7RQU7AIV6wAW8DoQ9YAL7AMV7AQV6gAX9XoL/N4D+rsG//8A7ywS7h4T/vAB9XcL7AYU7AAW818O+8QF6wEW7AUV7yYS7hoT7iES7RQT+bIG//4A/vgB8UAQ7h0T7yUS7yMS7h4S8DAR7hkT9X0L//kA/vQB//oA//0A//wA//sA7hwT8lMO95YJ7iET+8kE/vYB810N6wAX95UJ/NsD7y4R7zkR+KoI7QYU9oYK/uwC+8oE/NQE+KEI8k8P7ygS//kB+bMG81wN95gJ9G8M9XYL/NUD/eYC7AcV+KMI+J8I8UYP6wUW7RIT////RWZ05wAAAAFiS0dEUZRpfCoAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAD7SURBVDjL3ZFZN8RAFIQTuUW6USaW0QYJYxsi9tjGMmPf+f+/Rseb43TLo6Ne+j5859atriD4WwrrcnXBgajWTsHgEOIaoNLDI6hjLBjlGMSfQkTioJFwHBN2FOelwCSUniKbmIaVizMzrVZjdm6eabaw2F5aXll1pV9jZ72zkZNpvllkbG45wBDbCXOmZIVyx8B1ZIzdPUtWHPcPytgdXcEcVhtzHh2XylePwYl1LQqe6q6/FpwxS1nw/Ne+L8jLniX73r4FV9e8ifRtwjsvqMp7PkBM2X58evZ5h8FLXyuxp6rXN+/KboSvX5Hg/cOfJoy/vx7zn9P/0ydsjBUrBoCy/wAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo0MSswMjowMLsLDnsAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NDErMDI6MDDKVrbHAAAAAElFTkSuQmCC"), + "wf" to CountryFlag("Wallis and Futuna", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAACFQTFRFACZ/AymBABl3qbbU////+/z9//z8+7G58gok8xsz8xgwxtlaVAAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAeSURBVCjPY2AAAUZlVxcgSKmYtQoEGEYFRwVpKQgAg3q7n/McyNsAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MjcrMDI6MDAetDLGAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjI3KzAyOjAwb+mKegAAAABJRU5ErkJggg=="), + "eh" to CountryFlag("Western Sahara", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAiJQTFRFAwAAAQAAAAAAqgAAGAAABAAA/wAA5gAAQgAAAgAA+wAA/gAAgQAA/QAAvwAAHAAA7AAATgAA/AAAjwAAygAAJQAAAgEBAgIC8wAAWwAA/wEBmgAAHRsbHysrHxoaHx8fHxsbHx0cHyAg/AIC+iUl+cvL+f//+fb2+ff3+fn5+fj4+fb3/AEB/wgI/5iY//////39//7+///+/52l/yw1/1lb/+Li/gIC/gMD/lVV/u/v/v///vr6/v7+/vz8/nFz/kVE/vLx/vPy/vPx/wQE/yEh/8bG//z8/8jJ/w4P/+Di/7Su/6Ob//v7/wMD/3x8//r6/4mJ/zxC/+/u/4h8/zoo/zIh/35w/+nm/wIC/21t/4yM/zo//9HO/xII/wUA/725/xgY/7m5/8/Q/wgJ/9fY/8nD/4t+/5KH/7my//38/0hI/+jo/4KC/zU1/+bm//Tz//Hw/AIB/QMC/YiH/f///f39/fv6/f79/fz8/bOz/T5E/VJY/d7e/fr4/f7+/gEA/AMB/yYr/8vQ/QEA/AEA/wABqSgAR5EyTapPTJc7TJw/TJxATJk9TJk8+wIA9wQAb0oAAoMAA3cABHAABHQA1BYANmcAAIQAE3kAE3sCE30DE3wDnjIAEHsABoAAFXkA8AgAX1IAD3wAxx0AKm4AAIMAFHkAEXoA/AIAjToACX8ACH8A6AwAUFoAAIUAEXsAE3oAsigAI3EAAYMACn4Az0nTXQAAAAFiS0dELyPUIBEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAG7SURBVDjLY2BgZGAiBjAwszCxMhKjkI2dg4mVkwiFXNxsPIxEWM/AxsvFxsdP2HoGNjZuLjYBQSYGToIK2diEeNmEWZlYCSsEWS8iysQqJo4bQBSysXGxSUgyMRI0EWy9lLSMrJw8DCgoKinJIwG4QjZuZTYVVTV1DU0Q0NJSU9NW19TShAOEQjY2HTZdPX0DQ30gMNI3NjE10zfQhwNkhWzmFtyWVtY2trZ21vbcDo7WTs62cICikE3Khc3VTd/AXd+DzdNLX9/bR98Xq4lA4Ccl5a8foB/IFqQfHBIaFh6hb4hDYSRbFNCYaLYYff3YuPgEuDMxrE5M0jcw0E9mS0nVT0vPyNTPwqYw0o8tO0ff1xBoTC5bXn5BgGEhVl8X8RaXlJaVVwBBZWlVdU1taV19BQwgFDY0sjU1I4ccKoArbGlta+/o7OrugYLePjgTDGAK+9kmTJw0ecpUnACisKGfbdr0GTNnzZ4zGxcAK2xtYZs7b/6CefgAKCv0sy1cNGPxzHkEFLb0sy1Zumz5inkEFK5sYFu1es3yeYQAA9vades3bCSobh7Dps1blm8grG4ew5qthK0FAQAMqy9yC7XdrgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo1OCswMjowMOI5SzYAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NTgrMDI6MDCTZPOKAAAAAElFTkSuQmCC"), + "ye" to CountryFlag("Yemen", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeBAMAAACs80HuAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAABhQTFRF8QYA8QgC8AAA9DQv////Ly8vAAAAAgICaSnPYAAAAAFiS0dEBI9o2VEAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAAsSURBVCjPY2AYfEAQC2BQwgIYjLEABhcsYGgLhmIBDGlYAEM5FoBd5YAKAgC024zJhQVl1gAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNTowOSswMjowMONsJdgAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MDkrMDI6MDCSMZ1kAAAAAElFTkSuQmCC"), + "zm" to CountryFlag("Zambia", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAelQTFRFGYoAGooAGYsAFYwAHIoAG4kAG4sAG4oAHIkAGIwAGIsAGYcAK4AAFYkADosAD4wAF4sAFIsAEocAEIwADY0AG4MAG4cAEY4ARmwAuV8AonMAemwATX4AGogAPoEArGwAM3YADI0AIYcARH8AXHQAfnIAp2IATG8AFosAKYEAg2kA12QA4moAuVwAtGoAzHMA73sAl20Al28Ar2cAvF8A0GQA7GsAxGMAL3sAFY0ADYoAT3EAo2kAwmMAyl4A0GYA6XoA3W0AvV0At14AxGAAyGwAnXAAQXwAEYwAGokAEI0AFIYAPnsAX28AlGoAxGkAx24AvmAAplMAbGgAKIAAEowAGosAEY0ADo0AEIkAkGYAZ2gANnwAEIoAHogAJYAAiGYAf2EAKHsADY4AH4kAHYkAEI8AD48AFZAAHJAAG5IAGY4ADooAD4sAQnQDSHEERnIERnEESnIEKm0CD2gAE2sAFGoAEGcAI3EATogAS4cAIIYBzygP6hoR4x0Q4RwQ9R8SZg0HAAAABAAAAwIARiQA/4MA9HsA9n0AyCwO4h4Q3CEQ2SAQ7SMRYxAHBAIAAwMARCUA+YMA63wA7X0A7n0AySsO3SEQ2iAQ7iIRYw8HBAEARCQA+4MA7HwA730A2h8Q7XwA////hemiEQAAAAFiS0dEorDd34wAAAAJcEhZcwAAAEgAAABIAEbJaz4AAAEHSURBVDjLY2DABRgZiANMzIwsrAyMbEAd7BzsnFw41XHz8PLxCwgKsbMLCIvwiYrhUMcqLiEpJS0jKyevoKikrKKqpo7LgRqaWto6unr6BoZGxiamZuYWOL1iaWVtY2tn7+Do5Ozi6ubugdMznuxe3j6+fv4BgUHBIVah7Hj8zRoWHhEZHBUdE2sJ9D9uZUAQxxifkJiUnJLKzo7bxLR0IMjITOHMys7J5ePjw2lgXn5BYVFxSWlZeUVlFRDg8LNAdU1tXX1DY1NzS1NrW3tHRwdOhZ1d3T29fU39E5omTpo8ZepUnAqn1U2fMXNW0+yWpjlz582fPx+fwgWjCkcVUq5wISkmAgDy89vmc0Ci5gAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo1MCswMjowMNHWBVEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NTArMDI6MDCgi73tAAAAAElFTkSuQmCC"), + "zw" to CountryFlag("Zimbabwe", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAuhQTFRFnKICwcEDvr4DrXMC8YUH8oUHrxkMsBkNDAMDCwEADAIBrnMCwsEDv74DoKCgIychFkgBL40HMpQIMZII/v7+xMTEPkE9ETcCKoAG////5eXma2prEicKImoEMZMI+Pj4nJucIioeGE4BMo0HNpUINJMIyMfIQENBKTwC5+fob25vPzQLu5gA/tQA/9QA/9MA9/DwnZyeNDAgiG8A88kA/9IA+vr3/f388Kyo+uTjyszNSEdEWUkC2rQA/9YA/9UA8OzN2sxJ6OCJ+Ovo4FdP8rm16enqcHFzOjIM+Pj23dJz6NEC8NwN4q5v1yoj6IN9+fn6oaKkMiMkcgwF0x0P4B8Q3h4Q9fXp6dpJ9N4A1p8Kzi0U3k5I/PDvzdDQSklJSwsFvBoM4SAQ3iAQ/fPy+ufl++vq/O3x4dB65M0A7NUA4aoE0lgd8Lu4++np++jn++no/uvq6dvadXZ2MxIPmRQJ+uPh53123EU73EU/14Ij8twA9NwA+OIA7MwC14Ug10c33EA520A34FlR9L67+vr5pqioMycmbA0F++rp1Skg14II7NgA5M4A8doA+OEA9NsA3JUG0DkV4FpU9cvI//390NHRTExM//r76q+g2q8N69YA79gA074A18IA6NEA7NYA3bUP59Sr7u/veHl5BwcHAAAA6uWr38oG6dIA2cQAw7AAzbkA4csA4swA2skZ5uO87u7u4NiK1sEAyLUA0LwAxLEA3ccA2stF+fn2TEtL7em+6tUKyrYAxbIAx7MAyLQAx7QA1cx2/v//+vr6paio8d3M5MAS3McD5M4E5c8D480B4cwA2b4A3LB6//7/6+vrdXd3MxEP66Kc3ZJl6eKv7eex7ues7eak7OWZ5ct44Hpj/fDwzc/PSkhI//z899XT/fPz89PRnpGSMiQk3h8QcXJ1ysrLR0dE27QA+fn5nZ6g5+fnKjwCnJqcISoeGE8B5eXlamlrxMPEEjcCoJ+gIichL40I9LVm3wAAAA50Uk5T/v7+/v7+/v7+/v7+/v7BShreAAAAAWJLR0QZ7G61iAAAAAlwSFlzAAAASAAAAEgARslrPgAAAatJREFUOMtj4OMXEBQSJgwYRETFxCWIUMkgKSklLSMrJ0eEQkl5BUUlZRVV/ACkUFJSTV2DgZEJL4AolNTU0tbR1dPHA6AKJQ0MjYxN9ExxA7BCM3NJC0sraxtbO3ucAKTQwdHJ2cVV0s3dg5mFlQUHACr09PL28fXzl5QMCAwKDgkNww6ACkXCIyKjomNigWbHxSckJiVjBQwpqWnpGZlZ2Tm5efkFhUXFJaXJSdgAQ1l5RWVVdU1tXX1DY1NzS2tbewcbOxbAINnp39Xd09vXP2HipMlTpkpKTpvOwcmFCYBunDFz1uw5c+fNX7BwEThIFy9ZugwTgIJn+YqVq1avWbtu/Qawwo04FW7avGXrttWbt+/YCVI3bRcuqyV379m7b/++AwcPHZaUPHIUp2ckJY8dP3Hy1OkzZ8+dl7xw8RKu4AEqvHzl6rXrN27eun3n7j3cAS4pef/BQ0gKevT4CTAKn2IHsGQGBG7PPLjxJgooeP7C5iWBZAYCr14Tk3AlJd8QmRXU1N8y8PASzFzy795/ICa7fvxEVAEg8lnsC1FFytdvAt+JKaQAum8igK+St78AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MjQrMDI6MDAvXChbAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjI0KzAyOjAwXgGQ5wAAAABJRU5ErkJggg=="), + "ax" to CountryFlag("Åland Islands", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAMAAABpA6zvAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAIRQTFRFAFOlAFOlnZ8//9IA+rkG2Cgt0g400Q0152gc/9AA9ckGPnF9AFGnAFGonZ5A9ckHPm9/AE+qbIdfxrMl/9EA+csEj5hIaoZh/88A2Ckt/84A/skB/soB+bQH5mUd/ssB3kQm3T4n1Bcy0hA00g803kUm30Um30Ula4dgaYZh+rgG////mzb/7wAAAAF0Uk5T/hrjB30AAAABYktHRCskueQIAAAACXBIWXMAAABIAAAASABGyWs+AAAAkUlEQVQ4y2NghAMmZhZWNnYOTi5uHkZMwDCqkDoKeeGAD6qQX0CQFxMwCMGBsAhEoaiYuBAmYJBAAE4WSZBCKQlsgEEaAWRkgSbKyUtjBQwKSEBRSVmFVVUBK2BgRwbKysoq7NgB8QqRTFcDW62Ow2qiPUN08GjAASLANTUwAfFROBTS4xBTKKIlqQIKcGwKGQCIhy8sc3x++AAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNToxOSswMjowMC/GJUYAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTU6MTkrMDI6MDBem536AAAAAElFTkSuQmCC") + ) + } +} diff --git a/android/app/src/main/java/network/mysterium/vpn/connection/ConnectionCheckerService.kt b/android/app/src/main/java/network/mysterium/ui/EditText.kt similarity index 50% rename from android/app/src/main/java/network/mysterium/vpn/connection/ConnectionCheckerService.kt rename to android/app/src/main/java/network/mysterium/ui/EditText.kt index 916ad6b6f..863574866 100644 --- a/android/app/src/main/java/network/mysterium/vpn/connection/ConnectionCheckerService.kt +++ b/android/app/src/main/java/network/mysterium/ui/EditText.kt @@ -15,25 +15,16 @@ * along with this program. If not, see . */ -package network.mysterium.vpn.connection +package network.mysterium.ui -import android.content.Intent -import android.util.Log -import com.facebook.react.HeadlessJsTaskService -import com.facebook.react.bridge.Arguments -import com.facebook.react.jstasks.HeadlessJsTaskConfig +import android.text.Editable +import android.text.TextWatcher +import android.widget.EditText -class ConnectionCheckerService : HeadlessJsTaskService() { - override fun getTaskConfig(intent: Intent?): HeadlessJsTaskConfig? { - if (intent == null) { - return null - } - val extras = intent.extras ?: return null - return HeadlessJsTaskConfig(NAME, Arguments.fromBundle(extras), TIMEOUT, true) - } - - companion object { - private const val NAME = "ConnectionChecker" - private const val TIMEOUT: Long = 60000 - } +fun EditText.onChange(cb: (String) -> Unit) { + this.addTextChangedListener(object: TextWatcher { + override fun afterTextChanged(s: Editable?) { cb(s.toString()) } + override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {} + override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {} + }) } diff --git a/android/app/src/main/java/network/mysterium/ui/FeedbackFragment.kt b/android/app/src/main/java/network/mysterium/ui/FeedbackFragment.kt new file mode 100644 index 000000000..fa67994ac --- /dev/null +++ b/android/app/src/main/java/network/mysterium/ui/FeedbackFragment.kt @@ -0,0 +1,103 @@ +package network.mysterium.ui + +import android.annotation.SuppressLint +import android.os.Bundle +import android.util.Log +import android.view.LayoutInflater +import android.view.View +import android.view.ViewGroup +import android.widget.* +import androidx.fragment.app.Fragment +import com.google.android.material.button.MaterialButton +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import network.mysterium.AppContainer +import network.mysterium.vpn.BuildConfig +import network.mysterium.vpn.R + +class FeedbackFragment : Fragment() { + private lateinit var feedbackViewModel: FeedbackViewModel + + private lateinit var feedbackBackButton: ImageView + private lateinit var feedbackTypeSpinner: Spinner + private lateinit var feedbackMessage: EditText + private lateinit var feedbackSubmitButton: MaterialButton + private lateinit var versionLabel: TextView + + override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, + savedInstanceState: Bundle?): View? { + + val root = inflater.inflate(R.layout.fragment_feedback, container, false) + val nodeRepository = AppContainer.from(activity).nodeRepository + feedbackViewModel = FeedbackViewModel(nodeRepository) + + feedbackBackButton = root.findViewById(R.id.feedback_back_button) + feedbackTypeSpinner = root.findViewById(R.id.feedback_type_spinner) + feedbackMessage = root.findViewById(R.id.feedback_message) + feedbackSubmitButton = root.findViewById(R.id.feedback_submit_button) + versionLabel = root.findViewById(R.id.vpn_version_label) + + updateVersionLabel() + + // Handle back press. + feedbackBackButton.setOnClickListener { + hideKeyboard(root) + navigateTo(root, Screen.MAIN) + } + + // Add feedback types data. + initFeedbackTypesDropdown(root) + + // Handle text change. + feedbackMessage.onChange { feedbackViewModel.setMessage(it) } + + // Handle submit. + feedbackSubmitButton.setOnClickListener { + hideKeyboard(root) + handleFeedbackSubmit(root) + } + + onBackPress { + navigateTo(root, Screen.MAIN) + } + + return root + } + + private fun handleFeedbackSubmit(root: View) { + feedbackSubmitButton.isEnabled = false + navigateTo(root, Screen.MAIN) + showMessage(root.context, getString(R.string.feedback_submit_success)) + + // Do not wait for feedback to send response as it may take some time. + CoroutineScope(Dispatchers.Main).launch { + try { + feedbackViewModel.submit() + } catch (e: Exception) { + Log.e(TAG, "Failed to send user feedback", e) + } + } + } + + private fun initFeedbackTypesDropdown(root: View) { + ArrayAdapter.createFromResource( + root.context, + R.array.feedback_types, + android.R.layout.simple_spinner_item + ).also { adapter -> + adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item) + feedbackTypeSpinner.adapter = adapter + feedbackTypeSpinner.onItemSelected { feedbackViewModel.setFeedbackType(it) } + } + } + + @SuppressLint("SetTextI18n") + private fun updateVersionLabel() { + versionLabel.text = "${BuildConfig.VERSION_NAME}.${BuildConfig.VERSION_CODE}" + } + + companion object { + private const val TAG = "FeedbackFragment" + } +} diff --git a/android/app/src/main/java/network/mysterium/ui/FeedbackViewModel.kt b/android/app/src/main/java/network/mysterium/ui/FeedbackViewModel.kt new file mode 100644 index 000000000..e3b6ab190 --- /dev/null +++ b/android/app/src/main/java/network/mysterium/ui/FeedbackViewModel.kt @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package network.mysterium.ui + +import androidx.lifecycle.ViewModel +import mysterium.SendFeedbackRequest +import network.mysterium.service.core.NodeRepository + +enum class FeedbackType(val type: Int) { + BUG(0), + CONNECTIVITY_ISSUE(1), + POSITIVE_FEEDBACK(2); + + override fun toString(): String { + return when(this) { + BUG -> "bug" + CONNECTIVITY_ISSUE -> "connectivity" + POSITIVE_FEEDBACK -> "positive" + } + } + + companion object { + fun parse(type: Int): FeedbackType { + return values().find { it.type == type } ?: BUG + } + } +} + +class FeedbackViewModel(private val nodeRepository: NodeRepository): ViewModel() { + private var feebackType = FeedbackType.BUG + private var message = "" + + fun setFeedbackType(type: Int) { + feebackType = FeedbackType.parse(type) + } + + fun setMessage(msg: String) { + message = msg + } + + suspend fun submit() { + val req = SendFeedbackRequest() + req.description = "Platform: Android, Feedback Type: $feebackType, Message: $message" + nodeRepository.sendFeedback(req) + } +} diff --git a/android/app/src/main/java/network/mysterium/ui/Keyboard.kt b/android/app/src/main/java/network/mysterium/ui/Keyboard.kt new file mode 100644 index 000000000..dbf24c044 --- /dev/null +++ b/android/app/src/main/java/network/mysterium/ui/Keyboard.kt @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package network.mysterium.ui + +import android.app.Activity +import android.view.View +import android.view.inputmethod.InputMethodManager + +fun hideKeyboard(fragmentView: View) { + val imm = fragmentView.context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager + imm.hideSoftInputFromWindow(fragmentView.windowToken, 0) +} diff --git a/android/app/src/main/java/network/mysterium/ui/MainVpnFragment.kt b/android/app/src/main/java/network/mysterium/ui/MainVpnFragment.kt new file mode 100644 index 000000000..21744074c --- /dev/null +++ b/android/app/src/main/java/network/mysterium/ui/MainVpnFragment.kt @@ -0,0 +1,260 @@ +/* + * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package network.mysterium.ui + +import android.content.Context +import android.os.Bundle +import android.util.Log +import android.view.LayoutInflater +import android.view.View +import android.view.ViewGroup +import android.widget.ImageView +import android.widget.RelativeLayout +import android.widget.TextView +import androidx.constraintlayout.widget.ConstraintLayout +import androidx.fragment.app.Fragment +import androidx.lifecycle.Observer +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.launch +import network.mysterium.MainApplication +import network.mysterium.vpn.R + +class MainVpnFragment : Fragment() { + private lateinit var sharedViewModel: SharedViewModel + private lateinit var proposalsViewModel: ProposalsViewModel + + private var job: Job? = null + private lateinit var connStatusLabel: TextView + private lateinit var conStatusIP: TextView + private lateinit var vpnStatusCountry: ImageView + private lateinit var selectProposalLayout: ConstraintLayout + private lateinit var feedbackButton: ImageView + private lateinit var vpnSelectedProposalCountryLabel: TextView + private lateinit var vpnSelectedProposalProviderLabel: TextView + private lateinit var vpnSelectedProposalCountryIcon: ImageView + private lateinit var vpnProposalPickerFavoriteLayput: RelativeLayout + private lateinit var vpnProposalPickerFavoriteImage: ImageView + private lateinit var connectionButton: TextView + private lateinit var vpnStatsDurationLabel: TextView + private lateinit var vpnStatsBytesSentLabel: TextView + private lateinit var vpnStatsBytesReceivedLabel: TextView + + override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, + savedInstanceState: Bundle?): View? { + + val appContainer = (activity!!.application as MainApplication).appContainer + sharedViewModel = appContainer.sharedViewModel + proposalsViewModel = appContainer.proposalsViewModel + + val root = inflater.inflate(R.layout.fragment_main_vpn, container, false) + + // Initialize UI elements. + connStatusLabel = root.findViewById(R.id.vpn_status_label) + conStatusIP = root.findViewById(R.id.vpn_status_ip) + vpnStatusCountry = root.findViewById(R.id.vpn_status_country) + selectProposalLayout = root.findViewById(R.id.vpn_select_proposal_layout) + feedbackButton = root.findViewById(R.id.vpn_feedback_button) + vpnSelectedProposalCountryLabel = root.findViewById(R.id.vpn_selected_proposal_country_label) + vpnSelectedProposalProviderLabel = root.findViewById(R.id.vpn_selected_proposal_provider_label) + vpnSelectedProposalCountryIcon = root.findViewById(R.id.vpn_selected_proposal_country_icon) + vpnProposalPickerFavoriteLayput = root.findViewById(R.id.vpn_proposal_picker_favorite_layout) + vpnProposalPickerFavoriteImage = root.findViewById(R.id.vpn_proposal_picker_favorite_image) + connectionButton = root.findViewById(R.id.vpn_connection_button) + vpnStatsDurationLabel = root.findViewById(R.id.vpn_stats_duration) + vpnStatsBytesReceivedLabel = root.findViewById(R.id.vpn_stats_bytes_received) + vpnStatsBytesSentLabel = root.findViewById(R.id.vpn_stats_bytes_sent) + + feedbackButton.setOnClickListener { + navigateTo(root, Screen.FEEDBACK) + } + + selectProposalLayout.setOnClickListener { + handleSelectProposalPress(root) + } + + vpnProposalPickerFavoriteLayput.setOnClickListener { + handleFavoriteProposalPress(root) + } + + connectionButton.setOnClickListener { + handleConnectionPress(root.context) + } + + sharedViewModel.selectedProposal.observe(this, Observer { updateSelectedProposal(it) }) + + sharedViewModel.connectionState.observe(this, Observer { + updateConnStateLabel(it) + updateConnButtonState(it) + }) + + sharedViewModel.statistics.observe(this, Observer { updateStatsLabels(it) }) + + sharedViewModel.location.observe(this, Observer { updateLocation(it) }) + + onBackPress { emulateHomePress() } + + return root + } + + override fun onDestroy() { + super.onDestroy() + job?.cancel() + } + + private fun updateLocation(it: LocationViewItem) { + conStatusIP.text = "IP: ${it.ip}" + if (it.countryFlagImage == null) { + vpnStatusCountry.setImageResource(R.drawable.ic_public_black_24dp) + } else { + vpnStatusCountry.setImageBitmap(it.countryFlagImage) + } + } + + private fun updateSelectedProposal(it: ProposalViewItem) { + vpnSelectedProposalCountryLabel.text = it.countryName + vpnSelectedProposalCountryIcon.setImageBitmap(it.countryFlagImage) + vpnSelectedProposalProviderLabel.text = it.providerID + vpnSelectedProposalProviderLabel.visibility = View.VISIBLE + vpnProposalPickerFavoriteImage.setImageResource(it.isFavoriteResID) + } + + private fun updateStatsLabels(it: StatisticsViewItem) { + vpnStatsDurationLabel.text = it.duration + vpnStatsBytesReceivedLabel.text = it.bytesReceived + vpnStatsBytesSentLabel.text = it.bytesSent + } + + private fun updateConnStateLabel(it: ConnectionState) { + val connStateText = when (it) { + ConnectionState.NOT_CONNECTED, ConnectionState.UNKNOWN -> getString(R.string.conn_state_not_connected) + ConnectionState.CONNECTED -> getString(R.string.conn_state_connected) + ConnectionState.CONNECTING -> getString(R.string.conn_state_connecting) + ConnectionState.DISCONNECTING -> getString(R.string.conn_state_disconnecting) + } + + connStatusLabel.text = connStateText + } + + private fun handleSelectProposalPress(root: View) { + navigateToProposals(root) + } + + private fun handleFavoriteProposalPress(root: View) { + val selectedProposal = sharedViewModel.selectedProposal.value + if (selectedProposal == null) { + navigateToProposals(root) + return + } + + vpnProposalPickerFavoriteLayput.isEnabled = false + proposalsViewModel.toggleFavoriteProposal(selectedProposal.id) { updatedProposal -> + if (updatedProposal != null) { + vpnProposalPickerFavoriteImage.setImageResource(updatedProposal.isFavoriteResID) + } + + vpnProposalPickerFavoriteLayput.isEnabled = true + } + } + + private fun navigateToProposals(root: View) { + if (sharedViewModel.canConnect()) { + navigateTo(root, Screen.PROPOSALS) + } else { + showMessage(root.context, getString(R.string.disconnect_to_select_proposal)) + } + } + + private fun updateConnButtonState(it: ConnectionState) { + connectionButton.text = when (it) { + ConnectionState.NOT_CONNECTED, ConnectionState.UNKNOWN -> getString(R.string.connect_button_connect) + ConnectionState.CONNECTED -> getString(R.string.connect_button_disconnect) + ConnectionState.CONNECTING -> getString(R.string.connect_button_cancel) + ConnectionState.DISCONNECTING -> getString(R.string.connect_button_disconnecting) + } + + connectionButton.isEnabled = when (it) { + ConnectionState.DISCONNECTING -> false + else -> true + } + } + + private fun handleConnectionPress(ctx: Context) { + if (sharedViewModel.canConnect()) { + connect(ctx) + return + } + + if (sharedViewModel.canDisconnect()) { + disconnect(ctx) + return + } + + cancel() + } + + private fun connect(ctx: Context) { + val proposal: ProposalViewItem? = sharedViewModel.selectedProposal.value + if (proposal == null) { + showMessage(ctx, "Select proposal!") + return + } + job?.cancel() + connectionButton.isEnabled = false + job = CoroutineScope(Dispatchers.Main).launch { + try { + sharedViewModel.connect(proposal.providerID, proposal.serviceType.type) + } catch (e: kotlinx.coroutines.CancellationException) { + // Do nothing. + } catch (e: Exception) { + showMessage(ctx, "Failed to connect. Please try again.") + Log.e(TAG, "Failed to connect", e) + } + } + } + + private fun disconnect(ctx: Context) { + connectionButton.isEnabled = false + job?.cancel() + job = CoroutineScope(Dispatchers.Main).launch { + try { + sharedViewModel.disconnect() + } catch (e: Exception) { + showMessage(ctx, "Failed to disconnect. Please try again.") + Log.e(TAG, "Failed to disconnect", e) + } + } + } + + private fun cancel() { + connectionButton.isEnabled = false + job?.cancel() + job = CoroutineScope(Dispatchers.Main).launch { + try { + sharedViewModel.disconnect() + } catch (e: Exception) { + Log.e(TAG, "Failed to cancel", e) + } + } + } + + companion object { + private const val TAG = "ProposalsFragment" + } +} diff --git a/android/app/src/main/java/network/mysterium/logging/BugReporterPackage.kt b/android/app/src/main/java/network/mysterium/ui/MaterialSpinner.kt similarity index 55% rename from android/app/src/main/java/network/mysterium/logging/BugReporterPackage.kt rename to android/app/src/main/java/network/mysterium/ui/MaterialSpinner.kt index 5b04e84b2..9df46074b 100644 --- a/android/app/src/main/java/network/mysterium/logging/BugReporterPackage.kt +++ b/android/app/src/main/java/network/mysterium/ui/MaterialSpinner.kt @@ -15,21 +15,20 @@ * along with this program. If not, see . */ -package network.mysterium.logging +package network.mysterium.ui -import com.facebook.react.ReactPackage -import com.facebook.react.bridge.NativeModule -import com.facebook.react.bridge.ReactApplicationContext -import com.facebook.react.uimanager.ViewManager +import android.view.View +import android.widget.AdapterView +import android.widget.Spinner -class BugReporterPackage : ReactPackage { - override fun createNativeModules(reactContext: ReactApplicationContext): MutableList { - return mutableListOf( - BugReporter(reactContext) - ) - } +fun Spinner.onItemSelected(cb: (position: Int) -> Unit) { + this.onItemSelectedListener = object : AdapterView.OnItemSelectedListener { + override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) { + cb(position) + } + + override fun onNothingSelected(parent: AdapterView<*>?) { + } - override fun createViewManagers(reactContext: ReactApplicationContext): MutableList> { - return mutableListOf() } } diff --git a/android/app/src/main/java/network/mysterium/ui/Navigation.kt b/android/app/src/main/java/network/mysterium/ui/Navigation.kt new file mode 100644 index 000000000..e7f9b393b --- /dev/null +++ b/android/app/src/main/java/network/mysterium/ui/Navigation.kt @@ -0,0 +1,42 @@ +package network.mysterium.ui + +import android.content.Intent +import android.view.View +import androidx.activity.OnBackPressedCallback +import androidx.fragment.app.Fragment +import androidx.navigation.findNavController +import network.mysterium.vpn.R + +enum class Screen { + MAIN, + FEEDBACK, + PROPOSALS +} + +fun navigateTo(view: View, destination: Screen) { + val navController = view.findNavController() + val to = when(destination) { + Screen.MAIN -> R.id.action_go_to_vpn_screen + Screen.FEEDBACK -> R.id.action_go_to_feedback_screen + Screen.PROPOSALS -> R.id.action_go_to_proposals_screen + } + navController.navigate(to) +} + +fun Fragment.onBackPress(cb: () -> Unit) { + val callback = object : OnBackPressedCallback(true) { + override fun handleOnBackPressed() { + cb() + } + } + this.requireActivity().onBackPressedDispatcher.addCallback(this.viewLifecycleOwner, callback) +} + +// Default back behaviour fully closes app, but we only want to minimize it. +// To do so we emulate home button press. +fun Fragment.emulateHomePress() { + val startMain = Intent(Intent.ACTION_MAIN) + startMain.addCategory(Intent.CATEGORY_HOME) + startMain.flags = Intent.FLAG_ACTIVITY_NEW_TASK + this.startActivity(startMain) +} diff --git a/android/app/src/main/java/network/mysterium/ui/ProposalViewItem.kt b/android/app/src/main/java/network/mysterium/ui/ProposalViewItem.kt new file mode 100644 index 000000000..53208499d --- /dev/null +++ b/android/app/src/main/java/network/mysterium/ui/ProposalViewItem.kt @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package network.mysterium.ui + +import android.graphics.Bitmap +import network.mysterium.service.core.ProposalItem +import network.mysterium.db.FavoriteProposal +import network.mysterium.vpn.R + +class ProposalViewItem constructor( + val id: String, + val providerID: String, + val serviceType: ServiceType, + val countryCode: String +) { + var countryFlagImage: Bitmap? = null + var serviceTypeResID: Int = R.drawable.service_openvpn + var qualityResID: Int = R.drawable.quality_unknown + var qualityLevel: QualityLevel = QualityLevel.UNKNOWN + var countryName: String = "" + var isFavorite: Boolean = false + var isFavoriteResID: Int = R.drawable.ic_star_border_black_24dp + + fun toggleFavorite() { + isFavorite = !isFavorite + isFavoriteResID = if (isFavorite) { + R.drawable.ic_star_black_24dp + } else { + R.drawable.ic_star_border_black_24dp + } + } + + companion object { + fun parse(it: ProposalItem, favoriteProposals: Map): ProposalViewItem { + val res = ProposalViewItem( + id = it.providerID+it.serviceType, + providerID = it.providerID, + serviceType = ServiceType.parse(it.serviceType), + countryCode = it.countryCode.toLowerCase()) + + if (Countries.bitmaps.contains(res.countryCode)) { + res.countryFlagImage = Countries.bitmaps[res.countryCode] + res.countryName = Countries.values[res.countryCode]?.name ?: "" + } + + res.serviceTypeResID = mapServiceTypeResourceID(res.serviceType) + res.qualityLevel = QualityLevel.parse(it.qualityLevel) + res.qualityResID = mapQualityLevelResourceID(res.qualityLevel) + res.isFavorite = favoriteProposals.containsKey(res.id) + if (res.isFavorite) { + res.isFavoriteResID = R.drawable.ic_star_black_24dp + } + + return res + } + + private fun mapServiceTypeResourceID(serviceType: ServiceType): Int { + return when(serviceType) { + ServiceType.OPENVPN -> R.drawable.service_openvpn + ServiceType.WIREGUARD -> R.drawable.service_wireguard + else -> R.drawable.service_openvpn + } + } + + private fun mapQualityLevelResourceID(qualityLevel: QualityLevel): Int { + return when(qualityLevel) { + QualityLevel.HIGH -> R.drawable.quality_high + QualityLevel.MEDIUM -> R.drawable.quality_medium + QualityLevel.LOW -> R.drawable.quality_low + QualityLevel.UNKNOWN -> R.drawable.quality_unknown + } + } + } +} diff --git a/android/app/src/main/java/network/mysterium/ui/ProposalsFragment.kt b/android/app/src/main/java/network/mysterium/ui/ProposalsFragment.kt new file mode 100644 index 000000000..3be88c09c --- /dev/null +++ b/android/app/src/main/java/network/mysterium/ui/ProposalsFragment.kt @@ -0,0 +1,251 @@ +/* + * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package network.mysterium.ui + +import android.graphics.Color +import android.os.Bundle +import android.util.Log +import android.view.LayoutInflater +import android.view.View +import android.view.ViewGroup +import android.widget.* +import androidx.core.content.ContextCompat +import androidx.fragment.app.Fragment +import androidx.lifecycle.Observer +import androidx.recyclerview.widget.DividerItemDecoration +import androidx.recyclerview.widget.LinearLayoutManager +import androidx.recyclerview.widget.RecyclerView +import androidx.swiperefreshlayout.widget.SwipeRefreshLayout +import com.makeramen.roundedimageview.RoundedImageView +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import network.mysterium.AppContainer +import network.mysterium.MainApplication +import network.mysterium.vpn.R + +class ProposalsFragment : Fragment() { + + private lateinit var proposalsViewModel: ProposalsViewModel + private lateinit var appContainer: AppContainer + + private lateinit var proposalsCloseButton: TextView + private lateinit var proposalsSearchInput: EditText + private lateinit var proposalsFiltersAllButton: TextView + private lateinit var proposalsFiltersOpenvpnButton: TextView + private lateinit var proposalsFiltersWireguardButton: TextView + private lateinit var proposalsFiltersSort: Spinner + private lateinit var proposalsSwipeRefresh: SwipeRefreshLayout + private lateinit var proposalsList: RecyclerView + private lateinit var proposalsProgressBar: ProgressBar + + override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? { + + val root = inflater.inflate(R.layout.fragment_proposals, container, false) + + appContainer = (activity!!.application as MainApplication).appContainer + proposalsViewModel = appContainer.proposalsViewModel + + // Initialize UI elements. + proposalsCloseButton = root.findViewById(R.id.proposals_close_button) + proposalsSearchInput = root.findViewById(R.id.proposals_search_input) + proposalsFiltersAllButton = root.findViewById(R.id.proposals_filters_all_button) + proposalsFiltersOpenvpnButton = root.findViewById(R.id.proposals_filters_openvpn_button) + proposalsFiltersWireguardButton = root.findViewById(R.id.proposals_filters_wireguard_button) + proposalsFiltersSort = root.findViewById(R.id.proposals_filters_sort) + proposalsSwipeRefresh = root.findViewById(R.id.proposals_list_swipe_refresh) + proposalsList = root.findViewById(R.id.proposals_list) + proposalsProgressBar = root.findViewById(R.id.proposals_progress_bar) + + proposalsCloseButton.setOnClickListener { handleClose(root) } + + initProposalsList(root) + initProposalsSortDropdown(root) + initProposalsServiceTypeFilter(root) + initProposalsSearchFilter() + + onBackPress { + navigateTo(root, Screen.MAIN) + } + + return root + } + + private fun navigateToMainVpnFragment(root: View) { + navigateTo(root, Screen.MAIN) + } + + private fun initProposalsSearchFilter() { + if (proposalsViewModel.filter.searchText != "") { + proposalsSearchInput.setText(proposalsViewModel.filter.searchText) + } + + proposalsSearchInput.onChange { proposalsViewModel.filterBySearchText(it) } + } + + private fun initProposalsServiceTypeFilter(root: View) { + // Set current active filter. + val activeTabButton = when (proposalsViewModel.filter.serviceType) { + ServiceTypeFilter.ALL -> proposalsFiltersAllButton + ServiceTypeFilter.OPENVPN -> proposalsFiltersOpenvpnButton + ServiceTypeFilter.WIREGUARD -> proposalsFiltersWireguardButton + } + setFilterTabActiveStyle(root, activeTabButton) + + proposalsFiltersAllButton.setOnClickListener { + proposalsViewModel.filterByServiceType(ServiceTypeFilter.ALL) + setFilterTabActiveStyle(root, proposalsFiltersAllButton) + setFilterTabInactiveStyle(root, proposalsFiltersOpenvpnButton) + setFilterTabInactiveStyle(root, proposalsFiltersWireguardButton) + } + + proposalsFiltersOpenvpnButton.setOnClickListener { + proposalsViewModel.filterByServiceType(ServiceTypeFilter.OPENVPN) + setFilterTabActiveStyle(root, proposalsFiltersOpenvpnButton) + setFilterTabInactiveStyle(root, proposalsFiltersAllButton) + setFilterTabInactiveStyle(root, proposalsFiltersWireguardButton) + } + + proposalsFiltersWireguardButton.setOnClickListener { + proposalsViewModel.filterByServiceType(ServiceTypeFilter.WIREGUARD) + setFilterTabActiveStyle(root, proposalsFiltersWireguardButton) + setFilterTabInactiveStyle(root, proposalsFiltersAllButton) + setFilterTabInactiveStyle(root, proposalsFiltersOpenvpnButton) + } + } + + private fun initProposalsSortDropdown(root: View) { + ArrayAdapter.createFromResource(root.context, R.array.proposals_sort_types, android.R.layout.simple_spinner_item).also { adapter -> + adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item) + proposalsFiltersSort.adapter = adapter + proposalsFiltersSort.onItemSelected { item -> proposalsViewModel.sortBy(item) } + } + } + + private fun initProposalsList(root: View) { + proposalsList.layoutManager = LinearLayoutManager(root.context) + val items = ArrayList() + val proposalsListAdapter = ProposalsListAdapter(items) { handleSelectedProposal(root, it) } + proposalsList.adapter = proposalsListAdapter + proposalsList.addItemDecoration(DividerItemDecoration(root.context, DividerItemDecoration.VERTICAL)) + + proposalsSwipeRefresh.setOnRefreshListener { + proposalsViewModel.refreshProposals { + proposalsSwipeRefresh.isRefreshing = false + } + } + + // Subscribe to proposals changes. + proposalsViewModel.getProposals().observe(this, Observer { newItems -> + items.clear() + items.addAll(newItems) + proposalsListAdapter.notifyDataSetChanged() + + // Hide progress bar once proposals are loaded. + proposalsList.visibility = View.VISIBLE + proposalsProgressBar.visibility = View.GONE + }) + + // Subscribe to proposals counters. + proposalsViewModel.getProposalsCounts().observe(this, Observer { counts -> + proposalsFiltersAllButton.text = "All (${counts.all})" + proposalsFiltersOpenvpnButton.text = "Openvpn (${counts.openvpn})" + proposalsFiltersWireguardButton.text = "Wireguard (${counts.wireguard})" + }) + + proposalsViewModel.initialProposalsLoaded.observe(this, Observer {loaded -> + if (loaded) { + return@Observer + } + + // If initial proposals failed to load during app init try to load them explicitly. + proposalsList.visibility = View.GONE + proposalsProgressBar.visibility = View.VISIBLE + proposalsViewModel.refreshProposals {} + }) + } + + private fun handleClose(root: View) { + hideKeyboard(root) + navigateToMainVpnFragment(root) + } + + private fun handleSelectedProposal(root: View, proposal: ProposalViewItem) { + hideKeyboard(root) + proposalsViewModel.selectProposal(proposal) + navigateToMainVpnFragment(root) + } + + private fun setFilterTabActiveStyle(root: View, btn: TextView) { + btn.setBackgroundColor(ContextCompat.getColor(root.context, R.color.ColorMain)) + btn.setTextColor(ContextCompat.getColor(root.context, R.color.ColorWhite)) + } + + private fun setFilterTabInactiveStyle(root: View, btn: TextView) { + btn.setBackgroundColor(Color.TRANSPARENT) + btn.setTextColor(ContextCompat.getColor(root.context, R.color.ColorMain)) + } +} + +class ProposalsListAdapter(private var list: List, private var onItemClickListener: (ProposalViewItem) -> Unit) + : RecyclerView.Adapter() { + + override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ProposalViewHolder { + val inflater = LayoutInflater.from(parent.context) + return ProposalViewHolder(inflater, parent) + } + + override fun onBindViewHolder(holder: ProposalViewHolder, position: Int) { + val item: ProposalViewItem = list[position] + holder.bind(item) + holder.itemView.setOnClickListener { + onItemClickListener(item) + } + } + + override fun getItemCount(): Int = list.size + + inner class ProposalViewHolder(inflater: LayoutInflater, parent: ViewGroup) : + RecyclerView.ViewHolder(inflater.inflate(R.layout.proposal_list_item, parent, false)) { + + private var countryFlag: RoundedImageView? = null + private var countryName: TextView? = null + private var providerID: TextView? = null + private var serviceType: ImageView? = null + private var qualityLevel: ImageView? = null + private var favorite: ImageView? = null + + init { + countryFlag = itemView.findViewById(R.id.proposal_item_country_flag) + countryName = itemView.findViewById(R.id.proposal_item_country_name) + providerID = itemView.findViewById(R.id.proposal_item_provider_id) + serviceType = itemView.findViewById(R.id.proposal_item_service_type) + qualityLevel = itemView.findViewById(R.id.proposal_item_quality_level) + favorite = itemView.findViewById(R.id.proposal_item_favorite) + } + + fun bind(item: ProposalViewItem) { + countryFlag?.setImageBitmap(item.countryFlagImage) + countryName?.text = item.countryName + providerID?.text = item.providerID + serviceType?.setImageResource(item.serviceTypeResID) + qualityLevel?.setImageResource(item.qualityResID) + favorite?.setImageResource(item.isFavoriteResID) + } + } +} diff --git a/android/app/src/main/java/network/mysterium/ui/ProposalsViewModel.kt b/android/app/src/main/java/network/mysterium/ui/ProposalsViewModel.kt new file mode 100644 index 000000000..2ad6e4de6 --- /dev/null +++ b/android/app/src/main/java/network/mysterium/ui/ProposalsViewModel.kt @@ -0,0 +1,243 @@ +/* + * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package network.mysterium.ui + +import android.util.Log +import androidx.lifecycle.LiveData +import androidx.lifecycle.MutableLiveData +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import kotlinx.coroutines.launch +import network.mysterium.service.core.NodeRepository +import network.mysterium.db.AppDatabase +import network.mysterium.db.FavoriteProposal + +enum class ServiceType(val type: String) { + UNKNOWN("unknown"), + OPENVPN("openvpn"), + WIREGUARD("wireguard"); + + companion object { + fun parse(type: String): ServiceType { + return values().find { it.type == type } ?: UNKNOWN + } + } +} + +enum class ServiceTypeFilter(val type: String) { + ALL("all"), + OPENVPN("openvpn"), + WIREGUARD("wireguard") +} + +enum class ProposalSortType(val type: Int) { + COUNTRY(0), + QUALITY(1); + + companion object { + fun parse(type: Int): ProposalSortType { + if (type == 0) { + return COUNTRY + } + return QUALITY + } + } +} + +enum class QualityLevel(val level: Int) { + UNKNOWN(0), + LOW(1), + MEDIUM(2), + HIGH(3); + + companion object { + fun parse(level: Int): QualityLevel { + return values().find { it.level == level } ?: UNKNOWN + } + } +} + +class ProposalsCounts( + val openvpn: Int, + val wireguard: Int +) { + val all: Int + get() = openvpn + wireguard +} + +class ProposalsFilter( + var serviceType: ServiceTypeFilter = ServiceTypeFilter.ALL, + var searchText: String = "", + var sortBy: ProposalSortType = ProposalSortType.COUNTRY +) + +class ProposalsViewModel(private val sharedViewModel: SharedViewModel, private val nodeRepository: NodeRepository, private val appDatabase: AppDatabase) : ViewModel() { + var filter = ProposalsFilter() + var initialProposalsLoaded = MutableLiveData() + + private var favoriteProposals: MutableMap = mutableMapOf() + private var allProposals: List = listOf() + private val proposals = MutableLiveData>() + private val proposalsCounts = MutableLiveData() + + suspend fun loadFavoriteProposals(): Map { + val favorites = appDatabase.favoriteProposalDao().getAll() + favoriteProposals = favorites.map { it.id to it }.toMap().toMutableMap() + return favoriteProposals + } + + suspend fun load() { + loadInitialProposals() + } + + fun getProposals(): LiveData> { + return proposals + } + + fun getProposalsCounts(): LiveData { + return proposalsCounts + } + + fun filterByServiceType(type: ServiceTypeFilter) { + if (filter.serviceType == type) { + return + } + + filter.serviceType = type + proposals.value = filterAndSortProposals(filter, allProposals) + } + + fun filterBySearchText(value: String) { + val searchText = value.toLowerCase() + if (filter.searchText == searchText) { + return + } + + filter.searchText = searchText + proposals.value = filterAndSortProposals(filter, allProposals) + } + + fun sortBy(type: Int) { + val sortBy = ProposalSortType.parse(type) + if (filter.sortBy == sortBy) { + return + } + + filter.sortBy = sortBy + proposals.value = filterAndSortProposals(filter, allProposals) + } + + fun refreshProposals(done: () -> Unit) { + viewModelScope.launch { + loadInitialProposals(refresh = true) + done() + } + } + + fun selectProposal(item: ProposalViewItem) { + sharedViewModel.selectProposal(item) + } + + fun toggleFavoriteProposal(proposalID: String, done: (updatedProposal: ProposalViewItem?) -> Unit) { + viewModelScope.launch { + val proposal = allProposals.find { it.id == proposalID } + if (proposal == null) { + done(null) + return@launch + } + + val favoriteProposal = FavoriteProposal(proposalID) + if (proposal.isFavorite) { + deleteFavoriteProposal(favoriteProposal) + } else { + insertFavoriteProposal(favoriteProposal) + } + + proposal.toggleFavorite() + proposals.value = filterAndSortProposals(filter, allProposals) + done(proposal) + } + } + + private suspend fun insertFavoriteProposal(proposal: FavoriteProposal) { + try { + appDatabase.favoriteProposalDao().insert(proposal) + favoriteProposals[proposal.id] = proposal + } catch (e: Exception) { + Log.e(TAG, "Failed to insert favorite proposal", e) + } + } + + private suspend fun deleteFavoriteProposal(proposal: FavoriteProposal) { + try { + appDatabase.favoriteProposalDao().delete(proposal) + favoriteProposals.remove(proposal.id) + } catch (e: Exception) { + Log.e(TAG, "Failed to delete favorite proposal", e) + } + } + + private suspend fun loadInitialProposals(refresh: Boolean = false) { + try { + val nodeProposals = nodeRepository.getProposals(refresh) + allProposals = nodeProposals.map { ProposalViewItem.parse(it, favoriteProposals) } + + proposalsCounts.value = ProposalsCounts( + openvpn = allProposals.count { it.serviceType == ServiceType.OPENVPN }, + wireguard = allProposals.count { it.serviceType == ServiceType.WIREGUARD } + ) + proposals.value = filterAndSortProposals(filter, allProposals) + initialProposalsLoaded.value = true + } catch (e: Exception) { + Log.e(TAG, "Failed to load initial proposals", e) + proposals.value = listOf() + initialProposalsLoaded.value = false + } + } + + private fun filterAndSortProposals(filter: ProposalsFilter, allProposals: List): List { + return allProposals.asSequence() + // Filter by service type. + .filter { + when (filter.serviceType) { + ServiceTypeFilter.OPENVPN -> it.serviceType == ServiceType.OPENVPN + ServiceTypeFilter.WIREGUARD -> it.serviceType == ServiceType.WIREGUARD + else -> true + } + } + // Filter by search value. + .filter { + when (filter.searchText) { + "" -> true + else -> it.countryName.toLowerCase().contains(filter.searchText) or it.providerID.contains(filter.searchText) + } + } + // Sort by country or quality. + .sortedWith( + if (filter.sortBy == ProposalSortType.QUALITY) + compareByDescending { it.qualityLevel } + else + compareBy { it.countryName } + ) + .toList() + } + + companion object { + const val TAG: String = "ProposalsViewModel" + } +} diff --git a/android/app/src/main/java/network/mysterium/ui/SharedViewModel.kt b/android/app/src/main/java/network/mysterium/ui/SharedViewModel.kt new file mode 100644 index 000000000..8dd61c4a0 --- /dev/null +++ b/android/app/src/main/java/network/mysterium/ui/SharedViewModel.kt @@ -0,0 +1,247 @@ +/* + * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package network.mysterium.ui + +import android.graphics.Bitmap +import android.util.Log +import androidx.lifecycle.MutableLiveData +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import kotlinx.coroutines.* +import mysterium.ConnectRequest +import network.mysterium.db.FavoriteProposal +import network.mysterium.service.core.NodeRepository +import network.mysterium.service.core.Statistics +import network.mysterium.logging.BugReporter +import network.mysterium.service.core.MysteriumCoreService +import network.mysterium.service.core.Status + +enum class ConnectionState(val type: String) { + UNKNOWN("Unknown"), + CONNECTED("Connected"), + CONNECTING("Connecting"), + NOT_CONNECTED("NotConnected"), + DISCONNECTING("Disconnecting"); + + companion object { + fun parse(type: String): ConnectionState { + return values().find { it.type == type } ?: UNKNOWN + } + } +} + +class LocationViewItem( + val ip: String, + val countryFlagImage: Bitmap? +) + +class StatisticsViewItem( + val duration: String, + val bytesReceived: String, + val bytesSent: String +) { + companion object { + fun from(it: Statistics): StatisticsViewItem { + return StatisticsViewItem( + duration = UnitFormatter.timeDisplay(it.duration.toDouble()), + bytesReceived = UnitFormatter.bytesDisplay(it.bytesReceived.toDouble()), + bytesSent = UnitFormatter.bytesDisplay(it.bytesSent.toDouble()) + ) + } + } +} + +class SharedViewModel( + private val nodeRepository: NodeRepository, + private val bugReporter: BugReporter, + private val mysteriumCoreService: CompletableDeferred +) : ViewModel() { + + val selectedProposal = MutableLiveData() + val connectionState = MutableLiveData() + val statistics = MutableLiveData() + val location = MutableLiveData() + + private var isConnected = false + + suspend fun load(favoriteProposals: Map) { + unlockIdentity() + initListeners() + loadLocation() + val status = loadCurrentStatus() + loadActiveProposal(status, favoriteProposals) + } + + fun selectProposal(item: ProposalViewItem) { + selectedProposal.value = item + } + + fun canConnect(): Boolean { + val state = connectionState.value + return state == null || state == ConnectionState.NOT_CONNECTED || state == ConnectionState.UNKNOWN + } + + fun canDisconnect(): Boolean { + val state = connectionState.value + return state != null && state == ConnectionState.CONNECTED + } + + suspend fun connect(providerID: String, serviceType: String) { + try { + connectionState.value = ConnectionState.CONNECTING + // Before doing actual connection add some delay to prevent + // from trying to establish connection if user instantly clicks CANCEL. + delay(1000) + val req = ConnectRequest() + req.providerID = providerID + req.serviceType = serviceType + nodeRepository.connect(req) + isConnected = true + connectionState.value = ConnectionState.CONNECTED + loadLocation() + } catch (e: Exception) { + isConnected = false + connectionState.value = ConnectionState.NOT_CONNECTED + throw e + } + } + + suspend fun disconnect() { + try { + connectionState.value = ConnectionState.DISCONNECTING + nodeRepository.disconnect() + isConnected = false + connectionState.value = ConnectionState.NOT_CONNECTED + resetStatistics() + loadLocation() + } catch (e: Exception) { + connectionState.value = ConnectionState.NOT_CONNECTED + throw e + } finally { + mysteriumCoreService.await().hideNotifications() + } + } + + private suspend fun loadCurrentStatus(): Status? { + return try { + val status = nodeRepository.getStatus() + val state = ConnectionState.parse(status.state) + connectionState.value = state + status + } catch (e: Exception) { + Log.e(TAG, "Failed to load current status", e) + null + } + } + + private suspend fun loadActiveProposal(it: Status?, favoriteProposals: Map) { + if (it == null || it.providerID == "" || it.serviceType == "") { + return + } + + try { + val proposal = nodeRepository.getProposal(it.providerID, it.serviceType) ?: return + val proposalViewItem = ProposalViewItem.parse(proposal, favoriteProposals) + selectProposal(proposalViewItem) + } catch (e: Exception) { + Log.e(TAG, "Failed to load active proposal", e) + } + } + + // initListeners subscribes to go node library exposed callbacks for statistics and state. + private suspend fun initListeners() { + nodeRepository.registerConnectionStatusChangeCallback { + handleConnectionStatusChange(it) + } + + nodeRepository.registerStatisticsChangeCallback { + handleStatisticsChange(it) + } + } + + private fun handleConnectionStatusChange(it: String) { + val newState = ConnectionState.parse(it) + val currentState = connectionState.value + + // Update all UI related state in new coroutine on UI thread. + // This is needed since status change can be executed on separate + // inside go node library. + viewModelScope.launch { + connectionState.value = newState + if (currentState == ConnectionState.CONNECTED && newState != currentState) { + mysteriumCoreService.await().showNotification("Connection lost", "VPN connection was closed.") + resetStatistics() + loadLocation() + } + } + } + + private fun handleStatisticsChange(it: Statistics) { + // Update all UI related state in new coroutine on UI thread. + // This is needed since status change can be executed on separate + // inside go node library. + viewModelScope.launch { + val s = StatisticsViewItem( + duration = UnitFormatter.timeDisplay(it.duration.toDouble()), + bytesReceived = UnitFormatter.bytesDisplay(it.bytesReceived.toDouble()), + bytesSent = UnitFormatter.bytesDisplay(it.bytesSent.toDouble()) + ) + statistics.value = s + + // Show global notification with connected country and statistics. + // At this point we need to check if proposal is not null since + // statistics event can fire sooner than proposal is loaded. + if (selectedProposal.value != null) { + val countryName = selectedProposal.value?.countryName + mysteriumCoreService.await().showNotification("Connected to $countryName", "Received ${s.bytesReceived} | Send ${s.bytesSent}") + } + } + } + + private suspend fun unlockIdentity() { + try { + val identity = nodeRepository.unlockIdentity() + bugReporter.setUserIdentifier(identity) + } catch (e: Exception) { + Log.e(TAG, "Failed not unlock identity", e) + } + } + + private suspend fun loadLocation() { + // Try to load location with few attempts. It can fail to load when connected to VPN. + location.value = LocationViewItem(ip = "Updating", countryFlagImage = null) + for (i in 1..3) { + try { + val loc = nodeRepository.getLocation() + location.value = LocationViewItem(ip = loc.ip, countryFlagImage = Countries.bitmaps[loc.countryCode.toLowerCase()]) + break + } catch (e: Exception) { + delay(1000) + Log.e(TAG, "Failed to load location. Attempt $i.", e) + } + } + } + + private fun resetStatistics() { + statistics.value = StatisticsViewItem.from(Statistics(0, 0, 0)) + } + + companion object { + const val TAG = "SharedViewModel" + } +} diff --git a/android/app/src/main/java/network/mysterium/ui/TermsFragment.kt b/android/app/src/main/java/network/mysterium/ui/TermsFragment.kt new file mode 100644 index 000000000..86e17e6c8 --- /dev/null +++ b/android/app/src/main/java/network/mysterium/ui/TermsFragment.kt @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package network.mysterium.ui + +import android.os.Bundle +import android.text.Html +import androidx.fragment.app.Fragment +import android.view.LayoutInflater +import android.view.View +import android.view.ViewGroup +import android.widget.Button +import android.widget.TextView +import androidx.navigation.findNavController +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import network.mysterium.MainApplication +import network.mysterium.vpn.R + +class TermsFragment : Fragment() { + private lateinit var termsViewModel: TermsViewModel + + private lateinit var termsTextWiew: TextView + private lateinit var termsAcceptButton: Button + + override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, + savedInstanceState: Bundle?): View? { + + val root = inflater.inflate(R.layout.fragment_terms, container, false) + + termsViewModel = (activity!!.application as MainApplication).appContainer.termsViewModel + termsTextWiew = root.findViewById(R.id.terms_text_wiew) + termsAcceptButton = root.findViewById(R.id.terms_accept_button) + + termsTextWiew.setText(Html.fromHtml(termsViewModel.termsText)) + + termsAcceptButton.setOnClickListener { + termsAcceptButton.isEnabled = false + CoroutineScope(Dispatchers.Main).launch { + termsViewModel.acceptCurrentTerms() + root.findNavController().navigate(R.id.action_go_to_vpn_screen) + } + } + + onBackPress { emulateHomePress() } + + return root + } +} diff --git a/android/app/src/main/java/network/mysterium/ui/TermsViewModel.kt b/android/app/src/main/java/network/mysterium/ui/TermsViewModel.kt new file mode 100644 index 000000000..7e0de5a5e --- /dev/null +++ b/android/app/src/main/java/network/mysterium/ui/TermsViewModel.kt @@ -0,0 +1,182 @@ +/* + * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package network.mysterium.ui + +import androidx.lifecycle.ViewModel +import network.mysterium.db.AppDatabase +import network.mysterium.db.Terms + +class TermsViewModel(private val appDatabase: AppDatabase): ViewModel() { + private val termsVersion = "1" + + suspend fun acceptCurrentTerms() { + appDatabase.termsDao().delete() + appDatabase.termsDao().insert(Terms(termsVersion)) + } + + suspend fun checkTermsAccepted(): Boolean { + val terms = appDatabase.termsDao().get() ?: return false + return terms.version == termsVersion + } + + val termsText = """ +

Terms & Conditions of MysteriumVPN for Users

+ +The following Terms and Conditions (“T&C”) govern the use of the Mysterium open source software platform (“Mysterium Platform”) and MysteriumVPN Software (the “Software”). Prior to any use of the Mysterium Platform, the User confirms to understand and expressly agrees to all of the Terms. + +MysteriumVPN is an Open Source software that enables you (the “Client”) to use the internet connection and resources of our contributors (the “Nodes”) for your private browsing using Mysterium Platform. + +The Mysterium Platform rests on open-source software. This is an experimental version of the Mysterium Platform, and there is a risk that the NetSys Inc. (“Network Operator”) or other third parties not directly affiliated with the Network Operator, might unintentionally introduce weaknesses or bugs into the core infrastructural elements of the Mysterium Platform or Software causing the system to lose cryptocurrency stored in one or more Client accounts or other accounts or lose sums of other valued tokens issued on the Mysterium Platform, or causing to suffer other losses, inconvenience, or damage to its users. The user expressly knows and agrees that the user is using the Mysterium Platform and MysteriumVPN software at the user’s sole risk. + +These terms and conditions constitute an agreement between you and Network Operator and governs your access and use of MysteriumVPN software and private browsing services provided by Mysterium Platform (the “Services”). + +The Network Operator or other creators of the Mysterium Platform are entitled to discontinue this project at any time without any further explanation or prior notification at this experimental stage. + + +PLEASE READ THESE T&C CAREFULLY IF YOU WISH TO USE THE SERVICES. IF YOU DO NOT AGREE TO BE BOUND BY THESE T&C, PLEASE DO NOT USE THE SERVICES. + +

Your Use of the Services

+ +The Services are provided to you free of charge. You may not use the Services if you are under the age of 18 or if you are not the owner of the device on which you install the Software or otherwise use the Services. + +By using the services of Network Operator, you understand and agree that the Services are internet security and private browsing services, and this mechanism is not a service to be used for criminal and/or other illegal acts. By using the Services, you accept not to violate any law of any jurisdiction that you are originating from or residing at. It is your responsibility to know and comprehend any and all relevant laws related to any jurisdiction or venue that concerns you and your actions. + + +

Client’s Account

+ +Before starting to use the Services, you must download Mysterium software and create an account entering your credentials and private/public keys. You hereby agree to provide true, accurate, current and complete information as may be prompted by any registration forms regarding your registration or use of Services. + +By creating an account and starting to use the Services you agree and accept unconditionally that: + +you cannot provide your credentials and private/public keys to others; +you will not share your credentials and private/public keys publicly. + +

Prohibited Conduct

+ +You may not use the Services in any manner that could damage, disable, overburden, or impair the servers and other resources of Network Operator and the Nodes, or interfere with any third party’s use of the Services. You may not attempt to gain unauthorized access to any aspect of the Services or to information for which you have not been granted access. + +By using the Services, you commit not to carry out any of these criminal and other illegal actions in or through the Services using our resources and/or resources of the Nodes: + +extortion, blackmail, kidnapping, rape, murder, sale/purchase of stolen credit cards, sale/purchase of stolen sale/purchase, sale/purchase of illegal sale/purchase, performance of identity theft; +use of stolen credit cards, credit card fraud, wire fraud, +hacking, pharming, phishing, or spamming of any form, web scraping through our Service in any form or scale; +exploitation of or contribution to children exploitation photographically, digitally or in any other way; +port scanning, sending opt-in email, scanning for open relays or open proxies, sending unsolicited e-mail or any version or type of email sent in vast quantities even if the email is lastly sent off through another server; +assaulting in any way or form any other network or computer while using the Service; +any other activities that are against the law of the country you originate from or reside in, and/or any other activities that are not compatible with the principles of democracy, freedom of speech, freedom of expression, and human rights. + +

Suspension or Termination of the Account

+ +Network Operator does not have an obligation to monitor the activities on the Mysterium Platform, and he does not carry out such monitoring actively. + +In the case Network Operator notices accidently or is notified of any suspicious activities using your Account that may result in violation of these T&C (see section “Prohibited Conduct” for more detail), in order to maintain the integrity of the Mysterium Platform Network Operator reserves the right (but not an obligation) to carry out any actions he considers necessary in the particular situation, including, but not limited to, the suspension and/or the termination of your Account immediately without any previous notification. + +Network Operator can terminate any Client account for the violation of these T&C immediately without notice or suspend the account until further clarification, investigation, or communication with the Client. + +

Limitation of Liability

+ +NEITHER THE NETWORK OPERATOR, NOR THE NODES WILL BE LIABLE IN ANY WAY OR FORM FOR ACTIONS DONE BY THE CLIENTS AND/OR ANY ACTIONS DONE USING CLIENT’S ACCOUNT INCLUDING CRIMINAL LIABILITY AND CIVIL LIABILITY FOR ANY HARM. SOLELY THE CLIENT IS LIABLE FOR ALL HIS ACTIONS USING THE SERVICES, THE SOFTWARE AND THE RESOURCES OF NETWORK OPERATOR AND OF THE RESOURCES THE NODES. + +NETWORK OPERATOR, ITS OWNERS, EMPLOYEES, AGENTS AND OTHERS THAT ARE INVOLVED WITH THE NETWORK OPERATOR ARE NOT IN ANY WAY OR FORM LIABLE FOR ANY HARM OF ANY SORT EXECUTED OR NOT EXECUTED, RESULTING FROM OR ARISING THROUGH OR FROM THE USE OF ANY ACCOUNT REGISTERED USING MYSTERIUM. + +IN NO EVENT WILL WE OR ANY OTHER PARTY WHO HAS BEEN INVOLVED IN THE CREATION, PRODUCTION, DISTRIBUTION, PROMOTION, OR MARKETING OF SOFTWARE AND/OR THE SERVICES BE LIABLE TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, INCIDENTAL, RELIANCE, EXEMPLARY, OR CONSEQUENTIAL DAMAGES, INCLUDING, WITHOUT LIMITATION, LOSS OF DATA OR PROFITS, OR FOR INABILITY TO USE THE SERVICE, EVEN IF WE OR SUCH OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. SUCH LIMITATION SHALL APPLY NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF ANY LIMITED REMEDY AND TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT, SHALL OUR AGGREGATE LIABILITY TO YOU AND ANY OTHER PARTY, WHETHER DIRECT OR INDIRECT, EXCEED ONE HUNDRED DOLLARS (${'$'}100.00) FOR ANY AND ALL CLAIMS, DAMAGES, AND OTHER THEORY OF LIABILITY. + +

No-logging and Traceability of Your Activities

+ +Network Operator guarantees a strict no-logs policy of the Services, meaning that your activities using the Services are not actively monitored, recorded, logged, stored or passed to any third party by the Network Operator. + +Network Operator does not store connection time stamps, used bandwidth, traffic logs nor IP addresses. Network Operator does not provide any information about their Clients and the fact of the use of Services by a particular Client to any third party. + +In the case Client’s use of Services constitute a breach of these T&C or respective legal acts and this causes legal risks for the Nodes whose resources Client was using, Network Operator might be obliged to provide the information related to such particular use of Services by the officially binding order of law enforcement authorities or other governmental agencies. As Network Operator does not trace the activities of their Clients, Network Operator would not be technically able to provide the authorities with more detailed information about their particular Clients activities. However, as Network Operator has no intention to contribute to any illegal and/or unauthorized activities, and/or to involve the Nodes in any of such, the Network Operator can cooperate with the authorities on his own account. + +Using the Services you agree and accept that Network Operator is free to take the decisions to provide any help and assistance including legal advice that Network Operator might find necessary or suitable to the Nodes who might need it in relation with a possible or an ongoing official investigation related to the use of their resources by the Clients. + +By using the Services you also agree and understand that your activities using the Services in some cases can be traceable by the Nodes and their internet service providers. + +In order to maintain the Services and to ensure the proper functioning of Mysterium, the Network Operator does collect limited and anonymized personal user information and site performance data (see section “Privacy Policy” for more details). + +

Data Privacy

+ +Network Operator is committed to your privacy and does not collect, log, organize, structure, store, use, disseminate or make otherwise available any personal data of the Clients, e.g. Client’s identity, IP address, browsing history, traffic destination, data content, DNS queries from the Clients connected to Mysterium Network, or any other personal information which could be considered personal data (i.e. any information relating to an identified or identifiable natural person). +Network Operator will collect anonymous statistics to improve the performance of Mysterium Network. This information is fully anonymized and cannot be tied back to any individual users. + +Limited License + +During your use of Services, we hereby grant you a personal, non-exclusive, non-transferable, non-assignable, non-sub-licensable, revocable and limited license to access and use the Services and to install a copy of the Software on your personal device. + +You fully understand and accept that the Software is licensed to you, not sold. + +Permission is granted to anyone to use this Software for any purpose, including commercial applications, and to alter it freely (without the right of redistribution), subject to the following restrictions: + +the origin of this Software must not be misrepresented; you must not claim that you wrote the original Software. If you use this Software in a product, an acknowledgment in the product documentation would be appreciated but is not mandatory; +altered versions must be plainly marked as such, and must not be misrepresented as being the original Software or any other creation of Network Operator, or the product created under any commission of Mysterium Platform; +this notice may not be removed or altered from any derivative works based on the Software. + +In any case, Network Operator does not bear any liability for any actions based on or related to the derivative works based on the Software. The users of such derivative works use them on their own account. + +Except as expressly indicated in these T&C or within any of the Services you may not: (i) sell, lend, rent, assign, export, sublicense or otherwise transfer the Software or the Services; (ii) alter, delete or conceal any copyright, trademark or other notices in connection with the Services or the Software; (iii) interfere with or impair the use of others of the Services or with any network connected to the Services; (iv) use the Services or the Software by yourself or in conjunction with any other products to infringe upon any third party's rights, including without limitation third party's intellectual property rights, to invade third party’s privacy in any way, or to track, store, transmit or record personal information about any other user of the Services or the Software; (v) otherwise violate applicable laws including without limitation copyright and trademark laws and applicable communications regulations and statutes. + +Any such forbidden uses shall immediately and automatically terminate your license to use the Software and the Services, without derogating from any other remedies available to us at law or in equity. + +Intellectual Property Rights + +The Software, including any versions, revisions, corrections, modifications, enhancements and/or upgrades thereto, accompanying materials, services and any copies you are permitted to make under these T&C are owned by us or our licensors and are protected under intellectual property laws, including copyright laws and treaties. You agree, accept and acknowledge that all right, title, and interest in and to the Software and associated intellectual property rights (including, without limitation, any patents (registered or pending), copyrights, trade secrets, designs or trademarks), evidenced by or embodied in or attached or connected or related to the Software are and shall remain owned solely by us or our licensors. These T&C do not convey to you any interest in or to the Software or any of the Services, but only a limited, revocable right of use in accordance with the terms of these T&C. Nothing in these T&C constitutes a waiver of our intellectual property rights under any law. + +Network Operator and Mysterium logos and trademarks owned by us or our licensors, and no right, license, or interest in any such trademarks is granted hereunder. We respect the intellectual property of others, and we ask you to do the same. It is important (and a condition of these T&C) that you comply with all copyright laws and other provisions in connection with any content agreement to which you may be a party through the Services. + +

Warranty Disclaimers

+ +THE SOFTWARE AND THE SERVICES ARE PROVIDED ON AN "AS IS" AND "AS AVAILABLE" BASIS, +WITHOUT ANY WARRANTY OF ANY KIND (INCLUDING SUPPORT OR OTHER SERVICES BY US OR OUR LICENSORES). YOU AGREE THAT YOUR USE OF THE SERVICES AND SOFTWARE SHALL BE AT YOUR SOLE RISK AND RESPONSIBILITY. TO THE FULLEST EXTENT PERMITTED BY APPLICABLE LAW, WE, OUR LICENSORS, OFFICERS, DIRECTORS, EMPLOYEES, AND AGENTS DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON INFRINGEMENT. WE DO NOT WARRANT THAT THE SOFTWARE OR SERVICES: (A) WILL BE ERROR OR DEFECT FREE OR OTHERWISE FREE FROM ANY INTERRUPTIONS OR OTHER FAILURES; (B) WILL MEET YOUR REQUIREMENTS; OR (C) THAT ANY ERROR WILL BE IMMEDIATELY FIXED; WE MAKE NO WARRANTIES OR REPRESENTATIONS ABOUT THE ACCURACY OR COMPLETENESS OF THE CONTENT (INCLUDING ANY USER CONTENT) OR TO ANY THIRD PARTY SITES OR APPLICATIONS OR CONTENT OR ANY PORTION OR COMPONENT OF EITHER AND ASSUME NO LIABILITY OR RESPONSIBILITY AND DISCLAIM ALL WARRANTIES FOR ANY (I) PROBLEMS OR AVAILABILITY OF INTERNET CONNECTIONS (II) ERRORS, MISTAKES, OR INACCURACIES IN SOFTWARE OR SERVICES, (III) PROPERTY DAMAGE, OF ANY NATURE WHATSOEVER, RESULTING FROM YOUR ACCESS TO AND USE OF THE SERVICES OR TO ANY THIRD PARTY SITE, (IV) ANY UNAUTHORIZED ACCESS TO YOUR DEVICE OR USE OF OUR SECURE SERVERS OR ANY AND ALL PERSONAL INFORMATION OR FINANCIAL INFORMATION STORED THEREIN, (V) ANY INTERRUPTION OR CESSATION OF TRANSMISSION REGARDING THE SERVICES, (VI) ANY BUGS, VIRUSES, TROJAN HORSES, OR OTHER MALICIOUS CODE WHICH MAY BE TRANSMITTED TO OR THROUGH THE SERVICES BY ANY THIRD PARTY, (VII) ANY LOSS OR DAMAGE OF ANY KIND INCURRED AS A RESULT OF THE USE OF ANY CONTENT POSTED, EMAILED, TRANSMITTED OR OTHERWISE MADE AVAILABLE VIA THE SERVICES. + +WE DO NOT WARRANT, ENDORSE, GUARANTEE, OR ASSUME RESPONSIBILITY FOR ANY PRODUCT OR SERVICES ADVERTISED OR OFFERED BY A THIRD PARTY THROUGH THE SERVICES OR ANY HYPERLINKED WEBSITE OR FEATURED IN ANY BANNER OR OTHER ADVERTISING, AND WE WILL NOT BE A PARTY TO ANY TRANSACTION OR OTHER ENGAGEMENT WITH SUCH ADVERTISING OR IN ANY WAY BE RESPONSIBLE FOR MONITORING ANY TRANSACTION BETWEEN YOU AND THIRD-PARTY PROVIDERS OF PRODUCTS OR SERVICES. YOU ASSUME ALL RISK AS TO THE QUALITY, FUNCTION, AND PERFORMANCE OF THE SERVICES, AND TO ALL TRANSACTIONS YOU UNDERTAKE ON THROUGH THE SERVICES. + +

Indemnification

+ +BY USING THE SERVICES YOU FULLY UNDERSTAND AND AGREE THAT IS AN EXPERIMENTAL VERSION OF THE MYSTERIUM PLATFORM, AND THERE IS A RISK THAT THE NETWORK OPERATOR OR OTHER THIRD PARTIES NOT DIRECTLY AFFILIATED WITH THE NETWORK OPERATOR, MAY INTRODUCE WEAKNESSES OR BUGS INTO THE CORE INFRASTRUCTURAL ELEMENTS OF THE MYSTERIUM PLATFORM CAUSING THE SYSTEM TO LOSE CRYPTOCURRENCY STORED IN ONE OR MORE CLIENT ACCOUNTS OR OTHER ACCOUNTS OR LOSE SUMS OF OTHER VALUED TOKENS ISSUED ON THE MYSTERIUM PLATFORM, OR CAUSING TO SUFFER OTHER LOSSES, INCONVENIENCE, OR DAMAGE TO ITS USERS. + +You hereby agree to indemnify, defend and hold us, our subsidiaries, parent corporation and affiliates, partners, sponsors and all of their respective officers, directors, owners, employees, agents, attorneys, licensors, representatives, licensees, and suppliers (collectively, "Parties"), harmless from and against any and all liabilities, losses, expenses, damages, and costs (including reasonable attorneys' fees), incurred by any of the Parties in connection with any claim arising out of your use of the Software or Services, any use or alleged use of your account, username, or your password by any person, whether or not authorized by you, your violation or breach of these T&C or your violation of the rights of any other person or entity. + +

Term and Termination

+ +These T&C become effective upon the installation of the Software until terminated by either you or us (the "Term"). You may terminate your relationship with us at any time by completely uninstalling the Software. In the case you fail to comply with these T&C or any other agreement you have concluded with us, this will terminate your Software license and this agreement. Upon termination of this agreement the Software license granted to you shall automatically expire and you shall discontinue all further use of the Software and Services. + +We have the right to take any of the following actions in our sole discretion at any time without any prior notice to you: (i) restrict, deactivate, suspend, or terminate your access to the Services, including deleting your accounts and all related information and files contained in your account; (ii) refuse, move, or remove any material that is available on or through the Services; (iii) establish additional general practices and limits concerning use of the Services. + +We may take any of the above actions for any reason, as determined by us in our sole discretion, including, but not be limited to, (a) your breach or violation of these T&C, (b) requests by law enforcement authority or other governmental agency, (c) a request by you, (d) discontinuance or material modification to the Services (or any part thereof), and (e) unexpected technical or security issues or problems. + +You agree that we will not be liable to you or any third party for taking any of these actions. + +

Miscellaneous

+ +The Software is intended for use only in compliance with applicable laws and you undertake to use it in accordance with all such applicable laws. Without derogating from the foregoing and from any other terms herein, you agree to comply with all applicable export laws and restrictions and regulations and agree that you will not export, or allow the export or re-export of the Software in violation of any such restrictions, laws or regulations. +By logging in to Mysterium and using the Services, you agree to the T&C, including all other policies incorporated by reference. + +These T&C and the relationship between you and Network Operator shall be governed by and construed in accordance with law of Panama. You agree that any legal action arising out of or relating to these T&C, Software or your use of, or inability to use, the Services shall be filed exclusively in the competent courts of Panama. + +You agree that these T&C and our rights hereunder may be assigned, in whole or in part, by us or our affiliate to any third party, at our sole discretion, including an assignment in connection with a merger, acquisition, reorganization or sale of substantially all of our assets, or otherwise, in whole or in part. You may not delegate, sublicense or assign your rights under these T&C. + +That is the whole agreement. Network Operator may rewrite the T&C from time to time. The T&C become binding from the time it is updated on our website. It is your responsibility to check for the new provisions of T&C periodically. + +

Contact us:

+ +For any questions you may contact us: team@netsys.technology + +Last update: 29-03-2018 + """.trimIndent() +} \ No newline at end of file diff --git a/android/app/src/main/java/network/mysterium/ui/Toast.kt b/android/app/src/main/java/network/mysterium/ui/Toast.kt new file mode 100644 index 000000000..515f54ad9 --- /dev/null +++ b/android/app/src/main/java/network/mysterium/ui/Toast.kt @@ -0,0 +1,26 @@ +/* + * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package network.mysterium.ui + +import android.content.Context +import android.widget.Toast + +fun showMessage(ctx: Context, message: String, duration: Int = Toast.LENGTH_SHORT) { + val t = Toast.makeText(ctx, message, duration) + t.show() +} diff --git a/android/app/src/main/java/network/mysterium/ui/UnitFormatter.kt b/android/app/src/main/java/network/mysterium/ui/UnitFormatter.kt new file mode 100644 index 000000000..d6e1d69cb --- /dev/null +++ b/android/app/src/main/java/network/mysterium/ui/UnitFormatter.kt @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +package network.mysterium.ui + +import kotlin.math.floor +import kotlin.math.roundToInt + +object UnitFormatter { + val KB = 1024 + val MB = 1024 * KB + val GB = 1024 * MB + + fun bytesDisplay(bytes: Double): String { + return when { + bytes < KB -> "$bytes B" + bytes < MB -> "%.2f KB".format(bytes / KB) + bytes < GB -> "%.2f MB".format(bytes / MB) + else -> "%.2f GB".format(bytes / GB) + } + } + + fun timeDisplay(seconds: Double): String { + if (seconds < 0) { + return "00:00:00" + } + + val h = floor(seconds / 3600).roundToInt() + val hh = when { + h > 9 -> h.toString() + else -> "0$h" + } + + val m = floor((seconds % 3600) / 60).roundToInt() + val mm = when { + m > 9 -> m.toString() + else -> "0$m" + } + + val s = floor(seconds % 60).roundToInt() + val ss = when { + s > 9 -> s.toString() + else -> "0$s" + } + + return "${hh}:${mm}:${ss}" + } +} diff --git a/android/app/src/main/java/network/mysterium/vpn/MainActivity.kt b/android/app/src/main/java/network/mysterium/vpn/MainActivity.kt deleted file mode 100644 index dc8e73f11..000000000 --- a/android/app/src/main/java/network/mysterium/vpn/MainActivity.kt +++ /dev/null @@ -1,159 +0,0 @@ -/* - * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -package network.mysterium.vpn - -import android.app.Activity -import android.content.ComponentName -import android.content.Context -import android.content.Intent -import android.content.ServiceConnection -import android.net.VpnService -import android.os.Bundle -import android.os.IBinder -import android.util.Log -import android.widget.Toast -import com.facebook.react.ReactActivity -import network.mysterium.service.core.MysteriumAndroidCoreService -import network.mysterium.service.core.MysteriumCoreService -import network.mysterium.vpn.connection.ConnectionChecker - -class MainActivity : ReactActivity() { - /** - * Returns the name of the main component registered from JavaScript. - * This is used to schedule rendering of the component. - */ - override fun getMainComponentName(): String? { - return "MysteriumVPN" - } - - private var mysteriumService: MysteriumCoreService? - get() = _mysteriumService - set(value) { - _mysteriumService = value - startIfReady() - } - private var _mysteriumService: MysteriumCoreService? = null - - private var vpnServiceGranted: Boolean - get() = _vpnServiceGranted - set(value) { - _vpnServiceGranted = value - startIfReady() - } - private var _vpnServiceGranted: Boolean = false - - private val serviceConnection = object : ServiceConnection { - override fun onServiceDisconnected(name: ComponentName?) { - Log.i(TAG, "Service disconnected") - mysteriumService = null - } - - override fun onServiceConnected(name: ComponentName?, service: IBinder?) { - Log.i(TAG, "Service connected") - mysteriumService = service as MysteriumCoreService - } - } - - private lateinit var connectionChecker: ConnectionChecker - - override fun onCreate(savedInstanceState: Bundle?) { - super.onCreate(savedInstanceState) - - bindMysteriumService() - ensureVpnServicePermission() - - connectionChecker = ConnectionChecker(applicationContext, CONNECTION_CHECKER_INTERVAL) - } - - override fun onResume() { - super.onResume() - connectionChecker.stop() - } - - override fun onPause() { - super.onPause() - connectionChecker.start() - } - - override fun onDestroy() { - unbindMysteriumService() - connectionChecker.stop() - super.onDestroy() - } - - override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { - when (requestCode) { - VPN_SERVICE_REQUEST -> { - if (resultCode != Activity.RESULT_OK) { - Log.w(TAG, "User forbidden VPN service") - showMessage("VPN connection has to be granted for MysteriumVPN to work.") - finish() - return - } - Log.i(TAG, "User allowed VPN service") - vpnServiceGranted = true - } - } - } - - private fun bindMysteriumService() { - Log.i(TAG, "Binding service") - Intent(this, MysteriumAndroidCoreService::class.java).also { intent -> - bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE) - } - } - - private fun unbindMysteriumService() { - Log.i(TAG, "Unbinding service") - unbindService(serviceConnection) - } - - private fun ensureVpnServicePermission() { - val intent: Intent? = VpnService.prepare(this) - if (intent == null) { - vpnServiceGranted = true - return - } - startActivityForResult(intent, MainActivity.VPN_SERVICE_REQUEST) - } - - private fun startIfReady() { - val service = mysteriumService ?: return - if (!vpnServiceGranted) { - return - } - - Log.i(TAG, "Starting node") - try { - service.StartTequila() - Log.i(TAG, "Node started successfully") - } catch (tr: Throwable) { - Log.e(TAG, "Starting service failed", tr) - } - } - - private fun showMessage(message: String) { - Toast.makeText(this, message, Toast.LENGTH_LONG).show() - } - - companion object { - private const val VPN_SERVICE_REQUEST = 1 - private const val TAG = "MainActivity" - private const val CONNECTION_CHECKER_INTERVAL: Long = 3000 - } -} diff --git a/android/app/src/main/java/network/mysterium/vpn/MainApplication.java b/android/app/src/main/java/network/mysterium/vpn/MainApplication.java deleted file mode 100644 index 6f6a43ec2..000000000 --- a/android/app/src/main/java/network/mysterium/vpn/MainApplication.java +++ /dev/null @@ -1,118 +0,0 @@ -/* - * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -package network.mysterium.vpn; - -import android.app.Application; -import android.util.Log; -import android.content.Context; -import com.facebook.react.PackageList; - -import com.facebook.react.ReactApplication; -import com.dieam.reactnativepushnotification.ReactNativePushNotificationPackage; -import com.oblador.vectoricons.VectorIconsPackage; -import com.facebook.react.ReactNativeHost; -import com.facebook.react.ReactPackage; -import com.facebook.soloader.SoLoader; - -import cat.ereza.logcatreporter.LogcatReporter; - -import com.crashlytics.android.core.CrashlyticsCore; -import com.crashlytics.android.Crashlytics; -import io.fabric.sdk.android.Fabric; -import network.mysterium.logging.BugReporterPackage; - -import java.lang.reflect.InvocationTargetException; -import java.util.List; - -public class MainApplication extends Application implements ReactApplication { - private static final String TAG = "MainApplication"; - - private final ReactNativeHost mReactNativeHost = new ReactNativeHost(this) { - @Override - public boolean getUseDeveloperSupport() { - return BuildConfig.DEBUG; - } - - @Override - protected List getPackages() { - @SuppressWarnings("UnnecessaryLocalVariable") - List packages = new PackageList(this).getPackages(); - packages.add(new BugReporterPackage()); - return packages; - } - - @Override - protected String getJSMainModuleName() { - return "index"; - } - }; - - @Override - public ReactNativeHost getReactNativeHost() { - return mReactNativeHost; - } - - @Override - public void onCreate() { - setupLogging(); - super.onCreate(); - SoLoader.init(this, /* native exopackage */ false); - // initializeFlipper(this); // Remove this line if you don't want Flipper enabled - Log.i(TAG, "Application started"); - } - - /** - * Loads Flipper in React Native templates. - * - * @param context - */ - private static void initializeFlipper(Context context) { - if (BuildConfig.DEBUG) { - try { - /* - We use reflection here to pick up the class that initializes Flipper, - since Flipper library is not available in release mode - */ - Class aClass = Class.forName("com.facebook.flipper.ReactNativeFlipper"); - aClass.getMethod("initializeFlipper", Context.class).invoke(null, context); - } catch (ClassNotFoundException e) { - e.printStackTrace(); - } catch (NoSuchMethodException e) { - e.printStackTrace(); - } catch (IllegalAccessException e) { - e.printStackTrace(); - } catch (InvocationTargetException e) { - e.printStackTrace(); - } - } - } - - private void setupLogging() { - // https://docs.fabric.io/android/crashlytics/build-tools.html?highlight=crashlyticscore - // Set up Crashlytics, disabled for debug builds - Crashlytics crashlyticsKit = new Crashlytics.Builder() - .core(new CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build()) - .build(); - - // Initialize Fabric with the debug-disabled crashlytics. - Fabric.with(this, crashlyticsKit); - - LogcatReporter.install(); - Crashlytics.setInt("android_sdk_int", android.os.Build.VERSION.SDK_INT); - } -} diff --git a/android/app/src/main/java/network/mysterium/vpn/connection/ConnectionChecker.kt b/android/app/src/main/java/network/mysterium/vpn/connection/ConnectionChecker.kt deleted file mode 100644 index 72b7c6402..000000000 --- a/android/app/src/main/java/network/mysterium/vpn/connection/ConnectionChecker.kt +++ /dev/null @@ -1,79 +0,0 @@ -/* - * Copyright (C) 2019 The "mysteriumnetwork/mysterium-vpn-mobile" Authors. - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -package network.mysterium.vpn.connection - -import android.content.Context -import android.content.Intent -import android.os.Bundle -import android.os.Handler -import android.util.Log -import java.lang.IllegalStateException - -/** - * Starts ConnectionCheckerService periodically at a given interval. - */ -class ConnectionChecker(private val context: Context, private val interval: Long) { - private var running: Boolean = false - - fun start() { - if (running) { - return - } - - Log.d(TAG, "Starting ConnectionChecker") - running = true - this.loopService(ignoreLastStatus = true) - } - - fun stop() { - if (!running) { - return - } - - Log.d(TAG, "Stopping ConnectionChecker") - running = false - } - - private fun loopService(ignoreLastStatus: Boolean) { - if (!running) { - return - } - startService(ignoreLastStatus) - - Handler().postDelayed({ this.loopService(ignoreLastStatus = false) }, interval) - } - - private fun startService(ignoreLastStatus: Boolean) { - Log.d(TAG, "Starting ConnectionCheckerService") - val service = Intent(context, ConnectionCheckerService::class.java) - val bundle = Bundle() - bundle.putBoolean("ignoreLastStatus", ignoreLastStatus) - service.putExtras(bundle) - try { - context.startService(service) - } catch (e: IllegalStateException) { - // We stop checker, because app is in a state where the service can not be started. - // This is usually because app was in the background for too long. - stop() - } - } - - companion object { - private const val TAG = "ConnectionChecker" - } -} diff --git a/android/app/src/main/res/drawable/background_logo.png b/android/app/src/main/res/drawable/background_logo.png new file mode 100644 index 0000000000000000000000000000000000000000..3a4023138ac08095fefe40f978ffe4086553cea5 GIT binary patch literal 143919 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�(crh(u5=R}Meps55?cZqiSiluso7*QtMb?01ir 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 + + + + + + + + + diff --git a/android/app/src/main/res/drawable/bordered_input_bg.xml b/android/app/src/main/res/drawable/bordered_input_bg.xml new file mode 100644 index 000000000..90e886ed4 --- /dev/null +++ b/android/app/src/main/res/drawable/bordered_input_bg.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/android/app/src/main/res/drawable/ic_arrow_back_24dp.xml b/android/app/src/main/res/drawable/ic_arrow_back_24dp.xml new file mode 100644 index 000000000..6343cdbb1 --- /dev/null +++ b/android/app/src/main/res/drawable/ic_arrow_back_24dp.xml @@ -0,0 +1,5 @@ + + + diff --git a/android/app/src/main/res/drawable/ic_arrow_downward_black_24dp.xml b/android/app/src/main/res/drawable/ic_arrow_downward_black_24dp.xml new file mode 100644 index 000000000..c31b7be6a --- /dev/null +++ b/android/app/src/main/res/drawable/ic_arrow_downward_black_24dp.xml @@ -0,0 +1,5 @@ + + + diff --git a/android/app/src/main/res/drawable/ic_help_outline_34dp.xml b/android/app/src/main/res/drawable/ic_help_outline_34dp.xml new file mode 100644 index 000000000..25614790e --- /dev/null +++ b/android/app/src/main/res/drawable/ic_help_outline_34dp.xml @@ -0,0 +1,5 @@ + + + diff --git a/android/app/src/main/res/drawable/ic_help_outline_black_24dp.xml b/android/app/src/main/res/drawable/ic_help_outline_black_24dp.xml new file mode 100644 index 000000000..850ca0eb7 --- /dev/null +++ b/android/app/src/main/res/drawable/ic_help_outline_black_24dp.xml @@ -0,0 +1,5 @@ + + + diff --git a/android/app/src/main/res/drawable/ic_public_black_24dp.xml b/android/app/src/main/res/drawable/ic_public_black_24dp.xml new file mode 100644 index 000000000..56a6e9b1f --- /dev/null +++ b/android/app/src/main/res/drawable/ic_public_black_24dp.xml @@ -0,0 +1,5 @@ + + + diff --git a/android/app/src/main/res/drawable/ic_search_white_34dp.xml b/android/app/src/main/res/drawable/ic_search_white_34dp.xml new file mode 100644 index 000000000..116da9b07 --- /dev/null +++ b/android/app/src/main/res/drawable/ic_search_white_34dp.xml @@ -0,0 +1,5 @@ + + + diff --git a/android/app/src/main/res/drawable/ic_star_black_24dp.xml b/android/app/src/main/res/drawable/ic_star_black_24dp.xml new file mode 100644 index 000000000..3c6fabaef --- /dev/null +++ b/android/app/src/main/res/drawable/ic_star_black_24dp.xml @@ -0,0 +1,5 @@ + + + diff --git a/android/app/src/main/res/drawable/ic_star_border_black_24dp.xml b/android/app/src/main/res/drawable/ic_star_border_black_24dp.xml new file mode 100644 index 000000000..e7d547918 --- /dev/null +++ b/android/app/src/main/res/drawable/ic_star_border_black_24dp.xml @@ -0,0 +1,5 @@ + + + diff --git a/android/app/src/main/res/drawable/notification_icon.png b/android/app/src/main/res/drawable/notification_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..57f545d20af04a8042b9bd2e73d8a2a3d3c90a85 GIT binary patch literal 3209 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 vyGgZJ + + + + + + diff --git a/android/app/src/main/res/drawable/proposals_filter_bg.xml b/android/app/src/main/res/drawable/proposals_filter_bg.xml new file mode 100644 index 000000000..57db345cb --- /dev/null +++ b/android/app/src/main/res/drawable/proposals_filter_bg.xml @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/android/app/src/main/res/drawable/quality_high.png b/android/app/src/main/res/drawable/quality_high.png new file mode 100644 index 0000000000000000000000000000000000000000..d6656bd94e68be847930cb9e89a45da5b2f3b738 GIT binary patch literal 1636 zcmeAS@N?(olHy`uVBq!ia0vp^2_VeD1|%QND7OGojKx9jP7LeL$-D$|I14-?iy0XB zj({-ZRBb+K1_llpi<;HsXMd|v6mX?tKo&&O01A4mfXs^2oCudpV1R;s0df^q33QFl`8oMT z!3BxQsUU}ewIB(hs|H&WiOU)!2_%gv$yUXsNm;4MB}lOaj5BcBcS=mxM-sNt$Ew-} zm=dgf^HVa@DqRvwQtgZk3@vpH40R1mLJSS83=FM|O>Feh)F8P4B;#C^npl!w6q28x zV+Zy{E{LmOtY@wVOeE+kpqg#;LHP(NUqLc0SQMCR?YMwCVI_ba7tN< zq=ND7&5gOU9R*kuZx%%7IsDzh_4P4Z$c!~?Y7ZVI%KSN8z+cW?$Lv;9{d%$k6Q{}q zRN{k3qrCsmMPF>~?e6b?@y6)?=il$Wm)Yxk@7gS^ap2siFF}lcIlH}CZ$!?E(>lNrs)alh8d=Z?IsFg(O7c8YUgnlpi<;HsXMd|v6mX?tKo&&O01A4mfXs^2oCudpV1R;s0df^q33QFl`8oMT z!3BxQsUU}ewIB(hs|H&WiOU)!2_%gv$yUXsNm;4MB}lOaj5BcBcS=mxM-sNt$Ew-} zm=dgf^HVa@DqRvwQtgZk3@vpH40R1mLJSS83=FNzfZjz@gX98`jB`l~Jle#0+fCb8HPZ!6K z3dXm$H|9z^2)G2EED(Lw+!}Q(?ARQ$SLHz0+jo-?hW@Jie&wzA|KHnh-S#)$|4iE8c8DL#3WM|B zEHiSo)R{tNJXd8pV>VToQR~cSA;z@Xr#cx#pH+4;Z1#QX(!lk3k4wYNWkpI3t(9>~ z2XcZf1s5E$(HBhEwsHn&(&siBPmFTKotoe7MK-pP`taXUeJt@_L}kz|+;wWt~$(69BBU BBRT*8 literal 0 HcmV?d00001 diff --git a/android/app/src/main/res/drawable/quality_medium.png b/android/app/src/main/res/drawable/quality_medium.png new file mode 100644 index 0000000000000000000000000000000000000000..e9a622ed098f9c6c8c9d51cfda248bd030eb8d6f GIT binary patch literal 1640 zcmeAS@N?(olHy`uVBq!ia0vp^2_VeD1|%QND7OGojKx9jP7LeL$-D$|I14-?iy0XB zj({-ZRBb+K1_llpi<;HsXMd|v6mX?tKo&&O01A4mfXs^2oCudpV1R;s0df^q33QFl`8oMT z!3BxQsUU}ewIB(hs|H&WiOU)!2_%gv$yUXsNm;4MB}lOaj5BcBcS=mxM-sNt$Ew-} zm=dgf^HVa@DqRvwQtgZk3@vpH40R1mLJSS83=FM|fNn=qgX98`jB`l~JJ}=+o0}GV9o-U3d z6^w6h8u}e^5MXd@{vpsP{7+wq{ri$;{*nh5R|uOwTvO&AuB#;PUeBpA!GQ^l@E811 zaf*NG{mR(uv(Kr0{%n&!v(9f?NxJ_6hU#gHr*j!3-QFG2V0-$aH>NcDg7niR3|z+gnhdu! z)L8>&RC+SraI@5GICRFF>wwuQPezfnxFCjYfqq;I3_ed{+R$4R#Lzl(x=2Irl*vpQ zXZ9>%$XPr`#3AvSDl5>aC*Q<3F0WY`^yUBbFY*bVhvzXd^qA^3sPa~GF&JFi!7$C_ zjV8l^h{sG3mo_YCU`X!ern{o;>WwTy9tx<$gO5!0p~YNNZnT%nfr@`mS3j3^P6lpi<;HsXMd|v6mX?tKo&&O01A4mfXs^2oCudpV1R;s0df^q33QFl`8oMT z!3BxQsUU}ewIB(hs|H&WiOU)!2_%gv$yUXsNm;4MB}lOaj5BcBcS=mxM-sNt$Ew-} zm=dgf^HVa@DqRvwQtgZk3@vpH40R1mLJSS93=FL-fDw(R2FV2=8Rw$Z#FG4?ko^1{ zJFqWuL0ko6J##&%USt(e%{Ka=e1w#*Aej~{3e2^3TtHi4C4e2*zb9%Tzyjr>r;B4q z1>@VB8*`Z)1Xu%a7kPh)XK=llm%tPj|F}W%&gHvZ=1PwqFZO5RRGHv_N*vhDQM2!~ z_|o@3YwYS@yfLb`k<*`97dx#aT|J;-?$eh`ndaOmo6faiv(4U+2I1T9f*8xDEuYR+ zkaRm%>%h5BUxFC@a&~*O-iVwRr*)t+w|pgo_36vrtQH&J>WL<#S5~cLP~UcUDbpJr ze|^yhN4D(_K^VHP+&?$|*Zcoj+wZrbP0l+XkK%={T# literal 0 HcmV?d00001 diff --git a/android/app/src/main/res/drawable/round_icon_button.xml b/android/app/src/main/res/drawable/round_icon_button.xml new file mode 100644 index 000000000..8dd5eba26 --- /dev/null +++ b/android/app/src/main/res/drawable/round_icon_button.xml @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/android/app/src/main/res/drawable/selector.xml b/android/app/src/main/res/drawable/selector.xml new file mode 100644 index 000000000..3108ff1e4 --- /dev/null +++ b/android/app/src/main/res/drawable/selector.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/android/app/src/main/res/drawable/service_openvpn.png b/android/app/src/main/res/drawable/service_openvpn.png new file mode 100644 index 0000000000000000000000000000000000000000..5ec1ec63c1ddaf16a6ef82c46e860028897d232c GIT binary patch literal 4717 zcmbVPc{G&&+kR%DA&e~zS;knBRMwDvH?n1|?6ND_Dn!N_#xkUd60&a*VTdx;C~IVk z>_iwPU%UBvU%xZQ>G!_pyyrdVbMDV|U)ObC_w&c|{P9E^>TA){a?k<*K#$f|Hv$0A zAp`+1$l>K)a^2+cf;y|{sQ^HE!pS{5s{c}bjI>mN(r(U00Du67x+WTj`fp;QWgWTxsY9cK>lQ38cL0>|6q$rSTnX~+GC zn4%u}DN{!hr5;WFXG`HJ;CRk)d}KIeDC80T=fB?#kK~s@hu^?~uaUkn&`-;GQF7U7 zVYagCp9eodkTXm)1JWZ>r^CEmh?ml~lZHZUYU^t1<-cX#_yE^Gx0#Pa(KVg;gXfr9 zdh?8Tugx@kKBHB`F^5Yv>NC-yaZu)QkJ}r@Yxo7fbrF^6{VT8Uuxd+2famnY(CfG9 zxNOz;p4eG$@Dy~8qnZOmH?sTQ%~@e!S==ueIuavUJ~1~p%;YVyO@N)~N$QWc9!%2f z99+FUn?>zA@M=}Hef7FhG45uLVWBhD4Oln}Zy#)KtwI``}4qS^3 zjnSx-FecVAd>%ujE6ne?xdfz0T;4 zcubv6TJ);DW31_e)XcB!in|I&ENI1|b$@$G%A=!iX>K)adW9todb^hBaj-7*^aN&u zXe`-jAROCsaL!#@-8H;}r61aO=&%mO7o3~3Tza(qmSzmb+>L*bO*W>hCG*hc)sRLKrZt)7 zN*^@h0>)&P=)K~0?OxXM{otHuAQM)n8SIA4PS@Dr8oAUpL;4Rk=NYmIZy%%!t;%F^ z)(Z%Dn2Ed2Wzq9z|JRAs2f#sGkxho8$j60PB?TqcS0z#=e=ql&ll(UAWmba)Ynd zV|<>P)-rn8mL;(JPj1R_;gym=k-eZ5MX-nHYn9ny+BZop!*Qj8k5@p zT+%Ep>VTnmyY2^zwkvoVq4cL`b3^=DnISIo`OKSvc~ z>4FA@Q;n)KAS#)c`-LFP{i7*x_*0|46a(vS1&u=f!sPI_GpGKHzkil^i!@G4JsveQ zq^&Y89Uv|-A(S!zd;L13zJlO8H~&3}PzW+J=W;c@!STXsrXr`SD6HSa`U?D!s{12F zi=9Z;=${hrRCYGZuicH%)L1m1qDM&0IRpb|%@<4iZrn5a=PYKi`k|>&N55dvKssJ> z)pXwu^TcWC4}UNuib!lu>LCkDKueMW;qoQhjMqD^Cj_tS1SEtJIs~%P?b_C2Eh|

Art?+~WMyLV)=IE~7?- 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 C9G{l} literal 0 HcmV?d00001 diff --git a/android/app/src/main/res/drawable/service_wireguard.png b/android/app/src/main/res/drawable/service_wireguard.png new file mode 100644 index 0000000000000000000000000000000000000000..87c373f7d3c3edab548cfddb63c584ccffa6d724 GIT binary patch literal 19549 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 literal 0 HcmV?d00001 diff --git a/android/app/src/main/res/drawable/spinner_input_arrow.png b/android/app/src/main/res/drawable/spinner_input_arrow.png new file mode 100644 index 0000000000000000000000000000000000000000..8e1949a7ea500d7751707e4244867ccda9baa0f9 GIT binary patch literal 1326 zcmZ`(U1-x#6wY)L*Ri3Z&`n`6`rycG!z+wdT-iov2=m_-0ytfJ?A^g$#|sy zOtY=cMi4}EUvFpt-FM-0=MHpjUnz;`R-X=p0|fE>X49J3fYyy_Z(JvcmIZv)-8t5> zA8{x-8iTR$Sx!>2w3t*z0BvMd#3l&d;Lu|hK#?@EnVilUKFVZp=o!NdMVb_N(MQF? z5i+P~fb60>X(uJvNRs5WWQrRI^;G0&<)cO+R5^wz6bf{~O)FZOVZB~2<8(1Dmjf{z z`dAK%h9jpRDsQsBPYCFeCaX|ZawOhY98vPnM^QM@#!;>l%BjsvIlW>F8DwyTVQD8* zO9l*i3mJ}VDN9NluGGAiF+C+E24p}M$!+*fJ`hTqlTI;SX5QbK(#QaWE5>s6(xWRGbI+Nnr)_uZgfv9JSL8ojw2KXUyK(nqDiFE;Es0 z>+qhprKaf8^{~75afie4i=3D#9(~<26!?_5EhXy5w++vEF8x{l?f=pq-}nCejp^y> zEB@6}FFdY?jSF=hMA0Bu=*e%x6Lw)S@v^tgo?3hWh>!5V@%cBSjc~OgIX3m#ADr~x fJM!wuwYh@?@vNHg46ccS + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/android/app/src/main/res/drawable/splash_logo.png b/android/app/src/main/res/drawable/splash_logo.png new file mode 100644 index 0000000000000000000000000000000000000000..a9fea89ab0f7d708341ac7f54cbad66581c4a3df GIT binary patch literal 22654 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 xtA5eh8Iu%*YO0N)RZ9hvN2#`sjQd{;{|`kR+^ literal 0 HcmV?d00001 diff --git a/android/app/src/main/res/layout/activity_main.xml b/android/app/src/main/res/layout/activity_main.xml new file mode 100644 index 000000000..daa7bc824 --- /dev/null +++ b/android/app/src/main/res/layout/activity_main.xml @@ -0,0 +1,20 @@ + + + + + + diff --git a/android/app/src/main/res/layout/fragment_feedback.xml b/android/app/src/main/res/layout/fragment_feedback.xml new file mode 100644 index 000000000..b6339d945 --- /dev/null +++ b/android/app/src/main/res/layout/fragment_feedback.xml @@ -0,0 +1,109 @@ + + + + + + + + + + + + + + + + + + + + + + diff --git a/android/app/src/main/res/layout/fragment_main_vpn.xml b/android/app/src/main/res/layout/fragment_main_vpn.xml new file mode 100644 index 000000000..4b3b6b59c --- /dev/null +++ b/android/app/src/main/res/layout/fragment_main_vpn.xml @@ -0,0 +1,325 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +