{ "cells": [ { "cell_type": "markdown", "id": "368f9a80", "metadata": {}, "source": [ "# Ising Model: Temperature Sweep and Critical Behavior\n", "\n", "The two-dimensional Ising model is the simplest lattice system that still exhibits a genuine thermodynamic phase transition. Each site carries a spin $s_i \\in \\{+1,-1\\}$ and neighbouring spins interact through $H = -J \\sum_{\\langle i,j \\rangle} s_i s_j$. At low temperature the ferromagnetic coupling dominates and the lattice orders. At high temperature entropy wins, domains fragment, and the net magnetization disappears. In two dimensions the transition occurs at Onsager’s exact critical temperature $T_c = 2 / \\ln(1 + \\sqrt{2}) \\approx 2.269$ [[1]](#Bibliography).\n", "\n", "This notebook turns the Ising temperature-sweep workflow into a guided analysis. It first shows what ordered and disordered configurations look like, then tracks how the order parameter and the energy vary with temperature. The next sections focus on fluctuation observables, entropy, and the growth of autocorrelation near the transition. Every figure is tied either to the project cache at `results/ising/temperature_sweep_data.npz` or to a lightweight checkerboard-Metropolis fallback that uses the same observable definitions [[2]](#Bibliography) [[3]](#Bibliography)." ] }, { "cell_type": "code", "execution_count": 10, "id": "8567dd23", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Exact Onsager T_c = 2.269185\n", "Repository root: /workspaces/vibespin\n", "Primary sweep path: /workspaces/vibespin/results/ising/temperature_sweep_data.npz\n" ] } ], "source": [ "from __future__ import annotations\n", "\n", "from pathlib import Path\n", "\n", "import matplotlib.colors as mcolors\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "from models.ising_model import IsingSimulation\n", "from utils.exceptions import ZeroVarianceAutocorrelationError\n", "from utils.analysis import (\n", " DEFAULT_CONFIDENCE_LEVEL,\n", " _detect_quasi_steady_stuck,\n", " calculate_autocorr,\n", " estimate_relaxation_time_two_start,\n", " summarize_derived_observable,\n", " summarize_entropy_observable,\n", " summarize_primary_observable,\n", ")\n", "from utils.equilibration import convergence_equilibrate\n", "\n", "\n", "def _find_repo_root() -> Path:\n", " cwd = Path.cwd().resolve()\n", " for candidate in (cwd, *cwd.parents):\n", " if (candidate / 'pyproject.toml').exists() and (candidate / 'results').exists():\n", " return candidate\n", " return cwd\n", "\n", "\n", "REPO_ROOT = _find_repo_root()\n", "TC_ISING = 2.0 / np.log(1.0 + np.sqrt(2.0))\n", "CACHE_PATH = REPO_ROOT / 'results' / 'ising' / 'temperature_sweep_data.npz'\n", "PALETTE = {\n", " 'mag': '#4878CF',\n", " 'eng': '#6ACC65',\n", " 'chi': '#EE854A',\n", " 'cv': '#D65F5F',\n", " 'entropy': '#956CB4',\n", " 'tau': '#8C613C',\n", "}\n", "SPIN_CMAP = mcolors.ListedColormap(['#4878CF', '#D65F5F'])\n", "\n", "plt.rcParams['figure.dpi'] = 120\n", "\n", "print(f'Exact Onsager T_c = {TC_ISING:.6f}')\n", "print(f'Repository root: {REPO_ROOT}')\n", "print(f'Primary sweep path: {CACHE_PATH}')" ] }, { "cell_type": "markdown", "id": "7103b22d", "metadata": {}, "source": [ "## Ordered and Disordered Configurations\n", "\n", "A thermodynamic curve is easier to read when the underlying configurations are visible. The two panels below show equilibrated checkerboard-Metropolis configurations below and above $T_c$. Below the transition, most spins belong to one macroscopic domain and the lattice carries a large magnetization. Above the transition, thermal disorder breaks the system into short correlated patches. The figure is qualitative, but it shows the same change of regime that later appears in the temperature-dependent observables." ] }, { "cell_type": "code", "execution_count": 11, "id": "ba95b78e", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def _equilibrated_state(*, temp: float, size: int = 48, seed: int = 0) -> np.ndarray:\n", " sim_random = IsingSimulation(\n", " size=size,\n", " temp=temp,\n", " update='checkerboard',\n", " init_state='random',\n", " seed=seed,\n", " )\n", " sim_ordered = IsingSimulation(\n", " size=size,\n", " temp=temp,\n", " update='checkerboard',\n", " init_state='ordered',\n", " seed=seed,\n", " )\n", " convergence_equilibrate(\n", " sim_random,\n", " sim_ordered,\n", " chunk_size=120,\n", " max_steps=6000,\n", " )\n", " sim_random.run(n_steps=200)\n", " return np.array(sim_random.spins, copy=True)\n", "\n", "snapshot_temperatures = [0.8 * TC_ISING, 1.2 * TC_ISING]\n", "snapshot_titles = ['Below $T_c$', 'Above $T_c$']\n", "snapshot_states = [\n", " _equilibrated_state(temp=float(temp), seed=200 + idx)\n", " for idx, temp in enumerate(snapshot_temperatures)\n", "]\n", "\n", "fig, axes = plt.subplots(1, 2, figsize=(9, 4.5))\n", "for ax, spins, title, temp in zip(axes, snapshot_states, snapshot_titles, snapshot_temperatures):\n", " ax.imshow(spins, cmap=SPIN_CMAP, vmin=-1, vmax=1, interpolation='nearest')\n", " ax.set_title(f'{title}\\n$T = {temp:.3f}$')\n", " ax.set_xticks([])\n", " ax.set_yticks([])\n", "\n", "fig.suptitle('Equilibrated checkerboard-Metropolis snapshots', y=0.98)\n", "fig.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "c82b7da5", "metadata": {}, "source": [ "## Load or compute sweep data\n", "\n", "The notebook first looks for the project cache at `results/ising/temperature_sweep_data.npz` by walking up to the repository root from the current working directory. If that file contains a sufficiently dense temperature grid, the plots are built from it directly. A full cache includes standardized uncertainty fields, effective sample sizes, and autocorrelation metadata.\n", "\n", "When the precomputed data file is unavailable or only contains smoke-test points, the notebook falls back to a compact checkerboard-Metropolis calculation. To guarantee equilibrium without manual tuning, this fallback uses the **two-start convergence** protocol. It evolves a random-start and an ordered-start simulation in parallel and declares convergence when both smoothed magnetization traces satisfy a mutual cross-band criterion over a dwell window, protected by a sigma-floor to prevent false positives in flat regimes. At very low temperatures, where domain walls can trap the random-start trace in a metastable plateau, it employs **quasi-steady stuck detection** to fall back to the ordered-start simulation for valid measurements.\n", "\n", "This fallback computation is meant for demonstration and validation. It is intentionally lightweight and may not match full-production statistics. For publication-grade sweeps with higher statistics, run the dedicated script directly. For example, to generate a dense, multi-seed dataset across an extended temperature range, run:\n", "\n", "```bash\n", "python scripts/ising/temperature_sweep.py --size 48 --t-min 1.0 --t-max 4.0 --t-points 45 --meas-steps 8000 --n-seeds 5\n", "```\n", "\n", "Finally, the sweep uses the **checkerboard-Metropolis** array layout because its excellent SIMD and multi-core throughput makes it the most efficient choice away from criticality. However, when working very close to the critical temperature $T_c$, cluster algorithms like Wolff are vastly superior to reduce critical slowing down. While Wolff is preferred in the critical regime, checkerboard remains the baseline here to maintain a consistent dynamic exponent through the whole sweep [[4]](#Bibliography) [[5]](#Bibliography)." ] }, { "cell_type": "code", "execution_count": 12, "id": "c9a53838", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Loaded cached sweep from /workspaces/vibespin/results/ising/temperature_sweep_data.npz using 5 retained seeds out of 5 requested.\n", "Temperature points: 45\n", "retained seeds = 5 / requested seeds = 5, confidence level = 0.68\n", "Excluded points in thermodynamic plots: 0\n" ] } ], "source": [ "REQUIRED_KEYS = {\n", " 'temperatures',\n", " 'avg_m_value', 'avg_m_ci_low', 'avg_m_ci_high', 'avg_m_n_eff',\n", " 'avg_e_value', 'avg_e_ci_low', 'avg_e_ci_high',\n", " 'susc_value', 'susc_ci_low', 'susc_ci_high',\n", " 'spec_h_value', 'spec_h_err', 'spec_h_ci_low', 'spec_h_ci_high',\n", " 'tau_int',\n", " 'undefined_autocorr_flag', 'tau_interval_unstable_flag',\n", "}\n", "\n", "fallback_meas_steps = 1200\n", "\n", "\n", "def _run_local_sweep_point(\n", " *,\n", " temp: float,\n", " size: int,\n", " meas_steps: int,\n", " eq_probe_steps: int,\n", " eq_max_steps: int,\n", " seed: int,\n", ") -> dict[str, float]:\n", " sim_random = IsingSimulation(\n", " size=size,\n", " temp=temp,\n", " update='checkerboard',\n", " init_state='random',\n", " seed=seed,\n", " )\n", " sim_ordered = IsingSimulation(\n", " size=size,\n", " temp=temp,\n", " update='checkerboard',\n", " init_state='ordered',\n", " seed=seed,\n", " )\n", " convergence_equilibrate(\n", " sim_random,\n", " sim_ordered,\n", " chunk_size=eq_probe_steps,\n", " max_steps=eq_max_steps,\n", " )\n", "\n", " mags, engs = sim_random.run(n_steps=meas_steps)\n", " mags_arr = np.asarray(mags, dtype=float)\n", " engs_arr = np.asarray(engs, dtype=float)\n", "\n", " mag = summarize_primary_observable(\n", " time_series=mags_arr,\n", " confidence=DEFAULT_CONFIDENCE_LEVEL,\n", " )\n", " eng = summarize_primary_observable(\n", " time_series=engs_arr,\n", " confidence=DEFAULT_CONFIDENCE_LEVEL,\n", " )\n", " chi = summarize_derived_observable(\n", " magnetization_series=mags_arr,\n", " temperature=temp,\n", " L=size,\n", " observable='chi',\n", " confidence=DEFAULT_CONFIDENCE_LEVEL,\n", " )\n", " cv = summarize_derived_observable(\n", " energy_series=engs_arr,\n", " temperature=temp,\n", " L=size,\n", " observable='cv',\n", " confidence=DEFAULT_CONFIDENCE_LEVEL,\n", " )\n", "\n", " return {\n", " 'avg_m_value': float(mag['value']),\n", " 'avg_m_ci_low': float(mag['ci_low']),\n", " 'avg_m_ci_high': float(mag['ci_high']),\n", " 'avg_m_n_eff': float(mag['n_eff']),\n", " 'avg_e_value': float(eng['value']),\n", " 'avg_e_ci_low': float(eng['ci_low']),\n", " 'avg_e_ci_high': float(eng['ci_high']),\n", " 'susc_value': float(chi['value']),\n", " 'susc_ci_low': float(chi['ci_low']),\n", " 'susc_ci_high': float(chi['ci_high']),\n", " 'spec_h_value': float(cv['value']),\n", " 'spec_h_err': float(cv['err']),\n", " 'spec_h_ci_low': float(cv['ci_low']),\n", " 'spec_h_ci_high': float(cv['ci_high']),\n", " 'tau_int': float(mag['tau_int']),\n", " 'tau_int_ci_low': float(mag['ci_low']) if not np.isfinite(mag['tau_int']) else float(max(0.0, mag['tau_int'] - mag['err'])),\n", " 'tau_int_ci_high': float(mag['ci_high']) if not np.isfinite(mag['tau_int']) else float(mag['tau_int'] + mag['err']),\n", " }\n", "\n", "\n", "cache_loaded = False\n", "cache_reason = ''\n", "requested_n_seeds = 1\n", "retained_n_seeds = 1\n", "\n", "if CACHE_PATH.exists():\n", " cache = np.load(CACHE_PATH)\n", " if REQUIRED_KEYS.issubset(set(cache.files)) and int(cache['temperatures'].size) >= 10:\n", " temperatures = np.asarray(cache['temperatures'], dtype=float)\n", " avg_m = np.asarray(cache['avg_m_value'], dtype=float)\n", " avg_m_ci_low = np.asarray(cache['avg_m_ci_low'], dtype=float)\n", " avg_m_ci_high = np.asarray(cache['avg_m_ci_high'], dtype=float)\n", " avg_m_n_eff = np.asarray(cache['avg_m_n_eff'], dtype=float)\n", " avg_e = np.asarray(cache['avg_e_value'], dtype=float)\n", " avg_e_ci_low = np.asarray(cache['avg_e_ci_low'], dtype=float)\n", " avg_e_ci_high = np.asarray(cache['avg_e_ci_high'], dtype=float)\n", " susc = np.asarray(cache['susc_value'], dtype=float)\n", " susc_ci_low = np.asarray(cache['susc_ci_low'], dtype=float)\n", " susc_ci_high = np.asarray(cache['susc_ci_high'], dtype=float)\n", " spec_h = np.asarray(cache['spec_h_value'], dtype=float)\n", " spec_h_err = np.asarray(cache['spec_h_err'], dtype=float)\n", " spec_h_ci_low = np.asarray(cache['spec_h_ci_low'], dtype=float)\n", " spec_h_ci_high = np.asarray(cache['spec_h_ci_high'], dtype=float)\n", " tau_int = np.asarray(cache['tau_int'], dtype=float)\n", " tau_int_ci_low = (\n", " np.asarray(cache['tau_int_ci_low'], dtype=float)\n", " if 'tau_int_ci_low' in cache.files\n", " else tau_int\n", " )\n", " tau_int_ci_high = (\n", " np.asarray(cache['tau_int_ci_high'], dtype=float)\n", " if 'tau_int_ci_high' in cache.files\n", " else tau_int\n", " )\n", " undefined_autocorr_flag = np.asarray(cache['undefined_autocorr_flag'], dtype=np.uint8)\n", " tau_interval_unstable_flag = np.asarray(cache['tau_interval_unstable_flag'], dtype=np.uint8)\n", " low_effective_sample_flag = (\n", " np.asarray(cache['low_effective_sample_flag'], dtype=np.uint8)\n", " if 'low_effective_sample_flag' in cache.files\n", " else np.zeros_like(temperatures, dtype=np.uint8)\n", " )\n", " entropy = (\n", " np.asarray(cache['entropy_value'], dtype=float)\n", " if 'entropy_value' in cache.files\n", " else np.asarray(cache['entropy'], dtype=float)\n", " )\n", " entropy_ci_low = (\n", " np.asarray(cache['entropy_ci_low'], dtype=float)\n", " if 'entropy_ci_low' in cache.files\n", " else np.asarray(cache['entropy'], dtype=float)\n", " )\n", " entropy_ci_high = (\n", " np.asarray(cache['entropy_ci_high'], dtype=float)\n", " if 'entropy_ci_high' in cache.files\n", " else np.asarray(cache['entropy'], dtype=float)\n", " )\n", " confidence_level = float(cache['confidence_level']) if 'confidence_level' in cache.files else DEFAULT_CONFIDENCE_LEVEL\n", " requested_n_seeds = int(cache['requested_n_seeds']) if 'requested_n_seeds' in cache.files else int(cache['n_seeds']) if 'n_seeds' in cache.files else 1\n", " retained_n_seeds = int(cache['retained_n_seeds']) if 'retained_n_seeds' in cache.files else int(cache['n_seeds']) if 'n_seeds' in cache.files else 1\n", " n_seeds = retained_n_seeds\n", " data_source = (\n", " f'Loaded cached sweep from {CACHE_PATH} '\n", " f'using {retained_n_seeds} retained seeds '\n", " f'out of {requested_n_seeds} requested.'\n", " )\n", " cache_loaded = True\n", " else:\n", " n_cached = int(cache['temperatures'].size) if 'temperatures' in cache.files else 0\n", " cache_reason = f'cache exists but only provides {n_cached} temperature points'\n", "else:\n", " cache_reason = 'cache file not found'\n", "\n", "if not cache_loaded:\n", " temperatures = np.linspace(1.4, 3.4, 15)\n", " avg_m = np.empty_like(temperatures)\n", " avg_m_ci_low = np.empty_like(temperatures)\n", " avg_m_ci_high = np.empty_like(temperatures)\n", " avg_m_n_eff = np.empty_like(temperatures)\n", " avg_e = np.empty_like(temperatures)\n", " avg_e_ci_low = np.empty_like(temperatures)\n", " avg_e_ci_high = np.empty_like(temperatures)\n", " susc = np.empty_like(temperatures)\n", " susc_ci_low = np.empty_like(temperatures)\n", " susc_ci_high = np.empty_like(temperatures)\n", " spec_h = np.empty_like(temperatures)\n", " spec_h_err = np.empty_like(temperatures)\n", " spec_h_ci_low = np.empty_like(temperatures)\n", " spec_h_ci_high = np.empty_like(temperatures)\n", " tau_int = np.empty_like(temperatures)\n", " tau_int_ci_low = np.empty_like(temperatures)\n", " tau_int_ci_high = np.empty_like(temperatures)\n", " spec_h_samples = np.empty((temperatures.size, 1), dtype=float)\n", "\n", " for idx, temp in enumerate(temperatures):\n", " point = _run_local_sweep_point(\n", " temp=float(temp),\n", " size=32,\n", " meas_steps=fallback_meas_steps,\n", " eq_probe_steps=150,\n", " eq_max_steps=12_000,\n", " seed=1_000 + idx,\n", " )\n", " avg_m[idx] = point['avg_m_value']\n", " avg_m_ci_low[idx] = point['avg_m_ci_low']\n", " avg_m_ci_high[idx] = point['avg_m_ci_high']\n", " avg_m_n_eff[idx] = point['avg_m_n_eff']\n", " avg_e[idx] = point['avg_e_value']\n", " avg_e_ci_low[idx] = point['avg_e_ci_low']\n", " avg_e_ci_high[idx] = point['avg_e_ci_high']\n", " susc[idx] = point['susc_value']\n", " susc_ci_low[idx] = point['susc_ci_low']\n", " susc_ci_high[idx] = point['susc_ci_high']\n", " spec_h[idx] = point['spec_h_value']\n", " spec_h_err[idx] = point['spec_h_err']\n", " spec_h_ci_low[idx] = point['spec_h_ci_low']\n", " spec_h_ci_high[idx] = point['spec_h_ci_high']\n", " tau_int[idx] = point['tau_int']\n", " tau_int_ci_low[idx] = point['tau_int_ci_low']\n", " tau_int_ci_high[idx] = point['tau_int_ci_high']\n", " spec_h_samples[idx, 0] = point['spec_h_value']\n", "\n", " entropy_bundle = summarize_entropy_observable(\n", " temperatures=temperatures,\n", " specific_heat_samples=spec_h_samples,\n", " specific_heat_err=spec_h_err,\n", " confidence=DEFAULT_CONFIDENCE_LEVEL,\n", " method='blocking',\n", " )\n", " entropy = np.asarray(entropy_bundle['value'], dtype=float)\n", " entropy_ci_low = np.asarray(entropy_bundle['ci_low'], dtype=float)\n", " entropy_ci_high = np.asarray(entropy_bundle['ci_high'], dtype=float)\n", " undefined_autocorr_flag = (~np.isfinite(tau_int)).astype(np.uint8)\n", " rel_width = (tau_int_ci_high - tau_int_ci_low) / np.maximum(np.abs(tau_int), 1e-12)\n", " tau_interval_unstable_flag = np.asarray(\n", " np.isfinite(rel_width) & (rel_width > 1.0),\n", " dtype=np.uint8,\n", " )\n", " low_effective_sample_flag = np.asarray(\n", " np.isfinite(avg_m_n_eff) & (avg_m_n_eff < 20.0),\n", " dtype=np.uint8,\n", " )\n", " confidence_level = DEFAULT_CONFIDENCE_LEVEL\n", " n_seeds = 1\n", " requested_n_seeds = 1\n", " retained_n_seeds = 1\n", " data_source = (\n", " 'Computed a lightweight checkerboard-Metropolis fallback sweep '\n", " f'because {cache_reason}.'\n", " )\n", "\n", "exclude_from_thermo_plots = undefined_autocorr_flag > 0\n", "\n", "avg_m_plot = np.where(exclude_from_thermo_plots, np.nan, avg_m)\n", "avg_m_ci_low_plot = np.where(exclude_from_thermo_plots, np.nan, avg_m_ci_low)\n", "avg_m_ci_high_plot = np.where(exclude_from_thermo_plots, np.nan, avg_m_ci_high)\n", "\n", "avg_e_plot = np.where(exclude_from_thermo_plots, np.nan, avg_e)\n", "avg_e_ci_low_plot = np.where(exclude_from_thermo_plots, np.nan, avg_e_ci_low)\n", "avg_e_ci_high_plot = np.where(exclude_from_thermo_plots, np.nan, avg_e_ci_high)\n", "\n", "susc_plot = np.where(exclude_from_thermo_plots, np.nan, susc)\n", "susc_ci_low_plot = np.where(exclude_from_thermo_plots, np.nan, susc_ci_low)\n", "susc_ci_high_plot = np.where(exclude_from_thermo_plots, np.nan, susc_ci_high)\n", "\n", "spec_h_plot = np.where(exclude_from_thermo_plots, np.nan, spec_h)\n", "spec_h_ci_low_plot = np.where(exclude_from_thermo_plots, np.nan, spec_h_ci_low)\n", "spec_h_ci_high_plot = np.where(exclude_from_thermo_plots, np.nan, spec_h_ci_high)\n", "\n", "entropy_plot = np.where(exclude_from_thermo_plots, np.nan, entropy)\n", "entropy_ci_low_plot = np.where(exclude_from_thermo_plots, np.nan, entropy_ci_low)\n", "entropy_ci_high_plot = np.where(exclude_from_thermo_plots, np.nan, entropy_ci_high)\n", "\n", "print(data_source)\n", "print(f'Temperature points: {temperatures.size}')\n", "print(\n", " f'retained seeds = {retained_n_seeds} / requested seeds = {requested_n_seeds}, '\n", " f'confidence level = {confidence_level:.2f}'\n", ")\n", "print(f'Excluded points in thermodynamic plots: {int(np.sum(exclude_from_thermo_plots))}')" ] }, { "cell_type": "markdown", "id": "037eeda9", "metadata": {}, "source": [ "## Convergence Diagnostics\n", "\n", "Before interpreting the full thermodynamic curves, it is useful to see how the two-start equilibration reaches convergence. The following panel tracks the absolute magnetization $|M|$ for both a random-start and an ordered-start simulation across three representative temperatures. \n", "\n", "- **Below $T_c$**: The trace may become trapped in a metastable low-temperature domain structure. The algorithm detects this quasi-steady stuck state and safely falls back to the ordered-start baseline.\n", "- **Near $T_c$**: Critical slowing down extends the relaxation time, delaying convergence.\n", "- **Above $T_c$**: Both starts quickly collapse into the same thermal noise band. \n", "\n", "The vertical dashed line marks where the mutual cross-band criterion (`estimate_relaxation_time_two_start`) is satisfied." ] }, { "cell_type": "code", "execution_count": 13, "id": "7ec4a2a8", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "diagnostic_temps = [0.8 * TC_ISING, 1.0 * TC_ISING, 1.2 * TC_ISING]\n", "diagnostic_titles = ['Below $T_c$', 'Near $T_c$', 'Above $T_c$']\n", "diagnostic_steps = 1500\n", "\n", "fig, axes = plt.subplots(1, 3, figsize=(14, 4.5), sharey=True)\n", "\n", "for ax, t, title in zip(axes, diagnostic_temps, diagnostic_titles):\n", " sim_r = IsingSimulation(size=32, temp=t, update='checkerboard', init_state='random', seed=42)\n", " sim_o = IsingSimulation(size=32, temp=t, update='checkerboard', init_state='ordered', seed=42)\n", " \n", " m_r_list, _ = sim_r.run(n_steps=diagnostic_steps)\n", " m_o_list, _ = sim_o.run(n_steps=diagnostic_steps)\n", " \n", " m_r = np.asarray(m_r_list, dtype=float)\n", " m_o = np.asarray(m_o_list, dtype=float)\n", " \n", " tau_est = estimate_relaxation_time_two_start(m_r, m_o, smooth_window=60, dwell_window=60)\n", " \n", " smooth_r = np.convolve(m_r, np.ones(60)/60, mode='valid')\n", " smooth_o = np.convolve(m_o, np.ones(60)/60, mode='valid')\n", " is_stuck = _detect_quasi_steady_stuck(smooth_r, smooth_o, lattice_size=32)\n", " \n", " ax.plot(m_r, color=PALETTE['mag'], alpha=0.3)\n", " ax.plot(m_o, color=PALETTE['eng'], alpha=0.3)\n", " \n", " ax.plot(np.arange(59, diagnostic_steps), smooth_r, color=PALETTE['mag'], lw=2, label='Random start')\n", " ax.plot(np.arange(59, diagnostic_steps), smooth_o, color=PALETTE['eng'], lw=2, label='Ordered start')\n", " \n", " status_text = 'Converged'\n", " if tau_est < diagnostic_steps:\n", " ax.axvline(tau_est, color='0.2', ls='--', lw=1.5, label='Convergence achieved')\n", " else:\n", " if t < TC_ISING and is_stuck:\n", " status_text = 'Stuck (Quasi-steady)'\n", " else:\n", " status_text = 'Not converged'\n", " \n", " ax.set_title(f'{title} ($T = {t:.3f}$)\\nStatus: {status_text}')\n", " ax.set_xlabel('Monte Carlo steps')\n", " if ax is axes[0]:\n", " ax.set_ylabel(r'Order parameter $|M|$')\n", " ax.grid(alpha=0.25)\n", " \n", "axes[0].legend(fontsize=9, loc='lower right')\n", "fig.suptitle('Equilibration Traces: Random vs Ordered Starts', y=1.02)\n", "fig.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "283aa46d", "metadata": {}, "source": [ "## Magnetization and Energy\n", "\n", "The natural order parameter is the magnetization per spin. In a finite simulation the sign can flip after long runs, so VibeSpin records the absolute value $|M|$ rather than the signed magnetization. Below $T_c$ the curve stays close to one because almost all spins align. Above $T_c$ it falls toward zero because up and down states occur with comparable probability. The energy per spin moves more smoothly. It approaches the ordered ground-state limit near $-2J$ at low temperature and rises steadily as domain walls and thermal defects proliferate [[1]](#Bibliography) [[2]](#Bibliography)." ] }, { "cell_type": "code", "execution_count": 14, "id": "c50e6b54", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABZMAAAIsCAYAAACHsTfeAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAASdAAAEnQB3mYfeAAA8HFJREFUeJzs3Xd8U1X/B/BPRtt078kqbYFSRtlD9sbBXuJgPqIgylBQHA8g+rgBAasgWhAU0cqSH0NkVBBkyaaMlpbRlu490ozz+6MmEJIuaJum/bxfL140Z9z7vSc36c23J+dKhBACRERERERERERERESlkJo7ACIiIiIiIiIiIiKq+ZhMJiIiIiIiIiIiIqIyMZlMRERERERERERERGViMpmIiIiIiIiIiIiIysRkMhERERERERERERGViclkIiIiIiIiIiIiIioTk8lEREREREREREREVCYmk4mIiIiIiIiIiIioTEwmExEREREREREREVGZmEwmIiIiIiIiIiIiojIxmUxEREREREREREREZWIymYiIyAL17t0bEonE3GFUyKFDhyCRSLBo0SJzh0JEVGNNmjQJEokEcXFx5g6lRli0aBEkEgkOHTpU7j6W+DuSiIjIUjCZTEREdZpEIuEHTguzbt06SCQSrFu3rsr3xYRE1ZBIJOjdu7e5wyAiIiIiogpiMpmIiIiIiIiIiIiIysRkMhERERERERERERGViclkIiKiclIqlfjoo4/QqlUr2NnZwcnJCT169MDPP/9cYp8TJ05g3LhxqFevHmxsbODr64uBAwca9Vm3bh1GjRqFgIAA2NrawsnJCd26dcPGjRsrJfa4uDhIJBJMmjTJZL2p5RzuX+P42LFj6N+/P5ydneHo6IhBgwbh1KlTJreVlJSEqVOnwtvbG7a2tmjTpg3Wr19fYmynT5/GrFmzEBoaCjc3NygUCjRp0gSvvfYaMjIyjOKcPHkyAGDy5Mn6ZUoeXF9UrVYjLCwMXbp0gZOTE+zs7NC2bVusWrUKWq223OMVGRkJAAb7eXB5hjt37mDmzJkICAiAjY0N3N3dMXToUJw8edJou/ev/blp0ya0b98ednZ28PPzw9y5c6FUKgEABw4cQO/eveHk5ARXV1c8//zzSEtLM9qev78//P39kZWVhZkzZ6JevXpQKBQICQnBihUrIIQweXzHjx/H6NGj4ePjA2trazRo0AAvvvgiEhISjNrqzo2ioiK89957aNasGWxsbPTnUlZWFj799FP07dsX9evXh7W1NTw9PTF06FAcO3bMYFu6JUoAIDIy0mBcdWtpl7W2tu6YTW133bp12LNnD3r37g1nZ2eDc/pRzwmdGzduYNq0aQgKCoKtrS3c3NzQqlUrvPTSS/rnaO/evZBIJHj77bcN+h48eFB/vLdv3zaoGzduHCQSCW7cuGFQfuXKFUyaNAkNGjSAtbU1vL298cwzz+Dq1asm48vPz8eHH36INm3awN7eHg4ODujatSs2bdpk1PZhX+MVdf/zs2/fPvTo0QMODg7w9PTE5MmTkZmZCQA4c+YMnnrqKbi6usLBwQFDhw4tcd3g9PR0LFiwAM2bN4etrS2cnZ3Rr18//P7770ZtK3KO6uhe66mpqZg2bRp8fX1hY2ODFi1aIDw8vMJjcPr0aYwaNQpeXl6wsbFBo0aNMGPGDCQmJpbYR6vVYunSpQgODoZCoUD9+vUxZ84cZGdnG7U9f/48xo8fD39/f9jY2MDT0xPt2rXD7NmzoVKpDNpW5LVw/++Oa9euYdy4cfDy8oJUKsWhQ4cQHBwMa2trpKammjyGjz/+GBKJBKtWrdKXHTx4ENOmTUNISAicnJxga2uLli1bYvHixSgsLCx1HNevX4+2bdvC1tYWXl5emDJlCu7evVtqnwft3bsXTzzxBDw8PGBjY4PAwEDMmzdPfx7eryLjSkREVGcIIiKiOgyAKM+vQ6VSKXr16iUAiODgYPH666+LGTNmCC8vLwFALFiwwKjPmjVrhEwmE9bW1mL06NFiwYIFYurUqSI0NFT06tXLoK1CoRDt27cXEydOFG+++aZ44YUXRL169QQA8c477xhtWxdLecXGxgoAYuLEiSbrTW3v4MGDAoAYPHiwsLa2Fk888YRYsGCBGDNmjJDJZEKhUIg///zToE9KSooICAgQAET37t3Fm2++KSZOnCgUCoUYOnSoACAWLlxo0OfFF18UXl5eYsyYMWLu3Lli9uzZokePHgKAaN68ucjOzta3DQ8PF8OGDRMAxLBhw8TChQv1/zIyMoQQQhQVFYlBgwYJAKJZs2bixRdfFLNmzRKtW7cWAMRzzz1X5nhlZGSIhQsXikaNGulj1v0LDw/Xtzt9+rRwd3cXEolEDB48WLz22mti4sSJwtnZWVhbW4v/+7//M9juwoULBQAxcuRIYWtrK8aPHy/mzp0rWrZsqX9+tmzZIqytrcWIESPEa6+9Jrp27ap/Hh7UqFEj4evrKzp06CCCgoLE3LlzxcyZM4Wvr68AIGbMmGHU59tvvxUymUzY2dmJp59+WsybN08MHz5cSKVS4evrK27evGnQXnduPPXUU8Lb21tMmjRJzJ8/X3z22WdCCCGOHTsmrKysRL9+/cS0adPEG2+8IcaPHy/s7e2FXC4Xu3fv1m/rzJkz+jFo1KiRwbgePHhQCHHvvHvwPLn/mBs1amRQFh4eLgCIJ598UshkMvHUU0+J+fPni3HjxgkhKuecEEKIhIQE4ebmJuRyuRg6dKiYP3++ePXVV8WQIUOEnZ2duHDhghBCiLy8PGFtbS06d+5s0P/tt9/Wv+fcfx5ptVrh6ekp/P39Ddrv3r1b2NraCrlcLkaMGCHmzZsnxo8fL2xsbISTk5M4ffq0QfuMjAzRtm1bAUC0a9dOzJw5U8yYMUMEBgYKAOLtt982aP8wr3Ehyv++qaN7fkaMGCGsrKyMzu3evXuLY8eOCTs7OzFo0CDx2muviYEDBwoAokWLFkKj0RhsLy4uTvj7+wsAokePHmL27NnihRdeEL6+vkIikYg1a9YYtK/IOXr/MYaGhoqmTZuKli1bipkzZ4oXXnhBuLi4CABi3bp15T7+3377TVhbWwsrKysxfvx48eabb4oBAwYIAMLPz0/cuHHDoP3EiRMFADF06FDh4uIipk2bJubPny9CQ0MFANG+fXtRUFCgb3/u3DmhUCiEra2tGDdunHjzzTfFjBkzxMCBA4WVlZXIycnRt63oa0H3u6N79+7CxcVFdOrUScyePVu8+OKL4vTp0+J///ufACBWrFhh8tibN28urK2tRVpamr5s0KBBolGjRmL8+PHi9ddfFzNnztSft7179xZqtdpgG7r3jKFDhwqFQqH/Pdm9e3cBQDRu3FgkJycb9Cnpd+SiRYsEAOHm5iYmTJggXn/9df25FhISIrKysh5qXImIiOoSJpOJiKhOK29SRPeB+fHHHxcqlUpfnpSUpE84/vXXX/ryS5cuCblcLlxdXcXFixeNtnf79m2Dx9HR0UZtlEql6Nu3r5DL5eLOnTsGddWZTAYgVq5caVC3bds2AUAEBQUZJHpeeOEFAUDMnj3boP3JkyeFXC43mSSMi4szSh4IIcTatWsFAPHRRx8ZlOsSU/cn4+6nSzzMnDnTYLtqtVpMmTJFABDbtm0z2fdBpY2zSqUSgYGBwsbGRhw6dMigLj4+Xvj5+QkfHx9RWFhoFJuTk5O4fPmyvrywsFCEhIQIqVQq3NzcDLan0WhE//79BQBx5swZg/3ozr1u3boZ7CctLU2f1I+MjNSXX716VVhZWYnAwECjc+qPP/4QUqlUDB8+3OQYtGrVSqSkpBiNQ2Zmpsny27dvC19fXxEcHGxUB8DoDyo6j5JMlkgkJhODlXVOrFixQgAQy5cvN6rLzc0V+fn5+sc9evQQMplMZGZm6su6dOki2rZtK9zd3Q2SdmfPnhUAxJQpU/Rl6enpwsXFRbi7u4tLly4Z7OvChQvC3t5etG3b1qBcl4T8+OOPDcoLCgrEoEGDhEQiMTiHHuY1LsTDJ5NlMlmJ57arq6vYuHGjQb+SnptevXoJiUQiNm3aZFCekZEhQkNDhUKhEHfv3tWXP+w5CkBMnTrV4Jy5dOmSkMlkonnz5uU69pycHOHm5iakUqlRYv6jjz4SAMSAAQMMynXPo7u7u4iLi9OXazQaMXLkSAFAvPfee/ryuXPnlngOp6enGzx/FX0t6H53lPRH09u3bwupVCrat29vVHfixAn9H8/uFxMTI7RarVH7d955RwAQP/30k0G5LmYrKyvxzz//GNTNnj3b6LUjhOn37gMHDggAomvXrvo/PuroztH7f3dVZFyJiIjqEiaTiYioTitvUiQoKEhIJBIRFRVlVKdLek6ePFlfNnPmTAFALF269JHi+/XXXwUAsX79eoPy6kwmm0om3d9HlxwqKioSdnZ2wtHR0SCBpqNLkJSUJHyQVqsVTk5Ook+fPgblpSWTNRqNcHNzEz4+PgZJf52MjAwhkUjEmDFjyhVDaeOsS7a9/vrrJuuXL18uABjMTtYlRUzNNl+8eLEAIJ5//nmjunXr1pmcDalLJpuaPaobp0mTJunLdImXnTt3mox5+PDhQiaTGcwG141BeRPw93vllVcEAKPZzlWVTH4wES5E5Z4TumTy6tWry2yrmwG5fft2IYQQ2dnZQi6Xi/nz54vRo0cLPz8/fdvPP/9cABA//PCDvkx3/qxatcrk9nXPpS7RnJqaKmQymejQoYPJ9rqE9bx58/RlFX2N60RFRZl8LyyJ7vkxNQN8/fr1+hnGDzp06JAAIBYtWmR0HKNHjza5L93r8ssvvyxXbKWdo3Z2dgYzVXV69uwpAJRrZurGjRsFADF+/HijOpVKpZ9hff/+de+V9yeMdWJiYoRUKjWYxa5Leu7du7fUWB7mtaD73eHt7W3wB6v76WZZP/iH05dfftngNVCWtLQ0o9+lQtx733wwYSxE8R8KnJ2dhUKhMIjP1Hv38OHDTcap06ZNG+Hp6al/XN5xJSIiqmvkICIiolLl5OQgOjoa9erVQ3BwsFF93759ARSv96nz999/AwAef/zxcu3j1q1b+Pjjj7F//37cunULBQUFBvXx8fGl9s/MzMTy5cuNymfPng0XF5dyxVCSHj16QCo1vs1C7969ERkZiTNnzqBXr164cuUK8vPz0aNHDzg7O5tsb2rtZJVKhdWrV+Onn37C5cuXkZWVZbBuZ1nHfr9r164hPT0dTZo0wfvvv2+yja2tLaKiosq9zZLo1lq9efOmyfV9r1+/DgCIiorCE088YVDXoUMHo/Z+fn4AgPbt2xvV1atXD0Dx+swPksvleOyxx4zKdWs7339e6mKOjIw0uaZzcnIyNBoNrl27ZhRHp06djNrr/PXXX/jiiy9w7NgxJCcno6ioyKA+Pj4eDRs2LLF/ZTEVY2WeE0OHDsVbb72Fl19+GXv37sWgQYPQrVs3hISEGK053rdvXyxatAj79+/H0KFDERkZCbVajX79+sHf3x8RERGIiopC8+bNceDAAX0fHd1zde7cOZPn17Vr1wAUn18hISE4efIkNBpNietN69Z3NXWc5X2N65h6HyyPyjjvdeOSlZVl8jhTUlIAGB/nw5yjTZo0gZOTk9E+GjRoAADIyMiAg4ODUf39/vnnHwCGz62OXC5Hz549ERcXhzNnzhjt//4x1wkICECDBg0QFxeHzMxMuLi4YNy4cfjiiy8wfPhwjB49Gv3790e3bt0QGBho0PdRXguhoaGwsbEx2WfSpEnYt28f1q9fj08++QQAUFRUhE2bNsHLy8vo/S8vLw9ffPEFtm7dimvXriEnJ8dgffeS3vNNjYezszPatGmDyMhIREVFoU2bNib7AsXnjpWVFX755Rf88ssvRvVFRUVISUlBWloa3N3dyz2uREREdQ2TyURERGXIysoCAPj6+pqs15Xff/Me3c+6ZEhpbty4gU6dOiEjIwM9evTAwIED4ezsDJlMhri4OKxfv15/Y7aSZGZmYvHixUblkyZNeuRksre3t8lyHx8fAPfGR/d/We0fNG7cOGzduhUBAQEYNmwYfHx89EmL5cuXl3ns99PdAO369esmx0MnNze33Nssa1+mkhJl7ctUsl0ul5dZZ+qGTx4eHpDJZEblDz4/98f86aefVjjmkp6/rVu3YvTo0VAoFBgwYAACAwNhb2+vv0FXZGRkhZ7DR2Eqxso8Jxo1aoQTJ05g0aJF2LNnD7Zs2QKgOLn4+uuv49VXX9W37dKlC+zt7bF//34AwP79+2FtbY3u3bvrbyC4f/9+NGnSBH/++SdCQkIM4tfF/c0335Qaky5uXfuTJ0+a/ENBacdZ3tf4o6qM8153nPv27cO+fftK3Nf9x/mw52hJ7526uDQaTYn713mY3x86pT0vN2/eRFZWFlxcXNCpUyccPnwYH3zwASIiIrBhwwYAQLNmzbBw4UKMHz8ewKO9Fkp6/QPAiBEj4OTkhI0bN+LDDz+ETCbDzp07kZ6ejtmzZ+vHCyh+Lvv27YsTJ06gZcuWGDduHDw9PWFlZQUAWLx4cYnvF496nqalpUGtVpd67EDx8bu7u5d7XImIiOoaJpOJiIjKoEtylHTH+MTERIN2wL0kRHx8fJmz+JYuXYq0tDSEh4dj0qRJBnWbNm0yOZv3Qf7+/gYzux6km3WoVqtN1ptKZOgkJSWZLNeNh+64df+X1f5+p06dwtatW9G/f3/s3r3bIOmg1Wr1s9zKSxfDiBEj9Im+qqLb1/bt2zF06NAq3VdpUlNTodFojBLKDz4/9/+clZVlcsZlaR6ceavz7rvvwtraGqdOnULz5s0N6l588UVERkZWaD/lOVdLSvKZirGyz4nmzZtj8+bNUKvVOHfuHP744w+sXLkSs2bNgr29PaZOnQoAsLKyQvfu3bF3717cvXsX+/fvR9euXWFnZ4emTZuifv36+OOPP9CuXTvk5OQYzVzVxX3u3Dm0bt26zLh07efMmYOlS5dW6JjK+xqvCXSxfPHFFwbJ+9JU9jlaEQ/z+0MnKSkJzZo1Myo39bx07doVO3fuhFKpxOnTp7Fnzx6sXLkSzzzzDDw9PdG/f/9Hei2U9PoHimczjx07FmvXrsW+ffswePBg/e+tiRMnGrTdvn07Tpw4gUmTJiE8PNygLjExsdRE76Oep87OztBqtUhPTy+13f3KM65ERER1jfH32YiIiMiAo6MjAgMDER8fr1+64H4HDx4EALRr105f1qVLFwDA7t27y9x+dHQ0AGDUqFFGdZWV5HB1dQUA3L5926guOztb/5V5U44cOWKw7ITOoUOHAABt27YFUPzVdzs7O5w9e9bkDDFd+/vpjn3o0KEGiWQAOHHihNFyHwD0SVNTswKDg4Ph4uKCv//+2+Qs3ooqbV+65/jw4cOPvJ9HoVarcfToUaPyB58foGpijo6ORkhIiFGSTqvV4siRIyb7SKXSEmd1lnauRkdHV3iWbGWfEzpyuRzt27fHG2+8gU2bNgEAtm3bZtCmX79+AIr/KHTx4kX9Y6B42YNDhw7pZ9feXwdU/Lnq1KkTpFLpQz235X2N1wQPcw4/zDlaWXRjZ+r9T61W64/j/t8fOqbe/2/cuIHbt2/D39/f5B9VbGxs8Nhjj+G9997DihUrABQncIGqey0A0P8hdP369UhJScHu3bvRunVro2UndO/5I0eONNpGWb/vTNVnZWXh7NmzUCgURs/vg7p06YKMjAxcunSp1HamlDauREREdQ2TyUREROUwZcoUCCEwb948gyRYamoqlixZom+jM336dMjlcixZsgSXL1822t79a4DqvvL+YLJh7969WLt2baXE7+joiODgYPz1118G8Wg0GsydO9dk0lbn+vXrCAsLMyjbvn07IiMjERQUhB49egAonon57LPPIicnx2gt01OnTuGHH34w2nZJx56cnIyXX37ZZDzu7u4AiteZfpBcLscrr7yCxMREvPrqqyaPKzEx0eRzUtF9DRs2DIGBgfjyyy+xa9cuk/2PHTuG/Pz8cu3rUSxYsMDgq+Hp6en6NVEnT56sL585cyasrKwwZ84ck39AKCoqqnAy0t/fH9evX0dCQoK+TAiBRYsWlTjO7u7uJpPFQHHCy8nJCdu3b0dycrK+vKCgoNwzUe9XmefE6dOnTSazdTMm7ezsDMp1s40/+ugjCCGMkslZWVkICwuDVCrVr3GtM3nyZLi4uGDx4sU4ceKE0T61Wq3B68bLywvPPvssTp06hSVLlphM1sfExCA2NtaovLyvcZ0rV67gypUrRtupDh06dECPHj2wZcsWfPfddybbXLhwweDceZhztLIMHz4cbm5u2LRpk34tfZ3ly5cjNjYW/fv3N7mm+BdffIGbN2/qH2u1WsybNw9ardbgdX306FGT5/WD52Vlvz/er1u3bmjSpAm2b9+Or7/+GiqVyuibNkDJ7/k3btzAG2+8Ueo+NmzYYLAGPAAsWrQIWVlZGD9+fIlrOuvMmTMHAPDCCy8YnAs6eXl5Bs9ReceViIioruEyF0RERIDJD706YWFheP3117F7925s374doaGheOKJJ5Cfn49ffvkFycnJmD9/Prp3767vExISgrCwMLz00kto27Ythg0bhiZNmiAtLQ0nT56Ek5OTfkbzjBkzEB4ejjFjxmD06NHw8/PDxYsXsWfPHowdOxabN2+ulGOcN28epk6dim7dumHMmDFQKBQ4ePAgVCoVQkNDce7cOZP9Bg8ejNdeew27d+9GaGgooqOjsWXLFigUCnz33XcGN+763//+h/3792P58uU4deoUunfvjsTERGzevBlPPPEEduzYYbDtjh07olu3btiyZQsee+wxdO/eHUlJSdi9ezeaNWumvznX/XRLBSxfvhxpaWn69TJfeeUVODs7491338W5c+fw9ddf47fffkPfvn1Rr149JCcn4/r16/jrr7/wwQcfICQkpMwx69evH3755ReMHDkSTzzxBGxtbdGoUSM8//zzsLKywpYtWzBo0CA8+eSTeOyxx9CmTRvY2dnh9u3bOHnyJG7cuIHExMQqTTr4+vpCqVSiZcuWGDp0KFQqFSIiIpCYmIgZM2agZ8+e+rbBwcH47rvvMGXKFLRo0QKDBw9G06ZNoVKpcOvWLRw+fBienp4VShTOmTNHf56PGjUKVlZW+j9aDBkyBL/99ptRn379+uGnn37CkCFD0K5dO1hZWaFnz57o2bMnrKysMGvWLCxZsgRt27bFiBEjoFarsW/fPvj5+Zk8J8pSWefEhg0bsHr1anTv3h2BgYFwdXVFTEwMfvvtN9jY2GD27NkG7du2bQtXV1ckJyfD0dHR4AaBusRycnIyOnToYDTL1N3dHRERERgxYgS6dOmCfv36oUWLFpBIJLh9+zaOHTuGtLQ0FBYW6vusWrUK169fx3//+19s2LAB3bt3h7e3NxISEhAVFYWTJ09i06ZNaNy4scG+KvIaB6CfAVra0jpV6ccff0Tfvn0xdepUrFixAp07d4aLiwvu3LmD8+fP4+LFizh27Bi8vLwAPNw5WlkcHBzw3XffYcyYMejVqxfGjBmDhg0b4vTp0/j999/h4+OD1atXm+zbrVs3tGnTBuPGjYOzszP27t2Lc+fOoX379pg/f76+3SeffIIDBw6gR48eaNy4MRwcHHDp0iXs3r0brq6umDZtmr5tZb4/PmjChAl49913sWTJEsjlcjz77LNGbYYMGYKgoCAsXboUFy5cQNu2bXHr1i3s3LkTTz75pMk/3Ok8/vjj6NatG8aOHQtfX18cOXIER44cgb+/Pz766KMy4+vXrx8++ugjLFiwAE2aNMETTzyBxo0bIzc3Fzdv3kRkZCS6d++OPXv2VHhciYiI6hRBRERUhwEo819GRoYQQoiCggLxwQcfiBYtWgiFQiEcHBxEt27dxI8//lji9o8ePSpGjhwpPD09hZWVlfD19RWDBg0Sv/zyi0G7v/76S/Tp00e4uLjot7t161Zx8OBBAUAsXLjQoH2vXr3Ew/waX7t2rQgJCRHW1tbC29tbTJs2TaSmpprc3v37Pnr0qOjXr59wdHQUDg4OYsCAAeLEiRMm95GYmCgmT54sPDw8hEKhEKGhoSI8PLzEY0lLSxPTp08XjRo1EjY2NiIgIEAsWLBA5OXliUaNGolGjRoZ7WP37t2iS5cuwt7eXv88xcbG6uu1Wq34/vvvRd++fYWrq6uwsrISfn5+olu3buKDDz4Qt27dKtd4qdVqsWDBAtG4cWMhl8sFANGrVy+DNklJSeKNN94QLVq0ELa2tsLe3l4EBQWJUaNGiQ0bNgiVSqVvu3DhQgFAHDx40Ghf4eHhAoAIDw83qitp7HTjk5mZKWbMmCH8/PyEtbW1CA4OFl988YXQarUmj+v8+fNi4sSJomHDhsLa2lq4urqKFi1aiGnTpon9+/cbtC3PuRYeHi5CQ0OFnZ2dcHd3F8OHDxfnz58v8XiTkpLE+PHjhZeXl5BKpUbHptVqxYcffigCAgKElZWVaNCggZg3b16J50RpY3f/Nh/1nPj777/FSy+9JFq3bi1cXV2FQqEQgYGBYtKkSeLChQsm+4wcOVIAEE888YRRXdOmTQUAMX/+/BL3GRsbK15++WURFBQkbGxshKOjo2jWrJl47rnnxNatW43aK5VKsXLlStG1a1fh5OQkrK2tRYMGDUTfvn3FsmXLRGpqqr7tw77Gda+58nqYc1t37ADExIkTjeqys7PFBx98INq1ayfs7e2FQqEQ/v7+4oknnhCrV68Wubm5RjFU5Bw19VrXmThxotF7TllOnDghhg8fLjw8PPTn9EsvvSTi4+NL3H5MTIz47LPPRLNmzYSNjY3w8/MTs2bNEllZWQbt9+7dKyZNmiSaN28unJychJ2dnWjatKl45ZVXRFxcnNH2K/JaKO05eNDNmzf1r+ennnqqxHa3bt0SzzzzjPDz8xMKhUKEhISIjz/+WKhUKpPjfv9zpHseFQqF8PDwEJMmTRIJCQlG+yjtfevw4cNizJgxwtfXV1hZWQkPDw8RGhoq5syZI06ePKlvV9FxJSIiqiskQphpSgERERHVaIcOHUKfPn2wcOFCo2UrqGbQfWU8Li7OrHGQZeJrnIiIiIgqimsmExEREREREREREVGZmEwmIiIiIiIiIiIiojIxmUxEREREREREREREZeKayURERERERERERERUJs5MJiIiIiIiIiIiIqIyMZlMRERERERERERERGViMpmIiIiIiIiIiIiIysRkMhERERERERERERGViclkIiIiIiIiIiIiIioTk8lEREREREREREREVCYmk4mIiIiIiIiIiIioTEwmExEREREREREREVGZmEwmIiIiIiIiIiIiojIxmUxEREREREREREREZWIymYiIiIiIiIiIiIjKxGQyEREREREREREREZWJyWQiIiIiIiIiIiIiKhOTyURERERERERERERUJiaTiYiIiIiIiIiIiKhMTCYTERERERERERERUZmYTCYiIiIiIiIiIiKiMjGZTERERERERERERERlYjKZiIiIiIiIiIiIiMrEZDIRERERERERERERlYnJZCIiIiIiIiIiIiIqE5PJRERERERERERERFQmJpOJiIiIiIiIiIiIqExMJhMRERERERERERFRmZhMJiIiIiIiIiIiIqIyMZlMRERERERERERERGViMpmIiIiIiIiIiIiIysRkMhERERERERERERGViclkIiIiIiIiIiIiIioTk8lEREREREREREREVCYmk4mIiIiIiIiIiIioTEwmExEREREREREREVGZmEwmIiIiIiIiIiIiojIxmUxEREREREREREREZWIymYiIiIiIiIiIiIjKxGQyEREREREREREREZWJyWQiIiIiIiIiIiIiKhOTyURERERERERERERUJiaTiYiIiIiIiIiIiKhMTCYTERERERERERERUZmYTCYiIiIiIiIiIiKiMjGZTERERERERERERERlYjKZiIiIiIiIiIiIiMrEZDIRERERERERERERlYnJZCIiIiIiIiIiIiIqE5PJRERERERERERERFQmJpOJiB5CXFwcJBIJJk2aZO5QiIiIiIioBrKEzwyWECMR1SxMJhNRrXDq1ClMnjwZAQEBsLW1hZOTE1q1aoV58+YhPj7e3OFRDTJp0iRIJBLExcWZOxQiIiKiGkcikZT579ChQ+YOk6oYr5mJqCRycwdARPQohBB488038cknn0Aul2PAgAEYM2YMioqKcPToUXz22WcICwvD+vXrMXr0aHOHS0RERERkERYuXFhinb+/f/UFQlWqXr16iIqKgrOzs7lDISILwWQyEVm0JUuW4JNPPoG/vz927tyJFi1aGNT/+uuveO655/D0009j37596NOnj5kiJSIiIiKyHIsWLTJ3CFQNrKysEBwcbO4wiMiCcJkLIrJYcXFxWLJkCaysrLBjxw6jRDIAjBo1CsuWLYNGo8H06dOh1Wr1devWrYNEIsG6deuwZ88e9O7dG87OzpBIJPo2OTk5mDt3LurXrw+FQoHg4GAsXbrUYDsPys/Px4cffog2bdrA3t4eDg4O6Nq1KzZt2mTU9tChQ5BIJFi0aBFOnDiBJ598Em5ubuX6StmiRYv0XzNcv3492rZtC1tbW3h5eWHKlCm4e/euUZ/Tp09j1qxZCA0NhZubGxQKBZo0aYLXXnsNGRkZRu3LM0bbtm3Dc889h6ZNm8Le3h729vZo3749VqxYYXKcdF+Zi42NxapVqxASEgKFQgF/f3/873//gxACAPDLL7+gU6dOsLe3h5eXF2bOnImCggKTY3HlyhVMmjQJDRo0gLW1Nby9vfHMM8/g6tWrBu0kEgnWr18PAGjcuLH+q5oPzq5JT0/HggUL0Lx5c9ja2sLZ2Rn9+vXD77///lBjRERERFRb3X9NGhERgU6dOsHOzg5ubm54+umnS1xyrrKvt7KysjB79myj6/YbN24YrQk8fvx4SCQSREZGmozt119/hUQiwcyZM8s1BtX5meHs2bN48skn4eLiAjs7O/Tq1QtHjx41GdOSJUvQsmVLODk5wdHREYGBgRg3bhxOnz6tb2dqzeSyrpm7du0KqVRa4ueVzz//HBKJBJ999lk5Ro+ILA1nJhORxQoPD4darcbYsWPRqlWrEtv95z//wXvvvYerV68iMjLSaHZyREQE9uzZg8cffxwvvfQSbt68CQBQKpXo168fTp48idDQUDz77LPIzMzEkiVLSrzwzMzMRN++fXHmzBm0a9cOU6ZMgVarxd69e/HMM8/g0qVLeP/99436HTt2DB9++CG6d++OKVOmIDU1FdbW1uUah2XLluH333/HuHHjMHjwYBw5cgTh4eE4dOgQjh8/Dk9PT33bb775Blu3bkWvXr3Qv39/aLVanD59GkuXLsXu3btx/PhxODo6Gu2jpDECgDfffBNSqRSdO3dGvXr1kJWVhQMHDmDWrFk4efIkNmzYYDLu119/HYcOHcKQIUMwcOBA7NixA2+//TaKiorg5uaGN998E8OHD0ePHj2wb98+fPnll9BoNPjqq68MtrNnzx6MHDkSKpUKQ4YMQVBQEO7cuYMtW7bg//7v/3Dw4EG0a9cOQPHXNbdt24Zz585h1qxZcHFxAQD9/wBw8+ZN9O7dG3FxcejRowcGDx6MvLw87Ny5E4MHD8bq1avxwgsvVGiMiIiIiGq7sLAw7NixA0OHDkWvXr1w/PhxbN68GefOncPZs2dhY2Ojb1vZ11uFhYXo27cv/vnnH7Rt2xbPPvsssrKy8MEHH+Dw4cNG25k+fTp++uknrFmzBr169TKqX716NQDgpZdeKvO4q/Mzw6lTp/DJJ5+ga9eu+M9//oNbt27h119/Rb9+/XD27Fk0a9YMQPFSgIMHD8bRo0f1beVyOe7cuYODBw+iR48eaN++fYnHVNY18/Tp0/H333/jm2++wQcffGDUf82aNbCxseFN/YhqK0FEZKH69u0rAIg1a9aU2faZZ54RAMSSJUv0ZeHh4QKAkEgkYvfu3UZ9PvjgAwFAjBw5Umg0Gn35jRs3hKurqwAgJk6caNBn4sSJAoD4+OOPDcoLCgrEoEGDhEQiEWfOnNGXHzx4UAAQAMTXX39dziMvtnDhQgFAWFlZiX/++cegbvbs2QKAmDJlikF5XFycUKvVRttau3atACA++ugjg/KyxkgIIaKjo43KNBqNmDBhggAg/v77b4M63Rg1atRI3LlzR1+ekZEh3N3dhZ2dnfDw8BCXL1/W1xUWFormzZsLa2trkZSUpC9PT08XLi4uwt3dXVy6dMlgPxcuXBD29vaibdu2JvcfGxtr8nh69eolJBKJ2LRpk0F5RkaGCA0NFQqFQty9e7dCY0RERERkKXTXpgsXLjT578MPPzRor7smdXR0FOfPnzeoGz9+vAAgNm/ebFBe2ddb7733ngAgnn76aaHVavXlt27dEh4eHiav21u0aCFsbGxEamqqQXlMTIyQSCTiscceK3uwRPV/ZggPDzfo8/XXXwsAYvr06fqy8+fPCwBi+PDhRvFqNBqRnp6ufxwbG1tqjKaumQsKCoS7u7vw8fERKpXKoE4X6zPPPGPUj4hqBy5zQUQWKzExEQDQoEGDMtvq2iQkJBjVDRs2DIMHDzYqDw8Ph1QqxSeffAKp9N7bZePGjfHqq68atU9LS8PGjRvRoUMHzJ8/36BOoVDg448/hhACP/74o1HfNm3a4MUXXyzzOEx5/vnn0bZtW4OyRYsWwdnZGT/++COUSqW+vFGjRpDJZEbbmDJlCpycnLB3716T+yhpjAAgMDDQqEwqlWLWrFkAUOI23333XdSrV0//2MXFBUOHDkV+fj6mT5+O5s2b6+tsbGwwbtw4FBUVISoqSl/+/fffIzMzE4sXL0ZISIjB9lu2bIkXXngBZ86cweXLl03G8KBz584hMjISo0aNwtNPP21Q5+LigsWLF6OwsBC//vqrUd/SxoiIiIjI0ixevNjkv48++shk+1dffdXo24K62cUnTpzQl1XF9db69eshlUrx4YcfGix90aBBA8yePdtkvNOnT4dSqcS6desMyr/55hsIIcp9bV6dnxm6detmNNt3ypQpkMvlBmOsY2tra1QmlUrh6uparmMriUKhwOTJk3H37l1s377doE43q/thP9sQUc3HZS6IqM7r1KmTUVlOTg6io6PRoEEDk8nS3r17Y/HixQZlJ0+ehEaj0a9n9iCVSgUABsnQ0mIoL1NfzXN2dkabNm0QGRmJqKgotGnTRh/D6tWr8dNPP+Hy5cvIysoyWMutpDXtSosvLS0Nn376KXbt2oUbN24gLy/PoL6kbXbo0MGozM/PDwBMfu1Ol3i+c+eOvuzYsWMAij+UmBrza9euASge8weTzabotpeVlWVyeykpKfrtPehRnkMiIiKimkb8ex+L8jJ1baeb0HH/vTkq+3orOzsbMTExaNCggdF9MACge/fuJuOdMGEC3nzzTaxZswavvfYagOJr5XXr1sHV1RVjx4412e9+1f2ZwdQYW1lZwdvb22CMQ0JC0KZNG2zatAk3b97EsGHD0L17d3To0KHcS+mVZfr06fj888+xevVqjBo1CgCQmpqKrVu3onnz5ujZs2el7IeIah4mk4nIYvn4+CAqKgq3b98us62ujS5Z+eB2HpSVlQUA8Pb2LnHfD0pLSwNQfIF48uTJEmPJzc0t1/bKq6wYdccCAOPGjcPWrVsREBCAYcOGwcfHR79+3fLlyw1mMZcnvszMTHTs2BGxsbHo1KkTJkyYADc3N8jlcmRmZuKLL74ocZvOzs5GZXK5vMw63QU2cG/Mv/nmG5P70DE15qbotrdv3z7s27evQtt7lOeQiIiIyNLdfw8KHd31m0aj0ZdV9vVWdnY2gJKviUsqd3R0xHPPPYevv/4aBw8eRJ8+fbBjxw7cvXsXs2fPhkKhKDE2ner+zGBqjIHicb5/jGUyGQ4cOID33nsPEREReOONNwAUH/PEiRPx4YcfwsHBocR9l0dAQAAGDRqEvXv3IiYmBoGBgVi/fj2USiVnJRPVclzmgogslm6WwR9//FFqO41Gg0OHDgEo/mrYg+7/KpyOLpmZlJRkcpt3794tsc+cOXMghCjx38GDB8sVQ3mVFaMurlOnTmHr1q3o378/rl69ivDwcHz44YdYtGgR/vvf/6KoqKjEfZQU39q1axEbG4uFCxfi+PHjCAsLw/vvv49FixZh3LhxD31M5aU7tnPnzpU65hMnTqzQ9r744otStxceHm7U91GeQyIiIqK6orKvt5ycnACUfE1cUjlQPLsWuLc0g+7/adOmVehYquszQ0W4urpi2bJluH37Nq5fv461a9ciODgYq1at0h/3o5o+fTqEEPqJHWvWrIFCocCECRMqZftEVDMxmUxEFmvSpEmQyWTYunUrLl26VGK77777DgkJCWjWrJnJJSFMcXR0RFBQEOLj4xETE2NUr0tO369Tp06QSqUm7xhdlUzdJTorKwtnz56FQqHQrz0cHR0NABg6dKh+lojOiRMnUFBQUOF967ap+2pbWXFVti5dugBAhcZct2b0/bM3HmV7RERERFR+lX295eTkhICAAMTHxyMuLs6o/siRIyX2bd26Nbp164atW7fi+PHj+OOPP9CzZ0+De3eUxlI+MwQFBWHq1KmIjIyEg4OD0TrHppR2zazz1FNPoWHDhggPD8fvv/+Oa9euYezYsY+8JjMR1WxMJhORxQoICMBbb70FlUqFoUOHmrzJ2rZt2zBr1izIZDJ89dVXBjfFKMvkyZOh1WrxxhtvGKwrHBsbixUrVhi19/LywrPPPotTp05hyZIlJi+8YmJiEBsbW+4YymPDhg04c+aMQdmiRYuQlZWF8ePH65ex0K0h9+BFbXJyMl5++eWH2ndJ2zxz5gw+/PDDh9pmRUyePFl/oxZTNx3RarVGsbm7uwMAbt26ZdS+Q4cO6NGjB7Zs2YLvvvvO5D4vXLiA5OTkRw+eiIiIqA6qiuutCRMmQKvVYsGCBQZrPd++fRvLly8vte/06dNRVFSEUaNGQQiBl156qdz7BWrmZ4bY2FjcuHHDqDwjIwNKpdLkjfkeVNo1s45UKsW0adOQnJyMKVOmAECFx4+ILA/XTCYii7Zo0SLk5eVh6dKlCA0NxaBBg9CiRQuoVCocPXoUx48fh62tLTZt2oQ+ffpUaNuvvfYatm3bhl9//RXt2rXDoEGDkJmZiZ9//hk9e/bEjh07jPqsWrUK169fx3//+19s2LAB3bt3h7e3NxISEhAVFYWTJ09i06ZNaNy4cWUNAR5//HF069YNY8eOha+vL44cOYIjR47A39/f4G7bHTt2RLdu3bBlyxY89thj6N69O5KSkrB79240a9bM5HrSZZkwYQI+/fRTzJ49GwcPHkSTJk1w/fp17Ny5EyNHjsTmzZsr7ThNcXd3R0REBEaMGIEuXbqgX79+aNGiBSQSCW7fvo1jx44hLS0NhYWF+j79+vXDp59+ihdeeAGjRo2Co6MjXFxcMHPmTADAjz/+iL59+2Lq1KlYsWIFOnfuDBcXF9y5cwfnz5/HxYsXcezYMXh5eVXpsRERERGZk6mbw+kMHz5cf4Pnh1HZ11vz58/Htm3b8NNPP+Hq1asYOHAgsrKy9Nft27ZtK3FSyZgxYzBnzhzEx8fDw8MDI0eOrNCx1MTPDOfOncPIkSPRsWNHNG/eHH5+fkhJScH27duhUqn0ayiXpqxrZp3//Oc/eO+99xAfH49WrVqha9euDxUzEVkOJpOJyKJJpVJ8/vnnGDduHL788kv8+eef2L9/P2QyGfz9/fHaa69h9uzZqF+/foW3bWNjgz/++AOLFi3C5s2b8cUXX8Df3x/vvPMORowYYfLC0MnJCZGRkVizZg1+/PFH/PrrrygsLIS3tzeaNGmCZcuWYcCAAZVx6Hpz5szBiBEjsHz5cmzevBkODg6YNGkS/ve//xlcgMtkMuzYsQPvvPMOdu3ahRUrVqBevXr4z3/+g3feeQchISEV3refnx8OHz6MN998E0eOHMHevXsRHByMsLAw9O/fv8qTyUDxhe758+fx2WefYe/evTh8+DCsra3h5+eHvn37Gi3BMWjQIHz++ef45ptvsHz5chQVFaFRo0b6C+P69evj9OnTWLlyJX799Vf88MMP0Gg08PHxQUhICF555RW0atWqyo+LiIiIyJwWL15cYp2/v/8jJZMr+3rL1tYWBw8exH//+19ERERg2bJlaNy4Md566y306NED27Zt06+t/CBra2s8++yzWL58OSZNmqT/Vl951cTPDB06dMCbb76JyMhI7NmzBxkZGfD09ET79u3x6quv4vHHHy9zG2VdM+t4e3vjiSeewLZt23jjPaI6QiLu/w4IERFZjEWLFmHx4sU4ePAgevfube5wiIiIiIhqnG+++QbTpk3D119/XWKys3fv3vjzzz9x9epVNGnSpJojtGxarRZBQUFISkpCYmJiiUl7Iqo9uGYyEREREREREVm0hIQEo7Jbt25hyZIlkMvlGDJkiMl+J06cQGRkJAYNGsRE8kOIiIhAbGwsJkyYwEQyUR3BZS6IiIiIiIiIyKKNGjUKKpUK7du3h4uLC+Li4rBz507k5+fjww8/NLo/yFdffYX4+HiEh4dDKpWWuqwHGfvoo4+Qnp6ONWvWwN7eHgsWLDB3SERUTZhMJiIiIiIiIiKL9vzzz2PDhg349ddfkZWVBQcHB3Tu3BkzZ840eVO9jz/+GHfu3EFAQAA2bNiATp06mSFqy7VgwQJYWVkhJCQEn376KRo2bGjukIiomnDNZCIiIiIiIiIiIiIqE9dMJiIiIiIiIiIiIqIyMZlMRERERERERERERGViMpmIiIiIiIiIiIiIysQb8D2kzMxMREZGokGDBrCxsTF3OERERER0H6VSidu3b6NXr15wcXExdzh1Gq+biYiIiGquil43M5n8kCIjIzF8+HBzh0FEREREpdi2bRuGDRtm7jDqNF43ExEREdV85b1uZjL5ITVo0ABA8UAHBQVV+f7UajVycnLg6OgIuZxPW3XhuJtHbRn3mTNnAgBWrVpl5kjKVlvG3NJw3M2D424e1T3u0dHRGD58uP6ajcyH1811A8fdPGrLuPO6mcrCcTcPjrt51PTrZp4JD0n3Fb2goCC0aNGiyvenVquRmZkJFxcXvoCrEcfdPGrLuDs6OgJAtbxHPKraMuaWhuNuHhx38zDXuHNZBfPjdXPdwHE3j9oy7rxuprJw3M2D424eNf26mWcCEVEVmTFjhrlDICIiIiKq8XjdTERkOZhMJiKqIoMHDzZ3CERERERENR6vm4mILIfU3AEQERERERERERERUc3HZDIRURXZs2cP9uzZY+4wiIiIiIhqNF43ExFZDi5zQURURcLCwgDwa3tERERERKXhdTMRkeXgzGQiIiIiIiIiIiIiKhOTyURERERERERERERUJiaTiYiIiIiIiIiIiKhMTCYTERERERERERERUZksKpmcm5uLhQsXYvDgwXBzc4NEIsG6devK3T8zMxPTpk2Dp6cn7O3t0adPH/zzzz9VFzARERERERERERFRLWFRyeTU1FS89957iIqKQmhoaIX6arVaPPnkk/jxxx8xc+ZMfPLJJ0hOTkbv3r1x/fr1KoqYiIiIiIiIiIiIqHaQmzuAivD19UViYiJ8fHxw6tQpdOzYsdx9IyIicPToUfzyyy8YPXo0AGDs2LFo2rQpFi5ciB9//LGqwiaiOmrHjh3mDoGIiIiIqMbjdTMRkeWwqGSyjY0NfHx8HqpvREQEvL29MXLkSH2Zp6cnxo4di40bN0KpVMLGxqayQq1Ut5ILUahUIS9PhRyVEtZWGsikgEwqgUwqgfTfn6VSCWRS/Pu/BFIJIJFIzB0+ERERERERERERlUOOKgdX8i+jlUNrOMtdzB2OEYtKJj+KM2fOoF27dpBKDVf26NSpE9asWYNr166hVatWJvsmJycjJSXFoCw6OhoAoFaroVarqybof326OQ7RCYX/PkqqUF+ZFJDLJJDLihPMJn+WSWAlk+jbWsmlsJZLYCWXwFr/870yU/U21lLYWEmhsJbCxkry7/+6fxKLTWqr1WpoNJoqf47JEMe9+nHMzYPjbh4cd/Oo7nHn80tERERENZ1GqBGfH48beTGIzbuBuNwbSC1KBQAo7F5AB0X5V2WoLnUmmZyYmIiePXsalfv6+gIAEhISSkwmh4WFYfHixSbrcnJykJmZWWlxmlKk0jx0X40W0GgFlCpRiRFVnLVcAhsrw3+21lLYWkugsJHqf7a1Lk5E29roHt/7304hgb2NFFJp9SWmNRoNcnNzAQAymaza9lvX1ZZx171vLFy40MyRlK22jLml4bibB8fdPKp73HNycqp8H0REVDnmzJkDAFi2bJmZIyEiqlrZqmzE5sUgNjcWsXkxuJkXB5VQmWwbmxeDDh5MJptNQUGByWUsFAqFvr4kM2bMwJgxYwzKoqOjMXz4cDg6OsLFxaVSY32QRJJSdqMarkgtUKQWyCl5mMtFIgHsFTI42srgaHfvfyc7ORxsZXD6t8zBTgYnWzmcHWRwsZfDSv5w95rUzWpydnaGXF5nXi5mV1vG/ebNmwBQ5e8RlaG2jLml4bibB8fdPKp73B0dHat8H0REVDliYmLMHQIRUaXTCA3i8+/oZx3H5t5A2r+zjssjtahm5gPrzCcoW1tbKJVKo/LCwkJ9fUm8vLzg5eVlsk4ul1f5B6IlkwORX6hCZlY27O0dAakUGg2g1QpohCj+XwtoNAIabfE/rQDUGgG1RkCl1t73s4Dq35/VmuJylUZAoxFQ/1un0ggUqbRQqQWK1Lr/BVQaLdRqoe+jUhdvQ6Ot0sM3IASQW6BBboEGienl7+dgK4OrgxwuDnK4OljB1VEOFwcrfZmLgxXcHOVwdpDD+oHEs0wmq5bnmQzVpnG3lGOoTWNuSTju5sFxN4/qHHc+t0RERERUnQo0+biRewM3cmNwIy8GcXmxKNIa5yJNkUlk8Fb4wN+uMQLsA+Gl8UEjj0ZVHPHDqTNX2b6+vkhMTDQq15X5+flVd0jl5uliDbVaCnu5FVxcFDXuw5FGI1Co0kKp0qKw6N7/9/9coNSgoEiLQqUWBUVa5Cs1yC/UIK+wuC5fqUVh0b9tirRQFmmhrcSVOXQJ6NspZb+IXRzk8HS2gpeLNdyd5HCwVqOhjwTebgp4uVjDxUFerUttEBERERERERFRzSGEQFpRKm7kxiAmNwY38qKRWJAAgfIlsxzlTqhvVx+BDkFo6hiMhnaNYCW1AlD8jb6qXlL3UdSsrGQVatOmDQ4fPgytVmtwE77jx4/Dzs4OTZs2NWN0lk0mk8BeJoO9ovLWPxSieJ1nXdI5X6lFboEG2flqZOWqkZmnQlaeBtl5amTnq/XJ4rxCDQqU2nK+dE3LzFUjM1eN6/H3r8mRpf9JLpPAw8kKni7FCWcvF2v4utugnkfxPyc7mcXecJCIiIiIiIiIiAxphRa3828hJvd6cfI4NxrZ6uxy9b1/1nETx6Zo6tgMLtauVRxx1amVyeTExERkZWUhMDAQVlbFWf3Ro0cjIiICW7ZswejRowEAqamp+OWXXzBkyBCT6ymT+UgkEij+vRmfm6NVhfpqtAJ5/yaeM3PVyMhVIy1bhbTsIqRnq5GRq0JmrhpZeWrk5Gug0lQs9azWCNzNKMLdjCIAeUb1DgoZ6nnYwO/f5HI9dxvU87SBn7tNpSbciYiIiIiIiIio8mmFFokFCbiWcxVXc64gOvcaCjTluxGYncwO9e0aIMihCYIdQ9DQ/t6s49rA4pLJq1atQmZmJhISEgAAv/32G+7cuQMAeOWVV+Ds7IwFCxZg/fr1iI2Nhb+/P4DiZHKXLl0wefJkXL58GR4eHggLC4NGo8HixYvNdThUBWRSCZzs5XCyl6O+Z+lthRDIV2r/TTqrkJ6tQtK/ieKkjCKkZBYhPbsIuYXlTzjnFmpw9U4+rt7JN6pzcZCjnocNGnjawN/HFo19bNHYVwFHW4t7KRIREVENlpmZifnz52Pr1q3Iz89Hp06d8Pnnn6Ndu3bl6q/VarF69WqsXr0aV69ehZ2dHUJDQ7Fs2TKEhoZWcfRERERE1UsIgSTlXVzLuYpr2VdwPfcactW55errbu2BRvb+aOLYDMEOwfBUeNXqb6xbXAbrs88+w82bN/WPt2zZgi1btgAAnnvuOTg7O5vsJ5PJsGvXLsybNw8rVqxAQUEBOnbsiHXr1qFZs2bVEjvVPBKJBPaK4iU66nkYz07XrVNja++EzDyBlKwiJP+bbL6bXoTkzOLHadmqcq3xrFtC41Kc4YxmT2crNPYtTi4H+CrQ2McWfh42kHFtZos2cOBAc4dARER1kFarxZNPPolz585h3rx5+kkUvXv3xunTp9GkSZMytzFlyhT88MMPmDBhAmbOnIm8vDycOXMGycnJ1XAERFTX8LqZiMwhVZmKazlXcDXnCq7nXEWWKqvMPnKJHL4KPwQ4BKKZYzCCHJvCXm5fDdHWHBaXTI6Liyuzzbp167Bu3TqjcldXV6xduxZr166t/MCoVrOxkqKeh9xkwhkoXvoiKaMI8amFuJOixM3kQsSnKJGYrkRGjrrMNZxTslRIyVLhxJV76+1YyyVo5K1AwL9J5qB6tmhSzw7WVtJStkQ1ycyZM80dAhER1UERERE4evQofvnlF/3ybmPHjkXTpk2xcOFC/Pjjj6X2//nnn7F+/Xps2bIFI0aMqI6QiaiO43UzEVWHHFUOruVcwZWcKFzNjkJaUVqZfWQSGfwU9dDEsSlaubRGY/vAWrVkxcOwuGQyUU0kl0n0N+DrFGxYV6TSIjFdiTupyuJEc1IhbiYV4E6KEkXqktPMRWqB6/EFBjcClMskaFrfDs0b2iGkkT1CGtnDxaFuv4kRERGRoYiICHh7e2PkyJH6Mk9PT4wdOxYbN26EUqks9X4hS5cuRadOnTBixAhotVoUFBTA3r5uzbghIiIiy6fUKBGdew1Xc67gSnYU4gvulNlHAgl8bf3QxKEpWji3QhPHJrCW8j5r92MymaiKWVtJ0cjbFo28bQ3KtVqBxPQixN4twPU7+YhJKEBcUiHSslUlbkutEbh8Mw+Xb+bh18MpAAA/d+t/E8sOCGlkjwaeNpByeYwaITo6GgAQFBRk5kiIiKguOXPmDNq1awep1PDbTJ06dcKaNWtw7do1tGrVymTf7OxsnDhxAjNmzMBbb72FlStXIjc3F40bN8ZHH32EsWPHlrrv5ORkpKSkGJTpfh+q1Wqo1epHOLLyUavV0Gg01bIvuofjbh61ZdxjYmIAAIGBgWaOpGy1ZcwtDcfdPCxt3DVCg1v5cbiWW3zTvLj8WGiEpsx+3jbeCLAPQohTSzR1aAaFTHGvUguotdV7/NU97hXdD5PJRGYild6bzdy9pYu+PK9Qg9i7BbiRUIDr8fm4kViIOymFJc5iTkgrQkJaEf74JwMA4GArQ/OGxbOWQwMc0LSBHddeNpO5c+cCAHbs2GHmSIiIqC5JTExEz549jcp9fX0BAAkJCSUmk2NiYiCEwE8//QS5XI5PPvkEzs7O+OKLL/D000/DyckJgwcPLnHfYWFhJd7cOicnB5mZmRU/oArSaDTIzS2+YY5MJqvy/VExjrt51JZxnzdvHgDgu+++M3MkZastY25pOO7mUdPHXQiBNHUqoguu40ZhNOIKY6EUyjL7uchc0cjGH01smyLItilsZf9O/hNAYU4hClFYxZGXrrrHPScnp0LtmUwmqmHsFTK09HdAS38HfZlGIxCbVIDLcXk4F5OLK7fzkJ5j+i9HuQUanLyajZNXi9dfdrCVoV0TR3Ro6oj2TZzg5sRlMYiIiCyFVqtFUVFRudra2NhAIpGgoKDA5DIWCkXxLJuCggKjOh3dB5e0tDT8/fff6Ny5MwBg6NChaNy4Md5///1Sk8kzZszAmDFjDMqio6MxfPhwODo6wsXFpVzH8ih0s2ucnZ0hl/PjTnXhuJtHbRv36niPeFS1bcwtBcfdPGriuOep8/6deRyFKzlRyFCll9nHXmYPf7sAhDi1QEunVnCxdq2GSB9edY+7o6NjhdrXjDOBiEolk0kQ5GeHID87DH3MEwCQklWEyzfzcOFGLi7G5eF2ciG0JiYv5xZo8Of5TPx5PhMAEOBrW5xYbuqEkEb2kMs4a5mIiKim+vPPP9GnT59ytY2KikJwcDBsbW2hVBrPyiksLJ5lY2tra1Sno6tr3LixPpEMAA4ODhgyZAg2btwItVpd4gcbLy8veHl5mayTy+XV9kFUJpNV6/6oGMfdPGrTuFvKMdSmMbckHHfzMPe4q7VqxObdwJXsy4jKvoxb+TchUPL9pwDAWmqNRnb+aO4UgpbOreFnWw8SiWXlPqpz3Cu6D74CiSyUp7M1erW2Rq/WxX9RK1BqcPVOPi7G5uFCbC6u3c5HoUpr1O9GYgFuJBbg58hk2NpI0TbIEe2bOqJDUyd4uVhX92EQERFRKYKDgxEeHl6utrplLHx9fZGYmGhUryvz8/MrcRu6Om9vb6M6Ly8vqFQq5OXlwdnZuVwxEREREVWEEALJymREZV/ClezLuJZzFUpt6UtXSCGFn209NHNsjtYuoWjsEACZpOYty1FbMJlMVEvY2sjQJtARbQKLv56g1ghE3crDiSvZOHElG7eSjdf8KVBqcfRSFo5eygIANPRSoHtLZ/Rp44r6ngqj9kRERFS9fHx8MGnSpAr1adOmDQ4fPgytVmtwE77jx4/Dzs4OTZs2LbGvn58ffHx8EB8fb1SXkJAAhUJR4a9CEhEREZVGrVUjOvc6Lmadx8WsC0hRJpfZx83aDUEOTdHKJRQhTi0Mb5pHVYrJZKJaSi6ToFVjB7Rq7ICpj/shPVuF09dz8HdUFs5G5yBfaTxr+VZyIX48UIgfDyShaX079G3jip6tXeDqyHWWiYiILMXo0aMRERGBLVu2YPTo0QCA1NRU/PLLLxgyZIjBesoxMTEAgMDAQH3ZuHHj8MUXX2Dfvn0YMGCAvv/27dvRt29fgwQ1ERER0cPIUWXjUvZFXMw8j6jsyyjUln7TO4VUAX+HALR0aolWzqHwUHhWU6T0ICaTieoINycrDGjvhgHt3aDRCly7k4+TV7Jx/EoWYhMLjVYcunYnH9fu5GPNrni0C3JEnzaueKyFMxTW/KoIERFRTTZ69Gh06dIFkydPxuXLl+Hh4YGwsDBoNBosXrzYoG2/fv0AAHFxcfqyBQsW4Oeff8aoUaMwd+5cODs74+uvv4ZKpcL//ve/6jwUIiIiqiWEEIgvuKOffRyXF1vq2se6pSuCnUIQ6tIG/vaNIZXwD9o1AZPJRHWQTCpB84b2aN7QHhMG+iIrT41/rucg8nwGTl/Ngfq+O/lptcCpazk4dS0HCmspHgtxRt+2rmgT6AgZb95XqqVLl5o7BCIiqoNkMhl27dqFefPmYcWKFSgoKEDHjh2xbt06NGvWrMz+3t7eOHLkCF5//XUsW7YMKpUKXbt2xcaNGxEaGloNR0BEdQ2vm4lqpyKtEtdyruJC5gVczDqPTFVGqe3tZHZo4tAUbVzboZVLKGxlJd80mMyHyWQigrO9HH3auKJPG1fkFKhx5EIW9p1OQ9StfIN2hUVaHDibgQNnM+DqIEfP1i7o29YNTerZWtydUatDUFCQuUMgIqI6ytXVFWvXrsXatWtLbXf/jOT7BQQEYMuWLVUQGRGRMV43E9Ueaco0XMoqTh5fy7kKlVCV2t7LxhvNnULQ3q0jGtsHcPaxBWAymYgMONrK8XgndzzeyR1JGUU4dC4d+05nID7V8O6pGblqbD+aiu1HUxHSyB5je3mhU7ATk8pEREREREREdYRGqHEjNwYXsy7gUtZFJBYmlNpeLpGjkb0/Wju3QTvX9nCzca+mSKmyMJlMRCXydrXGuN4+GNvLGzcSC3DgTPGs5MxctUG7yzfzsOj7WPj7KDC2lzd6tnLhEhgAVq1aBQCYOXOmmSMhIiIiIqq5eN1MZFlyVDm4nH0RF7MuICr7Ego0BaW2d5A7opljMNq6tkML55awltqU2p5qNiaTiahMEokEgX52CPSzw5TH/XD+Ri7++CcdRy9lobBIq28Xd7cQn2y+ie/3JWJ0Ty8MaOcGa6u6+xWV33//HQAviomIiIiISsPrZqKa725hIs5mnMGFrHO4mRdX6s3zJJDAz7YeQpxaop1rBzSwa8BvMdciTCYTUYXIpBK0DXJE2yBHFCg12HUiDb/+mYyM+2Yr300vwqptd/DD/rsY0c0TT3T2gL1CZsaoiYiIiIiIiKi8hBC4U3AbJzL/xtW7V3BXmVhqe4VUgUCHIIS6tEWoa1s4yB2qKVKqbkwmE9FDs7WRYVQPLwzp6oEDZzKw+WAS7mYU6eszctT4bk8ifj6UjKe6emDYY55wceDbDhEREREREVFNoxVa3MyPw9mMf3A24x+kFqWW2t7TxgvBjiFo79YeAQ5BkEk4iawuYFaHiB6ZtVyKwR3dMaC9G45czMSmA0m4mVSor88t1OCng0nYeiQZgzq4Y2QPL3i7WpsxYiIiIiIiIiLSCi1icq/jTMYZnMs8g0xVRoltZRIZ/O0bo7VLG7Rz4c3z6iomk4mo0sikEvRq7YqerVxw6loONh24i6hb+fp6pUpgx7FU7DqRhlE9vPB0H28orOvumspERERERERE1U0rtLiWcxX/ZJzC+cyzyFHnlNhWDjkCHALR0b0T2rp2gK3MthojpZqIyWQiqnQSiQQdmzmhYzMnXIrLxU8Hk3Dq2r1fTmqNwOZDSTh0LgMzhtZDp2BnM0ZLREREREREVLsJIXAr/yZOpZ/A6YyTyFJlldjWWmqNJg7N0M65PRrCH15uXpDLmUKkYjwTiKhKtfB3wJLJDohNLMBPB5Nw+GImxL83fU3KKMLC9bHo1sIZLw6pB0/n2rX0RWBgoLlDICIiIiKq8XjdTFR1kguTcDL9BE6ln0CyMqnEdgqpLZo5BaOjWye0dG4NK6kV1Go1MjMzqy9YsghMJhNRtWjsa4sFz/hjXGIBVmy5jat37i1/8delLPxzPQfP9ffBsMc8zRhl5Vq2bJm5QyAiIiIiqvF43UxUubJUWfgn/RROph/Hzfy4EtvZyewQ4tQSndw7I9gphDfQo3JhMpmIqlWAry2WTm+CvafS8e3uBOQVagAABUVafLMrAfvPpGP6U37wcTJzoEREREREREQWokBTgLMZZ3Aq/Tiu5lyBgDDZzkpqjWDHYDzm0R0tnFsxgUwVxmQyEVU7qVSCxzu5o2uIM9buisf+M/fuFnsjsRDzvrmBPq3t8cKTDnB14tsUERERERER0YNUWhUuZV3AyfQTuJR1ASqhMtlOCikCHILQxb0r2rt1gLXUppojpdqEWRoiMhsXBzleH9sIAzu4Y+XW27iTqtTXHTyfh39irmPq4/XQv50rJBKJGSN9OEOHDgUA7Nixw8yREBERERHVXLxuJio/jdDgWs4VnEw/gXMZZ1CoLSyxbQPbhujo3gmd3R6Dg5VDNUZJtRmTyURkdq0DHBA2qxm2HknBD/vvokhd/HWcrDwNlkbcwr7TaXh5WAM08laYOVIiIiIiIiKi6iWEQGzeDZxKP4F/Mk4hR51TYlsvG2+0c22Pxzy6w93GoxqjpLqCyWQiqhGs5FKM7e2Nnq1dsGrbbZy+nquvuxCbh5krr2LWyAbo387NjFESERERERERVT0hBBIK4nEq4wROpZ9EelFaiW1drFwQ6tIW3Tx6oJ5d/WqMkuoiJpOJqEbxcbPBwucbYf+pu9hwMAvpOWoAgFoj8Pkvt3AzqRCTBvlCJrW8ZS+IiIiIiIiISpNRlIHjaUdxMv0E7hYmltjOXmaPls6h6O7ZHY3tAy1yaUiyTEwmE1GNI5FI0KGJLbq19sKmg6nY+leKvi7iz2TcSirE/KcbwV7Bu84SERERERGRZdMIDS5nXcSR1MO4lHUBAsJkOxupAs2dQvCYR3c0dwqBVCKt5kiJmEwmohrM1kaGaU/VQ4vG9vh08y0oVVoAwImr2Zj71TUsmhgAXzfehZaIiIiIiIgsT5oyDcfSjuBY6l/IVGWabCOXyNHEsRm6uD+GUJc2sJJaVW+QRA9gMpmIarxuLVzgO90Gi9bfQEqWCgBwK1mJWV9ewzvP+qN1gKOZIyQiIiIiIiIqm0aocSHzAv5KPYyo7EsmZyFLIEFj+wB0ce+K9m6doJDxZvRUczCZTEQWIcDXFitmNsWSDbG4fCsfAJCTr8Fb38ZgxrD6eKJTzbtL7YwZM8wdAhERERFRjcfrZqoLUpUp+Cv1CP5O/QvZ6myTbRzlTujg1hF9vPrB3abmfcYlAphMJiIL4uJghQ9fCMLKrbfxxz8ZAACNFli59Q5u3i3EtCfrQSarOTcdGDx4sLlDICIiIiKq8XjdTLWVRqhxLvMc/kr5E1dyoky2kUCCIIcm6OXVF6EubbgOMtV4TCYTkUWxlksxd3RD+PvY4ttdCfovBO04lorbKYVY8Iw/HG351kZERERERETmkaXKwl8ph3Ek9U9klbAWsrOVMzq6dUZvz75wtXGr3gCJHgEzLkRkcSQSCUb18EIDTwU++ikOBcriG/Odic7FnLDrWDShMep7mn9NqT179gDgTAsiIiIiotLwuplqAyEEbuTF4M/kQziTeRoaoTFqI4UUTRybordXX7R0bs1ZyGSRmEwmIovVKdgJy6Y3xaLvb+BuehEAID5ViVlh1/DWeH+0b+pk1vjCwsIA8KKYiIiIiKg0vG4mS1akVeJU+klEJh/EnYLbJtu4WLmgs3tX9PLsC2dr52qOkKhyMZlMRBatkbcCX8xoig9+iMP52FwAQH6hFu+uu4GXnqqHoY95mjlCIiIiIiIiqm1SlMk4nBKJY6l/IV+Tb7JNgH0g+noP4FrIVKswmUxEFs/JXo4Ppgbiqx13sOtEGgBACOCr3+LhZC9H71BXM0dIRERERERElk4rtIjKvoTI5IO4nH0JQn8Xn3tspAq0dW2Pgd6D4G3rY4YoiaoWk8lEVCvIZRK8MqIBGvvY4qvf7kD77+/0ZRG30MDTBoF+duYNkIiIiIiIiCxSkVaJv1OP4WDyH0hWJpts42XjhR6evdDdsyespTbVHCFR9WEymYhqlae6esDRXoaPNt0EABSpBd7bEIsVM5vB2Z5veURERERERFQ+Waos/Jl8EIdTIpGnyTOql0KKZk7NMcB7EJo6NoNEIjFDlETVi5kVIqp1erV2xY2EAvwcWfwX4+RMFf73Yxz+NyUQMhl/uRMREREREVHJ4gvu4EDSHziVfgJqoTaqt5c7oJNbF/TzHgBXay6rSHULk8lEVCtNGOiLmMQCnL6WAwA4fyMXa3fH48Wn6ps5MiIiIiIiIqpphBC4knMZ+5P2ISr7ssk2Pgof9PUagC4eXSGTMKVGdRPPfCKqlWRSCd54uhFmrbqGxPQiAMC2v1IR5GeHfu3cqiWGHTt2VMt+iIiIiIgsGa+byZxUWhVOpZ/AgaR9SChMMNkmyKEJBvs+gWDHEC5lQXUek8lEVGs52sqxcEJjzP7yOgpVWgDAF1tvo6G3Ak3q8YZ8REREREREdVWeOg+HUw4hMvkgstXZRvVyiRyhLm3wuO9T8LX1M0OERDUTk8lEVKs18rbF62Mb4v0f4gAAKrXA4u9jseqVpnBxsDJvcERERERERFStslSZ2J/0Bw6nRKJIqzSqt5fZo4vHY+jvPQhOVk5miJCoZmMymYhqvW4tXTC+jzc2HUwCAKRlq7BkYxw+fiEI8iq8Id+cOXMAAMuWLauyfRARERERWTpeN1N1SFOmYl/SXhxL/cvkTfU8bDzR27Mvunv2hJWUE4+ISiI1dwBERNXhuf4+6NTs3l+VL9/Mw+qdd6p0nzExMYiJianSfRAREZmSmZmJadOmwdPTE/b29ujTpw/++eefcvf/+eef0aVLF7i4uMDd3R29evXC//3f/1VhxERUl/G6marS3YJEfB8bjkUX38HhlEijRLK/XWO8EDAdi1q8jz7e/ZhIJioDZyYTUZ0glUow/+lGmPXlNcSnFn+VaeffaQjys8Ogju5mjo6IiKjyaLVaPPnkkzh37hzmzZsHDw8PhIWFoXfv3jh9+jSaNGlSav+VK1fi1VdfxZNPPomPPvoIhYWFWLduHZ566in8+uuvGDlyZDUdCRER0cO7lX8TexN341zmGQgIo/qmjsEY4jcMAQ6BZoiOyHIxmUxEdYa9QoaFzzfGrC+voaCo+IZ8q7bfQSNvBYIb2ps5OiIiosoRERGBo0eP4pdffsHo0aMBAGPHjkXTpk2xcOFC/Pjjj6X2X7lyJTp27IjffvtNf8f6KVOmoF69eli/fj2TyUREVKNF51zH3ru7cDn7klGdBBK0dG6Fp3yHob59AzNER2T5mEwmojqlgZcC88c1wuINsQAAtUbgvQ2xWPVqM7g58utMRERk+SIiIuDt7W2Q9PX09MTYsWOxceNGKJVK2NjYlNg/OzsbTZs21SeSAcDJyQkODg6wtbWt0tiJiIgehhACUdmXsefuLsTkXjeql0lkCHVpiyF+w+Cl8DZDhES1B5PJRFTndAlxxnP9vLFxf/EN+TJy1XhvQyw+nRYEKzmXkiciIst25swZtGvXDlKp4e+0Tp06Yc2aNbh27RpatWpVYv/evXsjIiICK1euxJAhQ1BYWIiVK1ciKysLs2bNKnXfycnJSElJMSiLjo4GAKjVaqjVxjc8qmxqtRoajaZa9kX3cNzNo7aNuyUcR20bc0tR0rgLIXAp+wL2JO3C7YJbRv2sJFZo79IBg32ehKu1m35bVD48382juse9ovthMpmI6qTxfX0QnVCAv6OyAQBXb+cjbMcdzBrZ0MyRERERPZrExET07NnTqNzX1xcAkJCQUGoyecWKFUhNTcWrr76KV199FQDg4eGB/fv3o2vXrqXuOywsDIsXLzZZl5OTg8zMzHIexcPTaDTIzc0FAMhksirfHxXjuJtHbRv36niPeFS1bcwtxYPjLoTA1YIoHMo6gMSiBKP21hIbtLNvjx7OveEgdwDygcz8zGqO2vLxfDeP6h73nJycCrVnMpmI6iSpVIJ544pvyHcnpfiGfHtOpiPIzw5PdvGolH0MHDiwUrZDRER1l1arRVFRUbna2tjYQCKRoKCgwOQyFgqFAgBQUFBQ6nbs7OzQrFkz1K9fH0899RRycnKwbNkyjBw5EocPH0ZQUFCJfWfMmIExY8YYlEVHR2P48OFwdHSEi4tLuY7lUehm1zg7O0Mu58ed6sJxN4/aMu4DBgwAgGp5j3hUtWXMLY1u3B2dHBGVdwl7k3cjvvCOUTs7mR26ufdEP8/+sJXbVXeYtQ7Pd/Oo7nF3dHSsUHueCURUZ9nZ3LshX76y+IZ83+xKQO82rrBXPPpf/2bOnPnI2yAiorrtzz//RJ8+fcrVNioqCsHBwbC1tYVSqTSqLywsBIAy1z0eM2YM5HI5fvvtN33ZsGHD0KRJE7z99tvYvHlziX29vLzg5eVlsk4ul1fbB1GZTFat+6NiHHfzqA3j/sorr5g7hAqpDWNuabRCiyuFl3Ek9U8kFMYb1dvLHdDbsy/6eQ+Ajazk+wJQxfF8N4/qHPeK7oNnAhHVafU9FXjj6UZYuL74hnxKlRaHzmXgyc6VMzuZiIjoUQQHByM8PLxcbXXLWPj6+iIxMdGoXlfm5+dX4jZu3LiBPXv2YM2aNQblbm5u6N69O/7666/yhk5ERPTItEKLMxmnsStxJ+4WGv9uc5A7oLdXP/TzHgBrqbUZIiSqe5hMJqI6r1OwMwL9bBGTUPy1399PpVVKMll3w6HSvg5MRERUGh8fH0yaNKlCfdq0aYPDhw9Dq9Ua3ITv+PHjsLOzQ9OmTUvsm5RUfHNajUZjVKdSqXgDHiKqErxupgdphRb/ZJzC7sT/M5lEdpQ7oo9Xf/T17g8rqZUZIiSqu6RlNyEiqv0GtHfT/3ztTgHupBQ+8jbnzp2LuXPnPvJ2iIiIKmL06NFISkrCli1b9GWpqan45ZdfMGTIEIP1lGNiYhATE6N/HBQUBKlUis2bN0MIoS+/c+cODh8+jLZt21bPQRBRncLrZtIRQuBsxhm8f3kRwmPXGiWSHeVOGFZvJJa0+giDfB9nIpnIDDgzmYgIQJ9QV6zdlQC1pviD864TaZj2ZD0zR0VERFRxo0ePRpcuXTB58mRcvnwZHh4eCAsLg0ajweLFiw3a9uvXDwAQFxcHAPD09MSUKVOwdu1a9OvXDyNHjkROTg7CwsJQUFCABQsWVPfhEBFRHRGXF4std35BTG60UZ2T3BldHbphYIPBUFgrzBAdEekwmUxEBMDJXo7OzZ3w18UsAMChsxmY+rgfZFKJmSMjIiKqGJlMhl27dmHevHlYsWIFCgoK0LFjR6xbtw7NmjUrs/9XX32F0NBQfPvtt/rkcceOHfH999+jZ8+eVR0+ERHVMWnKVGyP34rTGSeN6pytXNDfewC6ufVETlYO5FKmsYjMja9CIqJ/DWzvpk8mZ+SqcepqNjo3dzZzVERERBXn6uqKtWvXYu3ataW2081Ivp9cLsfMmTMxc+bMKoqOiIgIyFfnY+/dXTiUfABqYbgmv73MHgN9Hkcf776QSeRcs5+oBrGoNZOVSiXeeOMN+Pn5wdbWFp07d8a+ffvK1fePP/5Anz594OHhARcXF3Tq1AkbNmyo4oiJyJK0b+IEV4d7f2PbcyrNjNEQERERERHVPmqtGoeSD2DRxbfxR9LvBolkucQKvT374r2W/0N/n4GQSTgHkqimsahX5aRJkxAREYHZs2ejSZMmWLduHZ544gkcPHgQ3bt3L7Hfjh07MHz4cHTt2hWLFi2CRCLBzz//jAkTJiA1NRVz5sypxqMgoppKJpOgXzs3RPyZDAA4fTUH2XlqONlb1FslERERERFRjSOEwLnMs9ge/yuSlclG9aEubTG6/li42bibIToiKi+LyZCcOHECP/30Ez799FO8/vrrAIAJEyagZcuWmD9/Po4ePVpi31WrVsHX1xcHDhzQ3736xRdfRHBwMNatW8dkMhHp9b8vmazSCOw7nY5RPb3MHBUREREREZHlKu3mev72ARjb4Gk0svev/sCIqMIsJpkcEREBmUyGadOm6csUCgWmTp2Kt956C7dv30aDBg1M9s3Ozoarq6s+kQwUrwXn4eFR5XETkWVp5K1A0/p2uHYnHwCw/8zDJ5OXLl1amaEREREREdVKvG6uvTKLMrD1zq84lXHCqM7DxhMj6o1EG9f2ZoiMiB6WxSSTz5w5g6ZNm8LJycmgvFOnTgCAs2fPlphM7t27Nz7++GO8++67mDhxIiQSCX788UecOnUKP//8c5n7Tk5ORkpKikFZdHTxX9PUanW1LASvVquh0Wi46Hw147ibh7nHvV9bZ30yOfZuIa7czEFQPdsKb8ff3x8ALOL8MfeY11Ucd/PguJtHdY87n18iIssRFBRk7hCokmmEBn+mHMLO+O0o1BYa1NnL7DHI9wn08eoHqcSibuVFRLCgZHJiYiJ8fX2NynVlCQkJJfZ99913ERsbiw8++ADvv/8+AMDOzg6//vorhg0bVua+w8LCsHjxYpN1OTk5yMzMLMcRPBqNRoPc3FwAgEwmq/L9UTGOu3mYe9xDG0oglwFqTfHjnccSMam/W7XHUZ3MPeZ1FcfdPDju5lHd456Tk1Pl+yAiIiJjcXmx+OnmRtwuuG1QLpdYobtHDwzxGwaFvOKTdYioZrCYZHJBQYHBMhU6CoVCX18SGxsbNG3aFKNHj8bIkSOh0WiwZs0aPPfcc9i3bx+6dOlS6r5nzJiBMWPGGJRFR0dj+PDhcHR0hIuLS8UPqIJ0s2ucnZ0hl1vM02bxOO7mYe5xdwHQpXkujlzMBgCcuKbEjGFOsLaq2F/Nv/rqKwDA9OnTKznCymfuMa+rOO7mwXE3j+oed0dHxyrfBxERVY5Vq1YBAGbOnGnmSOhR5Kvz8VvCNhxOiYSAMKhr4dQSTzd8ljfXI6oFLOYTlK2tLZRKpVF5YWGhvr4kM2fOxN9//41//vkHUmlxMmjs2LFo0aIFZs2ahePHj5e6by8vL3h5mV4zVS6XV9sHUZlMVq37o2Icd/Mw97gP7uihTybnFGhw/Goe+rRxrdA29u3bBwB45ZVXKj2+qmDuMa+rOO7mwXE3j+ocdz63RESW4/fffwfAZLKlEkLgdMZJRNz+GTnqbIM6V2s3jG0wHq1dQs0UHRFVNotZnMbX1xeJiYlG5boyPz8/k/2Kiorw7bff4sknn9QnkgHAysoKjz/+OE6dOoWioqKqCZqILFabIEe4Od5LRPxxOs2M0RAREREREdU8SYVJWHl9GcJj1xokkmUSGfp49cd/Q95jIpmolrGYKRtt2rTBwYMHkZ2dbXATPt2s4jZt2pjsl5aWpr/hy4NUKhW0Wq3JOiKq22RSCfq3c8PPkckAgHM3cpGcoYSXq/FyO0RERERERHWJSqvC73d34/e7e6AWhje99bcPwHONJsDX1vSkPyKybBYzM3n06NH6tY51lEolwsPD0blzZzRo0AAAcOvWLVy5ckXfxsvLCy4uLti6davBDOTc3Fz89ttvCA4OLnWJDCKquwa0v3fTPY0W+P10uhmjISIiIiIiMr+o7Ev44PJi7ErcaZBItpc74JlGE/B6szeYSCaqxSxmZnLnzp0xZswYLFiwAMnJyQgKCsL69esRFxeHb7/9Vt9uwoQJiIyMhBDFi73LZDK8/vrreOedd9ClSxdMmDABGo0G3377Le7cuYONGzea65CIqIar76lAswZ2uHo7HwAQeT4T4/v4QCaTmDkyIiIiIiKi6pWjykbE7Z9xKuOEQbkEEnR064TRDZ6GvdzeTNERUXWxmGQyAHz//fd49913sWHDBmRkZKB169bYuXMnevbsWWq/t99+G40bN8YXX3yBxYsXQ6lUonXr1oiIiMCoUaOqKXoiskSDOrjpk8l3UpS4GJeL0EBHM0dFRERERERUPYQQOJH+N369/TPyNHkGdT4KXzzT6HkEOgSZKToiqm4WlUxWKBT49NNP8emnn5bY5tChQybLn3nmGTzzzDNVFBkR1VY9W7vi69/iUaQu/rbD76fTy51MDgwMrMrQiIiIiIhqBV4311xpylRsuvUDorIvGZRbS20wyOdxDPQZDKnEYlZQJaJKYFHJZCKi6mavkKFriDMiz2cCAE5EZSMrTw1n+7LfPpctW1bF0RERERERWT5eN9c8WqFFZPJB7EjYhiKt0qCuqWMwJvhPhqu1q5miIyJzYjKZiKgMgzq665PJuYUaHLmYiSc7e5g3KCIiIiIioiqQUJCAH29+j9i8Gwbl9nIHjKo/Bp3du5opMiKqCZhMJiIqQ2iAA9ydrJCWrQIAHDqbgYHt3WAl59e5iIiIiIiodlBpVfj97m7svbsbGqExqGvj0g7jGz4HBysHM0VHRDUFk8lERGWQSiXo19YVP0cmAwAu38zD7RQlAnxtS+03dOhQAMCOHTuqPEYiIiIiIkvF62bzi829gY031+NuYaJBuYuVK8Y3fBYtXVqbKTIiqmmYTCYiKodBHd31yWStAPafSUdjHz9IJBIzR0ZERERERPRwCjWF+C1hGyKTD0JA6MslkKCrezeMbjAONjIbM0ZIRDUNk8lEROXg526D4AZ2uHI7HwBw9GIWnu7tBUc7KzNHRkREREREVHFXsi/jh5sbkF6UZlDuZeON5/wnIdAh0EyREVFNxmQyEVE5Dergpk8m380owsXYfHRt4WzmqIiIiIiIiMpPpVVhe/wWHEzeb1Auk8jQx6s/htYbBpmE6SIiMo3vDkRE5dQr1BVf74yHUlX89a/9Z9LRvpkjrHkjPiIiIiIisgDxBXew7sZaJBQmGJTXt22ACf5TUM+unpkiIyJLwWQyEVE52drI0KW5MyLPZwIA/rmeg9SsIvi5K8wbGBERERERUSm0QotDyfuxPX4r1EKtL5dL5Hjc9ykM9BkMqYSTZIiobEwmExFVwOMd3fXJ5IIiLf66mIVRPWwglfJGfEREREREVPNkFmViQ1w4ruREGZT7KHwwufE01Lerb6bIiMgSMZlMRFQBrQMd4OlshZQsFQDgr0tZGNzRHY52xm+nM2bMqO7wiIiIiIgsDq+bq87ZjH/w480NyNPkGZR39+iJMQ2ehlzKtBARVQzfNYiIKkAikaBPG1f8HJkMALh2Jx+J6UUmk8mDBw+u7vCIiIiIiCwOr5srX6GmEBG3N+NY2l8G5U5yJzznPwktnFuaKTIisnRMJhMRVdDgju74JTIZAoAQwOELGWha387cYRERERERESE27wbWxX6LVGWKQXmIUwtM9J8KBysHM0VGRLUBk8lERBXk626D4IZ2iLqVDwA4cSUbUx83vuvxnj17AHCmBRERERFRaXjdXDk0QoPf7+7GroSd0EKrL7eW2mBEvVHo6dXbfMERUa3BZDIR0UPoGuKsTybfTS+CWqOFXGZ49+OwsDAAvCgmIiIiIioNr5sfXZoyDeti1+JGXoxBeX3bBpgaMA1eCm8zRUZEtQ2TyUREDyHQz1b/c5FaIDmjCH4eCjNGREREREREddGN3BisjglDrjpHXyaFFH28+mN4/ZGQSqSl9CYiqhgmk4mIHkJ9T8PE8c2kQiaTiYiIiIioWp1OP4nv48KhFmp9mauVGyY2noImjk3NGBkR1VZMJhMRPQQPJytYyyUoUgsAwO1UJbqaOSYiIiIiIqobhBDYc3cXdiZsNygPcWqBqY1fhELOiS5EVDWYTCYieghSqQS+7ja4mVQIAIhPVZo5IiIiIiIiqgvUWjV+vLUBx9OOGZT38eqHUfXHQiKRmCkyIqoLmEwmInpI9T3uJZMT05hMJiIiIiKiqpWnzsM3MV/heu41fZlMIsOY+uPQw6u3+QIjojqDyWQioodUz8NG/3NSRhGEEJwFQEREREREVSK5MAlfRa9EsjJZX2Yrs8XUxi+iuXOIGSMjorqEt/QkInpI9yeTU7NUKFRqDep37NiBHTt2VHdYRERUxyUmJuLNN99Enz594OjoCIlEgkOHDlVoG/Hx8Rg7dixcXFzg5OSEYcOG4caNG1UTMBHVebxuLlt0znV8duUjg0Sym7UbXmv2BhPJRFStmEwmInpI9yeTtQKITys0YzRERFTVNm7ciLS0NHOHUaarV6/i448/Rnx8PFq1alXh/rm5uejTpw8iIyPx1ltvYfHixThz5gx69eplEcdPRFTbHE87hhXXlyJPk6cva2jXCG8Evw1fWz8zRkZEdRGTyURED6meh+Edkm+lcN1kIqLabOLEidi7d6/+sVqtRnR0tBkjMq19+/ZIS0vDtWvXMHfu3Ar3DwsLw/Xr17Fz507Mnz8fc+bMwe+//47ExER8/vnnVRAxERGZIoTAzoQd+D4uHBqh0ZeHOrfB3Kbz4WDlaMboiKiuYjKZiOghOdvLYK+49zYa/0Ayec6cOZgzZ051h0VERFVECGHwOCsrC82aNcOBAweM2l68eBE//PBDdYVmwNHREW5ubg/dPyIiAh07dkTHjh31ZcHBwejXrx9+/vnnygiRiMgAr5uNqbQqrIv9FrsTdxqUD/AehBcCp8NKZmWmyIioruMN+IiIHpJEIkE9DwWu3ckHAMSnGSaTY2JizBEWERFVowcTzDrnzp3DhAkT8Oyzz1ZzRI9Gq9Xi/PnzmDJlilFdp06d8PvvvyMnJweOjqZnwyUnJyMlJcWgTDd7W61WQ61WV37QD1Cr1dBoNNWyL7qH424etWXcddfNlnAc1THmuepcrI1djdj8e58nZBI5xtZ7Gl3cH4NGoymld+1UW851S8NxN4/qHveK7ofJZCKiR1Dfw0afTE5M4zIXRERk2dLT06FUKuHr62tUpytLSEhAs2bNTPYPCwvD4sWLTdbl5OQgMzOz0mItiUajQW5uLgBAJpNV+f6oGMfdPGrbuFfHe8SjquoxT1OlYWPyOqSr761Rbyu1wziPZ9BYFmARY1QVatu5bik47uZR3eOek5NTofZMJhMRPQK/+27Cl5ypglojIJdJzBgRERHVJlqtFkVFReVqa2NjA4nk0X4HFRQU6Lf1IIVCYdDGlBkzZmDMmDEGZdHR0Rg+fDgcHR3h4uLySPGVh252jbOzM+RyftypLhx386ht414d7xGPqirHPC4vFt/eWY08Ta6+zN3aAy81ngkvhVel7svS1LZz3VJw3M2juse9pG+clYRnAhHRI6h3XzI5M1eNnAI1XB24fhkRUW1V3TPC/vzzT/Tp06dcbaOiohAcHPxI+7O1tQUAKJXG37YpLCw0aGOKl5cXvLxMJzzkcnm1fRCVyWTVuj8qxnE3j9o07pZyDFUx5ucyzyD8xlqohEpf5m/XGDOavAp7uX2l7ceS1aZz3ZJw3M2jOse9ovvgmUBE9AjqexjO3LqdXMhkMhFRLfbKK6/gnXfeQdu2bREcHAyJRIKEhASo1eoqudgPDg5GeHh4udqaWpqiotzc3GBjY4PExESjOl2Zn5/fI++HiIjuOZR8ABG3N0Pg3jr8rZxD8Z+AFyGXMm1DRDUL35WIiB6B34PJ5BQlWgdU7CsiRERkGfbs2YNz587h/PnzOHfuHI4cOQIhBCZOnIipU6eicePGaN68OYKDg41uQvewfHx8MGnSpErZVnlIpVK0atUKp06dMqo7fvw4AgICKvxVSCIiMk0rtNgWvwX7k343KO/l2QdjGjz9yEsXERFVBSaTiYgegZ2NDK4OcmTkFq9plJB672vBAwcONFdYRERUBQYOHGjw3q5SqXD58mV9cvn8+fM4duwYtm/fDgAWkQS4desW8vPzDZbHGD16NN58802cOnUKHTp0AABcvXoVBw4cwOuvv26uUImoFquL180qrQob4sJxOuPeH+8kkGB4vdHo7zPAjJEREZWOyWQiokdUz8PmXjI57V4yeebMmeYKiYiIqoGVlRVCQ0MRGhqK559/Xl+elJSkTy6by/vvvw8AuHTpEgBgw4YNOHLkCADgnXfe0bebMGECIiMjIcS9r1bPmDED33zzDZ588km8/vrrsLKywtKlS+Ht7Y3XXnutGo+CiOqKunbdnKfOw+qYMMTkXteXWUmtMaHRZLRza2/GyIiIysZkMhHRI6rvqcDFuDwAwN2MImi0AjJpzZ+NRkREVcPb29toFnN1e/fddw0ef/fdd/qf708mm+Lo6IhDhw5hzpw5eP/996HVatG7d28sW7YMnp6eVRIvEVFdkaZMxZfRK5BUeFdfZi93wIsBMxDoGGTGyIiIyofJZCKiR1TvvnWTUzKLoFJrIbOWITo6GgAQFMSLQiIiql73zzQuzaFDh0yW169fH7/88kslRkREVLK6ct18K+8mwqJXIkedrS9zt/bAzCaz4aXwMmNkRETlx2QyEdEjuj+ZnFeoRXq2Gn4eMsydOxcAsGPHDnOFRkRERERU49WF6+aLWRfw7Y01KNLeWxavoV0jvBz0KhyseGNTIrIcTCYTET2i+5PJAHA7pRB+D5QREREREVHd9FfKYfx06wdoodWXhTi1wAsB02EtszZjZEREFcdkMhHRI/Jxs4ZEAui+UXwnVYnO5g2JiIiIiIhqgIPJ+xFxe7NBWTePHni64bOQSqRmioqI6OExmUxE9Iis5VJ4uVgjKaMIAJCQqiyjBxERERER1XbH044ZJJIlkGCI3zAM8n3CjFERET0aJpOJiCpBPQ8bfTI5MV1Z7hsfERGR5cvNzUVGRobJ9/6GDRuaISIiIjK385lnsTFuvf6xFFI822giunh0NWNURESPjslkIqJK0MDTBv9czwEAJGcUQaVmMpmIqDYrLCzE4sWL8e233yItLa3EdhqNphqjIiKimuB6zlV8e2ONwRrJYxo8zUQyEdUKTCYTEVWC+2/Cl5KlglLF5AERUW02Y8YMrF+/HsOHD0ePHj3g6upq7pCIiKgGuJV/E19Hfwm1UOvLhvgNR0+v3uYLioioEjGZTERUCep5KPQ/F6kFkrNUWLp0qRkjIiKiqrRlyxb85z//werVq80dChGRxast181JhXfx5fUvUKgt1Jf18eqHwVwjmYhqESaTiYgqwf0zkwHgTnIheoUGmSkaIiKqahKJBO3atTN3GEREtUJQkOVfN2cUpWPltWXIVefqyzq7dcWo+mPNGBURUeWTmjsAIqLawNPZClYyif5xfGqRGaMhIqKqNmzYMPzxxx/mDoOIiGqAHFUOVl5bhgxVhr6slXNrPOc/ERKJpJSeRESWh8lkIqJKIJVK4ONmrX8cn6rEqlWrsGrVKjNGRUREVeXdd9/FjRs3MG3aNJw+fRopKSlIT083+kdERGWz5OvmAk0BwqJXIEmZpC9r4tAU/wl4CVIJUy5EVPtwmQsiokpSz8MGt1OUAIC7GUW4/vvvAICZM2eaMywiIqoCTZo0AQCcOXMG3377bYntNBrekJWIqCy/W+h1s0qrwuroL3Er/6a+rKFdI0wPegVyKdMtRFQ78d2NiKiSNPC0wd9RxT+nZHKZCyKi2uy///0vv7pMRFSHaYQG4TfW4nruNX2Zt8IHM5vMho3MppSeRESWjclkIqJKUs9Tof85PUfFdYSIiGqxRYsWmTsEIiIyE63Q4qfbP+BC1jl9mZu1O15tMhf2cnszRkZEVPWYTCYiqiT1PO7NQNBouSg9EREREVFtI4TA3ozdOJHzt77MUe6EV5vMgYu1i/kCIyKqJkwmExFVkvoe/DobEVFtdevWLQBAw4YNDR6XRdeeiIhqh9+T9+DvnL/0j21ldpjZZBY8FV5mjIqIqPowmUxEVEmc7eWws5EiX6k1dyhERFTJ/P39IZFIUFBQAGtra/3jsvAGfEREtcfxtGPYdfc3/WNrqTVeCnwZ9e0amDEqIqLqxWQyEVElkUgk8HO3QXRCAQDAzrU+fFw5W5mIqDb47rvvIJFIYGVlZfCYiIgeXWBgoLlDKNON3Bj8eHOD/rFMIsfUgGkIcmxixqiIiKofk8lERJXIz+NeMtmr4yx8NI0Xl0REtcGkSZNKfUxERA9v2bJl5g6hVGnKNKyOCYNaqPVlY+uNR0vn1maMiojIPJhMJiKqRA08781ETslUQaXWQmHNW/EREdVWFy9exK5duxAXFwegeDmMxx9/HK1atTJvYEREVCkKNYX4OmYVctU5+rJuDj3Qxb2rGaMiIjIfJpOJiCpRfQ+F/ufMPDVyCzRwtONbLRFRbaNUKvHiiy9iw4YNEEJAKi3+w6FWq8WCBQvw7LPPYu3atbC2tjZzpERE9LC0Qot1sd8ioSBeX9bcMQQDXAebMSoiIvPidDkiokpU776ZyVaX/osXJ48xYzRERFRV3njjDXz//feYPn06oqKiUFhYCKVSiaioKLz00kvYuHEj5s+fb+4wiYgswtChQzF06FBzh2FkR/w2XMg6p3/sq/DDlEbTuGY+EdVpnC5HRFSJ/Nx5wz0iorpg48aNeP7557Fq1SqD8mbNmuHLL79EdnY2Nm7ciOXLl5snQCIieiR/px3FvqQ9+seOcie83OQVWEutkY98M0ZGRGReFjUzWalU4o033oCfnx9sbW3RuXNn7Nu3r9z9N2/ejK5du8Le3h4uLi547LHHcODAgSqMmIjqGnuFDC72hn+nE0KYKRoiIqoqKpUKXbp0KbH+scceg1qtLrGeiIhqrpjcaGy6uVH/WC6xwrSA6XC1djdjVERENYNFJZMnTZqEpUuX4tlnn8UXX3wBmUyGJ554AkeOHCmz76JFizB+/Hg0aNAAS5cuxfvvv4/WrVsjPj6+zL5ERBXh6264PqZKw2QyEVFtM2jQIOzdu7fE+j179mDgwIHVGBEREVWGNGUq1sR8BbW49wfBZxo9iwDHQDNGRURUc1jMMhcnTpzATz/9hE8//RSvv/46AGDChAlo2bIl5s+fj6NHj5bY9++//8Z7772Hzz//HHPmzKmukImojqrvqUDUrXtffVOpBawt5t2WiIjKY8mSJRg7dixGjhyJl19+GUFBQQCA69ev48svv8TNmzexefNmpKenG/Rzc3MzR7hERFQOhZpCfB29CrnqHH1Zf+9B6Oz+mBmjIiKqWSwmvREREQGZTIZp06bpyxQKBaZOnYq33noLt2/fRoMGDUz2Xb58OXx8fDBr1iwIIZCXlwcHB4fqCp2I6pj6HobrJheptLBXyMwUDRERVYXmzZsDAC5cuIDt27cb1OmWNwoJCTHqp9Foqj44IiKqMK3QIjx2LRIKE/RlLZxbYXi9kWaMioio5rGYZPKZM2fQtGlTODk5GZR36tQJAHD27NkSk8n79+/HY489hhUrVuD9999HWloafHx88Pbbb2PmzJll7js5ORkpKSkGZdHR0QAAtVpdLevhqdVqaDQarr1XzTju5mHp4+7rZmXwOC2rEI62NfuOz5Y+5paK424eHHfzqO5xr+r9/Pe//4VEUrPf24mIqPy2x2/Bxazz+sd+tvUwtfE0vtcTET3AYpLJiYmJ8PX1NSrXlSUkJBjVAUBGRgZSU1Px119/4cCBA1i4cCEaNmyI8PBwvPLKK7CyssKLL75Y6r7DwsKwePFik3U5OTnIzMys2ME8BI1Gg9zcXACATMYZjtWF424elj7uTjYqAIDadygAIOZ2OlwU9uYMqUyWPuaWiuNuHhx386jucc/JySm70SNYtGhRlW6fiKgumTFjhln3fyz1KP5I+l3/2EnuhBlBr8BGZlNKLyKiuslikskFBQWwsTF+I1coFPp6U3QfWtLS0vDTTz9h3LhxAIDRo0ejVatWeP/998tMJs+YMQNjxowxKIuOjsbw4cPh6OgIFxeXih5Ohelm1zg7O0Mut5inzeJx3M3D0sfd3kELCZIg3DoAAFJzrarlfeJRWPqYWyqOu3lw3M2jusfd0dGxyvdBRESVY/DgwWbbd3TudWy6tUH/2EpihWmBM+BqzTXuiYhMsZhPULa2tlAqlUblhYWF+vqS+gGAlZUVRo8erS+XSqUYN24cFi5ciFu3bqFhw4Yl7tvLywteXl4m6+RyebV9EJXJZNW6PyrGcTcPSx53uRzwcLFCSmbxDOW7mSpIJDLIZDX7K3KWPOaWjONuHhx386jOca/qfZw9exZRUVEYP368vmzv3r344IMPoFQq8cwzz2DWrFlVGgMRET2aVGUqvon5Chpxbz37Zxo9h8YOAWaMioioZpOaO4Dy8vX1RWJiolG5rszPz89kPzc3NygUCri7uxt9pVKXIM7IyKjkaImorvNzt4Ek/RQk6aeQnKlCkVpr7pCIiKgSzZ8/H5s3b9Y/jo2NxYgRIxAbGwsAmDt3LtasWWOu8IiILMqePXuwZ8+eat2nSqvC6pgvkavO1ZcN8B6MTu5dqzUOIiJLYzHJ5DZt2uDatWvIzs42KD9+/Li+3hSpVIo2bdogJSUFRUVFBnW6dZY9PT0rP2AiqtPqe9hAnrgD8sQdSM0qQpFamDskIiKqROfOnUP37t31j7///nvIZDKcOXMGx48fx+jRo/H111+bMUIiIssRFhaGsLCwat3nrsSdSCiI1z9u6dwaw+qNqNYYiIgskcUkk0ePHg2NRmMww0OpVCI8PBydO3dGgwYNAAC3bt3ClStXDPqOGzcOGo0G69ev15cVFhbihx9+QEhISImzmomIHlZ9T4X+59RsFZQqTSmtiYjI0mRlZcHd3V3/eNeuXRgwYAA8PDwAAAMGDEB0dLS5wiMiolLcyruJP+7u1T/2tvHBlMYvQCKp2cvSERHVBBaTTO7cuTPGjBmDBQsWYP78+VizZg369u2LuLg4fPLJJ/p2EyZMQPPmzQ36vvjii2jRogVefvllzJs3DytXrkTPnj1x8+ZNfPbZZ9V9KERUBzTwvHfD0CKVQFqW2ozREBFRZfP19UVUVBSA4mXXTp8+jYEDB+rrc3NzIZVW/6V2YmIi3nzzTfTp0weOjo6QSCQ4dOhQuftv2bIF48aNQ0BAAOzs7NCsWTO89tpryMzMrLKYiYiqk1qrxoab66BF8TJ0UkgxofEk2MhsyuhJRESABd2ADyj++uC7776LDRs2ICMjA61bt8bOnTvRs2fPUvvZ2triwIEDmD9/Pr777jvk5eWhTZs2+L//+z8MGjSomqInorqknofhxeitlAI0b2RvpmiIiKiyDRs2DCtXrkRhYSGOHz8OGxsbjBhx7+vR586dQ0BA9d/A6erVq/j444/RpEkTtGrVCseOHatQ/2nTpsHPzw/PPfccGjZsiAsXLmDVqlXYtWsX/vnnnxJvek1EZCn23N1lsLxFT6/e8LfnDfeIiMrLopLJCoUCn376KT799NMS25Q088LLywvr1q2rmsCIiB7g6WJt8Dg+VQmtVkAq5VfniIhqg/fffx8pKSnYsGEDXFxcsG7dOnh7ewMAsrOzERERgZdffrna42rfvj3S0tLg5uaGiIgIjBkzpkL9IyIi0Lt3b6NtTpw4ET/88AP+85//VGK0RETV63b+bexN3KV/7GnjheF+o8wYERGR5bGoZDIRkaWQPZA0TkpXQaURsPn/9u48Pqrq/v/4e2YymewJ2RMB2UFWF8C1bCqgVkQLaF2Q1lZbROtW+20VXIptrT9FLeJSFRW11eKG1uJSBYsgoAi4sIWdEMi+J5NZ7u+PkAkxgawzNzN5PR+PPJhz7vaZD9fx5MOZcykmA0BIiImJ0SuvvHLMbQcOHFBUVFSAo5JiY2PbdfwPC8mSdOmll+raa6/1LesBAMHIY7j18p765S0ssujqE6+V3WY3OTIACC4UkwEgAPKKa1Tj9sphD5ql6gEAbWS1WhUfH292GB3m0KFDkuR7uCAABKMPD32gA1X7fe1zkseoX2x/EyMCgOBEMRkA/OTH1y/SW5/nS5LySl1yuQyJpSYBAEHmwQcflM1m07Rp05rdNzc3V3l5eQ36srKyJElut1tut/8fSOt2u+XxeAJyLdQj7+YIlby/+eabkuS393Gw6qD+k/Oer50Unqwp6VPbdL1QyXmwIe/mIO/mCHTeW3sdiskA4Cc9UiJ8r4vKXKqu8Ujia3QAgJbxer2qqalp0b4Oh0MWS8cvpfTqq6/queee05133qn+/Zufwbdo0SLdd999TW4rKytTcXFxB0fYmMfjUXl5uSTJZrP5/XqoRd7NQd6b5zE8WnJosTyGR1Lt8hYXJ0xVZVmVKlXV+vORc1OQd3OQd3MEOu9lZWWt2p9iMgD4SY/U+mKyxysdKqpRZnLEcY4AAKDeZ599pvHjx7do3y1btmjQoEEdev3//e9/uu666zRp0iQ98MADLTpm9uzZjR76l5WVpalTpyo2NlYJCQkdGmNT6mbXxMfHKyyMX3cChbybg7w37+PcD3WwJtvXPiPxLJ2ScWqbz0fOzUHezUHezRHovLf2mRvcCQDgJ08vuFthh6rk7vtrSdK+w9U6tX+cyVEBAILFoEGDtHjx4hbtm5GR0aHX3rRpk6ZMmaKhQ4dq6dKlLf5FJjU1VampqU1uCwsLC9gvojabLaDXQy3ybo5QyPutt94qSVqwYEGHnvdQVY7+c6h+eYvE8CRN63m5wmzty1Uo5DwYkXdzkHdzBDLvrb0GdwIA+MnePbt09BeOcwpr5HJ7ZQ/jIXwAEMwqKyv1ox/9SL/85S/1q1/9ym/XSU9P16xZs/x2/mPZuXOnJk+erNTUVL3//vuKiYkJeAwAupadO3d2+Dm9hlcv731RbqN+LdCf9rxaETa+KQgA7UFFAwACJLe4RjVuw+wwAADtFBUVpd27d/tljeJA2rdvn7Zu3dqg79ChQ5o4caKsVqs++OADpaSkmBQdALTPJ7kfa3fFLl/7jMQzNTh+iIkRAUBoYGYyAARIXolLLrdXEg8uAIBgN3nyZH3wwQe64YYbzA6lkfnz50uSvvvuO0nSkiVLtGrVKknS3Xff7dtv5syZWrlypQyj/h86J0+erF27dunOO+/UqlWrfMdJUlpams4///xAvAUAaJfD1Yf1XvY7vnaCvZum9bzcxIgAIHRQTAaAAMkvccnpYmYyAISCuXPnavr06brmmmt0ww03qHfv3oqMjGy0X2JioimxHe3555/3vT66mNyUTZs2SZL++te/Nto2duxYiskAOj2v4dUre1+Uy3D5+q7oeaUibVEmRgUAoYNiMgAESEmFW5XVbknhZocCAGinIUNqvyr9/fff69VXXz3mfh6PJ1Ah+Rw90/h4VqxY0eZjAaCzWpn3qXaWZ/naIxNHa1jCCBMjAoDQQjEZAAJof55TvTOYFQEAwW7evHlBv2YyAISaPGeulmW/5WvH2+M1vfsVJkYEAKGnTcXk+++/v0MuPm/evA45DwB0RhMnTpTbY+iDQ/V9OQVOeTyGbDYKEAAQzO69916zQwCAkDFx4sR2n8NrePXKnpdU463x9U3v8VPF2GPafW4AQL02FZMXL17c7gtbLBaKyQBC2pw5cyRJa/74jUora7/mfKioRjVuryJtPIQPAEKB0+nUhg0blJubq7PPPlvJyclmhwQAQadu3Nwen+f/TzvKt/vap3Q7TScnnNLu8wIAGmpTMXn37t0dHQcAhKyMRIdKKyslSbnFNapxG4p0mBwUAKDdHn/8cd17770qKSmRJH300UeaMGGC8vPzNWjQIP31r3/Vz3/+c5OjBIDQV+Ot0XsH3/G1Y8PiNKPHT1mOCAD8wGp2AAAQqrKyspSVlaWMpPoH7uWXuFTj9poYFQCgIyxevFi33HKLJk+erOeee67Bg+uSk5M1YcIE/fOf/zQxQgAIHnXj5rZaV/CFyt3lvvalJ/xEcfa4jggNAPADbX4A36mnnqoRI0b4foYPH66kpKSOjA0Agtptt90mSZpx8zO+voJSl1wu41iHAACCxMMPP6xLLrlEr776qgoKChptP+200/T444+bEBkABJ+6cfOyZctafazX8OqTwx/52qmONI1KPL3DYgMANNTmYvLGjRu1adMmSZJhGLJYLMrIyGhQXB4xYoQGDhwoq5UJ0AC6rp6p9WtaVFR7VVxeo8xk1rkAgGCWlZWlm2+++ZjbExMTmywyAwA61vel3+qw87CvPTZ1PDUIAPCjNheTe/XqpYMHD+qiiy7SpEmTtHfvXm3atEmbN2/Wf/7zH0m1D9lzOBwaMmSIRowYoWeffbbDAgeAYNEzNaJBe1+eUyedGMMabgAQxBISEpSfn3/M7d9//73S09MDGBEAdE3/PWpWckxYjM5KOsfEaAAg9LX5n+u2bdumhx56SJ9//rnuuusuJScn680339S+fftUWFioTz/9VI8++qiuuuoqWSwW1owD0GVlJjl0dNn4cGHtQ/gAAMHrwgsv1DPPPKPi4uJG27777jv9/e9/15QpUwIfGAB0Ifsr92l72TZf+8yksxVuCz/OEQCA9mpzMdlut+umm27Szp07NWfOHN17773q37+/XnzxRcXHx2vs2LG66aab9Pe//13r1q1TWVlZR8YNAEEj3G5VUpzd184t5iF8ABDs5s+fL4/Ho6FDh+ruu++WxWLRiy++qKuvvlojR45Uamqq5s2bZ3aYABDSjp6VbLfYNT71PBOjAYCuod0LCUVHR+uee+7Rzp07NXXqVN1www0aNmxYo4Xz+To3gK4sPbF+hkReSY1czEwGgKCWmZmpr776SpMnT9Zrr70mwzC0ZMkSvfvuu/rpT3+qL774QsnJyWaHCQAhq6imSF8Vrve1T+52quLD402MCAC6hg5blT45OVmPPfaYtm3bplNPPVU/+clPdPbZZ/se0gcAXdnRD9zLL3FRTAaAEJCamqpnn31WhYWFOnz4sHJyclRUVKTnn39eqampZocHACFtZe6n8qr+237np00yMRoA6Dra/AC+H/J6vcrKytKWLVt00kknacSIEVqzZo3eeecdjRgxoqMuAwBB45FHHvG97n5UMbmwzKUal8eMkAAAfpKSkmJ2CAAQtI4eN7dEtadaq/I/87UHxAzUCVHdOzosAEAT2lxMfv311/X9999ry5Yt+v7777Vjxw7V1NTIYrGod+/eGjp0qCZPnsyDRwB0Wf369fO97pES4XvtdBnKK3WpR2qkGWEBADrQt99+q/fff1979uyRJPXq1UsXXHCBhg0bZm5gABBEjh43t8QXBatV5an0tc9Nn9jRIQEAjqHNxeQrrrhCkZGROuecczRx4kTddtttGjp0qIYMGaKoqKiOjBEAgl7PNEeDdnaeUyP6GLJZWU8eAIKR0+nUDTfcoCVLlsgwDFmttavHeb1e/f73v9dVV12lZ599VuHh4c2cCQDQGl7Dq08Pf+xrZ0RkanDsEBMjAoCupV3LXFRVVenLL7+U0+mUy+WSx+ORxWLRkCFDFBnJjDsAXdvChQslSXPmzFFaN4dsVslzZFm3w0W1D+GzhVNMBoBg9Lvf/U4vvfSSZs+erZtuukl9+/aVxWJRVlaWHn/8cT355JNKTEzUo48+anaoANDpHT1ubs6m4q+VX5Pva49LneD7Bz0AgP+1uZi8fPlybdq0SZs3b9amTZv09NNPy+VyyWKxyGq1qk+fPho+fHiDn969e3dk7ADQqX344YeSagfFNqtFqQnhyimskSTlFtXI5fEqouOegwoACKCXX35Z11xzja8AUmfgwIF64oknVFpaqpdffpliMgC0wNHj5uZ8ctSs5Dh7vEYnneG3uAAAjbW5mDxx4kRNnFi/LpHL5dL333/vKy5v3rxZ//vf//TGG29IkiwWizweHjgFoOvKSHLUF5NLauRyGRJf4gCAoORyuXTGGccuYJx11ll69913AxgRAIS+3eW7tKtip699VtI5CreynBAABFK7lrk4mt1u14gRIzRixAhdc801vv7Dhw9r48aN+uabbzrqUgAQlDKTwrVhR+3rglK3XHVrXgAAgs6kSZP0wQcf6Ne//nWT25cvX95g4gUAoP3+m/uR73W4NVxjU8ebGA0AdE0dVkw+lrS0NE2aNEmTJk3y96UAoFPrnlz/EL6iMpecNRSTASBY/fGPf9SMGTN02WWX6cYbb1S/fv0kSTt27NATTzyhvXv36rXXXlNhYWGD4xITE80IFwCCXr4zXxuLNvjap3UbpTh7nIkRAUDX1KZi8v33398hF583b16HnAcAgkGP1Po1LTxeKbvAqZ5prHMBAMHopJNOkiR98803eueddxpsMwxDkjR48OBGx7HsGwC0zYrc/8pQ7eerVVadm3aeyREBQNfUpmLy4sWL231hi8VCMRlAl3JimqNB+2C+Ux6vIZvVYlJEAIC2mjdvniwWPr8BIBAq3ZVanb/K1x4Ud5IyIk8wMSIA6LraVEzevXt3R8cBACGnb9++DdqJsXZFhFtVfWR5i8NFNXK5DdnCKUYAQLC59957zQ4BAELGD8fNP/R5/v/k9Dp97Qmp5/s7JADAMfh9zWQA6KoWLFjQoG2xWJTWLVx7D1dLknKLXXK5vYoIt5oRHgAAANAp/HDcfDSP4daK3E987e6RPTQwblAgwgIANIEKBgAEUGZS/VIXecW1M5MBAAAANG1D0VcqdhX52uNSJ8hqoZQBAGbhExgAAigzKdz3Or/UJZfHa2I0AAAAQOdlGIb+e/gjX7ubvZtGJo4yMSIAAMVkAPCTKVOmaMqUKQ36uqfUz0wurfSovMoT6LAAAACATqWpcbMkZZVv1/7Kfb722SljZLeGN9oPABA4FJMBIIB6pkY0aB/Icx5jTwAAAKBrO3pWcoQ1QuckjzExGgCARDEZAALqxB8Uk7MLnPJ4WTcZAILN2rVrzQ4BAELa4erD+qZks689MnG0Yu2xJkYEAJAoJgNAQEVHhik+2uZrHy6skcvNuskAEGzOPPNMDRgwQH/84x+1a9cus8MBgJDzyeGPfa+tsml86rkmRgMAqEMxGQACLD2xft3kvOIaudzMTAaAYPPyyy+rf//++uMf/6j+/fvr7LPP1lNPPaXCwkKzQwOAoFfuLtPagtW+9pD4oUqLSDcxIgBAHYrJABBgmUlHFZNLXaqhmAwAQefKK6/Uv//9bx08eFCPPfaYDMPQ7NmzlZmZqalTp2rp0qWqqakxO0wACEqr8j6Ty3D52hPSzpPFYjExIgBAHYrJABBg3ZPri8kFJS6WuQCAIJacnKw5c+Zo9erV2rFjh+666y5t3bpVl19+udLT03X99ddr1apVZocJAEHDa3j1eX7952av6N7qF9PfxIgAAEcLMzsAAAhVs2fPbrK/R0p9MbmqxquiMneDpS8AAMEpMjJSUVFRioiIkGEYslgseuedd/Tcc8/p1FNP1YsvvqjBgwebHSYAdDpHj5u3lW1VYU2Br3128o9ktTAPDgA6Cz6RAcBPJk+erMmTJzfq75kW2aC9L686UCEBADpYWVmZFi9erPPOO08nnnii/vCHP6hXr15aunSpDh06pIMHD+q1115Tbm6ufvazn5kdLgB0SkePm1cfNSs5yhatU7uNNCssAEATKCYDQICdkOyQ9ahP35wCpzwe1k0GgGDyzjvvaMaMGUpLS9N1112nsrIyPfroozp48KDefvttXXbZZbLb7bLZbJo2bZruvvtuff311wGJLScnR//3f/+n8ePHKzY2VhaLRStWrGjz+c4//3xZLBbNmTOn44IEgCaUu8u1uXijr31yt1MUYYswLyAAQCMscwEAfrJ8+XJJajQ7OcxmUUp8uA4X1T6Y6XBRjVwer2w2W8BjBAC0zaWXXqoePXro1ltv1cyZMzVw4MDj7j9ixAhdddVVAYlt27ZtevDBB9W/f38NGzZMa9asafO53nzzzXYdDwAtUTdudpxil9tw+/rPTv6RWSEBAI6BYjIA+MmiRYskNS4mS1J6Yn0xObe4RjUuQxHhAQ0PANAOn3zyicaNG9fi/UePHq3Ro0f7L6CjnHbaaSooKFBiYqKWLl2q6dOnt+k81dXVuv322/W73/1O8+bN6+AoAaBe3bj59L+c5uvrHtldPaNONCskAMAxsMwFAJggM6n+gXv5JS65WOYCAIJKawrJgRYbG6vExMR2n+evf/2rvF6v7rjjjg6ICgCad7Aq2/d6dNKZPHgPADohZiYDgAl6pNQXkwvL3Kp2eSTZzQsIANAqVqtVFovluPtERESoe/fuGj9+vH7729+qb9++AYqu/fbt26e//OUvev755xUZGdn8AUfk5uYqLy+vQV9WVpYkye12y+12N3VYh3K73fJ4PAG5FuqRd3OEat7tlnCdFj+yU76vUM15Z0fezUHezRHovLf2OhSTAcAEPVPrHyTi9hjKLXLphCQeLgIAwWLevHl655139N133+mCCy5Qv379JEk7duzQ8uXLNWzYME2YMEFZWVlavHix/vGPf+izzz7TiBEjTI68ZW6//XadcsopuuKKK1p13KJFi3Tfffc1ua2srEzFxcUdEN3xeTwelZeXSxLPIwgg8m6OUM37wIhBcpd7VKxis0NpJFRz3tmRd3OQd3MEOu9lZWWt2p9iMgCY4MS0hoXj/XnVOqVfrEnRAABaKzMzU/n5+dq6dav69OnTYFtWVpbGjRunwYMH66GHHtKOHTt05pln6g9/+IP+/e9/t+o6Xq9XNTU1LdrX4XA0O1u6JT799FO98cYbWrt2bauPnT17dqM1mrOysjR16lTFxsYqISGh3fE1p252TXx8vMLC+HUnUMi7OUI172MyxiohNsHsMJoUqjnv7Mi7Oci7OQKd99jY1tUiuBMAwARJcXY57BY5XbVrJecUOOX2GAqztb8IAADwv4ceekg33nhjo0KyJPXr10833nij/vznP+tnP/uZ+vfvr1/96ld64oknWn2dzz77TOPHj2/Rvlu2bNGgQYNafY2jud1u3Xzzzbrmmms0atSoVh+fmpqq1NTUJreFhYUF7BdRm80W0OuhFnk3R6jlPTk8RYPiB8tm7byzIEMt58GCvJuDvJsjkHlv7TW4EwDABBaLRendHNqbWy1JOlzkksvtVRhfHQKAoHDgwIHjDrzDwsK0f/9+X7tXr15yOp2tvs6gQYO0ePHiFu2bkZHR6vP/0EsvvaRt27bp6aef1p49expsKysr0549e5SamqqoqKh2XwsAJOlw9eEG7VGJozt1IRkAujqKyQDgJ8uWLTvu9oykcF8xOa+4Ri63oUjHcQ8BAHQSQ4YM0ZNPPqlrrrlGaWlpDbYdOnRITz75pIYMGeLr27Vrl9LT01t9nfT0dM2aNau94bbYvn375HK5dPbZZzfa9tJLL+mll17SW2+9palTpwYsJgChbU3+5+pxT+3no81i01nJPzI5IgDA8VBMBgCTnJBcXznOL3Wpxu01MRoAQGv8v//3/3wP3ps6darvAXxZWVl6++235XK59Pzzz0uSqqur9cILL+iCCy4wM+Qm7du3T5WVlb7lMa644gqdfPLJjfa79NJLdeGFF+qXv/ylTj/99ABHCSBUeQyP1has9rX7xwxUoiPRxIgAAM2hmAwAJumeUl9MLi53q9LpMTEaAEBrjBs3TqtXr9Y999yjN998U1VVVZKkiIgInXfeebr33nt16qmn+voOHjwY0Pjmz58vSfruu+8kSUuWLNGqVaskSXfffbdvv5kzZ2rlypUyjNo1/AcNGnTMdZd79+7NjGQAHeq7km9U6i71tc9MbvytCABA5xJUxWSn06l58+ZpyZIlKioq0vDhwzV//nydf/75rTrP+eefr48//lg33nijFi5c6KdoAXR1t956qyRpwYIFTW7vlRbZoJ2dX6OeqZFN7gsA6HxOOeUULVu2TF6vV7m5uZJqH0BntVpNjkyaO3dug3bdLGmpYTEZAMy0Ov9zSdKhZ/Jls9g0YtHJ5gYEAGiW+SPdVpg1a5YeeeQRXXXVVXrsscdks9l04YUX+mZZtMSbb76pNWvW+DFKAKi1c+dO7dy585jbe6RGNGjvP7J+MgCgc6usrNRpp52mp556SpJktVqVnp6u9PT0TlFIliTDMI75c7QVK1Y06jvW+ZiEAaAjlbiK9V3JN5IkV45b1QedslvtJkcFAGhO5xjttsC6dev0z3/+U3/+85/10EMP6frrr9cnn3yiE088UXfeeWeLzlFdXa3bb79dv/vd7/wcLQA0LzrCprio+idVHyqqkdvT/C/0AABzRUVFaffu3bJYLGaHAgBBa23BGnnFM0MAINgETTF56dKlstlsuv766319ERERuu6667RmzRrt37+/2XP89a9/ldfr1R133OHPUAGgxTIS69dNzi2u4SF8ABAkJk+erA8++MDsMAAgKBmGoTVHlrgAAASXoCkmf/311xowYIDi4uIa9I8ePVqStHHjxuMev2/fPv3lL3/Rgw8+qMhI1iQF0DlkJof7XucV18jlZmYyAASDuXPnavv27brmmmu0atUqZWdnq7CwsNEPAKCxrPIdynXmmh0GAKANguYBfDk5OcrIyGjUX9fX3BOyb7/9dp1yyim64oorWn3t3Nxc5eXlNejLysqSJLndbrnd7lafs7Xcbrc8Hk9AroV65N0coZb3472PzMT6YnJ+iUvVzhpFO465u9+EWs6DBXk3B3k3R6Dz7u/rDBkyRJL0/fff69VXXz3mfh6Px69xAEAwOnpWcoSNyV4AEEyCpphcVVUlh6NxhSUiIsK3/Vg+/fRTvfHGG1q7dm2brr1o0SLdd999TW4rKytTcXFxm87bGh6PR+Xl5ZIkm83WzN7oKOTdHKGW9+N9RiRGuXyvK51eZR8qlM0bccz9/SXUch4syLs5yLs5Ap33srIyv55/3rx5rJkMAG1Q5anUhqIvfe0R8SO0Q7tNjAgA0BpBU0yOjIyU0+ls1F9dXe3b3hS3262bb75Z11xzjUaNGtWma8+ePVvTp09v0JeVlaWpU6cqNjZWCQkJbTpva9TNromPj1dYWND8tQU98m6OUMn7+eefL0nH/Yw4qXeEpCJfu7g6QsMD8JnyQ6GS82BD3s1B3s0R6LzHxsb69fz33nuvX88PAKHqy8L1chn1EyrOTh6j0omVJkYEAGiNoPkNKiMjQ9nZ2Y36c3JyJEmZmZlNHvfSSy9p27Ztevrpp7Vnz54G28rKyrRnzx6lpqYqKirqmNdOTU1Vampqk9vCwsIC9ouozWYL6PVQi7ybIxTyftNNNzW7T/fUKFksknFkqeTsApdp7zkUch6MyLs5yLs5Apn3QP3dOp1ObdiwQbm5uTr77LOVnJwckOsCQLA6eomLjIgM9Ynpqzlz5pgYEQCgNYLmAXwnn3yytm/frtLS0gb9dUtXnHzyyU0et2/fPrlcLp199tnq3bu370eqLTT37t1bH374oV9jB4BjsYdZlRJv97UPFdXI5faaGBEAoKUef/xxZWRk6JxzztFll12mzZs3S5Ly8/OVnJys559/3uQIAaBzya48oL2Ve3zt0UlnsmQQAASZoCkmT5s2TR6PR88884yvz+l0avHixTr99NPVo0cPSbXF461bt/r2ueKKK/TWW281+pGkCy+8UG+99ZZOP/30wL4ZAF1CVlaW72Gdx5OeWL8efF5xjVwew59hAQA6wOLFi3XLLbdo8uTJeu6552QY9Z/dycnJmjBhgv75z3+aGCEAdD6rC1b5XodZwnRm0lmSWj5uBgCYL2i+23n66adr+vTp+v3vf6/c3Fz169dPL774ovbs2aPnnnvOt9/MmTO1cuVK34B+0KBBGjRoUJPn7N27t6ZOnRqI8AF0QbfddpskadmyZcfdr3uyQ5t31T6UKq/EJZfbkBo/bxQA0Ik8/PDDuuSSS/Tqq6+qoKCg0fbTTjtNjz/+uAmRAUDn5PK6tL5gra89OG6IYu1xklo+bgYAmC9oZiZLtctS3HLLLVqyZIluvvlmuVwuvffeexozZozZoQFAm/VIqa8cF5S4VO3ymBgNAKAlsrKydMEFFxxze2JiYpNFZgDoqjYXb1SFp8LXPiv5RyZGAwBoq6CZmSxJEREReuihh/TQQw8dc58VK1a06FxHfxURAMzUIy3C99rlMZRX7FJaAlOTAaAzS0hIUH5+/jG3f//990pPTw9gRADQua3Or1/iolt4ogbHDTExGgBAWwXVzGQACEU9UyIatA/kVZsUCQCgpS688EI988wzKi4ubrTtu+++09///ndNmTIl8IEBQCdU4CzQtrL6ZxuN7DZaNqvNxIgAAG1FMRkATJYUZ1d4WP1TrLPznSZGAwBoifnz58vj8Wjo0KG6++67ZbFY9OKLL+rqq6/WyJEjlZqaqnnz5pkdJgB0Cl8UfC5Dtd8Otsiic1JY4gIAghXFZAAwmdVqUVpiuK99qLBGLrfXxIgAAM3JzMzUV199pcmTJ+u1116TYRhasmSJ3n33Xf30pz/VF198oeTkZLPDBADTeQ2v1hSs9rX7xfRXsiPFxIgAAO0RVGsmA0Coykx0aH9u7Yzk3OIa1bgN2fmEBoBOLTU1Vc8++6yeffZZ5eXlyev1KiUlRVYr8zUAoM6W0u9UVFPoa5+ZfI6J0QAA2otSBQD4ySOPPNLifbunOLT2yDJy+SUuudw8JBQAgklKCrPsAOCHvIZX7x1c5mtH26J1arfTGu3XmnEzAMBcFJMBwE/69evX4n17pNY/hK+o3K2qGo8S+IgGgKBQXl6uoqIiGUbjfwjs2bOnCREBQOfwddFX2le519c+K/lHslvtjfZrzbgZAGAuKhUA0An0THX4XhuGdDDPqYxEx3GOAACYqbq6Wvfdd5+ee+45FRQUHHM/j8cTwKgAoPNweV16J/stXzs2LFbnpU80MSIAQEegmAwAfrJw4UJJ0pw5c5rdt3tyRIP2gQKnGn8BEADQWcyePVsvvviipk6dqh/96Efq1q2b2SEBQKfyv7yVKqjJ97XPT5usmLCYJvdtzbgZAGAuiskA4CcffvihpJYNimOjwhQTaVN5Ve0Mtuz8ahmGIYvF4tcYAQBt8+abb+oXv/iFnn76abNDAYBOp9JdqeU5//a1UxypGpM69pj7t2bcDAAwF4+aBoBOIjOpflmLQ4UuuTw8hA8AOiuLxaJTTz3V7DAAoFP68NByVXgqfO0fZ06R3RpuYkQAgI5CMRkAOonMpPoBdl5JjVxuiskA0Fldcskl+vjjj80OAwA6ncKaAn2aW//52Cu6t07tNtLEiAAAHYliMgB0Et1T6mcm55e45HJ7TYwGAHA8c+fO1a5du3T99dfrq6++Ul5engoLCxv9AEBX8172MrkNt699yQmXyWqh9AAAoYI1kwGgk+iZGul7XV7lUWmFWwkxdhMjAgAcS//+/SVJX3/9tZ577rlj7ufxeAIVEgCYbn/lfq0r/MLXHho3TANiB5oYEQCgo1FMBoBOomeqo0H7QJ5TPdMij7E3AMBM8+bN4yGpAPAD72S/IUO1S7XZLDZN7T7N5IgAAB2NYjIA+Enfvn1btX9GokMWSXUrJR/Ir+7wmAAAHePee+81OwQA6FS2lH6nLaXf+9qnJ52pjMiMFh3b2nEzAMA8FJMBwE8WLFjQqv3D7VYlxduVX+KSJGXnO2UYBjPfAKCTWLdunfr166fExMRm9929e7f+97//aebMmQGIDADM5TW8euvAG752hDVCP864pMXHt3bcDAAwD6vgA0AnkplUv9RFbrFLLo9xnL0BAIF05plnavny5b52YWGhoqKitHLlykb7rl69Wj/72c8CGR4AmGZ94VplVx3wtcelnqv48HgTIwIA+AvFZADoRE5IPrqYXCOXm2IyAHQWhmE0aldXV/OQPQBdWo23Ru9mv+1rx9vjdX76JPMCAgD4FcVkAPCTKVOmaMqUKa06pkdKfTE5v8SlGhcFCgAAAHReK3M/UZGryNe+IOMiRdgiWnWOtoybAQDmoJgMAJ1Iz9T6gXeN2/CtnwwAAAB0NuXucn1w6D++dnpEhs5MOsfEiAAA/kYxGQA6ke4pDWdx7M9zmhQJAAAAcHwf5LyvKk+Vr33JCZcpzBpmYkQAAH/jUx4AOpGUeLvCbBa5jzx4Lzu/2uSIAABH27NnjzZs2CBJKikpkSTt2LFDCQkJDfbbvXt3oEMDgIDKd+ZrZd6nvnbf6H4anjDCxIgAAIFAMRkAOhGr1aL0xHAdODIjObugRoZhyGKxmBwZAECS5s6dq7lz5zbomz17dqP9+OwGEOqWZb8lj1H7fA+LLLqsx3STIwIABALFZADoZDKTHL5icm5RjVxuQ+F2ChIAYLbFixebHUKL5OTk6LHHHtPatWv15Zdfqry8XJ9++qnGjRvXqvO89tprevTRR7V582bZ7XYNHjxY8+fP14QJE/wTOICgsbdij74qWu9rj0g4Rb2ie5sYEQAgUCgmA0An0yPFoXVba1/nlbjk8hgKt5sbEwBAuvbaa80OoUW2bdumBx98UP3799ewYcO0Zs2aVp/j3nvv1f33369p06Zp1qxZcrlc+vbbb5Wdne2HiAEEE8Mw9NaBpb52mMWuS7v/xMSIAACBRDEZAPykqa89t0SP1PqH8BWWulRZ7VF0hK2jwgIAhLjTTjtNBQUFSkxM1NKlSzV9euu+ev7FF1/o/vvv18MPP6xbb73VT1ECCFbflX6jHeXbfe2zks9WsiOlXeds67gZABB4FJMBwE8mT57cpuN6pNQXk72GlFPoVEpCeEeFBQAIcbGxse06/tFHH1V6erp+85vfyDAMVVRUKCYmpoOiAxDMPIZHbx9409eOskXpx5mXtPu8bR03AwACj2IyAHQyJyQ7GrSz850a3qd9hQEAAFrqv//9r8466yw9/vjjmj9/vgoKCpSenq677rpLc+bMOe6xubm5ysvLa9CXlZUlSXK73XK73X6Lu47b7ZbH4wnItVCPvJsj0Hl/L+cd5VQf9LUnpJwnhxxd6u+de90c5N0c5N0cgc57a69DMRkA/GT58uWSWj/TIj46TNERNlVU1z4dO/vIw/gAAPC3oqIi5efn6/PPP9cnn3yie+65Rz179tTixYt10003yW6364Ybbjjm8YsWLdJ9993X5LaysjIVFxf7KfJ6Ho9H5eXlkiSbjWWiAoW8myOQec+q2q6Pcj/wtbvZuukU+8gO+e96xYoVktTqB4WagXvdHOTdHOTdHIHOe1lZWav2p5gMAH6yaNEiSW372l5mUrh2ZFdJkrILnfJ6DVmtlg6NDwDQ+Xm9XtXU1LRoX4fDIYulff+vqPvFpaCgQP/85z91+eWXS5KmTZumYcOGaf78+cctJs+ePbvRGs1ZWVmaOnWqYmNjlZCQ0K74WqJudk18fLzCwvh1J1DIuzkClfcSV7Heyq5/6J7NEqaZvX+u5OjkDjn/Sy+9JEmaOnVqh5zPn7jXzUHezUHezRHovLd2iTTuBADohE5IdviKyblFNXJ7DIVTTAaALuezzz7T+PHjW7Tvli1bNGjQoHZdLzIyUpJkt9s1bdo0X7/VatXll1+ue+65R/v27VPPnj2bPD41NVWpqalNbgsLCwvYL6I2my2g10Mt8m4Of+fdY3i0ZOcLKneX+/p+nHmxBsQP7PBrBcu9w71uDvJuDvJujkDmvbXX4E4AgE6o+1HrJueXuFTj9ircbjUxIgCAGQYNGqTFixe3aN+MjIx2Xy8xMVERERFKSEho9LXKuiJxUVHRMYvJAELP+wff047y7b72SXFDdH4aD8wDgK6KYjIAdEI90yJ9r0srPSqrdCsmko9sAOhq0tPTNWvWrIBdz2q16uSTT9b69etVU1Oj8PBw37aDB2sfupWSkhKweACYa0vp9/rg0Pu+djd7N/2s9y/avaQOACB4Mc0NADqho2cmS9J+HsIHAPCDffv2aevWrQ36Lr/8cnk8Hr344ou+vurqar3yyisaPHiwMjMzAx0mABOUuIr1wu7nZMiQJNksNv2s9y8VHRZtcmQAADMxzQ0AOqGMpIbF5Ox8iskAgJabP3++JOm7776TJC1ZskSrVq2SJN19992+/WbOnKmVK1fKMAxf3w033KBnn31WN954o7Zv366ePXtqyZIl2rt3r959990AvgsAZvEaXr2w+zmVu8t8fRdmXKy+sf1MjAoA0BlQTAaATigi3KqkOLsKSl2SpIMUkwEArTB37twG7eeff973+uhiclMiIyP1ySef6M4779Tzzz+viooKnXzyyfr3v/+tSZMm+SVeAJ3Lf3Le0/aybb72wNiTNCn9AhMjAgB0FhSTAcBPli1b1q7jM5PC64vJhU55vYasVtanAwA07+iZxsezYsWKJvtTU1P1wgsvdFxAAILG1tIt+k/Ov33tBHuCft7nl35dJ7m942YAQOCwZjIAdFLdUyJ8rw8XuVTh9JgYDQAAAEJdiaukyXWSY8JiTI4MANBZUEwGgE6qR0r9usn5JTUqLXebGA0AAABCmdfw6sXdz6nMXerruyD9IvWL7W9iVACAzoZiMgD4ya233qpbb721zcf3OGpmstNl6EBBtTyeln1tGQAAAGiN5Tnva1vZVl97QMxATc64KCDXbu+4GQAQOKyZDAB+snPnznYdf8JRM5MlaV+uUwO7u5UQY2/XeQEAAICjbS/bqvdz3vW14+0Juq7PDX5dJ/lo7R03AwACh5nJANBJpSaEy3bUp/T+3GqVVLDUBQAAADpOqatUi3c961sn2Sqrftb7F4qxs04yAKAxiskA0EnZrBb1yYj0tb/ZXaHicrecLq+JUQEAACBU1K2TXHrUOsmTMy5U/9gBJkYFAOjMKCYDQCd23qmJvteHCmu040ClSiuZnQwAAID2++DQf7S1bIuv3T9mgC7MuNjEiAAAnR3FZADoxCac0k0R4fUf1eu2laqkwi3D4EF8AAAAaLt1BWv13sF3fO24sHj9IoDrJAMAghPFZADoxGIiwzR6YJyvvWVfpQ4X1ajSyVIXAAAAaJtvS77Rkj2LfW2rrJrV+zrF2GNNjAoAEAzCzA4AAELVxIkTO+Q8E07pps++KZYkuT2Gvvi+RH0zIhUdYeuQ8wMAAKDr2FmepWd3PiWv6icnTO9xhQbGDTItpo4aNwMA/I9iMgD4yZw5czrkPL3SI9Qz1aF9uU5J0oYdZbpgdJJSEsJls/I1RAAAALRMdtUBPZm1UC7D5eu7KONijUkdZ15Q6rhxMwDA/1jmAgA6uSiHTWcOjve1C8vc+mZXuSqqPCZGBQAAgGCS78zXEzseU5Wn0tc3JmW8LszkgXsAgJajmAwAfpKVlaWsrKx2nycm0qazhsQrOqL+I3v19yUqrXS3+9wAAAAIfaWuUv1txwKVuEp8fad1G6UZPa4wMap6HTVuBgD4H8tcAICf3HbbbZKkZcuWtes8FotFqQkOjRwQp5WbiyVJO7KrtC+3WmndwmUP498FAQAA0LQqT6We2PGY8p15vr5BsYM1q/d1slg6x5JpHTVuBgD4HxUIAAgCcVE2jR/Rzdc2DOmzb4pVVslSFwAAAGhajbdGT2U9oQNV+319vaL76Fd9b5TVQjkAANB6/N8DAIKA1WpR/+5RGtA90tf31fYyFZbWmBgVAAAAOiuP4dHzu/6urPIdvr6MiEzd1O83stvsJkYGAAhmFJMBIEjER4dp7PD62cnlVR6t3Vqq6hpmJwMAAKCeYRh6de8SfVOyydeXFJ6k3wy4TRFhkcc5EgCA46OYDABBwmaz6Owh8UqIrl/u/vPvSlTKUhcAAAA4ylvZb+iLgtW+dlxYnG4ecJti7XEmRgUACAUUkwEgiCTG2XXW0Hhfe/ehau04UCnDMEyMCgAAAJ3FR4eW67+HP/S1I22RurH/LUp2pJgYFQAgVFBMBoAgYg+zavLIRFmP+vT+dGORyquZnQwAANDVrc5fpbez3/S17dZw/arvHHWP6m5iVACAUBLW/C4AgLZ45JFH/HLenmmRGt47Rht3lkuSvtpRpoISl2Ij+UgHAADoqjYUfaVX9y7xtW0Wm37e+xfqF9vfxKhaxl/jZgBAx6PyAAB+0q9fP7+c12G3atLIJF8xubrGq5Wbi9QjJUI2m8Uv1wQAAEDntabgc7124FUZql36zCKLftrzag1PONncwFrIX+NmAEDHC6plLpxOp373u98pMzNTkZGROv300/XRRx81e9ybb76pyy+/XH369FFUVJQGDhyo22+/XcXFxf4PGgD8YPSgWKV1s/vaq74pUVmV28SIAAAAEGiGYeh/JSv1zwOv+ArJknTJCZfpzOSzTYwMABCqgqqYPGvWLD3yyCO66qqr9Nhjj8lms+nCCy/UqlWrjnvc9ddfry1btujqq6/W448/rsmTJ2vhwoU688wzVVVVFaDoAXQ1Cxcu1MKFC/1y7qiIMJ17SqKvfSDfqW/3VPjlWgAAAOh8vIZXb+e8qY+LP/D1WWTR1BN+ovPTJ5kYWev5c9wMAOhYQbPMxbp16/TPf/5TDz30kO644w5J0syZMzV06FDdeeedWr169TGPXbp0qcaNG9eg77TTTtO1116rV155Rb/4xS/8GTqALurDD2ufoj1nzhy/nH/SqEQt/SxXNe7aWSgffVWo0QPjFG4Pqn8nBAAAQCt5DLde2bNEawvX+PpsFpuu7Hm1zgjCGcn+HjcDADpO0FQcli5dKpvNpuuvv97XFxERoeuuu05r1qzR/v37j3nsDwvJknTppZdKkrZs2dLhsQJAIKQmOHT6oDhf++sdZTpU6DQxIgAAAPhbjdepZ3Y+1aCQbLeE6xd9bgjKQjIAILgEzczkr7/+WgMGDFBcXFyD/tGjR0uSNm7cqB49erT4fIcOHZIkJScnN7tvbm6u8vLyGvRlZWVJktxut9xu/69T6na75fF4AnIt1CPv5gi1vPvzfVwwupv+922JJMnlMfTRVwWaeX6aLJbWPYgv1HIeLMi7Oci7OQKdd/5+AYSiSnelntq5UDvLs3x9EZZIXd/n1xqYMMjEyAAAXUXQFJNzcnKUkZHRqL+u7+DBg60634MPPiibzaZp06Y1u++iRYt03333NbmtrKwsIA/y83g8Ki8vlyTZbDa/Xw+1yLs5Qi3v/vyM6J5gqGdKmPbl1RZNVm4q0vkjwhTlaN3He6jlPFiQd3OQd3MEOu9lZWV+vwYABFKJq1gLdzymg1XZvr64sDhdnTxLfWP6mRgZAKArCZpiclVVlRwOR6P+iIgI3/aWevXVV/Xcc8/pzjvvVP/+/Zvdf/bs2Zo+fXqDvqysLE2dOlWxsbFKSEho8bXbqm52TXx8vMLCguavLeiRd3OEWt79/RlxwWiPnv537bct8ko92pkbph8Na901Qy3nwYK8m4O8myPQeY+NjfX7NQAgUHKrc7Vwx6MqqMn39SWHp2h235tlq+QfRgEAgRM0v0FFRkbK6Wy8Fmh1dbVve0v873//03XXXadJkybpgQceaNExqampSk1NbXJbWFhYwH4RtdlsAb0eapF3c4RS3v39HiaNStHL/81VRbVXkvTRhmKNGZEkm7V1S12EUs6DCXk3B3k3RyDzzt8tgFCxv3K/ntjxmMrcpb6+zMgTdHP/2xRpiVRxZbF5wQEAupygGWVnZGQoOzu7UX9OTo4kKTMzs9lzbNq0SVOmTNHQoUO1dOlSfskA4Fd9+/YNyHUiHTaNHd5N768rkCRt3lWu7DyneqZFBOT6AAAA8I8dZdv0VNYTqvZW+/r6RPfVjf1+o4iwiJBZHz5Q42YAQPsFTTX15JNP1qeffqrS0tIGD+Fbu3atb/vx7Ny5U5MnT1Zqaqref/99xcTE+DNcANCCBQsCdq1Lzk7xFZM9Xmn5lwW6/qITAnZ9AAAAdKxNxRv1/K5n5DbqC8aD44boV/1ulM0SNL/Kt0ggx80AgPaxmh1AS02bNk0ej0fPPPOMr8/pdGrx4sU6/fTT1aNHD0nSvn37tHXr1gbHHjp0SBMnTpTVatUHH3yglJSUgMYOAP7WMzVCQ3tF+9orNhapusZjYkQAAABoC8Mw9Gnuf/X3nU82KCSPTjxdv+53U8gVkgEAwSVo/i90+umna/r06fr973+v3Nxc9evXTy+++KL27Nmj5557zrffzJkztXLlShmG4eubPHmydu3apTvvvFOrVq3SqlWrfNvS0tJ0/vnnB/S9AIA/XHxmsr7dUyFJKip36/PvSnTuKYkmRwUAAICWcnqcenXvEn1ZtK5B/4TU83RZ9+myWFr3TAwAADpa0BSTJemll17S3LlztWTJEhUVFWn48OF67733NGbMmOMet2nTJknSX//610bbxo4dSzEZgF9MmTJFkrRs2bKAXO/sIQnqFputorLaGSzL1xVo3IhurX4QHwAguOXk5Oixxx7T2rVr9eWXX6q8vFyffvqpxo0b1+JzfPzxx3rggQf0zTffyO12a8CAAbrpppt0zTXX+C9woIs7XH1Yz+58UgerD/r6LLLo4sypmpRxgYmR+V+gx80AgLYLmmUuJCkiIkIPPfSQcnJyVF1drXXr1mnSpEkN9lmxYkWDWclS7deEjvWzYsWKAL4DAPAfm82iSSPrZyJ/u6dCn3xd1OgzEQAQ2rZt26YHH3xQ2dnZGjZsWKuPX7ZsmSZOnKiamhrde++9euCBBxQZGamZM2eyringJ5uKN+qvWx5oUEiOskXp+r6/DvlCMgAguATVzGQAwPH9+IwU/Wtlrjze2vYT7+xXcnyYTukXd/wDAQAh47TTTlNBQYESExO1dOlSTZ8+vVXHL1y4UBkZGfrkk0/kcDgkSTfccIMGDRqkF154Qbfeeqs/wga6JK/h1bsH39GHh/7ToD8jIlO/6jdHyY5kkyIDAKBpQTUzGQBwfElxds08P8PXdroMPfjPfdp7qMrEqAAAgRQbG6vExLavmV9aWqpu3br5CsmSFBYWpuTkZEVGRnZEiAAklbnK9MSOxxoVkk/rNkq/O+kuCskAgE6JmckAEGKmj03VnkNV+nRTsSSppMKt+a/u0UPX91NCjN3c4AAAnd64ceP04IMPau7cubr22mtlsVj06quv6ssvv9Trr79+3GNzc3OVl5fXoC8rK0uS5Ha75Xa7/RZ3HbfbLY/HE5BroR55b529lXv0/J6/q9hV5OuzWcI0NeMyjUkZJ3klt7f5XIZa3oPhfYRazoMFeTcHeTdHoPPe2utQTAaAEGOxWHTTpT2UV+LSt3sqJEkH8px64NU9mv+zvnLY+VIKAODY5s6dq927d+uBBx7Q/PnzJUlRUVF64403dMkllxz32EWLFum+++5rcltZWZmKi4s7OtxGPB6PysvLJUk2m83v10Mt8t4yhmHoq/L1er/wXXnk8fXHWeM0I+VK9bD3bNV/J6GW90B8RrRXqOU8WJB3c5B3cwQ672VlZa3an2IyAISgSIdNd13VS799JksH8pySpG93V+ixN/fpjuknymq1mBwhAKAlvF6vampqWrSvw+GQxdL+z3eHw6EBAwZo2rRpuuyyy+TxePTMM8/o6quv1kcffaQzzjjjmMfOnj270RrNWVlZmjp1qmJjY5WQkNDu+JpTN7smPj5eYWH8uhMo5L15Nd4aLT3wmtYWrWnQ3yeqr67rdYNi7DGtPmeo5T0QnxHtFWo5Dxbk3Rzk3RyBzntsbGyr9udOAAA/mT17tqnXT4ix655reuvOZ7JUVF77P6NPNxYrI9Gha45aVxkA0Hl99tlnGj9+fIv23bJliwYNGtTua86ZM0dffPGFNmzYIKu19tssM2bM0JAhQ/Sb3/xGa9euPeaxqampSk1NbXJbWFhYwH4RtdlsAb0eapH3Y8t35uvZnU9qf9X+Bv3jU8/VZd2ny2pp+zfHQiHvdePmYHkPoZDzYETezUHezRHIvLf2GtwJAOAnkydPNjsEdU+J0F1X99Ldz+1StcsrSfrHJ4eV1i1cE0cmmRwdAKA5gwYN0uLFi1u0b0ZG+/+hsKamRs8995zuvPNOXyFZkux2uy644AItXLhQNTU1Cg8Pb/e1gK7AMAytLVyjpftfV5Wn0tcfYY3QVSdeq1MTTzMxus6jM4ybAQAtQzEZAELckBNjdNv0nvrLP/bIa0iGpIXvHFBat3CN6Nu6r7MAAAIrPT1ds2bNCtj1CgoKfA99+SGXyyWv19vkNgCNFTjz9Y99L2tL6fcN+tMc6fpVv9lKjUg3KTIAANqOpzABgJ8sX75cy5cvNzsMSdKPhiXougsyfW2X29ADr+zR/txqE6MCAJht37592rp1q6+dmpqqhIQEvfXWWw3Wai4vL9e7776rQYMGKTIy0oxQgaDhNbxakfuJ5n9/X6NC8oj4k/W7k+6ikPwDnWncDAA4PmYmA4CfLFq0SFLn+dreZT9K1eGiGi1bky9JKqvyaN4Lu/TojQMU7TA5OABAh5o/f74k6bvvvpMkLVmyRKtWrZIk3X333b79Zs6cqZUrV8owDEm16/Pdcccduvvuu3XGGWdo5syZ8ng8eu6553TgwAG9/PLLAX4nQHA5VJWjl/e+qN0Vuxr0x4TF6CfdZ2h00rEfYNmVdbZxMwDg2CgmA0AX8quLT9Dh4hqt3VIqSTpUVKN7X9qlB2adaHJkAICONHfu3Abt559/3vf66GJyU+666y717t1bjz32mO677z45nU4NHz5cS5cu1U9+8hO/xAsEO7fXrY8Of6DlOf+W23A32HZywqm6suc1irZHmxQdAAAdh2IyAHQhFotFf/jpibrj6SztyK6SJG3dV6lH3sjWDZNYPxkAQkXdTOPmrFixosn+K6+8UldeeWUHRgSErr0Ve/TK3peUXXWgQX+CvZt+2vMqDU0YblJkAAB0PIrJANDFhNttun9WH/3mie3KLXZJkj7/rlRJ0V798uJuJkcHAAAQHGq8Tr138F19cvgjGar/BxyLLDoj6SxN73GFHDbWEgMAhBaKyQDQBSXE2DX/Z31121M7VF7lkSQtW1eu7mkFuvisNJOjAwAA6Ny2l23VK3uXKN+Z16A/xZGqq0+cqX6xA0yKDAAA/6KYDABdVI/UCM29upfuen6X3J7a2TSL3s3RwUKXfnHhCbJZLSZHCAAA0LkU1xTpvYPLtKbg8wb9NotNY1LGa+oJlynMyq/ZAIDQxf/lAKALG94nVrf9pIf++vo+X9/bn+dr58Fqzb26l2Kj+N8EAABAladSHx76QJ8e/lguw9VgW2bkCZp54s/UI7qnSdEBABA4VAkAwE+WLVtmdggtMv6URNW43Hpi2UG5ale80De7y3Xj49t0z8ze6psZZW6AAAAAJnF5Xfpf3kotz/m3KjwVDbbZLXZNTL9AkzMulNViNSnC0BAs42YAAMVkAICkc09NVHykS397t0iFZW5JUl6JS7c9uUO/uayHJpySaHKEAAAAgeM1vPqqaL3ezX5bBTUFjbYPjhuq6T2uUGpEqgnRAQBgHorJAABJUr8Mhx6d3Vd/+ccBfb+vduZNjdvQQ6/v0/YDlfrlRayjDAAAQt+W0u/1zoE3tL9qf6NtJ0b11rQeM9Qnpq8JkQEAYD6KyQDgJ7feeqskacGCBSZH0nLdYuz66/X99OS7B/TvtfWzcN5Zna9dOVWae3Vv1lEGAAAhaX/lPr194A1tLdvSaFuqI01TT7hMI7qdYkJkoS8Yx80A0FVREQAAP9m5c6fZIbSJzWbRnKk91L97lJ5454BcbkOS9M3uCt34+DbNu6a3+p3AOsoAACA05Dvz9e7Bt/Vl4bpG2+LC4nVB5kU6J3kM6yL7UbCOmwGgK6KYDABo0qSRSeqVFqH5L+9RfmntU8vzSly67akduoV1lAEAQJDLc+bq40Mf6YuCz+U23A22RVgjNSHtXE1Mv0B2q92kCAEA6HwoJgMAjmlgj2j97aYBmv/yHn23t3YdZdfR6yhfeIJsNtZRBgAAwWNfxV59eHi5NhZtkCGjwbYwS5jOSDpLUzIvVbQ92qQIAQDovCgmAwCOKyHGrgev76dn3svWsjX5vv66dZRv+PEJ6pMRKYuFojIAAOicDMPQ1rLv9eGhD7S9bGuj7RZZNDxhhH7S/XIlOZJMiBAAgOBAMRkA0Cyb1aJfT+mu/idE6m9vH1DNUesoz/nbdmUmhWv8iG4ad3I3dU+JMDlaAACAWh7Do6+LvtJHhz7Qgar9jbZbZdWQ+KH6ceYl6h7Vw4QIAQAILhSTAQAtdt5pSeqVHqn7l+xWXonL13+woEavfHJYr3xyWL3TIzT+5G4aN6KbUhLCTYwWAAB0VU6PU2sKPtcnhz9SQU1Bo+12i12nJY7ShRk/VpIj2YQIAQAIThSTAcBPJk6caHYIftHvhCgtvGmAnngnW2u2lMjlbrjW4O5D1dq9PEfPL8/RST2jNP7kbvrRsG5KiOF/OQAAwL/K3WVamfupVuZ+qgpPRaPtUbZonZV8jiamTVK0PcaECNGUUB03A0Ao4jd7APCTOXPmmB2C38RF2/X7K3upuNyllZuLteqbYm3ZVyGPt+F+W/ZVasu+Sj31braG94nRhFMSddaQeEVH2MwJHAAAhBzDMLSzPEurC1ZpQ+GXchmuRvsk2LtpfOoEjUkdr3Ar35zqbEJ53AwAoYZiMgCgzRJi7LrkrBRNOTNZeSUurdhUpM+/LdGO7EoZR01Y9hrSxp3l2rizXH9726KzBsfrgtFJGtY7RlYrD+4DAACtV+Iq1tqCNVqT/7lynblN7pMekaHz0ydpdOIZslqsAY4QAIDQQzEZAPwkKytLktSvXz+TI/E/i8Wi1IRwzRibpuljUpVd4NSKjUX6/LsS7TlU3WBfl9vQys3FWrm5WKkJdk0cmaSJpyWyvjIAAGiWx3Dr25JvtDr/c31f8q288ja5X+/oProg4yINjhsqi4V/uO7sutK4GQCCHcVkAPCT2267TZK0bNkykyMJLIvFou7JEbr6vAxdOSFdew5X6dONRVr9XYkOFtQ02De32KWXPz6kVz4+pJP7xWjyqCSdMThe4WHMHAIAAPUOVedoTf7nWlvwhcrcpU3uE2GN1PCEEZqQdp56RPUMcIRoj646bgaAYEQxGQDgN1arRX0yotQnI0o/m5SpLfsr9OH6Qq3+rkTl1R7ffoakr7PK9XVWuWIibZpwcjdNGpWkPhmR5gUPAABMVe2p1oaiL7Um/3Ptqth5zP16RffROcnnaGTi6bJb7QGMEACArodiMgAgIKxWi4acGKMhJ8bo1xd79Nk3xfp4Q6G+3VPRYH3l8iqPlq3J17I1+eqbGanJI5N01tB4JcbyyyEAAKGu0l2pb0u+0abiDfqu5NsmH6YnSXFh8RqZOEpjU8YrOSIlwFECANB1UUwGAARchMNWu1byyCTlFDi1fH2BPt1YpLyShr8w7jxYpSeWHdATyw6oW2yY+mVGqW9mpPplRqpvZqTSuoWzDiIAAEGuzFWqzcWbtLF4g7aVbZXH8DS5n81i08DYkzQmZZyGxA/lgXoAAJiAYjIAwFQZSQ79bHKmZk3K0Fc7yrR8fYHWby1VjdtosF9RmVvrt5Vq/bb6dRKjI2zqmxmpvhm1xeV+J0Sqe3KEbDYKzAAAdGYFzgJtKv5am4q/1s7yLBkyjrlvmiNNZySdpbNTxig6LDqAUQIAgB+imAwA6BQsFotGDojTyAFxKq906+OvC/XRV0XalVN1zGMqqj3avKtcm3eV+/rCwyzqnR6pviccKTBnRqlXWoTC7cxeAgDATIeqc7SxqLaAvK9y73H3TXakaGj8MJ2eeJZ6RvMwPQAAOguKyQCATicmKkxTz07V1LNTdajQqe/2VGjnwUrtPlStvYerVVTuPuaxNW5D2w5UatuBSl+fzSqdmBahvkctk9EnI1KRDlsg3g4AAF1SpbtC28u2a1vZFm0t/V65ztzj7p8RkanhCSM0OvEMpUdmBChKAADQGhSTAcBPHnnkEbNDCAnpiQ6lJzp07qmJvr7CMpe2769U1sFK7TxYpT2Hq3W4sOaYX5D1eKVdOdXalVOtj76q7bNYpO7JjtplMo4UmXukOJQUZ2cdZgAA2sBtuLWjfJt2VGzX1tIt2le597jLV1hkUY+onjo54VSNSjxdiY7EY+6L0Ma4GQCCB8VkAPCTfv36mR1CyEqMteuMwfE6Y3C8r6/K6VHWwSptP1CpndmV2plTrez8anm8TZ/DMKT9eU7tz3NqxaZiX39EuFWZSQ51T3bohKN/UhyKjeR/mwAA1PEaXmVXHdDW0i3aWvK9dlZkyWW4jnuMzWJTr+jeOjVhpE5LHKVYe2yAokVnxrgZAIIHvxUDAEJCpMOmYb1jNKx3jK/P5fZqz6Eqbdtfqe3ZVdqVU6V9udVyuY89S6q6xqtdOVVNrtUcF21T9+QIX4E5IzFcKfHhSk6wKzHWLpuVGc0AgNDl8rqUXXVAeyp2a2d5lraVblGFp6LZ4xLsCeoT009D44dreMIIRdoiAxAtAADwB4rJAOAnCxculCTNmTPH5Ei6LnuYVf27R6t/9/onv3u8hg7kVmvrgUrtOFC/TEZ1zTGmMB+ltMKj7ysq9P3exr84W621M6ZT4u1Kjg8/8mfD190oOAMAgoTX8Cq3+rD2VO7W3oo92lOxW9lVB+QxPM0eG2mLVK/oPhoSN0TDEkYo2ZESgIgRzBg3A0DwoJgMAH7y4YcfSmJQ3NnYrBadmB6pE9MjNWlkkiTJ6zWUV+LSvtwq7c9z6kCeUwfznTpY4FRBqUveY09k9vF6pfwSl/JLXJIqm9zHapUSosMUFxWmuOgwxURY5QjzKDmhWvEx4YqLstVuiwpT7JHXMZE2WSlAAwD8rLimSHsq9mhv5W7tqdijfRV7VO2tbtGxYZYwnRDZXb3C+ui01FHqHddbVovVzxEjlDBuBoDgQTEZANDlWa0WpXULV1q3cI0a2HCby+3VoUKn9uY6tT+3Wtn5TmXnO3Ww0KnSiuZnZx3N65UKy9wqLHP/YMuxvyJstUhx0WHqFhOmhBi7EmPD1C3Wrm4xR/6MDVO3mNp2bJSNhwcCAI7L5XXpUPUhHaw6oINV2TpYdVDZVQdU4ipu8TnCLGFKjUhTv5j+Gp4wQv1iBsjitai4uFgJ0QkUkgEACGEUkwEAOA57mFU9UiPVI7Xx+o41Lq8Kylw6XFijQ0U1yiuuUV5JjfKKXSoodamwzK2K6tYVnH/Ia0jF5W4Vl7slHX+GWJjNooSY2sJz/FEzoOOibYqvex0Vpvho25HZz2EKs1F8BoBQ5DW8KqjJP1Iwri0aH6zKVm71YXnV/NJOR0t2pKh7ZA/1iemr/jEDdELUCbJZGv4q6fb+8B9KAQBAKKKYDABAG4XbrcpIdCgj0XHMfZwurwpKXDpcVFtwLi53qbTCrdJKj0oqXCoud6rSaVFFtUcV1V55WrKmxjG4PcZRS220TEyETXHRNsVGhSk20qaYSJtiIsOO/Fn/E3ukPzqith3lsDILGgBMZhiGytxlKnDmK78mTwXOfOU585RTdVA51Tmq8Tpbfc64sDhlRnZX7+je6h87UCdG91KELcIP0QMAgGBEMRkAAD9y2K3KTHYoM7lxwdntdtd+JTghQWFhYTIMQ9U13tpCc7lLJZUeFZe7VFTmVlG5S4WlbhWWu1Rc7lZphVtlVR4Zba89S5LKqz0qr/ZIBTWtOs5qlaIdNkU6rIqKsCnKYVNkeO3rSIfV9zqqbp8jf0aEWxUeZlW43aLwMKscdovsYVaFh1kUbrfKbrNQpAaAo9R4ncp3FqjAmaf8mvzawrEz70gBOV813tZ9fh+tmz1RaRFpyozsrj4xfdUnpq/i7fEdGD0AAAg1FJMBAOgkLBaLIh02RTpsSusW3uz+Hq+hskq3isrcKih1Kb/UpaKy2iU2SircKq10q7TCo/Kq2oJxdU3rvtZ8PF6vVFblUVmVR1LLZ0I3x2KRwsNqC8wOu1X2MIsiwmuL0xHh9YXqiHCrIh22+m0OqyLDawvajiPbfT/22j8ddisPMwTQaXgNr8rcpSqpKVGJq1jFrmKVuIpVUlNS/9pVrHJ3ebuvFW2LVkpEmjIjM9Uj8kT1iu6l9Mh0hVuP/c0aAACAplBMBgA/6du3r9khIMTZrBYlxNiVEGNX74zGazr/kMtdO+u5tMKt4iMznIsr3CqpcKukwqOySnftTOUqjyqqPapyelTp9Mrlbuf051YwDMnpMuR01cbR0Rz22hnQ4TYpKiLPV3B22OuK1/WzpuuK2r5Z02H1/XVtu61+H/uR/ev2q91W+9rG2tQIoP/+97965ZVXtGrVKh04cEDp6emaMGGC/vjHPyojI6NF58jOztatt96qDz/8UF6vV+PHj9eCBQvUp08fP0cfvAzDULW3WhXucpUf+fnh6zJXqUpctcXiUleJDHXs52tsWJwSwhOU4khVj8ge6hndS92juismLLZDrwN0NMbNABA8KCYDgJ8sWLDA7BCABuxhViXFWZUUZ5fUfPG5To3bWzu7+chPaYVb5VUelVW5VemsXeu5svpIAbrGqyqnR1VOr6pqvHLWeFVd41W1y9vuJTk6Ql2hWpIKyjq+WH0sVouOFJ+PFKGPKjzXFaSbeh1utyrMapHNZpHNWvuQRZvV4vvTZrP4tof59qkveNctI+Kw1/Y57NYG/TZmaoek3/3udyosLNT06dPVv39/7dq1SwsXLtR7772njRs3Kj09/bjHl5eXa/z48SopKdEf/vAH2e12LViwQGPHjtXGjRuVlJQUoHcSWC6vS9Weajm91aryVMvpqVa1t0rVnuraH++RviOvqzxVvmJx3Z8ew7+fKw5rhBLsCermSFRKeIpSI9KUFpGmFEequoUnym61+/X6gL8wbgaA4EExGQAAHFd4mFWJsVYlxra9SGEYhpwur5wuQzUur2rcdX8eKTi7vapxGXLW1PUZtX+6vEcK1EcXqT2+ArWzxus7r7OTFKyb4jUaFrI7izCbxTcD22qVrBaLrJba5Uas1trXVqtFFotks9T+abHUFq2tlvoid12B23p0odt6ZNuRgrfFYsjtqtHowVadNSTR7Lce0h555BGdc845slqtvr7Jkydr7NixWrhwoebPn3/c4xctWqQdO3Zo3bp1GjVqlCTpggsu0NChQ/Xwww/rT3/6k1/jb4/V+atU7CxSaWWZrBVWeeRWjbfG9+P64Z+Gy7fN34Xg5oRbwxUTFqvYsFjF2eNri8bh3ZTkSFZqRJqSw5MVFRZtaowAAAAUkwEAgN9ZLBZFhNsU0fxS0G1mGIZq3IaqnF45XUcKzjW1BdzK6toZ0pU1HlVWuVVcWiFZHXIe2b/a5ZWrrsjtNuRy1y7v4XJ75fIYcnkMud21f7rchjzeTlq1biW3x5DbY0jOjltPuzmx0REUk/1szJgxTfYlJiZqy5YtzR6/dOlSjRo1yldIlqRBgwbp3HPP1euvv96pi8n/PfyRDlXnmB2Gj1VWRYVFKdIWpShblKLDohVvT1C38EQlhicqyZGkeHuC4u0JirBFmB0uAABAsygmA4CfTJkyRZK0bNkykyMBugaLxSKHvXYph+MNcdxut4qLw5SQkKCwsLYNhbzeI0VnT13Rub4A7es/MmPa5a4tUjvrtvv6attOt1cuV22huuboIvaR4rXHY8jtNeT11r72eGsfvlj7I3mN+n6vt3bfzjpDG+YpLy9XeXm5kpOTj7uf1+vV5s2b9fOf/7zRttGjR+vDDz9UWVmZYmObXoM3NzdXeXl5DfqysrIk1f6353a72/gOWsZu8c8yD+HWcIVbHQq3hMthq30dYY1QlC1asWGxirHHKjYsTnFhcYoJi1FMWKxiwqLlsEbIYmnBcjKG/J4bf3O73fJ4PEH/PoJNqOT9sssukyS9+eabJkfSvFDJebAh7+Yg7+YIdN5bex2KyQAAAK1ktVoUEW5RhKzN72wCj6e2SF1z1NIidUVrp9uramdtu26ZkNrZ1rWzuz1HitFew5C3rlhd13ek7TWOFLSPKnb7itx1bU99wdvjNeT2eOX1eJSe6Mfp6TimRx99VDU1Nbr88suPu19hYaGcTmeTD+qr6zt48KAGDhzY5PGLFi3Sfffd1+S2srIyFRcXty7wVopRjLrZEmXxWhRmC1O4NVxhFrvsR/9Y7Qq3hMtusSvc4qhtW8MVYYmQwxohh9Uhh9WhcEvtn3aLXVZLC/9bNyS5an+q5VS1nP58u52Kx+NReXm5JMlms5kcTdcRann392dERwi1nAcL8m4O8m6OQOe9rKysVftTTAYAAAgxNptFUTabohydZ9BfOyO8WAkJCWaHElS8Xq9qampatK/D4WhyFuxnn32m++67TzNmzNCECROOe46qqirfuX4oIiKiwT5NmT17tqZPn96gLysrS1OnTlVsbKzf//5/lTBHbrdbJSUlio+Pb/O3D9B6dbOayHtghVreg+H/EaGW82BB3s1B3s0R6Lwf6xtnx8KdAAAAAHRSn332mcaPH9+ifbds2aJBgwY16Nu6dasuvfRSDR06VM8++2yz54iMjJQkOZ2NZ9RWV1c32KcpqampSk1NbXJbWFhYwH4RtdlsAb0eapF3c4RS3oPlPYRSzoMJeTcHeTdHIPPe2mtwJwAAAACd1KBBg7R48eIW7fvDpSn279+viRMnKj4+Xu+//36LZp0kJibK4XAoJ6fxQ+zq+jIzM1sUDwAAAEIPxWQAAACgk0pPT9esWbNafVxBQYEmTpwop9Op//73v02ugdwUq9WqYcOG6csvv2y0be3aterTp0+rvwoJAACA0NE5nxoDAAAAoE0qKip04YUXKjs7W++//7769+9/zH337dunrVu3NuibNm2a1q9f36CgvG3bNn3yySeN1kMGAABA1xJUM5OdTqfmzZunJUuWqKioSMOHD9f8+fN1/vnnN3tsdna2br31Vn344Yfyer0aP368FixYoD59+gQgcgBd0ezZs80OAQDQBV111VVat26dfv7zn2vLli3asmWLb1tMTIymTp3qa8+cOVMrV66UYRi+vtmzZ+vvf/+7LrroIt1xxx2y2+165JFHlJaWpttvvz2QbwVAF8G4GQCCR1AVk2fNmqWlS5fqlltuUf/+/fXCCy/owgsv1KeffqpzzjnnmMeVl5dr/PjxKikp0R/+8AfZ7XYtWLBAY8eO1caNG5WUlBTAdwGgq5g8ebLZIQAAuqCNGzdKkp5//nk9//zzDbadeOKJDYrJTYmNjdWKFSt06623av78+fJ6vRo3bpwWLFiglJQUP0UNoCtj3AwAwSNoisnr1q3TP//5Tz300EO64447JNXOpBg6dKjuvPNOrV69+pjHLlq0SDt27NC6des0atQoSdIFF1ygoUOH6uGHH9af/vSngLwHAAAAwN/27NnT4n1XrFjRZH/37t31r3/9q2MCAgAAQMgImjWTly5dKpvNpuuvv97XFxERoeuuu05r1qzR/v37j3vsqFGjfIVkqfbJ2Oeee65ef/11v8YNoOtavny5li9fbnYYAAAAQKfGuBkAgkfQFJO//vprDRgwQHFxcQ36R48eLan+63w/5PV6tXnzZo0cObLRttGjR2vnzp0qKyvr8HgBYNGiRVq0aJHZYQAAAACdGuNmAAgeQbPMRU5OjjIyMhr11/UdPHiwyeMKCwvldDqbPXbgwIHHvHZubq7y8vIa9GVlZUmS3G633G53y95EO7jdbnk8noBcC/XIuzlCLe/B8D5CLefBgrybg7ybI9B55+8XAAAA6HhBU0yuqqqSw+Fo1B8REeHbfqzjJLXp2DqLFi3Sfffd1+S2srIyFRcXH/f4juDxeFReXi5Jstlsfr8eapF3c4Ra3gPxGdFeoZbzYEHezUHezRHovPPNMwAAAKDjBU0xOTIyUk6ns1F/dXW1b/uxjpPUpmPrzJ49W9OnT2/Ql5WVpalTpyo2NlYJCQnNxt9edbNr4uPjFRYWNH9tQY+8myPU8h6Iz4j2CrWcBwvybg7ybo5A5z02Ntbv1wAAAAC6mqD5DSojI0PZ2dmN+nNyciRJmZmZTR6XmJgoh8Ph2681x9ZJTU1Vampqk9vCwsIC9ouozWYL6PVQi7ybI5TyHizvIZRyHkzIuznIuzkCmXf+bgEAAICOFzQP4Dv55JO1fft2lZaWNuhfu3atb3tTrFarhg0bpi+//LLRtrVr16pPnz7MXAEAAAAAAACAZgTNlI1p06bp//2//6dnnnlGd9xxh6TapSsWL16s008/XT169JAk7du3T5WVlRo0aFCDY//v//5PX375pUaOHClJ2rZtmz755BPfuVqrbtmMugfx+Zvb7VZZWZliY2OZaRNA5N0coZL3uvU6v/vuO5MjaV6o5DzYkHdzkHdzBDrvdWO0ppY6Q2Axbu4ayLs5QiXvjJvRHPJuDvJujs4+brYYhmH4M6CONGPGDL311lu69dZb1a9fP7344otat26d/vvf/2rMmDGSpHHjxmnlypU6+m2VlZXplFNOUVlZme644w7Z7XY98sgj8ng82rhxo1JSUlodyzvvvKOpU6d21FsDAACAH7z99tu65JJLzA6jS2PcDAAA0Pm1dNwcVMXk6upqzZ07Vy+//LKKioo0fPhw/fGPf9SkSZN8+zRVTJakAwcO6NZbb9WHH34or9ercePGacGCBerXr1+bYikuLtbKlSvVo0cPORyOdr2vlqh74N/bb7/d5pjReuTdHOQ98Mi5Oci7Oci7OQKdd6fTqf3792vs2LFB8SDUUMa4uWsg7+Yg74FHzs1B3s1B3s3R2cfNQTVHPSIiQg899JAeeuihY+6zYsWKJvu7d++uf/3rXx0WS0JCgimzXPr166chQ4YE/LpdHXk3B3kPPHJuDvJuDvJujkDm/dRTTw3IdXB8jJu7FvJuDvIeeOTcHOTdHOTdHJ113Bw0D+ADAAAAAAAAAJiHYjIAAAAAAAAAoFkUkwEAAAAAAAAAzaKYHCRSUlJ0zz33KCUlxexQuhTybg7yHnjk3Bzk3Rzk3RzkHYHCvWYO8m4O8h545Nwc5N0c5N0cnT3vFsMwDLODAAAAAAAAAAB0bsxMBgAAAAAAAAA0i2IyAAAAAAAAAKBZFJMBAAAAAAAAAM2imAwAAAAAAAAAaBbFZAAAAAAAAABAsygmm6y8vFz33HOPJk+erMTERFksFr3wwgstPr64uFjXX3+9UlJSFB0drfHjx2vDhg3+CzgEtCfnL7zwgiwWS5M/hw4d8m/gQW79+vWaM2eOhgwZoujoaPXs2VMzZszQ9u3bW3Q893rrtSfn3Ott991332n69Onq06ePoqKilJycrDFjxujdd99t0fHc623Tnrxzv3ecBx54QBaLRUOHDm3R/tnZ2ZoxY4YSEhIUFxenSy65RLt27fJzlAhWjJsDj3GzORg3Bx7jZnMwbjYH4+bOIZjHzWGmXBU++fn5uv/++9WzZ0+NGDFCK1asaPGxXq9XF110kTZt2qTf/va3Sk5O1qJFizRu3Dh99dVX6t+/v/8CD2LtyXmd+++/X717927Ql5CQ0DEBhqgHH3xQn3/+uaZPn67hw4fr0KFDWrhwoU499VR98cUXx/0A5V5vm/bkvA73euvt3btXZWVluvbaa5WZmanKykq98cYbmjJlip5++mldf/31xzyWe73t2pP3Otzv7XPgwAH96U9/UnR0dIv2Ly8v1/jx41VSUqI//OEPstvtWrBggcaOHauNGzcqKSnJzxEj2DBuDjzGzeZg3Bx4jJvNwbjZHIybzRf042YDpqqurjZycnIMwzCM9evXG5KMxYsXt+jY1157zZBk/Otf//L15ebmGgkJCcZPf/pTf4QbEtqT88WLFxuSjPXr1/sxwtD0+eefG06ns0Hf9u3bDYfDYVx11VXHPZZ7vW3ak3Pu9Y7ldruNESNGGAMHDjzuftzrHauleed+7xiXX365MWHCBGPs2LHGkCFDmt3/wQcfNCQZ69at8/Vt2bLFsNlsxu9//3t/hoogxbg58Bg3m4Nxc+Axbu48GDebg3FzYAX7uJllLkzmcDiUnp7epmOXLl2qtLQ0XXbZZb6+lJQUzZgxQ++8846cTmdHhRlS2pPzo5WVlcnj8XRARF3DWWedpfDw8AZ9/fv315AhQ7Rly5bjHsu93jbtyfnRuNfbz2azqUePHiouLj7uftzrHauleT8a93vbfPbZZ1q6dKkeffTRFh+zdOlSjRo1SqNGjfL1DRo0SOeee65ef/11P0SJYMe4OfAYN5uDcXPgMW7uPBg3m4Nxc+CEwriZYnIQ+/rrr3XqqafKam341zh69GhVVla2eE0ttN748eMVFxenqKgoTZkyRTt27DA7pKBkGIYOHz6s5OTk4+7Hvd5xWprzOtzrbVdRUaH8/Hzt3LlTCxYs0H/+8x+de+65xz2Ge7392pL3OtzvbePxeHTTTTfpF7/4hYYNG9aiY7xerzZv3qyRI0c22jZ69Gjt3LlTZWVlHR0qujA+X83DZ2vHYNwceIybA4dxszkYNwdeqIybWTM5iOXk5GjMmDGN+jMyMiRJBw8ebPHNiZaJiorSrFmzfB+cX331lR555BGdddZZ2rBhg3r06GF2iEHllVdeUXZ2tu6///7j7se93nFamnPu9fa7/fbb9fTTT0uSrFarLrvsMi1cuPC4x3Cvt19b8s793j5PPfWU9u7dq48//rjFxxQWFsrpdPru7aMdfb8PHDiww+JE18bna+Dx2dqxGDcHHuPmwGHcbA7GzYEXKuNmislBrKqqSg6Ho1F/RESEbzs61owZMzRjxgxfe+rUqZo0aZLGjBmjBx54QE899ZSJ0QWXrVu36sYbb9SZZ56pa6+99rj7cq93jNbknHu9/W655RZNmzZNBw8e1Ouvvy6Px6OamprjHsO93n5tyTv3e9sVFBRo3rx5mjt3rlJSUlp8XN29zP2OQOHzNfD4bO04jJsDj3FzYDFuNgfj5sAKpXEzy1wEscjIyCbXAaqurvZth/+dc845Ov3001v1L0td3aFDh3TRRRcpPj5eS5culc1mO+7+3Ovt19qcN4V7vXUGDRqk8847TzNnztR7772n8vJyXXzxxTIM45jHcK+3X1vy3hTu95a5++67lZiYqJtuuqlVx9Xdy9zvCBQ+XzsHPltbj3Fz4DFuDjzGzeZg3BxYoTRuppgcxDIyMpSTk9Oov64vMzMz0CF1WT169FBhYaHZYQSFkpISXXDBBSouLtby5ctbdJ9yr7dPW3J+LNzrbTdt2jStX7/+uOu3ca93vJbk/Vi4349vx44deuaZZ3TzzTfr4MGD2rNnj/bs2aPq6mq5XC7t2bPnmPlLTEyUw+HgfkfA8PnaefDZ2nKMmwOPcXPnwLjZHIyb/SfUxs0Uk4PYySefrA0bNsjr9TboX7t2raKiojRgwACTIut6du3a1aqvKXRV1dXVuvjii7V9+3a99957Gjx4cIuO415vu7bm/Fi419uu7qtHJSUlx9yHe73jtSTvx8L9fnzZ2dnyer26+eab1bt3b9/P2rVrtX37dvXu3fuY60xarVYNGzZMX375ZaNta9euVZ8+fRQbG+vvt4AuhM/XzoPP1pZh3Bx4jJs7D8bN5mDc7D+hNm6mmBwkcnJytHXrVrlcLl/ftGnTdPjwYb355pu+vvz8fP3rX//SxRdf3OR6Kmi5pnKel5fXaL/3339fX331lSZPnhzI8IKOx+PR5ZdfrjVr1uhf//qXzjzzzCb3417vOO3JOfd62+Xm5jbqc7lceumllxQZGen7xYR7vWO1J+/c720zdOhQvfXWW41+hgwZop49e+qtt97SddddJ0nat2+ftm7d2uD4utkvRw+Mt23bpk8++UTTp08P6HtBaOHzNfD4bO1YjJsDj3GzORg3m4Nxc+CF2rjZYrR2MRR0uIULF6q4uFgHDx7Uk08+qcsuu0ynnHKKJOmmm25SfHy8Zs2apRdffFG7d+9Wr169JNX+D++cc87Rt99+q9/+9rdKTk7WokWLtG/fPq1fv54noB9HW3Pev39/nXLKKRo5cqTi4+O1YcMGPf/888rIyND69euVlpZm4rvq3G655RY99thjuvjiixss2F/n6quvliTu9Q7Unpxzr7fdpZdeqtLSUo0ZM0YnnHCCDh06pFdeeUVbt27Vww8/rNtuu00S93pHa0/eud871rhx45Sfn69vv/22Qd/KlSsbrMFXVlamU045RWVlZbrjjjtkt9v1yCOPyOPxaOPGjcxuQZMYNwce4+bAY9wceIybzcG42RyMmzuPoB03GzDdiSeeaEhq8mf37t2GYRjGtdde26Bdp7Cw0LjuuuuMpKQkIyoqyhg7dqyxfv36wL+JINPWnN91113GySefbMTHxxt2u93o2bOn8etf/9o4dOiQOW8kiIwdO/aYOT/6o4h7veO0J+fc6233j3/8wzjvvPOMtLQ0IywszOjWrZtx3nnnGe+8806D/bjXO1Z78s793rHGjh1rDBkypFFfU8PO/fv3G9OmTTPi4uKMmJgY48c//rGxY8eOQIWKIMS4OfAYNwce4+bAY9xsDsbN5mDc3HkE67iZmckAAAAAAAAAgGaxZjIAAAAAAAAAoFkUkwEAAAAAAAAAzaKYDAAAAAAAAABoFsVkAAAAAAAAAECzKCYDAAAAAAAAAJpFMRkAAAAAAAAA0CyKyQAAAAAAAACAZlFMBgAAAAAAAAA0i2IyAAAAAAAAAKBZFJMBAAAAAAAAAM2imAwAAAAAAAAAaBbFZAAAAAAAAABAsygmA8APWCyWFv2sWLHC7FBNt3r1at17770qLi42O5QG9u/f3+K/x127dpkdLgAAQFBi3NxyjJsBhIowswMAgM5myZIlDdovvfSSPvroo0b9J510UiDD6pRWr16t++67T7NmzVJCQoLZ4fg4HI4Gf19VVVW6/vrrNX78eP385z/39VssFvXp08eMEAEAAIIe4+aWY9wMIFRQTAaAH7j66qsbtL/44gt99NFHjfpDUUVFhaKjo80Oo91xpKamNvj7+vLLLyVJF110UZf4ewQAAAgExs2MmwF0PSxzAQDtlJ2drZ///OdKS0uTw+HQkCFD9PzzzzfY595775XFYtH27dt19dVXKz4+XikpKZo7d64Mw9D+/ft1ySWXKC4uTunp6Xr44YebPH7r1q2aMWOG4uLilJSUpN/85jeqrq5uV0zff/+9rrzySnXr1k3nnHOOJGnv3r2aPXu2Bg4cqMjISCUlJWn69Onas2dPg+N/+9vfSpJ69+7t+/rbnj17NGvWLPXq1atRXHXXbGkcLX0vzdm8ebMkadiwYa06DgAAAB2HcTPjZgDBj5nJANAOhw8f1hlnnCGLxaI5c+YoJSVF//nPf3TdddeptLRUt9xyS4P9L7/8cp100kn6y1/+on//+9+aP3++EhMT9fTTT2vChAl68MEH9corr+iOO+7QqFGjNGbMmAbHz5gxQ7169dKf//xnffHFF3r88cdVVFSkl156qc0xTZ8+Xf3799ef/vQnGYYhSVq/fr1Wr16tK664Qt27d9eePXv05JNPaty4cfr+++8VFRWlyy67TNu3b9c//vEPLViwQMnJyZKklJSUNuWyqTha+16OpW5QPHz48DbFBgAAgPZh3My4GUCIMAAAx3XjjTcax/q4vO6664yMjAwjPz+/Qf8VV1xhxMfHG5WVlYZhGMY999xjSDKuv/563z5ut9vo3r27YbFYjL/85S++/qKiIiMyMtK49tprfX11x0+ZMqXBdWbPnm1IMjZt2tTmmH760582el91+xxtzZo1hiTjpZde8vU99NBDhiRj9+7dDfa99tprjRNPPLHROequ2VRfU3G09L00Z/z48UZKSkqL9gUAAEDbMG6uxbgZQChjmQsAaCPDMPTGG2/o4osvlmEYys/P9/1MmjRJJSUl2rBhQ4NjfvGLX/he22w2jRw5UoZh6LrrrvP1JyQkaODAgU0+LfnGG29s0L7pppskSe+//36bY/rVr37V6DqRkZG+1y6XSwUFBerXr58SEhIaHd9RfhhHW97LsXzzzTfMrgAAADAJ4+aOxbgZgJlY5gIA2igvL0/FxcV65pln9MwzzzS5T25uboN2z549G7Tj4+MVERHh+6rb0f0FBQWNzte/f/8G7b59+8pqtfrWZGtLTL179260T1VVlf785z9r8eLFys7O9n19TpJKSkqaPG97/TCOtryXpuTk5Cg/P5913wAAAEzCuLljMW4GYCaKyQDQRl6vV1LtU6yvvfbaJvf54b/q22y2Rvs01SepwUD0WH74UI62xHT0bIo6N910kxYvXqxbbrlFZ555puLj42WxWHTFFVf4rtGauOp4PJ5jHvPDONryXprCum8AAADmYtzc8rjqMG4G0FlRTAaANkpJSVFsbKw8Ho/OO++8gFxzx44dDWYiZGVlyev1+p4A3VExLV26VNdee22Dp2NXV1eruLi4wX7HGvx269at0b5S7dOuW6qj3ss333wjiUExAACAWRg3M24GEDpYMxkA2shms+knP/mJ3njjDX377beNtufl5XX4NZ944okG7b/97W+SpAsuuKBDY7LZbI1mePztb39rNEMiOjpakhoNgPv27auSkhLf7Aap9mtzb731VouuXxdDR7yXzZs3y2azafDgwS2+NgAAADoO42bGzQBCBzOTAaAd/vKXv+jTTz/V6aefrl/+8pcaPHiwCgsLtWHDBn388ccqLCzs0Ovt3r1bU6ZM0eTJk7VmzRq9/PLLuvLKKzVixIgOjenHP/6xlixZovj4eA0ePFhr1qzRxx9/rKSkpAb7nXbaaZKku+66S1dccYXsdrsuvvhiXXHFFfrd736nSy+9VDfffLMqKyv15JNPasCAAa16EElHvJfNmzerX79+TX4tEQAAAIHBuJlxM4DQQDEZANohLS1N69at0/33368333xTixYtUlJSkoYMGaIHH3yww6/32muvad68efq///s/hYWFac6cOXrooYc6PKbHHntMNptNr7zyiqqrq3X22Wfr448/1qRJkxrsN2rUKP3xj3/UU089peXLl8vr9Wr37t3q1auX3nrrLd12222688471bt3b/35z3/Wjh07WjUobu97cbvd2rJliy655JIWXxMAAAAdj3Ez42YAocFitGSlegCAqe69917dd999ysvLa/QEawAAAAC1GDcDgH+xZjIAAAAAAAAAoFkUkwEAAAAAAAAAzaKYDAAAAAAAAABoFmsmAwAAAAAAAACaxcxkAAAAAAAAAECzKCYDAAAAAAAAAJpFMRkAAAAAAAAA0CyKyQAAAAAAAACAZlFMBgAAAAAAAAA0i2IyAAAAAAAAAKBZFJMBAAAAAAAAAM2imAwAAAAAAAAAaBbFZAAAAAAAAABAsygmAwAAAAAAAACaRTEZAAAAAAAAANAsiskAAAAAAAAAgGb9fwAooOyvacl6AAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, axes = plt.subplots(1, 2, figsize=(12, 4.5))\n", "\n", "axes[0].plot(temperatures, avg_m_plot, color=PALETTE['mag'], lw=2)\n", "axes[0].fill_between(temperatures, avg_m_ci_low_plot, avg_m_ci_high_plot, color=PALETTE['mag'], alpha=0.2)\n", "axes[0].axvline(TC_ISING, color='0.3', ls='--', lw=1.2)\n", "axes[0].set_xlabel('Temperature $T$')\n", "axes[0].set_ylabel(r'$|M|$')\n", "axes[0].set_title('Order parameter')\n", "axes[0].grid(alpha=0.25)\n", "\n", "axes[1].plot(temperatures, avg_e_plot, color=PALETTE['eng'], lw=2)\n", "axes[1].fill_between(temperatures, avg_e_ci_low_plot, avg_e_ci_high_plot, color=PALETTE['eng'], alpha=0.2)\n", "axes[1].axvline(TC_ISING, color='0.3', ls='--', lw=1.2)\n", "axes[1].set_xlabel('Temperature $T$')\n", "axes[1].set_ylabel(r'Energy per spin $E$')\n", "axes[1].set_title('Energy density')\n", "axes[1].grid(alpha=0.25)\n", "\n", "fig.suptitle('Local-update temperature sweep: mean observables', y=1.02)\n", "fig.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "c4e058c5", "metadata": {}, "source": [ "## Susceptibility and Specific Heat\n", "\n", "The order-parameter curve identifies the transition window, but the fluctuation observables make that window much sharper. The susceptibility $\\chi = N\\,\\mathrm{Var}(|M|)/T$ measures how strongly the magnetization responds to thermal noise, while the specific heat $C_v = N\\,\\mathrm{Var}(E)/T^2$ measures energy fluctuations. Both quantities peak in the critical regime because the lattice samples many competing domain structures there. For a finite lattice these are rounded maxima rather than true singularities, but they are the finite-size precursors of the exact Ising critical behaviour [[1]](#Bibliography) [[2]](#Bibliography)." ] }, { "cell_type": "code", "execution_count": 15, "id": "45daf650", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, axes = plt.subplots(1, 2, figsize=(12, 4.5))\n", "\n", "axes[0].plot(temperatures, susc_plot, color=PALETTE['chi'], lw=2)\n", "axes[0].fill_between(temperatures, susc_ci_low_plot, susc_ci_high_plot, color=PALETTE['chi'], alpha=0.2)\n", "axes[0].axvline(TC_ISING, color='0.3', ls='--', lw=1.2)\n", "axes[0].set_xlabel('Temperature $T$')\n", "axes[0].set_ylabel(r'Susceptibility $\\chi$')\n", "axes[0].set_title('Magnetization fluctuations')\n", "axes[0].grid(alpha=0.25)\n", "\n", "axes[1].plot(temperatures, spec_h_plot, color=PALETTE['cv'], lw=2)\n", "axes[1].fill_between(temperatures, spec_h_ci_low_plot, spec_h_ci_high_plot, color=PALETTE['cv'], alpha=0.2)\n", "axes[1].axvline(TC_ISING, color='0.3', ls='--', lw=1.2)\n", "axes[1].set_xlabel('Temperature $T$')\n", "axes[1].set_ylabel(r'Specific heat $C_v$')\n", "axes[1].set_title('Energy fluctuations')\n", "axes[1].grid(alpha=0.25)\n", "\n", "fig.suptitle('Critical fluctuations in the local-update sweep', y=1.02)\n", "fig.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "47749aba", "metadata": {}, "source": [ "## Entropy\n", "\n", "The sweep also carries enough information to reconstruct an entropy curve from the specific heat. In this notebook the entropy is shown with the same convention used by the helper functions: the highest sampled temperature is the reference point, so the plotted curve is relative rather than absolutely normalised. That choice changes only an additive constant. The shape still shows where configurational disorder builds up most rapidly, and that happens in the same temperature window where $C_v$ is largest. If one wants the absolute high-temperature entropy of the Ising model, the whole curve would simply be shifted by approximately $\\ln 2$ per spin [[2]](#Bibliography)." ] }, { "cell_type": "code", "execution_count": 16, "id": "dba6bbfc", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(figsize=(7.5, 4.8))\n", "\n", "ax.plot(temperatures, entropy_plot, color=PALETTE['entropy'], lw=2)\n", "ax.fill_between(temperatures, entropy_ci_low_plot, entropy_ci_high_plot, color=PALETTE['entropy'], alpha=0.2)\n", "ax.axhline(0.0, color='0.4', ls='--', lw=1.0, label=r'Reference at highest sampled $T$')\n", "ax.axvline(TC_ISING, color='0.3', ls='--', lw=1.2)\n", "ax.set_xlabel('Temperature $T$')\n", "ax.set_ylabel(r'Relative entropy $S(T) - S(T_{\\max})$')\n", "ax.set_title('Entropy from thermodynamic integration')\n", "ax.grid(alpha=0.25)\n", "ax.legend(fontsize=9)\n", "\n", "fig.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "9e1d70ef", "metadata": {}, "source": [ "## Critical Slowing Down\n", "\n", "Thermodynamic signatures and numerical cost peak in the same region. The integrated autocorrelation time $\\tau_{\\mathrm{int}}$ measures how long the checkerboard-Metropolis Markov chain remembers a magnetization fluctuation once the system is already in equilibrium. The effective sample size behaves roughly as $N_{\\mathrm{eff}} \\sim N_{\\mathrm{meas}} / (2\\tau_{\\mathrm{int}})$, so a large autocorrelation time means that many recorded steps contain little new information. Near $T_c$ the correlation length grows, collective spin rearrangements become slow, and local updates decorrelate inefficiently. That is the local-update version of critical slowing down discussed by Madras, Sokal, and Newman-Barkema [[4]](#Bibliography) [[5]](#Bibliography) [[6]](#Bibliography).\n", "\n", "*Note on diagnostic flags:* The panels below highlight points with degraded uncertainty metrics using cross markers. These denote conditions where the autocorrelation computation became non-finite (`undefined_autocorr_flag`), the relative uncertainty bounds on $\\tau_{\\mathrm{int}}$ grew too large (`tau_interval_unstable_flag`), or the effective sample size dropped below a minimum threshold (`low_effective_sample_flag`)." ] }, { "cell_type": "code", "execution_count": 17, "id": "712aade8", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "flagged_tau = (undefined_autocorr_flag > 0) | (tau_interval_unstable_flag > 0)\n", "flagged_neff = low_effective_sample_flag > 0\n", "\n", "fig, axes = plt.subplots(1, 2, figsize=(12, 4.5))\n", "\n", "axes[0].plot(temperatures, tau_int, color=PALETTE['tau'], lw=2)\n", "axes[0].fill_between(temperatures, tau_int_ci_low, tau_int_ci_high, color=PALETTE['tau'], alpha=0.2)\n", "axes[0].axvline(TC_ISING, color='0.3', ls='--', lw=1.2)\n", "if np.any(flagged_tau):\n", " axes[0].scatter(\n", " temperatures[flagged_tau],\n", " tau_int[flagged_tau],\n", " color='black',\n", " marker='x',\n", " s=45,\n", " label='flagged point',\n", " )\n", "axes[0].set_xlabel('Temperature $T$')\n", "axes[0].set_ylabel(r'Integrated autocorrelation time $\\tau_{\\mathrm{int}}$')\n", "axes[0].set_title('Equilibrium memory')\n", "axes[0].grid(alpha=0.25)\n", "if np.any(flagged_tau):\n", " axes[0].legend(fontsize=9)\n", "\n", "axes[1].plot(temperatures, avg_m_n_eff, color=PALETTE['mag'], lw=2)\n", "axes[1].axvline(TC_ISING, color='0.3', ls='--', lw=1.2)\n", "if np.any(flagged_neff):\n", " axes[1].scatter(\n", " temperatures[flagged_neff],\n", " avg_m_n_eff[flagged_neff],\n", " color='black',\n", " marker='x',\n", " s=45,\n", " label=r'low $N_{\\mathrm{eff}}$',\n", " )\n", "axes[1].set_xlabel('Temperature $T$')\n", "axes[1].set_ylabel(r'Effective sample size $N_{\\mathrm{eff}}$')\n", "axes[1].set_title('Independent information per temperature')\n", "axes[1].grid(alpha=0.25)\n", "if np.any(flagged_neff):\n", " axes[1].legend(fontsize=9)\n", "\n", "fig.suptitle('Critical slowing down for checkerboard Metropolis data', y=1.02)\n", "fig.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "bd086fdf", "metadata": {}, "source": [ "## Autocorrelation Function at Three Temperatures\n", "\n", "The previous figure compresses equilibrium memory into a single number at each temperature. The next plot shows the underlying autocorrelation function $\\rho_M(\\tau)$ itself for checkerboard-Metropolis trajectories below, near, and above $T_c$. Away from the transition the correlation drops quickly because the simulation explores independent local rearrangements after only a short lag. Close to $T_c$ the decay is much slower, so the area under $\\rho_M(\\tau)$ becomes large and the integrated autocorrelation time grows with it [[4]](#Bibliography) [[5]](#Bibliography)." ] }, { "cell_type": "code", "execution_count": 18, "id": "f208dcf4", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "autocorr_temperatures = [0.8 * TC_ISING, TC_ISING, 1.2 * TC_ISING]\n", "autocorr_labels = ['0.8 $T_c$', '$T_c$', '1.2 $T_c$']\n", "autocorr_colors = ['#4878CF', '#D65F5F', '#6ACC65']\n", "\n", "fig, ax = plt.subplots(figsize=(7.8, 4.8))\n", "\n", "for idx, (temp, label, color) in enumerate(zip(autocorr_temperatures, autocorr_labels, autocorr_colors)):\n", " sim_random = IsingSimulation(\n", " size=40,\n", " temp=float(temp),\n", " update='checkerboard',\n", " init_state='random',\n", " seed=5_000 + idx,\n", " )\n", " sim_ordered = IsingSimulation(\n", " size=40,\n", " temp=float(temp),\n", " update='checkerboard',\n", " init_state='ordered',\n", " seed=5_000 + idx,\n", " )\n", " convergence_equilibrate(\n", " sim_random,\n", " sim_ordered,\n", " chunk_size=120,\n", " max_steps=9_000,\n", " )\n", " mags, _ = sim_random.run(n_steps=1_600)\n", " mags_arr = np.asarray(mags, dtype=float)\n", " try:\n", " corr, tau_here = calculate_autocorr(time_series=mags_arr, max_lag=160)\n", " except ZeroVarianceAutocorrelationError:\n", " corr = np.array([np.nan])\n", " tau_here = float('nan')\n", " lags = np.arange(corr.size)\n", " ax.plot(lags, corr, lw=2, color=color, label=f'{label} ($\\\\tau_{{int}} \\\\approx {tau_here:.1f}$)')\n", "\n", "ax.axhline(0.0, color='0.4', ls='--', lw=1.0)\n", "ax.set_xlabel(r'Lag $\\tau$')\n", "ax.set_ylabel(r'Autocorrelation $\\rho_M(\\tau)$')\n", "ax.set_title(r'Checkerboard-Metropolis autocorrelation of $|M|$')\n", "ax.set_ylim(-0.05, 1.05)\n", "ax.grid(alpha=0.25)\n", "ax.legend(fontsize=9)\n", "\n", "fig.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "d33240bc", "metadata": {}, "source": [ "## Synthesis\n", "\n", "The notebook now shows the same transition from several angles. The order parameter falls, the energy curve bends, the susceptibility and specific heat develop maxima, the entropy changes slope most rapidly, and the autocorrelation time reaches its largest values in the same narrow temperature window. These are not separate phenomena. They all come from the growth of long-range critical fluctuations. The same correlated domains that make the equilibrium state highly susceptible also make local Monte Carlo dynamics slow.\n", "\n", "For equilibrium work near $T_c$, this is exactly where cluster updates become valuable. The companion notebooks on Wolff efficiency, relaxation, and dynamical critical exponents explain how nonlocal updates suppress the local decorrelation bottleneck without changing the equilibrium Boltzmann distribution. This notebook stays with the local temperature sweep so that the thermodynamic story and the sampling-cost story are told with one consistent dataset." ] }, { "cell_type": "markdown", "id": "08ce5791", "metadata": {}, "source": [ "## Bibliography\n", "\n", "[[1]](#Bibliography) L. Onsager, \"Crystal Statistics. I. A Two-Dimensional Model with an Order-Disorder Transition,\" *Physical Review* 65, 117-149 (1944). [APS Open Access](https://journals.aps.org/pr/abstract/10.1103/PhysRev.65.117)\n", "\n", "[[2]](#Bibliography) K. Huang, *Statistical Mechanics*, 2nd edition, Wiley (1987). [Open lecture notes by John Cardy](https://arxiv.org/pdf/0807.3472.pdf)\n", "\n", "[[3]](#Bibliography) W. K. Hastings, \"Monte Carlo sampling methods using Markov chains and their applications,\" *Biometrika* 57, 97-109 (1970). [Oxford Academic](https://academic.oup.com/biomet/article/57/1/97/252073)\n", "\n", "[[4]](#Bibliography) G. S. Madras and A. D. Sokal, \"The pivot algorithm: A highly efficient Monte Carlo method for the self-avoiding walk,\" *Journal of Statistical Physics* 50, 109-186 (1988). [Springer Open Access](https://link.springer.com/article/10.1007/BF01022990)\n", "\n", "[[5]](#Bibliography) A. D. Sokal, \"Monte Carlo Methods in Statistical Mechanics: Foundations and New Algorithms,\" lecture notes (1989), reprinted in *Functional Integration: Basics and Applications* (1997). [Springer Link](https://link.springer.com/chapter/10.1007/978-1-4899-0319-8_6)\n", "\n", "[[6]](#Bibliography) M. E. J. Newman and G. T. Barkema, *Monte Carlo Methods in Statistical Physics*, Oxford University Press (1999). [Lecture notes summary](https://arxiv.org/abs/0905.1629)" ] } ], "metadata": { "kernelspec": { "display_name": ".venv (3.12.12)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.12" } }, "nbformat": 4, "nbformat_minor": 5 }