commit 05f75d9d6dc825aaaa9fe186435f9dead635abda Author: Eric85710 Date: Sun Apr 19 21:36:53 2026 +0800 re-init repo diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..aa724b7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,15 @@ +*.iml +.gradle +/local.properties +/.idea/caches +/.idea/libraries +/.idea/modules.xml +/.idea/workspace.xml +/.idea/navEditor.xml +/.idea/assetWizardSettings.xml +.DS_Store +/build +/captures +.externalNativeBuild +.cxx +local.properties diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/.idea/.name b/.idea/.name new file mode 100644 index 0000000..3863488 --- /dev/null +++ b/.idea/.name @@ -0,0 +1 @@ +Login_V3 \ No newline at end of file diff --git a/.idea/AndroidProjectSystem.xml b/.idea/AndroidProjectSystem.xml new file mode 100644 index 0000000..4a53bee --- /dev/null +++ b/.idea/AndroidProjectSystem.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/.idea/compiler.xml b/.idea/compiler.xml new file mode 100644 index 0000000..b86273d --- /dev/null +++ b/.idea/compiler.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/deploymentTargetSelector.xml b/.idea/deploymentTargetSelector.xml new file mode 100644 index 0000000..18f19f7 --- /dev/null +++ b/.idea/deploymentTargetSelector.xml @@ -0,0 +1,18 @@ + + + + + + + + + \ No newline at end of file diff --git a/.idea/deviceManager.xml b/.idea/deviceManager.xml new file mode 100644 index 0000000..91f9558 --- /dev/null +++ b/.idea/deviceManager.xml @@ -0,0 +1,13 @@ + + + + + + \ No newline at end of file diff --git a/.idea/gradle.xml b/.idea/gradle.xml new file mode 100644 index 0000000..02c4aa5 --- /dev/null +++ b/.idea/gradle.xml @@ -0,0 +1,18 @@ + + + + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 0000000..7061a0d --- /dev/null +++ b/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,61 @@ + + + + \ No newline at end of file diff --git a/.idea/migrations.xml b/.idea/migrations.xml new file mode 100644 index 0000000..f8051a6 --- /dev/null +++ b/.idea/migrations.xml @@ -0,0 +1,10 @@ + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..b2c751a --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,9 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/runConfigurations.xml b/.idea/runConfigurations.xml new file mode 100644 index 0000000..16660f1 --- /dev/null +++ b/.idea/runConfigurations.xml @@ -0,0 +1,17 @@ + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.kotlin/errors/errors-1770981180878.log b/.kotlin/errors/errors-1770981180878.log new file mode 100644 index 0000000..1219b50 --- /dev/null +++ b/.kotlin/errors/errors-1770981180878.log @@ -0,0 +1,4 @@ +kotlin version: 2.0.21 +error message: The daemon has terminated unexpectedly on startup attempt #1 with error code: 0. The daemon process output: + 1. Kotlin compile daemon is ready + diff --git a/.kotlin/errors/errors-1774944280303.log b/.kotlin/errors/errors-1774944280303.log new file mode 100644 index 0000000..1219b50 --- /dev/null +++ b/.kotlin/errors/errors-1774944280303.log @@ -0,0 +1,4 @@ +kotlin version: 2.0.21 +error message: The daemon has terminated unexpectedly on startup attempt #1 with error code: 0. The daemon process output: + 1. Kotlin compile daemon is ready + diff --git a/.kotlin/errors/errors-1776328136425.log b/.kotlin/errors/errors-1776328136425.log new file mode 100644 index 0000000..54b936e --- /dev/null +++ b/.kotlin/errors/errors-1776328136425.log @@ -0,0 +1,34 @@ +kotlin version: 2.0.21 +error message: kotlin.UninitializedPropertyAccessException: lateinit property cleanFilenames has not been initialized + at com.google.devtools.ksp.AbstractKotlinSymbolProcessingExtension.getCleanFilenames(KotlinSymbolProcessingExtension.kt:128) + at com.google.devtools.ksp.AbstractKotlinSymbolProcessingExtension.doAnalysis(KotlinSymbolProcessingExtension.kt:234) + at org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(TopDownAnalyzerFacadeForJVM.kt:112) + at org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration$default(TopDownAnalyzerFacadeForJVM.kt:75) + at org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler.analyze$lambda$12(KotlinToJVMBytecodeCompiler.kt:373) + at org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport.analyzeAndReport(AnalyzerWithCompilerReport.kt:112) + at org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler.analyze(KotlinToJVMBytecodeCompiler.kt:364) + at org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler.runFrontendAndGenerateIrUsingClassicFrontend(KotlinToJVMBytecodeCompiler.kt:195) + at org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler.compileModules$cli(KotlinToJVMBytecodeCompiler.kt:106) + at org.jetbrains.kotlin.cli.jvm.K2JVMCompiler.doExecute(K2JVMCompiler.kt:170) + at org.jetbrains.kotlin.cli.jvm.K2JVMCompiler.doExecute(K2JVMCompiler.kt:43) + at org.jetbrains.kotlin.cli.common.CLICompiler.execImpl(CLICompiler.kt:103) + at org.jetbrains.kotlin.cli.common.CLICompiler.execImpl(CLICompiler.kt:49) + at org.jetbrains.kotlin.cli.common.CLITool.exec(CLITool.kt:101) + at org.jetbrains.kotlin.daemon.CompileServiceImpl.compile(CompileServiceImpl.kt:1555) + at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(Unknown Source) + at java.base/java.lang.reflect.Method.invoke(Unknown Source) + at java.rmi/sun.rmi.server.UnicastServerRef.dispatch(Unknown Source) + at java.rmi/sun.rmi.transport.Transport$1.run(Unknown Source) + at java.rmi/sun.rmi.transport.Transport$1.run(Unknown Source) + at java.base/java.security.AccessController.doPrivileged(Unknown Source) + at java.rmi/sun.rmi.transport.Transport.serviceCall(Unknown Source) + at java.rmi/sun.rmi.transport.tcp.TCPTransport.handleMessages(Unknown Source) + at java.rmi/sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.run0(Unknown Source) + at java.rmi/sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.lambda$run$0(Unknown Source) + at java.base/java.security.AccessController.doPrivileged(Unknown Source) + at java.rmi/sun.rmi.transport.tcp.TCPTransport$ConnectionHandler.run(Unknown Source) + at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source) + at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source) + at java.base/java.lang.Thread.run(Unknown Source) + + diff --git a/app/.gitignore b/app/.gitignore new file mode 100644 index 0000000..42afabf --- /dev/null +++ b/app/.gitignore @@ -0,0 +1 @@ +/build \ No newline at end of file diff --git a/app/build.gradle.kts b/app/build.gradle.kts new file mode 100644 index 0000000..28f4073 --- /dev/null +++ b/app/build.gradle.kts @@ -0,0 +1,91 @@ +plugins { + alias(libs.plugins.android.application) + alias(libs.plugins.kotlin.android) + alias(libs.plugins.kotlin.compose) + + // 1. 加入 Hilt 與 KSP 插件 + alias(libs.plugins.ksp) + alias(libs.plugins.hilt) +} + +android { + namespace = "com.example.login_v3" + compileSdk = 36 + + defaultConfig { + applicationId = "com.example.login_v3" + minSdk = 34 + targetSdk = 36 + versionCode = 1 + versionName = "1.0" + + testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" + } + + buildTypes { + release { + isMinifyEnabled = false + proguardFiles( + getDefaultProguardFile("proguard-android-optimize.txt"), + "proguard-rules.pro" + ) + } + } + compileOptions { + sourceCompatibility = JavaVersion.VERSION_17 + targetCompatibility = JavaVersion.VERSION_17 + } + kotlinOptions { + jvmTarget = "17" + } + buildFeatures { + compose = true + } +} + +dependencies { + implementation(libs.androidx.core.ktx) + implementation(libs.androidx.lifecycle.runtime.ktx) + implementation(libs.androidx.activity.compose) + implementation(platform(libs.androidx.compose.bom)) + implementation(libs.androidx.compose.ui) + implementation(libs.androidx.compose.ui.graphics) + implementation(libs.androidx.compose.ui.tooling.preview) + implementation(libs.androidx.compose.material3) + implementation(libs.volley) + implementation(libs.androidx.compose.foundation) + testImplementation(libs.junit) + androidTestImplementation(libs.androidx.junit) + androidTestImplementation(libs.androidx.espresso.core) + androidTestImplementation(platform(libs.androidx.compose.bom)) + androidTestImplementation(libs.androidx.compose.ui.test.junit4) + debugImplementation(libs.androidx.compose.ui.tooling) + debugImplementation(libs.androidx.compose.ui.test.manifest) + + + implementation("androidx.compose.material:material-icons-extended:") + implementation("io.coil-kt:coil-compose:2.5.0") + implementation("io.coil-kt:coil-svg:2.5.0") + implementation("androidx.core:core-splashscreen:1.2.0") + implementation("com.google.android.material:material:1.10.0") + implementation("androidx.compose.material3:material3:1.2.0") + implementation(libs.androidx.compose.animation) + implementation(libs.androidx.navigation.compose) + + //retrofit + implementation("com.squareup.retrofit2:retrofit:2.11.0") + implementation("com.squareup.retrofit2:converter-moshi:2.11.0") + + //json stuff + implementation("com.squareup.moshi:moshi-kotlin:1.15.0") + implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0") + + //加入 Hilt 核心與編譯器 + implementation(libs.hilt.android) + ksp(libs.hilt.compiler) // 使用 ksp 取代 kapt，效能更好 + + //加入 Compose 專用的 Hilt 導覽支援 (這對導覽注入非常重要) + implementation(libs.hilt.navigation.compose) + + +} \ No newline at end of file diff --git a/app/proguard-rules.pro b/app/proguard-rules.pro new file mode 100644 index 0000000..481bb43 --- /dev/null +++ b/app/proguard-rules.pro @@ -0,0 +1,21 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile \ No newline at end of file diff --git a/app/src/androidTest/java/com/example/login_v3/ExampleInstrumentedTest.kt b/app/src/androidTest/java/com/example/login_v3/ExampleInstrumentedTest.kt new file mode 100644 index 0000000..fa3b0bf --- /dev/null +++ b/app/src/androidTest/java/com/example/login_v3/ExampleInstrumentedTest.kt @@ -0,0 +1,24 @@ +package com.example.login_v3 + +import androidx.test.platform.app.InstrumentationRegistry +import androidx.test.ext.junit.runners.AndroidJUnit4 + +import org.junit.Test +import org.junit.runner.RunWith + +import org.junit.Assert.* + +/** + * Instrumented test, which will execute on an Android device. + * + * See [testing documentation](http://d.android.com/tools/testing). + */ +@RunWith(AndroidJUnit4::class) +class ExampleInstrumentedTest { + @Test + fun useAppContext() { + // Context of the app under test. + val appContext = InstrumentationRegistry.getInstrumentation().targetContext + assertEquals("com.example.login_v3", appContext.packageName) + } +} \ No newline at end of file diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml new file mode 100644 index 0000000..c0fefd4 --- /dev/null +++ b/app/src/main/AndroidManifest.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/MainActivity.kt b/app/src/main/java/com/example/login_v3/MainActivity.kt new file mode 100644 index 0000000..734c7f2 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/MainActivity.kt @@ -0,0 +1,22 @@ +package com.example.login_v3 + +import android.os.Bundle +import androidx.activity.ComponentActivity +import androidx.activity.compose.setContent +import androidx.activity.enableEdgeToEdge +import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen +import com.example.login_v3.auth.HealthCheckScreen +import dagger.hilt.android.AndroidEntryPoint + +@AndroidEntryPoint +class MainActivity : ComponentActivity() { + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + enableEdgeToEdge() + + installSplashScreen() + setContent { + Technologia() + } + } +} diff --git a/app/src/main/java/com/example/login_v3/MyApplication.kt b/app/src/main/java/com/example/login_v3/MyApplication.kt new file mode 100644 index 0000000..515490b --- /dev/null +++ b/app/src/main/java/com/example/login_v3/MyApplication.kt @@ -0,0 +1,9 @@ +package com.example.login_v3 + +import android.app.Application +import dagger.hilt.android.HiltAndroidApp + +@HiltAndroidApp +class MyApplication : Application() { + // 可選：全域初始化 +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/Technologia.kt b/app/src/main/java/com/example/login_v3/Technologia.kt new file mode 100644 index 0000000..0e4df08 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/Technologia.kt @@ -0,0 +1,29 @@ +package com.example.login_v3 + +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.material3.Scaffold +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.lifecycle.viewmodel.compose.viewModel +import androidx.navigation.compose.rememberNavController +import com.example.login_v3.navigation.AppNavGraph +import com.example.login_v3.navigation.AppViewModel +import com.example.login_v3.navigation.MainViewModel + +@Composable +fun Technologia() { + + Scaffold( + modifier = Modifier.fillMaxSize(), + containerColor = Color.Transparent + ) { padding -> + + //在navController + AppNavGraph( + paddingValues = padding + ) + + } +} + diff --git a/app/src/main/java/com/example/login_v3/auth/HealthCheck_Screen.kt b/app/src/main/java/com/example/login_v3/auth/HealthCheck_Screen.kt new file mode 100644 index 0000000..25a0eac --- /dev/null +++ b/app/src/main/java/com/example/login_v3/auth/HealthCheck_Screen.kt @@ -0,0 +1,65 @@ +package com.example.login_v3.auth + +import androidx.compose.foundation.layout.* +import androidx.compose.material3.* +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp +import androidx.hilt.navigation.compose.hiltViewModel +import com.example.login_v3.data.health.HealthCheckViewModel + +@Composable +fun HealthCheckScreen( + viewModel: HealthCheckViewModel = hiltViewModel() +) { + val status = viewModel.healthStatus + val detail = viewModel.detailMessage + + //layout + Scaffold { padding -> + Column( + modifier = Modifier + .fillMaxSize() + .padding(16.dp) + .padding(padding), + verticalArrangement = Arrangement.Center, + horizontalAlignment = Alignment.CenterHorizontally + ) { + //health + Text(text = "API Health", style = MaterialTheme.typography.titleLarge) + + Spacer(modifier = Modifier.height(16.dp)) + + // 顯示狀態 + Text(text = "Status: $status", style = MaterialTheme.typography.bodyLarge) + + Spacer(modifier = Modifier.height(8.dp)) + + // 顯示詳細訊息 + Text(text = detail, style = MaterialTheme.typography.bodyMedium) + + Spacer(modifier = Modifier.height(20.dp)) + + // 如果正在檢查，顯示圓形進度 + if (status == "Checking...") { + CircularProgressIndicator() + Spacer(modifier = Modifier.height(12.dp)) + } + + Row { + Button(onClick = { viewModel.checkApiHealth() }) { + Text("Check Health") + } + + Spacer(modifier = Modifier.width(12.dp)) + + OutlinedButton(onClick = { + // 若需要重置狀態，可在 ViewModel 加一個 reset 方法，或直接呼叫 repository 前先改狀態 + }) { + Text("Reset") + } + } + } + } +} diff --git a/app/src/main/java/com/example/login_v3/auth/Login_Page.kt b/app/src/main/java/com/example/login_v3/auth/Login_Page.kt new file mode 100644 index 0000000..b44ef54 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/auth/Login_Page.kt @@ -0,0 +1,286 @@ +package com.example.login_v3.auth + +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.rounded.AccountCircle +import androidx.compose.material.icons.rounded.Lock +import androidx.compose.material.icons.rounded.Visibility +import androidx.compose.material.icons.rounded.VisibilityOff +import androidx.compose.material3.Button +import androidx.compose.material3.ButtonDefaults +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.Text +import androidx.compose.material3.TextField +import androidx.compose.material3.TextFieldDefaults +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.BlurredEdgeTreatment +import androidx.compose.ui.draw.blur +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Brush +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.Color.Companion.Red +import androidx.compose.ui.graphics.Color.Companion.Transparent +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.input.PasswordVisualTransformation +import androidx.compose.ui.text.input.VisualTransformation +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.hilt.navigation.compose.hiltViewModel +import androidx.navigation.NavBackStackEntry +import coil.ImageLoader +import coil.compose.AsyncImage +import coil.decode.SvgDecoder +import coil.request.ImageRequest +import com.example.login_v3.R +import com.example.login_v3.ui.theme.light_orange +import com.example.login_v3.ui.theme.main_orange +import kotlin.text.ifEmpty + + +@Composable +fun LoginScreen( + paddingValues: PaddingValues, + onLoginSuccess: () -> Unit +){ + + var email by remember { mutableStateOf("") } + var password by remember { mutableStateOf("") } + var passwordVisible by remember { mutableStateOf(false) } + + var emailError by remember { mutableStateOf("") } + var passwordError by remember { mutableStateOf("") } + + + + + Column( + modifier = Modifier + .fillMaxSize() + .background( + brush = Brush.linearGradient( + colors = listOf( + Color(0xFFDA7029), + Color(0xFF777777), + Color(0xFFB34800) + ) + ) + ) + .padding(paddingValues), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.Center + ) { + + + + + //Motion_logo + SvgImage( + resId = R.raw.tg_chat_v3, + modifier = Modifier.size(180.dp) + ) + + + //title + Text(text = "Login", + fontSize = 32.sp, + fontWeight = FontWeight.Bold, + color = Color.White + ) + + //login Box + Box( + modifier = Modifier + .height(340.dp) + .fillMaxWidth() + .padding(start = 24.dp, end = 24.dp, top = 20.dp), + contentAlignment = Alignment.Center + ){ + + + //glass effect + Box( + modifier = Modifier + .matchParentSize() + .clip(RoundedCornerShape(16.dp)) // 🔥 一定要有 + .blur( + radius = 10.dp, + edgeTreatment = BlurredEdgeTreatment.Unbounded + ) + .background( + Color.White.copy(alpha = 0.18f) + ) + .border( // ⭐ 玻璃邊框 + width = 1.dp, + color = Color.White.copy(alpha = 0.35f), + shape = RoundedCornerShape(16.dp) + ) + ) + + + + + + + Column( + modifier = Modifier + .fillMaxSize() + .padding(8.dp), + horizontalAlignment = Alignment.CenterHorizontally + ) { + + Spacer(modifier = Modifier.height(20.dp)) + + + TextField( + value = email, + onValueChange = { email = it}, + label = { + Text( + emailError.ifEmpty { "Email" }, + color = if (emailError.isNotEmpty()) Red else androidx.compose.ui.graphics.Color.Unspecified + ) + }, + + leadingIcon = { + Icon( + Icons.Rounded.AccountCircle, + contentDescription = "" + ) + }, + shape = RoundedCornerShape(8.dp), + + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 4.dp, horizontal = 16.dp), + + colors = TextFieldDefaults.colors( + focusedContainerColor = Transparent, + unfocusedIndicatorColor = Transparent + ) + ) + + Spacer(modifier = Modifier.height(10.dp)) + + + TextField( + value = password, + onValueChange = { password = it }, + label = { + Text( + passwordError.ifEmpty { "Password" }, + color = if (passwordError.isNotEmpty()) Red else androidx.compose.ui.graphics.Color.Unspecified + ) + }, + leadingIcon = { + Icon(Icons.Rounded.Lock, contentDescription = "") + }, + + visualTransformation = if (passwordVisible) VisualTransformation.None else PasswordVisualTransformation(), + + trailingIcon = { + val image = if (passwordVisible) { + Icons.Rounded.Visibility + } else { + Icons.Rounded.VisibilityOff + } + + IconButton(onClick = { passwordVisible = !passwordVisible }) { + Icon(imageVector = image, contentDescription = if (passwordVisible) "Hide password" else "Show password") + } + }, + + shape = RoundedCornerShape(8.dp), + + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 4.dp, horizontal = 16.dp), + + colors = TextFieldDefaults.colors( + focusedContainerColor = Transparent, + unfocusedIndicatorColor = Transparent + ) + ) + + Spacer(modifier = Modifier.height(20.dp)) + + + Button( + shape = RoundedCornerShape(8.dp), + onClick = { + emailError = if(email.isBlank()) "Email is required" else "" + passwordError = if(password.isBlank()) "password is required" else "" + if (emailError.isEmpty() && passwordError.isEmpty()){ + //login auth logic + } + }, + colors = ButtonDefaults.buttonColors( + containerColor = main_orange, // 背景顏色 + contentColor = Color.White // 文字顏色 + ) + + ) { + Text( text = "Login") + } + + + Spacer(modifier = Modifier.height(16.dp)) + + Text( text = "forget password?", + color = light_orange, + modifier = Modifier + .clickable{} + ) + } + + } + + } +} + + +@Composable +fun SvgImage( + resId: Int, + modifier: Modifier = Modifier +) { + val context = LocalContext.current + val imageLoader = ImageLoader.Builder(context) + .components { + add(SvgDecoder.Factory()) + } + .build() + + val imageRequest = ImageRequest.Builder(context) + .data("android.resource://${context.packageName}/$resId") + .decoderFactory(SvgDecoder.Factory()) + .build() + + AsyncImage( + model = imageRequest, + contentDescription = null, + modifier = modifier, + imageLoader = imageLoader + ) +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/auth/Login_Page_ViewModel.kt b/app/src/main/java/com/example/login_v3/auth/Login_Page_ViewModel.kt new file mode 100644 index 0000000..6da181a --- /dev/null +++ b/app/src/main/java/com/example/login_v3/auth/Login_Page_ViewModel.kt @@ -0,0 +1,30 @@ +package com.example.login_v3.auth + +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import com.example.login_v3.data.api.api_class.LoginResponse +import com.example.login_v3.data.repository.basic.ITecnologiaRepository +import dagger.hilt.android.lifecycle.HiltViewModel +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.launch +import javax.inject.Inject + + +@HiltViewModel +class LoginViewModel @Inject constructor( + private val repository: ITecnologiaRepository +) : ViewModel() { + + // 使用 StateFlow 或 LiveData 來傳遞結果給 UI + private val _loginResult = MutableStateFlow?>(null) + val loginResult = _loginResult.asStateFlow() + + fun performLogin(username: String, password: String) { + viewModelScope.launch { + // 直接呼叫 repository，ViewModel 不關心資料是從網路還是資料庫來的 + val result = repository.login(username, password) + _loginResult.value = result + } + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/auth/Login_or_Reg.kt b/app/src/main/java/com/example/login_v3/auth/Login_or_Reg.kt new file mode 100644 index 0000000..61787ff --- /dev/null +++ b/app/src/main/java/com/example/login_v3/auth/Login_or_Reg.kt @@ -0,0 +1,113 @@ +package com.example.login_v3.auth + +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.Button +import androidx.compose.material3.ButtonDefaults +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Brush +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import com.example.login_v3.ui.theme.light_orange +import com.example.login_v3.ui.theme.main_orange + +@Composable +fun Login_or_Reg_page( + paddingValues: PaddingValues, + onLoginClick: () -> Unit, + onRegClick: () -> Unit +){ + Column( + modifier = Modifier + .fillMaxSize() + .background( + brush = Brush.linearGradient( + colors = listOf( + Color(0xFFDA7029), + Color(0xFF777777), + Color(0xFFB34800) + ) + ) + ) + .padding(paddingValues), + horizontalAlignment = Alignment.CenterHorizontally + ) { + + Spacer(modifier = Modifier.weight(1f)) + + Text( + text = "Welcome", + fontSize = 42.sp, // 字體大小（像標題） + fontWeight = FontWeight.Bold, + color = Color.White + ) + + + + Spacer(modifier = Modifier.weight(1f)) + + + //login and reg button + Row( + modifier = Modifier + .fillMaxWidth(), + horizontalArrangement = Arrangement.Center + ) { + + + //login_button + Button( + modifier = Modifier + .weight(1f) + .height(60.dp) + .padding(start = 20.dp, end = 20.dp), + shape = RoundedCornerShape(12.dp), + colors = ButtonDefaults.buttonColors( + containerColor = Color.Gray, // 背景顏色 + contentColor = Color.White // 文字顏色 + ), + onClick = onLoginClick + ) { + Text( text = "Login", + fontSize = 20.sp) + } + + + Button( + modifier = Modifier + .weight(1f) + .height(60.dp) + .padding(end = 20.dp), + shape = RoundedCornerShape(12.dp), + colors = ButtonDefaults.buttonColors( + containerColor = light_orange, // 背景顏色 + contentColor = Color.White // 文字顏色 + ), + onClick = onRegClick + ) { + Text( text = "Register", + fontSize = 20.sp) + } + } + + Spacer(modifier = Modifier.weight(0.02f)) + + + + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/auth/Reg_Page.kt b/app/src/main/java/com/example/login_v3/auth/Reg_Page.kt new file mode 100644 index 0000000..3415676 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/auth/Reg_Page.kt @@ -0,0 +1,269 @@ +package com.example.login_v3.auth + +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.rounded.AccountCircle +import androidx.compose.material.icons.rounded.Lock +import androidx.compose.material.icons.rounded.Person +import androidx.compose.material.icons.rounded.Visibility +import androidx.compose.material.icons.rounded.VisibilityOff +import androidx.compose.material3.Button +import androidx.compose.material3.ButtonDefaults +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.Text +import androidx.compose.material3.TextField +import androidx.compose.material3.TextFieldDefaults +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.BlurredEdgeTreatment +import androidx.compose.ui.draw.blur +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Brush +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.Color.Companion.Red +import androidx.compose.ui.graphics.Color.Companion.Transparent +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.input.PasswordVisualTransformation +import androidx.compose.ui.text.input.VisualTransformation +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.hilt.navigation.compose.hiltViewModel +import com.example.login_v3.data.health.HealthCheckViewModel +import com.example.login_v3.ui.theme.main_orange +import kotlin.text.ifEmpty + +@Composable +fun Register_Screen( + paddingValues: PaddingValues, + +){ + var user_name by remember { mutableStateOf("") } + var email by remember { mutableStateOf("") } + var password by remember { mutableStateOf("") } + var passwordVisible by remember { mutableStateOf(false) } + + var emailError by remember { mutableStateOf("") } + var user_name_Error by remember { mutableStateOf("") } + var passwordError by remember { mutableStateOf("") } + + Column( + modifier = Modifier + .fillMaxSize() + .background( + brush = Brush.linearGradient( + colors = listOf( + Color(0xFFDA7029), + Color(0xFF777777), + Color(0xFFB34800) + ) + ) + ) + .padding(paddingValues), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.Center + ) { + + + Text(text = "Register", + fontSize = 32.sp, + fontWeight = FontWeight.Bold, + color = Color.White + ) + + + Spacer(modifier = Modifier.height(10.dp)) + + //Reg_box + Box( + modifier = Modifier + .height(360.dp) + .fillMaxWidth() + .padding(start = 34.dp, end = 34.dp, top = 20.dp), + contentAlignment = Alignment.Center + ){ + + //glass effect + Box( + modifier = Modifier + .matchParentSize() + .clip(RoundedCornerShape(16.dp)) // 🔥 一定要有 + .blur( + radius = 10.dp, + edgeTreatment = BlurredEdgeTreatment.Unbounded + ) + .background( + Color.White.copy(alpha = 0.18f) + ) + .border( // ⭐ 玻璃邊框 + width = 1.dp, + color = Color.White.copy(alpha = 0.35f), + shape = RoundedCornerShape(16.dp) + ) + ) + + + + Column( + modifier = Modifier + .fillMaxSize() + .padding(8.dp), + horizontalAlignment = Alignment.CenterHorizontally + ) { + + Spacer(modifier = Modifier.height(20.dp)) + + //input_username + TextField( + value = user_name, + onValueChange = { user_name = it}, + label = { + Text( + user_name_Error.ifEmpty { "username" }, + color = if (user_name_Error.isNotEmpty()) Red else androidx.compose.ui.graphics.Color.Unspecified + ) + }, + + leadingIcon = { + Icon( + Icons.Rounded.Person, + contentDescription = "" + ) + }, + shape = RoundedCornerShape(8.dp), + + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 4.dp, horizontal = 16.dp), + + colors = TextFieldDefaults.colors( + focusedContainerColor = Transparent, + unfocusedIndicatorColor = Transparent + ) + ) + + Spacer(modifier = Modifier.height(10.dp)) + + //input_email + TextField( + value = email, + onValueChange = { email = it}, + label = { + Text( + emailError.ifEmpty { "Email" }, + color = if (emailError.isNotEmpty()) Red else androidx.compose.ui.graphics.Color.Unspecified + ) + }, + + leadingIcon = { + Icon( + Icons.Rounded.AccountCircle, + contentDescription = "" + ) + }, + shape = RoundedCornerShape(8.dp), + + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 4.dp, horizontal = 16.dp), + + colors = TextFieldDefaults.colors( + focusedContainerColor = Transparent, + unfocusedIndicatorColor = Transparent + ) + ) + + Spacer(modifier = Modifier.height(10.dp)) + + //input_password + TextField( + value = password, + onValueChange = { password = it }, + label = { + Text( + passwordError.ifEmpty { "Password" }, + color = if (passwordError.isNotEmpty()) Red else androidx.compose.ui.graphics.Color.Unspecified + ) + }, + leadingIcon = { + Icon(Icons.Rounded.Lock, contentDescription = "") + }, + + visualTransformation = if (passwordVisible) VisualTransformation.None else PasswordVisualTransformation(), + + trailingIcon = { + val image = if (passwordVisible) { + Icons.Rounded.Visibility + } else { + Icons.Rounded.VisibilityOff + } + + IconButton(onClick = { passwordVisible = !passwordVisible }) { + Icon(imageVector = image, contentDescription = if (passwordVisible) "Hide password" else "Show password") + } + }, + + shape = RoundedCornerShape(8.dp), + + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 4.dp, horizontal = 16.dp), + + colors = TextFieldDefaults.colors( + focusedContainerColor = Transparent, + unfocusedIndicatorColor = Transparent + ) + ) + + + Spacer(modifier = Modifier.height(20.dp)) + + //Reg_button + Button( + shape = RoundedCornerShape(8.dp), + onClick = { + user_name_Error = if(user_name.isBlank()) "username is required" else "" + emailError = if(email.isBlank()) "Email is required" else "" + passwordError = if(password.isBlank()) "password is required" else "" + if (user_name_Error.isEmpty() && emailError.isEmpty() && passwordError.isEmpty()){ + //login auth logic + } + }, + colors = ButtonDefaults.buttonColors( + containerColor = main_orange, // 背景顏色 + contentColor = Color.White // 文字顏色 + ) + + ) { + Text( text = "Login") + } + + //input_block_end + } + + + + + + } + + } + +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/data/api/Main_API_Service.kt b/app/src/main/java/com/example/login_v3/data/api/Main_API_Service.kt new file mode 100644 index 0000000..42d4571 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/data/api/Main_API_Service.kt @@ -0,0 +1,33 @@ +package com.example.login_v3.data.api + +import com.example.login_v3.data.api.api_class.ApiResponse +import com.example.login_v3.data.api.api_class.FriendRequest +import com.example.login_v3.data.api.api_class.LoginRequest +import com.example.login_v3.data.api.api_class.LoginResponse +import retrofit2.Response +import com.example.login_v3.data.api.api_class.User +import retrofit2.http.Body +import retrofit2.http.GET +import retrofit2.http.Header +import retrofit2.http.POST + +interface TecnologiaApi { + + @GET("api/health") + // 必須包裹在 Response<> 裡面，才能呼叫 .isSuccessful + suspend fun checkHealth(): Response + + @POST("api/auth/login") + suspend fun login(@Body body: LoginRequest): LoginResponse + + @GET("api/me") + suspend fun getMe(@Header("Authorization") token: String): User + + @POST("api/friends/request") + suspend fun sendFriendRequest( + @Header("Authorization") token: String, + @Body body: FriendRequest + ): ApiResponse + + // 其他 endpoint 一樣加 +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/data/api/RetrofitInstance.kt b/app/src/main/java/com/example/login_v3/data/api/RetrofitInstance.kt new file mode 100644 index 0000000..19ed7fe --- /dev/null +++ b/app/src/main/java/com/example/login_v3/data/api/RetrofitInstance.kt @@ -0,0 +1,26 @@ +package com.example.login_v3.data.api + +import com.squareup.moshi.Moshi +import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory +import retrofit2.Retrofit +import retrofit2.converter.moshi.MoshiConverterFactory + +object RetrofitInstance { + + private const val BASE_URL = "https://192.168.0.217:8443/" // 開發測試可能需改 HTTP + + // 建立 Moshi instance，加入 Kotlin 支援 + private val moshi: Moshi by lazy { + Moshi.Builder() + .add(KotlinJsonAdapterFactory()) + .build() + } + + val api: TecnologiaApi by lazy { + Retrofit.Builder() + .baseUrl(BASE_URL) + .addConverterFactory(MoshiConverterFactory.create(moshi)) + .build() + .create(TecnologiaApi::class.java) + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/data/api/api_class/FriendRequest.kt b/app/src/main/java/com/example/login_v3/data/api/api_class/FriendRequest.kt new file mode 100644 index 0000000..e069f14 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/data/api/api_class/FriendRequest.kt @@ -0,0 +1,10 @@ +package com.example.login_v3.data.api.api_class + +data class FriendRequest( + val friendId: String +) + +data class ApiResponse( + val success: Boolean, + val message: String +) \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/data/api/api_class/LoginRequest_Response.kt b/app/src/main/java/com/example/login_v3/data/api/api_class/LoginRequest_Response.kt new file mode 100644 index 0000000..e040c5b --- /dev/null +++ b/app/src/main/java/com/example/login_v3/data/api/api_class/LoginRequest_Response.kt @@ -0,0 +1,11 @@ +package com.example.login_v3.data.api.api_class + +data class LoginRequest( + val username: String, + val password: String +) + +data class LoginResponse( + val token: String, + val userId: String +) \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/data/api/api_class/User.kt b/app/src/main/java/com/example/login_v3/data/api/api_class/User.kt new file mode 100644 index 0000000..93d0466 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/data/api/api_class/User.kt @@ -0,0 +1,7 @@ +package com.example.login_v3.data.api.api_class + +data class User( + val id: String, + val username: String, + val email: String +) \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/data/di/NetworkModule.kt b/app/src/main/java/com/example/login_v3/data/di/NetworkModule.kt new file mode 100644 index 0000000..a6764bd --- /dev/null +++ b/app/src/main/java/com/example/login_v3/data/di/NetworkModule.kt @@ -0,0 +1,28 @@ +package com.example.login_v3.data.di + +import androidx.lifecycle.ViewModel +import com.example.login_v3.data.api.TecnologiaApi +import dagger.Module +import dagger.Provides +import dagger.hilt.InstallIn +import dagger.hilt.android.lifecycle.HiltViewModel +import dagger.hilt.components.SingletonComponent +import retrofit2.Retrofit +import retrofit2.converter.moshi.MoshiConverterFactory +import javax.inject.Inject +import javax.inject.Singleton + +@Module +@InstallIn(SingletonComponent::class) +object NetworkModule { + + @Provides + @Singleton + fun provideTecnologiaApi(): TecnologiaApi { // 補上函數宣告 + return Retrofit.Builder() + .baseUrl("https://192.168.0.217:8443") // 記得最後面通常要有斜槓 / + .addConverterFactory(MoshiConverterFactory.create()) + .build() + .create(TecnologiaApi::class.java) // 這裡要對應你的 Api 介面類別 + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/data/health/HealthCheck_ViewModel.kt b/app/src/main/java/com/example/login_v3/data/health/HealthCheck_ViewModel.kt new file mode 100644 index 0000000..80c286a --- /dev/null +++ b/app/src/main/java/com/example/login_v3/data/health/HealthCheck_ViewModel.kt @@ -0,0 +1,43 @@ +package com.example.login_v3.data.health + +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import com.example.login_v3.data.repository.basic.NetworkRepository +import dagger.hilt.android.lifecycle.HiltViewModel +import kotlinx.coroutines.launch +import javax.inject.Inject + +@HiltViewModel +class HealthCheckViewModel @Inject constructor( + private val repository: NetworkRepository +) : ViewModel() { + + // 使用 Compose 的 mutableState，這樣 UI 會自動根據這個值的改變而重繪 + var healthStatus by mutableStateOf("Ready to Check") + private set + + // 用來顯示更詳細的訊息（例如錯誤內容） + var detailMessage by mutableStateOf("") + private set + + fun checkApiHealth() { + viewModelScope.launch { + healthStatus = "Checking..." + detailMessage = "Connecting to server..." + + val result = repository.performHealthCheck() + + result.onSuccess { + healthStatus = "Success" + detailMessage = "✅ Connection established! (200 OK)" + }.onFailure { exception -> + healthStatus = "Failed" + // 這裡會抓到連線逾時、404、或是找不到伺服器等錯誤 + detailMessage = "❌ Error: ${exception.localizedMessage}" + } + } + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/data/repository/basic/Main_Repository.kt b/app/src/main/java/com/example/login_v3/data/repository/basic/Main_Repository.kt new file mode 100644 index 0000000..a6cddd0 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/data/repository/basic/Main_Repository.kt @@ -0,0 +1,66 @@ +package com.example.login_v3.data.repository.basic + +import com.example.login_v3.data.api.TecnologiaApi +import com.example.login_v3.data.api.api_class.ApiResponse +import com.example.login_v3.data.api.api_class.FriendRequest +import com.example.login_v3.data.api.api_class.LoginRequest +import com.example.login_v3.data.api.api_class.LoginResponse +import com.example.login_v3.data.api.api_class.User +import dagger.Binds +import dagger.Module +import dagger.hilt.InstallIn +import dagger.hilt.components.SingletonComponent +import java.lang.Exception +import javax.inject.Inject +import javax.inject.Singleton + +@Singleton +class TecnologiaRepositoryImpl @Inject constructor( + private val api: TecnologiaApi // Hilt 會從 NetworkModule 找這個 API +) : ITecnologiaRepository { + + override suspend fun login(username: String, password: String): Result { + return try { + val response = api.login(LoginRequest(username, password)) + Result.success(response) + } catch (e: Exception) { + Result.failure(e) + } + } + + override suspend fun getMe(token: String): Result { + return try { + val response = api.getMe("Bearer $token") + Result.success(response) + } catch (e: Exception) { + Result.failure(e) + } + } + + override suspend fun sendFriendRequest(token: String, friendId: String): Result { + return try { + val response = api.sendFriendRequest("Bearer $token", FriendRequest(friendId)) + Result.success(response) + } catch (e: Exception) { + Result.failure(e) + } + } +} + + +@Module +@InstallIn(SingletonComponent::class) +abstract class RepositoryModule { + + @Binds + @Singleton + abstract fun bindTecnologiaRepository( + repositoryImpl: TecnologiaRepositoryImpl // 這裡要對應實作類別的名稱 + ): ITecnologiaRepository +} + +interface ITecnologiaRepository { + suspend fun login(username: String, password: String): Result + suspend fun getMe(token: String): Result + suspend fun sendFriendRequest(token: String, friendId: String): Result +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/data/repository/basic/Network_Repository.kt b/app/src/main/java/com/example/login_v3/data/repository/basic/Network_Repository.kt new file mode 100644 index 0000000..943c038 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/data/repository/basic/Network_Repository.kt @@ -0,0 +1,21 @@ +package com.example.login_v3.data.repository.basic + +import com.example.login_v3.data.api.TecnologiaApi +import javax.inject.Inject + +class NetworkRepository @Inject constructor( + private val apiService: TecnologiaApi +) { + suspend fun performHealthCheck(): Result { + return try { + val response = apiService.checkHealth() + if (response.isSuccessful) { + Result.success(true) + } else { + Result.failure(Exception("Error code: ${response.code()}")) + } + } catch (e: Exception) { + Result.failure(e) + } + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/home/Home_Screen.kt b/app/src/main/java/com/example/login_v3/home/Home_Screen.kt new file mode 100644 index 0000000..7e6706c --- /dev/null +++ b/app/src/main/java/com/example/login_v3/home/Home_Screen.kt @@ -0,0 +1,28 @@ +package com.example.login_v3.home + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.material3.Button +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.navigation.NavBackStackEntry + +@Composable +fun HomeScreen(onLogout: () -> Unit, paddingValues: PaddingValues) { + Column( + modifier = Modifier + .fillMaxSize(), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.Center + ) { + Button( + onClick = onLogout + ) { + Text( text = "Logout") + } + } +} diff --git a/app/src/main/java/com/example/login_v3/home/MarketPlace.kt b/app/src/main/java/com/example/login_v3/home/MarketPlace.kt new file mode 100644 index 0000000..1230a13 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/home/MarketPlace.kt @@ -0,0 +1,36 @@ +package com.example.login_v3.home + +import android.net.Uri +import androidx.compose.animation.SharedTransitionLayout +import androidx.compose.animation.SharedTransitionScope +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.lifecycle.viewmodel.compose.viewModel +import androidx.navigation.NavType +import androidx.navigation.compose.NavHost +import androidx.navigation.compose.composable +import androidx.navigation.compose.rememberNavController +import androidx.navigation.navArgument +import com.example.login_v3.home.setting.setting_detail_Screen +import com.example.login_v3.home.setting.setting_list_Screen +import com.example.login_v3.navigation.BottomBarViewModel +import com.example.login_v3.navigation.ScreensViewModel + +@Composable +fun Tg_MarketPlace(){ + + Box( + modifier = Modifier.fillMaxSize() + ) { + Text(text = "marketplace") + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/home/Message.kt b/app/src/main/java/com/example/login_v3/home/Message.kt new file mode 100644 index 0000000..38cf92a --- /dev/null +++ b/app/src/main/java/com/example/login_v3/home/Message.kt @@ -0,0 +1,161 @@ +package com.example.login_v3.home + +import androidx.compose.foundation.Image +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.Card +import androidx.compose.material3.CardDefaults +import androidx.compose.material3.Divider +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Scaffold +import androidx.compose.material3.Text +import androidx.compose.material3.TopAppBar +import androidx.compose.material3.TopAppBarDefaults +import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Brush +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.unit.dp +import androidx.lifecycle.viewmodel.compose.viewModel +import androidx.compose.runtime.getValue +import androidx.compose.ui.draw.BlurredEdgeTreatment +import androidx.compose.ui.draw.blur +import androidx.compose.ui.draw.clip + +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun Tg_Message() { + val viewModel: MessageViewModel = viewModel() + val contacts by viewModel.contacts.collectAsState() + + Scaffold( + containerColor = Color.Transparent, + modifier = Modifier + .fillMaxSize() + .background( + brush = Brush.verticalGradient( + colors = listOf( + Color(0xFFDA7029), + Color(0xFF777777), + Color(0xFFB34800) + ) + ) + ), + topBar = { + TopAppBar( + title = { Text("Messages") }, + colors = TopAppBarDefaults.topAppBarColors( + containerColor = Color.Transparent, // ⭐ 改這裡 + titleContentColor = Color.Black + ), + modifier = Modifier + .background( + color = Color.White.copy(alpha = 0.2f), // ⭐ 調低透明度 + shape = RoundedCornerShape(0.dp) + ) + .border( + width = 0.5.dp, + color = Color.White.copy(alpha = 0.4f), + shape = RoundedCornerShape(0.dp) + ) + ) + }, + ) { innerPadding -> + Column( + modifier = Modifier + .fillMaxSize() + ) { + Spacer(modifier = Modifier.height(8.dp)) + LazyColumn( + contentPadding = innerPadding + ) { + items(contacts) { contact -> + Card( + modifier = Modifier + .fillMaxWidth() + .clip(RoundedCornerShape(16.dp)) + .padding(6.dp), + elevation = CardDefaults.cardElevation(defaultElevation = 0.dp), + shape = RoundedCornerShape(16.dp), + colors = CardDefaults.cardColors( + containerColor = Color.Transparent // ✅ 透明背景 + ) + + ) { + Box( + modifier = Modifier + .fillMaxSize() + ) { + + //glass effect + Box( + modifier = Modifier + .matchParentSize() + .blur(10.dp) + ) + Box( + modifier = Modifier + .matchParentSize() + .background( + Color.White.copy(alpha = 0.08f), + RoundedCornerShape(16.dp) + ) + .border( + 1.dp, + Color.White.copy(alpha = 0.3f), + RoundedCornerShape(16.dp) + ) + ) + + // 前景層：文字 + 圖片，不會被模糊 + Row( + verticalAlignment = Alignment.CenterVertically, + modifier = Modifier.padding(12.dp), + ) { + Image( + painter = painterResource(id = contact.avatarResId), + contentDescription = "${contact.name}'s avatar", + modifier = Modifier + .size(48.dp) + .clip(CircleShape) + .border(2.dp, Color.White, CircleShape) + ) + Column(modifier = Modifier.padding(start = 12.dp)) { + Text( + text = contact.name, + style = MaterialTheme.typography.titleMedium + ) + Text( + text = "Online", + style = MaterialTheme.typography.bodySmall, + color = Color.Green + ) + } + } + } + } + + + } + } + } + } +} diff --git a/app/src/main/java/com/example/login_v3/home/Message_ViewModel.kt b/app/src/main/java/com/example/login_v3/home/Message_ViewModel.kt new file mode 100644 index 0000000..b035ca9 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/home/Message_ViewModel.kt @@ -0,0 +1,36 @@ +// Message_ViewModel.kt +package com.example.login_v3.home + +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import com.example.login_v3.R +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.launch + + +data class Contact( + val name: String, + val avatarResId: Int // 或者用 String 存圖片 URL +) + +class MessageViewModel : ViewModel() { + + private val _contacts = MutableStateFlow>(emptyList()) + val contacts: StateFlow> = _contacts + + init { + viewModelScope.launch { + _contacts.value = listOf( + Contact("Alice", R.drawable.avatar_v1), + Contact("Bob", R.drawable.avatar_v1), + Contact("Charlie", R.drawable.avatar_v1), + Contact("David", R.drawable.avatar_v1), + Contact("nigga", R.drawable.avatar_v1), + Contact("gbl", R.drawable.avatar_v1), + Contact("威威夢夢", R.drawable.avatar_v1) + ) + } + } +} + diff --git a/app/src/main/java/com/example/login_v3/home/Server.kt b/app/src/main/java/com/example/login_v3/home/Server.kt new file mode 100644 index 0000000..5733f20 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/home/Server.kt @@ -0,0 +1,203 @@ +package com.example.login_v3.home + +import androidx.compose.foundation.Image +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxHeight +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.blur +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.unit.dp +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.material3.Divider +import androidx.compose.ui.draw.clip +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.graphics.Brush +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.sp + + +@Composable +fun Tg_Server( + viewModel: ServerViewModel +){ + val serverList by viewModel.serverList.collectAsState() + val currentServer by viewModel.currentServer.collectAsState() + + + Box( + modifier = Modifier.fillMaxSize() + ) { + Column( + modifier = Modifier + .fillMaxSize() + .align(Alignment.Center), + verticalArrangement = Arrangement.Center + ) { + + //TOP_SPACER + Spacer( + modifier = Modifier.weight(0.6f) + ) + + + Box( + modifier = Modifier + .weight(8f) + .fillMaxWidth() + ){ + //glass effect + Box( + modifier = Modifier + .matchParentSize() + .blur(10.dp) + ) + Box( + modifier = Modifier + .matchParentSize() + .background( + Color.Black.copy(alpha = 0.08f), + RoundedCornerShape(16.dp) + ) + ) + + + //row contain server list and function block + Row( + modifier = Modifier + .fillMaxSize() + ) { + //server list + Column( + modifier = Modifier + .width(80.dp) + .fillMaxHeight() + ) { + LazyColumn { + items(serverList) { server -> + Image( + painter = painterResource(id = server.server_icon), + contentDescription = server.name, + modifier = Modifier + .size(72.dp) + .clip(CircleShape) + .clickable { + viewModel.selectServer(server.id) + } + .padding(8.dp) + ) + } + } + + } + + + //server function block + Column( + modifier = Modifier + .weight(1f) + .fillMaxHeight() + ) { + + Box(modifier = Modifier + .fillMaxSize() + ){ + //glass effect for server function_block + Box( + modifier = Modifier + .matchParentSize() + .background( + Color.White.copy(alpha = 0.08f), + RoundedCornerShape(16.dp) + ) + .border( + 1.dp, + Color.White.copy(alpha = 0.3f), + RoundedCornerShape(16.dp) + ) + ) + + + //column contain function block + Column( + modifier = Modifier.fillMaxSize(), + horizontalAlignment = Alignment.CenterHorizontally + ) { + + Spacer(modifier = Modifier.height(10.dp)) + + //server name + Text( + text = if (currentServer != null) { + "目前伺服器：${currentServer!!.name}" + } else { + "尚未選擇伺服器" + }, + fontSize = 20.sp, // 調整字體大小 + fontWeight = FontWeight.Bold, // 設定字體加粗 + color = Color(0xFFFFEDD9) + ) + + + Divider( + color = Color(0xFFFFEDD9), // 線的顏色 + thickness = 2.dp, // 線的粗細 + modifier = Modifier.padding(vertical = 8.dp) // 與上下內容的間距 + ) + + //gallery + Box( + modifier = Modifier + .fillMaxWidth() + .height(120.dp) + .padding(horizontal = 28.dp, vertical = 16.dp) + .background( + brush = Brush.linearGradient( + colors = listOf( + Color(0xFFFFEDD9), // 漸層起始色 + Color(0xFFAB47BC) // 漸層結束色 + ), + start = Offset(0f, 0f), + end = Offset(1000f, 1000f) // 控制漸層方向 + ), + shape = RoundedCornerShape(8.dp) + ) + .padding(24.dp) + ) {} + + } + } + } + + } + } + + //bottom spacer + Spacer( + modifier = Modifier.weight(1.4f) + ) + + } + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/home/Server_ViewModel.kt b/app/src/main/java/com/example/login_v3/home/Server_ViewModel.kt new file mode 100644 index 0000000..a0d0235 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/home/Server_ViewModel.kt @@ -0,0 +1,44 @@ +package com.example.login_v3.home + +import androidx.lifecycle.ViewModel +import com.example.login_v3.R +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow + +data class Server( + val id: String, + val name: String, + val server_icon: Int +) + +class ServerViewModel : ViewModel() { + private val _serverList = MutableStateFlow>(emptyList()) + val serverList: StateFlow> = _serverList + + private val _currentServer = MutableStateFlow(null) + val currentServer: StateFlow = _currentServer + + init { + // 測試用：初始化一些伺服器 + _serverList.value = listOf( + Server("1", "伺服器A", R.drawable.avatar_v1), + Server("2", "伺服器B", R.drawable.avatar_v1), + Server("3", "伺服器C", R.drawable.avatar_v1) + ) + } + + fun addServer(server: Server) { + _serverList.value = _serverList.value + server + } + + fun selectServer(serverId: String) { + _currentServer.value = _serverList.value.find { it.id == serverId } + } + + fun removeServer(serverId: String) { + _serverList.value = _serverList.value.filterNot { it.id == serverId } + if (_currentServer.value?.id == serverId) { + _currentServer.value = null + } + } +} diff --git a/app/src/main/java/com/example/login_v3/home/setting/Setting.kt b/app/src/main/java/com/example/login_v3/home/setting/Setting.kt new file mode 100644 index 0000000..3493f34 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/home/setting/Setting.kt @@ -0,0 +1,97 @@ +package com.example.login_v3.home.setting + +import android.net.Uri +import androidx.compose.animation.SharedTransitionLayout +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.* +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.Card +import androidx.compose.material3.CardDefaults +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.SearchBar +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.blur +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.lifecycle.viewmodel.compose.viewModel +import androidx.navigation.NavType +import androidx.navigation.compose.NavHost +import androidx.navigation.compose.composable +import androidx.navigation.compose.rememberNavController +import androidx.navigation.navArgument +import com.example.login_v3.navigation.BottomBarViewModel + +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun Tg_Setting( + bottomBarViewModel: BottomBarViewModel +) { + + Box( + modifier = Modifier.fillMaxSize() + ) { + Column( + modifier = Modifier + .fillMaxSize() + .align(Alignment.Center), + verticalArrangement = Arrangement.Center, + horizontalAlignment = Alignment.CenterHorizontally + ) { + SharedTransitionLayout() { + + val navController = rememberNavController() + NavHost( + navController = navController, + startDestination = "setting_list" + ){ + + //setting_list_page + composable("setting_list") { + setting_list_Screen( + //scaling animation effect + onItemClick = { title, iconKey -> + val encodedTitle = Uri.encode(title) + navController.navigate("setting_detail/$encodedTitle/$iconKey") + }, + animatedVisibilityScope = this + ) + } + + //setting_detail_page + composable( + route = "setting_detail/{title}/{iconKey}", + arguments = listOf( + navArgument("title") { type = NavType.StringType }, + navArgument("iconKey") { type = NavType.StringType } + ) + ) { backStackEntry -> + val title = backStackEntry.arguments?.getString("title") ?: "" + val iconKey = backStackEntry.arguments?.getString("iconKey") ?: "" + setting_detail_Screen(title = title, + settingIcon = iconKey, + animatedVisibilityScope = this, + bottomBarViewModel = bottomBarViewModel + ) + } + } + } + } + } +} diff --git a/app/src/main/java/com/example/login_v3/home/setting/Setting_ViewModel.kt b/app/src/main/java/com/example/login_v3/home/setting/Setting_ViewModel.kt new file mode 100644 index 0000000..92b9dfb --- /dev/null +++ b/app/src/main/java/com/example/login_v3/home/setting/Setting_ViewModel.kt @@ -0,0 +1,38 @@ +package com.example.login_v3.home.setting + + +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Devices +import androidx.compose.material.icons.filled.Palette +import androidx.compose.material.icons.filled.Person +import androidx.compose.material.icons.filled.Subscriptions +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.lifecycle.ViewModel +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow + +data class SettingItem( + val id: String, + val title: String, + val description: String? = null, + val setting_icon: ImageVector, + val iconKey: String +) + + + +class SettingViewModel : ViewModel() { + + private val _settings = MutableStateFlow>(emptyList()) + val settings: StateFlow> = _settings + + init { + _settings.value = listOf( + SettingItem("profile", "Profile", "Manage your account", Icons.Filled.Person, "profile"), + SettingItem("theme", "Theme", "Customize app appearance", Icons.Filled.Palette, "theme"), + SettingItem("devices", "Devices", "Manage connected devices", Icons.Filled.Devices, "devices"), + SettingItem("subscription", "Subscription", "View or update your plan", Icons.Filled.Subscriptions, "subscribetion") + ) + } +} + diff --git a/app/src/main/java/com/example/login_v3/home/setting/Setting_detail_Screen.kt b/app/src/main/java/com/example/login_v3/home/setting/Setting_detail_Screen.kt new file mode 100644 index 0000000..c1f5708 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/home/setting/Setting_detail_Screen.kt @@ -0,0 +1,126 @@ +package com.example.login_v3.home.setting + +import android.net.Uri +import androidx.compose.animation.AnimatedVisibilityScope +import androidx.compose.animation.SharedTransitionScope +import androidx.compose.animation.core.tween +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.automirrored.filled.Help +import androidx.compose.material.icons.filled.Devices +import androidx.compose.material.icons.filled.Help +import androidx.compose.material.icons.filled.Palette +import androidx.compose.material.icons.filled.Person +import androidx.compose.material.icons.filled.Settings +import androidx.compose.material.icons.filled.Subscriptions +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.DisposableEffect +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.navigation.compose.NavHost +import androidx.navigation.compose.composable +import androidx.navigation.compose.rememberNavController +import com.example.login_v3.home.setting.setting_detail_page.setting_devices_page +import com.example.login_v3.home.setting.setting_detail_page.setting_profile_page +import com.example.login_v3.home.setting.setting_detail_page.setting_subscription_page +import com.example.login_v3.home.setting.setting_detail_page.setting_theme_page +import com.example.login_v3.navigation.BottomBarViewModel + +@Composable +fun SharedTransitionScope.setting_detail_Screen( + title: String, + settingIcon: String, + animatedVisibilityScope: AnimatedVisibilityScope, + bottomBarViewModel: BottomBarViewModel +){ + //control bottom bar behavior + DisposableEffect(Unit) { + bottomBarViewModel.setVisible(false) + onDispose { + bottomBarViewModel.setVisible(true) + } + } + + val setting_icon_decode: ImageVector = when (settingIcon) { + "profile" -> Icons.Default.Person + "theme" -> Icons.Default.Palette + "devices" -> Icons.Default.Devices + "subscribetion" -> Icons.Default.Subscriptions + else -> Icons.Default.Help + } + Column(modifier = Modifier + .fillMaxSize() + .padding(16.dp) + ) { + + val iconState = rememberSharedContentState(key = "setting_icon_${settingIcon}") + val titleState = rememberSharedContentState(key = "setting_title_${settingIcon}_${Uri.encode(title)}") + + Spacer(modifier = Modifier.height(46.dp)) + + Row( + verticalAlignment = Alignment.CenterVertically + ) { + Icon( + imageVector = setting_icon_decode, + contentDescription = title, + modifier = Modifier + .size(48.dp) + .sharedElement( + sharedContentState = iconState, + animatedVisibilityScope = animatedVisibilityScope, + boundsTransform = { _, _ -> + tween(durationMillis = 400) + + } + ), + tint = Color.White + ) + Spacer(modifier = Modifier.width(8.dp)) + Text( + text = title, + fontSize = 38.sp, + fontWeight = FontWeight.Bold, + style = MaterialTheme.typography.titleLarge + ) + } + + //setting_detail_page_Navigation + val setting_detail_page_navController = rememberNavController() + val startRoute = when (settingIcon) { + "profile" -> "setting_Profile" + "theme" -> "setting_Theme" + "devices" -> "setting_Devices" + "subscribetion" -> "setting_Subscription" + else -> "setting_Profile" + } + + //spacing between content and title + Spacer(modifier = Modifier.height(26.dp)) + + NavHost( + navController = setting_detail_page_navController, + startDestination = startRoute + ) { + composable("setting_Profile") { setting_profile_page() } + composable("setting_Theme") { setting_theme_page() } + composable("setting_Devices") { setting_devices_page() } + composable("setting_Subscription") { setting_subscription_page() } + } + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/home/setting/Setting_list_Screen.kt b/app/src/main/java/com/example/login_v3/home/setting/Setting_list_Screen.kt new file mode 100644 index 0000000..30f3fb7 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/home/setting/Setting_list_Screen.kt @@ -0,0 +1,172 @@ +package com.example.login_v3.home.setting + +import android.R +import android.net.Uri +import androidx.compose.animation.AnimatedVisibility +import androidx.compose.animation.AnimatedVisibilityScope +import androidx.compose.animation.SharedTransitionScope +import androidx.compose.animation.core.tween +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.itemsIndexed +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.SearchBar +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.blur +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.lifecycle.viewmodel.compose.viewModel +import androidx.navigation.NavController +import androidx.navigation.compose.rememberNavController +import com.example.login_v3.navigation.ScreensViewModel + +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun SharedTransitionScope.setting_list_Screen( + onItemClick: (String, String) -> Unit, + viewModel: SettingViewModel = viewModel(), + animatedVisibilityScope: AnimatedVisibilityScope, //scaling animation effect +){ + + var query by remember { mutableStateOf("") } + var active by remember { mutableStateOf(false) } + + + + Column(modifier = Modifier + .fillMaxSize() + ) { + + val settings by viewModel.settings.collectAsState() + + + Spacer(modifier = Modifier.height(46.dp)) + + SearchBar( + query = query, + onQueryChange = { query = it }, + onSearch = { /* 執行搜尋邏輯 */ }, + active = active, + shape = RoundedCornerShape(12.dp), + onActiveChange = { active = it }, + placeholder = { Text("搜尋設定") }, + modifier = Modifier + .fillMaxWidth() + .padding(horizontal = 8.dp) + + ) { + // 這裡是 SearchBar 展開後的內容 + Text("搜尋結果: $query") + } // ← 注意這個大括號要結束 SearchBar + + Spacer(modifier = Modifier.height(14.dp)) + + LazyColumn( + modifier = Modifier + .fillMaxSize(), + verticalArrangement = Arrangement.spacedBy(2.dp), // 每個 item 之間 8.dp + contentPadding = PaddingValues(vertical = 2.dp) + ) { + itemsIndexed(settings){ index, item -> + + Box( + modifier = Modifier + .fillMaxSize() + .padding(6.dp) + ) { + Box(modifier = Modifier.matchParentSize().blur(10.dp)) + Box( + modifier = Modifier + .matchParentSize() + .background(Color.White.copy(alpha = 0.08f), RoundedCornerShape(16.dp)) + .border(1.dp, Color.White.copy(alpha = 0.3f), RoundedCornerShape(16.dp)) + ) + + Row(modifier = Modifier + .fillMaxWidth() + .padding(16.dp) + .clickable{ onItemClick(item.title, item.iconKey)} + ) { + val iconState = rememberSharedContentState(key = "setting_icon_${item.iconKey}") + val titleState = rememberSharedContentState(key = "setting_title_${item.iconKey}_${Uri.encode(item.title)}") + + + Spacer(modifier = Modifier.width(8.dp)) + Column { + Text( + text = "${item.title}", + style = MaterialTheme.typography.titleMedium, + fontSize = 24.sp, + fontWeight = FontWeight.Bold, + modifier = Modifier + .sharedElement( + sharedContentState = titleState, + animatedVisibilityScope = animatedVisibilityScope, + boundsTransform = { _, _ -> + tween(durationMillis = 1000) + + } + ) + .padding(bottom = 4.dp) + ) + item.description?.let { + Text(text = it, + style = MaterialTheme.typography.bodySmall, + color = Color.White + ) + } + } + + Spacer(modifier = Modifier.weight(1f)) + + Icon(item.setting_icon, + contentDescription = item.title, + modifier = Modifier + .sharedElement( + sharedContentState = iconState, + animatedVisibilityScope = animatedVisibilityScope, + boundsTransform = { _, _ -> + tween(durationMillis = 400) + + } + ) + .padding(bottom = 4.dp) + .size(54.dp), + tint = Color.White + ) + } + } + + } + } + } + +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/home/setting/setting_detail_page/setting_Devices_Page.kt b/app/src/main/java/com/example/login_v3/home/setting/setting_detail_page/setting_Devices_Page.kt new file mode 100644 index 0000000..52e4c49 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/home/setting/setting_detail_page/setting_Devices_Page.kt @@ -0,0 +1,12 @@ +package com.example.login_v3.home.setting.setting_detail_page + +import androidx.compose.foundation.layout.Column +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable + +@Composable +fun setting_devices_page(){ + Column() { + Text(text = "setting_devices_page") + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/home/setting/setting_detail_page/setting_Profile_Page.kt b/app/src/main/java/com/example/login_v3/home/setting/setting_detail_page/setting_Profile_Page.kt new file mode 100644 index 0000000..ee83a47 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/home/setting/setting_detail_page/setting_Profile_Page.kt @@ -0,0 +1,181 @@ +package com.example.login_v3.home.setting.setting_detail_page + +import androidx.compose.foundation.Image +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.offset +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.Divider +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.blur +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.layout.ContentScale +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import com.example.login_v3.R + +@Composable +fun setting_profile_page(){ + Column( + modifier = Modifier.fillMaxSize() + ) { + + val avatarSize = 80.dp + val avatarOffset = avatarSize / 2 + 20.dp + + + Box() { + //glass effect + Box(modifier = Modifier.matchParentSize().blur(10.dp)) + Box( + modifier = Modifier + .matchParentSize() + .background(Color.White.copy(alpha = 0.08f), RoundedCornerShape(16.dp)) + .border(1.dp, Color.White.copy(alpha = 0.3f), RoundedCornerShape(16.dp)) + ) + + Column() { + + Box( + modifier = Modifier + .fillMaxWidth() + .height(272.dp) + ){ + + Box( + modifier = Modifier + .padding(12.dp) + .clip(RoundedCornerShape(16.dp)) + ){ + // 1. 封面圖 (背景) + Image( + painter = painterResource(id = R.drawable.thumbnail_v1), + contentDescription = null, + contentScale = ContentScale.Crop, + modifier = Modifier + .fillMaxWidth() + .height(180.dp) + ) + } + + Row( + modifier = Modifier + .align(Alignment.BottomStart) + .offset(y = -10.dp) + , + verticalAlignment = Alignment.CenterVertically + + ){ + Spacer(modifier = Modifier.width(36.dp)) + //user avatar + Image( + painter = painterResource(id = R.drawable.avatar_v1), // 把 JPG 放在 res/drawable + contentDescription = "avatar", + modifier = Modifier + .size(avatarSize) + .clip(CircleShape) + , + contentScale = ContentScale.Crop + ) + + Spacer(modifier = Modifier.width(20.dp)) + + Text(text = "Eric Chen", + fontSize = 36.sp, + fontWeight = FontWeight.Medium, + modifier = Modifier + .padding(top = 14.dp) + ) + } + } + + } + } + + + Spacer(modifier = Modifier.height(20.dp)) + + //user detail + Box(){ + //glass effect + Box(modifier = Modifier.matchParentSize().blur(10.dp)) + Box( + modifier = Modifier + .matchParentSize() + .background(Color.White.copy(alpha = 0.08f), RoundedCornerShape(16.dp)) + .border(1.dp, Color.White.copy(alpha = 0.3f), RoundedCornerShape(16.dp)) + ) + + //intro + Column( + modifier = Modifier + .padding(20.dp) + ) { + // mutual friends + Text(text = "258 mutual friends", + fontSize = 20.sp, + ) + Divider( + color = Color.White.copy(alpha = 0.4f), + thickness = 0.5.dp, + modifier = Modifier.padding(vertical = 8.dp) + ) + + //mutual server + Text(text = "25 servers", + fontSize = 20.sp, + ) + Divider( + color = Color.White.copy(alpha = 0.4f), + thickness = 0.5.dp, + modifier = Modifier.padding(vertical = 8.dp) + ) + + //gender + Text( + text = "male", + fontSize = 22.sp + ) + Divider( + color = Color.White.copy(alpha = 0.4f), + thickness = 0.5.dp, + modifier = Modifier.padding(vertical = 8.dp) + ) + + //location + Text( + text = "Taiwan", + fontSize = 22.sp + ) + Divider( + color = Color.White.copy(alpha = 0.4f), + thickness = 0.5.dp, + modifier = Modifier.padding(vertical = 8.dp) + ) + + //intro + Text( + text = "Founder of JFF studios，Software Dev Guy，3D Artist", + fontSize = 16.sp + ) + } + } + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/home/setting/setting_detail_page/setting_Subscription_Page.kt b/app/src/main/java/com/example/login_v3/home/setting/setting_detail_page/setting_Subscription_Page.kt new file mode 100644 index 0000000..235e1fb --- /dev/null +++ b/app/src/main/java/com/example/login_v3/home/setting/setting_detail_page/setting_Subscription_Page.kt @@ -0,0 +1,12 @@ +package com.example.login_v3.home.setting.setting_detail_page + +import androidx.compose.foundation.layout.Column +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable + +@Composable +fun setting_subscription_page(){ + Column() { + Text(text = "setting_sub_page") + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/home/setting/setting_detail_page/setting_Theme_Page.kt b/app/src/main/java/com/example/login_v3/home/setting/setting_detail_page/setting_Theme_Page.kt new file mode 100644 index 0000000..c9343de --- /dev/null +++ b/app/src/main/java/com/example/login_v3/home/setting/setting_detail_page/setting_Theme_Page.kt @@ -0,0 +1,12 @@ +package com.example.login_v3.home.setting.setting_detail_page + +import androidx.compose.foundation.layout.Column +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable + +@Composable +fun setting_theme_page(){ + Column() { + Text(text = "setting_Theme_page") + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/navigation/MainViewModel.kt b/app/src/main/java/com/example/login_v3/navigation/MainViewModel.kt new file mode 100644 index 0000000..4202fef --- /dev/null +++ b/app/src/main/java/com/example/login_v3/navigation/MainViewModel.kt @@ -0,0 +1,41 @@ +package com.example.login_v3.navigation + +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.lifecycle.ViewModel +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow + +class MainViewModel : ViewModel() { + + var selectedTab by mutableStateOf(1) + private set + + fun selectTab(index: Int) { + selectedTab = index + } +} + + +//init navigation +enum class AppScreen { + PreReg, Login, Register, Home, ScreensTab +} + +class AppViewModel : ViewModel() { + private val _currentScreen = MutableStateFlow(AppScreen.ScreensTab) + val currentScreen: StateFlow = _currentScreen + + fun goTo(screen: AppScreen) { + _currentScreen.value = screen + } + + fun onLoginSuccess() { + _currentScreen.value = AppScreen.Home + } + + fun onLogout() { + _currentScreen.value = AppScreen.PreReg + } +} diff --git a/app/src/main/java/com/example/login_v3/navigation/Main_Screen_tab.kt b/app/src/main/java/com/example/login_v3/navigation/Main_Screen_tab.kt new file mode 100644 index 0000000..5cca33d --- /dev/null +++ b/app/src/main/java/com/example/login_v3/navigation/Main_Screen_tab.kt @@ -0,0 +1,141 @@ +package com.example.login_v3.navigation + +import androidx.compose.animation.AnimatedVisibility +import androidx.compose.animation.core.animateDpAsState +import androidx.compose.animation.core.animateFloatAsState +import androidx.compose.animation.fadeIn +import androidx.compose.animation.fadeOut +import androidx.compose.animation.slideInVertically +import androidx.compose.animation.slideOutVertically +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.BoxScope +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.offset +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Scaffold +import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.shadow +import androidx.compose.ui.graphics.Brush +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.graphicsLayer +import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.dp +import androidx.navigation.NavHostController +import com.example.login_v3.home.MessageViewModel +import com.example.login_v3.home.Tg_MarketPlace +import com.example.login_v3.home.Tg_Message +import com.example.login_v3.home.Tg_Server +import com.example.login_v3.home.setting.Tg_Setting +import androidx.lifecycle.viewmodel.compose.viewModel + + + +@Composable +fun MainScreen_tab() { + + val screensViewModel: ScreensViewModel = viewModel() + val bottomBarViewModel: BottomBarViewModel = viewModel() + + //show bottom bar or not + val showBottomBar by bottomBarViewModel.showBottomBar.collectAsState() + val navHeight = 64.dp + val gap = 40.dp + val bottomBarHeight = navHeight + gap + + Scaffold( + containerColor = Color.Transparent, + modifier = Modifier + .fillMaxSize() + .background(brush = Brush.verticalGradient( + colors = listOf( + Color(0xFFDA7029), + Color(0xFF777777), + Color(0xFFB34800) + ) + )), + + bottomBar = { + BottomBarAnimated( + visible = showBottomBar, + height = bottomBarHeight, + content = { + Column(modifier = Modifier.fillMaxWidth()) { + Box( + modifier = Modifier + .fillMaxWidth() + .height(navHeight) + ) { + nav_Wheel_display_block(screensViewModel = screensViewModel) + } + Spacer(modifier = Modifier.height(gap)) // 真正的底下空白 + } + } + ) + } + ) { innerPadding -> + Screens_NavGraph( + paddingValues = innerPadding, + screensViewModel = screensViewModel, + bottomBarViewModel = bottomBarViewModel + ) + } +} + +@Composable +fun BottomBarAnimated( + visible: Boolean, + height: Dp, + content: @Composable BoxScope.() -> Unit +) { + // 位移與透明度動畫 + val offsetY by animateDpAsState(targetValue = if (visible) 0.dp else height) + val alpha by animateFloatAsState(targetValue = if (visible) 1f else 0f) + + Box( + modifier = Modifier + .fillMaxWidth() + .height(height) + .offset(y = offsetY) + .graphicsLayer { this.alpha = alpha } + .background(Color.Transparent), + content = content + ) +} + +@Composable +fun Screens_NavGraph( + paddingValues: PaddingValues, + screensViewModel: ScreensViewModel, + bottomBarViewModel: BottomBarViewModel, + messageViewModel: MessageViewModel = androidx.lifecycle.viewmodel.compose.viewModel() +) { + //nav_wheel_selecting tab + val selectedScreen by screensViewModel.selected.collectAsState() + //message_contact_list_import + val contacts by messageViewModel.contacts.collectAsState() + + + when (selectedScreen) { + Screen.Message -> Tg_Message() + Screen.Server -> Tg_Server(viewModel = viewModel()) + Screen.MarketPlace -> Tg_MarketPlace() + Screen.Setting -> Tg_Setting( + bottomBarViewModel = bottomBarViewModel + ) + } +} + + diff --git a/app/src/main/java/com/example/login_v3/navigation/Screen.kt b/app/src/main/java/com/example/login_v3/navigation/Screen.kt new file mode 100644 index 0000000..a451925 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/navigation/Screen.kt @@ -0,0 +1,10 @@ +package com.example.login_v3.navigation + +import androidx.compose.ui.graphics.vector.ImageVector + +sealed class Screen(val route: String, val label: String? = null, val icon: ImageVector? = null) { + object Message : Screen("message", label = "Message") + object Server : Screen("server", label = "Server") + object MarketPlace : Screen("marketplace", label = "MarketPlace") + object Setting : Screen("setting", label = "Setting") +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/navigation/ScreensViewModel.kt b/app/src/main/java/com/example/login_v3/navigation/ScreensViewModel.kt new file mode 100644 index 0000000..db4d75b --- /dev/null +++ b/app/src/main/java/com/example/login_v3/navigation/ScreensViewModel.kt @@ -0,0 +1,25 @@ +package com.example.login_v3.navigation + +import androidx.lifecycle.ViewModel +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow + + +class ScreensViewModel : ViewModel() { + private val _selected = MutableStateFlow(Screen.Message) + val selected: StateFlow = _selected + + fun select(screen: Screen) { + _selected.value = screen + } +} + +// BottomBarViewModel 放在同一個檔案，但仍是獨立的 ViewModel 類別 +class BottomBarViewModel : ViewModel() { + private val _showBottomBar = MutableStateFlow(true) + val showBottomBar: StateFlow = _showBottomBar + + fun setVisible(visible: Boolean) { + _showBottomBar.value = visible + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/navigation/nav_Wheel_display.kt b/app/src/main/java/com/example/login_v3/navigation/nav_Wheel_display.kt new file mode 100644 index 0000000..7eb3f8e --- /dev/null +++ b/app/src/main/java/com/example/login_v3/navigation/nav_Wheel_display.kt @@ -0,0 +1,209 @@ +package com.example.login_v3.navigation + +import androidx.compose.animation.core.FastOutSlowInEasing +import androidx.compose.animation.core.animateDpAsState +import androidx.compose.animation.core.animateFloatAsState +import androidx.compose.animation.core.tween +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.gestures.snapping.rememberSnapFlingBehavior +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxHeight +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyRow +import androidx.compose.foundation.lazy.itemsIndexed +import androidx.compose.foundation.lazy.rememberLazyListState +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Dns +import androidx.compose.material.icons.filled.Extension +import androidx.compose.material.icons.filled.Message +import androidx.compose.material.icons.filled.Settings +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.derivedStateOf +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.BlurredEdgeTreatment +import androidx.compose.ui.draw.blur +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.unit.dp +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.runtime.snapshotFlow +import androidx.compose.ui.graphics.graphicsLayer +import androidx.compose.ui.unit.Dp +import kotlinx.coroutines.flow.filter +import androidx.compose.ui.graphics.vector.ImageVector +import androidx.compose.material3.Icon +import androidx.navigation.NavHostController + + +//nav_wheel_icon數據 +data class WheelItemData( + val icon: ImageVector, + val screen: Screen +) + + +@Composable +fun nav_Wheel_display_block( + screensViewModel: ScreensViewModel +) { + var isPressed by remember { mutableStateOf(false) } + + //position_animation + val floatingOffset by animateDpAsState( + targetValue = if (isPressed) (-80).dp else 0.dp, + animationSpec = tween(durationMillis = 160, easing = FastOutSlowInEasing) + ) + //scale_animation + val scale by animateFloatAsState( + targetValue = if (isPressed) 1.2f else 1f, + animationSpec = tween(durationMillis = 200, easing = FastOutSlowInEasing) + ) + + //different tab + val items = listOf( + WheelItemData(Icons.Filled.Message, Screen.Message), + WheelItemData(Icons.Filled.Dns, Screen.Server), + WheelItemData(Icons.Filled.Extension, Screen.MarketPlace), + WheelItemData(Icons.Filled.Settings, Screen.Setting) + ) + + Column( + modifier = Modifier.fillMaxSize(), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.Bottom + ) { + Box( + modifier = Modifier.graphicsLayer { + translationY = floatingOffset.toPx() + scaleX = scale + scaleY = scale + } + ) { + HorizontalWheelPicker( + items = items, + onValueChange = { item -> screensViewModel.select(item.screen) }, + onInteractionChanged = { isPressed = it } + ) + } + } +} + + + + + +//wheel picker +@Composable +fun HorizontalWheelPicker( + items: List, + itemWidth: Dp = 80.dp, + onValueChange: (WheelItemData) -> Unit, + onInteractionChanged: (Boolean) -> Unit +) { + val listState = rememberLazyListState() + val flingBehavior = rememberSnapFlingBehavior(listState) + + // 計算動態 horizontal padding（假設 LazyRow 佔滿螢幕寬度） + val screenWidthDp = androidx.compose.ui.platform.LocalConfiguration.current.screenWidthDp.dp + val horizontalPadding = (screenWidthDp - itemWidth) / 2 + + Box(modifier = Modifier + .fillMaxWidth() + .height(60.dp) + ) { + LazyRow( + state = listState, + flingBehavior = flingBehavior, + contentPadding = PaddingValues(horizontal = horizontalPadding), + modifier = Modifier.fillMaxSize() + ) { + itemsIndexed(items, key = { index, _ -> index }) { index, item -> + WheelItem(index = index, itemWidth = itemWidth, item = item) + } + } + + // 中央指示線（不變） + Box( + modifier = Modifier + .align(Alignment.Center) + .width(itemWidth) + .fillMaxHeight() + ) { + Box( + modifier = Modifier + .matchParentSize() + .clip(RoundedCornerShape(16.dp)) + .blur(10.dp, edgeTreatment = BlurredEdgeTreatment.Unbounded) + .background(Color.White.copy(alpha = 0.18f)) + .border(1.dp, Color.White.copy(alpha = 0.35f), RoundedCornerShape(16.dp)) + ) + } + } + + val isInteracting by remember { derivedStateOf { listState.isScrollInProgress } } + + // 使用 layoutInfo.visibleItemsInfo 計算最接近中心的 item + LaunchedEffect(listState) { + snapshotFlow { listState.layoutInfo.visibleItemsInfo } + .filter { it.isNotEmpty() } + .collect { visibleItems -> + val viewportCenter = + (listState.layoutInfo.viewportStartOffset + listState.layoutInfo.viewportEndOffset) / 2 + + val closest = visibleItems.minByOrNull { vi -> + kotlin.math.abs((vi.offset + vi.size / 2) - viewportCenter) + } ?: visibleItems.first() + + val selectedIndex = closest.key as Int + onValueChange(items[selectedIndex]) + + } + } + + // 通知互動狀態 + LaunchedEffect(isInteracting) { + onInteractionChanged(isInteracting) + } +} + + + +//wheel item + + +@Composable +fun WheelItem( + index: Int, + itemWidth: Dp, + item: WheelItemData +) { + Box( + modifier = Modifier + .width(itemWidth) + .fillMaxHeight(), + contentAlignment = Alignment.Center + ) { + Icon( + imageVector = item.icon, + contentDescription = null, + tint = Color.White, + modifier = Modifier.size(28.dp) + ) + } +} + diff --git a/app/src/main/java/com/example/login_v3/navigation/nav_controller.kt b/app/src/main/java/com/example/login_v3/navigation/nav_controller.kt new file mode 100644 index 0000000..8e0a764 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/navigation/nav_controller.kt @@ -0,0 +1,56 @@ +package com.example.login_v3.navigation + +import android.R.attr.padding +import androidx.activity.compose.BackHandler +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.hilt.navigation.compose.hiltViewModel +import androidx.lifecycle.viewmodel.compose.viewModel +import androidx.navigation.NavHostController +import androidx.navigation.compose.NavHost +import androidx.navigation.compose.composable +import androidx.navigation.compose.rememberNavController +import com.example.login_v3.auth.LoginScreen +import com.example.login_v3.auth.LoginViewModel +import com.example.login_v3.auth.Login_or_Reg_page +import com.example.login_v3.auth.Register_Screen +import com.example.login_v3.home.HomeScreen +import com.example.login_v3.home.Tg_MarketPlace + +@Composable +fun AppNavGraph( + paddingValues: PaddingValues, + appViewModel: AppViewModel = viewModel() +) { + val currentScreen by appViewModel.currentScreen.collectAsState() + + when (currentScreen) { + AppScreen.PreReg -> Login_or_Reg_page( + paddingValues = paddingValues, + onLoginClick = { appViewModel.goTo(AppScreen.Login) }, + onRegClick = { appViewModel.goTo(AppScreen.Register) } + ) + + AppScreen.Login -> LoginScreen( + paddingValues = paddingValues, + onLoginSuccess = { appViewModel.onLoginSuccess() } + ) + + AppScreen.Register -> { + //back to pre_reg + BackHandler { + appViewModel.goTo(AppScreen.PreReg) + } + Register_Screen(paddingValues = paddingValues) + } + + AppScreen.Home -> HomeScreen( + paddingValues = paddingValues, + onLogout = { appViewModel.onLogout() } + ) + + AppScreen.ScreensTab -> MainScreen_tab() + } +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/ui/theme/Color.kt b/app/src/main/java/com/example/login_v3/ui/theme/Color.kt new file mode 100644 index 0000000..c3d9de3 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/ui/theme/Color.kt @@ -0,0 +1,14 @@ +package com.example.login_v3.ui.theme + +import androidx.compose.ui.graphics.Color + +val Purple80 = Color(0xFFD0BCFF) +val PurpleGrey80 = Color(0xFFCCC2DC) +val Pink80 = Color(0xFFEFB8C8) + +val Purple40 = Color(0xFF6650a4) +val PurpleGrey40 = Color(0xFF625b71) +val Pink40 = Color(0xFF7D5260) + +val main_orange = Color(0xFFFF6700) +val light_orange = Color(0xFFFFAD00) \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/ui/theme/Theme.kt b/app/src/main/java/com/example/login_v3/ui/theme/Theme.kt new file mode 100644 index 0000000..fa8bd87 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/ui/theme/Theme.kt @@ -0,0 +1,58 @@ +package com.example.login_v3.ui.theme + +import android.app.Activity +import android.os.Build +import androidx.compose.foundation.isSystemInDarkTheme +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.darkColorScheme +import androidx.compose.material3.dynamicDarkColorScheme +import androidx.compose.material3.dynamicLightColorScheme +import androidx.compose.material3.lightColorScheme +import androidx.compose.runtime.Composable +import androidx.compose.ui.platform.LocalContext + +private val DarkColorScheme = darkColorScheme( + primary = main_orange, + secondary = light_orange, + tertiary = Pink80 +) + +private val LightColorScheme = lightColorScheme( + primary = main_orange, + secondary = light_orange, + tertiary = Pink40 + + /* Other default colors to override + background = Color(0xFFFFFBFE), + surface = Color(0xFFFFFBFE), + onPrimary = Color.White, + onSecondary = Color.White, + onTertiary = Color.White, + onBackground = Color(0xFF1C1B1F), + onSurface = Color(0xFF1C1B1F), + */ +) + +@Composable +fun Login_V3Theme( + darkTheme: Boolean = isSystemInDarkTheme(), + // Dynamic color is available on Android 12+ + dynamicColor: Boolean = true, + content: @Composable () -> Unit +) { + val colorScheme = when { + dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> { + val context = LocalContext.current + if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context) + } + + darkTheme -> DarkColorScheme + else -> LightColorScheme + } + + MaterialTheme( + colorScheme = colorScheme, + typography = Typography, + content = content + ) +} \ No newline at end of file diff --git a/app/src/main/java/com/example/login_v3/ui/theme/Type.kt b/app/src/main/java/com/example/login_v3/ui/theme/Type.kt new file mode 100644 index 0000000..629ff57 --- /dev/null +++ b/app/src/main/java/com/example/login_v3/ui/theme/Type.kt @@ -0,0 +1,34 @@ +package com.example.login_v3.ui.theme + +import androidx.compose.material3.Typography +import androidx.compose.ui.text.TextStyle +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.sp + +// Set of Material typography styles to start with +val Typography = Typography( + bodyLarge = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Normal, + fontSize = 16.sp, + lineHeight = 24.sp, + letterSpacing = 0.5.sp + ) + /* Other default text styles to override + titleLarge = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Normal, + fontSize = 22.sp, + lineHeight = 28.sp, + letterSpacing = 0.sp + ), + labelSmall = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Medium, + fontSize = 11.sp, + lineHeight = 16.sp, + letterSpacing = 0.5.sp + ) + */ +) \ No newline at end of file diff --git a/app/src/main/res/drawable/avatar_v1.jpg b/app/src/main/res/drawable/avatar_v1.jpg new file mode 100644 index 0000000..3e69a52 Binary files /dev/null and b/app/src/main/res/drawable/avatar_v1.jpg differ diff --git a/app/src/main/res/drawable/ic_launcher_background.xml b/app/src/main/res/drawable/ic_launcher_background.xml new file mode 100644 index 0000000..07d5da9 --- /dev/null +++ b/app/src/main/res/drawable/ic_launcher_background.xml @@ -0,0 +1,170 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/src/main/res/drawable/ic_launcher_foreground.xml b/app/src/main/res/drawable/ic_launcher_foreground.xml new file mode 100644 index 0000000..2b068d1 --- /dev/null +++ b/app/src/main/res/drawable/ic_launcher_foreground.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/tg_chat2d_v13.png b/app/src/main/res/drawable/tg_chat2d_v13.png new file mode 100644 index 0000000..da5d90a Binary files /dev/null and b/app/src/main/res/drawable/tg_chat2d_v13.png differ diff --git a/app/src/main/res/drawable/tg_logo_zoom_v1.png b/app/src/main/res/drawable/tg_logo_zoom_v1.png new file mode 100644 index 0000000..f9e3c4e Binary files /dev/null and b/app/src/main/res/drawable/tg_logo_zoom_v1.png differ diff --git a/app/src/main/res/drawable/thumbnail_v1.png b/app/src/main/res/drawable/thumbnail_v1.png new file mode 100644 index 0000000..3fe5a8a Binary files /dev/null and b/app/src/main/res/drawable/thumbnail_v1.png differ diff --git a/app/src/main/res/mipmap-anydpi/ic_launcher.xml b/app/src/main/res/mipmap-anydpi/ic_launcher.xml new file mode 100644 index 0000000..6f3b755 --- /dev/null +++ b/app/src/main/res/mipmap-anydpi/ic_launcher.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/app/src/main/res/mipmap-anydpi/ic_launcher_round.xml b/app/src/main/res/mipmap-anydpi/ic_launcher_round.xml new file mode 100644 index 0000000..6f3b755 --- /dev/null +++ b/app/src/main/res/mipmap-anydpi/ic_launcher_round.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher.webp b/app/src/main/res/mipmap-hdpi/ic_launcher.webp new file mode 100644 index 0000000..c209e78 Binary files /dev/null and b/app/src/main/res/mipmap-hdpi/ic_launcher.webp differ diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp new file mode 100644 index 0000000..b2dfe3d Binary files /dev/null and b/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp differ diff --git a/app/src/main/res/mipmap-mdpi/ic_launcher.webp b/app/src/main/res/mipmap-mdpi/ic_launcher.webp new file mode 100644 index 0000000..4f0f1d6 Binary files /dev/null and b/app/src/main/res/mipmap-mdpi/ic_launcher.webp differ diff --git a/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp new file mode 100644 index 0000000..62b611d Binary files /dev/null and b/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp differ diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher.webp b/app/src/main/res/mipmap-xhdpi/ic_launcher.webp new file mode 100644 index 0000000..948a307 Binary files /dev/null and b/app/src/main/res/mipmap-xhdpi/ic_launcher.webp differ diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp new file mode 100644 index 0000000..1b9a695 Binary files /dev/null and b/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp differ diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp b/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp new file mode 100644 index 0000000..28d4b77 Binary files /dev/null and b/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp differ diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp new file mode 100644 index 0000000..9287f50 Binary files /dev/null and b/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp differ diff --git a/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp b/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp new file mode 100644 index 0000000..aa7d642 Binary files /dev/null and b/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp differ diff --git a/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp new file mode 100644 index 0000000..9126ae3 Binary files /dev/null and b/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp differ diff --git a/app/src/main/res/raw/fullchain1.crt b/app/src/main/res/raw/fullchain1.crt new file mode 100644 index 0000000..276df2c --- /dev/null +++ b/app/src/main/res/raw/fullchain1.crt @@ -0,0 +1,48 @@ +-----BEGIN CERTIFICATE----- +MIIDsTCCAzegAwIBAgISBk04PnNRbDK7k8y6K1rWIU5KMAoGCCqGSM49BAMDMDIx +CzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1MZXQncyBFbmNyeXB0MQswCQYDVQQDEwJF +ODAeFw0yNjA0MTcwODIyMjRaFw0yNjA3MTYwODIyMjNaMCAxHjAcBgNVBAMTFXRn +LnRlY2hub2xvZ2lhLXR3LmNvbTB2MBAGByqGSM49AgEGBSuBBAAiA2IABID+bF06 +cwXMT3n0YXUylFIioGDgRjzZ0J2pgJFDsqBn+tM80wZwMmnhApI0rhCWI84aybFz +7U5YyzZ911w85Mi43ZCZ0hz8J3UjIP0rxqlocGCLUltF16+RdPsothbO4qOCAiAw +ggIcMA4GA1UdDwEB/wQEAwIHgDATBgNVHSUEDDAKBggrBgEFBQcDATAMBgNVHRMB +Af8EAjAAMB0GA1UdDgQWBBT6AgbGomnDB1DXHrA6GP+PqSfCOTAfBgNVHSMEGDAW +gBSPDROi9i5+0VBsMxg4XVmOI3KRyjAyBggrBgEFBQcBAQQmMCQwIgYIKwYBBQUH +MAKGFmh0dHA6Ly9lOC5pLmxlbmNyLm9yZy8wIAYDVR0RBBkwF4IVdGcudGVjaG5v +bG9naWEtdHcuY29tMBMGA1UdIAQMMAowCAYGZ4EMAQIBMC0GA1UdHwQmMCQwIqAg +oB6GHGh0dHA6Ly9lOC5jLmxlbmNyLm9yZy83NS5jcmwwggELBgorBgEEAdZ5AgQC +BIH8BIH5APcAdgDIo8R/x7OtuTVrAT9qehJt4zpOQ6XGRvmXrTl1mR3PmgAAAZ2a +vkWAAAAEAwBHMEUCIQDsHoBUCvx7jcRxWA962rCQC5Lm0nGpuUVmu3PPySCkjwIg +P64SbSkWuJVt0Pov7izzeUD2PdKt9tMGC3HYFHEU3iMAfQBGr4Y9Oz7ln6V33qgk +XTaw2e0ioiP0YXdBIpRS7pVQXwAAAZ2avkY5AAgAAAUABByQ6AQDAEYwRAIgPcu4 +01rw3VkZ3HUK7yJuN+ITSyGoRJl174XPX8dztNUCIBg8FLvQksKWBTFKYVvOQEN2 +joDgOh748gPgA3zedtStMAoGCCqGSM49BAMDA2gAMGUCMQC/qGFju5J53FGnn6c5 +NxKOqSUwFs6r4k3tXxNa/xa0HjrlSm+1twq8cewj702WzMECMAKwit2DW3oe1Umy +8lnIfQiHFNZIB021+MdCDm1VvQXv1Jbx8PImXi+E9EPr7sValQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEVjCCAj6gAwIBAgIQY5WTY8JOcIJxWRi/w9ftVjANBgkqhkiG9w0BAQsFADBP +MQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJuZXQgU2VjdXJpdHkgUmVzZWFy +Y2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBYMTAeFw0yNDAzMTMwMDAwMDBa +Fw0yNzAzMTIyMzU5NTlaMDIxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1MZXQncyBF +bmNyeXB0MQswCQYDVQQDEwJFODB2MBAGByqGSM49AgEGBSuBBAAiA2IABNFl8l7c +S7QMApzSsvru6WyrOq44ofTUOTIzxULUzDMMNMchIJBwXOhiLxxxs0LXeb5GDcHb +R6EToMffgSZjO9SNHfY9gjMy9vQr5/WWOrQTZxh7az6NSNnq3u2ubT6HTKOB+DCB +9TAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMB +MBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFI8NE6L2Ln7RUGwzGDhdWY4j +cpHKMB8GA1UdIwQYMBaAFHm0WeZ7tuXkAXOACIjIGlj26ZtuMDIGCCsGAQUFBwEB +BCYwJDAiBggrBgEFBQcwAoYWaHR0cDovL3gxLmkubGVuY3Iub3JnLzATBgNVHSAE +DDAKMAgGBmeBDAECATAnBgNVHR8EIDAeMBygGqAYhhZodHRwOi8veDEuYy5sZW5j +ci5vcmcvMA0GCSqGSIb3DQEBCwUAA4ICAQBnE0hGINKsCYWi0Xx1ygxD5qihEjZ0 +RI3tTZz1wuATH3ZwYPIp97kWEayanD1j0cDhIYzy4CkDo2jB8D5t0a6zZWzlr98d +AQFNh8uKJkIHdLShy+nUyeZxc5bNeMp1Lu0gSzE4McqfmNMvIpeiwWSYO9w82Ob8 +otvXcO2JUYi3svHIWRm3+707DUbL51XMcY2iZdlCq4Wa9nbuk3WTU4gr6LY8MzVA +aDQG2+4U3eJ6qUF10bBnR1uuVyDYs9RhrwucRVnfuDj29CMLTsplM5f5wSV5hUpm +Uwp/vV7M4w4aGunt74koX71n4EdagCsL/Yk5+mAQU0+tue0JOfAV/R6t1k+Xk9s2 +HMQFeoxppfzAVC04FdG9M+AC2JWxmFSt6BCuh3CEey3fE52Qrj9YM75rtvIjsm/1 +Hl+u//Wqxnu1ZQ4jpa+VpuZiGOlWrqSP9eogdOhCGisnyewWJwRQOqK16wiGyZeR +xs/Bekw65vwSIaVkBruPiTfMOo0Zh4gVa8/qJgMbJbyrwwG97z/PRgmLKCDl8z3d +tA0Z7qq7fta0Gl24uyuB05dqI5J1LvAzKuWdIjT1tP8qCoxSE/xpix8hX2dt3h+/ +jujUgFPFZ0EVZ0xSyBNRF3MboGZnYXFUxpNjTWPKpagDHJQmqrAcDmWJnMsFY3jS +u1igv3OefnWjSQ== +-----END CERTIFICATE----- diff --git a/app/src/main/res/raw/motion_logo_v1.json b/app/src/main/res/raw/motion_logo_v1.json new file mode 100644 index 0000000..51866e9 --- /dev/null +++ b/app/src/main/res/raw/motion_logo_v1.json @@ -0,0 +1 @@ +{"nm":"start","ddd":0,"h":2000,"w":2000,"meta":{"g":"LottieFiles Figma v107"},"layers":[{"ty":0,"nm":"tg_chat2d_V13 1","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":true,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"masksProperties":[{"nm":"","inv":false,"mode":"a","x":{"a":0,"k":0},"o":{"a":0,"k":100},"pt":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[2000,0],[2000,2000],[0,2000],[0,0]]}],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[2000,0],[2000,2000],[0,2000],[0,0]]}],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[2000,0],[2000,2000],[0,2000],[0,0]]}],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[2000,0],[2000,2000],[0,2000],[0,0]]}],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[2000,0],[2000,2000],[0,2000],[0,0]]}],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[2000,0],[2000,2000],[0,2000],[0,0]]}],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[2000,0],[2000,2000],[0,2000],[0,0]]}],"t":90},{"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[2000,0],[2000,2000],[0,2000],[0,0]]}],"t":102}]}}],"w":2000,"h":2000,"refId":"1","ind":1}],"v":"5.7.0","fr":60,"op":90,"ip":0,"assets":[{"nm":"[Asset] tg_chat2d_V13 1","id":"1","layers":[{"ty":4,"nm":"Group","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[385,223.63]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[685,631.63],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[685,631.63],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[685,543.63],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[685,543.63],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[685,631.63],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[685,631.63],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[685,631.63],"t":90},{"s":[685,631.63],"t":102}]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[],"ind":1},{"ty":4,"nm":"Vector","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[385,223.63]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[385,223.63]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[{"ty":"sh","bm":0,"hd":false,"nm":"","d":1,"ks":{"a":0,"k":{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[-105.49,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,-105.49],[0,0],[0,0]],"v":[[770,0],[770,447.26],[0,447.26],[0,191.01],[191,0],[770,0]]}}},{"ty":"st","bm":0,"hd":false,"nm":"","lc":2,"lj":2,"ml":1.5,"o":{"a":0,"k":100},"w":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[31.256378173828125],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[31.256378173828125],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[31.256378173828125],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[31.256378173828125],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[31.256378173828125],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[31.256378173828125],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[31.256378173828125],"t":90},{"s":[31.256378173828125],"t":102}]},"c":{"a":0,"k":[0.8785,0.4393,0]}},{"ty":"fl","bm":0,"hd":false,"nm":"","c":{"a":0,"k":[1,0.9569,0.0589]},"r":2,"o":{"a":0,"k":10}}],"ind":2,"parent":1},{"ty":4,"nm":"base_color","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[],"ind":3},{"ty":4,"nm":"Mask group","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[],"ind":4,"parent":3},{"ty":4,"nm":"Group","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000.53,835.55]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[999.99,1055.97]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[],"ind":5,"parent":4},{"ty":4,"nm":"Clip path group","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000.53,835.55]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000.53,835.55]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[],"ind":6,"parent":5},{"ty":0,"nm":"_clip4","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"td":1,"ao":0,"ks":{"a":{"a":0,"k":[1000.53,835.55]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000.53,835.55]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"w":2001.05029296875,"h":2000,"refId":"3","ind":7,"parent":6},{"ty":4,"nm":"Group","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"tt":1,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000,836]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000.53,836]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[],"ind":8,"parent":6},{"ty":0,"nm":"_clip4","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"td":1,"ao":0,"ks":{"a":{"a":0,"k":[1000.53,835.55]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000.53,835.55]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"w":2001.05029296875,"h":2000,"refId":"3","ind":9,"parent":6},{"ty":4,"nm":"Group","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"tt":1,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000,836]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,836]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[],"ind":10,"parent":8},{"ty":0,"nm":"_clip4","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"td":1,"ao":0,"ks":{"a":{"a":0,"k":[1000.53,835.55]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000.53,835.55]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"w":2001.05029296875,"h":2000,"refId":"3","ind":11,"parent":6},{"ty":4,"nm":"Rectangle (Border)","sr":1,"st":0,"op":102,"ip":0,"hd":false,"ddd":0,"bm":0,"tt":1,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[999.9996948242188,835.9983520507812]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[999.9996948242188,835.9983520507812]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[{"ty":"sh","bm":0,"hd":false,"nm":"","d":1,"ks":{"a":0,"k":{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,1672],[0,1672],[0,0]]}}},{"ty":"st","bm":0,"hd":false,"nm":"","lc":2,"lj":2,"ml":1,"o":{"a":0,"k":0},"w":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":90},{"s":[0],"t":102}]},"c":{"a":0,"k":[0,0,0]}}],"ind":12,"parent":10},{"ty":0,"nm":"_clip4","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"td":1,"ao":0,"ks":{"a":{"a":0,"k":[1000.53,835.55]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000.53,835.55]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"w":2001.05029296875,"h":2000,"refId":"3","ind":13,"parent":6},{"ty":4,"nm":"Rectangle (Mask)","sr":1,"st":0,"op":102,"ip":0,"hd":false,"ddd":0,"bm":0,"tt":1,"hasMask":false,"td":1,"ao":0,"ks":{"a":{"a":0,"k":[0,0]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[0,0]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[{"ty":"gr","bm":0,"hd":false,"nm":"","it":[{"ty":"sh","bm":0,"hd":false,"nm":"","d":1,"ks":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,1672],[0,1672],[0,0]]}],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,1672],[0,1672],[0,0]]}],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,1672],[0,1672],[0,0]]}],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,1672],[0,1672],[0,0]]}],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,1672],[0,1672],[0,0]]}],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,1672],[0,1672],[0,0]]}],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,1672],[0,1672],[0,0]]}],"t":90},{"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,1672],[0,1672],[0,0]]}],"t":102}]}},{"ty":"fl","bm":0,"hd":false,"nm":"","c":{"a":0,"k":[1,0,0]},"r":2,"o":{"a":0,"k":100}},{"ty":"tr","a":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,835.9983520507812],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,835.9983520507812],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,835.9983520507812],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,835.9983520507812],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,835.9983520507812],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,835.9983520507812],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,835.9983520507812],"t":90},{"s":[999.9996948242188,835.9983520507812],"t":102}]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,835.9983520507812],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,835.9983520507812],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,835.9983520507812],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,835.9983520507812],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,835.9983520507812],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,835.9983520507812],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,835.9983520507812],"t":90},{"s":[999.9996948242188,835.9983520507812],"t":102}]},"r":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":90},{"s":[0],"t":102}]},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}}]}],"ind":14,"parent":10},{"ty":0,"nm":"_clip4","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"td":1,"ao":0,"ks":{"a":{"a":0,"k":[1000.53,835.55]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000.53,835.55]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"w":2001.05029296875,"h":2000,"refId":"3","ind":15,"parent":6},{"ty":2,"nm":"Rectangle","sr":1,"st":0,"op":102,"ip":0,"hd":false,"ddd":0,"bm":0,"tt":1,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000,836]},"s":{"a":0,"k":[99.99996948242188,99.99980287688771]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[999.9996948242188,835.9983520507812]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"refId":"c49ef74dede5d64db54db7fa3523df362806ad8f","ind":16,"parent":10},{"ty":0,"nm":"Group","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"td":1,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"w":2000,"h":2000,"refId":"4","ind":17,"parent":4},{"ty":4,"nm":"base_color_2","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[999.99,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.99,1000],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.99,1000],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.99,912],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.99,912],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.99,1000],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.99,1000],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.99,1000],"t":90},{"s":[999.99,1000],"t":102}]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[],"ind":18},{"ty":4,"nm":"Mask group","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[999.99,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[999.99,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[],"ind":19,"parent":18},{"ty":4,"nm":"Group","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[],"ind":20,"parent":19},{"ty":4,"nm":"Clip path group","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[],"ind":21,"parent":20},{"ty":0,"nm":"_clip1","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"td":1,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"w":2000.0023193359375,"h":2000.0008544921875,"refId":"7","ind":22,"parent":21},{"ty":4,"nm":"Group","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"tt":1,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[999.99,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[],"ind":23,"parent":21},{"ty":0,"nm":"_clip1","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"td":1,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"w":2000.0023193359375,"h":2000.0008544921875,"refId":"7","ind":24,"parent":21},{"ty":4,"nm":"Group","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"tt":1,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[999.99,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[999.99,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[],"ind":25,"parent":23},{"ty":0,"nm":"_clip1","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"td":1,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"w":2000.0023193359375,"h":2000.0008544921875,"refId":"7","ind":26,"parent":21},{"ty":4,"nm":"Rectangle (Border)","sr":1,"st":0,"op":102,"ip":0,"hd":false,"ddd":0,"bm":0,"tt":1,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[999.9945678710938,1000.0004272460938]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[999.9945678710938,1000.0004272460938]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[{"ty":"sh","bm":0,"hd":false,"nm":"","d":1,"ks":{"a":0,"k":{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}}},{"ty":"st","bm":0,"hd":false,"nm":"","lc":2,"lj":2,"ml":1,"o":{"a":0,"k":0},"w":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":90},{"s":[0],"t":102}]},"c":{"a":0,"k":[0,0,0]}}],"ind":27,"parent":25},{"ty":0,"nm":"_clip1","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"td":1,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"w":2000.0023193359375,"h":2000.0008544921875,"refId":"7","ind":28,"parent":21},{"ty":4,"nm":"Rectangle (Mask)","sr":1,"st":0,"op":102,"ip":0,"hd":false,"ddd":0,"bm":0,"tt":1,"hasMask":false,"td":1,"ao":0,"ks":{"a":{"a":0,"k":[0,0]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[0,0]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[{"ty":"gr","bm":0,"hd":false,"nm":"","it":[{"ty":"sh","bm":0,"hd":false,"nm":"","d":1,"ks":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}],"t":90},{"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}],"t":102}]}},{"ty":"fl","bm":0,"hd":false,"nm":"","c":{"a":0,"k":[1,0,0]},"r":2,"o":{"a":0,"k":100}},{"ty":"tr","a":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":90},{"s":[999.9945678710938,1000.0004272460938],"t":102}]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":90},{"s":[999.9945678710938,1000.0004272460938],"t":102}]},"r":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":90},{"s":[0],"t":102}]},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}}]}],"ind":29,"parent":25},{"ty":0,"nm":"_clip1","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"td":1,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"w":2000.0023193359375,"h":2000.0008544921875,"refId":"7","ind":30,"parent":21},{"ty":2,"nm":"Rectangle","sr":1,"st":0,"op":102,"ip":0,"hd":false,"ddd":0,"bm":0,"tt":1,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[99.99945678710938,100.00004272460939]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[999.9945678710938,1000.0004272460938]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"refId":"d1184137c2cce24dd29ee9cd8bf4e8f8b82fb7bf","ind":31,"parent":25},{"ty":0,"nm":"Group","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"td":1,"ao":0,"ks":{"a":{"a":0,"k":[999.99,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[999.99,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"w":2000,"h":2000.0008544921875,"refId":"8","ind":32,"parent":19},{"ty":4,"nm":"tg_chat2d_V13 1 Bg","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[{"ty":"sh","bm":0,"hd":false,"nm":"","d":1,"ks":{"a":0,"k":{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[2000,0],[2000,2000],[0,2000],[0,0]]}}},{"ty":"fl","bm":0,"hd":false,"nm":"","c":{"a":0,"k":[1,1,1]},"r":1,"o":{"a":0,"k":0}}],"ind":33}]},{"id":"c49ef74dede5d64db54db7fa3523df362806ad8f","e":1,"w":2000,"h":1672,"p":"data:image/jpeg;base64,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","u":""},{"nm":"[Asset] _clip4","id":"3","layers":[{"ty":4,"nm":"Vector","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000.53,835.55]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000.53,835.55]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[{"ty":"sh","bm":0,"hd":false,"nm":"","d":1,"ks":{"a":0,"k":{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[2001.05,0],[0,0],[0,1671.09],[2001.05,1671.09],[2001.05,0]]}}},{"ty":"fl","bm":0,"hd":false,"nm":"","c":{"a":0,"k":[0,0,0]},"r":1,"o":{"a":0,"k":100}}],"ind":1}]},{"nm":"[Asset] Group","id":"4","layers":[{"ty":4,"nm":"Group","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[],"ind":1},{"ty":4,"nm":"_Image6 (Border)","sr":1,"st":0,"op":102,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[999.9996948242188,999.9979858398438]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[999.9996948242188,999.9979858398438]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[{"ty":"sh","bm":0,"hd":false,"nm":"","d":1,"ks":{"a":0,"k":{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,2000],[0,2000],[0,0]]}}},{"ty":"st","bm":0,"hd":false,"nm":"","lc":2,"lj":2,"ml":1,"o":{"a":0,"k":0},"w":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0.9999988675117493],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0.9999988675117493],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0.9999988675117493],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0.9999988675117493],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0.9999988675117493],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0.9999988675117493],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0.9999988675117493],"t":90},{"s":[0.9999988675117493],"t":102}]},"c":{"a":0,"k":[0,0,0]}}],"ind":2,"parent":1},{"ty":4,"nm":"_Image6 (Mask)","sr":1,"st":0,"op":102,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"td":1,"ao":0,"ks":{"a":{"a":0,"k":[0,0]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[0,0]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[{"ty":"gr","bm":0,"hd":false,"nm":"","it":[{"ty":"sh","bm":0,"hd":false,"nm":"","d":1,"ks":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,2000],[0,2000],[0,0]]}],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,2000],[0,2000],[0,0]]}],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,2000],[0,2000],[0,0]]}],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,2000],[0,2000],[0,0]]}],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,2000],[0,2000],[0,0]]}],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,2000],[0,2000],[0,0]]}],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,2000],[0,2000],[0,0]]}],"t":90},{"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[2000,0],[2000,2000],[0,2000],[0,0]]}],"t":102}]}},{"ty":"fl","bm":0,"hd":false,"nm":"","c":{"a":0,"k":[1,0,0]},"r":2,"o":{"a":0,"k":100}},{"ty":"tr","a":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,999.9979858398438],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,999.9979858398438],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,999.9979858398438],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,999.9979858398438],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,999.9979858398438],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,999.9979858398438],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,999.9979858398438],"t":90},{"s":[999.9996948242188,999.9979858398438],"t":102}]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,999.9979858398438],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,999.9979858398438],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,999.9979858398438],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,999.9979858398438],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,999.9979858398438],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,999.9979858398438],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9996948242188,999.9979858398438],"t":90},{"s":[999.9996948242188,999.9979858398438],"t":102}]},"r":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":90},{"s":[0],"t":102}]},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}}]}],"ind":3,"parent":1},{"ty":2,"nm":"_Image6","sr":1,"st":0,"op":102,"ip":0,"hd":false,"ddd":0,"bm":0,"tt":1,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[99.99996948242188,99.99979858398437]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[999.9996948242188,999.9979858398438]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"refId":"fb40fd0849ab74f83630c538b7f9df6b017e862c","ind":4,"parent":1}]},{"id":"fb40fd0849ab74f83630c538b7f9df6b017e862c","e":1,"w":2000,"h":2000,"p":"data:image/png;base64,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","u":""},{"id":"d1184137c2cce24dd29ee9cd8bf4e8f8b82fb7bf","e":1,"w":2000,"h":2000,"p":"data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAUDBAQEAwUEBAQFBQUGBwwIBwcHBw8LCwkMEQ8SEhEPERETFhwXExQaFRERGCEYGh0dHx8fExciJCIeJBweHx7/2wBDAQUFBQcGBw4ICA4eFBEUHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh7/wAARCAfQB9ADAREAAhEBAxEB/8QAGwABAQEBAQEBAQAAAAAAAAAAAAECAwYFBAf/xAA1EAACAgIBAwMDAwUAAwACAgMBEQAhAjFBElFhInHwgZGhMrHBA0LR4fETUmIjM3KCokOS/8QAHAEBAQEBAQEBAQEAAAAAAAAAAAECBgUEAwcI/8QAHBEBAQEBAQEBAQEAAAAAAAAAAAERMSFBYXFR/9oADAMBAAIRAxEAPwD7RHqVjzp/nc/z+/vjNgnXpvzKqglAvIgm/AkRerIhfp/MAqIeTZrxIBGSIxNuwvMeBjYxo9J4+fSKL9iLdWJENgAqjuUGR/d7syDQDK6g+pahDEPLQB5K1IUGJIrY8QisFEf23uBQNYkh6GXLhDE+ldL8mFXEeopnw9SIpBHps8C5BSsseomgeIRnIsJa2Qk5RtAgEWXQMggSD2e5cguQIJDGIX0hAg5Y0wHwPeAL4HVSMgnHVt3KjXAWoFB5+wA34kwUYlEWi7dQh3L9KcgrYsL6yCZdW+5Uo1gsRaY7CL6g3jR+eIEJb7HvILWxXvcIrYGWh57SC9kgBUCYqyNX9oStEkWoFBNMeJEQcDvAL/1FA99wLZ59pBf7TY94DEvQ5qER9Q0hAoQGxfJgASMUSJEa/vbrcAN7tu4AfqIN94Q9/oJBrWgC+YRQVlcAH3qQBZNiAFtFuEACqHGoGgWDoSCApDiBWClwFIgKK+8DWxCHI7cQFveuIDtILZ2V7Qi9/PmQDej+ZQHBgUXIhAfiQUbTO4RRuAUAx9tQmKFp1IKGqkAC4FhCtmAJOoRr/MgDUArkDYhFviAEIsADIKoQ5gVwEA5BZEIRYFgICRCBoSBAQgIGtyIQAgIFhKcwKJBeYCRCEAYFgWAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4cDJnjtkdD+J0LpfDI5OiMS7Kev8AskGijYJJPJhIHIDIgBnlcmBMgQ+pYkNb1AoOJxKQKAAkFxDCBAevqIqBYQxyQHjiRVxLwQff3MJhdnJhCgTCNFlIPJaHaBBiDWQQB54gDjkToGrqQUZYoek7NKEQnpZJxsLiBsMEAUJEZBAJGRobJlVQOkB/XzIKwT4/aMQy6gAz+LkFaxLYuhKhj1ENAAduZBdZf9qBSAA/vIgCECyO1oQUB9RS1vzAD0gls6JkQP6m6WoGv042xY188SodI6hfjbk0UhHQ46h/EAMRV0NgCQDaILAsHzHBW3ftCNVxkBw1UiJWyL+VAoOXuPvAEPeSJ7yAxkQCwOYRRdIgswBKOVIwLwH3vxIAA6jV+BCGNdjFC8SDxA0EDsyIg2wX4gaBJysMDUIb0GJFAiLOwahA0UWaRgaHc8ahKG0YA6ZuQXkdvEIUg5BRtF/fUCA0gK7wLsEgGBQ0tuRFJAF/aBMX9YFHf7iRDfa4FWy6PMIE2mvaBqjqQCbQ9veA+r9oQdXUCi5APFwKLGoQ1sQNOtyIe8B9YAGAflyIujAokAQG4Q43AoMIo02JBZA4gPeEX9oBqEWAkFqEIFgICQUH3kRYQECwEBIhA1IEBCGoGpESUWQIFhCBRILASIQgDAsCwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBA8PiTjjYskIG9/BOhx0tMwCOqrpr3kCm8CGe2zAo9Nka0zqE6YIHpC0yrUYFnFEavpIcATliSg0nINMFDppX42v5hEYxyyPqPcEpQrWWOQzux5/xJqGQBB9VDgQDbJJCKR7RgYn1PpxRKhMU8e9j+IQAGJLPShIo3lkeremYRti0QATxIiA9OsSx+pSilJgHzx7SAQET0kc3QgUjpAuQZqg07Q4lRsE4m8qPxyCkkoeLkTGeSCP8AIMqqCunEFD9pEqkHp267QC9QQN/eEaxrfJ3/ALkFGhwPeECzl3vQkEYxyDyJPaMFuunvZcB0rL33AoKxTQB+ohF5r9J12kALpbFwjXUSOr9PMCDkHT4kDjRUB/cOk19oRoA0Hf7wFkfiQP1cv2gaCV8JiRESGnAU3Y8nmUVL0s/WRCq6TRsQLxdrxIASoje9xUU3qioFCJsP3hAjF6BuoB3feQUUidQgCCEUPEBZ5HhSC7ovxAt3TUIhJCpxgoql7SC68mA4XAuRFBQ94KuWrdwhzW4FFXUgDcBfsYQLHtAr+0BotQKQjUygVzKKPO3IgCW/MCwFQC2bkRXAv8SAfzCKYAqAfeBRUiLAQEiKqgOYRZA7QLz9YDRhCBeYCQV3Ii8Qg+8CwEBIiiBZAgIQgWEJBYCBYQgWQWAkQhAGBYFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhicSiLA2R2nQ46Zer0/pYF3dxgUFkzfc6vciKLHCTTYgQp+nKu0GKzkAed++4wMrTHUBxpQgbFDJNIcQNf1CdJ3UkEJO+oHqu4FJ6sWQeeG/MJxSTlo4g8jcguBAyDDIhKhJ6iAmCnyYFxOksiNLZkSqDRs99mFAulglk0rhKZgE0QMe6+faINFN5cbN8SIZUGSQxYJ+kCYkNFe8FVYnJDngwNArhivZSIponJ37QIDT/tJsCDFOgwE/tIgCUxSFOBm9nH2Cr5/iBrHksImBTWaHSO3iEMW65YJBko0D1Gg5EABoqjqABZd/SBTRrpKNiBVrkmnowiAlvy9SGKOl9/pHAYZaJdOEUGrsKQwsAg32gXEoFVWxCKlXPtAZDE4snfP7SeoDz+0Co5UHcAWMj2TqQCe1/TiVF4X70pAGwAT3gUhhfmQK5aGoRSRss/SBWDRUiDJlBPfvILyQa94QJs+a1IHFJjgQLiUL7e0FDR8DbhFFv+IoodFmQStiBSXfaRFBPb/sAaXmEUfxAUTTkB1AvPnzCB9uYFy2hIHtKLZEiG+YFBkQ9uIFB/HeAEC8eXIhstlQLUiB/MACoF5gUGEJBfMBIAhC/rKKJEU7gBILzACEWAgJBQYRZEAYFcBASIsCyBAQhqBZEWAgIFhCBRILASIQgDA0ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4TAMlZMnYIpGdE6eumJJWQGy33TkQIBL3bsXJULxFY0ew+8CBgnJD0hC4FxQDIDN2eIRdZPt2FuAN44gYk9i9wGIebHKXC/eQ+AP9q6b4gV6yxRIK0bgQgEW+nxweYRrPZSsO5CB9OHI99fSBb2dZd9GEAeo7CHmTEV7J0oAEAUBiRRHeBTkAQyCDwoxFL6QgSXzuQRA5UL4BLhVednXYLiPEqgEfpLLdCRGQSBtlfaVVyskP1SI3kVgeO/+YRE8AiDyb1IKACWhergXkEv+DCG8tFa+faQMUFZ8KCqySBsB8xiNeomygt8yIzy/VZ0TKqj9Ia8oyChV07xNiA6SwnXOoTRqn+fnaQVEhCh5hBC7D49oFxtlEumZA5B5feBodRBJIAUIaAD6nw4Bdy65kRSACHQ3AhZ3xAvm1xIFZc34gU1v+OIRdYpFqAJBtwgwy2PMmC6yYHNyC/kfxKgB6QEoCtd/wASC+KcIdQ+naQCkNwLwBrmANG79oRfuDAvCOl2kExXkGBq6kRYC+IRLDP2gax1IGvpAIkBKEUC753Ae+vEBwDpGBeLEiB2bgXhcyAO4hFF81AQL9LkQd8wLsSBAfWEX2cANQL95EXYgOJA3CLCHMC/SQIF/aA+kIvvAQEgokReIQgUQEBIiioFkCAhAQLIhAsBAsISCiBeICRCEAYFgWAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhAPTeLQc6J05jkSznYC5oxUxR1HFjQxfaQVAn1Ei0C4FN4ghEa3IgPTRKfH7QdXEsE5NGmoomBKOVkaJ4+0tG8mcQbJyPMynGciSGUB4DgaFhGuQxX2hEzJBvIHz94goxJIK2NL52EaVRv1c31O5BccunwOB3hLEY6Sn2UDQWVhV9ZkAwB6n5v7y1AdIZFLtlA0cUK33Uahf27CpAQxxJOwbNwGV5AdRZOyBqEXIqgwtdpBBqsjewpRpEGskT4kEBOJLC/iBvEDEaZDUiAYooqBkFlP3IgXEkiyPF/4hF9zXHtIKCULLcJYoBp9glIA2HiwdwKQDfcwGTFkge52IRO9FciBQWEQdfaAYsuQaxrmj+IQx5pF9pAyHp2VApRPUCNQi2ANjsO3yoQshASKmJb7P1eJRorXiRB0gPuJBoGwSPpCJSPmBWCenZ8wIvD8wNAsa9TuRDkeIANeJBSb8Qg261SgwPYNmBV5Q/aEC3UirieDrvCAb3CKLCQPeoDjjUgYuzuKLw3xIhTuBeHUIuoFGrEggpmUU6HdyIN8/aBr3kENd5RQC5EB94Ff3kQfiBYBL/kC1wpEWuP3gN3+ZA0IF33+8IH/kAPq4ReeZBbgJBRUInKUIo8wLIECwgIFgICQUGRCEUVAsBASIQNSCQLCDgakQgICBYQgWQWBJGVgBA1AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEDwvcADLuPrOidOdRJH/jywxY0wb/zLif0RZCyRv2kVT0kMeouvEiI6IIHcdrgxVkQH+khFePhio1kuMkfejILkBkRiyiz+Y1E2Ux92YUwTxGuPJhGgSwWScvGpBRkDkQno15kxCyekEs7L0JQB6WAQEmjqSgdAJ5QAtFV76gUDIFdLTThOqTRIJOViRMAm/0hccQFYnWuTUCHtiUDvtA2SCUEDaB2IQxIHqdGgzIA2GL4GvxAEgA9QRFE6+akGgsRQJq1ZjqVb0cR95BLGSo+1L4pUMRTrxJRq945WSUV+IRAcvVxj3EKYAiuXvcWpVPpXfyZBR1cmuYRXtiBAiiLA/ElGiQuknzADFJDY7RogDHUxfKhAEEDgP2ijV6RHO+ZA9OigftCKkba/eQDv1aOu5gXfZeRCGWy6dN8QLi+T9e8gEohH0wik+BIAFJfaBf7u3YCEUAMh6GzAmXpsAf8hFGwT3kFDXnhwAIIeQ9oDE1faBqgTUiGWm/GoRO604FCXMC0+zkVRbdwgv0peXCHP+ZAbI9XSfaVF99SKvFCREdQKibN8GEUr/cCkB+JAHaAHD1CKON3yYFBZkDxAQh2EgvmoRRWjUAdeYDm4FkQMCvjUgDvAP7winsRAoNUBCL9pAgJBd94Q7uAFVCLIEA4FBhFgJAgUSIQigwLAQEiLAokCAhAGBqRCAgIFhAGQUQLASMkCiBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4TLqyxQyDe+fM6J0/ELJJHSEQbgbzIZC4sbhIuOQHSQyNDyFx2gxjpsdRYHG/x940b9R/p13Se+8iIMrTFFVA0H0gggAWf5kExIJA6uk19ZRTigQQUDo81IdBeLte/3hFBIBGKPcKQUHqyYBYvyJAI6UTRFb95Uas4jkmx4kErKxxZHEBgSKNgsqEq5PIEhmiBWoDJHM4khcE8SIqAF4r3OoOqA8fUq8xUQ/qB4CLhWhrbfc8yIgrGh87QrQs9TJI2AdSIgyeNAGr7S0AL6gWTpSIq2OryjAotquBcI0AaXfsRIagRyJFny/3gMihoHsxAo6UGaPJ7SJVIJGVnUCME9jAcUAfpzCKCDxfmMFYYor3kA3ib47QNaI4kRGh0srutwL0nvj89oQs437KBRZ6sSA+ZAafgvWoFD2k3zCKQQXi8nCGrWglIH/0FZgUkKkxW4BnV+7kCyBsk+YAFFdVKEaLbkAEaHP3gXaxA97hBAe4NRooGyTqECKOx9ZAGVBRgrG3vmEMSCL5ihTH4kFP6n2gNhPmEUsssiQUmzUCg/wDIREkZBd47EBcIvG0oAXSP2gU09SBwyIRbHj3kB3dQFDtKLse8iH7wKHIhtqBSQ91AfaBR5MlQG4FkDiBR3/eEGVAD8wiqQXcCyAJUC5EUQHeQIC4RfeoFgOJBYAHiRF+sICBYCAkRYFkCAhAGBYQkFgIFhAQNSBASMkCgwLAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBA8KF1g7y47Gp0Xx09CMq6mhSBgDljgmeL8wemTGkTq9wK/SGAHSbkRen6A10gnmDWWeot1ve4wb6icCk6sW/ikT6mORxzQJrbNCXC+xcsXiBQ7PmQ0IyfP/wDFV4hAA551dcwcUBZDBYnqDO/nGoBYgu++vxIAJB6gClxQhFNlnICxZgawJGK2ea3JROkkfq6S7rf1hFGL/UNd+YGiRhgVjaoqRGdIgEFbhVxP/wCQAfqPHiEoWACCO91+IGi2+bXaREB4D+eIUVBEbR8VcIB5BgAcl/4jg2TkAA7kQxWNFjK2zUVFGQ6eoGv4kwMiNsjn3gX1As/WQRnJgn3IlQYNNA7gWt90/PypADLdLz4gXIu2wfPEIYiw2lILvADXHMCgG91d/LhFPkrzIADxAB8LtKisAm0R2EggJD54uFaxYJ195KiKwjYcClP1Bd4Q8IqBRdgpMiRE7lUYVoDqApwgwWDX2kDdNVUqK+x/xIKAwaf+ZBASTw5RrEiitG/EiAMg0PDhEG/yLlDEAnleJBTb2ZEBRIezAt7yBuBXfnvCC0TagCQEg67SGB7AwK0L3CKg72eJBOSe0pWv7V/EiICj2gaIkA73fvAAX2hFGwO/iA58wDLcgq7tQigyCFEXCNCjfECtBDtAnECjepEPYwKe8ge0Cr/cIBnxAvCkQFcfWBQWJAgWET3hFBgUSALgU/KhAQLACQIFGoRZEBAogICRFECyBAQgD3gWRFgICBYQBkGoCAkZIFECiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhMjZQte3adG6hTRGIZv73IjOK6wD04ju25RrA4rkWiiq7VIlGTfSeoFe+iYFs5C0eDy48ESBF2gu4kGzljkwWBzWu0Yhksq6TR2pCI+kHv4gXI9QZG3qEgW94oHf4gV+rqWqfHy4Fz6RlrKtlFyJBBWwTovUC4n0/3EEvmCgJGNANdvzcmBkiiRwrEC3kepj33HEXDEHMo+HBUCIOAAPT3k/UVbHSt6J+kDRCLAAJpwiWa9jAuOR1XaQUIB31du8CErMh7MC23ariRFZXpX3+8CYhBsAwNAJps8yIdLbB2CyYA16V1Ed4FKAKfvIID0oWJUxpgBY4kH95BokUXXuYRBZLFA9pAPD1AuQHVtkaEAx1Vz2gBeJskbhFs2QQT+ZAA4+jhFBok9uRAWyHrn5uQUJv6QDWT5XeEqhi+quTxIBB0994RUQCAVs7gQj06uBR3ftIL1F7MIY7pvvAMGymIFFXqRAM8cagAWL0PECmsiQa8wi8jgyAf1Wa94FYdL7wgAtV9ZKLl9veBT40D3gQbvXgQi4lhENGQLI1rzAospwC3IjTbYPkQg3AOlv2gUtXIAvRqAt/iEU9gDUBS4uBRrW5AtQg4F8uRFCcAPsOID3UCyIA2oRQZFUfmECb8QHLgX8SICBZAgXwIQOoQBgX2kFK3ACAEIpTgHIAgUeZEWEAYFgIDmRFECyBAQgDAsiLAQECwgDINQEIkiLAogWAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeCzzwrqZvRLnSSf46jExZPScf1b5UithenF+knkyIuBWRBJfI/wAwiepkn048/vBiorqNEnjGBrEFEDEkkbJ34hEXQbo6Z9vzIdMQHtd/PtBVyxJvEc2v8wmraSY9z33IGDBGIKJyBriEpgccTeXtr94FxIbBKOj/AIkwAKxHTV37wLl1BAE0aK/iEUGifT5kERx9IAB5KoygOpB2r7fP9R4No77ir+d5ETEkIP0rSkpi4Ao4m9PnmEpbKKQutwqYgAvE+rm+YtRqgWMf+wGBDffnxFFPq6uOBciKUyq99+ZEQ7PUdcOFW8h/aPMIuDGNcVFEx6iLB7AxU4uKTv08SChnqZJJqArgkc12+kC4gg2EBz/uEVFAE1fNSAB0q6dQlUDklRRCbtFntcCo8EeFIJiQCO4gxonzCGSPJJ4EgpbADHiEAGR7QNJi8mfeREDd9oFOgyB57QLi2Se0Io0wiP3kExdOq7wBFWnxcChp8vYhDdEvxIqiig+8Ip+7ATkAt1/yAH6yaPIhFAQswLsp89oRB+mi4F7k755kQ+gHtApyXEgYtgfeBQq7QKKKUIWySfdSAmLvvA0Nce8In6fEgoW7H8wBHVCLrsIAcDvcgoKPMBW1RhF4UgEdpRQfvIBevzCAf/YF81IgKPMCimICBR4kQBgUSBtwi94E0YGmxv8AEiAgBAsgCEDKNDzIhIEC+8IXAsAICQV/eRFMICBRAQEiKIFkCAhAQLIiwEBAsICpBYFhEkRYFcCwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQPB5u8SMWdbtzpHUQC/8AJRZWuO8nwTGySP0hEI1A2D1dRv02Cv5kxPxjNk5eo2b95dGgRiCwcTlsHKQXEvJBECu8AQBll1l4my+I/iLkQOkAjIBPmTCLienJEoksHXzUiVSBkhli1bcC4kEM06HivaERF9Sy903CqQQCGDdBQg6NhoNndQABOSJQXHaQq4jpxGRK6fy4Qoturcirz1b87XmEQojLRpjmVFTFZA1t/mQAWCyLG185gaxxeP6SQdCQ0BHVRPZCEXEBgghtqNKZVQGwgQJETFFE5EH/APjKrROBA6eS5EGwCR2RUghQVbsiBvEk+oXSYMIInKwme0AB6V1FcVIgCKFqFUH0EG2IRGOrb4qBrpDNnXMaisiyCGD7yHUBNvstwmKz088XA0CRafiQZA2hZ7QNaHhVcBvIge9wig0QQfrJgM9VAKBQAkcaPb2hKerZH1kBgZJffiAJ2n7bhGgySNEV87Qhs7xUgoIp3/iAyeQQ/aEOqwif3kVR1E/p+8IuNKAXsiO8iJZIRAlVbSrubkRoFAUEu0IF6/3AZdqEBrTkFL0/YwgCOryrkDueIGgW/wAQiEWdwKPYX2gAfVIDAJLY5gV6ViRGh93CAvgGBQavmAXK/MgprmET62IAWbuBQgG6Ego8iA5YkQ7/AH1KLRoGRAfVQKB4EA7gULiRFfHeEPduRRioRbTMB2gUXIhzAvEgQHEIcwNBQhIEBxCNCBIFkCBRIhbhGhAQHMBIigwLIEBCKDASIsBAQLCKDILAQiSIsCiBRAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEDwRIB2NpdzzOkdQmeWI9Yx6jkECa/wCxP8GgOoZYdJN95BQenMd1r+ZPhiAnkgLzA1ZeIGoQKYLT2WHAgGID4Y44gXFELpQfB1CNg5JjpBG6r7SInJAEipldjstNQjQ1tvh/iBpjInJkOrMJxB044kkhkBHmAfpGQArdSBRHSNJAUH7QNZE9WRAKA7yImLGyWR/6yislInV+zgEASRiR4V/NyC4u7DWoqByORIBVseIMSsleLfbf0hONYYEUzIIdMA0aPtAMHJPKufn0gaIGQ1+kChzIjRJGJBIHFmj8ECNkBkFj2kDH0hpW96MC0DTNtPiEGUQzq3A1Y7IC5ERkAsUuZQIYI+kgpIRJakABIOwXUuopJJQ9qq3A1i9GpEQ4lWK2XAu9qtOQELR3pwGKLITJ04G0CR1exkRkDZ4OiIo0SQECfcwiWCR/EAqdL2kFYDFgNQKQCVy4QDITf8QGBZsekfmQV2xftAqLYOrDhAoZBHj6QKDRVnQkRUqJX8wGIbsl6MANnxIKdt/mEQgmthQNAhAtjh8whkbvmoMHb39JECTsDcChF6kFsZQA03rSgUvRhCivzIFJhwKOxAgW9uxIhslQG9QigjvcC+TTqQKGPOoQdPtIK344uBTsnxACu/3hDtAv0kAe9mEGyXArfeBQFCB9pAG0oF37yC6hD44DQgXypEIF+sgQG4RfKcIBagWQX3hCFHCLACQWAHmRFhAQLAQEiKIFkCAhFBgJEWAgIFhASDUCQiyIQKIFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHgfSCQScT1M0ERudI6kBJ9QG7oMfKhMaKBOICdPYvtAZE5Fjg91IQJKFADwF8qDFzLQNgD5ciYZDP1DHpItgD55gZBCZrk+DKNPq/TiTltv8SDRPpBWxxIHUuoYk1QyAYfaXGT+oECAA9gCQiLqJWVnjiFaxGS6SX76kStF9JDYt3uPqIucmcSNCDq4+rIPn6h7MAD1dOZfpxv/EiYtjIktG98wGRQZZ3wNdoMay6umxSkGSybw/SpRoJA7e5EGyGK4VCBcSxeVjYkqGP9xaJgwxyLPJrWopjRCL17cGEZBKZoMpQrXUKtXp7kxMDYGiT3FQDATLApKRFxB9LtD5+8DVI6XmoEy7c9knIgKz7KoVrAkA3e9QzUI5xbhVYAAyQBowi5eQHw+ZAxGIyCqECTtLyeYFFmwvLkA9SRG0Q4DEeq1X7x8Gh6nUIMDGiQ6QsuRAMY813EC55P27SGIKKKo95RoJbqRBoMDtA0TQbXmREBLBCIMC45B7HsDGFR2h+0ABu77RopRCxGUiLpoeYF3iQLqRAHSFk8Qq7/ALj94Qauz3gXRZX+JENbB22DuAvf1hFJ+3eBbJ8yASaJMCn8QgQSSj9IE8mu8ChmgBIK/TIBN89hKi5cqRBMnbgUchwKqkADlPxCA24FGgTwIDl94FfZn6yIccSAy+JRRr95EUEk3AD9oAc+YFDfeRFkC4B6hFgGi7cCiRFcAYDmQUQgftAoMIGQKgD3gUQi3ACQIFYUiHEIrgWAgJEUGQWAhCBRCEgsBAQLCKJBYCESRFgUQLAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBA8E/URaB7/ADxOkx1KZlf2nIGgBRHiIKvRiMwGdgUzH1GurLqBBxLIbHj/AHAgRGLAAPJ0K/7IJ1sA7xJftGGNAo7JQciBsDGiVz3gTF4htO2ku0o6EB8FgBKplGLJOT6t+w1KLiiG0G0vz9pB0Y6y7JQoqRMZAeZxaJu/2P5lp8MSdZFPhyFXHr6Rd9tR4jWOQGzsc8wAIOHSDf3AEh9VekdNUhCJo+kjE/21xAqx2W/s/jkDHEZEFDdjt7S2oAr9SxB1zAuJAe14EgelHRYQBKkFQFMa32hENaLPvA1/Ty6sR+4MUxephpHK/eExCWjRD+0iqaQtNsQnWiATZvtoyIzm8Mq6tsuUUHqyDLxUguN/pV/3EQUt/X5+8g0f7ho9z2hAkZBkbNkQiWBs8XCrlkmUPxERAbSL5vmSij1YjRjiLRfK0HApusmFriQAKGVvlQAWOBRB8PiOgcUaoee8IoJxCevAgMgMsQcT5kFxbJ+CEUeoDII+ZBChS/Eo1XUQfrIisEaKPiQMRW/ptRUWmWRR0dQI9CiRqBXyOmQUUdBrUIqqoAgHJ6kDJUTCDogm/wCYFBFK3IKaJqnKhk9AN8GQXgA3CDt9UAOH9ZAZ2vcQKPZ1AvjxAgrk+ZEaO34gO5vtCA8v2kGudfcQiD9S1zAoPB5gACrMC4mRAGlrmQa2KqBD9nAoUIDfmAH79oFB+siKCPr7QHiA9oFBq5EV95AgPyIRagQ0agUG9wjQ+wkCQXvCDYgOIRWYCQICBfeEXiA4kDmBRIgYRRAsBASIoMCiQIQgUGEWQICAgWEUGQWAhCRCBYFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4HI+o3SZJtHnc6R1S1gCn4Js/SETqeQYQHHfvBjRFdQAI0pBOsFEMPghrvLiLkVlZBd2Pz+8hFJQOOL9gfaDqbzQoGuSZEXIenqKDX47wNDpyZyegARz7/OIT1n1Li+OIVoI5ENEDqduEqnqJHqfJR17yHhRBAoj+6REPqGLB+0C5ZE5dOQLAFbf0+alFVdQxXJP1/MiIwckj2HeFaAIvImt/xCLlkDqiL1upMDl0LW9d4RcsSS2AD3MgE5U0HojtAhBxOW/tco0GwQRevJ+siCBy6gfpuADPHgUZEUBvRFA+0aVcW2Q+WoKZfqQyotKEUZD9ITb7SABiXiRZ7Co/QQOOvfx8cgBDIog9+T7yjXUKehv2kQwJAJv7QVfTjkUSVREiAILQJZgAcmfSQB2hFZyxIIJ5FQJkWQgwR25gUMkgEA7+kgtAF0dN2IRQz9Dz7yAEBTQOhAPI4+/iA0QtkQKGQaLMIUNkgbL7e8gpQ297AhAnIZYmvpAuwL+neQV6Fjk+YTDH2f1gVhMNfvIANsaMIAtWv4gU7vXJkDH3+kUABkEUmtyorHR5kFf4O/MIEmwL7yKJY2PEIpKPYK4FPpFVCALy/gQLsMEPtII+dGEVh78mTBT2AgOfHiEU6ZgULkPiRERTe4VRZIRoOEF2L5kGtscQibX+YFt/LgX7SCAsxgqX0hFJdXQcC+fMB9ZEL7t3AHmQXXiEUJwHwQH1kFEIv7SC+IE5uEXiAFEpwK5EUQDEgCBbMICELgWQXgwEBCLASBAtSIsIdoFgIASIoLgWQIQgUGEJBYCAgWEUGQWAhCRCBYFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHgf6nbIHIqwtTpI6oxAABNhO/8AMBiPUMjj00Wj5iooxOIOVN6NfaC0IWP9TRIoh3CGSsZY8Wcar/EQCc6GVEGgNSZBrJBY4j9V2HuDqAgEHlq5AxPUcickj+ZcRoZE/wBMBiqe/wASGKGxlZdPEm++oRkZIIMHmMVrE+mskAGJEMGMTQ6gaeOoqX1pgLE7sAn6SCY8k1o6lDE4jH0YAHcGNCgiRdd/lyA08gDqwfpH4jQYxAId0Dr3kSoNLXJ5MiqWMeoUtVKjJBs4jLfeBtZGiQb7uRADIpdL0bgQAgAFrba+biin1AZK+bkAkNEokL6wilsjIelfsIF/ppgE61IVSXbYFiAyIWmK9yIRbOK0SuNyIA3R+3PiDExPAIf4EDQPpNAs9tQCr0m+DAq88i5EAuCA9gwAZCDJ88yAGWaaoqVGgSWRYMgM5dyB43CHmz5+fWBUeoIgP7yC0aGj9jAgBI6f5gqsclnwBCKEfLuhIKTYABD7QiME2kLrUCtFaPFyC4kP2K94RRvRHgQAtGgFFAViQ5EUk9NgE+TAh3dGQMSXZJ/eUVhA39IGsTTDkQ3X3DkDE3+l9qgUm0LrvCLihIAu6NcQhoG7JgXjJFwiE0WiIFvm7pSCkpAVAatKAFtuEUGhf23IFb3APjUChKRFDAMIuqgBz3gUE6FGQKEBfAtOEUVYMgDt+0C8QgR45gUe8gbAsQgBXiBbIgOUfaEXmQXHsZA8/aBXx+IQ4gIFEiKDUBASB+IRR9oRRcBIHmEPaBrfMBACQIGpEDCAMCwAgJEUXAsgQhAoMIQKJAgIFhFBkFgIQkQgWBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH8/AAIyxAaHtOldUuJ6gSvf3e4pxf6YOOGQ6gH40ZKgBj9g7H5gQfp2unZHI7wLjilgSD4fMI2CizwzQ+shhhkEDkjVE4/bVQmKDsZDqfcSAQywSMgCuPlwCvHINDgmAWLJ2DrnxAbxHpvnn8wJhQ78urilaAONA9TKG5EaYIGTRX0kQCdjWzBqYggg5EM7UaGROQKQPkfHCSKS8gGcXQtfOYAPH1EAY8Bc/HHRcWchz4fz4JKNkL+08pSJqHIDPIkkeTUvT4mQDpojf3gi4iulb0O3iSoZEdIBHMCh4kHqJ53/mBQWTkD6uR3kTPgekEnFXe/v8AvAl9QPUT/mBciMtZkkeII0r6iXktyIPpxQFO75gCGLZPaQXEnrJHUYDIE2wOU4QAA/pnIuzuBciOljTNcyIgrbI/iFXLIEsjgUPeExcT23ypBpl8p1CI8XWvaAFl6K/thFw8Owh/mBRl1AjX8SYIUKwAI14gVugVfHMcF4JO97hFP6gbo8yIgvH+OYVrF8SJVAVo3+IBm7a7QmFIKvJMBiepgkgaRhFxHVsbkF7ISB3oe8BQyoa7yggA0E6hGhZHiQTXh6kFHcQGJf2io0AgQSbgKH2kECI7qVFHZsD7SItgvmBRklf+ZDFBVQCZ8+8IFBGhAtWRII64gMTTGoqKK1ArBDP3kReYADjZgNsOQKJtQKK9UIo2LkFVUjCDDJjAN+0Ciq7yAT9YRRRgP3gU3ImIrdwKwe8CqQOIRf3gBtqBaPMiGhApsQA9pAv3lQEg0IQcge8CiEHAe0CyBAsiEIoLgWAgJEUGBRIEIQK4QkFgICBRCKJBYCEJEIFgWAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH8/IIYBAAFIfmdM6oPTiv04qt8ajo1lkMkSe4XMyRMdk5DZoOCtY4/qoADRAS+fWEPSxjjkgSquQUg5DqJy2xRlRnHEEh9PudOABADOTyyLfiRWx1P0kXZV0q+kIhJBtZVzX4+bhG8iQWEFutyDH6swRppqtSjQBGGTp18Em+i9NEkEVR0HIlTpIJOWTBKSCMujVFZdFaFzKB0PX6r55lDF9V9I7KSgMaYTy4+kGrgQ+kAkH6ARUrSQOKGWl3FyBiT04gGq1FEIAIDABL51ArxGBFi7MdTGiaAIF0CakxGWAQFvx88wrWPUzSKe385hDR5GRNfzILkuCBScIYnIlEoO1SgpQN0+wgXq9J2tpqEwsCyNdtSKoxseL8wlVau6QciJTqwAqPmBSWygRw/2gQtUED3pGBqyGN9pARKFirDhFxvF0X43H0aDANU+BIiWTo7uqMBjrxuy/pAZE9BxFfXnUIo6jvupAxSJp+IouJRLJ7HxFB7CJXHeBaxyohwjSu0/9yIYgBpg+0FQM41sBA0IFsgHdVIGOkr8iBphaHtxCHYC5AIBxGmueIRd0jAhXuqkFSN04Gkw4RnVn8QNEeaXEgc/4EIpLtabqAFbVmCtC3bhCiQEZBE7XmEBu/wBoFGqfcyKo2n57QhY58d4RokujrtIMt5OUXQs7kGuPpIiJF3AvkgQgtC4FBuy5ApNwKN6Q8wLpgQgLAuQCn/qUXhESIpPECfSQX6iEUdpBT+JRBtE1CL95AdfwYF1yZBVCFc7gH2gV88SIe9QLIHvKgPeQXUIogBIHChAQKNQKICQNagaEiEIouAgJAhGhIEBAQiiEWQICAgWEUSCwEiEICBRAsBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBA/n4GQZJC4Y4nSurBkMcgcicWUH37sGXEaZ6USrsDZ/wAyGIssgOcTyRYgB6SGqLJB1f8A2Oi4/wBTAkpvfn5zJZUxcaZBAxxHz9oQRflWxx/P+4FBWRWQLCW+IFGWKxy6bDC/39JMDM9IZtBgSSaLiEf7vUFofY+YRg1kdI0k/m5Rp36fUDpWh4kFyNVoPXFj/MSAMiXbPFeYxFORK9JNp8fnUmCvJ3kHoGRDILL0oEhkvmCKMR0BgLWmHxKgaoourLkIE5HE6JvxCgIZDK2+f9wjeyQQD5EgB5EjpR8mROJt96oWpQZOISADZ3AD04h++pBbx/SDR1CNg0QSzjJiJtM8WVAGifUU2YAkEcMX7whkwhkaTNXCnUep6RsE/O0I2dg5B9+wkBjXC2pAyWIuvbUIYk5Dp+z0vhg4oLsIXxdxYgCQUWz3EC4442djYqTRAN2SRt8QAYxLGruBqyAB0sd5EBSsUo6YoZN0Nwig8X57iQVMBJH8wFEgoD2gR+lX9OIRRpP8KBpknbf5kQFFkovzAN999lIGNhFkncBigQRbPO4RTkOKW4wXZZP0kAhBcvmEEB33r58uAYBJ6VxA0CQH9pEStjJkSqoCd7kRf0/qEIvABkAA1tHYgHYG4RXa6T3gX31xIJCAIBYNmoGn4sSYB77KgUV/3UIlundQLs+nmQCaJH1gUHe7hAE8feQX6mEDvt3ga0LgNftIJZG4F+hUIrkFDvQgO/eEOIF0FIBrxCKDw/aA94FK/MiHi4CAt9lINdoQfvAGt3Ao+GRFfeADgUSIns5RQwJBRYkQgPeBYF7QhASBA1IhCKDACAkBwii5BYCELgUQhAsgQLAQigyCwEiJCK4FgWAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB/Pn1EDEZE8un/AI5nTY6toeoespmuQf8AUVP4n9QlhErppVJBcjRJyQ8DTjqofXgMsAlzbGvvxHPEavqGLsCnuQUEZAYk6t48FcQiYBZAgGjpxovSzjQBHc0FCUy/SWL/APZcQNvJsBADtxMiZZJhq/vGGKfScf1Vwf2/3CABG29EAa8qAX9ooGjW+yjUMw8sRQ8CIpYQBCI4hGscsQBXAt6r8SIjYJYvuEpBr0rFf1Op97BlEeQrLLFhcSCgDpTIAFoU4FxYx5fvs+IqLsoAVWtDUgziDlZKB5f8faWjROy/y7mUXAnI4hg9vMFQdfUSavmXwNoksbkG76RpuqkRHYq0VALrxYBIIbf7xxNxonIovs/P1EBZD6mBvzAIDkkkIgGEAAe9ck6kUL3VDThGsyOknIsu0JEERQ2Bf8CBT6tNkbgTG8UCSef9wNNUQR4kQGin+yMBk+kbLHwwiuhStAagXYtobA4kEROKOhQ8/FKNdQbOvxM4iF43e6lArWNX7yC71iwLBe4FF2X9P8wgK6QGVuAogd1tqQX+0Kwtf7hFfp595ADgUVWWjzCUpUF7QNB7NrTkQrq94AH38GDFwZFhHgmEKdL2kVN6FdydyooI5P2/eShlZG9SC+7L7QH6hpLiEV8cQKwkbEIAIigD+8goDPHvCDpfzArO3IBMGKaIr8wgN9zzcC7rj95AIZHeA5owKD41uRAWHdwi1SYgB2ZgVeD/AJkAa+XCKCzuQAOTKEguNqEOZAHeBrhO4QfHMBvhQLtXIh57QKF2ZkAQEIp13gB7wLse8iA0oFuQIQMqLf5kFkD4IFfMCahFgWAkAQLIiwiuAgBIhA0JAgIQECiRCUWQICBYRQZBYCRKQhqBYFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB/PX6CShQAHE6bNrrFzH9M1jiSywuY9QHKIF88dyIKDqBs87HEDQ6v/ACZe+geLk8xDBZDpyWIHbn4xFEJ9AyzCWI4XzcfwaeeWXVkP0tfvIiYNEHaJH1ihkziSMQLQQ5gas79KXGjCKSDogbBCq5BUF6jq74gEwwWDR8faQGdlkIJBQjXUEAGzY5P3hDGvULy9vvAuJRtooas+ZBMxkMOkFEbN7+GDocsgCQCef8SAMsf1ELqO9Fy4jWOWWybqpMFwQPSrHGvxFRnpWOsgeSCoVvIsdJJyy79zIg8RfV+oMVAcLj/cIPHLLdlJbk9EyToFDco0aI3tuRFJGWYR3tiDkCSU8Sxzr6yCjEoZfWE0xvEkM76g9wLbPSbCBP8AqEMiRiRggO68QpkAB28Lfy5IhiEOm+V5iikrEIDwpA4WOhqvMGNWWPA4/MIn9N2WQvzFKoA/u78SBkMS2wSR2lRoMYhF9lMojolC+41CtKkGFXZwg6SJKdwCIydEeYQVBrs4GkmcmPMghRDDJ5UCgkFHv2gUWSuOJECWCX7mEMkLI8wq4s39vMiAA6OncfRSS0QD3HIMINDTA7wFEkBFrcC0Mge/iRDIqiRVwKjcgWmd1xApvWO9Qh70/wAwCI++4FD6jbuRFGvVqAZA9W1AoeyfaEQaL9/aQXIHnbr/ADCD7nXmBrZ5kALUAEQx9YDzt94Rp0lIA1XMBifrCKRS7SBaYhBqyNm4wUHfeQUUVAnGhCKe35kFYHeAgVgmMQLeoFHHaQCWRsCEW+VAKnAC/eRF3zApJ8iQDUAK/iEUvUA4F+siA8wLIFcyosgNQLIhAc1CLAsBAXIKICRFMIouA8QEiHtAu5BYCEBAsISCwECiAhFEgsCQiyICBYFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH88ORAHUL0/A5nTusXHTxy0siuPI+0iNZLMYnDLVBBn2k50UdRx2PHPPEH6oxQx6CX+SYT+oATXUHZQFEwGZxObYJXezEDEV0/1CABQY12FcR1P4MH1MKn1SDRLQORGS5v6wYp6UcUAOVIgfTkGSjyRrxuUQEgZZHpfJP4kFxGJ/SOkEWHR8Qcay46RrlNfLkQx+uQoVxBU10koYt49OoAjLEg4jHtjUI1sU+z+slG+kDIgX9dSJrOCHSMk9I/vKUGzkMl2MgnVQPC7WT2lGiAMNja/z/MgAvHfYWIzESwbA8j9UDRHUdgrtxIBPpHORaGoFxyP9QbSs+8cTMMSgMTTVuQXEkjhDQUFUkAlEPk9vm4xCgN4hGruQaXqasv7wjNgAjEMCoF/UD35LgXH1gm1d+YQCALZGx58SKtkVkX+YQYNAO05MDEk5ZhfcQGwC3X3hGiKOwBrUIu8+EQ/EAyDd+ZAyGLBID9pIBsnv5lDIeqixwFCQxyTBYHc8yX0xo9R5QhFxBGVHyZBSLBIB7Pt294Bq77QDZdkeZEUNPpgCux173CIulF09px0bxLLKOUiYIE9Sa0IDHIYi9QU/ShZGoGsQDhv86kRmnol1Kq4J0Q+eZMQLADvzAoS/MClZB2OO0nEXGxvf5ihSCqQPqfeEDkDYgaFVkTCHmAqhf0kFP4hDRFFHagAwN3ILRNoQLZ1+IQH3kDzt/iBUeD7eIQ3+0g1QPECYlJHUIvLsQDp8QLxIDrkQhrR+0CpwB15gUF0ZKgO0C4k95BTsiEIFgS+9yJVgUXIAqA3CLABsuAkRrvAcyC3CBhAQq7sQh+0gQKNwiwEgRgokRYRNXA0DAQEiGoGglIEBCECwhILAQLAQiiQWAhCRAQKIFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfz3pOJAJ6gC0r+bnT66wLZJ4Toa+CECz/AE3j1LghdqhV/pj9LBAAQND5sSVEP6g8h0+z+VBi2MDjlia2z8/iEaxGFAgAHS5kozkciekK+SU/aBrEg5LqvwOZBQ0TkiVoVofiEXBkuhimBZXMUaGWS9Ao/pD9oZxk5CkQ+6JXaMVUOBQ5PPztIGJ5sV3r8RYNZAAjqBs2kBIgALKIIGhqA/p5HKscsRp7sxiVbFnaDLo+YIen9JLPVUggA/pg8DL0rtL0bTAyNlXe/wDHMyiY1xR48eBBV/p5HpJNMDfeWpYio8jtlIrYAxIAAKL2K9oZ6gNnq0RSkVQiCDbgQC235BgVg5BFBhHuoRRlSJwW6PvFAFh+Nk6EiKLyHUya51IGB/T1BcCWwqjFAlf8/wCSGhHqAKH1UIuJJpe7/EIzkVieSV8/MK0WiAOCE/vIi4knEhgunVuCrmXl0l355kSYhLviq+eFApJGNlU7gXEhE2AtLiKY1b8qxciIGMFloALxBn+IKYQBPg6hAXoIcX4hVPCAC/MI0Kxpf4kFYZV8yIhK0CPbiBo2fpAycWXsu7caNEgEm7/MIpJBOx+ZAy9LbRgCVkQSADsqoRTQbP15kEIraUCgihkB3hFIqwK4cC0D3795EQAIAIQqgB0XbhF53+dwgQTjo/eFXEVYr3kQ0Xa8QF4hFQauJBvclQs0NH8wKCCbJ8QLwbZgMds1WpEVnuAz9oRHxcCj7CQAeT94Gjuw7hDye1GABdMj6bkFsfbcC12kRNcbowNfvCAq1/uAxKDNOAHKkGmjRhEH3cgrCgEJRX7qRAHzXtAo+0gD7wigmnAQKd3IgHAvEgdxUANbhFO4CBeJEUe0BzIHFwh7ygJBpuEJBfpCECwCgHILIhCK7gXiAgJEWAkFgIQgWRCBYCBYCEUSCwEiUhAGBYFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB/PTQGOOPq1r86nT9dYCkTsBP/AF9oo11k4gCydl6MiZ6hZBZIxOLCoc3A0Sz05FPh/gR/ET+oji8sgXRrl/8AYlXGsRjiK/S6AEnUZ/ppHE5Eeoha18EtD0nCwRyHrzILhlsjAF95CxRbxO33ZW1CKsR+pgA2CH5V+0IgF2eOUU+IFoHLZyWgeJBUBli9edQNHI9P9wIRNSYmIQEFj1AFB18EAA8gaI8eYFPX0s+r3Hb+Y8Cz/T6bCo3CNFMDEkBc3/PvCILRBBfL34kVcSTfUcgO4+eJEQ9BR6X0n7XKNggFdWz/AOsgy8chiSdCy5fUaZGZYXcbUmC7rpBL1xIUxy9XcO3AlnIpIEe3zzA1iD6QPdd5EZx6ijnie/ztL/BcTZdDQko0Sk1RqoRQcfSUuf8AkiIC8brTZcKoodiuDCDIJbN61ApTLCLPEIE5IdS3RGpP4qknq/SeonmEX+1BsHt+YQBAAvj3EgrsmkLKgZNkvqJDdwNIMD9Q7OEUokuxIJQyS9zAo/SAOkcwijuyhV3AoY0SRIITYHSb8Qi8jsiNC4GwuoIMLbmRPSN12YuUTHqXZVuKjXJXg6kAfpCG9+IRSiNCABbxr3cgqK4f5gCWaIhEOte0C87OvdSCktAb04QBoX/mBXQH3kCkTlpfaEU1uBTrm/ECjggN2JBMVotuEAasWYFxJvjmDFHOPl1CAQ4+3MgYjs/pCKwyNmBaYMgElX+8CmtDnmEALcgWA39zAcKoGiuyHiREHAgUdw4RWUwHcCg9nIIwQGNQLb8+IRX9+8gDfiA5JalFHFyIBjcADsmQX7+IRXqoDjiBeJERowNOQH5cBbXMIsACKhFkDbqBeakB3CLb1AcQLw+IQ9pAuEWBYCAkFBkQGoRYF3AQEiECyCwEIAwLIiwEBAohCBQZBYCRCEAYFgWAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfzzEDpDFCwOZ09damQGJRI1RI18/wAQRoNXjXL2RCNAYkHq27B1qRKmRZWWPpdl/HA0OwPqHk1X+jIAK6Wwqo/TWpUTE9ZOQBe8f4jgq1wqCH+pBDkx0jfwxgoxWRJyB6q+fiQXWiAVVNQgCWESASiRUFUA2cV1A+pn3iof02eb6uTcUvirEgXka53IKusgFt8givijgoJ/S6SZFrj3kRkXiGzTPJlFxBIRIGq9pBrIhIl9h5kRAutrn9vggaxJC5o5JwmLiQcRl1McAajBMRkQwx0khdzJRr0mghsjuoRMaQB9Rr/EKuOQI9VsUDRMVFxLfQSu5uTBn+n0IDL1HbMqVSCDRBY7a+fxIq4gE2WQe3jUI1TIQL7BuQZwZJANPiCtIPqFh9+YRCVj6hyyhAvbpLX1Ug100sgPJ7QjJZCKW0oGl+ojFngjxAvPURa9+ZBQicQieYxKyMRjqqqNFDGLI6aZPiRG8d2FxAmKxBs2FBT/ANfd+R8cI0SSeQu5kETJBB8SALxoAA2iIF6j01VaX0jECXlrjnsoGi2tCRExyGSZF7uWwXYfZyC70WV94DH1fp8cWIqA1obkAHsgq/7CKFpBncByq1ILibAAR45hFDb77UBkUBRcCihdLjtIiFApn/EDQfj2gUVvcgE910uEARph94F1Z4gAy69oA1uRBkoQNIAsnfiAXZ/SRDacCqiiv5hDHXZGBaWpACJANQL4aEIg/aBQPMgpIFQHP1kRQf8AMACPr5hACuy1A1RkE1WoFBq+YQB+gkFxoCipQI7E+ZBce8VB3IA3cC1uEV/WAgXxIhAuwVIECjivMIkCurgaEiINQLIH4hFgAYFdSIQHMCg94RYCAFyCiRCEUQLAQEiK4FkEgWEBUCyIQLAQLCECiQWAkQhAQLAsBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQED+eA+kdQ6sjwbP8AvmdR9dYYYsB5AlGyOa+faTStG8if6eWLIrXEBkMxieog5jxHib/iYkEdBO+x8yKEYGtDQo0/5gU5fqxIOV2XCYZ5eojEl6T4gayT6cj1GT+ImDYxKo64UUazI6Cf1dN+wP8AyIi4knIjEkOvf6SGf6ZhvzVxBMMgT0AId3FP1rJerqx6RkDRNE+0MoycQcQhtnRL5jFUdIIC2ELv5UguyAR4N/uJD4BshFcsQgUMPTkyF7mPoZF4EAAkUX+IGsckQCKCZPz44zUqAEknAEHQLB/EH9aBDHpeW9aQkMaIrVB75G6kZTLJAvpTRuMVBZIOx5oXAZAdKBIxHG4F6jroLAfvuMRRlltkBkERg1qyCCRY/iSpAYrElGtDiQA2RliULC5lAFu2T9JBShgRweeNQhiEa6jpcwKCOpMk9z7SIW+oChftAr9JQ9UGLiCOoYkBCRBtfpADAgMkAA0ODAPLsAu0gpAJSQB33hDElJ0RrUAUMXu+/wCIFBxxyV90PaMQyIDbLRUC416QiAaMlDA5dFYjI6hKoId67bkDFNDEHcCiwCtaJ5iouRBBAenuQKIsY3xAvORGiQl4hAoOkBzChRbrVv8AMIWA/I3AuL418/xIJj1BMVetwikgiu2nJgEkkWRwVA0CgxZAW3CYAoDvAuIAGzoiRAkZGskYFIICZJ7wA/8AVOQGDREAyGB33CGVk1A1z3kQxNp24opoEgXuBRZ0pEDb8ygDaND95MFJu0yFUIWhxAUKQ7e0gvuh7wKPx7wgV00/EAWQhIKCvYQG7ofWEUEtK5Bd6+0IEkf8gBv+YApQKzqtSIWL+GBdXTgXvpyIcnR7QHy4F4kQARqBQQ+0B5gV1W5Exe8A3bkAwFwi83qAHmBeK7yIv0gPpIKD9uIRA1uVFBkVZEBqBT7QAMIsBIECyIQihwLAQEiAqBoSBAQgIFkQgWAgWEIFEgsBIhCAgWBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfzxvIA41rnnmdO60tZEEZYt6+nxQIV1Aq2q5gadAnM5Afc/7hDqJ9Ypn9XAEYh0hc+UPn28SK1jj0npROO+o9/fvcX/U1Gk8WKJvUABYDzxx5PIj9D/xnK8a9TY240aGRJIyL30lpyYgzQ6lkjzUCkWBYICX5/wAyIuOIaIGRwqzqBMRY6/6euQf5gaGXUMfTrfMiIT0g/wDkDN5JcS94LkDkLKqxkP3knlGvQMEQfSNAsyIzkViMSXk2CIGiHhsg2AH9YgE3sbOv5rzCBBGIBOPTpH6wqgh9Xq41fwSYhiQh6uk2Wq8f8lTFBzHU79xxIGI6iiDie8gdIyCZOP7xwAAAytkhHiUaB6sughdj1VInDD1EemkveQq/08T16CI+sJRIrppWQ4AgdSTBPJ13uAHIAyFKBvHEgkgA5a3+0iMUcD6R5PzW4GvZ+D7yAuUQeYRt6HUyQ9uRGSySMSxvUqr3DCVEyIDyySBQhVxsF5MbZ5hFyLKLexrciYgyNmja9OoGnyia4MCjJ0aLUYhRASQ4UggVn5qBoE9bVSIM9SZA4Hz6wIA08iFsupRq+oHg8yIFAIIVpKQMiWEltD7yjVkI8yAAMuPv+8Ck998SIioDY3UCmtA1zCKSARkX3IgMSDaGpKAII19CYFZ3xCD2Qd8QKWxTLUgle8DVkdWg2T4hBMd/rIKAtfphCwqBAgECbFQBD2VcCg7B+kiFMB2oGmCVyOxhFCBQIYkED56TAodVqEGcfMgq9wYFYWgeIRDQX5gVAhc8QHPO6kDQbqBWNqRFfBfvAIh3CA2ih5gUJeJAC3v6QLyivdQi4uQUC24Ab4UB7JGEPCgUeFIg/Se0C+0BArHeRCya1AtLdSB+YAKEUnv+8ACfeBftIivgwEgCVKtuRAbgWQIFgHcIsALkCAhGjIhAo1AQEiDgakCAhCBqREgWAgWEIGtyBASIQgIGoCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfz4jqwOICrR0Z07rPrkcEcXlsV2HxS6utlDIAf1HeyizIfFAxy/qBIC36uf53HxNwPURlaFNag8MAepXicTePf7fLii9WWPpDyLPG5EMTl1YnFo2B5MKYDJAvksAfiTwLyObohrkPxKi5BI4jqpm5IAQzDDRLP8Ag9oQD6jkAObS4EfBMU8rRGzzFHT0EAYGvZ/WRPR5vHq2m3s/tHiYrIxBOibHPaQQZZkZaGTQXPt85luC5khX0rYAY/1IJ1MAUQRQPJ43BWsQti2ObHy5EawQxDWVtc74+cQlQjEZY4lkeNRomqCyAvcKoyya76OV8Qgck+o0Gz88SYY2j6SERzVyIwQThRrtLxWniOlg4ntoSYi98Syt3CLiWWxviQH0hE0h6jS+kC47oocCAx6WLWKcJ6hxYJetRo3Suj2HaQBWNjbfaEpiACz1ACkRcUAAQSO3b8yJVrpPp0e/aBp9gh4MIxkCQAhoV/EK16kRQS0ZEDQ0u4A3AUQCceaqBcgh6mLkFBWJvWmIRoBli+kcmEQEAMM6VRQXpAIRPEgGyQySkHAoRILBXaEXRbG/VWoDAdKPA15EUNDz+5kRrhr/ACJAIDDIV8wGI6cQNX3i+iggKwx5gXpuiDIgqWRZ0nAY2Fb/ADAvqplAbhFA7JDtxIBsHiEZWNXsQN0wB1IwARyGhviRFINk/wDYEH6l/cPO4FJIFaJ29wAsggyBj724FDJP7iEUjRC+okAFHTD+8IW3r3gUchagWjoESIWwz7GBbQ79oQuxkUeIA7FkkdpAB1w4K0K7bhFxofXUFKemue0gmj+YFD4qEHXcQNex95EZ2IGjoEj6yC6KqAHdwiiq4/MBz2kFpsg6gCkYQ99yCg/eEBVr6QL5gOFUCvmpEPrAvG5AP5gW+0IhX/IFBr9oRR4kFdVASBKiyIagUVIECwh9YFgNSBAokRRCAgWAgKkRRuBZAgIQgWRCBYCBYQgUSCwEiEICBqAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfzs2ASQC9unxOndYAAf0xkULBA8doFByBBGKvktNcSif0/6g/wDJY1+XJZ4tijrBGJy6ieCNweGPSR1ggGgT27RU/GyBliKKBoJgVInHME4IIIC62N7+al6tbB9XDPqBQ7f6kDElAYofRo8xiLRYWRtvVSCD1fpWLLHzvuVGsWf1IYkCpkCLHUVkW1zKLjkQOroyGIutRifUz9OITP0sf4kg0MwS3YHFyYYmf6kct7JDlRprBnH1Y3X+frIBWP8ATfTY5I+6g+tB8gi+Bv8A3IiHIJXffkiMGscB15Dq8Gt9tRqMkLIgk2B7mFUjpxJeRKRIjooA9OGK3wVuRAZDqILB553xGIEg1wbxQ4ga6ukdOaPKI13kMXLq6wTiNvy4iMgEZaQLJvcpWxeZI6qPbj/EyMj9TyyIQ54gbYyodWWJ1JxBAPLG8ibf8ygQSDkgT2gMukY42X3HaQB1DEBt8kwB0vV3uEXFlEf+qkqBqsSDjArGLqhagaYBuz7whX6jV17QBBLBJakVAVjf5kxFJ6sX01v6SoqJAAQkVSLxQobEIrWRND6SCHpVhjjyYiLsF81RgDZpdqMIbrqL0XAoscUZBcQ8snbhAsigB4NmBRkL14AkwCjjok9uYFCF2FzqAZZAfwQijpWthQC2Xr8SItIVe3Ahr9VHuoFH6QeW6kFDooDmoRMciCzocxgoCSJkFBBxdjjUI0wnQ+viBkMUHUCglokhyCgl8iEXbCHe5A23X8SoYnudiQX3sjZECsiyB94RDQQ53cCjLnkSYBF8o9oRWelGyJBbGND7cwD7/vAvCShFAD57CQQhFQBQGnAtUP3kRQUbEA778+0IoyXLjBS2LEgnLYlGufrIiBNkagUXoVILrVHmEONwB7JwA0EZBdcQi9vaA9oFciDuBaTkQhSEXcC7UiB2IFkCA+kIsIBQKJAEB+IRQYFgICQUGRDvCKDAsBASIAkQNSBAQgIFhCQWAgWEJBYCAkZWAB4gagICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfz4olUS0yf8zp9dYJEdIJFa2qGo6BPoAOYHG4GMjjlgdMnXHBl9g2BiSA7FIfmZAFf0wQkLDalGQD+lA8MY89/sIP1rJ45ZZAEnH1IVv23IiZMkjZHP3v94irkwzjjeiSPEAQMQMepCgcuflwhkQhvuT7hSGLiMDmAdKiAdPjxLUaDeTALPHPP+ZKMnIDJZBk85b/PMqKgMfU963W6kVrIDZx6SX+3+pEUlnE4hX3KhMZxQLBd7+c6jFXHMZg9OVf8jLED6s0wdsDYkI0shvXv+9/FCGGOXc0j7eZBcrIJGgTswGRJJq1rs/aBclRytDkxiLnkGEHgBbHZVJEZOLz6ekjZMouIxdUCdzIoTtDsjAqfS8Buh/EIO0hkSUGa7wpvPpDIPLhGsQhRQMgmD6OS9xRQuojlwLjkX1PfeRMD6T0AB9oRbJHUd7f7wIyVlkxpG4FLLAyIL0EFIAqxpNwjQ6QN75FuBP6gJoMnXiINE+m7JCRkTAhkKu0AOkA5eX3Ugp4JPH3gXHKrRPDhFoe62eYEAJAxBfcOpEU3lvIHn3gOqkAEPEGCYJO19IRoE9R4JqQZB6R1ZGnrtKNFkrtz54kQIHS/jkCgUD5gUOlXfzAAujQ4QgaArstQjPqsINQKN8AGQaBGhpyIp7hcbMBSAfjUB1Ah6J5hGgupHepEP7QRXaoED0DWtwLlsqyJAPMAXoVApACFgQgTWtbgUbsEiKi2yG3IICigEPEChLTfaBo3xciB2CgL7QMgjiEUZPuvMZiqby3qRFA5pQgB8cC82qcgFvyYFYhFJLrQkMN5JQihHioBoo/tAvZkOQLBX8QB3pDzCKF3kDHTlDlSCg8wi+0B7/WRAd04FNwECsSIH4YFfbZkCBYQgUGRF8eIBdpA+kAzCLxAr7whq4DcgsBowiwEgcQLCEiKDAsBASIoNqBZAgIQECyIsBAQLCEgsCwEjKQKDA1AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQED+d4DLpTAd7nT+OtbHSCGSQqPc8QnoygSu5PY/HAmQCIGJBGnYyhYwCBl1gHrHe38uU/Gs+sEgCgdWZCBX9MtAgixYuOp7Rl5E4vpAJLuMFy6qCAxIs92LgMScyMgcR0lGtxwUs4lskd6I+sgYo9RLx5I7/LhAGhfgXIKVk8hkzi9Ek/t5lRrHnIFVzrx+0hTHEgItlZYn58uPEXE6HUrojmSwD6idpFZOvzAyggQMTkmR5gaK6gekjTCX/JBabOJOTWqPaERk4LE9KLGvjlGlTJVKwRJUCCvX0sB9mZCGJPpAHUtlOoF/qBYg1ZVxCVaKGwuDII/R1Y+nlviEWgkSQeH5+faEaF5EHFo0SUQv+RqGSIJAZdBX81IqZ+sjI5EvsfnmUni5Ml9TA5MicHiFXpO32gAx6TvLhyDbrqH07mEQFX0hbPt/yFMQenpZAMI2QUyi/wA/T6yIzlSGNd0oigv0rIHbMI11dJGW3enImIgaK6h9zCrlYvQHaEX09XsG7CgBk76SyK4kxEJO9gWalVvqfL4AmUwzyIDVkscxETbWXq6e1yi6PSSQ3oyDQyP/AJP/AJ1UZ4gCUgKW9qQAHn7DQgqHgnS7wNYlkvgyIAn+0dJf3gXpJDPs9fWEN5E8L3gTJApsvj/EDYGJDJ39JBELQYHnmBWDbJKhFKxAu+WVIiYgpErmFaBxBCsEV/EItgWdC3IB5pLRBgQHsADxCKQbI1AposXXaRC71QgDwzXaBRaJJCNeYF4IkAcki/5hAfPEBV+PEDQNs0ZEAOmjze4RQig6cBsn23zAexv+ZAP6gxcI0H2scyCWQixAo7lwimqJdQGJNAGQMqEC9uQYDeMiL2rcC92l5hB1AFGzzIKuYB2PyIQH3cDXH7CQRkX9YFA4hF+sgG9QgNpQK7qA8GBTIgN+0Ct+8gQEIuTUBRp3CLoyCu4CQBtwhA0IQv2kBQL5hB/WBYCAkFkQhFBgWAMBIiwLIEBCA8wLIhAsBAsISDQgICRkgVwECwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQP56SCA2H/NH+J0zrE6cSPTsIkqXQWWQy9TGWwT9IGsqyOGRAZtwT/XPIv1Gq5+e/aVWiVj2ANo7PIkwP6hNFgL9vjgjVjqxbW63IiPEkDG+BTPvKfq5ZAEBAY8Ed71JhE6iHmsiQv7f4lz0UnHMMdLNod1uT1ONEeoHH+6/wBWvn+JBM7zKOWXft/jiWIH1WwyGaH1K+bgXpeIORHUBXj52kGiU8wMWfjkT8YxJyBOVBC/m5cK2MSH1bZV7+bkETTYICZNwcbyBGRBNn5/iPiQYB9RsUCXUgYoE3l8tdoGccGcjsDRJ4+GLRQCMjwuVqpEVAY2X+YDAs1+k6R0YKuOQxGWJbB+w+kYlUsfpNgoMtVJouekchu2GIQIxxwsdXjUgoOygaoKg4FYeI6gUdg9oRmyiMuo+OIVvEAAAAAaviTqBBAI9ROhWj7wIQRj0n23cChElZHE8PtCL7C3XeQK/wDZBJeJUUEMFs3oSC0gQbf3gCGyGuS5BCbJAZ7vUI1i0cgDrtuErB7gb82YVp9RS9XHtwYzBTWNfcizIivueo+ORBigY7ALfPvIhZ4HS/eAo7/zAo3RoW5BQWwBo3CBIKJdjtxAuIJZyyS8QhkSwzrs4MSwFY7XA3bIQR4kQxRADrtIKCERXV5gQj1cD+YDE2XdmBaBYX1hFugcSzICBCRHPvCAG7T2IGiQCQTT4kGUU1/Mo1x3X7yIuTO7kFLBIuoQZ4BUBkef7ZABOwGfeUV9Q5ftIgU6ID3AtHL0h+XCBOmSyO8ChEInj7SCkoNi/wAwILvIwigJhiQF37QKQHtwigj/AGpAC2oDEC/xAqs7hChj7SBjd8H6QAKBphxiL7V7SCnXMIvFX7wAN1ZgVhjxIIPBcDQC8SIeNygkFILTLBEIe0BzzAoPNmRF4AgX9oEgUfmREga3IEC+zMIfRQLf+oQEgsBIK4QW24Q94VVIi8wAgUHiEIASB5gXwZEWEBAsBASIsCyBAQgIGpEICAgWEVyBAsISIQKIFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfz/PqKy6vUAed1xOmjq2WTdY2QN/B/qFP6hKOJvjf2MsImf6uoFYnaA7QqYViAMtDb+kqdXAZgHMnHqSs9v3qQ8Dlsg5dOVCMEyy6fWWzRDP2Ev4NDI3ZGK0RZkAZhZAA5I6Fxg3QNA7KC+eJEQ9Yy6bRLPp87gZ6QshmCTwqYjRvBADPFgaC4CkT8XFHHqyAP/qV88wfXP9JOJOJKRXI4lG1jSsWmNyCZF+pDGm19e0cFyYsEMWeZBTQyyBYdgQinFulxZr3hFA9AT3SCkNTEmx6QlXHzX3lopB6jQaY/LkA5knpDxJ71xv3jExSssUQw7v8AMgpQB2taf4+0CoIf/PHn6fLhPqAhkY5bb6hr7QetYljHE5b1ciGA6cgLqj5iqMhZDH6pfSoRNvE2SU+8C4hAhoitaio3iT/cdAAr/cgYhoELvIJ1FABnvqMG7zvsdyJxnDq/2/5louQBJZrktU4EFFsBcEVA1gd5ktDjiRKErIEZbNCBcSUkd0zepEMTk7+ycURNUXzcCkEJgKBeodRB7195MFyeAokBs1RhOqwh1eoe+5BPUNbPeUPSfQCQZP1FXORB5IWoFwOSQI8yVMUausX+YB5HEOzovmDFoUGu3eQLpPsUahFAPU+e8Cj9QZf0kRQMlYIPPmEQfpbJx7RVMe5uBemiqHPcwhkiAX3R7xBQyfLVCRDLtx8uAy279uYAAdPiQXEED9VqBbLKN0oQ0dPLmoFBvnwJA6kCQP4ga8jz7SMoX1bp95VANgh9pEaBoED6QKCsS/8Any5E+smim5RoJAihsSBZux7QB97ECnkh+0iKr4cIH9I/DgMSSdyCnZviAJtaqBaI4gO9SIv7ioAEWmPzCKFQP/JACftAM8X4hFHZc7gB9ZBRW4FHDkRAaClGvcyCCBSie8Ic8uQUfmEOQbuBQ/pAD3+0B9JEXUCu9SAfEIrXmBOO0C0aUIuu5kFD7wEgWhCLXECiEJBRuA4gBCKICQIRfeQWEIFgBASIogWQICEAYFkRYCAgWEJBYCEWRCBQYFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB/PTiSCMkCNPQJ7+J0zq2wiXY/Bgc+orpslnY44lVenPqHViTpEcf5gTIsHLFkEWBp+IFxBB9HnbK7fPEKl9Jb6xzr638qEUEAkEjq0Ty/rFgH9d+kjSFwrJxBxOPUe5p/WIjWPXiQDgV715f4g6miQASMj8MBkcscul2Kb+sDfYIAvubC4kRACcjRYNgn7R8FGPf1cjufZwlCcSAMcSBv3HsZBMMsxjgWWTyH84+8v0sXFG1Rqw5KGRy6WSvLsio8GgQcgsiT5F6kQN5I+oDQTK+kC0MWAkfqYQBAB6qKDPeo/g0Qs6DYTMyIAh0kUAUAPaVAdQRBBekyv8wLkf7kMe4LFxgpHTnsACRFACOQxPYo38uAYGDy6QTo/P2kFxJ5oloj58UJQ5LROtLm5MFGWIo6A20oxKhesrf2hWmPSyNPdfT6wgAK6QLHsHILiWygxAr9IxGIeNBi/rCIGGDTq+YVSTiX1G/moQJDJd8ntIHUXYXa/EJgssR0tkeTFFWfUR0McFfO0grJfTzYj+oBkUEHuAKOROJYVOEaA9bC6eT2kKn9SrCJ7/PaILkf010so24FGQBHHfxIKSwibOtwi5EUeeFyYRjqqiKD5jFaB6v3HiEXbxGOxRFSBiS/0pDvIICACCGOO0o0MenTJ241GgSHiR+ZEEQAnAoP3/EggZCC194F79Rvg9jArH9yHgmREBP6b55gVFhkF1u/pCBJNqyO+4FA/9akDhHY5hFBQVrWoFJu/xIIgaD+8CjqB4r8Qh7JH9oAtoGoGj5AF7UiAF6AUAEORApPhc7hExGQA2+ZBrE/8gCCv8Qi8qx7wHLFyBxCKDxz+ZBeaqBfyuIRB4P8AqFUtM7HiEUpt6kAXpdoQ0LcgosFwgT2b/aBepUYwB95BQRUB/iRFxLEC2umETW9Qq6uEOZBWXcIJUIFsnhQG4Fs+0iHfiBeXIB8QB4/iEUFKoF/cyIv5gTiBdwLZqRC/EIA/WMFUgsBCAMCwEgQKO0iKoQ94FgICRFECyBAQgIGpEICAgWEAZBYFhEkRYFBgWAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfz8ZYkWW+413nSurxk4vEnpJxBXmVdUoA5Y4qmzAIlLIBZEAofBCJkUfUQyKYALlVWCSyqXZwIQrZ73s/6jRn+sfSTS7NX8cTqwyJxYOGN8n9vBiDQBx1iMinitrx+YRcT0ofqyJKMgnpKQB7Db+0oHMDSFa57qTBX0vqyyyCaygU9fSOGF/iTiJ6GRkQCeCDcCkY0mUNPjvA08ulgb8wiZgA9K8FbMH6v9QselgtE/vIkQ9Vh9R4B395Qxr0jpHPgb7SZo1QAyBbss/OwhB4sdRWQP1+f7gP7+oh8EP6yDeR11ZPqHGx5+doRkEHEHTN+fikvitM/ptnna7GEQjFF5rACwOaiFaxAFggADsIRWUysnwJBcB6ccXvd7gZxuwGze3BxUF1ZXkKJUiH1GIGyBAuOJB6gj4EGhYP6gQdwjRoM6NYgVIFjIr+7S/aBQBYogbcIzs1ZfmoUJyPUR51CNCupvqLa/aEXQ6RkKsniQXFjIjGhuQRhoPEc+YDrLQCWuITGjtF2A3CGXpsfk7ieitnpAsakUAHUy2N+YRSekLfnakGcgWHnimx5lRsU7DKDVyCg+lGj7agTFJDIIpeYRoAgkjLfLT8yCEnpR+3z3gCKZAFFyCs07B5/mEXlA7KgLJAYB8KEF23+IEJ8Ht94GwUDR8yAitaNYwinRQVOQMT1CsiQ1Ri+IPht13gXG+CR3kwVBUK2o0TM7W+0QW2gQX2hFB4BB5EIoKofeRRs+faEMifP2kBgNfZuUU6AJAKUiAIa5PaBd6EgB8JmEXK6FiAJY+sBwUf8Qih/BAqQYHvIieCNHtAo21epBfuXREADQ94Ff8A0QghsuuO8gtbZgHTbhFCQEgDUC69xCHuT7QLzu5ANGBT93Ihz7wLrxCINwobhF039YFo05EUb3UBs6gLgWnIhq4RZFBuuIRTVQJzswND6yINC4FEgfXcBxCKfMIoMBIH1gIRYFcBIHECi5EIRQYFgDASIogWQICEUQEiLAQECwiuQWAhCRCBRAsBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQED+ejE5HZHUO+/f7TptdWZskjqA3b3oxBereOID9735+XCmIGP6Hjj84i/oYYnpJIGJCims4dWOKDxxJ0nLTp/S2ycsgTZ7xQCJyK9ieYVcekEHHq8EDgRUQLInpHSEQumx4/f4JRf6iwBZR5K9+JMJ6AjIgY+o0SQPiqBoYjqJyJ2tyGp0sNgdyPnkQGI6zsdRtkXCcQYrI5WFjVRqtYLHEXltkPZUl9TBZf+QdBAcAb/AEkIgBc/iEOoIoA3wP8AH1jBr0YsEjXsDfaPUUnJHq9NoGQMz6V1kFj2IgMR6ssiMieVqSoD08P239u8C4F4gogp7UXpUR46idjv9vmo6Kiw8sQeAQoAZ4nJZUSOdSYjZ109IGIJgxnEHEFogBWGF495dOqMsSg3TN/ViTEa1w+kj6SACT1FWtyBsnYPHjtKguTdj1D8iBoo5AZhcktyJ/EVsEn02HxAuAyJD0gaMg0S78a/YQjLCCKC2RZBhQDZIfZCBcmcTkMWCeDuGRWSOdbkVreIy3iPP2hEGQQTx5BJ3GCvMYvb5/j8SAF1LReyoGkBj6u9CGVOiOlYpqAxpEE+CBIrTAHUTR+8iMtAADfPMCgli+FCIQcsiECFo/xLot9IyVDYUguIQxog9tqETEtr7j5UK6ZALFgXuRlnELKi+frCmDOKCHaKikHqQABVuBQstIHaMiVRtEcFBwIMWWQq32kFIb2vaBQT+kBc6gwreu8IuP6bIfCkqACHZmrhTCrVPmKi96UguJehXxQgC2bFWIFyIDF1dbjEOwRXnmQaAAJYgSiNv+ZAwumQ5UFZPirkVQgBUIEXtCQCQdH6cQNM9jCKwD34cAaB6j/yEMkBbF7kFAslXCAqAxvEMDUgoHYQHb1FwgDdj6wNNvs5BAOln4oFB4SrtuMFa7VIg6MBtwij3cC8oortICUIAWyoFf7SBS7CUPzIKdMKEFuoF4dVIgDp1Aoaq4AbgXXkuRFu5EIVQahDwoDtACzIig04FEgCUXgSIcwKNRUD7qQPxAvMICBYCQIFGpEIRRAsBAeZEXxAsgQEIoPBhCQWAgIFhFBkCBYQkQgUGBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfz9kAFkhPx3nSurU5+nJEhUK38/iMGciQStAKFP6hGX/rbd9l4liQIOLGAGvFfAI3RMcSgMlQYJ5elLaqdXVse33/18qDP8Umjl093fFxgf0wDQ0OB45r6wVA8cCKXPVVe/wBv3lFNkoBkBknYkVl5jEdTYNfPrA2f6hTxeXBZ+fFGJiHAYayJH6R+/wA/3HQ2D/4wAiEuNfmQpiCQCUx3N+0tFxByKJ5thLf+pE4gIP8A9WDv5944N4gY49IxBx7n9pLUHkcjliWToNIGAHVkK7PXP+YDNZkFVpdxA1kcMiCct7BsCTP8Zn+KSQHjZ3pnz+8h4IV1ZAEUb2Pn7yhkD+kIOg/EgYHOlxsd/n8xSp0vEDIkI2uI0XeIZS4Wq+3MlFK6iiSNV3hFyLCOQPgW4wMnySVQfztApGJCzfn/ABCGTFUCNE3JAHVZSICvn5/MIuCxN0BTMgAAEsWQL6pRrIktAVQciMgIHqLxJ3+IVccAyCyC7UagOQQQtirMlD1DG+TpfPMDYCAAL6i9bBkRWQKZBFlQiADpJGl2swoA1ok+0IpJwCA9+0maFDn8wjWOSyZBIGrgxATZxydc8wLgziLR4MUMKDFFUO8lFOWOydOMRQa9geZBMSig7CuMAANAL2hGg2KY55JgAEd+y5ig2EHT0dyJRMp0dGBX/wCxX1+lwiJhZC7H1hWkORetyIpyHA/URCZgwLHzmBrqYO//AJUghBZI1oQKSciufaEUsNFVIJiFjZAHB7xRQSeH/Fwiv2cmC47tapwIKxQK8b+kJig9RPSRAAEYqBWVQUgpAGvaEDYPDMgAezHECgMonm4RAb+sDTVMASACySDZMqKie9D7SAby8wKwSDzzCKyvTIFcnUIEcPcC4uu/7yAtA3cAqDbgGCWNahFJHe9SB4/mBQQtVCGqf2kF91qEBR8QKF4gXvIAH1HMAAPpCKK3x+YEtPcDQpebkRdSBxAD3hFNVAQKD4kD2cIY6swL+8gNbEIvEAK8QLsyIo7wEBIEIutwAhFkBuAMIrgWAkCBRqRFhAGBYCAkRR2gWQIQgUGAkRRAQECwigyCwEISIQKIFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH8+yHWUDiwe37zpuOrASU8cgKIjMFZYbW2pBkkHLIM4klsV7XxKKC2AOoALf4gQ3icXy9fbfzcozlknliaLAOhEVQ2wcb48VzFDqJBAwDBtxgoAGYDCbs6PwQJWI9OKBCeoULDWZZC7gdpYijIZZCwASwgn/EmCA5ZDbDPT34v53gzFDJRGJOJcC5HFkE5DZPcjxIIRyyCHx8Uo1jgSGQeo2Hjq/HtIyEvJZAFo2NnUir/SxGOQxIXJff4ovqUxJOXIDR3fbvBwwtggshm7EUVj0EAF0FzIik9OOxichydwGQ0gLq/wB4FIAG6IQI4kRTVh5XSyRF3KjIKPVkS9o8fWFrV9Q9XlVp8SB0gdQDp5e30jqA6CTYSb7nvJQzBYICPLK+sQXB9KRAFermKgEDtEFXypKrVG0SAGCtfA4ZTE9eI0FyKjMOKQSK/T5rftAuGYYIIJJ1sRh8WtBY+537yImIAYLPYAQKC27PAMgYnpeLDbX3iw6HgMoIt17QKOpdT6srYMVFyByTCx3UDOIqyg0L894Fu/V1LV37SI1TADIFMSC4nIZWldmEqA2bJIHdnUCkgjsGioGsjk1yeJMRMme7om18/wBQLn+pBg8hwGd5DtQ8SACwf03AoQx2/D1CI8uQGxA6dIGKyVyIzWK7UDA1Y2QQtcwJW9L8QKCDog/SQX+mAMvbdcKKlQ+rZIAP2hF//kBxzAoOiWveQQokgijbgXEmxSFWIRdgi9/8gRtkPm4GhZ3fZSIAksVRjBR+qv2kA61RqBUNBsuxCK2R1E2ahC178dhIAbI7eIFPbpPeuZANboyigcGifP8AmRBn6fzAuKGQFakDHetQLjpL3hB2O/mBSUrRPiRA6CSP7Si0lsHiRDil9YAe1yC0DswLVniEBvRHaoDL6BbkAVVDgQLUgrG4QBe4QNh8QLjl93AtHxIAIHn6wAMiKO3MoV9BACh58yIpB51AJbgF21IjXYQArmoAQLxypEW3uENyKHcIHcCiBQlUiFwNSCfSA+sIsCguEBuQIQ8wLAQKJAgWRCEUHiBYCA8SIo8wLIEBCLAsiEBAQKIRQZBYCEJEIFgWAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4D9Q7+OPlTpXVouoEEA7dWoDIYkfqIG2kIE/qA+ojEZBhXcoAsceqiJFwPVgG8dg/pREqdMRleIoPsqijOTGYBJaT1cqhrMgEgmtft85iCggDEFgnQEC4hZYhOmtor94KmNZZZAF8cfL/iALJ6ukbKHm3AmJ6t5lgEa04MQ1i+vpD2Tv/Uov9MkgAk0EwX8/wByUXM459Jx6iDQPnvHBSSAMv6nqZ9JHiEUE+rsQxyvlzIgeN8rfO5RTkfUq8+V8+0I2Op5HEgW7H1k8PjJBJxC0DyKfz8wGIPSD0tFHIwNGgMQMSNAjv7SInr6wARv6x4YoYAyTxI0eYqGBPT+oEE0dExRcsesjEAg7387STw4YEf+OgD4TQW4GrJOH1ZPPf8AEiIfV6W+d78+BAq6smdtsC4Gs8eGPOIqRJUBx6QMRiToaDlDYOQI6se1V5UDQAS6hfCmUVY9Nn9oGCwAFUK1s9SGgfnmEMmSVXOoRWMbJVagAMr1v6bk8AZPK2b+3xQLkMhiURk6PmEayDDzZq7oXuRDArHEpDt9OYq9AmCCewaY+fxCCVEUOF8+OQXTyCR3UAeoBMkC6ChFFl7Hf63AoJAPpHsOYRMSEzl7qQUVkT0tElj94FYNghJAjmRBEZEAtC4Fd6IReoGQ2QMj7QNsggA1y/xCIRsABeJBQcjjX6gbfaEPVj5P1kUZHADO4RpsNu9wAZHizIilG7/mAyayIIT5gA1zZuoFtPHInuIRRshyUQixRNbgU7IAPYwKDoEMmRAIZBLUC47KVwBNskXCA7F6gCAibXgSIuOkRUUUnqSHi4BrEFjIH8QLp3uRAMBQBJIMI0GyWpAutQGJQGhf1gXlAg/TUiF9SfOpQDCL+kiA1uuIFrIqquQXEleTAoumFCJRqBre2eZAyXdr7QKCUtcXIiHRuxpyjXHMiFLcBa8QL5cghvcCmtiEUc3zAO7gX2MiLSe+8ADQ0ZKAXwwiwD87gD8cC+ZEUP3kQBC/eFLBhF3Ac1AoPxyIcwLIEBahDUI1ASCwH0gPrCKICQIFkRYRQeIDmAgJEUQLIEBCKDCEgsBAQLCKJBYCEJEIFFwLAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQED+faWFAbvkHfvOm/XVtetBgIugdePtJ4iYsrpeI0SuRCsgdQ5vY4PxS8VRs4tZL3B8wiAkdXToXQ/EKDqxLAAvR3A1/UyIBSH0KAEJGcCcn6Mse5iqmD4yZOLBXG/vLRSMQTkQXjXVw/lfWPQ6cselkYg3Qheh/pjL0jGhp0fm44m/UG67gAdrhWsurIgYVj7RPGWcuoDL091vn4YXrWHpCB6hso8RTdZyA68RiR0HRg1T3yGjtGQUhA9bsNjjwYRQRjuwefnmQUlZdJO+MbjE+KSyKsFrt2hEy/UQcWgTx9oImOQN4nAF0bAJ9/aMHTAenryvtkl8/1JUvcYyJCyRT4+8SK3RBAxCA0TuREGI6/QESERfzvL89NMSAgGQNM/KkG+kgggDpRQFQM5HEEEsEDn3NwijNDI0+myOP8AUmGBDwJADPmILkyS2t8MwiEdTByBBaDv6Rwaf9QjIgek+ZPBQOckL0tyAGfS+p77QjSAAxGiD9IRnEUsgLFEwrWXVoo/TfxQidgH6jb5ga/qIiteBfzcgo0BvIJHzIGQQRxQxB5hFxB4BC9oRN4sMZfvCjyII79xcIpsjuKoVA0VkS/2b95EZR1VjUK3eySK05GWcUwCMQ/z5lGiyK+nJX/ZAKGVFjmoFx6iQ0P2J+ftIJidBpdhKKuPUR95EUg0CftABEC2dipEMShol+ZRWgqY0DakBdWP6izuBbCBYxYIhAOj1A8nxILja2FW4RBxwfeKKKJx0UgRUgXadWBA0G6K8b9oMXMm7PmoQxOR2AK7yWANJkV9vH5hFGmmqfMgvSWLJ8CBQHWhwIRFyoFNkFoDzIiHR1A0AhWoEKOQIagWx3/FyCqv/Z/gwh1Ab1GCnff6ISIO1yLgCfUt+5gXHJ0zvtA0P03f7yIzdEB3KNN9qEiCZCqAB7BCQa8sLzAhI7XCKzfNQBvHYkA7I34cBXfcCgFEgiRFfJNwHKf3hGmOOYEGt7kFL04Q7cXApv6cSC8KA+xgUfLhE4uQUWDfvCK+PpAokEV7gX94QBtQLxUgcwijyYAPzAsiH1qBYAQHiRF/eBYQ+sge8ID8wLAsBIBgUeZEIRoGoCAgJEXcCyBCECiEJBYCAgWEUGQWBIRZEIFcCwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEDwWZPQQBos9XE6SOpc0MeokEE39PgmlXPpAPSVV5O4gmSBfT4ff54hYAM9VEJtv4aEgo6icunEEY5Fgi17yiEI9RQy4xfzvBrORPbJ8kj7QrbBxGSVa5gYIGTzKHa0j58ywB0rIYdS+24D+nle093cUxp/wBoaJTaLpQJsH10dElLwYGf6Y6iPSwQHYL/AD8+sq6oTWVeoAISIZZf2k5WQVzoxBGQAOpsNkeIG+vEg4ngPa8qTA/pn1/pOIJe9OKl4uQbQBfCfn57SQMjkMrPURukB83AAIlgsMEgdx3hFxJyAKByxKIADgpiQxmKQspe8UQPEMl1/wCv+YOtAIj1JcDj6SCjDIEehAcVfmGdMshrqQFULuIIQPUep47XA9oVqhjbAPB17yIuKOWJCOOPJ+vMCk+nGw22v3kRnKwMcRT6b50ZRpEEForfJkGVhkCyPFij28x6Nf08siOnHE4tB8cRUpkiGFXf7yBl1GxQ9momCginiu3z6wgR1ZEDshaHxQNjLqWQGNaR8yIzyrJJsd+YVo47CR7kpyIhIAOQCBsMfmMFQ6Dlgr127R99RooGkQBAgIKBJZFP6wUBABdEk0KcCruQibJMiNEgDy78yAASHp9j/mBMkKxB4If4hF0fptBqBScgMhruIRT+nz25kwMSSVzwCvrAvUX+rRcgn/zlkS+YFIINI48/PpCA6qOXTVmtwVpchtfiRAm2DYEA/X4gXIoFEYqzCBBHU8b2fn0gMkQgK7ftIK3YR9oQFB0vlQKCSTfSiU5AJAtjqgC+xHlwNEimhl2kRDdnfZQLTIGK8QGB7vzFRp6FI17yBWiU7vYhDHjUCtEAssrcgHsidQIqV/4gadEEfiEMTdgXuQU+6cIGj7cmAHIqt3ILiSRuwe6hKvkuhABgcwKr5cgaNkV5hAn38BwhTJDga4B5kDl2AIFdCzCJtKrUDS1uQSjcCgkjtAe1SIb/AJAhFt2NwKWTde8Csn/kgc/WA8VIinTA3KB09GBfaRAdlAP6yC65rmEXhQCgD4qEV/HID2zAp1IKHrvCEAK7kQL2INSIB94FkBwi8+IAmEWAkCEXzCkIsBIK5A/eEWEBAsBASIoMBILCECiEWQICAgWEUSCwEIkiLzAsCwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQPAEAk+kE3s/wAdp0rqlL56kdyDGLOVEa4NqaVoDpyQVm6qTdT4NrAAoh6CFSjJAJ0EKrvyYUIw6SUD5CvxHoAvqGIJRbyPaBggdWssj3I9pVdM11A5MVR5EiM5C8s28gDYEReNZEE5NYhLaPnmVGf6eKGJzIa548qKusonIZkElJr8+I34Rf6hPUAR04qiQPxKRBQv9WJBDkVrK8epmq7fWAvryNAJ3z8/iOpwzB6ivoBzAovzi94j6yIoLIPQ9gvQjFqoZiyzkVWjxDO4ziOrNgB6PmFvjZGJC/Sd0LqRGMXllkH1B0O4HmWjQyYJBzLYEmCE9JJ6gS2EVGbT41liyTQIHPPf+ZIiA45Nh0gRr764gbVnpBBBe+ZNRnEAAPIlBjn/ALLRcuo4n1E4ot8+IgpWOaTR7a8fPMgAuj0ggoyCjJhesLXmEao4dIPHFyAR05Yqg65BlTVxBXLxQN8/HIJfVWPjs4DEnbsB7ZChF6icR1lohdv9wZ/hyVSVPcgpZZZLtf8AYDGmxhYRtwjWYI0LSNyA/wDyfqxQId6AhOGWRFjQ3UYqjEdWQORN71x+ITWcUMSA/YX94o3kACS7fOlIi6vdHcCA08qJCYhAhZJ15MiqgMwcgBi9eYT+L/Y8gELuP4M50aJ1oG4R0GTDJd14kXDG8Q8unhcQn1Cdgc0u8gCgMcqXmh8/iEUlMH9twLiHkEkfEFNmy2FZgLONZB6438EiLzQAIhAeLANo6hSuSgtHtCNayrnfmQ+LiTkgLB2XCFk+1JQDBBO+ZBMTvpAAe/2gUdhiQPMDRo2OL8SIbas/YwKSDker2UIYAAWbG4oI/Vc7kAknLdLguEXQI0RApsMi+PaQXknUIFv31AfkeSpBWRdBbMBRF2fMIY+o+1QVo2EXIMjZ7cPUVFB4VnzAMBovlkQNEWbRkQxsGmDzKKmdCRAADgsRQIpa8GQXRqAvlqEH3HtA1wrv6SAQiDoQigVxVSCX4gUa+nEICt/SBaPaA795BoPv+IRD4UgoJO5QJV6gVAEv8yIg1XaBooSCtBwgD3uoCnUC/wB1mRC1CB/iFakAJXCBgPEC3IgNiBZA4gWEIFhCQBfZQijcA4D8QLIKahDYkFdwigwEBASIvEgsBCECgyIsAICBYCEVyCwEISICBYFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4GsaIPUf8zpXUsgjDIkg3wND3jqn9X1dgAAmAX4uJSFgave4VEMQcQUKNEg/7l/Tq40csg8rJd+0CINhD0ojI7+0CYrp6TiRrqGv2gUXjZHun78yKmTJ//IUSLA5U0k/BsdQxyQPfVafaRVOLBKIzPqvYl0QAgnE4k9Y9XDPcwJjknxx3XMKAYiumwOKf+40GOostg67mETJnHF5AlenzCtBg5Y2QC2bC+GETq2TljWTF7Hz9oFzKysDtu/NRgI4j1+pk0fEg0AMWSRqgoQxyGJPTiexA+eIMAT0ZKw0DlBU6gccNkAfSMF3aD5uwf+yCjHqwsglqqYhAk44sjIga08jx+8dRpHp6WrWkvpIGGROI9QB18EFhYBReRFlyIrHUMgQTl3I7SjQIvRW7FTIhJ6ECcqt6H+JfoZEEIV6fr9pEXH1HqZJCCfntAmBOQIJOQo/BA1lWJGRR6kGYTUDIXZe63zHFMLBBQ7gmRGsDTyxqyLcJVOIxy9XSbrhSHQoZA90SxcIdXWSsjieQKjgYZLIYlasniMDkqshutQKv/wAdhs6bkGiNnL9PH3kQJxaoUq5HaUO2yUD7yCZCliK8Gvo5RrpHUSKq/MiGNEA14IkqBPpGtMZDgxwV54rE77OBRRaJJFg/tCM2cFb8fv8AtCtY2WwA/pINFlPX+pEAf/yNortAA0OorxCAFBghFeQYFJCLf0HMCvHwdffUIfpCX+JA9QyfSSYFyZ7gDSqENVT3qQKSAeJ8QKAmQOeRCGroIdnADkEBhdXMguN48keIBsrI9RXEIosMAQKmCKGRuRFGJBQANKAxJ0voJAC0gaqBQQ9HUGHAsmqhFGytN7kB7L5YqECb/dRgv6eeb8QKKdmQAew8eIQBojT4gp2rUCgscdpBV6b77MINAfi4RT2JO+8ANBnxqQOEDCKKPZ7gUEbcgKq+sCm68Qhin5gMZBTQ+tQAupAHn9oRQVCLQO2SYFJSOoDbcgAoo0FAbe4RRqtwFC+DIK7RhDxAcoQNcyIAwB0oDXP1kRdHhwGwoF8yCwhzADzAsiECyBCGjSlFMiLIEBAsIQLACQBA1IyQKLgICQIRoSBAQhAokFhCAgIFhFBkFgIRJEUQKIFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHgWPVtDbt1OkdUn/wCQjqaIFhmU8DkbRFlFniQGhZDOvBlEPVj/AOgCJsFQKLOsqLPq+doGMr0rx1xKsULJnII+9EeYFx9BAyrgh0/54jqJjjgMwdHYsjUbcVcQK6R0qve4Vkll9Q/0IFzGYL6j9NCvuZZRBmQWAABskiowrOJIR6Qh3A3zqUUGrD6RZ7v/AFIKMhgAESUl37Rnp1GMsk8cGDoc/DKcMdsEEKgRrlSDWC6l0kHKj5/iCoQWSUiCe77QNZEgAEYt7xD+siT/AExzx6yOAdLdxhdTHLEvq6R5OxGDTs5VZ5+fHInxlAsDd8fPihVx/qdQy5Hc67xiY16SejL6eOJBP7epWmfPy5RMTkhb+3zxJfExcQBeKBbLNAS0avqtgbdX8UzEXAg/1EKx7d/4goCxRJs0K+sC9Wk7BI++oTE2ie6a+eJFU9JxA6l6QLo1zKi45EADLB9jZkwBrqBB8u9QAPVj/cVaA/EJ4uWySUfeQU4vMEbtSSoXmSMsNC+xgAQQA0UBrcUUAG8hXk6gMSSEBR+kATZxxA6gPSjzH9RT00w+318SehZIyGxem1CNANk4kHQL35gKDI2Tt33/AGgBk13BkMMrHSEAK3E8RSdMHvvcgEUTRY78/wDYAfq0CSdkKEazI5Cy4NRER+iku6hVyLx6kvnmQMay6kyQvpFTrQ6uu7yPEiGJxZGWVfxAovEB9LOiIFHqR3jwoRGjlSWlzIHSSGSGuBuBSb2i9LiAFVZfjUgpYZ6ikbUIoXbH37wIWndjahAEP1J8QNCiOeK/eQPSMgwH7QNDhhKRE55lFI53JopJG6A3uEQZF7v3imKDT4HMgrICX+IQ2UXY7QKCi7Dr6yIo2KHmAXPhwKSaDf0TkQGSyLBA/wBwAO273ArO2vpAkC45FHcmItNEMGABrjUAAU7gUDwu9Qhzf45kRcT6nr9oDYu75kGvpAgvvCLsJHSW4AdQCVftIKNV+0CCxq9wL7yI0QzCAZ2q5gBYAuACfEgoZ+tQFkofQwiu5AuUUdipEIAF/SQU3XAhF7BQBH7QA7SIpNQKCxzIB1ACtQigX5gAQNwL24kRR3gPgkBeYFMIagWRCAhAQLzAvMBIEC+RIiwgIFgJEIFECyBCECwhILAQECwigyBAsiEIDcCwLAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBA8EQBj6ynT7zpHUmTCL9PS306glZHqyxJWyXz7SqtPLLLKk2D87SCHq5sZBEKpQy6UAqFBD58MCjEnIYNjRB4g3zWSFl15DQAFWDKbqUMurIEI2OAPn7wp0EkM9WSVb+kaaInJ5ZEjRHMiiyBxZN719/wB5RMRk8WaXc7+ER4KSxzVWXBggX6QzZyCo9/naXUZJY6Qi74Xv+0KjJPScwH3BuBknL+/qwPHH5lxWsjxkC8sh0jt5EI0yUQxa0F81uRcM+r1PIh0CNaMRCxn6vUQQQhrzH8G82naP3+kiRkpocvZVe8Ax0g9dAcHjxAvSCaBFaDK8/mBRj0kkGjxlRr8QmmBGQJbx8/j+KgqZA4gaxq0j/wB1JBpsLHJBaVG5BTkADj1lHJvkGExB1MaI4qx+IFPT0ZdIAH/1TEfUayWQAaf4kAHIlP0ls/8AYDqCxI2kgdqExcclmRjl2RXHwSFiEnrQyL8uBohHpB5pn8SCK1Z89u8o1kSdn28eZEMnie5NkA+bhC0hkAPFuBWScRQXxSGM4jIkZY44g9l88yjSAyRIHK8yJ1cd0xvi5Bcf1WMR2L3pXAHIH+oCGO8CdJNhdXeBpWUdHiREBWVXxX+JRQhiQT1ZEfeRFZomiC3ABE+oWQB5kRQhq12cAMicSOkLsophiVwVp/PpAvqsBB9+F/EIqIyGyD3kAMkvqZHpuCqRbRN65EgEsY5CzKigelC71qQWhiH6hwoA6YyKV3qEQcdTT5GpBaRyI6sVtQigZNgkvcgpLH6SRBxQhkA65gPO9BA6hEayORAY3AqGm+C9SAr5faBdIk+De4QxCIul2+d4FHgIviQUmiCeLcIMmg/rIIPqvEoFgLIf4gUlUd5LmRGrKN7W5AyG275gXWRGzUIpsNt8AyCMeFs1AUQC9QNJ8cQghZBX5hDE7o+0hVPF67QDa4qoAnFVYJhB/wD1R7mBrg0nqRAkGjXBkF52hzAPXeABumoQrqQYgaK0KkDwoDfmRF5pEwG+SfaEW67QF7aMC0/9SAIRR5IXtIDZ1qUFSdyC7MIXAoIVfeQL+0Io8iAqBWeZEwBqBRf1kQVwoPPMIvmAhFFipBeO8BIA4lRa3IA7wiuQXmAgLEIvtAQEgDcI1sSBCLuAgIQkFECyBCECyISiyBAogIRRILAkIsiDgWBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeCxWgSQwx2nRupQLpyGITxT7y6YFCyShSMKz0kA44nMvQPZf5l0bvAkHJC1fnQhOsZUN5AJbhVNmgPFe0KuP6T+mjx294qMZ0Rr1EbEqww5xOOqZH6pKNF2QMiRsL6wMZDL9GWtgkfLlVrLE2sV09sv8AGoSVnJ4ZI5ZJ8Uf8wvYFnIk4jLuLPzv9ZUU98cgOoM+zj+qmv6RRA2Ktx9AF4kZYmqsQRhBVrFgstgQqhdQPqAF0fnwwVAsMllkdtnX/ACXpf9aS9Y2eCfneRGukUBXKBS8SCDoHpBR5BFR6KMOk5Ug7DqLdGsn0AkHEIjciM9WLtYvfmBqzfP2rX+YQxQHUcq39YFKAQAJH41IM4dA/pgFB8n6/7lu0AugY5Y4pb5faEbGTBtoURtTJgcByD1PewT3cuppksTZ4558ST1QkdSAJPFaG/eEXAcWhb1FGhZGVAHRUiIOCSCB34gaAyy/U+xMIyjiPTlifpr4BKNZI0M+nL54mYGOQBoeN/Y+YoozyaYAAA185EJiBg7DSvwf3gb7dVcaUiISUOkm9MHUYunViCRTDjBRZJAAs6kRQM/S2SCNCAPSMif8A+os3CKNIOtAn8wDGOOOIDIKr6x0ATu1yOJCzVxyCrugG4TAjHgqyh2kFNk49VDzCA8jJe2oFtp8a8QK8gV1AvY7SeIAkB7AXG/8AEALFAscSACQa02/8wjQIxKAQ2oAI2qdvmAdEaeKHeEwoWtMSB0ooBE+fEujSWRG3aEiMldgVxswrZZP+ZEUGkzR7L6RUTImkTagMSQEaA0ZKNE9kx3O4Geel18qBshtnHf3hGSETshpOBq2x+eZEU2QiQT94D+1W7kFD0R7e0CaGkA15hAEE6HsPntAoWOSR+cwKvT1Dn7SIpAJAKe4BgFIgvcgIAklDzA0WnRriER3Y91AMKzCKCBZJkFfAkAEAI8ygyAjrsuYRWERIKq0PBEIaIXP5kB+pAXADsdQNDgkwiA6L8QNAcGQT2JgUo0WPaRAGBWXswgGD2ga95A4Gw4D7+8IbkFAoXAUzXjUC96UIeBxAPnmQXXiEUr8wFOBR8uRDmBedyAHAtrVwh7agV3qAEiD4PaBZA+0ItOEHCrIgICBQVCLAkCyBo6hGpEIF2ICAkQECyCwEIQLIiwEBAsBCKDIECwhIhAsCwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQED+fjIk6/Tw/edJjqmsxj6T0s6b4UakTJn9LujyIFGQQBXUe3B+fzGKAjqGWTx7F9+IE0TkKJ2HcBmcx5JxPPbmUgSmDkAdEnzEGQGHZOktfSF1ECenNpWWqlFOPofT6v7f9yaGIsDEAkmjf195SqiKNkWPvIaj6uoViRbW5VzE6SV62uAN9/aAIJyGWIAyvl3L+Cf0mcssifn/AG4tLBP+p1YE9WhyvilFJJxOKORGgaf7yfRMcSwcRieao/HLpQEZEZJHEAnI8j4RGAGKBeJVLzJRohkZYh5ggXZI3GonpOLslDYP48xxQD/yZ7C7CxR7ScFxJSD7HIajEqDJ5HFlrWhGAAP/AB+oDa9v8XA1XV0nHJ5Nvn/EJUByBFrwmfnnzA0AOoMskOy+F+GJET+pj1ZFkpMqJVVYnOmUXr+ZEaRGslhjt8wKFkfSQFojiOIhCzP9QAMBs81G+YLkOodQDdnv89pOBiQlZ7W5DEJ6cswQXwhL1GxkFe9gg3IIerH9KyQqrjopHWGMyK3BxcQEOfYf4kqIgSMRicbGxr5/iUaOTAJCK1zqTEgDQz2TtcwNWg8gRsMKQAfT+pEWVoQhl0n+mwCCuCuZBbCBLDWrgQdQs4rLt+0CI5AgZDuXAp/UfVeT52exEfEVDJjGyCjHDW8yRg0SdLzJiMs5AHIg89lArvLqxeQ8SASgqQGwB3hFIHUBkefpAJZFolUdwjQyAC7n7yYAJBIeXm3AtnEsDyPMgjGQC37mpeImJJy4Y8RVbySBAG/wpES8rHtXaODQPpAsvkBCKgDY6gxwtyCd7t2IGshkBXZOEHsM9qEhTFJ86s6iigWsgwB7win9HA7eJADKAocMagXWi/MAD1Ag64MJgAKLJPvIL+qwnYajiH9OiS96ihRLFE8wLaoezkFBY/UFu4QBPt024AWfSzJRqiKIBEIgIINHUALyZP11IKNeO8ADaX1lReEdyC6OoRA3s/eBoLj7iQMgDZunECurUCgDY0O0iKwTCGiTzApDGh5EgAoQFs8vzCK0EYC/7SZBUxdQASkReUQoBlP9oReHzAv1MgDXPvAEg46hF0U/pIF+HKC+n0gKY8yIvKEC8VuQLV+9wih3yYB8QLzIhowigyKaMC2oRNj94AG9wNGwJEXcBIKIRP3gX2gWRAQHMIvEKsIQEgCEa3IgIF3AQEiKIAXAsgQhzAsIQLIEBAsIsgvMBIhCAgWBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHggPV1dNjQB/E6R1BvGh/Pj/EiqSg8UHpitQIVQGkqJrUojII9tc+3zzAmPQMhkc7V/5lX0y6t9QvY2j8/aIgvVvh0dQvWc/S/SCjSuOrGsupA445dRI5/eEFiujMVkVEX+IC/6iBxIHBP8wKATkcRXghLzAwGEB71ZfLlVS+glAdnzAmB6RRxPq7xRMRshtlBa8SgcekI5XiOB4KcDYyyXSAC6RFb3+YTGR/TGWJGIK5uF1jrILOIZxHsZcVrDE4/pGWKBH5ktT+n9PHEenInIosCpaXVxxPShkCT2/mTReSOn72+PrIM+vIgen00vn1l8FxDxLAp6JqpKjQoM+rIMXokwJgQW8iVseXFAG/UMcQkb5HMIv9PIH+p045IDYUWFjWRGQPSUh7giZgBkf+QAHu+38S/iGIyGGSxIN1pfmQX+njoHgofTvFQxHUiW7v8A3FG8iOiyKHd+8ggARYJPA+n5gZxyxoMEC6FYxlK0aQyBJF91Ihj00cs1dAV85gXQHU1lsfPaBOk40T1ItH/EHWrOGwC7vTPeROLkUCghyEn9OYEJOQ9GRyZ3sRiKKSIv8yCjKgAKxs9jGJiZ4nTCx1cRdUEBZJPvtKPxFB6T1Guo8mTouIJKt2Rb4hAI58Y4i7GjA0DT3af+IRnHi176MKrdEpaciYr6vUDknwNxgMUcmCeVINHqW0RTUIYkpJjvAUGTscDnxCDfUF/33hVxeRAJKI4kSmPSCX0rbMhSm/SSNeIGh7L94RSTSJBOvtAhIYoX3EgO98ahFx6WCsjS94oEOwTYtCEX+4jdXIJmwCQiNilL0asgDEBvvqRFBAKI6nRkEB9TaHDFSjQvI8d+0gyOEarXeBpsG/oIQxKFHZ7SUBRPBL5ga6U0yqYhFBPde8iYLFcAcwMjI73W4GwN0gGNxQx6dfq8mEoB6d/U8SCg3S8QIiSL14gUIg6+0gooVuEMSPeKFv1e2oFxLyV1JUxTzsHiBdhtHlwgijqFXDs+a8SVAWEYRXS2uBIA/MCA8WuXBWr0A/Y8wgFyyYFSX5kESNbgWlv3qRFJ/EBvThAHsYFevEgEPnWoFBp/cQAq6uEUJ8QKN8gSC/5hEp3Ao5cgbtQiurECnW4AfiRD8mBQXUgC04FChDUCi6gP5kRXcBAD2hCpEUQKYDYkFFcQA3CKICAkDUIsiLAsBAQiiQBILAQhAsISCwECiEIFEgsBIhCAMCiBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeCI2CCGeBOkdQWxmCFaLhfxcenpxO1z2+XIVkFHEgHI6FSjK7ggk91CtXi1kU9cAmOiY3jrIEcBioFBAwrqJVnt5MqBIIDDx8wsShkTjp8bHz+IExNE5HEreQG4wTJ9WLXSKXeXVXHqJQG6063BUC6ukEIBohRRRj6vSBonQtfNCNECzw/TXBHjnxHFTP1WBiSqA3qWeCrPHAhZECvr3MdTzWcciS8+nVP2/3FisZAknEi01pntLKrRWKxCRuvv+0nRsY5A5HI5AE67d4TxnHpD9Kpr+IUxyxyz6eodJtEENcy1P1QRiTiQAGg6JMh+mORJ6VrkBH29v8QYmOLJZQ7ELUGtYUOogWBzciU/p4kAnEDIHQaXYxpVBHSRRL2/l8SJi4jIXQ/z3cKZepPKjdBoe8IInEvpxI3/H7QLyCcgQ9CxIigHGgAcgGgdwalDD0iy0uIGgOkAtWuoGRGcSRkcBiSBTfz4pStYdJAtn6o38cgAkZjov8Bf5hFByAOSyvl/O4gBknYOT51INDJi+r3SJjEZYZeJF7OlGKpIJOIyBf1hFeWOOJJRJ4tyIYDZxAGS9lFF2bDJ79hIALaA1tdqEDQQBeQN609wiYvILHnt2UCggIo1wOT9JA4HSeeeIGh1nIMge/JhEKs9LYDfEAixs8EDmBaqwkyPnvIL5aPPiEDsA+98+8gUQEUTpVAoYxCXeoRQhkStdh+IREANNdmjA0Cg2Pr+8ih1dgnvCKASssfPGpBcSsBVAfaEQEsIXAe4FmBqmSDs3ciINLIBiBWOlABjfcf7hF6l9O8iqUyQOdahDHIo2SB94sA1kC9ahFxZI7HV8QH93NDmQUXYPD3CKLxLH3kEJJ5+hlGkQFRVJyImJIsn8QCLS4/MA+2vhkGwLJOz2hB9x/h9oExyBytgHvGI0CWlXEgMmjrz3gxALO+ykGsfp7QhiKJBF0iJQB9KP7SC8p3IG+65hFGizrtAoIbZMIeARUgcdI2eIFCVWGqhEDapQNYo1/Egc1XvAAFaHn59YRQVz9YFD0QfvIINmvP0gXlAm9Qi6A95AFvvCLf8A2BQyHx3kChyYAX9bhB8n2gX8SAGxcCvtCCHioFfMgfDCL2gNwKGpEHcC12kDXiBYQ8wKChIFwiwEgCEV8SoCQWAEgcwKPeEXmAgJBZEWEAxAsBASIoMA5BYCEBAsiECwECwhAsgsBIhCA3AsCwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEDwZpCyFwK8To3UQwORKCI/wDkwVMv0dOJF1uFQt1obKgX0kNe7r6wBOK9WJ6e4HHeUZTyoZZBsndSqIAkok2XAq3lRB+pN/PzIIVRoVYGTX+ZRnFElP8AanCrvVkFFjXxwKMOkBE5HHXMJoD0gHIUQWS4Vj+m+gkEo4FBe8pVJF0SPfcixG/6OrIAsXL9F9XWQQz1WA6g5GSScdimePMorAxBxORKoGnAhOIxYxNhkaY+KBSCCjwNglwIPTlvI6Idwp01WIBTHUP4+g+0CjLWWNAnjioT8Ugo9RBVtr/kgYfrWu/H1X8xRCPX0gEZZWC91L8AZY4gMEBV+0nTGicSQOpMmijyIRcf1EIMc8/eRGTkQMsdWiSaMvVXEggugT37n/fzclRcsWViw7Rr9oGu+kd3qREyBBZrI+1fFBFBOGLACXFXH0wxZyJogaP7QiDIA5DEPIWx9x/MYNkjLEjR/iQQ5Kxl6idDn588sDYZaHCkG8fUCVldMU/MIUh6STQJBR4hGTkCRXVyCOO/8QuD6qD77dwjXqCP9vT3uQC0QSSg/ffEIuJKAeRApcSGGCyAtsXW+8tCjoersSpBoEZenIImy0hHEN4oBkAcSDWNEug+eJBSAM/dFwkZXqOk+RviUTFDkl3ZgV444W2d6kGj+pFAJM6NQhmgxikrMgv9wtVaK+0IjAFq/UCPaDFIIy7lioFxAy/UDyeXA1kwUAdOz/EiRA3ZG+RAZI49I0fEgE8v0jvA0DRKShFJIF4vEftIiBE+kAje5RaB1fFsyC69TrtIgOO6sDH9pRAQW/z7wKDwKRkGukYihrmGR9ABKSvUdUx0SyCRp95BSxx95Av/AMa1QqX6ih9S2XoyA2Nmr5gAQvSLXMIr9IyQ7yAkVRVQGKBofWEXjacCvR774kFNME/cQgN3IId9Nd3KDQDHEg0wwLBMIoOxwIEuxqBQW3Iimz2/MC7vjmRAjjmAZTgxQ2bqETq2BGDTYMghNcuBfP1gaDILHi5EONA+8CM9mDAu4AdwQQpEU69hCAqBcdcwHGrkFfBqEUaQkFFHe4A7hDncCBa1A06oSBo78Qinx2gGHcA6kRdGBR5+0gHfEIuvEAdcwECyIrpwH4gXwJEPMICBYCQXiEGoF/eAgOJBRuRCEUGBeICAkRYFkCAhCBYQkFgIFhCBoSBASIQgDAsCwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQPBsZZHL1NFs8To3UJ/UIVgkgywMSwtkUfHxGBAjs1y1qFMdkkkEccGBSTlifUFpXcGMoAPRFFcfaAxaLGkQVqFpnQBJJxyf+ZRX6suko3zIMm/UgRu9y78AnpQyspFDRNxitZB9ePVlrmEcyQXjliaCv/cqqCGsR1MixxAueRIsbr5+fMGM5NG/AVv6Qrf9wKLrdn5cIyQSUCESAgPeFZxBGJxAHqoH59pdGisSQR6dpleYgnpOZvpZRJ7/AOY/p8QpI+l7Q0IGd5jEEm9Eb9oUfpFDQ2PaBsh+osrn679oQyLyIC7WDcBjkDiSekMWZKYZBgMI6fgwKNDI0dcUfn7Qh/cBjifIX+YAI59RJIQ0V5+e8cgoJtYEsn1PUIXkgKpEcyCg2mVZA/le8Bj/AOyyABDff/ny4QYANEK/bxqTBsAlHqol9/LhEPSyOmxSgg8V0sAnlSYKcM+kchciDQMnpO2tr4LgrWXVljs2HrciJiBWPU2aUFaJOOOJs+CI6JgxZsHjtsxUXg4gjwQEPtJ+gT1EdRWBgxSCcQCTzfcSICyLR2fJga9PRWTLqE9RA+rqpUxCqxskNmtQh0lCumkF83ILgCSTZRd/eKKf0emvpYkQwRyGRRdEi+ZStDLFjQI4VyIhBOAyIQ+XAA4je9B7UghOJYKoJLQl9MVjQZ4akI3zYFwjCSZLFFn54jRrEg5NB2YDMlEJkPZ1Ii45BJ624sDEW0aR2TILjRsI8GEUDqxJvSFVAKtEnmAxYBF3rxIUPBFg7v5zCLRyIFHxIgOo691KDVC0EYGj0kkdx3kBkEg4pU4QBtD6uBSSme8ghob5qBsG6XmRBEohm4AMBcG/pCKaJofaAeLugakD39yoAfq5EAzXeEa4kQbyQe61cCgvF3rtIJkO/wBYGg+d6KgHYVfWjCFdTN+8C2HQVyAPVXYQho/kXAo00AoRXsK/5gAkCTUgpNkciEHQFrvALtl+ZBRdVApsBuEABQuzAcAjfvILiEWNmBdlMntIicvLUCqgDCKOIFpIOQAt2HAfkwiqrVyBiO3eBdivtAY+7hFd8uQOB+0ICuIFe4DwBAvMiIAlA0JAOoAQhrtA0K39IAfn3kRR94ASB5lReTIgIF/iBZBIFBhFgIFkCRAQi6MCwEBIhA1IEBCGoFkRYCAgWEIFEgsBIhCAMCiBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeDx6hRABV1ftOjdQKgC2Rrk+8aGOLK6dsa2PlS6VLZdjwb8QGRAIJIOIO+YWJhk/73j4MUXAl0aWifrBVC6Ffp2eRE6VjEIZNjwPeKq5lZn0aqhxBFxyDKADC7f75hGM8QOokdLNs7lahi8jgMcQ3qEOoaywrZZ/cwfxMgN8cnuPpCg6TiQWjq9y+gsccgMzyUDz4/eDp+gZdQB/9uPnMHTEZ9OIvpHziBlkizZp0QpVUk5ZNCuSaIgQ9JAeLOOx2PH8wLiRlibGJ37wcQEEmgXrvzrvGYMnOxl0hbr2v7yrjWb6S8gOSePPzzJBcDiADQyV9/lxUxMx6ekenv0niBrNE275+l/PMgjLAJ9YIa5+0ouJJ2AQB/aH/wAkSrjjTNEgvqr7yGqSGWWdF2u0AEAwK5PJ+OEMjhiASEBXqPb/AFHu+EGB/T/8fUACD5/MfqLiSDladvEN/jiQrOJ9ABAxGJZCbEfVrZDZeIyDZT51DJmxQND8GSC+gEgDpPPmo+AH0/hY48QL61x0u7VXJ4KjiMST7X9fvqEQgpgALtUC4npIb8EHXaCqHjmEgWyvlSJ1GWXjvjKUaxJJQ0qJuSoAEBlBc/5+8Cf0+o5Mt/x8ceFaCDom/tIKF0gtHx3MInqA9e+FzzUDeNGsiLBUiVGmQEGRR+VAM9TGKJNwqkP35LkTi5ldyueygZyy0BySgDxCNDEDR33/ADcmi5G62e3ECDq/Uk0lfwwi4oAAmiuIBnELLLi759+0Io0MdntwIooNgMbKvvIVAGeMvH4gayYtE4jgjUiJgm/Ue4ViKNYbqqA/mCriuk4qsdjmRKgFZcnaBqBcsizpajBRlaNEhahEyQZK+lwq4snEaPnUiKCQV0ivDhMMl9uIDFLVHUYKECCiexEgYlAq+/LgUCgWE9QgOzO9iBqyXrtUiICVpkb7QKPUC3IDIZ1GIPLa+igU/p2V4gXE1riQMkQAwfxAuXmRELoGyOZRoPRJP4kQSF1UChMr4IB14EgpKDX2hEYA6XSgaRttbhED547Qqsd9duZExTetQi82F2kDgN3w4AA9/p3gVJGECz7/AMyAPZiBXex3gLH1kRcdrQUGChDFu+YFC33gWl3kBIXcIo3ID5lC3ILuED+JAPtuBoAcahAwFpwKCFIhqBRILzCIO4gU+IDH2iookFB2O0AJBTCDhBqBRuBbkCEBAsB7QEgCEakQECiAgJEWBZAgIQFQLIiwEBAsIQLIEBIiwg+8CwLAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQPBVQIGV2X/M6N1Cg9IYIs3AmaOQFAsERFULEAAML687hEyyy/8AGT1BfeUQ5Ig4lE3fPvCxQCyiV3/b9oEB9RyYZDJdQGLfp3owJ/VKFgIGwn7RFVgWVRIZ+eZUZHqy6d4mt7uFWwMssrqrMBkV6gWBsIEwAxebyIKsr7OBD6RSJbRqFRgdINhUjSlGscOk11ewC7/iS06yMceon+xuvvKb4y1lliGYVsZgAn7DaMYl9Q6yQIyfAr7QrPjDLIo3v9pRT6s/UCgLpj/JiHGR1ZJZEEpjJ0PfiUTJgMZgjEcKFUBZMdWrum5BTis8SRiELuoRVk8iSCxon/OoNaLNEIjYfz4ZODIJ6gAzVu3ffmBoZY2ckiObpf8AY9TE6ssQli0Q0RBi5AE+rq6TaHtHEXElHEfq5x3Y8RgAD0nIj1bPbUgdWStIkkWft94Guk0dY77SJrJWOVgAIprUDZ9KV+HQDkMMvViGw/u/vKiAnr/SCgAATYgaulXfj7SCWcaIbsCQUkgiiWTopGEQZAkAOg/1b+KXBSMeo9JaC+8grRGRzHS7hF6TkiaOhdyCohAEDqvHmBQbeuy4kRgLqAsE/iVVaOIHJ5qEbFghFAL6yIWMuo5D2agHwKB2/wBvEgo6iKrsjAu9ex4EiIT6QT9RKGQyxBPUu3iBcOrHFA+4kqGJOS16j9D/AKgMjkcHx4MYNIUgiRYEgB0AGAeR8MIaq2TpbgUvIjZHBWpBrSA4GjxCMk+h9X4gUspAj8qBoBv/ANbkRNEk1TJgUNgaRUgZk8FrtERQUPZiowTG8grHzcCihkTtciEU6Yfs5BrFDKy1CBpqi3cgnYrqHtA0Aj5feBB0gnI62jB8OSAIRoZb7/tJgpLB78FyIgDvHE95Rd5a1IJiGuHvtKKUn1GvcSIqtrizApCLbW6kQA2QeIKuyimJBBRC4gaxO6+gEIeoBWfpAMGzf1gUc2iOYRcVV+8gX+e0Cp23zIhYI7KlKKe4TkBMa94Qxb4+0C+/G5A2FzzAFvQPeEHaWowWuorcgUFle9d4RUwGpBewZuBfP3hEG9e8C3VfiBQeKXAkDRbuEXnt3gEZBdmA4cIEbs/SBQPvIgHTgDpuBf3gUPipEIF3IHNQBIUIbgaHmRCBRIBgWEQb7SigqRFgUbkEhFBgWA8yBAoMiLuEBAsBAVIiiBZAgIQG4FkQgWAgWEBINQEBIyQAgWBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhHkH6fZGdF46hGDnidkJoyhllYGJL7CAzB62D01dxoznjjrI91/9Sw1Vl0sFMdyfeAfUEMr2hzCwy/9mC/s4FLBANAHewfL+8IyAOoBkj2hdQA9fLSAIFyqp6QdbuitcfO8In9QX1fcFmJViZP/AMZYYZR1XziBbJfUPs3UKhJZyojmEMbDx6sQ2ide4iqmLR6CNFF7+/kfiUXLLEjXUEmQFIGRsZAXR3VG5YMn05BoEcLx+YVMAMcAmSOQeTsX9Jan1rDqxAxNUrNb1F9VP/bLEl+NuBknHDIdLAusuJenWunAk45bJZepNDEdYABKG+/+4W3GcCQT1EEUGSR9T9oouTx6uk9OKVVXb94nqFgnFgkFHInh7lP1S+kEi2CPTfn35kgurxo8EW69/wB5EUEtnKhSxPwwJ0h/pGQO13kVaNNki2r/ANfOJeMiDYYxONgyCjIYkoMnvz53GHSxk8XjjfiBtJAZPslUiJ05USQQSbHvB+AyyGT6lyb3cFhh6cgDkXbioYGyPFt3JVXIjqK3o3ZhAGzn1I9/PtCYuRDJGLsaO7qQMwsmG/Hb3gVdQuwbFwGOJARa7C46ikpltC+w9pMDDqsI2zfz8RcStYfqbHqWjuCoyMWzffvIGONsjE+qqP4l0bOOIytX3G/pImpkdl/qq5BokgLLgJCoQIxJdDv3kExIBVEdx/MKo9J6dsQi5UTu6b1AyNWbAL5EC4j0Dqtl++oRcf00gMi+0iKOrQWR4H7QAPrAAvFcKECRkR0hl77/AJheBXWHkA3rvILkMeb/APWE9XpeOwyFQkF/UOX8EIMPqBvmBrL0lH9IX29oRKGQBB9jIqgZNhgpAuXUDewD3YkEyANhPwBAv9hsEbhGg6LPiQAyyC/pAAMtI79pEUCiAV2pKBep6H5gCTtCue0IMsWSU69oDEIID+IqKPSgSBW5BUwSBuQQkMHEd9XKNMA/uZEMVkA6A4cBiwfFBKAKRLqQNeloA9uIRq0L3q4D2+igUA7srhKRDmkYVR4B94QVtIrUgNFJHzCLs9XvA1R195ERJHq/zKHLkAJ6a2YQxP0UitEj8qEGN2/zAE+0IuW5A9/2gUBeXAe1/wAyIuL1ABMHbhB17wKKt8yDWjAhII3uEW9bgX3kEBvxAulCFXrzIKPrUIY0IF435gPYwLz7SIOwIFonvIHlQi8bgOIFH1hF57yBzqQFArhA37wGhCLIEC++4CEWAkCBR2kRdQgIFgICRFFQLIEBCAMCyIsBAQLCECyCwEjJAA94GoCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhBQ6gCSuJ0TqD01myyd/PaCIMfULSPAo/aUQeojpFqgwYFzBxx6U1rXiA6vSL0HGKmTGAGLJ7uBCg/wBIYVC5SKcnkabCRXziQTLI5EIjJGjKL1l9JCHH37RIMn1MHJPn6yqClSyPwQBBHpWNlEa+CIJkQCB1ZWK8GJ6KscWLBTenUUnplXVml6UjH4M5GgWf/Y81LihCBKXnt2kF11eo9JI0H/2UQH1DpQdMjj4oVMvQT/UJyPvUvfAA631eoga9t3CLkxiBicRg3+rW4WMPoxrEdXz59IVrI9P9Mgiiw+lOEQAkAABDVfvChYJyyIegnuBkYgZXrIlBJS6N4rJf1AsgL9+I9ifiF454D0hcnj5/Mk9FAxyw5FcGNsGvV1HHqy8/O0iMD+7EAatHjxCt3jl0gsH8fFIjRuyQCyfMIy/U88UaF7g/iM4A4jqOWyPpL0a6lheWJ5rXf/MiGN0T6jx+f8yVWkuSALDO4RcvQECif7kIRARkCGAm2N/aOC5oEAfqPkJ95BABl/aQfB+fDHBokFkYhG2Ow4kTEAGWZGRyQFAwoz1WRV+/IhF2RiMkB8+e0C4g45o9vT4MdT+NZDKiDZCofmQUikKOPi5EZHqGLQT4XzcopC6hx2MDRBLfJojmQT0DIBYgF19v8Qi4302v7WD88wKOo0SfrIJYH6l7iBcK9WVgWSePH7QlUJmgekkFjeoD9LH1+sgoyx7mh5uEwxABJy6Tx7wdUarfmuZABxIBAs35UIAA5Akko7cCAs7xxK7kCUbyJxAAIXFzKBNALX7woQTiMcRxfiRFJKRJRGkoReo2q43AgyOQ9JJDjBrqL8HtJiJWWywe0cAHQp94FNoDIG0WHCDAIAxNjvqBo9Nhfyf+wQOjlypENgIP+6BToml4kFWyjsUKgAS//XvIUPpHUAWfLlRcQTRbXOqkFNiihtKER5AIBwKSenkgtXIA4Z1rxAp5JvyoQA9TT6iYFxII6xwHHECwR25qQWiLHEgK/EAGWP43Av8Ad6TAp0j7yIMg37QJqgGe/eEa1i7P0gB2NGBaHK7Qik1Wu4MiAvbCcAS0t95AbogOBokmEQD1WDqABveowVMq5AFHhH8QNEaRkQYITgBYD4hAINH8wNLvYOpAdiDBNOEUfLgPvABBmQV/iENNSCsdtQhiU7gXiBRrUAE5EQbv9oGj8qQIFPaEC/MCu5EN6gWQJQHEIe0iK7gXxILx5gIQgWA5kCBRIimEBUCwEBIiiBRIEBCAqBYReZAgIFhASCwLASMkCgwAgWAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeFACAI9RAH1nROnAOnsknAmJG1xcKydM4grFH295RvIghlE6FakMcxd5MM88Sq0CztUiuYQZKDALfvAJX0+fr9IVn+mAOfoBsy2lGxoYloPX/IwT+m9IAKwO/tLQwxHQGD2BAahavTljiulZAXyvtBrOI9Ox1d3Q+OAyAbXSSkQdGNUx/Szl7eYGmsxYA1Q+KEZqwWxxofaOK1lk8QiQ9rmDGQG68o3AzmdWgO30litZEHpzxxJBr9X+4QYHpyBWh9vm49VCCMiDkNEoGU6yF1dIBIFUdHtuAyxID6SWFqoBEkDqy6cgAxjBq9XTgTiRiWAyCrjBnFDFYhAjWJ+uuefzLdFxPSd9QWyTIuNZlnpJTxNfT5cSM8XEjPGrGK+0nFoD6VjkGTxahFJALw3aKkEyJ6saOSHG1AuV55E5ax10wjOJCGSA6dEfO8KvV6SGEOx5hMUnqsDnnvzcgEjPGwG9tr/UqN16QE7WKoj+ZkT1ZYXkAAe/5cIPEZdRdLmgPb/MopGGINMmzlv+e8aer6n1DIOzpPzIByyIIAy6ieeC4TGSMkwUOfT+8aN4ViyiuWqkKYdSLHpA4Gu8VEzyV4oh6e4i43iACuk6ElRBlQPpD88uoTEQ6qpWlXyhGjeOS2SceCDX+pKhWIZZx9vzCp6umzkCd3cI1YoEeCBb9jIGOJAZadm37QilDJqyQDAzjk80vTu4VsAYg8MoB8wgwssm9LkSCkhViPpGIoQxAICNEyFHiBWVClCAJokQDKpFD8QNHIrknvIjGBp5aO1xLVbF5XseNyIroA5ctyJi67OBME9FrUCs6PeiP3UBg0yXV1zFQw/SOfYgKQVFdLBK4P8AmMRAAMf5UKpvYF9hqRFwDxBDP/qpRoF5E2e8iJ9L4MDRLxDcgg5sDmAN8EiBo2BkBj5EIPpoitCQUhHbo8QiMA6HT3MYKQQHICsG0R3gVlFMeQIQYoU+2oFxQLH3kFy2j2IhAELsluQAQcaJ3cDRPaiYRC2OQO8CnZJepAZAZ4gHUItnQUA2FUI07G3IJ/bZoQGiyLhGtBAe8geWQu8BaI77uAIrZrzAuNDgyIB2z+YAntA0O1SIA0GYBWzS5hFBvuDAuruQTi1KL7GRFAQvTgUm5BMSSfEUXv5hDVwK5EVqAp04CxuoF2K7SIoMgDvAe8C9twh4cC4mQLhFHvAcSC+HCA1AA8bhFEgsCQjQNQEBIB94FBkRYQf2gWAgOJEUGBZAgIRQYFkQgICBYQBkGoCEJEIFECwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEDwmwAUb3wdzonToSAX0cshd/ECn1b40qgQLEACq2dwqsoCnAl84FD9Q4lEyDG7A2Dx8/aIBJ9AABvSgWuskks8K4EI6QT6smaPPzzCgyxObfpXA+fBLwQjLH0gg1owGIY1SXpPz3g0xxOOT+ff7xq9Mgn1GsVT+dhAmOOXXieoM72l/iVNB1YoY4uz+mlHVNBAhlArmBknqXQAUKCMv9VWUhkCAPqZBMgD00TkpQHVjSy0wHAG8iCEux88xFTePV1M4lokwAys4gCtWbgTIDpRsEa/PvxLBU0Ookas3X8wJkGERk1Qeh8MTxVFAgdR4N/cQMgYkMomtBnen83AYMWUccf1Dp1/uWi/1MVYJpNyRIpAXUtC7JHP1gMPT9eFv6RRpk5AkEWgCNDuJEMchjl6wwWwNe8YXniHJpWjyKEGND1HKiT+kvS7yIoFY2CcRxbgNZAjrxrka8RRMegZkBkIkBX3joElsgatG32jwxciR1YnEnsCJE6Aq7CIDyHzvGJ1rLJAg5E8m0ZAAJB9Nezf8AmBQL8LZxIBcAsQPUyHuRGWekpDprV7lVoIlIkHd8yItg2nv3hFWJyZXY2qgWxijiA6/EgDIEEEt8OoxEGWIfqZ0RpRg0COjqs0kLk+iIEEEI99RoAZAbRHb35gay9WJ6RaJBBjiLkhiFfIH1+faQQHYfTj49/wDcC97tcHjvIIDpj0k+/EqNjFZEHGyW3zxIml6JSOyP8wJ1FjIANwYptnK1pnj5/EiYoIASQEVVsIMswhbZROO7+phEKOPgBvxCtdRPR0mRDEgk7PgGQKAQRZq4FBeTOJ7AKEEj6cvEDQR/UBdI1CAHT6nX4kFQvnVQIMR14+qyfEIttAg3zIKRoC4EZy1tUwIzEa8AkIakDtWhswGu2quBUXY9ioAAdNbBqoRQSSkL1UlDiuYDEDiu4hAh8AuQUIaAgUa5MIYkgNkrY7wGS443Ii0mhVa/iBRXdyCu3z2fEACcS994QZOnUGKDs0OH4gWqvWpEKbS73zADIDKqppwDfIP+YRSSCV+8gA9qsahA68QKD5HiQUd7/EC0BpiBLS+kCjehqRF535gGHf5hFtbEgA7gH2BcIoNauBeLkBfiANjiEU6kDftKH+JBWYRRR4kD71CDO4FgH9oF8SID3hF2JFORAo9oQ9oFBLciECiASuQXvCA4hFgJA3AsICBYCQOIFBPeRFhAQLAQEiAgakCAhFBgJEWAgIFhAGQWBYQkQgUGBRAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBA8Lkeo5MB9jzOidOdIA8UF7RoyQchRPahu4UILOLAL5+acIvUOqlkR5HbiVU//AB4klvFbbfxR6NJFdLxPcbqQczj0+prsflKa3RcSMX0i3YNSf0ABpgkaP13KBbOLR4q3CpRYxQHwQLlgOpHJryoNT+pkS8VzQ+fSIQ5OOJI7Hn6wqYXYTBr594oAZEjks7+0odXggizfj/kCMgjIBWn+P8QYMjpy6rdlb7wv4ZZL05EWOB4OoD0v1HFjEMcQByJ/qoDILuaMvwQY4j+mBiyeVlGgSKIeKsfbj8QYoGOIZBRP0XeKusknrOkTwNwrL6Mgv7bBP1mk71QXi9UASBIGWXpJZ6srAITjDiAYo4knDV8HsVKrIBBIGJY7i/aBo1l1BnDjXeEaZxIyyNBp69jIH93Tojnn/kgHIdReRAJdalGuvEf0ywASrAXMiZ6g6UgCq/UNn4/zBjWeh2Gm/wB/vIi4kgMhYg9q3/2BnpYZxFAhLtGijHHLFY5AUfHzmP6KHnj0gBkbpSJxQLoAEGjBWeovoAYtc1xAuWIsnIdQHA5hGsOkJZUSz95KKMVt9qBXzxFND0dTdkoB2/4j1Bk4vpvp2f29pBcTiD6qJAbKgTEZI9WKIAT4gaBx6loEuv8AUJYmRGRPUSurQcCkl1lw6qQUDIAB/p5IuRFerGnWoFOSIyJSCLuExCyWQ8ToQrRZVGh9DIiZAisSh1fmBrVigPHxwgAdknsTqAxB6bPO3IGRyZdFc2IB4okEcAh8CPUwI6u/ayoGiOGQDbHtuRAZI0F2YNwK8QzjiSFQsGEWwWF09qqoGSAB1cE8QNNNBHZdyAEul+xXn95CncM+/wDuVFfUVrtUg1ljiCjaq4GcsiSmGdQimyuH9nIq4MjkeF8+GKgOACG+8B1A0QO8JikmsvMgNdJZ94RXoMlj7wKMhtsoWpLBSzn+kDz3j4AGPSgAe8IMH33UDQ002fxJYI7bompAsEJ+JUVsWe0gE1oswARbFDkbhAPivrApYPVx76uRFsWyfyoFdrgQISOrlwNdXoRZkTEHgKBo6Y1IKGA+xgS15UIoWVX7doFshH79oQYdkDtAltDX7SC5LlmoRQQgbkooHufMCkh+dKEL6YAEdpAAIBJgV2zowhRPe5BTv/MABS4hFfftuBfPbtIHL/EC70pEDf3lDzILrcBxa3CDvf2kFY+sIcQKfOoB32gV3r6SIoN7gPpIDgAoRYF3uRCnUC7gJBRfvCIJRQZEWQIFhAH3gXmAGpAgaBkQhCBYCAkRYFkCAhAGEWQWAgIFhASDUBCJIiwKIFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4TI9JttUDOidOpxBFY49zScaJl6UAST57wRrIMLs/+QMlk2LDI5DhRn/yHRAW+ftL8EGIB6csrJREB1PAnEU6BgXLBZE9Rva4jTWAiaGrF7Yco1wHiCxoQM49RyDDq6cLVKGRfU6L7wMZEOsEQRYuUaBJxyyeLJ/SRzIq4gY312a3/AJhKzjjj1elMmix2l9XQgCiAid8r5+0DNtL2H3lFxOwgcRbbUguNkJIAdJVeYEAJw6cRijrvCmWWRHpPqdBXEGcT0/0lZ8hXUv0UfpJoP9J7j3hUIy/p1k6GxqOmqGTi8R0jfb6D7wIzTFcKr7SjOWOOOLyS4IERTHjbNWVX/JUEmsSnYPivjk1RUTliun+3uJRQScywbdEMSHgi8Uy9dPK8QmoMgdXyclz8EuDWIxyy6sgQ6av/AFIGRASYx4Hj581GDYyxZ9K+lzKM5EhAH3HH2lGsj1hYFtaCUiSYEgskgkYlD5rcBhYyNDJK6Ke4vgHqIWJIFsl3CLkOoVhkGbK18/iQaxQKBZdxiamQ9S8O4VoYnMlKtADj4ZGbcZyssZjHHHynzLFbVksDyBYkRnEbAyK4GXHldoDDQxt+8lF6jYyNaHnvBjRwROziOBxGprOIAw0d7EVWiDkywer7SJ8CfSEja7SYISP0sEjz2l/UaJPSclRDMgAnqoO0D3FwK70B7VBgF/4wMdkEg8lQi5HIUErNivaTDoCsRll6ieFuAN549KZqzZhFyBwR6eK7CBSWP1Cu8gGgAB3EI0UWARyff/Ugltlco+YBn/yG9adx8RQMBkATb7cQL1E4sUTqMGlizd88SIyN6A7VyoGuysqREw6qtj3hWqdY+QRzCITlYACBtQLiSQbPUfEiNADENEeUoECJQ5PmA7diX/qRANrkyjWLBK0OFqQXEk5cjSkqFpNA8GBDkx+pE6uMF/Tj077AwKD6bO9QBHSVtBuEUEsEqt+ZBb5v3hAhDk+w1AJbC7vtADdASGLYZyTGhCGJPV5PmBUGOfxIiMngoDmMGgGbDcgHuAV2lGhk5EQmxcCk9WjXLkQe7tRiqP0lnxCCeqECmxqubhFpqQSupCEaAZN/xIJkiWTrxKNV3KkECZ4PaEAK19YFH/JBSACTUANagPLkRWxW3cCfAZUatSBf5kFfeA4Wu0Ipb3/2AFAcmA2QBUgpfEIPzAvZSIrEB/MAP1QLQkQBJEDVdpBA4F+sICBW+0iFwKNQEgouEIAbhF5kFEBAPvCECiQNQKDIiwhAsBASIoMCyCQiwKIFkQgICBYRRILAQhIhAsCwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEDwxIOJBJPgToXTs9LZGI2CjyZReAMbTs/PMCA4AoG1AZZDqAKQ0eFzAoAOVXl4g3E9JItUR1I1EVcV14lAA8K4DHp6Tb7mU+skZBGiR8cAAUQQ8hVb7waqeJRC7KBn06x6h2rzKsTDI5YEdwWe0FACyAuoBbcACUssuqtnRuL4RDRfUQewH4hWihQTqn+0IyEwMierkg9pVCDaJ6qZ794EZH9X0kZUiGypfggeQBRYHJrcipngCOrIJUKo/43LouR9byD5BPHO5BcABkOs122W/8Sl/EQJGWRRPpZ+eYDAHPI0S0fyjBagWXUySVSOo4v8AEbyJBIHgssSis/8AkA/qEZDLn9x+I/h8UYkD9I7188SGsgPJdQ9Ksg95TiYp4ZYkJBEDh8OWinEHIp2tGx77gRDIgg5BjS4K+8ewbxyukH5Q+/zcyUwGSHVkgQj4KippZvAUWY/qlZEINcSCaJBHSMl1DplRo9DOQ0+3zxILmQlj/wC1lQi4lV0gY9wa45hBgAIMWPz+ZFwJWaKOOjWvaPiKB0/0utDdr5cH0HUyLZ3or6QL1cnEfW/n+ZExTrwKcDOYTyPp/wDpt/P5j8Gv6mRxxA9IAPxST1MQDLsfPz7wqgcZBgFfmEBWPViTfa4Fx0cSCfYjmKhgB6sgN/3VZ5i0UjqHTkKfB5k4GX66yyxR7QjWQyIF5ImQXIYp5MDLt+0IjGV3kvn+oOKSSwQGe37iBaYDAf3+akFGNk40SLO5NDQIRYN8cwgAciUhk2AncogNABAX9vn7QNAgf2kVyNyYidbzAbAsLYHMYY0EcgOV7SJR40SD0qCtYl5YkFdwJEqDLEYndd/2lFGOeuR3HEhqpAjfv94FTBLIepEQ9jiQ9XCmJJx6ctIvvCUAvIAihviBcdAMnyebihT5J4RkRo5BoHFnvzJggAoEPzKi0a5q+8gjWbxPz3lGgCg0DIhlYeW+8CsvTd95AxWJBPPbTgqhUTvXkQLiGTxzZ1CAR6qfnsZBNnX0FQKCsgywefMI0iBsd5BMUDsgBXAvY2NbqEVN1/qERAkMF/tINBn2JgAuch2MC26qQOXAWMkX5EIp2wDuoAl6kFD+nziEAaBH0gWwXa0YQH6GLkAc/kgwKyD5hF2CeBIIUASUvEDWZI5iIiLhVFeRIh+8C4/QxUBzIL76gDvkK9wi0f8AsClJ7faQN8fSAs1twisU9SCoezgHsVUAL5+0iH4lFfiRB2+IGuVAO/4gAWRciKChqAXmQXQUIURAfaBRq5EIFHiA+kgr4BMIftCL4gOZAgOIRRAvmAkFEAJEIRQYFgICRFECyBAQig94QkFgICBYRQZBYCEJEIFECwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQPDEWQzfc7nQumFkOpfqHY/HKM5XoCt/wAwqkZVXKeWoRkIA0uGTu4VckEaJoi4VnYa+gIW6lFxxAZBKb7+P4gCDkGMR4faODZGXWSMuOTu5Ec2SQy3wJWlyyWNAgAVzd/5iJiIjIDI9RX45gMgWOAWl5/7EXUdY+oDuhKGIebxsBPEd4KEAf1ASTieGEqgZGC9SZA5+eJdXW7IQ2F9DIIMeAeoiwRGmoQDiAAbysdx9JQOXqGVZI74g/E2ULBO6r3heM45AZdN1e7X0lwavoxQxIxux7SH1GmDR0NH5v8AaUS+rpYJNf6/EA3/AFMccSMQRbTv57y/AzRIysIcyRUJAA9Jr+07BUp1c7fUAQQckzfiIfgdBIuyNwH9QiryyBG+Pn+YhDEkI4sA7BGjC9CmMmdujZ8V7wiY5gZBNJgdveMLAgF9GIJ7ikI0UkZ5Czf/ALUTe44JoBA97FGBv1A5PeR7eBzIi/pPVz/a+PEifiY4h5ZPLp3R1AvWaukLCvu/nEYYuIeCBSr08HsI+i4kgAsHA7ciVB0vpHpQ+GL/AKqkjEIBMtH3r3hDENep+XY7wl8TE5DAkFg78+YGulla8G69uZOGqQM+q2BROzuAOXpPSCCQr/CjEA1fG8Vq+8gMvqID4s1Av9PEIrqxBO4tQJKYxoIe4+OMF6nih9B2kpBEAZIm73CKCEQfTrXH1gMQOof0wScXcfp81R+sF+9rzIH9PqAQZALNFmEq5BmwiLTkIqByDtA1ltQggyku6/mFU0CAcXwUq8Qhm8g9AIGtwIGAMhkABzuEUEAEEAAUl55kA5DggkosjmMF9W16vrIigY4tBeO8A2Gchj28eIFID6hkAP5kROoHIMs8vQlxWsiQNICvn3kQCBQL7yUXIEkfb2+ODRsYgkki6EIuP6mKI40IFKGTI3yC5EBiRYoqBb/TqQEAwC+bhBMCufvAO2C/MCizTTvxCICilQuBoNBFKQAftwvnmA5T52YFN5iyABcfEU2GkvrJgdSAS9nUYKd2taXMiHZG9wLl4FeYAGwRXiEUnFDRuhCJibYHEiqeePf9oQ/URX8wFjQSga073IivkHcCUGTracgoJrnxAqY/HaEMSkXXI5kKrDvtAFhABe0IoAoQiWBsuBoCQKZ/aAJYNLvCH1uBR3/YSAOnsB7QDJv7QiupBeHXeEOrYP4gUJgcOAG/3kAdu3Bgqndpwi0+0gftApI771CB1Z1ACBWtyIMLmBTqBdQh7mQWu8CcyClwhTrUC8wLtcyIDfmBeZAgWEPaBRcISCwINwiwECyBzArciD+8IsCwEBIigwLIEIQKICEWQICBYRRILAQhIiQNCBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeGAIKrfNAzoXTGQB//AK67xqs4nqeGRO2DKCRQISS/1An9S+pkHXUQZYKMQMcRl0tNmvaTRSW7A43AmS6yUa7+0EZGPqAyBI3aHvKutDp6kA1aBjBkDFPLHdEHd1ApDxNtj8qBkhYljpJ77lVo+rJ4nLv2kRkHYB9aHlSqZHZBCaJMYaoDwPBIVa+0AcihWWR1oiMGT1dTJBoa4vUqrmQA2PdcSQTYx9Ru5Q9NaDB8gQJkS1Ysa2uIipj+rzvL/X3lAEgcX+58yKgBWWOI8Bn7KX+i+rqSxWzTcIzYyyBeQIBJPAty/FaBBC6sRp27qREH9O8SQMj4FCNXVyPViDliQBZJohXKMgI9l7l/63CrgHj6xZO3UVEIKZA3ZSRUCHHEpLTAPeoUwzy6zjhigEvaM+lXIE5gZM7Jr53iCgAdA/SK55uOs/61gCciOC6EmlZYyPqxVAn7pfO0Yqf0QTmGSBYRDlqVvENsEgVrY+ftMi4gggh5Hg/X/UqUJGWSGR/+g5AGRJQGN/8AYwRZdIaLEeDTOQJGV1zuTEayJOXp4FLehCJkf09LYIZ394hij04rqJfCgMViXfjq3+ZKKV6hkQHytyCE4rLLIepvspUxrEXRI9+f9yB0gppglgcRoJigifAgFjrqK7nvCJ6jmT0bKgaOBJ9ON73uQ41l0oFdPtIiB9SaJW9wCaKPUtp3AqGWYdL7k/BHEU9SLGNDcgYn1IZiz7uMK0ga2BoSDIonH+p+nbJlRpeph9pBMg3vIBNjfz+ZUaxGIxxBLpshyASxdChqBcv1EnGRExHSWRQ7l/tA0CDmUAx3EJUDAZxG7B+0L1oI41bCkBHoSrlXCKhkWk+XIICUcQ2RsVB1SWDkyL7fmEULpPUQyNwBypAfcjUYgrovv95BcslVv8xgBdINrk8QKxRPI2BIiZENEhUd8Rg0KysEEWXzCGgL3Wu8ALYCAkF9XULgBRIVeYFCq/FCEaxxscnl8SIEleoa42YEG/yFAuIoNF8yBxZfeEWvanAY9Ryr3ECkF21zcgq1VaQHvCGKex95ABdlalDAHqZYfaErWJ3/AJ4kBLXvfEIMHJfeQASVdGAGhfuYF2NwLs12kQ2kNHgwihBbJMAEHSkF7gwBKBYuEAiar6wLR3feQXdHfvAIGkV+YQ9TfeQVPSEIp1qAFld4D95BRZD1AtjmRAJ8yi1IIPS3qEXmA9oFBQQ0uJEW/MAe8AKuoRXfaQAVAo1IHHeEXzqBPEDXEiKNQDgJBTCHDhFBkCA1CEKouEXmAkBwKJEWEAYFEBASIogWQIQgUGEIFkCAgWEUGQWAhCRCBYFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhssTiT0AV4+dp0O/66bdREZAAk1RcC5AZgDIsEM/iXcIWAbRkVA/7T+nYMC4gE7B4QLqU1FkQcQA325g8QnLotvWowTFnZIDRZhQllpeXYlDLaAZ5BMEMRrH5qNKnqGZGBQaV3/EotAB0u1SDIDOJxZCQJMqr/AO3pY7fsIGAycUiDwQ+P2ga6R0h4Bl8/jzAyukl5UWGfrzLqtEUcmOr/ANjr589yIGMTgwiKD+eYUrPE4tIVpxwZzGNnp6hofPm5VV5ZF1k5EXF+kZAFlshfSBMhkM+gYgeavjvKoiOkCyAgZBWMlkT5NfPeODmB044kkJaD2JasaXTYJGVbO/tCMoEsZuqBIP3+fWXVRDDuTkUC9COjeGJBGX6hzWoKylkSclidlahU6j6gQdP7upRQMgAcbGgA/wCZE2NHILoyWYaergz6gOR6SARiV3UCYY45YsAdRont/iKNYYjE4/0jdVW+ZO+p+mOXUMbJOgP2hcQIjYxJYs/7ijfSsRkyQkX2kT8QjHqYDQsi5fUMRjiABsfj4ZL6qhELvsdpL4J/TONDQG/bmVKoPV6hkAePv9oRQCUMcij25/mQv+tPHpJxYQoqRGT+l2ktblVo4myGDdLXiRJUyJyyILJMC4vHELHF7IHEiNCkueFtwL/TNPLZ18+8FDklm0Pa4/ET/wAnpAF+3EmKuJQOPSPPtCVTiBkRfZ8GRFwQFaVH59ZaANnIjG68yCbBxxoJIcGBWTZKDJ3uEXLE5EjDLxxIAxZAxDBG4Ko6SMRk8gQyIQIABZvvIoEdFEfYwjWItr8IRUBbxGYBPnZgQsYAZe2/nmMDEOzwUh7SCsm6XPiBrIF0AD7QkTFMD5qAXVmSKvgSI2wgTcgygwUBsXuUaBPVlpvRkRMWSESO4/mBoBYgEB2dRQQDTOLR57wir0Ehgd1ICQvkQKwXiaK1JwD3AF6+fSEA6L+4gaxKIBy557wlCzl0gggdoBaA4Ccgr7ti77wIAgOStKBpdgAfFwiBfqDDHmShQFL1G/aBrGiwb0XIgrdrmADsLzAoDDxLhGmQEiRq5ESyQfvCmKOPHY1FRQsUOO5hEBBXJ8yKoRH+BKjVAA9pAomlQgAQBXG5BeEQfMiGJSehKG9sE6hFWha8wKwcSh9pETjnwIGl95BLejcCsqiIRRwoFx17yA9JnxAMkagASOZEWn/MIo14MCgn/SkEIJdeIAeTAptowijxQIgBx7QLQCkQ+CBR8cgVpqENBVAo/mAcCmRAGQXZ+sC/mEFABswAtSI14JgIF4kQgOURAsISCjcBzuEWAgP3kFkDcIQjQgICAkRRAsgcQEIoMISCwEBAsIoMgQLCEiECiBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhwsWmOWBOhdKgJrHEkm0vxCoChlnSFAkVAueOSD3y+Y2EK9KXVxalVDkTkB6vYntBiZh5AhAckb13gOnqIZ3oN/9gQFBhk72rhVIQAJXVZ/zAZZP0hny+fpKC6UP1I/WAGJ6gtEuQrOJQBoo6H7TQtG/UnsgSCMdRIAPMLEGXpGSDe3vmXBSfUCSS7SXz/cgjA6lfPv9B2lDreH6qd/8jBDkA7J4XbVSqEo9bByRGn/mPxFKAOT6iLFyKg7LlFnVSqAYkgoZIWfm4QAOIeIBdkijCpkaOQayGoBLNlEbL5uvpLpiIHLqxZISD+d44KCGA0R5oFBfvGCdTwyGIB6dfaMPqZDEoj/0Kr57RKplWOwcmON0ZSIwMccTiUcWSDb5lGm8gsvYePb7feTBnEdA9JQGwI3VR5MAf1OoOreoFsIknqNbEBifSw7OgH7xRoM2cPR2IG+8iIOnHEFDxr4YFwIQAyr+6luKBxB/WUCdOEaxQzPpCG6sbP23IlQBorGqIR+HmBOpADrtWW3e/EpjQybBsOmL/wC/5kEGORDBeTBBOgI8GhkQB1ZA3vuBJUPSEkD1E8qD1rDpeyV5LHeRKuS6hi35A+4gTE5FmwMTQagD02GKYS4+KAx6higL1886kqLlygvJgAenA54gA2nSgxb6gQKG2YFBxP8ATPUnTL1IiJYADa9JcujWWxgz7SIZE1+oeSZBbIGLLN73An9zGjwQuYGmmFv2hERrEc0Hw4FxfTlmH4p/j5uRKuWJWNsjavUaRWChz3I1IWIT6g8QCH9FKGR6ssS67d2PvA1jiMsgWye0iIGAFi8uGXIVpBAWWL5hAlhD9Omf9wKl6cbR1CADzogqz4kUxJCt5Awigg+z72YAZglhJSYAJOIP11cDVdQKvlmERgErfn8wKMu5LJ+vz/EYimgwD7SASdglpfNQi0icRfFSKCqoXcIuJf0FuEWxiEaTuQRghjnco0P1UdcbkETtXScDQIa5/wCRiJ1FFFdowVgo3pSCn9I3wjCI9BA1+YGuWHIGl44gRWET9oRaTb8uKKH5ZkFBL6ifo4RGAN+0goIrdd4FCPn2hFGVksIRgB0WX7QiNID8e8DQPv4kABgorzAChtiBd0Ad9pEUL6eYRTR0V3kEFs14gVjzAB6hFPPEAz0nguQOQaECgg49+8gaHyoRT+PxCB+IwL2EgttgGAfiEPwIFGiRs+YBCgDqBX/2RC3/AIgDsGBQj9pEBVUDAvaBb+kiHtAo3IAgAX2hFtwAeoF5kQcCwGuJEIF9oFEiAgXiA8wijcBACQWEJBYQBgWAgOZEUagWQIQgUGEJBYCAgWEUSCwEISIagUQLAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEDw9pZDpPf9p0DpVOJZAIKHVBrOOniStBfPilVSAB1AoQMn28uVdAQWdA99hwADyHVh0ga7QGJCCpijqAAIIdkavcCE4hBmmyPEYNclgH/AOVAgBRpE8/z+YVmsXY6jpDfv9ZRen1AI7YJ+XBrIAwyNa0SZegQkAMWBrzApZHVQIB5r6cQIRyn5e5FZyoknFpl6f8AqUinEEAkookGmfaIfTMnpJOYT4EpEz0SK1R3JFxAc+vQDJ3v7faXBukUWe8hGR1UccXidOUMRlkBiS143BxlHH+mCANaT+bl7Vb6V/UGRWL817fO8ib4wTlkPSTWhlupVVEEn+H9agQIjXDSv9u8KlDMniyB1WT/ANlRciCUMiUASAK7SE8Z1/UZQGJBvzzL8UJ6TyR2XmFCQdFkEbHeMRBkSCSgQGWPt89pbFT+3LAYnp7a/wBxf9HQrqvIDIB+m/rIiAjqvEgCz1CoA4FWEAVeNvxBrWWIJAOOVlhFSJqIjNB4gnY8Qqf1Ma9OCxO1aH0iJGuoA4glV6TIYtFEYMhogn3lRDjl1LKkL57uDVBWSGie9zIYZdRAAY4ruf8AUo2Aek+pV3vciXrNJ5MYjbF/P8QNZZZZk4mhvcJmJjYBDCKRY3xA1j2YJB5NYyUGBsHqfpJ7d/8AUHpYLpPuZEXIM5HEVve/eAySYAoX793AmOIxeNC9dREWo3SRyYRCVm5OiFhN+QR8UC42RujZ6QtwlMBkTgBl1cg/z87wWricqDWXiQLXTkvceYFOKJANEEhjZhNMR1B4vt8/MnBogHHqsHSAgZNHpNDcCgq8vSDx/iRGgzk8hiUyFCJhk6Wx9fAiwqgJCieDAEhCiQOe8YNPpyJd+ZE+KAV0lSDORGIIs6RNKVGlYCQb+fmBAsWkuOZFVooZBgQikV1E+pb7yIGg6XmFCTZCIDIMI0R6VkxRPMIZUGcsm/b/ALAZNcjVDUhiAk5fq5gb0ORwHIieo3QHY8QLgHTKEFPUMQjelCNIdQJI9xIIiRo4ntAoHOJJfa4QBq2OQID+5p7QUC7LAyrk95E4aLOq4cA0acAwaG6UYLiSi3QkCywBXYwjdHl+dSIgJGVhfVuBVXjUC5C7ALkRDtnXNwpn9JYiu1v9xIK+AAe1Qh0l7fkSC86o+IDEklKBpBWfpIiasg+0BZN9nCKPIRcChcEC5ABXHMAlfHtApsuhVQgcvP8AuQB0hh477QKCNB0NQhr+ZBoM90PMIgGkUPMC+CZBfG4Cn76hFAY/zILsPZgTkSivvsyIDe3AAnmQa1UIMoVXECu4DxIgdahFH4cimoDxCL4gPaBe6MiLAGQDADe5UWRFHfXeACkBVAvmAFwiwEgvMBuRCEVwLACAuRFBgWQIQgUQhILAQECwigyCwEISICBRAsBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBA8MCB+rgXc6B0qkvoJNA37wHUB6fTifBgB1MDEaJJtkyqzeWQJ/UPnz2gMmT1EekFfBKp0oDFs8nxGiMkMY9J2wVAZEg62EPDgEUMcdcQqbTOJqyObgUZAs3XPz6xgf1AAEfqTYMsAPqXAPwwKACiwCDIMDEAjrR5Y4G5Qxyf9REJhJuU+H9ME5XliQCi9QVKGPNlFaAXEKX0jLqORyr3+KDEIOWTyYrXn/MEU7x3l3DhUxAGQGIDIo8fLlFLOKGWWRIBvgwGdkgk3et/WIRgdTyOOW+Om/8AMvitZUH1bfEkQeLOK7DsYPR5I49QHdt+ZVQHLANALS4HaQTMIjHpZIpFyxdCelnENg2D5g6dY0v1F7NV+0Yhl0l5DEoWAwiiKoykrGZDAxYDp0vrzKvxccRQ5xPS+f8AUlFFYpFHh17QB/UNAEgPHkuMN8U9IHSUADtq9j54gY7M5HJ1r8D/AFKrTyARZCtLciNHqJB/tdkjzIn4hyQyrRZGQC+sQQMcDJV1Jn5f5+kqqCBlmTVEVv5/mRE/uBJXh863wIGwek5H1BUrkTqogPIoFoN/mBOoHJM45HR7/wCowaHUTih283IIeosDLRQ7mEXPq2ia2DofHEPAvIhWAyddoReASA/b6OQKDwsNFr+T8uBQciicQgGAf2gpj+rEIlckyImQ6UegMc9qg610gHQLu8fvGiGiQGCacHW8Q3yOR3kSgYG/SbfVv7wJleIA6Uu38QilZI5DsbOrk4APSRiRYFJsylU6xN+k3XvciKciHjlrv0xgCyBicQMbAHMgCyGR1Y8+8CoknMaB+sH4IYgYtAWzuECTljfStvy4DIkI8ZUXw4RrgKsfdTIAGgWUOyiigkWcSF8/iMRcvShxwRyYEH6loOh38wNBFEkgjmRAII/qGz+8BichnYA4KFCCr/TCyGTO+0alT+1kbNnuJFUADHEh9mYQR6vVtKKLohJjbkRRRCCC3BUCIWJ4v3+CBrLfN3upEREu8h3EopIA2Q3TkGuq0RWkYTC1ZQ5QgGtkE7kAgsAX+IFJOxyNmEUZcodzWoAkEumdeZMRMiCQgrhWsUkdAqSoAgpLvUC3TsP4YRWEtgFagT8nu4F9XuvMiKGUXUAyHwQe8ACqBpwKDZ5rQkQX1+le8Cqyem/Egorz4EIhN9J5gaHFyARR2uJUDfYyAXR4hF7d5BWBXEACWGfaCqBYCgCxYUIrVv8AMghHCK1A0PgkRKHaBTaRhD394FsVAdj2kFJVFqEKe9aqBR8MAufOpBaXiELVmA9udwKdM6kQH7dzAofMCmRDlnUCggyBqA0bMIoQuA0IFpBSIaKO4FkCEN1qBYDcIv0kFdwhAsByoCQVmAcjITA0DAQECyIQLIEIQKIQkFgICBYRQZBYCEJENQLAsBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEDw+byLBSG+06B0qEhG8ie2rgD6mz9BpqUaIDYGz9pF1nCwGFplSihj0teFIIdAEDy9ymoxXpXYDj/coIEgEDF6BtQobx6SG6CgO/Uxyb94Fstlhg70IGQrJOiQv5jiocgySgANf4P0lFGIW9diTIIfIPT9l8EoPE52SXa4gK6bOW/qFxKGQZONlB+8gyWdPp6epH8SqhyYx/qEEE9zH4RcD1UTiTyHuOA3j+okND6Qqf06JxOOPV3A3LQxtg9S/PtAt1mOhHjvAyQbxyGPXwTCmToFMvIOEMPVj0PJHv4lqs5lvrCrSRHz+YI2Cep8EAMfFIJ0PEA/1KPj8SmoKxydMX5/EKhx9diwKIH7R8AYY9IBpHzuXRnLE9JKN8JCAwYeWOHpxaIF+0pVHXiMMTbPz55kDWZRDbGJ79pT4BZMCgDTV6kqtCs8ciMgHePU4S8CMQKvDQLQ+8DIoA5Ytl82Yo0egDLMG2wOT8uQQP1XwGgj+PrGli9ZAJIIBNDwOyjEaZxyNu22pEOoY2MgST1a/eDEIeQRBV9TgUnpxAyCIsviBcmFZKHqD3/mRIgBJB/pEFb89o50oWukl36VUDo2dj6fvIjFAYnIosMJu+JRpMvrrbkExyZF6CowWNAk4JrY1w5MRBiSQym6VfmBTlkUQEW48MbJ0SA9/zCM4kAM8HchVHoGinvtHQL6mGSO3MgZPJmwEnAuRA9JxPUTQyOzLiC6siMmT/PtA0CCUE3f/ACREwJ6QDQG4o1oIkjz/ALkFDCx7bEiHUSicR2K48S4A/VZT2hqQCxiRkiD3pfP8wihFsA8n8wLokkgWDIiAgMlu/tCr1Xk78DmExQMelrXhR6gX1Mj6NwKCDn+kk/tIA6UR0vuHBV3kVaD3IJbYr06hAlDHLIYjI3/iX8GsGgC/DFSUowne0JAwyLOLa0YqLiNsVtQKGup37SIWHi/r4gC2MWyQ4FxHBBDioEnllhqBobfC/Egix08j4gUfpNuvvCGztg0DAoAAsc9pEQ6f8uFXE5F5DQ1CVRSDfPz8SC/3djx7wi73XaAxRyGSxJHaRFpPjzcCChoH6QKwiQ2dSBdtnwYFeQDI2YQCdF8xRWtN/tIggxdeYAlD2swNbSsgfeEQepHEpRxQ9t+/EiNMd5EQILbH5lGq2ypBAbuBRY5gANFn7wis1qQX94QBQfaQpoapwL5/JhA+YFNUhAKz+8Cu1q5EA17QLSkFgL53zCHv9YD6uQaEICA+kBY3viRGuIQEig3qBQfEIcwHmBbQkQD8wLxAA2oFH0kQH5hFrTgJBR5gSEagICQWEWREgaGoCAgPeRFBcgsBCECiEIFkCAgWEUSBAQiyIAqBYFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4kkEcjuO06B0qZ2X09SO3qCAuwV3J3xAziGz0rLuDA1kB08ircEZFYgEHO2blUxZyb4Jr8fzBQkHEkZAsP5+YIjeL6hZ4G5VEbBZHDLcBiSQxiOLECG9kPgKqgB1IEgfuIUIZBJHmlqEC+g+k2b8fTmVQZLHIjEk8UT4iFLZKTPfcCY4pnE4778f5gMC8WUGtC4Kzjl14g14HLlzPF4HkZYs/2gjjUaYpOeIxJ7adSHWDvpwWmia+kv9Dpf9QpDunx3l3xVAJeTYHpGMC/0zl0k5IcFn7yVKyMTlkMurpa2ZfxdUkBkH1igzagDkT6smtb18UCHG1j1dIqzcLEybXWbo+nxKKQTkSAATrsbUhpgQM/Vih245lKADE9HSScQwdXqXROoDqaKDPcfSTFZP6sh06Pbnfz3lNazB6OkgB/+oUaRAMS+hWEWfb/AFHohAOJJbP6TzfMQXLL1Y5ZV6ePMCYgYAh9IReQG9/vFugD6Bi943FVr+mPUSWlYIR7j3uGamOSyGIRA/uUlitA5ZLpx8NuAAJweGTWVu3H9RkEYZHprmhqOq11YkMHZJJ57SepimurDdV841CJl6sciB6TR8mFUdQLGQR0QEvLhloYY4ngDgGpDWcckQSMSKZ5hQHpyAyxs0QBW/8AcVFRDNHv1EjmBOo4A9WJ7DXH7R1MbxX9Q+kBbMnDgUsrSDQ/EgqyxxVG/STpQiAYk9JJZF938EprR/W+qt0ZAROI6XZ1jAoPTzu03x5hDMgAFg271IKSx6sffs44hkTetu+/xyC4ohErwPpAYgkLIYk7YEIuRHSAao0DIA9IxQBsG5QxRP0J7XIVWMgSDkSQ7ZPmEUF4hnNk+zkMBiiQtWv8ymmORLZAXs5MFHYkvg9oQByFkh/aQVteold79tQg/SSx5v8AaBeo445IX9BGIO2xZhWsRTxKZqvxIiYk9HrJLVVUUB1HEdQL7EagUEgEC2X3HaRMX1BFglbgRMrELnVQL0vMntulCGKLLZ0B4ko1gCA8j+PuoqMjEEgko81CtHLFEAhwgyGSBfHiQa6WaxrSkRCjzkub3KNbJL3zIAJGTyArfiBQUemtIEmEw6k/aAd5dh5kFz/SiXCAOOX6UPpuShSIOz+IFdg5B1/2EwoUeIFGgL1IGJALJ/MJQG0GoFDPaQUAKir+8CEo07gXqHSCkIxF0TiJAbEC3tlGEaoG5ERkEP8AaULBDs8yABtL94QBIfJ1uBQRkdr3kFJFg74gEhvmjCAWj2gVMvYkAj7/AGgUVrntCKe4kB1ahAndqBQud9oFDSbkDYSZ8QgCgEVAo3/mQBrScCjWoRVcgAnkwEIo94CnAvEiDK3AokF4gQFbhFvncAHAq7SItkwHNwA/MgooQyDcCuA1ILvtAn0hGtwGjAeJBdQHeRlTAoLgICRCBRILAQhAouRCUUSBAQLCKDILAQhIgIFgWAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeINgsDTIc6B0qCwXz3NQcQI5sdJ+so0AQdsAh95BGiCACOCRuUZyBJALrfj5/MRV+xJ9oIr9IGPS0rq4GcjkKTHsalBgkgMHkk/iFweK6iCX4T8whiQ1kfrCs8gj1cXzCmAALtj7GPUq9IOJRABdfSNUyAH/3y+8CUBiQOK1KDJeJYQHSNL8QM4kdQGQdbP8AiX9Vo5E5E0e3mTEZw0zqnXnmWqYkoEbSRFbgUk4nn7b/ABGAyGEcicWaQ88QiID0gDqBquIa1cjkcSAPbxCJjj6i8mDZII3KrOWAOLJGPVwde7iGhfUMckSk+6/iUXHIDJYjIdmTv44wRAYkdJNI1r6SKo9OJboMq/4gZys5HqYJ6T85lIZjE5E66SwQfrEIEEghEEukj+faFXp6gVtogFe8RGcic94IA2pV4wEh0oYjVH63LVaAPVfqQZOnfeRDIPGj0gC3+8Kz0lknIs1rVS6N9WOI2TmwLH+PlyIhRxIGFg/SAwAOdsA5AeV/P+oWqHsA4jG6vnXeEoX/AE8mSSnvxJ0XO8xi0Wz4+KER4odReI2O17/eJpVxyeSOAFch/mKYuCOAK+37X8qSo1iQyP7Qz7wVCciRtEAEnj3/ADB5F3bOQfPPmQMshRKb0idwki4EY5ekotgd/tBQhDpBDsnJqoQI9VgA5WcV2gUDqIyIxB/YSbgCwjl1BjnWu8DQGzQPOPH/AGRD1Mi8dcwKGSSSjontXmEMWMR0EeL3Co/UUUBscCRFZAJyWmlXyoACj1AB8mQBeXVrm8fz+JUaA6TR0RXeREBOJBxoD8SgicuUNkfPEgroI75LgaGXViMRkjpp3JiITkgkcST2+eIFYJISR2IMDl04s4m9An6P53jEXDIAogkeJLFwSvEJd/5hFwFvpsaMhVIHSeokOyOIRaC6LdiAJ/SAgVQdwAGRJBB1XxwiYlZBjYb5kVo5Fkv2hEwsDZ8D3ijQdFkHQPe5EW/7WRAMg9IZYsk7hFJYI874kwU9RxIfvADEA9x5qEQ9KDPqPaBUWAbC2vzIAPqQwA/gy1FFDjsbmRf0g01cdCiyGmveAyRJPbUC7CNEvmoRQiLIb+8gEk3koRN+B2UK0Bfdd+TIgQF2riBMQ2AT2NwNukAf3hAsg1o7kQG7GzCj9vCPMILpLx/7A0byRfmQQd0a3UIuJydivEUxcdavkSIAh+OIDZHbUCgioFL7EkeJEBR0jxAFJOhuEX+6zfMCiwyb5kAIc/eBQPvCJTRX0gaHcnw5AFgI+0BsuRBkbMCgfBCA3yIFp/aAvY+0Ar9pEXtxArpWIAviBWyjIg6oQAK9pBYRRv8AaBfcQD7SIdgNwKN7EgCvtAsIg9oFGoF9pENQLILuEKhBj3MC/tIDMCwhqBdwEBIKJEPrAQjQgICRD2gakCAhDWoFhCQWAgUQEIoMgsBIhCECiBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHiMg8BQv31OgjpVJCJ6iUdKAKCCvzqBhOzt9+3/IVoHHqIIXVoQjJPIyPTzUKdJBVlRpqHEuvuOJdFFbxWI8agTL0knv+XLAR1VbdrUKekfqI8KBLZAvbfIgUURkyKCP+YDMZKyC6NQM40A3dDx9ZVAB1dTINomAr/wBv6ndgs8QIcSnkeLjVaKHpNgG2P5hGf0sDjQ6bgAzV9IsDa/Eoj6cTwuQahoDzL1xivnvHEXHqJ6TiMQwwQNwfqDKiAxk+wJ94AEIPIF9z9fihUGIPrB9TQfMoZl4jHq6QNn2/5EDZ9KBTq9/8gBWSIx6TQJXmBCOoHLLNYk88blEIIAFId6L+XCtbCGIaY1IDA7N6JHtKMIjE+aGijC9XLCx1YuhzqBnIHE5ZldyPnmWemqTgxkiuDuz+8CFjIAAk8VUGr/TCaLOQFrlbiiYhenqaGgOPnvAYv1PRR6SSX/v/ADKGT6UVWiDsakA4gYkks0gAKgXHKtY9LBFW5CxokAg2e/nW4RASA1lukd8RRcs3l04lAjYEGGPUM6yLbS/EhQhHE2iefaj9JdQxACGIHe7v44KDH1jqtHfb53kNbBJ6sSR7g71CKSUBkAT3cyJhZGCR2bt/4lB9QBOIBG3WoTin0oLL1c+dyBli8dHJp8wKMlj15PAjJEP8RiIRgmQHX0DiHqvEY2T9WpBf6dXiiAAAXqKmLgCR+oIMEi1qKKXlgBy79Mhw4OQxzbqEUnpIAACN5cwMhWSQ38MiumDOX6T6u3EM1jK0R1dk7lVenpyRXh8zIEAlvq9zKjQJDyKQopSYB7izoLy4QxB0Ch4G4orxG3l9NSBiCz00j8EChUfowbHiEUg9z51IM4kAOi6PYCBvEYtoiyiDCVAMTQwfNG3G0U49IJJ4uDWgQ0LGJ+kiId5Y3VJiAxGzwuNSAwMSarnmBcXm39OFCNY9T9R0tGveLEHxYL4P8yACiByd1HQAxIYonUAbCvp8QjX6vt2kAEg79J7QlPSQcieb5gLpGvvA0CTQTkFseL8wjP8AaUd0bgaSI0XIIaeTuBpjYEIcsc8kyBih9eTAuKFBniEpjye64r2gXjYXFSAQALbPmEUE742oAlIyBrgeIFJ6igSQYQ55HLgFYyUACGAEJEqgX3/iBoc4k1CLoJj3kACxiQB/mAtXShBpAAX5gVMVcgA0yLfECkhfaAFDRcIuOicUvaQB5MC8In3uRDgoD7wKTxxCIKgaBZdEGQTaKuUVIqRD2gV+fpIHtAv3hD2BkDncCwi+0A1AokQ+0C0BIL/EB3hAd4DgwKL3IijzAeIAGRFFiAcIu5A5gKhFHiBdwEBILqRCEVwLACAElQEDQsSBAQhAsISCwECwEIoMgsBIhCDgWBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeJzfTTBL55+fvOgjpDEEAM5cmNChkQ3TsQqHEDnfEGgegcghAjRBo2TAZdRy4JHziAAAAJAA1CoAz7mgefdSiB7179/hgV2uxsaUKHIA9KRRtcSiBE9Ly6nv57QJiScR6S2wOe0orG277/ADzIHThkkEbrX1jRk1uuQufMqyrkOnJ0MQHUQTInMdJyAHm+0cApkd+wUATj1t7PqQ3Bhi+jpCXJ5iiAGwReWtFyg+kgYjwTCoDXSQGaQgTpIGXcH3uCIiLD5IZGpeqpIY6AsQVVwIceAcmCmHA1lkHzj27b5iCYZCgSjqu0GMoAmhjimXf8SmqHixWuy57a+kdUwZzpY5H38f5kLxeokMml3gxnpwLGL6tAOveXRA+rHA4kkNcKNWqMNP8AVyG/39oNZyoixaECldRDxPbE61KI3isRztcePn3gUEWHYDA33/MH1i/0kpmlp8KVVwIRxBaHI7/DIIDlbJJ2DkjfhSjeJ6gejHLpP5k+oHkkUEj3kFRXUwcjyiYGcSMcwQqFL/PP0lOumLrEpHb/AIkRB1jJWlQVb8yCHF5AjEMPfz4pRrEY4sP26TZkvqNEDpJ29Ec/b6SImePR1B9SClJdU5IkA5ZZAPVyCEnpGSL5Z1GC5BALfFREK0BmB43A0SMRiliB3r4ZMoEPEr1Y1dyB1HteI7QgCOgjEkDt38R7oEEgZD1DhcHzKH9XQxPSMiwYiRrAY4gA73vbkqNBdXpGRAGx3kKEYv0lk388SCBGlxVwK0AQdPioEIPUupkd7+agawIpkHgrt7QlBeQOibHK8wAaeuD7yCklsh8l6gU5EUdAG3ImIEUOkplZShgckGm2ATFStDIUjfaQa9Oa6gOoc/OZPU4z+eQoNaP6idgCwrgT9QslCqECtlB5Da3CKwSwCe6kMMbxAfpFSUwBXIL5B4hFJI0FjzAAknpPqOoFAIBv6wIAFSH1/EDRLNBDsKqRE6QWANbMDXVevYjiEXF6IJkKmi+COBuVFZDL2G5Bcd2U+VIK6vtAINdKy0IAfqAKL7wlUADs+ZAOwndf5gGOokG+6hDqYTXO9yGKOatcQFvpLJMIoKFMdoEFA2geXA0HkCQABIi3f4kBVRLNQAb0a8alFFK138yIBs3+YBE3qQaCDG19FCKQFpyAQn03VGVA0ekAtcwFrQfMgp1ThE98aga7Ua8SBtqBWftCDrShRUx25kRTxjs+0IBCtmQUG60u8C1x7wgIF4dyCK6JgUEfaAH79oRffcBbkFJ+0ID2qAGtyUV+FCNAuoEgXl9pEBfECizIHOoAGoRfmoCBRIi0twEBuRCEVwKJA8wGoRRAsBACQUSIQi8wK4CAkQECwLIEIQLCLIEBAogIRZBYCREhFBgWBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4ko5jLvpjU6B0iAbyvIyKCuUPejKIOr9QARYgCOAUxXgwLkKONECioAhMkkLv34gZCeXSxk39IVNZCj2DqvglI0QyCOogmA/U00AveBjKz/87Xf7SxWkUDjY7DUggOJx0ARvxKIdvoRKD7QGr5o7gOksIJig4EH6cwCX/ddiVS/7QscrS/MCWEcMl1bMCpPIAsUu+xAiBeIY5r5cKYhgBYv8GA2SCSkyBCCQJDBI5PMqpeLxLyJD5gDjjiP80z3gQsEDLFfS0YXqZdQGIxvqb8/6lmC5YMtHHEaPj5xCamOWfSRkdhNQuNCjjhkAxoefggTIA42SAljX4I+kAB/+NB7s8iF+mSRZJVgvcEQ2iSSy2lBErqx9RIHJHClPiY9bvpGJQhUD6R/bZRJ1KNAYEgdIDpLiQ9Y/qYtUgPS5YsDiQ1k+rZJTHgQiu7y6chTJ+KMBBZAYi0nS+/yoVkroaBwGyvv7yjd4sFDFXiOPC5kQ6gciUfHvBigtZH0gZHX1sxUMMvW8cyaeQJ38uT4UxyAwQRyOgb+f6jDEfTdXsk+P+bjo2CBigXbZYp/aRKwGTliCb2VsfFKrXUTWRF9iqkxFOQJ6MX6Dx2+fvGfQ9QLyyLFEkA1CLnkcnk67iQngMViA8iOLb+fHCNZJeqyRY/bzIGOWZb9B15lsEB9QeSy2Acd+6gXEkrEDwyvrJn0WuhBF0HbkRXwTSN9h8+8AT68SWCX7geIRAEzT8nnvCtYr9Trv/EiICW+q8n7qKYpWmmNDQMI0eQCCiuzkAoA5EpPRdwiUTliABkS4XgWC8gAHzxA0U8ckA+5kRpdRJRCCDMiJkCxkQQOK/wAynVIYxyGTJpH3kAZelEAH2/aUHlyMbQJkMXQBqxuEXpL4B/aQQD0nFX+8CskDIUDdGoRMrVon8wNcsLqSH3NxUKI1UitYsgM/WREXqsP8QLwggxweYQSJAAL5XMaBOOI7JjvAp6gVv2kQyBWK0XAuQBLyQG09Qhj1IgsjRg8aFFUu6/MgUrfYXqEUfoWg7uQ+lWr5EBSG1suBaBFEAQICrOYRjEBpeV7QNg8kVJiM5caQ+OFUgcU+/MIMc8VINA0UQAUfaEA0xofxAvJLa48yIAvIoXCqLs2jxxCGJHUwwQIFGSxqvMiJoMftKNUkBzyJBEXogd4FDoG3Ii7K6dagUBd68whkyGXAAAAIe0gv0ZhAE6ygNFFtVepBQTrUC8IVAfdQi8++5BBoqBR3uRAd7uUWj9dyIrHeoFKAakEFlfmBbb/aEXkcSC77QIduUWq4MiDKuBWe8gPzCNbgTxAb95EO0DQIOt8SBACEXn/MBAtjUiK4CAPEIv5kQFQLIL9IDiAcIsBzACQBCNPmRCBYCAkQEDUgQEIAwKIQkFgIFhDmBZBYCRCEAYFgWAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4pWH+rie+6RkDIUR1PvAqQIr2/5AlDYCAYMvVN0ECDvvAzkjigwefEcFzs9A1xw4ID/wBhzo88QKcerFdTJqw/nEAEV6LH4hUsmmPHmUQsoZZGwfNwIWxo+JVTYBpDtxf8QNCkMgcX8/zAz6SCQ1oeagVkgX4W35MCEkCyUALerrUCY9PTiS0eOJVBiyCUCP3+KBMUCxRFb8wLh6kOk1+TFGcbxNkgHyIqtJ2Qr23CBWOLonutL2gQlX1UdVKocQSHQJZftJohJJbRdj59JRCScR1Ppf7yrEyxKQLLQyy1vUCsDIkZZNo/mBQiPUhVyDLLJBd6GPziUAD+np1ZI+fPEeAR6RiDYp94VD0gkBng3L8DLqyNM2QlADDArE2OXx4jaIQiODW6fl/WFDjkP/xn9KoXGhiBkGx6qDGt0vmpeFZ6sCx0k8gslDvA0VkB6Vbehl8/iODKxISGIoa2XQgaxNi00cgSBAZHK1jvw394ExB6yQVz2IPY/OIvFBlkMvSMQeQD9vr/ALhFOK6kDz/b7yBiB6elkMrt7EfNyi3jgAQiRrLixJnqbq2Okk2R1AyCgvMPI3sEwYNjErIF0RoCEMSXdMpk/pjCtEZEovV9u7kTyIs+hdJd8/45lNUl9IIWJsH/ACpBcT6gsgGyMhbo/wCYSoWAB+o2/AcgZEEkvqNWBYlGsXl09RJ4FJiQMuk59IJekNnUiKCX1PbolB9vnmAeOJAyKORT8wGGOQrGxtxaLYBsle57wh1p9lS4PtBhR9LSNdzIYmSOPQQv/a456jWbyPSGuHwZBQQiX0ghrtqBUBjROLomEXDNoIPkv9osMQXmQwMkk9QFU9EFkSC2271CFkXxZCW4FFIFLx895AFjI9PgQi3V2KHCgSumlkAOO0n0XEisukP9veEUdibgR4gsoEftAv8ASJJSFVFKuAeOjvRkFpPJIcrUiVSVit+9wgx3JYoOBUGHVsqAs72NrmAsph3rmEOn+3H0s7kFoEkA7UC4mruQG2QcifJlQx/9WEJKip4gDQ0YCgSsfeQUgk+WrOoFx6WhxZEAVyQFrkQgkeFILj9QcvuIRAdgYDvqBpnICvaQDq9aEC4lpnsTbhMV5bH4MAB6v47SCMvYftA0RtfvIhjsED/Uotgdu6kQpUX58wKF1PXeA3iCvq5EAVZp7MDXP+5AR6bUqG12/aABD39tyBwADCL9CfeQUcP6OAJBKgXl8wgwKPMAAkqEgtBx0LuRF8Fp1AHseNwhz2EDQsOQKWlADLgn/cJi83vvAdvaAXvIL/EIaXMCgtyBz5hF9oAE1UBIitQLi+ZAEC8NwhwhAAiEX8yC+/EBAbriRF8qAEIv0gB+JBdjxCDgWAgJBeZEWEATAsBACRBwNSBAQhAvEiECwECwhAsgsBIhCAMCiBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeKzxLZxanvyuk1CxQyQ7QIWciGLF+0cAlk+kJsntABsNCnUqqcQy+eY0Q6Z0eRBKiAFnHVv/cCsDH1aF94GcQOp09gDgQq5oZdQVH3MpEQIARfuvm4AnIgUF7X8/3AmWRByZA89hKp/aAX1Cxw1xApCBIy2b95Bkgs5GuTKQDGXTiAhSXEAWAukfeBCKp9fm5dUIxOKI6jyuP8xwU+nIjQ5PeQDbyxdE0JSMn9PSQFwJf1QgHIerSdeIRDiMcSeVrsI1YtYn9Vff5xIJkUfUd8jtKKwBiciQTzyOYGbxpZsiU6uQJ9ANH8fFJFOOoEPZqBGBi+kHzxqUZrDIBgo731fHL1Wn04jHk309hyJOowcshijgT3JEuK0ssiO72PtIJicTYxIdZIff55lDLECiSb5D8RqxkenIA2CLV8/PvKdaJxAZdfpQv2kDFDM5Cg2Vv54gZZOJIx6Tj2JQAmhor1BU+RXn2k4M44C8cKIIvL7/xH6aYgAlsAL0jKgPpGiZdWXqB2fOvjhVIpkAAgOtKEMgT1AEXwyD81E8GgxfUOxAHzmRAHq/p5Jq9ckjtxAYjHpIx0cnSTihWQWOSdVcDQayOA+hFP2+bj+oiYGORBGrG2fvzJoMFHGlf5gXM+jpyJOK2nEFLBIAAJQJUiBRx6hiCe63ADuWen+NwNY5dWJIOLPD/aMRrHqw/psn1Pm5E7WcuViCXyVDSjHI5h5jW+8iGeJbBxP1+d4SUyQPSciPHaARyyVkENr8R8FGWRJSIBZUYNYsp5MLSUiCx//qb+8IFEOsgbOjAoIxrqI7/ntIAyWLAJADq4wAL6iLNgka8OBrLIG8TrgDiTETpOjiK2TxApORGN0eO4hEJyDJas0P2gUa6UyNE2jA104r079pBOSWPpArPUxlQ12hFJy4I/38EgKukUe4MIosJdR7/4gCfUnX7yA+r1dyfrFAn+2uy7QKR6rdED3MIFYjW78GQivHHTXj2hDKisg3cCsDEA875kBHQGxwZUUok49QXMgosMEsfBCAJ0N+ZDEFEDFkDSG5Rpr0878SJiPJICk9xg0jyfvIDJ3j4IgWgUG/EBohWNGEVoaJWh2kFCdXyoRlsF9LHiBp2UFf3kBCwPSBzADp6mQCf4hD9XqcDSKvkWJECG+3tCrWmX2hB0f21IKNJU4RKMDQtkUYALT8KEN8JSCmhQJECsmn4kQsj+YUH7Qihkdj7QiisU78SByQE/MAB6rJgUi6yuEQp3AqeS495ADcCjuyZEVjfEA7o3CLrvAOq7SC68cmAJem4RR2pCQOxlC755gXQUiLUgDnmA5cIv1gPFQLwpENGBdhyB4gX6QiGBXzAvNXIijQgICpEXiAsVCLzUBIFwiiBYCA9pBQYRZEH5gWAgJEIGpAgIQgWRCBYCBYQgWQWAkQhAQLzAsBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBA8VkPUSV9vnae+6QOOORPJQ1JoyCQ8+o5A9uJoX9JFZCt1IJoAdXPG6gQ0ESguSpVVDH9IRBR5qBrPENEbBvvUakYyQ0CARVwp6iS0tJwJgCD2SBuoGmAKeT2zKMiyA9eOIWlo1wRvX8f8gTLL1UuOPzKqAnZ9L0jUBiQyeEdagoTj08J3AB5YhFl8BQHckdK3fiFUPY0uIGctjLj9v2UsFWIwxxbfHMnoyrOWQ3yD33Kfxc1k8uo4kFhhjvLD1nIAY4k/Rv52j0MgD/TLsLYhVxvMh5Zdj2kEKoeluq+faWBgPSTdtEfO0UYwxtkZFq5dVop+kobXUFAuR6vXj+rHwpBlkeoAh8EoCUXqHIZG7sQIiEAmQgOwjRqsScSsilZ3xuDrn1ZAk5YHuS9Sq08T/UyOOXqXHHzxJ8E6T+g0ueY1UxOJyJBK56h95cFxvHEIjItZPcIz0Y5k5aOQVG7bllxTEgDGm9Fr2j0qE4n+nlZPcP76j6NdIyzevK9/9QcZ2/6ZC9H9or7y/qn9MkPPLOwEvzH8S/40eo4FPIXok9u0hys4EGwCyz1fVy3RUOu8iSStfPeQaPUSbIx5LYEgqIyxo9JN/PpCGRWObHSCaJGr1+YFyFZdIDbFflyakVvIugDa+fHBjP8ATJ6cUT4f/feKNAdLZZBekoRccfORt65k0qEBKi95Pm4Gjll1fpJ2d/HGIWKCZoHxIICRlkelFUe/8y0UkB1ZZcz0Uj1Es5e30/wIFHSSRskDxUIyFiP/ACBk5f8AtXwal74NZPHIUKBfqseJE6EIgBm2tPiAKCBVjVmQU/8AwA8TsbgdMxoFEJb7iSMsZWfTiNccQpbOWWQXfvUBgPVsUruUrQyxxxQACF9UiYYLIq0LkKqIa6bBZ+fWEMsicxt/xBE85EM8iBQbJR0aa/EC9VLf8yYNYg547yPvCcRsdRI+knBRrqdIcwhlxmfq9RBXigBZOwTIiDXUVlj8cqtZWCSMgeCP8SIV0gq3dNfDAEeg0TX3kFwTIH6e5MIpJ0z4+fzEDEEC8d6e/iiomIHICpXCtFMHXPMiYp9XB6hIJYRIRP1UCtDQQhDsHv8AEDYKJxAfHiRlh5YsnpPeVWyjllRB5JqQF/a6HaAxLLAOMIY3jjjV8iKKgWchZrtIgKAqj3gCR0li+xkGgGXagL1kyCE9QiYkD1Mv94Gl6aV/OZETEkjVbbiikB8wKd8LlSCqwu+oAnfbdQim2jvUC22buRExFCiIoopplGEXEA637yBRFa7wLb4gNU1/EIAm19JBfAEKEhm4RX3+5hE0GkTAp2q5pSBTH8wLr/kiK2x2PtA0fooRG4CtuQBv/UCuqqEUEO6+sgGtniUHcAD9ZEXzArkAWP8AcIosPcB5gXzIg9AQKNOQDqxAcQi8QA32kFhFGoASBKmLsSAPihFkCBXAljmEagICQUHiEX3kQEC8QEBIgKgakCAhCBqRCAgIFEIQNCQICRCEBA1AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQPEjEokFjxR+0990i7JJ0pBDewPAlgzkyTlQom7lG9ouwO8gyCySnSHf/XEon6W2zwI6q5On+IE3jlliwa+u4/ohAWPUaIqBSgSyAAdji4PiZDwCCGXzCmq/SHftKGz6if2MCLZOLHCLp/eBOlA2CR54+CVVeLSdBE8f5gXHEE26O5BjHLLFrvp6lFCx/pjFaH2gEQenJpdqgMsgjrpPfiFQCzQrJXwKlNXIrHpCO6HHiDE9R/tIFwJjsjIoPv5hQ5AHpFkf6hELJySxoED/AFKsqkn9PSChxIGWRo5kgNjvqUxkgjECia37f8hRg0eNN3AuJRIO/n5lKdwSSBYDZEgmVgghBWK+38y8IziAwXwv2hWsQbHqFlkEe8IzWWwD1HXaFa6nl/JHMDJPpYD5Iffn8SiE9GJAP/6+4sgOOkRA4rHqGXAFL37Sq6Z5bslXrXvJiRnEime6H+Iqs5DqyPb9ICv3ftKNf0yRgQciARS88wXrIJyfUTVVySeJTidKIOQQHCr5X/ZFXHLEnpIJI+pjCgGSTDFlabgMW+kl5bHn44RQj/T5YKF3AuBOILBDtv8AbvJU6AZCwAToDut+8FVAZdTKRoceB9o0xOsCjmck0D4jpjWJORXUMvDsqTERHBjrIPJb/MdF/wD16HGgb1HRoEjE4+hcL2kRMvTlx4v58MDXqJIzGKri4QxPRjdDkgSdKUGGuWDfECdIIJb8ZBEfX7wNBM9Rr/1PzxIgSXaZ0SNQfxCMiSSwQCaFgy6NoHpqwCq/EiMgkDN0EriqH00nkbN7+VCNZPksftMh+rApjIgEDnmXiLQGLvsO307wKSAyS8XSHniRPiGkiBTXeFWiGdA8XUIoTHV6noGQNAn0kG1rmAQAKOvHjUDTXBAIGx54hAAP1DmQTB302WzUtK0+nDp7D4pELxytkKy5EU5IE6HNQYA2SwPV71BVyJSBZJhMB1OwANyKUMj1acCko9IxIWq9v+QyGySSmKUK0erQsDxIiZHpXVzYx7QFoAHsPxAoIIarggSIuPpYXztBgFa1uuIRSTo/aQMVR+ktFA4yVO3Ig+43uQUGzsAcwBaoX7QBKBAaxNQFEF7fJ1CNHLe+8mChci7hEPJZWvCgax/SefEgg2XarfeEXlm4AZbCoQKA+SfP1kQFVrlwoP0WIRQwFV3UgqO3fEIFMnfe4DVBwKP27iQEAx+0IpYoLWoFJ2OqECCD/qQVnnKoCxjbIhAEWNjdSAFxvtuBRt8wDPnzCKQS32gXtUgjTJMC6oQin3qQNhcmEUccwHc2ZAMC/tCKCpA1b+8od5BWf8wgEDIA91AuhCKka7QBPMC/fciHtAt95AFHmBWdQhvzAv1kQNeTAsBIKIQ7wg4FkCAgUGEWAgJBXIiwh5gUagICRFBgWQICEAYFkQgWAgWEIFkFgJEIQBgUQLAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEDxWIAyRu+T7z33Rr2NG7kVMh76cASfUT+0CdQBJ5GgZRCsgrjgpxsvEiq7wJZ6uq8dhfSVVxQLQqKgiNsF/C4VnKqGLpqFQnHI8DX1gU16SAAhCJ05EUepHkKWVUIeBYruBAiyVjIu9blNXIrEBNndqFGOp5aewaNQGXTiBw+QUPnMRDLEHA9QNCRdXyUffRlEOIyxKBLHJqNGSASWAEWOoKVVyoGtfOLiCEnEM3buoF/qf+3S9WPEQZJsElHdyinaxxAxANkyCFgCi9i1CpkusZZGgGR5v7Sn8MyOo9IAPg8qBMUMTiCNr2JgUPLMp1wRzCo8j1DHFEbAUoFnJ4o13+VIM5HEAAWuAVxLFXpGbxPV/McEJA6kdsI8dpQyQfUr4AbiCk5nKyjRJEDJPUMUQjZY1AZYgYlA5PwW5dEP6Hma2V5j6q/q6nWYr9XyveAJf9MgrZK1XaD6hOWKTWO1AZ4+k4jJEkWW/eWCkMDHEl6yPnmQlMgjjsjJ8P6wu6Y4kWy+lMePEFZz9RovFLf5ieDWX/qNe7+/5hOmR6SgOoq1JgEsHHSF2kv8AsDQA6SSekECyGCIQGQosGqWSUgZk/q/tJHkG4iLiMRkTkcjbJ7eKgTE9TPUB7m4KHH1dXQxvJxKOmKPp6icuy8yVKmBw1mF3Jf7f5inqZdZAFr+2/EDSGgQMUERT4hE/prHPHpFff8xS+tCkiaN8VMhmN1sd4QZWRLOu3vAdSZAR0O0FgupY9B8Ff5jg0iCSQEtA/eEQWyfUDYGu0g3hkjwEYqYJBbtUakEy6msVf7wHUMu6YoRwxepFdQS44jEOliii66rdQVQzgQXk+KcgmOJVB2/1So0eoYoDmyrkAoHqyAIdFbrtAv8AUXSHixtq5IildJBAJGrgVnE2bHeQECEAAx8qES2Tkxbe4FNgq/zECwGPe7gaJOxY57yIdu+6ECsuiAFqQQtDXcPiArqGXj7mEXIvIinrVwLiQkHdRhQEHPgfWRFHVkSkx2MFDZogVzII2KHVKNAAlHH8yIhyTGiYMaNM2X2hD+5ZG613gWyAbX3kBUekHtxAH9PqZ5Xcwi9xkmDtQK2ET5uRD1cX01ApAOPTYB7QhVAVw+8iqeFCKBynUgh9ViOCnjSGoFJ/9bqREPY0oGgR0t14hAHX8jUBl/7QKELT5MiGNuBUQRkAP8wNYkSIgK2NSgiZBaPkcQhjRHbcgvAIEAb7GoAHaswis3UgXr+YF5siAH/tt95EUFGDFri4Qt0YBvcgGu8CgD27QigFJbkES7SjVpfzIhYuAJqBeJEXRgGDAdyYF8yIDVQLsSBAp2yYQ+sA+fEC2SrkRRrUBuQBcIphAHtAokAwBhF8GAgWAkFHaRFhCBdwEBIiiBZAgIQBgakRIFgIFhAVINQECSMrACBqAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHjKBQ0K9vgnvOjNv3HEDKspn3uFQIFGx39pQNjjhDcQMjkMgg/wD+0QGyP8jUCBDFZOtriFAPUiQz55lNUHEFnEogWBCMgmhTGzCiTA2NwrIRZKJaKEo3liO4ofVyJKgPq2KCfTrUqslrIXrY4iDeWQDQOXeEjORHT6sQOzMRUOkWVxcqriQbBFXrzJRMh6rNtblEyQLfTdd0YIFnFUAy/MKMHCgrXZwFpAIADlyhrALI+oEOtwHSSDlY59oGSyiEGNmOGtEWN0dQMoGjrsB+IUxAObBRPJAlACkFWvHmBnpxROIdoE8wuriRjixQLRfmXAJCBAxPAB57SCYrCtBr2l9omiySQUoVTjiT6+AskLjU9TLEjqZI6jQHz45dDLEF5AFjRIkXULGNH041tfX52lDB9IDbLqSqhBOXS738Moox6ib82H4cJoUEgASdEt/WFZxOfQcsQy2O2pfBQRigBkVQZ+/7wYDFbHUAdgH8RoPIY30nIlUPnmBnqIzxBfYrQ1R/3KuH9N/08fUbJ8fNyX3gqGRIB/T4r94RcQsenAM3TsfeP6WmWT6jlgQNexgEOlEJjQr4JNGsMTjkS3SA504qJksiCXiCLB5/zqODTRyANWPr8/aQMVvHqBI0YQyyPUMbKZHHtUGCPSQQNNjmBMckPVkH0+rk+0WDYy44S3v7TKYDIdII/URQHfnUo0MgykQKPtIhjkEXQBGzQ+ODEAsnELl9/nmAHoyFFWWfEFCSiyXWqkRczkMh09B1txMFRyIryN6g4D0joIOVfKjouIx6gG2NqRFGXSRl0MEDsDCYgJATQGytyVVSYA14or94QxZdZZEVcDZAZAdBJQkMcick8tEf8kMYN9Q/UFv/ABKV0OXOGI+v5kSGWaxRGPt2jBKVBrvA0LRRGlW5KgenqAYfH+IDKrLF6HEELyxFhAmhzIKcnhdM09Qi7CBxHAGMCEj/AMdEpInqMfUaTBJIsPcgEEgFpgxwWitN95BCrGX24gaxIJFkfX52hKDs99u0A8UQFj2EmCtDS/cQgyQE90ID9IY0wCpAoergo+0o0ekEAlrh7kQOOzsmyoRSiwkdDvIIQU+NWIFx1yQYoV1dLgaA7kjmEGgEhfGu0mAOogkb7/SEAQNAfP8AsGLXFg9+ZA9QCZb3CF9QKa57QLj6Rt3ZcX0WiTxIgNdIowK8i3iOxUALF3ILiADuzxAbIJHEIvJgARvR94CzlX5kRbW3UAKCtq4FfipEAWArJqMF6gzcIoO3IAvVQA7ixcAdFwilsIr6SCiyPvABigHABOtGRFZ3RqDANcqEXXjtAoBur8mQWuPaEQbgByOIGiSdVIiM93CrxCL71AO1dyIp7wHG4B1Au+XIgCFX1gXiQOBAsIQKOxkQgV/SAkB1CLACBakRd+YDxCDrcCiA5gJBXIi8QgIFgICRFFQK5AgIQBgakRIFgIFEICBZBYCRkgUGAECwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQPFEEWPt3M990YdVY48yC0CaIHu4Gb/SSvBuVWqIrkfzIM2QMj+BuUAwBkDYFCBWhtnTgQ+kMoKquUTA4kAC/rxFVT0pLnXiETJnHqJS8wp1HrJse0GJ/T3WRfLiqqv0i+Dr6QjOKAJPF1z8uXqqBaOSL14g1gJlt+8KtHFjXFfNyiY5EgE5NXzxCFHSOQFVcKuZBGXrQMQYfKK4Xxwrax6VktcmEZArHIY8ui1Uq6mIs4quxPYxRrEjqILQfGpBnJdA0Da8SkSgV2pqlUqtHA7PqJH6TJqazkC3sigEv295VS+pYn1ACnqBpY5FjFk8gKvhg4dOSHV9UG/lQazgNAHJncVVsEvHIAX4hDFisscTil3uWiZ44uwWKBG41YYvH+mSGUEjyIL0WLNZdQHuRq40ZC6PVmUD/AO3aVV6gP6Z6SFwT7yZ6M4hjLMi+QexUtD0k/qPSOT9K/eFGDgEVRJaScqGRTF9SZA7yKufQSP8Ax9K55+alJ+pkQMWgh32P8RDGsLI6ykSTXMJfxk9Q6g9jSv4IVnI0ciFdjgn3+0qqMAWXZ9LJKk0XEB45Am+Sf8e0IDI4guzdjcYGHUunH0kGx2ijQvILHglnt2/aQQ5DE4q6AcZqNf1MgStIK/lwkZCOBIxQP8wq4Ej+0+eYqGJyxxXRYDF6ElGzikRf1uREweQxZoUUOUPtFDBY4sD7IKCpkBRBDVa+7iDSJFfR+3+oRQQMtBFfp5EgnSQem1/86/xA2FkK7B+L+feRGeqsTllehco0AenqFFfaQVrFYv5zIISMRvqWkFLiL/TyBAACHII44kpjXVWtHfG4TEyDHq3wE3AHL/8AISb9jIYYJ9Nhd4o02UEH378whiUMmCTtd4ouIAy6ciSd/SQZA6W8dVyoGiXiz1DwfEImNgGyeK+0UV0QGEKr+YFJGQP6rujImIGbQOq/1A2OkBE8LUiICEC8XsqowMUM0UCtfWLwaxPqIRomKDeA/iEGjyu8itdIogjqP2kRCDvZ4twHPYpMtQjTBKOzd7gUA9IL6h45kqJiAhwt/wCIGrGRYHfcCAnD+4LtqEUrSfAkFAIxPTR4gUcjpAqEQDHpsc0FuBX6SAx27yCY0Dwew8xRR0vRA/aAYVlU9wik0aZGzINZFrpYAhB1X2kFxIpv6cwh3AJ+8CEu6JgUDFUtomBQqNDvIDVNx1APWr4gaGwAhypAdhB1AZG+1IQg6ZQgUMcCQAwOIRpLX2gBYZJQ3IgNPf1gD72oAj6fxCK74kA7/wBwNbGlXMCaA5+kIux5kF48QI+zPvCKCapSCs/mEOFzAr9Wm/EBjtftILytOEUMce0gBArfLgNShw1Iij5cA68QLvjciFtwKwu8A/N+0Cjf+pEAbNfSBeJA0dQLXG4QUB+IReVIL2kASihuRDXJgVwhxILAmhCK+IFgBIECuRFMIQKICAkRQYFkCAhFBgJEWAgIFhCQaEBAkjKwKDAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeJ4vsvYT3nRrk2GSO61AEF0D4gUAk7rwYEu9APemIUyRrpF0CZYgdEA/eFT/wDiQa1tQI8UK3TMoYn3P0kUpUKJMoEGi2eDAHpr/wBvpABVkO7uBnIkcB8nsTKNdXUOOriQxC6IH1J2IUG7LH9w+fKlEDP6hkXbUAQuq/U3qVU56QXwfMAdelUF9o/ohIvLEb0Fz4gCAxtNGBnoDJo7f/I1VyQyOWQxr8e35lAlf1GAH+9x0wxKACKA/ECZInbAtAAfWNC0CEFl53ANY7HYf4lExHVbrW4viiJyGWVlXl07+kaL/TJ9OJb3WooyRiaGR8+f9xqxeptZep2ShXYQmM5AnLIK8d0yJVbyxJZ0Sddvn+JNSIWEvBD+eZYrOQyIN/hRqpksiAckQQvVBxcCCBkzvf8AEYM+oI9IHc9xKoQTQBBQB8QBAePVjigA0I0MRlbH6i0NH4IFb8O1riCIxvH0vJAE3Kf0/plUgu5F4moKBjAZebNfOYwZIIL6MV4hTJdKxIx7tj5/qBcRicjZLNrn5/mCqEv09RHL37QhgMscRll0kjgnnT/aAxfUCw9El8cxRrFjElFpsDx83IiDIk4gjEA/pfaMVP1HIEHJ88bcI1glkzZq3UhdT1dHTkyRaPtKAORQ6jl/FbfzcYjf6cclWDL6j/n6yIvSgACFugfV9ZDWcQVYssLfhQLmCx1WAUSDE8QzHqL6e9mFbxAJeVjQC9pETeLOfpBq3UCnJg4sAGq7QmKgQhQNMBv4pA2KJHcKvzAhKAHSBx5EBjl0kEg+GeYs0abRATP8/PvIgcTx9/8AsDTFAC0Eb14kQxpEPEgvWoKZHOhf8vxKkXqPTZIPe5DFZNBDn6eZMEBGJHUdbcBiwPUKN2RcC08gMiSTuEAR1dIKXEC5AkFMUg/EmoHJgkhE9zBioVkAEDxAdIBYNvnZkFJIZ/jcIrPV1D7rz3gxAdVofPnmMFbP9xrkwingEovt+ZFXQVkyImAGSP0A5louOwySg27+sIuDeLvy5KHpJSNVIK6OxySSbhE2cg9edwNEN2GdwgaK1IBANPzv8wKgdjXiEMSCAYD1ABkL95BSH6a4BgGRkAbQ1AoHJIJ24RbJv/lSAC/BJ1CGOSrjtBYrrevMgW2EYFKIA19IQCeuYGsdelf5kRB6QC71qOiji9eOIFDXeQQHKro/iAGzW+YRrFX5rUgl65EodtrlmRGtBhAP7wNEAAdhIiAEBc25QI0dgGQDvcI1j5cggRDs3UK039dwycePtAb7jvIBJCB54gAVwBArf3kRVSgV8L3hDE/HAeBAvCMge5hFFGAFdoAK0DvcgvPaEDr9oF37yIvL7GAqA8/zAtyIAqBfKkCEX2gBADt2hFFcyCyBAbcItd4BwiyBADUC/WEXlQGpAgUGRFhAFQLAQEiKDAsgQEIogIQEgsBAsIQNSCQiyIkDQgUQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBA8WzRR/ie86JcgALaNwRD0nyee8KDJoBA8PmMGcQOnpoFHzKAr+1e8K1ktAjwOJBlEotYm1LohHVkCcgTyAdSgUSMU1oHbgCCyBsGrhTJtg0quBSP/AKH3X/IRkUSN87/EKAkZA2hw/P8AuBB6rewB7RwUj1ksMi/AgiURXqRYJDlUIGR/VT76+neD1ALCAvJ/xAHpOaOz23UvuKYnqTJQHe1AvScn+WLgZLR6RRWoEA6kSSOY4qkZDF0cW24QHVWPUDzqXxUAeQoBIedf6gTEHpYLF86imqQ8uHQs2P8AcGh6jZFoagPTiuCLHg94GcgcMTkBZo3oSnTIEkoL2P2jVAST1DEa+h7OOGGYJbWu6Hz/ABEExH9oAvRhUA6QCCCN7uUaKI6SCckwTvtAz6GwXxrQEeiN4kDNd3z9tSqFBenppFQNEEhAdWKv9kJDXPIk59Q5ejKrZxebNqvJhEIH6WGQKA8QQwJSO9Hz8qAAAyTQ6XcKyQGitcV/yUayF9Y9Pcnt3UfiamAPScSekkem0O1QtqHpxxJIPpyLPvHRkk9T6SUeRyt8yxWgDjkBiTji2CB8+KRBIYg0k8uxr8wNdKGiAUK7waxiWPTmWBQxtd/3EZhXQJdPADXaQMCCQ+kcgj7RUQ5AZAjKnsZCow6uJBeQdFEqSjWQByI/tW4ReBiMQseADchxC8tsm0DojzKMvI5dqu7+0DoQAP0k7+kjILHpB/PECDMlB9L0fnzUYGKxAwypgkEDXtH6LiSHoGmi5BrMg1YJ5Ir5/mRGQNZEoFHpB7S6L6DkHkyNsIPx5godpLhHWpA6fUcRtsVAuRB9QIXHg9pEbWLIZ543fMIgHSUEtj3koD0kZED2+sdKY2GXYAPz5uEUj1dRJYDyKYgXG8CcWMRYe1ALEk5FgPspAtjQDeq7QKcgckQSC/xGIYqjkEANH9oFAsjq6SLTkCyz3TcIAAgHKqcDRFURtgK5EQbA6iBu6hWg/wC41x9oRMcWCcb5Rimqw9jHQ1JgtpsH8QisMAb8SYJkCMXiurlfxKi5DqZK+0mgMiwWAePH0gUhssFU1Ii4gmho+NQJQAI90RArrpQ13hFBxsgFPcmCFItj6SjRfIdXIik1RC0idmBkslk+IGiACyfZmQX/AObLEBjQv7wi077SAd3fFwi7eWltbUCgUQTvmQRoFAE/vAAklgfzCNK/HjiASAHAqRFIWxRqBAHwf2ga+mtyAOCf2hAm6u/MADutbgaO/EgtkgLQhE/fiA7GoGieykQFhJQiMmi/tqBRpFkEbkAMQNG+D7wiVRO9wLXY+SeYA7/EgqsiAJ5kRquxhE1fECjfmAHnw5BeauvvADXbxCKEbIcArEgA3Lgo7yIBF/xAu5EBw4F+sBX0gUSIYqBfdyB9YF8AQgdVuBd2TIhfMCwEgQi+IAGMRYC5BYQgWAkCBX3kQhFgWAgJEUQLIEBCKDASIsBAQLCAMgsCwhIhAAwNQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEDxaIF0e63PedG0EvUSOPeRAgvEAjfEowN2QCKUqqQUWDpB3IJkLKY71cLFBJOwfKgQY9R/uSIqUQ4/aNDJbDIbhVLOYXP+IRn0kAAU7UpAk7D+g3Cheg0GfzAEA835LAgZv9LJMqtD9LeJOiG34hELpaIseO8gy94lPSf+ZVbIfKA5/H8wanTiDZQLT4jTUOgP9yrE6QD0iiRvL9oAY5X6mSWv4jQ/q4ikUAPeIRSQGfowdQMbR5Vcwpkisep8ASwMcgAUC6NHcGNfqCIHityDAAJAFyiYNsDF/wDtxKVq28MhunIf1P6gpAVTv+YiwGLPT6SdshIcQVNn+5bKEopPpJBXFjxAwfURi0eKF/DKqAl5BLIHSfeMGhiOk4o+b/aNEolZA5AnkVKB69Ihi2vnMipmcScUBRetDvLCJiCR6gT6tfz/ALiq1kH09YoGgQ3/AIiIaHVk1/b95BDonpeJOh2qWKhyFAgs2UK+f4jALADobs+4N94EyJxBAQHUjVntLD9Nr1Mnt3EC86ILQK47d4GaGCx/UH+koAR/VUl4hZ4tbOz7/aIiHqOSdH7vbhWyT0+sjJH7QiZEE3kMQ02ajD0BeDGXIJft9pDPVBBs3gCt6NQGBIeRWOWz28/aEq4lEsBBEkovm+efxBhiSfHGvrJRDkRmCMiSQESfniVMXLHzRIR8CQOnIYgNiiEjA1icBiGHxijIl1vLpOWI6/0m3IjA/UW+rWuO0vwaIOOB0AaCMCZbLe7v9jINYnIEnqy6Vs1UAOnJZFdJY/V7wlCgT1FAbEgEgnqA8/HApvMAELId9VB8AWnjo3FTMUk0QC2xackFKNDWxe77Qh6QT/ae6kEVLg22ZRoEAVkOrH/5UIEFg8q69vzIAJBX0aUDZR2UNDv2kQGOLYG3oNQISkGEnUUkUgYrFdA5I7yImOI4Nks8By2q1mBkB28fPpJxGntBuvgkRnh6rfaFwJHUrbAMCgvGsR3EI0CTRfiRExIJGP09pVMeocp8nciVoer1YEi6MnAzHAGkwv4hFxRPS62X5gqNm7QtlQNf2nYOluRE2QCT95RB1Bg0X95BoJELHz5kDE3rm2dSpVRrh+YFOXUiODJiJhYvk9+Io0aAORQ4uQB+nqTBK9oFJIsjf5gDkkx7mEVFa+gEgmRVNXERdjld/MC9wuZA2EAz3gU2NmvGoRHadHiBrQ2w+0gZEbyoO6hFFh3IA7quy/MChgM7W4QBR37KBb8yCEXQPv5lFI7a39JEAFQL/EDQKCT4EiK8SQiaMCao/eBSKOi61CB9v9yAEPaBQqK/EBX27QivnUmC8jgc1AXyNQhvs/2kFonjxApUIn7QNcc1zAc+ZAtq4RW6P2kFV8wiEgbMK0e3HiESt/mBrK05EPlwHH7wBN6gWyJEUHiQBtQAqBaPiEDAoRkQgWQE+JQvUIsgAwiyBuAEIsCwEgQLIimEBAsBASIoMCyBCEADAsiECwECwgJBqAhCRCBQYFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeLHV1IhHhT3XRHagVaG9wp0+pbJ43+8uoZA9Vr6UYWKupIH7QcZDoFbEAe2xrcKY9NBD23AmS6bFkWTKGWNACxfvAFdQDB40oFvKwiO+vm4EV6Z4uFZIPUsUQOHKBu8q73AZIlOiuIIZDJMYgg7LgUEC+5S/zAj9Vhnt5gDXDLrxKocssMRkUChqoz0Z/qDHJh8UfETwCTkTZ7X3lUyoFY8QKwP6YJ0NWrcJ9RshED6QoOoAjPDe1zAiGRORHGweYVMTkz09NcHtKKMcurZDsF7qDWGiMsiHr8y9Vp40wKPJ+dpEQBFYk2aHzxCqT6wwWT30vMJ8TFgPEOux4lq9QAdXqqgytfDA0RfUA8hZqQZfQN4E8knmWeiAnLK77f8/iVQgdjqx3kBLFEP1JuUBZGIFG9tfO0CYDoCOVvgf6+VL0ZyDCCxVgP/AqIqlZAoAi/PtAZEBer0mwBSPeIKTkc/WMTiEbOvn8QJkR1YiiHrZ+sCjqH9QVkcUt8u/3l8wZy9QPo2CL3JPFXNBY6By+/aU/U6gMc/Uy+Oe0YJ/TK2CDkEw/3gvq4sek+rk8P/OoVzHT0hiwe1k/FKNYnI46eLop13uQqnHrBHqZVHsveXcQGWIyXURjsMpj5/EmCgsPRAsEkVqQW8gAEwBuApYlI47YtwgCelo/Xvx8/eMGhkDYYBsh7kMXH1kprpAWvn+4RnF9RBOJ5b1/r/EC+unZ2iN33kDEAZgYrqCZFAQjWWJBssHgj+YI0CM+w7rKROIMcwgWmFVVKeJ6XRCf+pFawKyRHq9v8xidRHooGxZA/ge0iLlgEF+m6PaNFY6k8jaL/mBbyTKDXqHj/cImIsgDE8OSqHAnP0kDsF25liKwV1fh38/iQwJGWTRIKBUDRGRx9OWK58yeIY5AZAr1Fca/zCAyIL2Ts3f8QYpYaHqFnxINZHPHDqJaAuM1EyGObADHgOOA2cmxw+0C5EogdNjUB1j/AMfUUeBzGIoPUmT3PmS+ADljs45PzuDqi7IBpauQTE5ElZdJF6ftKmNAYtnILuDIjIYv1Hg19Y6rYyFa3VSYiJn08n6Qqk+sA9N/WRDF4ilivYQNDfq1zf7QinuCj3q4B9NdR80S4RBZfeQaT4v9+8ghBxxR0+0oos6ACZMiAWNWfMoZAmjR3qRF3rlqoAkEvbH2kFBPWbBA8QKSsh+2lCKj1jS0jAMkcdpAyIrkN1CLwaPioAMBEN7/AMyCiq37wVAaARb1CLiSiiAPeArRQJXMgoN6KhFT4D9oDdNakFtDYUIjWPaBoF2pBRZ+iswiDe3zqBbH+4Bhix7mEaIVgn7yACDtfaE4Aea99QAL05BWcaNQFkCBSBxCHOuZBeGSoAHhyAnlTcIVTuBdlwi7H6lArP1kAH/sBwhCKdIFkSBvipQHL/EiKT5gGsYF7ORFDHP4gBf7QA3tQLXP7SICoFcgedQK73CEC1IiwEBILCGhCKIChIG4BuEXcC8wHMgvMA5EVwhAsBASIogWQICEUQhILAQECwgJBqAhCRCBRAsBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQPGV1lCkv5nuuiOq1k4EI2FyObMoEk0yh3kVQBiASNyprOORONPX2hcaHSjSXeBMvV6sq7QTzwHUCKyXkQIGAW8kVuVQ/qKFHuYEP6SSadQIQRlRo2xCtIjJ2VCOeyLWkvzKqgJGwCRoQBJAFUdFwHLrqSHiAH/AOu8T7GD6o5IWWoENUTRFg+0qpQKB6eSBuAGyCGCL7mCoQGKyPhcQqIdJABDRI1LopvEjGzq+0B6enHHIhOqHwQACI5uu7gSgMlxQdOFTIAekkAPgU5YNVjbJuz894OoUQKV8SBRAGLAJaaMozmHlQD8NiUij1ZB4v8AYyDJDRbHj8/PELBHIgFA2v8AP4lDJ5ZOwuwiASOkYi7vpggOpHMCzqqgP6mWWsiK7wsCMg8T6itDV+TKdZ6WgCcit/xGquXULxBOyHk4SMlD+oQyxoB17SqEdJwAKxy7C/nziAfqOWOJ0IGSRlj15EEc9/t7mMVrHL15EPIIbyFnvF4jICokAkMbv6CFaGGPUA8TiG1yPgl1NTryoHI5VxSuOriAtEk4qrH119oz4KFeRPTYBPDgRgMkHqB72IUOIDAKHkVAiKDxxJIQsH5/qBrZy6SWQSA7BuEQjOjjkX/8jj+JTxenpIyTGwX2+CT1PDPMDFgMALEuTBQPRYKPGQsVJQGJ6Uk2U1CtDLHqxxBPn583H6iAn/ysCkt/X94+YKMrIyByAHz+YQODBBxxQITD9o1CyzYxHxyYrYrEELyR8+fuZ7WMTl/4ywhyTTcfVdMSCChQPAqSoE9WJy/qX4TXMAAWCB//AJP2+e8VAA4Yk0wQie0m6Lf/AJKAFAragCB0HlnW6gTPFZ0WP2MfBrH9Ryx4K/V84hKyUx1MaAGtQNBUU2RzqSgX0v09J/ECkp9RRWz7SRGgCMUcR1HjbEIAgAkHlXXziDqpEZD688SCGisgQrXECiiqS1yZChTBQ2ORAFEGuzuEXeJIrydKBoZekA9RDFdveEwXSh30JKdQFvpHjHmMQyIBZJI5IiK1QNXpvfiGQlgPuoVWMkEL4kviJmGeCxdQNYknIGq1IYiBR3AoIOXScg1+IRSL6iPynAHKgBY+zjEAScephnljcguRLIZK7RgthgF+XUIgRQF1zCtEF+kYg2akRF6isf8AEIp3imQdgQALLAGvvJgA0z9QrgXE2TS0G4QoUTaorUDXpBs0L1Ig+zIVkwqAoPKiCqjEa8nv2uQNA0PMClbBIG3CGJpDIF1AtMjTHMIhD0Xcg0kiL8QIcqYS48QNCh57bkQAq+YFYYpD8SCX1HLQ1KNAo8GRFu79oEPc14gafpbhED6bkGgavvUiA82YAb4+0CrpBVXUIW21UBRFbkAgHKrgUbrg9oQVhiBRxVu5ECwN+4gXQv7wLoJhyAD9LUYLIg+9wGjAv2gOIQ47SCj2hF0VADmoCveBWNCRFfBkD3gPvCKNtwAgUWVIh5MCwHHaQIRfaAEIsgcwh2gVuAgUSBAoIkQhFBW4FgICRFECyBCECgwhILAQECwiiQIFhEkRYFECwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEDxuQAP6l2nuOiQ15XbmUMXkuzdHcAAdE+k02q5lEIWJA3yIA8Y/wC4Ve6CA32gTLqVd/vAyxjy/HiXqmWRJ6Sh4MDVt7aEgzjVsAalBiyAQxTdwGKAHdkkjmKJm8rA5o7lngAcosIkBKFoEQBRuzqAQzeLP1EHEtknqY1AABAkVv3PziUUsdntSDGTIVm+ZVCXlu20tfSBcwHSHK4MSkQjLkphUK+sqsvMVkFivpA0bsV1XAp611EAUU+IALHL/wBQRZEDOWLx44dMRLggXUX1MgWLVSqAMDLMN+POoEdHpx1oLXeBfUQaBA1/iBPGKYRA5+XKGBB6k3SEDIrP0jQRoOPirn+lZOhqCBZPSMdPmQYS/p2kNgDR+Ca1WyUSepcnz7yBYBRxvw4hUQKCSSgZJI/qCyHs6X3lxXREBEZGjo/vCOeJLAQ1v7xVUrEgY0QzY15r6yhiPVk8eo2CQYALoAfUDbXxSDOQA4ByOTIs12+5mt0QpYjhlk3UihQIFpljx2iC5Y4+rHMo8v237ShiQTsGkB28QIGQf/VMhv6fWBogDD1UAgQkD87QRjA4Yt4vVAX9YW61l0n+mMkyfST3hPpkFn6QRTKNA/zBFGRBCsjt2/7BiABJA4MuQMbxYyHpF9W/dy0XZo5Il48fzIij/wDX0kAuwz+8C/1OlnE9SJ1JEiGsh0glUKv5cC4A5LSB9pKAxBId4FJhlS6hlWIxaOlw/AkF7AoDxUg02dJa812hEyBIeOWjtygCBksQTltG/wAwBJOXScrFkAP2kzwbui9qiZEZwX6mTXA4iq03YxAOQ9KUIYkAABlE+/3imGXVkQNXxsfKjiLi/GWXuQyJCriRkAGSAbJ4EVGgBkTiQR+xkTjDA6mcfB6pVbxSB2rT5/zImIT0/wBw6uO3MdAAnQIDHMiqf1It7L4/iEXJEv6sQBxJJeRNLeoRDjmC8tR4NE2yg9yDTPT1dQZBa+OEOoA2XirkEyFbvlf79oQCDJxYIs64lK1iCgS8jz7yIjzRKI/zqFUO/V9JA3WO6IHyuYRcdZUix4kEBLYKA87lG8hV4sgfTxIg7TA3Al9J3kqIgVjbfZXIjSKol+BIJyiNfiA3kNrk/wDJRv2RW7kRnEkq6VedxUayIB7Hu24DELIhAm5KLoCij3gSgKTbJAEIukggzAf3a0ZBogPpO/lwgCjzrmBB/GvMg0ShZ153CAyXHbcASDiNdrgay26CFmRBniAHfh6kAfp7IalCjfG/aEVrFEgPvILkgdfnUgW0OO/EC43zqEAhesTxCKe35hR6dyIrtn6QgQCKOoAbWIR/EgX1K/eBrzAgScCsnmz51IgNIDmBTdGEB4I+okFBoDSMIovYH3gO/wDiBR+ZAP1feAVcCEOYFNnvICD7wgkduBef3kF43CKxvxAQAafECihIgH94FGz3kB3CA0dQH8QNcfzIhzAqkCBeOe0IcwAMI1IIPxAv0hAG1AsA5AgUSIv5hAGBYCAkRQYFkCEIFBgJEWAgIFhFEgQLCEiECiBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHjCWSyD3nuuiaGwW34kGAfVkMTz9pRUenx73AiYHqeWxx9ZRekpfqVJQazlW6IqVdXhDSsyAGyQnSXPiBGASRswq0k/pAiKojsLuAOJGiymu0ppiBvXqrzAZVkWUTQPLiDI3QOypRCEPeyRCtBi2SO8CZYgFHEJjjXvAg/SSEO5gEMgCx2fD8RwUgkVQ4uNGTj1NElbez4lWADAW1dQBpm7MELJfqTqFZJG6ZF1KAHqIBBHiBCAH1AgH0owrXpZsu5EB0nEYg9QHcfHKJZOQ6v0nbNiVQYnk0DzIFdbATFvzqpRjkIdOfYHXaVVxvFAk2CWW4qNdI6URva7yDLy6V1EgfU0ZYuQI6kekg2bEAGK9Lr6nvAhBAxrp5SgiHIhqi2Gwz4lxfF2erZVm5BA+jIACh6T+8CEHpePSBTJClDE49CAGPbZUBiyLXpHZyqLq/qdWTxy4APnVQJj1ZAPI067HxIqkUerEeexv5+JUQMBppp6MKvT6+phE/P2jfEZDBFgnv1Wn8qVUBJ/qdCHo0z/MfBenMDVitMAqNEGDxyB6f4+niNDgViUOVv4YEBHX0HEEilX3MKZmigcsjsF+/wC3zcsRoi0RnibrpXzUhAEqwwWRsAhRYKR1Dp5AQunIBAGGXQQLR53CH9TpIRR8k/tE2Az1ZC8lwrPz+YGsSCaJyJ21W5KjGJf9TIAZAE358S3iugHVgUWE+lTKIRj0gMhisspRcR/biXkKAJBqROJmMgNFgpgfHBGhYQ0BfBhFuz1BsIpKAGVkYsk13v4JMFJCN8vx+ZOmItI/RahGjgASBtW/4g1QgOo0zX1hDNAnAk+qv9xBAboUTQJhaZJC3/nmRGgqX2dyJWiMhkEGGD7efMCY+rEh+ChZgKIZJHBOn5X1hFN7IR99mDEGILApcPZ+CBoJANHvIBolbd3zBDeQfemdfP4hAk9i1cgq9ZTI8j8SoZem8gA6Ug0Di8qPP0kwAQFiGAOMoRKZB0DVQNAYgAtAEJQin9TXSee9yDOwGA3vgdpVXBKkP5kqN8Ki+e8gy/SnrhyjX6jYDvR5kQa2fAKgDwz5oyIWvyOYVrytDaUiJ/bldcVqBbIokALzCANIhHwIFxYBZ1CBT6sk+/EC4ju+frJQJFkkV8+e8C412B/tgVYgt8wiY8AEL58+kgP1kUANdoRoAqjqie0BiNh78bkAFK+EIRRksk3x4jAN0B6j3hGjtEXzbkED93qBStEgcCA/tJDA8CBTojj2kQGygYFBHHG71IIH1GkDz3lqNBEN7kCkkgfxAoHArzIhkCluUU/gDmRDvZbgAeBXEgvGjAMd4Roi0KK+8AD9bkA7W3AW+0IcVqQaXhfSENaIUAC8bgWlcgfz4gAvbtCKElAHmBR3kAvtIhyTqUUsXv2kRXZCgUeyUCe8ItbkFdyBenAD7Qi8eIEga95EPvAv5kC4FhDgwi7gBIGhAv5hAQLASCyICA5hFECwEBIiuBZAhCBRASIsBAQLCKDILASIQhAogUQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBA8cWC173PcdDGfSASae7lVXr+2BEgAz48wBKKIYGh2gU0CcdgbgCQbOoGSCD9OJVAiUw3Y5gCFogndQJkBYtctahU9L2gPP+frKNZZH38yDJA7ggaB5lAf+2V8VAuV/1EAKtQJniBhQZGy3LBASUTj+BqFUaBZIQXz5qERLAFEA+I+qyRkTTAI7a+VKANjkDStfLkAbAoHfmFO5s+Fo/HKBA6ssQQTvdwLkKBI/7BKhIJIdnX2gZzyI/ufB4+sqtEHILpapncghLJyHTex9ZQIbCum5FTMVbBB+8sEGOWVMLwKMooy6g/7gUnGCZLJ9KBxtHxEEx9YCwQBN+FBqkP0ix7gfmBAB1FgoeosKX4JrIEB0WfJqFUgFjzbDXaQQJZEYsMLvKK8RWPb59IEZ6TiQSXodlCpkum8gGFp8b8SgKLANnvuoKgIxyJy7N7YlP4uQvIZAnn3kUOIOOQVPW4RCSCHaZCqtfYyqmSOVDAgoZDniIIR1XiDkrbRETwDYoAXR/wDaxzGrDF9PSkeFjxAh6ScgUTZ/P/ZfQxZIAJGJ2g3q4KpAx0P/APK/YQHSBl19PUHV0PMaIccQUB8KRMKj9RAxOlWxe/eDAhAEk45H1Ei61AoDAzxzyNen594RrIhjLLEFGnx8MhjWTFAjpS6V+ISM45EYAY5FpFj8xVxrKsheJBOu8iMnLHHFnEXSHP8AmWeiksYk0EBRo+0JxTiMDjiRTC/3J0Dl05lIsgWfaMGsv0HpY9Jv59YiL17yLp/XmQxMsT3fH+pBcS8tkEEk1/MqGQxAok+9XJp6Hna8EljtADpfUcKHhc+IGsjkFv60VxIiUDTxI1AuJAByJareoFJ6v6hVq70/eE+BA6FiivCOzAoOZ3fKZKEiZFC6QVS0eN7+8AcV/THUOLD1H1OskHI3pXHiriSMu640vlxUUNgE0ma/mSqH0spE9+8I0ekk4jRBTFH6/OZBcggNa1IkGCSLuUTMZBkArVjcQ1oNEMANeZECWeponxAoZCGvHMhTMAD1bBpQhgOqzkSO73BVxZ49YPbiED6u4yGlHBcerIDqAAZNyBR9IRHIOoALqZFC7LuQOysJFwivFG1dkQKGASALOoGiUUlUiYhPSCDwXZ8QBIW8tKq4gAD+oAJwigjE64pQKQnyOPMgosFd6UiBfHq5lA5NF15FSYBsGgvPeAdIkBa9oMUEpEn3hBixdXqQUAk479vtCLQFL2kCgeodNwKSAQNf4hBkkirqAKQB3tiBUDiCO0grLcIp7g/4kEFAAMUpRTujz2kQaxaf0jBUSiQ/pAFAjSY+kiKy65PaAYIIY0oReob2eIBdjuQUWVyPMIFWhAp7r8SA+SIAuBfK12hAFAyC7yJEAbCH/YQAPiQaBXutQh/aNE8qATswA24DRs+8gv8AMIrZWpBTAAv6wgRzqBfc1ID8mEUGt1AGgoAJ3BVvRkRd0ZAD5gOe0Io71ACBW5EUagJA1AUtOVF8yIrgJBYD2hF8wEBIAgVyIQjTgICA5kRfECyBAQii4QkFgICBYRQZBYCEJEIFgWAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeOukOo7qlPcdCEUAhv7RohK6UQQOwlVNsltwIUNe+vzAqQrqPbmBDiTTIK0TLotkAA71IJogkj6SqGwR1B91EBk5DEf8ECZlKt8A1CwJLRF+TAjJY6We/H3lDHEkI4jz5jQrEPEt8QBBDIND/cAaPpe7K1KBGjkQWbXPhQagZY8O7+cwvEyKwbfeARZo4vk7+8AnZAHBD3AhZJBOJIPaVQsZdYvGkO30gRs2CVzqA/SiPazuFXqJYJHSdo6qVA3sijYXMiplizWWuAZTUyxOOCxyS4BuBP6pAAJ6i9A6iKoxAY6kqI0o0GkX6uRAmJPUSMckRUDRPrAJa7HxAhA0G/YfeUZQLAA1qxCgBPT0+H5+kDKDIAxQKv8AMooN9BNMkQLkQQMgeojkX84giEAt9J4DOyP41EBDEaCxRvnx+JTpaIR6RwDoyKhXSMiRVBDxKfTFdJJyWL1uuwgMc6R6QzqqimMA0scxRv8A52lVq+lEBAohihIJmQ+gonI7YClgueGJGJdkI18PaSUZKx3iQDsk9pcVQHmcSAeo0AI/gZYkZBv06vf+f9Qayf0lgA8yi4aAGIORFK0fEH6jGWYOfF2LgRDD+qRlb5Hyo+L01nZvZY1L8FCoPoBoDLY95EUHpyGJ9L4J13+kHxaGPSdW/PxxgEj+ngU8kNlR2p0DK6SCzZy5kVURiLAGRWv2EiByfR0ZZHaGn8EqJir5LdaEKpyR6R1B/P2kwVYj9GOIt7SI3HrKHHB9JIwyVfP8RtVpVjiD0sU5ABxYIyBJ5HMe8QyOJxOPUV37jvEGgcsv6nSDyyDxwo+In9TIgigzyvEhGj1A2vJVSHUByvEK9ZaH2jxFwBLZFcriBr+30A2bHAj+ohRyeBDGuasVCqS/06Jsv9oTFWLGT68gbq/rIiY8ogIEsdxFOGRWCBNHXmQUA2CABlVa+blFRKOSB7Ab8yIgJZAzK2DFVogv/wAuNtPuI/E/C2WKHeQAEAcV4Q7/AD8QKzvIvE7rxCKSDZyLFLvIBAJN637+ZUMscelA32HMgZEIHHFk8i4Gliy2SNyIP0jkg/SAD6iUL8wNdQ6xyuTIisEIM33jBNnXHI3BQDqOKrXvIGsjxoahFDBRas+0C9QIoa+ijBaH7CtSIMYtEBWB5g6G3WJ4kFNYu6r2gAcUcjt3CAyKs7NxTDEghAnfaEaLGyGDcghP9rBBqMGiAcQb83AAp0FyoxAfqTbP2gaVqitCREIPIv2gaxJ135kEf/s+8AKyNMcmBf7ue5hFFbHSNVakB3wuVYhF47iA/SD0jiEBsAFfmRV+ps33hDZAA+8ANnvyYAm1/Mg0+xHnxCBWj23ApVAlQgC0mfeQCiEioQH61rkwKXSuQWxzXJgL067ncC4++rhBhdjzIBRNMGBW/b95EWgk35gPc8QgdVsQKL2QXAvuSSJBKaZgUiurUIo5NKA4BgAfeQX6XCFOBSiO8iKeEICoDxIi8wK7UgOAEIvZ1AcwL+0iDjBZA1AsIcahFBCcBIEIsKOEWAcmCjcCyIQigwEBAcyIokFgIQgUFwhILAQECwigyCwEIkiLzAsCwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQPHH0knatT3XQox3YB5gVAIhjx94GCD7Ei1CtHEnJ94BBn0m9wMnhp93CgL2CUPtCBWIAG3VeJeiEgAjp+5hVsZNImAfPSTzfEDLBK21Q/aXFUukDwzxIBKquxfMCZAnLpx43csD0g9Q9gv2gDYS6faFEWSAr70Y0ZpUf4coCy2UeRdQGQIGPTkD4JO5RST1Ci9L5qQYx/VjXTwT3lVrHJ4AKuTpyImLyxNEskrvKqkAAANDjyJBM/IJeh3lgUDwt6v5uVUxHV+oF8+TFF/uKGt+JAKCrpHClGGiW2DfgeYwXDK+kD1OgR4hUrIld+JRPVlkH3qoBAFM8Pgd/nvA0cUEmr3+Lg1kF2/Y41KLmiiDfJJ1IQyJLos7AhYyBj0nIW91UoZAmtDyftChxOXqGLN3xLE0PfI14x3Iq7WIR/O4RnLFg4hZEl2/vLKqkA4lMJxDUJxxIQBWwP3g9Zy9Vg7OyLhZ4gSsLnEgGvP3lKrySfSMeO8GKccdX6gygnGjINgLosvLKMVrq0T0gnJ7v7wmJkS+vInwIVnYJJOIBr3+vEobxIAYvlivPEB/TxAI9ZOOQJ3uLRciMWX6wEPj7ynWWcQurqVGRVxGSRyAAtAb94RSrGJKDdUO3MADlkfSWMmD4EC5LHI5YmwH3bkRGuogEAbY1VRmq3QWSt2jrfz6wjnljl1DEmyLRXH5jR0yweZJQBF+B8+bkiao/UfQAzd8uBknEYXkEt3AoKBOWLoAkr94FPp9OIyF8cABf4k6gTkMchjiAB7x4Rcnjk8kMjvwJMSKDmLxAZR27+CBkZAkIEshg0H2+dpcGshltUECWf2kFJ0B/aQwm5IJkBnmccVWytwjbxJJAJL+xgTNl9SrkUvMC7PV1Yi2DuRMR45JN7DDccFHe0TYZEIuQAAOJRpjpgVlggAnTdSIyATlj1BAeN+ZVaxyPRj1D0//AEL+8mJhgXiirZAKR8wNvFBDVbqQTIo6BN74hFLB5XaQMQf7hYEUVoukvuowXI85f8kRkFFKmDUtguGR6jjrLf4kxFfUSOxsajggJOV5X72IFA9VA6DMDaAH9oG7EiagPViz6h5H+IKZHFBUKcg1kTyvNwgNMYl894EKJRON/BA0QTZQNon/ABCHkknsJBoWgNfaRGSAAgU++pRoog+HJAOSscbhMP1dxcBoWNjxUALO9aUg0U0Q65gMSSgaHi3CL1HpF89qgw7myez1IHDOuIQxZFCr4UCgY4o6HMgpKYG1UIgoellfmBobAORrQhAkP8bkDE9Ro+8UUoErf7yAyHSXEo1w07kRkjQN+TA0R6m9yIrRRIECMKmR7QKCgmPvAp7BffUIEZI9vaQU0d+TCHqGkO8CAsg/vA19qrzIKXSdahDeS0P3gV8q5AL0bgN357SAPYiEXyRCKbFN6owH1EgWw9CBQSAP2gMfJRhFb1IBJlFciKAYAd+JAf1hAOBRtQDsuEALkGh7QKfeREECk1AOBRqRBhwL7mQNQLCEC94QcgQGoRRAsAJAgakQhFFwEBAe0iKIFkCEIFcIsgQEBAsIoMgsBIiQiwLAsBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQPGlgNk+89x0IS7+/mUVgkj5uEDe67d5FQE8lnXvKobyfUB9TAiwXcdoETvIVAps0eLv52lA5FIB643AhDLyJPgdo1UfYn8feAQY4ECHItWXzKqj3H/8AJKQaC/wYRjJACyH95VQ5LLImwKUDXSjwu0aIAiSFXAOpRlkllXq4VQT0rZPeBFRRBxX2gEVRYI3pwGsbfp5OoEIJHVQXaVVxA9IDHd8wIuefPMAABiT1E87hYY5EIPqJ8VKliBHHpJ1S3CocSdk0qMGqDiNi+APeAIAJyBXNjY4/aBCg8hZIvhwrJOIIPSBl+8vVUdQR0D2HEeIpvE9RYOhuQQ4kfpYG6FHxLKJjiMgAUQrgVdWJGXSSRcDH9MpknJb3qWquGOGWQyJ/SPn8RuHqfrBJpHv57xxQBbJyRrRrmBoEUTiTywefaEZJBPqAZ4A0YVMjWSLJ2Fz7+JYAAbyxY1lVQpiT0nqTBOuTLYjWWOJ6TkaKArchrmOrLEDDpxyP78SrWgBlmyBZBdyABRIJBHC13lGShjjY0KB/hwrQ6gCRkChfsrMIyMiMQ8RXELgCSCQ1oYgK5cE/qDqOIuzoDfY+f9yzwaPGRZVAV38SEZxxOGFWcWwC6jq6IZf1Accubg4H1dPUhkLQSfEcRQcRiMsQByVVR6Rk+nTb5L+0C5MnqRePzn5+0DfUXlikLL1TNyVMCyFnXYLR+OQTB1ZyX6T4+GWi5dBy68jQ56e0RFxOPSxjr7VzJQxFsgVSAD+VAHFsmvSjSHzUDXVmQAGQEN9pExOkH1m/qgI0DkC9vRs2PnwQmKF1YlfbX2gD1dQWBR5auQaBYA6slppmEsaGWJD4Gi7FSGM5LpH6kBoHXiAJIyyyRNVA2F1sZW9N65kRMSLIyB71zAgJ6iyCcvx9PtKNY1iAKJ7mREojIg0RzuQaTFEpc873AJYkkfp0feoRNg5EsjtWoGwh0AjpAHezIAAWwx+IEwGHT6QyQ4ov9PIhDEk3ZJ5hLFxS6f20ZBMcbrY7fPeUaGXqSeR+fPeTEUpk2FakQKIYH30YE6jVWNIVBjSyCZN8DiBUh36pEMhYvWrXzcQMQCLNAW4oo0nautyDOHpfUPKlo1h0ksglD5/EiGKyooxgoWNI7oORGsSWD0g/vBQktkFnZhEPKb57OBQUWdgI+0gmJIG3aHntLg2UUTfHtMozeWI9S88SjYs3repAVWwT+YCkOSN1CLj4PxSAMsgIMGC++kTqMRcrOLBbq4FOgdnizIiBYg6YgUIkHT/MCnYxy2oFJYHeREApjvsQFm+0DTLIMiHuW4ExI4PkXcUa5aykQxNaii4vdmA99qBb8D3hCt0/Mgf/ANfxCKODuALJ4UgoWkVAr8VCIV2Fb8QLySPpIKE63AAgglmEBR5ZkFWhCHcojxA0Ax2rUgKjAnd7gaaT1CA1ADVDcgY8CEUSABA0y1zCDbMA2KgGSO8C695EX95BTuAH7QgDUAGIFx9pEA4F+kgoJhCBP3gaEICQWBO0I1AQEgogBIhCNbgIDiQOYRRAsgQhAohCQUQECwEIokFgIQkQECwLAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQPH6b0NT3HQpz4Nd4FyQJJPhQIwgd+8CdJGiWtEyiMXY8iFGtAgfeABRNV3hTI07ZDUIbsD6AyiCwBScA9JbuFKAokK/MBkde3eCKgyQF2gZFgojtCoQfUG6sGn8coDhXyfaBAhYBfvUBQYXpf3gUh5McHfHiUAymMTluBEQ2K4qFASQyOlji4DE2iWPxBWUsu/B8QqlZBEWKFwiBLy7EqmNI4hjY4+fWCsn9XTjvqTRlVTeXoBrRB2xCAPTmhQZNQqsdZz2Qw4ELZAAD24AgYY9hwHHSVnFdP9uPPwwofVn1Mo6vzKNZM+Dp9pCJTGeeVaoSw/iZvCyKWyN9oh1BihbPFeJRSfXfSeEn94GATgHZHNf5hetf3jLEJ0Fi0IPgmGdhmxr/cBgur0llptKCsdWZxRzYx+C5fFxccaZOQz963Gi5kYnqR2ixuIIOkdORAQP0HaNKPEoAXkDffzAEYCkQuFUs/0Z/qElPJDZPYSRWrIJBYsYkj5coI5ErEY5ciDjGCxDsEFhjj4Iq9VAJEZFWBtVAwOnQAyLtWb/wCy+jYstgo0CfP+zAhWP9Omenvz7fmBnJdZBSI/SfxBFNroCAyrm12X7Sn9a9GRRbOid/f6SenGADjfUwLALe9ynWh6RltWgB88yUGstlaPC+GKNZLEnIb8a1J0ZGdAgAENj4IMBjiMerEgD/24PG/n5j+ooy5By6m+UbP+4FJILAAG6KPzcmIoOWDVY8/vHSn9QhMb6R23EIuT/UQBkODr7/OIQwHUr0dKThTroEZenqv/ABGCkjpBRA7A8iEMjrWrrcixsWSUB2+siMhkbIdWPH8SiEC0f7ebBsb7wjQ3iQOeokj8fO0gDIaxxHUefn1gxdGg8Wx4+XApvKzzRP7qRFxJYBzHUbZEJYaOROQ7i7EgoORxeXItVAuB9UFZSLtck8iBoZA49OQx7ArUJgLQ5eu7kFxPIXdHiMSskvLpsDqo184hWiDllWIHYmtwignr5V0JBWicgH2fMIIlhgDmt+IFy6cQFvLQAkxImJHTZTGgKhVo5dR+XCNFkImtVxIiMYrPIk8S9FJONgsLi5AAQI3aiis45tn7aEiJeGPUGvtCtEkkG72jqEBpcvjv2gXEh0QA0z2kRkNJkgcGUaAxADXV3kFOSII2PMiLidEB94KDJoLjcCkj/wBT7gwjOfklDcQbFgkEgGvaQWybQMCYsDRBcVFoa48SCA8Dg8wNYrgqEGOlYgUV7wH93vqqkFZOqulCKEfT074hEAVhtaUKo5Iv6yIvc2VuAJ2RuQAT5YgPSqNcKVFHse7kopb/AIUgBhka7QGRp+IRp+b+8IY8WfvAjoG05MFJCtQgcvOoG9mQQeWIA/ZClCKHXiAs0JAsXA0rkQFUzAd/MIvF37wGJDkDyIGgeDzCH+dwAP0kEdrz3lGtm5EOZBQe0C/UwgTruYAatwLy5EOIFYF7MiBoOFXUIcwGg4F81IijUA5AEotakQcIrpyAIFcCQNCEICQUQEiLCLAQEiLACQWAhCBRcISCwEBAsIokFgSEWRCBYFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgePxyxOvcue46ErqARvcDIGXTfwQH91ZA743KKABiB0ldnUaiDQ7eaUKZEddBrYgCGK/1AiYex25hUstivJ8yjQAsDhW5Bg9PSkQvHMqrli2uBrUaJ0s92foIFtm0oA971xoQrP6tAL94FZYXT7GBMSOp9KqUCRo5L6JQBJb6QYEXqOqFOWALOTxGle18McC0iMvZQqBYkk0u58VAmJosEgUtwK/UAU9LiAOQIohvY/ZyqhB7e/f2gTpJIySDICLFxof1MqJFGoiwxyyGjiUOLcuCjdY0+S1IABN771Azl/aUN14+sodJI0tDWoDkFelr6wu/FXSmN8QM54lpDmiZYGYOgCBl+lD6xBnNn2VnlyxTMZdllpM2rhFPSQceugWmxJ6qEPHLHqXLcouTAxRA7E4/n3gZz9XpKxPsf9QQBAyI5J72YxVOIBBIYTrUqayq4BfBtd4VbGK1QLxrfwwBIGAxFE+PeD6DpaL7UYVnZ6iAfUyH8ZlAlDIhdKu2IFKReQ0EQfi1IJkD0l50OV37SkCC0AbtQqHHbZHgagUg4nLMoBdt/Llib8F6isRsj2P8A2F3wxxIPI6TRUBj1HF4jXsPf54j8Lms5A4kHFsu1ZhYWcQP6dMby4j+of0swcgF0oNLn7RYWGJPXiAAQbyuiIExx9AeQ2+3eLRogdQ6M8wwUTyIGgFiCMMDT8BH5+ZKgCqa/9gbQ/wCxRcsyf6g6dj7H/MmJngRT0UL01AY4nhkhHpP7fPMFMWciR0hlhDn/AJBWgcbSWICK+KRGSaXRrgHn53gxrIDLqPpFc63UQQYgkkclZP8AxGovOTJp64MCj1dWWyBdq/YScAvI2SD2+lOQUZHrHqRP+oSrjlk+rKgt6qDDI305dQ7+PtCDz6mD9xuF8V+os1w7/HeEq4kg5HIgBUHx7yVM0DSIt1YkECAORSGinxxKLgQASsaJBvUUUGwb8HgSB19Q6LN8BRxMaRIY0JA6LGRTJPCUaiZ5MED9VMCFaByFdRNVS/eEUWXj0gEupBQC7bAsGEZb6TiRvgUIF3RyHm/zIKwwWNpdjCK+lWC5DpljdEMtIblDJn60nqBMi640RILliVYAPtUIrxaD+0gIEHF1uhcI0dADI9qMCFlDJ+/EC6KI2ey5kRcliWVq3UBsLd8CAR6QCGKMIr9Ixu5BaFkV34jADCy88iEDyQvtA0Ui7oE1IIQADvx5gXZpXIgdE7HvKNaeQLriRKcvypAxTN894FDI2l3MIHiA2OkenvAY5s3sDvGGKH1Ymu+pEMQOlN+FAFPRA94GgTwRrtIgPt3WoA5E5e0CkMXIArsD51CLfJNwKDvciISdUVKrRtksVIgBz9zCJyXcDQILNfvJwTzkV/ECjfPvCKCdmAPke6MgW9kQLy5EUUyeYDjiEBTgUOz/ABIL5/MACwuPMUWRBcvcBk9K4FEIu7PMgCoD7uEUQEC6UiB9zAu/5kCAPkwgx2gULXHaBdyIQLIHMIQiwK4BqQW4Q8wLAQG5Aga9pEIRQoDiAkQgUGBZAhCBRIhAsBAQLCKDIECyIQgIFgWAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHjUH1NT3HQtYliu1f4gXEHLhCQZKvk++pQBINpdPEBXUdWdSic/wD1+0BsNgBfeRVy/wDk68qEZyoMGpY0gBSVkniEUjbOxCpllikB2P03KkAyKBH2hUDeVcd4FAHYgm/eKahxyIbN9r/MuqLsTf8Ad2kDY6KgZyvM49RfJUv6RQwUx39oAWDRNoGBMllT6e1SxQj0q6G+YBHsBjwODAgFsrpyOqgU/p6dciACxVAeSY6FMVkAR/uUZ6sltIbJYhS0Sgzo6cBiXkLJKd8QJiQUFkANIcf5lVWWeo3r6SCFY5DgkpASpExRIaDVjkQp07OJDrRgXIgbDLoLmFjLtGg0DtDuJRDXSjs2i/aBR0vXN/PnEC5g5FIkPcEZ6bJurHiAAxxzOWRriXqpi8Cz3Ghz2g6De2OQ3wJBOr0+vEgLvr4oUzxSORBCJRLcsonUBgSjyQFuvBlT6oBsk5VW/wCO0irmAcn0gGlEIyjkzkT0hhbBU0L1ZpE4nEU4E4ZB8187SKDqD6QcwRR7jgfvKeA9I9RBoF7PyoKzi6ACCp7BUUA30kF6ITBGn+JVMeof1CARZ0vNR8RrpyIBY6bIQsjcnhrICL6AAEQv7l7/AFlXqZfopga/T9U4ImYQ4JFgC395SKt5INqzvzIrAGJPWAyQglfn/Uv4N4l4mjiSKfB7eJMStYhgZZEY9T5Tg34AjJoAk8qpOGIzhlZYGPqpc8y4dUEDItomwqW/ntIgNngsPIQKMgbyyXYJfeQ43mBnWOxwQ4ic6xmjiCGREVcRl0gVZNg+TFRUC76mKVyCZf1GekDkE8ruIxJFxJON9IA7ZUv53FFHUOrqA1shwigIAHHEVJQOAyxTZ7A0+aMaHp6Sj6CE3woGnfSa5fz6yIySDkQOrp79/rKKLyrJ0yJAxLB81ZsRg3l6iRkMr7fvIiH9PSLxAW/nxQKQeo5ZFEWIRQD1dTKdjtJ4B/SAwsmjviEBkMekelDYFqBrE9RB6QeDeuYsGQ9dQCHH4qBsdWWO29O/rIif07yFEVdxSjS68SAO514gWg2fnEgpKy0SWj29v3hFDeLdmjAiBG+AqTEg0ciCaJLkRl2RlolV2lMXIIY/nYgaBIOqBkQyvt0k8wC3XP2MC4gDLqAOT1IIHiQvUyOVcIo2UvI7wGJPTeIPdQKkQRtGvMiAJ6f0spj7SlUYiyRfvIKSz7pSIDFkkh7FSmnURvKteY6mLoWPe5AFfpI8MwKKFEkJoSCB+AF9oFxfV57wih9ZIJ3A0EUep+JETySKRHEClnGn7SAQf7bI0qgGAGwD7QgAdos64gUF4njh+ZMGsUQCTuEAWPfkyBo0yhKGJ9VfiRFF125gAXtk9oGijWpEQ619IU/t2E4RoImu0ghyL7f5lRQ/7t+0goBDutVCGlYkFQPv3gK0q7QLyjqESnr0wLzzr7yAP34UDWzYBkQ48LtAHZZv9oRQEXzAvHvID7fVQKD7eYRB78QNAUnIJjvS7yg1tSIuoF5q73Iih8/8gKO4B7UBzciKeIFcgsCcmEXyIAVqBZEA+YFMgWpUUcyA4RRcgQECwhAsBIA3A0FIh9YRdwEBxIAhFBkFEAIQgWEJBYCBYCEUGQIFkQhAQLAsBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBA8hiCBxXie26BGLG7ZhUYrtw5QBAx8bEATvlizKGmtCmZAsa/MDKt4h+4lUJLYPPEBkwEg+BAZADEonwogYi2EPrxAyh1GgO8qrWWgH2ECg9VfW+8CMP1OAIsH/ABAgA0frKulkOiX5gTIPFfp+tQICqYegoUPSEUuER8+KEaOSN8feBNIL7L5/yVWCzl6t5QNPuR5UCEjqGIyoapfNwIQMSe1NbMDRBBP9obPT3jRlDQJLXvC6deXUlb0Nr6S4LskgEA2hAxmG8TkwNotSxVIZ1viBT1hZJAnW35hPA5E5dPSd1fEYMc/qA6QNw0Aj1Gy+dwLRDPJ26g1Cy7NBd5QHVfN3ipA/t9RBy7dvaU+shq9ksrRMqtLpAR9I8oyJ1MQekshgsE/t+0qoDkN4keF88faBrIEkgEYjwVY+fiEQZg8ixTPi/PMYrIXULICe17wqhokaY3Az1BDoPh/PrKNsY5+k5E2SrhPjOQBpAo89vijVQ+k+pm0vqYVlojIYDyU5Rr09OiAK0/pX7SCkLL/1BHC7agYOROQIC2exMsimIyGWVX2W/pxAmCx9RPpN6gMwAchZYqn95YRQTiSwRiAzseTcFMX0gDfK5d7gZOOJwI6hkh/cLjVaxHSOnrJIHGwB7+YRnEi1i8W/eFBkAWQcQknr4YwAenA0TyjxGaNDLq/SWCCGrPj9oxFJxxeQIwDQ7ntIAf8AY8XyLfH+IT+p6gXj6OGdv4IFI6ywSST249vrAZ9QKB9RDfb5UkFz6eg1s89/aIjWK6n1Ac64+CQZPpzyGSHcEOXDrQyOR/8Ardj58UmI1jlwVir9jCYnUAWQCL5gxfSweofcmQMUx32St/mAANnlv9OoopWQ9SZCr/H2kRB1BA9RZ6QSKgaOX6T08+9RgpJFgNdv3cIrNCiB7j5zIMH9YGQvL5uUbFos5L+f+zKB/UlkKp/iBSmUOoVQpwLkiSSQVviEQdKXB7nRgQ5Z9WwS34H3jBvZORAD41MiHHddWI3X7SjQ9WWw/wAQgskCCPYHiEUHMlIIl+AJLIIUMrJB48woNZIbkTGgQQ6RLcYgmSEfAgVHFsojjQMGgKxLLPJMdADTN9+8g0hxYHG4RMUiH5cgA5AM/g1A1ksiQch7QiDMaJTHI8RiYos64Z5kVQ0ToNwiNgAAi4Gh+r0A1u4RdtaBcgn6ShdwDy3/ANMI06sfSQU/q3vjvAy8jkPvA0AQSTR+bhDH0rK4FyFlA3IApk2ALhFGhj2kErpIDHvA1j0pC4RBlzxAoLtDtUgXiKF9oFBfgHgwi5HksXQkDYHA8VAH3Q1UqFG35ZPEguQKQP1kFJCVMwijfPeALBLf05gUF793CAPBPHEmGDR4hFqq/ECjhCvEgD3P3gXYu4RBVDkrcCsp/tIKymLEAOFIhyORAvGq8wgd6qBrZr8yAfr9YD6QiX3ga4ZUgEfDzKKCz57yIdruBQ3vzIhzowLAA1AbMiL+8CjUgDXeBR3hAfWAHvAtM7kQB94FkCENwK74hFgPaQLUIrgWoEuBZABVwNGRk8wLAQEiAgUXAsgQhAouEIFEgQECwiyCwEIkiKDAsCwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQPH8gAWrntugAF6TAg8DqXfmUXkk67yKmggEuZQyAT32EQXEUEyBAyQTwV1MuURECvYowrRBtiQZRIYs+TKBQesqUBmQdgE8mCJydBoSqDEsvenBocQWtcXAgZyAQ3xKLr6DtIBIFkm6hSsR3PDgTJ9LurVlyif2nt2UBiR0P+3etwIyWAH/yFTP0i1XO5YKCP08dxAF0CRf1gQkYpZH3AgC2KAZ2acCMdJ0Rwx87yiotdKH7yLpliUQLf4lAnLoxJIL4AuBmh79xblUxvQVraijWJQAaAFnfEgySCeojEJqUQEF7I747gZSKAIXHClVpIhZAGxu5DU/qUCSaSuXfhFx0v10loGCrRxAFGxfvAziQMuk+mqpAwI8QFib8jSlEH6d0TT1pwoBzVjagQgDIIPLf0+sRa2yCVi3TH+Pm4ZTKiQ6BPUYVOk40ASF2t+ZeroHiWd6QO5BCRiCByEQNfLlIhy6ScgOnIUjyJQzxHSCyMcf2/yYlA4gEC68/5kWAoEInItMWENSgiGCSOWv3kEz6suoF4nLvUs8ESwBbx2gb4+fWU31odWVkZH24kXjGYTAXqF+ruZZRSSP1D1I2IVknqAIsUNV9VA0j1Y4pIBnV63CanQcfTkD00qBg1MAQCP6ddNgnZlL+tAgZPIsN+ef8Acgnq/Qvbk/KhWslkGH1E0zo9vMM+rgcUEkP/AGPEgycSCSUAMmu6Mp0GFdO0x9JNVslVkcUdXIymOPpYIGQ5I8Xf2l0+q+kHoZpFhbkFyz68a9QTJv7xmJxkkbaGRAFBKM1WscQOpkENA/PeSopGJ9SAeifeBB1HIW8QWaWoRok4BWAAi+fEdDqxQyCLKqTBrqGOIxFk65kwTLEjEkBZYh0r95UVvHIh7RA505D6Y5PDqAKNgdzFRMSSSMVXnVfiMWrmenFCwe2zCHULw2NEfvJgpIFHMnuv9wikhhDMrnm/n7QLkSU8lfuZBGQCEfA7CqlGgMmiAA6AmUCASRiRbfwwNHq6MSyS9GERcAE8doUBBKPSCCQXuKjQ0BaWxzUiIMm8ifqBGKrBD6eodjRhEt0NDfCjCqQArITGvtIi5ckA9qDgxoBAK1Q6oQBAxGB9PHz7SC4n1Ig9hAjCQBA/aMEFYvQJqBrHuylxIgSMSBo7sqINPLdLTO4QJG3QfO5AI6aFePMAAskwctSB1drf5+XKissoLIdhxAuSOLOhIh6aAVQAKCH9z5qBQltjwZALLBp7UAOnpBBfiEaAJuj3cgmXYK/G7gW9UVCDYBuQU7AJqt8mEUBcgjwYDg/2rUCgj9QZG1IJemhA0wRSBcJhiRxS8SAr3y6lDp4+GQaaP+pEAGEyIF3WLhBkimoAk7LswKENGjqEX8EyCAEnn6wi+1+1wKCwCBIK0EIDIFXvi4Q4J5gAfT1SAGSf8QKfEiDvVQLVbhAnsAveBSRV04C9d4Gg3tyIb1IH9oW4D5cCgwijXiQAebgW+30MIbgKgXfmRAeKhFfBkUG9QiuBOIFBgU7UiL9YCQWEBuoB3CLcBIHMIsCwEBxIKJEWENQLuAgJEIFBkFgIQECwhAsgQECwiyCwEiEICBYFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB482B6mPee26AJNsscQBayAJauAVkWvuZVOxX1kGRQJPBlFAAyX4MAd3ppmBMnRGSfiWCHZ6kuPHiFUdqfbvILiX9YGaxFFY3sblE2AE1qFXp0h7XUIZBkENj+2pdIjSJIAt1ULWQSQgifuJcABAekhWoFIJIAo3uRVyPVkL8FfzCM5EALFtMyqoQx6SlwdOBF0lhBt+YBjK9p0o4BHYc3Uqp036gL1cFAO7B3uBlAgOvPMK0105Gy9mEOpnyWQH8uDEQXpBf01zKHW0OkgDm/rC4mXfqo7R/MDK52CG34lVf6bIVjgeIpUCFUCeDAub6cVuxS3EIn6cWOPPfjtEKujeQT51r/MCYuzgW+G18/iF/qisQTYdb3AySSWVza5lF5BDBfPeBkeoXQFUVCpisv6YLQaAcooCA2Ge8gmSIGRRyI5AMvAwOhl+np297ii/1ADgRjbDxCcTpKn9oyJJIHFglShigDkgMnZkE6VYAoEDwuZdUyyRyzFUySLUfhAYUnul3+XGlZ6G2UO44l1dDikAiBWN/zJotBDpQIYMCBAZFFbN1qUQ4joxyxQKPHz7yjWKBolUOxJkDEtFP3P6exgrJTyfpL/jcqgXUEQR4HJ94EyAKLP8A/Ya/3AZAg5cs0F9/5hYhxOWGWILYonR9pUEA+kemkAVv8SKpJWLXkU38UIgBxGRIZxN153HVdMEMuw17+5kZqH0kZPpxfG1EWp/UFYl5B3R1ABgkknIE9uf8QjYquRykyvn4kqLgS8VRJgrORxx74gEr+YwXqP6fNE7EGNAX6QAtf/P0kRMlnkDjeY7ZQcUZGj6inoMyFiYj+ovSDiUR1AKa8QBOIaAOP/14kFrPkBNnY+VJwbJGWWJPHlJ/vImJmfSRjiaxZP1gVgYdJvBpEfvHopIB6hkt/PrAgyBvRsb3GGNEutI3IgAQbRf4hL6oAQYvcgyADj6hQ7b1A0+kYlc+6gBk8q5ZYH4hMa2OkDp9zAnVkSAcaHFbgwyGJXJNHv7SegAFsEJ3xAv9JkEZfZyVKA968gMOUXM1iGOQLUmIqIBWwj85gUHEItAlv6SIYAn9JRP2+kH9XEgAEI32EFT1MhnZH1gUGupJeWIRRY9Q9qkVMEcQSCzWoqVQPHNgSCg+kEEvxCGPpRN4paii5EHEjH+4VIAQwaZAQOrlRccvSQxu1IYqKretSASbIdWoRQB3vVQIACCSWPECrsa4kRWRxS+sANE9IgD+kbBgaCelwjCGJNIDzIUJT6vpArsIn9twgtUb3zIBonyYIIEEaevMIqZJACPioFurLHFyIiIB5I1CtAhv6CEDR+uhIGQCDG9ygkXZZ5795EaFlPUYA4cgZVsHwBCF6gaCJNyIH1dmOVKA4Qa8yFFkkde8IBgceCoF33XiQaBarUGIWiKCEI0GBypBCQ+XAA96gabK7G5EBXPvAuoRBrv4gasJfaQH/mBd1UIM94Ciu8AP41AuPmRD7wKdD7akDjtCKCNwAvlGBQakqHMC8OpA94AWIRYAaUCipEVv6wHECupEFCD3AtSBAQLcIsBASCgwhIiwLAQEiLAsgQEIcwLCECyBAsIQKC5BYCREhFgWBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB5HJ3rxPbe+HfNSKlAAMvwJQGjte0CE3rdtSqEnLF4iztXAzRxVsQG2TftKLldF+w/eQUBjjeoErqbPtAhbIoLR2ZQIeyDW15jRCtofy6hTRNo+YDFB0B7QH6SOOHKqE5EAA+y5gAiLABf/YoLEZEUoAIAW34hULZGuIAtACw97fmUYWTPpBDUo1l08YogmQMV1kkbI+/tKDJBvwSIUy/TQtaJUIziQjkaxrmKp1FHI++384jBcQNAkHViBGmfVsm7gRph8q9yqEIjLqVuzqAKBdIi37wACZDYCEarKJQo9Xn+JRogFPHSP7RqIXkSRTQHmFTHEnpYIXH4iij9fp6qL351BeMgLEA09ri5dVd+oNtr+ZAQ6ekOydwJkeodLtC+0piAILHI29H/MqqsgSOX8/iRNMekB4gMqgdS0ZNm9PvXP8AuFLHTQoQqf3Lq9IFj6wA9WBKQdoSjYsLHY54mUYFIkkAkujKoAcf/VtwJgCR0sC2187TVEyYLSxoN12kihyCA52fN/tKRcih0gkHVX9V9YEZOQBo+3Py5BpANn1co0fb5xLoyGEQSxs42Ofn1gXPDI/qSX4/iNGcgckMWqA9/jli6ZZFlZnlVcGNFf8AkIQrd6Pt9Y+DKCGPRnlw/wDcGoBkASsqauFDlkCOOq933gxSc88AgsrHY/mPE4xRxOIxLHsPhl/VaHUSSnlq6L5/eSouQZv1cldh/Mg0NF53sfn44S9X0jN9JGQPFSIhRyOPUOkkADEa+f4lFKYeZNDZsI6gDnVkM0gFdMyYKgMj92A5BQSBkwMgmKhEBAIRCoV89oAsp5FAUWtwNYGukkV40jFQ6gM0yiAq1ILh09OKBJMghFkE/wC4FZKGJQ47r2hGQMxk+rEs8/vqXzBvIgh9ONc0pEMP1nIAFkMj94ot5Yq+33kFJeNdL9mIGcMgB1lIqhFiNA5HEnZ3TuQax6Cxrg2049SoPQaxRbQMKDqAIRQOlw+8VFPS6N7KHz4ZBSfUMhvRWzCAV8FVcigROKyF18+8qNHhqkfr8cgl5G6egPrvtCLiLDT8SUVPNIA7A73+0HxkAdIBLCLuBrhkI8X894RQAkMeb8QBPUFwRcgAAoAbHtAo2QCN/aSorA2hkdsKEOQT3qAGwiCQOIALqpoCBQ8sCSOdQjWKy9OP3kKiARtcyC/p0fcqEMQ6ZHPmWhk2zr8yCslDpNQgVWI3qu0CtkXr8VIKEGN8PvCFUe3OoFI28q7fxIBDXbQcIEi7NwNf3GRAaQxBHvCpoElfeEVkFVfAgU3gGQPeREZRCFdzKqgZLyauRF3595BQlb7wi86viA2dkgwHpFeNQgyRyTrxILoq5BQTdvmER2m1xKpRF6kRoHYZMIA+o7/xAoIQr7yBs9+0Bs9oQR7wNEt3qQMW/wAQhsSCutmDAE/qRJhAPpJ3A0CDxIH2gLEIvKUAfEBQ8SAF/mEV+YAXs7kGgFZ+8ICzsQAgXi9yIA/aBdyBAsIOABgX6yIDcC8XAoLqRCA/aBfEIeZAuEXxAsBASCyIu4Q+kCwEBIh+YF2JAgWEBAsiLAQECwhAokFgSRFhAGBYFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeRIpgXPbe+jRJIZgAwRdcwpkDoPxcAA737wIdWzzuVURur/eBbJFgkX8+sIyiAUT2MKp/V7DValBko1IMljXFyqEeq24DJIoincQUp6XYwM4k5MBLVXLRAAmN8r5UBkFim3qFijXD0YGf7h1SjWStV2kIV6CO1QMkrs1CqLBvwIGc0AqD4FzUDHZWQxH+IFNK/PeQYaIsImkJeqqByGOIY+8CglABAGnAIDQF7Cv8AxAmIL7nV6hQZHLQ8fmETKsyRtyrOIaOmQQSoFyATI17xBFiSsRu6MaqYggjZFFnvKKDicvTkEP7r94RMxn0pXqguI8WGIayBsbZuBQAMMrD4HFwJkQRp1yNe/wA5lihBx9LbZrmCJiPScsVQVx/Qti8W6EQQVi1/ddblA4nIEpnpVnfP8xpwyxKs34OvIk0lRDrIG4+NIXicvSVrW5cTWyg8cggDa57XB1zwAGQWayS7e8urfQoYks9l/iQXgtCuS3LiKUT1aHSn2jVTMLIE0Bsv8waozS6mFbPtBjHpxIyAJVApyqaJxyAxXa3xA1kLPTicrZkP6yRjkD1JEOWKmb5ST92e8AyMaALG8n+0qYZj0ILq4YHzxEX1Oo4sm/cd3QgyKunILIAY7XO/igZ/qDHJgHHSFaiK0Eur9PnJG+IKygMbHUETf0/j95fQR6SSg6BNv3hGvUCAciCGWeEP83IdRA4EgkdNG/nmD6pXXu//AORS0pPhDHI5L1BpVxFgqyP6WgGN37D7Qm4EPLpNvy67fiAyyBxyGBNEruYRs5DInRDoizx/iRGcDlmd0aBSJ9ovigA6bfUd0uX9fpKi5IYgYgkHXhzP0jWJ9Nd0wNwMis72LK/mBvMgsloj7bqRGhfQQOmgOaMIyepEDa7SK1giCyT28KKjORBS9T/9R+8C4rLJkm//AF5XP7SopQSv2kVGerH9RZ12hGgWQqx7tKQBlQsDHRChMbXYEHkf7kRnELVOmYVRlll2B4/n9oqLk+opgtv7QQR/ttEXoH44FyXS0K4Q+0gpWRQA7lj95EZwCyACHK5BlKrxL3jiL1CLkMiBj1PiyIOGABAI9KmaNYkDDJHfIEIdT1tX4ECkAIAsWv8AECCxRWSQHiBQb/VGA6AG3Qex3kxFCIo4ikIAgKyD3kFQ6ziku8ARkCUGCe8I0cgKKyDrsYTExxDDGUimsWBv8wiigu+kIRWzfZKQUp+3AEAMiF1ChYO+IxMGrA9j4gP07SHaBrI36enbsyAwd2+FAhP/ANMJQisgVVbTMDRvFAyIjyxa2T94F9LBBoQBRexxILiQto+IQGvSjUAkLKZQXEiKFr31AUQe4r3gCup88VJ8FHYk9oFTsfTvCHKqBCQQaT1A2Cz3kRMWTZNmgeYFCOKP5MIuwsQ3ADS8yCD9Q5UI0S3W+IF2tOQD2fFXAo0SfzAH2J94RAQTdyDRKgTmh7wjXN0JAejcIvH+6gAEVqQA3ZuUU8/vIh7GgeYFb0bkF59oEG4RXZYPtApHDkQH7QLxzcAGdQL7SID7GBafMgQA1uEX8wA34gU72JEVyBAfvCLCAMCyADAQi/mBYCAkFZUIpkQ1AvmAgJEBA1IEBCECwhILAQLCECiQWAkRIRQYFgWAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHkS+PbU9t75kCh45gRId3ChFoAKAI3X31AdkF76+VAhvEV5hTIoMi/eUTGyfTu4ETytVvxKNZABsIvfaER9js1IqBiyHXEKDF6AY0jKA0EBAhYKoLUCUU3CgIGI1wpUL6li1CoBqgz2MC13IgQEgdVkjjvKGJYGRZXFwoBSftIISRoBWqgZKBPSSCNbqaVenLLIaHcSbEBZ0i9H8wBLCAQI3KqdI4SfbcDRIIrKuX2gZbIvHuS5Q9PUEwRY/eQEcgQa+tnxHBMvSK6iCeKUvVBillbGwdGNFDL6hkHzBamSxyYBK5ULPUAYIXqOg/glQyAVEsFNQrJ6yD0LVoK48FxyAxaB4TgUA44+VsjiQZskngWAB8uaUIOJBWJyBtcQdMRYZ9TRgZA0Xx6TAoGIGqG/wDEarRGAohg+3vqIz6zn+pk2NyrDJDpbDqvrCoOk4ZEgACwO0fRBmD0g8jg6cYKildcHgr+IDIsY5M4jt2lxYmR5xBJbY/MQTKvXokeoPtH4Rf1DLEAgaGXz2gREiliAFf7doEFt4vEFLZhUxCxJXsCHQ7SgAjeZGQ3XncCEY9JA6WfHjcqr1H9IOJZTf8AEC5DIGmCda18/wCyCf1MT0jSxVg32llInT0D0ijxkO5/Ebo1kCxoDel9fnmCJ01kQADxkL9oNQAgg9IwHBHwwKWcV0+rfwwuGeQxxYGLFPXv9dx1In9MZEk5ABWfBPwS01cPVl1WRjyQ/qJKNf1CPUKyJysg/PP28yYkQF6dnS19tQpiwOrZXPMiNDHqCeJQqtVGgDlSIB0jfEIWcyG1QQcACCP00C/9yBjkgEwa0LcuGLvOiN9/pIhgOpCieUPnaQrXoYNh9j9f8wnrODxDXr4ezL0q4EZAZJ5Duvm5L4NAaxu9CQCctg7ZUIzvLLpxI8gatSjfQcswTkBsLgyaAZN+kk/QqAOfUN0RGI0cTtFOh/P4kTQnHpG8R27yCdQYZVc42ZTGniSKXLepAAGQ6SvYDnmVKZLEPpCJsHiQXHEBZALIcjn5UltGkdZgI+YQyovHGpFQEH0kjqPJMqcXIdWKAKBVniIIssmASKtwjWORAf8Ad2IkMaFYIFfX8SIyjeR4BXChVukRkjtbhAIIGyDuETFd6OvEVWqHavz8cg3QpMGRlCLYBIHaAPDD4K4gUH0ZZZe8CY5UGGDutGMRr8fXcgZaBy3yIDJqhWzEA1wBkBdQjQZeKQfG5AAKZpDiEpiw6FHUBiwCq8AwCAotjzILZCDuAZYxB2e1wimynfvqQazFAE0KAMIn6bFA78wNGyLPtIB0br4oDaJIPZQiskAOAyyYKLIhMMQXZkDHb0PfcUaJ4Fs/eREF8b5hVFaNwigMbP1kC6tGAGzZ+8IrO1IDPYuVFF5cQA0GT5chVp2NwiBgLR4gXE12MgoTXPvAXsFGBUS6+sIqDByPgSCa333Arq4RfP8AMgpPj7QiNUWBAr8SCge5gCeQt3CKNcVILraMAW4Adv4hBOlAJizx3kRQwPMC0oBQL7fmRAdu0Cj23IDga9oRF2gV/WADRMiAJ/zAsgfvKimQIRZAgIF1CL9ICAkFhFMiGoFgICRFECyAICEVwEiECwECwhAsgsBIhCA7QLAsBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBA8jkEWSdT2nvmV5L9uZQy0iMgSKgMrAI/MgyT6aq+O8qqOEZBQqNsSjCBHLO+ZVaC7tyDOO0GBxalEDAGn5HMDWhsAgfeETxf2hTH/9YQPkxRkvfbvKoKBJKdOAyopLwoAH1Mc1CgAFo3CBWIIafMsVjG7RAHJEopbD50XqQTPFXjXPvKKGSxZPnX+IVSAAMiT/ALkRGaI6QDtyqmdDHnzoQGV8qyoDLEEPEfxBqHIpMu/SXKuBfTYsXqoA4jIo5MmwoGQushQrV4o6D7CETO2BsnW4Am6KH7iVUHqJZyoXUHDLqOQINEfaBAGdAWtalVeraVHkoKMQxPoS/PiSqZDZ8NkioGC6Fob7yqpOtZB2HviEwyIxBAYt0qHxywZITAPqIsLhQqgUOKr0wBxwJFEkA7NfKjQaxVsfi/8AsoY5EDpwLIXiuI/aYmJYyLDWm5FAMh6SGCdLfy5RlFHEC2xWu8C5JYhgEGqkVAVgeslrZHNzQoIyYJxHcP3kzAN9OY579vn7wILWQeJG6v6/OJT8MASF6hqFTIuwMiDerUIznkiGPW2iNqVYp6iCaJ5HTs/P5gMb/phZaHHNxRCCcwLovz94lVMhjjn1A7DokkmX2i/1L/qB6dE/zEF/qfpOOeAZHBaqEn4FHpGsqCd1CxnInLBAHIkhL94kOL6aIpDfaFXBLEjFo0R/j2hKxiukAYgHJshB/P5iq2OkEDF3CM4i/UABW+4/aBoDLEYgZZdWhyR5gU9IwokdOLBA34+d5ERgEAuyUeq9+IVrGv6OIIAQtmKn1CMij9Rz895BCsMScnzifn1lG8uo5dI2mADSkxP0DObAN9xuQQHEIrENgh7gayIGBBZwNuIiY9RvIELVs7iikF2QjRPbj6QmmeLSeuDzEFGNcMiyakGvShkAyf8A6fG/3kROrJA9SBbgXMoBBgEhm1XMQM1k2RsldoOLkBkOqsS+fniRE3VjIXoIQNeoY7Z7gtwL0jI9JeTu/Hz8QymN5n00995FaLxAyJIDpH54hEzDvT5FCFVsuxdIKpETEgktmv8A23LhWiDll1A7FuTQDJRJF3ArrIg6OzwIxkxZwSC4qSq0abpjzIjJBejWx5lFBvE4m395ExrJ2BiSi9mIMlB441kfNGoGuwyJ131CLiiQsRTvcUDWKSX48/b95AGX9oJHk/tBhhbVHwJBr1Yq6feEZsvFq3xUDewNlGipBH0YkZBV3uXqdUF1kee2/lSYVdjEivA7SIBnYIXaBccdek8QaWdY+VCGXU0j1DncAOrgkn95BQHgAXQgBZ8eNOAy6QRQ1pQin9f1XdRg1kSkekvkCRIEhAGv2gCyF+9SA/pUDWJBQp/mES1iCN94GmNJPvIiDbJgUCgB+DApXTo0KkEJGilAorAAqthQhvRH0gNCgzqpBognJfmEAyXIKDQP8SoGhoqQMQUz9hFBWmbowikA+8gvG1AtKgHAnAJJhFJqtD8QKeX54kA2GahD9+7kF0E4FQaUIBuBTp7kAjvAbN32hDHeh+YFomQBtHcovBkQDUg13hEv7QLdQKedQIe0iLA1+JESxUKeNQig7gX6yIQLxIGqTgH3lRdqRAeYFEgfaAuBYRYCAMgvMiKfeEHAsBAsiAqBZAgIQECwiyBAQLCEDUgQEiEIAwLAsBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEDyJAJ/ZT2nvlAkm+YA2Pp7ygOHscwoe+q9lIM0U0j+ZRaFivrUCZEePSaiCM0VY4HMqrSvvIIeoUyJQdarmAyTREC5aJP1EDII0C6r2lVCNsjfMCt4sLE/vAgJ1b1qAABJoAHUCZPKgQB2UopICLC8/vCxEUGSCLPkwA8P3ECZslWQ/vCwPpxCDWzqANBFb/ECEP+mtEm3uXT6uQBDAC9v8QJkSsfIgKJ3sQMkKiU0QdSqpJGTOXTSL/eADAJRPI6faBGSByKo3ADJkMUKXn2gxLBY412hTo8Igfp+sumln9JdbBgS7y6WfB/iUaxRFkEbIfeQZw6kC1ZX0Mq06qZT939YwXIrLkAv7x0jH9TIhEIAaexEhF6qdkW17QYwnkDY7E+ZWmmSMielkD3IhMMSCAiMa3oGBWSXl0i0jzAzkljllrTS+sBj02Sd3RUtDI0cgCcQXr53kUxDxfSuAjZ8uWhjkCAAALdeIGciM8n0skgF3BwGJyDVDLvrUqgJAA9LaqiIoo0bo0SK+/wDiRE6igdYstblXEvpJHVjw9SjTYKJA0ff3kELAxWSJFGFnqHJ5dTBxNcn5qXA6UBjWLIa7wM5AEnL9V0/eFQZDDMnZs75+0vT8aIJwex0sIUPik+omKoG1xuVUyyBHqVhwpVHJH3Gg6faEUh5dQA6lsY2IOM/1MwCT1H0kELiv5/iWLiHIrHRyDRdfnxA3WIscoV3/AIcnUQ45BiyA7Gh8cGr1U2At9zXb6xguSGwFtkMSQU3iTymVo9vniE4mBxNY42ByKAi8FSfSSG0u0gvV1/02ckRde/MJhiMwOlF6JcUaxBJPAIpCRGcnmS8ssaape8o0cgEtLQHy5MDpQxxy/UGKNkxaior9JANniDUyB6qFNpyKuWQH9MHEhDZJjPUU/wDq2W/p8cn6jNH+kMShet18/aU+umR6sRkOfivciJmcliyqHMC0y2KtyKhAFZaNg7I7yoMdXV1HSYupBq7K6ie5XEniCyABDGkFKKMic2dirv8AMiIaJIKXPaFbW2hkBwa3IjKBFZDWzxApaOTx6j35+sI1icaJNgii7MCYA023x+I0qgkApPRQ18cCko2AB4/EiJ/UOQVkcAbgi9Xp6kwHv2kwQYkrJIcHcDTKJJT1UJgD1IZPXbcHGhkQXmdGqhAoDEnngllSBiQmQ33EWC5EgHJUO9fNyC4fpR6fA0oqGOTWrLFRgDIkhIWiYAAkNDepEVkUTzzAPFNhHv8ALjEVnp6jq2FICeJY/wAyithFgaUiBSxD4gGj1XfiMGloN91IJVnzzAE9OVb+sdRoEENtjvAYrQ9pKHUhZ4uMRWRt+R2kFsk7Y3AhLJTJo1CFoL6GBslBnvuRGSNmiIFBdA2OBswKTzwm5BdhbKhAZLxT3AFX8UCt4+p+KgADqvJkRobZO4ErI327wiu6syAkANrUIpGmvvAHf1kB+kdP2EC+PrAf2o9+IRomhwftIIeO8CjeoDXse0iH0MoutEfWRAfmuYFBR3IB5OoFrmytwgEuwgU6TuBQRIgFAXqBS29yIZP6+IFdOAUB4tyIoK3Av5kDSgUQh3gUahAH3kAFwLIAhFlAGnIiyC+8B2hDzAsBIECiRAQiuBYCAkQEDUgQEICBqREgWAgWEBIKLgWAkZIAQNQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQPJHtU9p76IHj1OA0LB+8CfpRHN3xKFK17QplfYO4BodXeBkeR78wLXau8CE0i6lVQzijR94EXqa4gMf0kZFV+IBoEgPxAAM8oj2lGbO6MKADpPb7QKOpog+YPEB/+qUCYj0vI+9SgkQRt24FIPWi26PaFRkos5DYA/mA0Tz3ECAAY9JAf4l0K5IBde0iiHUaC+nz4YBPuAJRks5C2k4An1d/ruBTekRagZA4IXC7yqWrN93AZF5EDIP7wILyIs+HCr0tNo7r7wgxtngXqBCAaFXwalUIFvdKBCwL6SuS4guSY6TfgniURkg5Idq2YUxPUCCWHurjgueKRJXvckNYP6BiaBY9pRokhohCq4gMwG8vsDQlIySAQTRNiItGCGQcuV3gCMcgC2NBDUcEeQwHUEGJQAPUkchq+8gLLY0QS1v4JTWRWPp6Wh0hR/VUDHFiisiX1NKAIy6ceklLhn/cCInKr5sxFoccExiUBx895dFsY9OWQt1/mBkg46PA8qFVlax6m7Ve/3/EIyx1EltAAJF7lUORorqxdDpbrvAp9Kx6nkSipDUyIa6sQCP8Af+ZQrMaHU7y7bjisgjHH+xujtOUKxRxKZZKBR4j+hQHqRJPbzCrmSSBlsh/4hIP0dYt1l894GBVkgVZBVcSq0CeMfSACfggZZI6f1ACkd3Z+fzA3hienoyW3qRKCv6hNAgNwH9NHA45PVkceIpTqy6erD9Xn34kguAGdpghXx8qL4gsizkQ0LWy9wLiccsHsaFknzCNYY5gtVyQvhkNjOOWKBJ9KquYsF/p49GDIyqyOZLdBEEEBEc9/P7yo0f1HEkdJO3QUggdZDEk7ANdMeI1o5HGyNvT+CQTA9A6TwyxxxxLfTFGWJokllhfkSYNP1M19fnz3kQIZ9QNeYEAeYIJ9Isx8DIrMaBFBuMGi3tbN7kRBwcrJ0jAC3j1M+NwNH9RTD2VIiYkHMoA070pRrpFP3IJ2BIHViiUjQ/1AtZDjewV/2ECAGxtJyBeIKPigIFKyXSPavtCAyOWJLB7e0BiW7KB5JcDWaxRJR8dpEQg9KLRooagaOVk9XtIi5J9dE9xBEOQCYb8duIAHdeoXArxOLs2rpQgsukHdjzINAEZBIdv8yUOnLuQFr8ypqMohkZKQUdOJIC2SKgXLGhwANahAB5UQDw5FqkjaFDuoQoHp6mfEAlQPv4kGnkk7cIjIPqB0r1CK8gje6DgWgAAXaJkwCQNko+IAWERzZMAyBvZ2oRTRFEPa3AoNUzdyA7AN1xxCK6rY33kE1u1A0zvgIkQiB9mFTEDY0iWNyIWz7doDGgQQxz7wJZFUT35gax2SaY5kQAQs8bgUGtX2SgAFbCkQxPKMChYjh++4FRIC+kIHfjmoAfQGQXuR94QBTBsQAI7Hcg07cILuoABl3UAd/wCpBfxAJcfiRALUopv2kQxNlQNdpAdMj7QG967qEVqpA9ifvANqBRqEB34cClL/ABIhr+YFgXyLhEuQUEwLw1IgBVQq8wgoDwXCK7/MgsBILCGoDxCLAakAwi8eICBZAgWRCEXmBYCAkRRAsgQEICBZEWAgIFhAVILAsCSMrAAwKIFgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHkUHaVT2nvhYJAADgCKNUIBeLgT2D/MqhP92woDIG0C/eAWJTSygZOXpKBHBUDSOgAD7QIWEyifMKjKtfaUazCBQ6WWSYSMo0ERdKFMtHpKXaUQvpT1Wt+0AABwrYGpAGVUSqlVAGF0iqHvAh6gQyT2895RQaQJ+2hIBRxQxY8QIfJK8ciVQnhEB38+8GADJetVAnSBiSigdwaDpKZJGwdSqrPS8iNuQTIEZEChzKJkGCCL8D9oERNHI+/z6wLke1+w1AyAOsHpON88yqcbJGjWoFwxIBPJC019I0TI+td3v9oEyfABdr/cKpAOJxBSDHiEREiywef4lVCsck7Jt/PijBSLWJIWuVAn9qAxFVcqoBRB1lo8mNFK6j/5AkEBuBCcjboGxx5gOkvEL1GjyqgAxiuNMwGSsEI3EVNvLFA8v+fneUQM0QACdOBSUscCHqv+wI8hmysqQXbxKY0LG8iQOysyIxneZo+0sajIIJGV9OnHPFbbxeZZA33hChkGEQeP8wISCPUuGSLP0hUVfoJy0Srf0lA0Ms08iX9oA1l0h9tKBnIvA9RBJu/eUxcwcjiV1d+LEnFigIdIA6DsU/2/3LqMBDIN5AIgLmFxf6nX1EcZINRARzBIIyFdPf8AEcNUsB5dn1E6hWXkcfSgLpKP6IXi8gCStL58Es9DJ5dS6Ce4lFBxYJsZ7r/cg555ZHAgYs8+filnVdPVkekZWXqxIfrLBGOPV1VfTA0P/Igzkey7x4i/1FkECMQScirPvCTwyxPTYCbfUgJIan9Qj+oMvVf53/Ms8JMCCcenqPYa9Uk6NMAkH9W7P8yGGGTBOIPCEYVcWQUcSAVX7xUZI6SGWKT47wN9SxAsc70PEGKcniEAnyVIlZyOIPqDRe9/aINEl9PSBehzBgE8jleJ57iRChhkUECCLtS4aoTDxJB11CQX9P8ATByyJZYqRFy//YQcq7D8fzAuQPTliQ39IRkYg0SSB5+fDGq0SSa6jdsq7kTDFZZAjEJui9S8S8THsMcuxBOxJVbwx6cSSSCeRJUqEn/yLu/JcAWT6SyrHA3xKKURnjdC1xIigAgF+k/dwB9OQAB2tfPMnRcsLQBEJoSemyAFVfLgAkQwQeO0CgrNFEnQEYg3ZLIN395DFS6QF2yI7LvAfpCfSDS5kGiSzir8QiNhvpUGAZNkFmBWwBjwd/BJRR1DJg9THPaEULKlYCsgyImTOWvzqBBkCsiK0uTKrYrG7IS7yIpKIBHO5EHV/blwIWMUV5ZECljEkB5E7hFNFKtXIF9KLsXUopddx38SI0Gwmu1wjONZUCdfeFXMHq3R4kgoDdm9AiEqogePAkCyNkQBdkbXeALsdVeRCLiQSFb3IIeohQNCzv6wiAgoWauBpEAf5kFyIy5qzUJgfJB9xcgh9Qy/xKKmF9r/AHhFBWvfxIGJJtXUChkGz2vtICRfwKEV+nW+YGi0OPcSIhKOn2qUVkng3IgO+xAcH7gKBRR19NqQP0483e4Rch6rgXhSCINHUCkjwPeABu1+0iA+g/mBoAAQh/d4gD4o95Bd9QUANO0YReRVQKQ/aQLTuAhAG6uA4faRF7XUC1AttQGxIhjuBdyBosQigg9oDlwAPf7QiiqkFkCA4hFOoRXcBIECwgIFO4AQEgr7yIQivzAogICRFBgWQICEBAsiLAQECwhINQEBIyQDgagICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHknWg3PZe8ZGVYYg45K68QiPI4kMQptMp9uIAd98QCeJTB8SiYgBL7woEAz7OAFBpnxAyEvTs1AoNd7+0Kg6RRNyjRDZ2O0mjDAaX2mhcT2AJcCHhEF/eBBQ2eIVaAQQ9pBCmiQbuUTYAI9gYVTY37QgQGDkD9pQI0b3/EB0kekpHUKi6iV4FQKats6UDOVgPQpCFXIXYB8rUIEvFAks8yqwdE4lrkmFXYPnzCIAhoj/APiFKqEZDLF+nglyml5HpJQW5APcNnXvAhBbAobMK1+nImj1bhEVAWQPweI0FkgDkB5/mXxQnOycq/aoDpyLB1wNwIBiSSq2Vvfz8yiADAY5AWA7jTqjFg49BAosC4GcsT0+m7dVGqlkgm+wMK3kVmwQDs3xCMErgEdxcrRgiAcQQRW/tFRr+n0jF65PZQUyB6WASKHSxYgYxGNEdQfY940MyAyCsSKsyiZjCstB+NRF1cQQQS20v5g1McjkMRlyrj6ohiOSe4tH+IFI9KIGWhW75hGScmCcTvkwoDkj1A79LG5QeSrJHpV37x9ELWXUHSrvAFv0Zdg3z2UH9Tqy/SCBk6IC/wA/vL4q5FtD1a/f7yAAcf6pskAc5/tL8Trm8kR/5CE+fG5WnRdRHUMsmSckDx2kQAQejQ9WiYGTiM8CCL99Rqr/AE8QMgMQR9LXxGUtAsMHkCWE1sQMg9OKGIJP05gRHpQxIyPftqVTDJggeouwZKLiQB0nHI+QIGsQCTnT7H8yVEJy9SGQ3x/EooyQfUMWTZ0oxKiPTj0NcgipAeOI2ixzpf6gbJYQZV0KEgz1Yg1l1DqvtcuC4lgCu6bAkqNZEHH1ZFmk/nEgD9T6WQHRf1j4lUEEDLdujqtwKAAenqYP4hPgB1GztI6+f7kGj6bvq0133+8HUyDIOQ6j2gayd2TjrLkyREKOIA9Pm6/1AyfUCMa7MMmBoLJhAkixHARADxfuVAZYrLHryxCKrZhFROSyYxPKkEJYY1lW4F/UQiEA07MiOl4ljL9R7QiKn/byzXvGqL0gH+oUNSIAZA5B5M7A9oGsQyQx2QNCEXGy01scvt87QlZGQxxHSgUxCtAZZelA41QP4hEIeNEIF3IoAWO60YRvI+pg3tgH3kTGWf7WR7KFXDQHSAQVrXaEawSZAf6n3EIuxSJ7OlIM+lA9IHiBc0GUQxpQGRCGS2ZBcaIJN/xCGJPTi30mBWAKurLkFaxQIXbQUIepg1+8gY9SO7K3+8qLoJnGk5BbRV0hGiE48FDuYxCyEzuBqyNG6cgvSv6hQCXbcaMqiLr9oGwCVTZO1cIo0ONBi5BKOPSVCLjx2PmBaxxW+E5BGggb8wFoAoEwi4Gqq4ooYQ6WJBQdlowiF2TXG4Fsdwy67QhtKu/mRQoFEWfEI0S/K7mQQlFo75lFB+8iLXa9QLzxCHbvILTo+8IAM3zqBWNDfvIKjVMwDFo/TvCKfIT8QJsEa9pBQeOYEGuIFI0ySu0Ioso2JAOmt1CA3v2EDX3uQOxqApWzCKBAoDJkAfBCDoQLzsfWA2NyIDcDRgT2gUNXIi4moF3rcgjgU94Q+lwLX1kQHwQLIHEBCAhFHaBZAgNwii4F5gIF7SAJEWEBAsBASIogWQICEBAsiECwECwgJBqAhCRCBRAsBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEDyaL/TPZe8B8pDmBCbda7QqJOuORKL1EYg0PaEDtUhCxADtkC5QukWe4gQ3W/pCoFll4MCne9QJqxj/mAsdm9R4oAz2+sCZctkmzLAIYDVdxUCk0u3mBMsWeqj2C3Eoz3bEqhAOhX54gUpMV3kEIF0yDKGLGwX4gWuogAJcagYDFkSqooLqDC3xAAsvY3uAxJOTBCgTIGxiD7kwqgk0fuoEy9JVA95SMBgdbFboiVWkkDkzvciGQDsCj2cCAu0cUt3KqDHLRSB7fPECjB3ideNxpoxkeWLgZeRAHTXiATPgmg+IVepDqBBNncuAC9Dp5a3AYkg0RevJgYAxyxLIbq9e0qtH9YTDOxqQR+vLDQNSgWMu3Fm4NP7VbH1MipielbYHbcof1MhiNa2ZekFYxaJKB8doKjs5Xj/dQ+dhAziR1B2Dq3zKNEZsgv3NyCaDJH0GrlAgFn9LAC4hdMmFwDsff7QAxRsMDsOJBij/TA6hqx9tTX1WgzibAA5PbvIM45IEBhlhmUXIDqJI3fqMaRcSQafg8VB1j059IKeJNd/b8S8GunJmgACDwhIbGcWACcx0DQ8yqpyPUSCWBrckgnGSPHBb7OAOWQwFuigOJQOQ6qPoAQULDHAfqOi0AfnvGpvwIQGIyLfNKFZB6id+TXBX8iWnDAjLPqQXL7BS+wvDNdWjRQJ17fO0k4oesAGgDQHECEnBg5jqB+kHVCyz9WWNC/wDH7wJkRYKOySe/+f8AMRG+ASch0/3eNyGBRYxGJWkIQyA6urqu1fMCUySLK97+f8j4KTjmy6G8SfaODWWWJAaYVDkyCtkgI5g/eEQHpHqRPv8AzA2//wAp5BD95E+MDqBTBOvggXFALqIQFrzahFwfVQAK7b+klVcMmerrK/D1FiGePAAwHD5uBceo+kkru5Evi5EA9LY7iMIwKxZyJI7gXKNDHDEjAEPfz7Sbvo2aLRIf3kRAT/cOk0KMBiCz62GBuKjWOIyDBNWPnMaUGb2NByYIepDqVe1ShXUyQLNHgSDT9PpNonUmIuOXUEWvHMGGLYRN1qEQHHpIyOyCyN/HA1kjnYG2ZCJYzyBrE1KNJEHuaqRD+0+PP8yAD0gLgfeBcsiliGq7k9oTFQKDQJ2IKckrzUCYFZCt+PMUaAIJxB+xuRFpN5HuTIDBByPsSNOEUgkg88r6wCRexAldIBetLeoGv7SSUPvUiJi1+lM9oFrqYQJ7Bwi4kv35diQBaYLBorcovc9eNW3IhigWz7CBWXW1wZA7r/CMAz0gMkkcwKSCXa0oRcQNlE3XaRAgNX5ciqH2+t8f9lqGLOTIP/JCnOuV9YFuj1b7Qgadn3gUJ2TV6kAkivhhFpXrwZBWSDdaEAU/JgQENcwit2l9IFJY9qkFewDfBhEB6Rt/SBu+onhSIyG6JcqrSVqRFDN3qRDE/wBxYlFy8lDiQMRa4gXL6riEQJIN8XAtAgWJBo1fHmES9GQXEC4FACZrtCAMYF933gOX9dSC8U9Qig95AAupQBQt3IKTciH90ovMiLwYCAJPEC++pEBvTMCjcgU9wLSqEODAu/pIi6uAgB8UAHCLIKDCEgQH7wiiBYCQPMCj8yIsICBYCAkRYFkCAhAGBZEIFgIFhAGQagIQkQgUGBYCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeSy/HN7nsveECK4+0B3KcCJOVVC9oEK6UNnzzAvsz7CBGN7PeBLBSF3KBC4X03AhBRsA7fmFUlLka7/WBCGC0WDcAACKFncKZLKwAJRCQKJ4gS0w0+0oEfXy5BCLaPN8SioU8F28wIh5ftfvCqcdnG0N94GQOMgxzLqtEpV+JESuqtuBk02talUfqo1+YA47woACNFztl6/Hz/ABEEIIZ6kRwnCgZAr6qBnDAbPhGXRcrzCxvTgTqyOBBD9oDMEgHqZOlLASyIB57UYVcLADFUfggrJHprRrxAlEm7I77lFeGTAHO+4k9AA9OshkuRvUGovSenfEqr1Ilb3evpAyek4qgQtlISnAhHqK894WKek46JJ+0QGCDlwLBEDOQIJAPpWlcKK+p6KXeAxCzodRGIPaAJNA41294FoZGwGhrhfPtKMgEkDXb7QJkAADYKTB1GqBdJAybGvKlRQCRlhiAWRo/mD9ZLBCOQJ5heoDkabssfz+8Cl0CieSdeYDJY9iNXqAfSASChodXMKhIGZRT+V95Q/qLosHBlMbEQa6jxi+V23AxkjYxC0ls+33lAqz+jIc8mRUZAySC/EKvSR1PZFB2/ghNMcgSjfGr8j7QVCssRiAAcnaJvk/vKAyBy9LL7lMSgMqQxJy9rEmKyeoZEdVK13/7KNZEghlZbrKIJ0npIGRfBAsnvG+idSXRYfSsRa/iUwR0STRBex9PtCqADikBwfv8AKkQz9aJKPFIn5dwcZ6hiRRQHaM1VRIB0Caxf0/eEXMAEFhUuHIIQj1EYijZKco6A5HpOQxZ/SAdDhqREQSANlIGj/uQaIxRyxoYhh/PpHU4zgnZBAbHEUbyOQQRL7/lyJ0ayp4l88a+feBkleSaSgafrQeOKakDLH9WJPoGMuouZBGR8/Px+8gHEX6shl2xPzv8AmIKMjljiOoLuTclMP6QxDddu8Wo1l1ZZCmP/AG/EDI6zj0E9VUDuEXPH0hHIk86gUpm0O73IL/TyGSx6mjpOMqUIQCYdH/kgg2aVblG31E4jEjtWx2kQwB6elWQP7vbcU1DeBOtkF1INdRAJFUwe/wDiBGCDia504FNK34UgrBxYAJOi4TAZAg575rftAEEkp604QBHUC/Uyr+fBAorMjFMAN95EaeTBIB7/AFgBl6tm1YhMBiSUa/5AhRogE6MiqEli2Rr6QjS3iwGeZBCOFXJ7QAPDOywe3wSothAHWzILq8faENIoeJFUmydMfeEwz/SshzYEQaGRtHi7kTAvdsUIAkJZV2hEJNpiBoABhhpe0goNog+x5gAWOng1CUBsUveBQT+lLw1IIay3X8wNFAgZJ8SIvSwcbPa4EBf6e+tVAoxKoHkQighIqtwGRYuQGRoHtABEdVbVaEIp4N3oKQD+Q/MqKzTIJ/aQPoO0g1RZFdlCJiQC+0DRY7feQP57SoFjv2uAN5NSAVfZQjR0T8MgEC6ZgBoOhAuPmKLs7qREApNQKV0+PMIFf4kFxI1Ygqkf7hEfBgaslEbsSANJjxAbEIrKMgWlalB+ZBq1qREf/IFoniEP8wKN12gWxdQEiA7QLIH0hF+sBACEX24kF9oDUgQin7wKDCEgHzAQiwLASA/pAo7SIcwiuBYCAEiKDAsgQEICBYRZAgIFhCQagSEWRCBQYFgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHkwe55nsveTJkijAEXqjxApB72mYGRZ0jKqhcHmBKBVVyIA0STR9oAJ2f9ygUTiVZrtAgY59jCoMUrTO3Aod3YsuBOBx37QC0zqFO9AyjK4sdmbcoosWNGnIBAO9kcwImGCf8SibNacKos8LmQMhiEPFmUiX0vKu/iAJZScCfqxSR+alEJRRDKTuFAKLJNQKUSlVVAhNvHp3z2lAjsKD0IUCIojXcGQS8QieDL0UB5MgiCoLHSGQFzAiY7nHtzKrIAGR21scSjT9Vp+RX3kE/qD1PEZLl0IhFOSyGQsgpCDEPSwnjdX88wGOLxTD14j6qD1UTR4EovpJI6lvYUCECgCPvYhTFpdIBCIrtKieg08sdOufEKvbIdWI4gQgAY5Lu1xAY0Sekl/cwJll6hiSEaJaMQZzQPSCAeSPeVY2CRmcsAwd3r5qBAQz1JoyCe1H2RVyif1CBzex7/WWKMogg4rfJMJikDqeQGmTCsB47LJVgb9oopJBAWi2+34iCZDLIi1RXCqXSAIy0GAEFzJxTP8A+gmNn3lGciTmwE9oRBRsPqO/t5hUyeXR1AIkIupUXK8gfSD2B7yLEyGN+oMBk95YGOXVn05ENoI8xhxQcdXt+feBnWfQWQEtswq5FZZC8joIsmVPiegJkr+2RVJGXR6cednQlRnAb9RL1aLUKdAAxJQZTD4/aDQMY1mQuXyOIGQAsSe1kc/T7Sq0Okgl9WI3TUhVyOWJJPg3V/DuEZxG8UAMtDHT7y0bwyog0Qa8TNMChRYyyF/WA6eoaId5A9v87jcQGXVlvz9PaMGxierqLAHYSIZLHIYjEoAeSYIBn+mMsiMu42/b8R98QyfYAC7GpFB1549OYRP1cJxAcn0gOkyP8GBcAOnLmh4fEI0d2PTXtIAyOYeGS9Xbj/MuAbxYLxDG/wASC4nEhA6Grr7yXxERA6RZD1a+KBvFE2iBZD1VfS4SoA/SAEEUeY36AsHk46fPeBAAcjj0knT5+m4GhlezdPgyYh/VF9YxGI5JMQjRJBasFdgJBD05dKA2F08fFCLgAkcj2fIiqY+rJH1HtCNAiweoCx4H2kQWh+OmRVx60id2FL4nUeJ3jlxo77XAqayQR0pEUn0g88iAxK0MboB/WLBTeS3joghyImRBPSDQ5A7wRoEdRyxOI7wgMgCcWCV2gwBdF/vzIpkR/azzUC+rRGgUAZEadgkgjv8AvCM4oavv594otsJd/pAuWLvJhjmEAWde3EihNogfDCGT62d86gUEMBA/WRDYxLBBPEo0dsm/ahIgelHZAH+ogYm1lfGpMFao4/SA1klXEC8lXwPrCKwA+krjxIKCfTxt1xCM49N9vMVWkEORzUiAARXFV3EICwCiVzA0CE4A0y/5kQ8m3T7QLid+8gGqO+VAq4IR58+IQG/9QKrZ48yIpKISAEAKxBbP7wBPmuYFAKRIhEZ41rcCgUa+8iKduAfUORcC8Mf9kAIjR+0AiKEI0DyTqQBvt2gB+2nAWCkh5hFBv3rcgZf+1fSIili/MCt/eQAtGAG9XCKNliQO24FGkS4Q+ggXhlQHAW5EUGA5gDfdQL51IgDxZkF8QB9oQ+xgWBR4kQv6QKpAcA4QO4FBtQi+YA+8gQiiBYCQPaBQZEXtCAgWAgJEUGBZAgIRQeIQkFgICBYQBkGoEhFkQgUXAsBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEDyY3v/ABPZe8pSVIahGU+on9oUICgEHSbfaANliVU7E/7gGBYswCKWQBUALfB0pRCAFRuBVTOoXUrg1AgIFFfaBEirHBUoEg8sCFQEpc7gDWgUeYFTzJP5lAElnmQQgtgK+YAnKwSfeUCMnok6bhRA4gDJgCo0QAnENvmA5AZHvAAAAHj3UomLfSx8MKG8ACfaAI6QQDX2gQ6WIC9uYU6cnSxEBj1HE6BIviBAuk9tUJRR2sHyLgTVlXp+YCjkxvZpftAwVj6fsXrtNK1WWKbrnUnBCTkLsA2XBEHSDRNkf9/eFASx+o5bXBqVFIyBr9T2A4Akqz7yKeoGxofeUS0TjadPUCoaCAfMKlIAjox0JUQlHfUfovaFAA10LtfMCe7HVq9ke0BiEDy61paiqg6ekEnFfP8AMtAgYkl0KajoEjVA/v8ASArpYQDpfPaBP7rBqmDKITlQWKNhfDApWIZQekJFTSyxZAD9xKLkSMQSiQyu3EghwJIy0f2+d5dJUIHBPKXz3lVMgRkQbyPJEAABmSaXK9+I0V4oj9OPHp19oJGRYzOZNBgur95RcsfSUOGe3xwKRZHYs9QkVCeo9QPSTp8/SBD6Rj1FJ13+vaUTInEejEs/x/2J+quLxxOOWQyA76PyoRGC+rIAjnQXf2hUyAxSxCOwJekaAWHU2Pyf3uDQHHeLHceYPWQelXkQBaFR1WcsVleLGIRRT+eJSLiRkjiCQO3eTBB1FYlimzL4NEZBLEgEry/n7yI0AD/VyKRBvk33/MIYEn9WXqOnt7kAjP8AUCACTrn6yKGuoEkDhE6cqKcTp4kEpk6EiL04EAPJAMAjX34i0MMXjiECSjv9UWi0x2Vq9SC9IAHp1wR57e8ImGwDkUTVbuCtEPABMv8AMiM5dN9OQIvy6lGmcsQigH/37SCnEkgnPpxAoD7wGIy6FlkiiGZPqVQ0iMjaRG+0ANLQ4RcChg7PqvvXtCKycmQa72/vBjJHSSOmid9v8QdaCIIIVbXMyiWcRkT6R3f8yi6P6Tx9vgkBZAj0nq22pRS9DLZ2DIin9PUyavzIKshktkQAHpJxHd+YGgX4t1ciDZWaukNyogKLxZ83CtYnq/8AVGgpMRP/AOQHqqrv6wLj6QU7koAoBv2IuKjRCJXUhVQjJLICvgq4VoHqB7vipEQHmjj3EC+skFt/iPBcj07JJNVxIhwCHQacCknEUfVcHV6QUaf3+0moJigSN+IENMd9ncC1iSTS55ga6m212kTGcUBkTfnmUa4Y3yRzIi88hF+8gN2afy4wDQBOxdagCSR6UHA1iOkEAnxUdQHPU/eSi5NgjZhALpcCsHjUh6gpEAkQBF6BVe8Ioe0vxAAFr6wKQfC7ORFF5E+eIQxoWwYVSPPOpEQoNgL2gaXDgB09kFrtIi4pAMUoCgjx4qBo1epEQKtoyi7xAkRCRsOBRY/EgpAYJuBQEETCAB7fmArlSAK1s7UDQbqu3mRENFDR3AoNXUIKn/EChtKAVqoFVeJA4YhF5rtILsdoAXuEX6uBPaBoe/4kQBQvn8QCXG4AQKf9SMj4hVkAfcQG7dQi61cC7tXIhqBZAgP2lRZBQYQHMguxAQDYuEX8wG5A1AokRfaEAagWAgJEUGAkFgIRRCEgsBAQLCKDILAkIsiJA1AsBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQPJ0Z7L3iyaIgCKRZfcQiMhhQqn3f8wJXP07wIu9g/iVR+YBsohDmAXdH6SgECjfvIJwrXaUREEAm+0KooI6gNhEEHxAHaxC8KBCwXvxCjYd/U8wIBdE7s95RCUUblGrpK+CZBnIdRSQ/aUgd8g+eYVLOint3UCf3cfSBSEFrjcC5nVkle0EQgAAerTlEtGwL37XCsrEL7SiogY6TuAxPUjWtRwXI+CakUxLLZXcd4Rg4kq63QlimstutuBrB0z1Ad+YojBBy73ZgSjfBXMqqC8AECOFCM5EnpTx4ZhVL6jla2YAIgBYk6AgTEPEYgsGm9CUGQP1Ds+TC4uskCxepBnIgdRHpC4/3LAyYLX3+eJVTB4oFeWe8AQQQAtGwNQM4shfqX+NwNk+l5EBV7XAyVvqGtwqZHMh0GQiDsykUCyRSKvu/n3g1AfVR35uAOOIJGAC0txomLAAAT/eUE9WfP8wKB6gSAiO34kGSLLIobPHn7yrqlggBoYlDn5qAJOJKaV8QYIE9JNCmvEKyDjkCw+52OPn0lAY9WXpJD7D8/eDcRJADe9XXIlD1Y8Aa+p1IoUkCSlZf1cE1AQKOm0vuD41KdQDpZKIyJYMdBrVI3Uiocsur1hAdvbVSigpn/AMhI5L8SigjHIAgrh39pDGAml29LqUXp6COon3Gn5g3VxY5Yxr2cdEJJCyA1sFL6wpketXS7hQTxCPV1AjInY7wKFli6BNWzcUX+mBSYxBbe6ioZE45dO2DRs7hGv7sSMkTZYcgmTyJOQAx6rNKBTZaurxLcCAdQFpokDnjkxuInUOuyLvW79oVvJdAFEaC/H7yI1/VQGIIdc6MiRB0pY4g0AmdwKAUQSr4F1evmoRHiwACeE37GF410kdJBJILobMJp/TyOQxyJLXIoSWYKcibxGJQDLagXCySqobT+kiVk4shk91oxuA8RkUQQef3ijf8AT4WX6aANxamGJBBPSiUUrkwowwwLRIgawy6sAARl70RFiIWekn0h7B3ApXV1GtH3qQVnpAa4ZFKEZwVAaZdKn94K0wMRiytJSDTAybKgTM7K2K4fI1ERcmK0e33kEx9JxAyGuzcop2mwW4Ewv0gscA+0lRtjp9RZ8b3IYVaZ9hqBMnlvIHxyI4jSFnV/eETzxstwrTBJOJA7qQQUhWrX7wi+AUdXxINA/wB7r3aMIiCKNLiBbda6Sg6gUm34kQCaL6RqAxLDVd5MBAkElcbUoAikRrv8+CEUdXB8VIKUtIBJwihjg7+xgTEgWCLNxRSCGwQjcgHqB9dq1AIAEormEaxKyofaQTnXZ1UC1irY7vXmEUcriQWwEUa5EB+oiEKbBuABBx4DqhJRcUVVDiEUsZBO6gKBFkd1IDtkjfGzCLvsYBOjsWRqEAS6ZhVP6W6PiRGiUgFqRDegO2pQobO+HAchC5EVCrseYDElAnclFfaq7QKO5+jhEIHPaFXmmB7SIuNeO0ADwdwg0jINA1yPeESyA7D4gVjZgX7yANeOYAoLciKw/wCIDL95RbkQFEJ/SA9tSBj4KhGnXeA+kB9YFkQHtArZkB+YRfxADuIFqRD/ABAsgDcC2oQrmEPmoFkFOoCEAYFgPrIECiRFhAHiBYCAkRRAokCAhFBgJEWAgIFhFcgsBCEiECiBYCAgICAgICAgICAgICAgICAgICAgICAgICB5RUAK7z2HuoDQ/V/iUAOzgVWt32gQgmhX7mFCRelAgDFmAyO6APaVUslIwGQrQXMAaI55gFen3lE2VZHvAhYFfWFAQRY8GAFAmuK4gEgNg/LglQC0HUqmIQbK7HmBSzdAeRqEZu+r8mVQiw6H4MCj6v8AEgholEgk/KlVER2+2vEARSJoUY0TI8HQ0blFFBUDuv3kEKK2yiJYBFg4n2qFMj6mCRT3ADQGuw55gZyCIGP6TuqlGtEB+1yKh9R2EKgZKNAjVUtyio6oHYrcAW3ePeveBk3kundSqpC/SAO9fiAFDpJo6YgQY9WFi3VwGQqj0g0jEAj09h4F94DIDIjpH0+sCAV1EMuxKqm16cgte3eBlkZYnIermArHLEItoSqekCycbt3AiAWKu13ECCtogB3UKpJByyGT8Dk6hFIHTovuOYghvaXBcs8UJXDB9iHJDoMQDkUE7EoygjkRzocSi5fp4Y2ZIJiOkHpFE6N/iXdEDoEWO2jI0pIAFFAkewliMnEgAGy/PziAGVYrp9jCjYxxa7q2+ZRK6A8RsjK+eIPqjF0sQNjiNDHpGVOiSSxVqAPq9JK4Ar23H8OBzQOTKP8AMuDniMBjaFhBAQreeeReJ/UT9IMiAHPNFGgj1H4YOGYIrdaOz8qIowCsSD393qBQLQvuzCOa9RPSFQvt8EutCIwBxJCFnuI0XHNi0V7liVOKAcXkA8qsD7SCAAYgItKj83uKsZxGLoDEDV12qWjWOIBayGQIQ39/vJqNPJPInHlBfiPExm8SQSKumf8AcKHE/wDkxyLCA4v5qPg1gcVXIFmRFyFk2yUSDZk0wsA9OdA2R37fmA6QAmcsR6e4IjUUu0CcQrQJ94waawGJNnlfLk/UYYIxeKa9VFS4OhwNZDqHZ8fLkRnMgloJfc/5hWrSO9LgbVyImdnHIAgckn7/AJlGihkvg4+kgH1EsnpFJbk4idTPSeoUCHA0SKGWSGwX4/eMQIJyZGtkHW4UBJKIHTq+BxCNZk/+xHP8yBixVrLtCGIeB6ulkn/bgXMAAHInDhiSIpHps1wIPoR1Igc/zAmP6eoI5BtxRX1AAjHxfEgdRxOLLVv58uBq8TisdnfYSJQLp0QP/mxCIEPQErdalVbx9gORzIimnkCTaDjBoj0pMSIjHcIn6wqssHE77GRFGzkEb45hEABBKZBvxKfWsj6QH7HvIIFiyCMSfMAHVglUZBon0tU+8IiSFG+3ztAoJoaPZSYBNgHjtz7yooaAQbRqQpysiuUZBQcXwBt/WEXeSyJ8DgQByolH294xEYA9W+HA0ciad9xJgAepFKuOYFOwAb4EAD/6td/MI0FSIrmSjIt5BL2gUj0jhQLia9vEIoYBAciCpIeYAb0nqtxRQPAY0uJEW/7t+IERFb7IQKQsg9rUgoK4T+8IenwnAEe8goHb/sC2dWOzhBrEA67wDoefvCLR0voZALNriBdCz9eIQN3rvIL/AHfvAbuz2uA5XTCLXmQDvgqBQS7NQB7n3kRR4G4RRpHcAUrv2gWveQN3qEBrsRAoLAZH2gNKBe2k5EX8yCftzAuvtCLwT+8C+HAkCyIoMgDUBxCLACBXTqRDxAvMgSgHpyIvvAoMIVIEIa4gXdQLzASBA0CJESEWBYCAkRQYFkCEIFEBIiwEBAsIoMgQLCEiECwLAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBA8pTJPHiew9wO2h7QqEHZFn6SguDChHJ3x7wiG2AIUyAKK3Eoc8wId0DUqqWSx+YEFDQ7iARA3ragO4pe8oIn2PHaQZKAIAlU9S89xAEkH3+sAgKJXvxCqDdVyzAhIYORH1gZOm/qpYHUSWrOpQF2guIEIKBZXeFGB2I34gUVlR+kA0CQrHMCfqQJ8wIQQLx1oSi307yPuZBMq4EqobQ1YNHcQUMsXTCMAqey/3gK19DbuFBYB6SSeYGMk10g8nmWCkH9Qvqs3Af2Lb2oAh0elAWXqVdTF7aA7QANlrWoAg5MH7GxGiZULFi1sQAf6Aa494ApULP7QMk4dIAQOxKoAfS8eqoFLPpJH0MCHqHpxyT+CVQPqy/SiOf5gU3ZLQZRkGCXit4k0RKrQXWV1el1uEZXTeXfmVTRFhvXZQGIIGOQYxI7xQD6iBlXJW4EsldH6UoDLGnROv0y6Kt1kBiEKdf4g1nILHpZVgB7hSgeoI+WlIp/wDXURZFkMfP5lQVkgZZHjn5uBFkMhk1kewqFXLEhdSOWyTarxCROkaIBAoOVQ4rFlkkEN9+Y0QA59VAcv7wcP6g6rIB4LFvt43LLhGXZ9II7KGgs5FYgWBvmEaPqPpOON/5X8yCDqxeDAOwFrwRKdOmltcaJgQG0DijwMSjp1KAAJ6urZIIOhUL+JmSsgcRjbLH1hUvEAHME6Jd/vL1NCcutYls2jrwpPFX9IRJVav7QNAF3icQiR9+whEyyAyZ6t2g/n+4w+MtgdORO0QQ9cQK82yAzzyPigaDJeSB4BGuJBlDoGQ0vtA1jl/cLpgyI0EM+oUVviE+AyIBODDAXdGDvVGLQyBIQ/7CMkZBH0nLhGFXHpxxYAxOtyXRrIkNZcpmETK0DYBB1q4ngoBthbDbEI0CFRHU9+8goXGIQKKEn9QBIx1iDzfEDOWRGSAAPPD7RBo4lg/pyysgjZhDWIx50XV/FCqEaJYAWvpGIYvZJpId5CgJZJLKr+IRoAMgkA9wkfp7wIT04srq7jV/zCYu8ukZek8SKpNatsle8IhyxOKXHVrX+IwXFhELWzpOSotaOTBvXz4YVCLQyQJIJhFDBLyABrX4gq1RoofeQCyNHpPB8QjQXUxik12ion6BvkSKWwiW7+kIoGskNIhwATbPSvxA0Ook0OFIhlQZJvkq4FX6iq4WUiBAFfQCFGBY57iEKHhmxcC6dAPTMiKjRZfcQKQgA7554hECAohDUir0rHTlRb9TqQDY34I+bhAEtj5qA9RJ1295Bo+p2u8AHYZ+nBhFA/GncaAJOQ/UXqpEAn1WCTAZHLRPmA6UFf2/mEXZoyKEjH2P0cI3bWS1IiEotE/WFSiEvpCKj33uBcXyb8SBsP8ADgUE8Qi8643IDN8PiVFG+9fWQNV1XAcHg6qBT9ZEORzAoFnXOoRQWOZBXBgDWx5hEyJEDRGu8gnC+nvAo+siA7wKDAvufrCDrbPeA51Ug1ahEJKtwKOLUBrbUCn8SIK+YFkBdvtCKDd/SAJAgPaBfMiAIgW+8gGhCL3NQECyIfSBYCQWhUICEXioD3kF3CJCrswiwEgCBR8uRFhCBYCAkRqQICEIFEISCwEBAsISDUBCJIiwKIFgICAgICAgICAgICAgICAgICAgICAgICB5S+6U9h7i5ED/AHAyTol+ZVgx5UKoPeEQWx3gQsVy/vCpo87ga4BoGBkK+kyqvLr3gOPPfcCGjSCNOUNIC/MCEvEMHzAhvI0PtCqlkDrvAhSFs73UCk2DfvBBA9zcKgAtIZb9pRAT2CgCQTTbUAAA+rUDIOkL0hKDJ+sKqXSbUATw759oEOxsWvECgYrgcwIgj1PxUohWgn55hUB7dS5cC9+FAmXhhwqYhtni4FXXs413lDJm7JH1gZVA5Nvs5RUnYCoCQC+SQrMKix76PEohPceBAdIA9Q/kQIayApHShWmSKVj44RMgMgRjvtQqWHENGwT4HMKZLLHHEIH3+HiIJlsvR4G4iqRog7IKI5r/ADKn9QF4AkI8HiMVcwRkACcg4RkdWRHpIGOhCoceojFX4Nwa1kVj6USzfiBkNokM/QQ0npA6dEA9z4l9RrJAAlhELzIMkdX6ixVECprRcxl0ngHYXzxILliSTik1ouDWRhkQstivaVdU+rM4lgjRWpIMkMeqwHZ+sui55Aaola/H+IIw2McunLIjaP3lVQQNYk4pEQGJIQysiybPaAxtjJnqFnf7wM5URgDbIEqpojpFPvS9/moGwR049RRV15kGRliWj0vjLRuXBerE/wB3SN1Ugh9I6cSLDHf2uVTPIA1kcUUCLpSxEr0jEgYumWmpFZ63gAUUSMr1Xz8zWH1TkTmSyQP5kWRSBjkCUhsDUIzkcCAOl5Lq6iO8q/WsifTmR6Ts6v8AxqRJ/i4gGgA3onxIIDiccvUASGSmJRB1g2xVAhfiLh1okHWJZK2mpEMUASR1CtfmFR5USEWr7xgoLt/qV3X+pErRAHQaLZIfzvCDVFscpOtQGY9QyyCtN8QRt4r1Ajlr73IiAgA9QvQR8Qe6N1j6Vors4MQGupdIAu4MaZPU2PY9pEQrIMD3R/EcD+mAyPH3PeKLh05t5mvrUcStHnfUB3TkGQFgGGXwqPwwNqy29AAGE0R/SWQA6JvvIHpKKd8fxAElPKxp9hAuPTiOD5A+fBCG8wGwfepBq0mq+0ImRxyeOmXZqDDIrIayNK4Gsj1jHAiz49+JOeoEHLQOQI0OfrCq8T09ORBPn2hAH0AnZ57CAPSx/wCMsb3CA6iXkgkrqQEMiMSjuBrIrEDEpkm/ntIn0DBWRN7JgQnEAhaBsKBrIgAWHsIwhjds8cuSrjWbDJN8h7hF6eooEEEcPUiagADBIfMDQ9WRxL7MGCoKHiBrInh32EiMWgRiCR3lGgTRAFBSBi8Stq2oRcCNdxAlA9IPMC3sCiZEaaA6m+ZABbJBx+kA3sH2gXhBo32hDMhmjvivpAoLPpocgSAygFqixuEWzka1IKU2LW4EaCSQbhMUk0SlyHBGhtUC5ERhEF/7gAwbN8XqBSSeA3uQAU+dVAMhMriABCZ0dwjR/tW5AfG1CKdhrf4gUZBI37GENcC4F+49pBBpofQQi7JdwBsSCitsCAxXmEXuORAf28HvILT7k6gAvBUIPxzzILe4FDApmEKfvAv1kBvYXlQHNQi2ViW4BeJBaKpQhwBAtE1IAsskGEWmiYA9h7wA/ECviRFeue0gBbqBTCCZgBVQKLfaRDQgU3IFrcC3uELhFEBIHmEXQEAO8C/SAkFO4DciEI0ICAgJEaBkCAhCBQYCEUSBAQLCKDILAQiSIsCi4FgICAgICAgICAgICAgICAgICAgICAgIHlSC0aep7D3EHtAMpCFAHQg0B7qUKFviBCLf1cKHswjAhIO/vAFEJQC3QT7SgGdrVQqEX73YgEjrehKIR4vZqBTokY74gQDYNW7hTLYSv8QDxyCZgQ/qre3BBMBAI+JVU8HI77yIhQtq7rmVUFGxs6gR9RRHP2lExBPFKkYpqiy0uRChB+u9/wAQGYJBiDOiWaHBMKoDN8fvCAZa434hU2DiuEeZRLtZc9oFCOPgFuBks5UUTriVVAxxJSR7dveQCTizlZVlSjB/SMQdm3CtDq6n1ZVCLoJkEh23AyUukAt8D8ywM2hYHiIpvQOOI4IgZzrBg8UdROqtEskh6fMIL9LAANvt8cDNdX1orgalVoM5g+mwq7wGJQNoWABBjIxHAHC4+0pq0wFTkVn+mAOwGj5lpVwRxHchXYijKPUzQ1XzxLBp6zIFBXrzIMh6JFE938/zCgAaKLDa8SgqGQ/ppauzAoxWOmBv/EhqZDPJkY4mtOWHBrL0FEVWkYMD+otPtvvAyfQMuONyr0IPV05ErIV094DHqDe/5cCEZkLFrS7/AFiKuC0SgvFd4KYnIXkWHwOPhjxEIxsgFqqrmpVDikUgmSagPSQhlkQaIGh5gZyyYZDHfmuZVh1OlRCA3JgoBBJGeiyOYE/p2hnmCwguLuUqZI5AtM9XeFP05E4kMugdfKlFzBKtkJl8yEMiTj1YnEHIr3v59pUMUCRlVsL3/wCQvrP9Q9WYxBF/q7d9R+k8HifTlhkAdeY4v8MiTkbPJZ7wYuTKOXpdsoX3lQHQ8dHI2VZFSCk4jEmzwV/dz+8YIHhn1EMkvJ/aTdBnq9Yp7IEZ4H9PAv1dKINEIAxajQPqGWVMMeOYopCQBD2+ZEXLEs2nQ7/KgZWOGZ0CqC7R7RrHG1kwBrm+8lAMskpbf8RiKCUcSFSoIGDEAujk8jThGhoA8FgHf2gTIHMrLIhrmv8AEk8Giscj2/H2gCTgCma+8nUZo4gCg7lVoYjqKBrzJqNEDHHpIRN8EOEnqPqHSn6k3+IwXIsA9V+JBfVlk0caoAwjOf6KbpMMuJ0bABTxIJFc+8hw/wDVkI7UCArJI2WFR8ftGDQPqBOewjwoRoErIl25EACj2K3cFBk8u9vfztIYmCBDJHHk/P5lKYEDEcOnFTF6TllfqrQ5Hn7SGrjlYLHUAvMlMQBDdBqh87QNBYnlENnuoQZIBWO6EDQCDCI7d5ELJJGWL0KgCb2kdwK0SWyO0ghrHJe33hFXq/8AYZbR0YFxaPMAiRRprxqEXDfMhTEkckluExX2FnlyByP25cADidA9jcGKSeRS1z4hBntugOJMGgAzZb13gTGv1ElhQFPzsqEU7JBvmtQKRQARX5kAl47slQjQ5dyCH1ZDfkwAy4IC94RcvsP5gXaZ95EUEcX3gQkAMjXeMFDBYuQB1A8r7wGItuyDFRRu+32iikaEgtaYviEDR58QLiFZ1xABWz/uEO7vzIC8bhFFDsoBAlmQV2SBrcBoen6QB0OIFA8DxIimq/YwAZrzCBRHJkF2WU/EIH9NQKD3X0kF7W+8CW9buBocG+0Io0TIA+0A7hAIKABq4oquRFB+4gIFFe0iF94FHiQPqYFhDvAcVAvMiAgVQA3IAqVFkRZA+kAYReYFqA1ASBAsiLxCKDAQAkCEUGBZAhCBRCEgsBAQLCKJBYCEJEIFECwEBAQEBAQEBAQEBAQEBAQEBAQEBAQPLEgJe89d7iW9QIG0P+Sh9IAtBXCp9ZQJLZ1CgHZfTmBMuaUANj76gD+okqA7MSqcnUCL0vkwHCaPMAQAt7lAu+/HvAlbAuFBZVtoNwIWXYHiA3uyYUwAtBvkSjJVs12gU9mn3gKI2SBAN6IY+sCbGifpACwdMSqjZG3wfvAEdXqPSw7jQZ6bPgwI2Tv938qUWiLLPAkOGiL1qVUF2Te+3MAqXFGBFdnqZuAyoPtoE/eFQhlELxKHUhdIMeYBvIN0VAga9JFlj3Xy4EAyA4IP57S6qv0gskkVdjxAAgsIPvAlA1kUlvcB6QKIID0bgUDkZBgV7KBALR6SFtNyqM2GA+CYEBIxZa8fPeBCBwVft85jVTIJFkodpRcggj+R+YIgJFmiyGB2gX+68d0SBzAyx2a8wqm8RTBIECIpjG6+koAgBYtj58EgV1DqDPhDlygWTQxyDS7QBBIOIxLe/wAGAAIxAANjRlomeS/SK57fNyYsQMFsAGlAD9aaBD8c6/MvwL3jrI8QqEMA45b57CUO7NqqVoQIeoZdfcV3ECgcDjxuBP6nUTkxrsPneIsRF8jniiZQJI/qHJnIFJfX/UCnQJR2DfzxIAWWWYBBYLriUZIWG0ctwqgekY5N49vntAZgBektv25iCHHIggGyAfDu/aWGr1BOsUX9W/5gxMcR1EdKD2gYGMh1ZEZZEEVqJcVQn07JR5fj5/iBr+n0kEYhgll1FSsZVll1A+Qb7ftKrVBAnLEHfO6kRsJHIDJDgmQZxeSA6vCCfzcU40GdYk5csyVAZVkMiBwD47fdyoAFj0EPRFd7gXH1dTyZxJtSC2MALN3XH+IpGQzkfQRvVV8UDYI52VsKpMRQUQb9kgADCA0s7fBHMhRADkCvp3/eACBolksvnZ+sGKaxeJAO0CaHJhAgnK0dtak/gDLLpoEgD09P2jBX6gcgrAbuAs85Ys+3H7QMh4hjMI8d+zgaY6QALIciNDJhKjWpDAdN5Yh4pfiVFJABI1dJOQXFEFZH/EIYsELLLp6aUASQSyQTeqkwAxiDu/zAFZBunvcAQAgAaHK5hGsh00z2chEZG7u+8DTu1kNG4RHZoVbPa5MFBeIIRBPz+IFHUQUQ65hKvcYgj5+8ADeJ/UIRWSXjkOyPbxJQ2OmgO7gVLEChX7ydQzyLYr3hVAILJ3VCEBebJ2BfeAPcnZtyAurEJrmOIqb2SvhhELbbJpQrY+oWmZETIZM8wCW68tQinZyFjzxApoMnW2JBWGWSAncCL0rk7ga1WXEIuSqh3/mRA4unZEB1UbuQUbL0+DAlO32BcAwAjQ8iEawLHb3uSoiIyKF+JVX3FcqRGvPSB2kEFoF+GYFDVAAd4QBogtQKLWkZABF2eYReF577gA2WvvAr09mRBogwKK3CIx48iBQRS7yCnXneoFIt/cwgGmLCqA5DRuQE99+8BQGzAtpJMSIoP5hAEbFcCBrY0ZAC9oAd+IQ+/wBIFGqkDbqUX+JEDUBYkFfn7wgCYFdQHG4RfxIKDoyBstqA8cQi8bgC4F/eRAbgWQOIFhEgaGoQ7yBCHmBqAgJA1A05EIRQYCAgJEUQLIEIQKLhCQWAgWAhFEgsBCEiECwLAQEBAQEBAQEBAQEBAQEBAQEBAQEDy2688T13uIT9eYA7DCI1AHtKIF0/DAVsrUKlnj/UqqLpqEQk3r2hUJF+P3gBfpCHmAQIVwBXSUUeOJRHze4UyPd/SAXBOpRHYIL9uYArRRK1/MCd97hRAEOBCHzz7f7gUeyBg0Y39blUOlsjaECO1uBASCE/8Si3egKAkEy1Y5SlC+pMgDXJhURpK93AWii0frAMEnjw4A2Q6UKHyX7Soycrov37yqpxaIZBJkNZOufDlFQJ9JGlepFVHqysJqoEvEAMB2KlEP6gG/zAui0wTUDJWQXSAfEcFyYKVgbAZlgybGKCullCqOjpPqOPFcwA/Sf5gQ69LDKMC4IYDZ9/9RRGCL0IVCLQBAcoj6ToJfQ1AoIJJPbjiAIQPU8iO2/eVTL6WBxIJljSOIrt89pSVAKDDpGtwAx/t6aDt6hUJ6ciCMWKQNwLonCzkQx47S/omC6COpoNKC0OI9IsUQuYDLBh4katRKazWWYGT6Nm9LcvBpdRGJtHkK5DWTl6qPLuVR9OQ03SuBc1s2CbPniCJiQMON2ASIDHJDqbCtA1/qMGbRZVls2PMqtC3jmSBjflVCfrDJyJ6/Ub8dvntDQcm6ZApmnKKjl6C+kt1x8EkAdJx0xVksQGfT/4z1enq0xf/JYiNs9LthHQ4hWcy3kQMgA2PvKrQwfoIJ6eV89pNGT6jicTkTsGUVdKCeRG+niBnv6adsr5qFUAA411AWk3ESs5YDJguiyN17a7S7g1j1NnGjvHtJgozqgW3XJgwzYxSNIslOAGXqQLDQ5ZKjCoHSaB9T4v/sg2WsiSRhSHA8+IRMjVonqW/neBURmRrEhjEBPzG6IgTiBkOxC5HaEAeAUWOkE2fr3v8xg11A5ZNd6Fd5DMFYJeqX5kFHSWh1AbY5hDq2cRkAkyypRo4Y+nIIMndSamsZBBAIHQfeFbrIgvpXJEiNEerJ5PElIwiEkAAZm+2vHtIAI6semwBvt94GuoD1ghE/aEQvIdJA76hcay6hTJCKR/kyIyXl0hYsHgGpTFB/pEFg09SYnq4EdBtVtyUaI6gFiW1CfTELAAD6biqBgPpKGqhBPKqHgyADkMvTtdt1AoyTOQ2L4kFITC6iqB7QillIkjsO/aECCkQCPbXyoDEHpFMCAG+k9KDHmAyJxyI346f5kRWB6ByNk0I/RcEMSLad6hKFVVAEIQKcRkGxqTRB+v1AHEWQeDBWhtHT5MgjugR35uBp+pA9RexShFy9nd94RB+lHvbECjKm3wvPiMELsGu47iQaAT6gwL8QibJ/U9wKyHS4chjQvf6R5hKAgCgBIBI6EeeBahC7YDJaMKXkCQGvEI1iA+na1IGwKS78QK+MTxt6hC7rnSkDRC3CAAJ87qBbbJvkQALFBmQXKhwuHbhAG0KtCMKdkgBuBavI8/tIinXcuAI9V8iAoqz2MIeNPUYNMsks+ZA7O5Bq7oj3hGXyAlVSjRRXvqREO+Gf5ga3sESBTJ/HiAOuYFd1qEW935kQvRhTwCCPeELPPMgoIv0uEBr/UDWxxuAFVzIAgDZuRFDNjiUAa7yC+AnCG9QL7GQBQHHaEUPTgNEpwDRWgZExR7QK+8gtGBBtwiiADcC+1yIsBAAwhAujIirxAXIA/EIuoF4gIDcgo3CEgvtCK/MBAQHO5EUGBZAhCBRCEgsBAQLCKJBYCEJEIFgWAgICAgICAgICAgICAgICAgICAgeWuu89d7gi3RAgF2v3gQ64+0oIXweYEqkdyhkL194XQ794DmsfrAm7pQp9T9NwIO1QBBO40AUQUblUxFH8wiWMnftCh8UdSgNHZ8wIbJRfgQJ5twpYRHPbmBf7roGBEMVY94EJdZMr8SqcA6RowHTsBowacdLOoER5FCUXO0WQeHUEZIWXKbYhTJekpkaiCZA0QsXcDQsCjR3An/ALfahRgE8SBTlEIaRsdzEUOurZC2YAGu6CKECZA9QHULCMsUWwV/uQQBbeuP4lDPZCAD0lBDMGyD9Ygp962OXAyOUP8AsqmOI/UiHsfeNCssD0jGo+iWbBonQqBRfqAZ/aBASEAQQLLOoCxkPSX3S+cygChQb7+0iog+nq2H3HtKJ/UovE6Ce5YQHpPUyMW+/wBV9YUBzTIXeCqQelE0RRFQJkCMurp8kDfy4E5JyPHz+IEyxBR0d71EqqUm7HYVuUT9RRJD8cwB2ccVlzcCJjezZ5hVR9IG6H1hEAZYyAGwDzKHT/60+SRuRdQHJFEk35tyijpIPVtonjiBg9Ppo2WK54qWarZFg0OQSW5ETItHqrRuFXqOWQ6V9T6vMqMAHIHIE8EgjYjjShHE0SKYGn/McRET9PEKgxBJsEbQ/aXRfUCMzgLZNtfLgP6Rx6Tjjly09/5j0rJrIZ47egYXpkWE70T+8BiAOrEAA/kxohWWZIOXVw2HNcENAk4ovk38uQXIEdOQNm1r88QKaz6v6lA/mD+MvHAYjHJAge6Val6QDsHHqTr/ABIpXTYARdCxA0McC9Yi2DxCemIxJGIFfBIGLBJOQSIAe/8Af+48FzRXVWRsO/2hA4kErEnB+rgExoZkrHIAvivxJAyRGJOYAN1p/wAwOmBeONCzV/kSM0JLyJ6jwGagMQDiiECXQ3B9QgFIoj3+doFKI6gR1AhVv93EQGRRTPSACcu3z7xguQHUB1ZALpK5HvJCro5A5MDv3gCDgQCGSB3DhOrnkeo2eftIRcxtHl+YgINgcML8OEMWQUB2Hv8ABJRcBrI42Twdx+FH1Y5eoYkHkKTPUN2S2WjUooOzQPJK+fOZEqNdJBQG6/aFaHUw8QR3Jd/P3iouLAAxCdrvUgAYirGKZy4hE/qCz0scVsxFUIevjsPm4/EMRkmwT4kFrp9RYVPYhGsmEWCrTqBAQG7J/f4pMFyxaJF71Bqj2yJHI4uETZeQIdN8wKz1EYFe4gUDqxIshosSJoEwARxz9HAuIZ6gSOyEiFEUUD2+/wC0GmIJYxfbcDWJGiH57wiEiiizs9pBSgi0N0IDJMFeNQijJn9QC2P3uAAJHVYNHcCjuvvIL7k15hECu/vILYWTx5cBgcVqvaBSCfUN97hA8Ajn7wNY6IHEiM0ST0+xIccFtaH0kFyGrvcCjYP6vaEGEOlqtQAdgfnmQW1yfEChO6MIYolAVIAA39BUoptV5YtSIEXS9jzAFlLcgUU2T4FwNA0NX+0Io5q5EX3gQopiDF45HYwiPp8LvzApTHaSC0Ce3y4FIR7+8IHcC5WPzIIw9wKGZEXHTqBdgsmETl8wNA03IJ9wpRQxyFIi89juQK2qlDK4FfP4kQVQKNfxIB97hFEAoF+kiH0cCiz2kFEIdhAC7gPeBQHqRFxPEB2gWRDtCAN9oFGnASCqAgV+YQBgJAgaEiDhFBgICRD2gUSCwEIQLCEgsBAQLCKDILAQhIgKgWBYCAgICAgICAgICAgICAgICAgIHl+3E9d7jIYpfUwHhyi2GZBCwfbiUReaEBx+0BsWqLoblVnVg6hVJXMBykF3EIH/AKoVEj/iAIJBs9qlgmIsUrga8BDzCsoUeHAq+/NQMqx4HMoGzsV3EBtDZW4VB6sQjf3gMQOB1QNVse0CLuPeFTLWrlEKxsBQJyrXfzAEh8uUMmzYABLDgiNAAkVCnpFnjQgEgPGoDLVpwAZ8d4Agi1xrvKus+wFGBU7IJqxqBTjaPAJg1msjytGFOoZEAkvmU4ZFkgceIBF8EJdoGaIKBfjKUUkhqudSCMCgTW/EoEgkaL24U4DsntxAzz0b9/eMUBeBJB3rtcADkQteHzAoIP8AUYJYo+JeIgDxOL8AQq7L/U7H8GBigFS/Eqr1MmkFoV84gN9PSG/9QGQZ9N8wIQOmkwfcmBepZDIml7/aDExJLIBunCpaCxYF2Uvu5RbxGS2rPA8wBJxxJwZ/nzBiIME0ACaHECA5Y0+nEbO14lEJ2B1IeK1Cl4gkEC0LhQg45PEkkUEK3CdAAupk4j59oA0LBsc8eIVMcmjlkckXiafEqMkYdJI4d9/p/mPVayarqOK4iCM9RJI6L3SlGsiCULD4pjchGchZ5AduF1nIBFo+5Xe5RrEWsjjiGfa+4grRyBHSckN/SQxg6GQtZMu/+SqoH9oJBFp9quBjIAZAPppDsS/EsBg5FZHHp2teRKYrxrEEGrJ395PRMQP/AB4s5Y5M3+mNDDLEBYEAt3+I/q1o5Yj1UDe+0JigEqu+Pf7LmBM2ACjR/V/H8RE+p1AXjiAew5CjFCQCQR6VVr6/epMAE9RxxxO1R/CgUh5k9X6SdD55hIYsAAP00PT/ADAoOOJOQBJYS+fHInVsACjdc6gDkAP1Mm+/ziQUMmyB38/L+0oJkdJBKIAB38uRL4tmux18+kAmskMiB/de5NRs4gZFooEviEQeu1Wvn1jioMhkcRkDrb3Bi5E5ZEXR9nIjVjeVJWPlQMhZArHBuivvKi5Eshrx/EigyGgPfyPpCYvVeKNndP6SCgEYg/q7kwiB9XTYA7+8BiT0E7JOhzJ9DG6JDXwy0awIy/qNXo+RJfEUAIixf07SC4kZayZNhmkVCJ/NDzEVQcssrBJPH7wnkAz09Ncn8QL+rJY7FyCkjp3o1ScIvUj1cK+JDEDG6cCjqCA6ca0ftx9IRWhkAbV/8hAk9Lw+nt8UKrBR/UAzUiCI2UBwO9wJk+xXFyCn0htPVR0UhF4vwSVThFCA6kQjQcC69/upETEoDe6BPMARTGJY13gU2KsLRMgrL6mV2IlRSWfHD+8hhkAD+zkRKRS7SjQHqZPOwJBTkGi1uQB422RKjQHjWjIMkBgkeAQIQYJLdcuFaYrHQ7ESYgADiBkPruBcS9AjyoSqcldgwYob34kRDpVAvUTYsxgHZp8QFkpDe5BUCWWbqEA1yuLgVpoXIGhuv2gU6p3CKNonUBzRviEB/wAkAICiAYRphlXIAu6gAbDFd4MDZ+tQjWrZUCWQQ/xIB2nArfEIdqIkFAoKEBvxAo/T5gB9ZBQWdRUVeIAI6gOP2gUeZENriAontIKdc+IRXzAQH1hF7qQV12kB/DAKED9IFgUrxIiwEgCuIQ4lFkFHcQhIBgWEWAgJBRIh5gPpCNOAgBIg4GpAgIQ5gWEWQICAgWEUSCwEiEIAwKIFgICAgICAgICAgICAgICAgICB5a1RnrvbU+RuBKIKeoVNgQq/WEZs8ISi8s6gQB6HNQIfYCVTjlQodgbEIqoIL+YGTwDXmFCunvAcowJX1EqqPZ+0Bz8/eBCFsO2JRABtMHcCEM6gaO0V7dpFZ/SGgedSgmgR9fEC2Doi9wDBBIP03KMgLt2hUyBZJRuUVonIBDbgCVQG1zIJ/aRYIA+sBTKDhUAJJBr3lAJinUCBHLYJ8fPeUMLLapg9oKZEAgskwoQDyR7HcCLKwyXANE6HAgTLsECk3KrSLGxoyCGwWT3CuUZrElGz4gXIE56APECcBD9NF8Qo+ogJKguJRcgf042BUDOLCBBPkwJ/bsVqFF3HSgtXKhiDiQqkVcjZYIvtKkTELKhWtdjC9X/1xdgsMQIxvRcAcckh4BLhUoMh++pQIGQyPapBk2CBjRJGqIl4qhlA2fMAcSxkTYKDP1iUZ1kACya8yhmAQOkodoDpePpOQA7GNFJIWRILfz8wJ1A4kkdNFF0JREcscW/nNyKFdiT7+ZYI8n6qvmFbDB6jjXZcncIyyfUSMQ6fyoVHkT+r6ga8ShvHqAbSRgU7HSCQ/f8AeQgf0gkAAFAtyn1nIEnAFHWiyPgiKtdA6QEbCH1gZFGyVx9vxBThAPpNGFMWfV6SVs+lL+JUaWQJ30gj244gTWKxIyZYDJg/WcMWshi7Z1fwS6qHE5ZMkbdm+3z2l+DXWP1dTB0ePp3kwPUMAcOoq0Nf9+kIxgGRi+rk2ynzK00Op6BD7syAMsSylnuhsfX5UYiYg4gEEI9ufNDxAEF5HrJeXa4A5kk5f2m1jBjWeRVdPSwiXUmIoZ/p5C/Skdl/FB9U5AE6FbJ95OljIDJ6iAE2Pz+8v8RrAo0OPpM1cMVlkFd2V8+KVk/pix1DIMEeeV9Yq2mR6V0gkj8fSRGlibIBT1/MCdBDTDDbjRS8csn20B8+8iJkeoJ0tgGMwbIA6dURqkYqFdJDY2EZBCQCQDl1HntGDWV5jqI/xCIGgQqqrP8AuFaByzrIaquB8UJwyFrHIAeefMgYMDED9JvbvxFQaxLojTGpFUA2DwNDt9IZQBZAA6KowrZyLyJfcnq4hMUA9RIa5H1+XIKEFgGF+IRGFYVwqkMIEKg5EECCRixx8EALGXfUAydaJr29oRcC1i/5koIbBDaC4UIEpIkA8uoFzAyAKStfzEEIBxtBaZUDZYWTPLkAEkF48HQhAALF134kBgX0j3MIqy3k6gbBL2z2kSoGR1NM8QJt2SOTAosMAX4jgvIOKA+0g0TVqiqFiGWewYIphQrVkAAFn8SIgCJqoKoaIAoGpBQ+/k9Qcoqsn7SIBL0GjepaA4LAIvciCZbgUZA2LcmBx6f1e8BgLAGhcJWkQaXslADJj9oQAoFmQCBe9wBJPq2+IFJPBrmtSCo9JBFcQivf+IEAs8jdQNYvcgC0bXmEMPNuEUt0PrCjHNyJgcaZ0YRURkdmoA2FakF2ueIF+j94RGBofVwNHdk3IJx2gUM7kRSjrUBjwtQhYdFwKL8wCuQV+xfaEBtsQKFriQW/zxAb5hD2gUaMgefMIogK/MB2kRTdwFEXuBZBWVcIdoBwKpEUQEgCVFF+8gOBZEIFhE0YVqEICQWRAQiwKDAQAkRYFkCAhDzAsIsgQECwEIokCBZEIQECiBYCAgICAgICAgICAgICAgICB5ZEeBPXe2BkWvtCiK1AcCjADtAbB5gRkcvxKIaCKgBQfHMBiFQVcSql8MiFN8eYRGyFzCrdEfRQiF9q8QqH6/aFU60LEoEkCzAmgV2pQIiMSLfClAkDh/HAIdHgcKFAwOXAUDVa43AA4uua1AL0utcQMjqARFDUqnew+xgTJDEBKUKoBLmQasN2OVUIzkNaD7i4aTQYS+8ouTAC48bgQUx51AEo8n3MATf6d94EVFLzKoSTXSVqAJP6imRyIEGkSBUBjo0Rzpyqp4rsCpBgAHE5Frv5lFIPI4UBVPegBAnqJIxY4IXeUUhZEEEgCu8CMBWg/T/qFQEEWcTkRyYCwAcQdWNQASJAIt3FUIWKWhoncqA/9beiXuQQMZFsk8fPaVVyIBPLsAj8wiAfpRWJL94aZxBsYZXvxKKSBvZFAcwJkEEAvPhQKENb1reoE6UB0/qBacaBxFephtcRKvUZB6UEe5hU6WfUWu0qKGcfVkSwSQ4+iEZYj9QH1X/IBk4jLpxW9gr/ABLgACgdHg3Uir1E4lMBq4GMWCOl5ZX/ABKUy9IGIJ+LiFUrDHqLXPnQ1946hgsSRohqtxV6yR6nj2/T81KDJL6gyP5PftAgyZxVPheIxWjk/UM790vf8QiZdRPVitXaXvCsvRxZAO+rco2TVkHqxRpEyfRg0SG+UDZqVREdWIRCS0R9IDL+n6TiQ8igCa8/SWJqZ5EXjiEqOqIPHHaIsAPRyxoDk/DHRQDoBlFHnjmDVJeSD4OP5hE6/WB05gmr+fFGKYo4AdWLIoAL3+eIVnHqxGXqBAvdSotA5A5EZbFMe/5kFzOQxxw6F1cBx31A5AZANdwt/f6xitWGWcgO7kRMmAGSGmuPrJBR3xOuAEVKi5sYgAkDEV83qBceVYeuF4kEJRPTihevneQDkepDpDNhuDFKvVdwNd4Q9TSC0iagxeo9JzORZ58/OIQw/TskAcWmoo1gdg7AOiuZBT1Hp5tPTkRnGsCSGCNEyiiw2CP09w+37SDRIGI6rNhmhCM9ORyNHFVv/ccNbJGByoJCmgI6iEq0QCTr5UimJ0GRkuQSYxFIKBxArgyACwSkdpwKQBigQCAgvvL/AFDE4n0ekh77/KkFxxOORCJenq5BrIok4sPYcJgBeJJPdf5gZAZIBIJ5IuNGsvSLxJJC1XiIgdHHQ/1r+JBWvcJMyCkDpCQIIL4hAjEEHEl77RqoTljkigO38wKhZfUBCGAFCySGrgqkBfqr7yDQOWWNENMgOMQxBBaIHj2kRQ0yEHAyBrpraJgay7Dj7wKVjj1LVVsx1AIE+NHxIBDPUKKvtAB9zCAJyIN/BA0CCKBrxqQDdsVtwiPlBCBt0AyWEQZBFZCJ5S8QLtrkc/5hF6VicQRfMIZHLY7fWQBeK2feBcbHTiQQpBW8l31cIDK0h23Bij9KJLXMCJMg+dQLQYLFbkFPUhjRhEdgXUDQqx9JECNbOmjAfd9oFyHHbVwiij2PmQGST0wDJO/NCEV7syKW9iENB3CA+utQNDnmQVGh9IEFDj2hD6wNcd/O5BOkklqBp2SLhB87cgDSR+kIt/UQA78yCnXPaAB44hFARpSAe8oUx4kF8GoQNf8AYF48SIQKdQB7wHMiL7cQLjoSAveBRfNwgIF4vUAvpIi+BAaEgohDfvACEUSBAQKG4RR4gPpASCyIQiiBRcBASIogJAgUwhzAsiECwECiEIFEgQEiLCAgUQLAQEBAQEBAQEBAQEBAQEBA8vX3nrPbTmUPz3ECgJhHt4gRutmFNg2F7QDVV9IE88O5RMvYrtAcOA5Ov5lUAfIH8wCulAIP34UDJ1Q3u4UNMpj+ZQ0SbPZiA8gX3UKjLqx3gW16nAyia78GUMC7G4ooIF+OYGeGD59oUvncC5IHivECZCiKFI1CorvI/tUopJ32/ECL1XZfwS6KWua+5kENbLdXAnOkd3KKPVZ5+kiskjGifn0lDEUx9QYE0dI6PL+VKKVijkE6gDiSCQQTC6mOiDoOACHYP6P6QAIIoW7JECPIZXlzVSquQAY/btIMlFAY9NvtL6GNhEjIKAyyoskH6RggsWOoDbHEoZNJUNm7hVyI2F//ACFwdSwbCHvABHIiveAIOJAXU+UhAyMQMhrx7/P2jVayGQOz7wkYOXUVsCiVzLitJMlkkcwM5DJnk+/EKIlDL9ypRr9WPAfJ25EZIC6jffj95VQpXlVO9QKSMj0g2acYFZbDyevEAdBCshYVGVWWRmxXYntAcCw9IpOBQsWQR26uoVAyMjkMsQMmyzKGxl6swOAr3AgOxeQ8DkwoXi8ywiy7+bjTD+ot0uzqIIvSwyV7P55lUwIJPqd6Gvn+JPg1iOoB5FEUANj5zKiHE9TxyQ7ryf8AUeLpWJDGQJKIaEHWDYrptMd/n8SqZMdWeIYLFhv6cQRKByzxadDqe/8AkDRORFMM7O5BACUcP0tAKVeLgMsMS0apaW4qdZAOSLTHPEKx/SzxLIQJPcWP4mrBvHMYvpxRoUGr7j3kxP6h0T0kZbPcF/8AKhU6TiPUQfYdoVf6mXqIFr2ghkywyxvRgTHHDLLnNbDdfSVKrJZYPe/naRWsQMTejk+1/wASdSqcXiENB44j3/3CIMsQjiWDRV6uMUDJIyQ2Sr/P2io1gsvVlZJt/KkSs/1Mhju63v8AeWTSNYJ0sMuR4kpVRxPSa/t9PI+KEMicE8WTXSIOiBBWV71/HeQX+maIJCAPkyFGKO3ymdftKhhkelXiAR2/EWAXjk8sst7dOBvJBhA/8/7MpiEnJdWIHn6QH9OhTRHaKGeYWQO/B+0GL/Ta9B/TwS6ipVvILFED2uBcsx0hH0nkUZDNXEZDJpjwy4Sjs9WhyRIKWMgMSweSfH+oREOrb37D5cK0QsiH+bkRhlmiBjRco3QDH93O3IGQN35Z7cwCFdRHuoRreIB9I9pEB7E3fwQUyQBbpEsQKT1HoRAtmRFB9m2+IMOpogi9/XhQIGTTHNWvECvpRJRATb+sdFYtELWi5EMScmEkduCgRBYIeg/MiKzjRa16oBdJf9wLrcC5n+6BUVqxyZEMTbRN86gXEApu9XrxCBDybIEgvIPSCWnuBCSgyRrjfy4FLsgomlz7whV5YgAntA1ZADQJ05BOW1eoGsQcQgfb99SIg0CSvPaUMCTsEE+D9oqNDI2gfpIB0QQjsiQCFTJgXI2R28wgeQ9eYFxAdYirhDglyKoCP1hFXVqzseJER6I/xCqAefeoRcSEyt3BUyKSH2gaH/1RkqBopvtxUCkkAJHjxCFauBcadGSlHrzcIAkjw4BAWL8yDRMGJdAwKP3kQJohP6QAQ5GKgXYo1xcIrY1XaQB3BEIrRL1AvNSABejAU1CF7OhUC0qkBf5gUe8Ir8/aA/eRDXEDTZSqAgHqRAbgWl/iQH9oAXUIv0EBr2gX95EVwEgCEqheIQ8wK5A94CEVwLAeYCQUQgHIiuBYCAMiEDQkCAhCBXIiwEBAsIQLILASIQgIFgWAgICAgICAgICAgICAgIHl16Z6z2wb3AhtUxKIewhVYsh3CJYD4hobHH0lQNm39dSCZDik9SikhlJwIgPaAB0mpVLXEKAgmy4RCiUK7wqPQdwCVa8doFO1W+8Cfi7uVTqOtQYHF4pr25jRlAAlY14lF1+l/aD+obLaMAS3V2NQqbvRNwFP35gMaCG+a3CpYqv8yivbR5AgSsWASIE9OtdgJRWAf3q5AIAfD4cDPpIZvxxKqplO9PUAQd88GBHSJHuTcCaKvq/eFTNgUhfA3KQArigoFCBS8qATXVfhuANn5UKyD5H8D5UACUNFeZQAv9NwJjiEXkieRUaAIxBAogO5RGAQE8SWIVScsQg0e0HTIUWyLsj7QRGRizt1zAqIIKFi40TI2Sa7wQ/qI06Jv/v0lhExFjsCNj9oVWSLOOluBjLHI6t65llVUeMSKVuBq3yCbcgheRIKv03KMglq2eYVQulUQdQjJGIwP/tsWl/mVemCOTHUGNPcFF1IDEEAc7jRMg1iHi+T/qIaHIMrHpyJ0fnaUQjIYdQ9Q2oUy6s8fVZejj+ITgPVkcgDzYL3/EKZAnII0C9V7fO8HA5vqAKukKjAyIwO9tXqonqpiTR6QvPft94oqKTNXQZFa/MomJAOskq4+cwIfUcf/XbHP3lEBDxCJfMCoPfNrQ9pFi5HEJ5Dpe1XyoGT/wCpGjY53AuZzfqYFgHz3csPA4g4AZH02lTr/cbghyQyy6iEk+P5lAh3/TxL1+qF3/WSQSySCgGOR8MCnqyZ6S76SF8/5AhBI9baZKgTFZGh1AvYDC+fmLFXF9IABXm39YDIZD0v6Ed+/v8AzCKCRkb6jZAXiBXiQenqR101+0cGScSTicS+BpQN9SI2hx+N/WTEPSQSRiQbrWv2kDFc4EZcP/HEqfwCyIxZWnvjx2ga9PTvFm3yK/5IIP0nFhIf28wA2Bjj1G+kuA/qHL9PWSeoV/mRFxVgmxXfj/sDWOXqCXjtJU+GK3RToBAS0Vv+TIM4lHe0SVFFZCDGqY8OTBrFtIE9oSmOOBHqeerTj0qNA4jFIaAfMqKyMwsU7OOk5MPge2JBBPEg0UHe2PPtIg1gVZJJoyjVsXxpyInU72t9Nwq5EZIX0vjUIY0lQY7XIL//AGLFa1CIR1B45UeXQ+GFUCiR0ilShGiGidG2ZAf/ALEAaf7RiIGCknzINAhbbqx+8IFdBCZ7/wCIDBZH9IevxBVDK47AwIR1LEhYntcI0cmwgMna+akMRHpo+raMChnFMt9/rAYnqsAEeNvvCLkPUD533MgvV1HIXuMFyIGhvxIhidFgDsuYoJjpDPgHmEMckdDVOBW0eNjgmABNYqpDGgA9M8lbhAkAjaakA1R4P3gC2jY0oGvScbscOER7FukIGjehiD5kRNhokKBbIJJHi5AX/t8MC4lmqHb59IRQCAAl4gCCDsgj8SAKJTfmEUlgkij3gQsPqx+p1ArsfiQaezv/ADCAelfvCATSqBQaTNyA977QA8LwTxAEdnv6Qiin9pABtgwig87gW+xkAV3gPvAoPmRFxS1XvAnVseOIFZYNQgd7+8g0RCJoLz2gaqrkC/eAJZ1CGjdeIF+8gEDepReNyIsgDy4AfiEUEKoDhCBRZkSg94F3vUgFwHHYwgL94FBe4F3ciGyRApkAe8JiqEASDAu4CQWA+kCwhzILAQi/WRCBYCAkQgakCAhCBZEWAgIFhCBZBYCRCEAYFgWAgICAgICAgICAgICAgeXO/pyJ672zE83ILpOBk6oalAjlXCntAaLuBAsfEC8JmBnTqVVIq7UIyxXmFV8j3uUQb9uIA6CGuIDz2EKMDt5gClYCHD1AJkkv7QIXzfaVTmwSBAieR/b6RohJZVeJRSR0Vr2gQkaZUKMu78fxAgBB9OxtQLl+qjQ4UA2ASWSalE1yDzuFVBAftGjLB2i7ejKGyMTV/wAyQQHYXOnKKWwefPz2gZuun6riFCqL8IcwIdkAh7lVTjSB6R3ciKvVQXA8mNGAOoWQCbfz3lUC1YdwAIx4Q5Eo0SGGBiBIJkKBA+nz6QqJgWSRowJZ9QClFCDx1wvIgZCFh13gDbfUeOoGUQp0gPyYUyPqVJ0SOZcDNC+CyFRMkEyQJBPqdeIIuKFIWte6gqgIBl+FxAzl+q8Tv7SquNZ2TuyoPiVkElbX7QM5IBkgDsPaVWj1Aavs6kDNHBI3oV8csRCWStCyCYUOKHpvne4VMgigDjSTcIzgTdWLlVo+kBh33sf6gD1HAgBJWoDLEkAKy0YGGyMtfXzKrQHSXiORoyIzWJQxNUhKsECEB36b0frAgJxJJx9X294GyFgQmid79oHJhY1v7cyq2HaBwP6hIArIvEMVqjqBMxVdOK4Wrl0iMC8hYGuYFOXSXyE68RAyKeR6atL9vsI6QGIZOTN08vzCoiLCyKY8e5lCwSekEBi9eY0QD/8AJllziL4RA+alPjGfVkSRR7eP4uOK1nkf/FQyQ3ieB9I+kif3IYEg8H3g0Bsl2DyiAfn7yiHEmgbx+jvd/SNF/qL/AMpLy49LkJxRlWJPV1ZHn+flS2CPpH6mw/0/PMg16ViCWN3qBMc+rCycsSCSMr+kXwxd5AFENggedyQqYDM5Zel29G/hio07HqR5R7/iQRj+oR0Za2X89pedGiGBl6ijQ+v/ACRGUTkcQS96gazGOsshiCubiDQv1axQA7Dz2kRjE4nED+plRtx/BsbAOG7Pf54gHlij08aAqEa/8jLJYx/9d0vzqMTDPWJYBB0Tyf8Av4kkUAHSMb8EmQAMjj1GnxCK94kC2K17wM0MeroGK5NqPwVUR0PENd4FJZaKKQW/cyIuWR695DElJD5xLmpi5vYBPYHg+8kEKsBlnagbBI77F/WRBDFGzkEb7QIS/wCp+kEvZgXGshZI97MgpPV+oBtjzAmRxTNngLxqBojJUn3k8QJeNC3wdeJUOTx4W5BVj/aQKev3k/oFE8AJPE1KiYNWu8VWn00DiUbHa9yIp6jgjQOr34hFIoAkd9yCbs8bhVrqrp6mF3hB2UAaW4RQkgAG/pIHqGRH9wDjBprFBUSRzCYyD+lCzIrVkIoOwjzCLYJBPsZEMjwy5QaHBpDtIYvV2DXaMMV7LJP794QHSCf02VIL4BtP2gB1AkhCATyPt9/8wiFkl7gaJOWDAv3ciD9aAD7Exgo2w/eBF51YkGijmSBdQitAMIk/aEGFRNiQVgLt3gTAlUCOVFF57iQA2b8uVF7P9pBKy3S2xA0RQJF8OAFlXIilHyOUIFolvhQiBAWCRCtBgqpES2xZAhFBv/2XECnQ7+0gVohQHkkOEVwF9L/aQBQYSgXzIgf1P+ZRT4H+JEH9j5gakAVoeYBl7hFFHVQLfMgn0JMovG5EU2ERANn/ABILXtUIEu+O8AH3gH2MmIvG4FpSB/ECwhAo7QHhyIsgSi73IhowEIsgOBe8ICjAsB9ZAgIRriRB3AsBAcyINQNSBAQgIFhFkCAgWEIFcgQLIhCAMDUBAQEBAQEBAQEBAQEBA8wff6z1ntIG9SqH8nzAE0LFyAX9pVQiveA55BgNQA9oEvqe3UoFNuoEx40IAZVcAWRdGFQWmRuUC4USDJgZ5uh5MDR3dciBBp+OLlEv6HmFLZCX1ggedA+8CpFcHvKJYzduBFToj/MKhIBveoAbvZgD6jRS0oEBC01qVVQocDzICxBo/wCJRAh9O8AOpch1Kh7AeZFQ4hekbl1TI0BePg1AFi2XAyRqn3JECkHQJ9hKBA7UKuQQs+oe8qjKJXHehAn6V53AG2D2d/vKBaPJe+329oVnF85WOLUCloAbFmBA7Gw+AwYFC6hiXelAInEAk+DzAmfSiTkANlbligZPpPU2SIAgoAEXoDt/2DRhIsckQF5Bi2agQD1EktnSgL6hjoukOHKqhX6SSOEKuEZD5AbbhSwRjkTf4hVq0GSWAKhERs8821CmXT09QHYfT+ZSMZdIwQfQTVyhraGPlLcihxPADP8AnmWUGFgiSuO0CkEDkhIFgyCZA0A/VRA9pdEXqBIt0RGh+nEgrtVOUUA8kB04NZvq6gSjV2SPf+IVT0sFHV/PvIM4p4gnpVlCUTqIo42EUZV60f0LIgZPjvIM49IGOWWRIBbI0FL+AcSQsSx/bzBKoAGLAJ0CAf8AEFZxbJ0DxiCZVXLo6y0T+rFKo+HqYLoJJHUO1EQJaORPp0WbhVIyOXC0OnkeISIf1HEkYlvVlQrS6cvSQMEkB+mOoxkBjnlkg9Ek6qWe+KBpj6AjgwJlkMcukgE2O30jBcaIGX9wTGjBUyH/AJMiSyBXaOLwxyIY6QCCwEl3/EpWvSQGunHgv45EU9IyBAyvn8wGOWPUcarjZXeSz6Ij0ooOlt+N6/mVFLX6ukcsSClZYOke6LkDM9WOJNc/+1bl/ECExi+pWjofP5kAFYggrEDb+OBcsQUizxaHz/EaKy6oWFsyVAgnHqaOx4PvAoyYyLxFIn28SAfSRW99/n+ZYgDsePn1gU45JBlnZsnepBnAIlgvENqKNEGsdF/eRFBIdsOjofLgaA9Yx6GDvx4hEGHoR1q+INMzh0k5dRdkCmomjWIJyHT2LYkKEBjF2bFKkoTVYAAQ+nPtIKLxJB50eIRAAMiWyU32hVLaJKbfiEaxyvJD1f8A8q3IlSwLK5cKhWJGOXMDfULsM3dakTjNDsD9nKNt4sY3S9pEZKOLxHpeu3vADe/YD/ECorf+pBQf0oF8/PrCLQCfYbMBRSIPe9SC7I0Q6uBeCP1dnCGPBOVHmRECYIrVSq2dg9PH3kRMdgFmnXMFHkAuR9RJ4K/SiSS9wiYkYoI7agUhtGjUDQXSwGq8SImLJdnuoK0cgSSHkw/aEQEDEgm/MCqmdaIkBElksGBUSV6j2QhGtZcrkSIhBBYG61AD6v44FLBQBPkiQQUnY7wLss/Rwig5Akc7gVjfapBWOrQe4RBlZ/HaMF8MOBfLI/mRBvHfiAJoNfSMCjWKgXgeO0iBRvtyYGtnz2kQVSgyiyf5kDKl+YRRyF4gVUhqQQDdfWBe2LhAc/zA0H1aBHMiAFeIUJqwzJEUBkcQKQGi3uEAfrAvF0XIACOjAL6iEUH2fdSAq8ShojtIKxCH5Mg06hEfZe0C7u4BQKOENSIagVhfvIECjxCAUAPaEakEB+sC3ILwoRBXEooUgvtIgIF8qEQFCBrzASBzAvMiLCECwEBIgKgakCAhBwLCLIEBAsIQLuQWAkQhAGBYFgICAgICAgICAgICB5hUp6z2hDkQo9njUAFx/wBgQ/gSia2X5hQQA4YfeBA0HqUGhrV7kFL7CBlI3coHZf0gCCu5gRC0Qf2lUsA/hQANIC4UxBHMCYpJI6cAcd/HAEFWK3QlEBaVXCrjZezBSz23cCGyilAYg8nxKM5XlShRPFdteIFsioEIZ3vmAosF95VQ9TuuNwIg2iK2IBEnl+0Cm08gt6gQoEAJeeDKBxRAojmNUxYsAs9z/MALYTDFDiBkpAWL+sovViCxfy5ABYIslaI1AhAAaQfbcqmQednde8QUAXVk/mBkHIFGioFZaK7QrOP/AOz1fng/FL8DIekr3JJiC9Sq2/vAA7BNe/mBk2bAyKahVWWJd2a8yp1CR1deW4MTZxFMfiFREss32hVBJyYFaHp57QisELYGzAyAWhRH7yquTp2EeIGcmCBloWCrgMsQCzaKRPm5dXphiwMgASKHMaAyoNgcnQUYAx2MW+V5gMQRavT3qAuyixRC3CjxFhjsz+/2gYJGTIsDgUXLwCBgCEVo8P5/MdDFgmtDR44jQw6gRQJBuXwT+mGGwuQzFAko+nFrfngQqkZX6gPK/EngmHpNHqJ5uUCdliyguO1xgmQIwqsjqWLqPEvLE+p7X+YAgdOSIyKNQKMniBjrvx5cYJ/TAxB9Wx9u7lpVwB6RgcRiCDjVSfozljicX4o95dxVvxkw0x+0gY9WSYIRZQ3zAuD6qpPdV94KyCSnnYP8Sri31AdXgAfK1AziACXm7L5lEyeRJByANcwRRj1f0yB5AriBM7CJSFAnUETIDqTXubH+9xF+GOQvEijybfCjCmQsk5iwqqvpKhRRIHSmOPlSK0MHkRbHmTcQKrLqySZA+bgD+vEYUEiAORcI1liAQd4g28fzJomFA/pxJCblooyLOj6gS6+0niIf0gHHZ0D9b7yjRyReOPmx8UmBiSeoX1EI212+eJCt309XT4ouoRMkf6jbdd/v25gaxILVkmyD7lyJjOHUD0ksEDXz2lo0CesYtnVCQTAEf1PUB2fz6ReCp4kY13QLkRcSUcQHZLf0/iCqNl64rzCJfVokm/UN3CtaLxNcI/vIgMkerIE5c8uEwFnG67qQQYt2T7m41WhlkT1WjQvUMqCdIgY7cCAca4+sg1YIOOgDUARkKs48LftAEAZUPU6Hz6Qi4BB0CPpIJaDBWiZRQiUw+77yI1iCO308QFs/+wpPYkQBCaXtxAE9TY0EjHAI6Qxixr3+KBcWMiGGveAHUFYHSefxIhguTfIUFaPWiH41zIgefWVf3gTBA+i3yrlo02yLfYa/mRDJdAvejuSdBsGiPMGKQAMlRRF6hDHIlDQ4/mMDDpAYPH/Yo3i/05IixIlSjj4VeJBR7jVuAAJXV3e9wLiLZqAY7lg7hF/u2bkAdOLswiFE9WnCtC8T9/pIgexr8iBUOyHIhAEhgioAgdzl9IFvZH0kFAdVIiUUValFJeQ8V2hGjRBuvMgmhZXeoFDZ9/vCFoUN12kFeXAUANHQBpwjXDqQSjkFAr/PcQhiLQsRRdZWfrIGLGXfiA2F2hFD1IK7MCa8QNU6/wCSIBi04DkXUIACBRt1cgoPx7gKdwi8uQEeLEC81uBRqREDqUULUiKK5gFAPmBfMiGtQLqQNc6hAfmA+sCsQKPGpEIF4kB1cIphAHiBRAokDixACoRYASBAokRYQcCjUBASIAqBZBYCEBAsIsgQECwhA1xIEBIhCAgWBYCAgICAgICAgICB5gH3E9Z7QD5CgU7J/mBkdiIUC0l3UAWfMCfVHUoC/rAaDr6GFLOj+IErTP3gBQAB+soipD7RobADHiAXB58QqZU/4lgDv+IAAa78QoSb1CBCx4A94VD3+kA+x1ADsYVF5vtKKQXpK3Ayekk48ncoAFEI+BCmIKIppbgTJOxxuBX4buBCL0l4gSq4PLlVaJ6ddqECNMkH/MAQAagQj1DYf3Eo0+pnY7OQZyDsj7SrpR1vzIICDSalDIkFI/XmBMiliK0ZRXQWRUgycch6gunvKuqEd0F2gHkL6PK7QIdssH23AZcHqQOzEVnEkk2me+pRosM4g+SIghVAFn3gCCbZ8IwJiCySOkDYlVdAhvjXztAiCAZBXz9oB2SMa/2oEQoM8+0ASTkh1Xp34gCniTQdD8wIa2Sl84lXVZAxZ6u5W4GX6wS32BgW8upHvf2hRnpFojg8lf8AZRnG2Dj6tfWAG+plElsdx/yBc8gOrIoDwLieiY12QF7v6wI+Mh1aZW5VFkbGt+30gCcd5Hpy01xALqs2SupjXy40Sk2z1IEC2pRSOrnIHuTqQZPTeJHnpvk/iVWQKxwxBD0t8wNgEYko4+RqQZCOIwaBusdD66lnhV6MgfU8gbPaVdT+o0Qjk3qSBjibzKGQtXUuiAAKtsePMaKcl1evX8xgZBYWR2yAxv4YIzkCLXPbd/PxKrQ9XpGJKsBfPEhxMa9N90YGcscbBrIb7CWLrXTk/AH1H1+0fEZJBJwONclMfPrH6rPSWQQHkgA6l0+L/TCGWOWQ10motDIklIJG+yo/zGC9VIAXZZhcZz/V6qI2iL4cEC0CRlirJ2DA2+o5A9QB5BNV3hlAchixgTQAHf7ajxVI9Y6QXaQ8yCEA5B8hkDn6yjXU3keQx1e0icMgcjfqPZrUGoMh+kLHLuTfMg1hkdJgcERUwJzZAXi3Hgn9QlDA4+kXqh3iEaKABPUB2PEghwy/UCFoDnx5jUbxbX9R0Et2g4T+H/5MR1DpsPdO7jw8Q/8A3iTxtuP4KUUQTp1uQZwDy9VElnbUUbzrEkIActSRA9JsDe8kvzHouYHNv6L5/iNExYyOWZDHDijYKxQ6iNbkROkIYov7wKMiSSAPArkwigA9KxNc/wA/WQTeaAQJq+dQfAkA4k82FzKnVrq5Nd2vzINDqxxxXUR55kRL6gUz9nCrvqsj3+kIo/TtHGqgTElnEp6gXHjIjKzqrfwSIuWe8mchVftGHDEq+BqqkSgyOtgVcKo9QOXUNWeYQJpZjL3hFDBso8n58uQOAmbrxAqxOwB3L1AAgE0PtUgCwMUF2epUaP6Xl09pAx9QA9SItVHEp0jE7B5LMBm1V+SZBRimSfVAorp8/mRFNAn1ASgTS6iT27yJgeFt0IFBfj6yCiqpGBPC1siBojlhdoRGWiK5kADdgk8wLiOkEEmKitlAggyYKCdj8CBCeSioRbTI1bEC0WwCJEPUiagXZGr8yBzp1faUAfoTIi87Z8wD419JAxJ7qUXkoiRDIl3obuBr6XzzIgRy/pKKCjf4MiCOxkGRAB6QPaQCqJgMd3zcDRBX+oQb9pBSB7wJjRLsxRa4SkRa1AM7e4RRxQUAd63ID0dyi86GpEUaCX3gLY/EAOZBf4hAP38wKO/MiBKvnzAoPNwGvpAuxIhYpOBZA4gX3hC/9wAgXiRF3uA1qQIRfeAHEIpkClAe0IoMCwEgQK7kQhFFQLAQEiLAsgQEICBZEIFgIFhDmBZBYCRkgUGBYCAgICAgICAgICB5kbnrPaPMghFqUQgqoUgB2EBvGwIEd7H+ZQLAri4DYYcKhT8wCItiBdhP6QJrYIGpRCa5SgXYqBMvuPEqnja4gTYS91CoQePq4FR23ynAmle/MAfsRKqAsHkmBS9D3gQ7/eAH6iBa7yhR7d1AyxaFwqgEYsjiDUICRb7wLZrvxAyMh7PvLiqyCrkEtgmh7uUDQ5epRBu+NeYF/u5YgQ4ovflSLqC0AbTqUXFEHYej9IE2S7B2oEbbBK3KKx1I9nXMDNn1XvTuVWh4ydUFIM2MqJyrtAvSTj5XG4NQbDs9+whV3ROOV6UIlAHE9mvEqo2SPNHcAASTkACFbMAV0oOtMqAoFk/Y/mUQgA0+kL34hYYjLpskABAjmBMuwAYsWIgz0npGXbTlVo7YPq+f5kRR6RuwNbEDIITJpMeJVp0//QLDWoNTFEkMh37+0qmJDGOyWLH7wKAd9tjgQjOWPrQy6caS7qo1UIJAAIB2nCqr0bs+/wA/eERf2gEPdSrpiScHkQSm4EZOez3sQL/UBAQICAVjvEIhvEEgDadShkQ0gtE+ZFQ4oMZGxwPn3lJVABBCZ2uAYPUDDJAQdYnj2gMrByTr6vzBD9WKGPjUKmRD2Mt+nn6yiriyQSmKAkGXnlj0m7TezL4YmWKZrEAI8xqqAKzxyBO/bvH4IUsdL27fDKLRHq/toEaECYZA4kAsk7ElimY6gsUBt7EupDM+ola/V94Ux/WcQOkOgQ4RMsgbyIBAdvUsmrxkZGxjijtgJQrQxyx/pAkjR0Vr+Y6m+pkAcDj014P7xp9VFkZVVjj6wrIyOJ9WBx6uwqXBVkMukD0826/3Ih0kEEgEEsDERRosY0LNHzahGQscnlRBWNKF6oyxOaY5ALkRogIdJr/6Pn/MhqURiCOmmzQb/EouJxOGRyxABr2r/cfxL1cSCz+oEo6R+hkGeo4skAEEX1Jn7yjZyAPqvHpYr9+JExm0cj0gg6OoHTHpIeOWTIV0ByZKnrP6cgcciiKJygWujpyyxsHZj+C4kbBGQ2zx4ko0M8Rkv/I8n/dGICiR0lbH31IJiT6qIxNgj57QY0McmwsStW3CajxSxAALAdwqg4s5Vk/H5kZxSLeOPoCC7agTHE9LyLxXpD4i0XIsUQQBRD5iQOlYuhQO9QauQ7MHT+e8kGgBiP8A6WxIiDIAMux8/iCxo4gWyGwWOYTUwRJo+499eIFxyRGIYGt6+LUFi4iyQfUNrmRGc+k5+rIr38fPvLBU0Oq+ZBoBkFcd/naRE7cD38Qqg9OHqJad0Y+oWc/7gd71AuQrfARhFN42b9mpAyNo+2pMAgaDa76hGhyOTfwQCLaGR9oDqeOxQS8wLsXXEiBK99IioFAT4vbkRMSSAGPBlVcsT9qQ5kRQunqBIO9QhaG5BRe/V5gMdHFFnvFA2dp/QwLkbb1+YiLiXkQK7KEGxzXKcmCdRseLuFaQGP6mfz7SJtAWEEf4gat3CI8gbDfYwLo0Qv3kBEIm/wAQilqoC8Tb8eJABsj+IFr+2uFCDaB7e9wLiT0l6PaEXE8+eZBL1XinqBp2919oREQGSi+0DQRFBMSIygwQg4GqAR7doFx8UNyACGg/3hFabS94Ac9jAq7m5AvSX0gV8/FIgduhCAFPb4gNjx7QKq3IKfaBfjkRAUGtiUaIEggO4FBuEUfDIJRLThF3UC+agIBoKRF5gU2PpIh8qFHCKvECjtIhY5gXcB7yC/iEO8IDzApEgcdoCBR2hFEBASCg3ciLCAgWAgJEUQLIEBCAqBYRZAgIFhCQWBYCRlIGhAogICAgICAgICAgeZI2Z6r2TUKhS7yhrYuALTcKHW7gTIByh5kEX1QlDu7uAIe4Up6uAG24AltIQMkLf1uUAas+ygDZJC/3KoX9OYACwkveAOV/W4MAAaGoE88dluFQ8ka3cBT4EqoGhRCuAOy4Ed7RcoENgpc+YFQZ2CdyB0u/qpRkLqQcKreLRuAAY/UDAAWnfvCoD1UMjR8SoE8bp3ChsWiX8uBjKiViSeJRrQZNiwIEWLsk/mRUeKICIlFWKCLGz/mBhO07+0o0ggCDlw+8gFEqiNwJeunpAIYMqiBACS1AY9OZIOIrdRwEAFqmoNZQJaHbvLqqQSmz7FSALx7A1uUMjZeRcCZDJ+nEBePneICx6kGl/ECkcHLp8alGR/66PAIhUoMMJ2CIAoC8g9KAbytkbUCixyT54gQ41ZoUPEq6mRyf/sGN1cGBo66QTAhADKZPb8SqPpx7O2OYTFyFfpBOkQ/g1GjOT/pjTZs9o6qr0/qROr3AZYhHG2R2/aIJ/UAOVh+CzKsAGSQyUQuZBKQAIWI0fnmUSgCWLNkngGAOJKJ9nA0Mnklf8fKgxGH1Xq/EKznkcgfUg3QVSwxMgMbo9IDQowKP0+oE17fvqBC8ySWgsQCPzKvDIkksocj3kgqBILxAToJj2lRDmSRlZD2KcLnjQAyPSQcQNdt9o4frOVZDJ5NE4h7gYLvLGqtd9SqoyBJJPhgeYpxFkRgMsbxsHlwJkhlk0Qin/qFiaRWQuyAuP9SjSsg5ECyAKfxSaGQxeQyAB0T3gijEZMuxepTiYgDMnHFYNksj5uAZI0OrsTY+XAzh0HEHrJGgT39+YqtAYlNLg8fO8ImHqYJyCPJK/wBD/EpfPWmVWlZTALkFJAwvK3RKXiRPrn/UYyyGIByJt5e3z/MvixtjB7/8gZFSI1gMX1DDLI/b/UhU/wDJiMT0sYJB/tLYik4dIIYGy+3+ZD1MRkQ+SS9jfb94GgF0gAEHRO5EG8ukEkAOMU9fUAUCF+mE+K6Z6QMTsfaEa/pk5E9eNA/f/MlS/gKZ8bGnCsq6YOqCMaNHBgNF9z4/7JqLoeoI5VriAOyCCwGTAZ9eWVZIiqO4ieLRy/TSv7QLl0ErM2ONq5PUASD0lgk0pCjWRvLfu3L0CcQNknmAJHUcj72dyDeLRGiKLOoqJ6V+oGxQgPV1UewRuQXK87T5AgKWRCNQikkBMmmtfeA6uMSAdUYTDJ4g9KVHKQUgDEA7OlA0QC8butyRGcv1AgeRQUEXEjIUu26gq0qYQ0oD9IurerNwnVQAsggcyK0MiStefrIziAq172oULyb6jyoQNFgknEV3gXFjFp8MwgAcnkfA71Atkst+OZBeQcsi92LhA5GidPmDGhv1BdvvIIUC1aK8QiG3l8JgXHKyCCeJLADIxxYNUHzANEl0frApBOw77wjRFvJriQXL/wCtaYEIuIb297kEBBJIXSLgASthmBcOlCiPEVFx7qjCGKJLAFyAyLapEwL1Ygb3ou4wTIFlc+IFaCFnvINBOgPrCDK/SQ+IBhApKRBVe3bgXS0B54gGH9OZBUWGX28yorQuRFxJZ6uIAH9nIGz5gAAqI8wi+/1gH+0gEM7gaFloKECgURID4J3y4DyvrCLwgCYDypBRqKAR0yYQVvUC8+ZBWn/MIcQD8wKa0ZEVjW3Au6gQm4AKRFECyBxAoLhCBRfEiHNQKNSB5gX3EIfeEHA0JAgTiEUHhQA94FkBQLIiwgDAsAID6SIogUSBAQhAsiLAQECwhqQWBYCRkgUGBYCAgICAgICAgeZVT1Xsmx+JROdkQodQo7HiEGHuBAzZhQBHf5gSAKdyqF6uETHkvUqqvikCtQFM7XaBC9HTlEBpHfMClXoQIb4XvKooAn6+YEy7kV37QqcaPeACK4u0JQRdEn3gQDuq3CqCw/MBsavwIE2CyP8AcoYnzCs2AQgjxACiOTApA9h3gGsUtbgZNBgt7lVrwiifvIMnEEB/vLoHY89xAnDP3gUAvdcF7gTgA9LJ7SiVbsSKp6n3rWpRN7v24gZVn1X47Sq02AUiODuTiJR5b44lVRkBRt2BAzYYscEOoFNLPqxAgQPzZ96+OVUPqJZdd4FJJRxxYI8wJj6v/wCS4gMSUj9juBTiyCRsh940YRyTo9nKrQAGBf0I37iERABsAu3CoR6TQyXb3gMS8WCT3PeWhgE6BQ/VuKDB0fh94EY6yQCx4+fBCnSC2b5tfNRogvXsTytOVU6R1WEdhGBS0Se/b7QM5EjIZJ4jTaBqUXrGOR3sAPUmHTEEizdr/kWqDHHF9iaWhLuiIh7K2u31gU2SwTZkGf6g3igu30lis/08sUSciw0+filsRspo7D7SADY6QRz7/WBnFdWWXT7XrxKoi11FHKhXeNDEnHFG0RxWvzFFOY9Vq6Q187wYM5F5IclXUHDLB1RPO+yjSVklegDwARf+5Vnpke6INrm+0KhBAZC5T+d4ECKOYIPVZFP45QxxHW8HiQOflRv+lADi8TasgjfziAxKxZogj/Ig6tnHpyZemfHEKnp6MuvLIDgLlwJiUQD1Ar8QvWcXiD09IZ7C5aLiAF0s6BOQ18/mKi5JvQ+r+cxBBkccUP7BcGMkgB/03dl8syr/AF02L6SH383IidOBGLxHVyhx/mNFyKIxZxfD1IjIB6SdgW7e4VoAAt02Pn0iopzIA6siCSbSQ+fvBi4j9XpJ4IXzvIVCySeoErk0H/2UAv7h1MMsfO0iHSMjkfUTu/zGjQyJwAyQyxsAWrkvnEwBGWQNsjZ49oMXHNOgSmeR7mMSwIIJJAYQJ8fKjoPGs+o96x3GCjEhYpdRfz8yAESqsME/YajgpJyAI6RiRyu8mIYkH05/qA5pQNYdXTogG1x94qKqGRAI5v8AzIJ0tDNOn2j+Cg4j+mQbevMJnolj/cL4kDEsHpIy/m4FxBOGsgquvmpah/T6gD0kJJ8yUrQ9Q0fO/wCIEfqJRopvmQaQO7PNQjIsADga8QKh1WASbG6/iPgpBGJ3R54kEsZdYCrt+ZUU5HA5HpItMyZp1cQv1bLsyUUoEn9+IQSB8M7UChskAd5AyPDo/YyiYFA+gu1FRvZ7ni/xMlOoMNBd9Qi4sklAn9oEQGTfPfUC45IbaO/pFRTl+oFln5/yDFBdkvmpKBGOuoP95EGR6RXAAMoPsW+JBTXZm/eEEUDkGjuBQATXp9pAXTyUL3uBcCV5B4iooBSW/wDEgBAFgk8AQAogGAZH9x3AuNI40OTIin2fhQIzocQgSOAu8DfzUiHYbPMAUx2O1Amhx7QNBP8AjmRE0ALLZ+kDQ2e/vIJy2ityijuveRFA3W4F/tR3IgO6XcyigkaEiVDTf3gVhAoviQVasb3AC/t7wDatQijse2zAoBA/MgulCIPN+ZBQaW3CKq1ADSFe8CgVYUgD38KBfeEGfpAoHiQQdoF5hDiA8uRFJIZVQKEAoBjiBeJEWQQwKCbCuUWRBwKHciCRcC8QHeBX3MiFQgDAsBILxCAvcCwAkCBQZEIRRAsBASIoMCyBAQgIGpEICAgWEBINQEISIQKDAogICAgICAgIHmhrTnqvZTR1KGy4U+ruQQ65UB+r6yge8Kl94F4/yYDjdwMnfNSqK/4gBtqAUCA0WPeA3uFTuAJUEPvAIrsq3AWb7+ZVS33XMAU6/MCb2Wtwo+DAP1GAPNtc8yrCh5gDkHseIEy4t3EE3dvvKpRNMj9oQoIQo+SBUAgA++3Ai5HtGgSB7cwqHLkAsjj95QI8WoCmd3oagAXlWt3zABZY2ACql4IWNkjuZFQpoCuYFH6LG6feUQZV2gPotQBIAZ1AhFUR9ty6qdQyB45qXgg2gdHR2oFstZE0SCeIAHHqoWODChxIrnXeDTJGyAe/dQBzy6TQA0FBiElBmlY7OMEO02BzCogN2lKKCUORbXt8+8IYgAtIDRHMKZHIg794Ed+nK3QUC9WLLJHIHmUZH6Rid7Ou0KY5EYh8n4YwAdEI+0CJnE2zxKo2KORD5gXJdIVhUjsQIFkFkw+DxAZXiCTx3cDPSS7YVty6NUAsjiAdAh/zAD9JHKT7GRWCuoj/ANaAejKRSFmUfURdwpiSCCaPA/33lSp0g2Roo+ZOCYnIYk9lYr/veVQEJ52KtSKoBIIAHSFx+OJUOkG1st9oNZGPptAAgAD5uXVPSR1ZEB0SRr/UCAEHbAIT2RAhIYGIGJPlo/DKQARWXUx/7DcKrvovIc71IIH1lMX2oSilXiLGNDEiyPrAYkAA4A6rz8uBDlsgZ2dI/vAmR9QGPU9+VEVB6gWGuWlcoG8sliuqyD5/5BFGQWIX1VOMAZnHEZEtDgVtkwWKekY9QF8/Pm5BkYMsC9EFy6q5HpyCBSfOuYkRPWQCMLLBVfDUHgQQE8QF8A+0CvEkkh5ZaeqkAEHMZE9IHq1t9+ZUa/p5HLEDIDHIivToSUsMgMVvyQWT8cguRJysIbMAMjh/TDX7H6x1MTHPYI9Q4elGDTbFHTRfeEUlAlbOv2/eTArIdIyLxsBwM9XWPVifsl4jnBQCHWQAI2KXbtCGCOOQxeOKP0grQy9aGKyD9jINHAArnuEH3+eYTUOWiwg6MmCnLMvEm/09KsQmQIIAJbGIf1gUg45IMYrn5cUgKDGJIAC/79pBQShvkkGoTDEh9VEf295BchkQeR78wFOmCTX2gVpk4nW9jz7Qhi+nEJ15+bkDHI4gBl6inTE9SOOT94qKmQeXfvCqLFYkI8mwIQyIOIIGPhyC4IiwqtWBCC9I20qEggxCJ/St1KNgpWboIa/EiARxOJuluQZK6jQ7Cq+ko16es4g+pXILi8UTtfSE6A41Y7b3JgDqGJt9nKi4koNnjdmQUMtFAfDAoXYWfrIggrLLCEaAIAeRIu+/vGAAjRKYQhAlkDRKaEBiEUB7It+8DQbQFPmRC+p+e8CgiwGADQ4koOgUqowD2enZ7hQKbIAHmEBYLS1cDSJyNI81IiDLQ+kYKCRiwzUgrAApQYBPYBhFJRoa9oAjIga7X+0iB7Pi4FB+5kAFl3VocSi4kkLIlmRAoaXt3gUvqD95AZGK34gAT2cIoP8AHECk11b8whRYRq4EBJ3z5kwVEOlfEIo5YUCs9SVjRkFIGoRHqBS+SWagEh3Q+8gUCOBxAvBIEiKPzcFUVf4WoQ4NwLvjcgMhlC4AaGlCGgoFH1HvAotfvIH2FwgTXaTBQe/1hF0LgFzAoP1fmAHtIgy/eBTtSAKv8wiwJoQNCpENeIFkCAdahF5hAFwL8EBzIChFfeBYCQOYFBhFkQB4gWAgJEVwLIEBCKD3gJEWAgIFhByDXEBCJIiwKIFgICAgICAgeaNz1Xsoun2jothQJf5gTwJVBy4CQMpVRfvKFriQED7uUZfqcqrsLd7kECLR1KKfA9pAKWvYQG9VAl2eJQGwK7wJkARwoihb79hKIkf5hQtg7+sIFbD4MCXpD3cKZD3Ae4CtcCpVBsjjxACiyL1uBMgimUToS6DN5HFF3AgRNPuIADjgPUKbCa8QIHVk5cowLiz5PNwDIPKfaFZIdgoEyhQRWtDkwGItN1cCA3se/aUMh6QS65kDa2eO33lVCCciP3gEwT0/VQJjienlv6y6HBZOqkFxQJJWkSNmUZIQ5YL3LqtElpE9wZBEUkA3AZdL6gfEETMg/wArjvCgGLACRFOUTIErIkDzzGkUdRCJP7wMlneRNVlcouJCOPV2qQNDK9uzCoWOAPY/xKL/AHLuAAIGBvbI+qlFH6T1ZE2gtSCBoA5UrMop9QBXkkQrOQ6SEQiyAPaBoBAIjpFnmBkdRbyR6t95VSiEBVfBAuP6TyNa/ECNA+pgHbjBMzx/aTxzzAqATJAdM8fDAhfSFlf/APGPFVgoANGn7y8GLP8AVPpPUfxHwU/pIGgVfaBMQCSUQjVJbl0q5An04gXeMkAnlYs66TChuyhXFCUQgsk77Qqj9WIb8p/SEZz6Tj1EgAPdxFXJ45E9Q6nQPHz6yiHFer+0U5DUXrxOOQCe9zWinIEMAushfP3jhjJJ/uOPS9rUKf1AD2TSB4F8QQBBYF46SpQKASSEOndioEHpZCvm17R1UyAGQTyBy0DQEo0Mv6gByyOHU2enmTxMYwWWbAROr0ZavFxolmg9IfT+YAdJrMouFZGIeONE47P1RlNX+n3eJ2ye2pCtAnqO96bVSCHF5E2CTofiVIgy6bOI6hWIOvqYK1/TTHTkwRfH3/ElSs4jIr9QxJrIY/t34lWtZjpxDAocmz4EiG+kIvEr1HUgoxf9QgZIHy/MouIzOOVIAd7HwSImOK/peogXyfK3H0oRiMcsTpa7QNY5AMdXX0vFcm5KmJ0joYFtg8CNG2ersXdv6SJgiQAckifK1cC5pdayHDSEYQ/qElgjhmv2ggDiCOAlrR+MyJiFHHE5ZH2lG8cSAsn7g67bkGenwTiqKsVKi4kB4kZbGxMq0wMckUC73UIZEtEgkME24TFNZDhgfaBnEgZEAljZevEF9UHEYsvMEoFyehiPSGScVrv8cVGyXhaQDMgmSbBJYf8AiBrXSsiAOBzCIAwiSupuNUOi8Vp/PtCLixiSGvn4koMI8gae4QJPDI2BAqxB1zocL4ZEUkoAZZMedQY0CTSV8wjCyOdjZsuFabBCQB1upAxskkWdXvcJWiyFoHvxIBJIJ33KUIptHPtswJ9bOvMDWILxA6lIgSOkG/AAgCQMqyWX3gUhWNNKRD+4WQmBUopJOL6U0Xw4EvfUVzUiLkGXu7EC4mygRIKP1G/8wAYvvyrgMgBkCAG7faEUE859WWxW5EMbysAE+IFBRZZs7MAx/d95ACCHA5PvA1iwNkK7hC2dNyAQDZ2+8IAke/B4EFijpY4rmBAGto+YFyoKvbvIijsgEbgEG3RgUAosj2kQxA6U77AfxAunXEChDTqg4QVakF54HPvCFAWYFJBtAn3kAv8AH3gV3o+fEIlBNvtA0AALSkEVeCNQKKYIgV0VqRD8/SBTWV8wgOygAQBVs8yC4gdvpAcDxCL5gXzdSCBfRwLfMIDX1gV1/EiECwHhQKPtIgG/EC3IA3xCKf8AsAD2MC+8iECiQD5gCoRTCAgW5A+8CwgC4FgJBeYAdrciL7wgIFgICRFBgWQICEBAsiLAQECwgJBqAhCREgacCwEBAQEBA81+J6j2QiUNbH2gREQBRHaA1UKiClUPYn2EIh0yoUon94FoHhwJf17yif2uvMA0GLgDwQ71Cpjq4Vcta+0Iif08wDNfFKIA0DX0gTJF9+JVinkEQAHn+IVDpLUIKoVGN0u8AAik3AGyQDKsAtPmAby0N9+IEAJyFrxADukXAySUQn5lDIU+feFTbv2+fWBo344SgQbBOVnYX5gXu/v2hWUbqtSgg6BA48wBoBEgBQJmSCOoNSwU0WiXcglIo64lVSTY1p94Rk45bXV3G41T0re6LHeUK2ht0JOiM9IB9ktygP09W93Cot9RyHtUDToOh2ZUGISCieO54gMtXz4hUIBO+FqVEyNI5E+O8Kt9DRD/ABAmKO8uq1UABSAJd/zKMtAk+p2DCrkCxkUfDqAIPWSEh43GjIHinSuBrk9OJQsdu0CbXUAPPeFTK2AfTpD8SirIBlZAW9QamQWJLf1qIaZWjkC+3eVTSBYHvUgiBxHfgJOUMgiR6ixS12g1kH0AvfbcK0U2a5sJiETLJZAMk95cVAViQSCkz5gUAnEpsdhfHEGs5AgdWIIR2e38S6LkyAelA2fHy5BnAoLLnhm5V6f1GQGepaAKiBiA2OmuE794F68vSTkRtgfxBgAgOvQGwVxGjBIIIAZ4Pz7Sq1kcurQIf3kBCgci2V1XKazmScekI9PDr2iDSHS3zAz1UcwD0+xP3lEB6cl1BHbVQqkdeeYDB0aX3g4uPTlQOSBZ7Dle0HEJy6/Utuxxf3gZxA6xllkQXsUB2lVpH9WYRdESEcs+vEHGlx3fwzUwayAOA6gAV7SEZHqYLI4HZeON/iXg0fX6ich7EELuZCfgEBhkcsidZF0JRpEdWJFEqQ6wQQySAO1ff7Qqj1Zg9Nca/PaEaySxQWkrfsJIjP8AUOWBDWWPD+vz6SxWz1BZY4ggj3fz/MiH6hkscmP7UfrUIuRNjVh9n7rt9YJEOJxeWOWPUD6mUD7mOi45YnEdPUnfLe5KYpLWRByt6EiYjyAx6iSWvfVkS0XHIf8Aj6wjvaf+tSZ8FGOJfVicqYsfxAulkQAfAoRqAzDAQBFefb95MMXI0iW9mQU9JLs8PmE4hFdPTmVoHUC//wCv1APLgQGPSCQXkXYPI4389oSrh/644gg2bgqXhgUCiHcdGiPUMiQcu5EiB/WSMiFoSBiySgCC9e0DROXWekAc7+cQiA66iF3HMKuY6u67cfNSI0BliCepgWXHU1MgBiTW+30iKpdEhkSIPEFen6fgwAIOIHPDgXJNAM5ck/xCIH0gIk/+sDfLOJ7iREJsUV3+fWMAMYlNUDWzHRReKZY4cIEHpJCCPEClkOrRMgYAjj8akoG6fURweIFxILLP8QgzR3sHge0DQACayCkRGSCOPMq4rLrILiRFAApEe3EiBJII5HiUWk/t7SB6iOrpVa1CAohE3uBf1EgseXIKE/0q3AMjLejCIE3kzdmBvX6iCfe5BkjIBA1xA0Wg7r3hEHLG/n+YF3sXxxILQAK1RMIun2NSIh5LMKtvqP8AyEU2hs1qQTJ4og1xKNM7xIakRdti/cQGT5a/BhA4oUURyoFBYCH5kFBOx+8gIgBAlc9pUAxi7HiQULVGoC6OzCAPjXiTBTrvArHbxCC4SXLgXi7J3IAo6XvAYl6IhDQqnIL9bgCuo94RQ/8AsClkmQAwtqAN39oRdaNyBxTgUfeEH9ZAcC80oQGuIGoRL7Qq6HiRAdoFIqRD6wqgGEPaBQeZEIFHiQJRfZyIQFwiyB5gORCKLgWAkCBR95ECIRRAsBASIuoFkCAhCBZEWAgIFhAGQagIQkQgUGBYCAgICB5rxPUeyfSALXiUKa3AjgCH3hUV715lD7wHFQKeIGR+IUKLxgL2alBkhd9wI2wHAFugG+YVArMKcVp8GECuz5lEPix5gFx28wDHatiFQvejKoOYAscUIC/0jS3AiBI58GBTX183AyaBv8SqpIPECJ8QLkVtqBGCQwa47yhkfSGNd4Eyov8AEKzlkFQ0L8QNILweHAEEu/xAmRYXT73KotcAiBBeQIH41AZAJNkaBgTHqAO26EtFyYskhiyIEe+pJheYAkpEUTcKlD9NCBNHpZ76hWnZCF94RCh6UEoIBYkE06uVWRwSfuNwARJq3fiUMqoi9qRQ6QCHHvAHq/8AbcBkR3Fd+JYJldstKlUB+nLpxBfcwJmCcjYXZyy4oLyORr9lBwFkk4WYAfTH2gAbysBAPvAyxWJT2EIFOVWEPeIGTFs9jLFAiekY6Nk6gRp0fF7gRAlpEInzKosQTbQpBQJschIHJiAJoAMZeeRA0WqJ22oGbRyOidHg9oEyJJOFrYlUBZDs8rY/zAtmtE2Vz83HgyGRmenpx2yfrKKTmz0khFsdtRMExKGWYF9oVkikwnYSgXIjqQWibrjagR9RBweIT7sV/uOCkbAIrvo9oXU6kOoYgY7AI1KYZdRxthnjg/FAX6gWQA/9SCZY5s5A4nEXQf0UsNG66vQk3x294FxxeQQIOPk+0aamRASOPYjalWJkPSQ82TydSaKcjs47bK+eDKQGJYKpWT3+ONXUyoknEm9bfP8AECHLJjqx/SK4EC5EjAIWOx+0pjOZViyEAHW4PUzyyIKx1vbfiWQaIxIZ2dyESsgXmUu4Wx+YUORywQxxAIJ9/jiRFokPKhWQ4EH6f02xmGGXkdX/ABBeYuQx6SmCAeGJIes44HHHIkLJ744lvprWfSB1F5UjdyIoyF9R6gCBiFq9/wDYRT/5DWx1I3x8+CNgnViSVy+fftJlUI6ScQMlvfPaEaGfqOIyTs3IYvWygXrh+IxFxHTliRiyaoOTomPBeXargqYksggbvz5/H4lRcsiD0khlmuZMFPUaQX7d48F3rIo9u8gpyABNgarlxiBRFskgDZAEQwNZdGAGPPz5/ohkHmSSu1aEaYMdRyzTjpxoZWeoYM/eTEUEk+vcgDJEjIkeO8FTqSxyOXd/Plyi9R0gfHMhTJNgsityI3iScqCAvqjEQEugL/StwKEQ0AgDVSBXUfTkT5UDIscAUDdnvKjVdIxS/Mg0wKB8n1X5kQsDqJTNwIWSa9Ko8QqjgkPW6+x+sMgZ2fJPf4IqqGRkckBsd4qKWSbIVsGxJAxJRITuQpvk75DBgayJ6lqvrCJZLI6ae/nmBTXK/wDU95EU5Zfqse3Bg8DiSFkHdxoafbYuQUgl5DKtgalQFn/57KBrEAkUK5kRMilaOjwICulJPzINPLzADexQRgCSD6US+DCAJ3RQo9pDFJ9IAUIZFdgTqAy6iCB213gaBCf3kAI3faEGSLI12jBQt9tyIY96rcDWSuke8ggHSDpm3KKUqDWwZEAUTs3XiBSD3oGERgnW4xVIsgCv5kRQd9uYF6r+0IrREggpPcAGN0P3hFJtb5cgpbsi4BAwL9IQojQMgE2AChAu8jbMANs3IitUT+IRR5uAa39IDVKoFZkCjqEV96G5AvXfUCur7QgPH7wHvxwoF4/xIigjQgNe8By4FEiA/ECjln6SB3+8Io15gPxAu5EL5gWAvcgQhA1CEgo94EJhF4gWAkCBXIi8Qg4FgICRFBgWQICEUGAkRYCAgWEAZBqAhCRCBXAsBAQEDzR/M9R7IUiZQsQLIM8ygUKF1xAf52oENCVo3/mQUfHKiGFQ+2oDRpQH8bMCEFgWtGUC37iFID6QIwchVwGuPtKB2jAcIouAN2DCslj5uVV4ThGTXtCjI0WbgE91viAN0fvAEk40DuUQEk1VhwqpGz9oEIBKBJHaBLXbyZVUgGkWO0Inc3CoCEhb5uBFtUBYEBaIFqpRVe97cKhKYe/MBm0lsdxEFTo5HUCHpBTb4gQrqrTEooZJ7fmRWQAMtLt8+sopOydO6gQ44o9JDI3GgAABt1Aj9X6v4lU2RAZitK1BEAZDRvcoZAsIlnv/AKkChfn4IU/uXmgRqUTEijseYAAek8/kwIyMgbJ13+cSgB1ZLKidiBegH9RDd1uDUskWiuYUOHU7NaPZRpqEEhHEncCHLHpyyAv2REuB0kaWwHu+0Lqi6H14qBB+oMJa4O4D+oReOAde1Swg0iGuqrswM5oYngvtz8MRWiEAwgKakGVjiz1YhjZDqUDl/wCya9xAEnpqgD3YiKEngkikFUoiQOJ9OOIDPeBcsVkKoUWfzBqZYlsaOKZ5gQUGea7VUou0ClxxIM9ROeNfXUqmTALvHgn2/MClEjErICr4MGBWIHqbLJOif4giMZAkZXtGq7+8KxmMmOldn2Z5lg3kAMUXWzofiQ1jN4gEOxrv4c0Rb6SAVRRPaTVxnIAkHPVq+LlFKJAROPspBXkcEFiX3uURFhjp9QL4yNx8FIxwyJ6ie+gY6QQ6kMVetQOZBGKJAHfZlnVa9Jy6SBlljpnUegSGSQsjSat8fOIEH/p0EA98bcH6iJORscgYmn2jYrKPTkjooGt/F9pRvHpT6gArA0JBnKsiBT3/AI/MdI1/UfJABxZLL/MRI0McMsgGTVXq5EM+nHJgG9sUoVMj6xkiuoJ1aj4jQtgn0sUTuQUV/URxG0KsR1AZHqyPqySKGzGDWQw6TiGDl3HPtCIgAB0+rmRWQQSycj7hwNsEh7I5+ftCZi/1LwaBR+g+acJGcd4skjqPHz52gUrLICnokF/P+ScGuoC2r/PvIFjJvIAnbqETDJBpe/8Aj6iWjQXTi16f8SIyQcM8ULfzf0lVr+neQBLY40flyVK0sB+rI0aJV+8iegBpk4lbHMCnHEsaBoXqQ9R0QTjTslxgZZnL+lll0m+/8S56ipUDTVd/8SDQ9VcDk/tIAZyHUPbm4D+pkSenEABMOEi2MQRiAHQgT+o+g0b5H7/vEFYA8CqMmDQQxY6gDziIZQZc7XIjFwIKBruFzILZIIfhnmEXgg3iAEoDIAZA0APyIRSLdCkZAGu7/wBKBX3NeRIICTkNLZcoprX0kRQQ6/TruIMU+lJ+Sdn3kQo7rJOxxAmQJSK/iBopDR8tk/SRGcqAP/JRpURr9xIFCyjuvnvCKdh6PBkDqeKOQFuXBVY6uCF7yC0CUzXc/eEU3lob3IIlinXiBp2ca73CD7hkyACX06HZwJskm3qBeCj4EI0NsgtLUCZNpSBklsJXUI0AHr/sgpo0PeBMv1Akc65lRcU2dSC2Mj7qRDTK++pRopaT5fMiFhYqRUFWpRQRRMJi5fTciJiqWmYFYNfeQVoQFN8QAJ3CNDQB2JBLBCPMC48O/MVFBxH0kDaf3hFrlIwAO7/ECknpNJwEgo90NyIA3KKX7SA6bG4QOoBr/Eg0dWPzCI68QLAcuBfz2EiKa+kIsioIRRAAl7gX2kQBtiBTUgcQBhFhCBZA8wHmEV0oFgJAkFhF5hAGBYCAkRRAsgQhArgJEWAgIFhFHaQICEWRCBQXAsBAQPN1dmeo9hFwoUNCAHvAfvKIUwu0BsDjzAHsxCoedmUNjiA/HvAmtke0KD3gL1UBkCaEoltE+0APggNKFAArNwHvxAiQ3Cob8+FKipfaArgfYwrJ8NdpVNg/iBT50u0DKpZbgXyqVQIQKokmUMmgRpwJlyQASkoUfJ15gFV3GiJ5kipRcjiB1b5uBn1Mls7hVNV+0CAMINeIBgY6H2QgDZC3KqENsIGg4FIRoXEBEhE75I/iETPirsxFTLGisteJTTIrI/dwoFoN67QJ6iAXy2NiAOSByKarxKKADzSutSGs9IQBbH5lFyCNnjXBgSukdL7qFZxWNkHXeUaPSToLiQiFaOn73CiQIIlEKZvX48QCZBBeXD0IA+lAGu4gQ/8A8GDw+8qgbxBLCJgTKwFiqYgU9DPp9J38+0CYsrXST9FAmWuoDXYOFUeeoPjx9pUQFMOx54hTM6JHSFcEVHLEAkrxuNGSqx6slx5EqiFpJMP/AFAEk4BkpwMkGgl//EbPMC4r/wBiSEBTgGAbYqv5P4lEDa6vZCRTIdbHUgKJl4FdV5FH9+8CBA+QQN/O0KtAjn6fPghDHpSbyXU/EohWJZOhzzIqDHEAANffn/sCl5gVk3BwOKQAfpHx/WXQYIrpNscQrB/UMhiQvK+soqGWOX3sa+fxIGWyQTkEyiJTUxAGKyR78/NQBOyTjprkf4lEyxQAGAJ/+tARqrn6gwWWWtycEyyJBOOQfSvp/iX+iWB1IraTd7hVQGO//wDrUCHEZZnLIkDQJKEpwzyGOHUB037xmkZxDJRvYZ7KFayWJGIA4Add46jIwyP9qHIaUarQ/qEYv1eCbIMJiEk5jEFZAcm4Ah5EkIZUAPnxwapJJAxyxdEDiBrpIWOWRDF9/n+5E6n9UlYkgOyD9IgZY4nHJHJADmBf6mRxyIP6TdwRXif/AMZA8MtyfqVlPFE+kHWvMo1lkRgc2TkQF/j54k/ExXhvJgLkjxqMPUWIX9M4gkBgfDH6NZjEZMI5KubHz8yRIA4nEdA6Smu0DOJ6d44kgH/UDp1jJn0oGud/PzJmGDxBQsEnXzUYABA6SvAHNyIAgkmyvDR7CBQMSQMT05dzsRpUzOOPpB9OiHfyoFByBoYXuk4RcQsgLKZIPHy5AyeQxaBVL/EDRJByPQAORqRExJKzJptvj+IKZMhiyPYRBcQecbNn/G4qAQJx5HK2Pn7QNZZEkMaFgSAMR0+qwODXtGoUwOgo6hTZK2Q8QnUIEjpHUdnvIKjkQNrt3hOGJFgNsAH/ALBVJRRFkSIoB6k8jGioZkgkoURHE4g6QXd1CrjtdIYIGvniQaBRriEAcQOlXsP9oRCsT7CqcitDppAeYQ2AShy3A1SACSA8SIgyYKPmxAEEnq6QxAosZbEgUX0o1qEMaC2oFJQNnWlCLYA6UHzAH1BW3qTghPUCiWtwKGurftAtYjtIioHInL/MIZ5LHSL0IEC5K5EDZNrH/MggD2vIMCgnpKH2hBsga/aBdkk26riRBsoG4GkKBvwDIJkShEFIxLYhDI34P1jBQbSXkCQF3e9QBJ6SQ2dwi9QG+3duBV/aA1CBo1IBLHYwgCQasgQKM2d/STBWjrmBR2BcIgO6qBQjWnIGW6H0gX1PcIooiQLK5qEUuz2gMdMwGxUgoHs9mAHIH3hFJZWyIFCEgj1QUC/hwhr/ABILuEUdlzAQAX0gWjIgCHrcCjtILCGqgPaBQZEX3gJAEC7hAagUXqEBUgQiwG4DYgXiQIFHMiKdQgIFgICRFBgWQIQgWAkRYCAgXiEUGQWAkQhCBQYFgIHmzzPUeweOIC1ChfMCKtXKBu2/ECNb1AfsIBezAgTf+IaASDKiMCwIU2NXAa8wAKBgRfjtKA37wq+e4hEXP07QoEd3AIhD7wIdDhVKGjuBAgDAG+QRzCoCdK+RKqhCAQ/5CM5aLVwqgsAc/vAhF7X8wREB6eZVVrFP8QIb8uBCXi+CJQRIuBVZpKnAz2INnvcKYF7JcCq0OOe8AgB1WSYAhbyuFRLJ/wAyiDq2aPDgLJsewgGGXVd6gQh8lC5TTFdT35Ei0JxRYBgQ/pRZ9pSGWAa2u8aI36qOS3uUWqK3yJBDjR4RuVRAMp+V+IEQrpAuiflSgSAz0sD6fOYAjpOyT/mRRIoGh/jZgQ+nLqOuK+ssGckuodJJtmUaZKy/Sz4kAI6Pq97gQEIL1ZAeCRKBORBVvjiFwSPTXTyI0QA2jY4hVPUA2yTZEIn9jYD0W4Aj+5kE7qVWSdsEg8bgXy2Bw/5+sANC0QKK/mVUrLHqOIDA3oQGIIut2veKM9R/Vjjq0t/P5hVBOQRQzCPmELGi9Iv8wqXiDRZ0f4lOnSHtpJwJi+oBo5XBWggOpBEb7fSBkI+s2SK5+vcSi49JBKtHYkKiGOQxJFbBNwu6lEB6BQAHtKAABKeQ8QJQwyKIZ8eYX6DIH9OZI5HJUuCYnIIf3dyaPxxRoEKseQfMgoAa2SDqoHPK8C8nfmppWgaxxpgp6UiImcbPgi2iZVF04jEAooDJUZO+iMY4dPq2efnwSjOTNAEtb+d4ir6iKCJFi2fH79pU8QinlkH7/WFa6WT1AL9OLDgZx6csR0nLHItrn6xwT+iR+jJ9Wwpb/pVGPqWOQQ1ZZkVR0DBjHYe9KE+mXRh6TkSdHjUek9Dj0/1GlR4s1z94+G6YDLFnIonkX9IuCjZ6yO6fvIBO8ssdCynZqEQdJtUL7e0K2CMcicqHDCkxL6uWZRptIpwmMMDA87ZacvaN5Y4jKlWn8uZIgyIw/uBS7SnVGQ9PL3/EmCnEHEnLQy4LcaiogZdILe+e69oQTRQA0aVfvG/AOR9VArg/Pr9YxF6RjkOmyTwe+5FPSDR9IoA6S/MieheJGaJHFhDmD8Mi8R0kgmyU3ApJPSc8kci0zCRcMsMh08iuZMKYlYgYhEDuR+eYRT1ergnbK/EHi0Mh6mBx3kEAQ6QSx9oFIQYyd2XBAEHAgGiONxiKRj09dg9wRIICXQeXZ/5gaQXVse1GEUWOkug6kAZPHqpkBqAxrWTux3lojzIGQoiwHuTEaxaOGRRrjcgKh01iUqhC8Qq9Wr5g6vpJKOu9wAxPViEQ+QINdAwBke31kRnGh1L9Q3/2BcMgjwmtSJRAEAGhwqhegNA7uvGoRQmwHxe4BrHKtnvIAINgGuDKhiwsQfrJRoGqAUg0CDWytkwjBXSffnco2CUMb9+0iJ6SuRxA0QQsUUdd5BKAQHPeBNpK1A0GQtH8GEK6dyDTsnqo6R/MIg9WIBxPvAf0zxuKVodL8cVIKP01jsOECcRSJkRSFl+wgTGh+pjuIF0WebkBkP4YDfGuIGgUdH23GIEnQkDWOq9pUUnF0dSAP0rxAoJpCEKTKKNQKiiu7+siBaDNQDNqQWmgRArBNfT7QhosK4A3iKI9pAqnbuBcSwl9ZEAa4gXv3gX+4G4QEgUBUC/224RTeOpADaG5RfKLkAL3gAahAb8yBZthwijSJgX8QGuYF+kiKNowL8UiJqBQYDR5gUakQHiBeJAHdKUPEiKzAokQgUdoCEXxAQEgQKNSIsIA8GBRAQEiK+IFkCEIFBhCQWAgIFhFEgQLIhCECwLA84d/4nqPYTmAgQwqoagOLgRLdSiGhQqAHntAUlahUEA7HaVQfmED+IVPr5gX2gTtl+FKHg/aBPFBVAHdfvCncqACXtAmmNkSiGwlAIcKBMgXS3LFhzWtwoCyFAHjUBQNqBMddr0YFLJH3UCENpsKVSuC4CwWe/O4RFsHfaVdQMgb7QKQhQgTHEcAg9zClIII+8CvFoLVQM5B5auUgeqid/dwqWAifzAZAK128QFIIsA32MoUv7ZAzHVeyoIjdjgfmFZJPSiKXaUMsS2SFqNFNqvBB3AmO8Uv3lFVALhq9yCE5WbC5MqhLAAcCZZJ/vLAw/UwwNtwHSOodlqRTEPFEl7viBcsWl6fEDCGSDtUdy6L+goDySYGSKTIvT4l1Q5PLjM2DAaJarUBwS+a94AhvdDgwKTgDwARHT0I6cCCvtUfV1nEeps5E/8AqJQyyIxCIWoEBT9XUULhTFAUPEoBAnIgYwIWc8QNaSgMdEM5EXYgDs9OQIBHKXMCeko3pr63CqQF2eq78QAyyKIfUTp6lFBO8iyzZ04GSOMmQq9vCgQgFnAAjmoF791rtAmOWCIJDHB3Li+owyAWQk/zAEkhIeT2uOAekIBB+rVfeFTPHN+nIN1S8SwMunb6QACuD4/eBDZxY6fwt7gMv7STwL6acKDMDL9TK0OblxOoCAC0C2k67/P+lDkerHI5gZcMwBAPUqIXPEgpAC6QQj2pykYrBHqFl9NEeFKrQxF4ntx35vUiM4Y9QQF6IpqXVrWYNohjd+e0QMADijgMV5EUQ+rFLF21ofHAH+piwinjRHb9owxnIHL+oMQibdrUqqQfS8h1cI/59pETp6Acctc718cbqtkEYPLqQP6iHCIDjkAcWek75+sCjIE1kzsVZkwXJEBZAHpd/wCftIgcnlpZEIYkBky4J6+kg6VgFr/EIHAM5E14Fq/5jVdLKWIqiCKXb4pllnAo4h9K8fv84lWtDElY9NrRA38EiJaJBp8FsagUk5gBED5+YTMZzyIYBpb57xIq/wBNHI5dOIA2oqVsDEf1AaBISFfP9SfBMekYokDy/wCYR0yGOWIJKt0akRgYjIAWQqPHaFaLx/SEBbEJ1hD9KDJYAhWupZendj1CRFBIORZKQFfWBQkS2HUIZYs2A1Ug0cwywSFY7RiYH04lZE8+8gYgNjqyJBLJUoZElIkEIK5ABGLAJQHPEdFB8CquQwfS8ib8SoAHLPFP2kFwQxIA8hwi5I5GyL0RAvZ4orUgp/TbAP4+OES09ZckwigjEdTp/q7mOigP/wCvq5BSCWQCFti4C2e6MiGOSBBxII1UYKNkYgjUA8iEdcn59IFJdI9z4kRMgzWR2CCZRcjj+o1o13kAsLqrv4gVsDZQkQ6kXZ89/m5cOgPdsXUiLyCy9scQKwQqGiJBT3RC+OBAQLBLJ4dwjQV8+ZBMbp2eHCVclsZB9+8DeLSyXb3kEs47flQh1hhg2H7QYhsi67nmBUKt9oBIVY8SDVJDvwbhB1pAacAC6D8SClEK9QgCSVzrvGAQQLPFwKtmypBW+dQgCk2oF5AYBXeRACpShZQNSIhdrUK1iWWdCkpEVjqgAQAu8DTB8wiBLxIKQfpAnK3ArLpiRFHJEIAjzAvKYgUlHUgFAQAApAfWEU39KgBTQMChyB+YQVgyCj2hF51AfaBeNSIcKBQV3kQhVhDvAAkcQL37SIQLICgH9ZUW9yIoLgH2EgCEIFFwLASA4FEiKdQigwEA4CRFkCBYQgUFwiyBAQECwiiQWBIRZEIFEDzv4nqPYTjuYCtQHMCHmFC+0C2PpKIR4gQJnUB9IAiVUB5EiqFwIRObEol1UKt8pQJzuAIpauUQEk9oFHavKgQb94UQ2QPtAC3UCIrz+8omjYgX7+FAzkK1LF0fUD1C4UHIPEIIA9/xGiIcwqrF3xWoEVuvvKBZpQqLF8eAYCziVADbH3ECDtz7yqpZ5A+kiJjpB3KqL/QgXt/G4AXr6QJzZbdSqE2n97gZxQCJ32EoDb0qcAT6wEGtQFdQr1bgCDpokfeFARbKfECD9LBKJ53BqEHn7wqgs8vvCJiiekLu6QlE6rBKfaFWjYx3Vj5xAACwLZuBljrfSSBpHcqmeI6ToEaQiAP0oNd/pAZA4hDT7QLllSoB0YhiBAgk2NQImLYPVx9ZVEQABZNvvALEDRIf0gTIEZtnwCyoIi/V1O4VT1HHhFI/8hAjpeLHp1y5TQjLsGYUBx6sur6hQIbQ6QHswIg6Z9gEPvKoCU9edQKCMgFjj4fMDLPUH05Uz8+bgT1EDvsM6EKoP/3TNL52gMkTbI/e5QzCQyBxAJ1qCM4s5FkgM6+ghVBNBnJbPeEMdl07O6qBQ+kks89/aBnEkkumW2q4lVAj/TXUHw+f8CABILpH4PeBShwCHX+4GSAQNHsuTqXigJ6DjmOwa3fn2j+GJh6TkjapdvjgX0g8nHHYyuBMdHICjzviFUIZ6L0PKhGQLogmv7dDX+ZdUPUSMScbx+/aCKOnqypFaAoG/wDMDJBOJ/ZqFMcgQMqIFgu/2i/4HTrA4h8ekxpoT1PqzI5FymGOkj6iR2/bzADFti9fPvBrJ6UqyAGjCriRkDej4rxYi+C4n1UCSWPAbUJYyOnqHS+SEGa9zKUxIxAwy6zVtVJTGhvwEkLMgdRP9XEDI63wTHwaxJYAx9yOT/P+oQzxoDJ62+ZNIDMWcmSSCw1CYuP6WMemwErigQqPH3kAHbxACbJ7+VKH9LMZFAgYiyb+kZiUGTyxO8lRXz4pDHQk7OPT38SImKXp/wDZlsKABPWchgDaA18/5KGePoybrRAUkDQNdI5OjIGX/wAmnqlCNnIkIlgnQFxDAIWiT91ADEkLOyMtiu8iABCxxe38/EC0DWIN/WEQgDN6Juvb9oFVFhuQUjI4M5MEjjUIpWJOIK6f0qDqkFfqG2Se8gY5gEkgn9rgsUHIoUjvuoQGKNA+5KUglq/fvKN4ZErgnxIljNjIIk123ABoAkA79oFxIBYOe+JAJALI47wNHd+rsjwYZZAZOWRoQrY4ood5KgD0/qS2dQNfpxJPv2kRAbLV3Crijj0hs2K/MIgYLBYPYfaCteyT5GpEQ0B41SgUdQxIOpAFE78GVGtEkYkKQMTT4gVgZCh2EJiDwS9wLyHlw2u8gv8AcaLUCcF17wijKrrwRGDQGVD+ApESrYN9v2gUF7W75kFAsjkwIMhxAoIRZV8wig3q7syIHeqR8QID00q94GhfcjgQG8sTa7wKzWlxIioVzXECAo6v8yCg0tF6hFS1oVAAlXriEMSzYQ9oAEsbkGn3IhAfa2WIAEksEfXiQU/pPL1cBuuO0BsvHcIpPB+xkAEDScCgcFG+YQ5AEgr7KECm/wAwKO3MgKm4FNPa4hClRgUGzVyA+CalFAciHECgnmpCnIT1CA0j94FrtANWZEX8wGPcwKPGpBdQGhCA72oFHaRAHzAsgQLoGEQSjUiAkF5qEICBYCQIGhfMiEIAwLAQEiKIFkCEIFFwiyBAQECwiiQWBIRZEIHn7c9R7CcwIfdwH1+sB3gOFxCorMB8cAfeUQyiu/gkE2DzxKqMcCRQpg1CBS/aURPQhQh8gQHDswJVi5RQEAIA37e8Klrt7QIwirUAESwu3iUEhtkcQJzutwCY7QBsJFmIqJd+9ShtvmA4Q+zhRHeQNfiBOVyu0Af0sj77UogYdi4VWLZoQIh09idCABI3sXcojFaVbEAAVZgP72/vCoMT/bz3g0Qrz25MA7ahRWOHQXmURPEkgl+ID9O/pAoQIFH/ANYEetAA94B02UNg3KMgMbA9pFOQeok+JRrZPpIs7gjJBSrIrUCaAAxT3KpQ9SKQIriECnZyrbhRiwK4XeANBMsmALSOoVkGxy+8oqGI/wAByCELsToXKAxuiUIFIyOSBp8iIMk31AnR7XLFHshq0wXAgA1dU1cC28iEVrwYEJQWvDcKoxJORbHdQjKQvXI5MuqEABlhnSgCgDxWw+PEC9XrAB55v5uBgA9JA3q+LUqqMibS3fiAyIYyBP2uAYsIFiu4Hz9oGQCSvTh2DhVyxxzYJ3SA4iU4BjE9I9XbsOJaIOcelj95BaxxHVl9Wx83L0MwCbS8jQ/7EEWWWKyLZVfPn0lOMg+jIYhLRIuFUM5u8ToFfx2g+IAsT0smgNo+YDEhtnpbHv2gCCcT1ZIit9v+QaE9QOJV/qLSlGSERrJjqAOWzCr6nbJLp/tAymSGAedr/UK0k+rpJA979oTqZAg2CAqL/H4hZUZH9LqCVUnXAl+gAt57u+dj5/ECsdRBByVpbPtswMnF4nqrI8qhGqY5HELqsX4B7QWHVQPqAIB7/X9pcGcMcekk5N9vnypaNY//ALGsscmu68yHwH9N2CMCSGT7XGmskB4ghoAI/wA1LqqTbIC8+ZAKJHWfFnTiIAf/AIy13IyP6e0H0xy6CgQXYR19Ivo3hkAenEgg2K1J+p1DkzZ/SddOq/7CmJFEA4kcA/Oy/wAQllMTiQss32OjIUHSwSyWiSUjKN9RZYxDJoH7GSpiFsYY5epMA/KEBeQxW2iR5jIBPS8+ngZJ9o/EWgWcNdv4kFJZLBFoeflwioAdOIbdiQNAh64XxQGJIyx6fSd3BjX6dNrivP8AmREKAs4pbI1EFGOJLLH+KjRo4vJjIjEG9fWImsOxlqikSHH4Y0iiekgElAgSIAf29NA65gat5kFHz9ZBC6GiuBSgaACOTPT5MCBY1Vf2jUClADIskl0dwhlYLxpdr3INA+umA7Xz3hGcf0kAqyCfniKL1HpJyof9gaJ0VlprtIithDkW+IMTHEkgZFVSEgp6cmD1F+aUJwD6UECTAuJWSq6EC1iBVDZAk6gTi20rPgRgAelktlEmoE6j0ZD9I4gaFknJr3/PaRBBEAXw1qACbOJXbsYGkL6jf8CECyFlrkkSCFAghadinAoBB1Z3CARJHIpgSDX6XbKRrcHQ/QhbcIM9DBvsI+h6Qmw794GgSDr2v4JAA9K77IhAHpCB/wCwANArjgyBj0gOz+IRrEg5cfQxRekHZT2pAGwOR+IQZa/EC0wx+JA4PB55hAFGrfiBoMFBjv4kEduzAE6OQsQihJFkdlBhVVowNAll3IgewJDG4AMoHiBSxYT8d4RbGwD/ADIJfb2hF4qx3kF7iA57d4FPt94Q0HagK2ZBSLeoRN/8hWr338yIttLXEId+IBuuYFC3IGj5hDgU4Fsgq/EBbsSANQi2oFfxyC394QHYlwG+IF43IgDe4FBqpAf+YAKEDouBYF/EiAMCyBCBgUe8CyIQLAjqEWBeYDiQHAokQhFBgWA5gJEWQWAhCBRCLIAgIFgIRRILAQhIjzznpvYK0JRT94EPeoIj7QCuASChUqUOwkACiy5Q70vaBCE+frKCrvCoV3/EBzUirRuVGWjCg57wGiHAbGuVcoiNvagOAnAhD4IHMKp7dVwDGrEAcfeBnm/2lApFg/aBCNGXVUFWbMAN9ncCMdW4VG2DeIMCNUGoFyAq+4EEZ6rZBB0PEqtD/wBTsmEZXerhVRCHiBF9K1KAW2b8wqAs2wOIF+5PMDP93egRAuTAvEOUgBZYqRUKxHdcygw0iCa1zABJ35qAyRGoEKbA8ipQQL+9CFGti5BDegOzlBgAED6yhZBC+p4kEyL9hzLFTJ0BYgWzWI6feBK6iXsAwDPVpjQuFUjqHAJ7QIQSDiVrS2JeCEPR9OvhgASrRHNfeBKJSqr7QNZME9N4+YIhtll8+mVUOVFhdz4gwyHSQSf3g6JgAWHvcCbZGL8nvKJ28fbxIq4LHG8iWOeJaLdghk6VQjGQGIKRCO/niVqCHTSIPf57wLlrWekBCREX2+kigNn7gfPeXBlnHKwmPfmDq/2ka7Hz/EKiGGQ6sb7+ZQGVAEpnu6jBBgSCEDwSo0TeI4Bs3/EoEdVEBAoh+Kgaz/8AGAcSUgdHdR6TWTkOpHFHvCtLE/all97gZ5YZBY3W+8BkwOk4k8/q+d/xBGcsSgSCmKcqqMujH/2V2fniOihE2nsjHvAx1D/yD9RYD8j+Jc8UBTIAGLCGpMEyYJAxqt8H95Rr+oMaJfIBWu3tBGCcgsssbNN6+Jyz8G8cksEFllsGvaQYOKZysvvqXVaIOJxpDV8yG6hxADyqkANS6M4nEaFkP81CriUTnmFidWfn8y5/iVRoECwbL5+fvIMWf6hOIJoInYNS/F/rWfXjiATiab5EniRQFlZD3cis5EYgY4gnhq/ly9MX/wAqrNh0T1cjmMTFxyBAQNNh95Bc/VgziV34ccDrBJIoOrHaMRrZOySj2kB5YFGzz7COohyYvLEYhguFayzIAoCne9RjIi+g1y+fcR+qhyOVsoH6n4xIgWchiCvEDYBzPSFiSeO+zUJwAHUcgMtA/VyCAk5N4nE6HdSjX6sQMsm7r5chiorIElfjtIiHF36hjoj59YFByAFkoWD+f5jEA8jpCmB2/wCQNkeo9FePvIiEg/8Asyre4MHkrA9wGfp+YMxchjiQf42ZDo8QlkAGT2MIM3oIc7fEpiAtcqn7yK1gsMaGTNH3kvqNWiCsif8A2hEyQYwPBGvnaBR+l4lD5fiQM6BeI9nriUgi/UwO44kFBslB8f4/MIA5OiD36T5iwUfpyHGjID6UKPkH8wgMliGQL4jBQKI6mBTJgNgEgA003rUAWTao9tyI1kcV+lgNECRE6i0cQR7QrQ6TwCwtQiBLqCRP8wNIgIDEg/n5ciJkAgSvaBR6R6Rrw4FfOXZ3QhGX6hVK4GmWT51JgZO9AahGsjjwHsG4Gb3RJ2t/NQNg6GwTciIgGSieY0xpEEJfSQEA6ZSqBHqrTgaxYJJDfChKKgAv8mQQbPFDnUqNZUEM3UguP6kDY7SUQmljr3gOoqwxpxiY06FJSASVx2gHsn/kI1Tvm7gLGr/MgPu/tApaC+whFR/SdQiHuYUNnt/EI0jlv7yIDZK4kAMlg74UChIAwCFvXEIpHJ/eA0kb7SBuyRA0UWdSIjHiBWVtwikgKAYPfuoBp2oF/aQUUKHvIi+O8CH2IgV/eEC/EC++pAv7wijfeAGoF9tSIj7uBQrGpBe0B8EIpO6gAS+8YNOREgX2kCBbVQhqAB5hFkA+8CuEIFgJBYRZBIRoQEBAe0iKJAgWEIFhCBZAgWAhFEgQLCPPz0nrJClrcoHw4EX1gCGBcAOwcCc+8KvECcqBdlyjO+PpKHtqALdmRUv/ACZQpyBKHB0twpvkGBCOFAEJllSgtcwqMeIAgB0wdQJQu/rAuh/HaBFVNSh2PDgQ2IAhuh7SqEew/ECAcK1AZKnrZhUs5IoCA2NNwBXdc3AYgLmVQAEEFgwA877GBDssFPcogRzY0fxAWr6e4gNaP04hUsAZPdQKrssKAITy5PfiBlLwVzxKoRiQjiPaBTiGwV9I0Qn6BsiURUX+BAZAtjciwIRsknzKCGSC81AjQaCOinAO+OriBMqbQuBSCcjYfPeVUBOJCNjtApIRRVXAz6Qb8m4E8HfiFMnp0mVzLBSTkCBY7uBk72CeEW7lFrQyVbkEAPS+ok9+0CZ4hUQOQXLKq4sA2HwxxCBAOIvW1Cs9I6hicUfNyirqzW2dOQUAdIFeUYEO/Gz4hVYJfakvt+8pxmyQaBPHmDiEDkoch+0qiL5yQWoAsgjqq29/74hAkGwEBzCgAAqmaUBSyeVbQGz9YAiymL0R/mNIwQTRS3sS600QASbJPD7+IQOICR5G6DiDINkFsHkeLhVPPSjjl+PpKiH0gHpIWy/nMBkwD072ewhUx9WJQCWnFFGTRD6RlQUGM5WCzSZpQqskGwLZI19IAjHJYktUk5UZ/wDh4hjZ8/vCoSDkKB2wO/8APaUUYnLP1kkIIAcyAiAyA8tul5+kq6ixJayA8e8C/wBNdOrHmSiY9JxOGWIL7HdfPtKUxGQr1DJC1HghOQORNhm+q9woB1f1RX6tjn/ly/AxOSvMvKwenn5+8GBIrIEg7f04gxMsenEE7yogjY7QdDgBmcmwlfzzHw2qDj05ZYFEhki7Lg/GVjisSQD0gsfxKdU5ADjR4rxIN5Y49VsZFU/aRImRRGRKsEoc/Z/8EvREgWTk+Pm5FUgksFlUUEpEa6ccCUyHtsDxFOmPr6WiP1MUvrLxEGWWI6gT0nYGxBi9R4yskF8TOCZnFWXZ4CMuDQHUSjXsxl8UnEtLxKGRJA8/DB1rIhWCOK5kiBIwOk2a7r2l6IAeRkWvxIqkFgWQqrfKhAnqxKXSOTxJiHI7j9Nat8+JRojEghHpXbUggxHQmfN/bcaNZYjLFEJjYxkQxCB9RDDHK8fiWjSxOAYJPkJyIyCBn0k4jucYFQ6x1AAZHREHxqugdWhRYkQFmtKx3kGup5PRFKBl9R9RLIvkQcVB9RH2gNFgsAbJhFo8odhb7Qh1sA108SYuNbDss78Qijn9RPA1f0+kiFMiwXp8/SBDWR6jx5gVBsAHI8vvCHpo4nkXtSBjbAGjSiq0bJ6ebLFwiIjWIqq2YRcmAUUdk9+ZAxPUDkSL7wKC0ex09QYFJlipEVsFk3b7wAOJVk3CI1TQVlagUmwdkVcCgAZPIv3MgqIp2d8wikcnGQMSBiNDkRQBQ6SAR7QKAR6fy4QsB0Q6CgaD6wwnZEiIAQE8mfMC7/t9+8gELEHnmBQmwXxCKSOk7D3xAFCj2DkAk7uEaPS+HAh42T2/1ABcWfeBSObvmRFoGoAepO+bhEBp35EDX395AJ9zZUCoE79pEKGuIFJ8faRAvHiBQD2gDRs8cmAOi6HaEXnmBT5FKQQAKhApLFwgK796kGqQH2hEdpuBrm6gNAb/AMyANwivvsSAPzKFQLTqRCAcmChHtcIovi4FO9QJqRF9oFYMgCBX2qEPDgIFB51IivvASBKisSIQLABOQWA81CKIDUBIHmEa5kQXiBXAQEiDgWQWAhCBRCEgsBAQLCKDILA8/wA/tPSeqeIElUMBAhH0gOdwB7wIvEKeeIA7qAIDuUS9GA+vEoEXUiyoANWJQ7IyAfa5VQm/O4FNiBDr9nAhBf5lAPx7wIz7BSi27qRUJgMUh28QC7KVRM3CINJfeBFyPwZVF9YUp/XiEXH1cnu4GSyeCR5hVsC0tdoEAB/bmBMvFSqrKbJKgTgA/tAM9TKBlBkdvaBkmu0KpZJqBOUNC+6gDjVUtiANkP8AAlUF9l5EgJ5EngjcomQPcGBMQSnA1+3gQMloru65lDFBCrHECFWl9IWHBQCXHF1AdIqt2hxAY97A8aijNnEki2/9Sqr0wubjAyIR6n9tRBWNtDjUDLsNnvxKoVkFrXMguVljk77QMkg0yuTqUQWGAwNlQLllSbAujAhKIx5/iVQsIkmr3AhxAy0ft3qND+rXDX7RCBByAB0Pn+YFAyAGQ5pCBCDkQtnlKFOnpsuUQBU2B5QgQgAmstfb6Sqqf9QDFJUIT4gxFg4odgY1TpsAdQ7BsQaeqgN+O0HidQ6+G3r7QGXqo7OyeYlVD+kkHpBKHiUTpL2QKNfZRouAIAHUONURGjmOojquwdF/T8zSugfU3xvE/PvMoha7njupVTEADF4sWBSgBddXFhIyKoA6vUj4dfaNRkMD1dOO1UpqdHpJ9O7Gkf4l1VW0aJvqHEghLz6UCfb8qUX+l05hkek2+3zxKX8Sy/UK/uIkUL6S8yQArurv52lRcUB6xWgxofzzAz/UBP8Aar4FfP8AERTgf3ZIbgRrpxPUt74hf4vUesAl5o0OflwJkxl+r1HgDY+CWHjGWeSZKZvb863/ALlMjpkMurIIB1f+JBki8kABiWQKv3gT+pjiizeJFOlEXQ5dRWRJIrjzuDG8Ds9WQxfixCWM4nF5FhdQ6dEV8EXYLkFomhdWt7+kB/TxRHVXiSjdm/UVS7cQjBRxeJFEJV84jlVrBDpBLGQ2ro9/5is3/VysnHFk7SX0kIpOXqB2tGldVAUCLBKZBNSBiqyyB1zzFEGOYwLHleYRQcgQMgj2TMYNZPpPpOXUNvz4kiL1W8mtAXAy2UQDwer317yik9VZbrvMmNZEbaBNspRECQgcgegDm4ANO8QO9EmBMrYxHUuCOX7Qi9RYx9r8SLikAAZUadO/lQi/3BBrzIh/Ue8Qz+/CiCj1DFkFaD/mNF6SAC/VpahBHPIYkny4OL0qwGfdyAgL4B2d/wCoBWSMXVI37OEarP8AqBHdXCfESJ6hj9pNUAHUFiBaYgXtiMtLxCL1ZOxlvfnUmIMEAOjz3hQ6Ld8DcIHEbOgjvTg0AAAZJDHwRqJjjkQ0OQh3+GBteq7qqRkBFIaNyC4lAE2PNoQhT6SS1owNYoZdzJULARJt68QIEi8gTzUChbBIDcgMjNXxZ+KVF/pkJ5U7I0XBTkhkAfeQVbAdUhCNYkh/FCJkzv6yKDQA7CBRSCfP+oQBR5Ju4FL3fvxIMntu9JyjpyS5lEIJfjiAo8MiwRArtGyO51CLjd3vTkSgIDyuyFApWhwNOAxQTOvtIKN+feBD6hzA1iUhaUVAslCQHu+JUWmFtWVuQUFb37yCIgG/MoobFvsoRS1xe5EHyRuQAbopQLZ2PxAp7/eoQaRIocQAZD44EgF8MQK9DiQNAQi8wil8QKLkBau4ABkAwi60RIFJjUC349oDZ7Qi2CZAG4DdXCKy7EA68QL+ZEK3AoSkEX3gahBVAYlaii8qRFEBIAhFpQFuEUHvASCqEBApgBASBAsjKwLAQEiEDQkCAhAQK5EJRZAgIFhFBkHwF8E9F6pxKA1An8yqGA/aA8wIe0ANeIA8Qo+0CH3gD2lgkBQPYwJkzkZVgN/tIq68SohvSgQjUKbOhAeH9IEPuPeUUbHvxAc/TiBPx5hUVbdwFdXmUQaB/MCk3qtwJYN2D5gFSD1KulNwqeBrxAFPfGnuAa7XAE38MCZPmu8BiqQZW5VQkfVQFN1/MAifmoE7sB/iUXZ5N7kA8yqytqhyYAiydPkwAY1a/MAB6R6UN+0tEBGWRDXeFN6R+/zvAZEgsFQIgHpdjKAIqhrvAY9QDd7LGoUyXck6fiCJiQySnoPUoFFAmzq1IBJW8i6cCUup+occyqX0vqpIXAZEoFW67QHSx6gQdwIOo50AT2UKURaN81AUcA8mBuAH6bH3lGWdgWbMCZEEpEHSEqtKgbAST1CRAq5PjcKuSeIsA8+YGRQORoPXaAL6giWR76gMiQepdN77VzAEM7IsalioecRpO/EQUEh+D9vpAhWL3slgahYzkcssyRkwftKNYb3vXvIIem2thEW73LgHIZf39LPz6xwZyxCx4AOhGi+rLJjYNsQIQiRdj6a7y6oUziyMdWGjAAsggu9tAQK3k11ABtwDoDKhyu0DBA6QjYOnuNVN/wBQoEnk8ymLh1D+njkivn1inisnJjEkCyDpwMEf+M45DpIPhDiXqy6qHSRoAd5BTkNkUrfz3iGMkE+rILlkKVQnEFjgbsCXBWQTkC2bUifiZFFgb7c94WJniQ+s2O1OBcMqAxQAxFnfiUTLJ8EdzIqee3C8yip4h5IHYde38QMjeR6rFNCUaAAXpWJuzAZkeq129jAyQSxeIA4NkCAP6jloJHIWYU1kRjleHfv5hOxQMun14gKyO1VAziv/ACEZA46sc/Kl+DQNANMc4j53+8gf1V/5AyiNdxchAZY4nJFECx8+8ZcMXDI0Qjj07XncYi/06/p1ma2W7HEl6UPScQMR9R2+KEX+nkiXtUQNQWKhWOQJZskNeJBC1WJR5J3AMDBI45hoa1CLijjtsIC/iiikZH9KOQehoey+kIoxAAxzRPjj7RT+KOs/1AASDW+ZABJFtdizIARwBsr8/O8IuOQxxXViN/PEGAOWSQvZgZyeWXT0267QOgDs4hkIgSMgQArq99QvTIg9KHpLFGEH0g5H9T1wIFTIAer8eP3kQLIfDZ6bIqAIGRZFFfWOCmtenFdmPtA0HZF2ff3kRCV1USPeRQgnM5MhjmXUXFO321oyC9QDdtJUfeMQeOe2SfrHAIGS5LdQAs/qRB77kSqll08/yu0AQGkQDSB3CKCz1bsMniBQWWEgOaLkFB0MvUNr2gT09IIQILEgAvMgDfncC4gj+mDXs4RoEk9QVeahEIRBxLPMC9wQgpBTlXVxcgiLv/NyilcDiqkQfIZgXI26/aECNs9S5cC4lgAUFIBJ5CEADzyPtA1XJsm5EQc2fF7gaFI0BswgSCCeJAIYeWlXmBfJ0oQoEhpUIGgCBZftzJUT+49QriUOpIEkPzIGSfeQVomixAuJPnWpUMF01+OZKKbGkO5kDAmxZf3hLFFUqdwF6oeIFLSIvvCAWuToGQUs07hAVRuoAWdry5BRqABC0lCKChz9oAM/5kAslfmBr7PmRAMaBEASCjShD9PvAp+0C/nvIG7hB2/2gUXoyB3SgEy4RRAr+rkAF8Qi0fcQHMC8yIc6gUHnUiHnUKohDiABuBQKkRRdsQHtAe8iK6cANwLIhAHvAutQiwEBILIhUIsCwEBIlIGhIEBCECwhIKICBRAQj4Q0qnoPURWu8qgs8wAgTzKoaMB+IEVbgKJ8QHnUCcQq+PtAl6I8SgTu/vAg1AFePaBBp8yqchwAAHaA5sGANF3Co7gPO4BAVKM6oFfSFa4BXEDNbgNMjiUW14cgh9IQNcmUReChAZc68wCpHT32lU5v8wItCvMAQUOIVH6dfmBTvm4EV0N1AJhyqh33HMCkA7PmBkhDsvaUUDIlEEcCBCAQUR9YCymD2hURI7OATyZYffvAuRq1v7wMks3KocWQTajQAbYPgmAAByob3AMURpfp7SoiGNLzI1PTLwfoBKLiCC+0DPqWR2/MAdP6fiA6qByAJOqjBMuMkcV5UoEknqxK+v7woL4Z1AFcG1uBMdInjZhUFmhR5cBiOrL9OIHmXRrAKtHmBgnRG+6hVJWTByLShAlVlXgDUKyMR0kBkDUuikdWYJCHbvAZAW80RuBkaWJD57ISjWO0EQf0+JBlF9O13OxKugJDGPUD7OAx7MN88QGRsIn6syqxiQcDkckXviL0aNZDqAPn59YEHTiSBfZCBQMhkfQyKKKgQgAsD1PgwBKyZq6alDd4ksaBvcKA4hjd9vlwnWCOqsSVqlLxppsY0OpceZEQI4sYlHgCpfozkE8sSiNA0YVo1jZQZ8SCFAdOJWPK3w/MoqSIIQejuNE/qbLJfNbhYgAGKo4ks/XtKKP1N6skSAcSwHpgsR4azliaZGJ2hL4soC8BiQL8O/n7yoItjEgHfv2/MigFjpGIBN3xH9ADqx9XdI88qOCJ5PANE1KvwWPPu7Pf7QiZiuxxLBD1LFBhmcyCcfVQRhNKOJ6ScR2GNfNQvKoBOOLASX6q9wooyQcmMsrsHVcxonT6+rPFIatD4o1W8jkqLLWKHioRglokEj99v8QL04sZ7GPewPYmNFwOKIKAOvVqD1cLzYobJdGQOp59QCyTIR94TGj6MhiEEBfLkJ6mZYK6yCRyhEMa/p4lk42uyY+VCVlZDHIsM9xHitH1Y9QWX76hEGZxxGycr7xgZnWefSCNPe/EkRS8/VYNqtfb5cHGxrQWgTIiIEEY4kBI17wGCxHSWGBzv5/EAGc7AAItyC/0ycsmSAuEDUJWsFiBiSl5ijJJX0smvn/IFKGQOI2jZ4ga6kUSSeUZMRnHEIjp4p8D4Y0a/VmMskfaRDI4dLyJK2dgy+h4sHknn/sguJDKKGX7whiLQIWN8qAALyGOKPgqpBcUArAfbmBSdEA48sQiY1h6m+6j6NE9Nuhb7SdAFNAkfj2hMVEEknDsydwLkb4feQGdn6ImEAQTVZ8XuCqCAUA2V/r94RlDIpFaTMcVtk4h2VtakQxJzDGLJ8xhTIb4PAgU1jbT14kRSGgAenkAb/iACKyBBA1UC5IvZV73IgCBrRLIgxRui0jICRFmvMIhDTLPiUaByAGJdiROrZut2HzIBZLdO6gUfpZ71AnPUK94Ghr9PtUImSAIPHiBcR6ryBciDGQJv7wNAFAldmpKIuCTfvAU2U/EI1ZFM39oEDKID+FyChAsbEIAjnnxBiiy67uQVklqwLPEIGskOwggb4v3gaxto/mREVG7MC7FfZQAYAo3uAJpt+1win1b3IKPeEN+JAC1uuIFDf7wLi2yT3hFxI1tSCWoA7obuBQRxciKF48QALLbIhFYA1qA4v7wANvvuQXnaUIWyKgUfiQC+RADS/mEXzAvOpA1zWhUIrgIDxoyIrR+sIC+BCrxIKLhDfv4gNQLIithyBACEWoCEWAkFgIFEIQEgupEWEIFGoCAkRYAGQWAhAQLuRCBYCBRCV8Keg9Q+kCGpVOYAahUlCAgTmAI/MB9FAmu8Kc195ReXIIRVblEqnUAACP4lAirMipfiVQtb/MiBDsblEN8MQoRdFKA5flwJYNKUWul6gQVpQAHJuFDZSgAUWhAi7NSiCySjAK9oQIWNHfEqqz2XmAII7mBDrq7doC4UYvQEAATAyDXaVVdC0IEN142IEyYRAIX4lgoCxJfmAselKqqBMjbSPdQpdgt+YA0l9u0CAWmVCgFPY7OoGTq8ZRaCF6gAV1EiECmMsjuFSidMC5Rca/STdlSFZJscyqB4q9wF8CvbUDOQoEkSquR/wDU9tHVwKP0kZfZwJ/aSDa0IE0R1AAkf3GAZBtP9oVD1DFgAMXKB/UyKJHmIKAFlid9lAyCCSj4HtAdJaFX2dQCOxoU3KJiRjkra7wqkYoXR8VAlkert33AnH6F3vUKG2QxibJ95RaJBBb+m4E3ggbfJgDkCgb9hxAgIIPUfVZN1KqgAggsgbHf3gQdRP6g+w1AZYjLGi7oKOGohkAR33+0Gjf6SKo49j8EAcRlmwwtES7gh2C0QWP8QqLPqor6d/8AkbMG6P8ATZPF/PtAx+g9IyXghFS9FBxBfVdAMhwGV5HGg9CRYnVlibKA2FKJiiCgsN0VUBiCSWAHSfMCAYnMm1Rq4XWem/ScurI0B7yjayV9IDFj3cgmQGIeCytb1LPTVzYByLy7DmOkZHIa7gIKFMsv1HJ4j/1I4l/hFwsHqyC4GxIVgdfSeocJbfaXwaJ9IyyOVb8P5+YEy9S6mcU+pC4VP6nUcRliMabVSwBiB/TJxNm0q37RoDIk9IIIIKtiKLnkfby3BIyRiCQVdsF1v57wq5+nIEG+VQF9vpCRMOkZEhjEG0UuYWgGL6mBkSrNmBCTYKJC1x7OBokYgY9JrHb+z/MYjQOWIyAxD2Me8iAICyIJ4gBl67FhFH5qDFw6a6d7LKuRKmTeJGuHyjEUDxTJv8ct/SE608iSWQ939vntIjOQQF5OgAvtLuquWWOSR7caviTiN4kY4nqINFGQpkHif1dSriEMHiQAA1fSGjzL0oG035HbxIGXWcB6tjXcK4QLxya3kiquBvBAZBf4kGcSPUVkO3YDtAoHqQKtlEagUAeAvFj6SImJGOSAFg3xKY2emjYJTdHf/ZlEF4+o4lCoFHUcaGO7UCZAG19OWYg0ESDfexpxiJRwRKA+0g0CcgKOYB/xAjAHrFkNrcDWKIq1q6kSoMeotl7co0gRyC6kAHHLF68wgMhnYyWQpcfNRmCrHMk7HFycQ2QwW2PeNMOknKie9fmNGgR0PZUiBCodS+9doAZY4pMP3gsU2dhdxqQCSCySf5hAWCSAtqBcSySSGa8QKEySK32kSskDtZOzQ3KNrJF5MPgTIhQHpPu4FyrEre0TCAvuX7qCq2bZJ0AXCLiQLJ+0gAEAveqgWgASL5uA2hsKg7MIZM4gv/cDQHpKbkQ/u+i0lAEk+3iQwp1bvUCm0RfcwgF1Mj6EQKF2R9pES+++dQrRK4CAhFsa2QxIgDQKcACX2S9nAoSHHvIIeCK7QLpeYRfPf8wCfDPvApL4NqEUEAKy5MApEcnzCAKIDOvaA+rEgcJ3Ap227hGhTHeQTuwuYBB3rcC/FIgyDBjRI5HvCANbJ+kBa3AHvIKC7FQgNXAofH5gGgj2gUXIgBAo7K5ABYuEAXujAtGBZEFcCgsVIGoF+kIQGoF8yIA+fEC8uQIRV9YQ9oF9pAgPzCKChAv1gNQEgcQjUiHMCwEAZEXUCyBAQhAsiECwED4ZU9B6ZAQIjKp5gFCpAfiUCv8AcCEVAVowA+kCLgQoNwLsVKJo8QJRD8SgCgTuAFHxIqO2hCg+qlQQ6qhUFDcBZ49oB/4gQduJVU3CMlHQcqg2n9ZBaO9cwINLQgQhaJFygNrjvAe5+0Ay9MeIVArlUxPVtwFXxAmrLPZyir0rju5BMjVNbgE+fsJVBatDiBFXiBdf4gQBJJyicgEg+DAn9oQ6lzCqWiFzv6wJ/cqvdQBBABJBvcKD/wBigu4lBG3AgOXVYaa7wAoaIuEQ+Wb3CrkK5H04glTH1AJkDvFUKIsjxKJoFokQALRskwH91AdvaBExqxxxKoQzvergH6kMSMowTqCABtVcoGrNfXUinS9nRbgQ6J6kToIftKKQSNrx3gZI91rz7QqlMZEmETL+0nFY7lVMyCHkgSeCoIoQIBwLaKu4w1nFmhkkfaFCAe4vfaAxIaAJHkwLRCSYV8SiArKimdD58cBWWPqxLAr/ABAzeOJOIJvnjiXtVrFY5n1V58cwiHLJ9RKJDDHMKDEWhS1qBkgY5j0oP6KBR0jGjyj/ALj1Us7QWg9QHqAIS4Y7fP3lEwegwFXJhWjljrq71y3CMk6QXghED/v7SkTEaw9XS6rZEfopyDHUEFY8feMVBr1ggJgeO3mKJniB6TVg0YVUSbHo89lCIViVk8jw6+sqjz6mOkg2jUmC4BkrEnX7XCVjC/141jR+kqtAptgCgB/ECYgYB4iyxiPmpdBPBBdIZ7mTVMyxogH1J/T/ADKSBGJZyyY1aC4kEAGRGbQ0CNy8EyFI/wD/ACQuYVtovq35rcIwaH6g3s/kyxUCGYAJbDdi5fgPLoBwDGJbyKKpxhvq5DLpOAPNBDv+ZCf6m/6uLJ5D45j4prDEjPI+r3J94T6AodWR6VQAtfeBRicRfeu3y4NUHPE2iEU+3Z/SDFxZFYizodjv2kRhgB0cSWSTCtZnEgAmuwI0tbhI1/TIzxBAIA0zJUR4lAk3Q7uFUFA44nqIPZwhjkECKdEtOBWera48fSTAAPSzRHOkh/qEVDqvle4kFy6jkMTgGdEH5UviM9YrEC121FhjZCeS90L4kDHHAgPKho9/gkDePUeo5HV6UIpDDyMAbR3j2fMCqwSCfb6Qhnl+nLNIhrmMQyNLKyTtXUi4DIjLpWJRRRjEMR1G3XJ7SaL6cqVE8f4g4YlGgACa94Ghk8boEIkfxCJ1DqbNm5BQfSRkAwLv7iMQHV0E4bJ5L/7H9VqscyT1Acjv/uoZRl3keojgwrQ5KGufvIgX1dQFdx2gHiA0lkBJlBElZG/aEVFEFJ/iAAI2OnxpQL1Dyvw4wMiefTyR8+8iRQEQDiU6v8wHUiCQCqIEYLi/7gDTQ4ioZgaIY3rzJBrEFvjtIifpaBPkwL6uptO0RAuFmlsQlZwJB9SrULW3smwdLmRDGsfSP1aWoRdhaG0pBMiwyBd+IGq3Z4tmBGKOVeIK0QexciLzzcIlKteBACsggRokwKX00sUWjuBSDp8/zIif3Bv3cC+kALg67QKNHKz7VIi9K83BpeJfV3NwDpkjbuQQUPHtA0SD5hFxLFgAyUPBBlFDAIxciANClAvNsQhxZgUImvr4kBZEgd+VCJ1axUDRoOQULnXEAq1cIBK5A81Ao3wTApJot8qRBlKzAAlocQhj8uBre+ZBA2xAr79oQfMChqARRVGBdFqRCBR3kFLbhB/vAKBe9yIe8CvxIB+KBRCDIuAB/wAxUU7Ugo7sQHtqQPrCKPtCAYgWQIFgHCL7QEBIKCpEWEOYFgICRDUCiQWAhAQLCEgsD4nmeg9NFAbgD2P7wIVCo5VWEDCpuieJQV2oDyIE+sB2gRVqFPeUAlAH2swIyyKlA2pBKlUMgccQCv34lE5dL94VXAlr/ECVyJRSGL3Aba9xAygfeFUbt9oDIM++oELW/dyibZ47mA49XEBYsMDt3lUrZCgRFAcvgQHlMQANngAQp2BtwJvVg68yiAUBv2MK0S2ahEL/AI9oVnEMH8CUW2ABAnIeiLhR2+IEOztDxAmweL44gXnp/eVVfdL2kDp6qIQNBGE1ksEY8zSmXSlXtIIQGSghKCIAo77SKzzbB9pRpr3JMgyfSGXlX0mhpMFpcVIIPP78wIAQyQdv2EqqyMR3VVAzTdOBT5Fe6cCEWBRXYQqjIaHOoGCwBZ6VyJQxONbT189xGDWVaJGSgYslZMgCnjKq6zvK+SvrAAbIABPxQILxBx6l4uAA9Q4VhFKBf7RQCscwJoeoMariBAAMSxvgyqWuGRaFD3gB1MgGj2GqOoEPqGPqOy3KoH1PpLW1AZ0BZ7o8wBYxJB9J7hQAx9QYJffWoAGxmPdefMASbK1R+8KyQSL9XAvcoYn06B8d4opHoZtgWewgiEkjK9gp/WoEHTkCNg2ckrloYrqZHComxqFXJHlvzr5UDOgmQqokuBeHYHbv/mBkHpx9RJ6bfeXqh2MqBFjEcwNf/WWK4C95EZOJGGIeRu7AUq6YlNIeHXf6RQB9R6qSHe+0YqYhdOJZY5H+4ExJN4u9A8e8pQBgYgY5EWQRcFayyJOVn2S+v4gxn1Wj1cb/ACI8VP6YBZBtpPUUp6siAxy3AgJ6hllfGSHxXKVrLL+4mhv4ogmQeWVZVrn6/O0DBByB6geokigvMqtY9QyGLWN+R8395BoZZIZl9PsITPioEr+p0nqP2EJ6zkPWMGDXb/XxxF1rPIADuUB2kEJ9WRCQOhswKAsWdg7Y+f8AJEZZZ6wfKyoyjZyIp2y2dSYMvpxOWPqpEuw/EqOqJGQJJfBNiZRnEraKHbmKpj6McsmDb3/MdRrqIwABZR51feRMSgb3xXn/AFKrQYNgEOge9yIZYnqA9RXOoJV6i107184kTGEcQDiCiAUC5RoZAdJOJshDj5/iTDrf9Qb4yWwefeIjGIyGZCyQGnr5/EXitazF5EHnk/DIiuiyjyfMgAHLEZDE7SaEqADyDPDvj5Ug0P0hECq6YQsWR1cHxCoCACEATx81CKyQEbONn/AkFAJyyso7Z8GET0npDRZG4VRlzWtsfeEMkAw/SHXEQVvEllEmtyC4hZOnyXr5cIA/pNvgeZEaJLL2FuDEC6dg9n2gXHqAJ57nn3gXWIAfHvXEIFothiQBbBBW73FAEAsgIePMgpOO2O3tCCApa7BQNDufoHAg9IQxJVgR1F3e8hqqkFZTKPj6yIhAQFHksyjQNumfEgYlEk2NAjmEpjRAH7wGJ5Sf4gW9Arm9SCuztmAVEg+GYRcQgSQvJCgOdoDdSIAkFtkUfMFV7ysrfz6SAdmh4uAtXZJOzCKlkHUC2AD+HINBclvdQjJ2A6gaya0b5UgmyTAuseKhE1sA/wAwNF6vd1IJrH0ofTvKjdDncyGJPnUqH6Qb2X7wLwhIJqoRQVbkFIv/ACYFBPi4EIV1rvCKCQquBckRxrcggCyOoFV6kRXVwCYdOEUUXAuwm5AFauAB2OYQ45+sgqvwZQoqtQKD5kQMCsJ95BRRhAFo8wH1gGO6kRRqBeJEP5hVH4hAFQDgWRFH5gPaQP3hFhCFWRCBYQBgWAgJBRW5EWEBUCwEBIhqBRILAQhAsiLA+JPQemh7wEA7qAUCX+JVFUBZgOTKqc6gBfMCaFQDEAr8QA8wqblDlKQCvaUZ+5lF+tEQC7yKiqUH7QJ2RhQMnlQAFWSIA+NQB1/Eoh7b/mFDQI+xUAQqRgRMdoU32gCDRlQPMCcn294A7UqpXJhVrmoRK/35gNB2/wAwqGAo2DZhUL5T9pRdVwIEOiBVqtwHtiblCmruBCE2QQYNQtsFOFUnuDXm4EyNBk0a4iCWkTx9IVb7aMCEcO1s9pRS9ZDmmIEACrRhDY8cgQqZBixWx/uUiEhsg/bcKZIYkgFO4ELOQBJBQuBRrR+soiYRffVQIG2FQ/SoUy03fEAC0AWj3gU5PIo88xgh4APbZ3CgtB7HHEAudoq5RMPUEdPvuKAJOWR2tquYAM5n1CvqoGaLGT3zKqnqA2Q9DzxAMPpAZ0IDEHrJdApQJjkAAzW3vjn8QCZaT8eYE1lwq41CqfIPYr5+8oyiGBZdFr5xGiDEVVZCXV1ocCtpcHxCJ0gAC1aRhQmqR9xu7gZAfSMWx9YVcfVkCNeTADHFHqtUUalNMmmKB4ez2kD1IoPJ3/Moh2AC+zP7wpkSGAwMq8whnjsILlmIMkDWZR3ULoXeWRI7nTlAhAZdQvgwLmbKIZoHn2iAsgSqq13gQl5HFBjftCpicbJs8kfaA6hiPXjQtiXof/JB6fbXLgCAMf0ojzf3gZzF7YELLo+oAEZMlfH7SiZdWJ/Xfeq+X8uCLkFS9I44+b/EEMic8SLyDSBjgpGRJHRiOrYe/hgZKYePpPLevn4lX1GMT6ciTlwDf2+8uHTIPIWRYP14kihIJQGJGOhjf5MJIzkeoYsHJH0kmx9ZdXFxZIvIk4t7NyCsf+wogAvcIEbweQQRdrxA11EVkW7CINNSWCjp6GPTiQGPxCIdPIsK3TkVSzj1ZAEAMBfpHz9pUDkdonssvzCYmRY9IBu8eZIoUchjkiOkBwjYJxxJIAXL7+8IgHGVkW37fPpCmLJ6xmWq0ifeRFyIRZPVq3rj2gQFlaGJ5qBo5vMi8b7N3JiY0QGMRXaoExIyFl4kW9RiVoUyGxki91JRP6aQ60A0GN/P5iit5ZE6F3zcBj+vI9R18uABCPUK83Ii5DpF0T24J0YFBOsRXtX1kQxXWcno68GBcckAEV4Gvjgq6Ly9NWjCDIybJFG5Bq2B09SVCl/iEZAIYxS7mNUxDWS2GYGgQ8bsGpEwyGIxHUAjoGpQZJAHU1XfciAAKAWNd4FxBJB/T7uRFHSiTZFEmBTY6gR7DvAWcSBthmECRiQNe/EirkdgEI7AOoRcuSDih2+fSQRcZPJ9oAivUD4vcI0hsE9XKgUnsyDyv5hBEk80pA6vUiUvlRgAqkTJQGS4GQAdS4jT541uQH6EAPYahDJC/NOCAsAKjAEcAk+XINFgte3z5uAN0QNq4RWWjljIDvQXtCFA0Cz3g9Uho9+0gMur7BKBNhABP7QjWPgcXAoIOr7VIC2FQ7QAPYvmoxFYV1WpEXhm/e4UdNspwg/A/wAQBZ1tyAw0bCUI00DYqBQK4MCAXbfmEU6SLkC3YIhDqu9G6jBqiQH9pAxNP7wLS7XAY1+p7qKhbPHaQBsm1+IF1x9pEU6u3At+0IBMnzAoPiQPJuA8hqEUN0jIC7VKA7yC/eEXUALK1IgLgUdzUCihAbvmRAaUCkyBuBfrCGvMB8EItSCuAkDmEWABWrhFkCAMIof0gFAsBIK/MiLCECwEBIgIGpAgIQBgWRHxZ6D0yBD4gDpmA9/2gNQIW5VCvzAd6gQSqEMQBZEBzqBBAhTgPEKcSihyCcyiaCgKIp94ENpyqDYkAOVQ/b2hE8L6wp94FHfzAyUTzKoe9whfP5hQi2/xAhJI4gWgoGTX/JRQSmjtwJWz9xALkaMqoN9wlAWefvCodEj8wBBIex9vnMACU9e+4Bd4XRghsd5RCV4VoQAB6rZPJ7QJaPp1xxKCthHmBCwGHx5hQeniwI6LiB07gQ+kEtcQIAskMX9JVa7mQTpFnhd5dGdsLiUVggYpqQAMjikexepRlUVQ8/PEKpQK5PKgQAF0KK3BoR3aPBgOPSGHuABoDpR44lDIUCAzGrEyBIpHyoGSPTVkVUoqQ6rfvIBCB9Pp5EohRKxNbb5hWs11BjRaHEJGbLQBANMQqY/pAIYVntFFIGWKCA044JkCQjv+eJYqlh0AJBlcFAygSs/zRhU8JjLRMqKSRinS+0gYE7Y9WjKqf3Ux27QB/SgKpr3EQCiH0pBkyxUXV6cy+n8GOC4kkjIN9+VCVjEE4lLwYaUl9yHSKIhAM6XSyK33gFvFAE68yqr6bNMtd4GcllkerG3YPiOETLFAnEWUr+sf0iAAbK/LhWiiCWQDVGEZ9WYIGVjuNP6yqEjEA8k7ZgSulAkjXpPiBsDJBD1NgNfNQMVQyxaPS/Pt95RdnqCLFguRWcaJNALpL+eZQGPUCiegeW/eFAD0lelOhfz2lRMkQ2CrGOR+fDAAZDGwq/SPEXqzFrHEv4fMgdQIB9WmWLUozmer1B5HFFjQNf4lgmOKz6Sj3yJi+xdUdZGWQ6SXt7PMeAcf7hkbDDFQSpkCqbpAGCHqxHkDfPt+8eUawxxOKvq2fP0+0h7rGRxxBWSJKo8+0qrix/UWC0GT88R8K0NEs9+0iCxx6skAPbx2+8ozk7GWIDG1EFJNYELEPdP6SDWGGRGOPpGXBB8b/aKmsrbWJ35XwCBt2AGccmWJEMdZUE0K2oovSi+nexv2caIyvSQAC0Tf/ZBQcz0g4h99/n5uXxMaIyOI6QXUyeJmSQurXJNiWDOQHSgGQwBrUQUAYYAgCOjWRo5Yo+Ad8KREPTlmMRyGByY4V1/qPr0ScbPb3kZnEHU8vUgMqBH4hUwYwxC9Or9+IqKxniGUDwNxwCAcUSP9mQaJIZ6gtuERgAjIjm+JP4IT62gRv2+sooKK0DsdveBSenEBkBa/xIH9MsAujzJUqtZs0+XApfTQCr63ApJItUHuzCAHBtc/7gMSwDoN7kEx/TkGv4iimzYbNAwjWLyD/taSUiUFkgkHz29/nMFVgJ7JaEIerLI0G/eBCQqOI19OTCxaF/kSDVEEnEl1IiAdTDMcFJAAYH21CIV2+9SjYsJ4tvdCRKjVVVI7k6KPUGOR2owAKLaVQAAPtwIFRO92lCBW9ZLSciKAelk67agXQ0SP2kFevSWmoGSbPjvUDQCK/t/eOoAFH1fi4FIG7BT3IiEM8dTD4gVEekbGpBoJWL7mBCrQJLUIo/VRQ5gaCkAlPIwiXbXaoFJsAlK5BcUQjkF3hE9/epRr6ekyIB2WVxIqsUWIQF2ClxAoaAhDYojzcgG2IA6/zCLof6kFPJG/aA3lrhwNE+qk/wB4RBollOlADW/EgvF88QBSkRfP7QH5hB2xYMChk/vIBqBcdfvCHLkGjAjPJ1AoHC1CA1ADlyC/zCKLDgB7wK/vIhzsQK3IH0gX7OEF3gHCKakFHZwEgouEIAeYRfeA/eQPMIuoFgICQUSIsIQLAQEiKIFkCAhDUD4xn3PRJVIA+IE4gDAeVAhlUvQgS/pCrxKJUB4MCFbuBICAP2lUXAgN8yAQRKJ94D7XAmgrhQ+OZVDCHCH3gS0+ZVCj7iQXzswM8/4Mqj8CECL8e0KaaV1AlFjcoAAjgHwJAsZc7lDeXMCYsb1AhTQuVQfpCpwBaBEAmyrhS0d93AHV/bvAho86UHU9gnuVVT1AmjWoCiLKlDRJJf1gTlkwqNJkOAq6tuAIIGrg040WahQsgsBa5lELTyZuBMi8tsjcoYo6OXA9oFrI6KoOQTIgVq6hYoQC4OoGSDT/AAZRNX33W4UZdaH4lRRWNZFmQSiRQsXKoSCaFEQFdN2DyoEyoAgACCFLqQYCHtC4Mk7vW93KmGYI58swsZGORDF4v7HvKNYojTWpBPSXWlxAgBBGJDHPMqowQzi8XqAIQTr9oE7LeTdSqZWusmgSBEQR0EH+JFCiORfPftKKjRB6gK8CBknuADqjAMkUeLqFQLoIVC2/nmUXIWUCHGiZixfFdxBA5AY9I9IIbJgQhYdie447fvKHVjlQ2BseBxCqGAV+ruSoKmOJJ/SDsmvzGiE5WGGxRA4lhi89QZxfepAJC9OQskBBJQIB1ugQrJev2lNSsgcczkD3NQoB05WBeS+kCgA/1PVja+z/AJg1MAf6Y9RWK4NR0QkdSA77FRioicMTp8t/OfvKGQyyxBxo63oxBQDlieoWt/PaFQB45UOnYR51Ccqnsy9jHvCmVE0q2D/uBnIEokDzCquvEI0r4t/6l4jJLyYLrjtCq8en1sN194T34iGLI9T5RjdVQCMuojJ+zfzxKMkgdI6mTaT7QDshIs87Xz9oEyodIIJvkVx4lxZVfpCRyJ6aOv8AGpAyPoJyOJD6RQqEOnLAXiS8ne15+0WkymV5fpNCyRsQQwA6clgcQSAST/CgaZOReKAQRo0ZEXPJC2iX4H+JOmLjljxYIH0HwxUZyxRAeJOP0lVQQCCCq4O/EgPIkEM7H37Pm4RR044JIn6d4T6oLIX/AKozKqcuo2BeOjKmBIGDLVAk78xiLl1HEZOkP09vMgHL02QzqvxAMNFA6B+v4hGiKAxKx4VyCY4EvIEB0QarvBrWJ9Ia/wDlwh1WQcbHFfWMDH05AAjp8GQASn0jbAP5gCMQQAa+ahAH9IBIbfHECkMMg5USO0AmV1APcg0whikXptn6RiFD1DLXJPmQG6KJ8CBWx+oirtOA1iQdD5/EIZp/2g67KBc+G7GuJEgTXSkCNJkwKQRgtF14+XIHV1URXdJ1GI0NEUO5MFACwSR3uBOogrqNpXUGNFPqQo88SC5EFh5Mk0eJEXEFl0PaETHXTmD4LcCojIHvluBRWTK7E+8iUxAxtv2EdBk5aI89vn8xgdLxAP43AVliPUHz/mEaAPSQT4kAWLI8BcwlWl3PB4kAnYojmARJHj4oF2nXvAbNbI5kQYFZC+33lOtaDxBXEiAC4fsYEaQDZkFtkEQKewO33hB1sEkomMFJQJZ2pEEcRRG+8ATf53uBQDziBr3gASTa9pBSb+twivlfeESiaJKkVdrvCFvsddoGmEiLhAWvAkVWSX4hMONeFCBaBPH0UgHStwK+DApAcIAA27/iBQfo9SAyzCFOjUgof1gCuNQh2+0C8Pcgc2YFbC/aEGExUC35MB9JBeIQJ+vBgXciDP08QKdKAffUCuk1IgKgJBfMBWuYRR5MADwURCLzXeQUSBQgLMIvYQg6uBZA7wLCAMCwHvIECgqpEWEBAsBASIOBqQICEfH5n3PRSAlUgDAj4gIETuFJQECdrhTzKHlmBfsoGV3gTsbgUwIYU5uUO4gSuz7XAd5QPZfaBF3e5FP3lD3TEAbvcKiHYvxAHaagHxzqBDvXtKA/SeHoQIR6nV9oVpobgReXAbA5gOLFyjJ5DP1gVX/qBOasdpVQJbI53AA+TCgslfnvAgZAIcAOWj7GAP8AMLAmhalALeuNQMkWy2tQLaVQISQV1fnX+5QIDHEKhNMIlu4GliUaPfxAwA7DHMKpDGgt6lD1Egut3AJ2WIEJIT+ogCgCT/uUQ6aB5LgF6XUBq0E7MKIc4qBkfqGqRqBSDyLUBjvj2gTulKqE+pIG7BgDlvGvPaMDZZGjAhFs6/IlVQSbFLjjcAPSbLPncaIRYxZP0gHXWrG5RAqy6Su0KuR6fUdKqiIyOkqiYqn/AKlW3teJROoIYgnsQ9ahVy6Q8kBIiIDIDpPiFQgWFS4O7lFBVoWKYMCANpnslGgS8ilkx3lUxGJshk5NxaDBABNkMF+IwSwE2QeYAsgLZ06hVogBAgctXCM5C0zuyP2iKdTIBFhgGpcAtsjHsH71AEeg5ZbIg+s5If1BkyX4XzmX4NnIJs75uQZABHpy6gFY52Jaqg0CPp1GQA+iwH3Vf9gYPTYRBIAb3KNAeqmj57/BAmJByBDZHMKmIxR9IpGpRk5AfqB+5q4FxRydYjQ/yPzKIMSccWEzfEKYP/8AkDQ9Pf4Yo16i0LYNbkGf6mQIBL9JVcRBcWUQMgeFdQMdPq6gHmAXyO81vxWy0B1Ma0N/FUiMZek9IJR7P7D/ADNK1RIOQbHApScP4wcqIxJ6iXpk1KY6PEgFkkbC58ORHHEDIEkI/qrj45b403ZS0uqwLD7SIpxJIyyKAsg3Zg0GII6iOav9vzBqsheok4hkb+cyCZHHEHnJ0BvvVSxFLFggEXr/AD+3+JA//wBYy6nz87x9FxJKP9MggFlCEasNgI7Qvx+0gg6upk6RZCdwKQj0kho+5PiBcWCydCwlIGJbAyX1/wBRxE6j/wCTpwyDBffiM/0UnI5dPqPlb8r6QijqbIYBk8EIHUzz/bzAoeRJJWX359pBcfTl0AW9bUdQokAaHLv94ovUehhdQ/MYgBkPUf6YHB8xVayJXWGapcGRlMEUBiN67n7RRASRiR0ki32gqnLWJx5R2oGiQRlmLrYH5+dpPeAjjkhjxAhTOjXZcwNY5FgB+oaTjEoCCays69UgHJ5EgjWzCNf070LJfvJRAaA7hteP+SooBGJAaH1kFIJA4J5PECg9QAHSRwxIiEAlJgGFXHOwPNXGIpGQ9Tp8DUIorAsskQfUyX/kxNs99x8GjkEVsb8TOCY9JxBGgk6lqLjl2IFfWQaxfTt+e/iEQ7OPSNKtwNU6pyCA2yOk6JeoFGrD5kRlkbxf0lVrGyyCAdKRFxBIB33ioYvjq+sDV6d+ZBMiw01AuN8C/MAQtUdPThFBaIJWtyIhTQDB7D5UDTsO3AhsEBjkwNdQ9iN3uREF7F7gaG/o04BBsmx2kQCTKJMC61xIBKBTZ+0opfkGEAumm/zILZ0TXeBbu/eRED7lBcwLqnSgUb8iQBbEIgs+l+8cFt193cIoYuQPniBQzR3AoooVCH0QkBlLmBbFkhwKe/KkQDoQAJIFwhdMc9oGnRIcgIgwBN7+8IAljz5gUInW/EA77QKNfWZQHaUUeJEPECg6uAO4AHiRF+u4F4kA7gVwh+IFFyIo1AN1ASCvvCAgATCKJAA1ACBfEIpgBIECiRF5hAQLAQEiKIFkCB8efc9AgIEEqigF2gSAgPpCpz3lBwooD9pRDAVAmoEC7CBeIAnmFRMhOUP47wJWJo6gALgUILtAyr1qVS/EA+5gRHjjiFDUABzKBsce0gb19ZRKJZN6gQjY5MKqAofgwGhQcBoIwIjtN17SiM9wP4gEwBQJgKBXi5VThmFNEUF7QhYWiHuFTqAoN/tGCuzaMCEcd5VATvH7QDvj6QI6CHnzADb7cShexqBk7Q5G4UJG2dtQHD8gVAusnRr9oEyookwpwu0omStQJWSXOjKLkWdEJQJV9pACGJVVa7yqZFZHYB86kEbBDZHEoEK6KgGDknuMExIbYxfEKDEYstfSXdAbrJEagBkEiU+9RgiZGmnBpYLK99QoGcmLKfaUS2hju6gEgLaO1ApJsmxsAm4GTka0uwClUFZBA1elAAAKl5GoEBJFixdjUAB6P/UagXLLZsEewgZ6RnkMh3W5TUoZMHpOOoiqekEHHGwGK1AdLJJAHnhRouJ6TibZJrtKdZ0yKpj57QqA5ABZA6f3/wCwDDL6jR+/wiBAOerpIFXCrlWwT5giDHp9RriXTqsnFEkEDtR+kBvQAVWLMHGR0nIPHLq1HwQrWjm7rtzKqkB9IAIFWF4kTTh4DDa9u0qg9IFkhixB0DI6wQyVl48wfjOVkk5FPYEHAorDLIAnf+Zf1WsiiiCAArH2EiMgHpVkrQ/eVQ9eJxyDN6CQiYF4IDKnwL+0HWTmicQC0WXqXFayPqLZJCB/33kErVg5a4S1YlELoj0Zcghef8SASSbILPI/zKIz0BDpxFoAfSFAh6wRXbX0gVM9XnSUujOTORxGJ6SLL9/vEAi+r/xnqokD+YNTL9IyfID+fKhVJWZzBdHY5H8blQIDoHIG3uQi98aY0F5/7AzkXYFG9fPvBFHTmAEVlyXHBcjlnneNhJGyOf5hMXG8j0iyNLe/9yUa9RwRxLIsef5k+iZFZZZKi2iYDHIZAgcJVRio0SBiSMqf5kEGQOQYQJbXxy4LhkCQcgQSBQH4ksAAYgkOtI/x946igBnEkjIVqQAaAyxIbdNyoBJE8NpCQaDfU3q9n5uQTH1ZEdSKZ6uJajR6gdhbJakBIUzf1UC3eVFlpNGEQnLqDJJ1of4hcUMlqh3L+cyIMBMBbBH7xYhjkVZX1epKYuN4skkCqLKqUXImwRY+siAxGeQyQBd1oQcD3LC/SvnxQKckukfmn84kFSeWS7tQigrpIFk32gTbSDFLm4AUAjkP5LgXEgP0uiG/neRKixTJvgj9oGi9YgF65JkDEUTvgq4RWxbYBLBgXeLPpAoQhibAyxsndXCh4xR9XL1INH9VUBV/aRDqY9OSv7QgNBeoOBQKBBRO62PEIbbBIB1AVWNpbAqBSVkv53JggAGKpruoFusgXd2YRpLRKB7yDJyLIQA5MqY0xfIPL/EgrB2Aj9RIBsgGsvEChg078QDOQF/RwhiQbBZ/f6RRoI2D9JESyeOlQLw1i9tyB/ax3gV+okNo+8JiqwhUAyXZkAsnW4ALJUgYRSMibFBcQiiz2MgWgCmvvApBZK96kEBeq7S0a7ptyIAlimNmAB0TfmBV4vjvIgESj94APtzxCL7tDvIKNMGoAeaC3CB94VaVKRFuyDAjL/3Ao3xIiteYAfFCLjpb8QKe0gCzdGEPJHtAr9oF0CZABSNQhAUqgUeANSID7wL7QA8QLwt1IhoXCKDxUil0IRee0BvvAo1IhAsBAO4Q4kRYFkC4CEUGBfEBIECiRFhB3AsBASIoNwLIPj0J9z0D3gFAigJVOYEPs4CA4gPwYVDKECQpKEAX9IEWtwHECWeIDhwpuAGpQPbiBPHmA5Uog89oVf3gSRTkKVDTdiFQfTsYAlhSiGr5EKDuvaEUi26hdRAGoAUEYDsP2gRF6lE9rMBkNFnubiCaIH83Kq8gQqbNH6kQgRZpg19YVOKYPAJgNkBe0AdvZlEYJQ+8Yq4+R9IEHSqagDWn7ygLy2UvvAI2iSxCshEJi/rAoHcEPkwHbp7cwIN+eYUyQV+JRANIEqAZpC+faUU0X+0ghJJBByrjmBGRRDp6lVMUF6TqBaA9RECdKXZ8Qo8f/ZfXUqALKCBXMgMdRGzv3lVC+muSwTAHSW9iAAQTKHxQJwimarZlUz0QXvUETlI3W4ExZBAJ1od4FA9TtOn/AKgADRDAJ7OBnIEHqKS12/1Kp6QcRrjcC10k4oe0CHqJZQK77UCsgMDY7+YE2LaHEKmKSJG6+fWUCQaYRMCA6DCBfz8wB32HdLm5VQasZUPdVAuKyoEMgitRxACmAPr3hUxJeKWIZtQFYdRCR4dx0QO2aAWRW5VTLMZDpOnd6jAyHSCeeC/neBoFg5UTwO1wBxxZyYWvgg1kjF0Fq/vAYkD0kghHXEqjfSvUO7+gkMFl1MLub2X495RDQAFe5VQJlgKyGxshxvxUusUCNEEePnxSilDIBjpcggIyyIHUBqrf0lCrISNIjnzC1CAcNDE5DjQj6KATkMTiBi6XzmNOIE/QcTkKB0fpKKciT0rIDTXn/smB/SVfpZsIyjI6R/YcS+Kj1TKtAY4iivxAAY/+VnS09+/4l+CEBHEHhEFfG49DA4rm6oUHH0pjRWWOIaLBZ+sUUsnHpeBHm4VMWFxiOTz3gMyGE6o9+IRcGCFiAhT76P7RRcznWJPSrJyNEQni5V6hYJe98SDJsjJdJx0H/MKvVnj5CJ3594TxcGChiNI/fvIL1DEDJnJjfeOpi9IBq7vipBH/AE7YIFjlSnqjI5beKH6gH2kTjQI6kAdMFL5xIMk//jHqGPVY/wA/O0v0ayGQFjdl3z+ahFwxCVnHHjsfvqSiH9PQb99RBcwEQhtviRED6kgAaPz7wLjdF2gGaJcFaAANhBsAl/vIAxIRIIsP4ZU1MgicuplM/wCY6AIGWOKsjhuTPo2f0kgFgC0ipETpyJZPFEDRgXeHUFq/aE+g2jZHH+pFMUMUWQT2lQGQadHYSUYKwEX6R6rHf4ZBSCbs46/MIYggPp447r5+YFw9RGNs09Qn9XG7Bvx+8lEBNMkBl188QNXeWIJ8JyIgKex01u4UOTFinZ/39ZcRcliCKfgfO8kGscqKPqOvEiVfT+v6agH1WAxVjiTgmJTDJCuDFBFJfXzqEUiwSRXJHzvAcjHR7bhFyxCB7PjcggYQBQ57QY1lWQJBXNSCYnrOq4Rl4igv1CuPaQDeJ6tkWdKPqKGcrIXjiQAQaDD0xKKX/cPT76kFwKAZ3yRBRnkD/UiBJIexAtDPqI47fO8IUdc17xgoI5B8/WQUPH9SVHSUIbWgPEAKvgQLltL6SBi3sCECNXq2IFOuoXIgbsoEQpY0QgIRoE8Ea+kgMADpDqBSn9dGEAeemvHMAC6MDTvVKpEQ6T3aECkEdoRcVIA7C4FN/XmES32ECgWiETUCii0PpIC5hAjkNq5BbYCf0gU6MIAe9wLx5kAb8wAQF6hAFnnzAPn6wKJBRp1qEBdfvAokQD8mBr2gT6agGZEUlCBRdcyCwhswAqBX9JEX6wHiA/iQIReXAY3v6QijvIHECwgDxAtwAkoQLuRF5hAGBYCAkRRUD5M+x6CEShAkAoCVSALgR7gIBd4EvtKpAlwqwJwXzKB3qBOVwYB13gOO0Ccwp9pQA7AwIhpwF/SBHS/MoLpkU+sqr9OZEQ8lBSqlcncAUteZQIBKLCgQBEt+0B9NXAUHaVLcKmuLMKf44gUsgoQjK9TMooIPNeIEPYhDvCoWhWMqrgOQF7wlThAfeBCCkoUZZA35gEAUkXUAdafEqlf+q7QA9R3AAMapcwMoZEgb9pQrf1gCCD2FVCpkzdLuIFOu3a4EIYXVXEACCepH2W5VLAoPzAZB7v8AMAvTRG2IEyd6IH5lIhSLp/WBHyAa8wq0+kDVKQOSC337yjJS7DzCgtrjftCNbFHwDAyce99h2EuqhJV5fcwKCbA/x7wBp7DGzABO7HF7hUslMNfUwKmRoqwOZUYJKZNfdQ02WX2uEZRR6hZH2F/5lEL6yaHYiBWTnyQePEKAnp9IvzAz3CAW14gH6iSETz2uAzHpRyofT5/uBMRZWIBRbOv9S6qeh9KKOw4BkL1KqXzcL1BkR6D1BDXMo1WPPqPYftIdZGyEe1blFLALAHq96gDlkHkKCY4YECcmsiUzX5gZKI6VoOpYrWQZIyxoK3+IExHScifu2PEUQt0kBQdQAK6jiMgRQGND38yi5AgCkTvtIrGQADyVDmnuU1sg5ApeOZBkEDMZPlA7LlGgRkURl5qBjLqBWQ9K0F87yxTI5ZAeprdE8Qcaw9OIJOOA4AhGRpAAF8X82oVOnJIgEJm6/wBwum2AemkCvp89pQYGRxQBohGgIDIkA4hHhZSToZZWshiHxH8ExAyJ2eL+kqrg+kaxHTpeO0Iyus5Y5dQtDt4+upeBpEPviBr6fmFQhZnqJBQrv29pTTMk2ciRRuifpIQzA6BiVj1aAqIfUOIOILPST5AcLrWOTz6ugnLQDuEvE9XSOg0efLfz/sDQQoI912gWuj05IktJSH1MsSyQerEaY37uCIz0lh9X/qOYAE2Bjj4DNfSExsEHLpxAdAHQMicQbIIGQB2Df39pQ6mAmANAfjUgY2SaY57jx9YG6yCBIHeRABGi8svijohQxskcg2ftEFDJK0Un4hFIOLCOLGx+JDq4kAsWggx8/iChBJ6TmQNBj94RoF5MElaf+ZBlkAHqJfA7d4G9krIWwgpEZBGIyeQOR/VfzvKKX1l5HVcKQMS/6qBZPBOozxORsHIhY0VXNyGIXfVafHtAA5MlN7IGo8QyA9QLIHEKuAJf6cdtD3hE6sRkjiB3/mTBUu5rsvpAgYohhJA194GygEAcnuREtkL6QNkkAklPKlThEJJeQPDAjBQ+xJXOUiIScqTQ/OoGy/V1dJEIgHT1E/dQpbbtUTIBOyr4JKqEaINBXypBOO4AQ5gbHqBLHhQjLGOXPt2gaBdkVqzIiEZC28VwYCyg8qP8QNYkJnJ//wAeJEASu17FSh0kCiEJDVFvaoUY4lHZFHkkQKzwVwJBeovbfaBMSGj+8Fax0yeOIRAjkcch4EIp78mQDWRf7wLl3v2MgZFADI7iCoENf5BhDElunBVIoIoGQV8dvpCDBGyzIBGyCgNeIAEkVb+kA7TAJ1UqNN5J+ATMiA+xG5UVuyOJBQaLKHyoFo8KRAeOeYAoY/4gBvs4RT5SUgookgFwKrRdfiBeeRCM8MWZBqiSX4gQGufJUIpFnZkFF59jAo7Ne0INbMC+r/MgVaDgUM7JkRGXY95Ra94D7GBfYTKHPEov5uRDuYFH01AXA13kRBTuoFkD7QL2G4Q9oFFyIaMCgyB5gIRR9TCK+DASBAOEVwLACShAoPeRFhDRgWAgJEfKn2PQIElAagSAgJVIE17QB1AfSAXtCoNyiDtAXCleXKHMBQygTWoDZMBxAkqnEAQ/8wIRcAvvKKpBm98yqb58wFpQHNQp/MA+CfKUCLgmtSiEeEYUF8wLz7QMnRFmBcWBAhXiFQ0d+ZUG6f4gVPVQrIBYCD92pRSk9cwDHBowIaHYQqAUweFAAPYJPHmBFtGxUoo8doUxVgv38QM2b+rcotLWuZATLewpRDd8D6KFCHvjvAhJRHZkwCO7UBoXoXKpQdfWQQAg2NSgCDT9y4D9I59u0ohxDBZYHeNBerstKFQAEECu54gMRX0pbMaJSQsbqUXmiP8AMgqtNKBkhgk2B5lURF37QBJWxW9wISQChj7wKHbIL7iBAfXsJe0KyNDkd/EoBAlFHZfz2lA9KXTXfv5cC7yJQ7XzAyxjn1ANC6+eY+CnwUfLhTIEksEBfeCAKFnn2gQHsD5O33gBrpxA7uFQ4gg9R3z3PMom0MS/bKApdAO9F8wfqirOQAG4WskbBJBN2ZRSjvLhgH2/7BiJMPHR4uAs5HYGm9GBSlzZ4qFRrKyWmivjlAICzlliStt3AZKwUCDduQZxWQXmnuUXE/8A5KbBqPhQggHHHE35UomOOWOKCH0kVCizfYlOFCL/ALvSCVKgxeJ6kPMAmmhd/wCYVMMSDjiDiDQJGK4/eUXJEeRZAFN6URE6hl6scSBlwRxCxMsliVfKB8QqdOPT/diSEQfpKGIQIOI7gk67P6RoAY2ASMgUEI/p6oFEoaNkW9wGAROHSUb234XeD9YAyI6ygO6L7Sq2ACDiMAUiKdSeoz0g+plEJn5+ZdWoD1Y9RLALIPuYONEAvqA9PcPx/LiDGXIBu/rCnQdlLkODVHp36lfSPfUJVzyTfIo04hif08csSKBA7D5/MX0awyxyCH6SVrd6kwqLpHpxvSxNfTx/mUDjixkgSBX+u0mouQt5Dijr2gXBZ4kDQpj/AB9YpwwRwsggCvHgmL1KUQhixdHkmQWid+RW/eQa9PUQcgAOxhPQCsjRVgcqDQoDr/mj+Y74B1ZNL+0IwinLLQOzVXJg1j4yN719vjgxL6xlkTY7bk+JxMWA/wC2iWJRRXULHJXMgpyWPScQMR813hIuL6ySVxr4I8SmWSy6wCsRcmKenL9NeQjGYi5fqPV0oir3IRRkuTT2zBgGA0AAe694RR1LpGt2IUPSiMj+bhECyIAA80oGqRxVFB/yZEAcQOo50PzGFCBeJTP1+cQFAnYyIcDQ7DI80uZEAWSa6dU4FJCe+SzIDWQotHn8Qi4jHjFiq8OEDdFG6Q3CpiQfSUL1FGsC863RHtIlUgkFK9k+8gY4obP+YAmrC+u4Ra69WivMACGfSFxcCqx1G/aRAAsDqyqn/EIE11bXOrcQVnIvpROxAZO1Z3IKgg8UV3ioCuyN61AuwQQd7cguhtAgwGJ6SvSjfaEqD9LOVdqgbxJND3EiCGyEwvMCA0z7qBruORpSIhfHmFABtj2hGhRKZIuBciQ9oyImNF9QIHmKKMqug4AsDhn8wL5H3kA0bD94RRe696MgY6+UYB/RQi+7X7QK8SS7hAckGQCk6cB5vwjCKTwzvUgo1UCgFtGEB3gO9SAz9BAuiSTCBJ/V2EgrY/xUIFPbqBWqUC2vaQEdaEBWlCAsqBf2gGN3IL4hD6cSC15hFHyoD2EBowKO4EiD+0CiQBuBd81CECuRAG1UCwEgVKi8SIA94FkD6CBYAciEWA0ZAgaBciEICBYCB8qfW+8gIENShAkB9YUlCAMCftAQBXaFZLUqqYE94CUOFqApQIfeA94D8QA3CpuAD8SiLiBCP7fPeUUfqvUCHcKBPcgu9a8yiEL24hUKbMBjXtKB2K+8B08wATBECFiFGTqBD5cAAdskiURQKe8AVRB8wM8SqWqr6QKRvWnqBC+qtQqHSgC3wjAHXcQpy7rUoZf+ulcICg2yBCm0jAzXUu/EouX/ALAjtChFEAAmBOB+pviBGBkdQBsBowpia5r3loyiuwHbiNF6gUAF5fztKh/bV9pFQ9Vsgo8ygasA3CoXYCXKEBkCaDB5iGoySBoe0qiRNEkbECgeknG+NyImSIASbC4lVaIrtqBCwska3AhogGi+TCr1Gsq6d61AzkwEx5gUtoFjzCsaKJJ7/F5mkaJGQ35MgieCJHSaY5lVQgFiFbK4+KOozkAQDb1EVat2e45gQaPUHzA1ieolH9PaMGSsh1EBJP6QrIBGTJvWpRpBEHL08nj7wM5YgEYIb0RuXVjIIH9Q5HIJ80Y+DRfUDtih2+XAuIGWWstvt/3iCogwj0V+kwJkBiCkjQ/3CjeRKZ8QcTAZ4kb0vtLQReNEY/tAqwF0UVHoA4nPE4hFaASgZJTxCrcHQ9SDBFHjTgTO3XUASu/y5Yp/TxsnF9WJQLcFVA40ka8D5/ECH1Y/+QcCiPpcfhKHpOIzZATJ+fSBEelJA3Ypf5hTLEnkg1y5RchZIOQBDfJ9oNZy/XsADvwIFyFDFL9+/wDmCVMhkysiQaXS1f8AiFPScQcfUuHAlZZNA0ED2jis5nA5dLxQurB3+JpGgsMWz6RRO5Oq0RjkOovaZPnmE45hH+pSIO+wXz8S/FazL9QztKhcQXLWWGJtsAqD9YOI6R6f7hbA+f6hUGfT/UOIJJ2l/MueDRz9OLz+/eQxMKxfSAAVxZiidJLZY0h3uEb6+sI4jpD2Gt77ajEzPQA9Cw1tHiRfqF4nL1mi7uBo9WSyGIII7v5xCIeokkFjnj9vaBcseugkAyeDzE8TT1HINjE8SC9KJWAeINscQaoAOB6SAqsHtIl6pIOIJXLIpiDFePSUOmvp8uRMDif1DFkcd/8AcoEkZY4GkeGRIfsXHPIeoE6sK4MMwqZY7cqQCbPTkh3cCAdNYgkc7v8APmNRokZYogoXeifhgAQMAMsicTQGioRomkAAHf8AiQTLGgOn1Ere4FGVf+w4MiLgSAWH2v8AEFXHIElnWmdxiALs1Q90osGccbYJJa91A2OmwiQNgD9xIGQWQx87AECA9OZJGVnS3BjRbeJ45NCRFxDzvG27MJQLLIEsZJoGDhkRiGCnS7SZodTJSP8AMBiDjY4o3FRdrLeLRRgaeIAIu6/mEOt5A5BENvvJYIckCjQ57/xGKtkD668yIE9gLND57wLgBYHS+JalUEEEtdzIAIIbvgc/9hOKSECQq1z8/wASAj7O/pAHGg/CUDRAIaoilyZEZJBzoj6Sjex0yIhFsE+b+sCghVR7ESC7y1ftqBOoHLkjYQhGqxxoaFSCscgCER+t99nUClZf+z1IKbeLUALHBDtwICST0gkC3xCNMADcgYte1QIMb78QjQyJb0NiAVdpBKDRP0lGrqwPEiGyS9eYF3zQv3hAiwTqQW7SrmBQji2pECWLuBSWL7QgfcMagOVtcyADbBvs4FIdWYQ2aqFVXQkQ9xABADftA1Z13kQOlUANVYhFBW/zAot1IA7wAA4hFB7yAdqUBR1ILzCLjuQAQTacIEwLAAL3gXzIigriRB2HChgX6wiQNC5EAYF3AOpA+sIvECwhzILAkIr41AsBIEDQMiHMIOBYHyp9b7yA9oCBLlCAgSFJQgC4EMBxAb4hUA+koBMQJCkoNbgC9wIKpQH4gIEC1Ko4Di9QGzcCFcgSqU1zIgDf+YVDR5ftKBWoEAThSy4AELlQB1pgfSUZ5hQr7wKdVcB94AVzZ7QINLj3hRLuFKggQmYEPUT9KEqo6/ntANgI0NQIue/e4VS6PeBLW9ntAJ2AfpAjDYlUAxTABUASSOF5gCDdg+0CA7AF+JVFdG+dQhy1CoH7gwAFE/lQIdoqoiqa7EOAPcfSBnQJ77uUOplMavxAq4TuA3p49oEFJaPBKlVMez+kC/qJZJWqgQOw/eAHAVNtwqAMLuKr8QIeopAELiaFttk+3G5BMmzvXEB076Wcu/eBR1FMCwXKIBjTonYUAxjliCNwrLZAJAC15hVptOqhE6jjSB59pRLrIl+/EKYlE4oLsfaBSB/zmBnWSoLlQKCiAlqz9oGQSD6RuxKrQBDyIMACzf14gTNgNH6xFTqAJC7s8GUUNj05Yvk3IJkOku7FEHUsNTNElDt5giYojJEEvgRVUW2d+yMHExyQXTTaFcygSWAKT/Vv7CBkXkiAd0YUyDAAxJdoCpYNJ4vHQKfb44RKQpni9SCenEAdTOgdL5UqpiAHSAi3VPSMk8SQWEbceo0RiRYISt/LgYPUSzlxXAlVQSMPA2SLHtH0wN4jeIGhpeftHBnHEA9WI6SR/ba+/tLv+qvAIy8rR/5+8h0I9IDLPBVfAYFxBy9QxdePpBuM9WRzfSR9P8+34lPDC8aB9IVjjmKJk+k5DJY6Fb+MwqnGy8uqtEJRoyyeoENUMjKJiiXjl3JLNn6R/RS8Sz0gnufMBi8fUNFt19YoY4kYn9WIPAriNGc2MiMmMcb189pZxW7BeJYbSHj/AHJU6MZLop2ADxB/Wf0gvEM/qpVApydk5LH9Xvzf1jBoBekDHY+g+CQD6v1DpK4PtJwARgcSVgTRBDlToALbvxWoGsb6uoZLgk0JEML5PFA0YouIJAodLcgYXybt9j2/MUT1lEZUA0QlL4jSx/UC+L+viREyAaYJQCe4VoDEgjEBnWXOuZE4uAyJx9QFEFKEoMsQR1Pqpor8xgvV054V+r8fX7yfBGyOo6H0gaCDyXG5BkZHCgdC6oOXqYooN3yCZBccjiSigddjX/YxK1R2iv3kEZxyIJIxH7wNA5AjFUe1wMAl+kgOk+RKNj9PVRkRQ36rSbD+kgZAgA4yB1EZJd7W5UxqwQMgA/8A1MgzkALxAL2RL/RciyViqdfvIhgiMl1eHJRRonLnkwLjkU0Cdwg/KAsW4EB9TfeBosqrNtyCp49gDdQgwAAhfeQCRj6Vl9YRcT+O0KMApu6YUYjTCRAXiRGUz+qyJRoMYkDywOZChDDIIUAFR0T2qEK4JeyIFpdu9+ZEaAJTIB8yAOpswGJojRHmA2Gzuh8+sCoMpvz3hEBNjjjvAoRPZeJBpop34EICrBvnuZAVWoDKiSdbhGtGiibTkoA9WhZuEL94Dhqh+YFB7ZVIKLoo+0AyCCWDyoQHt9YFxplfWRFA5I+sChvfvIGOpURHuRXMC1sSIUTV6GoVQQcUwAZEUcPLgwDSBDhFBIIVjmA5DBakF7+BcCMjkwKKvmRFG4F+CEOe8C25BNn3gXhwihyAdVAoJaBgPdGRA/8AXLgpLJHiRDHkJOBeNQAJTgPlSIo+sC88SCwg+0BqgIFB+8iD94FcgSi8SIeYBvcIsgQKIAe8IsBIECjmRCEWB8vifW+5YEhQwBgSUID2gSFJQgQ1Aa5gL3Ah2+YU/eUED9oEhQyhxAEQIXAcNcwB7694VBv2lA+HIHECE1f5lDRuAyOrlVP2kDz9JVOaC94QKAhUOqX3gCqV9oAgXUogYswBYBH1MAvx3hUPDomBaov7wJ0g+/eUMq9oELAY0O8ASVxfMKjYarmUAtc+8KEXTgEsWRxAA96UBdslDcDJ6rQuVTEfbiBefL5gQDbgQBaJA4lDZtd0YDTdwoTXkQJlYswGTYJABA04IYgAMUUfMqh5kE3gRiGJQC5aXG4AoWciPJgP6mLDY/eWES6AkUbBxANSiH0/4AgX1KkOxgTEhaF0oDIerbCR8wMmqVc/Pm5VUgAoY80TAiA5rQA7wA/T1Y8CipRD3yAY+0itUkvYwJdEgB40FqUiE7BxTYINwGQHSab+0ARWn5IUKmQKCvsFKI20QqQgMiRiTktu/MCtkWsvHbvAgCyJQePj8/iAyDaFa4uFGVRv95RGcReJFFKBChk/Lf7wJmbx2zetSyK0eScaJZA/MCEbyJR0R3EBfUKGA13v4YEbHSmwtP8A7AZVh6ShpowoQCAMcd8ESgQuoABE3AyB0kPIEh7LZXb6wdXIZBjkI0G4hoMSfBAV2+XKahdHJ9Wqv4YEJwGWJoEj3r2EKo6cicLyPf8AzCVMjjRxRJ/tHZf7hUzxIHXiUqAA58xKociug5B+KLlBk4PIBA2D7QKmCOkPQorcgyek5PFPuD+JYqiv6bolCo+oYlfqHURb2t/7gZCPVyANAm/55lVMscj1I4jLkmqg1cMTtIFo9vMFUfq/UiDtswIBiMiyCx2X1hU6cbJCBpN940TH9dm96/eXQBGLyFgDfY3B1SXicdnhj9q/zAzmhWQLeokXVPUxkUcgKWMIuKxwL9JGJNVvzBYFgE+WxAAnLAjGhoD35gXEgsHEFC8QgRCCxxNAj23Qk9Vf6gBxfWUHQ/b+YQv04igA/av4kFJyWWJCRJBdfSpUD1XeWS2Cag8X9TBzXUdjcgmGYAF2f2ixFy6X1MLGmRIGXp4ocfPaOjWXIxxGOJ0RCHTjlYxOQKACqDUF4ciqdGQUnLEM8MDLt9PpHRoEgEIX232P5kRfUCDkT1HFUq+f4hB5gkZBZF60RB1MtFI8ex5qBQfT6TRHJkAh4jLE+54EB+ruNIKhCcOpYfqZJaA24Ghk0Cye4qpMQxolFkUC9+0Cmzlrsn+8A6TIPuoB5AAZAEpV7SAwMqHLYqDAs9KBLsqBosllZO19P+QyFWT+pgV2kVST1A5FcVCAJSGlvtIGS6QLHioI0WVSJ3eoQyIDWQT+8IyOnDRsOx7b/eOq2QbDase8iAAGyMSkFyPrAEGsTZ0bUgAhggEkKwJUaxyxJ6QlxIUyIogWe4QjAyDx6gTVBcQha6WTwlAry6WTo6kFDIPmmhCBs6kAFYUfUlA0D0gg8X9YRArKa0CIBMEdW+e8guNGyA+HcCggFE67VCL+k277yAEDYHsIAUeat9oQaa0pBXsOyfzCD4TMK1fBJIH2hAfpRthyIHR5hQMjtCKyyDZVg6kCuz8QKRiQ9wgeHqBS7BUiGi8diUVcFo8SBjlxzApX6g6hAsFiQXIvmjCAs1s94AXj57SBY5f7wNPhuEPq6suAZ5IPmQDqjuBR9vpAux8qRDZtuER0rZsQNA8G/JgWQNk3AeOYRbW3IBb/AMwFlQLy3cISC82XCKD9oA+YF+wkQPe4AfWBT2kAKEXxuAB1AoNqRFL7QCYkCBePMID3hFbkDiAfaBRuENwKIASBqBXIhCPmT633EB9ICFICBDW5Q8wCgSVSAgTUA1xAbMCGFOA5Qy4gQuFJQ494AqBCNfzADuagLhU5UocvjxApv3gZqAf3HeUD5MKgbvcgWZVBqEDcKPSgTlcfmBCtpygy26hT7mAvcCEAaRgQbdgqVWsgEDXhQiXqlAho+pD8wKPVwfPmDWRkhsqVpSgB3cInBhUVF5b50oAO1AH2JgALDf3lNQKyWDqFP1Dvx2MBkPNd1AdwF4MoEVqnocwIN8MXCgvKxffcCsjSkGSaDv8AmVQmm6JlEIyVFfSAJvqW+YD1fqGz34lBEDYkEIyIBgWwzk0oEPpYOz2Mqo6GXPtcCIA8E6cuqBEdJIuEUnq9oEpAjg6e4UDA9JsduYAHL/1GVQIHlkCaC5NSiAGyCa1CtDQBJJ5kGc2elM/WUgcShdb+saIFjiSfpHQ6fSBzkURxLouWQdaBuCMrEdKoivzCiGL6j4AEAK5D2BAg/Ud3yf8AMKvS8uojquhLqFEKmDscQqMaKBOvpuMEBIx6QERqAoEG0NEOVTEHqWRHV2/zAzvIEltqBoD/APGGONr59o+iFZEEracHFJJI2DXmCM20RT/SQN1/qVUHVxhSSIgC+pk5e3+oVTiQEmBzkY1EHVeQ9WQ1AFBjAi/z/wAl70YxDeXToWjQPiGm8yMsQQ8uyhDFiwR08BUXAheJ5y//AIeIFweVEYg4o2YK5jI44vEZEG1xL/Va/qZY9AIIIdlmCIiGHukef5jqp6OmyT1dyz9JdqYAZFkFdvLqFOrZxGJXHVQ0YwaGI6x1DHqBWRP7xTfGMQ+onEnJqvMAQSFkCOFlv7v2gikYksdZBaSf5hQjIvGw2nAm9EEjLT37yiDgsPeJVe7gq4Pq6SBpMVa9vaPBcmgQb01Irnll044spJM/4ms0U5CyAQ0TieB/2QXLD/6IJNAH3jU0GWXpyrJ/F8/iMMXpy6QRmMcstj32o8TWukYisqFjxIqAEgZHMJ2HzINBYnLKsqW2jCdM3jSGWtMJRE6gyP8A4wciXX895TFxAfpt8q5CoCLxyJAV0vnMDXWcr7/T6/tJiZIoSFLIGhAL36uOHxCAOeOSGQJWjRPaDwwBOeOWY6VWvxBTEC0PI7iSjYQxGKJRZvciM5j9KQRgXLp6cfVXAgV9INEn8x0VLEAkM/qPiEMsx1DhHXcyYFHpCvTHvAtY0R1ElADUnUUNbyPlMQIAskkGhcCgLLq/uJpmEXrxOJHUF319YwOrQyBL7cKTAHUuiuND55gVDa6gOKqEMQBkQciT37QACyBt3v8AeBvEegBcX395EQEH9XdSC3kRTNaOoQDBdrs6MAOtsUSEnUCH9QPPvA2BsBDvzIgAQCRR80IKFH9NNr2kEAJeSFCz3MDZyGWPUPazqoxDR6uojmA5r197UIuB7kBCiBIVm0xiHzcDWRBAQ510wioirHEgPEBDHexKAGzrt4kRbsijywYG8f1APW64kqfGcQboEuFAKVVSFiEaP/8AEgHhqARt0C5A3XILsQhidbvRjCri2iWNSCvQBgQsDX8qEaLPCO4A4g1RuRAMIgwCY36uVA0UHZkEQQJP0gaFNLS1CB/+bEiAYx1cCjxrzADsQSPdwKybhAF+74kFT/jxCABBQJgMdgmQXv8AFAvYdoEJfMIpIQ3IBoICBUgP3UiBN+0C7AqoQ0dMwKIDn6yC6vTgX3BXkQiA/WBfDgWRAIGAFGQaGl4hAGA91AurkQ2dwEDUgn1hF3Age4Gmw5ENXAvt+ZAHuYCyIRSahFgPpIChFuBQeIAQAkD7QNSI+aZ9T7WZVIQhSAgDAhlCA5gRSqQEBzAkBAEQqSiHsIA7hRygU4AwJs/WA+agQ9z3hS5QriAXcRonMB28wB32cqoeFArT7SCKjKGiwVCoDSp94AEvuoDmt/mUBb2nqFO/EIi+8KCsd7MCEKg1KKb5QkE1lwKdyiao7MCrhQrKoAI/SUUso0IEXhwHNlcKFCAASgOYBPI6f3gQEg65lUt3cCM138QHUT8uUQNkDb+0AwcQRoQAXFo94U9i+24DKzYHsRAh0xzzCoCH+xlF5VAOQQgvve+0oH9V/nUCJjtzKDxsiBMyggb8wq5H7QQFhg6oriBOWgjAuKsb4UCAAEbPcwqEnYXj7yiogs3y12gTRLJPiARIJ/bkQan9xKIeh2hUySyJNUauWCZgEdgH+IlAknKu1HuYAk2De+PxAZI5FAEt/wC5VWw6+37wICMj56qJ+/8AEBwSDkB71AySQOo2er+IVLJDy5FD54lFJxNADsl88x6QxxIpgrVxohIYtFbv6fvA0rAGz+qvniBhsshA7UqtZX0oqgGeflQBIBJBaAHz6QMjFYktkd9QBovq6XdOo0wBeBxJoY0SO0fRMaJR6ukcyqD1HoGwTS7eY4fq4pk1trx/2QMmSQdD4/O5YMgMDEHnwUH8+0ousKJyshSH1jLEUBjV0ChLqrl0nIuhojmOAenH+p+oYvEGh+PMHxF0jpI3YIhdax7MEOzySRFRkhIA5Dj1bfvKRcnmurJZHS8+OKhYhxLNB+e/z9oFFk9TJG0K7wITTdkcW4VRies2meAkPlQnxgZZDK+mi03/ABKq4hFg4nvJRgnInEXnl/MqtA5ZMI6QxIexAzbIZs2fD4cuidQWJ/SRxyfpKY1gQQSFthij8qQoACQcKJHpeOuY0MupgstBmiC/+QRCfT+oh8vVwsTHNZIA2b7gg3LiVquo4nLZaAbkOBBBpANknZ+0HwJ6cwUb5NyB+q8ikj79t/X5slUZrqy6SOSIwwzrDpwY5YseYG8+p6y9tmRIzijiSTrbrR3FVoEsEHd/5EVFwIvpB+9e8lGcOnHIAAADfeKivI+rGuwXD8e0GNXiOrqPSNsydRkZYglEH2NDvKreI6gbZfe5Ep/cSQLHH9ocgmRwAyIeVAoBSp6f1ERYQHwSDXqOasUrgQjIFPI2abRga6jkchiH5I+faMTik0QCDwnIGOTN16tn7xiARBzQHYgyCMjFt2/opQAaPUcrHtA2csjayHuKkxPDHEA9IydUPeQMiAmCltD7QKwCA+zcIhyLHXY5/mDGskeka0KhAnpsPgAHmTqg6R/TOQP1hFzQLzbO9SBiaTKSHJqEwxonpoDTELWg8j02meahn9AUyTZPIkxRgskgjj59YQxSQNNm4GqGAOI++l3kRMthgc7hWsiGTlrsNQgx/wCQfqLDrvCfBdPpog32gXE8AlfvJQKQxscJsQFEWWdE6XvCNEEUSvcSAE7sjl75gGxTJI4hFQLJNNk1CICQd6vSEitCrZX8QMh0B25gaDL4rvUId+Bz5+XIBJQJBYgawJPcFsSYlWiKp+YDnf1BhArWvHIgAS9RgrHVzdyAdp0/eEW9gV3EgBIP3EoM+oq9lSIEsUl3EDRHtIA1bgXndniEUHdASA0eyhBt2j+0otJg1IiNFj8wLiiCGKkF5L+sASLQJPmEMr2HAuzdUpA6e3MCgkvYhDmjIKD37whsEr8QA0hvagAt/mBq/aRAAeYFdCmPeAYC8QEg0b3CHkCQK6SYRWPeAHaAH2kFFn+YRQf9QHMgD2hF48wHO4F35kQ51Av5kAGA+VCDEo1MoCBdwHmEIFgJAgfPn0vrQj7wpKHECQChSANwJKHtAQIZVBAbpwIoDinAQIRuVUMKt04ROdQp3lD2gFAnHiApqBF2hT5qAlA3RgQg94D6QG5VStGRThKoA/iUQ4kagPwIBrlGBCNcygr8QoEE+0B4EET3/BgK7uAIDfaUTkcwHY+VALqLvujCsq92ZRonunAhrnfmBNWhUKoNJm7cCEeC9QFFgaZEqmPBAuAPgmBk+CwdShl+oUFu4DQ/zCiNAcdoDXPO4ETvZ9oAfqsGjuAIBNGxoqVQra1wZBa6dPtKjJRYWl/yFUq9kHmBlAMOvfUGqS87JxW4GQxtXSlUF+obeoAIU32MBkPC8qBARyE5VECsb8gwIMQh6d+PjgUhYkj0k+YAi9FnYAgZSJ17pQpmVkBXZGUPVTLpkg3AM7NL5uBb9Sq4GSAz0kAsGxLBQGa3sjzCowAwkT/EIjHUKqwOfpCiCKYBveoFLslpWHAn+bPMugXeJscU6hWcsAQ2T+fMaKf/AKRAfEKm8j3b/wB+8oO0XkHXYSBx0kY4g8SiZgMEg61yfn8QBxv0ZAZbgQXsjuArMKjyDA6gQHQlVSD6cQGkb+fv3hA4rIBBf+vz6RKC6QPSSCNgbgMm15V/xKRkhi/VaZB+doFpoPJ6YqFDWTALAdbuBN5BNnuIDpoFWDaFCCVMSCWUCmLhUxxBJxDLN2VLopyJ2TkfZwJl04kH241uJ6BeI6xS8U/+Sn4APHpGPpytH9o+qmVhKyhvev8AMkFYyOTKAyLfEouJeOJAAqn2feQYzTID0iipYqG/ViDf4K+VKL/VYyHUekC8ge8QiEZY6Y4YNxq9XpNCkCB2jUQrHunfB+ajodPVeLOXOVP/ALGrxMCsmQCBkhfztA1kBlwcRxkeOwqNRdnq6QMg0EC/3gXHJYHEaI1oA/xciYhtrEUl9v2hVWLJGPpJukYT0WIJ7c0lArB/qdOSA8cyYIAcLJJJpe8BjZJ1mza5/iKjQIB6dgmiRIGY1XfScQ1ASnlhvZHfjjvKjWIGRAGCAs9vxIVRiSAw35/b7QiZjHpJPSCeRUaNWS/1Ep2JDidJbZ9Wqg0zJGYT7ABoSJFA1bCZHPy5QJIfUdCwO8g0Qb7k15kAkHvgyL7y8SqADkh+rnt85kPh1IHJkM2/aExBmOoEWHscQY0gj6QARcgIWT060OYQAKCDxd+YFLBI444rtJ0Djj0g8e/G4FBrfUuIAFk+T8HvCANrGwfP8SYKD3OxwIwXIK+ka+kIEDIoZI6epAF7JPjhwF2AHXBX0gVWBih25twir1sEPZHEIoK6SA678yBvJA83y/n8QINA42H4gVgFj0vkmQaJti0H/mENEC8eIFpPl7q5ETE2ztbDgAA0vqYFsUGT9pBSQEUbT8yoF7tjzIKL7B8eZEP1aRvcooIslpyCgsDiAyILoVUGCOVgI/zCLkD1Al1tSCEVwoGqOyF55kQJA1YB1AoDrS7wgGL4faBTbBFfeRFZ274gMcuAbI+GBbLkAnxT1CDDgVvK7HEAukc9pAxOxzAoKKA/1CBPxwKOpf8At7Qhs2kJBeBY8wgdcl+IFBBNEeZAAuueHAZNsD6wgFV/SBfqz+8gve9moBuiN9pEUX/mAJpwgzvjzA19nIFbbMAPeAO4RaWpAgBAvNSIutuBT3omEKNXAQH2+sC7KkReZA9oD9oRR4gHAsiL9IDiQBAU5UWQX2hDiQUQEIAwLAOQfPn0vrIAyqzCkBCBhSANwJKAgBcCSqXAQIdQGjuAcCEXCo9SincCQpKA3AEOoE8KoB17wIfrCn7QD5gXdKveUZqBBtSiqRU5/wBQquETvKIkdwqmn7QJrLmBL3+ZQ52U/tCqFzAiVfvAiZ5gU+N6gQsoqUQ62BuBQBVQMorq17SqjqMVobREIFH6wICjs/aFTEjgXv2gVUtvlQIOwtCURbd94VbGktwBIL571Az6jR7cGVVNJs94RnKi0S4UaLBQgN0UOYAEn/EAPoIVMe+x5lAkhgA/5gCxyLMBmn3+spEYOh4cihLDOlZ5lEAZohnw4GgNkhniBMeRkNb8QJiV5qnfMohB9SyKPIjVA9Mg+aUCZ6dVpiIBHSShlqUTqGJ5fbtCtcnE9795BkksUdaEoEDrqzW7gQEtk2KUAWTqhocwKGM2NQBAzzVeB3+KU4ywD/aMfn+4xT1IFWeCIEQG0kLepRURp+z+eZBCSUTZPbiVVAJIB6QOIExVlEfPn4gZG10kC77eZVaVpAVsSCUwX9GK8SikkghO3uoMTQytssHzAnSAUMqPHJgU9KKIKBJXEGs/3npHmjKosgzx+TAHH1Nekm/9QA9JRDKg6HpxoZIKlr6SidHUbH0Ov+RoZAEFBcSaqEkgPIPkV7yiZEHEA5DnQjBoEMa9VkH54gc+knAZZEnJvcuqPIY2PIKsCPBsUfUBXJ4+KQTLLEnueRKDGORYyBaZNefaBMMkgMbL8B+JVUYvHpBK8qQAD6iHQ5CuBBhWVPf1jTUIKPTmRWvMqr1EnWYPBITjEY6cjkRkjWtP5cuquQ6CAggVfPy46JmQPUBjft83EEyLy6yT7eL5j8I0Way7OgVz88uBMTkcu2RpcGFUZOssulJ+n+IxP4mAIyeIIK52u37QBOQrEABmyfMeDWQLQybP449rkDNAsY8EtedfvCRBlSXSAbvQjFaBJAYKV48/LhMBjwSQw+Bx5hNaxPSCyGXZ+qk6WGBXVjl0m/F+BCUxeKQOLH5fz7QqHEE5Mn1Gg7UmooARdDZO/p+8BkWD0ksdrVxEMsSMiccRrg93HwOoj1DEgmyeJMVsEAnGukFG24qMkknHJAkAcoD5UDWv6qxCKGuO8iABZNgh+0ASepul31XeBrE+vqGQ6S/3kqKUcwSUOHQ+VCDNE9Rx0B0/PMYHq6QWia2IArEMj0kWh44gUgdX9rWpET1U2TowreNkE5BJ6+sjNMSwXj58gQtTHqJ0OlFr+IK175BFASIhqyF33UDQJRI5O17QYjxRAOz+YRfQcq50OCIFOWCyRdXS5kxC+vSquIAAjn2DajRSAMuqkSyO8Cg30hH3sSIEjqOzRREC4gEti+2jJUCXiaHvC4t0GXCIeAeom4GgbA5NmRGRiOkc5S6qrIY3zciNYnpOxr7yIpL4NbqoMQHpJKHkguBQcqYTdmEUdOgQPrILjbXarcAAACvpAEAs2KhFZaXtcCJFHJ8ByDWQIIXBhEJYBFuMFI/uXnxILdO6hAMG6J+0Cg2iTXmRAN9qacAdoEbgXmuTIKW694EfdQKDQf24hFXfXvCLiVQkKYkhhk/zCGMKqDPkwhoF1IdCyCgXCBs0QagUk9pFXR8cVCCJIOytkQi/3QFcpyCdy4GgfU+8iLyz94C20T4hD+0X9YF4e/EC87kBGoFx4LMIA7akAMnbC1KKx3YkQ+kgrrcAwj2MIoIJgHtOBeZENcwK7cgc1Av0hAJwDgXtIh4UC8iQOFASooqRFgJBbgOYRRcBIPnz6X1kBAilVICAgIUgD9oElDmAgSVQwH0gS3AGA8wJQuFOXKHMCEGFBKFVAV2/ECfUwFJEVAh7wp5gUVtwJ9ZRA+ZQXkyAV48wqVxqUS/8QqjzviEABdG41UqAN8wGQ8qUQdwyYBa1AHYRhS2oUp6DhEXqsD6SiEcwqpHX5hEOz9oXU3+0oY3tP23ChGmagC0KDcCaLbfAMCA+SfrAoJSDcqiPSSON1AA3bPiBk3mblGi+RruJBkhYohq9yhdA/txCpkSx9tQKCyHStiBEOSAfeFXWQfARgRUe/wB7lE0RzUAGR7BalEIeXvtwCWTbBseYNCUFl++oUIXnnThERbBH8SqdSQXse8gAsuh+TAhVY7fAEoAgG+kfP9Qqc0Tj9YA2ALgQX2oWApVaBAoYsuwpAILrZ8QjBPq5NWGpVMsRd15jVALoCgwIRScUAQS79vMomORCB2qZ8QuASGKPSO8AWrFLUDNENIkd4VX3FkteIQA6QkKpRp1APVZIY47Sqn9NgbpIRQOIWKscW9S6arGja2TzIqDINAECkJRg4npJI9JL7EfO8uihYgvnRfGpFaxAIORxBB7kd4RMjbRBSxqCJkGeR7cmrl4q54imd6uCJiiukBqmTcFSgvUBT+nv81KKsTkOl4geNwIrJFjvsSLq9VgsEbGS8/6lwTHq6/19RH58/mBMgV1aPk/PhkUSzIBxYr8fDKaE+ssvQA/7HwZp2B1Cka95RrAn9OTb+CQRBYosXQEoHq6ADkN7XiPFRAEZ4jqJZLx3L/U/GcT0/wBpxAu2FFjS3+mmGGeef8wi5AHA+oghgjufaSeCY+k3jkcjV6lVDf8AUJN2N95fgueSYOQCddTkwiZYnDHpxA9IYHmXdpC6BJIN8a5EBkMiQR1EimLqDyIxlkMcyTRI4PxQvD0/pyKJxpAuBX05ho9IRPcdoRAji8SLSI7+8CissQCDWyKcHVx6jRbxCF/PhkRkgdb13ZfbmFaQBGQsZB4vUIpYBC6gi0KHyoFoEjAlkdW/xInqYg9XVjlk9O+37y6WKMzjQAVEePJkwxcSTZ72h/MhUOQeKeXklAe/mMTjQyWRBOVB0PnYQMnpbKxB7c/iBSbAIVbf58wigsgk+oBIsCSjYyyCABbW5MSqQTybe1RgY/uGXSCh/dKKcQWQ0DYAepBQzkcgRQYXEC9SWPS2CcrkxMMScDeyN2eIM1QUggBwG5EOpHeLXiAshZYort+IDqVEjqJdftA0D0UwwSq13hOogM/VzdmA/p0AdUFJRo4gAIAAvhQmqMkUOPzIICy+kAFDvKIliSSEb6e0DQIAIABZvuJEa/p5US8WeGZLEMiQycU6B4EBkHWQCRA86jguQxKVuEBYCWNbUBwGSqOvxIKSDkGEoFRfUNSCgkIho+LhDEHqCJ1T7QB1sAwLXVRPiqNSIjHUSOVAoZdW4RcXos3tyBSxI+0B/aPUSIMaaRDB2XCMhi0uf+QNBpOhTkFPT03RArzAB48B8lwiA+tvf5gaJAJHPCBkFyFLEsAV2hAffnbkAhpfdwGJtGwuYKospE1xxCK/VVqRDeKtEQKNhOhADseKkEpvS7SjQ31Y8/iRDui6+8C1xzbkABmgYQZdX/EDQf8Ac981CI7HSP8AUCtE71IB2CbhAlJ6UKo7kFimpEVkLXvAtd6PmESxeqgUqzIA2b4gV6S8xiA9NSDTREIW+SVAWRcA7WyYFapyIALLv+YAQNGQA+1cQgyTAKnAvdSIuJ+/tAFwH1kRagUWLYkQhV94QUA/jgUAORFgOZAcCwgK7QL2OpEOIF/EIluBRA/BP3fWShAQIZVIDmBIUgICBNSiQLAkqhgIEX0gF2gH7wIfBhSVT3hElUgN3AHvAlbOoD6QIg4UO9yhyfEAb0vECfBAfaBCF5lU8OBOO7gWgL1AZduYU35gQguAtUB/iUFaI9oEFkrtUKH00vxBC6CQf2gBWXtWoEKJW3UogId/TzAK7MKHgpxpDvv7SieNQpS59oEyPxwLtc/mBNh2u5gReqz9VKq3o7gRBdQJ+sCekl0fJlAk0uYFpH4pBGiACfEqokSxfHJgWmxRVMXAiRv6woax/ShwJQBBboAQBo8fQwM8E9O7s6lFKATXZ6kEALYJ0oAbCEqjI/TYHmBmgeSNNXKKMm0jchiIiiBepQzCLZuohEF8a4hRMMm4FIY0/neD6nJHST2RuVQlhAkSAnim+0CCiRkQuVsyiAgFaLLGq7SgAcmV43JqqjlZH3qBCyOukmFxKFAdRDr/ANeIEORaFo3CmPScgVfnXEJUyvK2v8xFCjllltHwvb3lQ/UHi+wBFL3hV9RG2C1+ygZrXUOoKgJRCEB02EwOD4hVx6TVqvLEDPBIxs7b+DUC4npvp3wn2gX+oWOnZN1qA6fSXW7yqCVk48hDFiwdyrqkZdKYD2x94FQ6rRBJV89oRkI5ZCtIMKFMjkDXqevn3jCA6skWCBlZDqXgl4f1LOSFSL2Ix19KJ4L47fPEvwAUQwT/AOo7QIMRjmRfutwuqyDiMTfK/wAQAdmwDoOt7gQjLIpFPYGpYazicSGAWAlx7/O0VV/q5LIsAEDXaWQgOOkgkBjS7wJicT/TOWsO3V87R7oIdYGTIQTLN8QL4yIIdkc8SDKwGLAOOel27+2pqrFwyByK40w5LBnIZUimUUPnmWUarEZCgebv5v7QMvEZDEGjYZ1smA6Ti8SAQdKoFG8gBliVocfXvAgCJIsCz5+30iq1lkenqCPZF/f8QmM453kchYCAA+ODP8ayIBsjfZSDIaeIxHUX3Z8faUaKAQGWHY43+JAxxuiiAhwdyI1iyQBj0gWRw4Sp1IrA4hMLREp/U/SSRjkcRSaL94OxrqNklE5N5ePeZMADjkur9WlKGeOsgCRqRDEnRTHfkwVr0dDyLutdzCetUiGAa2a+VIIsvUOkHE8HXiAbCIIXz57wYqBCbJW/8SImNFE9YDQXzzArWSP6mTrf+oAYnKkA/n7Ro2ASHlRTu/rIiG8etun8EDXVljj1AElBB8fFIiergLEG+xgXE+sEhHufpBUyxeReL8GBcT6siGDRdh/68xxBsO8XzwBA1oFlb3xx9pEHsPIkL2gQqjjVMQrWPsQNgAqREDXArx8+CUaZxRAsyIp9QAAJfMgqGILrv3hNQgGyjiD2gVEhHI3v59YGhWVWCeRzCIC8sgWKAuTAyKJRHlnXy4wUC23dsJyIdPTm0xAA+pAVondSihg/p/OpBUBkaKe/8yIbOKPjyYDh1cIHEnej3g0BYaRA34kFzKJBT9qjBQQdHy4xEBBxOSHsBA1iuoIfY8yC0KJod4CunQfJEIYEloFeIopZVnfeQXur9hv5cIjDAAQgVLlg/aQXuCPHYQgFsEV5gVvFgvnspABNsE8CEUlWyhBicbT8QKb4b7GQVCEUMkNCBDbVb4gNWAF2OoRoPyOakCmm3AuQ5EIYvX2kKo/TowgF4+0Cosoi5AvREChKBBVhrh6hF/ybkAXswNDVmRE4fMC2mE4RUW4AE81IC5qBXsmEPJqBa/zABdvrANyIo+kBakFLHvCLsDtAvEB5uRBVA0JEQbMKQi/WA0XAvMiAcC8yB27QiwhAvEAZA4hB88wPwz931koQEBAhEqpAQBhSAuAXaBDKJqBYEMqkAYEuAgPpAiUKSgvrAmoUlA0PECHWoAXAUu0BZFXCpKCY7QG+ftAgAe7gAPeuJROHCg7cyB9bhTQupUDe/rCh0oAlhDftAn0lE80bgOTCoWOYFJJofWAIQJ5/eBD3CIlCwWe8CDXY/vAH9IqFATrtKIuEuIUyDN2fJ3Ag6RWj3gBjwUByHAUcqJF1WpRkp/SFaK1T/MAFielfWBD36qBcABRpnvuURDIUA1CqeAODIBo2RKMhhgX/ADAPEBcHsIULB8XfmBCKAJBBlESOqBqNFLaBsVAgLytutSgQQmSPrABZCgvPJhQv9JgZyYFX7iApnuNIGUCwUC1akDKgFZ0XKIdY49ONyqpF3XmQC2QTb1AmTBZXt9oWKuV99wICEAvY95QGKHc9+Y0Sxe3XIgCyqJJrsoD+oN9OvA2ZYRCSP6bosbhVxJPTiSAD9YSpRxJIrgwqWcT6ke+RgTLX/wDj7QHSCCMmAxzLKqkA5I/3DRpwJj0/pJvXz8wVBiOASQi3+JdAH07PdfxCmliQHxX4gMkdg+61IRGccRbqxjzKKLKBJpkd/wDMHAnFUQRv587wIXkBgiO63KoDmSUqGuZBHsggspEbUoz0k5ZMU7Y/Eui5Y9iSTowaHqzS487+vzUcAgDEgXkgQBzCmRKOWOVNgQIfT6si71XwwMoDEA1/6oyq0S/6YPp+/wBlH0MCSekkHp03XxRRF1JpHsdiOCEAkerGg8Tu4UCA6ek+4B+bgBjiEciFyh+/31GhiRl/UIAOLPB15lORk+rJrLVMcwrWRwGJx6hzwvo4iIHiejHEnADjf+46B6SOr1EAuq/EfguI/wDxno0dHUDAIyxWql4rRRxCQxBe6kEyyxYebH3EvpGAOkkYkXp7JHFy9XWuofpxxyLD6QAPYSCnq6giemxT3xCJlj0gAnJdunhcxoq9RYBsId6rcHwOJOXSCQqBHaQMSepEdTXK+f7ih0oBl0mHsRo1jkMsCCsQNcfLhnMCCT0CwKAFqvn3gT1L/wDGT2Mf0aYJyJe919D+JAyB6vSSaY5Ef0XLIDEDEpbJP8QmByPpxGQ7MDXgyIvSNnJgAa4+0GrlRIJLfH4kImRI9XUDkr7QNgIUl2F/WQR+lIIa/wB+YqLgB09OPuv3j0qcPG6GwNQKeAQL73A1/UWTOLopavvDM8ZORx/p+nIMi+7kXreBeWIORvtuRKYl4EkBH7xRKOBBy6R97lDLSPsacgo6bGYB0e8JWq6gDyH3HiQTE4gB4lafEelXECwAKLBXMIYkEEAMm15gxbxq/ft3k6By4I94wDQHJA0a7wihNdg7qQU54nRrZ384+OELI6MgEN3Bn1R1F+rjXEAPDBev5gERlyL7yAsV6S3y4RTaBIC76McFKGKo6XZyIpsdQe2oB9PqBZ94ErpAKIOvHeEa6niL/G5AxokGl3EUBdtj9oFVq9VUiDXpIrY1A0AKyLK8QiMZZnqAvcBZOuFvUgpyCTKgasFV0jiECl1K93AovCqB7yIgui3ArBAJI7yYBIYTgAEUGHqEaJPbzZgDsH3CkAgBJ/fUIo37muIDIWjqQQMZKuNwKggrEI0Cx6vpUAmSAf4kE3QKlRobI39ZATJ6drcAdUEvEIE6BJTgaAB895EOe7gPZtSK1CIzCKOwqQOGKgW+Cu6gU+q4RGsaJkFCYBhFBr+IClf4gDILiV55hFCcgAriA8OoFxLrmENe0CviTANa+kIo9oBviBfdKRDvxAo/MgK4DiEPrArQUCn8yIAjiBYAa5kRRRgBCLIDgXzCPwGfu+sgJQgICBCJVSBYEgIUgOYE1KFOA8wIZVIDu4E94DcBuBCFKoHAGFS5QgFxAiuoD21AKoEP1hT8wHYln6SgQ+0BrRgQBXAEFpwqDzyZVVSIn7yiAAAsKVV5kEF+HAK6lFy0TAzqFQC0yEIFIRgEYGfzKFHv4gTWKQfmFXIBsc9pSVNMahVr6qEQdyf4hU8I77QAq19YBercGoRWpVX6ruFuANjm6EAAdIoQIdEgDEjiUQjj/UKnSALQffiAO2Tq4B77+IAbXVfbUqhZ8+ZCAYAJBKMqAXNFQM+5LHhSqqWOzrtqQZBx8V3EooYyJG7+sKaBIHECBdR3rkQGgSDvQ3AED/1JD7fiUZo7HL7Qq/066gVY1BQH0gokLmBAjxSsqBQXYWIhWcqHUX/mUXAUwQ1SpyUTKqPpoeJRPUQk4VddvLO4RCGEBiSe/eVQB5MUPtAAEhgIHT7QIeno3e/D3AE21SpmJAIRJC0rjRCVjiQySwiZVUgrZXYhQBACFi77yCY4gXjs67y6IUcz63jqjKqAEHHqZJyPEDRGJds/e3AyS8aDtgnmBARiCckD9/eUVs9IDCkUAOQvR7bgW09Dg9h/MouZBxOQvJhAmRJ45oDslSGvMqpgBkSOw/UJaNZAHJURv+ePeQibaIIFV5hWMAaGN9mz7fSpoaCyJAwvQHIkGS8MDiOBtNS9qt5gZlhl/tIk8YKxJA/Ar97lVu0GCSBWXntUIxgMRu7p3ev4hpQyV0oMV1c/xCMj2B/J+f5irAdHVskPZO4PVyxPYaPEQ0NgHJggNPfvL/CJWQSsgYrcKuGORy7gcPzCWs5NZMgZjfTz/uVYidLfBA+0arXSALd+5Ipwms5USydApn58EERFFskhg3r2MqmIBP8AcTwTr6mSjRsPGsXfgr59oSdMBkMcTiskSQX5/wCxRrEhevEWLQf51Ifxk+nL145HIXZlFA9FdWrRrs5PqJj/AFAGfUOnw/gjCto4kkbvepIUOsjiACvtCLhWfV0EAjdfiPhfT0rLLHZsgdo/qKa9QATexIMggoHEH1aI0e0VWv6Xo6nzZ+cRfUoHjjiUq0d/NyIYksE/p5e/xFVoE5HqJI9u8JxnMgAZAM7CPHeMGsQOm8kSKOX8yIZEPpJa4FxAWS6QeY0XRFpeG/lwKmAAU6BI2e8iLiBkeo6BKV8f4hAM2xj1f2tr5UASBheJBIskc7gU9yAAkGGivn3kgqFnE7oIQiXjjisQy23A0Qh1EkPvk3ILkqCFG5AxA4CJB+n1hKh6eo5FnHVsSgAji7JyLZgaocH9pED1dHIDpwJ1dIss7C+eIMaZYACCkRQHWSJPBgXhkp2nr2hFOXppDIkKQQm9k19oEwALBA6QIo0UcgQWP3kQrIkgtd44JiCCgOnfGpRoFktDi+3vImIiMTji14kVskZXwe8IhokgMDmBRrvUiGKx4X0+dpQHc9KkAZIbH7QivEZaQfMDRB1ypA7MWNQGxYRNPUIuA9VEFVIUNghnLyIQ+q+sK0Ekm9qRGUOB+IFAJFBsMFXCLj4H17RRUw9d5AAQCIEIuOXe/aQw06FcygEQkGrkAE36T9JUU1bXlyCm33UguJLdIjvCdCQX3gX223CJi+LuBcSBzuQq6HDHEIgb/jcK0LDNyIHWr4gULpuv4hEJHv5gVOpA0VcDW0A+1SIC7MBzZvmEGhqBq/8AkBv6yBaHeEWt/tAu5AgGG1CA4XeBWuNyAqWoRX7mA5gUSIGt7hGnUipAo57QhyDABQKPf8yIoJ0YCQVwgeYAQiyBrmB+Ofu+lkwpAShAQECGVSFSEICFIAyiCA1AcQJKpAGBPEBAcQJetSqe5gIVOZQ5gWBk7gD2gKMByrhT3gN8yiFbcBz/AKgZOqFblFPd+0Kh1qBXQkEIFcyqlOBXAhZKNfXUAVS47SiDmuIDQ9/MBqFQarvcKuldwjJPIYtSh3/w4FFADxAh0filUv2hUT0ddoEy+3eA4pEwCohO4Amm9jtEEdhkGVVHbnvAlgEjLmBUj3EDJ7nXiVRsCyD7wiWmXfiFUlDfi4EGjvEQFgHRHtCjV8cXAUkCb7wIiSWTzKIOqwKlEBvVGBSHjbXgyAaFFkblUxJXgd9KBCOnJb7waAhN8MShiE1Y5rUgxwif5lVos8Ht3gQ1kA9wKwB+eYEROIq9IdpRlZEEH/nmFaQAFZavvAgKJZUCf3EkgdnAtggkjf2gAU+msdfiUZNkEBM7cKpPUgS6J3AEskoi+/y4IArIAChq4Amw/UCK8QJRYIVO5VQEHAZBl+IFyNnaXwQOeYyI0QEcr/xLFaKdsH+2vnzvAuXUcbxEAScgO4MgwTj1BKtuUV7HTlRS/wAGAZYFCkDzC4hBOay6b5H8Si5JWKH0MggO32Vj4ZQLAKIvdNwBIGNIhhLvAyPVi8QrXvLxTJYAPInucn9Y6ISwyAACiuIFuiCS9AK/vEBdIAIpX2joZEog80Q2/wDMqnTlzXVIJkBknk1V1faWUYz0sjQKlitL0gYq+TiJAQIyXSWd5XAHOhksmQUe32gxH0gZM9OiSP5lGqrAkb2T+f2kHNekkHKiS/8Am5pWxRBxItEY+JEYKORPpy36QOFKo+oY1ZGw0vPfiXgI4b29NHf+5BTl6fSSOAB88GMGceTkFVjE/PghVBKPTmTzj854gCSPUQER5qMRUOkEYnHq5Pz8waoAHUDQINPf3gZv1PIDd6+feBMc8gsl0473QjCt0cPUAaRGhIijpOHoJPSd/wAQGLGLLAFg1r2i+ouQGJoAgGye3uZBQUNEHp9LddxCGKxaYA2CVIrAGnaWhrvuUbs0gyUhz/mRDLpGQRKJ39e8RG7xFYnTrEXICJwxZWTZviPqM9OTOJPFjtCtUMMfSF2fPaT6gCmb+nvBgLyZOTOkHAr6cmMraPwQijJmvtzIWIbyZXnvA0B1LFErEnX+YShyZJIAL4PECs9RoACg/wC3UiBKyB79+IVQV1dQVfPrCUGR/wDHjkAQ+57xYKcm8mDifPypBnIZEOgw6Nn44GjRIyBe647uExSyP1A+0gdWgSAQe9iMBtHEELxCKMiSQAO26OpOACSQAaTQ/eBpHqLPUCLrcIHWgQONwgDkASWoUyQH6k/zILkUProiTEEcgKV9oFPThiECvZx1EJJHUbRP2lGgjYsnyvvIUYAFggC1895EPFHgLmBpUyQjIJ6VdDQcoGwzaMDQaABI+siWKOQCvaRBnpfTsX4gCekA2AKTgVgBaECIHE1yeYRoLqBFGjII/VRZ7GMBsB8cmEUBaRJkFKP11GC422slxCUHhjkQK/v2kFXpaAEIBXowJ3BJgB1b+tQNOm/vIAIIQpGoRRpn3owKfS1QG5EBquRx3gUIE6H8yCC9XKKGdyIFMVUIrI+3eQVekA97gRWQ+IGuAQv9whIA33PiAoH6wK/+SIeT9YFHA8QhbvftA1bbUgaP7wD27qEB+kFCBXyP2gCDz2gV97kQ+twK+DIFlFGoRQSYCBRumpEHTECjv+0gGBTCHvANBqoCEUfHILIEqLIhAVA/JP2fSQMqFICUICAgRSqkKQiwJCkARUCGUICBEjKpAEQHiBIADcCH7wp4+GVTnUCShAQGtVAhqFIRD3EKhfEotJOQCAlKILVKUDu/xIBBfiF1K3CnpHH4lQt/5gT8Hhwq2PKgQ9m4EJQu5RLhWj7VCMjQVHtKpZxREgLQ8QouRxxKgLq4ArqoFDzAl67Sqi+ogExRhTSKcIgSuoUvVQBRfU09QIL3cqhK0Ke4A8J63Ai2QuqUVD9OoERJs29woEAKJViBBuqJ8eIFKBCUCHgnvsmFW0i12hGTrZ9zKqZU/Y/WIKx08KqlEG1ZEgHBZED0j8S6CNjfvIpkTkKDGQ+algh3XqHBbgCLt3xAIY5bbP0gRBkgoftKBA6QFrh7hVJBdlcFwM2rL/iBcbJyyO+XAhOKGIq33lUKAfHf/MggfUwqlEVgkGz9pdFNGt8KQREg3xdb+suqrKyLIICBH8wiZIcM+faFQt3feAysEoFG3SgZz6y+B87yxWh0nEBkL6gGREQCxXjVf7l/VTE9RAy6QQkBLThkScyCOp7LURQjpyJoBFlr6QaZDZOKy8iBTkgB01x5EYMY85A4gcEeIooIsMYPkcCzKYIgHpIQHu5FTJYkY9RFalOmROOIxWRY5+0YMnEkI3qJVayDJOQBVEK/9ysypiziAWMxTLvzCmPUcRiekr45FQgDENAAKzCriMS+nYsgH7SoAYljpAEmhkv/ACE444rjj2l0nPURIA4dCl8uNVD0oHq6sTRao8SidPXiUDiNQavqHTlilvV78wdKxxPViQtmBLYxOXdrn/MKhOIZyvuG5VACMSC1RPV9D/iEQn1DoAIdAMHUC54lCkDigXcLKiYIvqa6jjLovSCegA2WUOY0YxwyGVkgA0bjV1oZAYgYYAkBgHY+8f1MZRJFZAm6p1HBo2jiCkwFxAzpH00WaJPj8QrYQ9NG7HVTLhLGPSAOkEAjg3CqSA6sgqIijMAAsA0gBGIYrqoAh8mhItaOAP8AVLKHBxNxuJ8UDYH15qQpn1ZAV+pgg/7UsTyAPqWABHHBvxJT+rkACGHkb3895ECMf6eQ6Wjls/4jp0o9WTIDu9R+C10jWq2oRTlgcrG9DkfaIIAR/wCzLPaQb/pdJZYyBXDf0ipWTkEAARdkDUKpI2BQKS/TIi6yb19D9YAA7QJJv3UaGRTv69oFHqHSSfZ7+kiBNZO+B48+e8IZZAIiq3vy4kFLCJNDvqQXJ9JOkeR/iBn+oCzkcunw0pYNjLFIhLsZExSwqK78KTDUwyORAyyZY4ipwZOfSEffmFaI9XVwAeGY/EC0Qd+DIKc8gAKXvGImPNm6CFiBW2MmiWVCYq/9TxSEgEBgIpHWoFyGWOIAxVd4RkBU3Cul7bPzUiJj+gY5BHjKDFxB6QCa8jjvIiPHFNBDjiFaCJ1e7FXCNB2whIhkXm6D0xuCRObrteoA9I7g8g7hBAg9QAgauiCR4kBrFEAgRiIEUASR3gVpkYvvUnRceV9beoohNtjeiIGshQBSSXaEOCCxa3A1+3NqREGN9w6hVGRA9KHPtImImmB9/EDZJK4piETitC9QNBcL7UZETY19oUu1tfaEUmrb34gMf1VV9pBSAciTYhFQ1IBtWjqVB+rt4PEmClAjTPMDXI6Rz9ZESrK5lFrpHtVSGDJOjfEIAeOJBrAhO4EJJVVApPMIMPmQF+9wKa9oAKRF4I26EGBPYKoRdFwKdHiQTId5RRkNIGRF9tSCYnu5RbdakFPf8Qh4cCs95EAoFBfmA3AbIkRUVxCKLkUhFGluAHvANbgX45EUSATcBCKfaEOGYH5J+z6SBIEhSAlCAgIENSqkKQhCkBAGUQbgDAGBOJVOIBQIP23AaEAVAh/eVQiA/wAwIitSqfW+0BxAiuAOmoA+UIE3Cg1KB+6gOm2I0Er5gTYUAeDuVU+sKClCFaMCAo3CnLJcCvvfMCJBn8yhy7UCcefMAPcQqEOjAuj2cCBd9mUQ7EAxfftAhDfaXVHVmFXgXcCckG61CIPb86hQIt+2oA6J76gRL6cyqpINkv6wBZZEDL5D3corPAHi4GabB3+YUZrfaoFBLHAXHaAC6e7ECBIHcqo1q2K7wLWyZBlXpzQuj+mySO0gWwEL7WYEsZAlpKoUbvzKA/UyPNQJlwQyhUECfV0nY+twIikESbMoL0LEl/tCiL0HxUCDI2yQR+RGAXjj6RxcouVFcNGpDqHYCROx5hTIAsg9R95QPLYJy2IAj0rJDwxAmQAGyMjzw4gZBAEgD95VQW3iElYgXK8AaPjiBnM0erL6j/EB+v8AUBqhRcCDFBnfl1KLkSAVoUATCw6ASekq/r9INAhfpfcQMgthkLzqFP8A1yAV2z9dSiEAlM9RvvXz9oFxCVi7fv4gShmkx+3v9oExJxy5I8QKEMmOoq0P+wqdRRbIOgd+0pjQAAaRfF1IIw+yogHUoz/YgfUWRoyigZAWTQWj84g8QgHJEAu+r6/mFi5A9QCP+O0gYm16kSyJSxnL9QoulAE/qeJZdowrJRJyyJPL7SgSBisix53A0QSgOp0CeRAzisSSbQW6Z4+eJRQ8AQgDVEftIrOJZLd1XMcFPpBICbQ7d7cCHHE5HAInkbYlNDlhZokbBBgCOp5Hxwr594VnIkjRT0T+oyi5ZEH9eANoa+ncRBnIAInE4g93KABqiQCXxXz95FtUtg56H+dQn8MF0AAC8Rv9oomBWAIGq55Xz6RVVkVix1BrWoFFMjq88nUICytnz58QNEkFelsgvjzUiM9YCGWeKdgIXZ3LmlVrPE5LIoADq4kB28kMmg6dyC4n1dZWQN2h+Y/EM0UkCqJ4gUkjLpBJCTBI7cwdijEoY4kghElfmEEMsOnEo/3F+OJOHur6hRyd0X8UggPSMhlRxHfY7S5/gp6ukY4lIWN/9hGjv0gkO12qRBk5Y4lM7Ui0JxP6U/NfP9wnrR7ZWTlt3B/BLFZZAkUU+0ImfSAMUiXfYr594g1lQDN8Dn7j95BGcSeooEIvcHlUk9DGXq7yIuSRBZ88wQZs5ktVCJjiq53r9vnaUUkPLpIB0PMitEYkl14W5EUZAgLJ+0YjI9TBFeLfMK0dY5IYo3VnmEQgPpI7l/xAuKCH8X5kF/TmEED9FHUQE45UAR9pBpLNjCx9IQxJSxG+OHBWhqtt+mpETqAytBfTncuCi8FiSHbBkAAAXzQsXAvK3ibkRTtFLmABAIKABL3AWTocXArLII+siJpjIH2MKMAID6CEaAaxA4v2kQxTJF0nKKGGAbK1zIiYlnuX9YGuGLf2kCiUDqAaZGJB1rcC7sn28wiHjQuoGsieTlfiRA0iR9oAceNuQXsTcDQfSKTAhEx/SwIobNchriQWgGvzAAX2MIpPmrvdQD0ySPMIAgZBImRVfc7NQigluQCeNQikXp46uBUEmly4Qo4rQ794Bea7mQTTarUI0boFKBSzY7yANgEvzAN0G4RrVbuQKFNmAJ4X2gU+7MiICjuBTrzCKapfSBdbupA0JQbciLVuQAff6wD7yi2g5EPH1gUFLtIKWC4Q5qBeeIEEiNfv5hB3IpRCgAoRefEC8wD5kRYCQIQfaUfmIn6voZgWBIEMKQEoQEBAhlVOIU/eEIUgIBQIVKB8wECSqsCEOBIBwHMCICFBKodwId2zKB7mAPvUCL6CAMAx/wAgDCpQ3KHNSAqoSiVwYA6qBD3lU+n1hV4ciIe8qmv5gQb8/eABLJlEItxoBBMpQBfJJhU9t+0opJkCtfzAhrYlEvyiO8CHTShRLzKuqyLV8wia9oAP3P3hTEdrgP7fbvAgHqJAIJ+8oBElfsoVB1a7QBFa13gQBh5D7jcoZHT54gUfqQDcDJ5B4tQqgghg6gQGq/TAhJ2j9ZVVHknjUATT0ZBk9vz3mgACLHUt1AhGlsftAEE5AEauBUNcH8SKhRSDJ0eDKamR6Sl1eIF27P3UCDp8oc6lGs0Gwh3khGMgOo9VhXVzSgbduQXHLaBS0RbgZCGW7W+YVfSgUjAYs7P+pRCiQST3MAAerqGIy+sCZMBlk2O0sAgE9VkRqqADZocqCs/1CCLJHDBiB1so+rvxBgTTxr2MBl04JhkwBZyaQv8AeFgAF6ekFyiZdJ08QOwVwGRJwBdvRFalJ1D6uogE3Z3Cp2AAIL5gXJHEM2nr53gQ/pY9SHIqBWrJ1RvfyoExLKFjvjUqpj1Mmw+dL5UC5B+pDSDH4k0TFY5DE4nj6ylQ4HC98B8P4JdNhZxC6hwT/wAgM6NHRSN8SLEBxIRGJxBQQMopJxBHpKWu/kQdTIWcsgADje3AwSU8iHyBuVVCGSxvPgP2jopOQDppFDa4hERBYb7AeLr3l1TAZAenvv8A7ItawA/t5dmrhKxiQMCAUrABZ+XFUxD4A63o0PMpWsT1nI2gbZYBElgwMSiDkEBR7GXVVHpJAGKqtQGDGJ67TKbJ95ajORLxNEkklQsaH6+kAJ2/nxQMZnHFspJWr+GIvWuoZYski6BJ4j1MQNHLF44go1xzCssvqQBAddq4+CUa6Xs9RKCfP7Qiknot9RB1vcmDJvHp/tOi9wNYjLEaJT3z7OQTpaAGQN+rv495RrEE5AFZAWP8yajQTpgHfCLchgSxigB1GjpfSMRMjliSMUQ+ddoGhiMgT0saZ7yGowLOB6RoHn2/MqOn9QjpaGWOwuZlIw8Wz6gtUuRKvRXez3Pz4oFxyLNKqD783FiFDIhUvl/WQbYrHp9XYUvlQiYDIM5P6j8yUPT6ckwNmBrEZdQyx6bFPtCMlgEiyGCy4VpA5MY9618uRGgissg/pZ8iErOZGWw+Pbt89ogDMk8keeYMay9QNe9fv7SIuROAAxxbox0LOdoeIFdXkr2RILn6ierE1HEQl4CyMvu/+wH6hkQPfuv8QUFoAhHhcQNP0X1UGb18cmIhPpeJLXJgaodgqFbkRMT1HuD3r6QGNkssm+5gbIO7epBMSBkliVdHSlxA4gDqxRfMguwiObtk/NwKQRp0TqQXAk2iQ+0YlCSKGT4FW4A1Z0rCgRZdPJXiBRsgJ9zIlUjLp2T/ADCIrJTPv4jRrEeV+JCtYELsPPEJUH6SgXJRQDykd1AuPJIGIgQBA2VqBf7CXWqkQx9ItValvopdc9zIKH1dh+IRMinTHtIKDVhHiBdgnXjvCJe3YuBoAHReg/8AcIf2jlyCcJUdVAoC0gYAWAOPf8QKNt13MI0CN99zJiNrQB+4gUt+moRQKaAkAEi0PCMqNZGmLGxIJfVQZhBKFMSWddq1CK0fEg0/7TuBAE3+8IoOjAtttOQRFVA0rJ0ZEUFBmBCXxCAJcDWw5AyYSgP7r3CK65kFPLXbcCceYF3CHPMC8akQ4qoFgA/+wAkRpSADcBSowA7QimBcSd/zCHs5BYEUCj7eZEfmn6voQyiQLAbgZhSUICAgIElVIVYRID6wpAilDmA4gSAlUgDAkB2gOYElUX2gOygPpKoDAmwFAhEAj2gIA2eIVN3KKNagQ2GOeIEKQ5lCg5BNZSqvGhIJ4EoGFTHwFAFCwf8AcCsvXMCBNuUS+WF3gA2QvpCjDuAxYCK+0olAM/8AZAyD1fiWCfZ+0BQR57iAvV/aVUdlEr3hR+IA/wAcQIAiyoFBr2gQpEPySJSIQUQe8KEoJm4D357bgAWGk5QBNsfzAzkiFv3ERQBHRIGoFWwzAlEMUxABBBli9blEZBAL8PiFUglAD2qBL5b3ABCgSefYyiIJAmBSgNfeRYldifrcorHUWyCdGBkk9JINCBDaGRS/EorrpRCY1AZAC9rxULEK3viBRiQHVW4GSNYlk/NyhrM5EG5FA8jbvYuA6Rwjj7+8Gsk+oI6PsvEo1jwEH83ADIEnbW1zFGQTkAkOnseJVCA+3MAcSwiB4HvGgHYa5X+fvAhJyyRIFv2gwBGXr5A0ZRcQwjiCuDAySSHYyIZZ1pQqMILE0q/aBSekGi+KlXrNY/1B5rS8x8GgculGwrKkPqHEGsQ2QA5RMmzTHfUKuPFAMUNQmpl0jJ47AoJHmVZ6rybBoZP2gTAYkMY7ehuKMnFMH0gaAMaGL6iXiLvt8/zKAyALLV33chhiD/TBBzNHjiXp1Mj04sjQoqM2qZrLIjFN2MoDYOIzII5181AmRGOICa5ieqqySR6VXq8wiEAvLHE9J94Vk5EFnp8yq1QxIohDeoQwCvqJAHb5qABOzviFQl4oshN9/ooIzkMgMh1BDI8/PMomfSMcgiuewMRVsUQcidhQNA5dHVkOkHcfRn1Bgq9AV9pRCWOnEHX/AGoigHTl6QOmwATHUVA5HHni/ig1Gw0cSRxvmOKA44jpRCJILCPv9vxKn1LwPSq+6X7fxHRr9WQxxI+mXxSG4WM+kgf+TzRcIoWLxAIBAYqjz+0aYnTjeCN/j6SK0wMXQAHF9/8AEmICghjil9RSNxpjQyGOZyOJB2STq4T4w+rEouv0iMGgAU2QP/UceI0UEkJMWG3FTGsj0ljqe2T53MgSg+1XCL0rF9Q7jyYNYr04oFBhnX1lGsT6uoAEn6/OJAw2DmLJvXl+8FaxRWWBC2a95ER+oFEB7PvA1iSxiwSBVaqEqgki8TpM8mSiB54gk1jetiDikgZIlK/4jPAONj13oqqk1FGKP5C18uAJ6j6iSNv5qDMMcmOvRA2bEqfjWB9Pqyx9zY+MSGIbABrI2fx+YBsBYgEbEguROLCvYhOhPT/UBvy/vAoOQw2UB3kPNUEZFBAEge0JQ9TfB7jcChkAk7r2kQzyD/SQRoHjcEVkknq0X7QLiXseziohABPUj7VCmKJOXVzsCRFxyugxxJYGIGLFm+DqEUkjGrCpQKfVkh6T3W/MAFlV63CGRIxQFDvJFXp2+lbuEDZJQHiBOrIW/OoG2h/mRDDpBYJ7C4SgPkOBbFKtgcyUiED1I6Pz+YFNA+l8GBbFDfkwigkBkjypAsNmzUIBmgOIFx28UjSGpKLXURTMACSA+YQYA1QsFwCINaO5EWjyhz2gVF9P58wDAJFCkQ4AAHge/wDuQaJQJPEIMiteIBrLQ7yIgsef3jBRvvAr7r+YRrKg0vMgjH1ECoLZ8QiNVSHjUCjuOZBcdh7gV8tQhsj34gUe5kDW0OIAauRFcCoFc+YQG9uA5kBoXREouJXMiKNAftAMnsxAEkOQXlgQgBQgVvw9yFW9gwgOPMATelAtHnmRAQL+ZAH1gUEwhXAcBoQLsyIoUAdSD80/Z+5AhECQLAm4E1CkBKEBAQJcqnmBLgIUgIEIlCAgDAkqkAdQIfG4AQB8QJ4EqpAphUlD8CAPO4ENQH7wp9IRD4lU+7kF/wCSjKvW4DZlDfEgUgJVQSKceIQDIBIlAgsnUKmhswKa7wIN3uURIL6woPauIRCxRBJ5hV3j9OYAbcCGmR7e8oh0WBAoLOq1AyTu699SqUkR7wpwjAaDD3AlfXdwBJ7hgVAELIsUZSIwtbuFLOQuALII57QI3kL5lFasJCBKH6Ufe4UVv+6A50frUCEjkLxAaAYZ0B/EohBFhB+UYVX6mV1e24MYyBDJJ73xKNNB5MPkwBRqrDQgQ881xqRQkE/i6lEAuqHfmNADJ1r2gSuogfQDxKKWQAbIC1AmI6iWUD5cKMnEBaLgCGCgBW9QJiq9QC2pQz2ENGSKmKNYkiUEU+2vEAi1jf7wBdDfsV9YE4ZfSOBcoHRQB7F/WFgUv1XwYBvEFlqu3gQJifY8aqFDjlliSB6ft9IQVIC1zr394CgQwukmzf1lGcerq4vf8Q0qJy9TIoFhfWEAySCuzMKmOWIABIFcivlSlhiLaX4+xgGSKLXB3AmAz6A1zXb5/MU+mYBeRyQQ51EE9I0377jqmRRpHfP3lwXBtZC+aqQTpOOOh3Kl3RnAjYOIY7y0PUPSANbe4VSjgP7CkIJ4gOiOPOvlSLgR2pDpxXaVFyBGGTIIsXBqYnM564SPMKybyLHk7fz2lFP6eggFUnvxH6CBCPqvYNPvAmOJOAOI0XRvxGlQHDVDJ9ql9UzNerIkpPtX/YguQIyJQ6c9+BHwOorVE/ln/EYMgdX9QMk8P59IUr1YA3+8CAjL+pi2ST8/aU4pyIeWORx6fH8RDEBx1/TJxoJD7y0aOKAR9VHq38EhqX1IAC0GX+IGciepZANojEP8S4rTIxCHUWmdAr5ciJmHi+rFH1EIkSwaeQKJJISIp+8hkc8sQH02UCSLX8wa2D0f0w7BCos7qo6KcmmepgnsP9yJgPXkelZFO/8AEHF6gcqog9IYdQghwUKrtUmqowLdojlB94tQyR/q5AizYfC+fiPhGrA6SSUFZr3/AGjqJ/TxZ6sggtgSUUHLoGJWNvzBn1cgcgcSQPeyYiJgcQQMsielkhL5UZStZlkEVwD3+0kExIyIBC537xwXEb7+NiTUpygVj/8AUCkPIAh+4gQfp66yWgNeYFJPTkKANhhVCNMLpHV/iQTGwEC+/Y+30hDHLkm6s9viksGjic8ethb86hOeB301jku3EK0GBooNL94RnHHLEssA7JH8x0aAeTNihZbkQwt36dBeYFxyIVZUFrXxQWCL9VcXzIAdgMFNQhgxiCc7D7aijWfQXlkSdBW5PUKC9KPEAcrPT5gXCiiRXLiooFAMHn3kEGXfJEiwQYC9YkIDiBR6sL7JiQUHRr7QBt99DwPghFJGOOXq7xiKH12QDqQqAs8Eb4uOCkr0lHp8QgOyBtWFINAPHgXo1Agy1ij7iMKvCs8fPnMIpothHcgAn5xAgAYPHeCtbY/MIgNhjfMFaNs2xY7yBvgioRpA40a7iQTnYF8QHUTlvqI7GEVrGvZwKUUWXvUIc7aSvUghAIPStOBrQ7sagAdHxs8SCvn9Nc1CDtWC+O0BRd+8gqvf0cIu8j55gVAQhiOTAAkhPzUhVOrNcKEMSAbBKgUs39pAxZKIgUBsd4Q57CQXmBA0+fMC8G9/WRFB4AgoO0IAruIGkw39IA9pBeHREIgHTZ1Ao3xAA3uQUPtCAoyCi/fcIY0NmBaTUBcBvUiKKKhFpUZFPvAfWEUau4FBKkCEWkYH5p+j9iVSBCICBICBDCkBKEBAQIZVSBTAkKQHMCKUIEgU6gTiVSAMCAd4CA8qBDUqoYVd3CJquJVOICBNQJ+IF1TqAP2hUdQKT4lELYUCDfMBXhwIYUaLqUOCbgROioDnzCgFkEQBPv8AeAtbJlGasiUUCRRLE8wAWtOBMSHf/ZRMgSPfzEAthn6wAHYwGzdGVQC9sOABrRDgZOI9vpGqgsMIn2qBSyICUTfgd4U0bAgQCu+QqpRaBu+/aAPBAXhQID6Vwh7wJjY2zCmsikSN3Ave/vAhXVRXiVQsEvxuBkb5HEC1YAsDRqBlEPFHwJRedrsqcB/c0Be388wA6e4PtcKj5JoeYEDZX53Ap1ZD3YgRk4bW1KGY6Sm6Hy4WXSziN1AmIDJN3xAo+4ECMphMfFKql4mqLJoSDOYNDzdSwGdmu63AAIrYTSgTeIA9R89oVdfpb7yiF4XorjcCHFgdWKA5H4g4PpO2CaqUUgdTyfUP28+JAaxR19lAmRyOKJBHPiWKhZyHSgHxAoxtAKNEdofqNDt7wqM5Gya2T3lA5EFhkkccD4YER6SenhAd5TUxXUmCFyLPmQVkj+eIVMAeo0wTuBTtjEFrvcogS9JoU3AhAy6sgCxsQLiFStRREB/TyGJFcEy/fRRwDjT1tfP4gZwYLzxrhfz+YWplgc8SkXv53qJcAhInJjvzGqAY8A49gdQA2RmgTvzAoGIybp/3GBASrRZu5RFjp5AjsbA5jRMSelgkZdz+ZVRHIAMX3FgQNaHqrv8AaxGGoiSsn0gaXj/sAzjkUcSF9nC9ZwHo6NkP9RpD4Zb/AKNViWLICa/iQ6n9Qmj9F1RCJgT09NnEgFCap9P6fScAATdB/O8lEIAzPSQwSGk/nziUilB+3v8A6kimS/8AJ1EHE3ff5cfEgR0nKwq1bQEoitZDp4P1pfUQrb6upYogU7B7/wAyMsdJZxCO0sqhWsl/eSRYD1J/Bep5dZOK0x9Pn1j8RccsA0z3pX5hPQnpJzy48e0mKYtkD0viPEq9QSZaff6RgfqxskFHX9vxOEXIAFYvQH79pCfqgekYEaGjCGGJBJ6cijzJTWsaeQ0KXdQICSMhjkerZ+doKp/UsSSWTRFGRDIFjBnvuAv9ORvkaJECpZNnTIOoExvHpw2Lj+lbpemkU3z2kRDWPpINFL27x9FIJHrAPa0feEQ5DAsdVnnvHRsnEbRIv2kxCwEX2S/EBkXiHkwbJIgMkchkcgA1fb45BoYjqdAbfaREbKG+54EonKNId9wLkelkPyylEFDALIaQB8xiKHjkR6gEke0gXs/UmQMGCSwjbMFaZOk67QmADCGNe0ICwSkV9CIFBAqn3ciqQOggVR4hDHJUUubkQwJBtEcAcQUOPUP1e/kRuAgNMgFEQNBdk5EMaPTkX9IKoQyBSv3kRAekBkIntuUVBI4uTRBpFg+9wKAwACYRoFU37GMBepm0NOQLxyYJ+0C4hYoV57iEX9NoocyBlYGX5VQJifOwKJiouBBAACclFJHUQCaNQKCCyL9oRTtkVdiAq0WPEIgs9/a5FaZL4qiIRFewjowLqyD79pBfNke0IoytI3pwiNercKoBJvmRFYFAbuoAEEXdQi5JoQLxaqQAFaA94QBGwfA8yBRBx5cClEr94AiwOIRfG/5gFf0kFFhCuYFOuJEHVOBUebhEasD3gafYOQNQH3hDl3A1zIJ+0C/xCBgODdyIo3X4gUe8AK3UCs95EBCLZ95FBAviEAYFx7txUFUg/PP0fsQEqkCEQEBAhgSFICUICAgZ5uVSFIQhTiAgQipQ5gIEMAZVID2gSA53uAgS3Kp7wBhQSiQAECbJEARxAHcCHkmFK+cyh7uA894EgK7uATELqfcygNOBPDhS/P0gXUCMKtQI1xKoU6MC/DAyLgW2rUAGKgRUgD3lBFvjgQJlfkwIiQ5V0Ireu0Kvv7OEZQ24VQnQgQ+bgBu3cCEdk5VDfYQBZGn7QG8UhAgD09cSgiF44hQj1FDzuBKANEE8QGWky4EXTTsvcqjAy7uBeaoKBmgV24lDKwQZAAWOhfiAA5I9pVRMKwXfz7QLb/Sh3MDJAB1oU5RSK9NutwBboB+/iBMtMG4iqzl3R8qBANXT8wIAOp4u9qASsHfI7uVU7H2Z5gEcUcmVz3jRCQdGyPtCtYEBkdIr0wjOwTw+TzAY4gV1DuBKaoPVll2tVBxMsRkVZv7RqoSBkljeoA6ORLPG7gCaDBIAr2/iUQ1RHV7aEL0BQZfqqAIvLFEHXf6wA6UrPckQqLEgs/dSoqI4bRZKdQILwOVk67v7x9VkB59JbAO/nt94DZWSyABV8fzAprWN9hCwGRogHHxzKYy8+EXqPAy6SaYPt+0K0LLJNMGzCMYoglYpq+BKpvJAUOORXeCAP/1TQSvxAv8A8gWT1bTgOl59QOLOsXGiZBsgtD9UKnScg2cSPnz2lDIY5YgAHJCidbtR6CQWRY0DcCDpDfU39X/n2hV/uoAHtx294GT6GRwNpLxL0XAovK69RfwSFMwP/cA7DJ8SkZJZRyR4ANAQAGeWJAIyxBFE/RSq0Oro6TQFKZHPpBtAUu01ooxRxDHVaQ+faBTi80OkP9JAvKPhp+l4jFZk8f6+sDOWI6egM3d7feNU6ej0YkgEF88bl3UUEYZ+nE3XaxB1WSeqkuB5/wBSKP1ChlTAVfSEMqBxyNEfn3kgoYxXV3f8weNYOskOr+2rH+pErIAOKyCAIt1KNDqGQvEAsgg8SIa0OK5/5AHpOPo6QP0mtfLhFIy6t4sja8f7kEzOPQmu7iK2Ccl1pXRe4ZqLHEh1dV/v2gq4o5AjG9l1JQIB7l8mi3Ab6e1Fd/n8wioYED9RGgDdydBg0GCR9o4N4ks8E0PSl8cVGReJPHkQrWIw/wDYs3qvEierg8ssmwCSouJfAgEoBB3cghzOOW0D4Sgxa6SUydVAMgNBAdyxCAy5xIydEv44wMCrFvd3FMayQOQKA1R+XIi46WOJXk7kAEDbB43UoY//ACcePlQhj/8AroI6HDk+hiPWAtDf7QKi+CLTkRW6CJ5gBkT2fYGDD1bx5jwUl0cSuVAoOLdUV5kQxaJLF3X4igCzSXbj6SCghUSnUIp4xochjmBafV1WeeBCIUm0BTMgqBHqojtAbCA8SACAw2Ne0qKqI6YFd9pMAsApr3hFwo6dbkoHp1YPFQGyQWT7agBqslfMI2NWakEROxeoRUQUzzcClZHdHUiBaVFncKEMJahBAVxbUCkkZUPeRBstwo7r3hFVdwpBUgrEIuL+8CAhWk4FLBDNGEH2kFJYYJEC7/uOoRKWvsIVQdEnxqRKtBeTCGJZGtfeQKT48wLsAwKuBfaEG+PeBQTy7rciA5dQqhbR95EMdl8+YKuz9YQJIPMC8GQOHX2gB4/IhAHUCn7yCj2AgB7faEX6qAD6ZEBvxAo8cwLABn3kQ+qgXfmQBACEXzAC4HCbfqQEBKpAhEBAQJAkKQEoQEBAkqpAGAhT2gIAyiQA1AWoElU7QECCA4gFAh3cqlJwHbUKh7ShUBfECWNwCfEB+IDxCpKFSAU+ZRNf4gEbYBMocQoO0gnP8yhzCg3yLgS2ZRV2XuJBn+RuVVrg3yHCJWqhU05QGqFCw4FKJEghQIGpRCF6XswHLhU0ja9pVVB2eYQJI37wIAHtmFGmExAn/wA/fzAhtcmWKpCJQZgD/PECc7gB2/iUHyq/MCWCByPxCoC+zECkrf34gTb2j3gQn1V6ieDxKoNFj7QCKCBYuBcgANE1pQITRZAqUXsLxJ5Ugx02upgFmXVUkNEBjSpwkFXID+VCshdB0qlFLADIepBkA2CAZVXLWPJbcQCRXVwftAgYslVvt94GiAMUSrswayiwAq1CrrL9NjmE6npOLxHv3lVlsgdVtPzAp6iSKBrWoA1iScUhzAlkjpJfHH1lAHLHYY2fEKhDBJ1wa7wFNW3/AGj6QKhp1zz7wMkjEWBjzQ5lBgFAahVKZHQ/fgwF449V7O9OBkDJGwUaJlUIAxohnYS1/wBjRWwiq5GvaEZfGOlCqD6gLI+97gB+rpIGN8HY7QMog5IgFByrq0a6q8sGQTaAyCyFyinoJoerHZAqD1PURYN8rj44GdMCwCKEqgBROI6eVAuRBNsBM/bvxAhIJ6Ti8UtRP9A4h9NkdVq1r6fBLKI/U9k9/wC7/ciqH6cscTew7PaUFiCyCQCSfn8yQoeseUGV95fBjDofSGe5N8uLqqSQUEQa39f5cIWCOkFY6PcKFZLIBGwQb/zqWFbJs9BB8n5bk/ozmKadjhL/ALLDUBA3WNb9tQq4ktW2m+eHAE5LqPJASb7ywZAWQx2QOIDHqOJGgCwQPooPNayYu8lT53BHMWyaBNhviFasZkY45A5Vkctfn6SoA+nIkDIrcinTkFSIuz+ITW8iCCcAyMUQMqkRk5BEHIlikHx8+8pjRLxGOQI3kVlM8MQYAZj9VF2Ny6N5M5dOQ6l+kkM7/wCSVJE6aJIXqtURGif08h0dwVUWFaIQAGXqApDivnEIzjjlgCKI4Ji1etZfpxG1ZKkiHUEP7kdqvp+YwAOkEklJFV9KhG8Th0jAHqH/AMo8yURWuoc/5gbHUHiACPBkRAXhWJvY04GQQRiGU01rz7QNZPLM4nL1UH4hFZGGWvYX8/1ICGZHBOiTqAx6sf0nqGz5gUXiyayavzCDsAglmrQepBfSGzQ2uV7wiZZdP6iSe47y5opJaA/T/iQaZ6yAADX3kFSxY2CdF+dQiYjpxKyQdEwKQ8VZyfZwgMmNsbff/UChmgCABID6chVAH5cC4l5IkENhSIhrIjqINeIg1SeTA5YqBFYDIpEaga6gSAi8edE95EwAyr8XfECHk8N3A0BkXx7SIPTHve/8wKy9PFQKh1UP7r4+cwiWC+3J/mTFUOiBi+R/mEVgWgU6ciF8FoOAxWhihLQdoH6fPeRFRJ1Q1cA6A0rgaNvpoDxIB8FliAG9H9+IQx7UhUgtoF2SlCA2gWBswKH0lkr3kFO0LVeYGf8A+RA8QjVtBDuRArQPjvIC4Yrt3hFKOgAVyIDwAbHtILsWARuoQQGQP2uBXZAIXHiAVEm7kDE15PEYilNMkwAC0YFNgAGhCDPA5+pkCg3fcGEaBGrrvUglPf1gaO0xAMkcOEQF1a94F2V7XIK6Nv2gE91X2kRR4P8AuApe/EIAgdt7MDVfaQQleYFfEIrLkA6gAgD+0C+Bv3hAEQKL8SIO6gUG+8AdkQL9JEHYcCviRAQHcwKu8DiZt+qQEBASqQIRAkCwIbgSFICUICAgQyqcwJAQpAQIZRIFO4AwJKpAhG4CAVwB37wJoyqJQEKnvKFQDgQjQgT2MCrdwIQ/vCh3W5RfMgzxKAvmoA7f4Uomuaho1oSAj3hEIvzKobNbgUjuoET95Qoc/SAZ4L7QIRx37Qq3rmBniA7r/sAalEOvlQLzRgZTJF3K0OEMdiBEv5hVegkPJhEQ7/TiFMRTb41KqXsP6wD7wKdUPJgQcN7rzKACBPMghPA09a9pVA2TAhRFgjtA1q8jUDCJBIG+JVWzYII/eAOLyop8CESuK3a1CoMvR1UtXKKePUyu8ghKDZMqh07A5cDJAx26/EDRXXTeoEydM8agAKQLKgZXqYICXtc0qkDI5WQPbmQMR4APKHmAONkBBbMGpZzCYrvCgYy/jiAyGI0aPHiWCBE0L4gBVgMHtfMCmgD0+xgZZHCtSqpx0EatQjBWQRJCvcqqgQUXyR3gRDLarL7yKmQLWIvkk74lg0Ngggk2gIGbGN8J8MqBQi2SnrKBSPUw2OHyvt+ZRhAEoFLXaFaeToi+JBOnRBYtgymslAkA80R7QGXqyHpA8mBoqx1DILSqVWcfULZOm/pBxScQiQX20IgjC6sTT+0BsoesEfP3gVr0dSN2agYIH/8Aaz5HxSqDIFo7/TdQLkUx1NBuQTIE4k8EfPdSkWur068u/wDMDOOHXkSmDf0UurwJKaAx01v44FxBaOJQ+fzBrKSO2GTo5P8A5KKcgCOrLHEMv3+GTNGenE5f/Qr3+naXVXEgY9XUeBkDIIR/cFiRTcoeoFAZE8rcHi5dSIGAA2UPuP2gZx0HiSCfSz87wqrEA28qJPeXRkk5npVv9O32944GP6ss3arv/jUBmHX9TAdR0g12l/go6cPWcnigx95Bkg5YnIkDqDs/v+ZVaCN45oA6QF+fn3kTFyAy/qYkk93x8qE40B1CupWK/iQYw/8AJ/4upHE9ul/jtL9GgATiAyelWJBDTWLK7Io3/mBTrqSWwDv6SIEdJJ6Tki/8IyjTByrG2iZkMwsger1KCJiMOkAZIAUYqL0k59Q6gav339ZRSsssjkCNjcifFv8AvLKvzZ/zIKQGQ+kcUL9vvAi6swSBQRPb6x8FRGbPIkQPSSDjyoFxy6iMQg6F6gsOOoKxrSuEaJyA6kFyXakw8ZZTraCEK0Ua9J7ojtDLIAyCyxrw7hWquiDu6cIbPqOiVUgmQJIGKAuzKN4+rpTOR441M1EAIABshbtyjWKBfSQSfvIKnkSAOoUfn+oRk2SRiOTAvUyxmGfH0/zGDQxFEMKyOJETJAkWn7KoFJOVmsVuQaKBYOTVcQiYAHFECu8FDkP/AFZ+4EYjQZFDIPhSYH91c7GX+IFH/paPKchUqxzZgHt09PiEaNUCUBAqYffjmEK6gh09pAwWWRZx7lwXwJKBJrQgUVkiR9TJiCQf9o78+8o0zRJJD4G5ESnq+CoDHLEeCPMCkUzSoVIA7L8wNEk8jT3uEACF6RZ54kRQlTPnzAlk9u3aBQmT3kF9Qo2+0IMAdQZ8QCpnZ8QLR5yC47SIoWRB2O8CphLbqQZxGRwbvwZRrtxW5ECTofvApB2rHjcgho0Bf5lGmX2RkQypG33kFo0iIQTLXaUXZJI8VIgPdwKU7+l7kDl9twLy3AbSBhDE9RXeQAzY2f8AMCuqI9owLXeQV+a7wgLGmIRXwlADaPeQDZFqBQRXfu4QAVftAo2qfiQX6+IQs3AebgWt05EHtagVvmoF+kANSINagXfEgc9oFHbiEcjNv0QwqQEBASqQIYCAgQwJzCkBKEBAJwJcqkB4MCQpAQIZQgDu4EgBKpAQJ9YDnUAdMQqVKAqzAQJcqkBAyBRcBQL/ANQKvECcbhQftKKd94GeXuBQ2hAj8fVwIqqVQe8gcXKIdd4Ut2FAaGj9IBN3AItJeFKJYND6QB3rVXCmr+9QImhCqn/mES0QNjUog9j4uA4KeoDQRlUvlvm4EG1xAmQY4UKI7HuDAIHdfmAyFUjEVASLDPkGUGExkSdQLxX7QICBoVtyiNZUUu9QBAYFC4VH6mS1qAXfXaAyLKQWoDFfz2iqiPSQN+eJRovHRpwjIyIPSyYUDIYa1AjWzasO4BoWxCljbCsXuUN9y7qBCiQCX7cR8B6yQVQLiTW15gZNA2PLlUAOQ2DAEhDZ4FQIyyAr7ahTInpdj3gWgEiL7QMoYYujVS9E/Tt3QagDS88E7EClYgXXECDGiwh3/Eq6mLGGW91KGTORIZOrv9pCBBrIkD37f5qApK+qFTAiyWE+ZUXInH+oC2CUH5gQIZDIM9i/4hoBeR9QAZL94RBlpdKSBV+ZVTpHRRAPFLXP5jRoWASclpwVkH066mLdwMkrFBX3MK2iSsiwLqEYzPSCwGV4OpYoACTkBWtQrYYyB6q0CMqiozk31U3/ADEB5dTDCKB8Qf1BrqDrYGzKJkssgCRV3EXigApZUtu6+fiDQAnHIYsHgyCKgSMbNWal0SugkDprbZ+sqrpBjI8A8/SQRWAQDmDs/O0oUMkSge/xRKBZWIyo8BhcQJliSG0BruP8Qup0/wDtjfcDfwRouVhYk1fzvAyfSH6U6JY+alEPT0+nDI5CvaX+q3jl1aJYrclmCDIih+kl/WDGcqzLBAD3YAlIH9QZQJogbj4KNsMgGt/eCxCh6yaFD59Y74GWWWWXfFkEgJSmLgGSxl3IN8XJVTpIwyxB6bRqNRrJBnEsNb7QT9QZdGv0k7OjzHRUcg0gKIdyCMYg9wLqjA0z0suux5+nuIxPBEbR2cVuRAHqyCsksh8jctONZHHqGJeSssJbkROor/yHw5F/FwaC/TXL+kVEyyAxvJIOMGsceoUTQV19YS3A5PFjEqxfEYLiTllR6nTSvtJRcgejSLQA2aiH0yy6QiP/APLiTEVHDD0MlLUdExeJQGyqOoCqIQd0OIGiRirPtyIxAAAepJHXz6yGpiFhli9lj6y0Ul5EhA3y/PMiKksjlbvn6fiDq0kAH3fMhiYUMjliKfEtGjWYywNE+8iGNZPEXXFuQX+4tjEPiEBll/8AQCAS1FMU4vDpPUPeEAAADliVzxIvTBjD0hII1qKiF4hD0n/+NwdbSJ6ixu5ETPqGK58h8RBcUfXoHXtAo6epsF/f7RUDwXzv6/6kBknYF1cCjTHFgPcgMEhmhfeBodKDobv57wgniWU9HUCjVkFlkKRE3hoAKlKKCisSXxIYNel6O4FCGevsJEoVll0uzsSikbe+0iKjo39ZAK1rmBCwGNPtAvBAwAI2/wB4GsS6QBElQDY3AEEZEqu4hFthsh/HAAcgfiQNWjAEknw1cI1iDyJKCYIfPECnkjTUIa0KgN2UOFIGhoscwLoMh8Qi/V9pAejQ95RWAdasuRC0+RuBRp8SIhIX04lGgBo0dImRC1pQALOyjVyC5NXuBS9JwGgen94Q+gLkDtt7gUkDiAC7uRAaIe5RSya37SIv3gXhcSCApwKdjIUzCKD2kDlygH8MgqCuRFFdpRAa3Ii3q4FgC1UCjv8AiRFBR5+0IbkU+vMDnNtkDJhSAgICFJRCICAgQiBIUgJQgIA6gZ95VIVYRDCkBAiuUICA4qBJVID8QJ7QGz4gNwqeDKD1AK4VNiUB7wB+0CcwB/ECb5gFuFNiA51KIaGnADWlKBI5kA/iFThCVSjCHl8QofIgQcdpQAG5A/aUQbTgFVQooE4EKrYMIirvKIVoELiBR53Ayr7n3lUK7tQp55hELJo88wqkkmoBHuGaEBkP/mvMoL9RX+4EC2OYVPNj6QB2WX4lDI9l+8CElUAPaFN4kEC4EHIdOBQaB/iANivvCshjFoEblFRXjzAnNF3AZJo83EFKIQCA9VQjPvxK0enqFAB2oE3+o8WTxAgZY9+IFH6KQqoEWPZ/NSqE+qg64MBiRkC67pagTwCatirlFROXUT6fb8yCLIllWEQRqVVG6JOLvzIjLLxGLB5J3KoQBkVVIVAC7tHnnUcAAW+/MKyVyOeOfaUNZEEBCmf2gU7d+wu4GRetb1uBpDpJJ+5QgR49GwOx0IEDfXiiN739Zfxavq6QrJHPMCMjH1FHK2OYDLLTZBG5VTIl3fg/L5gTIJAkgHzw4FJZv9XJ2dQIwnkTo/WBS6B5MDNhMBBi9D45VawAXUQ6a8cSFOkrQRD1xz9f8yox0gZP/wBdPj5/Euqq9IAI8F/VSAMBWrulBrJaATIDULpZGQRJJsHj5/Mo0BT50XIamYJKHUHpDUspwwRpAsQVAGx0hnkwqHpsh0H9FAi9PVz3A8y6qZWeo5ZYBss95RovLPaWvPy5JxEOI/ScrKD53CtZPviAyPHzcEQEE5j0kpAE2vn7yog6SiNs6/cxViMonIEG+fxCoSMc8h1EnsbB7e3+pcQzJoglE8BX7wsMus4hlDxXiDwGR6T1EX2+VBYziAeqyurR7wrQOXTiVltr57QYEvFCvaj7wJichh1DIZckR9RrDErqBXZRTQHHIgYGn48ycF/qHpOgBvXzvERrI9QLXSPUO/z/ADCYyCCaZVIe6ci1TljlkOpHEGwuIxGcCNX/APSsyq1/T6smiXf+JOJVDP8ATJsMcD8fvIIDj/aN/dyjROXV1LQ2RciYY59QIzNg6ZHEWf4mIur0jFgD7n/ijg1iHl15GiNN89vtJfBcRkS+otLJa+XFAdNZYh4vnmv2i1MB1HpxAIxAuQaK68iiK7/X6QiC8bFF+kn58UcFwV07Dkq1D/8Ax6vVS5hFHUM91xT+3iEXyi9LUgYnqHPTxfMooGKJJ9Q5If4kT0GQ6LBWwVqMWqq/8gIA8j94/EVHHEAUVsj95EBWF+p8gcwBOgmFonXxQdCUi/xUBkADjiQO6HaBoG+kt/vIgEBqyKUDRYV895EZDHqfNncDeBCZsp3CWCK3RGv4gTEDqKGvn8yBSTAD+0DQAKLfLkER0ECA/vAoZ6hTd3CKEtr7RRckTfO7kRcDx94DFpUPMhUKJIAtMCBf7FZ+XKiFEshc1A0PVlv2kSqQAEWjIK3fU7VQA/uD/FQgCGHv9oqjovp5uEWuo9IL7gfPMIZXdyKpessnCANG25DEHSzwzA2HXfs4QJYR1IJj+lg3A0BCDfcCQMjyNLiBo5Ns+QITEBZ78QL1WDJgmJtC+65lFAe695EUH02bMCutV8uEL7iQAe4d9oD8BVCNYp9XJkADub0YFeskveERWAUhA1smhIIPggXEwF+9yCjfiGT94FHkCBR9XIAPpP58QG70YReE5A/tq5RWXqQPLhA7HMCjspEB7OBfMB5gUVIi6smEBupBibfoQJAzCkBAQEqkCKAgIEIgSFICUIDxAKBC5VSA94CFICBFKAgIEgJVIEUAO1wEAQqhUuUD94AwqSg4DcCGjuA4gT+IUXpUoBrsIBwCKH8wJ279oE3UqhdPcC0DpGQQpftApHaVWbIWz4uUU+6kA+6UCWHzxKJTXxwoUAxAOitkQJ5B3uBfdwMlnn2RlF//AIhFQI2CnCoFy37SqB3AFVVdoDg5EI/eBN/LgPB7wIr7+VKpjskn3igwSteSYBWCh55lEP6eD/EChklswM4pd2OYUIQJR+kAytsntAP1dKNcwAC73ChJdHELzKIuAb8cQBrEnJkHtKCdBnzxIAoOha7yjKPWR06+KFMQixibNeYFxsp/aBBsWVALjSFShvRryZFZIGIsM3xKaaQ6rAviOi/0yzoLi4ogLJIJAJ1AuRAoI4qjq5SIQVWX3kUyFkA75MomRAAo9x5gTQFl8qAejdWQtyquNgWEAmIRMqz/AFHhCFipCqRvzAzbJoI9t+IUxXQnvf1+KEMQVic2k13uDUZ1lT5NuVVQAGPUmWYP1CHz6xRKqBnpOSxIIA2JeKpxy9JLJUCsdRaPNGQQoAI9l4EoZEEJgA78QM2ujq5fbiD9XNJmgwAh3hYZEGrIBFD8SgQcX0lMjdntHRkgA1igjsNmBciBgemh21x8+8AC8SDRIRJ7iBlA6JseqVQBkBBpEAjcUCGCTdcjUcA+o7xBGN/VQcR0f7eAHzuVVxQA6gQaRBuQvrIBByHVfc34l0UkdQIAtahYB44nLJDJihUqIfUsXvQJYMKgpYDTXuX/ANgA+oY+ocWeYDH0knNu2xZEUZyXV6h04ohrxEVoHp6X6UWSOYRnJ9B6SDXPAcsVQCMiSsvJMG+H9MigAQSHYtKKJli+ogDIivgjRknLpCeWRLekJVHkMzgQBiDz+0H62MRiLxA6rbS4kRMi8z6xWgr+8fCJReJyPDL5X+oGv04lDqf9tCvaEB05EIj/APkTxxJi6uNYtv1I9MVC/wDyEHpAFgugV+0HxcQRkMhjiyUBz7E9oRcLTaKIJH2koADrBOJNUN8yFCkiViquq/iUAcSWK5oWa5+8hil44oYkmz7R1BY4jEWUObEdF/pE7JHTxWosSmNlo2RUg1/UPVkelkJAEO44kCAaayfv/HtBfFIDQKB8SCZ5UAgSL/72jBQiAMR1EEgrxAXROJYseYGg1ZKHcXIhkAMwUTpdvpCLSJ7UxyJAWTOwQWFAmK6Fp7rvAv8ATxIRfUQKRioo6hvX/wAyCkY44gFgNkx1BhfqIVdTgQYsgFLwaMaqnFDEMV5ShGur1H+7ntIgwigXsriBSQkiB/cFIiI/oPVR59vEC5lDqLs7/eBWyk0aBhAhPpKZAQ+0BYOkERR/MirmR0k604xAZMdJ2kVcYggSAr0Rtwq4llMFU7kQGiWRV+IFfUUT/b2hC0yN0FxzAuNYogGQTpAYseRA0ySDs19JEUg44HqLJt95UAiQNE6qpA0seGhAD9QCA+rXmQXH0hp70dxQJILyHpHaBTXS75rmELVMGQUUUx9YRcChpBX2iwDbA35kEtIc2XAtsmukGEaoBlLkwgbJLyQ+0ggWlX7wrWtbNoniEAQfA9oFGuTcgX1G/rCA8Eb+0C414EVFB9TQcgfSvA1ArBu4C0sV3kQoChrtAYHlmEUF2Uz9pBSbYriBa5r2hA2eYAk8cSC3oDXeBO2q1A0NSIFN1cIvHtAd2eauABqQXEIPcVC/eQWlp+0BS8SgN7BkFQkRbdQD/wBwiwCDUCnTkDmoQgZmmyBICBmFICAgJVJBCJQgIEMESFICUICBCIUUokBAQqwJAmpQgIEUKShAiUBAaECH7SqHiFKhDvUKn7yhAG5BDzKDgRceIUZUB73KGxagTlQH1gLPMKV2lE5MALgFb34hTYAgTRgD7yhCplWN7MRBer3hUacKIhrdSoFkFAowCD7QBDHECHzThUfB3KojZ/iEU6Dv6QM1RH/IVSuoLizAInZv3gQWADfkygfrkIUNtjWoGeN/eBapj8yigEjSPvIMjfVw+OZVAEGdKAI9Nlk3qBMrxI3BDvojvKqgA7rvIM79QbSl0FTGNQAY5BB2u8BkuwNcXBEX/wBb57SqgJXKG1cC89RY8d4GTyyN/aBQBwjAYtDIIscmBCCcaNeZVRAA79oADQfaBSgCRZ/mBglkMEHgjcqt5H9KrxIIVdbAfmUAwCiAU9KANjpCNd3AjORQ9yJQNoOhqRWciLWO+cZQZ+/mBCGTiy0vHz/MoDIr0nEA9t/KkDqQKLNQoHlijk/yJRF6hiR9EhAUCr0vb5UCL+45MEb/AMSq11dgqZq4QY6suQ9/vCpiS3kfnvACz1Y5G7PIgKzC6sTiB+8cEFEEffv3X2hQjpBT27gNkg2oGP6oWAxrI8pTUGgAf6gNau/ntIIiGUU2+8KzkAOoDMA0uJYKX0nJDFm3BFrqBI+o+sgFHH9SHFfipRg7v+4ax9vn2lUBKIP8/SBSEMiMiEO9ntGgSRjjvIilSUCMAPSPq8cwqkjLMHEBYs1dxxIgxA/UU6Zf2hV/pkIf09AOj88y0ZPIxRFsE/O8Cos6P/rIrAIXZglsn57zQ0CGOoY5csfeEXp9BGZxA/BkVnHqfXl+oE0QuJTwAQa41v8A3ItqEDH+mMHkz7ftKiZ3hlTHJP73E6qj+7F1yEf2jh1odI/UUB2pyJ6yB6RkQit/vKNInEkJ8AiQTFMdGfVwQ/PHzmKOhJP6Qciuy+XIjB/8Y52EaRAX5lPTG/0g5KijvvuEqnfVnisuF3kBhn1WT1c3BihNYksnkDdf5gawBxxGWPpy6Q2JE6ieNE43xuQB0gZFBlHdL5+0qAGNYv3Go0aOQOHpDvnv9ZMEPUSAcX2XEeDeRPpKIOq44kQJVGghv7XAosHFl9P1gE/TiVXaETHLqyAGQxpriCxoregHsakEJOQKxBH2jDheuCO3zxIggciO4TB+eJRSSReRANogyCvIAgAg8Mcd4Qx0nl8+GKKD6gNq2TUgtCumkjfmEQdP6uo/yYVrrrdAd187SJg1kWKJ5G5UXDz/AKkpTFEtdJ76cguJGXJQHaEAgshr94KpFFDzAAX+bHxwiZfoAx9XmFbCOQ59xIiWikeU5AKu8rSK7SotkNhk2rkGgQwNswYrBFuRGd3+qr+feUAwCxXtIKgiXfjn6wi2AO/mQLTR3aEDQPVkxoeFcVMEAm78SC4HWOoqJyelDwoVRZPqF6gTgvFAi0IRoZEUdeQpKi0BZgAwWSRk+TABAOrEgpWIAX51CBsFQKN6MgrHNjiETWNgQqryjIiDppV78yjbevqzIiMLRXMAAfqO9QKSrKJ/aQOdF7hFBumPrAo0LIKkQT39oUdHvDJRA7CBplUFIJfg/wAQNG0a94C38qEBpLiQXdaCgBZtiEV8yAyX/MIdoFAZNfWKH3kCxWpRQK1Iijf8wHsJAHsfaBXCKyD4cgCEUeRAD6wD5gX7SIzNNkBAkARAzCkBAQEqkCQEBAhgSFICUICBDcqniAgSAhSAgQ+ZRKgX2uBICVQQIoDxAfSBNwpzcoH2gQ17woO8oeIA/iBCO0ADyoEPFCFDtVKEgfvAmlo95QXilAURKqfRQF6UAa8CQEtCVU4CagXa35gQnlfaUTW1CrQOoGWe/wCYBPQgWBGOoQIu8ouPdbgTY0YVOK/Mqh+VAuwRT8jcIzjVXcKE0GQhAuQHUwYEQBPJ5lVAbBC9nAFH9K9u0EUjdQIb76lUJZs62ZEQhL7blUytve6NwABFEOrgRk5buBCCgOe0qtbWP3kE2WPp0mUYHSCbAXaUafnIPtICC6SHlqUQsWunk8QqFEWz7HUgHv08IEcSiVfTZB2ZeCkkDK3W+0ghLNDlyiAIgZewEaoumjdfWBcqKSrtzUERZCxqF1MWSQ9eZRbBD9TJ4/ECZEhAbB+qgMnihz3gTFbIRHccwI3Q1y+8ouTBKIRdcnxEUIYBxY4gASMWAPNfFxAyeo9Kv6fvCrmX/UAbeiJUgSA+oFD7yKmIrVqj3lAggY5OhuqgCLZGNBIe0aRkHE4lYg3xXzUqmRtZIrXeAJIyOLB9zcdD+pl0kEkAcDnUYQApgjt294EABxFBHhwKCxizxZexCp1ZUQASdfyJQ0CQyjQ4MKpKNJWk4RjEEe5BsCFVEgADpHdyopHSiLL2FJq9ZGQ/8mLxsMa5l+HTEF76jBfFxYBypHYVfP8AMDDyOIYAbVyqtJBY9yd9/wDEAfUyOo33kFyeIOJJwpg8feWDGBQFFGyXqWxWlkgxkQNBPX0kRP6nSM8bRBrgCWKUHtvmQZDPRkECh/bXz/Ev4GeQzyIBIyIeQ4+kv6TxSeolnEkWt1uRUIHScigFt7+fxKBLyHUWBb+kgEALRpALh1UoZPIZgrI8jt8EQMcThyCFbr3/AIjYdZxeeQs++oXidJXQywCfHP8AuU1usugE+nZ8/FIgD1E5FEPn09MZ8ECOR9OWWKeJGMB6SUm9+pScK2PT/wDj6b08tfNxUCyS8g+QLJkD+28RkdXXzUCPNNAhady+IrYyGIGIau5OC/25dOlvyeBCBeWQoUW79xccMXADHMN5Esd1JpfRDAdILCS3A1/UJGZFmu9jX2hIAHgg3rkmQ1MBZ4x0PzFGgMhliceosls8+YRMzlWAKIL+kQayBA6cbCT7CSBiSvVsUALvvCM45dRCQGq58y0dMgW8SS2EtmZhqZAZAGsTpuBr1jFlirC3IniEZFWau+DAuSP9QbOL2eJUgyCaa/tcmKoISJD4PI7iRFA0cSXjv29oRcmCCSCUh9oGRm8SEzy6UYYr2G+RAF4kokBfSOhnmrJPsNCpM1GgiN6KsakAB9ND2UIoIWIyVVqzFB5UiGbviPANFh9XDMDRPPHkSCY67g8hQKB1AGundCRFYQRd7cIM9YBF2BAYoaO+8DQKHUcpEQPpZIt8Qqt0a/eEwoglAXZgU6OJ0uDqREDxVAd5ejQ8ccORFzXUKL7yQAQBQXnvAX6SSQVAGyQcSCrPeEaBdgn3Ugf2nI9oBo+OIFJ6Va95EU/3DnlwgB080O8KgRN/mEAH6fG4GmGHobkQezlV31CA8pghhmBT5A8sSCgr04r6XCC8ljtArQr8yCerb9xKKD1Ma8CRF4PA19YFIJ3r2hAekhcyAUNOAyPqOtQjQD0fpIA7nUAtEIXCBevrCqdIGveRAVRT0IAMln2gXyD7XUiKbF7hCwN68wKnAps+JAtlQA0vghFWu41ApC5kEGVGEX2uAPfiAyPKJkRoa5gWBAUoElaICAgSAgZhSAgICVSBDUCQLxAhECQpKEBAQIZRIVVAkBzCnMAQ4ElD2gIElUgPeBD3cBAQBvUKilCBC99oU1KDv2gNwIT+YDUCaP7QEKcP+YFOv3gZy8Sgl9fMohAf03ChFeYAom7hTlQB719IECJ7ShadSAL8ShxAmoUFCyxAgof5MKeXqECnT8QBHBa5lE/t99MagEzaELqAGxKqsZbt+YRntbBEKrNmx4cCN8Xw4A6se0AiWBfEoEHfTxCoQgQLPgQC9JxyD9pQKKNjsIEIZBypVAZME7vcLEaCPUTAEjGgPfagFzifeBMwhss/iWKUQQaHMC1QZAUIyxvR7SqoCI2eCTIgQsyeG/MqnQTkLvtBqXSVj+JFQgOvtKD40G5RBlpGFMSD+YBBG3VQMsHqyt3fiUaB+nkyAjrtpiA6gRvp/mFEHeViixAhTIBNIblGUTYNjQe4CsQ6A3APIEgAoeZVB6iK86hDInyXx2EKEoG9hnxAzrI8sx1V6lZrRL3GIEDpOVP2hQ6BBXetiUTPqIVsX7e8QOkOkX3caMlYkFIKjL1VyBOHSPazqBMziw7BPYRNDWRCaL7fmBSUAXvhLmDGRv1hc/PlyiokGx1Gr0IVMPUjlyKI8RRpdXLJ0Pgg4wR071x76iXQxWGLZWgCZeliBDEpD6MXzCgA2C8gaVwBAOSGPt33B/WlhyAQHz+0h6yiMO3Vu2n4lEx6SQcsxVla7/xKtBjsZZek7+eYNMcsS2ADkhpL3gZTRDRCu1KrQtk4rMnXz6yVOMjLI4lAaogmVQMYmhkCaAHiQVDInEHlBp6/1KcMiSH1YmtdS+cwM5AgdGPUXYupTVDGBxPrBCfEgFEDLLBcjsIVk4jIg5hgaV13lhpm31BkEbdf7ggzjj09ByBOydx0+s5ZAViAb2gXzLirRwGWJ6Vdv94D+oMekhM5XkQbEQVjIZdWLxX1kTK0DiSGGF9Pn+IPUOTDyBZ76Ov8yEXDpxzxGCxAo3cVFJIzOQPUGyP5cB04nMesBc8RqXhZXqDIvzX8yKpAbA6fYQg2UTRLQ5gTqNWQ7Z94wXDIkBggIqpLBr0o70r7/B2hPUAJwyyOB7wfVBIYJQ97hFxIJ6RlfAYKksGiSQsxkO1b/wBxiA6GBYINSHqPHqOK0B4r4oAAZA5dQYFVAprE5M90vECDqJIABxxNDtA3iXlex59lIlQvfLAPaTBTQK7Wf5EqICs/Tyb8QfG2RaNIoW5MRDlj0Ek3qMVr9WOKZV1J/UTJ5BHi29f5iCoA0UOWBGoZenYpAVsQKQ8UEHUmiZ5LIFEXyVLILzQp0Tr2kRSa5JNEGxAjAPrWhCNelEdSJomQMSK6i2KEDXkkslWaHiKiH07/AOSAFgAelE65jouLIK6voJACDQsfSEV9RKS/a4ONDLEWER+8YiL08M7W5AxTD6irJX1gUAWTqAGXGXNahEA0QEEoGw0erb3IiAkggLXbUCh9LFuBoWTjeN0JBDY/Va5EARxiBdsmEX9OKdeYGmTiyv8AEiIOMt9oUN69vghC8QsekCQU5HhqBaOIKX0hDIUQveBQ7YdakRQbBXEAa2A+8A0RwB4kA7OQ4s9pUaHSS39ZCi1uQNmAd3cIAwKHzAtI0pEAD0koX5hDVHXaBQn2cgrPIfsYFCaXtCDshQADBLOqkFNAnmBBs3AoPkVCL7b5kFPjt94RHcDXD37SA60YF2IQ2FAtPZEgFg/xCFESAaLUC+dQi694DR7wJK0QEBAQJAigSFICAgJVIE1AQHECEQRIUgJQgIEMqpCkBCEKQECSh9IEgFKpAcQJ9YD6wHvAhF+YVPMqqPaAIriIJKAHkwECcwIP+wKfNwqQLKIdcwIa2YDIgqAAp+YVCHR7ygdK5A2q5lEIe/3hSiyyLgQ6B12lF86gTIE04U3j7QKQixqBBqj7wAr7cwIghv6wC53KJQ7DvUALCILhUQ5BlUvtCFo+8CVjx9IVeKgOW4GVfBlVrW/pcDJqi/aA3iRf2gR0QKI7yqnCseCIA/pJs/WBER+xrUDSCQRHaBClu1yIEZvx+ZVUWHiQoEyB2RrQgTLTS795RoB4nEBE0ZEZKWlCjYD/ABxKoPBqQRFtaDT1KIVeiuJVXRR9h2kRkvp/f3lVQT0nkdoD0l82rlADH+1MFsCT0AMmXxy9GBk/qrhWPeFHyV1EUBKAYTAAVj6QGd4kjKu38wJxTAJstQL04gkKzu5dECNbfxwrQ/V+hhKErHS0SCO54KhTq6QMRZas2YAgMMCu4gOenGuIEL6aFgaJlVKGLRL/ABAv9QjLIbDT7wTwwAODBaKBcqoR1EjIMA2Y4GSOIxXZWlAhbHViAW3YuBAAT6gH7QBGOT6sTiSaHiUZzAyGJIs0PnzUK3a9XfgPnf5gZzHWby+o5+XHAIJxAIJPAPt/uUaP6ngVWtPciIOnLEkF9938ccVCBiP09OKWmzKoAAMT0gUSLfaAKxeXUMeL+eJOjJyVWx25+fzL1T+mUOkgPW6UUUIt4irKPj8QIsgUUyGAP96lNOnIjMEldvEbBH0nqGNqvMKpoJjG0IIhCIyBJB57GAASLJpWN9oFYxDeJdAgfO8DnkF/b1VtlTStD9OWKyD/AHGvn+ZEZP6Tguhc/wAwqAZKwQdsHfmWqprDI9Ib53H1E6SD0Avuy2I/VaKQGJ5NHtCMk+ixm1tvl7hT1jJO/wC1c1BWh6g+ojhLj2hDIEslHLhfKgMmkb46e5v59JINMHHoKDol8fX6QiPviAU0BqQMc2gbK9XF+0YLiA3iF9L/AOwVQCTkSiUz893CB/uIBe0caMCkjHIkoglPtCMEEYCy9H/6NQroDkMSQx2GXaTqDFvEi0XdXuEUZY5AqxiW/MnBcQiWlokcxRnI+v7ePrHw6oOSbJyy5A54hFx6gmdBL6SUXJZgkEsjXeAQICxCfvAo6Qwsd3UiGNrpFEduIo3iSc2OlEL594ZrA6SR1dLHm9QqtejEa7hhfHApyAO9edSAcgSqTMYjSyOFJge4P+5BH6WAyYFzJyyDxL5RhJMXDp6F2yphQVVt3iDuQQ2EMQinUC+qhkQfp/uEMTfST5kFNk9eIZMIyT1YjRPz/cqt2AyXa35kZTIArqa9o4qqgCLOvNQjTGWTBviQMDicWHWq9v8AMmIEq+NIGBQaGmQ64gKFhg+LgOrw0eDCGDAT+qko1i0aBA8UYEDe2/lwigBZAkf6kBkZUnoSi5EAeoq5ECheu/eQaAVhjiA6gOWSYE0P7UVcIo0iBfL3ApfSWK7iQTpKDAMCglEA2DoQh0ooV/MmjTHFcwC9P6QlsQgiCvtAoR23zIB5DZhFOu/7cwBKAGVCEVnksqQATQTQuBR7SCgG7cIF2RXa4Bo9wagQj0iBoaJ0YQa8IyIoLBqvMgoXd/zAh34qBf3O3CKBy9QBII1cgb9oGn9pEAdcQKCW3CJ2fHiBQToV7doFkBsqBbW+NwiAsV9YFLJDUguJ9PIuEUSBcB9ahFFb+8CStEBAQEBAkCQJCkBAShIpuUQwEBAhEKkBKEBAQIRKqQp7whAcwpAfSBJQgDAkqkBuBNQKIE4gCLhUv3lAwJCkoDjiALgSu8BzAhhQdy5QD/3ABLzAVuBB2AUoEhe8ghqqK8SqEEncgH8yiHetQoEzdcSik8dpBCNpS6I7D45hSmCBCAQ8CFBYuBL7DR3KG3rKBONXuAAoXrmBShVe/eFZvkGVT65Gu0CpnjmEQhtjnvCp7WN1AptAa8wMpoSqeNAQKLQ+8CF6X3gUMhagZpEtsvcogIOXnxChRNV9IGkelBHsO8CZb4125giV2s8QoU7KY4gQMIbBDBlAjqAddvn2gT+5ZbXtKFFLf7wICbofeoVQSyAG5BLIOvF7lEyFPsWidywESnIq5aAN8sSpEQyYJT58QqWAUl9nKLiNAllo+8gyUMSSyigVepSLyaoXtKRVVkdVHkwMkI6t0jRMoJAgUfrAaQog8AbgTGzjZFcOv9SgQiFy4UWJzJ6T9oOKQsnwvxAxkENt+IUxAFnFnt+8ChnFMgOiN/aVEx/Su1vYhVBBRWyt3/uDiAHI9PSufaDidVV1XtXLih6gcuk5EOoFyxD3RNbcGpkOCCO5IAgiMs6+/wA8RioAHkgUeEoAlsMJle8opARyGRXmQAfUOq8RqBDsEYgIr8+ZRMEHT8Di5aGAeIGQB/JMl/BCT1VljigdBqVUxP6jgWXsxf0WziRiMQgyYEAeAF+ngGzCtZZDEJ+n4Y6YyHiygB2cX0ZPSAfTlrnLXj+JRvpByJOXqsaUAQCCMxjZMb/gwSMiSCDzfJlXijPHIoEYhMgFyYJ6SQMvSQzY9v8AEoFInJdISI4gMV1Y4k/pDLqP1ajJoZBCtgj394FB68Vll3Nag4yAOjIgG/UTcomOYyKLNXaEZitZDrJWOQ9klsRqcUfo9OYD/T24/wBwH9QkneRCtCn5+3yo+ETHX6A8tlVIqEAorq6ha7/SVDF4np6h09IJex7iKdUgZgdZb43xv8ycAPrAyHVW019oDq0H0lWT57wmLjlkGDkCVsvv2/jxBmricurpBCPc7PeRKB9OxZ9NGAyAXUEMg14r/sQVcEgDS4Eg1lSwooM8F8uEAsmCKPbtzAhNH1EAaB+eIMaxAxAfBRJoe8InUsMgiUUA78Rg0X1EjpPuOe0gvpZ9RGJHw/tIhliewLNFfmDTvhon2swD0Rk8R7LcBjeQGQZA9vr+PxFRaY6S9vk+JBoZDIk9NE0sqhMxSgW6HaQZIQrqvzuAx9IYRy0/aBcQ8QN48AUYqGNYq+77yDYLAHSNijxCXxB1ErIgA/aBbT6T54gQrqIxPNAmBcul7olJahGstAH9O9uQR+o2GPEmALyyo2qJgOoFrKrUYi+ggkHY13j0UE45PYGh2gUkm6C/H2kxDFsodR8xQwNAN+BJQ3kVllT1UBjYJxBxvahGmUmNfWAC6HRA15hFJWmhx2k6Gu3soE01jjqBv02ST2faRB7BLdqENgmx7jmBQWbCrgQALoug6kDQORZECggEA6HeChb2armEUEEWXzJQrpNcM6hDEsoj6nmBT6mSu5uQaFiiQ9eIShs0yEtwgCSPy5KoRqnVuEMU1iaTQii+8gCj3HNwB4BpfiUUAhi/tIgNpoGtSCihZ34gDYfPEIutmQXIgIPQ5lRR2IkE77hFSAo1ADRAFvUClgm0JBaZ7eIQ9jAvPTIHLDgMdo9oqFOuJBQXdQi1/MAvG4AaqQUavXYwA14hGgT/AJkEG7MotrUiHLATgVjfmQK4R9oQlaICAgICAgSBDAkKQEBKEKcQIYCAgQiFSAgJQgOIEMqpAsCXAQpAQJKEAb1AhlikBsQIYCAPeBFCg+socwIahQb/ABKA3AQI4DtALzCpxAcSgfpAW98QDQsfiBn9xKodQF83AGA/MKgXvKCrmQETKJyRdwoCNtQiDuFCncgGBcQEOHAVzAz4XuZQ9w3tQB2zUq6m2rfeAyrmj3MBz6vZQBAFKFSgKFrgQBFsW3uAGiDr2lVExQcB4q/G4DpVD6ymh5Ay3SeoGeOyKhVLDHjvAhOgNcVAoPpp+TAljFW3zxBAOw0B4lVAFeyubgDo1/yBNALJqqMC7NgEnvAHTK+m4EK7GuVCi7uoEAZpSgVlQq3ZgMgCSddy40BWW+rv/mBMQ97P3UqmWXBD+XAAU02eIDKwSGOwgTFGtugfn0lVcRk+kh8WZBCmyj51KJkD+kc//Nf9j9DG8iwW18/MCAB/+pP29/zKqBUNdh3gAQa8W748QDLAfUAdcwB6MaaPaBCQMaYGivaFGEB9u8opYBIy4WlAhAGySh/yBTkRjkDZG7gYLGw8gKKlUL6NFk8jm3AYhZFnHdMwBHPhErzAAXRsd4GR0g+nEH6CFaAxpAAjzo9pdAB/q/dQalMhC93Xn+IAEMvqd1pfa5Ss4tene/039oGiCWsQDUkDBejqrqGgYLUGWihkDqoXEGukAdI3KIHRGPUG8uGI8UYJZ8AEXUofqJA9JPpvgxwMhj0kgsG6ZgQHpIyyT0CB+8dGjSARxPn7QRnI5dAQLIp18/3Hgh28aou5Vi48gkkaR+fiKIMOrF4ojYJg0byGLJJO1vvGKdOscUULPG/ntCahP9IjIgi2MrrwHL7BnJjH1A+k0RVd/wB5Wmswniw+le8kTdMiT+lp9/8AEQQZegBHEDvv/ZimJiFicAebRaHwxVNvqzPSDQb/AO3Kh/THSB0lZAcAH6QX1v1kH0s718uZOMkY9OKL4D51/Eo0CeoJepkU/n+5EV0LJJNi/wB5BffGtOivjgB0ou0+fpXaEBuz0jz9IBj+osaBZOv2+8cDMY5bS32MTwXA49fpyJOrOxzJUP6eh1FE+eH/ALilayyIICK2GfniRMNYPv3K94Anrb/UdYuDi4kCuCdnj41FQ/poZG8F+PlyFUGyd7DIvtx9IDJ6ByWjk9QGJWR6wGwN/PMYgwLzr/6/n3uP4AIGzr7fWTBcT/8AJCBZB3VC4qFjIbCOjqQa6sWcQD1D/wBf9RlEJY9tj+YAZLG9b8D45eo1loo5WEGfnmQHiLGlXmTBpnHEjZ+tyIyScQQyUNuXBSD/AOMLkgfW4PpgFkSDzxjqKNFH6f8AZEXECwGEV7SURkEoELv4gXEg9n47wligD+6wXwxCF9Rr3r53kUxIJPpZP1/1LiVQ0mRzf+ZBSyLI4VSQq4Eel2eaqEMcjxzsQYA+a9twAdJUWjzIg7Z8eDKLvfpfpqRAgbAPdICBQTjtk9zwIFOQYRC7SGBNJhrvr5UIHb1tqBcaJCvs5KADBRQ7QDRGOvJMDSGgUuYQYIPpPLrcmImVY3d1cK0UGHwnIgQTxriA6vSigBCYo0QPxUCBXT7KBrHSDY7VIijqIQgQpClwHAoPLQPPaQXgAC/OoRWmK+8AwAdSIDudeIVf1IEGEUl7+0CBOqhFx4BuQofCUIusX+8AEarq/aQUFD/5MCirZXtCAP8Ai4BPWpBQwb5MAPZ/vCGjfEgt7Ir7QgBfZGBWyul+YDY01IFwKdUFxIivsOJQ4q5A8Qin9MAPrAsKQEBAQEBAQJAhgSFICAgIUlEgIEgCIWJAShAQECKVTmBIUhCFIAgwJ9JQ5gIElUgIE/EAPvAcLmBD8MKkosCfWFPeUF4gCPpAnJqA51AKFQqUU68yCURqURH3MAu8AboSqg8he8gHX5lDZ3uBD/FuFORKKxXiQQpOBNF8vkyqqVv8QIdU4AJC/YmAHaoEIX14gO1X2lEoCyAYAbvvCiXi5RGTtKFMla3wuIAh6/5CBsEjnvChAs+YEBoiVQho6gTFnioEXAxQ7KUU2bYC7wJkl6mHAWDqiYUyRBHwGARXViAvJgQpUBCwx7g7lAZEEl0JBkasfp7TQDgA0NyCixRL7wIbyyHPvKIieadrtCrZ4oyAV1MUn9JQpX2gZC2APPSW5QFnS+nEKha5P7QK2AMunWoAC2AX37QIbx6RfLlUpIAL/kAf09TKe1uAVIW+4gSitkgs1AnUNFF9/EClc9J7qUCiCDp0BzUKFk5Jd1zBxmxkUB2hVxHOhW+YRCQe2Q0gIAroSRFsfPeD6gZH6AAOJaqogdLthM6gQgAAlFh78wrLdArAJP8AeUX+nkWQQndGKJkCcVRbIRRiB1Dqske4UYqZm9pDW34hFIWQoj2o9v8AEqnVWJGOVCvtApITRJTrmQZCY6UC+HL6LkMcQ+o03fEdGToYgWOPnMp+riB0oDIA2ObkogHSTfGyPtCoQiSCztcD3lF5x0MiX8+d4EyAoFknRAf+4DE9LaIBOy/xKdMsUiX+p0eJFRZ/3NGgxx7ykxP6gxHV6bPKWoixogZA6xe8iPx+0IzleGRA6SbuUUnFZZCyTyZF9ZxIZwtml+0FU4jMY5Gyk9xuDIBbzQuwafaVT1HIcFnRcC5YgkZZ40gNe0aJl/6nF5HYxuvglEJIL6gsj3/fvKGRxzxyGIBJr6+PvJ7KLsHLDPEKknqOdGeo9ISANBYxVaxCWSOPf76/EIgyIzOQOuBT9oPgAQxmATjt/wCIPFAYFekG6rLzIKA/6fK02X7wBXXkCg+SNwiLEo9bALR7fzA6Y9WWjRAYC88SJxOoMnXSyVx5/eBccgkwUH51495MExIyAI6ci9AJ6lqALLI6UeDoSYqonEdIo8v+OYRcS0Dkc67c3CABxD6Rj5JuBR6sOgAICx/HzvIKToJDa+0CV0gh7YDv3kRoaWLF62rgAQQED6SbcCDIg+kZWe2yIG9IkkgW8hIgSCCdh121AGzlkMt34J94/qcQkjIjq+d5FawI6RkwBX1hKMksMs8jcDRJ6OgjV195E+piMzeWx2+ktFCI6RkAyERIBQ6eSu18QnUHqy5QVQLgTyQQTw97iin9NkHq4IqEAQcrB+7MmBkQ96AA6eT2gU/qDvw9SI08kMujQgXeNY9RAr7wjLsG7VqFaPSBq+w+fiRAtDEL+IFCQHSB7UpEMdoNcfO8KEAM4kvk8CEUNj32IFr0jbGwfniRDE9LI0+1wdCBwsrcAMSA3R80JBczut8xExWDRKvjcGFnE8E3UIpIRQRfaQAbS39oFogHmAx0yXfZiEETkjt8QNX+o2wveREJ0KMBtFu+2oFJYI06vmQUXokHsBCFnvA0kLCW5EZdvnhwq4sO7EVF89j95A/tRA9vEC7yItHtCCFFGjUChnngbkQJ2SNbgUHgdoAFrb46oQ85e8KvSSKH+RIgCAtn3hFFUx7CAF0KkF5EAQhpeIRfGvaAfgBSBfaBfbiRF8wBVkuENE3A0CKe+0CedPzIKdIqEA+TArH0gOApBRZhDHfeBYUgICAgICAgIEMCEOBIUgICUIUgQwEBAyYUgJQgICBCJVTvAsCcwqwJAQJKJAo+0CSqOAgQwHPiAgQiFPMqkIlKpVPmoD6QIfaAO7gPCIECBJiFCYAGpQI/Hm4AiBKH+IBI1KqHvAe8Au4/MKFvzAB6gSuHAhI4lABhmBQRu24AgunCsjegfcygAbFH2gNjzAc61An0XgwBex+8qhLCB+8Ae24VlHJrjy4FoC4EPsuYA7Br6QJYXEqrlogAGABZaswI7AOtwA3yDKIBQBB+0CY+BowrQQPmBCQA+nmBMiuptO4ADF7P04hUe8jouUDQTZ7QGN5bo/aUWiSrve5Bkh66a3KautGv8QMp4ocgOoUIr0oF9ol/0THQrp9jqWqMGilCAyyogVwIVCAEuDAuTBJRI2jxAiWTLANwGIJSvt/iUDtc+KkUyBHqJXbzBqZMOudalFJeNUYEBZRLHNxgWKQS15hWSz/TBHT0nXiUCPV1EAg1UaBCzAOOlQNCAB9OJWQVwIcvc/WFwxyY56if+/PMooALQ1wB54gU4ouzyIGSscvS+p6+ssOpWP6UACbOgYUysAlIWoIIhFa13MhqYggmse6I1KKQXWya80YAPWWXdvUKgojpxI1/de5TGciQLxOlqJBoYrE9brJ9iIEBAxLx0e8C5Y9RD/JgZD66IxVgIoSiDHYOTZJAIThdMcsTgigyQC0/lQijEslBAMVxIrIJIB1pLRlVGCXiQF9F7y8F6sc8Ly6QGxxGYLn2okpMVJBzA6urLqx/b95pddAcRiAibciMZlvLJBW32ln4vA59RF6C1YMi4dJJqxonESopZBxwQB8cwJjkTlYHWSfBqWnwxyIIZABBKWpFQ4odJxARb4Hz+ZQ/p0AH3P6opUAKAIIOJQ6jv7+0DYOI7A/7chjBzyIeAZe2/b3mjEyJOWf916Zvj/ML8XE4HIjp6jz8+bkEZxxP9TIEAv8A5L0apLEvIcnXiRDH/wDZ1EFHv8/1INAhk46ewxFSc9UA5JHJY3o8/vCbiZJ7S49pFVdeIxT6gCfMvETIvH9Rxt1UkFAJwHUB9jUaIMgTb6eGO8GLjl/UOTDFj06jiWKQECA1dfPn1kFXqOWCJ5vR7Qh+n+oCfsNg9oOr/T/SCMgATzwTFKpJLBPUxsmj8Uh8M1j6uo8JFyIZOzRJPv8A94gaJJw0tv8AkwnEwvPVDcYtUZHgjV+8iYhLwGXXWXClGiD1bZOwkdSIFj+oGiQr7SHTFnHH0erYEoF66H7iQP6ZeKAsGz27y2JWwsmefoiz/wAmRpDYDer25EZyyDWKY5dJ/wDJQaLFCwxu7gwyZRJeXZQRqxT1oSAOoFs67VCKiUjvR+8IAKi6bMgCyAMcXAZdY42ON/P8xMAHHHEsgh6dfiEaGSxLA2frJRSAwyBcggfUcuojlgSghiUWLP6rhF6h0epIkokfPgjEaALLOg1IqBlOzSUVEYysOvEDTGWLyBrsJOIZFcpq5FMfU/UXxX+JU40CAgACzUiIS7JfaoBkrf1gaT9tdpBS8qBKgTE5aO+f4hGgS3fLUBxwRtiRDBUAnvUUXEUqF1IVprY/EDLyQVQils1zTEC45AkofeTBERj1L7cQLwhXmEUBZMiQV7PHkQgEfoGLgGD/AKgUBgA/WEQ3jci1Rqy++oRQSLIPeARN/wDIRT4Egvciu8Iaye4DHWyO8gvKgMkA4RTApZFyCD9XtAvO+JEOKJfIgVWESfEItjKADXDgL4UguLIShKoLv7GBaIYUghLP8yiuQWAgICAgICAgICBIEIgSFICAlCRSUSAgIEIhUgJQgICBDKqQEBCkBAe0CcyhAh1qAlUgOIEMANQHMCEPblUMAdLUCAIkyqcwFdqgPPaA5gT2vtAfSFQcoShrmADP0gRUz2lDdC+8KHcgm7gOO0ojgXVEcwqNBtSgT3kEzFaP3lDKxuFU+7HEIh2vpChgQgJfiUCeWe0QRoDUAgHr/MAEjVASqc2GHAmih9YUqi4EQ2aEAB4uBWBYagTE1qFQImtyhwTVQL37QIAjwONyiFvTtiA2LGh3hR16Qj7QALzQEDIo0n+ZVCWCCa7QF7S0VAZsN/eAApXq4EBWsil34lAikET3cGoGQUQFpQqpZdJIINKBK5JF9+IEzKBQCAQlgrAJdM7kFRqgjAzgsgQCntc+ZVqHkpbPmApAEXtSh+ki/SQvYyKAC8cr+soG9M19uYDI6wJBN6uBMaORJ+kCN5oYlL1eJfgaRGINafwQvVBDOSZGMJgw7IoXeoGXaxIB4cKoJoMFHZbgTEo5AAYlFjvABAEC+kcD54lVnDq/S9edRRAAMGSP0iUXpJoMdPeRdNZMF+XqULPq1V9xcAWcRiSR2P0gZeQJ2BojXzco0DkNMh7bkGP7WGC+NqWK0W9Fr3UgmWIOPpxxvSt1NaGYBxXY/c8yBkLeLyeqr5uBk5IrEBFAHtKLk8stgl2g4XiEAhAHLXtAhNdQBPAvcBlmMcQyiKNfOYk0XEY7xscADfxQLiVicksVXb/cpWTWZfScepIjUAQBkUwqK/gxFAAOkkZA2a+VAlDJnYsBeIUxDOw69twcUnpR6fobgT+mT0Kh37xRNki8Wt8ygBksiDbfNvxCrir0ArBgOkdTo6SC+CIlcy+o9Jx2xevlStNA+lZpAckmPqBzOQ6TR7V9DBz1Hll/UsUALOltR8VnXpHpyJQY0feMFGVkFt6dNXUGL6iBkSOCFyfny44jWQKNHIWR8+kAACegpa/VZk/RMQKIB1aHDlorxGJxxyxXPHeRDEjLEvI3+lBO6/aBpAf1FiSQTfYfNyfEBjiA8sUHZWx2gP6mWRxIxPCAT5iYYt4kggonQG5Bo7wPULPPz55kRMUR05sBUymJUqE0WuSACbhVBOKBF7PmEasZg4jKx0kBsSIYgAnEgEN2DcFGM9bIZZ3JgpPqGA6stnXzv3gMReWRZpwVGT/UYAQFs/t95fiNAkFg49SRrf1+8hijLpaABGNSJisbuhtH8SCMk9IYHs17wKNLqQB5EIdRBIJAIB5jFBkADiOBQoRYhgF6SUHo6/3FFxA6bZyQ/eQUYk0kvzBqPEZHpIQ34+KEavkrJWIFRXTkyPvIjJB6iT3L8/P4gaDH6Um/jkRD+jTALTqFa5IC83YhFyeWNEeCP5/MImQBxXbXmFay6SXjs9z8+GRAnJ1ooewgCWf1WD7SAVwA+5gGxWIegIRciRiAsiRE9Ggv1AG9EyIYkgHLxUFUsZnYvUIh2ewr3gUUAwHzIGiyCTAuNnl94RWQiF9JAxPpTUALyRCa1cC0jd7D3CDAJJIFBiQarbfvxCIQW7DLagXGnidrQEgPI0fpAoZy8Dn+ISl6sPkagGsrFwC0zcgp7BeAYRQLVLipAHgQDCIDAHiEUCiwb0+IFrrYEiKGAyKcCZNHYgasEhOBexZ7yIDhiuOYE/LsVCAYrfeBrsQB2MgookcQJtaH0hFbIAFe8AKZ5kCzk6rxuBX2JeoRWQ+JBX27feELJ7QDHkLhwDW/pIK978QgAt/eBRQStQAHeQagICAgICAgICAgIEgQiBIUgICUIUgSBIFgZhSAgJQ5gIEIlVIVYRBAQpAHvAhlEqBdwJKpAQIfMAFAQIQAdwoO8qkIneVT2gPxAECBDXEBzAhW4U5lDfvIB9vxKIzAEL+ZQO+/eFATtSBsQAXDAgRIJSqB7uA1AzsqUQFKyfaFUpcQFMqoA7rQ4gTRlDL2H1iCNUIC0uAKgCySVvxKqcoH78wHvuFXIEgF33UIyMgOIUGwy4FAH50IE/uZCEqo0YDIHYB8yhYBeV/aAHkCBNlp+3aFNm8UYAlVoO5BCT1AdMoFFFLy5SCNB+0KGgMjkUoEyIGSGxKJiCGepb32ihkECkydQKaFg+PTAmVDtyJFUmk/oIGb5xIPiUUE9Wn3PaBnkDI3whApTRIJGncoiQaKH1hQkYt3uOhhk6DD1AMkPWoVCcRkhweBKGJAVl+ZBC2nR/aUQAiu/MKoWVj0uw9y8RktPK2wCIVoFYj2QeoEJO8SD5GrhEyHqAPO4UIBDOLBv8QqIM61tQKQSERY+4jgmRNkBHwZQ9RFa4XMBlgAfHK5jV6mRIIIDQ5H8yi9WQGwwL94AYnLB+G5DUeJJOQAGmTKKaxpLbMgyAEUvN7ozSn6UtXQJkEwHuce/wDiWiLp6SAT7/iBSWCmgeOYCsjkwAhQXP8AJgMx1ZsLqHB7ykZIIyBVtvt9YXq5HLeuy3JBlkjoAYIpj8SgkCOodKruNKN1R/1CTkjfZe7l8Ah5IDLBarfyoEoHpJDfb53gayxeAHUWEPPdfvGmsjMj+3Z+0YJjWWKBsVdSrqgYg3Z6qGgeIOgKzGR0qR/kQVM2DYYNWOPf7RBnPDInQBsH/kspq9KGYPUT33+0GqMigzfA+fSRcZxIOYyYJfdVKNA5F9WIoEME+mhCJkUU0AWQDuIuM5HMZBgAU7qVTK+nq6QRerHseXCRRiCUcmSePx+ZKqZdOOOP9T1Gkjt+8d8Sa3lkeojHAoaNrxAziMQcvUiCf+RRcgQ03kbqpBo5dONtH/6B5jNRSCcSh9uD9JAJ6icWci9doRHkR05Y45EhMH3/AMS4NjI9ewCdvZ/zImM/p/USRlTaAjqr1AE4gndLY72ZMQrEMJDsYKuWXQ0CQW6jEP6edEIAHzUWDQPViS0lr+ZLAOQ6vSCQ+1CMDCkBiQdCpKBYyZBRMIoxIYFjxuDVA31DoJtB1FqJ6gPV6m1+IFBQoAVvtJgpL/TkX7XcIpDzFVslbkDePUgt3fECW7aRgUeodJIP1Yi+IufVbT/iAAyzDFhVf5kONZAAjlcd5BCcgkx2EqKGAhkWu24FxvDYQ8yJV6kXkAuwFwKCOn0kLerkRB+mggNV7qAJGOQsP2hTEWjo8Hn6QgjiiAvcwNEsEkJaDUiKySXwKgwI6smNjXaREypEkI7PmFWz5HChBnisT34gUgAFkgEaUiCy29+flwKB15a1o4mOJwBAoEp7+e8K2cRlgBfCUiM9WQ7WY8MAFkKFwjQo0GSakAfqZvxAFjWuYgENeoO7HMIqAGQT8uBcTzsyAN+W7EIoZbIP0kFy3YoXAhJYLCr6wingF+wgAAfIkoEgYggcJOBokl0F3hE9LL34gU9u5uQUlCgPzCKbEBspX5kCxTHuYRWjZUAKVN8wK7QB3CHfxwpAJI155hDHI88xRpsWZAZeqfMAHQS4gUgg6/MIIaY9pBf/AOQgNU4FciBvThF/u3AA0xIKjADtAfWEUBhuBqQICAgICAgICAgICBIEIgSFICAlCRQyiQEBAyahSAlCAgIEIlVIUgWEQwpAe0okCc7gWlAnmVSAPmBOO0BAfSAIALhUgLlE+kKblD9oDXECdj+8AGlAh7VCmjbgJQ1UCG78QB87lA3x9YUDFSCeCj3lAa3Cpqv4gNqAdiAN0JRPF/SFC3+8AOD9zAFaddoANQIQhTKlErnSqBWP0wIHt8+8qiAOoVATydQiZe6iKe/9sAyQCFXiA8/jiAIyvzxKvgQvoe8CEnT2YBIvbgCtivKlA07PdQIfIvmFQ8BsIfWBeWQKgZYBtBnvcvVOEUfEAOoBMniA6eUSf5gCnZMBkupdMCYsIvfaBMdkhv2lULrvvUCZI5Al/RxBW8dFi9QIQayW7UqqU3RYVwjJYBJDhQYrEg9tiAW+ysiBUbAQrtqBckEQC9wIbxuyP3iKh7kkHu0/9yiE5bTD7wJeRAYB/aAT6t/QP8Si/pJJAe4VFos43YbUeCY4+npBpElwUyydNXR6YBdOTAJ7cwMkvmz3PEqxWMCgUPECMEglaXvAZMAgtjntKA68iAAEqPMeLxfDHP3hEsZdLBQRY5hUwx9LZT/0f5gTqCOOJLB0/lR+hkiAckDq+Kli6X1A0xWtagXqGROLR8yDKyIsdQ5OhKGQyBYIFWRzA1jrFA1ZHO5Rn+oidEq0RQkhExxr9gCvb9pVpkMQCBaLIJ3E/wBFJADKIIftXmAJL6Vku5HMDOARokEF5Lt38SrV9I/9V495BMBkMRkepC0DS/mUYzWiCT2FSxVGQGJJLTIZ+sYg8jiCCQUV5+seK1z1F9S32+kgnSS/VeR06PmUMgAEwSCDiAOO8ErGQLAdE2R2+fvKrQQ9QR6tjvIGRJRWTZvn/cEZyIxZLeN7qxqUXIlB7G+y0YGCBXToAJ6BMo0Si8sg/Hfn3kVnqOKBRGRSxxKUvRv+niTjQOQNoY1/iSpayMTiOkFglWal1WgikiUhbPH+ZMRUGaNBd5BciRnWIIq+d8QhiCsSWeL3epAxZbBB7k/O8BbAZJ+kBkuodWJIXK+doiKDl0Cg9ixfxwJl1AD+oVwfEH42GMmCdI0zXeRGbROPqLocwNIYg4EtY8Qi9KZTAH1+hkFLsHJBcrf+dwNZEEhAMcvSMiH9pux3OzxAyQOQCQPr9f8AMDSzs0gbB4+VAyjQyKPLH8wNC2SDa0QP9SJxp5BmsidHvCMjpJGhk7GPz2ii4gaZCBK7/wC5ChyOQR6hiTRcqKlkTiByrkVGqNF9vsIGj6To9I7Cu/0kQ6rHUETSIgUsYkG+5f5hAdRKOQxFV2grS96fGpEB6cukE1XvBmmABxJ3fvBqAgvHEaNfaBTxjlvmnxtSIoYOzW/aCqMgSQyOBGCB9wR5O/pA0cTRfihciLjoVYtPcFil9TxxLG7kRAlZBfB181AE4r0oLUCgoMWw9KBWf/66b5kRB0jfBZ8yjT7F+w4mcExCDIBUoZ9iPvERQUDXsFBRZHGwQVUiNDfc9+ZBQAbGz4gCuGeRAlEgPn6wjWjW+XIKbACf1hEyplfX+IF2AQbB3IId0FQECsYhk/WEC8SNln2jo1jqt+TIidKSplQqi6HtCLya8SCsutH8wgBqAAOihAePuXAttrjvIi2gGHxAKnswLzX44kRNCqlFoMbEiKkHx27yC/zUCtilXMBQHbiEOO8B5fvIHZn8wLxxfeRFscwGzdkQgEN1UC7GqgXmv2kE+kIposSDcBAQEBAQEBAQEBAQECGBCIEhSAgJQhQwIoCAgZMKQEoQBgIEIlWEKkCwJAQBFyiQEAdQJKpAQI60YA7gPzAhcKe8obgTz+ZVLgPeAIGw4EOmDAeICFTniUPB+lQBFtaiCOrFwEBxCoT94DQ3AK+0oiLv9oVQia7QIAPvAEe8ohIAX7wKaDgQkcbPeFRPR+0AhzAEcSiMtE1AEbJeoEI6QWu0qqiEC4ENprUCEBUPxCnI/AgUP7d4EGxa8LUCW63KqjFnftCFE78VCpwC4EPY7IepVUXitF8+YRgbH0qFUhhXAuSQeuDEEJOOKBS7QH9rYqFUAC1zKjJbJsfzCq0fYd4EDoln23AHubWxAyiySQL4MqqAzZ96gRaPA5HEAaHSVZUACywg/MARYHSmeOJdGQi3Z/BhTqPT+kEe9Rhi5WkHbBggNoJm7gQor1BP7wq4hgkM0UQXKjJ/SzkcQfO4UTwZJ6e5gVFAAjJBv/MDLIYyKPCl6Kem8scE7dCBMkcX6m1CnSdEEDf1gT+5aJ/EKhJ6gy2WlKgW+myD21CqQSSSB/uBHkjisSU4ENgoP/sqqP0/3dje/lwBeRQx4sjcJxOlY8i0UdwqdIGWPF0jsKA6Vl1ZZWG7uBQRlY9LCsQM4dBGKXkfzKqkAUQXj51IGWRASIttPiWGGRWHUCGRXj55gZ6iX0ggr1EXcuCHDqe64NI6jV4Y9IKRK2K/j6wKQiLHS+y9oNQYnEmicTaCIv39oGSBbDYrURVIOOJIJIO1dfbXmUD045AME9XeDqZEZdLyBCAJMAGWgQSSbNxVX1MEHq5AZ0qhEAIJGjj9bhd1nHMPAk5D21/yXBVkSgTpv58uTVAMDmSSMTvyOfpqX1D05ZHIs8En279pfTgMSsSAQdfiRWTYARyrdIH/ADLBcF/41kOkk8DT5cUrOI9WJyYyJCcv8AgZ4jEj0mhew9/SFa/qEHEMdWJrzJETMj/xmyhfH7wv1a6P1M2QLhPrWKAK72HzuEZs9WXNo4lwqs4pJAIVwef2kQwDIK6iP7Wj94WtB9TXVnjDKAbOWTFGnqFXEesgknpB6g+PgkSnnYp9/vApyGKAO8lUmCY5W2BaKEuDeQJyxGSL2KocftIyziQyF7EyKdX9Q4ghGqK/iVGi2FX9wexQhIuDJWJT7ceJFqPHIBs4vt+8ewawRGVDWtXpL7yJUePT1HX/AMwKADg1TXSrgVACsisQwcglCIDeQJ6j3D/iBvI5EE9IDvliREyR/ph48rfmPooxLDSX9vLkEGQyyTfkFxwVZDIfqs6hBFqiDySl9IGrsg38/Egnq/S7TsfPEIt5UAztdoUxsaFMb+eZExWcqeKAu05RTigiLBUiBxAyD70uINFjiWTpnm5Brq7vDiExMcgBiwRwjowKUCqoVcBlkcaVPgqSC5EHGj6iPqP8QiHIlsADkuMF9JJZA9y7kAEA6DHcwNGjzvXaGUHpLBF//S+cQKtrt+8gUMXiSj9JRSsSEttqRAFrZC7QKGQqD7eZAA0R73xUCgFkdtESImJsFE95cGk7423JooOJJf1X5hAEE65jArpBqQA+BxZcDWJpZbfeETEXjV9xxAC+y/YSDTYCD8QgSOkgOrTgaXp0eeJEGB4gQWCd9oFd741ILjx/OoAFaI8GEAt7agUAPWu8gDXj8GEVigO8gYlpk7lRo7DL7yCA+EO8ULOjcIu/bftAos8+ZAB5R/xAuPP8whwyHAo/S/xIGu4rvCA5AD95BSTyu8BsaEIo3sGABBMArHnzIL54hG5AgICAgICAgICAgICAgQwIRAkKQEBKpIEokBAQMmFICUICAgQyqQIoCFLgPeBDypQgOYEgOZVIBQJAauApQJY9pVQa8Qq+IElDmA3UCGtwD8wCRNwHY04VHKKe0gh5Mogo1+0Bw+IEFDnzKoSxu4DncAbkUo20JRD7CBN2/wAyge5cAvnaA8X9IUI3vfECELKBWCHvxAhGSYoe8oluALWilAZDwBLqwA1TGtQH6RafvAmVY9mFAA89/EKyCFoIL3lF4CcglWSCPfmVQGqDHiBSLTKPbiBEXUBlphp6PMol0Xq71AgA6la4eoVdewu4ESFhuBaOv20IEJesVKoP/XXkQIRQv81AgN0UZQALrL/MAaIDJChUstAhiz3gGF34EAvWANfzHwZHH3cqtEklA9g4xE1se8KIjXfvAAlrfk9oDucSYEaxWu648wqF4l7tmUAD/r58qBCVXUN/WFV9RK7dnCBWORIGqqBAyV1ZF0zKo0gX3I4gOoNYvwfEYJ0Yh9IYpEQKEsXmSQfn7wICSqqqgXJhaRqoIybByRKLCMqgfUSBs7rUB5BAXHPw3Cs4oY9IAOmNm5UV9eJZyBNf7ji8Rg5mzW9n5qANi7+mhIqsZHqIyN2AP8yp8TIsgm2KFRFjKC6iVrYOpRTZPot6b8wL0gHqLDbJP2EaM69OQH3hTLEWTiDZ8cxqJmhmRu3XaX4sqgsHJE5d+51CYz0jIfqwBHG/+RxVRxOQOVmyCYDLHJdQxBYdSkpk8mCcT0rEgDfeAFdJBQQF9pAPoxsg1VOX6vWcwR/T/wD5DpKv5qWdFBKvqGsik18qQYxyPTWqOIW/rzKuK3jiMQEd3xGA99WPTXB+LiAJIAyAD+x+8RRYmt4kXpD8wBB6yilt9vaAztZYhEk9ICP1/wCyxPxkA4ls4q2Df2haYgD+oaQPIv8AH0j4NavHhFD+IGV0nWJ6kEfzC9U5dRXqDZsgc6hEyOWRGJxxxPI5gUb6Dp+37R+gRgQ0ARzz9YExJyJB6gR2uu3iMFGDqwHojXP8xaioA49OLxX2mRSMjieAqL2Y8AZHpCFNB8RnooD/AKtVilXHmPiM4pBaFxRoknJXiGBcSIr6RZAANv2k6CAJDxBd904Gh1AnEUG9d5E/TYOWL+8BfSECRbXPmAyBxNPb5v6QLiMnsktLj5/iRNQkaZLOgIG7yyJtrenBxMj05ZEccQGIdLIDVlsSIrGJxCZI29x0V9RWONHRI4kQ9AfSlw6gUdPTjWROJThAdZRSFVx7wqksh5Me+vMIh/Tll04kvmoGgCyaAJ7nUgu7tigIRMSAABV6VH7wFZYkZDdbgMcsSWvT9n8UYlaL5f1mRRkGCR6mtpwlQkEsFkhJwuA6UW2LIomErVtAYt0oQoLIpFnu4FDCaI45cijB7GyncVDJDNANl9vpA1iSjV9zIiDpIZyL8CoFARq+aFGKKQSGCGQ5ED2JNFB/mBaBBaWwIQ/SCma+0gmdYp2aPz5uWDViiOxTkRAckN9wOBAoLGOvNQK99SPEgepN+PigWjfHLhCiW9QNEsA88cKRES3xdbhVH6mgvARhFeyP8SA0kRZAhFDNrd94QJJKOSkUG1sQi0Qu0gg8ru3KKMbehz2gGAaQ95EaTFpcQI/pcg1vJnSRhEHwGBT5oNQi6D7eIUrQJkRUe9e8IcGlIFqrECmjVcwKl/mEQ+xga5v8mQDskDUBivG1Ig0gBA1Z8D9oQYdV4gUaFSAHuBuRCAgICAgICAgICAgICAgSBCIEhSAgJVIAwJAQJAhhSAlCAgIEUqpCrCEKkBAhEoagIA34gSVSAgSA4gDAlwopVPaETvKprmA51An0gPYwECGoU4swHtKAgQN65gPbcoeNGRdQLQlBsqRRaLO5URWncKEMnkGtwLq/MDJDCL7VKB4uAOuXAAMuFNMfmBAALHMoZd+eeYEaH6jAZb7PtAJyqQpb9T/iEDdq9QqKguPxAUqHCMDJ0+8qhLx4W+9wBr2gCCCQ/vAAI2NCpRGy34IhQvjjvuAGmNkihAG7YbY+fNwHb6/vAhFvLjmVSwASh5+kCHRIIJJ+8BWwq7GBQSR4OoEAJrkcOUCMukhcaEGsi7Gk19YVSwGLf47wJkF4gCOoF0u0cE36T9Hcqn/0gbUH4tjHZJ4K4gRgE2Ee0AAV0u+IELo2eN+0KAm/VfV7QBXKH1sGIJeWIy1wLoygeWN7gRgFA5Hm+IUsm8RRqUA+k/8APeAOIyNBc81BxMiQuB55gTPI4Ai/PaMOqsQtrRECHqJFAEnXEqxcMjspKvn2jCoOoZlEUfbmDrJRBBIob7eZVUkF4le+xAYnEjpQ6e5HzvBiN5Kt8wIcRWR/UT3SIjQ6cepfRg/T7xopxeR6VewuJV3/AE1YZZ44EggDxDRDQtMSiZBDEeoIaJ1zBFyAx2EVvXzvAg2zwXcCmniSEWjyYGF/aAWf7fEqhKATGmih+/aArHB+qu54+0B/UI6wCDk7BB+jlWKAwzTDe/8AsgWwU3Z2GI4IR052sl5ZfkS6dCT3ZyKH+oxTpGWIDt99jmJ/qWnAQAGtb+OFYP6Qdu/rSMqtPI4BNEUMRZMfUZyIZ5GyjyB2iKhxGJyGg+JdGwOk2A+muVxrUidYJsZF7Xg99yqh6gCqOI0e0L41SHJJD4hEyAPNksVr5UCg0ADRrlbEaYmWPT6iGBYNM18uU1WMcMScwAt471+eZBneB6TbbPb7R9ONDLA4t4rHQ6YyihpFgZf2k388SImGINHpY5VE/tA0RmiOoH0haA94NQEZevXpZfvCXxrL9DwPpyP4kPoUTtlhI+YFXWCMkVx/iOImLPp4OgPzCjTRAyBS0RJifjWNY9APkWH3goSBndk8L9ozxFxCHS12/wA/P+QCGknq+df4gAQiMsmskySfnEUaIosEvYX8yCMZYDLI4gmgeY4jRY6nzvzCMsArHEjk24Vr1WyBZRX7yIoxy6T5357wVSBkf0+SEJE4hYI8aAuPAz6sAViTySOfpKkWgq8J1Ip6siGQ2iRxCcXAnEkkkU9a+VIdLGb6tZU/nvANjIF0PqBCL1bxOu4G4MUZHsRiZDEGXrANXGCgDoB7nfz5UIqDsVomQUhnZHg6hFde5e4ABb78/wAwiECghqwLHeBrIoIohbkAeaW4ough+k0EOZEQdgL5LoQGRYGj57yjQHpYxZFiQoS8gg35+kiKK3VcbfiA7E+9qQARjkwQV9x9ZUXsHuQX0kDEkd75hKtkDfaQZ4CFr/ko1eWIbNJNKQQ5BsXApTK94RoeknWvtInU5BV/vAexRFhQrXA7vmRFIfe+e0ACEO3f6wlipAkaT3AV0gWVwOKkRD+ntbuFaBJD9XgKMQH0viQMVydcwipgrJ1uAB51UClIHTkCn3+kIovcChkoglwhaO24ChXeQVo63CA7ccSCni0YAEaXPaBeOS/sYBhWb/aEXTkEaOgO8C+59pEUa3AuyfzcIHiAyY1A6TKEBAQEBAQEBAQEBAQEBAQJAhECQpAQEqkCGAgIEUCGFICUICAgQiVUgICAhTiBMtSicwKNqAgSVQuANwJAQBA5gQyqh1uFUwJKGxAXAho0dwHZwBv/AJAh15iKDQI7yhIIRzKFfeAXcQB8DiVU/ugC6CgESO0Ccn+IUfC+0ByjAhe5QNje4VSib/FwiF+/aFNCzergQBiUCaoQJpMD3gDqBMtc/wCpVgUzCrzi9+IRk7B7Qqg1AaQPtAmjtI61KMlInlwqkJioD355gFaN+O0CI3zXMoZLqXECMvtW1Ci0NLdwKT6bWuTAgWjjZ1Kon7eJICFjhcgSiWTwTAHsl7QGnX5gZy/SVKpnQQ1+0QQgsqu0Cj9YBrvAEoghV7QBVl4o+LlGcsTsEb32iKvOrHPMCCu541AD1Mp9kfnmAIGJRDNnv9ZVOooCxXEgmeOKBsf8lgZElEcrcAmOzG4AHqw9QIuFRZAhZG/uZYIx1HpJeXmXBp/pBHqFvmRGSds5LTfwQrOb6FTdf9iK0CBjiRV2FcIZDZIJabNywRFMAkHudQpiWD6SXyIEoEDK2kjCjYeKNfbtL/RNf1CxXwQKQa6SENAGv294DpJxRyqPpTZIRLsH+VAySciGAQ00pVVkZkFk/vIJkCiWGOx17/aUCAQAz6ilBqnfUQx4r9+IE6cgNoGw6+vj3lNjJIA6f7tFW4UxxxALpC2YLQ5HpxR6Xdc9oFvFdnRVwM5NHIB1t6+XEUzZxCxbv/UoZdLzAx8mQUhHAG3TS+ewl6MZYkkEAlCgRv6yjeOWSWLW6EhWV0gEEENDIaUKHpGRZV+4Pz+JRjJHDIgW2ShQ/wCyn1rIekkEEJdQA+eJCIKxDPUDyrhVCGVbV+KgZWzjkAgieBXwyi55f/kINjs7CcYTieun1DEhPX4hQIlMLGjyPxAZH0FlAC0G/EfQxyyxFgPIh5do6mCGaLYLoGOKt4nIAZAACmdcftDIP0vqC7nTe/3hVzGVjIA6a/JkSAO+kAq0BXy/xBUyOXSaI5+fn8QL/VLBAXtuIYuWGROWWgQ/3/1GouFf1ACPSBZ+ef2kL+LkSCMsSR23InQ5EB9WaKpSmJlj1DZRO/nypNxWgT+lICwOyMJiYj/1BN96iouB6yTWT9Njla/eKKxj+gAhMEHUgMlYnQHBSgMzgAyAD7yQUspMNHUIvT1Y3eK3BqYlYPMDwaijQxZHT9h895ErLByQC6rLcuDoyscSWAH8MiIx05FPHRR/mBM2cOh882vpEGgaxTb0OZMRSlw6o8wGOPp68QAEX4kPxQTpBbviAFdjq7kFZOmCRzw+I4iX19xx9ZRSLDJ7iiFJxFxxxI37KCqCydEHub/xIiPJrI00stweLiVkhfDcBkGDbXjXtAqoAg3S8SI0/wC79QfPH2gRA31BH6wUY/SA1yIFxAAIISF1IlMiSA29wRpkAWVxepAIy6SQgxCBGRAAA/3AZZXkO0gpKOIbBKsyoJ2ONXUCjIra52pCxdAI0dd4RCQCWOdiAJJBA2b8mBSaKJI1IKKAT9oRRRp6kAoW1W/pCBPrNMDdVAI0Tojvcgos8143ApaRdcJQijqAX3KgABl58SBs5ID6QgPqIGiD3YkAEk0b4hEyaR3uUXIvX/ZDA4tk+8C41ldgVIlU9xXtAeQ2eHCBDrv5hWr+akRFygL3CGJ3xFGn/wCqS7SA2nAE1qBdkfSEWlepABIFwKnIic695RWkOFIg6Ol2gdZlCAgICAgICAgICAgICAgICBIEMKkBAQEqkCEQJAsCGBFCkBKEBAQIZVSBYEhSAgDKMwLAKBJVICBB7wH1gN6gQ7RhSVThQicSqvtAiHaBFcAdKATgRQoeIC14gDqUT8cQC9hAF328wqShjzxALzcKnOleoD94AjYH1gPNyhx4uFRGtqBP7qHvCryWu2oRDweP2lDJo89ogjJCVKBb7BQM8sSqI0O3nmBT4feBFW1CpasIDgwCbelAFDQbFByiLgGFA0jAZFFQM5X6fPEqtK+7O4Qz/aRWQQNEDuJcFL2R9AIAlggZC9uBNaGvEqgd0S04EJ4TA8QL1P3PECArIEBX2gMuSSR4OlKJ08sr2kXVZsEoLXMDNhgsSgdHaVXAEUCCveA3o+YAhtLexKsQBIEr8KBAAATq32gKGKAIW4BPIEBAE78yqHp6kQ/5kEZ2+e/4lCwEQfEBsEN7T/aBQW+miADAyLKQcqmIZGyEfpAHH0rE7FxoDHFvkbuAxx7NjUCEAkWKN3EE9QbYxPEqoSEbDBUCkgAjLbRA5gCCweoskEKFCMsciWuAJU6XlYJyeiL+kHGcP1EZV2QhaIE9IZ+n0gUs5DqHNcwRMcT/AG4kluhRhdTMUgSA9yi/csafiQRj9RQDNalE6QEf7R51LqoC8mEuTwZBTkjkerZ3895RkjJDIPLFELmBcxksgO3PmIMjPIi0iDT/ABC46HqbaVnxCOaZGSVhvn3qVfxroNJEcFfmQ1TiTiwCOWINxnp9J6sV3QfvKJ6gfUQCBSuFAGDkSwRQe4DIn9WOAZARIoXz2liBxxOQGjvtzJPFZwGWmWfLLlUzOWOaxxJ9uI8EzByohgFg6AlONABrFnElk8yaGdhgMeP4gjJz6d9QIB0D9feXP8Fz6w8izkhXVS+fvBEOWNjryxovZ32MpinqDIHTkAxe3IGIyAYQ8tOBOrLqIAFXx/MK0MySMdHkcP45MT9TqsZaD4VRgFdWWRJOR0QX9IGhiCQVl93qRNUEEnqJIodI8+YRkUSCiC0j3dyjR5YFhADfxyCoEDIEg+BZrUBiRlolkNDiRKoIzB9TxbHziL4AQ6QTVtlo/SE/QJGmdgbJgERjeCAviDVrLMaxANDm5DinLpy/Sg6kwSx6i9l1cCtAj0kEqEUZYkZAFAs2Y9FDIyFggD7wiY5Ogu0hWsR6mgUwXxBQgHGiq2eZEUDEGxY7werjiElfFwIwSEbBtc/O8AAf1Mew5gHXNGqQhGiwLxJIKcgqxq2SRIBBGbdlIA/zKyInXPJKLkDAkZZY5M1BVonpANdzXzcgoPqDyBukYFGJpbeydwmpkAaNWfc/P5gAQaHSSRb9oGmRZB54kRPSFlXt2hVZJGWuQe4kQJTNrIwBBAGQ80ZUXIUQCBXeSADkQydi+xMGNmy+rXmRGRwaB8QNdPY1r2kRf1DY93zBw4RT5RUCaN5P2gaAAD5VAyIEnYKYvVX+ZRT0k3qQZxC9P3EUaLOXpXmEDb7NwKCGEgNqRFJJsc/mQQnwyB4lwU07BI/EgEjRxI9uYRosNkBagBYohSCMuihx5gaBZAd94xEfMgtWQG9ESihMUHIihN7P4kE78vxKKTwdkISItEDv2ECgvbvvCARB7GAoL8qQOD9xCLYFrvRkFHqL/aAZcBw/MIrWjzAA1ogGQXuDVVAA+YRcaPbiQKI9oR1mUICAgICAgICAgICAgICAgICBIEMKkBAQEqkghEoQJAQJCkoQEBAQIZVSA5RgWFSAgRSgdwECfiAlUMARAh0oD8wG4Ge4lVYEUKSh7QH7QC2jAgRgHCpAfWBSKgTel9ZROV9YC6e5QaFCRU8mFBT7wh/EqoyDzArBgQjnmBCK4P0lAdJF6/eAIBQW9QqVTFQDJAGoFo6J94GUEKlU3or8wgfcfeAB91KpYFOAAvZLgQi6JL1AcL4IUy2mh7wJtGjAKwQb8SqNGn5uBETQ54gQoEIFGpReKKXeBnYPfUKGwScvfntAFMAr3gUl0dn8QCXBUKhXIIKgRHqeyJRP05EJ4yjSxHHLFSCZAjXAuAKa4fECYo0WPK1KpmL7keYBK9CBkWaYKpSi9NLGvpUgmYRAA7seJYuqtEH7QJllRBJorv7QAHToX5gZDIHNtOoUBOQOKOX1lBMUN3qA6a0L8d+I0CTf5uBk4+mgcVte8ujXqXUBRv3gBj1PpJ1ojmDcAWQSF3cWKzbT2a/1CiG7HY/xCAAA5vxuBcqV1THaWCAnIFE4/SFZ/uQsEMGAWQxDbQDEuqvUSKAZMCMi16nYcAhiCAC39oEPptJeNQp6hlxR5MAwSziV3I5gQY+nqAA8iUCD01nkSDyTUADihllieEO9wejGRGCBr6iP0TrFdWhwJcE9WeIBq78QvF9JKRAXKcCA+lJeO0GHoytoAsqAySPqC8CxCriTshAmwTvtCM6wPSAO4evMqnTiwWnby+sGs+nqQJ9RtnXmUbbwPN72pD6zmB1680PP+YWGOQKWWIpkEcQBGJI6SyaEohPqeOIH/tAyA0BkGTxUqqSHicccaQPK94DLFYnIjLBIe3+oNZxRwyBFtPt8coZdKPUSxWQFdvv/AKgUrqxxsgeGfn+ZFUk2CDeztKEEl6QAGEPm4UsgA4MgUcbhEOPTnwMho5dv+QdUAjInHHqwFSDXpH9rxN0q+KEZyWV4kHpGxH4reXSwV6QUJETAglZA9Ksg68uEumYByYRPBviCNAf3UGKXYR6eMg9VG6CvX+4GukEkNLd/xIh/UHqAC2W/2/aIStoZKyWAhp/eRNZyaRBQNEPypSLj6UP6YAdVfKi/og0LAO2eJFMWukjFGh1VCVoeob/Z/wDYRQF6WyTp8yAT1V6arTK7r7wiLrwYGJGOzifLjitMkAsNNcuRGgMSS3gSOTCXTElgnfK5+CSiAEFXZ7QLuyGLIRtwUHTsDY7g/NwNZHHvuiO8iJiWC3j7HtBQrrQSTvj6Qi9JGIHhG1GqoORxHDK8XCcQsDhgt8QL+kHEAC0ZEMqv6VHRURlRG+0g0Dkw8fYckwnibx2OfEB049J6fr8caLjmgyL4HaMTGmSRjYB25BnqSJBP0QjCxcQcgAS74kFBsYkAeAYTANcfSBQRnZBKuOIpG/1GmvEgYnkoO+7ihwQEzWt/HCKEFwN1cgU9L/23KNA+lA/PElQyfU1r8SEMcvOQW4oHpK4fJgUkkscQIPUrN94RWWFRGwIGiPSSbW0ZEZxfSfJ3CqUNhkVfMIuiOw8yCv2XNwi8tyBatHsdQgkSij3FwGj1BAQNPtbuQQkZaOteYGiWimOIQx8gEdoKFGx91IKLs27hEHnt21A1RPFQhlsBwL6Su5kSodcEOBWiA1AD3/EguL0965gX3cIqkEJ8kf4gBY7rxuBf3UiKOktoVxA6zLJAQEBAQEBAQEBAQEBAQEBAQECQIRCpAQEBKpAEQJAQIYEhSUICAgIEO5VSFWESFIDmBDKHjtAQJ94AyqQECQAgP4hU+koPmAqBBQ/3KqwJ9YEPtUB7piAgRencqnKkDQlDz/MCM+TcAWkAApQKT1IqcM75lCjAHV7hUuj+IB0oBE47LlETrzAOwf4lAgGlIoEIE/usagN61uBEgQB9VKDopaUAGW67GFCQKPeUESe4gF+qhAyiAoVWbgZ0dbEAmg0hxKBQJxRbhV0kNQIrJHP7wBNEbHPMommiIUIDBI6oExbRDPdqBqia7wFJEFnlwIOzgRjqTZJ5lVCaFkY+8BjTd9nAiGLDCHECnQx7faBB+oJEEMSiNVoe0KHqxHSWSICmAFYcDIbsbO3uVVJH13Igj2I7EupdUBJQNIjzAFC77VxAgRb+5gTYYOtOFbIJ1iADz5hGMmAcufI19ZYoEyelV5ECYHpxACZ4AijSdkptsagZy6QSzwi5VC7KHSfPy4EJPq9Ty7iCNCirNGlAwcQP6Y/UCvv4lBYnPpJ1ZXEhp/b0gEkviVTRBPT1Hb7QISQdMkvcCZFjpGePpuhqWDRLxseEIXE//wBbPqyV+Y+iekh+WPHy4AlAijltj58cAs2MgT1B86/xB4hoJ+CVCoMH/T3YpgqXfQA6vTyCWQvzAmWRYzLBHlywaNvHpA7AyCjpBYFvQdOBg+n+odFP/cp1AQQMv0ja8wqgEYHpB6Tog7+IwdMsisurI4khEGCYzeL6yMcbXivn3l6qnIYkBEnqAfz7R0xSPV+rdIlOQBjl058vxXmXRghDpBNDb1CqSQMiya5NdoRD6bpENw0IZZdGR1jvWpUXN4k49OzviAyBogAAduJCIAepjsme/f8AEoErWihVMxBjIgMAqqfH0+cyq0NggDIBXlcCY/qGBOJ3eW/Mfo0QCSTike3zx4gWkjhiQafz3gZxRIdoKxVQIMv/AMpwAyZy3GeaISD0kkKq5cYrWBAByDI4O1/2KikYY5HlAEAD54kPaqKxCrGiR7dpEMSOvHIGjYY0d/xLgWGCD0+AEDIJeDwBB2i9/wDJUaYa1RZN/eTBMBk66SHRUFUkIsAn9pBUgQQAzwmIRcG+k6B/tEFXKyfT1GgXx5kSGJABYWjBUAWJN4qhA6nqyvqCOu7kTxzJPRkQXxtj45RoZN9WISdrvIGJIAXU+aEDQHckbauRKhOIOXpLSyAuAy2SSNWPECFAZB5HjqPz3gdMSysbYq5EQ4g/0wOi+FLvqFf+Q42Rjvj7SYugZxWIY7uEXEkDFFnuBIFisVZfMAS66s0Hwn8uOI2CcsAV1aX+pExlL+mgGQNnmX6pjkDj+fbn57yZUxokgHEM+TUCLkZAG7akFJWIDK7vcC44g4HGiR33GpQeoDE2AXZjghY9RCI7bgdGST/HEiAyxddL0ZMMC8cyjp8Sp1GwMiOP+yDSJxQS4Hz2gRsFsnRVgwKQcWciSC4RWdDF2LkMCuqyj95BoUMr/P3lRkhBAV3kFHIG1CKfvX1kAWUWRpmUXNgnSe5BS9sVxqQUWe3EqDftxJghIZTagXEojpQhKuNHpBK+8goLNm/eBRlWwoTAEA3S8wF9RHTTsyIhKRO+0K1jQYCcIc0CaqQXY4IFQgNg2KvxAXZ39YA0wCFA0D4IC4kRACLZRgasggBwh3B+qkFxb7wULhAFbEgd+44EDWwzlAnBW4RoEu+RIINBfdwKF/yECbPeQdplkgICAgICAgICAgICAgICAgICAgSBDCpAQEBKpAhgICBIEhTmAlCAgIEIlVPECwEKkBAhlCA9oD8wJKpAQJUBAOtwIdSqcqBIUlDkwGxAi7OA0YFgY895VUakFMCEcyiLmoAVqBGH4lUXYVAfRQHMKEcQA9v9wJ4APvAhRKMqj/xcAkeb8wB2UIEASBUChpXAhAb1fvKJnaB79ogIrUCEA2Te5VXfJUCb/wBbgEiefDhQDuaUCHe3AZMgefMsEJLv8Qqhp+TAiuzQ5gZNEko/zKqgM0/PiEF6mne+IURtEwIf0jfEClEmubDgiMtgWfEqhRLVDXiQDtAVKC7URAWqePJEDONsH8CALsSqlUgnsmABBpgs7UBusWNIagAUGmOWIDH1EtKBPUH02QVKqtkj6EwMkh8wqkAlsWbhBoAEZQrNdJXPjUoo/UB7gGBBvxyIBEab7uFEOom0deYRE8WS6RJ5lVCBkniQ+8B+kvEboGBp60CIHMj0u2fzKrQfSkR3r+JEMjxjRdcSrAgp8cLcDPpS6gO0ACQAhW912lUGfqB6ase/iDAjnEYga/iBMsq9XFkRAxDJPHkRRSASR6SvtUCB7QvQ194VBZ6cQP5H5lA5A5HqsO+0AWA8Qg19IEGIxvpxId+TKGfV1HhDnzJBEMU8mFzL1dA1sGtuRVpdSQddNOVE/qHTJTv/AHEAjIAl/Qcwup6D3dlwKAMsuUzXaU4yHkCCSR/6tJ/SUWscyQmqPzi5AAxB6smAvqINYJAPpJIs+Pf8alitf1GV1Id2IgmYzxJJsIs+Pr9Y6aY1gCTbJg+g6RlReIFe3EXVZI6HkF9R45l6LjiDk6ABAJevbiNLUrrCIsiybgXos5AAEHQ/Z96g1C8sAens1+YVc2f6heOPUCtbEakniPMoAmxyYXxcsgT1FLd8eRCGRy6gK6R32O/zzBI1RTPSdAivt34qSJT9WIKR7Y+Y4M4E2My3UVVBNgLXF18/eEDkPTrEbJ7/AC4wX+nkMwBicjiT8+eYsxFyeX6x06onQqQXEnEPFggWG4S/q/02SSSUR2+dpKVlkA9GQCKBfEDYyBokIUz2+KTERvKsXy9wqsdVlElHuYRcj0hHEWeTHRCR0nYZt94Rcf1AIoMN6HEgYrqBYY2IKtALHp1SgAETkRRFPt8UHVA9CsVrZMiAPUhkMWT3ii2MicUidux7wjROQWOVH2kRnp9IKvTjVUEnH973AuRfguiYRSOf1bPSZAQFEEEj/wBe8AyLoUyx/EAM8uoHs4TFyJs9SvUgHJAOzsDvCLgiWCQ794o0SCSkhyRIiBkbHsdCFAzl06Gl2/EIHK+o3iDsxgt/n8SC/oSIHhbhDLbJA7IuQEMdAx0MRW6gaJoZZXdcQhkQSOUeDIBSbDTEIoI0R3+8ACGzV8wgN3+dQNMA1T1WpAYxsjY1CVCQ6B5gaLoF+ZAIRKL/AHgXGgrbtQFdRo+0IH0gkH/UdFxAJZ+tbEiGj2HNQNIF6BkRLIDXG4Vok9SduExAyQu0UU5f3SAW/HbcIrGjAbAe/tIGP3cCjsIB2AeNiMQxL4Q7EwKd+pM9pEXV0CO0C4d+8iVNsCpVaffUiIy+BzIL4IMIpJHaAdLUAE+FCKN22JAOtwKKZgdphggICAgICAgICAgICAgICAgICAgIEgQiFSAgICVSBCICBICBIUgJQgIDcCSqkBAQpAQIQtSgYCBICVSAUCcwKbgZr/kKD4ZQ7wC8wJWpVIDiBDUBtswHECH8wpKL8UghF8faUTlQCpwIdgSqJ7kDXf2lUI3xAl6OzqANNbgE8TUoniAy4r6OFMgaNwECGh2gMu0CEKtyi0hfECEfS9wIa8SqGuPtCnPAGoEIZtpXAFA63AuR3/iBMtkE7pvXiUQWaftCqQiDXECGwW99oEsDnVSgWV6QIBWL2SYUBH08GABeTJUByB9DAgFoohV7Qqnh47gZyDHLdGWUQ0BZFSikDz7KQU4gHtUDmU+PZSq0gBVe0CZ3Zs8CICOi3yBzAepBUO7gAhWn41CoAef7T23KAD/SfeApm/FwKcRkmjxAxTOzyjUqmJCDJAPLgOTonlVAHEd/xAEho67uAP6si9agZRVCzbl1VIqvd94AkWciWBRgP7emzAhoIBeVCiJFps/eENltkvQhdOoF5dRKH0lEC6kS6LgEh1ZEA/vGjJQyAPaz2+8qqElkQl9pBDj0kUQQUEdSgQ+oGgOxgEMSMTk+umxUCZmljkGQESf5liwA6v6ZC+m+Y3KByGzoiiKPMYH9Rk45eknsohGSARicTjZadA/4lFGSBPBITJ12kwMxl0kh7rp+ahUz6iekgmmQdiWCFDI44hh0NQNek4gEcI1wY9giJA5DZO/Pz6wrOZxAAy9+9f4lI1liSSlkXIJvJnVaF+8oiZOWbQF3+IDJ9VAE9xfMKmeaOQHtsMF/5lwiZIZEf2nlWD4hVD6uohE7JKhPi59IIz6mCQSr5uCf4zRwy9JRILYMqnSh6aYIxs/P+xoZdeSB6bFhR4FEgndkl69+0GnVibQINrVe8BvJ5DIUh3/3B/EBvFFDm9+QYOqARkjYIYC/EGtEZDpCD5RftIMZgIjKmU2j/vtLAOgEWBYFka/1A2ekY0/vQ/iQXIYtkqtj7yI59TyYfV4VkG7lHTIAhLyVwPn8yImYKJDJPPaINHEhDIAkGux+sCIrFEANhC5BQQNu6JHxwLiDy6y9L54hADHMUShsmE4rD5AND2kGiqGRT9NwMGifT9cv4hTE4gYnIU9W4qNf+2ztnL3+nmEX0tF3ae/MgoyRKxHTzveoxEOQGWd3xqv8xgIkDFhnfcyDSOVYur8wiaBeJLFfPrINVjifSAO51AH9O67/AMwAYF5WzfY7EI0LI31FhtSYIDjZRBW4FFf1Om9HdFQigLEEkkiqHztAhrIVSv8A1AooWyEzUgaNgN7cB6SciSCtfaEUdIQDIJWW4Rc9dAYYHBkIuIPRk6Nsa1cIhy72CNfPeMVciXjZftIikA9J0Sf/AF5gMT25IpQGQY4N1akFybXC5NfeEUtlBDzqBQWOk4nVyIUtsA3AhyFDd8RhjWQPdXzCAbZa7akAL9RRQ+8Cln9JfnXMIZE3Xg/5ggSnR6Tx3kFIIIOQA8rcClCw+GIC+k155hFOPgDq1UB6iQ8pBRRsdyYQGXPe7FSCjd/vAAjJdvwY4iii3vzAppWPMiJlq9NQHGn3gUkJ15Mg0SD5riEYd19LlVsoj8yIhFFbO4GtUxUiB0CT9IFdeJAAXHNSooRD0JAJVkbhFYp+0gl2UoFBQDH0UBp8CEappSCO/HYwO8wwQEBAQEBAQEBAQEBAQEBAQEBAQEBAhgQwqQEBASqSCEShAQJAkKShAQEBAyXKpxAvECQpAQIalDmBOIFIgSVQQBECXxAe8BkBCsnxKLCoU4CUX2gS4EP3gD2MBxCpzpyij7SCIagQhFyi72ReoEN9oBbhUO1blCkzAnP+YUKpoHiAH0uAIEolsOAN6IClAjkWBIpzv7QFkr/sCMH/ACpQFkQJfFfWAQIPMaoSk68iUQ0bqBaS7wM658QqCy1vcDWQI2oA+o6qBlE1/EqqG19NQIWT4EBdLcCEvlPvKJ0mhY7+IVb4sd3AALX3TgBd7HFwHUDkb8MQrOV1R95QAJCpmxdwFEAb5NwAeh7agMsdEA+3eU1k8I0RuRVJ6bP6d3KBZyRZsjcDJ1Vo+ylFPSgdDxID0XcCYlhJMqVTL6IUIEvIgO9vtHBSQMSyxrTuBP6i7HTURTNkIAgn5csAgC/pAjHUQj33v44Eb9RA24GsrLFatRwZvFEZINm5VTwDojZgXIPFI5XxEGf7KxIHcwL/AHUk+dQDFdZAIHeP4CAr3PeVUIsZBk9zzBFCsnI+oN9oRCOr1MoaIErQ6TJbXkQjOQJyI6SGNuIoViH0h9hHRLBSOP8AqFayLDJJK2PnmEQEgoko7rj2MqgA6qZN0hXyoGA6yJJACfz2gXNZFdWQIsedyzwCAD14Zas+ZFU/qGyeyA+34lQ6T+nIrH5zIrHWwiCiOSq9pcGgbByJBCZ/i5D4ycT6gEKZA/34lNaGIAJQxLpgQqZnQLyFkcmIJmVkiSb4jAJxFdJI2RqUZrFY321+fzHVMeokdVHkcID/AJLcNazxIH6uoeNfLkJQvLIAkcsH8wcQghg5EE0Wd8iXRADsk9POToj4oEPVlkSTWJCsn7S6YoZ6ccSHwfnMissZlMg8q0feXggwJ6QX0jd0Y01f/wCJxVE9W4FRBCeIOkACYNT+miX6TYrShavV6j1AruQkO6MYjOQOuopdvnNwNYY5HHoJFgEhVj894FBCA6QKJIITkRASwjRrj52DhWssWjiAD9Krn8QidP6aICaIsSKpyIy6hY2QAz5jqYELP1JEkWaPy5ULyrEPJ2D/AB4kG8jigTi3oAXJgjPpHqcBh1XjkFelod4RrIt8jX6QakTGCASMcsukLer+VKrYKxKGWXH4TuEX+qeUyuTJAyeeOt23qE4pQ4O19ZBCXkXiFVm3BivJHI8EmBonmwEDRFSIyQkmA2g/2jooRrFCxx88QVreNIgckyInqGH6RiHfiBS31PpDskNREARWJ9RXGO/pBWqAoUi1IJXFEGrv5cDXpFkH1C+6hBOy0PKIgGFrdh9oELOSHSvEcGlkMRTPgUpEREEseK8QrVHHTC3IygIB3+YVqmwCDbLUMsgJG9fWVVPTkxkDWrkGiAS8WCBQ7yASOrd1swiqyCa96kExJIsBL3/1KNYm7437yVAplmwPaEa4IJRJ7yCZUkGE12EBkQD3H2gXqrVbL1CIT0kBEcb4gXBkgE34uSo0QOC3IAIJvIcvtGB6dMfT7wAQ2kPvAqvI0h4hAHQaHBkDexX4cCpJpfvCLsUUO2xIL2vfmBcTdm/MIgyLJ2Pf/EYFElPXEDWI2GfMiD06IHvAD3gaytWAdORE5Gh4gHbx+0Cmsn57QgGaFHfvINPVMniQPCuADD6jzKik+T7OREp+rUK0Gih4syIZE/iANi15hF9h4gGX/iQd5hggICAgICAgICAgICAgICAgICAgICAgSBk1CkBAQEqkCGAgSAgSFICUICAgTUqpAQpAQG4EO9SgICA5gQyqfSAI5gQQDgIENcSqQFeIVLlCA/JgSwN1APYgDqBFdwpxxAc3KH0gPA1Amt32EogBHcwoC0DIB/mFEVWuRKiBE7hTjtAcWIEI2V+dSqDtUAQW7cCPhswKmwE/zAzfUXrmUGO/HeBd5KoELXvUCInXHaVTL9NV3hQpswApn9S+sCDVHyoBbs8qBF3/AMyqEhLtsOBR9hzAyEULHkQGCWpaK3g9L9oEoEa2lAp0y/EKit/6gTfY13cCfX3cqqSQKFnzIIwW31ftKIAQbADgaZ5X+YAhnZcDDLXSq95VVtsAgQIMnYo6bgHfbLQZhQXl3tVCJkyAbBO0bMoLLtfIfeF0IxIZD/iAD83xAyfIPaxKqqvHZ7kDI5Aigm+8omsqt/P8wNdQNJ+4gYAyZ7Eagat26O1AyKAAFrcqsoCiSBoAGBp9XULPtAuV4jV/mBkBEIkrmAL6ekH6KBCOkg5Gzpd5V1QSU7KMCAjPJAoH7xwEAQP1E0GBKJhiR+kMiyzFq0w/qMhmlwajDEyonFskmoWKHRGSA2P8QjOPTvIHe0FCqWcQCVz3gMSAP7SdHx4gQj05Pp8jtKCyYLKSBWo0TL+mGwmeXsxpqDjGySFdG/MouIGQywxySoDt9YGMWM3vF2GA/hl1QZYZAnpJCv037uBrH1Zm6HK1IcMh6U9vFE8ywZIeJBOqDr5qIp/VR/pjErFUftE6QFnqRyfgJQLgekZHAM7BSr6yjOPT0DJnGie4j8UGAAJGPcBfPMGocelg8D/1UKEjIdXSGKfBPwfvCKBZOWkDkuRBrOBGQxGWLx76lVf6ZJwAXOvMlKEv+kOsIv6kdhKfR4gjm0gKAgxShgyN9u8h9RB4nqB0LLs/NSms4BlYdrCUVQLHFhjbK2d/WpRcsiiMTiMiVJEwwyrIEPI0S387RTF6SHkSCCFkQNSCk9K6smXQPfiE6qxZx0dn4/n0kEA/qAh4jEHkAe33lPGscjeTBA2NMyJUxyJxsADTA41uWgCyhtpgNSC4kHMnqdok7gMgcsMAUWWhz5cIttPDqH5ezINDT6QTsse38SIBm733qBn1ApHkANnz+JRrpZGmdBfxIGfWwQQhZAC+seIusqCJ77Hy5BrH+o/0njb4jEsZGOTPq/V5+fBGq2OoUinV3IiIgDEVXO4EQKpugBoQNAnIkAEju9SJWuoEYo7FfPpCYgQ6QNVswoT/AGsgnuagCBgnevC+CEaxJofQuQARkeRifzJwVjEg406b1KhhiiggR3jSphkTkKaD1YgoSA/ffAkGgjbsb8whieSCeG7kSqLxA53UC4lUN6NQH/sH6tGtwACskrSJ1ILliHSBW4RGgMRQXOhA0EScCSO3b7SIgB63u6BcumKMij6TpEHtBig+qyRxZuRAgICmeN/WQKRZQ4cC/wBS8QD/ANqCKHtEHuTqRDEmxj9HKGP6bBBXHeSoq9JNAa3AGmC9cmQCWPwDA0KIORdfeEpiSh1D0+YF/ptdpKUfoR7uoRXYIBN78QYp13MgBML9oKCztVzCGhbC8wLkyEGPYSCYlemn37xUxrTJL4MAwNG5BWLB94Q9TvJ+xgAdlk9hAoOSt7hAMsIyCghni4DeONv9oRdf3HwYGg15kRkfTcCgZaUC+XIGX/8ALynCLzX1gd5+bBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAkAYGYUgICAlUgQwEBAhECQpAShAQG4EVyqkBCkBAQIQpQgK9oEUBKpAhqAd8QHEAYVJQ1AQqOUC/rAHVcQJqAG/EAYVDsQBPeA+sogHaNDlSivXMgylalUP5gHsQqHtADu4A1wv5lA6aswJ3DgXY3Ayu78GFUoXYMCbgBoiAyfZSiXT3AEOoEyv2laX8CEQa7wqHQC/xAZEDHnvAG/wBTsQJkgBdP8yxV2bBUBSQ12UCBfzAgsAnvKBIAVRimVWDUAiwlAnf8EQKQxyuFAg2SQFxKqpZWP4kGSiDtEuuZQIsUTAm9Av2UoephgqAAAIDLJ7QodUvaQRrVd6lEQ2AfKhVHAxII8S1AhpC1akC9uublGSUTwH94VTkcS3z2gErLBg1my9kJf6hWu1omBkAAoIdwhKCZrIE8wDvFNkoD4fECZ45kAc+6l8IjQPSgR9YVo0k9wM4C+oChUFDZKVLfEKh/UCMQSj+YFzKNgkGyxCIdA2m+ZVMQwsSvc6gQ+o9K2zKL1aIR9xBiX+oFlWAf3hU/qP8ASgLuqJUQiMjLID31Cmj03fb54hAJdVj6/WFMmPUnx1fOZQJ9PUvUdcKBCR1ZYk+VkefzA0Unq7fz5+YGekqwwdeJVXNdLIZANg6kSMou23bOjKsTC8cq/wD7PXaKfV/qXR6erEt1EA45AjEj1BCtwSpkNgpAdqJlUyBQOsWx/iQMj1MZHvTuUiAEBgAEmiWHUKlgB8Db/eAzyBwWIJdrb8S/TikIPMEg7H8SQ/jP9QD0oEngAb7n8Sw1r+8dQBN0SJAyIIV7NDQgZxyQLH+zxuVQCurIaLS8wJlkQOkAldhS/iXNDI/3Ykh9v2iCkHqAOaQUKmQZNNmnsfj3gD0miAQR+km4DAkE5HKtgdh8EFaKxzDRVWoTqZYlM4FEtEfNwRUOpAY1sEyCfqo4omrP2l4h05DIEgfs1/2T4LiAMhisnyX84kFJ6v0kg8jv/uEzF9Wx1eVz8/mA2Ael9+H5uAxOJIxxzrmun5qKNEMAbAx5r/siLojJ2CT7yIwcvVl7ih7b8S4rROWPqBy+9QirpHqxPFAsOQ1AOo0N0Gjx+0DdViyD2HPMiAPqQJq61AIEnf8A9Fb+KBOoPFADIkjhD4oTFywKGJINb35jQJeJAKPCCkGsqxB4BqEMKPWwGgPNyFCbN9OuJRSMmEOORp/8kAnLEhA+z5gEEMhiN6HMIuOIt+hyCkE5gHnZ7QijIodJOMGIRTBZA50IDMlokjsRyVuIAJeW7kFRB6UwYQBxTQfj/EguTA78XCNeo4d8jZ8QISBlkEq41A0Mgcfrx8+fiREAWiL4diBo/pVH6SDJQNkdi+fMov8ATLwOkZErWRP6eo+FzAAGgCCBJUUgtXQqBDp/WoFTdMdl9oQDGKoPTEKKuCB4hFyJOIQXMiYulontIGVoAM6Fy4NA2688yC7/ALb5kRMSbrx9ZRcQU0zuQMurSP1hA2iAbPB5kFOIdtagLa78QL2NWNcQgKJNs+IGmiCDX3kRDQdb7wNc7oSCC0KD7SgQQQSR9ZBaGQxQhF33qAIvz7wALALH33JiKDf91bcCm1/MiLQ9xcDJLJMCkKwIRoV2JkEF8gOBrfcwjvPzYICAgICAgICAgICAgICAgICAgICAgICBICBmFICAgJVIEUBAQIRAkKQEoQEAbgSVUgIUMBzAGBD+JQ42oBKAPiCJKoYEMB7wGoDniFQLiUPbcCc/KhQmUEIBEwJrmAOoDf0gN/T8wqDQ0oA+0ocwJxKCooQqe9wHPb3gU8VIMkVKomSOHAovX0gTIDcohqy1AcUS4AfiFCAmf5lAdgKkEK5gLtX5lDYcCG6BMKlgUOJQPmwOYU7gwCrXtAgJKYr/AHAoHqH+bgQA8iVV0WRsyCclqUMtf6giZN1XfzKHASo7cgEX5PeFQ9QyfIv7SifX2Y/mAPDxT5lClb+sKMkWSbgZbLCXJe4AcXAuZBYL94ImRsEizzAmRGOi5VCcgWue8B0+lnqXizAK+GdqBctoH7wRkOzkOPtKJkmhTN9yIU6gSAPtGCgq8tc3UCGiw6vl9pQ1lZSPaRVx9RYxIYhEJpCVUIDJQAdv+IFORYAW0twBAVgjyIGQCj6vT2Ny6rJIoM0+IGsl00XWlcEPUW+oAa8qAxPUda/SBAmNrK/LHtcCZkkpjvfP+5VjRvMbY8wMpYI8fQxvohBVIdnzKugCqz7iBMfIS7MiBrIEAIhA2fnmQYrpBQ2/8yq0MXkSdDk8QIC8tphY/wC4KZAFlO7Iu5SMn0+oYun0g+3+Y6CxIKrKxZ45jQwTJDK+4VCWhkMQPUGh2B/Dg9B+pABBEKRQ8MEp63KJYBAIA80TAp1+ojJ97/zAwSMtPEEcnjtKqnr6KKCSBgMigTfSO4+d5ASeJB3xXz/cotnG0zwYGMepgr7e/wDuWq0AMcgfSAN/9kE/pgiicfbFfmKN+rHJ8krcDAYyKPlwq5E9NOto+fn3lSM/1rIPVQO9sxCBHpHSgAR3f0hUYYHUjs2+3+pcEyxyGRIyvH1Hz2g06SBYzGI09ftBvvgcsx04kCywtiUweOARAGkAdfHHRPB2cmj39pAxyORCQAGuncuDWI/R47BL95kX+peRxOJITBJZ1qEiZZerH0gkksjdfBGeKf1chiD0nLyD8qIkn+rl1g9axYP1P+I8RRjiMWcQUf0ggIwLyuoknfn6yC5nE5VQZv6yYQwGfqJRpEC/pcVKmRGRAAQBaHaBf/J1HHg8dn3/AGjDFBH9M9RX2sx1CgaHDAq/MDVg/wBxD41IL/TPWQSMQ/PMlicOqgNXRUBvMlKywm4A5EkLLRSGhCY0SAPUAe0gmOIZIJZpCBDkKrJWr3A3kR0oMFa4VVIgAUTkB0/23vxBpiTlkWL/ALQeO8IYlI2Cu9qKLk2rXs/oZBWOr+0L8QUH6el9XC3wo+pgmCGtIC1AoHSEKB8/PECY0XkAVpD/ADA2SKHUEDqRGWekP3+OBoJnJhfxIALy9TDoeISqfUHiAb3zCJk8T1AA5J3Xb/MKrxII/SnfiRDEgN12B/iBo0KDrvf7Qgz1llcgEKRVJIQQKOnCIWHaA4garpRkGSeo2F7fPMouQeLJ4kRXyPs9yBokEDcI0KBLR5MImLokiKNMAgtD2kDDV5OKNO0CG5BBshyi5duf9yJDNUe2lAZEKyvEIrDH8RgHHkE1bHPaQUBcD6GAZoMG/tCDXDcCh6tuEQEkuwrAkFCpn3kFO0EoAksD7yhmVwoRb2MnILoMonzqQVDUIEs+OVAoCBL/AIcIFkj7wDLDB7SA1Y+kIrsrfEgvLF/WB+ifm/MgICAgICAgICAgICAgICAgICAgICAgICAgQwMmFICAgJVIEgICBDBEhSAlCAgCIVmUIUgICAgQyhAQJxUqkBAhgIFECGjCp/EqhhAgDmFSUIAiBB9zAM09QAgQbhV5gTzKJo3APmUCipBJVID9oU1towJv+IAID+IAyiLvCg3cIpF6twsQ7YUBybUAUSWGXAyXRVqUMiBx94A3Sr7QqEFBW5QJ5bgB+m7gL6TX17QpRJCKgTWO2e6gCwXuVTnft5gLs1AhFb5gQAlt/eUQ2Sl3gWgNguFCSuXIJ22PJ3KIeKavURVI9RIeXZSgAdrUgydkuvxKAb3f3gVWy32184lEIGR03qA8HfMiobC7EA/O8ou33ECZU2AGTKQLXZe4kE5BS47SqFbQHaBECue1wALZ7agXEAMNLzAhrOuC0tQqMFq0WB/qUXL9S0/v3giZdIY0R25gLJasa8wFlGwT2MCECigl+faVTFI40T5goeqsiul6/lQMjLFB0rMYpiGS7A5MDTBNlO4RnIAWQdXW5VMcTijR5inUJC6tagUmsScSBxW4VBaJDC39pRBZ6lZ0x+YDe7rX1gAhZGJBgKy5Lb3o8QAPSNF8cJVKqZXkNLyfnxQIAF0m2N83CiAzsDJWjERoggloMm3rzBGc/UX1eryNBS6TxKOWXUS9uFUEMhNls6MCWccbDS7iPBP6hIvHHjgPs4iqSSVSISMAcSBicWyUXX08SohILOyKsc/FIqYgjC2e7B+s0KicDiVdGTVGMsyDjj3ROv8AcqcZoYLA5Ejv89o6oleKLruvniABw6yyi619jAIlnqBegrgBiCAGdhc0vxAgw6ietE/t8UuqiyzyQYVhY6PiU8ijLHEAA0TJmrhl1dJo+7/mSIyQekHo6Qd2S/rKsMniHiSAL/aBpPL0WysWVCX9MAcrGQK/I9o4Ws8nK/NA37e0ouP6kCjvSXDkGjiB6sgTkrJ181Un4H6yWF//AC4+f4hOAWHpp9+8nRSyEf7SA+4+c+8qL/7G2ORxIGRT/wDplDa1UEMgTgWqYsBD94AHIrIqwgdyWC9TTKyP1IUYigNIJe9VIGJbNjX7youJxxJxJRpfevniT0Uh/wBQkAlbISgQZPqIF7AMYjWV5JEh6GhIBIJXSciNEfSAsnYJGi4FNoZIsLciLkfU2AUjSPy4E/pkAHEEhXYi/wCpVWTGe+4TJEeBjkgAcTV1zBYYC8uAHJStDIAvJo8iEDwUyB33ILiDiAQa3fmKIcvT1eQPrA0MsiBkqBVFwiY90Er8SADoko5av5couJbOyNvQv/UnEXE8ggvx+ZKdHiaPv/uEGhQBJdmBSQwaxHtAAIdKpaPmBcaz9PGpErWidWyx+8BkHvqHH/JBKeXUCabMDQJ6iAFy+YRMbGKNrYgMjl/aeOCogpPqvJOpBSB0gggXbO4QJ+haF8wGNBciKjXBxfgjmQXEk5E9/EJZiUB0gIg8mBfajoyAMg+bNQKAyQCWeISixC4d/iBcRtny5KHSTksn94TQZIaKNyYLkK4+sBaBKXiAIeuIRoImkH3hALfUkacgWC0e24BMq5BaAde8Ci91AarxGIeHo/iEX/2H7yASNNk2oFtGzVQF7cCvi2e0ICw6AkAaJIhGn3BvRkH6J+b8yAgICAgICAgICAgICAgICAgICAgICAgICAgZgSFICAlCFIEgICBCIElUkCUICBJQhUgICFICBDuUT8wLAnEoQp9IBQJvUC+0DKuFPlyhTgQQoZQgFuBH9IDmARuBNyqe8gbriBCBrgXKA7fvAHxCpzyZQAR9zABakVCF7ygfZSgd64kETINCpRfb6wJaexqBN394Va8fQwIP1Pf0lFAAO+JBm3r6Shsj+IDfD+sCBk22+JWlOibhEAJJMKAVVngwIdlP9oAey5uA6Q795dVfIBB1AzvKiQvEAjde/iAZGQRfbzKIUwCOYFPAGiFAyzoa7QqkrjcCAUSGCIEGJsa/EqqXZAAECBVRfmBLOH919pfolshbgUgsc83Ag2eol69oVT+ogc7gZI7Gx3gPUziqOxCqSEANyoADqG3xqBD1AeDsvxCqRAyR1Lj3EDRNdIQBHfcDKWRfPA7Qqkp8PXMCAjr49gJRMaJYThUyaXjiEKytMm3KCWRYRO7hVBJssAlVYjBH6nVfiAAIJHVwo0ZTCJQdOFWw2ite8A2SERiVKIQCeysVswGJVCuSIELNIX3+e8qpzS8P34+kBTLIDyRANQGK6kuaVQocVRB8eY1AgkjXUGK4+OUQg9aOPC7x8VNkZZZcL594ON0f0npAMh/WUtZeFz3/AGlEZJBJNXkOxlAnEqxl2CTdR7BMQes5AZF1Z2PrH4q4jEf1B0B0iBcH9QsZP0Xt6/5B8RMg5AEC1ob4g0FoAYo6GQXzUogBBeQB9VHKoVSABQvdJ/NRogHqORzDuz/2UB+j0npdg5GT6GeJyyJGCdg7/aVZ4YnIgGgO7dyCjHFhgLhcKUG76QMrDEgx+rMsZIefEqrZbX/1exCIX1YkHIvRJOvMpAm/0+l93XwQocgek10pdiD9fooxEWWTVLhfAIVcusXiLOyAoJiAMZAekoCj+IVMMccnicgQLFse8t8RvLqyLJG2B9L19JDiYG8QMfUexcWDKf8ATsDuQ0o+irLr7g/iv9SDSNDEgAiBAscvUDY348QnWz6s/pZ7iv8AEiMnG3YIpkeZVaAzJI457SIZE6IRRZI9/wDUDWP6tX36tSVEsYAg49N9SHjX4lG6yoHq8CZ4n9Z6Tkhl1YgdjqXRsnLIAGsSKQOlInjKWfds9nC/Gjlttn/17fLkQGX/AOQEkk8EBAmMPhgUydHzAmQPSgyOkQKNXiO9iEqgeo2Ce48yUUErqyDZ4qvaEOpZom5BcAPUAeFTr6/NxqVAAaJp1Crj1BpngLT/AOQVX6i6DDEiKxlk7rRCgAUiT9Qe3/IBkqwHr7RiD9ZRA/7AEAZMizkiVA0C8rBs0xIgkFwdIyAXkQDk8joyopeOToBLxICt5MoK4GjewcVlIiDp4N6X53KAovtvzINPkDJ+RUiJiFkcgsT5Kl/BoEdTxqvvIF9X6rPjcHxQCS9rb94ROqx6uknTuDFxBDPne1IVf7avmEQdLLJBuBR+lfpf4kFIORNAe3EIYmgyFuoGgRR2DJiDdUT3hU/u9QAHvA0N7vfvCAGiAv4EiDLBCUCs064REAiWZBcupb/MAEWCQ6hFAFvXEVA2bLO5Axy0B0+4jBAjjZHmo+iogt+7gaWuB7cyAHiV07D9xKi/3L4ZkF4IgAGdioRXwT9jAvOh9pED3ZrdSi0bEygA079pR+mfk/MgICAgICAgICAgICAgICAgICAgICAgICAgIEgIGYUgICAlUgQiAgIEIgSFICUICAgZ+srR7QhAQpAGBJQ04CBDCkoCBIDhwBcAYVP3lDiFPaBPaUB+YDtAz3JowK+YBQpoQIeZQD/zAigJQQkEXJlUGnVQLa+kghotSqHaUCH8QB8rvKJQyuAPMBXj7QoezvxAYggvzKIbNbHeQAxVn6SiFEjivtAbBG4U9g5VZ2VAp0AmqMIW1oDZEKmqSHvAV0hP7wIiDsfWVVKRvxUCDunAB/Q6gBooHxKBDBgRng1yYU9WgTAisnRMAx6tAe0C2L/MKyscSETKIhk0/rzGgaKLHL7Sik12A5kEs8sigu0oZLpbREKAt/vAh9PUXTjon6ubV3CqzZTvj9oRnqGlzqUXGitBHUKAlrFrkmAyypggXqBCMrTK0xCqSCdccQIT6ViATxAiHSQR0gG6coBEFGoBvYIHcwABx2LRZNSiEh4vIc/mFZOicgepOrMorKeILN9nIGOKJ33I7f4imqaAR1pQMkj1PvXmWCYg0k9kPdf6hdaIC0AB3gYQ4+L+Y1Wh0vqFvXD7SolVkS613hQMgBli7H7QnBLEDqaCHiFTMrKgOFV/PaOi5erI4AA46v7Rw36yT/cCTib4OpVQ5I3k1fvGDVDPTGwFUCZ4vhP8+3ziDQHJovq++vEozkiDjslM+PeBcMLBBBxf0hdP76eJHJgMAb6AVky39YKmWIOWIyx42OI+GprHLEZLuTuFVqhQHJKBgYIPWj6R3PMvwUdSABYxK8n6/aAyXVZ9IsqiYDJa9Okh7SrEo4ADELSb+XAdPqOQyONrTfmBSBmCsTkqSvn6eI4IGFmuWDlCpgcgbJD2O1fiE6oZoDG7xZ8VCh9QbZLsmU4z1sBE9K0dnvFiyHQyQOAGDk40Q4nqJIROiKUb4Q63j/UORy6deJTGmlYpBMOQxkjAHHpwp8QgOkjJgYdrQ+XBY1kNvE5AI5EF3ApJIAOrSO/K+0gYMhgnLQxJqotTIZHHook5DtuBRkCS8vS+diEUjoORAJJLQFydUxAyIxI9SWk/iioMsjEglsPcQOo/3YkFj25+faExrDKwCWCDQ/xJhTHqOVDpA+5hFJ6gw+onQEmHER9SK4FuBvqOWVI8kSCE5HFYVxr7R/UW+n1CgeCA4AAEGiOER87wALJeKA2vf58ECj0LEkMAl7PEdQJWWP6iQyPTpyCawyYBp0a+f4gUnLgDq3fEg1iBi2mbNxUCcelDJ/xAA7CJZ9KH5hD+niSkmBtbijR5CQFakEITCIpeYGsSP1AVoPQ+KTEAAAMgEVVIQiY2sbexbco0selD2viQMiXTIPaDGiXlRAw1r6SIhY9QBFa9h5gCektZeIGmv6jAf1hAo2Vasc/HIJi3Vkcg/wAwKUQQBUguHSxkMhuEOUaXIgXEchAGCqd4vRp9/jkRKRFge0DXKHH1kGUWN9PiUaAKA0BxCGW2RQtHtINEnue2oRG0KekoD0tmuAjINbBpe+jABoGhb7yAHibb0ftKnVBOiRicr1IKFkOL+sIyCwDxFitdIB4H03IgRd3AWssjiYRpig/CkBgkICAbBOQ9jCYp8dJH7yAdfxAYjYH2MCldOoRR3tQBonp26uQUWgR94Q5ID7wDIs/eEUG+8FObQ8SI/VPyfmQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAkBAzCkBAQEqkCQEBAhgiQpAShAQIRKqQLAkKQEAoEPmUBrtAQJKpAQJyKgPrAe0CHxCh99yh7QB9oVN3KB3xAkBxqAb+sCKFIAd0JQo9yIAg+IE0FAp/EKy7lDSkCyPaVTVQINKtcQG+AICr37SiB6+0KrR7HzCMnRQEKCiuJQPO5BfA4gRtHtKJl9n3gFzUKjoP8AMqgJXt2hDKw1WoAjfHvCouRsmh2gCnqrgQsaMql6H5gDbK33g4EWO69lKIB0q7A5gXpCAF8QJZvttQpsksj3gKSpOBk6evpqWKYjXt3gVA7S/eBCQCgQe65gR4m2hwZRbGSWuO8ggxsjk2KlAAAAEL+TCnJLNAyBYDyo/mUQEFZD7yhRxRt8yCIbsHyJQI2TkQh3UKjLBCFQCCthcOAdFPFiBKAYJAlVchYDJBsyC5WXYDcojIoJmjAzRWR3+IDIHqCyJogKvaWDLfG+BdSq0TQYANvgmQQGg7OQftAdIxHCPK1AdRxD5hQdQVgHaScIO2Me7ZVy4oRRIyJ/MCZVj0gUf8xAyIOz6e0KwDbWnuUaJQHP+e/iBBiSDf6XqArH0iwIURQ6siQRvmEATkAMj7LmVQlM5YkE8uBMcWTiGQfaDcNFID/+Ijozl1dJ6aZPF/NS+KAEZXi/YcQhsZK1y4VpikEig5BCyiRosDS5lEzBI5AJTGvnMEpj/wCwuuK1Xz2lVnHqGI4VoWPm5AeXSWyAVdP5co1l15DqTQS8L8weQIJBbxL9zAhxd2Myb/8AmF1CD1PpBCPGmIgzn36j4BepYNdJJ6QekP3MCF5E98rHN9/naDiFHZGmzY+nztKAxxwQGVjXNxqhAAxxxYDtjmBP1AZZEE47eifEACMiTQL4LZ+OMFBv9RQJol6gZOORH6SVRGPHtKurhj6gKBALK4+KEtAcWiQQNDV8VJgrPX044nIjvjv/AFcYfAEZX05I0ELk/BQMutMMUC9wAxtElGwTd/HGouPpGL1pDXuZOmAAsgMgFB8wGJ9ABPUV+nG2/MtiNAvHHOxiR9+ZMRBlj0AEBEb/AIhcUJFgg+CDJiGQxsnehyXEDI5EjIlIWx4194/EirFAnEMWEKjRep4JIEcFcScpgQr6SD4OhxAek5DpILshi5EbKyLXPB3AE6x6uQCYgySABkd9zUC5Y+sD1dgzrtqEAcvq/I8qBWTiA+oi0nIgMkA6JHqJjBqhieklc9xUgnUV6bPiBQ6HWSR9bgxR1FHHEDvz7SIoGJwJDWxxr5+YDKgQEufn0kA5Bh8n9KlRLBugDyPtA11JdJ4kAYvEvhgQjTRIx0JMAYgBWQRqAxLTyb1FRSUwRiXCGGLyrm0TFXcUkuy12kRMgSwCQTxUCjqGVWfeQRhEAgD7SjYyxJQQLVSYi+po/q2oRMvUrBZ4NwAI345kDF0G8t1AaBugaB+fHA0+odQyDFD7QjRCCNe0gEPFEW/VCHqbBrn6yDJRsbP2lGkyjQ8SC72dwgwvC2IFAAoA9gpEU8DX1gQEKzY78wKGbRfgSC47oH2hBEjg9/MC47XYGCgN8viRAEnJB/UwKGbRvhyCMP8AUFxA0AONHtGoClz29oF7oXxIICAEL/AlRoWAV9JAxJSAqBdMKRCkagfqn5PyICAgICAgICAgICAgICAgICAgICAgICAgICAgIEgRQJCkBAQEqkCQEBAhgSFJQgICBCORCpKL9IEgIUgIEUoniBRAkKe8oQJxAQECL3lUakUlRCKhQd5Q5gEH5gTnvAvECK4VIByhx2gSnyYA2VqUDzCpRgBrYkDzKofeBFpcQKdB3AmixKIF3UKDbJ7wBfDgRDsnAl70R5lGiWX9JBnsJRVaH2gQXaX1lVExb7wq48BkQg2ASd9oAE9Je/HMKBhjncDBCA/mA6hyUa1Kqgh2UYEQ/S90oEfi5RbQY5kEpX2lAjp1XYkQqWHwYFBOw77QJ2TZYcAgfVjvhiVQE7D+kAGCOF2hGDsgNcXuVWuMfEgEWGHAltoVxCogDX7yiA0hxx9IFxArsuRAAjZ+sCB6KJdl8y0Dsh87MKgZxskcQKkCyAP9QI+CXx5hUGIYpe0uitAU/MghxDAP6tp1LoZAdJJAPf4YgmJoZEnhsyi5AMm0Lk1UCxJIA7PiUTl1kFrIRpjVIAKj94GR0dSISJ5gAUARdokQMnI8ClalxWjl6RrHE1RgRgFdNtl1AmQeVj2IG+0sAsEt9wD89oUBxyL6UtAQGOQOK6rqLBEUx1PmFUtgW8n/ALhE6bAxoh8QumQWGOXbZ/mBASDxS8fOZVABl+oFLcIAep5Asv38QMm2X0+XcKpATICI3AwcTtAZhmhe9zWjoCT/AFD/AOzX03IeYziWiEhyBAvSCQBiGrpCDWMSf1ZYgZa9NXLVPR0jrA11C7Mei4jELDILpthLX73AAsY9bO/f7Rw/hiSP6ayJOR+kUVdPViaQbP7KDrmViMQKItAUPJ/zL6ocx0gZdRRCpNRg1QPrxy4RTHiQ3/EGIJGIBvxUq6gOSARff9oFHURjycT/AD8+8DDxGIJFralGsstjAkA8Av8A5qDP9QME2QT2/wBQpe3urKPyoABnHADuDf2gUHHMdWLxyPkfO0VGR1J9IBqtOv3hW8S8h6hkQODFRzy6TkQAOngfmB0sY4kMdIkRcmCD6dVevD+8BiSyRkGNLUgZYjFsADzAmBb6Qdj9pbBvCi0QAEbv5/mZQGSOJNk/V/P4jBMaxXUCA7I3LUUrE7OIe5IIP0LOmVVQNpOzrQGq7yIgytGx28QuKP7WAQ/j+0Ji9WSAFjyfMgLF46J31AQiv0k4kEj4qgZwXT1Aa2O4ijZTafv+0iKCmcdLYF3+YwTEo9WJIQV3FTG2CBiONV/qQR49ZGWIKf2lE0B72CLkQeVIOrrf0jIrWeVA5c8JfiEis9SGKIL0/nMiGQPWsmRw4Cx9bC1AoJyJOWLuqgxMcgum3X0q4sQxHVi8bI7HvJwaY6hjRJdk/wC4/RSurpaPHmRAkD+mCCOnHzH0QGzYKHbxA1jewwIFBAyRTv8AMghFHqCHtA0eOa+siJ05HHbK45lGur1pov2kQBJRtDvuBrZDK8mRGQckDl6jxUUWhj6sXT1AuNIEdQGi4RMSKaJ0vxGDWBAwABboGSihAlGu4MIya6RzAvVQBxJ0pMGgwf0vyDADY9KHeERlL8wNDQvRkQBIxCB1AEg9kdqhBir8yAPpuBUziClCKCxYRMJhfO63IoCO7Q5EIF9VA3AvA7gcGEU1b/EgC3f1gU1IIGXX3gaHetakQBSlFFJEoahH6p+L8iAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSAgZhSAgICVSBICAgQiBJVJAlCAgQwqSqsIkBCnEAb3KIlAQJASqQBgQwH0gPrAnEKSqa3AigX6yieIEP3gF4uAUCeYUEoFKA3feBLf+IDgEqAI7VCopRGtQNJ3fiQTyJVRFrj3gKuUVdnAltn8mBDYQ3ClX+IDFoQJz1WO8C+wAfeBn6kShylqBCHv9pdU//lCgFuEKG2QLgEe7PNNwqdzRUCkAABOBASrUqlqnYgB2uBksDZDlFAGj9u8DNDG69jcKEosaEAaLIftAoyx3fuTAnZJ8wumRPueBAgClDJMa06EAT7jgAwB/S8hAJYjuQly4NZJv1FgcqVVFAoLyoEsBnmBEftQco1QdMBqQQogFg62fMQZOraXNq+00qmjRP+ZBNkAJjkwKg0PZLUKgYGtGnuAP6WAwBAg9IFCyD5l6AxHaiULgX0iySe3YQIkSyLC/5AwAeK99CaVscAK9FyIgHNX9YVG9sn7wM66iWF5lVrPT6TkR8f4kghaByon6KUB1HP1M8OrgAR04lv2EBsmylwYVkAC995RASKwxIKRQr3l6N9IIOXSLp9pBCyBlrhkRwTpHVwcY0ZBAfpLXbbqVa2BjaAF3Z3IIgzll0sfVyiZPLEgMdi4gDIXTulxBhhoWMaSctGcsWRlkLHD/AB94VerKiSMdNDUCFEjqBZ4B4cB6usYgBDRFwqEZIsZEH8+IAHpI6vBCOpToAHw9gBRoyDjgyMQgWB85l6NjEdIAfZhB/eQZA6gTiOrpXSw/mpeKuVEYY7C96/5IRnE5dN5EhuhfkS+GGT6ADQPc/LiBj+ojp/SUXAzl/wDru72+e0qt4kD8Lsfn+JEczj04I4tOkdcfxL9aMj/eDQ44g4pJxtDNWfO7rUuIozCHo17k+ZDEZyOIskbqMUJORWN5G/YeYOCGLNLl3GjWZWQBJYxBPHz/AHDMCReRxGJHpY4H8SdA9Q/p9RR87gVDpxxBDISHHcwM9YxytnEa7x0x0tIHxv8A1IiBjEEELJ/XtFDpo+pDQO0LP+IGmAckieH+JABoEMGuD3hKyfSBkjiFaNj688QdbPSwUWnfP1iIg9QFrHG32gaCORABeiK1IGIyGKx02AI6U9R/p9eI4JvmT+orywAR5FdvEHigAgUE+zXxRqUeOI6kSDok8bqAGyz1Pwx/qQZ0X+ljfFyjoCCseD4mUQJUffiBcTaTK09SlZQHUSB9I0aLXpAfmRAoYg5EEnw4GsRl1clFBu/ikDF9OJAyL1FRScS2kuYADpFBX7QMk5MgIEBEuB0BBB9QvY5kQvpZJx43IAX/AJGD58x8RASmBQFX3grbxL/TXiEP02TrRAgD6sTiQv4kAZbCbOlBi46DNrgfmRAhWUxcKrNMnhqEQbsAnla3A0Orqojp4kRDiQ6H3gAVdZee0DQo7s64kRBkbOIvspStUAPwypEMdEj06TgUkGsTUCY6skh8nmQUj0jQB7QNYu+AJErJ/T3lGgQN/SRE0CAiQ+0Ktn1c+0iKRkCUGR3EIozIpfRQWAsgW/eADNA/WQWg1xAp2k/8wgyiTfkdpAsY7fMChFAG9HxCF4l9JXAgakRBQCPdwKhd/aBQdqQfqn5PxICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQwBgZhSAgICVQwJAQECEQqQEoQHMBAhlUgIE94UgICBDKEBAkqkBAnsIDmBYGeOZVIAQIe0KeRKHvAh/wCQGoC98wJxcKXUAmIA8SiGgPEoHtqQOP8AUKl8794UH1XeVA2LMCJDdwq8cL9oE/mBDrUsFux4gTgIQorqAu2QXAf3LgwIRz83AD/komWXpB/YwCft3jVQLtcqqAjqnCJsgM+PEKgrRqAxHpJLfeACINXuANjQQ+8qgfezuBMliElAmQVW/dSgCRleub8QBr01ClbGQD8cQMu6TgVohA63HwMaG/rGhwWmRKod/wDszuECB0kWWeIGdAM+IVEbI97lGkNkhc1IIGPeUMnjQA+phUyIS1VeYEYN2IVQ9N194QQ6Ay77wayiV2Gg9+JpVWRCxCBkEZJ4Yo8fmUXRNorTkVGAACKOkYDIN439/nEoB7LHtAhBLx/tVQMktEE48blAqhkCahVdPXAPb5cAARaF8QJljy7NEio0T1DEvH3qVVNZYMvmRBY5YDKgg/8Acc8AuiGbbBlVMysMS6GkVEDMcHD8QQZ6dF8M7lVDWzj1E9m4ExWKJxC7ncC5I4lv3A5gQ44jF8ujAqQTrkJa/wCQIQRaT2VxCsk5dI5YoS+K0QSSH/bvZK/kfzCIigAgeAaUAayNoCmflwIlkQSSTRBFqXVB/wDt8FHcfBCESAETxzRgXE2Q9hivH+oGM8icAgMuD3litABHErpev4k0BtZCwbKqAwGXX6QDdkSmsUcrBItk8eJRaJBWSOpFMMQP6R7Olz8qWmmGXV/TKTyRfn/Kgql/+Mkn0hIKtyCYgoYhk5MG4E/qk4ghB6r58/MsWM59JWI6SUiWT8cpAejMl4ob8hR0TJjIYgsAAviFnreRCGRyzxd71H1GLLI2eSHz7QoSRkCMEABZN/eX4GB9ARYG/m5DGgMlkDZI/wDX32fxCUJAIGNsuyaSg/rTHQhiwStpSGVkr+mcerIvVuPaM0jkMhiwxbco6tEHI5IEEgvnx/mRExCIHVemTt/OYFzGXUsSHygzJE1MsnS4pf8AIwBk2elEUV88wKAimkCASJLRrHoGI0wbBBcJ6yhRyIC/S3unKNrLIA9QxfmZTiMk2f0sXr/MopQJJogOpMFB9IPQMhkWK1BgQOo4kAMV9/gkRRvqIZ+0AeSSBjkGGddoGMunLpJrJcb96lGuoAorIgWXcg0WN4p/cfEYRrHHIGrPZTKVk9Jx31Iok9nAeoYFo+ApRrWWFvmTRQfQDmwQPY/9jPiKiV0hnvoiQTM49ALfYES4NZMEAosqREDGDQFbcBl6ABllkCxeonooJxANdPZORMXL9DIr7e8AQBj0p32kFrybvz8UIbSL5owIeoDfC9oGiFRJA6SuHCKdDElH8CRQkAllAfWOoIY5UwzcgoP/AOUGvNR8QNFU+31gXHKyHa72KjAJyOIGN+CIRdb1tGQUdT53t7kQxfVRFWZRMd/prn52gWmD0pyC4oYWd2IQxypNOMK0X0ksv/cgDHQXu4DMkUL9uYQN+kAVz0wAYybNcKQMv1APSuBopDqxvaBkRA9NOBT1AigAtQgNc+QYGg0cW676hKGkAEPaQV0kN24EKxQ37SBSZr2lGggQQLkRRSH2gUgk0T9KkRCSwO8A6ZAYKgfsn4vxICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEgQwJCkBASqQECQECQIRCkBAShAQIRKqQBhTxCEKcwECU5ROIFMCGVTiAvzAnMB5MAoEPeFN6hTtKiEVcqg3AG4AvYgRGAMKhgKSqUWxpSCEPipQJ7nUBRqBDZ0D7GUTwZGlTC1CJZ/3KqFg7gPlwG+YEOwZQL3ChsabgHyU4D6QIf1cwBAGyXKArcCfqFC4Dze4VAU7AfaVV4oNwICD/ECDsaQgCFpp8QKeQP+wQYB3qBCvzKoB2HFuoGSDZov5UopCy7cQGQf7f8AYIz3s1tQqlmkvpAIPRxgPU8vtuBN7QlUSxtmBMsT1WCR3PECEUB0hK5dFQOf6jrmQQrqYIKMoYG2Mn7CACYIZhUI9BPlngwGQverhUKZCvTcqQyRxByCW/ECEGwSkqalXQboMce0gGmDtaUAQQUMiBVSqEHeQMgIkpEfWBAKxBII4QlA4EYmmeUNS6aziA3XuRApLtshDcLFtMZEIacGJ0iwxxo3BqZBmj+F84gD96u9x4GWQRxZJ8iDFyF1mQTGkZTsAVwL7yqpItgki18+sCPE+k0PfzAI55EPHNG2JeCAXfNkcQqrqwGORo6kGACb6iFZO1KqkIpkhdoAAgMDpVagAG31HyddpRMyWDS+sQU40Sffz3/zAyf0jqFl7Ql/gY5advVef5kUJ79NsBi5UZJxOYvEc7b/AMR8Vo444AUS9nz2kPoHiSBt7FynWT1Z4BhUiT89pSLaBIy33/MiprbIz/Sh9dyil9IWKY2aUhrIy6gzjZX8yqiAWOYWICFP6Sp/FzwrrABZRZSckXTMokND997gjWWYx6toXv53jNSJkALOPP47mF1nGziMSASLtuUQ4lZHHO0yPmpRP6nTjmerIAP4/neIsayRsZM6fb/IgjAAyZAJXIqFby6mMcm2F8+kRP4mX6nmPZZc/NwfwAWWbyxBItDY94EfUxlkzx6X7RwxUMcdMl31Wa+feA6fWwklZsR8DPQxJx6RjY7/AC4FAx/8gN4sVdAyfEOoHLrx6qyIuo4Nf0yCaOXsSh8/1FSxkZA5AhMJAkVChIP9I2CjYPPn3j3Ubyx9WjWv+zIi9XRjiL0QJagS8AcsQSNgcnheIwEGeo4vjl94GkRkKCIYdfOJELxCZfTt0XAEY9XZohHfaQUg/wBxxNWH+YF6ST6gAO/z2kTVCWBZO06gU4rEgZAnZeUIzgCNArur/mFqg9TAbBA1INHFguiBQuNQIw0SxQWvnEJ6HHry50u8hxpZUAGUN8iETqKOGAK8HUC5YiwWHUaQ2OoFLsEJBepvleacWIDK/UHu15/1GC4erI9ORo7MFAnd8kupBcUR0k/TtCIMQRZobRjVWmUziu8iGwyaaowLgBwB4LhKFsEe9C4GkgfFqRED6VzvvAuORCDNjvGCsgWSjXiREdvgdh+8YrVDEIBHfvCKGGAyPtUIgGRx9SHn59IFVMgb1IAPZkZWnqBWSAiA/LuRDE5KxuBQwUQSOAIFyxpheQuJImoSOqj7KUjXUA0PMgpfb7doExLOI17CEp0tokHn5zAuSBtkPiRFKI8fNQILda7yDRbAN3AGj6gD9NQi0yyf8wAPDJgAun0outSIqt6C0oEJ/wDqgIGq6mRsSCMG1zAuCJa+pioA3pGQGOldqUo/bPwfgQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECQIoEhSAgJQhQwJAQECGFSAgOJQgIEUqkKn3hCFID2gFcDMosAdwIZVICBNwFcgwB94EL5hTiVS9uEKhUHtKLAhECDvAO9QAFqFSzdShSQ3Ah94DfEAK+8AT7QrLvzKq6qQDUqHG2XUKBgKyYADgtwIdqUSkIEtPtKL2YBEioB3XlQHYE1Cr5UIyyR4EooZ+kCcMaGnKoFyfuYEHYIqBdkagQmyCdwqEc7/MCLvr94F9RJ7GUTRHChVxbPnxAmQD9QB7yg/SAALkDIIFE/aUORkT5riBCzizjfH1hUNmgx7QBS6gR7uFXFDEduCTLRGDVNqBEDvFd7gB6kMT9IGdUQaLlFI/9aqDQD1MgJ9oVkAEFBF6gUNp1AWcniCF2gDyAmIE7UBTuVQk9Ts6RgTGweoUIooPfAV8ECZAUSwDLFSwACQSbIgCfStLv2kBAlv1OUXE6IxVQGLHIROwIBElk1AygEQiBKoCQSQdeeYB5dVGnvUBiupY3i7L4gQdWQORyscJfWDhl+jpRAt1qUjmhaNfkytNkklFBGhzIhiESB3tQajJJA7oVxKrIfUVhkzzAp6cSjr31AEDFgXxo9jADpGCAsmoAA4gYgA5DVwpigx3/ALnFFPUM70u24EfpBIRS3KMI5YsPKkFyJVXHKwDliRlwf8fSMQAdE9WP9wA3GiALpFjE6duRprEngjaW4xGSTs8AplauUXF5ZIlEWteIGcUQSul2k6+KVWsAMbOPnWpErIZPSCWNDIblVccmRkMgVv68RwxCQzeSyIsGBnLFGh6ivDXb6S6sQBHi0h3+sK2suo2gRp/O8iJyPA0PGrlEw6uo5AnknVQtXJDIs9SJ6gv9xiI8jiAOaIWoVM0ASOpjYcsAHF45HLqOzBlTI5n+mX0kny4+jOXV1DIVi+ULlVcsselgrvRfvIN/0yBiBigCaAFjvFTGR/U66ddWx2/xGYY0OOrDEcEAfj/kIuIOeQAGWOS5ofWQt+sAHErpB6T+R/qVWsrDCxC/PtJE43iCMjllp/jd99SJ8Yxx6mEsx42uZRcQiiPT2UguTyy6igHVrtqBbLxDYNVv/UiAJIBoACyLjBSwevQKECYFY5H+oAfBi98RvHLMGxiVxIeIen0kgkG0D/EB+lYgnLLZJHeOiknpV7VdpEAB1ApZNvTjRoZGiQMSe3eEAEGSel/aRVA0foh76jUSgjjvgQAYZDob8/DILierJDKncIuK6wBWILIP8QiY+oE5ZHqHcyquWXp6Tq+RftIjKB0Deh3hW2ysjzQGpEaA+oJ2ZKIzlkbO9vQ7SpiLJo44ryfniBpgcPEtqQUgWMeK4XMIArHSuz2kLFSHTivdQhicQCPT0nnmKY0QRlZpQiNAAp6UCAPEkfQGqhWsSRljeQJ4V/P8yWIuI5srbkRMaONVpCFaB0XzCHk7AKpqBQjksjY1IiDIW99gZTGsSgT+XMogFoMXRlFGQokkLbqQGLIDBNwKR2+73CGjtPxQgaTyZO5BNkc1XaBcdktd7hKpOILB0eYwAyNnzIGSOLAEIoICJBfmQwvpI6oEbILr3cI0S8axPsBA0D6Ru/ElRAWUQdvzCqyF1Hx7wgB1G68yIgYNHUqqb5443IjWK2wRAg30kgH7Qj9s/B+JAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECQIRAkKQEBAQpKJAkCwMmFICUICAgSVSBNQEKQEAR2Mon0gICBDKpAJ1AluAMBAhC3cKkqrfvCJ4lUcAfbUAVAgECeygPrCh1AShkK1cCfKgAdHvKBe+OVIqckASqO/3kQQZHEKSiADS9rgUlwJRPtKIa1QhQiwSHAA/aA0mdQJoEowCYsoyiHfYwAgMbxtwpos7lESBYXeFNC0B7wgd6hUH6WRoe0C5VZ+kQZB7AsSqDe65hEN+XuFAbpEd1KDeNc1CrkB25rzCIALseYUABQTA8wAXAF8kVAljY+nMqpiQF6f8AUCkvEfCJBASAwSe/eUTHuWYFWyRQgQ+NHud+JSCDskHxT1EBkhIL3gQAE2WIUdsNcDmUQggdK/MKB5bZrUAOnnnZJgpYzIOQZ3AmSujrji5Qy6S/Uuz3AoCFZPt95FQhjnx7yjJ49TRdwDOt9+0KoPF7B9oQyNugcfmpYGR9IqjtEqAxGIurskQrKLOT6RyxYHMfggABBsltCFU6oBtJXAiSyDorX2lDKsVyeagDYFvwaEDPqBBSpkESrFyFM2h6h9oNQnIkihj9uYFYOXUK11VuMCiSy8f3hQCgeO7+kIiAQIxRNAwIb3bXtwYVWCWcQO1MwJmDtlJJfPhlC2CET7tiAwLNfpPHfxBUKBBBZxv3lUZGP6QeACaMCYj0+on3x/EBkCStl306+8ErKAJPLPAuVWv6f/6wM8R9dqSin0kbJ8/TUHWOkdGRIGV2rZlNVdIdHmsd+/0lhS2kETaEggPT/TJzAJA/u5EqmVM/q7AeD4kggfSD0AEas19pdwwC/US8QQ/tBrKYHpdpHH6yqY5glBjEd0z8/iLABOWPSHjk0hx87xw/Ws2QWKdPQ94E/p9LI6j3I76il1cQGFjiAAwF5/3CJiSgcXjiT+qv241CsvIYtgrYBpWZVMMzRQPcuxGFjRPVjjir5B4kQxBxxp1XT3P1jouGJA/S9UT4k+lQLF5nLF0lzBWloDHpHAA5XMIH/wAZI6gMuxftHsT+KyRfShwtVIYmAxGQOwUXya/1FFJ6fUQANolLy4gmQKQOJ51rw4Fx6mzTCs7ko1hljiQ0ARZuEqV1rqJbZ2D7wi5AnIgYNi681ApyxyxsEA13/MguKH6MiSRX3qC+gAyDA39be5EQDS6gAe30hV9RyQBffn7Qi9Xq6SNkGPhinNkkk9Q0t/eSJhlkEGMfLr8QRoEVsu5EZFskkXYBB1xKKEwsSS/sYFyemsu0gAHYB2j8EVNXNjBE0ts8QLTV9RtZXIIs/SeVfP8A2KRoijycRYPMiIWc8gckPzuUUZHIjJGqrmTEUI5ElnlQLiliWFx/mRB/Y2aYEA9edfiBRlay9gBJgZhF29JykUaeNLdKRDAkkb8CMKFDToPvIAJGulmhCVoYgYnqBP4gQ7TY5LT+kIorT3SMC/0ysQCQfHiSmKSAQv8AsggQxNgl1W5RWrZJXiRFtt+8C4k44H8cwiZUCRZ/a5AZIs47qoFC/UGUdQAtd/eEBkW0QOBAosI80S5BrIjuN14hDA4shWJKKCy3/qEHomgfNwIQQOrl7Ou8C4k0AvIUCsoDR5kAUOxEIuI7JyACESC4wXZ4+nEIDIao/BGD9s/B+BAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAkCEQJCkBAQpKCgSBIFgZMKQAgJQgIEPiVUgWBICFICBJQMCcQEqh7QECQAD4uAECcSqfSA5hU8ygr+sAIEPcagOIE5gU7rcKH3lEqQCH7yiMc7gOPeAIuF0qzqBBr8Sge3ECP61Ci8n6QGu9QIf1WeZQsdvMCCtNwB+0KcjldoVWx4hERHIlEI/eBSNWYEO74lWJWmoUvvUBzs+TAAMortAntUBwCl4comIowoPcj3gE6ra8wA1Y53KGQP+u8EZAbIqFMSDs/eBUwmgrgTFELYMBiOwHuipVCWHjjcAe/UR9IAnp7vsT+YGQAK6W+/Eui4dXckyUZON0APrKoxpd4FNFUAPnz3kEzBGJGx33LBn+1dSZlVomzpbRkDLpdMi+JUiAbI+/aFAC9kkQJiCR05Jh64lAUdIj9oVASlpC6gaNC/wAH2kgjIyaP15lGVTIseLlGjjdgmxepBkYh2Cns25dUJC6gDXFiArp0zsDS5gZBWTB9JO9yquTJ7Dk/7kRT/wDJyG9fLjRCaSY9/MKUTs9YG5UQZoD0kk8ximwE7FnmFCB1k96gB0izXgacqIDiBt5CjSr/ABCoVwCgeO2oB+lgZCu1QIsDyzptS8XQ0SBiH73+frAI9RZyI2+9wAFIZvv5jRnFgkCsn31UqhBtqgig/wAQKcST1ANapSGj6sSeHrvLwQ4pElpjVeIFIJBGD2SCI0DhiOn0nUaRCnZBA5A/LhWaOSILNVKfqdLIy/tWlZjRQAcgn0ittwq/0ziciOoJhL4oxKmekR0gWfH0hUVY5HpboAUzL+B/T7OzrgHfxxRBiiHiieAd+INTdOgee3f/AHLxVxJ6DjRxboWORIif1cRRKY/dCWX4sQYvqJQv2+b/AOyh/TOIJBCKeVCSjRGOSGR0Eb38/wAxw1n+mWBZIypH52MLTBuqI5IAI/MtK1llllgCBiOSTUniZgQP1HqBKgOoY1gus16S0IwP6aR6BiskwC1wn94qLhh0Mau3r/UluiIZEkHGymNwcXHKgK6QCPv5HiPpY0W+4fA/H7SIEHoI/pl48L33B/UIeAYyDO0xApN5EUE9SDWWQOXoBRdE/mEkQEAZElDm0YKowDQGRI8/xImpgUDjl/UYAJ6j/H3lK0HrtyKEgg6v0ngaH5+CKNlB2CjafiREJOOVoJbMYdA+lIsbAP0+CBs42kDYRJtQmmA5GKDYANyUCyOoYeocLcASenuTydDmEYGQGXUCgdgVGK6FkN+k78yIuQxO8VtcRqJiSQsQCIWqFeJpDffzCAyyGIWI7k8yDQHUAAClcgpXU/fGETqx2UcjTHMIYZUccRkSDzcWASzoEPvArPS10lUXIHptj6kGEUsMBDtx+YCuorQ8+YAdISOv4gACyCgdkyCnRJLHcK/rCNI/q17mRC+kkv2gVDFEPm4BMFJX9IGiGqciJq7OI/aAH6km6hBJZFjxCriGQQEAkBIi4EHJ2iRxCVS+eO0gna3l7acouI7895AAsMBk8cmAF90D24hFBICfLUC5IgEFqgZEAGC/nxwGGXBBrsdyWDSA2K/eBMSkx0uoqVQe9fWBSTljtc95ECuwJPmAOXA33SjBQ7470pBQOnwO8AL7r2hH7Z+D8CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSBDAkKQEBKpAG4E5gIEgFCpAShAQECGVU3AsKQiQpAhlAQFQHHMCSqCA+sCL3gIDn3gQiFDcoW4AlQoalCBk12UAu2vMAdKA57Qqa9pQ7oQJf4gL1UAHyu8oEX/uRUx2aF/WUKHJcgp1uUY+g3Crs/y5Q1TZkEIQalDnzzCqdKBkGmT9JRRdKQNjn/cCFqqv8Sg1v6QIq6YE0iG+JVGxxUKoqr3CIlxUKFmtvmBkbCyKOqlF8KxIAIruNGUS2ErqFWjoD7wM+OxlVVo/cSIlbMqmXsKuAypL76gRAlntA0cSlBrJGzoC7lVMACn37KEKoAIeKhVLIWVe8DIGQ0AuQBKLXGNNKDUvEijvahVxQ8X34hPWccgQHYZ1CpvEhfmFXIMgJQiAWWAj+8oU2ciiN65hUQK9I0twLizou1YgREHq7gwomewMAcepsJd7l0ZRGTGQLMCnJDElHy4FyYVa7O4AksIHxa+8KySUwGOyfzUoHF2umlpxoySEgkmLhVI6svUdWO0IM4+rH2NeO0oySCMiEDZswoLBt0Kex/MCnqCxaYGhB4l4hHJj2fncvQyxBLCTb1Gqv9MkZEUOq6CipYnpoK9s94VCiFaDcCM2zzyOIUeORGJS2XUomIArFl7O/wAxRcnjjx1E61cAASRivVYvnxAEBDEB4nhcbqBnErDI5MkcGxvtKNXlR1wTzJxURzxXSzoWkZRA8gUn1NAcQKCQCr2kdQIRXQCSAN8wrPbp2QL6td5RSTniWSendfmQ4qIpGjZepURHBH0ol7I/EKbrE13I8wOaHUD6gMit2CP3mlaZsP8At2Dx3kwMM/7CPII2+9wWBB6gRkn9Iij6wMghjux4/wBxxE08QOlEoQrSrEuwNAoERozj6QScSVZ95QzyYohAMODE/qIgEJAhkln5cE8DjbyB0R6h5quIGjiFsIe3n/MCJ9WTxHTYAsvUBgmB/Ue/7kfxKfxeo5WRQJBJmQDIOJLAGhfgQiA5AsZigzYAPeUa6vUwB+rpF7+f5kD1DIAAl2wQz/qEaxAxF4hN64vf4k0xP6eRIDwJstjvFgfqx/tsvUGr/UBJHXQ0DX2cfxIuIyxOWRPjWj3kKLFg5AkLRtXGmFMdQxBNa7k/eEXBkFE42BZ4+sFFfUECWxILTeR6RWuIABs0ANEKREC6njkbP+xA0SQMcQOok3Vn4ogv9R/qo9J7REUk9QaBKQ7GQHmurF99j5xB4pG8sj0lf2njciMnJ8AMMMRg0QDmRndP4IELXViS3f8AHiX+odTGTo2dSC4imAqCqvb52gayFAZZHpoG6kEXRjXV08KhHUayRLdHuLMguD6ukkl3qVEGQCxQAHMlXFyQFhLju4RAw7NncgrBIGQKPC3CACQAQPJMDWQPTV5NPcCY8YsBcwN7ITs6e/EiMYFA16+8UrYY/VQOhIAsInHtcINsHIsF3UCgp6u0agUAH0jXaREtBABiyoFB6gb1+YF0V6dwgaWTB51IL4sDt2gQYtHpomx2jUVqmEowXHIpcSARYNjvAoy6hZSsiOJiPfv9IG6ruOZEQMBoNd4GiX3FdpBCQgqHYCBRRvfuzuEWtO4QYIJJkDEjHffu4FBJ3qA8E1IJ56i/rKP3z53zkBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQJAhECQpAQEqkAYEgSBYGTCkBKEBAQIZVSAMBCkAXAGBkdxKL9IA+YElUgQwAgP2gNwIalVBCqr1CJaMqhgA1uoEy/eAIgQ3qAhQi/wAQHFCUD9fECcfxAe+hAFtqFQ+0BChsalEO/aULRQ1IK9v9nAzblFGwjqBCL1AQqaI3Ae1OUDuhAeQdC4D+0Ff6gRLRYlURZZ39oEbxC9UAdWgYVCde9CAXYePpAmQv5qU0sjUKBI/s4CzwzBDwBYgH7hiUQ2K4CPaFQe29CAemWf2gP7k2X3gEUir5Eqi/9gW4CxjrnvAhoVSFnxEEIDS7jwZRUwCSH76kEyxILBZ4AlAaG/rIqYkkMP6yg7AACWoAk11Bg8SgCcjkCebkE/VzSlVnIEqy/aUUcMnz2kFK2+YEs0QCFzCplQrTlguI4SIkBEZ3R03qUZL6csaJ2ie0sDMuwQwdnmSBYxxyJoFASqmTIW34qILliHW+x+sDL/8AJkSPoZeEUIIUA/rIqnAnIUUK941NRE4oCh2MKhBPUEwdDdyg1inbSJqA0ScgwNFe8dUyOQyCOL8dpURUwAQB+OIVCHkGWuDftGiX4FahVy20UKH2hB5F61Q2YmKY5dPV+pHt/wAlLNYRBLWIa/1+I6NgMgs1qv5gZzAGaHTQRtSwa9WVom5BjIXjkuEbqVZQokNA5BkwI3mqBI5uP1WvSyQUQLW4ROp4Cx5DtwoMcQziwuNfvAhGIyeWQ6mC983UojeA6MUO2cf0MmvUyTyByPpCwORCTBYBGh8+cS4iHHqWQSB5HEcVM0yOpDafj94goGeQBFir/PxQeGPSQckGfC+kKiIeq70+0DRJ4FDnj2hGWyziCTjxxCjJFcBEtP6fWU+oKsgAnT4gA/T6ciTyR+34gRD/AMhxGwbJHj5+YXfAAnBEjIHaGh3jcGgECMsXf47wiYg9I6ekloK4FyPViQwsbPnxEAj1JDm1+/3MgoDxHUWxZR5feKn4Z4gvME5EpE0udxo1gSBignYtyVGMGmMenIUjsOVa31ZdQaXTo6J+ftJiWDIOJF5aIWvpAuIyORBafPOpE8Qon1FBaMBliMhZLA31VvcaLisemtc/6gaYBJG2yB88yJhj1OjxyIDN7DW/pJCrhrprsD3iop9JeeQRomOiL0kYndhh3uP6Vcy/7jiRpiyIgBLHL+4HX7eYRcgSgGjb/wBSDWYALFFt+bkRgE/1Mi+7AlvhxolEdRQegP5kG+h5A0hq+I1EHqxshCQBbIOPqH2gP04kCi9rQgUk4EuxwHcnRciSQs7lTCyGMh/n4oAADLmjIdBf91rgQi5bJq6Ae6kFtkNEihqEMSQ6YISZ/aCxCweolB8cwNAh39LEguV5IaARqEUPuBxtSCEGskGKMAcgF1FBXKiv1JquJBphErjtRhBvEd2iFsyA8frAUDovbVwg8l/6eNwKj085A8/tAMsd6fiMRdhsi5BMl1H+B+IGgCcQXXmQMSSPJgW9P25cItkMaFvvIKOrs2NwibD4xqBQT99ncgAFCkOWYFH6umwNuEACtkvbgXXINyANUVfZQg2CO3EC7Na/Mg/dPwfOQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQIYEIgSFICAlUgCIEgIEMCGFJQgICAgQyqkBAQpAQIR2lEgIFMCSqQCgThwEAuIEHBEqhZEB7QJ7yqDQ7QECFwAC1AnFwLfEKggOe0oFQJ73ALRgF9oUhU/5CClVOfMAOXAUQjAJjncqpQ3uAZtGhCHAqFTIPIVAVRA/zAACxKJqx7iA2SMSzAhB30gSrFPsP8QICUjXnzAC2i33gTIqhXiFCGde8BoIH2qBAXoSqoD3+YAH0pD2gQkgNVvUoLs1Ah1fH0hVZQgZHJcBiyPrqKIj1J88GFAwGF3qUVIqruBlF1kL7wLkwKlA3wV4kEBSCJ7+JVTyO1swCyJAPOvECEIk/iUaL2D51IIQwyCTuFQfpR5PEotAMjjvAhKx6itMIbgGCVAiIPST9zuFTAaQIItOUCOoAdTQd8xPAopDpDo+YA79Q3s7gAFt1ZCuBMmCHvVSqmXUWCQO/u4FQBbRAdwMl9LyxJpx9VoWP1IV9oRBQTbvScDPOjo0P9SqZZC7N8d4GuMfT1Hz2gRBYnZ3XMKIN0mNd4FY0chuBkrEEhcCxxKIgi76RZGwYXQ1mGT1JP6/9hAEYdRyNcceY6oP0gZA654MoiBDI/SWSIAk40i6O9wImTfSBp2zKNPIrTFn2kGM8erIFYp32P3llVC0D09Idgj+YGggDjljXDgTKra5xbK8wIccciRiw7sEf8lVT1EPLIUbA+fP2ngZFg/pNWxr2+0qYyDkB0k+laG/eoUxQBIYBAs8dv4+CUX+ozQBYtAVrhRDiEHLIFPX1kXQ36R1ALvqBnAk2ECNUqlooArqy6XrnjvxBTDM9CKGTIS14ixUyyyxDB/+unq5MsFIxJKFch/xAzoD+5Fj4PEDXV6QWmdE/iMGGMQyV2br7+8e1V/pjIgsrJkp8RRkAZZFZY5Yg8d/eW+CmsWct/S935+cwn1pDHMAZfrD7uT4dZxOGWSw/qdLJP4i7BrP9JGJAPwSQUkZElYku9O/9QmGJOKxxAvd0f8AcAvSxigrQo8QL0kZgHLbfjxIamWPT1FafFfb6yo2SECMkNgvmZA+kF43u9wdMbABJyBMVGsSEMgMTXGz/uEqMnDqZyyI9PvGei9Y5AWzJhgsMchj1B6Cj00/p2QwMchy4pUQyAxDHS/rwoRtneQ6Q9gIjzJ4LYRN48kfPaEMR0pAsBoGj7QIWUvUqcgZA6yyK1rdwNBGwDQBq4RAMumgC/zH0aeJ2SNVzIABAC6kQ2S3An91i135+KEU5I0C/EDeJNDFNMg3XxSIgONI2NX8MK0mOqyB+9yInVgCAcjGCkrkh65gAAiNjEIjUiCR0apj3hFB6GdjtuOi40EQNXeoDj1cF3swhqsQCAjWoUVkl49lzIjQZQdi/wDUgEE5hcHgfPMIjKDoPQ19oXGwwSE/a4RmmVWXYJioRojqKOJxf5kDh9ZKIgVvRNj7wiBjkkLXiBQwDXT378/PvApeWmVy/EicUgsPjvBqHsQgnuAxZdlyUUJWyOVr6wKMiAjt7hAsCt/zA1stX5EiJ7WRqBp0Do8yDIp0X2AgawHB/UTCIESTaHcVAvHJP7QioDIJ2HUggIy4IDjg+hPnfOQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECQIRAkKQEBCkoEQMwLAkCQpAShAQECSqkC8wJCkBAEcyiQHiAPeBJVIA8QJALmAUCEKVUMKp7QiOVVHmBDZgRfWA/iAOoDgQqcwH7wA2ZRAvrAWKUoEY9pFT+25Qu6hTciIQ6MqhsG1/iBTrmBnTblDgOFUsBpe8Imm4VL9x+8KO70IQVk8+ZRGeeBApH8QJqlzKqFebqBW68cQI0iOTChPcj6QHDJo1Ai7MEwogk378SiDgkU4DJOhAbPYygKxHtvvAiG7LHOoUo2vxAepsCBAB05dI81AFEE0b94UxHJLVOUQjEAjRJ2o0Ui9D7VAgC0n+8AD6b+lbgRkDv7alFIRZ394E3V+YVCtIL2gU2Oqzfb8fmBmmFsCUBWLX4QhQ+k4q+agCKGO/pAEBOmLcCBMWGkfneFCAND7d4DIEldu0sEJfTiLvXdQIDdg1yDA1jw+b+KBjIgm9HVyqtAVzXsYRaVEBdv8AUDJAOJKv9/8AEKZZdOIeQA/a4wQhklO78QqiuRsBjiAxYJNCtn5+JRPS7QPf8RNA9WCFXRv+JTp6cgPQGJBF6T1PlHkSqhBtoklVuBWACymPvIIrIIP3lVCsmSSC+P2gXLQC87uBkA4gg48aHiUVFBgvaI14gMmBsDLVFv5/MCgHFm+47mDrmiTWXUEOkGVVwyy6jniSV2uC4Y42SiCbBqx7xQZCZ6kKgUgV0kMr4oWICBkKxABpdoAnFAYijW/uJTEOQyKJOh4gGcelMMglf4+8HTIj+7I5WeDeoGQgL9QSW/xKqnEA3RItFSCgAA4gHHgiBkAkY5ZIklgeJRMicjQG33fn53jiqBkf1dQpvXzmBAQP6eJrSY2/P+5T6DpBobHJv7QLZtImt3IM5AnIZDLHEp3LFMfVjmB4K02IE6hZB9T7JwNf0wFRd8myDXeKlKOJxAPTkf7fp/uBosZfq+r/AIkQA4GSIr2XwwJhl6ADk3YvfkxYYvqHkjRNfSBoAEA42sa6ZETG8ukAjIcDmC/qklpFGlzIYpOJx6hZBaY/PiVGeoPpCBxH2EZVaBIxJT7lv5UmImZOKyxsAXx2iejSKGOLVDwJEUoYkEkL1e3+tQJj0sNlA4tbgUqgADSHHEiGV5WvT9Ev9xBbyOIxx/u/AgqYs2gcfbcUbxoh3zW39YSs9QyJKY0eVGYNMAdnR9+/2kQyIOyXwFuQCfRk0D30/Jl6LkVjb1aDkwRHIki+TA0CAgSTrwQ5LEXAENUC6AhKME9JBrlX8uMA45BIsaaf5ga6zljoVIZiALA4psGhuUERRLZQYuRFYV8jjmQF3AXxwH6tskmrhGiWBpJmoEscgsV9IFDAA52b5ko0RSbI7QgAgVrYuQRAZbIYoGNEwNnLFVq1KlbC5Qdi5BAQAEWhT1CVopq2/rIHVdmnXtBhkfSKAHPChAF0QwhuMFNgHdg7kFYA0TdeYQHp0LFEagUgMAh/SQUJpAd1AmNK/US1AEtFjuPaEUI0SDXdxRX6B2S1qRFCBoBq0IF2LX+JBEzsj2gMbB+cQh1C9twNY9K+vIkRf1AoMcwP3T53zkBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQJAhEKkBAQEqkCGAgIA6gZhSAlCAgIElVPrCrCJCjgIE0XKEAdoOBFcBKpAGBOT2gBAHzAnMqggB4hUlCrqoBVAhH0gT6wKQ2FAhYhQ1qAagQjlPvKDtQHiBC2IUgOJQKW4CgPaFK8niBP38yiW93Cqfb6wiE+agQAu+O0KAf+pQlF59qgZIoFGANFmBF3hVpGUQIX+8BsC1AcB37Qpy+eagGGzYgTKi0Q+8pEDJhVIAHzUAB3J+8CEekj6wBCL89pRDaThQb/T9YCwghdQIgndnvAhBA1Kq4npHgncdEyCKZKECmmbB3cDISrj8Sik9wXIJYBGJRdCUQPEnIA3Crk6JBI2xAmQ9RAAHlwHT6mijzGijpLRpuoGWD6SrOnKocgNMg3GAx1nIs45UAYDHsO/MCHYt+QIVKaOnfMouJSu/sDAmKDRSHOoUL6QdeVuEWvUQAu3eBk4+nb+f4lVck8RlRdEXAwQ8hZPdgfO0DWX6jiUCtGCM5PEBHjvEVc+QBZ/AhIM4gkHQiL1CCAMn7syigkHR6feBBs47tIV3lER6sdmt/TxCha7/AJUDOsH9AVVwNdQXSSXwhAAgYlDqR0OIEYGNBYk2SdCUZDCxfSdXf1hVABJDLW3/ADCrldMJ2Rz8cRGSWHi+xA1KIvX6siSNB6jVOnEmicRyANfzGikFnqQ4FQMgPHFYAkiwzdwKaPVvL38fiIMpDfUL1KrRJ6MvT4RDkggIxNb4G5QQGIB9JbQPj/kCY6xD6kNEJfHKqkvuzvV/7kSIMrGQvECFMurq6ukAGijHhGcbILG96cqtZYjpSoCgRx2jUP6f9MX6Per/ABFpaJ45DbDqRUzACyGRDLTuaIwSMgFp2SaHeFbwOXUQBhW1/iEqF49ODDNcD2qCMrDp1iD/AHB/mPVMtIJ7T/iUXHLpYApvLuPpJ1KmeIwPoxKXbfEdVv09JoAgbF2YxEBQNEBaPzzJgdY5GL4L8fXtGItF4jJZdRSgATeWIx9R/tPv8+kC5105VkHrRkRrL1f1N4o2Cibg5DEB9QXQbBBv5uE1RlieoooG2AB/MmCYkE9J7vVDvAHIo5Y40RzxGIvUB/UOYH6qT5/iO+GNYVl0gHHmSiN1iTkF9frcBiwTijRZGMVGsScUS/8A+XeQMdko4obW4FIy6RutLY+D+YRSSBlmF4gZIx6A/awIGm0P1AnYkEQ6gQDW7+eIRo/qOL+qYkGcsSgMTetc+0sGv6hTFB2SeRJEiv0kg8KQCAMRkMhQlFB9bHTVqRFxDyS6r57W/wB4BXj2TsuQQ1jXIuUAVjdceYRpgvFEn312kpi9SBARIKRqTEAaoABsqAAL6bH/APGAx6cniERpwNEvlgFSIhLvkFG/3gMcQDyf2gqoE+oEdxIK7LyZ4v8AMIBrHTXIgU12a9oBEBhn3kRQckVXa4BqxzzIAI6Q0b3xKiikLB/+oF3X0NyVDEk+oBhRRSMjexooSCDyfvA0fH7wjWI4quHuQoBRgM0n5cIyTpoQreJPUR1a8XIiGl6vDJ4hF41Y3UAjrn2gUEjXuRIP3z53zEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECGBCIVICAgJVIBQJAQJuBDUKQEoQEBAhEqpAQEKQAgQyhAg7QCqAlUgQwEB5EBVwJ9JVICAuVU4HaAECELvAH8wFQIdqVSpA7CUQjn7iA1YgHpGUD4MipxKFj5qA8moENMH7Qo77+YAAXdyguFCpr63ADfD1ALn6QJzZMChuhriBnLupQHagDAF0oENdpVirg/mBORUKLZrbhDEJIUuYU6k2lAzkEdqWLqjuTUBif/AKuEHw15hWd0Rb7yhkNovsIVcgsjlYfaEiGyjxzCoUmwXAoskjY8QIkTzQhTb3vv7SiUAdhcwBWyaVQJ6QXX1gMhtC+8omPbEcwoC8iKA48QBpWBcCYgijS+3Mui9J6UaZR/3GhtIfaQAEFkfzRl1WVsdN8vcCkkFZG6giABsBHtAdSJKJB55hVxJPsLHmEQtMQoCjs/u5QAOWJRC1AmV4gkjeoGcQcRulVS6rVC0DVo2YEIeKBI894NGLXuC/tAxl6sgONeJeKtB1rg6kEBFA6RHEoqHU6YoofPECkFBMEhC40ZLKA6m+34lVScSNn2gQh4+5+f5gTLHIMgHVkLxBKBX1Bnx35igaOVEnxxAYjOkyOTcqpgMQCgns+0UUC0tEb7yAAy8QfUCTzKM4Agpna7yqqB9QJ7SIyMQNgrTlVQzkSMg+ATJCoXkWuR/wAlIdVLIkYrgwGQLBDoI8VxCwLIAxII7AQf0AxARQDpa+f7lRlkkNa91DSi+o9T/u96hOJiQOkgjEAaf794XDL+of6fVZ6fbmXNM3rP9QBll+w9v8xBrBAnPLjjt9pCpiiQCS+/JIEoMgW+lbhT1EL+oGzyCuygY/qAMolkel6FnXzmalI3muo5IHIrRUhEKORxy/SKsOBGDiBiSSeIFxyZyRyBGmeV/uOKLo0doAH9o6iYgZdSR9XugF3+VAj9JWJPgb/BjBonEDqyOS4fBXaTA6gMmKNUbMBniS8QK4MBiWRiPTZC+fSEUZnrPUwDpCTBSEry3wOPnMCf0wQbPVyCL04qda6AMMQUb44jU+q30MjuBoAyC44pA+qmDdwFnrxIxBxAf+zGH6EjFg5dWIXt4hIqLeWJ6t6/mQASygCCNPtA1gyb98R38GSpS6LIJ47iAB6T+aO/KgxRj1YkkoOqUIhKAJy9TsQpiAALKIQDkRuwNAkDS3IiZAHHpyeI4gV2QrNhuBk3kOA0/HeUVo5IBiQXEkqmLe/naEXR5JHOn8qBogFAJ6Pj4pkREqjRbcqL1YnhZfP9xgL0APZgDr9QSv1GEUAjg5fNyUXLeQCJ5vvIhjjkgkMR3G4NUEAHqxVp91CKBfH7yKAFhBUWjCJiAD2LsuFUHEgkGxu5EAhRAI1uBrWR9XTkdQiWeRuAfGVjsIFyst2Ns8SClkgAnfNQisd35HzxCJiT344kVQmdva+kIoTHcaQgwJIJOLMIFWgTA1iQPUdzIgQQIKlFxaYBOPYQgGKJbPiKGStV1cyI0T6uCStiBWsiDoSCbQAuBQRbAHaEUIfp/ED98+Z8xAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQJAhECQpAQEqkCEQEBAhgQwpKEBAQECalVO0BAQpAQJKAgHAkBKp57wIYCA9oCBDSlU4hTxAkocQFA3Ah/HEALgCLgQwpTW5QHt/uA8v8AMCB94BKBPtCmyvHeULgESzzCnqVKBCzQH2gOIC3QqUSyBwYUHIgTk/dOBS2woAUC4GSnKHvpwKC9QMrQcqgBehCgdlowBA2vvqAXeBNhDcBl3Gv9ygmAGOqFBpUfzACw2/4gZyFB7lAsZEkLtAWSSQboQoMSDqxyICmiOdwA81f2gRbXeFAQCmdcSiZB9I4P5MQCLRCP7yiFsXWoApeYAJB86P8AiAxOt61IpiHQGuAdSprIKIHaGlItkGvEIbIWS9u0CZHEkF/q3x95ViEhJcdqlFZITkEIJIyHpviUH7yLgWwcbAEqIV0skVv/ABCrY9KePvAllt5cNQJ/b548SqoIxyu1e4TrOd3kgCeeIWKET1E2O0BkLJ8fKgQ2Gke4CgKH9QDFl6ECYmgwKSZ3KoECbbO7cBoXkuPHyoA4jFUzyVqXV6YuxeyNSDIRzDCBFVyZQPUjbx7AwGOJWT2UH9Y0VZHEesCxx4jwZyJz5xOIuzLFA0dgggHxAdRORLHm7J+CBkrIBnEZNd5eKuH9wpEssfvFQCBy0zbgP6l5k9YYFP7v94IgoZGifbxIpvJ9Pcg9xKCo5FIl39vtADI5WKasj54lwQDElFg8+PjhVxxyBXUBrXeQTpNt9Ss/PrLoHLpWRHSXvagAg0WALX5hWWenHBHEnS4l/QyNdeOh9t6/mBrIBDDIkHbMh+svpxIGRCJYS4lDHpQyoPvxd7+sCZ4+nEIk81EqoWM8sniuEedCUS+vLrGOToXoSjYwIyQIPkFEv6yab/qEgZLIDIA9r94GcGz+2PyoqtV6+CctHgKEMcll0jHIgCyz8EfohJPRbx/Tt87MC3Q9JH9qO6/xAzn0sHqpqy4g1leJ9L0Cd/4A4kRrEgenIbCPf/UBgUAdIcGpCtYgHIgnHq7EU/hhGcSRliLY57uCqRbA6l5rgycND0kgZE+RAuWQy6Xibs7K8/O8YgcimiEN9oMAQR0teO3xQKcTksi26SUaitnuUUt+fxIKTY6SAholfP8AcJhQw5KXEgE44jeBw80DAodjbQs2YRB+nd5fiFaGQwJ6Q1+8iZqZGus5U7VqBrEizlx+0iKUcjkC393AHqIuz3JgQ/8A7QccV3J0I+J/Wv6ZyXslTX0goCA0CQ+wYqShQDP3W3HRSQKxOt3CLiUSGbPfgyUA+sMbCEoJgkEEXSrcnBRigcSQCaEIIZYj1ZNjXtJxAs31LEJMQNAFEIgg35gTkspcKAfpHUTvYFQNYsUyAbkQBAJbvnzAZI5Gy0mOIFB6QQD7SIo6ibD7QArHqfL/AIkQGRK4a5lFxRKIfcyUAP8A6f8AmQAECO4b/mVGiUGfqRIA8PUIWQMSPdQDJsb/ANwNUhjtWwXIIaB3zswNArF2O8IEUAA+9yCbyJGTeqhAPEmwX41A2AHRY48yAyDVjtAYs+X9HFR9CfM+YgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBIEMKkBAQEqkCEQEBAkCQpAShAQECGVUhSAgICAI7SiQA8wJAfSVTiAUCPiAgOIVPeUQ6UKsILuJVTvAJ1Ah8e0B9ICFQQA1YgOYEIY7+JQ48ygr3IJ2O5VP2kUGw4QlVDqv2lFB7/WpBCIgipK/aUO3pqFTZ7Byimh5JUghq7UCvUCL0kJyiAfjiAXqO78bgQvmv5lVT+VAhNepQB0Er3CpdXfmAoAXX7wB1uzKqNmxRgUpHtAjdA/WAAx40PnMomNlEFjcCOwV/MKp8v25gQEg17GAPSSQTBDFgsgHupVRKwQuwgBrgVAhx9I9Ll0MdbYMUVPLV+ZBmtUfrKrWQFLZkEYA5+0oyKNmvECohkiwuKgOqn6XyIMZJHSzY3RG5VX0iwrG04AkggE12EBkEUkg+zq5TWSK0z5VyRWhWNcntCMZYhdP07yyq1jdMUNjYLgBRpHsBAyRZe/MLp0nSrkcH5cuozkRlikmekcSq1l1AMhDupCJ3Z/KhQA6ILO4Qw6gLRZRUBTAoclSrEYIGiTp694KhDFiyLIG4VcsR1gNDS+kuonDF0mfrcKAEn0shMSBiCwMgSX9oABEJ8UQJRMi8QB4QOXtCmJRAJJOt7+fxHQzxxQJPuWblgmsBgQdpOAJyYKwqiIGDvqzQDYHziX+K3rEYhEkhoX94RnPvjiKOua+GFOojp33J/mBsA9GQTo7qQYGPSiaIHJ3LogHr7Dj1fPglVCwOknQrpr6wNEFINdKvQ+KPqMs9KNrgBuFMiSMaIK7KCJ2xGXqpjs/MuLoR09O1sDujGnSscOR1fNiDozlkCQMq1A1mcVkb1rvX+5CMYnqYxae3wZeLjWHRsY6D0n9o91LxgA9RwzAfvu/Mv7F1MTkEQPAVCMGhohEnHgHX1gZPU6aFHgX2lVViciDjkca2PaRDDrBBF9PjYgpTYzJPGK5+fmUMLx51xz5/aSinH0BDEcF8yaJgEAcQbssfaWjYHqA9OK53IjIIxqgHyIOt5HHJaskGROJ1EYnHHErSBgwwCeR6sgFfiKNdOQByfUQlkDIgMjkNl71RO4MTqWBNEjYvdRno0MucQWuKP8AnmEwJOJx3liTpABwNZPqOPihRdSYIf0oFEdzq4GhQIGyWe8iMEBIaaYhXTEP0kkgCwlbhmro0fcJAVAwSAW+1vcYrWIBLGQ7e58j7wyhy6gOoUckARxuFby60ScmPdzKRnHpLSy41LlFxCWu7cguIIADd3ArseA2AruRAGhsE8kNCUC0ATsdxINEYnMD7AaShAMj01S7xpiUSCCNUzAuFFPErZclSqCOpArLkdVQH6sQkNLakDFAjEB8QLkcCBokHszHqISsQPSuEYGgcij1e6EmIltmztDiUbJQGAe74CkRMiTYTevb/kAyEFqzIrY/SQD97kRAsTaBAUqIUM/Uh94FNVkXVM8fHBjR7Aqu8yiBjEbMouTWPVuuYILQIIWzoSIpFCtccQDHR4O7cChsFv3kFOQAcGAsaWO77QijLv2oHmQBWXST4EIgJq3xcK2NFAE9+JEZL6t/7lH0p8r5SAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEgDAhhUgICAlUgQiAgIEMCQpAShAQECalVICAMKQECGUPCgOICoElU/aAUBuBPEBAg/mVTRgBAh4/wAyqcQFGBC9OAXvAP8A1AnsXCkAdcSgeLgTn6Sh4D+okE5Uqg5bkDzKqcMQHtZEBS/MoZC19oECp19IAh9oAjkHiFBrYJMCE96gUH7d4GTeQ2d6lArkcShZbs95FEe35lAHxAhLhUybKHMEUMwIQwQ2IFoVo8SjCJG1CqK5VQGXcVWpSIWcmR5gUoBI/eAdlIHt3gZyhVxaRJgQPg/6gTRBJG9rmVRoVQA5gADyWxAEkcHVxgyd0WFKNLwx91AyQWAil+YVXpjYa1IDJQQDlExPpTsi1LQxJ2kB2kAot4C/pKJbfJJIAEK1wepe0IgvsO5hUFlVkOTAjALJv94UwII6Xy+JSpmxlvId7u4IYvVp7gDiHjQ3owGWPoB0fsXCshGiPtrUopA5OQvUAMQAOle4MW0Z1wcQdPYhVxIs4vQZfaKgbBojx9YVCzihl7VKCBAvR5DgAPU3oJ8wMv1IE4o/+0qgxDAIXEaH9NLIkDyBFEA2QGXZjVUXh6QWPwYDEMEYmxTMIySAGMbP7y9WLliOpAgjJ+QPn8QauLWIIyuq55ECEAknqVX9/wDMSjOQBSJJIOzLBQhgEQQ7OQSMdomR9RBF9hcYuoMvUASEr7qAHq/qgDF5Fkg0ZcNyLl1GzgMqR50YInSUWQfJF+ZNVoAnXSCnCDy0UNtpQMZ5V6l3Z/b7GWLD+qcuovJAkpn21LCLjbeQ3Yfz4JBDjiiOD4XzcuqpIAONALcg5EDMWdcCh7y6rVKyTiiANv8AjiOhm8iT0rJcNP5+8qREetlNPfga/aPirmsfSMcW6f5MQ6pyIbosqqgxM8fUin35jSJj09Nkm9uhAiOAJfSbZ/7uVegWKyGWRD/O5Dqs9LxCAFABjt8UIYBEjqGkRyPrFXqnqCKde7/zCMlEvFnHsQvC/aBvAgHqxyxSRRX2/eRKyurLED1YohE9+Y3B0BJOIKyJDIIYkQeZ6Rkd/wDP9x4H9N9KAJoAlJ1/EWpgM3eRG3tFxitPIto8A0V8/iRPExeVgnIskX8XEHGxkLeXVkqtuRMMSwiQO9XuAxKyTWPkQUasjIl0dv5UB/TLABBTez5ipYmQHVQYXFjfy5BrAI9NBHXMIpHqx4O2nAmQf9MMsoVtSfVAX+oBdz3UIoxxORxTL0DxCVUF019vnwyCMjYAfALTlFxItYjGr41JRqy2LuQT9WJDyHJ1UvEAcSrSPB8bkGgESTQAQdQM/wByIA9TpwNBNHWvn3kRcGBkcheu1xRMf00Rtn94o1i8sTQBG7hAIvEHp4EiIcljSH+YVogHKiUW4RcTYGSyNjeoQ9J2SR+8ihxBSCYMIusEGF+p3AFg2GfFCQMSWi0rCgxceo5gALZLhFeYDqhf3hAfpQy/P3kVri8lXaGRkUclXHMgE5eT7QGV5Ei74v8A5KNYgFvjx87yVAq3zw4DqQR0RIIgX1bHeUAnpm6kGsmWxfeEhyyRrfEC5ZKgRIiv69iIMCLW5B9GfM+UgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEgQwqQEBASqQIYCAgQ3AkKQEoQEBAzqVVhUhDiFICBDKHtAntApgQSqGAPtAntUB9oEPChU95RTzAbhUO5QP7wG/JgQwG/MCcqAPPeVTvAAd4AwIRaVyiFmFU1VQIqqA+8CJXCiJ45lD24kA1dyiGu6gADwYVN7547wQPfmArdPmFB3YfdXCB2VKIirPfZgET+yECc25WgeR94AWTyPMCGrEBwzZEBTR7QIQASKcqh58GBX5gQhoA/aIahRVH73KHYX9YVUTkD+8IAAFVrXeFQ3+pGBCj9rgLDAGtXKqJEkX3cCm8X+JBAdjXJ+fSUQ/pfSAJQB0sfFQACNOFQsrwPzIK62jZUDC6gEBuzNcGrGQA7W+5gMRZAWLgZzYyHSgeQtfWWKOxQb4EhikNspC6iCHQWa7dpQOsUPKkUxYCDOR4gqZWTlyuPeUig9+dXAh/UOlBQGY1W7XaBnEZMHEEZc5HtKqmw9wJlZr0koX/ECWcmgrtwoeQyz2OhKil+pC/HMgmIxHY1VS6qkjl9rFe8DJfUuOD9LgRZZMlV25lVrIn9JyQP3P8AuBCAQAKa/SR8UABtDdFH+IGQhiMuokfSFOnq/V0hHSEJuKbJ4IqFZQbxHUS0Qdy/0CkKpcHg/wAwKuBkQdIcfeNGQCxtn6vi5QIJx7o6vj/kQUg6Gx4kWVMbARy7ISgSCcklYIJ3GCdHTiyUQCQVxGmhxYss639YVPKBKYPClGseoDnz/mQrOLGRIoHYfhmWhnQJBRv9oiiWJQJyHf5YgT+4Ahjprn6/P8yiZHF54t1bd9riBkCOsrkh6r+YFyIfTlR7Hn3MAQMwAAenvoP444J+oADDErdcXz7wqaQAQSHf5cvRrEHqBOXShZB0a+XCUBwxz/Vj+nm/vAIkEn1bAJDvUKwe5BQCyd3XMK0QQ8R0/wDy2eNR1GQgScUN7LfyoGmDgS/UaS9v9QfQZNg8BkvfH+IxAnI45EpgaAa+f4kyLp1ZsA4ojf8AmMGsAH6cdmz2EJUXVoh4i7kGh6uD1FmtQJiD/UGI0AXra+eI4jW88VkKxTNt9o+IAWesoOzVSH8T+r1EhEjua6e8sSNPMkD1FFv2+fiQyKceoFtJVyYhrIDGKOY3Y7e31ijWTPSwAexGjILiMgAAPVlyfpCVMiC2iSAmfMhGhl6gDZPj95CmXqzrWN67yi5OkBYeSGhIiCwASMeW7lGryxKDIkSmTLOTx4KsHuzAAZHPsH2/iQRDJ44h9XI/aUaRPUQvBUg1hp4jIsV+ZEGAdEcb4gQg9SBePHev2hCyycmRQPeFaPAZOJ0r+kiFZgDdh7C8y8F/tJpaP/ZEQIBhvkMxRpc5ZH0/tImoSLBKIp94VaK6QGWnCG0gCxrx2gVBotmuwkABEaa+0AAwSLIPaOJWj/6tdrkDFEIg1wShCLZyKCN8OBekjF3QJBGxCanpTY94AHijzr+JBQCB9JAFZMoH/UoZJEjjtCND9KxT4MiABGVB1AE/qABXtUYGVNkWacgvVYC9lYga3wh5kQByPOoAjTFQKEwy1tQj6M+V8pAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECQJCpAQEBKpAhEBAQIYEhSAlCAgCHAilVICAhSAgQi5RBAsCQEqkAdQJ9BAp9oEPgwJ9xKp5/iFIElDXcwLAyfMA/8AUAIVONyi6pfSQTYlENd4AJfWAO1uBAgTCr4HeBCPAEomQKfHiIoBd19YEx3SqUUgg61AlMXAcci9wABBRr+YVC2XAvB4gPFQIT9R7blEQe6gABCg2bEob5+sCIaLuFDr2gQlH3GoBDRVwFq2ZVD0737wHgd+0AWAxrxAyWQCEZQNE7IMCZdLXeoVTkBV3dcRghxOmfqdwBIGQ/y4BdWIOjyhCriBRCrlyoyq0u9fiFMv/wDluURnZNH+IGgLA8upBlHXSB3OpQ17e6kVASwmdtygQiNCoEGRy7EciUxogHEF+/7GTQRAI4P3Eoy/SOk/yYUD6gAfdQLkzaG7uBgs2CaFKVVQyZOP2kDJEHIAvwRAgQRGuZRCx+r2eoVEAwAMlyeJUaxIRLKIdGBNjkvtzCqSSyG+FIMYsEAEbdV7yqEgY9IJCr95UaBIyGIBfZ1IYnSwyEUQ3Lqs5NHdW3pxBaR9J2CjAhPTkh7e0qqCASUb0tVAFZMf2kvxcaIdskMb6eIEy9QBZyC7794DHEP19JFkq6jRnFk2UhyEpVXILJg41bcASCcf1b52IAnE4sj0uyNwAHSbPpao/uoGTWfft93UotHEklMcBuAa5Ttn9pFBlkX0jI8I/wAqDxkjDq5I5HbXEunph0lnHE/P3lqqNn1H6iKgAMttAF0yBIvGfQAkFkO80dGCOlIjQCf4kUyOQyYZJF1AlBYksEu/57ygAelEAkBWX9YGurGukI8BakEBOXpxLZ5P+PlynEyKDBBu+PxCoXliMgSK0Rv6alE/qf8A48icRWQSPBiekTPLHHLEEIGnqokGsslXQwbyIiQZOGORABDOiL+kerp1dGYyxAQ2cRx8EYdaKyw9eR6gmyt1CcXE4IF4+lqkahMZawDIxXAO/wDUKv8AULAZBBdDjzIM2B1ZEl7BP2/zKOoXUMdlvh+0yn6esgdRx6Qd77wggUQGNIh/aDjIGVdLAtvn5uVWzZC7Wufn+ZlGcMs8vUCftRlvg6UcBkySNnvxuRD9LxJrLh/NwjLf9MKuCIMaAeQRJAuuZBScjXUK7MagZyWTOkOUIGkSzkATd/BIik9WBKxJ22YArEY5JAd6gREf/XD5gUPE5DDH3KuEaxyCZDJGufb7SYgCOUct2bXmBW8TlReiTqQTEFpmrLHxQGX6SOk4gFUKv/sqNAkf1EE1Zk+GKvQ8lohqTRnIUaB5ezfMo2CUStkHbEiMtZkYjhGBepZEpk1uDFJHUjTLvzIByB/VkSRs6+0YmHpKIN4igdiBcVibL2UBIl1MQWyxFVScSWMgt6hFopY1yHqBep4MohsiMRRsH9QdeJBCQMyAbPH7CEaYOLs1oVID44+9wKOooijwzAMdT6fdyJhgXYCX4ijWIs1lfwxUAg2EA61IICAggj4lFJYR+jMgFumxsuEVgdItb9oFxrFAjW+w4kovU70e8ALY0NkmEU8JvzuQRMDI+krvAudF4q6MRH0p8r5SAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBIGSIUgICAlUgRQEBAhECQpAShAQEDP1lUuA3AQpADzAilCAECfeAlUgTUB9YDlQBeoVJVD2hDeveNVJQ1AHcCa5gPYXAG+0CcwofEB4+8CI6coSidtwKRYUiorlU86gT/kBz5gSuRUosghFfSUPihRA5e0Ca8eIAutPzAoBe/tAhHq95RLGgu8BeuYAcm73KogE9QIeDrzyYUNAmr7wIgSOFSMASuPvAgpeZVXGvfXtAgPVlQEAXpFa3AGwXAKrsDTEoy+D3qFNEdIgAQ7oeYFyxBJrfEGslAlj8SqLFJEqoE6cjj2UaCYJtjblFA/ud7EgZFodJD4HEozj1Y5AFv3QhWkKbA8mEQCgq+sKziQEH/yUUNJAjwf8SCEXokuFKAXJ1cojWjw/aUNWT/uQAH/UVFbEKZMsDLxXvAaBsLn2gMgTkMTY2uJSJiQR6Sud1AM/WrgMgDY934lEPSciAfDO4VMRj000BrvAo6j1Ygh8uDxk5dVdXNA1cuCv+5Lv7V/mQMiSOQfxAg30vjenKqdJ/SMvSH/EC8CieGO0DIxPV+kt789/3l1WswMswGlsrUHxDiMj0o8HUDPSP1kMnsI/FMA0e5gU7LN+1d/hhGaxsjFDnXzmXqtaAIFeJAICWIAKaF+0oyCOqkV2NQCBz6lo3W+1/aUMgh1r7aQgMsSgQVbJA+eYWAFgdTA1wj7wLRydLJCQcy9PEL9SO+JVWwRiMrBNuUXH9LKJO2W/lyCkYhIeVu41GM7A6tDQG/eWNLkSMci97prvCIsciz6VVa3CsnIhaFcaqv5l6Kzj0ggpCl88wAyxHoyOzb5Bj9EGRyyB6wORxxGKEEjp9JxaTMCkjpJKpHzAhHQP1ECwATrtL0ZxyICNspm4xWsgTlj0BcAk7+XCf1kFFkLZoPz+8dVvIYnIkoPnhSJKxll0sl8k8dpeqqAof0wEUK3q4RBicsQDnqt+0uigAgsHHIdztaUguIFr9RLAVfW5Bo5ZkgnHEvaND52hMYwBwyxKBJFZbEHXUdJWSxXgvzIiABYlii0vi3KGKBA6cu/6ePhkoAPEo45C9h/W4AhP0i8k1RuQVjHFEgE8mMRCQynpkHvzA0cTiLxyNn6fSNDEf/lRKONkkbk+IuWLJBOQH6dLmNFVEoptqzIBA60wUPp9vpHxFxIODPp5a5gHQDqgDz8qAeOQYsbhFJByIAOIaripAwOO0jjXaPSriy8OpDvxIgySWMu98VuUHXXQ5rnX+YRd3z3fH0kUBxJRPpATP7QgBiaBPSz8/eBpHpFMPkqRDHEsa+cwNEDLICwNSIiZIIqiWYUxRveXPeEMNAnRLMFaVltinIidSsFjzGK0WgePPzzIgURsArYqVAEEuiuSJOKusmQkeTUIuVDq52z9YQOPUAAyrK+fHIA6SU/odQNMdT7oeYGS9PXjcAU+l09wNYlAWH+8iNNa9/fuZEZPAIfYcCUaLAKflSBRLy2KYhEyJ2/qIgt4kPtdyYdUnorKg+Y6IC1lkwNgmBpPmn2hFfpPOlIPpT5XyEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAhgQiFSAgICVSBCICAgQiBIUgJQgICBJVSFIQhSAgQiUIAQECVzKpAkA+YA1AKvMKkomxqAIhSUOYD+YEtwEBunAh1Ckoe0Ca5qAdhGAJsaEol2XIoPrqBRVIwIu8qovb2gV+YEP1EoiQ1bhRlbhDYUKBg74gIVFftCIRdgSgB5hQix2hNPzKpssa8wI699iATBHpcKla8wDGRuAId5Y3KqAMYj+IFHAC7wIthD6wBXK7lSiAaFvhwGVPhdoVCweOdmA3iVYUAjqj5gKZBBe05VDVJQJkCwR6jEEA6ceoF3zKKR6Q+C/eQDiC91X41KaiZIH2hTIYlnqQ4UHqA22xz4gASAB014gUbIJcDJOIXUOp95YJlRsEF6hT1dyeXwYAk5WAH7eYDMolFl8xBcSDimSfeoVCjiaXPapU1PUcQDQY2IUOPvSK7waAJBABa7wFNkq9QqFAg8nblACxaX7QiM03/o6hTHpSRQ8QKQsbKZqvnaBEF+kM14+VKMlURX1/MKNepmuCYFLeJAK+0QTJ9WJ3Z0NShRGROSunCmC6jWOvYmKH6SMVibSeoDG/7uok8QJkMQWchiRwoUbQBJ94ENkDIdNWu0oGsQAjf0gTJ9Ns8M+2/wDcopGVDLXLt/4gQenJnI6THvAdKbCIEi6hQJJoBouUCS2VkFX1gQY46yLo78Rq6qBIyC6QLgHiX0lrhl+YD05E564F6q5fwRkgAA9RsgcwGI6sSOuyP/XtzBrIR9KYOTvj4lKp1EkdeJ0SXGCkEvHIY5ZOg25BnFnDEEkgWewuWn1cSxiOpd18/ECYn1HDqxCIXMv6qkjX6u9bkGR0saCFFipTTOhkchQ7UD494gmQWR9QbJIFvhQL+rBDFMEo8wJiFQzK4PP+Yqq1kRljiyy9D5/iWoZZiwCFz0lvUhIpxRHRkj3J4iF/UGPT/T6sCQ2nz8qP6fWsulDHIgkFjkm/8mSIAYZHLIAZAHbpr9oyw1Tj6iSDiDzlqBchjk8iMi9cKTUxMSvWH07L5r8mUax6wgvcakFCBNktC+7+fiRE6jh0rElh9/nMGaZfqDA6nvE8eIPiY48jQtsP5uBo5ZZCjfA0r/1CLkUSMAi+1SC4ELpA1s3X3gMj1Y63ao/7hAdRGIyyWjW/+QKhaP6UU6J8yIaI8CgoUC6mbIetKQXscRf9y/zCLiMTkLsc/P8AUJUugbuh7/4gawyBGj0jkHmSwMkMdks8H52hFsBhC0SvnvAySCjQOgv3gUV6ulEe6+bgUvIgjjdtScRcmSCHlyfEeB6TjlkffuoFxyRIJ0ORINAokAjd1GJUxSABbKuvpAZHEFkl8KQUF6CigbXUiBtftCKWMQuDswCICS4EIq6SA0B2P7yCABuzSBkGgN+3H5hF5S7pbgAx6sSwvtAAY4phMVCKQKyaQa7yChHQ+ikOFEnIhHwNSoBoDnb4kFCI6SchADskGy4QByFkcE7gaDFME91IM4ih7WYouN9Iuu0FUMZEWA3pQj6c+R8hAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECQJCpAQEBKpAkBAQJAkKQEoQHMCJyqXAkBAQpAVAilCAgQyhCkBqBFACBLUKShAbPmBNyqa4gIEMAN+IE8wp4coZQHiA494E+qgEERKIeaUKVAaXCgQgGFB5EAdwIdIKUCXx/qAvLXMKIAX7QDrmAOu8CFIgdtSgbVQHC1UAPAH+YE4KFl71KoNwIKNwJywKhV2FZqBCXYXv5gAA014lVLtAC4FAd/wAQJolD2gZA217Sq0QyizzCMhIFQqmiPAUAAubHmBDlbI4+kCJAggA+0qgFLLIePMBZBP8A69uIQdMgPuZVQANCsYDJpbG7/EEV8n0jyNSDI/SAx95VUdWR8wcQFDijfiA303Y4lEJH+GYVUUqHiBB0vu7gErbJuAHfu2uYGQEreUqqenXIoEyCIDgXvZepQd2UbviACJYBCa8wJeIeKQpyqHZYTLcBlVB1p7gTFN8E6GpRCg3la0IAHqJA6iHvyoov9THn9SpgfOYlIz1JA88iFUBAkUT2ECEDeRLA1/yA9IBAVjTlUy1l1C+fc8ftAMApAMa7v4YENLgC+9qBAsg+mnUcUxb6argD/EC5Wa03rzBEJyOJFkKUGch1Hkp/4g4Yj/yFgoFPUHEeOAVgAjHcvQsAUD2VSBlr0BkEsssSqzkSMSuoPH2B5gavM8FSHA3gRukEIAEgoFUCHzuU6jogVlk0frRUogIJBJXDfz45FAD1EmwedqUQnIkZHpuvVAC8VwlZr5UoPLIFaFIC3IoDiMwDV8GvrAyBkQfUBbofzL5BrH1AIkutuBkE45HpAA4r8faPFxnDFCydP3l0byHTk8lVjqy55uIazifSFijVa+fWKNGiEOpenuEtRKmM9OIKd7G7DH8wunVn1dSOkxweO8eCNDLHLMElE25cOrjjjjis8ijpiQoCSMn+oXtcwKyML6Wd9/ikMVDqBIIwAQ8CBCxWNDju1UJHTqLeQI3QR+0iM4j0PQBN9KWqMouIyJWR1vx2/aQUZZAGyLtSFiIehts8BG5dQJYfSACf/VoyK0UQssg+3f5VwhiQ6AL2PJ+GQq9IH6SWgTv5/iElMSGGQSWgTv5/MWCADA44glj4nF9G2D6VXB3/ABIia4R9vaOiuyM3ovJwi8jLIdJfpJgREYvE1oIWYVrIF5A4sG5ED+lYpaCv5/uETErLrNMok04CgCT1EpNcmAxsn0oOiT43FGv6iXUCxoM+JEiA1jyDTFJOBsXi+af3koZABHLFlMQiihXPjZqAyJWTLr7n/GoBopfYfPMnwwLCNIdvaEAXdWaEguBZrJ/WOCllZWjYvdwn4WR9OYCzi8uTfcwNYes+qu4kqcGMaGLvQ7QDYCIL7iQMv0oIDdiANg0GRuVG0ea8GQXg70vaREBeigmFAbrRydjcIouz7ORUxQLBo+ZUW+oepZHwzAuJq6Ve0iVbIbPYDUgAgZh487UAij1Ep8wLgQUvaCvpz5HxkBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQJAQMwpAQEBKpxAiUCQLAhgSFJQgICANwqShCpxAGAgDKJACA7QJKpAQECe0BAEX7QqHxcoe8CFxFPEofW4CvdQIRUCXsiBe3EB8qFTx+8ovEgytEyhoa9oCi9wCuFQpaMKL7QiID9JLlVfbXmAL/ANQJklsRAG+0qoESDCIKT4hTeNexgAyEjUor/wCSCNM8CUQcs61Ab1sSiUlDSA8NfWBSjl9vpCM8H31CqCiQYBEpgQB/T7wpiANsSohJaXPeFTnf08ygbKPBuAICT+24C9wqWC/G4FRGP53AhABAIDgULLpo75hUK3Wu0AQ+CfEoySURRdKUUpBEVsuA15kGCSeoDUqtJ8jS94RBT6uIVOqwwa88S4A5BaJGrgUi0hUgiLoGVVBbVcDu/eBnLQJQ/C+VKL3P11IJrIgcD8yr8Df6WjyYACx/c4E/qAkC/wARAAIPSjeioE2g8idNpygNjHHFKw4UzHp4o8xBAMw8iaYKlAkAjqQFgyCkhJAgGu0DI0BoLf5/mVVB9JI/Gn5gQgAjLI6oDdQDIxKDKY8GBB03RukTcqqCOpkpyCZZBCvzAmQAyBPApcS6BAXTjiQTpQB4voWgUbgCCcit0QJVMkALyPsJIIDj1MnVEvXEouABIIHFK694GMTjgMdLjzL1QrL+mjSWJdGOVEwGR9PSCRY794q8aLrk0rcinVvJM8Dv9PpKmM49I6uk1ZAHb7SmjYBJI6Wi/wCYFsBdJRJ/7IrFJZAD2+fFKq5Ef+QZEIMDq+fT4JYnxkWxbJvsdwrTWRxJdobrvCAfpByD/wCyKhIOB9TJ7wLgccSQQCRtHn5+0ozkP6nUP07HftHiyg2ciMnok6HmAyoqwAd8f7lJUy6BicToJ8bEeh0khkrhHUAQcT2WJ5v5uIdDiMf6axyxPYeYXfUzy6UGD3Pb/UDWGQPSwAjbRUJVJN/qYGgGTADelkTQMgwHYxO91/2UbyI6cccdY1QuRJ/oD09u1/iRWS8uolpVwvxL5EdBjodggCOPnwyagMTi+oHIC9fPgg1ASxQQsgNfzAoFEkHLHNMjkwiljPoBRHC73895ADy0iBX6teIGscgQWekGgOPf9oRk+oC2eVe/aBsc2e+9yAQes+1Hz3g+I8cv0rHHm0oTjWI6cgt8vj5UgmfTkP12P/qJouIy6ukfpOyCPzBUx6SsQBwie0I2CTl0hAY37SBkViCywaO+OJIJjgQ8upkkGuZdRrqIyGWVhkFSGL1PXqZp/PihGceAaHjY+P8AEK2CcsWASeNhdpOIgWKyVjSHztAvqAyxxHFvg/HCGJFoC+P9xTFYbJ+3z2kDI5VQB5ouBShkyWVCKQ/R0ixIGRGyek98T+YQ3kgbOoFyNUMid/qURAIeoihTUKuBar6a+klRkZDAD9ozRreKypUR3jgYApEjw+/vCLw6eiVqQVldXPHmABA6ij3uEBYSu183AtpdIWiJBA9G+ShA0S8gw7FDcIyLpW2+8DbWRAZZWpEwAoWxyoFBYKb17SCgopMirED6c+R8ZAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAkCKBIUgICAlUgQwBgIEIgSFICUICAMKkqpCEBCkBuBPeUICBJVBAQIfvAQHMCKFPqpVOYQ+sKmpQ8wJvcBAH28wIr3Cm5QDGvfUBAhd+YDQ4cCKtuVQ3qRQyij6uRGcmZqKGi3qA3Y+0gEBe+5RNaPtCiBPHtGoFOFRoyi87UgbISqpREGQlAmvlQKDZC1tQMirTlaXFHY5hGVTHZwocSCGrPeDSt8CBQB0uoGV6gwNsnvKq8bswBZeI4/MQQrpuIImFsSqoI6kd8CETLE7f03CoExY24AolIXzAFaGj3gHqiydwo+QXy4EGyUQAR8/aUEeYEY551zKKGga1IM9VA6NblVQToklL7QIKx+XAA094j6KpRLvJ2NEqQUUvTeRlE6TvjcKCmce7CO4AVvvx+0Ceo5AmvAhU1xQs95RQASCyTyuO0CdN9VEcxoBW3iagTLpFgenblAjbomyQTCp/TBJDLIiiggM6QQgTI2NL8P7wGIx6m6aY47wM07yR/I+GXFa0EMiNW+e0IFvkpgP55hWSN+qiG3Av8AYSCyeQKgjIDYDJbISMqtZEki0eO5kGSj0iuLblFBoumDYMDGfqBse2pYrRGL6g/SXXeERZZHqAL/ABCqTjiAL8hwfUQZsjS3UAcRlkS/eo0QkEkq+XxAhPqAAYDr6/5/iVVQJIyJAIMaGyLQBSXEB3GQ2LuiJBD6cqLyHMq9XDIsljLEckIHsZamMYZEAEdPzv4hetYUTlkA97kKwj0sUOlhfw5pdU4LJdYZ3uvtImldIIoDjv4hVxOPS3eV0N2YGcerrxvEht2SdygQBihWR2Rz7yBkDkekFAPpO395Yqk+jLFNbxAcDGOIONXiA7OoFBX9Q9QORICPb3lMQgZDq6nlRWJrQjRQRWTJAJZMCEvKyADltXCxAWscQRiUULQ5lFJPoeIvJbciDGOLBOI2WEYVcSeo5Z46IQ7H4oSw6VRR5Xz95ERnEMg3bHfVx1W8CTjiRnwwFuMSsjLJAHFElLbijWNJepEEEn7r6QlB1Y4ckDZ95OijXUvpkHscQIkDZx2gyT8qBvE5YgIWTZ7SJfQYisuvdp/HAY5DJjEgvJ4jz7RiUBABLfqvj7+LgBjllkMsrP7/AFktF9XuA6/G4DEY5ZArqI2/NiKigMjN6uxx3kFBBB6g7Fgv5xAZvYwo2QdlwkKIRRKZQuA/pYrLk5d/nvJaVoH0kkVoBSIhbB+g/wCKUUdIzJy7q9yenxAcSbd9h9KPvKLicSCMdBEkPcI0aJIICpuZEIH0Xb5dwNC8KORJ5MCCz0gW2iagrWRZDPtciIx6caTBSlGsdEH2IAUiMn1A3A1RZAaP5kRbyuge8C0OlY3CBGNsbhVCORJYI2zIgcrJ0txghfUOkU6CgaAHVYbBkFBZG6PfiExdG184gRh+kvzILjkQerqQaD5lqICUES3pWJBrH0tp7kREx5I01co10hhEnvUgMFFewhFBBx02JBBRx9VbFKB9WfI+MgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEgDAzCkBAQEqkCGjAQECEcwRIUgJQgBAhlUhSAMIkKQECSiQLXvAGFSUFAhF/WBe0CfzAa0IVPEofcwGX0gT6mVT2gETUCfKgDuAVdzGiAdpVWQQ9oE1KHO7lA2QXCoPyIB91AEDxIoiDKICVoqUDxIBH3lArtCoEv3gEQWteIAthIwI+BcCm+IGV3fg95QSCMKEDSR/aCISGyUJVUfeEO5QC3AhC2ioVLCAv24gETbC4gS9SqpolGv2gS0937QATQ14gACLdygNBAeTxAmSSND8QpSdHx85gQkIEU9GAxv6bdqANnRIlU5IkBWW71KJlpEPvcBfVjoagQ7P4uUXkVrhSCAHnIl8KVWdkWXuBphEgFqAdrgC4GSn3VLtKqdID6QQRpRoqx6lw+IFel3gZL2Nn8Qo1YQZ3uBCT1EUvMoEJdIPsYF/qEHIAktVXMERY4hB+4PBlDZJDC7fiQQYlnE5BCyvP7SmgsW+91CmYtonvTuCJiB0dITdff/UFTEX6QMWKH8S0aWIoorvzIIQdI1upV1ARW+9QJyAAQQG1404EHSSMh9u1/wC5VXCwiNUDFExJZPUyTaFwKQMSxYHiAGBewmyjBrA6kScUFzL4pll6hjs7WlEg30kjRJH/AD/MBlyE+9SDAOJHUqSNblU0WCyNBxELyyHRk1Qrv8/Mol2MQQO5owrV5AhAh8fSRGcV0n0gh184lVlYoBg87fzUtWNZZDVDuR/HeEiZEf8AkHUMn2Gz4UL8UA9Xpt6e5D+oCSP1Vil0jfcyilYlDIEhpiDrBCXRkTiDftLP1THHqAIyJBKANkGDQA9I7EUeD8UaGSBOWJIxI8/vAgFD+4ugbMLrWJtqi1SBqErKGI/Vb5/1CrYVrue64X1lEzP/ALAEAkGv4ggMgjlifUNhr6fmETO8BkQQ+LY9/vCw/pUwjiiiOT7fPpLS1DksyfSAtHKTF+NUMin5WuIQCByNFmi3FGsgTQGOQCbDMiBYyxOWZGgTZEdE5ICWQBCB+LUDRNgvRr1OQxMRj1WciTYBMUQYvIA4l7B+fKlHUNFYLIgMd5llOsDIer0gUzs7jBnJdXDej22xApAyGZGI4t/Pgg+tFdYJBIYPt5+dpEUkjIbxL76gT9WLBRO4F6iOTu1IMt5Egjpb7yjWQJRxGIPIJYkRr+pkMshiWXW+feEkZ9C6cMcSNlefmpfRsEllaXP2kL1McB1EHJgWaTg0x1Y557/SZouSCOOu7ABMqLgcTh0vfJ+eJEqc+r0kj6DxCtg9BAscj2hOpkDrgedyADrtvfaAf9qWOI70CoQxIyWQGq9r3HBQUCMkBq4oBgp5EvRomBqm8Wx5kRRgOqzovW5EtQDMMkca3L4BJ6hiA+/IkVtcMPi/nmGTqFgEfeTAGXpBIXAB5jFQoGiHw3CL+rII5DgM+IQDJICAHDcitgHKn9CNahGccqKW9doALQ/aKNEn9KK7AbkQJeb6eo/t9YAdwUCVcg1sEkkrTqEUkAoEgwMlUjo2DzCKAHyCTp6gfVnxvjICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSBFAkKQEBKEKQJAkCwIYVICAlCAgQiVQwECGFICAgTnzKFwJuA8yqcQEBAggNDUCEQp9alVDvzALtAA1qUHzAHUCWlAfBAkKdpRbuQTcomioBLSlAj6SKK2NwJfD7XKLb7SCPwJVQpvmAfLMB32SpRKIF/aATyahTRquYDhs+YBkQMkAE3/iUAgf0iAxRRowARLdmVUDX7QKO2lAidvxxAiHSTeoURGk4Aomjr7QQpeGhKpjd8/aBDY8eIDeP6R95QDIZFwIR5KgTpIGveFUClZgTIsk6Xb94ILqJeI04ND/HeVTIIkCgYE13fCgCzR447wILAQv8AaA8BPzxKGKLV+XCo+5tUu0CrKkb4L5gZA6uloXKAD6SUStfPlQH9h6eahR9JAtng7gW729+qBMR/6muH9IoF4hoGrZjonfRSBhQfqJveoGchfSARtGXSKE6534/3AmORVo2BUYGRrq7eN/F+JRGgBq+VfmFQ/pQyFePneUU4qjToVIagJNkg/wD8h+JVXnEMkpByIpFZMhjv7QayNkHEPt2pSqHfpAIJ+h94EIWsgGH/AD/EoZi3keJFjSGTLIyI7QjGWKNHp425pV9RzRKy/eQBllY6mQPuvb3gxDRQo8iFQ/8Asi3CmITIxBKlRT054jGygtJRwZIJyZ6VxGrxexdba8eIRl49HV0rIWQDx/wSgTkCUQz2MKyQBlkQDkr9/p9o6NDKwAcTxq/lRguH6RkSexPvAxhkOogsZFuuJVTG8enqBFEePneCtg7B0PzUDIx551ZPz7y6CBxLx9QFA7kVM8SCjn6kETs/P5l1IhyxOZPIKZ3uMWKUGUA8kOK194IuDPUDvyqfP4gZPqdOtIBwoOr/AMZ6ukc65lPpgzgyQyuZBMhiPU/S0LUovQQGUUCmr8xppiOnE4gBdnqhHaan9QnLPNknLQA3KTyGPqOWWRxI6SQe8mLwyQo9IqitQh/UROQxKxSKNiISNIjG8CeA+O0dTxDdEijXaRQDIgVuyUIBgel9JOzx494RcedY9XcWfH0igClj3BXCHYwjQxBQGYWwex7yCAA9OWZoHZHEfwXFem3kBzof6/1AAHLBAEHLjVd5PqLiUQMAXyBr7wf1oViV6Ruj4kRMBix05dLVdpaNeoYg4ENebXz8yInVdZNEfXvGKoQyJNFinQkRCsiccQOm7Bjg2LT0lk3AzgciAbysbxii5ZEWW+ByfijEB1AABgeCdfDIH6ghll4Qv5/iBr3yZyKbkRMHoEg+zRlFARxVVXgSDVAZepuwd8QgyMiMl1bf4+e8AC8h0nkyYFHk+UOfigayQO3wv4kRpAsZDpy7vmEYyxVkLigmJdGkTlZ9ipAxJJOIJJAqnAp4HzmQR+nQ39oGgSiQRYonmEGDiGDpFwilvqyP3EihohkgbhAn0WB1D8/BAGufxUgf3E4Dz5MqNAkZDEHL2IkFxrEMEL8yIzjldizyDuWi4pHYFcakKoN3xqEABqgfAjRcbxIQJXvIHpXSMvEeo+tPjfGQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQJAGBmFICAlCFIE1AQECEQqOAgJQgIEUKkosBAihSAMCShx2gIElU8wBgTUBzAQBHMKlyqSIntKp+ZQgRD2gP3gICFIEZJJMoagRezgBblFL7yKy2jxKLz7SCD7eZQLeoVO7KCcANcn2gCKqUQnhiFG/Hhwgn2H8wqHaAfmA0R5gE7AuUN6/7AgHP8wAA41C6hF1KoDun7QJe+YAgPmAAZaG+IA3jy/aBAU2a21LihQKG13gV16tKBCEChoSgERwR8+0ActMbECHXn24gKokovcAqFr2hU3kSEQvtAJHj3MKWiCaHc88SoZDEepD7xFQGijvSgUgLz3gZKrIX28yhw2PdQqOgSAPpAZj0+rXNxAoHV19YFa5N6gQ0AQhV+IGSKdh8SqAIjuN/PrKDRBGhS8wBxR2LqRVIBDNn2gTp2q/aACIZLx5lE4oquOIDdiytmAxs0GE/aU0wBJfSV44hbWAR0odIRV1KNK2r+t9hIAPqIItagR40QQBwIGR1EnIg2N/PpKqg4g0tr9oDEUQCndDn3gMQDkcTs2PnH+5dDIXWR3YO5CIMienZ74n+ZVaOyLXc6v4ZEYxNl6aYKMqqWeceK7fHAhGN9RKI4FvtCs4A5Y0GqspGUaIHQWPSAPn5kEJ6siLIXb/MojOWXqRL7P5/uUVdQBypGkOdCBk+srFdNedwvCxliNMl1AAsHIlcN7gUFotXRP8AMggxuwGOBxKauCyNA9L5jC3EyDyPSnwAIVkEhnfY0PnvKIBkMkCjx51xKqkY9SGKt1Jpi9JJdki9KBnL9JxOx5S9v8yiDIYv9RCadsf7jAy6SekY6ADAd/8AIDEnFjL1ADQhSg+lA/pxX7d4Fx0SCSTZpff8xRDnkEr6hZ/zLh4tnCup7GT0IRHiMcccnRRtr/PEL6mQxWJJOQdEH55j0TEPPPNkBFsAS/i8axCKwyPNgMyJUGK6sQaaxGwexl01c8sV1jpfkfaRFJosoZeAF2+akVr09PpPkFwjGWQxAz/SeGOQhGU/GhbHqo/X7SYaPLpGeT90OY/E8MkMfUQfC3CqxX0DbsSIvUDeOsjSOvn8wikgYi0QPUAOPpGDJAyAyTJ2r+8C4rqQJJwr5+YRdZdQx0sdfWBSmR1EgnR5kFYVH1Ek+ZAAGRJ6rqwYFxI2bRvEwgUQciCKviAA30gj02TAv9P1Gkk0eDIlXAElkA9/EJWRkTimQGtNwY0NkABg8LcguGTyKvJbFiEoSGCWHwvpAzgMgT1EWNcxVbxyD9D2q+kYn9XEML1EEPwfMhTAeo4kbHb94Srl0iwUAbHEggbxJCI4Pt+ZRokMmgODvciJiWSCsg0lA1u+o34qQAmSRka0O8ImAJxdDhmKrRXSSQEBr57yMoGcqBXvKqgl2T3ciLwOt1q185gLyNUOyUAWMsbIu5BR+lmr7Qi6XV6eR4gUWDkwfNKRNMby0r1GFXKybX1SkRkdQBIf1lVVdmEU3wJDH1p8b4iAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSBDAkKQEBASqGBICAgZMKQEoQEBAEQqSiQEKQEAbgSUID7wJKpAQJyYCA3Ai8wpKHEBCpqUA+8AQIE0vMAu24EPmFLgAu0oeIEY3+ZQI3ZcgHvCoir4lDzIoVpyocwqB61AWQrgD3Acon3+kKHVn8wiJaoQoGgTAcaqAN8KUQHfJgXSIJuBCUGd8wqBGv4lF2faBkvcKr45gCARbJ/eBOWBAh1z+0qriQmRaigktd4GWfvqUAcrJCXiBRTBOoEItbKhQWqoQMghBu7KsGAZABFKFatlkDsoRHjRQ9v2lEyDftzCoivSfaBf1AaW0ZRC+oKiE4A28WrpQoNNCQQ8pDdSgAAQOlPXECN7VwqoB2nqVABEECy3Cps5FgA/aBB4DQvlwILtAeVCgAB548SikE2/DUgjHSEeoELUoAo2RpfPEB6lQ+1feBEiWTVHzKp/OukagUhdJDDs1CJjiUsSGO1X8cLahKX9ysncARprq87cAAQSOle34gTHIlCtVa+kq4gzK6wCu3MYpliER38xKGVrf+ZREsbI9OvPxQKRziA2/wCYDI4pY3jxwvMCAgEWceN7gALRa7OFRE0uCBArJZxAY4MCZc9WPFcSwTJAeu6+e+4IHEtg5Dkq5RMQT/TBy9SEKtqyOK7lXAmROSOfOjt9vzB/AZAY9IOKOhXMGBQ6MgCTlbPiD8Qn0o2QWRtiVVFEPHLHi+/tqESsi+BW9/O8KxkMissS9UDUv4rbJCIQJ389zIgRicWuK9XDgZyyRBKBI5KjFTIAhdPs9mUawyWHqxWWI/VFEQxOPTl51uFQNnG2Q0bpmBAf6qJzy9r3UvhMaGIHUC8karnu4N1CuvpYadi/9iPgYkFFgADnka+kFc8cx04kjqDJ6gV45+8tih6sccCihrzH08dgCWczkQaCHyv3kT+IMjkccgEbFAwYmQDyYIKFjmQOlgkZG+5jRbWJJOLSxR2IQOORL/8AVWArjQJGRyxyy3Y8VuODQJAbAZQEiBJOaZGSNXcCogg5YhHk8fb2hGRkSiSxl9fm/wAxitheo2WVT+CRKDeJGQpgo0IALI5ZdRDVgfDCGIP9oDAY4cFXHLLIHqJS/MlEp0NoWXAtHEE5laFyIYkdAODHFlagaDFs/wDrYf1gMmkTf/0UogixxJfH5EI3ZyIRJIvggSCkD0L3KMIAdQI6rCTHPxyCCsR0tYhtfmBUekInswPz+IRR1Mgr/BgTEn9J0e73ADMkE/3A3i7kwbOILWPihzIahGgQitQi9IFWSNU12+eZdRS2gVlwDIplkEwED3jEwC9LHKBHMgoxvQL7feDQAvpQGxrUIvqIJBS54gCSASUaom1CKao4knWpA6Xe+67wGIWAuxxIKAQHrXEIbALfZQAzQom+YsMaY9HSAP3hEBXpAsX9JBoMZAnEdmNwiYll14hUIdj9UcH2J8T4SAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEgQwJCkBAQEqkCQEBAihUgJQgICBCJVIUhCBIUgNwJoyhuAUCSqQECQFXAe8CEVC6kqrxpQifWFLIlAEwBgTvxADS5gDvUKD8wJUAQPrzKJqAPHfzAAcyqnPncgKuFKpzfEIcwoDYgTiAN0RKJs2DAoP2hU4oQHkGBADTsfeBCKCA7e8qiKCOoQHfmALTLowsShqxKoO9feEVcC4GTr60IUyNhj7iAqjvX3gQmlX+ZVA6sdoAkGwekmrgK0wRxKAXSmTzuBCkyL4e4GcqOhrmFVDVc1AeCda3A0QVs9u0DJJ/thVTOiXAyWD3dSilE7NHUDKIpnzuUMul0h78CCJi2HCrbYPgf8AYAnqAPej2gEEjSpiBkGtpmFXHFEgXCaiGJ2SuJVTImj4gWmQiOAjAiQt0dAQocR0a9oAgX+QqECAkhZUR2t+ZQXUuQeY0RdQ/VieNSiAlvqIOoVrTsO/PzmBBbHPK/eAxB6Ti2dNkQHq6kB5CC/mAxPpsg3AhJK9JGz7QqZAW8UeTp/LlF0yCQ+X/EGM5HqI6Wyd7+cynDEIEnIheYVSCciCxlt7kGc8QgDlR47ShjROyMWu35gXEtJpUvnxQYDqJFl8n+IGQCkXpASqAkhFEbrSgUkkkm1y7Ff6gQdWJ5T0l7/tAWaoEV8ECUb6iOrh1+ZRMcVkL1sJeYqoQekdNcD0wBxBAR6SOY1V0RxlQEIfpABIJBq7PeVTQeOKxHcKpBkBrNt1+k/DL+C42fQUAbgZPYA9TrHS+veUXPqC9JT7vn/EeBj+kHpZoHYiqyclihlxwOWFAmI46ztECv8AkVdMvWLx6DogByig2rLoA49nIGPR09CFWQdynoj0/pu+kCwPJgZy6gWANEmnEVU1ZLB4KEIlAkZMjih94VvIYkPIsjueNdvMfxGc8wSscg0Dvx+eIwjQu0FplV7wIyCwW6vt5gUnA5koMEb55kEOHTQvFfQ/7jRcsxlkgEdkC6jETALIdR4unGjZv9ORbQDQkQGRyGORXYnk94pjRISztEiqPtIjIaBLDKr3hWsBiMziD43qoqI8cCVfTW6vmDpkyAW6+3n8xBTvL0hHV8fxIigVzkXwYFK/8dra/wCwfUyOLJd0Dy/aRFxJOPSbWiKcChEDQxO75gw6XijlmjsEef8AH7QiYn/2J337RVbaKdokLtIgAcicSGe3jTuEUYUcCL08hBoyctgnYLH8SJi4lY2yruFOo0KCZKMJhlY6SAQN8/SQUgWSN/eBD6iAMVdkf7hFwxHSa00hGlVMkbrYMgEAWeq99oOgWJJAW06/aEUXZFLn6yCqwMivfn/UIYhjTdDxBTF3bV2IFHOj2qRFvHJEovRMHS9EqA9J9STqhIKAsht9jz9oQIJxBxJWgjoQCBABpFfO0DQ4H2MiIOkBAg9qqBSdkV4bkBaNvynKj68+J8RAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAhgQwJCkBAQEqkCQEBAhhUgICUICBDKqQp9YRYEhTmAMCe0oGBICVSA2IEgIAwIRzKoID6Qp9lAlSh9YDR4cCMuA+rgNwqfWBfcGBPeUSwaEoro68yCX3hSj57yjJ977QKO3ivMAR5hUHi7qA57PxKB1AmRdwDryYVFpiuIFdvftAPiBk2yqlVUk3UIi5vwYVCSjx4lFJXFC/aBKAKcKpBWkeIRnLu77QoGRuoAJa9oENVyfzKqhr8wBW3owIrLWuJQ8sjvAckCoEsDx47wqDRKdQA3cCIDYBPjiXVXekjcAASV3MgxROz7qaFGgzviQWnQ+r/ECc9RG4A1KqENEMDsoIuQCBJKP0gZDKD32lFC8Bc7cgmQGgiSZYag0yemuYVTYejUBod/pAhvQfccQocT0vpD4coAsoK6AEghYTxCa4lFxZJye7SgZJHSHXLPEAVsOgr+XKqg9OW2fb+YM1kksWeUW4ArEHuuYVS9W3owjGXSLYB583KrYBtI9yDzCM3ZIK2zxChYsZBDk8mA6iiezYUCAKuoircqtMrR6ce/IUI55Y2i+p9ioVR1WFwsX/AD+ZaLngzola8SEqY0R00HXiFZZGVlMM2D8/3KKSK9SviQM/UbDPkWNykS+kMDXaFxAyXRDVcfQSodT9YIyA50oVQSD0dIA57KBn1HqzI5Q/3BG105Af+t7syHWDiBwhloc/SVdTIZLIEIlBf7lFyzIyB9JVleS4TA/oKx+hiKZD0kZHHsPC0hAzkRksm86sCXgBZAHLIdP4hWsSgfSnqpBnKkC7Q9/rKLiPSA6LON8QMnpOtg68wq0HichlVBL2/mBPTkiaJZKO5dDIIkH0A7OrgXIZIMGwl5MDGAPSTiAWDv54hQMEEhjuP8fSAI6e+RPPb2cQBljkf1Y2D8+OMTjQBOfSSLLLML8ZABIOWGSHJ2yIqNYhAHI5dRHL/wCSBWjjiAS2RzBVB6SMyrKb18uRKpqiWDx2lDIDLhEXliwgP8Qk8ayRAYJB4JkGQAVZIIv3gaxPp2RiNHHsJPoUSBgWz9nGIYivWCPSgBeoGjeLNlCwP2hBrFDL7mQCerWwN/lwKj0vEhnSPzmCoMvUmb+wkwUnIEFggfWEaxB6jlkxkQyNQn8QsYgHDIH2t+IAHHIekCq7v2kvitAnDIAdQfPBhnvURaAKsIDVQNEjEEJEj8yAeGUW9sXAhR4yrsN3KNh2AQuWJEQegklDvcHQkCxkcQNV8+GQXqokmwD7GAAGrocWIRplcADQ71qRGSAyCObyBEqqGCQwGEA9SVG8sQ0F7PXtIiAF0Ej20IEaIJISdQKcseXRj0xSyTjyNiAZoO+e4kAbZPi9/mEVodXf/wBhuEV5dSOv3kBZI5Gy0PEDWjxRr/siJ7I9VoQqI2CWT20fMqNPJhEk+23akTH158T4iAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSBCIEhSAgICVQiBNQEBAyYUgICUICBCOZVICFSA5gIAyiQECeIDmVSAMCQA1AP4YEVyqcXAb5/ECHzcqggDviAP0gTcB9YBf7hUgXwe8ohDCiCeLP1lC1fMgHQP4hUPvKFk1AM1Ac+YVE6qUEFIKRb55l0Z8/iFXz59oEPT01UBvm4B3woEPdIyiaI5QqAt0XAEKxd8yrpbXECJg94UO0hAgAIviBUSKfaBCt/wAwREQBZKlVo1oCBCLZxPiAI6dkfZQMoHCyT7ygepjEm9wHHseIVNJ6/eADI7/LgQYgWdf/ACJV1bol3+IDqtrqB7QgLduFRM+o60IEL6mmFUoZdwxeoInGVeIVbBA2vn+ZBMhQRB7yhoL+3niBH6kO2gE5QBseqvMKIo8H9oBdrCoqBMcmCfTfcQIWKxCVyqoAdqq7QI0CDvWoF/UyTlqz3gQ9QI9RKu4DGgAg/wD5EUMn1D1AjHuJQeQLvyhB4n6gLXN7hUItDa0vEC4hHaIOu/8AmBFQLJHeBekdSrIHLmzGjKGaV8e8qoAOpBFj+7/HaUOkgUTZXt4kU4xJTJrGUTJIbZ35gEcj1Ij7fzAer0lt+PEDQNgB7sv8GDGMgCg0PIhYHHHpKG7vtKN7ZAvRI5k0YIAJyIeRLPCl0iE4p5Ebp6gUrPH9N8bK0pTlKIAyYL8gVJxWetZEtglD/MphlkQhkRvjkwDGBGOIZVCvtHQXqPSTQX+o1TKsgliXT7/BAGsl1en5+ZUZONF0Ts/aNUJy60xbafzmX4Jj05Y5MMgX7R78Wr0jIEhMUWdfKkDI6qzsAX81KJ0AAY4sHFZEGN+jWeQA9JxAZB4EYGYIyB6Qy+dfWCBIx/uyJRpu4GBjj/4xiiOwNu5d9VF0rEk9OyePniXo1tggm3dP45BCCBibLASH7waxjjS867/9l1Wjj0+rIZZeDRLhN3ioodSL2CdeJFBlkchngOsHb4HY/eGcnF/pnEnIMsll8yXVRDq9ZaBI5Q94FOOX/k69sIPvHxDIsPpIy7DLiOBaIyA8fxA0iLbA5fzzIgQwBbF2IAAm8bxCfOvaQMhmcwxkSq6uZQwNgjq6Tsh/aRK10lEEl8o3Ap7BkCwzr5UIzh/UPSSMiCdV5ixcUgkjEbtdKb/niEaxqzoUK7+0iVOs445WezfHeTBR05A9QC7dWzzBRDEhFBMH7wNDqGID6lb0O8VAkPq6z04rcgpGQIN+A4TYBEBkjRQ4kUK6lorv4lRR04kHKiDR4kSiAA9xRN/mFawQyWJQOWvrCIUU0OATUAB6vS8QfHPeQBiFR2b/AIgaFjHnI/b/AFIlTLQCv3+8ooZJJpbv8SIt+kstd9KBQR6RW6PtIiEB31AaW4Va6UALLUI2FkKIIkRk0jybuVYdQAJvwpMGurqwZAvlDxFjKPEoEAllHcKDIgnINHb4EiLkcgAySBzAtjIDEEFP2hFQJPH1kVCRVq+P3jEfYnxPhICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSBCIEhSAgJQhQiBDAQJAGFSAlCAgIEI7SqkKQinUBCpAQJ71KHG4D6QJKo4AwIoDzAH2MCL3hSUDCkog8mBbgRBwIe8CbviBeV/MKGjuUT7wBR8QJxX3coXR/eQFsiFT8yhAqkGT5lU5gUVomBk9tmUABr6Qqj9KEIi+vlwqHshKKbGpApjvAg+KUSiEW+8BkLD95Vhyt+TAnLuFCASh9VUARta5UCAnqHxQGL6moAh+xOlKpkf3gZrjiAPgGvxKKxrg8QIb8EwoGBux+ICgd6gVki0TAzQZupQNIa9ipFZXL+soEA0Cezl0ayJWr95ECg+oJU3AyVsMcKVV0MgQCHUCBL1F+3+RAekYgNA6W4VGWGqPMBQCBRWu0Bjk8mrlEy2Rf4EKgFgAfYQKjssEHjzAmTAXTzSMRRUWAOGTuAyGJPA5lgh6UAR9TxAo5xX0cCDHg9RA8bjQRKRNdzCoF1mnvhDcqBAPqocwrH6sXlomgJf4rVZZgFVzIi5dIyFmoIzliSni9kE3LxYuWQyo8B1Am8RrELSuBAOxR3UKCxkaHv+f2lEdks298wKreWkQL+sAVR4dKBHyQ6fkwHJy4NmtQoAAB0+ndA0ZRlmhtaf+YFCvE61rx8+8KDH0ABCu1XGoixx4CA7Ij6yiZMBAiwn3/z/ALiKpyeJHcWK4MC9SIYLPP8AEhjII5yBlVkdC/8AHR1o/j9pfejRfWA+pXWgZPiCIJQAxF9RsyjK9QyGgO/1jVUrLNJpPq1ox8F/qY1kShiuafy4hKx05Y/1B6Tizb/j7yrurh1DNkjHiQvq9JJBWZfsohU/qM/pGyqMQjFXSIJAC3wv2mlCKPSMQKWrFagb/SWiASufvIjm+qiLKBXftUrSgAD/APjsmkPH7QilApGile/8QAJA6erftfMLiDRIwLGlz2+ylQyAYDGRHK1/uRWUAG6Ns2TApxxNEEAGioRvMk4N4mt01Ik6vUB1DLEZgFUHGCZWf09J0R4fzxA0MiOsgu65+cyJgEMUQc+LFfmA6sBisgSDsLUYKyL6q6qp8wiZHEAdyEwK+kmK1jnkSyAON89oxMMuQRQ0ySP2hEFK9nbXvCtDGvUyavW5EM2i+g3UTBrEFEIUtC5EtTI4kgHm/nzmBSSK6SvFmBcTZA6foKiomIGJFEqw8r3HVUANMAyJdXErImiLLPFwhkjj1MDl95PoyinmHkctGpf4OgLyAOhYrUgZoZfpLEJBZBCkdd7igcwf1B07gwBJxDYBDQ1JxMAAR53VKFaF4m0T27SIyE+zYFyjQ7lEGgNyI0SNnu0aX8wIHwHVCQGiSTsWDAtHgcnXxQgAeGAOYQBRIOvvS3GK1iAcQATrciBKd0tfvAEaRK4gXqrd6N+ZEaaWJAo/aBnHINAkn2iwOrHpGJXT3OoxH2Z8L4SAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDAhECQpAQEKQBlEgICBmFICUICAgQipVSFIQ3AQpAQIrlEgDASqQCgQOAgPFQIRKofaQF9YE+8qg7yhAhFQGzXEBAFvUKcbgRCBK25QHiAG91AmQpwsOfaUWloyCH4ZVRMe41AcUmP2gUEKlcDJFk0ZRdQrJsb35gVHniBLVSi2UfvIJ0h61LoyQAgpRTR89pAIpWXKpCp3TgObZ94C2Syb5gTIscVAEk6NQJYtc/SVVXJgQWCOB4gPByY5uUMXiCrt3Am3b9oU/cQIxpWLuBeonXb7e8CGjp3xCgA6f28SgTyh3uBkrXGkJQANth/aBSy3sDg7gClW3YkEDIs0dE8Sqpx9SOPfZkRmwLOu8qoQAsU1x2lVonHaHcjiRGcgVe9yrEQV+4ZgXB933Z1AN4kkD2gMWyOsjyoKZKykXCqeKXe4RkAf25WTzKqJUbrvAuIsEizw4GaBQD5liocXih6tVwohqn1ZLXTxHECCzu/xCoSTntwLicc8P1HLIcRgixNm91GqziQRiQMvaUWu4B3Z4gQEAg+rp+feVQgEMF5CwoDFsEJDS1uBT636QCeSX8MJxksHoFPXeGlKIGRFkFtQhZxPBe1SgQZE4j/654feVUOKeTBrkcfzAUDWSP7SDJRxZQvfaaUBH/s0O++8CInEIhkP6v/cCm+kk2Gx3+8EUBHLIAAYjfeOlZKIAAxOLXcByhmweqiUb/O+IimQAHSQE+TIKaJe9+w4cDOQBdBCh9ZdDEep4jfIMKvSRkemnkEI1Gcj1YkNDHgCVYZE5EkZFEpZQBeORyAxb+v2g6ILr6ga912Ij0MDkeoM+LiqYjAZFtBsEURzHqXiYjLHE9BQb8Rq5GQQAST6b5Uo0AyhSVrfv5g9hjlkjSADBtQYycsssTl1UrL/T/ky56DVYLINv+ZFaxHVgR02UWODCcQ5FkilwbR7RgEtvFhpALRjBQOcy3/8AXfVQi9JLGXqQYpfDIVvYQBfUra5fzxIms4AnE7R2rIMLW1/+RLFFirhPjGNAW0x3MUKBWIYF1rUDZzXqP6vbfj52kTEOPc2Lo/O/xwQYxooMcOpDF/pgAMEDuT2lvqUGZ6WbO/Gv8xYNYgHIh5rwfvIVcsmC02NfmQxcjQZxABhDpqurFk/PaBn0gcEDZMDX9N1ok77cRUoMnkOkBm3IWIelUUe57RIVr9WVkDp12hAgAkkrvfzmQCR1fqQ7xguJxOPT0kZL+7SlxPdUEchm98TJjONojFZDyq/iUaYAWRRF6ciKN9QxPt8/nvCgWWJRJO3Ihj1PqbRQlGhl1DpeIfb9pMQys9I1AoLAZDVoyYionEg9TB2DftAgyKxBYdM7gxSE8gTQ5siEGGBbMiowcb/a4FxOJsWFW7ioJ44hlkff5cClBM3j31IjV2WgBQUCMkhad+H4jB9mfC+AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEMCGBIUgICVSAMCQJAsDJEqkgShAQECGVSBDAcQpAQBgSUIE4gJVICBIDiAPmBDqVT6QJ4MKalAP6wAHkwHmBnvagOYDR7SqKQB4lBM6gQ0Drx4lAUJA9veFTRC7yh2NwBHEA+xhU7UlAHkQIkPPEoDp7MQoANAQJpeIAo07hRm/MAgGq1UqJ4NQKUTcDOQAuWLALZ1vUKor6QJ5ZH1gKDHMCDdP6wBCOiYEQNAECVV0ffTgQ72A63AvcO4EyANcPUoiPVWSrtC6WrS5ECaQIrxAvSnd/aBMQRfUf4hRGz9dShWRSTLgZyNNfmUUErbPZ2IEL7n7wKyNEe0h1k0FyfvKq4htH7CDUPinRhUs4stiUUogjRciJkLRAfgyqox9IAsvtUAhfYD2gQViSW9MQMndAnspVU/o6TdO4QJyN46sbhWQAAstGUUA4gWQgJDqAdJAaPc8QGIxIv2syqCgigXfiBnJerr7HViUCPWAdAXVSapk+rpNn/AJKjQxeRxZY+8hqYgrqNAiyePEq6C7QOKZagTLWQGRWR2OPEAB04nRxT+kHVRIf6XYPDgYIHUOm0WSvlblUA9IyAfeBFZAIB7/PrCtdQJYOUIysyccjjrmVdgW8sV1Ph/PMAljz1UB47wAIB/SFoAiBMAz0Y8a4+f9gQJAi+kOvtKBWWJor/ANuO8KmRTZIJq4irTPBQ0fneEAHkiHwwGNb7wDu7YpcwJl07xDIRYFD5uWaqgnEH+pmCXe/xIHDDIF63KMALHqS9uJarb3jiyXa9qkRgBZBAYUnyZVOk4EHABao6MCkDL9WIxxB7oe8kEfqHByCFP5o/aUZJDBaGVDpFSq2EQWX/APXYcqRGcyMzVkZUBr3l4sTpxOT6shSBr94NaDKyORK7osmKMLIHAgHIIEfv89oOqcAWi3YJsfKjTVw/p0MrZ0SeY0tQXj1uj2Mfg02XmOllm0x/2BnM5EeoInhFwQCGBAyvkEFD6xh9Dj2HCdkSDYJ/tOVf/P4qRGckMegc7X7y/o1jiDs5Bhh1uQ0JOVNPgFsRgdPosWOXqNRo5A9WNt2u3xyJgSDkMRljl3VRg0AOnkEE+oqRKpttogoHmBkLHAsMmvglOoTZAAPZlLt9LkHRgYn+mAgA1teIT9ZyBPqrHY7GQMUEV1Ajj3/3FG+hYhaAFj78RqM4gaB9I2dqFaw6UKWhqSpUGQxCOS2Tf7R0XLEjq6sXRZAhB+tsrEWW/pIKf19Lfdn2dyjXSCTidDT1fmRDAFAkojYFlwUBRBJA8d5MDJLIWsj6g+YTGrxDB3aMh1SGHmV55gZIZHSCgXfeUaxB6QhY4MiCbAJT2PniBeoEtLy5MRAMqJyFQKG/SAjT4gCgDjVrnUCjIgni0u0YGK6lrsTIA/S1rUIreNhYnynzIJYYRv8AEDXOrICIqEfZnwvgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSBCO0KkBAQEqkARAzAQECGFICUICAgQyqkKfSEIUgICUTtAfX8QB3AkqkAdQJAcwHJcCGpVKQgHuFSAlAjvAl/eBBowKLJ7wF9/rCpZdwEoEfvAndGAJKvUoc7FyKW9fSA/ECLiVQ6VwA2KJgF3gZV2PMotcfiApEAQM8VrtChvYuBT7fWBFZIlE+CAFA67QKmBCptAGu7lCtMmBBSW+8Kb2P9QJ7WYAMjW5QNB3CoNXQECFlga8QLQBq/AlVDXptp1CA0Qw3AYkL9X0cKEoJUNwDPddoECQpDtCoS1dfhSi59+oLv8AWIIAXa8wBNkCh8uBQDsW7X4hEXJGwtQuomUTQlVA1iSB4UCoBvq/iBGjq4EACGXHtuVVKyqiPeOAdI5JfWBnaYQ8/PMAQdnX7wGLGeQYN27lA+VlxuRQJChS5lEJQy4xHnUCvpH1dBOASIr7QMHEF0+K3LKqjqe33uBkAdGVeYFxJ6smN2yNQGI9KbB8wovVkGQSfaEQh5HRRdy6sXIgAlg2tfmMCjlkGTfPEDGbAeVjacsVoWaP6r0fnEA8usE5BrbqQE+CC/7eYGKZx9NeZRrJ9JxQZKJgMQa6cWB9AF8MCLFAsEnR7yqg28kAyW9mBSccigHyigYEfUDiB3+lQBBKPSeD4ECEF7D5Lp/4hQtIAEJ0L+VKAFk9IBPpFfiBBZIx7VqvEAjj/TN1oEiv9yn1cR6QwKLf1k0xABmq9IuxYjhqf/jor0o8195Zqi6ekYk6R4UKjGR9Qx6ibfe4RC+o44/qAWlXz5UqmAyQBQB9n+YD+ohgMgOrhv6xBEV6tA6hWcgTkST6aQS/mXwbfpyp1t37SCZA/pGJyqsn9vrKAI6Tjlkd2+fniBP6ZwTLu0RUUutHqNAdQHAt+0DJKeRJ7wq4ldJyCfDr2+0eInV1c8unr2jhhmcV+ooG/oe0QXFjJ9ZR/MgpZzQxQSrsD+9x8GlWJCeVgH7QgAXdkhLf1kExHqILIHBG5UTF9OJYz8LQ+OKraGJJ6AeX1SInUXVooePHv5gACMRlfYDvfMg0bI6hTfqx18/xCB6QDiQQg/TXj+YQJP8AdQG/f4ZFEiyeoClCLgenLJZrF3BQG1iRkdauBrE//IpFdOpExk5enLOuh7/xGDRyAAPUyCwzGI0GMhyuaFXAiBYAZ0tSBixz2bcCYroNAg+OYGsOrqyDN2VcJVwxHSgKNkGQRYsg8+aMDRXUbR8wi5ZIPHqbS9+YxAInJBAkN+ykEyBGIP6jvUQaxssOxclD+4E5aG1ArDAyRuuIxEJ6ciDSPaPg2T6Tixu5EMWUQcR5PiCgSAtnXf6wGPcli9bcIvUykuUbkwwfUw9uAL2UDs3ICsB3388QNFohsbRhH2J8L4CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBIEMCQpAQEqkARAzAsCQIYUlCAgICBCPtKpAQHEKkBAhClCA5gDAkqkAYEcBAKBLcqnCVQGxAGoVPbcoQIvtAcwHFQIX2cKqgReBKH3cCHyBAY7gQ7UqrbgQi9B+IU2eYBoNwJyIA1sQIrf0lU5JFQDYf3AhDKFCSODcCE8lgQBCsD7SiDaJKgOaNQo6K/eUQaRriFXfeBCLaD7QJZBe+8AaF6gAKoMfvAhLOq/EqoDTKPvAp32/mBHdOUUoWSSu41Ah1xUKYmwjZ1AYh77BwJ1A4gHnXiBAK88woue93KKbpA37QgmrIP2hRhD/MAbG0+VCMvnS7/PEqlD9LH7yKNlN8wIgPcXKBK6efHeBOok+p2BxqUAOpFm6T/eFMwOqnXeCDIFCzYK3AhDYpE6MAAuEe8KDqJrL8cQBCxIpcDt9JRKV4gc+TAuTD83BEPgAHTJgTLeuq/pKoMQBo9PjiCgLyopUVyY4JiWKonzAmQIAXS4itEDIpEnhwiEEAiyufML1B+lcdwddpQZFMGiwRSgMWCSQfihWSD1EPv3UouWLyB6gUacBmDkeMiLsUfrGiIEuvvCjGOIyf0hAvqBdLmFMicTrm1x8coKmnwSZBn9RJ1wEPnEvAbx6zeQo8CUP6hdg3f34X4iETLq2MQWGUfijwQujliSCNDsu0KuX/ALEhnTKqMIYjHHNLTQFQIi2AQO3DlUxzBwIAGmEJMDAEgY2nQxt/XiUqonitoHVyaIQxwSqeNKUTeBxzI58fzL/FZyQaRFUAzIrQ1XcAOnCITkc2RrW/pUGM4MDqZ6kXTlVrJjIE0AaX2UDJyZFCw345f3lwUoMgF1Tf2H0kEyKxbsdvnmWKuOwGQSNshQh/TArqKIAp/eCsDMdIxW9//PmXFxcQsfUSxd9pBcVaHLOO7+8VFLLByBtk5Bj7fSEXHpyQJutlwvFfpvFePAkRSOrGxl05dr+GBkHI2QkXp94FeOsQK4Fa8yGD9QTYuxA0ByLON9UiJlXSQCxQepUHkMiMgS8Q/G4FxxxIBIAdB6H+ZBckc/SKGr3Ap6gEGKfn6/5hPE5I6qNnke8itLWJ2fFnvCJjiTZOSJgbIIdkk6C17SIyMiAGvA7n3gazKfqBbO2zCQyaRIHlWoAt+kMjRPA/iQXBIkAZAph7hKWciS0KrRkDFpEdJPiBchkh05H3UQWsskAAffUIumGl53IJiQBvFc8fiKKzxkdMnYMCgHE9RQP76k6jKHVR7lqUbOI6mCflyJqboZaoE9/aBQA2UyElAt9IIxy6u37yIMMEH0gcQLkSPPJv55gOExVEGAss5aP7QAI6XvIUzzCLmeoHfNyAerYI0zxCPtT4HwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAkCGFSAgICFJRCICAgSBIUgJQgICBDKqQpAQHFwECLmUIAwG4ElUgIEgO0BuBDCpKqmEDzKqcMQGgYEUBo8QHHeBB3hTI1KBo+IAj9ogcXcCfeUDXgSKj7d5Ra5kEO/YrUons4UFh35gUijZgZddhKAHPD1Ci9twDWSMAdQJVUyIEIHlygTW/uIAaNKA0CjQNcSqAqvpAeO0CEPgXCpXUBQPMChU7gZ10k9pVUWR7wIS2AR9e8AUOAe1wJafOpRSHRQqBMtDIc94UAHjUB07IgDeJdFRBKAJaKlUyYHFwJkn2+f8gDld0O8CgkkWvCgZJGA5LGpegQRvXdSLAsHqNLhygkw9wMk9z4gXHYJ6uwgEUBkdGBAFZKupdUdnZ4PdQJTQviBeASH2uBBl1E8EHvUKMr0mxAzjYQ7MfDKGSTQLuoFJFmsmagBicg7B0Vx9INRIEYt6F1KpsIOwyXSMJ9Fa6sjyOYVAUAL+p/MKYEAWCDz3hD+oQqul+IhEI9TxAtdzKuhCaenAq9Itock/SBkf+oxVUH5lVc8kSeEGj88RiMtpIZHJwqk47JHau8CPNoHJ9SCOxAnS/wBOJxC+CBcWcD1Ymts8SroRijvq1VuQTI5J5Y0AlKIAP1AW9cXGikhjFjqYKXHz9oEOS/qEN+1iU+GQojngDkfvEodSAWICOzC2JkMQADijtnUCFL+4LR2RCgGQBdHsOT8cqKD6cy8k2Op/OIDHIA9GJD/iTFKALIAH9w+fHKMk6PV0tChz8cdOBzHXj6tbWjx89pcFxIxAetMjQ8yKxiV0mihxx2lFDOQLG37b/wByCZeonEdWIIsr6P3mp4BKPoVaeOjJ/VL6fOmbXz+YGsgSPWerFcWj3/aNRghrIA45F18vQlWNYnFi334uCnR1HIhPgXY5g3EP6SC+pFIxFqEjEGjjkQkrP+5UM2BRCIBWpCGXqOj9OD8UHDr9QJIXC39oxcaxPVkHkepWH9d95GUfTiD/AE8WSBrQ94zb6rSIokrs+X/yEU16yRTKDX7wiEAEl7bPt+8ghITLIOq/P3jFaxICyW6BbQioAALHLIEA67fHIKukFkm+OIQxKyyHvXjmCg/VQQ817uBrE+jEhHi7kQGXVkSQN/qA3FMX9Q6cWCDXz3hOM467BFOvpA1lk0V1dVhi/wAyDRyQJxZJLDHtCYgGJx9RAyG+CvcwVUxkMMQHTv7yC/8AytjqJOy9/mKgBiDWrVqQA8Rj6d6gXBjH9P28QlP6h9NDwjzUQP1ZA4kMo0F/MCpvpGw2+YNaACQCIHA3MjIs9KxBWvrKi5ZchZUNO4wR9StFt/PlQN9Y7HLwvzJiYisJbCLVQKR1WQBWnbkDAem+l8cuKjXpRHS+ARUCepdTBOl3gAQB1cts9oGiQwGW2+8iJ1L+ptvmDH258DzyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEgQiFSAgICVSBCIEgWBNwJCkBKEBAQIpVSBeYEhSAMCESicQFwL7wJKpAGBICAgRWpVOIAqBPI5lUG4DhwJ9YC3Ab3Acwqa/iAfAlE471Af3MQAWpVRQCkVRuEQ+8qoD3LgBqnAfc+8CLhGVSkSWxCCD7HUKcguAAZSMCG9yiZAgOFAS1CDLLF/iBFyAHLqqh4P1gFWvvAyggwvzCnGoBIUKI7QA/Tz5coKn8PMCAE+C4VdsMf5gQPuYEBKJ5AlAhH8QajJ0wu24UHHqGu8AfzwxAlNEvsHuVVCANwIQF5dQC9SFEjcAaCDX2gW/1UOYGctDHQMq6g1fHEAx0o8UFAgxZAbCXwRouIIJ0TAUSexLcBkqNDzzxLBCgxVf5hQJrV15gEaAHkBbgQeAu3kSqAA5BgGvoIBgi6PbkQJ1dhQCacBlj1BgC6UQQUQB9bQ+bgPUcXZIHa5VRisdF7I1Aq9TOVi/H2gTHLgu+BQgUWVsNLn/sCEBIEZWqpQJ1Hq6caXj6S/qoyMWDRGz+YFyHqaAonfuIgzimuB+lSqvSbAxv/f8A2DVC6haPjn/UgmG9MDx+PniUoUdep8qBARidHx8+0KV06IB7n8wIAMaFcIHky6AVYLEut/iBRi8MicL4WUaJ6X6sURyL/wCQIEwbdkjXzcBji8i8QEd/SUZbAyONbfaFMwQOrXdbiKA5DIY9RX7Bwh1HqvpJdZP45VU4nQIBvYuQUAUlegvEJqIrpPSxxs/P9yrrNAYjIa2BrxuU9L6bQdUNH5+0imQOIophKtQJgR/4wkOTZLMtFAWLBAXbnm1HRgY9VZZAZux/yXTjQ3kDkVodiHIAx6Uwje/4hWMeo/0ydrGuR7/vKNHFZAp3vVQayT1IZXdBp/X/ABLAxH6USQv/AFKH2hVLFLLVePHf/kgyDgDSIdAijL6NYjEYFt+3n595D6uRHSHTsFtP5/uEa3muCLP7SCZih0j00mWIIpYIJyILa5EJDJkAWRyuIGQccRZBIv5+I6VXvHIdWTQ/mEXEA/1ASTziGb1IVoLB+sDtdE1CdAQcvBL8vUiqSEGSR2HHy4QYAK/TxXlyGKDj1kEHtX3uMQugaehxADKkSAHT4Hb8QAIGdrVkiPiYvVsZN2xJgvVk6Bqq3GC53iMjkA++oiM/pzAQF8/n6wqhnABkZDQfzmPqUGe8EQAfUuJLBrEDqYJJAbG4QxJCGQJJ7v7wVWKLokC9L5zIgUQQCSHb4EHozlkrAAo/PeAAPSekEAhEbMDWX6iSQKOhJBMfIrYB1/qBpNo472/nmRNAuoDZdIQNYE9XNd9/P8wlD4BXJMggKJQD/mDF2LAHcdhABbC7VouEUHWLG+RGC4/pyHoL+kIdQBtHyO38yYPtT4HnkBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECGBCIVICAgJVIAiBICBOIEhSUICAgIGTKpCrCBhUgIEI5lDmA8uBDASqQIrcC7gQwBgStmVQ19YE2oU3KD8wHvAhC1AfSAgT6QoIDiUCCdAOAQ4qBHaZ3KIaNQo/pCl61IgRu7lUA7wJ4+xgD9alBEV+YAAHn7QJRLEKlvf0gLAA3AWQoEO6AEoatUPEAdwqWPPmUXRJ5IgE/8AsDIa3zChZqAHCA1APpA17SgOCf8AZhRUl/ECZWGzXiBASMVXtKNWSaS47yDNV6Xf2lVBWiddoFDbP7SB0vHq49pTTek4VnI4lbVSikPHjxADgb/mBMrNV+8B1JlFc3AyRyB+JV0RJJYB4cCkPJaG/MghGK6iGikpRMiClweJRUr8faRULOKVPiUQY3zxzKNDpOyu/vIM54jeKIO2PneUgUciwyf8SKPkhmoFzQ0WSfYiVIwgSOrggBkqVV9ORtvkpLzIIbH6T3a1EEALPpBv6n3lVV/6N/b5xGiFoK9h+IBaryj+IEZWk2/9QpijQt8A+YopY0eQg9ywRkkDqAPdQNenLihw4HOgQCCj25HeVVy2saPK78QIDkQO+qviBciShkSByQfEBliPVaNo/mAw6dkgju9wMWiP7ctLiVYEIFhgLnZ7QNUCcWCjfcOQQf8AjJtGqdS+noCS8hiQhswMjH1AtN8VKKunpDBR5ELExwyyF2DYvUcKM5ZMZYhWENQYEo5EHtVa+GBMj0gkNc9vm4UIQIpbJNfKgaPp6iyMshzB1CAGSguLXz/MsGcMcunpZFt6hVOJy9J4fk/f6wmsjqKD6QmGH81KoCRgOl0OAxr/AJAYljHqLAP6fCcC5YrDpJAJZv55g1lA4hjIl1Yr/MqoOrHEYk35/ZyUbPUf6hZGJCGIHMDIy4HSyfUMuPMpWTSIYBBfq57ftA0CvVlkUNWnAvQej/yFtsgGDfcNjaf9xAuvtAxnmMkf/GxkBvjcpjRAOAZd1WpBccgElWifnmSmGeTNkADYfz2gidZBJQ1pkv44TFyGS6ulFbC2IABks5A8eJBogdd/pFriEaKx9Rx9bA2ijCMZnq2OrpPNJwSNEby7j7SKM5Y7GQf8wgMPVocfSBsEM9eJeqG5ETIMjLEEckK+3+YIr/8AyFhk6LuAxJWgTSf7yJY1mcdC2bY+cQRkIEZZgBEepQVoLLFnE9JQJJb+sVELV4hbLPO4FWQPgcEakFQP6QAfP4/iES0BiXsXA1iCUsb33uQT1dNpMtcygCGyET3rn/cg0R93VORCygTkANmBt45DqIFaqpEYBWQoEE/AfMqrl6ih41XtCGLKFk+KgKKfqA7b1INZAertYhFwOPdh/VyJYhaZ1ld8QFWkQNDzA0xYBeIN1AY54sv83FiY+3PPeeQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECQIYVICAgJVIEMBAQIbgSFICUICAgQyqggWBIUgIEMoeFAQBgSVSBCIFY1AkBCpzKBgD+IE43KqiBBAmhAP7wB0YEhTzKL3YkE+8onD7GUPMCAEXqFOBCkIi+kKHtQEBUAq1ZlEOPiBbUKh14gOXvtAjVPXmBQgUtwMkAWn7SijE2IEySt32hUPJ/wByjROuR7QJi+TAjZqnAg7kGFUaIDUCZLqWlxKBu+xhUs0kRAqZZ+ggQW+7lECb+kAQCFw6UKiHBd6UC5E+YDLuC0X4gTxVcQqmyaREDOC0h93KARIBAfiUAgSwzxxCIDkaovULw2RYkVCWyiBqUCT1I9J8mVAB6sq1IpWsbQgAA6a4gQAlo/WVUtl5F7Eo0c0UkDypMROxDNbXMKyCQVfiFU7T8HzKGYFAXWnEDIFJel6a+3mNGWxtvxKKDyye7Mgg9OzfvUqjAGSF/eAbVkGwDxHAyfRkWEd+OIEYyVMaECMq9O/n3hV11EpcwISAQEABwT+8olEbR6nUonUN2Cl9YVccSLK3abH5jUqYg9OPT/2FCuqyLLR/xxAnpNg7PEK1kDyQkaAoeIREMb6feufgjqol6GGd9/eX9A4jWJxvmBb6SGCq6Xv5/EDOd4v+3jv8/wAyxVGJB6kjwT2kRnIjFssCwxUsVsFZLpAGR185kRjMAYsAEjvS7SxVH9NtFDe9fnt/EabiZ9KAOBJOh5iKivIoDsvnkSmtl9QOIJAFYu5EY/phDZJ7dvaW1TqeQZ6QT3O1cDONAlBPg3v29pRrEAtMDgfOZFTMjrR3iaWhKH6j1dWiTf1kEIzyHSfUKsF2vzKHpGQOVEiloe59h+IDFHEjJYgk2dfKhWAcTaJuy+FY7SjR9SYJBLDPH14gQdPT14sBsk6FiBf6gJNgPXuz251EImaOXViCMsS2rviXSGOQ6v1s6oU+ZLFaOQyORy6WNEHRhMzif0WDrFf/ACK1FFwJ6hibu+ADX+R7wi4vHqPT7E2HIdZxORyI6yz+O8LjQ9Rsnul88SIheXWTiHoiXgDqGXTjkejn0+3EamKF3DGLZrmQrXp6liEQCQxZhALr6ulVRofWQMQwhQ48wIALBeTaJ+v0caN5Z5DJWue/j3iM4Yk9IQKS2i/ikqoH1EAcQrRogI9j5D5kZXMArpAa2oDIMsnEg8EN9oggIyxpl8P5zHBrCrGJq/n5grIOOLZBI2VCNDILMYgA+DIYraBG9GTiLl+nIsknb39IQDYKQ0BcKjOzd2Bz5gaxIHVbPIkxAG2Eh2DAgGCLJJb35+bjEQF7BaVfvCt44obdshCNSoMT0430rvIKwM7o39PfiVA6aN+/z/sg1l+p9RJsfVyIEqxxv59IUAYABYOyoRSOr0gnz3hH2557zyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEMDKhSAgICVSQQyhAQIRAkKQEoQEBxAhqVSBICFICBFKEBzUCfiAlUEAYE/EBUAfMCSqfeBPPEKv0gTvKB5gZP2gXZQgDrUCK4U+GUNNwIQOPoYAKABLgIVnZsXKKPbUBze9qBDqFEfr94BI9ypRAd6e4D4lCqeIGSubECglDmAKIvmBD7/AGlEIIRv6wFkr8wIWLsH3lUFHt9YUyVntEQyCHfmFQVXwQGiiOIA+kfS4UsV25lEIqz+IFyHDHmIM5JICvGyJQBBx6n4gGP014EKje3V2VABnKAQJr31AIdD+9SqDtofmQCSSCBo8cyxEPUAtgyqoSDCH1BkRngn6UIUZ7bMKmN/WUEyNEEQAvIH6fSBESCMj4qUGGH34MKgJxDV/OIFO9MnTpwANohd4FXYGDUyoM2IUFBk/wAQJ06FkDV3qXRkJvV0FuBsE9w/2kGOCU3yrMqoRZ0gaQsiUQmtqwK4gaPqzolPZ5+sE8gSQHT24DEE5WQfaBP7mQi7G5QXQMgueDvvHVZJxSCINMwKDV0xAgOQyxCvmXxVDP6gSHQkGcQSfUBZIff5/EtFDPkA6MCYLqsMo5OAL6DTAGxAY49I6QUd1G6qMDL0m1yUNcS4dMcijZKZFUYBFsgjJcEJwGSCGgDoDUDJzxHrH6T3N7v+ZcANY4g2OHx7Qre8GtmypD6yVYRK3wpSJliB6gUro9o0iAPJEoP6qVQ4MfpDO189oNNF+lcECQM0igT2u5YLlisSiC7LuCMAJ8DeRqFPVjkaYTYArx+JTrRPTjsn0/fuZOiFhgF4hiBMsfSCeohfjlSw1cgGPUfoNwM/1Cc8UMeoA0AfGnLFZxOP/j6iCSPevlR+H1Rl6unkgIkaO7gsQjKurBDaLJ1AuDOW0DVGvaKBR2Ur38+KFUAZYf3HLSpkfzCXyhasensu0C5dZyxPINOifMJiEEIYlvYP+DCtAgYYnMYjHsgvcfiEQFDIkElrgW/n3kAZFgeZFMOCafcfgypVx2C62a8/iQUXliSel69vaEqABZDInJ0teIE6seodQGTNlfmMFwOQ/SXl9yRIjoWf0j1Hk394RBksiMlVEjmQaaHAHuowCR0vE9QgB0gEnb5u5EuiAC9PSKXav+/eNB28n1Og/r/mBsWTj1ernxIMAkap6B2ZRchZBJyALxxPb3jUQl4l8ENBSDZOOWTPpxddlqE+KSRg+r6yC4D1M5E933hBZAgkaNrR+VB0IQPSAXYr+YA5MIMYk2xxIKGBYJaSPEImPUMgARQ2IVoVZW/t3kRMQf7jTWtfLlGsQWeEaciGNZALYbPeOil9KYISD32kQAAeLPftADLFvHttPiowfcnnvOICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEgQwqQEBASqQIYCAgRQJCkBKEBAQJzKqQKYCFSAgRShAdoEqUIUuBKgOKgPEBuFT2/eUN7gFcKnPIlAwFcj3gRVAcQAgS/EKsCV2lCnqBLgG/tKFf6kU5hU5lQO1+0Kh3zAAAUZQ4RBCgR3XaA1bcKgDpVKLyCNyCDTBP3lGu7kGNAyir1O4AviBO2J3KqA+PEAATVwJ/aa8KFLBosGABJ44TgEdSgwE+KhQNI94DTQ9wIEHSfAlEyCKtsQNFkcSDKs6HIEqlHt5gBZorzAhNXqFC2rfeUMgywdwBAIAAY4gD70RswJkEGU/4g1GAUUqO4UCRx3KIf1AfZwATxIFmUQC/0EEeKgAEQkCYVEQB0lA6JMC1pPj3gMh1AIY3AAAEAfQjXMDIuz9IVR6gCF7EJwJZFh/vKKgC/DJMCIddj67gMryQR47GUiYgjeLWztwHT6S2eKVQunpLxBZ7dvpAmJIoWHdQDyO86WnCgISFeHoQgd2BrQ5Eqp12SaCqMMKtZD7CBk9j27cSq11AklX2/wBSJhbW2IVCS+pHIYlygQepJkH7GBnLpK12JB38qIqIYFVz7S9BIdJxBIv0/wC4FZJAB2KHmAQF4Ag87v4IExBJAoB6Ca1LpVvJH3F2j84kGMcQhliACN9zLqtsYg9SPzUkKwQgQr0OTKrRGIzOaHd6hIhCNEBBrz8MKvGOJZAFn94Rl5IgptEGVQf06RS2TX0iUtZBy/8AGVjjvtSlUVvBgHZj+iA5X1EaTFEeYGxR6W3QviQASFRKOlHRAgBgcgeot9/9SiE7QHtoH44AEZWcVj7X3hU/qBUqJFmwgJYRq8sf1aKD4ag8jNPLJ+R4gGEPVrdUdUoGXiU2AOT71CgzBG2BSHv8qMGjs4sbsvv8EJqEAk5aJ2B28wcbyIOI0Ae/EiHbpJ6TjrxChKwKybFqwhGJ9THMDLYIp1JhY1gQcTiGcd3rx8+AmMiyDiVibqxKrWP9mQQ75KRDEZHK8cWHYI7R4ATDyXkD6SFOmsbGAOkL1GjeL0MXwHIzVyeQRKLLYgBWQokEb7bMDODI6tnjmKNY9WWIyJyBHcfv87yVOKBkMSw/B5gAgiAgrXMAP1WMSPEIZZepAoUAMhx8cYRrDqACVGiDZkSgxKIssrfHP8wUGWJJABbs/WAw6sSg9pE/PgkoABskkmoF6h2DLZApQjRLItkilz4kE/8AIQyeddowxSgH6g/zCJYJBetA/iBsZFnJWKa/mRE1kL2IUaZHFlmEaR6yBweZBCiAUx5HHz9o4H6cuXd94Tr7s895xAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQJAhhUgICAlUkEIlCAgQ6gSFICUICA3AnMqkKnEIQpAQIpQgA4EPvKEKQJAGA1AbFQM3/mVVO4DmFTzKB1UAPeBChAHdQC99wqACA+CA3xKH0gTlyhUgmVVzCnjmBbf5lGSgGhCia1AsArcDN+zlAuzpcqAL13hTjjcCbbFDcouVl9pBggu/8AUqqQH/uEOp6UAO/fxKo/rAjpUxvtAH7CBExXbvCgBAv6GUXVk2tQIFv7Qoa2PxAGr/EQZyrEg7/aUPNp6hTIE/XgQFJ/Q1zzAmRCR3+IALqoL3gSv1fAZVXnnUgECrY/BlEFYlHj7SoGqVSKiBJAFQKFoDeoGcaCoA3uVQp7rxxAB8m/aBmulWR4tyq0SDlxXmQZJJaJ8F8yht9k24FJGrJFe8CI4g9mtQa11PH9WI/xAwW0ygUb3Kqn9TxNbHaAay0veBkhgFPm/nvAuX6QMWCSxrcQTHIBWQfMq4EgaC7U4DJ5F4k0dtwREsXSfJgUdPTYArZgR2uVXz6QI7TAR0pVUkml7ODGbObALHEC5MPEvz58wv6mZsYgEnYcsBBnE70f9wBB69lqve4GTnkMCUiloS/TGgGj1L5cgnpJrSt7lUY6urrNjuvnMH4nT1Av+47AgTL9JyGRrsWTEFIyJQvq7a9pQdLq0dkee0gx6mcsgCBVc95VX+oDlkHvgGIMnFF7HGWo0aIxOYFV/ba4gTryyyeu9XLi5hiVi+ogco6kMU5EaBAxLviBknIA4hsbyIIf2lI0cnZJ6dbdf5MGYwMWOMSt+TX8SqgxGIIOQXCLPtGjdDn1pMD33IAyHT1cHn66gZzJwAL9IoXuWHTJAkggkCxtH2iKZAjHLEM5FsimvaVGSgevIAHaKENGdrqyZNlmhCRrH9PUBkx6a5UDGfV0EEMneV18e/ETBQT19ST2i65hUxoHJWke45JH3gbBDBo0bGX3/mEPQwi9G+fpIelf+PINDpt81L9RDkskwWGmzBIreRYAxPfmQxvHIdwPPb6yDGHc0wMisfniVKuS6jkASyQf8fiQMdDqyN8915iidLAxGD2glA31PO/7fHf/ALIjJDboavg/FKNDRIQx6STSuQXqBrHHq6aH8/SMQ0CRkSOoAX9YG+odJ6siCPFi5MP4wQHQCxy+8DRWX9TqBVA/BInxrqIy2AKtuBBiwCABb4+f9gXIg4jEU93o+8IgyAApdzupBcsvH24hMXIMEj0gHyPnMCrpAS3WKkFGQGJBpCyPlQliEkZKwxz3+CAGTLJO2CNQVRkTzIJjebCfjiBsnY2hsHYkRMyX04ga32MooQK7U+0gIHLfCB2oQJzAO+pcGDGgMViSUa+kg+5PPeaQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECQBgZhSAgICVSBCICAgQ3AkKQEoQEAYGZVIUhCFIAwJ9KlCA1AkB9pVFAkBXeA+kCb4hUMovu4CFTz5lCrcBAnGoDs/2gClcCHvW5VFIL9IEV8iUT3J+sAd7tQIRfvCntAFGxKBY4qIqLiAOhUoKlcCCFU0PrAh349oD8+IDt34cARVwMkAbKPcyikc3/iAKRChWcrHb+ZVW1ZcImJ9JBuAOjqFQpDkmwhAcXswIdIfSWKtUCIBDf57wGRoEOBCWGQPtKIUy7elcAKKBcAyW67+3xwoNj7VAhIb/KgCQCix2KlVBXjybgC1seKgZQQP/wA7Mo0AxeuBIJkOFXkShkd7qvpCmJJtAB+8YIATilSrxAhJxNG3Vwq6ZsP6yohvEDqb2hALue4qFS8bq69oAnHsUr4gXZRTO+8DOHU+ERrcqmX/ALFrul9IDEEAekHgGABCohPjcCOgSBZa8Qq5V1HLEB0vAhGbdAAEn3mla9RxOOzqr+8iM9Q6geok86j4oP0Mgli0IFzPVYJIbNXqCM0l2+kKoPSgQGd/O0odKQOKPAacGoAEulOuTAyek0yaN6lVSiaK5IEAdrELf5gQnqHUBaVGOBkCP/U4jzqA6cf01yuY9ELONLueUHKugxHT0kBNGr13jQw2kyvc/aKJkR0n1A2K3AuRWdMI0KgQJg+UeB8uAKQD6TaPaVVzAAvLHsTuD1k9AxHVwKID+agU4gsgM+7IjQZ9VUSgBuFZy9RRFvXPsRqXhFAOOIxZybo06g1nAkf08sVo7Ig7VYOBPVySCOHxH0ZOQI6QTkSGzx7/AIlz6prA9QZIALFR9As40N6+e0Cvp6SQDv1SB6SAXY8kkSiZZE4YkaA4MKnWTh15HmuGeBH0/gF1ZEAZN6q13lDA4jJYWO/znf3i8Cychk6Nq34/f7iBKo7xIt9oVDmT6rQT7/LjDFyz6cyDjkQkS9D+P+SxM1nGsWKxGzj+/wA9oK2XiGcsnwTxxIMjpOAICAx7sgwNYoiyPUKHzcl8FyZICCet38cImRbKDBHPHxXAv9PM5jqOQX/rj894sRcWl1YgEAIH9oDIorE8rXeTBSRiGQnpU677EIAg44Y9WRAF8cagXEYpknIB2tX/AIchVIItsmjTUAcgQ+mlZP8AoxiLiXl0dTba/wAyUTAZN9RRHArxFFyJI6iHo7tyJxrAHEADp7Dv3+e0FG0CyCf05COIjKDsnKwteIVsk4slEk0B4kxGWasANoSjWLyx6RkCdBUvz2k4l/1OoAg9J7Fkr9rj4KGP6Y9JNd1syfRrL1DqGOW2QfaEjLFkjR2YxWmcQGQTskj8wilBDM4toHaMmCjYAxB49IhErXSSOk7hVKyva3xHEDaSAtESBeYZxtKxHE4pB/tyBAOk1A//2Q==","u":""},{"nm":"[Asset] _clip1","id":"7","layers":[{"ty":4,"nm":"Vector","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[{"ty":"sh","bm":0,"hd":false,"nm":"","d":1,"ks":{"a":0,"k":{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[2000,0],[0,0],[0,2000],[2000,2000],[2000,0]]}}},{"ty":"fl","bm":0,"hd":false,"nm":"","c":{"a":0,"k":[0,0,0]},"r":1,"o":{"a":0,"k":100}}],"ind":1}]},{"nm":"[Asset] Group","id":"8","layers":[{"ty":4,"nm":"Group","sr":1,"st":0,"op":91,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[999.99,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[999.99,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[],"ind":1},{"ty":4,"nm":"_Image3 (Border)","sr":1,"st":0,"op":102,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[999.9945678710938,1000.0004272460938]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[999.9945678710938,1000.0004272460938]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[{"ty":"sh","bm":0,"hd":false,"nm":"","d":1,"ks":{"a":0,"k":{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}}},{"ty":"st","bm":0,"hd":false,"nm":"","lc":2,"lj":2,"ml":1,"o":{"a":0,"k":0},"w":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0.9999974966049194],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0.9999974966049194],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0.9999974966049194],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0.9999974966049194],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0.9999974966049194],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0.9999974966049194],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0.9999974966049194],"t":90},{"s":[0.9999974966049194],"t":102}]},"c":{"a":0,"k":[0,0,0]}}],"ind":2,"parent":1},{"ty":4,"nm":"_Image3 (Mask)","sr":1,"st":0,"op":102,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"td":1,"ao":0,"ks":{"a":{"a":0,"k":[0,0]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[0,0]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[{"ty":"gr","bm":0,"hd":false,"nm":"","it":[{"ty":"sh","bm":0,"hd":false,"nm":"","d":1,"ks":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}],"t":90},{"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0],[0,0]],"v":[[0,0],[1999.99,0],[1999.99,2000],[0,2000],[0,0]]}],"t":102}]}},{"ty":"fl","bm":0,"hd":false,"nm":"","c":{"a":0,"k":[1,0,0]},"r":2,"o":{"a":0,"k":100}},{"ty":"tr","a":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":90},{"s":[999.9945678710938,1000.0004272460938],"t":102}]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[999.9945678710938,1000.0004272460938],"t":90},{"s":[999.9945678710938,1000.0004272460938],"t":102}]},"r":{"a":1,"k":[{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":0},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":12},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":30},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":42},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":60},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":72},{"o":{"x":0.33,"y":1},"i":{"x":0.68,"y":1},"s":[0],"t":90},{"s":[0],"t":102}]},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}}]}],"ind":3,"parent":1},{"ty":2,"nm":"_Image3","sr":1,"st":0,"op":102,"ip":0,"hd":false,"ddd":0,"bm":0,"tt":1,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[99.99945678710938,100.00004272460939]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[999.9945678710938,1000.0004272460938]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"refId":"6fbbe90a284d32d2276a6cdf144a7fe49b442ec4","ind":4,"parent":1}]},{"id":"6fbbe90a284d32d2276a6cdf144a7fe49b442ec4","e":1,"w":2000,"h":2000,"p":"data:image/png;base64,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","u":""}]} \ No newline at end of file diff --git a/app/src/main/res/raw/root.crt b/app/src/main/res/raw/root.crt new file mode 100644 index 0000000..593a069 --- /dev/null +++ b/app/src/main/res/raw/root.crt @@ -0,0 +1,11 @@ +-----BEGIN CERTIFICATE----- +MIIBpDCCAUqgAwIBAgIRAI/SRGy6bA6e4vvMIYZ1k0EwCgYIKoZIzj0EAwIwMDEu +MCwGA1UEAxMlQ2FkZHkgTG9jYWwgQXV0aG9yaXR5IC0gMjAyNiBFQ0MgUm9vdDAe +Fw0yNjA0MDYxMDI2MjlaFw0zNjAyMTMxMDI2MjlaMDAxLjAsBgNVBAMTJUNhZGR5 +IExvY2FsIEF1dGhvcml0eSAtIDIwMjYgRUNDIFJvb3QwWTATBgcqhkjOPQIBBggq +hkjOPQMBBwNCAATtG4qugfT09Y6s2HqTrfx7ZVAnoms8z2J/0BgS+yvBTHMQr9bP +Dpl5eYMGEdzKKLuz7zFxAPt2FyPU/xf+R8/jo0UwQzAOBgNVHQ8BAf8EBAMCAQYw +EgYDVR0TAQH/BAgwBgEB/wIBATAdBgNVHQ4EFgQUM4CUTmtbdbVr77Owah55rj/W +IIswCgYIKoZIzj0EAwIDSAAwRQIhAOUB/yfaQjwV5bT8CqJmPFWXhr2Iv8p5DrsA +mlHPZjFgAiAnkIo4DPOoDqTNpfqPRHra01PZN4pXj/aT93GvHvDf6Q== +-----END CERTIFICATE----- diff --git a/app/src/main/res/raw/start.json b/app/src/main/res/raw/start.json new file mode 100644 index 0000000..bbd9853 --- /dev/null +++ b/app/src/main/res/raw/start.json @@ -0,0 +1 @@ +{"nm":"start","ddd":0,"h":2000,"w":2000,"meta":{"g":"LottieFiles Figma v107"},"layers":[{"ty":4,"nm":"Rectangle 3","sr":1,"st":0,"op":14.8,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":1,"k":[{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,258.5],"t":0},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,258.5],"t":4},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,108],"t":5},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,108],"t":8},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,436],"t":9},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,436],"t":13},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,258.5],"t":14},{"s":[146,258.5],"t":17}]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":1,"k":[{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[1371,1510.5],"t":0},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[1371,1510.5],"t":4},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[1371,1661],"t":5},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[1371,1661],"t":8},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[1371,1333],"t":9},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[1371,1333],"t":13},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[1371,1510.5],"t":14},{"s":[1371,1510.5],"t":17}]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[{"ty":"sh","bm":0,"hd":false,"nm":"","d":1,"ks":{"a":1,"k":[{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,517],[0,517],[0,0]]}],"t":0},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,517],[0,517],[0,0]]}],"t":4},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,216],[0,216],[0,0]]}],"t":5},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,216],[0,216],[0,0]]}],"t":8},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,872],[0,872],[0,0]]}],"t":9},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,872],[0,872],[0,0]]}],"t":13},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,517],[0,517],[0,0]]}],"t":14},{"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,517],[0,517],[0,0]]}],"t":17}]}},{"ty":"fl","bm":0,"hd":false,"nm":"","c":{"a":0,"k":[0.851,0.851,0.851]},"r":1,"o":{"a":0,"k":100}}],"ind":1},{"ty":4,"nm":"Rectangle 2","sr":1,"st":0,"op":14.8,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":1,"k":[{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,430.5],"t":0},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,430.5],"t":4},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,224.5],"t":5},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,224.5],"t":8},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,249],"t":9},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,249],"t":13},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,430.5],"t":14},{"s":[146,430.5],"t":17}]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":1,"k":[{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[890,1338.5],"t":0},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[890,1338.5],"t":4},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[890,1544.5],"t":5},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[890,1544.5],"t":8},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[890,1520],"t":9},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[890,1520],"t":13},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[890,1338.5],"t":14},{"s":[890,1338.5],"t":17}]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[{"ty":"sh","bm":0,"hd":false,"nm":"","d":1,"ks":{"a":1,"k":[{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,861],[0,861],[0,0]]}],"t":0},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,861],[0,861],[0,0]]}],"t":4},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,449],[0,449],[0,0]]}],"t":5},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,449],[0,449],[0,0]]}],"t":8},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,498],[0,498],[0,0]]}],"t":9},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,498],[0,498],[0,0]]}],"t":13},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,861],[0,861],[0,0]]}],"t":14},{"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,861],[0,861],[0,0]]}],"t":17}]}},{"ty":"fl","bm":0,"hd":false,"nm":"","c":{"a":0,"k":[0.851,0.851,0.851]},"r":1,"o":{"a":0,"k":100}}],"ind":2},{"ty":4,"nm":"Rectangle 1","sr":1,"st":0,"op":14.8,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":1,"k":[{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,200],"t":0},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,200],"t":4},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,436],"t":5},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,436],"t":8},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,103],"t":9},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,103],"t":13},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[146,200],"t":14},{"s":[146,200],"t":17}]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":1,"k":[{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[409,1569],"t":0},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[409,1569],"t":4},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[409,1333],"t":5},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[409,1333],"t":8},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[409,1666],"t":9},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[409,1666],"t":13},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[409,1569],"t":14},{"s":[409,1569],"t":17}]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[{"ty":"sh","bm":0,"hd":false,"nm":"","d":1,"ks":{"a":1,"k":[{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,400],[0,400],[0,0]]}],"t":0},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,400],[0,400],[0,0]]}],"t":4},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,872],[0,872],[0,0]]}],"t":5},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,872],[0,872],[0,0]]}],"t":8},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,206],[0,206],[0,0]]}],"t":9},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,206],[0,206],[0,0]]}],"t":13},{"h":1,"o":{"x":0.167,"y":0.167},"i":{"x":0.833,"y":0.833},"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,400],[0,400],[0,0]]}],"t":14},{"s":[{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[292,0],[292,400],[0,400],[0,0]]}],"t":17}]}},{"ty":"fl","bm":0,"hd":false,"nm":"","c":{"a":0,"k":[0.851,0.851,0.851]},"r":1,"o":{"a":0,"k":100}}],"ind":3},{"ty":4,"nm":"Frame 1 Bg","sr":1,"st":0,"op":14.8,"ip":0,"hd":false,"ddd":0,"bm":0,"hasMask":false,"ao":0,"ks":{"a":{"a":0,"k":[1000,1000]},"s":{"a":0,"k":[100,100]},"sk":{"a":0,"k":0},"p":{"a":0,"k":[1000,1000]},"r":{"a":0,"k":0},"sa":{"a":0,"k":0},"o":{"a":0,"k":100}},"shapes":[{"ty":"sh","bm":0,"hd":false,"nm":"","d":1,"ks":{"a":0,"k":{"c":true,"i":[[0,0],[0,0],[0,0],[0,0]],"o":[[0,0],[0,0],[0,0],[0,0]],"v":[[2000,0],[2000,2000],[0,2000],[0,0]]}}},{"ty":"fl","bm":0,"hd":false,"nm":"","c":{"a":0,"k":[1,1,1]},"r":1,"o":{"a":0,"k":100}}],"ind":4}],"v":"5.7.0","fr":60,"op":13.8,"ip":0,"assets":[]} \ No newline at end of file diff --git a/app/src/main/res/raw/tg_chat_v3.svg b/app/src/main/res/raw/tg_chat_v3.svg new file mode 100644 index 0000000..e152a8d --- /dev/null +++ b/app/src/main/res/raw/tg_chat_v3.svg @@ -0,0 +1,49 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml new file mode 100644 index 0000000..5d21f44 --- /dev/null +++ b/app/src/main/res/values/colors.xml @@ -0,0 +1,13 @@ + + + #FFBB86FC + #FF6200EE + #FF3700B3 + #FF03DAC5 + #FF018786 + #FF000000 + #FFFFFFFF + + #FFFF6700 + #FFFFAD00 + \ No newline at end of file diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml new file mode 100644 index 0000000..61a3f15 --- /dev/null +++ b/app/src/main/res/values/strings.xml @@ -0,0 +1,3 @@ + + Login_V3 + \ No newline at end of file diff --git a/app/src/main/res/values/themes.xml b/app/src/main/res/values/themes.xml new file mode 100644 index 0000000..c334915 --- /dev/null +++ b/app/src/main/res/values/themes.xml @@ -0,0 +1,25 @@ + + + + +