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,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAIAAADRv8uKAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAAB3tJREFUSMeVV21UlMcVfu7Mu+/uwrILrMaCH4AoKhy1KjVoIERPpBgTExNqLSZaP2ty1MQEjWlq/TiJ6Ikeo0Vj64/G2qbGJmpQU7WiVbRqISp+oJYoKmLwqAeWRfbrnZn+WEVYCcic+fHOnHvmmXvvc5+5L1WMzk7Y8tdaU8T4l9YeOnJK0xxKkRDeTvFxJfkDb//q1e7DBu+evOY3szZpmg0gw6jXHF0+XjBy7J7l9nC9cOTcNz8o1LjZEAodGUx1jrmRMUw/dfzg4fkf/vaXhuFRyg/wxyxJ4zAMV8/UITveS87ZPEcfMDB2/6EGsx0IgKhDqABYTtXQK+PfcU2bWLXg/Y8+fuXw0cXdYqMAt8ZZ8DAFMMYAv1eICdPH7k273m/T76JWr+v52YZPPtm/MG8bEC6E7DDw2UNHX9pw48tJf+DnT1WkDU1PtJy/uurlFzM8HnfQDSJm+Dywxm5ckrW6Yi0rP5t4rtzIyBqdtWbBgs3B+KqOhRkAGGD23b05f8lXv7bk1g1MP5ecYmzfunPX7M8KJgcCggM+jy8pJW7PDOfYv7wrnstOLDr4ddH1pG5z9v7rBJFFSqPDmMHMnSj7gYg44e69+30Gxfeou3G/uib8Z6lM0+r37buYnW3r2y/lYrm/7JRhtYcl9ZJS/ee7aglYLSZbhGXLn4/mL/uS8w5HW+u+aGrwq7vGPA3eK5qF6SbhcknG5b27HPBX3bg8YiSz20kYwu1mmpYYYSGCX6hOunRetQNOyFZQOSdAKUVStpIJOt4y7s3ZSQ+XIadKQAECLAryb6zfcvk8h0eAtbRSnBsmE/d6JWACQrGZBJomANVyouWmbPYhHy5DXSEAymTiubkZS5fmJCR0AQx6rN60Yd9sA0CMFOCqbQx4fZrdrixWCvgbT56oXrXaEhOTkL/cEIoxMjmd0h8w+xrCHOEBvzA5TAk7rqPgLHEdjwSEABkVFb5o0ZjevZ+qrLy3ceN+Ii2E+drb/40waczrMxoavHNmZKUO+EnD5QrPpg3OvPmIdqpVq7XISFvuG7qJ+2tu16xc6cx59QvfM4e2HenstFls1pKrtwG0TKICWG1t4+bNx9PSehYXVwAm9VjBEVGuUo0msq7+dMacuSNurVlrrFl+a/TrK+v7r8yyuqZOiE0b/O2kVRcu/PBpQW79nl1X35jse/bny/nzhdsPEDwKkYCltZDLsDCulDIMBAIqyBYiIkKQa0wpljH86as1m+a8OfzauFew9fPDs9Zl/9N2+MhFc5hZBq01tnb9P0aNWuN+etRPb1U9ZdT/6c4fN694zZk4BJCtyiUR83qVzwfDwEOOKqUMKQPBW7LfL5lw8NhCx+Xv/pfUW0V3WjL0w0lL/+2qqtAt4YYhBWAoCAHAUVRU1j/xva+/rUjYvUeMy31m3Vu7x2tDnk1VyqdpjDFi7NEVlHo0H9CYsT59YlJTe2oaB8CWLh7TuHKZa8rEW1Pef/nK4E0FO0xSAlZDSjOnaMBBYIwAoZvCXQ3+nNdWzZq5xTnvnR6Hjw49883U2gOADcJHFJDS3yLVD1GJCBAxMY7t2986cODdtLSegI9bD1Yf/6LwxPjFb2+5fvP8OY3bhQQguWbqFM5KS89ctsSXUrczZVVKMYBxbi4pvbDrqzJbv74Xe2fs3lV2qYHHxXfOnTjcMFBT42ot7AQop9M2btwgm828dWtJVVUtAVPAIyHqGAFklo80SAICiAACgAcwNzGIcyaED/AAOtMc0qjPz5+wcGH2vn3lL7ywTkpF1OLZYIyUglKBlJSuum4qL7/p8ylN47oSbmK6UFAtlI9xxiEbQaTILKVi7IH4CSEZ0xmzQCkpvIBeWnq9svJucXFF0LlQfssAQIyZysurAUWkB/k2E22OpusTCaV4851gGJUybDaTxWI2DKOuzkMUUrWyV68ubrfv9u06xjjwoJw4MATtDMG5xjkNGtT9zh03EZPSQAtlZoahGhv9fr8EtOaoRACMwsK5sbGOoqLTjJmbHgzWNiYRRUfbhXCFh6sVK34RFqaEqI+Otodor1IAuFIUolDB/WnTPi8oOAiYmz9TbXnMOZPSM3PmiHnzxkRF2WfPfq66uiEv78XISOvJkxc519UTdR50716d2+0FtObpbyvHRKSUBDzFxYvT03v5/Yaua0eOVGRmLgOsROzJgJtY3cK4rVArpRhjWVmpUVFhTZvR0eGjRg1hrH1UomAFQ0r1uPGPAjNGgJGSEjttWnpDg8/rDei65vUG7t/3TZ+enpwcCxjNNbI1YEUkfqzxbaecGIOUdUlJPc6ezS8puZaaGte//wfff3+TMYdss8ciIrudR0eHXbtWB/DHPW6nnDhnUqrMzAF1dY05OSu6do1xu8WlSzWc6612UnjYgVgs2vr1r8+fP7q8vKay8hZjoU+y1naehJCAfuzYlb17TwMReXl/j4iIAPQ2e8oHHUhKSmxyckxcnBNohRDtK1fwAoxxpYhISSla+8EJSRBJaWRm9o2P77Rz52mXq5GIhUA/EXBQgZUKhpGesHwZCyhlANZW7f8P5F+JjoWibAMAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTMtMTAtMDdUMTM6MTQ6MjQrMDI6MDAvXChbAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEzLTEwLTA3VDEzOjE0OjI0KzAyOjAwXgGQ5wAAAABJRU5ErkJggg=="), + "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,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAIAAADRv8uKAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAACJdJREFUSMetl2lwVUUWx8/p7re/l7wsJGR5SQhLkgEFhQyJaIKIQEA2iZAadEYZJE4haLTKIYoMChIQCnDcA06JaJShUBlEU4ASQJZRtkAWNGFJQghJIOvb7+0+8yEwAjpVjHg+9u1bv3v+5/T/9MWarHti3l1nTU1ZWPh50fLPCFAIKwDpenfmuHtKp4sTs2a7bkupevnD8VPfYsyIiEBBqQIDs0e8NsEaueo517SJ66InLFj8meA2XSq4uWCBgUMvT81pXr3mlaIp+79fOigtQdc7EQmAXbeRAAAFRym7WUhYQcHkTxMPx7/5YtzateFvrW9xKwAFeJNQAACWcyB+V94S+mLL6Yz0oQ5PedXLS5Y+LJgC8HL2ExsZA9CCmj99bHbp032e3fm8MehJqa5ik6bPnLl+9aovEe26frPpAoA4X370zyesE/PyF8XU0OiR5kdmLVy27KG89BmT/+73exAdAICIMugHa/jSeRmPnNmilxy1rXnDOT7ng43fFczb0NbZjmgnov8jXwBmD40Kcdi2fVw2aYdj3zPr/UcOV2be1Y93HTr6t6LleV5vUAAEfMHktMTdLw15fN+rFNEr+WS1NmLU9OnFf/pjsSfInOExBqOxpxg3H3j+dBMACMG83d4gN/XrH61VVSiTxRQfx63WltdfPzN/vs3lGlhZoS61BHy69XepqAVbGtta23wRETZNk+Fh1ldW7ChauU0I282rLdz3ZwAAETCGDKjKp6HNBlIqv18hA49bAGhNF06mpKHFwhCUxwOMGYzCZOCdUumEBh4Mtg0AGAgyCIAAwBkSEAAxZIpAqV8QQ3ScqbtO+hsEAUAA0mWw6cK16/6rykpgHJQfogAYEQEgYyiVn3MDkVmXHgAAMPwC2GQ2/xfCOdN1SVIBEBpNSkrUddJ1QGTCAACMMxCCgkGOgIIrSTqgCf1cE6ADAgIQYzgt964klyU73Ve6233w++5jxy+on1VADDhZQQCCM12qzk6f0240hoUSN/hrahwpyRfffa+usNASE5O6t4zbbP72bnB3mV3xbg0DLa3OcLs/KEMirJErymBVKTPYQNOeezb9hdmNyl0uO/aOefo+t+nBrElQUVHHmPFazcXgySVC8I4OL0d4cdGE/FmZ3vrzrfNmW3pFnC1YHh0WQQAmq/kiORAdrrTYxhUr3ZtKZMGLiw+bd27+NswmzHZLy4V2AJOmS5s9JGNootX9dv3Z41zYQy17ulR/o8n+c6l5x+WE1ov1cZHODSVzHpx4W2PRCve82b7h9z7VkPrJjprHBmHTv76IjI8uH5A1avSaAX2jMvIfMsTEdBbMHWVrxcyROw/WNddVB3xEREmumDFP6pvLy7Z/qy3b1PLxIahtC9t5MH3HzotK3XjOmZEblyx57FTt8t87faeHp8Ou7d88tmrM7uit28sEIjEOAERkMJrc3d0PzXhtypS3PXePHVR/ztYr7KmdC3c/5cqePEEpgcDrG5prvgoz0qVtlXsbW+SPDYHXNpw92Pn5/TkuAMXYdY7KjlUvX7hw/IXnC5tyRneNfGBubP6sl/Y0VVYC2JUCvGoLpAhAGA2OrVsPpCUWFP/ju4R1653rPui95Z3N5m0zc5IJpAJ1rtaTM2qOISl3wdr1kZnzXij+yJqScuRUEwAnuK7BRLL7XNUdo0WYs/TRtYvfr24/9yXndkArqC4CAEAGwHpOFZCUinOH26vlz3m75IMD6z6c0/dkte/5Z+Le2gqY/ugwGBhrmB/nsjrHjQtEDR2S2dcdwtqHNEee63bYtlRqQX8Ark4S7GOYykniwLtrqmpRCzBukVdGm7LarYmhGGysFxabv1dcXX1bz2uIyBhK6bFbLUn9XAZnaP3RU5c1tidhj7nXyc4TzDZeBfaD0cLabcRshrRKeSn1rqyaDH/bZUTRU2xxVsYAMCiv5Myk0Cx/GqjM6/ZWuwEgFnwS6lsBxBXZiaQkzm0en6w4UYuoiIymEEeX32Dqw0KGmTvv1MJTWdBAseHYUcHOW3R/MyMguGZwCkY6EAEzS0U3Gj0yBgAUBABghhucT0qFiIyZEUFKXTDmkW55TDkeCNBB6T3NvXZiUcq+z9oVqzqxk8nrm0sRKMBftFMguPL0f2wgAqVIKQJACgbv2VicnpUX+kl89thNUc1DEzuyb8/6yHg+ZPCQucPWvqF5PddlDL9BIABYDGxNW8LEv5akLzj0zqXbZnyT49eg+KJ4/GjUfnZv6aHTVgN0ab8puKd0vqD+4w/n19Rsbzi+scHbu2TYXJ34pYr31svqpMEzIp13I8erX0m/AZghMCSdmAHk4rF9ImPYlH2Fy6YP6ZeZLoShqXxXUfGnq2emohzw1VIB4OOIClARcYChtyizIjklN+qflq+3frhvkXHE9HunrTxg781OVdQcffVAZH7e/MJdLCT/LyunddYkDf6hqgtQArBfnzFDUARpEWxERp/chyuCG/QF+YrHtn9VecfWJx25T+T6A75P3txUuDv5mezvZkrjKWx94eG2flrfr8ubK+u62K2AAdjwaFnE9gOmHhvpxPGx4+x89RjnxkrHHybdlzdx9Pa68PemxtyhmumJhO2S88bAYtg75PZYAA0B5vxaMCrSkuKjjr98JnQa+/6Av+50sxfu+2JfXGWoyxPem3MR1t7Yv+PCsP5HXM5/Z41J7W3odB9JH7RI1NXU/nowXG3QqTMSJmWZa+tC05Kb+kaXna0PejyJWnSq02GGph+8vqrM4VE/No4qr1CpqeKzMr7p/cOI/JbAAIAIRDqiIPLb7ZG5k6NH3NkQam2ICA3ExYa0ux1Nl5NK90Z8vPlMd9clRBORD9FMBLcKBgDOseeXR0qNiDgPiY2xRkQIzkVbu6pv6JB6O6LgXAARAUpJPWrdKvja7DlDqSSRArji/IiCcy7ljTeQ/wBc5gKe3mD2HgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDo1MiswMjowMEZJFHgAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6NTIrMDI6MDA3FKzEAAAAAElFTkSuQmCC"), + "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,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"), + "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,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"), + "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,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"), + "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,iVBORw0KGgoAAAANSUhEUgAAACgAAAAeCAIAAADRv8uKAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAAASAAAAEgARslrPgAABzhJREFUSMe1lnlwVWcZxp9vOffcNblkg5AiEEIKLRCRNFiMMA4MoYAsslaBDlqWmYqyamug0Ka0bGOBApMyKlpSFimIiNDaBqyUkSUJSxILFwIJIRAg4ebe5G7nnO/7/CPE0mVqGOM7549vvvPO/N5n3ud9zyFVw3JTNm11ZQ14ecWhN1YfEEpx7iIEptk0+tnRewbXly1c9vjw3PdnbZj93BbO3VCQIixhGzl12Gu9atnWtX0K8ueXJu185xhnbktItC9oY//vND03rf6VVQUF485UrMvJzrSsACAA9qVkwqi0RHNSZp9NL353m/8P3uIDT5447vzZslt1AYCqdjJbwaOOeoryVlgXztUMGtDXf+n02fzC3/w0zq0DzZSSz/IoASJCd816fnTx8LsT/7TSO3ZM79Nny6yUrP6riosvEuIQ7ZYLgPuvXXxpXUXR08NfGRJ6YuYsPTtn3o7tEyesmTVlq2VEiVIACGBEI10ey3j7R6mDjq01u3RLLT7R6E19dur2Pfs+JIQBHqUeSTDIoNw3GYW/scWe2mXJ3JyRZbuCFyvTt73FuveoDsKxefX1FctTcrL1wyfUn/faD+1i8xYmjnmm3NewZMl7vqv3kpI8XGO+ihv+e35CePvxJFpyVgGcUytmBCPCk9ZF3rtrRaLUbnenpdSu2XC7sNCV+XjmH3eZ/oCM66S5naKxMRwxdYfN5dKjMcsVr/9w4Qe7j1ZyZrdEu8Fn/3MCKCCA1sYqQAG07a1su28NBihAAgLEC7WYDj8in2CIis9lfW2PjYer+JKVFUDainhYiwW0GkkARtv5kYJnzpj64MSpYYhgIKyE4F6v5JqKhGMVFeHLl7X4ePfQocISjHOe4JWGqUVaPPFOIWFJlaArz9/duGaAELTbYfwfM15jlBBKGu61pKV68oalA2i5UE6rLzvHT779+hvB/F+5e/XKOHQIgIhG/Yf/Gp/RoyZj0AfvV3p1cLvudNruVB/AtXOgTrR7ovikUQWEGkpGh+Q8Vbj7BRlqqf35Qr3kxOms8Reqkl9gEECcRz948Hx11Z2FS/Lsdv6v70+0Mp8s7z5p2/5KK3gdxAnlBB5tjimg0jqnHTy8+uTp/B4Xim8O/pYZjW0a8eqEosip01d1h00AjPNgS3jR0rfz8jbfyvpeVm1NWna/X5xZc3J+4pjpk8C8BBIAIWBU/deHEADgCxaNX7VmcsL9uuujR3F/w6kJS1cUx3zvHgXClNtNoQRgSSUEBTwfFZf1T7/w4vIfLF+7HrNnx+bM2ULJ2MU/zn+36n5dPcCE1FrFtJnyC0EAC7AAyjf/enKk8M3ajZv9I6asa8nau+EUYk26LS5mmFIpN0Ui4KWtK1NqLM4S1qurdu3Z+cm2HXOGnzgZLtoxf+dbJx1ZRaAzpn9z7sy4QDDAqKYgoRiUIvQzqpSWy5O4dOXVkhIfX5Q9L1J63DFtwZ5jZv2nRxh1Keo2TAHYqipuFARCt5GeWJ3sO3ge0ExLKAXO433X6kcMXTVtSm72Mzmh9HllHx8HPOk9SG7WIqMyautkQDigt4BKZRCiyJ06pjtJvCdGuj2VnDILkHxjqQAbi72VBIKxOCFk21jqvvKqgnICjENVDFX/BOxSKgCWJSjVQbB33yd79xUDLs6TgLBlKQREw5Uuds0umke4eu+3JdQ21PM71bb6Wpumk5Susb42BaUAUE45E82caSD2z9tSEaJxyhlaOLEYczzcMymVlIoxF9cSObMRmABhFJDcoROPeEwXGaThaUJgxZgQtKHGGbirKwnLpA/MZUkFUHzVjlVKWQoAhcJXDqgQEqJ1+RAAiigIjRkOIbzcFk/C3ZSAO96kClc05XKLzmnQ7Q8+IxQdFkoKAt1kPStIXIURCYqES0LBE0dS02OelFhy91hyKuBWorXWDgQ3hxRgs7mk6lql2bYFU3zn53Rt7hmZ+HJTKMjCQSUtMEsPhUWHgZUCIG/USSABVh3TDVufymuVhPhct4KmESL9B4fsLlAK00iqvxMDSAeCUXE5HDMybLTcAmURcZR1OrKAtDgT0kV43JCQaTCicP1+z5obAYB1TI+lVATa1Ut3S2oGEic0iHsGLzI89TmR0gHYGEhAC6ywgNvzYVm6FW3gTOswc1HGgYbt7yWj00BYsjTm9JvUESP2mCwx7LeE3UFgaiN/u9sEYvLhhfY/hhAK0N4p8n306UwkkVMBWzO4qREnl83KXtKk0K3zlr/knSu5xKhdStWB4wRKNYjG5xdHA+qlgQmNVETrlSOk9GTjbr9v2M768n+58gpgSUUAEGBuh7KplKG+/Qb87XdmimP9mWq/nSG7d/rHlcvG/+RmoPEmIQ6lZMeDATBGhQjFJ/csfK3X9FH7hZHw+u9HrFxfCuM+oQ4pH2zAjge36oaKSmX7dm5WUyB6qbycMSqlrVXr/xEMgFJCiBIiDBDGnFLiC//6/wbpyX5GRbA9AgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxMy0xMC0wN1QxMzoxNDozOCswMjowMCRWQrEAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTMtMTAtMDdUMTM6MTQ6MzgrMDI6MDBVC/oNAAAAAElFTkSuQmCC"), + "tv" to CountryFlag("Tuvalu", "data:image/png;base64,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"), + "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,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"), + "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 000000000..3a4023138 Binary files /dev/null and b/android/app/src/main/res/drawable/background_logo.png differ diff --git a/android/app/src/main/res/drawable/background_splash.xml b/android/app/src/main/res/drawable/background_splash.xml new file mode 100644 index 000000000..8c32c102c --- /dev/null +++ b/android/app/src/main/res/drawable/background_splash.xml @@ -0,0 +1,12 @@ + + + + + + + + + + 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 000000000..57f545d20 Binary files /dev/null and b/android/app/src/main/res/drawable/notification_icon.png differ diff --git a/android/app/src/main/res/drawable/proposal_picker_bg.xml b/android/app/src/main/res/drawable/proposal_picker_bg.xml new file mode 100644 index 000000000..ec57deb22 --- /dev/null +++ b/android/app/src/main/res/drawable/proposal_picker_bg.xml @@ -0,0 +1,7 @@ + + + + + + + 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 000000000..d6656bd94 Binary files /dev/null and b/android/app/src/main/res/drawable/quality_high.png differ diff --git a/android/app/src/main/res/drawable/quality_low.png b/android/app/src/main/res/drawable/quality_low.png new file mode 100644 index 000000000..73a91bdf4 Binary files /dev/null and b/android/app/src/main/res/drawable/quality_low.png differ 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 000000000..e9a622ed0 Binary files /dev/null and b/android/app/src/main/res/drawable/quality_medium.png differ diff --git a/android/app/src/main/res/drawable/quality_unknown.png b/android/app/src/main/res/drawable/quality_unknown.png new file mode 100644 index 000000000..fdff94167 Binary files /dev/null and b/android/app/src/main/res/drawable/quality_unknown.png differ 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 000000000..5ec1ec63c Binary files /dev/null and b/android/app/src/main/res/drawable/service_openvpn.png differ 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 000000000..87c373f7d Binary files /dev/null and b/android/app/src/main/res/drawable/service_wireguard.png differ 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 000000000..8e1949a7e Binary files /dev/null and b/android/app/src/main/res/drawable/spinner_input_arrow.png differ diff --git a/android/app/src/main/res/drawable/spinner_input_bg.xml b/android/app/src/main/res/drawable/spinner_input_bg.xml new file mode 100644 index 000000000..27a2a152c --- /dev/null +++ b/android/app/src/main/res/drawable/spinner_input_bg.xml @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + + + \ 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 000000000..a9fea89ab Binary files /dev/null and b/android/app/src/main/res/drawable/splash_logo.png differ 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 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +