From d1209ebe9c06f45b46d5b507c0b4572852883d14 Mon Sep 17 00:00:00 2001 From: xoth42 Date: Sat, 20 Dec 2025 03:58:16 -0500 Subject: [PATCH 1/4] final error improvements - errors on all models. Batch tensor multiplying because the kernel model was taking too long to run. --- .gitignore | 3 +- README.md | 85 ++++++- error_kraus.py | 21 +- qml_training.py | 382 ++++++++++++++++++++++++++---- quantum_simulator.py | 217 ++++++++++++++--- run_experiments.py | 432 ++++++++++++++++++++++++++++++++-- tests/test_parallelization.py | 109 +++++++++ tests/test_run_experiments.py | 137 ++++++++++- visualizer.py | 402 +++++++++++++++++++++++++++++++ 9 files changed, 1663 insertions(+), 125 deletions(-) create mode 100644 tests/test_parallelization.py diff --git a/.gitignore b/.gitignore index 7eada52..67abf9c 100644 --- a/.gitignore +++ b/.gitignore @@ -120,4 +120,5 @@ dmypy.json data/* plots/* *.lock -.vscode/* \ No newline at end of file +.vscode/* +prof/* diff --git a/README.md b/README.md index fc8c010..38f2827 100644 --- a/README.md +++ b/README.md @@ -40,10 +40,14 @@ T1/T2 thermal relaxation applied after each gate: **Noise-Aware VQC**: Same architecture, trained with simulated T1/T2 noise using density matrix evolution. +**Quantum Kernel**: Feature-map based classifier using quantum state overlap. No gradient-based training—predicts labels via kernel sum against training set. Useful for comparing encoding methods under varying noise. + ## Usage +### Trainable Models (VQC, Noise-Aware QNN) + ```bash -# Default run +# Default run (all models, all encodings, all datasets) python run_experiments.py # Custom parameters @@ -53,15 +57,76 @@ python run_experiments.py --epochs 50 --T1 50 --T2 100 python run_experiments.py --models deep_vqc --encodings angle --datasets moons --plot ``` -| Arg | Default | Options | -|-----|---------|---------| -| `--epochs` | 25 | | -| `--T1` | 100 | T1 relaxation (μs) | -| `--T2` | 200 | T2 dephasing (μs) | -| `--models` | all | `deep_vqc`, `noise_aware` | -| `--encodings` | all | `angle`, `amplitude` | -| `--datasets` | all | `real`, `moons` | -| `--plot` | off | Save comparison plots | +### Quantum Kernel Model + +```bash +# Run kernel with default noise parameters +python run_experiments.py --kernel + +# Run kernel without noise (noiseless simulation) +python run_experiments.py --kernel-noiseless + +# Run kernel with noise sweep (tests T1 = 25, 50, 100, 200, 500 μs) +python run_experiments.py --kernel-noise-sweep --plot + +# Run kernel for specific encoding/dataset +python run_experiments.py --kernel --encodings angle --datasets moons + +# Compare kernel results with plots +python run_experiments.py --kernel --kernel-compare +``` + +### Combined Runs + +```bash +# Run all models including kernel +python run_experiments.py --models deep_vqc noise_aware kernel --plot + +# Run specific models with kernel +python run_experiments.py --models kernel noise_aware --encodings angle --datasets moons +``` + +### Unified Noise Sweep (Accuracy vs T1 Plot) + +Run all models (VQC, QNN, Kernel) across varying T1 noise levels and generate comparison plots: + +```bash +# Run noise sweep with default T1 values (25, 50, 100, 200, 500 μs) +python run_experiments.py --noise-sweep --plot + +# Custom T1 values and epochs +python run_experiments.py --noise-sweep --epochs 10 --T1-values 50 100 200 --plot + +# Noise sweep on specific dataset +python run_experiments.py --noise-sweep --datasets moons --epochs 25 --plot + +# Custom T2/T1 ratio (default is 2.0) +python run_experiments.py --noise-sweep --T2-ratio 1.5 --plot +``` + +This generates a plot with **T1 (μs) on x-axis** and **Final Accuracy on y-axis** for all 6 configurations: +- VQC Angle, VQC Amplitude +- QNN Angle, QNN Amplitude +- Kernel Angle, Kernel Amplitude + +## CLI Arguments + +| Arg | Default | Options | Description | +|-----|---------|---------|-------------| +| `--epochs` | 25 | int | Training epochs for VQC/QNN | +| `--T1` | 100 | float | T1 relaxation (μs) | +| `--T2` | 200 | float | T2 dephasing (μs) | +| `--models` | all | `deep_vqc`, `noise_aware`, `kernel` | Models to run | +| `--encodings` | all | `angle`, `amplitude` | Encoding methods | +| `--datasets` | all | `real`, `moons` | Datasets to use | +| `--plot` | off | flag | Save comparison plots | +| `--kernel` | off | flag | Run kernel experiments | +| `--kernel-noiseless` | off | flag | Run kernel without noise | +| `--kernel-noise-sweep` | off | flag | Run kernel with varying noise levels | +| `--kernel-compare` | off | flag | Plot kernel comparison charts | +| `--noise-sweep` | off | flag | Run all models with varying T1 values | +| `--T1-values` | 25 50 100 200 500 | floats | T1 values (μs) for noise sweep | +| `--T2-ratio` | 2.0 | float | T2/T1 ratio for noise sweep | ## Datasets diff --git a/error_kraus.py b/error_kraus.py index e088d4f..6a09112 100644 --- a/error_kraus.py +++ b/error_kraus.py @@ -203,6 +203,7 @@ def add_time_based_noise( accounted_for_time = [0.0] * num_qubits noisy_circuit: List[Tuple] = [] + relax_cache: Dict[float, Tuple[float, float]] = {} for op in circuit: name = op[0] @@ -220,7 +221,11 @@ def add_time_based_noise( for q in acted_on: if accounted_for_time[q] < max_time: idle = max_time - accounted_for_time[q] - λ1, λ2 = thermal_relaxation_error_rate(T1, T2, idle) + if idle in relax_cache: + λ1, λ2 = relax_cache[idle] + else: + λ1, λ2 = thermal_relaxation_error_rate(T1, T2, idle) + relax_cache[idle] = (λ1, λ2) if λ1 > 0.0 or λ2 > 0.0: noisy_circuit.append( ("T1T2_NOISE", [q], λ1, λ2, idle) @@ -231,9 +236,13 @@ def add_time_based_noise( # This models T1/T2 relaxation that occurs even while a gate is applied if gate_noise_fraction > 0.0 and time_to_elapse > 0.0: noise_time = time_to_elapse * gate_noise_fraction - for q in acted_on: + if noise_time in relax_cache: + λ1, λ2 = relax_cache[noise_time] + else: λ1, λ2 = thermal_relaxation_error_rate(T1, T2, noise_time) - if λ1 > 0.0 or λ2 > 0.0: + relax_cache[noise_time] = (λ1, λ2) + if λ1 > 0.0 or λ2 > 0.0: + for q in acted_on: noisy_circuit.append( ("T1T2_NOISE", [q], λ1, λ2, noise_time) ) @@ -248,7 +257,11 @@ def add_time_based_noise( for q in range(num_qubits): if accounted_for_time[q] < end_time: idle = end_time - accounted_for_time[q] - λ1, λ2 = thermal_relaxation_error_rate(T1, T2, idle) + if idle in relax_cache: + λ1, λ2 = relax_cache[idle] + else: + λ1, λ2 = thermal_relaxation_error_rate(T1, T2, idle) + relax_cache[idle] = (λ1, λ2) if λ1 > 0.0 or λ2 > 0.0: noisy_circuit.append( ("T1T2_NOISE", [q], λ1, λ2, idle) diff --git a/qml_training.py b/qml_training.py index 503bf40..3b969e1 100644 --- a/qml_training.py +++ b/qml_training.py @@ -2,6 +2,7 @@ import torch import math import random +import os from enum import Enum from constants import DEFAULT_GATE_DURATIONS, DEFAULT_T1, DEFAULT_T2 @@ -251,28 +252,59 @@ def state_encoding(x, n, encoding=EncodingType.ANGLE): return state, circuit # ============================================================ -# Deep Variational QNN, no errors +# Deep Variational QNN, with optional T1/T2 noise # ============================================================ -def deep_vqc_forward(x, theta, depth=3, encoding=EncodingType.ANGLE, n=None): - """Forward pass of the noiseless deep VQC, returning ⟨Z0⟩.""" +def deep_vqc_forward(x, theta, depth=3, encoding=EncodingType.ANGLE, n=None, T1=None, T2=None, gate_durations=None, gate_noise_fraction=1.0, cached_encoding=None): + """Forward pass of the deep VQC with optional T1/T2 noise, returning ⟨Z0⟩. + + Args: + cached_encoding: If provided, tuple (init_state, encoding_circuit) to skip state_encoding call. + Allows reuse of encoding across multiple forward evaluations with different theta. + """ + if gate_durations is None: + gate_durations = dict(DEFAULT_GATE_DURATIONS) + + # Check theta length matches depth + assert len(theta) == 3*depth + # Calculate number of qubits based on encoding type if n is None: n = len(x) if encoding == EncodingType.ANGLE else int(math.log2(len(x))) - # Prep state with desired encoding method - state,circ = state_encoding(x,n,encoding) - state = apply_circuit_to_ket(state,circ,n) + # Use cached encoding if provided, otherwise compute it + if cached_encoding is not None: + init_state, circ = cached_encoding + # Make a copy of the circuit so we don't modify the cached version + circ = list(circ) + else: + init_state, circ = state_encoding(x, n, encoding) - # Variational layers + # Add variational layers to circuit idx = 0 for _ in range(depth): - state = apply_gate(state, RY(theta[idx]), [0], n) - state = apply_gate(state, RY(theta[idx+1]), [1], n) - state = apply_gate(state, CNOT, [0,1], n) - state = apply_gate(state, RZ(theta[idx+2]), [0], n) + circ += [("RY", [0], theta[idx])] + circ += [("RY", [1], theta[idx+1])] + circ += [("CNOT", [0, 1])] + circ += [("RZ", [0], theta[idx+2])] idx += 3 - - return expectation_z(state, 0, n) + + # Use noisy density simulation if T1/T2 provided + if T1 is not None and T2 is not None: + density = run_noisy_circuit_density( + initial_state=init_state, + circuit=circ, + num_qubits=n, + T1=T1, + T2=T2, + gate_durations=gate_durations, + gate_noise_fraction=gate_noise_fraction + ) + Z0 = torch.kron(Z, I2) + return torch.real(torch.trace(Z0 @ density)) + else: + # Noiseless ket simulation + state = apply_circuit_to_ket(init_state, circ, n) + return expectation_z(state, 0, n) # ============================================================ # Noise-aware QNN (density matrix) @@ -299,7 +331,8 @@ def param_gate_layer(gate: str, x, specify_qubits: tuple[int] | None = None): def noisy_qnn_forward(x, theta, T1=DEFAULT_T1, T2=DEFAULT_T2, gate_durations=None, # needed for noise model (all times in μs) encoding=EncodingType.ANGLE, - gate_noise_fraction=1.0): + gate_noise_fraction=1.0, + cached_encoding=None): # Optional cached (init_state, encoding_circuit) if gate_durations is None: gate_durations = dict(DEFAULT_GATE_DURATIONS) @@ -307,7 +340,12 @@ def noisy_qnn_forward(x, theta, T1=DEFAULT_T1, T2=DEFAULT_T2, # Calculate number of qubits based on encoding type n = len(x) if encoding == EncodingType.ANGLE else int(math.log2(len(x))) - init_state, circ = state_encoding(x,n,encoding) # circ now has the first RY layer (if angle encoding) + # Use cached encoding if provided, otherwise compute it + if cached_encoding is not None: + init_state, circ = cached_encoding + circ = list(circ) # Copy to avoid modifying cached version + else: + init_state, circ = state_encoding(x, n, encoding) # circ now has the first RY layer (if angle encoding) # First RY trainable layer circ += param_gate_layer("RY",theta,[0,1]) @@ -382,9 +420,80 @@ def quantum_kernel(x1, x2, encoding=EncodingType.ANGLE, T1=None, T2=None, # Noisy: trace distance between density matrices return torch.real(torch.trace(ψ1 @ ψ2)) +def kernel_predict_batch(X_test, X_train, y_train, encoding=EncodingType.ANGLE, T1=None, T2=None, + gate_durations=None): + """Batch predict using cached training feature maps - much faster than repeated kernel_predict. + + Parallelizes feature map computation across all available cores. + Computes feature maps once per training/test point instead of once per pair. + """ + if gate_durations is None: + gate_durations = dict(DEFAULT_GATE_DURATIONS) + + # Set up multiprocessing for feature map computation (parallelized by default) + from torch.multiprocessing import Pool, set_start_method + try: + set_start_method('spawn', force=True) + except RuntimeError: + pass # Already set + + n_workers = max(1, os.cpu_count() - 1) + pool = None + try: + pool = Pool(processes=n_workers) + + # Collect all feature map tasks + all_tasks = [] + for xi in X_train: + all_tasks.append((xi, encoding, T1, T2)) + for xi in X_test: + all_tasks.append((xi, encoding, T1, T2)) + + # Compute all feature maps in parallel + print(f"Computing {len(X_train)} + {len(X_test)} feature maps across {n_workers} workers...") + chunksize = max(1, len(all_tasks) // (n_workers * 4)) + features_list = list(pool.imap_unordered(_evaluate_single_feature_map_task, + all_tasks, chunksize=chunksize)) + + train_features = features_list[:len(X_train)] + test_features = features_list[len(X_train):] + + pool.close() + pool.join() + except Exception as e: + print(f"Warning: Could not set up multiprocessing ({e}), falling back to sequential") + # Pre-compute all training feature maps sequentially + print(f"Computing {len(X_train)} training feature maps...") + train_features = [quantum_feature_map(xi, encoding, T1, T2, gate_durations) for xi in X_train] + + print(f"Computing {len(X_test)} test feature maps...") + test_features = [quantum_feature_map(x, encoding, T1, T2, gate_durations) for x in X_test] + + # For each test point, compute its feature map and compare against cached training features + predictions = [] + for i, x_feature in enumerate(test_features): + if (i + 1) % max(1, len(X_test) // 10) == 0 or i == 0: + print(f" Computing kernel overlaps for test point {i+1}/{len(X_test)}...") + + # Compute kernel values against all training points using cached features + if isinstance(x_feature, torch.Tensor) and x_feature.dim() == 1: + # Noiseless: ket vector inner products + vals = torch.tensor([torch.abs(torch.dot(x_feature.conj(), ψi))**2 for ψi in train_features]) + else: + # Noisy: trace overlaps with density matrices + vals = torch.tensor([torch.real(torch.trace(x_feature @ ψi)) for ψi in train_features]) + + pred = torch.sign(torch.sum(vals * y_train)) + predictions.append(pred) + + return torch.tensor(predictions) + def kernel_predict(x, X_train, y_train, encoding=EncodingType.ANGLE, T1=None, T2=None, gate_durations=None): - """Predict sign label via kernel sum against training set.""" + """Predict sign label via kernel sum against training set. + + Note: For multiple predictions, use kernel_predict_batch() which caches training features. + """ if gate_durations is None: gate_durations = dict(DEFAULT_GATE_DURATIONS) vals = torch.tensor([ @@ -417,7 +526,115 @@ def kernel_predict(x, X_train, y_train, encoding=EncodingType.ANGLE, T1=None, T2 Otherwise: None """ -def train(model_type="deep_vqc", encoding=EncodingType.ANGLE, epochs=25, dataset="real", record_metrics=False, T1=DEFAULT_T1, T2=DEFAULT_T2): +# ─────────────────────────────────────────────────────────────── +# Parallelized training helpers +# ─────────────────────────────────────────────────────────────── + +def _evaluate_single_gradient_task(task): + """ + Evaluate a single parameter-shift gradient task. + + Task format: (sample_idx, xi, yi, theta, param_idx, model_type, encoding_cache, + deep_vqc_depth, T1, T2, encoding, shift_direction) + + Returns: (sample_idx, param_idx, shift_dir, forward_value, loss_contribution) + """ + (sample_idx, xi, yi, theta, param_idx, model_type, cached_enc, + deep_vqc_depth, T1, T2, encoding, shift_dir) = task + + # Create shifted parameters + theta_shifted = theta.clone() + shift = math.pi / 2 + theta_shifted[param_idx] += shift * shift_dir # +shift or -shift + + # Evaluate forward pass + if model_type == "deep_vqc": + pred = deep_vqc_forward(xi, theta_shifted, deep_vqc_depth, encoding, + T1=T1, T2=T2, cached_encoding=cached_enc) + else: # noise_aware + pred = noisy_qnn_forward(xi, theta_shifted, T1=T1, T2=T2, + encoding=encoding, cached_encoding=cached_enc) + + return (sample_idx, param_idx, shift_dir, pred.item(), (pred - yi).item()) + + +def _evaluate_sample_batch(batch_task): + """ + Evaluate gradient contributions for a batch of training samples. + + This batches multiple samples together to amortize IPC costs. + Each worker processes all parameter shifts for its assigned samples. + + Args: + batch_task: (sample_indices, sample_data, theta, config) + - sample_indices: list of sample indices + - sample_data: list of (xi, yi, cached_enc) tuples + - theta: parameter tensor + - config: (model_type, deep_vqc_depth, T1, T2, encoding) + + Returns: + List of (sample_idx, gradients_array, baseline_pred, loss_contrib) tuples + """ + sample_indices, sample_data, theta, config = batch_task + model_type, deep_vqc_depth, T1, T2, encoding = config + + results = [] + n_params = len(theta) + shift = math.pi / 2 + + for idx, (xi, yi, cached_enc) in zip(sample_indices, sample_data): + # Compute baseline prediction + if model_type == "deep_vqc": + baseline_pred = deep_vqc_forward(xi, theta, deep_vqc_depth, encoding, + T1=T1, T2=T2, cached_encoding=cached_enc) + else: # noise_aware + baseline_pred = noisy_qnn_forward(xi, theta, T1=T1, T2=T2, + encoding=encoding, cached_encoding=cached_enc) + + baseline_val = baseline_pred.item() + loss_contrib = (baseline_val - yi) ** 2 + + # Compute parameter-shift gradients for all parameters + grads = torch.zeros(n_params) + for p in range(n_params): + # Positive shift + theta_plus = theta.clone() + theta_plus[p] += shift + if model_type == "deep_vqc": + pred_plus = deep_vqc_forward(xi, theta_plus, deep_vqc_depth, encoding, + T1=T1, T2=T2, cached_encoding=cached_enc) + else: + pred_plus = noisy_qnn_forward(xi, theta_plus, T1=T1, T2=T2, + encoding=encoding, cached_encoding=cached_enc) + + # Negative shift + theta_minus = theta.clone() + theta_minus[p] -= shift + if model_type == "deep_vqc": + pred_minus = deep_vqc_forward(xi, theta_minus, deep_vqc_depth, encoding, + T1=T1, T2=T2, cached_encoding=cached_enc) + else: + pred_minus = noisy_qnn_forward(xi, theta_minus, T1=T1, T2=T2, + encoding=encoding, cached_encoding=cached_enc) + + # Parameter-shift rule + loss_plus = (pred_plus.item() - yi) ** 2 + loss_minus = (pred_minus.item() - yi) ** 2 + grads[p] = 0.5 * (loss_plus - loss_minus) + + results.append((idx, grads, baseline_val, loss_contrib)) + + return results + + +def _evaluate_single_feature_map_task(task): + """Evaluate a single feature map for kernel model.""" + xi, encoding, T1, T2 = task + return quantum_feature_map(xi, encoding, T1, T2) + + +def train(model_type="deep_vqc", encoding=EncodingType.ANGLE, epochs=25, dataset="real", + record_metrics=False, T1=DEFAULT_T1, T2=DEFAULT_T2): if dataset == "real": X_train, X_test, y_train, y_test = make_real_dataset(encoding=encoding) elif dataset == "moons": @@ -429,9 +646,8 @@ def train(model_type="deep_vqc", encoding=EncodingType.ANGLE, epochs=25, dataset deep_vqc_depth = 3 if model_type == "kernel": - scores = torch.tensor([ - kernel_predict(x, X_train, y_train, encoding, T1, T2) for x in X_test - ]) + # Use batch prediction with cached feature maps for massive speedup + scores = kernel_predict_batch(X_test, X_train, y_train, encoding, T1, T2) metrics = compute_metrics(scores, y_test) print(f"{dataset.upper()} KERNEL TEST METRICS:", metrics) return @@ -442,53 +658,116 @@ def train(model_type="deep_vqc", encoding=EncodingType.ANGLE, epochs=25, dataset loss_history = [] acc_history = [] + # Pre-compute encodings for all training samples to reuse across epochs and parameter shifts + n_qubits = len(X_train[0]) if encoding == EncodingType.ANGLE else int(math.log2(len(X_train[0]))) + encoding_cache = {} + for i in range(len(X_train)): + xi = X_train[i] + init_state, circ = state_encoding(xi, n_qubits, encoding) + encoding_cache[i] = (init_state, circ) + + # Set up multiprocessing for gradient evaluation (parallelized by default) + from torch.multiprocessing import Pool, set_start_method + try: + set_start_method('spawn', force=True) + except RuntimeError: + pass # Already set + + n_workers = max(1, os.cpu_count() - 1) + pool = None + try: + pool = Pool(processes=n_workers) + except Exception as e: + print(f"Warning: Could not set up multiprocessing ({e}), falling back to sequential") + for epoch in range(epochs): grads = torch.zeros_like(theta) total_loss = 0.0 - for i in range(len(X_train)): - xi, yi = X_train[i], y_train[i] + if pool is not None: + # Create batched tasks: group samples to reduce IPC overhead + # Each batch processes multiple samples together in one worker call + batch_size = max(5, len(X_train) // (n_workers * 2)) # 2 batches per worker minimum + batch_tasks = [] + + # Prepare shared config to avoid repeated serialization + config = (model_type, deep_vqc_depth, T1, T2, encoding) + + for batch_start in range(0, len(X_train), batch_size): + batch_end = min(batch_start + batch_size, len(X_train)) + sample_indices = list(range(batch_start, batch_end)) + sample_data = [(X_train[i], y_train[i], encoding_cache[i]) + for i in sample_indices] + + batch_tasks.append((sample_indices, sample_data, theta, config)) + + # Process batches in parallel with larger chunks + # Target: each chunk should have substantial computation (multiple samples) + chunksize = max(1, len(batch_tasks) // n_workers) # At least 1 batch per worker + batch_results = pool.map(_evaluate_sample_batch, batch_tasks, chunksize=chunksize) + + # Flatten results from all batches + results = [item for batch in batch_results for item in batch] + + # Process batched results + for result in results: + sample_idx, sample_grads, baseline_val, loss_contrib = result + grads += sample_grads + total_loss += loss_contrib + else: + # Sequential fallback + for i in range(len(X_train)): + xi, yi = X_train[i], y_train[i] + cached_enc = encoding_cache[i] - pred = ( - deep_vqc_forward(xi, theta, deep_vqc_depth, encoding) - if model_type == "deep_vqc" - else noisy_qnn_forward(xi, theta, T1=T1, T2=T2, encoding=encoding) - ) + pred = ( + deep_vqc_forward(xi, theta, deep_vqc_depth, encoding, T1=T1, T2=T2, cached_encoding=cached_enc) + if model_type == "deep_vqc" + else noisy_qnn_forward(xi, theta, T1=T1, T2=T2, encoding=encoding, cached_encoding=cached_enc) + ) - total_loss += (pred - yi)**2 + total_loss += (pred - yi)**2 - for p in range(len(theta)): - shift = math.pi / 2 - tp, tm = theta.clone(), theta.clone() - tp[p] += shift - tm[p] -= shift + for p in range(len(theta)): + shift = math.pi / 2 + tp, tm = theta.clone(), theta.clone() + tp[p] += shift + tm[p] -= shift - fp = ( - deep_vqc_forward(xi, tp, deep_vqc_depth, encoding) - if model_type == "deep_vqc" - else noisy_qnn_forward(xi, tp, T1=T1, T2=T2, encoding=encoding) - ) - fm = ( - deep_vqc_forward(xi, tm, deep_vqc_depth, encoding) - if model_type == "deep_vqc" - else noisy_qnn_forward(xi, tm, T1=T1, T2=T2, encoding=encoding) - ) + fp = ( + deep_vqc_forward(xi, tp, deep_vqc_depth, encoding, T1=T1, T2=T2, cached_encoding=cached_enc) + if model_type == "deep_vqc" + else noisy_qnn_forward(xi, tp, T1=T1, T2=T2, encoding=encoding, cached_encoding=cached_enc) + ) + fm = ( + deep_vqc_forward(xi, tm, deep_vqc_depth, encoding, T1=T1, T2=T2, cached_encoding=cached_enc) + if model_type == "deep_vqc" + else noisy_qnn_forward(xi, tm, T1=T1, T2=T2, encoding=encoding, cached_encoding=cached_enc) + ) - grads[p] += 0.5 * ((fp - yi)**2 - (fm - yi)**2) + grads[p] += 0.5 * ((fp - yi)**2 - (fm - yi)**2) # Update theta -= lr * grads / len(X_train) # Record loss - loss_avg = total_loss.item() / len(X_train) + loss_avg = (total_loss.item() if torch.is_tensor(total_loss) else total_loss) / len(X_train) loss_history.append(loss_avg) - # Test accuracy + # Cache test encodings on first epoch + if epoch == 0: + test_encoding_cache = {} + for j in range(len(X_test)): + xj = X_test[j] + init_state, circ = state_encoding(xj, n_qubits, encoding) + test_encoding_cache[j] = (init_state, circ) + + # Test accuracy using cached test encodings scores_test = torch.tensor([ - deep_vqc_forward(x, theta, deep_vqc_depth, encoding) + deep_vqc_forward(x, theta, deep_vqc_depth, encoding, T1=T1, T2=T2, cached_encoding=test_encoding_cache[j]) if model_type == "deep_vqc" - else noisy_qnn_forward(x, theta, T1=T1, T2=T2, encoding=encoding) - for x in X_test + else noisy_qnn_forward(x, theta, T1=T1, T2=T2, encoding=encoding, cached_encoding=test_encoding_cache[j]) + for j, x in enumerate(X_test) ]) metric_dict = compute_metrics(scores_test, y_test) acc_history.append(metric_dict["accuracy"]) @@ -498,6 +777,11 @@ def train(model_type="deep_vqc", encoding=EncodingType.ANGLE, epochs=25, dataset f"Loss {loss_avg:.4f} | Acc {metric_dict['accuracy']:.3f}" ) + # Clean up pool + if pool is not None: + pool.close() + pool.join() + # Return metrics history if requested if record_metrics: return { diff --git a/quantum_simulator.py b/quantum_simulator.py index 720836a..4b1db8a 100644 --- a/quantum_simulator.py +++ b/quantum_simulator.py @@ -218,15 +218,27 @@ def kraus_operator(density: torch.Tensor, operations_probs: list[tuple[torch.Ten # Probabilities must sum to 1 assert sum(ops[1] for ops in operations_probs) == 1 - return sum( - # the probability of this option - op[1] * - # U * ρ * U† (matrix multiplication) - op[0] @ density @ torch.adjoint(op[0]) - - # for each op and prob - for op in operations_probs - ) + + # Vectorized batched approach: compute all U @ ρ @ U† simultaneously + # Stack operators and probabilities for batch processing + operators = torch.stack([op[0] for op in operations_probs]) # (n_ops, dim, dim) + probs = torch.tensor([op[1] for op in operations_probs], dtype=density.dtype, device=density.device) # (n_ops,) + + # Compute adjoints once + operators_conj_t = torch.adjoint(operators) # (n_ops, dim, dim) + + # Embarrassingly parallel: batch matrix multiply + # Step 1: U @ ρ for all operators simultaneously + temp = torch.matmul(operators, density) # (n_ops, dim, dim) + + # Step 2: (U @ ρ) @ U† for all operators simultaneously + weighted_results = torch.matmul(temp, operators_conj_t) # (n_ops, dim, dim) + + # Step 3: weight by probabilities and sum + # Reshape probs to broadcast correctly: (n_ops, 1, 1) for multiplication with (n_ops, dim, dim) + weighted_results = weighted_results * probs[:, None, None] + + return weighted_results.sum(dim=0) # ─────────────────────────────────────────────────────────────── # Embed a local gate as a full 2^n x 2^n unitary @@ -256,7 +268,122 @@ def build_full_unitary( return U_full # ─────────────────────────────────────────────────────────────── -# Apply a named gate to a density matrix via Kraus formalism +# Optimized density gate application (avoids building full unitaries) +# ─────────────────────────────────────────────────────────────── + +def apply_single_qubit_gate_density( + density: torch.Tensor, + U: torch.Tensor, + q: int, + num_qubits: int, +) -> torch.Tensor: + """ + Apply single-qubit unitary U to qubit q on density matrix. + ρ' = (U ⊗ I) ρ (U† ⊗ I), implemented via tensor contractions. + """ + # Cache permutation orders to reduce Python overhead per gate application + key = (num_qubits, q) + if not hasattr(apply_single_qubit_gate_density, "_perm_cache"): + apply_single_qubit_gate_density._perm_cache = {} + perm_cache = apply_single_qubit_gate_density._perm_cache + + if key in perm_cache: + row_order, final_order = perm_cache[key] + else: + remaining_rows = [i for i in range(num_qubits) if i != q] + row_order = [] + for i in range(num_qubits): + if i == q: + row_order.append(0) # U_out + else: + idx = remaining_rows.index(i) + row_order.append(1 + idx) + + remaining_cols = [i for i in range(num_qubits) if i != q] + final_order = list(range(1, 1 + num_qubits)) # rows stay in order + for i in range(num_qubits): + if i == q: + final_order.append(0) # Uc_out + else: + idx = remaining_cols.index(i) + final_order.append(1 + num_qubits + idx) + + perm_cache[key] = (row_order, final_order) + + # Reshape density into (row qubits, column qubits) + ρ = density.reshape([2]*num_qubits + [2]*num_qubits) + + # Left multiply on row axis q: contract U(in) with row[q] + tmp = torch.tensordot(U, ρ, dims=([1], [q])) # U_out + row_rem + col + tmp = tmp.permute(row_order + list(range(num_qubits, num_qubits + num_qubits))) + + # Right multiply on column axis q + U_dag = U.conj().transpose(0, 1) + tmp2 = torch.tensordot(U_dag, tmp, dims=([1], [num_qubits + q])) # Uc_out + row + col_rem + + ρ_final = tmp2.permute(final_order).reshape(2**num_qubits, 2**num_qubits) + return ρ_final + + +def apply_two_qubit_gate_density( + density: torch.Tensor, + U2: torch.Tensor, + q0: int, + q1: int, + num_qubits: int, +) -> torch.Tensor: + """ + Apply two-qubit unitary U2 to qubits (q0, q1) on density matrix via contractions. + ρ' = (U2 ⊗ I) ρ (U2† ⊗ I) + """ + # Ensure ordered targets for consistent placement + targets = [q0, q1] + k = 2 + ρ = density.reshape([2]*num_qubits + [2]*num_qubits) + + # Cache permutation orders per (num_qubits, targets) + key = (num_qubits, tuple(sorted(targets))) + if not hasattr(apply_two_qubit_gate_density, "_perm_cache"): + apply_two_qubit_gate_density._perm_cache = {} + perm_cache = apply_two_qubit_gate_density._perm_cache + + if key in perm_cache: + row_order, final_order = perm_cache[key] + else: + remaining_rows = [i for i in range(num_qubits) if i not in targets] + row_order = [] + for i in range(num_qubits): + if i in targets: + row_order.append(targets.index(i)) # 0 or 1 from out axes + else: + row_order.append(k + remaining_rows.index(i)) + + remaining_cols = [i for i in range(num_qubits) if i not in targets] + final_order = list(range(k, k + num_qubits)) # rows stay in order + for i in range(num_qubits): + if i in targets: + final_order.append(targets.index(i)) # outc axes positions + else: + final_order.append(k + num_qubits + remaining_cols.index(i)) + + perm_cache[key] = (row_order, final_order) + + # Left multiply: contract U2(in axes) with row axes at targets + G = U2.reshape([2]*k + [2]*k) + tmp = torch.tensordot(G, ρ, dims=(list(range(k, 2*k)), targets)) + tmp = tmp.permute(row_order + list(range(k + len([i for i in range(num_qubits) if i not in targets]), k + len([i for i in range(num_qubits) if i not in targets]) + num_qubits))) + + # Right multiply on column axes at targets + G_dag = U2.conj().transpose(0, 1).reshape([2]*k + [2]*k) + col_targets = [num_qubits + t for t in targets] + tmp2 = torch.tensordot(G_dag, tmp, dims=(list(range(k, 2*k)), col_targets)) + + ρ_final = tmp2.permute(final_order).reshape(2**num_qubits, 2**num_qubits) + return ρ_final + + +# ─────────────────────────────────────────────────────────────── +# Apply a named gate to a density matrix (optimized path) # ─────────────────────────────────────────────────────────────── def apply_named_gate_density( @@ -266,33 +393,33 @@ def apply_named_gate_density( unitary_cache: Dict[Tuple[str, Tuple[int, ...], float | None], torch.Tensor] | None = None, ) -> torch.Tensor: """ - op = (gate_name, [qubits]) - - Uses kraus_operator with a single Kraus operator U_full (probability 1). - Caches U_full per (gate_name, tuple(qubits)) if unitary_cache is provided. - - For parametric gates, use - op = (gate_name, [qubits], param) - ie: ("RX", [0], .4) + Optimized density update: + - Single-qubit gates: einsum/tensordot contractions (no full unitary) + - Two-qubit gates (e.g., CNOT): contraction on two axes + Falls back to full-unitary embedding only if gate arity > 2. """ gate_name = op[0] qubits = op[1] - - # take care of parametric case (have to deal with the param value) is_param = gate_name in PARAMETRIC_GATES param = op[2] if is_param else None - key = (gate_name, tuple(qubits), param) - if unitary_cache is not None and key in unitary_cache: - U_full = unitary_cache[key] - else: - gate = PARAMETRIC_GATES[gate_name](param) if is_param else GATE_LIBRARY[gate_name] - U_full = build_full_unitary(gate, qubits, num_qubits) - if unitary_cache is not None: - unitary_cache[key] = U_full + # Resolve unitary matrix for gate + U = PARAMETRIC_GATES[gate_name](param) if is_param else GATE_LIBRARY[gate_name] - # Single Kraus operator with probability 1.0 - return kraus_operator(density, [(U_full, 1.0)]) + if len(qubits) == 1: + return apply_single_qubit_gate_density(density, U, qubits[0], num_qubits) + elif len(qubits) == 2: + return apply_two_qubit_gate_density(density, U, qubits[0], qubits[1], num_qubits) + else: + # Rare case: fall back to full-unitary path (cached) + key = (gate_name, tuple(qubits), param) + if unitary_cache is not None and key in unitary_cache: + U_full = unitary_cache[key] + else: + U_full = build_full_unitary(U, qubits, num_qubits) + if unitary_cache is not None: + unitary_cache[key] = U_full + return kraus_operator(density, [(U_full, 1.0)]) # ─────────────────────────────────────────────────────────────── # Apply one T1/T2 noise op to a density matrix @@ -313,18 +440,36 @@ def apply_T1T2_noise_op( _, qubits, λ1, λ_φ, _ = noise_op q = qubits[0] + # Caches to avoid rebuilding kron-embedded Kraus ops for identical parameters + # Keys include λ values, target qubit, and num_qubits to ensure correctness + if not hasattr(apply_T1T2_noise_op, "_amp_cache"): + apply_T1T2_noise_op._amp_cache = {} + apply_T1T2_noise_op._deph_cache = {} + amp_cache = apply_T1T2_noise_op._amp_cache + deph_cache = apply_T1T2_noise_op._deph_cache + # 1) Amplitude damping (T1: |1⟩ → |0⟩ relaxation) if λ1 > 0.0: - amp_kraus = amplitude_damping_kraus(λ1) - amp_full = embed_single_qubit_kraus(amp_kraus, q, num_qubits) - amp_ops_probs = make_operations_probs_from_kraus(amp_full) + amp_key = (λ1, q, num_qubits) + if amp_key in amp_cache: + amp_ops_probs = amp_cache[amp_key] + else: + amp_kraus = amplitude_damping_kraus(λ1) + amp_full = embed_single_qubit_kraus(amp_kraus, q, num_qubits) + amp_ops_probs = make_operations_probs_from_kraus(amp_full) + amp_cache[amp_key] = amp_ops_probs density = kraus_operator(density, amp_ops_probs) # 2) Pure dephasing (T_φ: coherence loss from 1/T2 - 1/(2T1)) if λ_φ > 0.0: - deph_kraus = phase_damping_kraus(λ_φ) - deph_full = embed_single_qubit_kraus(deph_kraus, q, num_qubits) - deph_ops_probs = make_operations_probs_from_kraus(deph_full) + deph_key = (λ_φ, q, num_qubits) + if deph_key in deph_cache: + deph_ops_probs = deph_cache[deph_key] + else: + deph_kraus = phase_damping_kraus(λ_φ) + deph_full = embed_single_qubit_kraus(deph_kraus, q, num_qubits) + deph_ops_probs = make_operations_probs_from_kraus(deph_full) + deph_cache[deph_key] = deph_ops_probs density = kraus_operator(density, deph_ops_probs) return density diff --git a/run_experiments.py b/run_experiments.py index ebf200f..39ea76d 100644 --- a/run_experiments.py +++ b/run_experiments.py @@ -16,10 +16,14 @@ from itertools import product from constants import DEFAULT_T1, DEFAULT_T2 -from qml_training import train, EncodingType +from qml_training import ( + train, EncodingType, kernel_predict, kernel_predict_batch, compute_metrics, + make_real_dataset, make_moons_dataset +) # Configuration options -MODEL_TYPES = ["deep_vqc", "noise_aware"] # kernel doesn't have epoch-based training +MODEL_TYPES = ["deep_vqc", "noise_aware"] # kernel handled separately (no epoch-based training) +KERNEL_MODEL = "kernel" # Kernel model runs once per configuration ENCODINGS = [EncodingType.ANGLE, EncodingType.AMPLITUDE] DATASETS = ["real", "moons"] @@ -177,6 +181,308 @@ def save_summary_csv(all_results, filepath): ]) +def save_kernel_results_csv(results, filepath): + """ + Save kernel model results to CSV. + + Columns: encoding, dataset, T1, T2, accuracy, precision, recall, f1, roc_auc + """ + with open(filepath, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerow(['encoding', 'dataset', 'T1', 'T2', 'accuracy', 'precision', 'recall', 'f1', 'roc_auc']) + for r in results: + writer.writerow([ + r['encoding'], + r['dataset'], + r['T1'], + r['T2'], + f"{r['metrics']['accuracy']:.4f}", + f"{r['metrics']['precision']:.4f}", + f"{r['metrics']['recall']:.4f}", + f"{r['metrics']['f1']:.4f}", + f"{r['metrics']['roc_auc']:.4f}" + ]) + + +import torch + +def run_kernel_experiment(encoding=EncodingType.ANGLE, dataset="moons", T1=None, T2=None): + """ + Run quantum kernel model and return metrics. + + Args: + encoding: EncodingType.ANGLE or EncodingType.AMPLITUDE + dataset: 'real' or 'moons' + T1: T1 relaxation time (None for noiseless) + T2: T2 dephasing time (None for noiseless) + + Returns: + dict with metrics and configuration + """ + # Load dataset + if dataset == "real": + X_train, X_test, y_train, y_test = make_real_dataset(encoding=encoding) + elif dataset == "moons": + X_train, X_test, y_train, y_test = make_moons_dataset(encoding=encoding) + else: + raise ValueError(f"Unknown dataset: {dataset}") + + # Run batch kernel predictions with cached feature maps + scores = kernel_predict_batch(X_test, X_train, y_train, encoding, T1, T2) + + # Compute metrics + metrics = compute_metrics(scores, y_test) + + return { + 'model_type': 'kernel', + 'encoding': encoding.value, + 'dataset': dataset, + 'T1': T1 if T1 is not None else 'noiseless', + 'T2': T2 if T2 is not None else 'noiseless', + 'metrics': metrics + } + + +def run_kernel_noise_sweep(encoding=EncodingType.ANGLE, dataset="moons", + T1_values=None, T2_ratio=2.0): + """ + Run kernel model under varying noise levels. + + Args: + encoding: EncodingType.ANGLE or EncodingType.AMPLITUDE + dataset: 'real' or 'moons' + T1_values: List of T1 values to test (default: [25, 50, 100, 200, 500]) + T2_ratio: Ratio of T2 to T1 (default: 2.0, so T2 = 2*T1) + + Returns: + List of result dicts for each noise level + """ + if T1_values is None: + T1_values = [25, 50, 100, 200, 500] + + results = [] + + # First run noiseless + print(f" Running kernel (noiseless)...") + result = run_kernel_experiment(encoding, dataset, T1=None, T2=None) + results.append(result) + print(f" Accuracy: {result['metrics']['accuracy']:.4f}") + + # Then run with varying noise levels + for T1 in T1_values: + T2 = T1 * T2_ratio + print(f" Running kernel (T1={T1}, T2={T2})...") + result = run_kernel_experiment(encoding, dataset, T1=T1, T2=T2) + results.append(result) + print(f" Accuracy: {result['metrics']['accuracy']:.4f}") + + return results + + +def run_all_kernel_experiments(T1=None, T2=None, noise_sweep=False, T1_values=None): + """ + Run kernel model for all encoding/dataset combinations. + + Args: + T1: T1 relaxation time (None for noiseless) + T2: T2 dephasing time (None for noiseless) + noise_sweep: If True, run noise sweep instead of single T1/T2 + T1_values: List of T1 values for noise sweep + + Returns: + List of all result dictionaries + """ + data_dir = ensure_data_dir() + all_results = [] + timestamp = datetime.now().strftime("%d_%H%M") + + configurations = list(product(ENCODINGS, DATASETS)) + total_configs = len(configurations) + + print(f"\n{'='*60}") + print(f"Quantum Kernel Model Experiments") + print(f"{'='*60}") + if noise_sweep: + print(f"Mode: Noise sweep") + print(f"T1 values: {T1_values if T1_values else [25, 50, 100, 200, 500]} µs") + else: + print(f"Noise Parameters: T1={T1} µs, T2={T2} µs") + print(f"Total configurations: {total_configs}") + print(f"Output directory: {data_dir}") + print(f"{'='*60}\n") + + for idx, (encoding, dataset) in enumerate(configurations, start=1): + config_name = f"kernel_{encoding.value}_{dataset}" + print(f"\n[{idx}/{total_configs}] Running: {config_name}") + print("-" * 40) + + try: + if noise_sweep: + results = run_kernel_noise_sweep(encoding, dataset, T1_values) + all_results.extend(results) + else: + result = run_kernel_experiment(encoding, dataset, T1, T2) + all_results.append(result) + print(f" Accuracy: {result['metrics']['accuracy']:.4f}") + print(f" F1 Score: {result['metrics']['f1']:.4f}") + except Exception as e: + print(f" Error running {config_name}: {e}") + continue + + # Save results + if all_results: + if noise_sweep: + filename = f"kernel_noise_sweep_{timestamp}.csv" + else: + t1_str = f"t1{int(T1)}" if T1 is not None else "noiseless" + t2_str = f"_t2{int(T2)}" if T2 is not None else "" + filename = f"kernel_{t1_str}{t2_str}_{timestamp}.csv" + + filepath = os.path.join(data_dir, filename) + save_kernel_results_csv(all_results, filepath) + print(f"\n{'='*60}") + print(f"Results saved: {filename}") + print(f"Total successful runs: {len(all_results)}") + print(f"{'='*60}\n") + + return all_results + + +def save_noise_sweep_csv(results, filepath): + """ + Save unified noise sweep results (all models) to CSV. + + Columns: model, encoding, dataset, T1, T2, accuracy, f1, roc_auc + """ + with open(filepath, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerow(['model', 'encoding', 'dataset', 'T1', 'T2', 'accuracy', 'f1', 'roc_auc']) + for r in results: + writer.writerow([ + r['model_type'], + r['encoding'], + r['dataset'], + r['T1'], + r['T2'], + f"{r['accuracy']:.4f}", + f"{r['f1']:.4f}", + f"{r['roc_auc']:.4f}" + ]) + + +def run_unified_noise_sweep(epochs=25, dataset="moons", T1_values=None, T2_ratio=2.0): + """ + Run ALL models (VQC, QNN, Kernel) across varying T1 noise levels. + + This produces the data needed for the "Final Accuracy vs T1" comparison plot. + + Args: + epochs: Number of training epochs for VQC/QNN + dataset: Dataset to use ('real' or 'moons') + T1_values: List of T1 values in µs (default: [25, 50, 100, 200, 500]) + T2_ratio: Ratio of T2 to T1 (default: 2.0) + + Returns: + List of result dicts with unified format + """ + if T1_values is None: + T1_values = [25, 50, 100, 200, 500] + + data_dir = ensure_data_dir() + all_results = [] + timestamp = datetime.now().strftime("%d_%H%M") + + all_models = ["deep_vqc", "noise_aware", "kernel"] + all_encodings = [EncodingType.ANGLE, EncodingType.AMPLITUDE] + + total_runs = len(all_models) * len(all_encodings) * len(T1_values) + + print(f"\n{'='*60}") + print(f"Unified Noise Sweep Experiment") + print(f"{'='*60}") + print(f"Dataset: {dataset}") + print(f"Epochs: {epochs} (for trainable models)") + print(f"T1 values: {T1_values} µs") + print(f"T2 ratio: {T2_ratio} (T2 = T1 × {T2_ratio})") + print(f"Models: {all_models}") + print(f"Encodings: {[e.value for e in all_encodings]}") + print(f"Total runs: {total_runs}") + print(f"{'='*60}\n") + + run_count = 0 + for encoding in all_encodings: + for model_type in all_models: + for T1 in T1_values: + T2 = T1 * T2_ratio + run_count += 1 + + config_name = f"{model_type}_{encoding.value}_T1={T1}" + print(f"\n[{run_count}/{total_runs}] {config_name}") + print("-" * 40) + + try: + if model_type == "kernel": + # Kernel: batch prediction with cached feature maps (fast!) + result = run_kernel_experiment(encoding, dataset, T1, T2) + unified_result = { + 'model_type': 'kernel', + 'encoding': encoding.value, + 'dataset': dataset, + 'T1': T1, + 'T2': T2, + 'accuracy': result['metrics']['accuracy'], + 'f1': result['metrics']['f1'], + 'roc_auc': result['metrics']['roc_auc'], + 'epochs': 0 + } + else: + # Train VQC or QNN + metrics = train( + model_type=model_type, + encoding=encoding, + epochs=epochs, + dataset=dataset, + record_metrics=True, + T1=T1, + T2=T2 + ) + + if metrics is None: + print(f" Warning: No metrics returned") + continue + + unified_result = { + 'model_type': model_type, + 'encoding': encoding.value, + 'dataset': dataset, + 'T1': T1, + 'T2': T2, + 'accuracy': metrics['acc_history'][-1], + 'f1': metrics['final_metrics']['f1'], + 'roc_auc': metrics['final_metrics']['roc_auc'], + 'epochs': epochs + } + + all_results.append(unified_result) + print(f" T1={T1} µs, T2={T2} µs → Accuracy: {unified_result['accuracy']:.4f}") + + except Exception as e: + print(f" Error: {e}") + continue + + # Save results + if all_results: + filename = f"noise_sweep_{dataset}_ep{epochs}_{timestamp}.csv" + filepath = os.path.join(data_dir, filename) + save_noise_sweep_csv(all_results, filepath) + print(f"\n{'='*60}") + print(f"Noise sweep results saved: {filename}") + print(f"Total successful runs: {len(all_results)}/{total_runs}") + print(f"{'='*60}\n") + + return all_results + + def run_all_experiments(epochs=25, T1=DEFAULT_T1, T2=DEFAULT_T2): """ Run all training configurations and save results. @@ -203,7 +509,7 @@ def run_all_experiments(epochs=25, T1=DEFAULT_T1, T2=DEFAULT_T2): print(f"QML Experiment Runner") print(f"{'='*60}") print(f"Epochs: {epochs}") - print(f"Noise Parameters: T1={T1}, T2={T2}") + print(f"Noise Parameters: T1={T1} µs, T2={T2} µs") print(f"Total configurations: {total_configs}") print(f"Output directory: {data_dir}") print(f"{'='*60}\n") @@ -278,8 +584,8 @@ def main(): ) parser.add_argument( '--models', type=str, nargs='+', default=None, - choices=['deep_vqc', 'noise_aware'], - help='Specific models to run (default: all)' + choices=['deep_vqc', 'noise_aware', 'kernel'], + help='Specific models to run (default: all trainable models)' ) parser.add_argument( '--encodings', type=str, nargs='+', default=None, @@ -295,35 +601,121 @@ def main(): '--plot', action='store_true', help='Plot accuracy and loss comparison after training' ) + parser.add_argument( + '--kernel', action='store_true', + help='Run quantum kernel model experiments' + ) + parser.add_argument( + '--kernel-noise-sweep', action='store_true', + help='Run kernel model with varying noise levels' + ) + parser.add_argument( + '--kernel-noiseless', action='store_true', + help='Run kernel model without noise' + ) + parser.add_argument( + '--kernel-compare', action='store_true', + help='Plot kernel results comparison with other models' + ) + parser.add_argument( + '--noise-sweep', action='store_true', + help='Run unified noise sweep across all models (VQC, QNN, Kernel) with varying T1' + ) + parser.add_argument( + '--T1-values', type=float, nargs='+', default=None, + help='T1 values in µs for noise sweep (default: 25 50 100 200 500)' + ) + parser.add_argument( + '--T2-ratio', type=float, default=2.0, + help='T2/T1 ratio for noise sweep (default: 2.0)' + ) args = parser.parse_args() # Override global configs if specific options provided global MODEL_TYPES, ENCODINGS, DATASETS - if args.models: - MODEL_TYPES = args.models if args.encodings: ENCODINGS = [EncodingType.ANGLE if e == 'angle' else EncodingType.AMPLITUDE for e in args.encodings] if args.datasets: DATASETS = args.datasets - # Run experiments - results = run_all_experiments( - epochs=args.epochs, - T1=args.T1, - T2=args.T2 - ) + results = [] + kernel_results = [] + noise_sweep_results = [] - # Plot if requested (always save when --plot is used) - if args.plot and results: - datasets_to_plot = args.datasets if args.datasets else ['real', 'moons'] - for dataset in datasets_to_plot: - plot_from_results(results, dataset, - T1=args.T1, T2=args.T2, epochs=args.epochs, save=True) + # Handle unified noise sweep (highest priority - runs all models) + if args.noise_sweep: + datasets_to_run = args.datasets if args.datasets else ['moons', 'real'] + for dataset in datasets_to_run: + sweep_results = run_unified_noise_sweep( + epochs=args.epochs, + dataset=dataset, + T1_values=args.T1_values, + T2_ratio=args.T2_ratio + ) + noise_sweep_results.extend(sweep_results) + + # Plot noise sweep results + if args.plot and noise_sweep_results: + from visualizer import plot_accuracy_vs_t1 + for dataset in datasets_to_run: + dataset_results = [r for r in noise_sweep_results if r['dataset'] == dataset] + if dataset_results: + plot_accuracy_vs_t1(dataset_results, dataset, + epochs=args.epochs, save=True) + + return results, kernel_results, noise_sweep_results - return results + # Handle kernel-only runs + run_kernel_only = args.kernel or args.kernel_noise_sweep or args.kernel_noiseless + run_kernel_model = 'kernel' in (args.models or []) + + if run_kernel_model and args.models: + # Remove kernel from models list (handled separately) + args.models = [m for m in args.models if m != 'kernel'] + + if args.models: + MODEL_TYPES = args.models + + # Run kernel experiments if requested + if run_kernel_only or run_kernel_model: + if args.kernel_noise_sweep: + kernel_results = run_all_kernel_experiments(noise_sweep=True, T1_values=args.T1_values) + elif args.kernel_noiseless: + kernel_results = run_all_kernel_experiments(T1=None, T2=None) + else: + kernel_results = run_all_kernel_experiments(T1=args.T1, T2=args.T2) + + # Plot kernel comparison if requested + if args.kernel_compare or args.plot: + from visualizer import plot_kernel_comparison, plot_kernel_noise_sweep + datasets_to_plot = args.datasets if args.datasets else ['real', 'moons'] + for dataset in datasets_to_plot: + if args.kernel_noise_sweep: + plot_kernel_noise_sweep(kernel_results, dataset, save=True) + else: + plot_kernel_comparison(kernel_results, dataset, save=True, + T1=args.T1, T2=args.T2) + + # Run trainable model experiments (unless only kernel was requested) + if not run_kernel_only or (args.models and len(args.models) > 0): + if not run_kernel_only: # Only run if not kernel-only mode + results = run_all_experiments( + epochs=args.epochs, + T1=args.T1, + T2=args.T2 + ) + + # Plot if requested (always save when --plot is used) + if args.plot and results: + datasets_to_plot = args.datasets if args.datasets else ['real', 'moons'] + for dataset in datasets_to_plot: + plot_from_results(results, dataset, + T1=args.T1, T2=args.T2, epochs=args.epochs, save=True) + + return results, kernel_results, noise_sweep_results if __name__ == "__main__": diff --git a/tests/test_parallelization.py b/tests/test_parallelization.py new file mode 100644 index 0000000..f1db4d7 --- /dev/null +++ b/tests/test_parallelization.py @@ -0,0 +1,109 @@ +""" +Test suite for parallelization functionality in QML training. + +This module verifies that the parallel implementation produces correct results +and handles edge cases appropriately. +""" + +import unittest +import torch +from qml_training import train, EncodingType + + +class TestParallelTraining(unittest.TestCase): + """Test cases for parallel training implementation.""" + + def test_parallel_training_completes(self): + """Verify parallel training completes without errors.""" + torch.manual_seed(42) + result = train( + model_type="noise_aware", + encoding=EncodingType.ANGLE, + epochs=2, + dataset="moons", + record_metrics=True, + T1=100, + T2=200 + ) + + self.assertIsNotNone(result) + self.assertIn('final_metrics', result) + self.assertIn('loss_history', result) + self.assertIn('acc_history', result) + + def test_parallel_training_metrics_valid(self): + """Verify parallel training produces valid metrics.""" + torch.manual_seed(42) + result = train( + model_type="deep_vqc", + encoding=EncodingType.ANGLE, + epochs=2, + dataset="moons", + record_metrics=True, + T1=100, + T2=200 + ) + + # Check metrics are in valid range + final_acc = result['final_metrics']['accuracy'] + self.assertGreaterEqual(final_acc, 0.0) + self.assertLessEqual(final_acc, 1.0) + + # Check history lengths + self.assertEqual(len(result['loss_history']), 2) + self.assertEqual(len(result['acc_history']), 2) + + def test_parallel_training_different_seeds_differ(self): + """Verify different random seeds produce different results.""" + torch.manual_seed(42) + result1 = train( + model_type="noise_aware", + encoding=EncodingType.ANGLE, + epochs=1, + dataset="moons", + record_metrics=True, + T1=100, + T2=200 + ) + + torch.manual_seed(123) + result2 = train( + model_type="noise_aware", + encoding=EncodingType.ANGLE, + epochs=1, + dataset="moons", + record_metrics=True, + T1=100, + T2=200 + ) + + # Different seeds should produce different results + acc1 = result1['final_metrics']['accuracy'] + acc2 = result2['final_metrics']['accuracy'] + # Allow for same results but they should usually differ + # This is a weak test but validates randomness is working + self.assertIsInstance(acc1, float) + self.assertIsInstance(acc2, float) + + +class TestParallelKernelMethod(unittest.TestCase): + """Test cases for parallel kernel method implementation.""" + + def test_kernel_method_parallel(self): + """Verify kernel method works with parallelization.""" + result = train( + model_type="kernel", + encoding=EncodingType.ANGLE, + epochs=1, # epochs don't matter for kernel + dataset="moons", + record_metrics=False, + T1=100, + T2=200 + ) + + # Kernel method returns None but should complete without error + self.assertIsNone(result) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_run_experiments.py b/tests/test_run_experiments.py index e5db32b..606416c 100644 --- a/tests/test_run_experiments.py +++ b/tests/test_run_experiments.py @@ -21,6 +21,9 @@ save_training_history_csv, save_summary_csv, run_all_experiments, + run_unified_noise_sweep, + run_kernel_experiment, + save_noise_sweep_csv, MODEL_TYPES, DATASETS ) @@ -306,16 +309,21 @@ def test_csv_files_created(self): self.assertGreater(len(csv_files), 0) def test_history_csv_format(self): - """Verify history CSV files have correct format.""" + """Verify training history CSV files have correct format (epoch, loss, acc).""" data_dir = ensure_data_dir() + # Filter for training history CSVs: exclude noise_sweep, kernel, and summary files csv_files = [f for f in os.listdir(data_dir) - if f.endswith('.csv') and not f.startswith('summary')] + if f.endswith('.csv') + and not f.startswith('summary') + and 'noise_sweep' not in f + and 'kernel' not in f] if csv_files: filepath = os.path.join(data_dir, csv_files[0]) with open(filepath, 'r') as f: reader = csv.reader(f) headers = next(reader) + # Training history should have exactly: epoch, loss, acc self.assertEqual(headers, ['epoch', 'loss', 'acc']) @@ -323,14 +331,18 @@ class TestFileNamingConvention(unittest.TestCase): """Test that file naming follows the expected convention.""" def test_history_filename_format(self): - """Verify history filename contains expected components.""" + """Verify training history filename contains expected components.""" data_dir = ensure_data_dir() + # Filter for training history files: exclude noise_sweep, kernel, and summary csv_files = [f for f in os.listdir(data_dir) - if f.endswith('.csv') and not f.startswith('summary')] + if f.endswith('.csv') + and not f.startswith('summary') + and 'noise_sweep' not in f + and 'kernel' not in f] if csv_files: filename = csv_files[0] - # Should contain: model_dataset_t1{T1}_t2{T2}_ep{epochs}_{date}.csv + # Training history format: model_dataset_t1{T1}_t2{T2}_ep{epochs}_{date}.csv self.assertIn('_t1', filename) self.assertIn('_t2', filename) self.assertIn('_ep', filename) @@ -349,5 +361,120 @@ def test_summary_filename_format(self): self.assertIn('_ep', filename) +class TestNoiseSweep(unittest.TestCase): + """Test the unified noise sweep functionality.""" + + def setUp(self): + """Create a temporary directory for test files.""" + self.test_dir = tempfile.mkdtemp() + + def tearDown(self): + """Remove temporary directory.""" + shutil.rmtree(self.test_dir) + + def test_run_kernel_experiment_returns_metrics(self): + """Verify kernel experiment returns correct structure.""" + result = run_kernel_experiment( + encoding=EncodingType.ANGLE, + dataset="moons", + T1=100, + T2=200 + ) + + self.assertIsInstance(result, dict) + self.assertEqual(result['model_type'], 'kernel') + self.assertEqual(result['encoding'], 'angle') + self.assertEqual(result['dataset'], 'moons') + self.assertEqual(result['T1'], 100) + self.assertEqual(result['T2'], 200) + self.assertIn('metrics', result) + self.assertIn('accuracy', result['metrics']) + + def test_run_unified_noise_sweep_single_t1(self): + """Verify noise sweep runs with minimal configuration (1 epoch, 1 T1 value).""" + results = run_unified_noise_sweep( + epochs=1, + dataset="moons", + T1_values=[100], + T2_ratio=2.0 + ) + + self.assertIsInstance(results, list) + self.assertGreater(len(results), 0) + + # Should have results for all model/encoding combinations + # 3 models × 2 encodings × 1 T1 value = 6 results + self.assertEqual(len(results), 6) + + for r in results: + self.assertIn('model_type', r) + self.assertIn('encoding', r) + self.assertIn('accuracy', r) + self.assertIn('T1', r) + self.assertIn('T2', r) + + def test_save_noise_sweep_csv(self): + """Verify noise sweep CSV is saved correctly.""" + results = [ + {'model_type': 'deep_vqc', 'encoding': 'angle', 'dataset': 'moons', + 'T1': 100, 'T2': 200, 'accuracy': 0.85, 'f1': 0.82, 'roc_auc': 0.88}, + {'model_type': 'kernel', 'encoding': 'angle', 'dataset': 'moons', + 'T1': 100, 'T2': 200, 'accuracy': 0.75, 'f1': 0.72, 'roc_auc': 0.78} + ] + filepath = os.path.join(self.test_dir, "noise_sweep_test.csv") + + save_noise_sweep_csv(results, filepath) + + self.assertTrue(os.path.exists(filepath)) + + with open(filepath, 'r') as f: + reader = csv.DictReader(f) + rows = list(reader) + self.assertEqual(len(rows), 2) + self.assertEqual(rows[0]['model'], 'deep_vqc') + self.assertEqual(rows[1]['model'], 'kernel') + + +class TestNoiseSweepPlot(unittest.TestCase): + """Test that noise sweep generates a plot file.""" + + def setUp(self): + """Create plots directory.""" + self.plots_dir = os.path.join(os.path.dirname(__file__), '..', 'plots') + os.makedirs(self.plots_dir, exist_ok=True) + # Track initial plot files + self.initial_plots = set(os.listdir(self.plots_dir)) if os.path.exists(self.plots_dir) else set() + + def test_noise_sweep_generates_plot(self): + """Verify that running noise sweep with --plot creates a plot file. + + This is a minimal integration test using 1 epoch and 1 T1 value. + """ + from visualizer import plot_accuracy_vs_t1 + + # Run minimal noise sweep + results = run_unified_noise_sweep( + epochs=1, + dataset="moons", + T1_values=[100], + T2_ratio=2.0 + ) + + # Generate plot + import matplotlib + matplotlib.use('Agg') # Non-interactive backend for testing + + filepath = plot_accuracy_vs_t1(results, "moons", epochs=1, save=True) + + # Verify plot was created + self.assertIsNotNone(filepath) + self.assertTrue(os.path.exists(filepath)) + self.assertTrue(filepath.endswith('.png')) + + # Clean up test plot + if filepath and os.path.exists(filepath): + os.remove(filepath) + + if __name__ == '__main__': unittest.main(verbosity=2) diff --git a/visualizer.py b/visualizer.py index 96a736c..0180eac 100644 --- a/visualizer.py +++ b/visualizer.py @@ -176,6 +176,408 @@ def plot_model_comparison(data_dict, dataset_name="", title=None, plt.show() +def plot_kernel_comparison(kernel_results, dataset_name, save=False, T1=None, T2=None): + """ + Plot kernel model performance comparison across encodings. + + Args: + kernel_results: List of kernel result dicts + dataset_name: Dataset to filter for + save: If True, save plot to plots/ directory + T1: T1 noise parameter (for filename) + T2: T2 noise parameter (for filename) + """ + # Filter results for this dataset + filtered = [r for r in kernel_results if r['dataset'] == dataset_name] + + if not filtered: + print(f"No kernel results found for dataset: {dataset_name}") + return + + # Group by encoding + encodings = [] + accuracies = [] + f1_scores = [] + labels = [] + + for r in filtered: + enc = r['encoding'] + noise_label = f"T1={r['T1']}" if r['T1'] != 'noiseless' else "Noiseless" + labels.append(f"{enc.capitalize()}\n({noise_label})") + accuracies.append(r['metrics']['accuracy']) + f1_scores.append(r['metrics']['f1']) + + x = np.arange(len(labels)) + width = 0.35 + + fig, ax = plt.subplots(figsize=(10, 6)) + bars1 = ax.bar(x - width/2, accuracies, width, label='Accuracy', color='#1f77b4') + bars2 = ax.bar(x + width/2, f1_scores, width, label='F1 Score', color='#ff7f0e') + + ax.set_ylabel('Score') + ax.set_title(f'{dataset_name.capitalize()} Dataset - Quantum Kernel Model Performance') + ax.set_xticks(x) + ax.set_xticklabels(labels) + ax.legend() + ax.set_ylim(0, 1.1) + ax.grid(True, alpha=0.3, axis='y') + + # Add value labels on bars + for bar in bars1: + height = bar.get_height() + ax.annotate(f'{height:.3f}', + xy=(bar.get_x() + bar.get_width() / 2, height), + xytext=(0, 3), textcoords="offset points", + ha='center', va='bottom', fontsize=8) + for bar in bars2: + height = bar.get_height() + ax.annotate(f'{height:.3f}', + xy=(bar.get_x() + bar.get_width() / 2, height), + xytext=(0, 3), textcoords="offset points", + ha='center', va='bottom', fontsize=8) + + plt.tight_layout() + + if save: + plots_dir = ensure_plots_dir() + timestamp = datetime.now().strftime("%d_%H%M") + t1_str = f"_t1{int(T1)}" if T1 is not None else "_noiseless" + t2_str = f"_t2{int(T2)}" if T2 is not None else "" + filename = f"kernel_{dataset_name}{t1_str}{t2_str}_{timestamp}.png" + filepath = os.path.join(plots_dir, filename) + plt.savefig(filepath, dpi=150, bbox_inches='tight') + print(f" Kernel plot saved: {filename}") + + plt.show() + + +def plot_kernel_noise_sweep(kernel_results, dataset_name, save=False): + """ + Plot kernel accuracy vs noise level (T1 values). + + Args: + kernel_results: List of kernel result dicts from noise sweep + dataset_name: Dataset to filter for + save: If True, save plot to plots/ directory + """ + # Filter results for this dataset + filtered = [r for r in kernel_results if r['dataset'] == dataset_name] + + if not filtered: + print(f"No kernel results found for dataset: {dataset_name}") + return + + # Separate by encoding + angle_results = [r for r in filtered if r['encoding'] == 'angle'] + amp_results = [r for r in filtered if r['encoding'] == 'amplitude'] + + fig, axes = plt.subplots(1, 2, figsize=(14, 5)) + + for ax, enc_results, enc_name in [(axes[0], angle_results, 'Angle'), + (axes[1], amp_results, 'Amplitude')]: + if not enc_results: + ax.set_title(f'{enc_name} Encoding - No Data') + continue + + # Sort by T1 (put noiseless first) + t1_values = [] + accuracies = [] + f1_scores = [] + + for r in sorted(enc_results, key=lambda x: float('inf') if x['T1'] == 'noiseless' else x['T1']): + t1_label = 'Noiseless' if r['T1'] == 'noiseless' else f"{r['T1']}" + t1_values.append(t1_label) + accuracies.append(r['metrics']['accuracy']) + f1_scores.append(r['metrics']['f1']) + + x = np.arange(len(t1_values)) + width = 0.35 + + bars1 = ax.bar(x - width/2, accuracies, width, label='Accuracy', color='#2ca02c') + bars2 = ax.bar(x + width/2, f1_scores, width, label='F1 Score', color='#d62728') + + ax.set_xlabel('T1 (μs)') + ax.set_ylabel('Score') + ax.set_title(f'{dataset_name.capitalize()} - Kernel {enc_name} Encoding') + ax.set_xticks(x) + ax.set_xticklabels(t1_values) + ax.legend() + ax.set_ylim(0, 1.1) + ax.grid(True, alpha=0.3, axis='y') + + # Add value labels + for bar in bars1: + height = bar.get_height() + ax.annotate(f'{height:.2f}', + xy=(bar.get_x() + bar.get_width() / 2, height), + xytext=(0, 3), textcoords="offset points", + ha='center', va='bottom', fontsize=7) + + plt.tight_layout() + + if save: + plots_dir = ensure_plots_dir() + timestamp = datetime.now().strftime("%d_%H%M") + filename = f"kernel_noise_sweep_{dataset_name}_{timestamp}.png" + filepath = os.path.join(plots_dir, filename) + plt.savefig(filepath, dpi=150, bbox_inches='tight') + print(f" Kernel noise sweep plot saved: {filename}") + + plt.show() + + +def plot_all_models_comparison(training_results, kernel_results, dataset_name, + save=False, T1=None, T2=None, epochs=None): + """ + Plot comparison of all models (VQC, QNN, Kernel) on same chart. + + Args: + training_results: List of training result dicts (VQC, QNN) + kernel_results: List of kernel result dicts + dataset_name: Dataset to filter for + save: If True, save plot + """ + # Get final accuracies from training results + model_scores = {} + + for r in training_results: + if r['dataset'] != dataset_name: + continue + model = r['model_type'] + encoding = r['encoding'] + label = f"{'VQC' if model == 'deep_vqc' else 'QNN'} {encoding.capitalize()}" + model_scores[label] = { + 'accuracy': r['acc_history'][-1], + 'f1': r['final_metrics']['f1'] + } + + # Add kernel results + for r in kernel_results: + if r['dataset'] != dataset_name: + continue + label = f"Kernel {r['encoding'].capitalize()}" + model_scores[label] = { + 'accuracy': r['metrics']['accuracy'], + 'f1': r['metrics']['f1'] + } + + if not model_scores: + print(f"No results found for dataset: {dataset_name}") + return + + labels = list(model_scores.keys()) + accuracies = [model_scores[l]['accuracy'] for l in labels] + f1_scores = [model_scores[l]['f1'] for l in labels] + + x = np.arange(len(labels)) + width = 0.35 + + fig, ax = plt.subplots(figsize=(12, 6)) + + colors_acc = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b'] + colors_f1 = ['#aec7e8', '#ffbb78', '#98df8a', '#ff9896', '#c5b0d5', '#c49c94'] + + bars1 = ax.bar(x - width/2, accuracies, width, label='Accuracy', color=colors_acc[:len(labels)]) + bars2 = ax.bar(x + width/2, f1_scores, width, label='F1 Score', color=colors_f1[:len(labels)]) + + ax.set_ylabel('Score') + ax.set_title(f'{dataset_name.capitalize()} Dataset - All Models Comparison') + ax.set_xticks(x) + ax.set_xticklabels(labels, rotation=15, ha='right') + ax.legend() + ax.set_ylim(0, 1.15) + ax.grid(True, alpha=0.3, axis='y') + + # Add value labels + for bar in bars1: + height = bar.get_height() + ax.annotate(f'{height:.3f}', + xy=(bar.get_x() + bar.get_width() / 2, height), + xytext=(0, 3), textcoords="offset points", + ha='center', va='bottom', fontsize=8) + + plt.tight_layout() + + if save: + plots_dir = ensure_plots_dir() + timestamp = datetime.now().strftime("%d_%H%M") + t1_str = f"_t1{int(T1)}" if T1 is not None else "" + t2_str = f"_t2{int(T2)}" if T2 is not None else "" + ep_str = f"_ep{epochs}" if epochs is not None else "" + filename = f"all_models_{dataset_name}{t1_str}{t2_str}{ep_str}_{timestamp}.png" + filepath = os.path.join(plots_dir, filename) + plt.savefig(filepath, dpi=150, bbox_inches='tight') + print(f" All models comparison plot saved: {filename}") + + plt.show() + + +def plot_accuracy_vs_t1(noise_sweep_results, dataset_name, epochs=None, save=False): + """ + Plot Final Accuracy vs T1 for all models and encodings. + + This is the main comparison plot showing how each model/encoding combination + performs under varying noise levels (T1 relaxation time). + + Args: + noise_sweep_results: List of result dicts from run_unified_noise_sweep + Each dict has: model_type, encoding, dataset, T1, T2, accuracy, f1, roc_auc + dataset_name: Dataset to filter for + epochs: Number of epochs used (for title/filename) + save: If True, save plot to plots/ directory + + Returns: + filepath if saved, None otherwise + """ + # Filter results for this dataset + filtered = [r for r in noise_sweep_results if r['dataset'] == dataset_name] + + if not filtered: + print(f"No noise sweep results found for dataset: {dataset_name}") + return None + + # Get unique T1 values and sort them + t1_values = sorted(set(r['T1'] for r in filtered)) + + # Define model/encoding combinations and their display properties + configurations = [ + ('deep_vqc', 'angle', 'VQC Angle', '#1f77b4', 'o', '-'), + ('deep_vqc', 'amplitude', 'VQC Amplitude', '#ff7f0e', 's', '-'), + ('noise_aware', 'angle', 'QNN Angle', '#2ca02c', '^', '-'), + ('noise_aware', 'amplitude', 'QNN Amplitude', '#d62728', 'd', '-'), + ('kernel', 'angle', 'Kernel Angle', '#9467bd', 'v', '--'), + ('kernel', 'amplitude', 'Kernel Amplitude', '#8c564b', 'p', '--'), + ] + + fig, ax = plt.subplots(figsize=(12, 7)) + + for model_type, encoding, label, color, marker, linestyle in configurations: + # Get accuracies for this configuration at each T1 + config_results = [r for r in filtered + if r['model_type'] == model_type and r['encoding'] == encoding] + + if not config_results: + continue + + # Sort by T1 and extract values + config_results.sort(key=lambda x: x['T1']) + x_vals = [r['T1'] for r in config_results] + y_vals = [r['accuracy'] for r in config_results] + + ax.plot(x_vals, y_vals, label=label, color=color, marker=marker, + linestyle=linestyle, linewidth=2, markersize=8) + + # Formatting + ax.set_xlabel('T1 Relaxation Time (μs)', fontsize=12) + ax.set_ylabel('Final Accuracy', fontsize=12) + + epoch_str = f" ({epochs} epochs)" if epochs else "" + ax.set_title(f'{dataset_name.capitalize()} Dataset - Accuracy vs Noise Level{epoch_str}', + fontsize=14) + + ax.legend(loc='best', fontsize=10) + ax.grid(True, alpha=0.3) + ax.set_ylim(0, 1.05) + + # Use log scale for x-axis if range is large + if len(t1_values) > 1 and max(t1_values) / min(t1_values) > 10: + ax.set_xscale('log') + ax.set_xlabel('T1 Relaxation Time (μs, log scale)', fontsize=12) + + plt.tight_layout() + + filepath = None + if save: + plots_dir = ensure_plots_dir() + timestamp = datetime.now().strftime("%d_%H%M") + ep_str = f"_ep{epochs}" if epochs else "" + filename = f"accuracy_vs_t1_{dataset_name}{ep_str}_{timestamp}.png" + filepath = os.path.join(plots_dir, filename) + plt.savefig(filepath, dpi=150, bbox_inches='tight') + print(f" Accuracy vs T1 plot saved: {filename}") + + plt.show() + return filepath + + +def plot_accuracy_vs_t1_dual(noise_sweep_results, epochs=None, save=False): + """ + Plot Final Accuracy vs T1 for both datasets side by side. + + Args: + noise_sweep_results: List of result dicts from run_unified_noise_sweep + epochs: Number of epochs used (for title/filename) + save: If True, save plot to plots/ directory + + Returns: + filepath if saved, None otherwise + """ + datasets = ['moons', 'real'] + + # Define model/encoding combinations and their display properties + configurations = [ + ('deep_vqc', 'angle', 'VQC Angle', '#1f77b4', 'o', '-'), + ('deep_vqc', 'amplitude', 'VQC Amp', '#ff7f0e', 's', '-'), + ('noise_aware', 'angle', 'QNN Angle', '#2ca02c', '^', '-'), + ('noise_aware', 'amplitude', 'QNN Amp', '#d62728', 'd', '-'), + ('kernel', 'angle', 'Kernel Angle', '#9467bd', 'v', '--'), + ('kernel', 'amplitude', 'Kernel Amp', '#8c564b', 'p', '--'), + ] + + fig, axes = plt.subplots(1, 2, figsize=(16, 6)) + + for ax, dataset_name in zip(axes, datasets): + filtered = [r for r in noise_sweep_results if r['dataset'] == dataset_name] + + if not filtered: + ax.set_title(f'{dataset_name.capitalize()} - No Data') + continue + + t1_values = sorted(set(r['T1'] for r in filtered)) + + for model_type, encoding, label, color, marker, linestyle in configurations: + config_results = [r for r in filtered + if r['model_type'] == model_type and r['encoding'] == encoding] + + if not config_results: + continue + + config_results.sort(key=lambda x: x['T1']) + x_vals = [r['T1'] for r in config_results] + y_vals = [r['accuracy'] for r in config_results] + + ax.plot(x_vals, y_vals, label=label, color=color, marker=marker, + linestyle=linestyle, linewidth=2, markersize=7) + + ax.set_xlabel('T1 (μs)', fontsize=11) + ax.set_ylabel('Final Accuracy', fontsize=11) + ax.set_title(f'{dataset_name.capitalize()} Dataset', fontsize=12) + ax.legend(loc='best', fontsize=9) + ax.grid(True, alpha=0.3) + ax.set_ylim(0, 1.05) + + if len(t1_values) > 1 and max(t1_values) / min(t1_values) > 10: + ax.set_xscale('log') + + epoch_str = f" ({epochs} epochs)" if epochs else "" + fig.suptitle(f'Model Performance vs Noise Level{epoch_str}', fontsize=14, y=1.02) + + plt.tight_layout() + + filepath = None + if save: + plots_dir = ensure_plots_dir() + timestamp = datetime.now().strftime("%d_%H%M") + ep_str = f"_ep{epochs}" if epochs else "" + filename = f"accuracy_vs_t1_comparison{ep_str}_{timestamp}.png" + filepath = os.path.join(plots_dir, filename) + plt.savefig(filepath, dpi=150, bbox_inches='tight') + print(f" Dual dataset accuracy vs T1 plot saved: {filename}") + + plt.show() + return filepath + + def plot_measurement_comparison(normal_counts, kraus_counts, title="Measurement comparison"): # All bitstrings that appear in either result all_bits = sorted(set(normal_counts.keys()) | set(kraus_counts.keys())) From 73fe77a7270a4b11a3b3badca2dfe11e740dd4a7 Mon Sep 17 00:00:00 2001 From: xoth42 Date: Sat, 20 Dec 2025 11:59:24 -0500 Subject: [PATCH 2/4] Plot management for per-epoch runs, env setups, plot old data script --- README.md | 33 +++++++++++- plot_existing_history.py | 107 +++++++++++++++++++++++++++++++++++++++ pyproject.toml | 2 +- run_experiments.py | 52 +++++++++++++++++-- visualizer.py | 94 ++++++++++++++++++++++++++++++++++ 5 files changed, 282 insertions(+), 6 deletions(-) create mode 100644 plot_existing_history.py diff --git a/README.md b/README.md index 38f2827..0749862 100644 --- a/README.md +++ b/README.md @@ -109,6 +109,22 @@ This generates a plot with **T1 (μs) on x-axis** and **Final Accuracy on y-axis - QNN Angle, QNN Amplitude - Kernel Angle, Kernel Amplitude +### Accuracy vs Epoch (Per-Model Lines) + +When running noise sweeps with `--plot`, the runner also saves per-epoch accuracy histories and generates accuracy-vs-epoch plots (kernel appears as a flat dashed line): + +```bash +# Generate sweep + per-epoch history and plots +python run_experiments.py --noise-sweep --epochs 100 --T1-values 50 100 200 --plot + +# Plot from a saved history CSV later (optional) +python plot_existing_history.py --history-file data/noise_sweep_moons_ep100__history.csv --dataset moons --save +``` + +Artifacts: +- Data: `data/noise_sweep__ep__history.csv` (columns: model, encoding, T1, epoch, accuracy) +- Plots: saved under `plots/` with filenames like `accuracy_vs_epoch__ep_t1_.png` + ## CLI Arguments | Arg | Default | Options | Description | @@ -143,4 +159,19 @@ This generates a plot with **T1 (μs) on x-axis** and **Final Accuracy on y-axis pip install -e . ``` -Requires Python ≥3.8, PyTorch ≥2.0, NumPy, Matplotlib, scikit-learn. +Requires Python 3.11, PyTorch ≥2.0, NumPy, Matplotlib, scikit-learn. + +## Environment Setup + +Use `uv` to create a local 3.11 environment (reads `pyproject.toml`): + +```bash +uv sync +source .venv/bin/activate +``` + +Or run without activating: + +```bash +uv run python run_experiments.py --help +``` diff --git a/plot_existing_history.py b/plot_existing_history.py new file mode 100644 index 0000000..4c93021 --- /dev/null +++ b/plot_existing_history.py @@ -0,0 +1,107 @@ +#!/usr/bin/env python3 +""" +Load and plot per-epoch accuracy history from existing noise sweep data. + +Since the existing noise_sweep_moons_ep100_20_0400.csv only has final accuracies, +this script shows you how to regenerate the data with history tracking, or plot +from the new history CSV files when they become available. + +Usage: + python plot_existing_history.py --history-file data/noise_sweep_moons_ep100_20_0400_history.csv +""" + +import argparse +import csv +import os +from visualizer import plot_accuracy_vs_epoch + + +def load_history_from_csv(filepath): + """ + Load per-epoch history from CSV file. + + Expected format: model, encoding, T1, epoch, accuracy + + Returns: + List of result dicts with 'acc_history' populated + """ + # Group by (model, encoding, T1) + grouped_data = {} + + with open(filepath, 'r') as f: + reader = csv.DictReader(f) + for row in reader: + key = (row['model'], row['encoding'], float(row['T1'])) + + if key not in grouped_data: + grouped_data[key] = { + 'model_type': row['model'], + 'encoding': row['encoding'], + 'T1': float(row['T1']), + 'acc_history': [] + } + + grouped_data[key]['acc_history'].append(float(row['accuracy'])) + + return list(grouped_data.values()) + + +def main(): + parser = argparse.ArgumentParser( + description='Plot accuracy vs epoch from history CSV file' + ) + parser.add_argument( + '--history-file', + type=str, + help='Path to history CSV file (e.g., data/noise_sweep_moons_ep100_20_0400_history.csv)' + ) + parser.add_argument( + '--dataset', + type=str, + default='moons', + help='Dataset name for plot title (default: moons)' + ) + parser.add_argument( + '--T1-filter', + type=float, + default=None, + help='Filter by specific T1 value (optional)' + ) + parser.add_argument( + '--save', + action='store_true', + help='Save plot to file' + ) + + args = parser.parse_args() + + if not args.history_file: + print("Error: --history-file is required") + print("\nTo generate history data, re-run your experiment:") + print(" python run_experiments.py --noise-sweep --epochs 100 --T1-values 50 100 200 --plot") + print("\nThis will create a *_history.csv file with per-epoch accuracy data.") + return + + if not os.path.exists(args.history_file): + print(f"Error: File not found: {args.history_file}") + return + + print(f"Loading history from: {args.history_file}") + results = load_history_from_csv(args.history_file) + print(f"Loaded {len(results)} model configurations") + + # Infer epochs from data + epochs = max(len(r['acc_history']) for r in results) if results else 0 + + # Create plot + plot_accuracy_vs_epoch( + results, + args.dataset, + epochs, + save=args.save, + T1_filter=args.T1_filter + ) + + +if __name__ == '__main__': + main() diff --git a/pyproject.toml b/pyproject.toml index 361062a..bbc8dcf 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta" name = "compsci648-qml" version = "0.1.0" description = "Quantum Machine Learning Project for COMPSCI648" -requires-python = ">=3.8" +requires-python = ">=3.11,<3.12" dependencies = [ "torch>=2.0.0,<2.3.0", "numpy>=1.24.0,<2.0.0", diff --git a/run_experiments.py b/run_experiments.py index 39ea76d..3e60643 100644 --- a/run_experiments.py +++ b/run_experiments.py @@ -370,6 +370,30 @@ def save_noise_sweep_csv(results, filepath): ]) +def save_per_epoch_history_csv(results, filepath): + """ + Save per-epoch accuracy history for all models. + + Creates a CSV with columns: model, encoding, T1, epoch, accuracy + This format is ideal for plotting accuracy vs epoch with multiple models. + """ + with open(filepath, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerow(['model', 'encoding', 'T1', 'epoch', 'accuracy']) + + for r in results: + if 'acc_history' in r: + model_label = f"{r['model_type']}_{r['encoding']}" + for epoch_idx, acc in enumerate(r['acc_history']): + writer.writerow([ + r['model_type'], + r['encoding'], + r['T1'], + epoch_idx + 1, # 1-indexed epochs + f"{acc:.4f}" + ]) + + def run_unified_noise_sweep(epochs=25, dataset="moons", T1_values=None, T2_ratio=2.0): """ Run ALL models (VQC, QNN, Kernel) across varying T1 noise levels. @@ -424,16 +448,19 @@ def run_unified_noise_sweep(epochs=25, dataset="moons", T1_values=None, T2_ratio if model_type == "kernel": # Kernel: batch prediction with cached feature maps (fast!) result = run_kernel_experiment(encoding, dataset, T1, T2) + kernel_acc = result['metrics']['accuracy'] unified_result = { 'model_type': 'kernel', 'encoding': encoding.value, 'dataset': dataset, 'T1': T1, 'T2': T2, - 'accuracy': result['metrics']['accuracy'], + 'accuracy': kernel_acc, 'f1': result['metrics']['f1'], 'roc_auc': result['metrics']['roc_auc'], - 'epochs': 0 + 'epochs': 0, + 'acc_history': [kernel_acc] * epochs, # Flat line for kernel + 'loss_history': [0.0] * epochs # No loss for kernel } else: # Train VQC or QNN @@ -460,7 +487,9 @@ def run_unified_noise_sweep(epochs=25, dataset="moons", T1_values=None, T2_ratio 'accuracy': metrics['acc_history'][-1], 'f1': metrics['final_metrics']['f1'], 'roc_auc': metrics['final_metrics']['roc_auc'], - 'epochs': epochs + 'epochs': epochs, + 'acc_history': metrics['acc_history'], # Save per-epoch accuracy + 'loss_history': metrics['loss_history'] # Save per-epoch loss } all_results.append(unified_result) @@ -472,11 +501,19 @@ def run_unified_noise_sweep(epochs=25, dataset="moons", T1_values=None, T2_ratio # Save results if all_results: + # Save summary CSV filename = f"noise_sweep_{dataset}_ep{epochs}_{timestamp}.csv" filepath = os.path.join(data_dir, filename) save_noise_sweep_csv(all_results, filepath) + + # Save per-epoch history CSV + history_filename = f"noise_sweep_{dataset}_ep{epochs}_{timestamp}_history.csv" + history_filepath = os.path.join(data_dir, history_filename) + save_per_epoch_history_csv(all_results, history_filepath) + print(f"\n{'='*60}") print(f"Noise sweep results saved: {filename}") + print(f"Per-epoch history saved: {history_filename}") print(f"Total successful runs: {len(all_results)}/{total_runs}") print(f"{'='*60}\n") @@ -659,12 +696,19 @@ def main(): # Plot noise sweep results if args.plot and noise_sweep_results: - from visualizer import plot_accuracy_vs_t1 + from visualizer import plot_accuracy_vs_t1, plot_accuracy_vs_epoch for dataset in datasets_to_run: dataset_results = [r for r in noise_sweep_results if r['dataset'] == dataset] if dataset_results: + # Plot final accuracy vs T1 plot_accuracy_vs_t1(dataset_results, dataset, epochs=args.epochs, save=True) + + # Plot accuracy vs epoch for each T1 value + T1_values = sorted(set(r['T1'] for r in dataset_results)) + for T1 in T1_values: + plot_accuracy_vs_epoch(dataset_results, dataset, + epochs=args.epochs, save=True, T1_filter=T1) return results, kernel_results, noise_sweep_results diff --git a/visualizer.py b/visualizer.py index 0180eac..2d54698 100644 --- a/visualizer.py +++ b/visualizer.py @@ -604,6 +604,100 @@ def plot_measurement_comparison(normal_counts, kraus_counts, title="Measurement plt.tight_layout() plt.show() + +def plot_accuracy_vs_epoch(results, dataset, epochs, save=False, T1_filter=None): + """ + Plot accuracy vs epoch for all models (including flat lines for kernel models). + + Args: + results: List of result dicts from run_unified_noise_sweep with 'acc_history' + dataset: Dataset name for title + epochs: Number of epochs + save: If True, save plot to file + T1_filter: Optional T1 value to filter results (plot only specific T1) + + Returns: + Filepath if save=True, else None + """ + if not results: + print(f"No noise sweep results found for dataset: {dataset}") + return None + + # Filter by T1 if specified + if T1_filter is not None: + results = [r for r in results if r.get('T1') == T1_filter] + if not results: + print(f"No results found for T1={T1_filter}") + return None + + plt.figure(figsize=(12, 7)) + + # Color and style mapping + model_colors = { + 'deep_vqc': {'angle': 'blue', 'amplitude': 'dodgerblue'}, + 'noise_aware': {'angle': 'red', 'amplitude': 'salmon'}, + 'kernel': {'angle': 'green', 'amplitude': 'limegreen'} + } + + model_names = { + 'deep_vqc': 'Deep VQC', + 'noise_aware': 'Noise-Aware QNN', + 'kernel': 'Quantum Kernel' + } + + # Plot each model's accuracy history + for result in results: + if 'acc_history' not in result: + continue + + model_type = result['model_type'] + encoding = result['encoding'] + T1 = result.get('T1', 'N/A') + + acc_history = result['acc_history'] + epoch_range = range(1, len(acc_history) + 1) + + # Create label + label = f"{model_names.get(model_type, model_type)} ({encoding})" + if T1_filter is None: + label += f" T1={T1}" + + # Get color + color = model_colors.get(model_type, {}).get(encoding, 'gray') + + # Line style (solid for trainable, dashed for kernel) + linestyle = '--' if model_type == 'kernel' else '-' + linewidth = 2 if model_type == 'kernel' else 1.5 + + plt.plot(epoch_range, acc_history, label=label, color=color, + linestyle=linestyle, linewidth=linewidth, marker='o', markersize=3, alpha=0.8) + + plt.xlabel("Epoch", fontsize=12) + plt.ylabel("Test Accuracy", fontsize=12) + + title = f"Model Accuracy vs Epoch - {dataset.capitalize()} Dataset" + if T1_filter is not None: + title += f" (T1={T1_filter} µs)" + plt.title(title, fontsize=14, fontweight='bold') + + plt.legend(loc='best', fontsize=9, framealpha=0.9) + plt.grid(True, alpha=0.3) + plt.tight_layout() + + if save: + plots_dir = ensure_plots_dir() + timestamp = datetime.now().strftime("%d_%H%M") + t1_suffix = f"_t1{T1_filter}" if T1_filter else "_all_t1" + filename = f"accuracy_vs_epoch_{dataset}_ep{epochs}{t1_suffix}_{timestamp}.png" + filepath = os.path.join(plots_dir, filename) + plt.savefig(filepath, dpi=300, bbox_inches='tight') + print(f"Plot saved: {filepath}") + return filepath + else: + plt.show() + return None + + # # Example usage with your sample (pretend it's from one of the simulators) # normal_counts = {'00011': 33, '11010': 57, '11101': 73, '01101': 19, '11111': 108, # '10010': 84, '10100': 22, '10111': 56, '11001': 33, '01000': 34, From 546fa75ef6365c6b0c78cc2c765d5d3b0dff683f Mon Sep 17 00:00:00 2001 From: xoth42 Date: Sat, 20 Dec 2025 15:37:16 -0500 Subject: [PATCH 3/4] fallback to build_full_unitary density gate applicaiton, improve demo notebook, bug fixes --- demos/circuit_visualization.ipynb | 780 ++++++++++++++++++++++-------- error_kraus.py | 27 +- quantum_simulator.py | 96 ++-- tests/test_quantum_simulator.py | 86 ++++ visualizer.py | 23 +- 5 files changed, 751 insertions(+), 261 deletions(-) diff --git a/demos/circuit_visualization.ipynb b/demos/circuit_visualization.ipynb index d93483e..ca2f340 100644 --- a/demos/circuit_visualization.ipynb +++ b/demos/circuit_visualization.ipynb @@ -11,7 +11,22 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, + "id": "757f849c-268c-4ee4-8f6f-6abe39da656a", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, '..')\n", + "\n", + "# Minimal noise-aware run + plot\n", + "from qml_training import train, EncodingType\n", + "from visualizer import plot_training_curves\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, "id": "51311e81", "metadata": {}, "outputs": [ @@ -19,21 +34,27 @@ "name": "stdout", "output_type": "stream", "text": [ - "MOONS | NOISE_AWARE | Epoch 01 | Loss 1.2864 | Acc 0.507\n", - "MOONS | NOISE_AWARE | Epoch 02 | Loss 1.1830 | Acc 0.533\n", - "MOONS | NOISE_AWARE | Epoch 03 | Loss 1.0872 | Acc 0.547\n", - "MOONS | NOISE_AWARE | Epoch 04 | Loss 1.0001 | Acc 0.573\n", - "MOONS | NOISE_AWARE | Epoch 05 | Loss 0.9226 | Acc 0.600\n", - "MOONS | NOISE_AWARE | Epoch 06 | Loss 0.8547 | Acc 0.653\n", - "MOONS | NOISE_AWARE | Epoch 07 | Loss 0.7960 | Acc 0.693\n", - "MOONS | NOISE_AWARE | Epoch 08 | Loss 0.7459 | Acc 0.740\n", - "MOONS | NOISE_AWARE | Epoch 09 | Loss 0.7037 | Acc 0.760\n", - "MOONS | NOISE_AWARE | Epoch 10 | Loss 0.6684 | Acc 0.773\n" + "MOONS | NOISE_AWARE | Epoch 01 | Loss 1.3874 | Acc 0.520\n", + "MOONS | NOISE_AWARE | Epoch 02 | Loss 1.3634 | Acc 0.527\n", + "MOONS | NOISE_AWARE | Epoch 03 | Loss 1.3407 | Acc 0.527\n", + "MOONS | NOISE_AWARE | Epoch 04 | Loss 1.3194 | Acc 0.527\n", + "MOONS | NOISE_AWARE | Epoch 05 | Loss 1.2995 | Acc 0.520\n", + "MOONS | NOISE_AWARE | Epoch 06 | Loss 1.2810 | Acc 0.547\n", + "MOONS | NOISE_AWARE | Epoch 07 | Loss 1.2640 | Acc 0.540\n", + "MOONS | NOISE_AWARE | Epoch 08 | Loss 1.2483 | Acc 0.520\n", + "MOONS | NOISE_AWARE | Epoch 09 | Loss 1.2341 | Acc 0.520\n", + "MOONS | NOISE_AWARE | Epoch 10 | Loss 1.2212 | Acc 0.527\n", + "MOONS | NOISE_AWARE | Epoch 11 | Loss 1.2095 | Acc 0.547\n", + "MOONS | NOISE_AWARE | Epoch 12 | Loss 1.1990 | Acc 0.547\n", + "MOONS | NOISE_AWARE | Epoch 13 | Loss 1.1895 | Acc 0.560\n", + "MOONS | NOISE_AWARE | Epoch 14 | Loss 1.1810 | Acc 0.567\n", + "MOONS | NOISE_AWARE | Epoch 15 | Loss 1.1734 | Acc 0.567\n", + " Plot saved: noise_aware_moons_t1200_t2250_eprange(1, 16)_20_1347.png\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -43,22 +64,21 @@ } ], "source": [ - "import sys\n", - "sys.path.insert(0, '..')\n", + "epochs = 15\n", "\n", - "# Minimal noise-aware run + plot\n", - "from qml_training import train, EncodingType\n", - "from visualizer import plot_training_curves\n", + "# microseconds\n", + "T1=200.0\n", + "T2=250.0\n", "\n", - "# Small demo run (moons, 10 epochs) with T1/T2 noise\n", + "# Small demo run, moons, with T1/T2 noise\n", "metrics = train(\n", " model_type=\"noise_aware\",\n", " encoding=EncodingType.ANGLE,\n", " dataset=\"moons\",\n", - " epochs=10,\n", + " epochs=epochs,\n", " record_metrics=True,\n", - " T1=80.0,\n", - " T2=120.0,\n", + " T1=T1,\n", + " T2=T2,\n", ")\n", "\n", "plot_training_curves(\n", @@ -67,27 +87,19 @@ " dataset=\"moons\",\n", " model_type=\"noise_aware\",\n", " title=\"Noise-aware demo\",\n", - " save=False,\n", - " T1=80.0,\n", - " T2=120.0,\n", - " epochs=3,\n", + " save=True,\n", + " T1=T1,\n", + " T2=T2,\n", + " epochs=epochs,\n", ")\n" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "bb14f9fa", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✅ All imports successful!\n" - ] - } - ], + "outputs": [], "source": [ "import torch\n", "import numpy as np\n", @@ -105,9 +117,7 @@ " EncodingType, state_encoding, quantum_feature_map,\n", " param_gate_layer\n", ")\n", - "from error_kraus import thermal_relaxation_error_rate, add_time_based_noise\n", - "\n", - "print(\"✅ All imports successful!\")" + "from error_kraus import thermal_relaxation_error_rate, add_time_based_noise" ] }, { @@ -122,18 +132,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "b61c06cf", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✅ Visualization helpers loaded!\n" - ] - } - ], + "outputs": [], "source": [ "def draw_circuit(circuit, num_qubits, title=\"Quantum Circuit\", figsize=(12, 3)):\n", " \"\"\"\n", @@ -241,7 +243,21 @@ " plt.tight_layout()\n", " return fig, ax\n", "\n", - "print(\"✅ Visualization helpers loaded!\")" + "def format_list(values, sig_figs=3):\n", + " \"\"\"Format a list of numbers with specified significant figures.\n", + " \n", + " Args:\n", + " values: List or tensor of numbers\n", + " sig_figs: Number of significant figures (default: 3)\n", + " \n", + " Returns:\n", + " Formatted string like \"[0.5, -0.3, 1.23]\"\n", + " \"\"\"\n", + " if hasattr(values, 'tolist'): # Handle torch tensors\n", + " values = values.tolist()\n", + " formatted = ', '.join([f\"{val:.{sig_figs}g}\" for val in values])\n", + " return f\"[{formatted}]\"\n", + "# print(f\"Input: x = {format_list(x_kernel)}\")\n" ] }, { @@ -259,7 +275,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "0c31ca5c", "metadata": {}, "outputs": [ @@ -268,7 +284,7 @@ "output_type": "stream", "text": [ "=== ANGLE ENCODING ===\n", - "Input features: [0.5, -0.800000011920929]\n", + "Input features: [0.5, -0.8]\n", "\n", "Circuit operations:\n", " ('RY', [0], tensor(0.5000))\n", @@ -295,7 +311,7 @@ "state_angle, circuit_angle = state_encoding(x_angle, n_qubits, encoding=EncodingType.ANGLE)\n", "\n", "print(\"=== ANGLE ENCODING ===\")\n", - "print(f\"Input features: {x_angle.tolist()}\")\n", + "print(f\"Input features: {format_list(x_angle)}\")\n", "print(f\"\\nCircuit operations:\")\n", "for op in circuit_angle:\n", " print(f\" {op}\")\n", @@ -307,7 +323,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "595f3d78", "metadata": {}, "outputs": [ @@ -316,10 +332,10 @@ "output_type": "stream", "text": [ "=== AMPLITUDE ENCODING ===\n", - "Input features: [0.5, 0.30000001192092896, 0.699999988079071, 0.20000000298023224]\n", + "Input features: [0.5, 0.3, 0.7, 0.2]\n", "\n", "Initial state (normalized amplitudes):\n", - " |ψ⟩ = [0.5360563 +0.j 0.3216338 +0.j 0.7504788 +0.j 0.21442251+0.j]\n", + " |ψ⟩ = [0.536+0j, 0.322+0j, 0.75+0j, 0.214+0j]\n", "\n", "Circuit operations: None (state preparation only)\n" ] @@ -343,9 +359,9 @@ "state_amp, circuit_amp = state_encoding(x_amplitude, n_qubits, encoding=EncodingType.AMPLITUDE)\n", "\n", "print(\"=== AMPLITUDE ENCODING ===\")\n", - "print(f\"Input features: {x_amplitude.tolist()}\")\n", + "print(f\"Input features: {format_list(x_amplitude)}\")\n", "print(f\"\\nInitial state (normalized amplitudes):\")\n", - "print(f\" |ψ⟩ = {state_amp.numpy()}\")\n", + "print(f\" |ψ⟩ = {format_list(state_amp.numpy())}\")\n", "print(f\"\\nCircuit operations: {circuit_amp if circuit_amp else 'None (state preparation only)'}\")\n", "\n", "# Visualize state as bar chart\n", @@ -376,13 +392,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "711f939e", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABQ8AAAGdCAYAAAC8WIX0AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAf5JJREFUeJzt3QW4FOX///+b7gMISqdBSAqCqICBAhYoKhYgYiANFqiUqJiIAoqJiYAB2IgIxkcUpEQlDBCUjkM3879e9/83853dM3vO2T199vm4roWzs7Oz99xT97znjjyO4zgGAAAAAAAAAMLkDZ8AAAAAAAAAAAQPAQAAAAAAAEREzUMAAAAAAAAAgQgeAgAAAAAAAAhE8BAAAAAAAABAIIKHAAAAAAAAAAIRPAQAAAAAAAAQiOAhAAAAAAAAgEAEDwEAAAAAAAAEIngIADGoXr26yZMnj32NGDHCmz5v3jxvul5r164lf9PAn5evv/56luWlftufFmQNji8g+8uOx6nS4E+T0ujSNdydrmt7dsA1BwCQ3RA8BJAhNwuRXjfffDM5ng2Eb5eTTjrJHDp0KMl8O3fuNMWKFQuZN71urrJLYDAzHD161EyZMsVce+21pmbNmqZ48eKmYMGCpnLlyubSSy8148ePt3kNJBfw0KtBgwaBmbRy5UqTN2/ekHnPO+88MjQOJRcoi/V6rvNVyZIl7fmrTZs2ZuTIkWb9+vUmo2kfzm3lBwKDAICcKH9WJwAAcpOTTz7ZPPnkk977E044weQEW7duNe+++26Sm7OXX37Z7N+/P8vSlRv8+uuvpnPnzub3339P8tl///1nX5999pnZtm1bSC1W5J7jKz0tX77cBnfCA4PPPfeccRwny9KF3O3IkSP2tXv3brNmzRozZ84cM2rUKDN06FD7UuA6Ox+nSoM/TUpjdnbmmWeGpBcAgKxG8BBAhlCwpGnTpkmm16tXL1fneJUqVczdd99tcqJx48aFBA+PHTtmnn/++SxNU06n2mCtW7c2O3bsCDkG2rVrZ29mt2zZYr777juzaNGiLE1ndrdv3z5TpEiRHH18pScFCv3Bw8TERPPmm29maZqyGwW5EhISsjoZuep6vmvXLrN48WIza9Yse33QSw88Nm3aZF544QVv/ux0nB4+fNgG1bUvZJc0pcbpp59uXwAAZBsOAKSDuXPnqsqL95o0aVKK31mzZk3Id7SMd99912nWrJlTpEgRp1SpUs7VV1/trFu3LvD7K1ascHr16uXUqVPHKVasmP1OjRo1nM6dOzsLFy4Mmffo0aPOq6++6lxwwQVOmTJlnPz58zsnnHCCc9555zkvvfSSc+TIkcDf0Gf16tVzChUq5FSqVMkZNGiQs3v3bqdatWpeuocPHx4xH7SOrm7dunnTW7du7WzYsMG57bbbnPLlyzsFCxZ0ateubX8vyC+//OJcdtllTokSJeyrXbt2zpIlS+xvu8tUmlLLn8a8efN6f3/33XfePO+//743PV++fMn+zsGDB51x48Y5LVu2dEqXLu0UKFDArpe23w8//BAyr9bd//vhL//yw/epb775xm7D4sWL25fy4ddffw1cx1WrVjk9e/Z0TjvtNLtv6HXqqac6t99+u913gqxdu9a57rrr7DoULVrUrs/s2bPtb/vTklotWrQI+d6jjz7qHD9+PMl8P//8szNz5sw07bPhx9OcOXOcsWPH2vUvXLiwc/rppztvvfWWnXfv3r3OwIEDnYoVK9p9u1GjRs706dOTpCt8P//xxx+diy66yElISLD5f/HFF9u0h1O6r7nmGrtPu2nXftuwYUPn3nvvdbZu3Zrib2lfvPDCC+1vadrOnTuTPb60TiNHjnQaN25s06bfPPHEE+1v3nrrrc7nn3+e5n0k1mM4PN16nxrh29Q9VnU8al91PfXUU4HHqtIYbteuXXY/1HlWeatjtUqVKnbdgo6lv//+2+nfv79z7rnnOpUrV7bHhdZV+47OSR999FFg2nXM6Pfd7a/zufL52muvdSZMmBAyb3LXjvA8T+57M2bMsMecrgclS5YMmffbb7+11watq9Kv/fGss85yxo8f7xw+fDhJ+sOX/eabb9p9ScfSySef7IwZM8bOp+Nw1KhRTvXq1VM8j0dznnTz0J8Off/hhx+2+6h+S9eku+66y04POo6CXkH7RLTX899//91ea/3z+I+v9DhO/de2SC93uf5rivaX5cuXOx06dLDnS03TtTKovOEKv47qGq9rvfZ3nR9VxtB2Cz93h/9ucttOwtMQ9HLLEyldc/bv32/3wbPPPtseW9qXTjrpJKd9+/bO1KlTU9ymf/31lz0O69evb9dR26BHjx7Ojh070nQsAwByL4KHALJN8FA3p0GFad0oHThwIOS7r7zyir15ilQAf+aZZ0JuVlq1apVsgV2/vWfPnpDfGDx4cOC8TZs2dcqVK5eksB9N8LBmzZpOhQoVApevwIufAqG6yQqfTzexCuT4b3pSy7+cK664wsmTJ4/9WwEfl5tnurHQDUmk39myZYsNPkXKWwU8FMRKa/BQ6+oPdLov3dAoDX7Tpk2z+RPpN7ROClT7aVvpRj58XuXNJZdckuyNXBAF2vzfufzyy1O9fWLZZ8OPpyZNmgR+7/nnn7eBo6D1/Oqrr0LS4Q9E6Pd0gxr+PQXc/EFnifTb7ktBj//++y/ibykA5A+CpSZ4qKBqcr+pwFFa95FYj+H0Ch527NjR+/uee+6x8xw7dswL5Oi85A9YhweKVq9ebYNcya2z8sXv448/TjZf9VIwyC+lwI/S6ZcewUMF5Pzv/cHD+++/P9n06Ls65iItO9L+PHToUBukSs0+EO15MiiAFOka2aVLl0wNHsqCBQtC5tGDhEjfj+U4jTV4qKCkgsf++aIJHmrf1DU+6Pf69u2bLYKHGzdutA+DkltOp06dQh4whW+TSPuSrjtpOZYBALkXzZYBZIgvvvjC9uEW1PxJTZqCfP/997afn7Zt25q5c+ea//3vf3b6H3/8YWbMmGGuu+46+/7HH380t99+uzl+/Lh9nz9/fnPNNdeY2rVrm3///df+tl+/fv3Mt99+672/+OKLTYsWLexy1PzK/W3N99prr9n3CxcuNI8//rj3nfLly5uuXbuavXv3mldffTVwcJFo/P3336Zw4cLmzjvvtM0x1eTrwIED9rMnnnjC3HLLLfZv3cPqb/2u6/rrr7ed1k+bNs3Mnj3bpNWpp55qLrnkEvPpp5+a6dOn2zzcvn27l2duvkfSpUsXs3TpUvt3iRIlzA033GAHAtH207bQdho4cKBt9nbOOefYdb7sssvMPffcE9jMXZ3yB9G6ahtfddVV9vfUT6AordomgwcPtu///PNPmyZ3G5UpU8Z069bNdrj/xhtv2P1Sn2lakyZN7PpLnz59bPM71+WXX24aN25sPv/8c++3oqE+wfzcbZoaseyz4dQUWs2jdUy98sorZuPGjXZ6r1697P9XXHGFbRan5urav7SvqY+tCy+8MHB5+r3TTjvNHmvaR9566y27bbXfdu/e3TbRzpcvn51XA/Ao/9SvmJpna7r6dpw6dardXvr74Ycfjtgsfv78+aZo0aLmpptuMpUqVTJLlizxlh1kxYoV3qAQ6ntNx6rSqm2t/tnCB4yIdR+J5RhOT9o2Srv60dQ+ryajOi60jtKzZ8+Ig2OoiemVV17pjXx74okn2mNV20f71A8//GDXWXmnddY5xj2/NmrUyB6f+o6af6oZuY5vnadFfd/16NHDbivxN2HV4BpqYq3vaIAN7UduPqUnNf8vW7asPV9pe/722292ugYqevTRR735dH3ReWjz5s12W2vf13d1jnrppZciHks6/i666CK7D69atcpbb1HXBK1atbJ9xLrnkPB9INrzZBDlnbZh3bp1zTvvvONtS/392GOPmYoVK5oHHnjATvevs/YLt4+/SNffaOm80rBhQ7Ns2TL7Xucr7WPpdZzqnKeBpbQv6VgT5Y2uFcn1pahzhfZZ5beOW52XdJymlvYLdQOgPCtVqpR5++237flOdK7s1KmT3d5p6Xfx559/tvuRy9+34dlnn53icm688UZv/5arr77a7hM6F+jcKR988IHdB4YNGxZxX9L5RL+n8pX6UnW3o64zZ511VpYdywCAbCqro5cAcofwp9qRXv6n/eFP4VUbym0+pv/VBMf9TE2IXFdddVVIbQ01R/M7dOiQs379evv3tm3bQmowqZmNn967n2k+zS933HFHyHQ1b3S98847gTUFoql5qJea2LlU48T/mZpNyfz580Om33fffd531LxITd/SWvNQzd6+/PJL7/2QIUOc7t27e+8XLVoUknb/7yxbtixkWV9//XXI7/hr7F155ZUR0xCppqp/HjU3dPNFVMPE/Uz7hEtNLP37h5qwufS3v/ai5hU1P3VrX+p10003ed/RvhheyyM11KTe/51ITaXDxbrPhh9PqgnkNrN78cUXQz679NJLA2vYqpmfn78WU9myZZ3ExETvs0ceeSRkmWre7bdv3z5bk1FNONW87sknnwyppaWae5F+S+ul/S5cpONr8eLF3jQ1MQxvXqgm4P5mvrHsI7Eew+lZ81BNJ5Wf7ntt1/PPP9/+rZrYqpHkrw3lr2WmZvH+/FUtRH/+qPmi+7matIfTOXDKlCk2DWomre2pJszud9Ss1+U2NddLaQqnJpPpXfNQv/nPP/8k+S3/eaJr164hn6mWpfuZmmNu3749cNl169b1rk2zZs0K+UzNbZV/MnHixMB9INbzZHjtswEDBnifLV26NOQzf/Px5GrZpWdLAv+5SC+3Bnh6Hacp1e4Lmif8uExNnoTXrtM13v89f43rG2+8MVVpS67mYGq6wYg0j2pR+qerGwh//vlrHut8rprJQdtE+5mb/9rv/dec5557LuZjGQCQe/3f0GgAkMVuvfVWU6BAAfu3/q9Ro4b32c6dO72/9bTbX4ukZcuWIcspWLCgrdEhCxYssLUhXKpJ5Od/r/k0v6hmgEu1HVQ7wqWaD246Y6UaIh06dPDe16pVK+Rzd3396RDV1HCVLl06ZBlpoRo1qrkgqn2jkZdFNWDOOOOMiN9za4e6LrjgAlt7y335a+ypZlNaqCaJauy4/NvEv3+4NS9ENaj8g/Tob00Ln1c1i/wj1apmh0vb+tprrzWZJdZ9NpxqNmkbSPXq1UM+86+Pf9RRfz6GU01Ff61Q1Qr08w/6MmbMGFOuXDlbU0W1hAcNGmRrms6cOdObx63NE6R9+/bJ7nfh6tSpY2ububWbTjnlFFsb5/7777c1z7Re1apVS9M+EusxLKqt8/+6irGv8JGSo6F8d2tcjRw50qv9pxqhqiGdmmNV+42OH/c4VU0tt+ZR+LGqWmw6D2j9VKuvb9++duAJbU//SOz+7ek/Jys/L730UjNgwABbM081J91ajelJ58aqVauGTFP63Np+okFl/Ocn/3Fw9OjRiMeS5nPP+eHHkmpCu7XtwkfwdfeB9DpPurWGU9rfMku0o3tHe5zGQvtbWq6L2s7+2o3a3ueee673PqsHtwo/H/mvB9oP/edlDdTl1pINpxrT7vVB5xPV2g3al7LiWAYAZE8EDwFkiEmTJoXcLKfmpjn8pqxQoULe324TZfGPXOsPMAbxzysKaCT33i00q9mSS00w/VRAd2+AYpXcuvrX158OCQ8OJBcsiJaCAqJmpQcPHrR/9+/fP6r8Tc7WrVvTlL5Y9o/w7Rs+LWh7B23zoOWkxG3C6VLzudSIdZ8NCm75A+qRPlPgKDXBgJTyxM1DNYG76667QpraRxoFNRI1T4+GmiWqGb8bPFIzRzXbGz16tG3mr22hgGZa9pFYj+H0pibSt912m/17w4YN3vSMOlY7duyYqsC/vysHNXV0mz3qfKLg2LPPPmsDyWpKquBMpPwJ3wdT20VE0D6jbRdNgCvSOSqWY0ncdUyv86R/n8us/S05q1evDjkGU7ouRnucxiLac0c4rUN402v/+SD8WpHW/TZa6XV9SO31NC3HMgAgd6HPQwDZRnhtPvepeDg9Jd+yZYv92+3rK5LwPpHUn1Fy71WbT9TXkcv9LX+tHRWiM2Nd/elw0+JfJ38ffelRc0c1QNybDfWNpf61osnfhx56yAY3snr/iLR9w6cFbe+gbR60nJSoPyn1P+Z6/fXXbSAmJbHus+GSqx0bHuRIjZTyxM1Df19e6rPsww8/tLVXFDhQH4e9e/dO8beKFSsWdfpUm0vng8WLF9vaZqoVo6CX+rNToFI15VR7UrWdYtlHYt0fM4Ly8Omnn7a15UQ39+qDLjn+dda2cPvrC+LWMFWtJbdPO7c2q/ryU8BM66uAclCwS+cO1ZDSNlBtPvVbq5qNqnmqNCuApP441VemaFlu8CW8DzV9NzWC9pnw41rbP7ymul+k2q5pPZbS6zzpT0dm7m9BVCvev2+oH0D1Y5iex2ksYjl3+OnaHt53o/984N+n/Osb634braDrgz9oG+v1IdL+FO2xDADIvQgeAshx1IRIAQn58ssvbZMwfwfzKtCqAK1aDM2aNbM3AW4zUHWQr8FBXHrv0nya322q7DZP0k2Sali4zWQVHDly5EimrKs7iIhLzYnVVFEU5PM3A00rDVChpuNu5+1q1pTSjXF45+5q+qTvhVPn7uE1ILRsN/jhb/6YVkqT2/xQ21C/rYFBRANN+JuduelX0MAfwNAABLohEm1r3SBFq3nz5jaoo87nRdtKgZd77703ybxKk2qRaZCRWPfZjPbRRx+Z3bt32wEzRAMJ+LlNff2BdTVpU5N4Ue2U999/P0PSppqyCkioWaSOGfe40fbUzfOuXbvs7yvYoaBELPtIWmggiPPPP997r6bGaWm67Ab233vvPfteA+ekxL8eyi+tr5qHh/vpp5+8WkjhD0nUxNStUat1ilRLTvlcv359m9f+IJCak2o/EgWP3ICDAjLu+UHHi9s8VwO5pKWZqAJJGuzFbbqs9VENzfDAifYPDYzk7gPpLS3nyViEr196nl/doHL4QFrqmiC9j9PwdUnv9Qii872u8QqUu832/V2l+Ls08AcSNVCLgp+qmaoBofzn6dRsH11/Y9mX9Dvu4G66ZvjPywo0hjdvj1a0xzIAIPcieAggU0dbVo0Wt8ldrFQzQU0jdZOhwrJuytUnlQrJqomnG06NnKt+efRE/uabb7Yjk4qCQGp2FD5yrVvzzn2Cr1Ey1fefbmr0G6pVob6F9uzZ4y0rMyj4pIK72x+Zagvp5kvNvrQu6d3PlQJb7s2JP9gRiUbbVHDIHfVZ+a6bcN1gqVbGP//8Y2uVqH+r4cOHh/QdpSCEPhfVotKNvWrjaITjSCP+prZWlppaqdmY9hF327kj6bpNrHST59aCU00qBVLcvsd0A6ZAmQIPWh//yJbR0L6iwLbb1O2+++6zy1Zg0q1Bqxo3ClArfxQ8jHWfzWg6nlW7zT/askt9vbn7i45Dd3/45ZdfbHNEBQuUj24gNb0pf9Rnp4I/CqZqe2pf0k2/AhLhN/ux7CPZzVNPPeUFONQPWUo0j7aDjkVRLVj116d80/r+9ddfdqRVHZPqdkL7voIFOo7d/FDgTYE4HauaJxI1ZVS+a5/Qca59Xcv39+3nD7xov9KDINF+peCLtp87La3XC7cPUz1oatCggT3OFKzSeijoo/2kQoUKKY4sH6u0nCdjoVGxFaByH3KpBrSCQJqmoHX4Q6nUXs91TlR+6b374Ed0jGh05PQ+TsO7f/j000/N4MGDbfBVL50nM4Ku/zovu6Mt+x8W6gGbf7+dPn26/Vs18/QQSseYHg4k1zohvEsLHce67mpfUN++yXWToX1J18c5c+bY93ogpebfylMdL/4+EXW8pqY2aHKiPZYBALlYVo/YAiC+Rlv2j9Sb0oiQyY1k+Morr9jRRSP9zjPPPOPNu3fvXqdVq1bJpuucc85x9uzZE/Ib99xzT+C8GnlXI8+mZbTl8FFDk/vewoULneLFiydJR6FChZwLLrjAe1+jRo1Ub6/w0ZZTEmm0Zdm8ebPTqFGjFLe9P59EI7oGzde7d+80j8KqUVQLFy4cMS3Ku3fffTfkO3///XfICN/+V/hontHQqKi1a9eOKn9i2WeTO56SG+03uZE//SMgX3jhhTbfwtOhfP7mm2+87/zxxx9OiRIlksyn0Ww1Umlqfit8X0npONEooCnlr0ZzP3LkSJr2kViP4fQcbTklkUZbdkdMrl69eop55T/WevbsGTiP9odKlSoFbrNatWolu3yNAusfVVcjdftHO3dfZcqUsdst0vokd37w0wjyKa1z+Hkt0rLDt4n/s+T2gVjOkymNypvc+ms03aDla5Ts9Lqe65geNWqUN6JvRhyn/lHCw6/D0YzInNrRlnVt17KDfrNXr14hy9Q21T4aPp9Ga2/btm3EbXfw4EGnQoUKgb+h631K2175qBHAk8vHTp06heRjcvtmcuffaI9lAEDuxYApAHKkHj162BowavqlDtLV5EdN7dScT03r/DU31HRNT+lfeeUV+/RcT87VZFY1T1Tj6MUXX7RN8NQ/m5+e6E+cONHWlFANJNVMUQ0L1UhIa79K0VAtEdVKUc0hpVEv1TxQLSF1WJ7VT//V75maOqoml/qzUo0QNadVHmnbaPRHNQNWDSC/Rx55xNaM0MjY4R3Up5Vqx2n/6Nmzp609pT7e9FINOdV8Ve2Z8FpGGnxHNeNUi1V5qRoxqu338ccfp6mGi2qKqAae8qBTp052NFEtW7WAVPPmsssus/0hDhw4MM37bEbSMaWaW6o1qVGvlUbVptJ+2KpVK28+5bemqSaSjkulUWnW+mj05YygfBk/fryt5ajjVfmlfUpNrHX8qMauft/fDD+WfSSnU9cL2hd1blNNJ+Wb8knbUzXyVKtKNancGo0ybtw420ef9lvts6r1rGNZx0Wkbg00AIbyVTXrNKiTvqd9QecDNUlWU2T/qLraL/S7qrmlc61q06q2oOZTTa60evTRR+2+q3ORjnNdK5Qm1aTSfqrP3Zpc2e08GSuNhqvatKrFltbaZ+LuJ8o/XX/UfYaa9D744IOpXn4sx6n6P9R3tB+ED1aTEbQ9VBNSA4hp/9Bvqja1BglROsK36TfffGNrres8p+9q2+rcnNy5Q/ufau5p33O7gYiGjqmFCxfaGvu6RqlFh/JMNU51ftbI1eoiIpa+bdN6LAMAcq88iiBmdSIAAJGpHyXdBITfoGk023r16nlNfxXwUFNrIL1oRE53/1JzyhEjRpC5AAAAQJyhz0MAyOZ+//13W/tCNXFUW0O1N1TjQ7Ui3cCOAovZtW82AAAAAEDORfAQAHKA9evXm8ceeyzwMzWrUlM4NY8FAAAAACA9ETwEgGxO/TiqPzz1o7Ru3To78qH6ZlPfUxo5U/0Oqf8hAAAAAADSG30eAgAAAAAAAAjEaMsAAAAAAAAAAhE8BAAAAAAAABCI4CEAAAAAAACAQAQPAQAAAAAAAAQieAgAAAAAAAAgEMFDAAAAAAAAAIEIHgIAAAAAAAAIRPAQAAAAAAAAQCCChwAAAAAAAAACETwEAAAAAAAAEIjgIQAAAAAAAIBABA8BAAAAAAAABCJ4CAAAAAAAACAQwUMAAAAAAAAAgQgeAgAAAAAAAAhE8BAAAAAAAABAIIKHAAAAAAAAAAIRPAQAAAAAAAAQiOAhAAAAAAAAgEAEDwEAAAAAAAAEIngIAAAAAAAAIBDBQwAAAAAAAACBCB4CAAAAAAAACETwEAAAAAAAAEAggocAAAAAAAAAAhE8BAAAAAAAABCI4CEAAAAAAACAQAQPAQAAAAAAAAQieAgAAAAAAAAgEMFDAAAAAAAAAIEIHgIAAAAAAAAIRPAQAAAAAAAAQCCChwAAAAAAAAACETwEAAAAAAAAEIjgIQAAAAAAAIBABA8BAAAAAAAABCJ4CAAAAAAAACAQwUMAWWrt2rUmT5489nXeeeexNSK4+eabvXyaN2+eN92dVr16dfIOAIAcZMSIEd51/PXXX/em65ruTs9sKmO4v62yB4KpzOrmk8qyQpkWQG5G8BCIYz179vQKPno99thjJjfxF4AjvZYuXZrVyQQAABkkN5V1xo4dawOOeuVECpCmVC5LTEzM6mQCAALkD5oIIPc7cuSIef/990OmTZkyxQwePDjL0oTofffdd/b/woULk30AAOSCso7SfPDgwcDg4T///GP/zqkBxNysQoUKXrmsZMmSWZ0cAEhXBA+BODV79myzffv2kGnLli0zK1euNLVr1za5Tfny5c17772XZPqpp55qcrJzzz03q5MAAEC2lFPLOk2bNjW5XaNGjcy4ceOSTC9RooTJqQoVKkS5DECuRbNlIE7pybvruuuuC5we1K/LL7/8Yvr27WtOOukkU6RIEdO+fXvvKbjr+PHj5qGHHjKVK1c2RYsWNeeff75tHhzUP0xy9u7da5+s16tXz/5WQkKCXcbnn38ec4Eu/FWsWLHA/gP/+OMPc8UVV5jixYubE044wTZ7CqoF8O6779r1K126tP0NfbdLly5m165d3jyHDx82jz/+uC0o6/eUJw0bNrRNp/RZuPHjx5uTTz7ZrnOzZs3M119/HXG9gvo89DcLUv69/fbbNg+VvtNOO81MmzYtyXK++eYbc+aZZ9oajPptpSF8OQAAxENZZ9GiReamm26ygSw9fNQ10HEcWwbSNV/X56pVq5rnnnsuZBlB19/TTz/dXlvr1q1rJk+enKp0h/d56C7XX97yN/UN+m1Xcv3wuWUzrY/KbCNHjjRHjx6NmK6tW7eaQYMG2QevKlOo7HPppZeaH3/80URLNfOCymX58uULTPfChQtt3qsMpW3y4IMP2vKm37Fjx8zzzz9vWrRoYZev9VJa77jjjpD5du/ebR544AFTp04dO4+2c/Pmzc2LL75ot3P4MpWflSpV8sq0CkAHiZTX/r4tJ02aZGuQnnLKKTYPVR4MKuep9qnKbtp39L/KbpH6yASATOEAiDsHDhxwSpQoodKRc+KJJzqbNm1y8ufPb9/XqlUryfytW7e2n+lVs2ZN72/3dc4554TM369fvyTzlCxZ0qlevbr3fs2aNXZe/e9O0++4EhMTnfr16ydZjvuaMGFCius5d+5cb/5q1aqlOL87b0JCglOmTJkkv/nAAw+EzH/LLbdETJ+7fgcPHnRatWoVcT59dujQIW+ZTz75ZJJ5ChQo4NSpU8d7r/UKT7N//SZNmpTs9sqbN6+zcuVKb/758+c7hQoVSjJfw4YNvb+HDx+eYv4BAJAbyjonn3xykmti3759nVKlSiWZPnv27MDrr34j6Lo/efJkb35dW93p+q5L13R3evhyg17h8/iv2ZHKWX/88Yctm4Uvq0GDBt7f3bp18+b/559/nMqVKwf+vsopM2fOTHGb+NPoT0sQf7orVKjgFClSJMnvvvzyy978hw8fdtq2bZtsHsmOHTuc2rVrR5zvuuuuC0lH7969k8yjcmI0ZVr/dg4ql2k/VbpcH3zwgZMnT55ky2X+/QUAMgM1D4E49Mknn5g9e/bYvzt27GjKlSvnPSFdtWqVWbJkSbJPnSdOnGifppcqVcpO+9///md+++037/tuM5S8efOaYcOGmY8//tjWoEtNbUOXnggvX77c/n3JJZeYTz/91Lz55pv2abMMHDjQrF+/PtXL09P68E65I41QrCfSJ554ovnggw/MqFGjvOl6Iu3SZ6+99pr9W0/J7777bvPZZ5/ZNF500UVeTQA9Xf7222/t31WqVLG1DlRbUTUWRJ8988wz9u+dO3fa/HKphqfWu3PnzmbFihUmFn///bfp0aOH3eYXXnihnaYn9a+88oo3j2oRHDp0yP6tJ+raXqp94OY/AADxVNbR93StfvTRR71pKtuoDDJ9+nRz5513BpYN/PQb/fv3t9dx1WL0X3PVF2M0VA5SX3puGUj03n3FYujQoV4ricaNG5sZM2bYdfzzzz8D5+/Vq5f5999/7d9du3Y1X3zxhXnhhRdsCw2tzy233GL27duX6t9Xi4fwcll4zUjXxo0bzRlnnGFmzpxp+vXrF5j3qgU6a9Ys+7dqCKr8pjS+/PLLtmWF6/7777fN1qV+/frmww8/tGUi1aJ0a6VOnTrV/q35VJPRLdOq5p/2K9VsjKZMG14uu++++8xHH31kax26+5tbK1U1HQcMGODVgLzmmmvsPqT1jlTjEQAyRaaEKAFkK506dfKeXM6aNctOmzhxojft3nvvjfg0/plnnvGm9+zZ05s+Y8YMO+3xxx/3pul3XHqi6n9qnNxT2mPHjjmlS5e20woWLOh89dVXznfffWdfvXr18uZ/6qmnUl3zMOgVXhvR/9mSJUu86f4n1KoRKR06dPCmDRkyJGIa/E/wP/74Y2+6/vY/SZapU6d6084880xv3qNHjzpVq1aNqeahu2z58ccfvekdO3a00zZv3uxNU+3Dbdu2efPr6XtQLQYAAHJzWeell17yphcvXtybPmfOHDtt69at3rRGjRoFXn/9rTLCr+PffvttVDUPU5oebc1DlbP86/Xbb79586uVRXjNw+3bt3s14cqXL++VyfS68sorvfnff//9ZLdJSjUo/bX1/OlWWVA1R920Fy1a1E5XTVCXv1beiy++GPj7/vKlXsuXL/c+GzdunDddZbzwMu0111zjzauyoJuGaGseusuWKVOmeNMHDBhgp/3000/eNOW1alS6zjrrLGoeAsgyDJgCxBk93dQTTFFffhdccIH9+6qrrjK9e/e2Tzz1xFX98bm15/xat27t/V2mTBnv78TERO+Jqkv9x7j0RFedkyf3pN+1bds2WwtP1CdgmzZtAueLpjZe0IApkUYoVt+K6p8w0nqqH53Vq1d70y677LKIv+ufz58fqokZPo8/7/xPyVWzsUmTJmbdunUmWtFsL/V16J9HT9aD+oUCACA3l3X812iVX9QHs38gk7Jlyya5nobzX/PDr+O69rZs2dJklS1btnjrpL6Y1R9j0Lq7VBvRrQm3adOmiGmPplwWNGBKpBGKVX5UzVG3BqC2yf79+0PyPjXlMrWeccuXqp2ovgRjKZcpnbVq1UpVmTYt5TLVtixQoEBIuSyW/iUBID0QPATijJqluAN/7NixI6RQ4m/iO3/+fHP22Wcn+cxt1iH58//fKSS8g2kJKpCnp2iax0QzAp5/HVOznrGINm9izcvstL0AAMgJZR1/EEvBKv/DxXCpLRdk9DXWv3wFR/0PZGNdTkaWy9wBU9JaLotV+HpSLgOA5NHnIRBn1IdPasRa40y111waGc+lJ71uHzMp0RN9t6CovnRUg0CFc/9LBWONWJdVNGqxy63dkNJ8CxYs8P7+6aefksxTs2ZNb9rPP//s/a119b9PT/7t9ddff3lP5EU3VQAA5DQZXdZJDf81P/w67r/eR8MfyAwfadgf8FTtQJf6/Qt30kkn2RqHbsDPX2PQXz5xaWRgN7imcoNGZA4vl6mlyEMPPWSyc7lM/Vm7/XVrvd3+uqMtl6mvSPVpmdHlMtVs9AeCKZcByErUPATiyPbt283s2bPt3yVKlAjpCFxU8Lvrrrvs32riq8E+/AXV1OjQoYPtCFoFSXfAETW7ePbZZ82BAwdStQz95vXXX287qVazmosvvth2FK2gojrr/vXXX20H1xqwJFLn2uE0IMj333+fZLoKiCpER0udn6vjbnniiSdsQVqDjSiPNZiMBpWpVq2aueGGG8wvv/xi51NTKQVCVQAfPHiwtyytq2igFTWlVm0J3XSow+y2bdvam5tYmiynhgrSqnXxww8/2N+97rrrbF4vXrzYTJs2LUN+EwCAnFzWSQ2VOTQ4iq7t/uu4mt+eddZZMS1TD1bXrFlj/1aTXzWFVtBQA38owOdSOURBKJWhVEYJp/VV0153YJAuXbrYAVT+++8/mx/h1PS7ffv2dmA4PWi84oor7GBsyl/V4FSQS+UyBbciDUYXTgG4oHKZ1iVS8+WUymXugCIaVE9Ns9XUWOv00ksv2bRpvVXOURlNbrzxRjN8+HD74FT/h5fLLr/8clumFbdMqzwfP358VLUso6EyswbY06CAGzZssIPTKJ0aDIYmywCyVNZ1twggs/k7CvcPZuKnjr/deTRQSXgn4m6n0Ml19N2vX78knWAnJCSEdPSdUufSO3fudOrXr59sx9r+gUNiGTAlPN2RBlKJtP7qSDzSct35Dh486LRs2TLifK1atXIOHTrkLfOxxx5LMk/evHmdmjVrxjRgSkqdpsv8+fNtZ+Thv+sf7IUBUwAA8VjWiTRISUrX30hlmLfeesubP9oBU+66665kBxlp0aJFks/r1KkTOO/q1att2Sx8/lNPPTXJgCnyzz//OJUrV062TOXPt1gGTPGXcSKVWSLljwYWadOmTcTlujT4i38gvPCXBos7fvx44OCA7ksDAFaqVCnVZdpI29lfTvXn9QcffOANUON/+fcp/3IAIDPQbBmI02Y8emocRE9Z09qcZ8yYMWbEiBGmYsWKtiadOtaeO3duSJ816qg6OWpWoqfEesrbsGFDU6RIEfudU0891Vx99dV2XWJ9cp9eXn/9dfPWW2/Zzq/1lLxgwYKmatWq9gmxu67qa1E1INQpe4MGDex6KE/0ZH306NHmyy+/tN9z6Qm3amnqyb2+qw7FVcMxIztWVz7qibY6glda9NuqeXDLLbekensBABBPZZ2UaHAW1ew7/fTT7bVVA2yozKAacrFS7bjbb7/dlq+C+uh75513bIsFlTPUsqB///5JBotzqTylslmrVq1seUMDy6kMEj6IiUvlG9UwvOeee+wAJvoN1TzU36od99FHH9kac1lF/Vp+/vnn5rnnnrODn6jbG6VRNTJvu+22kFqUqsE3ZMgQu0207mrCrVqKL7zwgpk8eXJI3io/VCuzQoUKdnnnnHOOmTNnTkhNz4zYd9T6QwPZaN+pU6eOTdeFF17ozUO5DEBmy6MIYqb/KoBcTaeV8EKtmhGp4KnR8RQY1PuMaCaE9NleoqY9bpMmNUe68soryV4AAJJ5qNi9e3cv0KcHqUB6lcv0sNftm1HdyzRu3JjMBZBp6PMQQLp76qmn7OiG6k9HAUP1h6OntgocyjXXXEPgMBvR9rnzzjtNz549bY1I9X2omgpun4d6St+mTZusTiYAAECu991339lakDfffLOt2ZmYmGj7bXQDh6oxqVY5AJCZCB4CSHfqRFrNdPUKp6YXaq6L7EWjMQaNyKjmMq+++qptmgQAAICMpZG01Zw+qEm9ymOq4UrrHQCZjTaDANKdRkC+9NJLTaVKlWzwSf3OqGnFQw89ZEcRLlOmDLmejahm4a233mqfbmtbaZtppGj1YbRw4ULTsWPHrE4iAABAXKhZs6btG1MjZqtvQ/XLqD4W1UpEI0pndZ/fAOITfR4CAAAAAAAACETNQwAAAAAAAACBCB4CAAAAAAAACETwEMhAI0aMMHny5Al5DRgwgDwHckG/nuHH9rx587I6WUhnnMMBAACQ02mgpfB7F43oHg2Ch0AW27Rpk+nZs6epUqWKHahC/6tD5M2bN6d6GTrww08G/tfatWszdES4F154wQ6Iok6dS5Ysadq0aWPmzJkT1XJ+/PFHc9VVV5mKFSuaAgUK2GXVr1/fDB061OzZsyfJ/IsWLTIdOnSwg68ULlzY1K1b147ifPjw4STzHjp0yDz66KN2Hs2r72gQkMWLFwemJScue+bMmbZzbXWyndK237FjhxkyZIhp3bq1zeeULiCO45gXX3zRnHnmmaZYsWJ2UBV11v32228nmfePP/6wARcF16pWrWo7+S5durS58MILbRrTegxoXxg8eLA57bTT7LI12Mtll11mfvrppyTzfvPNN6Z///6madOmpnz58nbZFSpUMJ07dza//PJLmtYTiGX/zcpz+NSpU80555xj92u99Pe0adNS/f1///3X9OjRwzRo0MCei/Lnz2+PbS1nwoQJ5tixY2nOm2jSmBOXrYEOevXqZRo1amTzz92+KtAHefrpp83ll19uypYt681bvXp1E8nXX39t2rVrZ7eLrhkaBEsDlR08eDBkvl27dplnn33WXHHFFebUU0+15zu9dB0fM2aMOXr0aJquRxl9zdBydP3S+V/5WKpUKZvnL7/8sv3tWK8Zrl9//dVeTzXom75z0kknmZYtW5pXXnnFpFU0ZYDkHDlyxDz33HOmWbNmJiEhweazBtTQQGc6Vv20jTp16mTXQ+tTo0YNM2jQILNz5840Xwd1rPTu3dvulzpW9Bu6xq5cuTJN+6goTx577DFbFixSpIgtX55//vnm888/D1z2n3/+addf5UilRdtPg8H9999/SebV+WrcuHGmefPmNv+0H+k4U/n1gw8+SDL/ihUr7D6hfVTLVnpq1aplyxhB5wWl5cYbbzTlypWzea6BT+677z6ze/fuFB9Ehr/Czw/R5KF89dVXdr2UfyrznXHGGWbixIm2/O6XUjrCr0XRlDuz6v5iyZIl9vg/++yzvUEcTzzxRHte/e677wK/k9ptF0sac/uyYzmfR7M/6/7l3nvvNXXq1LHHoO4XK1eubM852tbhlD6lU+lVWpR+7bN//fVXmq6Jy5cvt8tROnT9UTp0/tB6Tp48OUk63nrrLdOtWzdz+umn2/V0B0DS+WPbtm0h827cuNE8/vjjpm3btvZcrfXUCOstWrQwkyZNMildFxo2bBhyPEY6L8TMAZBhhg8frlKsfT333HPOd9995/z999/e5+vWrXMqV67szeN/Va1a1fn3339T9TvdunULXIb7WrNmTYatY6TfzpMnj/PGG2+kahlff/21kz9//ojpP+uss5zjx49788+aNcspWLBg4LwXX3yxc/ToUW/eI0eOOBdeeGHgvIUKFXK++uqrkLTk1GV36NAh1dt+yZIlgfNqWwbp2rVrxG0zZMiQkHlHjx6d7L74zDPPhMwfzTGwa9cup169eoHzFihQwPnkk09Clt22bduI6ShcuLDzww8/xLyev/zyiz2eu3fv7s0zd+7cwPxDzpVbzuH+9Qh/jRo1KlXL0Lonl8bbb789ZP5o8yaaNObUZev8FzTfpEmTAvO8ZMmSSeatVq1a4LyvvPKKve4GLb9169bO4cOHvXnnz5+f7LbU9cQv2utRRl4zlKfJzX/vvffGfM2QDz74IOJ1WnmQFtGUAZKzd+9ep1WrVhHzQMeq64svvrDrGjRf3bp1nZ07d8a87davX+9UqlQpcN4SJUo4P//8c8z7qPa5Cy64IGJaXnzxxZBlL1261ElISAict2LFiknOoT169Eh2P3r++ee9eVesWOEUL1484rw1a9a028SflqBjV69GjRo5u3fv9ubVeieXDr3efvvtmPJQXnvttYjzKw/8UkqHXv7zXzTlzqy6v7jjjjsirkvevHnt8e4XzbaLNo3xsOxoz+fR7M8HDx50Tj/99GTL9YsXLw45/zdo0CBw3tKlS9tyfKzXxLfeeivZ+R999NGQ+XWdjDRvjRo1nO3bt3vzvvvuu8kuu3///k4kDz/8cJL5Dxw44H2+efNme3147733Urz3i4TgIZCB/DcVQYGFK6+80vv8qquucmbOnGn/d6ddffXVqfod9yJQvnx5e1IIf+mEmxGUXn/hbMqUKfbC4AYCVdjatGlTisvx54MKiyrsquDmL/C6hdD9+/fb33KnP/jgg/bi779BGD9+vLfsZ5991puueTSvvuNO002imz85ddnSt29f58Ybb3QmTJjglCpVKtlC3G+//WZvPAYPHuzccsstyV5A5syZ431erlw5Z/Lkyc7UqVO9ddFFf8GCBSEFBxUydHH7+OOPnQ8//NBp3ry5t4yiRYuGFLKjOQaGDh0aElD+9NNPnbFjxzr58uXz0udftoKHKtTrIv7ll1/aQkqFChW8ZSgPYl3P1B7jyNlywzlcDwt0k+Te0OtmUi/9rWk6fpYtW5biclQov+mmm5xXX33VBkG0rpdeeqm3rjrvx3psR5vGnLpsBQkvv/xye04655xzUgwe6ubpzjvvtPMnFzxMTEz0ghtKz1NPPeV89tlnzrnnnut978knnwy5UdL26ty5s71R+fzzz5MEjfRQL5brUUZfM0444QTvM133Zs+e7fTr18+bpryP9Zrx119/2d/TZ0WKFLGBSKVJQcYxY8Y4I0aMcGIVbRkgOT179vS+c+aZZzqvv/66DeAqr3v37u3dFOuhq/YXd15d81W+8u/jmt8V7bbr0qWLN/9ll11ml+3Pc62b++A32n1U5xl3+mmnnebMmDEj5NjS9lGg39WyZUtvfpVrlBZ/4EjnKpcCpu5xq5duuLUfXXfddSFpdw0cONCb3rBhQ7tPKHjgL2u9//773vyNGzcOeaiic4g/2Hv33XcneRDpf3300UdeQEUBkW3btsWUhxs2bHCKFSvmnZ+1D6uc7g/4+gPoQdeehx56yJu3adOmIfthNOXOrLq/0D6g6+oDDzxgz3Pap2vVqhXxfBrNtos2jfGw7GjO59Huz/50a3/TMaj9V8ekO71Pnz6Bx63Sq3OI/5ygc2es18RPP/3Uue2222wadO6dNm2a06JFC29e7XN+Oo61XhMnTrTnGj0E8z9IGjZsmDevfl/zK7iva4TW8ZJLLvHm1blB16pwK1eutEFKfTdS8NClY9T9nOAh4pZu7NyLbbNmzZxjx455B4h78dTB7I/uBwm6kAe9Vq9enaYbz40bN3qFF51o3YNb/7tPeFTATc3F0b3xjFQjIaO0b9/eWz+d7Fz+k7MuBinxP132F2RUUHGn//jjj3aaCrLuNAWHgp4a+Qt9derU8aZrnqBaaW6hL6cuO5wK/aktxL3wwgvJXkBUKHA/9984PfbYY970W2+91Zu+cOHCJMeYCr7+mqU//fRTTMeAf3+YN2+et/x27doFPqHXjZBqL/ip8ODOq5uPWNfTRfAw/XAOz5hzuIJP7j6sgn1QDQF/gTsaugn3F1K3bt0a07EdTRpz6rLD6SYlpeChv+aTO2/QPqLrpvv5eeed503XddOdfsopp4TUGNNDpHD+m8THH388putRRl4zVK7zP1R0b0L1v//m1A1YRXvN6NWrlzddN4XpKdoyQCQKCLl5o1o4yT1Y+PXXX71lV69e3Zuu/dedrpt3dz+PdtuVLVvWm7527Vpveu3atb3p33//fUz7qIL07nQFR4MCpwr6yZ49e7zyv27IDx06ZKfr+u8GJ/S5G2zU/+4ytA5B+aV1cPkfsvoDvP40KgAj2lfdaTpu3H1R281No2o9hdcQ9FO5OahcFm0e6hh2p6tcHlSzSUHf5Ojz1Jynoil3Zub9he7X9u3bl6Qmnf+6pdpYsWy7aNIYL8uO5nwe7f785ptvBj7E0zHpTtf5QXQOcAPaSqfSK0q///zkVkyJ9poYxN+qS3EHPz1wDTdgwABvfm0T1++//27T46fzvP8Y0/XET+vlPkDxP2zMiOAhfR4i11D/Cup3RRYsWGCef/55+/cdd9xh9u3bZ/9+6aWXbH83yenbt6/t2yal1yOPPJKm9P7www9efyPqf0T9PIj+13u3T5b58+enepnqJ0F9uqlPj2rVqtk+mjQtI6jm8v/+9z/vvfoTCfo7Up8i4dvOpb4lvvzyS9sXh/qHEvUJ5ObJ999/H/g76tdOfU64/RWpLx/1jaF+akSfqQ+f5NKYU5edkdQPiEv9fwT97d8PtD7hx5j6dlIfH+HfjfYYiDYtF1xwge3HyE99mQR9L9plI/1xDs+Yc3ikc09aziU6/6ufHvW55qpXr57t8yeWYzuaNObUZWek1Jy/1GfVli1b7N/qI0rX1XDqgyn8u9FejzLympE3b15b/nKp717156b/XTfccIPt5ymWtHz88cf2fx1/6rdN/SRq2+v/J598MkkfcdGIpgyQHPX35/a/pb4A1Ve08k/9bqkvxd9//92bNzXrv3fvXq8P4GjzK5r5o91Ho1m2+jVz+7pUXmr7ia7/6ltM9Ll73Gr/d/d1ncdUntd+NGrUKG/Z6s8sqIyqfjU//fRT2wekviPq5/Hiiy9Osp3VV6S7L+q87vZXqm3822+/mSBKp/ojdLn3NbHkYWrOT/55wv3zzz/ms88+847J6667zmSG9Ly/OPfcc22ffpHKgeJ+Hs22izaN8bDsaM/n0e7P2pZumV7Hno5BHYs6Jt3rw/XXX++dSxMTE+3fSqfSK0q/+g4MX89oronhdF3YsGGD7SvWpb5Z/dzzQ2ruR9SPotLjp/OY+pAMml/021oX9Xd4zz33mIxE8BC5ijpWVqeo8sADD5gnnnjCBqLcDunVQW524e9QWB24+qkg4lqzZk2ql6nOpdV5tTpMXbdunS2AqKCvk1p608XC31Gufx2iTb86v1VH/Pny5bMd56qTWHUqr/VQ59dz5871CteR8k0XFP8FS/P559XFS8tPLo05ddkZSR2Cu3ShVkfs2p/eeOMNb/r69euTXYYuaFu3bvUu4rowxnIM+NMyfvx4u/+p8/nZs2enOi3+jtDbt2+fruuJtOMcnv7n8EjHWaznEt1AqpCuTueHDx/uFeo//PDDFH8z0u9Gk8acuuyM5D9/adR3DQaigUI0IIRfcucw3Wjp+uveYOk6LNFejzLymiFajhtA1PpddNFF9n91Kq/gjx48BuVLStcMBdHcv1WW0mBt6vxfA8Xof5VT9DA6VtGUAZLjDw5OmTLFBndUHtON+EcffWRvjN1gr25O3Zt9TdONth6mP/PMMyHLdNc72m3nn3/s2LF22SpzL126NNllp2Yf9c+v4MD27dvtdvBfw915lZ8a8EGUBt1I79+/3w40ou+Fz688mT59ug2+yoMPPmj3Iw18pH1clQ90D+EPJCpArRt4PdTWgDtdunSxx4z+1kMHNziS1rK98k8BE9G53x+sjzYPU3N+0jpEClj7B1W55ZZbvIcpGS097y+C+PchnUs0KFC02y7aNMbDsqM9n0e7P2vwkHfeecf+rvZbHYM6/nRM6uGljp1WrVqlW7ojXRP9FFDVNVGD8eh40XxK06uvvmpS4i8z+e9Hgiid7oAw2l/9D9E0IJQGhVE69LvhlSbSG8FD5CqKxL/22mv24HVHWBJF8FWwSQ2dwP5ff6DJviKNjphabm1IcZ+SBr33zxeJnjhrRDkV9nTy1ChNGj3OPakMGzYs5nT+/PPP9smT/6VCani6/GmONv2aXxcRrUc4rY9/VMRo8i3aPM6py85ICt66tYl0gdaoo7pIar9wJTeSly54GqFNdFyqppICD+HpT816Dhw40PuubmZ0s6CnnP6CUHJp0U3Www8/bP/WzZq/lkFa1xPpg3N4+p/DIx1n6Xku0cMd/2jL6XV+TOu5NDstOyM1adLEjj7s/p5uaLT/qLWFX6Rz2IEDB8w111zjBVo0Eq9b4yLaPMnIa4Zo1EnVEAm/QdI6KCjgvxmM5prh1lJxqeavlqego1t7TaMt+wNj0Uiv63p4Ovv162eDghopVbRu999/v/1bAX5tD1EQSDe1uvEMP5+4eRDttrvrrru8v1V7T8vWDbb/XODOH+0+qgfIbrBK50SlSzVA/UEBd17dNA8YMMCbrpHSdS3p3r174LJFwb6gmkY6Bt57772QEZS1HyoQGx6EEJWJ3QCDu25p2c4auT6o1mEseZia81OktCho7gZAdAypFnxmSc/7i3B6eKAWZqLj2h9Ij7Wcnpo0xsOyoz2fx3Ld0v28gojhNLq7gnFurey0pju5a2JytG66NqVUS10PLNyRrbXe7nk6iNLQsWNHb91Gjx7tlQ/dc6XO+0qj8jSjETxErqOnDuEXXJ2I3KeSKdHw6+HBsqCXnoCmhb/KsS7SfnrqHTRfJAqM6smsTtB6eqon5P5gqZq5xOrqq69O0mRbTz/C0+Vfh2jTP3LkSJtmnSBVENZJUAV0FdRUC0dpcAuM0eRbtHmcU5edkXTzoeYBjRs39qapANCpUyfvfVDQ163poP3FfWr47LPPhtT+jXY91Qx58uTJXvMD9zP/E7tIadFN4JVXXmmXqxucTz75xN4cpsd6In1xDk/fc3ik4yzWc4nO1998842ZNm2aueSSS+w01Q5X8MIt5KfX+TGt59LstOyMphsnna/cmmZuMzT/+TLoHKaaHjqHuk0wdcOk4LUr2jzJyGuG6CZKNct0I6XrgWoMqsaYqNxwxRVXeDdu0Vwz3AChSzXP1CRY5Un973Jv+KKVXtd1fzrdB+M6Dv1BJ3dbimpi3n777SHB1tNPPz2kNqebB9FuO7Xo0TbyT1PNPX8zX/9n0eyjSp+Com5rIvchhZpmBy1bAVEFTVUD1aVmfs2aNUsyv2p2q1mh9hvlp7ap9qOnn37aO5+pVpNLlQVU8061wVUeVVlVtQOVRgVzlb+qfZjW7azla53dfOzcuXOSeaLJw9ScnyKlRQFUt7aYjpeggE1GSc/7Cz/du+mcoAoQOh7efffdkGBLrOX01KQxHpYdy/k8mv1ZAUJtP1UoqV27tlm1apXtVuPaa6+11wPVGFaLw7SmO6VrYnh8QZWO3nrrLZtuPTiZMWNGsi0d7777bq/rM62HaoxHqi2obmsUYHW7llCAsE+fPt7nerCi7+s8qbJZZiB4iFxJJxQ/9X2QWpnV56HbV4T4n3CKAmauWC/Y/gKTWwBIT3pq63/y4V+HaNPv9lfhFthVs0D9NrgFdp3o3X5XIuWbLhz+5imazz+vPnOf2kRKY05ddkbTtli8eLF9grhw4UKbpv79+4fciIRTgFkXPNWaUqFANzbu0960HAMqTKsgomNaN4rat/39lwSlRTVO9D3tRyqE6GLr/05a1hMZg3N4+p3DIx1nsZ5LVEtcAV4VqNVHnPtdHevffvttsr8Z6XejSWNOXXZGU23q999/3/YPpX6fdZ5UEMRtkqjaFuE1J/SZgr4KBoseQCrY5m+aHMv1KKOuGXpoqxs1UeBG/Vvp5k83j24wTDeYekV7zVCwxt83mv/hkv9vf63FaERTBkiOv98r1Qx0b7r9aVRtGjeAqmCagq36DW2Lv/76yz4k999Q+7dHtNtOD3y1zylvlcdq5lyzZs3A+aPdRxUo0DbX9UA1xpQWfyDTv2zV+FG5XH0Yal7tA3///bfXJNU/v/YhtwKAfkMv7Ue6MXf3ATVtV9Pn8DKq+hPTeuhmXcFTlwIGaS3b+5sJqyufoGbC0eRhas5PKhP5+6Nzuf3GS3iFjIyWnvcXLpX7VCtWx68CxspDPVD2i2bbRZvGeFh2tOfzaPdnBejc85ZqFasmstbHXwM6rcdhaq6Jfg0aNLDrqa4NdM5wj1nV1l69enXIvDq21fWF+5BC39W5SA9tIvU5qniD25/k4MGDve+63C5tdF7XuUt57Q/EutcAPXRLLwQPkeuokOT2Z+Me7Hoi6S9MZgd6QuFW3dZJ1q2xof/dfg2U/qAgh58uhEG1IP1NfYOaWqSWavyFN9nWU2WdnM455xxvPvepq/gHefH3yxCJCnsuPf31P/0Jn66+tYJ+U4Vc96ZGfV/ogqKLkntDoc80T3JpzKnLziy6GKvJl9L41FNPedPVFMpP66en+rpJ09O0N99801arT69jQNN0E6CbHD3l83dSHJ4WFVhUyNB86udEF+qUjqnUricyBufw9D2HRzr3RHsuUTOelLhNKqM9tqNJY05ddmZR8071k6ZaaTr/ueugVgn+Wmu6odJNj27YRM0SdXMWXgMiLdej9L5m+MsK4c3N/GUH/9+pvWZou/uvDaoFFvS3AnaxiKYMkBx/uUs32u5AIf40VqxYMaSptyhgoG2hwJ5usBVYE+VLUMAymuugagQqb7UsBQHcmqCaHtRPWGr3UVFZU0ECDVikm2N/jeygtGgezauHHApousFmBYfVPDC5MqfSoVqJ4Z/FWkbV8eFuHwVR3G2kPA0PwurhZjTNhFOTh6k5P/nncSnf3HkUJG3Xrp3JTOl5fyHq31I1wRQMVpBYtTv9NVhd0Wy7aNMYD8uO9nwe7f4czXGoc6nb4lBBOKVXlP4ff/wxyXpGc01MrjzkD9z5u5jQOV61md0m2ToX6dwUqWynByZKm4KCblNlvbKFqMZmBrK5tWvXOiVKlLBDj1erVs357LPPvKHkmzdv7hw9ejRT0zN8+HBvKPS5c+cm+fzKK6/0Pu/YsaPz0UcfhUzzD0Uv7nStm3+49QIFCjidO3d23n77bWf27Nl2OPmEhARv/t69e4fM705v3bp1mtZv5syZ3rIqVKjgvPvuu84zzzzj5MuXz04rXry4s2nTJm9+DQcflB+NGzf2pl944YV2u40fP94pVKiQN90d5n7//v1OxYoVven333+/88EHHzinn366N03fdT377LPedM2jeR944AFvWuXKlZ2DBw/m6GXLwoULnffee8++SpUq5c33/PPP22nKU9e+ffu8eW+//XZv3vPOO8+brmPJ1aFDB2fEiBHOxx9/bD+74oorQrb7zp07vXm/++47p1ixYt7nd999t53mfyUmJsZ0DOh7Oo6fe+4554svvnBee+21kPxr3759yP45ZswY7zPtS6+++mqStPhFs56pPcYRHc7h6X8OX7x4sZM3b17vnKzjQMeO/tY0na+XLVsWuE9PmjTJm37RRRc511xzjfPSSy85X375pfP+++87l19+uTevrrWrV6+O6diONo05ddnav91z7DnnnBOyfd3pOj+7dN7WNP/14MQTT/Tm1XnfNWzYMLucqVOnOp988okzcOBA71qsNP7www/evJs3b3ZOPfXUkOtu+Lnxn3/+ifl6lFHXjO3bt3vrpFe/fv1s2UD/+8/1u3fvjumaMWXKFO+z6tWrOx9++KG9hhYuXNhO0/8bNmzw5ldZzJ0/JdGWAXQ9caer7OQ6fvy4U7duXe+zAQMG2P3k4osvDskX18SJE+33VT78/PPP7XYpUqSIN6/2F79otp327TZt2jgvvvii3Q4vvPCCU6VKFW/+O++8M2TZ0eyjcvbZZztPPPGEXb933nnHOffcc71l169f3zly5Ig3r5Z31VVX2XOW0vLUU085pUuX9ubXOdWfbne6XqNGjbLfuf76671p2lbKa/Ef/40aNbLnhDfeeMM54YQTvOnKg6Ay7W233WbLyq1atQrZx8Np+7ifX3bZZRH3o2jyUPuqe2xpHpWJtI/790MtI9ytt97qfa58jCSacmek/Tmj7y+mTZvmfUfXKO1P4ecX/7krmm0XbRrjYdnR3gNEsz/7r0M69nSs61j0p0/HsEvLcqe3bNnSptt/z9O0adOYr4l169Z1brnlFntN+eqrr5zJkyeHnJ90jnWvQ+I/j+ocqeuRf9m//PKLN+/KlSudk046yZv/xhtvTJIWpVd+++03u+3CX/7z25NPPmnzyc9fjkzN8ehH8BC5hi7yF1xwgXcwqJAkKrwEFR4yQ0qBhXXr1tlCt/8gd19Vq1Z1/v3335D5IwUPg77vvmrVquVs27YtQ4KH4Rds/0sXaRWuIs3rzw8VUv03BOEvncTdQpyokFewYMHAeVWA9geJVbjU94Pm1U2GTvp+OXXZkbZDLPtMeNCgYcOGgfMouPH9999H3OcjvfzbPppjQDctkZapC7m/sCPav1NKi1806xm0vgQP04ZzeMadw5M7LnXjHGle/3kgpePp3nvvTdP1LZo05tRlKz9TOidp+wYFp4Je/kJ///79I16LddPl57+Rj/TSesV6PcrIa4b2s+Tmfeihh2K+Zsi1114b8TsKivhFEzyMtgyQXLDlp59+8gLU4a/atWs7O3bs8OYNv5H0vwYNGpQkjdFsuyVLlkRctoILe/fuDZk/mn1USpYsGTi/gl+6wfabPn16xLTooUd45YHktrNe/vLrzz//7BQtWjTivAoAKzjsz5dIaVfw0R9U8AdKw+9fgkSbhwpuuJUowl89evRIMr8CO+66KgCigH0k0ZQ7ow0eptf9RUppDD/nRrvtokljPCw72vN5NPuzfueUU06JuFxVHvr111+9+Xft2uU0aNAgcF4Fu/0Bu2ividVSuDZPmDAhJO0pLdtflktNOcFfNgvin/fAgQNJPid4CDiOPVDdA+WGG24IOdm4T0JVyP39998zLb9SE1jYuHGjc8cddziVKlWyNQj1v94HFWqDLsiHDx923nrrLfvE9eSTT7YXfV3w69Wr5wwdOjTJBeOvv/4KKaym1bFjx2ze6wKip/IqYOomI/xmIrmLu6hQqloe5cuXd/Lnz2/XQ4XYRx55JPDEp8Kcar3oybK2a506dZxHH33UOXToUJJ59VRRy1GhWvPqiZWeAi1atChwnXLisjMyeKgntU2aNLFp1o2PbqD19M5fOzHWgkM0x4DyQ0/EFUzRk013Px85cqSzZ8+eJGmJNngYzXoGrS/Bw7ThHJ6x53DVOGnRooU9dvTS3+G1jsL3af95QDV/dP7RuUTpc49V1VQKf6ody/UtmjTm1GVnZPBQD+H0AFU1FpRm1VDUNTW8hnUsN0rRXo8y8pqhhwy6uVVwSjeAqp2iG1ud77WPpuWa4QZKFXBTzTaVaXRDev755wcGdNyypdYxtVJbBkgp2KIaJwqKlS1b1m7vGjVq2GBgeA151dy55JJLbMBN6dTvqhZxpGM2mm2n2i833XSTU7NmTXveUh7ru2PHjrVl03DR7KOiWkvaDipXKq8UOLjrrrucrVu3JplXwcROnTrZ9GpefUc1gV5//fWQh8/+7ax0NmvWzG5jPcAuU6aM065du8BtvXz5clsDSNtcade+oWNBweygVgmqha17Ea2r8lHbR/MqoBFu6dKl3rbWOgalN9Y8FNUUV7lc66ljQDW1VEtU5fdwyhM3LapZlZxoyp1z5szxpmt/yqz7i2iDh9Fuu2jSGA/LjvZ8Hu3+rAepOgfo2FO6db+oh31dunRxVqxYkWR+pe+ee+6x6VW69Ttajz/++CNN18Rx48bZ8pd+W+cbLVu11VXz8dtvv02SjtwUPMzz/34AQAYYMWJEktGP1PG0v8+WzOaObOV2IKz+JABER/1+uh0qu9TJs3+USeR8nMMBBNHgHeroXrdRGuU3rYPoAbnZmDFj7MAW6j9u2bJlpm7dulmdJCDuvP7667YfeL9u3brZ6anFgClAnHEDHgogEjgEgJyFcziQ9TSyuAKHGkDlgQceyOrkADniuqUKFAQOgZyLmodABtJIVP4R8KRSpUpJhobPTI0aNbKjM69YscJUrVo1y9IB5GTLly83u3btCplWv359b3Q35A6cwwEEGTBggHn22WfNe++9Z66++moyCYjg+PHjdjTdwoUL21FkS5QoQV4BWWDLli1m9erVIdM04vOpp56a6mUQPAQAAAAAAACQ/Zotq8r/5ZdfbipWrGjy5MljZsyYkeJ35s2bZ8444wxTqFAhc8opp0TVRhsAACA3oAwFAACAuAge7tu3zzRs2NBMmDAhVfOvWbPGXHrppeb88883S5cutU0Gbr31VjNr1qwMTysAAEB2QRkKAAAAmSXbNFtWzcPp06ebjh07RpznvvvuM59++qn59ddfvWnXXXedSUxMNF988UUmpRQAACD7oAwFAACAjJTf5CDz5883bdq0CZnWtm1bWwMxkkOHDtmXv9PWHTt2mDJlytjCNgAAQHL0nHXPnj22m5W8ebO00UbMKEMBAIDMlBvKT8ihwcNNmzbZEWH89H737t3mwIEDpkiRIkm+M3r0aDNy5MhMTCUAAMiN1q9fbypXrmxyIspQAAAgK+Tk8hNyaPAwFkOGDDGDBg3y3u/atctUrVrV7sAJCQlZmjYAAJD96SFllSpVTIkSJUw8oQwFAABiFa/lp9wqRwUPy5cvbzZv3hwyTe8VBAyqdSgalVmvcPoOwUMAAJBaObm7E8pQAAAgK+Tk8hP+T45qeN6iRQszZ86ckGmzZ8+20wEAAEAZCgAAALkoeLh3716zdOlS+5I1a9bYv9etW+c1l+natas3f8+ePc3ff/9t7r33XrNy5Urz/PPPm2nTppmBAwdm2ToAAABkNspQAAAAiIvg4c8//2waN25sX6K+CfX3sGHD7PuNGzd6gUSpUaOG+fTTT21tw4YNG5qnn37avPLKK3bEZQAAgHhBGQoAAACZJY+j8bPjrNPOkiVL2oFT6PMQAABQdqAMBQAAiL0gl/R5CAAAAAAAACDzEDwEAAAAAAAAEIjgIQAAAAAAAIBABA8BAAAAAAAABCJ4CAAAAAAAACAQwUMAAAAAAAAAgQgeAgAAAAAAAAhE8BAAAAAAAABAIIKHAAAAAAAAAAIRPAQAAAAAAAAQiOAhAAAAAAAAgEAEDwEAAAAAAAAEIngIAAAAAAAAIBDBQwAAAAAAAACBCB4CAAAAAAAACETwEAAAAAAAAEAggocAAAAAAAAAAhE8BAAAAAAAABCI4CEAAAAAAACAQAQPAQAAAAAAAAQieAgAAAAAAAAgEMFDAAAAAAAAAIEIHgIAAAAAAAAIRPAQAAAAAAAAQCCChwAAAAAAAAACETwEAAAAAAAAEIjgIQAAAAAAAIBABA8BAAAAAAAABCJ4CAAAAAAAACAQwUMAAAAAAAAAgQgeAgAAAAAAAAhE8BAAAAAAAABAIIKHAAAAAAAAAAIRPAQAAAAAAAAQiOAhAAAAAAAAgEAEDwEAAAAAAAAEIngIAAAAAAAAIBDBQwAAAAAAAACBCB4CAAAAAAAAyJ7BwwkTJpjq1aubwoULm+bNm5sFCxYkO//YsWNNrVq1TJEiRUyVKlXMwIEDzcGDBzMtvQAAANkBZSgAAADk+uDh1KlTzaBBg8zw4cPN4sWLTcOGDU3btm3Nli1bAuefPHmyGTx4sJ1/xYoV5tVXX7XLuP/++zM97QAAAFmFMhQAAAAySx7HcRyTRVTT8MwzzzTjx4+3748fP25rE/bt29cGCcP16dPHBg3nzJnjTbvrrrvMTz/9ZL7//vtU/ebu3btNyZIlza5du0xCQoLJCJs2bTKJiYkZsmzEplSpUqZ8+fJkHwAgaplRdohWbi1DAQCA3IFyQ+6SP6t++PDhw2bRokVmyJAh3rS8efOaNm3amPnz5wd+5+yzzzZvv/22bdrcrFkz8/fff5vPPvvMdOnSJeLvHDp0yL78O3BGUuDwso6Xmd37M/Z3EJ2EognmkxmfEEAEAOR4ubUMBQAAgOwpy4KH27ZtM8eOHTPlypULma73K1euDPzODTfcYL937rnnGlWYPHr0qOnZs2eyzZZHjx5tRo4caTKLahwqcFj3xvqmZAWeymcHuzbuNr+/s9xuG2ofAgByutxahgIAAED2lGXBw1jMmzfPPProo+b555+3zXX+/PNP079/fzNq1CgzdOjQwO/oqbz6VfQ/NVeznoymwOEJVctk+O8AAADkpjIUAAAAspcsCx6WLVvW5MuXz2zevDlkut5Hqh2mwq2a19x66632ff369c2+ffvM7bffbh544AHbZCdcoUKF7AsAACA3oAwFAACAuBhtuWDBgqZJkyYhHXers2+9b9GiReB39u/fnyRAqACkZOG4LwAAAJmGMhQAAADiptmymsJ069bNNG3a1HbePXbsWFuTsHv37vbzrl27mkqVKtk+d+Tyyy83Y8aMMY0bN/aa3Kg2oqa7QUQAAIDcjjIUAAAA4iJ42LlzZ7N161YzbNgwO0pxo0aNzBdffOF1AL5u3bqQmoYPPvigyZMnj/3/v//+MyeeeKINHD7yyCNZuBYAAACZizIUAAAAMkseJ87a+6qz75IlS5pdu3aZhIT0Hw1Zoxxece0VpsXd5zBgSjaxY912M/+p/5mPpn1kateundXJAQDkMBlddsgpyAcAAEC5IT5lWZ+HAAAAAAAAALI3gocAAAAAAAAAAhE8BAAAAAAAABCI4CEAAAAAAACAQAQPAQAAAAAAAAQieAgAAAAAAAAgEMFDAAAAAAAAAIEIHgIAAAAAAAAIRPAQAAAAAAAAQCCChwAAAAAAAAACETwEAAAAAAAAEIjgIQAAAAAAAIBABA8BAAAAAAAABCJ4CAAAAAAAACAQwUMAAAAAAAAAgQgeAgAAAAAAAAhE8BAAAAAAAABAIIKHAAAAAAAAAAIRPAQAAAAAAAAQiOAhAAAAAAAAgEAEDwEAAAAAAAAEIngIAAAAAAAAIBDBQwAAAAAAAACBCB4CAAAAAAAACETwEAAAAAAAAEAggocAAAAAAAAAAhE8BAAAAAAAABCI4CEAAAAAAACAQAQPAQAAAAAAAAQieAgAAAAAAAAgEMFDAAAAAAAAAIEIHgIAAAAAAAAIRPAQAAAAAAAAQCCChwAAAAAAAADSL3g4d+7cWL4GAAAQ1yhDAQAAIC6Ch+3atTMnn3yyefjhh8369evTP1UAAAC5EGUoAAAAxEXw8L///jN9+vQx77//vqlZs6Zp27atmTZtmjl8+HD6pxAAACCXoAwFAACAuAgeli1b1gwcONAsXbrU/PTTT+a0004zvXr1MhUrVjT9+vUzy5YtS/+UAgAA5HCUoQAAABB3A6acccYZZsiQIbYm4t69e81rr71mmjRpYlq2bGl+++23FL8/YcIEU716dVO4cGHTvHlzs2DBgmTnT0xMNL179zYVKlQwhQoVsoHLzz77LK2rAQAAkKkoQwEAACBXBw+PHDlimy1fcsklplq1ambWrFlm/PjxZvPmzebPP/+006655ppklzF16lQzaNAgM3z4cLN48WLTsGFD2wR6y5YtgfOrWfRFF11k1q5da3971apV5uWXXzaVKlWKdTUAAAAyFWUoAAAA5CT5Y/lS3759zbvvvmscxzFdunQxTzzxhKlXr573ebFixcxTTz1lmzEnZ8yYMea2224z3bt3t+8nTpxoPv30U1t7cfDgwUnm1/QdO3aYH374wRQoUMBOU61FAACAnIAyFAAAAOKi5uHvv/9uxo0bZzZs2GDGjh0bEjj09+kzd+7ciMtQLcJFixaZNm3a/F9i8ua17+fPnx/4nY8++si0aNHCNlsuV66c/d1HH33UHDt2LJbVAAAAyFSUoQAAABAXNQ/VzPjss882+fOHfv3o0aO2VmCrVq3sZ61bt464jG3bttmgn4KAfnq/cuXKwO/8/fff5uuvvzY33nij7edQzaM1UIua/yhNQQ4dOmRfrt27d0e5tgAAAOmDMhQAAADioubh+eefb5sPh9u1a5f9LKMcP37cnHTSSeall16yg7J07tzZPPDAA7a5cySjR482JUuW9F5VqlTJsPQBAAAkhzIUAAAA4iJ4qL4O8+TJk2T69u3bbX+HqaFmzfny5bMDrPjpffny5QO/oxGWNbqyvueqU6eO2bRpk20GHUQjQSuo6b7Wr1+fqvQBAACkN8pQAAAAyNXNlq+66ir7vwKHN998sylUqJD3mZog//LLL7Y5c2oULFjQ1h6cM2eO6dixo1ezUO/79OkT+J1zzjnHTJ482c6n/hFl9erVNqio5QVRGv3pBAAAyGyUoQAAABAXNQ/dpr96al6iRImQ5sCqLXj77bebt99+O9XLGzRokHn55ZfNG2+8YVasWGHuvPNOs2/fPm/05a5du9qagy59rubS/fv3t0FDjcysAVM0gAoAAEB2RRkKAAAAcVHzcNKkSfb/6tWrm7vvvjvVTZQjUZ+FW7duNcOGDbNNjxs1amS++OILbxCVdevWeTUMRf0Vzpo1ywwcONA0aNDAVKpUyQYS77vvvjSlAwAAICNRhgIAAEBOlcdRNcI4otGW9fRf/R8mJCSk+/I1UvQV115hWtx9jjmhapl0Xz6it2PddjP/qf+Zj6Z9ZGrXrk0WAgCyVdkhpyAfAAAA5Yb4lOqah2eccYbtj7B06dKmcePGgQOmuBYvXpxe6QMAAMjRKEMBAAAgLoKHHTp08AYecQc4AQAAAGUoAAAA5F6pDh4OHz488G8AAABQhgIAAEDuFNVoywAAAAAAAADiR6prHqqvw+T6OfTbsWNHWtIEAACQa1CGAgAAQFwED8eOHZuxKQEAAMiFKEMBAAAgLoKH3bp1y9iUAAAA5EKUoQAg1KZNm0xiYiLZko2UKlXKlC9fPquTASCnBw93795tEhISvL+T484HAAAQ7yhDAUBo4PCSDp1M4r6DZEs2UqpYYfPZzA8IIAJIe5+HGzduNCeddJJ9KhHU/6HjOHb6sWPHUrtYAACAXI0yFAD8H9U4VODwxA4PmqInVSdrsoH9W9aarTMfttuG2ocA0hQ8/Prrr80JJ5xg/547d25qvwYAABDXKEMBQFIKHJaoVIusAYDcFDxs3bp14N8AAACgDAUAAIA4Dx6G27lzp3n11VfNihUr7Pu6deua7t27e7UTAQAAQBkKAAAAOVveWL707bffmurVq5vnnnvOBhH10t81atSwnwEAAIAyFAAAAOK05mHv3r1N586dzQsvvGDy5ctnp2mQlF69etnPli9fnt7pBAAAyPEoQwEAACAuah7++eef5q677vICh6K/Bw0aZD8DAAAAZSgAAADEafDwjDPO8Po69NO0hg0bpke6AAAAch3KUAAAAMi1zZZ/+eUX7+9+/fqZ/v3721qGZ511lp32448/mgkTJpjHHnssY1IKAACQA1GGAgAAQFwEDxs1amTy5MljHMfxpt17771J5rvhhhtsf4gAAACgDAUAAIA4CR6uWbMmY1MCAACQC1GGAgAAQFwED6tVq5axKQEAAMiFKEMBAAAgLoKHQX7//Xezbt06c/jw4ZDpV1xxRVrTBQAAkGtRhgIAAECuDh7+/fff5sorrzTLly8P6QdRf8uxY8fSN5UAAAC5AGUoAAAA5DR5Y/mSRlquUaOG2bJliylatKj57bffzLfffmuaNm1q5s2bl/6pBAAAyAUoQwEAACAuah7Onz/ffP3116Zs2bImb9689nXuueea0aNHm379+pklS5akf0oBAAByOMpQAAAAiIuah2qWXKJECfu3AogbNmzwOgRftWpV+qYQAAAgl6AMBQAAgLioeVivXj2zbNky23S5efPm5oknnjAFCxY0L730kqlZs2b6pxIAACAXoAwFAACAuAgePvjgg2bfvn3274ceeshcdtllpmXLlqZMmTJm6tSp6Z1GAACAXIEyFAAAAOIieNi2bVvv71NOOcWsXLnS7Nixw5QuXdobcRkAAACUoQAAABCHwUO/9evX2/+rVKmSHukBAACIC5ShAAAAkGsHTDl69KgZOnSoKVmypKlevbp96W81xTly5Ej6pxIAACAXoAwFAACAuKh52LdvX/Phhx/agVJatGhhp82fP9+MGDHCbN++3bzwwgvpnU4AAIAcjzIUAAAA4iJ4OHnyZDNlyhTTvn17b1qDBg1s0+Xrr7+e4CEAAABlKAAAAMRrs+VChQrZpsrhatSoYQoWLJge6QIAAMh1KEMBAAAgLoKHffr0MaNGjTKHDh3ypunvRx55xH4GAAAAylAAAACIo2bLV111Vcj7r776ylSuXNk0bNjQvl+2bJk5fPiwufDCC9M/lQAAADkUZSgAAADERfBQoyn7derUKeS9+jsEAAAAZSgAAADEYfBw0qRJGZsSAACAXIgyFAAAAOJutGXX1q1bzapVq+zftWrVMieeeGJ6pQsAACDXogwFAACAXD1gyr59+8wtt9xiKlSoYFq1amVfFStWND169DD79+9P/1QCAADkApShAAAAEBfBw0GDBplvvvnGfPzxxyYxMdG+Zs6caafdddddUS9vwoQJpnr16qZw4cKmefPmZsGCBan63pQpU0yePHlMx44dY1gLAACAzJWeZSjKTwAAAMi2wcMPPvjAvPrqq6Z9+/YmISHBvi655BLz8ssvm/fffz+qZU2dOtUWpIcPH24WL15sR29u27at2bJlS7LfW7t2rbn77rtNy5YtY1kFAACATJdeZSjKTwAAAMjWwUM1TS5XrlyS6SeddFLUzZbHjBljbrvtNtO9e3dTt25dM3HiRFO0aFHz2muvRfzOsWPHzI033mhGjhxpatasGcsqAAAAZLr0KkNRfgIAAEC2Dh62aNHC1hQ8ePCgN+3AgQM2mKfPUuvw4cNm0aJFpk2bNv+XoLx57fv58+dH/N5DDz1kC9nqYxEAACCnSI8yFOUnAAAAZPvRlseOHWvatWtnKleubJsZy7Jly2yfhbNmzUr1crZt22ZrEYY/gdf7lStXBn7n+++/t819li5dmqrfOHTokH25du/ener0AQAApKf0KENlRvlJKEMBAAAg5uBh/fr1zR9//GHeeecdr5B6/fXX26bERYoUybCc3bNnj+nSpYvtF6hs2bKp+s7o0aPt03wAAICslhVlqFjKT0IZCgAAADEFD48cOWJq165tPvnkE9tXYVqoAJsvXz6zefPmkOl6X758+STz//XXX3aglMsvv9ybdvz4cft//vz5zapVq8zJJ58c8p0hQ4bYAVn8NQ+rVKmSpnQDAABkVRkqM8pPQhkKAAAAtswYbTYUKFAgpJ+etChYsKBp0qSJmTNnjunYsaNXmNX7Pn36JJlfBe7ly5eHTHvwwQftE/Vnn302MChYqFAh+wIAAMhK6VWGyozyk1CGAgAAQMzNlnv37m0ef/xx88orr9gn1mmhWoHdunUzTZs2Nc2aNbN9Ae3bt8+Ovixdu3Y1lSpVsk1n1B9QvXr1Qr5fqlQp+3/4dAAAgOwmvcpQlJ8AAACQWWIqtS5cuNA+3f7yyy9t3z3FihUL+fzDDz9M9bI6d+5stm7daoYNG2Y2bdpkGjVqZL744guvE/B169bZEZgBAAByuvQqQ1F+AgAAQLYOHqq2X6dOndItEWpiE9TMRubNm5fsd19//fV0SwcAAEBGSs8yFOUnAAAAZLvgofrTefLJJ83q1avN4cOHzQUXXGBGjBiRoSMsAwAA5HSUoQAAAJBTRdUe+JFHHjH333+/KV68uO2H8LnnnrN99wAAAIAyFAAAAOI8ePjmm2+a559/3syaNcvMmDHDfPzxx+add96xT9MBAABAGQoAAABxHDzU4CWXXHKJ975NmzYmT548ZsOGDRmRNgAAgFyBMhQAAADiInh49OhRU7hw4ZBpBQoUMEeOHEnvdAEAAOQalKEAAAAQFwOmOI5jbr75ZlOoUCFv2sGDB03Pnj1NsWLFvGkffvhh+qYSAAAgB6MMBQAAgLgIHnbr1i3JtJtuuik90wMAAJDrUIYCAABAXAQPJ02alHEpAQAAyKUoQwEAACAu+jwEAAAAAAAAED8IHgIAAAAAAAAIRPAQAAAAAAAAQCCChwAAAAAAAAACETwEAAAAAAAAEIjgIQAAAAAAAIBABA8BAAAAAAAABCJ4CAAAAAAAACBQ/uDJAAAAQObatGmTSUxMJNuziVKlSpny5ctndTIAAEAWI3gIAACAbBE4vKRDJ5O472BWJwX/T6lihc1nMz8ggAgAQJwjeAgAAIAspxqHChye2OFBU/Sk6lmdnLi3f8tas3Xmw3a7UPsQAID4RvAQAAAA2YYChyUq1crqZAAAAOD/YcAUAAAAAAAAAIEIHgIAAAAAAAAIRPAQAAAAAAAAQCCChwAAAAAAAAACETwEAAAAAAAAEIjgIQAAAAAAAIBABA8BAAAAAAAABCJ4CAAAAAAAACAQwUMAAAAAAAAAgQgeAgAAAAAAAAhE8BAAAAAAAABAIIKHAAAAAAAAAAIRPAQAAAAAAAAQiOAhAAAAAAAAgEAEDwEAAAAAAAAEIngIAAAAAAAAIBDBQwAAAAAAAACBCB4CAAAAAAAACETwEAAAAAAAAED2DR5OmDDBVK9e3RQuXNg0b97cLFiwIOK8L7/8smnZsqUpXbq0fbVp0ybZ+QEAAHIjyk8AAACIi+Dh1KlTzaBBg8zw4cPN4sWLTcOGDU3btm3Nli1bAuefN2+euf76683cuXPN/PnzTZUqVczFF19s/vvvv0xPOwAAQFag/AQAAIC4CR6OGTPG3HbbbaZ79+6mbt26ZuLEiaZo0aLmtddeC5z/nXfeMb169TKNGjUytWvXNq+88oo5fvy4mTNnTqanHQAAICtQfgIAAEBcBA8PHz5sFi1aZJseewnKm9e+V63C1Ni/f785cuSIOeGEEzIwpQAAANkD5ScAAABkpvwmC23bts0cO3bMlCtXLmS63q9cuTJVy7jvvvtMxYoVQwKQfocOHbIv1+7du9OYagAAgNxdfhLKUAAAAMgWzZbT4rHHHjNTpkwx06dPt4OtBBk9erQpWbKk91IfiQAAAPEqNeUnoQwFAACALA8eli1b1uTLl89s3rw5ZLrely9fPtnvPvXUU7bw++WXX5oGDRpEnG/IkCFm165d3mv9+vXpln4AAIDcWH4SylAAAADI8uBhwYIFTZMmTUIGO3EHP2nRokXE7z3xxBNm1KhR5osvvjBNmzZN9jcKFSpkEhISQl4AAAA5VWaUn4QyFAAAALK8z0MZNGiQ6datmy3ENmvWzIwdO9bs27fPjr4sXbt2NZUqVbJNZ+Txxx83w4YNM5MnTzbVq1c3mzZtstOLFy9uXwAAALkd5ScAAADETfCwc+fOZuvWrTYgqEBgo0aN7BNxtxPwdevW2RGYXS+88IIdZfDqq68OWc7w4cPNiBEjMj39AAAAmY3yEwAAAOImeCh9+vSxryDz5s0Leb927dpMShUAAED2RfkJAAAAmSFHj7YMAAAAAAAAIOMQPAQAAAAAAAAQiOAhAAAAAAAAgEAEDwEAAAAAAAAEIngIAAAAAAAAIBDBQwAAAAAAAACBCB4CAAAAAAAACETwEAAAAAAAAEAggocAAAAAAAAAAuUPngwgWps2bTKJiYlkXDZSqlQpU758+axOBgAAAAAAORbBQyCdAoeXdbzM7N6/m/zMRhKKJphPZnxCABEAAAAAgBgRPATSgWocKnBY98b6pmSFBPI0G9i1cbf5/Z3ldttQ+xAAAAAAgNgQPATSkQKHJ1QtQ54CAAAAAIBcgQFTAAAAAAAAAAQieAgAAAAAAAAgEMFDAAAAAAAAAIEIHgIAAAAAAAAIxIApAAAAALLMpk2bTGJiIlsgmyhVqpQpX758VicDAJCNEDwEAAAAkGWBw0s6dDKJ+w6yBbKJUsUKm89mfkAAEQDgIXgIAAAAIEuoxqEChyd2eNAUPak6WyGL7d+y1myd+bDdLtQ+BAC4CB4CAAAAyFIKHJaoVIutAABANsSAKQAAAAAAAAACETwEAAAAAAAAEIjgIQAAAAAAAIBABA8BAAAAAAAABCJ4CAAAAAAAACAQwUMAAAAAAAAAgQgeAgAAAAAAAAhE8BAAAAAAAABAoPzBkwEAqbFp0yaTmJhIZmUjpUqVMuXLl8/qZAAAAABArkDwEADSEDi8rONlZvf+3eRhNpJQNMF8MuMTAogAAAAAkA4IHgJAjFTjUIHDujfWNyUrJJCP2cCujbvN7+8st9uG2ocAAADZBy12sh9a7CC1CB4CQBopcHhC1TLkIwAAABAhcHhJh04mcd9B8icbKVWssPls5gc8dEeKCB4CAAAAAIAMo1YhChye2OFBU/Sk6uR0NrB/y1qzdebDtNhBqhA8BAAAAAAAGU6BwxKVapHTQA6TN6sTAAAAAAAAACB7IngIAAAAAAAAIBDBQwAAAAAAAACBCB4CAAAAAAAAyL7BwwkTJpjq1aubwoULm+bNm5sFCxYkO/97771nateubeevX7+++eyzzzItrQAAANkB5ScAAADERfBw6tSpZtCgQWb48OFm8eLFpmHDhqZt27Zmy5YtgfP/8MMP5vrrrzc9evQwS5YsMR07drSvX3/9NdPTDgAAkBUoPwEAACCz5DdZbMyYMea2224z3bt3t+8nTpxoPv30U/Paa6+ZwYMHJ5n/2WefNe3atTP33HOPfT9q1Cgze/ZsM378ePtdAAAy2qZNm0xiYiIZnY2UKlXKlC9f3sQLyk8AAACIi+Dh4cOHzaJFi8yQIUO8aXnz5jVt2rQx8+fPD/yOpqumop9qKs6YMSPD0wsAgAKHl3W8zOzev5vMyEYSiiaYT2Z8EhcBRMpPAAAAiJvg4bZt28yxY8dMuXLlQqbr/cqVKyPetAXNr+lBDh06ZF+uXbt22f93786Ym769e/faddq2Zrs5fOBwhvwGorN70x67TbRt2O7xg+0enzJju//7779m556dplLrKqboCUUz5DcQnf079pv/vllvt03Roum/Tdx9yXGcbLFpMqP8lFVlqOPHjpk96383Rw/uzZDfQOod2LrObo+MPJ8K2z3+tjvbPPthu8enjN7u2a38hBzebDmjjR492owcOTLJ9CpVqmTo7/494u8MXT6id+aZZ2Z4trHdsx+2e3zKlO3+O+f5eNvue/bsMSVLljTxIqvKUP+svClDl4/sdz4Vtnv8bXe2efbDdo9PlJ+Q7YOHZcuWNfny5TObN28Oma73kZodaXo086tJtL+Z8/Hjx82OHTtMmTJlTJ48edJlPXIrPSnQDcL69etNQkJCVicHmYBtHp/Y7vGJ7Z56emKuwGHFihVNdpAZ5SehDBUbjq34xHaPT2z3+MR2z5nlJ+Tg4GHBggVNkyZNzJw5c+yIyW5wT+/79OkT+J0WLVrYzwcMGOBN04Apmh6kUKFC9hXeqTpST4FDgofxhW0en9ju8YntnjrZqcZhZpSfhDJU2nBsxSe2e3xiu8cntnvOKj8hhzdbVq3Abt26maZNm5pmzZqZsWPHmn379nmjL3ft2tVUqlTJNp2R/v37m9atW5unn37aXHrppWbKlCnm559/Ni+99FIWrwkAAEDmoPwEAACAuAkedu7c2WzdutUMGzbMdtrdqFEj88UXX3ideq9bt86OwOw6++yzzeTJk82DDz5o7r//fnPqqafakZbr1auXhWsBAACQeSg/AQAAIG6Ch6ImNpGa2cybNy/JtGuuuca+kLHUXGn48OFJmn0j92Kbxye2e3xiu+d8lJ+yJ46t+MR2j09s9/jEdkc8yuMwbjYAAAAAAACAAP/XHhgAAAAAAAAAfAgeAgAAAAAAAAhE8BAAAAAAAABAIIKHsCZMmGCqV69uChcubJo3b24WLFjg5czBgwdN7969TZkyZUzx4sVNp06dzObNm8m5XL7dX3rpJXPeeeeZhIQEkydPHpOYmJilaUXaffvtt+byyy83FStWtNtUI9X7qQtcjXxfoUIFU6RIEdOmTRvzxx9/kPW5fLt/+OGH5uKLL7bneH2+dOnSLEsrkNNQfopPlJ/iD2Wo+EP5CQhF8BBm6tSpZtCgQXZk5cWLF5uGDRuatm3bmi1bttjcGThwoPn444/Ne++9Z7755huzYcMGc9VVV5FzuXy779+/37Rr187cf//9WZ1UpJN9+/bZ7aybniBPPPGEee6558zEiRPNTz/9ZIoVK2b3CT1AQO7d7vr83HPPNY8//nimpw3IySg/xSfKT/GJMlT8ofwEhNFoy4hvzZo1c3r37u29P3bsmFOxYkVn9OjRTmJiolOgQAHnvffe8z5fsWKFo11n/vz5WZRiZPR295s7d67d3jt37iTjcxFt0+nTp3vvjx8/7pQvX9558sknvWk6/gsVKuS8++67WZRKZPR291uzZo39fMmSJWQ8kAqUn+IT5SdQhoo/lJ8Ax6HmYZw7fPiwWbRokW2e6MqbN699P3/+fPvZkSNHQj6vXbu2qVq1qv0cuXO7I/6sWbPGbNq0KWSfKFmypG3Ozj4BAKEoP8Unyk8IQhkKQDwgeBjntm3bZo4dO2bKlSsXMl3vFUjQq2DBgqZUqVKBnyN3bnfEH3e7s08AQMooP8Unyk8IQhkKQDwgeAgAAAAAAAAgEMHDOFe2bFmTL1++JKMn63358uXtS000wkfadT9H7tzuiD/udmefAICUUX6KT5SfEIQyFIB4QPAwzqlJcpMmTcycOXO8acePH7fvW7RoYT8rUKBAyOerVq0y69ats58jd253xJ8aNWrYwq9/n9i9e7cddZl9AgBCUX6KT5SfEIQyFIB4kD+rE4CsN2jQINOtWzfTtGlT06xZMzN27Fg7NH337t3tgAk9evSw85xwwgkmISHB9O3b1wYTzjrrrKxOOjJou4vb5+Wff/5p3y9fvtyUKFHCDpajfQE5z969e73t6XbwvXTpUrs9tV0HDBhgHn74YXPqqafagvDQoUNNxYoVTceOHbM03cjY7b5jxw77QGjDhg3eAyJxa58DCEb5KT5RfopPlKHiD+UnIAxDTkPGjRvnVK1a1SlYsKDTrFkz58cff/Qy5sCBA06vXr2c0qVLO0WLFnWuvPJKZ+PGjWRcLt/uw4cPd3SKCH9NmjQpS9OM2M2dOzdwm3br1s1+fvz4cWfo0KFOuXLlnEKFCjkXXnihs2rVKrI8l293HdNBn+scACB5lJ/iE+Wn+EMZKv5QfgJC5dE/4QFFAAAAAAAAAKDPQwAAAAAAAACBCB4CAAAAAAAACETwEAAAAAAAAEAggocAAAAAAAAAAhE8BAAAAAAAABCI4CEAAAAAAACAQAQPAQAAAAAAAAQieAgAAAAAAAAgEMFDAAAAAAAAAIEIHgK5yM0332zy5MljevbsmeSz3r172880D9JG+ThjxoxUzfvJJ5+Y1q1bmxIlSpiiRYuaM88807z++utR/+aIESNMo0aNYkgtAABIDuWnzEH5CQByLoKHQC5TpUoVM2XKFHPgwAFv2sGDB83kyZNN1apVTXZ3+PBhk1uMGzfOdOjQwZxzzjnmp59+Mr/88ou57rrrbHD37rvvzurkAQCA/4fyU/ZB+QkAsh+Ch0Auc8YZZ9gC8IcffuhN098KHDZu3Dhk3uPHj5vRo0ebGjVqmCJFipiGDRua999/3/v82LFjpkePHt7ntWrVMs8++2zIMubNm2eaNWtmihUrZkqVKmUDZf/884/3JL9jx44h8w8YMMCcd9553nv93adPHzu9bNmypm3btnb6r7/+atq3b2+KFy9uypUrZ7p06WK2bdsW8r2+ffva75UuXdrO8/LLL5t9+/aZ7t2725p+p5xyivn8889Dfj81y+3Xr5+59957zQknnGDKly9va/25qlevbv+/8sor7RN093249evXm7vuusum79FHHzV169a16dG0J5980jz99NM2oCiqiai881PNRi3f/XzkyJFm2bJldppebu3FxMREc8cdd9h1KVy4sKlXr56t7ej64IMPzOmnn24KFSpk06rf9dO0hx9+2HTt2tXmSbVq1cxHH31ktm7dagOfmtagQQPz888/h3zv+++/Ny1btrT7hfY35ZnyHgCAnIjyE+Unyk8AEBnBQyAXuuWWW8ykSZO896+99poNqIVT4PDNN980EydONL/99psZOHCguemmm8w333zjBRcrV65s3nvvPfP777+bYcOGmfvvv99MmzbNfn706FEbHFSzXNWqmz9/vrn99tu9oFdqvfHGG6ZgwYLmf//7n02LAmIXXHCBDXYqaPXFF1+YzZs3m2uvvTbJ9xRwXLBggQ0k3nnnneaaa64xZ599tlm8eLG5+OKLbXBw//79dv5olqtgqIJ7TzzxhHnooYfM7Nmz7WcLFy60/yt/N27c6L0PpyDskSNHAmsYKtinoNy7776bqvzp3LmzDToqCKjf1EvTtH0UCFW+vf3223YbPfbYYyZfvnz2e4sWLbLrptqOy5cvt0HQoUOHJmk2/cwzz9ig75IlS8yll15q80zBRO0LyseTTz7Zvnccx87/119/mXbt2plOnTrZ7T516lQbTFQQGACAnIryE+UnofwEAAEcALlGt27dnA4dOjhbtmxxChUq5Kxdu9a+Chcu7GzdutV+pnnk4MGDTtGiRZ0ffvghZBk9evRwrr/++oi/0bt3b6dTp0727+3btyua5MybNy/Z9Pj179/fad26tfdefzdu3DhknlGjRjkXX3xxyLT169fb31q1apX3vXPPPdf7/OjRo06xYsWcLl26eNM2btxovzN//vyYlytnnnmmc99993nvNf/06dOd5PTs2dMpWbJkxM8bNGjgtG/f3v49adKkJPNq+f5T9PDhw52GDRuGzDNr1iwnb968XtrD3XDDDc5FF10UMu2ee+5x6tat672vVq2ac9NNNyXJs6FDh3rTlH+aps/cfeT2228PWe53331n03LgwIGI6wwAQHZE+Ynykx/lJwBIKn9QQBFAznbiiSfaGmSqYaZYl/5WDT2/P//809bIu+iii5L0Oehv3jxhwgRbc3HdunW2H0V97g7coWa9apqspsZaTps2bWxNtwoVKkSV3iZNmoS8V/PcuXPn2tp54VTr7bTTTrN/qzmtS7XtypQpY+rXr+9NU1Ne2bJlS8zLFa2Pu4zsZOnSpbZmqJvucCtWrLBNj/1Uw3Ds2LG2SbpbQ9G/vm6eRcpHNeNWPqrG4TvvvOPNo/1MNSHXrFlj6tSpk85rCgBAxqP89P+j/ET5CQDCETwEcnHTG7cZqQKA4fbu3Wv///TTT02lSpVCPlP/eKKBV9TsVv3ktWjRwvYjqP763L763Oa76u9OTYDVfPXBBx+0TXzPOusskzdvXq+pq0tNecOpiXB42i6//HLz+OOPJ5nXH5gsUKBAyGdqLu2f5jafVlArrct1l5FaCujt2rXLbNiwwVSsWDHkMwVgFaw8//zz7fvU5lM49TeYHoLyLKV8VNNrbfdwOWFQHgAAIqH8RPkptSg/AYgnBA+BXEp90ilIpcCPOwiJnwbwUJBQNQrVZ2EQ9aWn/gN79erlTVPQK5xqKuo1ZMgQG2TUyM4KHuoJvgYoCa8tFx6cC+q0XAN9aDCP/PnT7zSVXstV+lVzLznqD/C+++6zgdfwQUrUr6MGF7n++uvte+XTnj177DQ3kKp88lOfkOG/qRqD//77r1m9enVg7UPVANQ29NN7zevWOow1H9W/ogaAAQAgN6H8lBTlJ8pPAMCAKUAupeCQmq0qyBMUKFItQtUq1CApGiBEQUENjjFu3Dj7Xk499VQ7sMisWbNsgEqDbfgHCFETVQUMNVCKRlj+8ssvzR9//OE1W9XgJPq+BmXR9OHDhycJJgbp3bu32bFjhw2u6feUNqVBg76kFLTLjOUq+DhnzhyzadMms3PnzsB5VANPg62oifADDzxgVq5caX9vzJgxdiRnDYDSvHlzO6/+L1q0qB2MRvMo+Bo+qIl+U/mtoKJGhz506JAN+rZq1coGKlXbU59rdGnVAhX9htI5atQou/20XcePHx84iEs0FBT94YcfbM1WpUfbdubMmQyYAgDI8Sg/JUX5ifITABA8BHKxhIQE+4pEQSUFBDXqsgJ+etquZsw1atSwn6tp6lVXXWVH9lWAa/v27SG1EBXwUlBMwSvVZtNIyypg6nuiGo9avoJlZ555pq1dp1F7U6Jmvqohp4CeRkxW/3sDBgwwpUqVsk18Y5Vey1VNQgXrqlSpEtI/ZDgte/r06ea7774zTZs2NfXq1bOBwRdeeME89dRT3nzqO1KjJX/22Wc2TRqFWSMj+ymPtX3U1Fk1Fd2RmlWTUnmrgKhqkyqv3UCoagpoZGw1P9dva7RsjRytfirTQjUeNSK3ApItW7a0eaBlhzfPBgAgJ6L8FIryE+UnAMijUVPIBgAAAAAAAADhqHkIAAAAAAAAIBDBQwAAAAAAAACBCB4CAAAAAAAACETwEAAAAAAAAEAggocAAAAAAAAAAhE8BAAAAAAAABCI4CEAAAAAAACAQAQPAQAAAAAAAAQieAgAAAAAAAAgEMFDAAAAAAAAAIEIHgIAAAAAAAAIRPAQAAAAAAAAgAny/wFFhDUyCD3zwAAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -411,7 +427,7 @@ "ax = axes[0]\n", "values = [counts_angle.get(b, 0) / SHOTS for b in basis_labels]\n", "ax.bar(basis_labels, values, color='#4CAF50', edgecolor='black', alpha=0.8)\n", - "ax.set_title(f'Angle Encoding\\nx = {x_angle.tolist()}', fontsize=12, fontweight='bold')\n", + "ax.set_title(f'Angle Encoding\\nx = {format_list(x_angle)}', fontsize=12, fontweight='bold')\n", "ax.set_ylabel('Probability')\n", "ax.set_xlabel('Measurement Outcome')\n", "ax.set_ylim(0, 1)\n", @@ -420,7 +436,7 @@ "ax = axes[1]\n", "values = [counts_amp.get(b, 0) / SHOTS for b in basis_labels]\n", "ax.bar(basis_labels, values, color='#2196F3', edgecolor='black', alpha=0.8)\n", - "ax.set_title(f'Amplitude Encoding\\nx = {x_amplitude.tolist()}', fontsize=12, fontweight='bold')\n", + "ax.set_title(f'Amplitude Encoding\\nx = {format_list(x_amplitude)}', fontsize=12, fontweight='bold')\n", "ax.set_ylabel('Probability')\n", "ax.set_xlabel('Measurement Outcome')\n", "ax.set_ylim(0, 1)\n", @@ -445,7 +461,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "c03f26fa", "metadata": {}, "outputs": [ @@ -454,7 +470,7 @@ "output_type": "stream", "text": [ "=== QUANTUM KERNEL FEATURE MAP ===\n", - "Input: x = [0.699999988079071, -0.30000001192092896]\n", + "Input: x = [0.7, -0.3]\n", "\n", "Circuit structure:\n", " Layer 1: ('RY', [0], tensor(0.7000))\n", @@ -482,7 +498,8 @@ "kernel_circuit += [(\"CNOT\", [0, 1])] # Entanglement\n", "\n", "print(\"=== QUANTUM KERNEL FEATURE MAP ===\")\n", - "print(f\"Input: x = {x_kernel.tolist()}\")\n", + "print(f\"Input: x = {format_list(x_kernel)}\")\n", + "\n", "print(f\"\\nCircuit structure:\")\n", "for i, op in enumerate(kernel_circuit):\n", " print(f\" Layer {i+1}: {op}\")\n", @@ -493,7 +510,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "48dee4a6", "metadata": {}, "outputs": [ @@ -578,7 +595,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "73880b24", "metadata": {}, "outputs": [ @@ -613,12 +630,6 @@ " (\"RZ\", [0], 0.7),\n", "]\n", "\n", - "gate_durations = {\n", - " \"RY\": 1,\n", - " \"RZ\": 1,\n", - " \"CNOT\": 2, # Two-qubit gates typically take longer\n", - "}\n", - "\n", "print(\"=== ORIGINAL CIRCUIT (No Noise) ===\")\n", "for op in vqc_circuit:\n", " print(f\" {op}\")\n", @@ -629,7 +640,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "50aa648a", "metadata": {}, "outputs": [ @@ -637,22 +648,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "=== NOISY CIRCUIT (T1=100μs, T2=200μs) ===\n", - " T1T2_NOISE on q0: λ1=0.0100, λ2=0.000000, idle=1.0μs\n", + "=== NOISY CIRCUIT (T1=100μs, T2=80μs) ===\n", + " T1T2_NOISE on q0: λ1=0.0002, λ2=0.000094, idle=0.0μs\n", " ('RY', [0], 0.5)\n", - " T1T2_NOISE on q1: λ1=0.0100, λ2=0.000000, idle=1.0μs\n", + " T1T2_NOISE on q1: λ1=0.0002, λ2=0.000094, idle=0.0μs\n", " ('RY', [1], -0.3)\n", - " T1T2_NOISE on q0: λ1=0.0198, λ2=0.000000, idle=2.0μs\n", - " T1T2_NOISE on q1: λ1=0.0198, λ2=0.000000, idle=2.0μs\n", + " T1T2_NOISE on q0: λ1=0.0020, λ2=0.000749, idle=0.2μs\n", + " T1T2_NOISE on q1: λ1=0.0020, λ2=0.000749, idle=0.2μs\n", " ('CNOT', [0, 1])\n", - " T1T2_NOISE on q0: λ1=0.0100, λ2=0.000000, idle=1.0μs\n", - " ('RZ', [0], 0.7)\n", - " T1T2_NOISE on q1: λ1=0.0100, λ2=0.000000, idle=1.0μs\n" + " ('RZ', [0], 0.7)\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABWoAAAEbCAYAAABDf70FAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAhT5JREFUeJzt3Qd4FOXWB/D/1nQChISE0HvvCCgiKKCIgr1eRRTFir1d+8e1YsFer4jlgg1FAQUEpEiH0HtJSEIaCenJ9u85E3azm8JuIGF2k//vefbJzmZm992Z2Xd2zp45r8bhcDhARERERERERERERKrRqvfSRERERERERERERCQYqCUiIiIiIiIiIiJSGQO1RERERERERERERCpjoJaIiIiIiIiIiIhIZQzUEhEREREREREREamMgVoiIiIiIiIiIiIilTFQS0RERERERERERKQyBmqJiIiIiIiIiIiIVMZALREREREREREREZHKGKglIiI6SxITE6HRaFy3v//+2y/X/VdffeXRTn902223udo3YsSIs748+adA2HefeuopV/t+/PFHtZtDRDUwbtw45bOr0+mwe/durjsiIqp1DNQSEVGdueSSS1wBiSZNmsBkMlU5n8PhQIcOHVzz9uvXr9I8hw8fxhNPPIEBAwagadOmMBqNaNasGYYOHYrnnnsOx44d89qe7du3Y+rUqcrzy3MYDAalXeeccw4ef/xx5f81Je2SwMuQIUMQHR2tPGejRo3Qt29f3H///Vi9ejXqk0AIhJ3tIOyLL77osU58uUkbhcViwTvvvIObb74ZXbp0gVarrXHbhw0bpsz/+uuv17gdztc4cOCA0o4rrrgC3bt3d33G4uLicPnll+O3336r8Xqp+FoffvhhpXkGDhzYoALm0k+99957yn3p866++mrlvrz3mm47+SyKlJQU/N///R/Gjx+PFi1aeMwj+2Zdyc3NVfa5a6+9Fm3btq1y/z7Vss8++yx69uyJsLAwpc+Uvv2NN95AaWlptcv98MMPGDVqFKKiohAUFKS87h133KHsv4GkpttabvJDX1FREWbPno0pU6Yo6ys+Pl75nEZGRmLQoEF4+eWXUVhYWOvttVqt+OWXX/Dggw8qx7rWrVsjODgY4eHh6N27N5588klkZmZWu/z+/fuV7STbS7abHLtHjx6tbM/qyH4g+4O8T9k/ZD+R/UX2m7y8PKhFvisIu92Of//736q1g4iI6jEHERFRHZk9e7ZDDjXO208//VTlfKtWrfKYb8aMGR7/f+ONNxx6vd5jnoq34OBgxxdffFHl85eUlDjuuuuuUy4vtzZt2vj83mw2m+P555936HQ6r8/rlJeX55g+fbrrdvToUYc/2rlzp0c73c2cObPK93a2/fHHH672zZkzx+N/EydOdLXvggsuqHJ5X+bx1QsvvOB1H6h4k9cXJ06cqHYeX9qVnp7u0Gq1DqPR6Hjvvfdq3A7na0yZMsXrvPfee2+N1kvF5ePi4hxFRUUe8wwYMKDWtoO3fdcfPPDAA673+84777gel/de020nn0Xxyy+/VDuP7Jt1JSEhwev+XZVDhw4pfW11y/br189x/Phxj2XsdrvHZ7aq/n/BggWOQFHTbS23I0eOONauXet1vo4dOzpSU1Nrtb1paWleXzc6Olr5/FUk20W2z6n2Fdm+7mT7y35Q3TJt27Z1HD582KGW3r17u9qyefNm1dpBRET1k17tQDEREdVfkp3XuHFjJXtKfP31164MMnfyuJNkpEp2odObb76pZNI6SQbsDTfcgJYtW+LgwYOYM2cOSkpKlOybyZMnK1k+7svbbDZcd911+P33312PSfbRVVddhY4dOyrLSSbt4sWLa/TeJFv2448/dk3L61555ZVKNqJkH+3duxd//vmnR+aPZAU99thjOB0FBQWIiIjA2dCjRw/l5u/Z2nLzB2PGjFEyy9zJviHZ1s59tmLmlWSGue/zsr4lu3Tp0qU4cuSIz68tma6S2XXhhRcqt+nTp3v8//vvv8emTZtc0xX/36pVK4/pdu3aKetVMjPlsl7JeJPPkPjoo4+UfVwyGk9HWloa3n//fSX7riHuu9JPOfs6yZyWfsnpnnvuwWWXXVZl5p6QfeP666/3+L9kUDrJ/idXCsh8khl9tki/JxmV8rqS6XnixIlTzi/7qvTfSUlJyrRkbt91111KP/zpp58q6yghIQF33323R1mIDz74ALNmzXJNy3NIXyv9v+ynsvxNN92EXbt2KVmm/q7i5/DQoUP45JNPXNOyrWWdupN1lZ6ertwPDQ1VPqd9+vRBfn4+vvvuO9f/5Lgox8xvv/221tstfZV8/mXfk6sBZBvJ64msrCwl09f9KpLU1FTceOONrixp2Way7WSbybYTsl3l+e677z7XcrJPyH4gQkJClOeVfe3zzz9Hdna2kl0sz7N27Vrls3S2yWs7r8CR/VZuREREtUbtSDEREdVvd999tyvzxGAwVMqUKi0tdTRu3Ng1z5VXXun6X1JSkpIp6Pxf69atHSkpKR7Lb9++3REREeGap2nTpo78/HzX/z/55BOPTJyhQ4c6srKyKrUzJyfHI8PtVP7880+P5+zcuXOV2T2SPfjaa6+5piUjyn255cuXV5mVKdlmsp4kgzE+Pl7JmHRvW2FhoTI9fPhw5f3Kem3evLky/cEHH/ic/VpVdl51y1Vs++lk70mmtHPedu3aefxPtovzf/PmzXM9LtmyzsdlO1sslmozYiu2u6qbc51XXF72iXvuuUfJ+pR9rmvXro7PPvvMcbrcMyRPlaktmWTyGahqOV8yTC+99FJlXtnPq1IxC7E677//vuP333+vlNn25Zdfeiz/yCOPOHxV1fpv0qSJIzc31+eMWvlcvvTSS8p8jRo1Uvb1Fi1aKP3E4sWLK81/qn1etvGjjz7q6N69uyM0NNT1uRk0aJDjvvvuU7IVK9q6datj0qRJjvbt2ytZgWFhYY6+ffs6Xn75ZeVzWBPffvutq13nnnuu1/krZh1WR/YfyfCvarm6zKg1m82uz6Nwz5Ktrr2SXenePvdtKJ839//t3r1beVxeQz6Xzsdvuukm1zLZ2dke/f8TTzxR7b4gfZgv/Z9YuXKl44orrlD2NdlPZLvL+7vkkkuUdeq+D9cG6ZdO1R73493//d//KZn47jIyMpSMVvfjYG2Sz85DDz2kZNa6Ky4uVvpK97bLlSNOjz/+uEf/LdvLSbaj83+ynq1Wq/L4rl27PJ7PvR+W/cX9fwsXLqyyr6vY51ZcvxX3BVnf0v9ERUUpV+/IdxI5rl933XWODz/8sNL62L9/v8f7kqt2iIiIagtr1BIRUZ1yr1UoGTjOLBonyXR1ZtxWnH/mzJkwm82u6eeff75StlSvXr2U7FannJwc/Pzzz67pGTNmuO5LRs5PP/2k1MerSLIeH3roIZ/ek/tziv/9739KJmJFkvV0OtmDUodQ6o5KBqNkJEkWmpNkaUrm3MMPP4yVK1cq71fWa0ZGhjItGUf+auTIka77kjXqrCssWXSbN292/W/VqlVV3j///POh19f+xUCSiSYZXZIFK1mfss9JRrRkdX355ZeoS1J7Umo2nm6WtWTgynNMmDDhjNohnyHJ6KxYd1jqj7pz/zzWRGxsrPJXMi4rZhNWZ8+ePUq25gsvvKDsH5I5KPu67DdSL1MymX39zEpGn3ym3nrrLSWbr7i42PW52bhxo1I/99dff/VYRvYHyWqUfkg+d/Ic8tncunUrnnnmGaW2tTOL0RfuWfvnnnsuaovsP6eTVVjTurgV691KdmVNP4/utY7lCgP37OyKV1s455WMcPlcVjWfZJm61zY+nVrKFclnSvoq2R9kX5P9RLa7ZAHLVRIvvfSSR3vOJjneSU12uVLFXUxMDIYPH37Kz2lNa+K6D3Ypx0zJ1HZ+jp0k21UG13In66uq7SHbSbZXVdtR1rMz87/iNnSfT/YX2W+qev7TJfv1pEmTsGLFCiVbV66Ike8kUldXriiQ+s8VderUyfU9QvrhdevWnXE7iIiInFj6gIiI6tTgwYPRrVs3Jegi5NJf90sc3cseyMnmpZdeWmWQrqqgkftloq+++qprWi69lICvnPxJwM3p4osvVi7pPhMSNHU/gZVLT2Wwk9p0/Phx5SYnpeedd55ySWnz5s2VS9ClnIT7wDkSYLzooouU/61fv14JZtUFOcGWAJucTMvl9E7uQTdvwScJMsjJrbw35/aVbSftdg8sSMC5qn3APdBbFVkX0h73y/3bt2+vXFbuJAM4VbRv3z4liC/zSeBBAnQSPBYymM3tt98Of/THH38oA/TJgHoVAyi1xf3zIyQ4eTpkOy9YsEC5TFp+6JBB/eTzXh0JlkiZBRkoS8gI67fccotS8kQCaDt37lQef/fdd9G/f3/ceuutp3z95cuXK9tZyLaWgY3kRx8JtEqbJEjjbs2aNUrw2vkjiQygJJeaS1BGLtWWfVgCvvK6vpZNcd+XK17W3lC4D9goP265/zAgfYyUpXGWi3HOW3GQR/lMVzctwTX5TJzujx/is88+c5X76Nq1q3LckYD00aNHlSD9li1b4I+c+/eZfE7PtI+QbSEDvQnZDrI93P/nruK0bGf5vuC+vWV/cA/uyv4i+822bdtcy5wp9xJGcsyVgLIE5pOTk5XvEs5jQUXyGZbAvfOz3RAGQyQiorODgVoiIqpzEjR1ZpZu2LBBOXnr3LmzEuxwnugIqS3rnqHlzLgUkkHknknjrk2bNh7TzmwnyUZ1JyfdZ0oybtxHJa+N56yKZApWrDUp2cc7duxwTUvGp9Q1dA92OOui1jZnfV0Zad49UFuTmrvSTjmZlaxm90CtM4AlJ/iyfiUQIifKkpnlDMgJqcHqS31SWcYZqJUarL60UTK9nVmpMqK5M1NTgh9nsz5wTTgzQCV4Xxdk9Ph7773XY193r6taE/K5lsw0qSMq21ZGp5cga3Xmz5/vEXiS2rbOgLvU+5Uff5x1Tt9++22vgVr3z+wFF1yg1Dx1J0El5w8IztrYziCt7LOSZenMWpV91hkIW7JkiRIskszfU5HAn9TVrK42sBqqqot7KrWRBSxXADhV1Z/L58wZqJW+oOIyVS3n/tmUbSZZ22fyw4X7viLZ3FKP1J0E96s7Fqnl9ddfd/WVsp8+++yzlebxNZP9VD9qVSTHAvkBxv2qFyfZDmUVJrxvt+q2d3X7SMVlzoT79v7mm28q7TvVHVPlRyP3GsNERES1hYFaIiKqc5IJJ8EVZ5aSnAxNmzZNCY65XyYplx9WRzIdfeV8nUBW1Ym2+yAtQtZhxUvVK2Yp+RvJinUGap3vx/lXBoN77733lAwmuZRU/jqDZVKaom/fvnXSJsmydi8d0KVLF4//S8DB3wK18rlZuHBhnQVqJRg1fvx4pSyAcx3JDwVnkqkoAS8JKEk2nPzA8Oijj1Y7rwwS5M49ECt9gQSMnYEnCZRKKQMpNXKqbGtpuwRkFy1apAT0JbgqPxhJKRHJSncvq/LPP/+47ksGvWT0Vkeyb70FaiWg5B60cs8SVEvFwcnONvf1carHvM3jyzI1ISVWnJfUy4+MMlCU7CfSL8gVDhKkr9jvqkXeuwST5VjgJH1oVVcfnO5AltWR9eJedkgGv5s4ceIp23qqaV+W8XW5mm5vZ7BZBnmUrF4pbSB9hKxHGXS0Ks7MYSFXvRAREdUWBmqJiKjOxcXFKfUk5VJtIaNRS3ade9kDuXxZLo13J5ktzpIJciIkmS9y2XJFzsy6ipkuFevZVryM+3TIyZm0wZmFUxvPWZGUB3A/CXRyzzSSoNSpLh2vipzgOgMMErBSg3tWrGQHSwDLGZST/0kZBAmMSfmDilmQdTW6d9u2bT2mKwYj3WsE+wu5lF8yD2UUdQki1SbZLpJpKZd6OzPrJLjpS4bdqci+95///AeXX365UuqiYs3T6vb18PBwhIWFefxfSoG479dSU/JUgVrpEyQb/IEHHnCVLZCb+2tIfWdn9mTFLM5TCdQgjWRDyuXdNcmoPdOsWvd+TTLVK3J/zFkDtGJfWHE592npI+RHnTMh2fQS/Jfa49JPSn/kXu5GgnlS7kKOa2qStsmPm7Nnz1am5ccE+QFEfvCqimSJ1zSQX1Xmt/SHTzzxhFLv2UmCxRU/z7Id5DPvDKyeartVt7193UfOtPSB/PAjPw7K8cj5A5iT/E/WccXjT20HjImIiJwYqCUiorNCMpOcgVq5BFiCIs5sPef/q8p0kYCUs2alBIuqGjRJBvyouJwzC1Au13YGU2V5KYtwJifYcrIml0I7SzZIdmBCQoKSlVdbKgalqsrCkwzCzMzMUwZrK55YSoaqM5jlXuf2bJLtIetftoOc8MuAaXLiLUEGqbUq206CIlIOwb02oLf6tGdCBkVy5y/Zcqcig2nVRTat7NcSmHAGQ6Q2q2QXRkdH18rzSwBYgn2ShSo/1FSXWer+uJRgkHIJ7p8LGQTMfXtVHFypKhKElYGJpPyKBKPlMyD9i3x+5TWkbq20T4K28vry+RIyCNmpBmvzJXgpz+cetJIsbbVJgKpibd5TkWDcmQZqJfNYtr1zQEH3H48k4O1eY9v5w13FbGW5FN09u979snP50aK6rG/3Otin+qFKynTIvimBSGmrlOCQm3zmZLtJiYGnnnpKqVWsFllX8tl3rkvZZ+U4OHbs2GqXkYzXmpAarBUDtXLckfIl8+bNc/WdEhyuqo63bAfJQnYefyuWEKhYLsB9e0uQXMiPURI8dQZv5Zgh+03FZSqqOJjaqba3vEf5sVBqVUvfIP2C9A/yHuV7h6xXqU9d8Yof9x9zaqt/JCIiEnWTmkJERFSBBDrcM50efvhh132j0aic/FUkJ0buQTTJ4qmYvbZr1y6PepOSYeM+SvSDDz7oui8ZmjIwTFXZcnICLoMc+cL9OYW0vWJWr/OkVi71ri0SMKoYOKmY1ePejorBK+fI1HKy6z742pkENeU91pR70FUu0xUSeJHyAs4gu7R18+bNPtenra6Np9M+fyfb3Hlpdm0GaiVoLoFKZ5BWPkfLli2r9SDEK6+84ipRUl02asWAoHv2vQTw3X+ckQH9TpVNK+QzL58N2Tfk8vW7775bCcRJ7Vn3fcVZF9f99aUMhNSDlkvH3W8yKKL8UOJL8FKCf1L72Kkmmaz1iZTTcJKg7F9//eWadpZEcXIGxyVg6D4I5M8//+y6L9nR7tmupwqou/8wKAG56srlyD4g+4Ls9/J8ctz573//i+eee841j/uAYvL6Emx23txrEdcFCXzKDyjOIK1cOSI/bJ0qSFsb5Me14cOHu4K0MtCXZJ+earBF9+0t68n92Pvjjz+67st7cA6wJxn37ubOneu6Lz+2umfUVre95Ycc98/Yqba3/Ngqx0QpcSDHcjmuyr7oPrBpVQPIuT+/v5ccIiKiwMKMWiIiOisku+bGG29UgkEVA2hyYlbVpf5ySbqUSHj66aeVaRmETC71lsw4OXGXDBi5JNGZeSlZmVJWQbKLnO68804lqOXM5pXak3IJ91VXXaX8leCtXOYql7JK0MU5iNSpSHaNBG5kdHDnibMMbiSj1Ev7JAtHSjZIdqJkBDkHUjtTcuIoGUTOAcUkk0myASWIKcE7OZmULEB5TAwYMMAji0/es5SgkEDE6Y6WXbGchJzYSqBKsnelFrH7JemnCtQ6M6acAzg5A7SSVSvb0T2bVraL1As8nTZKsFcC65I1JT8ITJ06Ff7GvXake5aZ3Hf/n/PSZQk6yEB7cjm/M7hxpiRo6f5asg6lVuOHH37oMZ+sxzOtbSplLC6++GIl6FKdcePGKdl4zsCplCyQQJu0SwZRc/9Bwv1Hn+pI3yH7ltSqlcCu9B8SPHUfzND9xw2pnysBKfnsSD8jl7vL50f2b/lMy2dQslEl09fbQGZOEiB2tls+q6c7MFtFsp+4j1zvTvo1yRYW0t85B2QT7gHO0yE/bsmgcO7TTjKYn3N/kmxiqVEuZLvLNnAGTaUvnzJlitIPu7+Ha665xjVQo/QHcgyQfUBI3yGBNelrpf+XbeAMHJ7q8y0D48l6l2PRl19+6fG/mTNnKkF82ZYyiKPUUZe6xe3atVO2uQQY3X8s8CWDuy7Itpb9WEp9COnfZV1JwNs96C3kGOU+GNeZXKovrye1eVNSUlyPyY9EW7duVW7VlUyQ7SHHKQnKS4BV+nnZ5lJ2xP3HFtm+zjrQsl3lRyJnQF76bzmeSskhqYvrJO2R41lVZP+Q46J855Afgypu75deekkJMMvVMdJe+UzLcUn6F9lfZT27l0Coanu7/5DoPH4RERHVCgcREdFZsmHDBjlTrHT7/fffT7ncK6+84tDpdFUu67w1adLEMXv27CqXLyoqctxxxx2nXF5ubdq08fm9WK1Wx9NPP+3QarVen9fpyJEjHo8vX77c9b8XXnjBp3YcOnTI0bFjx2pfq0+fPh7z/+tf/6pyvksvvdRjeubMma5l5H5V7RelpaWOuLi4Kp9z48aNPq07eQ8Vl/35559d/x84cKDH/6677rpKzzFx4kTX/y+44AKP/yUkJFS5XcLCwnxaXraL+3Ky3WpKntPX/crb/lNxOzz11FPK9H333ee1He7v81Rf+yrOV92t4rry9X09+uijHv/btGmTQ6PRnPK5d+/e7WjZsuUp2zN16lSPZarbd9euXev1vV111VUez/Xhhx869Hq9z9vFG/e2DR8+vEbrT7ZPdSrur7Wx7XxRsT+r7lZx/5fPvzxW3fx9+/Z1HD9+3GMZu91+yn00ODjYsWDBglPuCxVv7dq185ieMGGCstyUKVNOuZz0Lb/88kut9hcVn8O9Pz7VfKe6nU47znRbVzyuifnz5zuCgoKqnV+2q2xfd7L9ZT841T4l+1FN+rCK2/udd95RluvSpcspl2vatKkjMTHR47X279/v+n94eLijuLi41tY1ERERSx8QEdFZI5lUFTMjZcAwyVA9Fcm2kYw4qbEnGYRSQsG9/qpkSEmWoXMgoIrksugvvvhCyTSVUaolo04yZCSDR7KwpF1yuWPF7LpTkWXlEm7J+JNLYyW7RzJx5HHJ6JXXkIwy98tta4NcYikZTG+//bZSCkHWhWQGSskHydirOJCMvG9ph2QKSUap1HB84403XJev1pSsa8k0kkwm92ytmr4H98vAK5Z1qJidVNP6tFJGQTLtZIC6qgafC3R1VZ/2bJJsb/cSJVWRLHW5LFkGKZJtKZ8r2delxrFkr0tG7rvvvuvT60l2rmQNS1asfAbkcy+fVfn8yOdGnmfOnDmVMjClz5DMRFlG+hF5fcmwlKxguRRe2ucrKbsi5T3E6tWrPersNiTOPkyybGUbh4SEKPWHpc63lIqReqEVr7CQzFEZDE62kWRKynaT/kwyN6VEjmwH90vVqyLZnbLvyH4kmZaSESlXUDhrEjuz06VWsVwFIZf5y/NLH+J8LdmGkknt/tlz1jIWbdq0UY5p5JkdL1dwyHZyXtkg20+2owxoJ9u1Yl1w2f5S2uG1115T9gvZP2Q/kWxb2W9k/zlVuQHZzhMnTlSO83JFhhzfJctbMrrlGCbHH+cgjFIGSEqhSJ8k204yq+WzLhnd0gfIfiLb1Z17mQ7Zl6RtREREtUUjsepaezYiIqKzRMoLyEmzXAbtDO5J4IYnTFSfOctsSABCLumVwCEFDqlr6yz/IvWZnZfzU+2TAKD7AFAyCJWU06ltEsxzlm2QeqryIwKdfTIgqXOANwms1mWtYPkh1lk+SH6Mra0SNERERIIZtUREFJAkQCXZVVJHUMhgKhK4lQAuUX3l/GFCstQYpA08cnWAM8tbBkGUWpoU2CTDVsiVIQzS1n9S29kZpJXB0hikJSKi2sZALRERBSy5hFECV9OmTVMubZQTpqpGZyaqL5566illUCAZNI8CjwwA5xzwSsq5uI9oT4FHstplYCw5Fr3//vtqN4fOgunTpyt/pfySlD8iIiKqbbxejoiIAprUF3z22WfVbgYRkU+kDqvcKPBFR0crP5xQw7FgwQK1m0BERPUca9QSERERERERERERqYylD4iIiIiIiIiIiIhUxkAtERERERERERERkcoYqCUiIiIiIiIiIiJSGQO1RERERERERERERCpjoJaIiIiIiIiIiIhIZQzUEhEREREREREREamMgVoiIiIiIiIiIiIilTFQS0RERERERERERKQyBmqJiIiIiIiIiIiIVMZALREREREREREREZHKGKglIiIiIiIiIiIiUhkDtUREREREREREREQqY6CWiIiIiIiIiIiISGUM1BIRERERERERERGpjIFaIiIiIiIiIiIiIpUxUEtERERERERERESkMgZqiYiIiIiIiIiIiFTGQC0RERERERERERGRyhioJSIiIiIiIiIiIlIZA7VEREREREREREREKmOgloiIiIiIiIiIiEhlDNQSERERERERERERqYyBWiIiIiIiIiIiIiKVMVBLREREREREREREpDIGaomIiIiIiIiIiIhUxkAtERERERERERERkcoYqCUiIiIiIiIiIiJSGQO1RERERERERERERCpjoJaIiIiIiIiIiIhIZQzUEhEREREREREREamMgVoiIiIiIiIiIiIilTFQS0RERERERERERKQyBmqJiIiIiIiIiIiIVMZALREREREREREREZHKGKglIiIiIiIiIiIiUhkDtUREREREREREREQqY6CWiIiIiIiIiIiISGUM1BIRERERERERERGpjIFaIiIiIiIiIiIiIpUxUEtERERERERERESkMgZqiYiIiIiIiIiIiFTGQC0RERERERERERGRyhioJSIiIiIiIiIiIlIZA7VEREREREREREREKmOgloiIiIiIiIiIiEhlDNQSERERERERERERqYyBWiIiIiIiIiIiIiKVMVBLREREREREREREpDIGaomIiIiIiIiIiIhUxkAtERERERERERERkcoYqCUiIiIiIiIiIiJSGQO1RERERERERERERCpjoJaIiIiIiIiIiIhIZQzUEhEREREREREREamMgVoiIiIiIiIiIiIilTFQS0RERERERERERKQyBmqJiIiIiIiIiIiIVMZALREREREREREREZHKGKglIiIiIiIiIiIiUhkDtUREREREREREREQqY6CWiIiIiIiIiIiISGUM1BIRERERERERERGpjIFaIiIiIiIiIiIiIpXp1W4AVVaUmYnkZctwbO1alJ44AYfN5vpfVI8eGPLvf3vMv/Lpp1Fw9KjXVdn1xhvR4bLLXNPy3Evvv9+nTXD+q6+iUevWrunklSux/dNPvS4X1LgxRn34ocdjWz74AGlr13pdtuXw4egzZYrHY4vvuguWoiKvy/a97z7En3uuazr38GH889xz8MXoTz+FMTzcNX3g11+x/8cfPebR6PUIiYpCy/PPR6uRIxHcuLFPz01ERN45HA6cOHAASX/9hePbt8NcWCgPuv7f5frr0XH8eNe0KT8ff91zj0+rdtjLLyOybVvXdMrq1dj28cdelzM2aoTRFeZL+OgjHPvnH6/LtjjvPPS7916Px5bcfTfMBQVel+1zzz1oOWyYazr3yBH88+yz8MWojz9GUKNGrumD8+Zh3w8/eF2uUdu2OP/llz0eWzttGnL27vV4TBcUhIhWrdD6oovQYsgQ6IxGn9pFRGeHfP+VfjQzIaGsv3HrRztMmICu113nmraZzfhz0iSfnnfIc88hqmtX13T6pk3Y/M47XpfTGo0YO3Omx2M7vvwSR5cu9bps8wEDMPCRRzweW/bQQyjJyvK6bM9Jk9Bm1CjXdGFaGlY89hh8MeKddxAWE+OaTly8GLtmzfK6XGhsLEa+9ZbHYxvffFPZFhX70fD4eLQeOVI5VuiDgnxqFxER1V8M1PqZw3/8gTUvvKAEZx2mUsBqBcq/U8FQVADrCs8vM7nr1yE39ZjX5y5q0xLWiBDXtCU3D9mbNvnULtOq5bC2bOmaLlmz1qdlgyMjKrW3YN0aZG/a7HXZRgYdrF07ejyWs2kjzEXFXpct+WclrJaS8vYnJvn8Xi0rl0EbFuaaLlqzuvKyGvn0GJCyciU2Tp+OEW+/rZykEhHRmXHY7Vj/6qs48MsvgN0OR2mJ8tf9WFjUKh7WyPJ+2pKfX4Pj2d+wJrVyTZesW+/b8SwivJrjmfdlG+m1sPbo4vFYzsYNMBUW+XY8s5lc0+akozU6nukiIlzTRWtW+bSsPTO90nvN27AO2fsPeh4HNRpkbTbi8IIFiGjZUvmhM6x5c5/aRkR1+2OXBE73/O9/J/vRUsBu8+hHY2OiYG0e5Zq2ms0160czUl3TJQlbfVpWZ9BX0Y/+49OyIVZz5XOgjRtQeDzb67LFnTvCapBOq4w5I8P3flTOgZo1c00X/bPSp2XNzWMq96Pr1iJ7x07PGaUfNRpx5I8/EBoTgzGffab0p0RE1HAxUOtHji5frgRp7QX5cOTkyNlq2XmQtvyLhePwAVi+/9pzwZQkaPK9Z+XYN6yBJTfdNW0pKYUmL8entlkX/gpLZHlWji0pxadlNaaiSu117N3l07KO3TsqLavJyoDGYvG6rG3lUliO7Clvf06u7+917mzlF38n+96DlZZ12B3Kd12HVgtHVDP8/cgjuOjDD9G8Xz+fXoOIiKq28a23lCCtIycbjsKyY5tGI7fyY6F94xpY8jNc05ZSk899vO2PebA0dj+epfq2bGkVx7M9O3xa1l7d8cxs9t7eVctgSdrnmraeyPP5vVp+maNka7nasfeQb8setVb+rnGkwrHQAdgdZcdCGIwosFqxZMoUjJ01C0GRkT61j4jqxtaPP1aCtI4TOXAU5Ffdj27ZAIspzzVts9l8/668eD4sCeVBXvuxDN/OC7S6yv3ojp2+nRfs31O5X0pLhabYewKHbe0KWDISy9tfUOj7e/3tJ1jCQsuf62Cib8vaTJXf68G91fejegOKLRbl6kHpR0Ojo31qHxER1T8ah/zkSn5h4a234viWzXBkZqBN63h07doBjSLCPb5UkR9dlnsiD7t2H0Baeia0sS3Q6uKLMWL6dLWbRkQUsEx5efhx9GjYc7KBgjz06tlVOR4GBwfxWOiHJLCTmZmNhK27UGgyQ9siHuc89TS6XHON2k0jarAsxcVKP2rNzADyctGje2e0bdsSISHB7Ef9kM1mR1ZWNrZu3438ohJoW7RE/wcfRI9bb1W7aUREpBJm1PoJq8kErV4PFBaicWQEzhnUh1+m/JgEz5s2bYxzh/bH+g1bET9mFNo+/YzazSIiCmgFqakIi4tD/tFEdO7YDl27dFC7SXQKOp0OcXExCAoy4sDBRLR74H60dKsdTERnX1FaGsJiY5F75BDat2uF7t07cTP4MZ1Oi9jYaAwN7Y89ew6i3V13oOX116vdLCIiUhEzav1MztQ7UZKZqQQBKXBoW7dD0FMv1vnrmM1mLFmyBL/88gsSExNhMpXXLayvQYCYmBiMHTsWEyZMQNOmTdVuEhHVMVtqCjIeux9GowFhbpebkv/Tj7kMhiuuVbsZRA2ePec4Mh64EzqtFhER5QPkkv/TXTAKxutvqfPXycvLw2+//YYFCxYgIyMDVhkXpR4zGo1o3bo1rrjiClx88cUIDg5Wu0lERNViRq2fCdFpEcIgbcBRBrupY2lpabjwwguxt8Ko2w3Bjz/+iLCwMCxcuBDDhw9XuzlEVIc0ZhOaNGGN00B0No6FROSDUhMau40tQQHkLPSjGzZswJgxY5RgbUPz1VdfoV27dvj777+VwC0RkT9ioNbfsGQwVaG0tNQVpDVEGBE/vCUad2oCnVFXr9eXw2ZH4bFCHFuZgsLUQiWzdu3atejdu7faTSOiusLjYODitiPyExyCJGDVcT964MABjB49Gvn5+dBHd0D4oGthiO0Cjc6A+sxhNcGUtAWFG3/AkSNHMGLECGzbtg0RERFqN42IqBIGaonOUFFRMUozshC0Ywci27eHMSys1tfp4sWLlSCtsZER571+AcJia/81/FmHKzph/UtrkLM7G19++SVmzJihdpOIiMhNbm4+HEeTYdi5E9E9e3LdEBHVUF5+AezJqTDs2IFmPXpAo9XWSUapBGmNbQYg7sH50AY3nNIY4YOuQ+RFD+DYGyOVYO38+fNx4403qt0sIqJKar/3p9OSvWcPNkyfji2btyEzK5trMYAcPJSEpfMW4s9Jk3Bi//46eQ2pSSskk7ahBWmFZA53uKKjcn/u3LlqN4eI6siRRYuw8bPPsSVhJ0pKSrmeA8iGTdvw16f/xeI771S7KUQN2tFly7Dx40+UflSSCShwbNmyE399OUs5p7DbbHV6ThF50f0NKkjrpG8Sj/AhNyv3eU5BRP6KgVo/UZCcjH3ff4+D+w8rWSlE7uRXX9G4c8MdTMv53pOTk+v9gAdEDVX6hg3Yv2Ch8gOY2WJRuzlERAEnc+tW7P/tN6UfLS2t34PO0umfUwS1G9RgV1/wyfcuAzMTEfkjBmqJAoDJVPZFu77XpD0V9/duNptVbQsRERERUaCeU2gNIWioNMYQ1xggRET+iIFaIgoMGrUbQEREREREgY0nFUTk3xioJSIiIiIiIiIiIlIZA7VEREREREREREREKmOgloiIiIiIiIiIiEhlDNQSERERERERERERqYyBWiIiIiIiIiIiIiKVMVBLREREREREREREpDK92g2gMiHNmiH+vPNgXVmKsLAQrpYA0rNHZ3Qffh6C/z0N+hBuOyKi09W4Y0e0GNAfti0boNfpuCIDyMgLhkJ77nAYr71Z7aYQNWiN2rZFi0GDYNuwBgaDQe3mUA0MO28QtAPOgfFfd0Cr52k6EVFDxSOAn2jev79yK3noLsBsUrs5VAM6nQ56oxHG8HCuNyKiM9DtxhvRZfAgmN6cxvUYYAwGPXTBwTwWEqms81VXoeOQc2D6zzNqN4VqiP0oEREJlj4gIiIiIiIiIiIiUhkDtUREREREREREREQqY+kDojOUnpGF7OR0GD77DB0uvxzhcXFcp0RE1KAcOpwEs/lvGIqt6HXHHWo3h4go4BxJTEZp8SrozBr0njwZGi1zqoiIGiIGav1EyurV2Pz227BtT0C3zu3Rtm1LtZtEPsrIOI59h49Cm5aN2EGDGKglIjpNCR99hKR5v8J+YB+GnTcQERGs/R0oDh0+irz9SdDt2stALZGKdnz5JQ799CPse3dj6JD+aNy4EbdHgEhMTMHxPYeg2bkXPSdNgo6BWiKiBomBWj9hLS5G/tGjsBcUwmyxwB/ox10B/ZhxsK5YCuvcOTVbWKOB4dqboRs0FI7cEzB//QUcyYk+zaPt3huGG2+FNioalkXzYZ33Y9ns0TEwTpwCTVwL2HZug+XbLwGLuRbfMRERqak0OxsFx9JgLyyC3eFosMdB/ZXXQz9kGGAMgv3gPphnfgIUF/E4SERemXJzUZCaqvSjNptN9TXG8wkiIqKa4fUUVC3r0j9hmfs9DKPGQhMTW6M1JSeduvMvhPmz92BPPwbjpCk+z+MoLoJ1/i+V5jfceBscNhtM774OXfde0F84hluPiIjq3XFQgrLymPnzD6Dt1hP6kaOVh3kcJKJAw/MJIiKimmGglqpXWgrbpnWuk8ka7Vjde8GRma5cvmrfugna2BbQNIvxaR5H4iHY1v/j+YQ6HbSdu8G+cyscRxNhTzwMbY/e3HpERFTvjoPWRfNhP3QA9j07AKsFmtAwHgeJKDDxfIKIiKhGWPqATknXZ0DZ3wHnKCeMhn/dAfuBvbDMngVth84w3vdopWVKH5kCTXgEYDIp046TfyGPHc90zefLPC5h4UpBfYeptGzaVApNVDNuPSIiqrfHQf2lEwCtDtZ1q3kcJKKAxfMJIiIi3zFQS6feQc4bDntmhpLl4zCbYV28ANp2HZT/2Y8egenV56pczlFYAE3TKOW+Jii47MHCghrP41JUCIfdXj5fULCyPNW+368oLzthsppwrCgN3+/7ERvTN+HdkW+jZUQ83k/4CIuTlijzTO13P0a3uQgrklfizc3vcJMQUb2i1nFQN2IU9GMnwPL153AkJykZtTwOElEg4vlEw3T4nvIBQUssDiTl2/H+JjP+OFxWO3nlzaFo2ajqC3zbf1x41tpJRORvGKilamni4qFt1xGm996A8fZ7oBswGI6MNNf/tW3aw/jAY5WWK33wTtj37FTm13bqCm3fgbBnpMEhGULBwUBwCJB74hTzhEAT2bisDZJJK+UQjmcqA6poe/WFZt9uaNu2V2peUd15e/MMNA1uilu63YxHBz6E2/6cjHcT3sdr57+MST1uxYb0jWgd0UoJ0p4oPYFPt3/BzUFE9Ypax0HdkGEwXHOzUgLBtn9PWZZtYQGPg0QUcHg+QY8sLUXzUA0eHWzEO6OCsf7rIuSUAi+uNiHUoFFWkFYD/HuoETFhWiw46B8DaxMRqYWBWqp+5zh3OOzZx2Hfuwu2hI0wXHwZ7MdSoQkJga33duUE0/SfZ6pc1rZxrRJMNU6ZWjaS9VeflT3nRZfAMO5KlEydXO08ur4DYLz1zrL5h42AtlsPmJ57DJb/zYRx4l0IevBJ2HZth3XZIm69OrQ6dQ0sdguGtzwf7SPboXloc+zN2YffDv6OKztdgfv63q0EasVH2z5FgYUZzkRUv6h2HBwyTCn3Yxg7XrlJsNY84zUeB4nOkMPhQHZ2NgoLCxEeHo6oqChoNGWBIqobPJ+ghYesMNuAyzvp0b2ZTsmizSm1Y1lSWWatePScsiDtvhwbnlx+shQQEVEDVeeB2vz8fLz88sv46aefkJKSgsaNG2P06NF46aWX0KFD2aWD5J8sP88G5Cb3Z89SbhU5sqqoJyvsdli+/0a5ubMu+FW5uV6jinls61ajROrxVXytzAyYpk873bdDNRRhjEBUcFPEhjZHgbkAKYXJyuPf7PkfBsUOxJC4wcr0ipRVWJe2nuuXiOodtY6DEpStCo+DRKcnNzcXs2bNwvvvv49Dhw65HpdzkQceeAATJ05UzlGo9vF8gpoEa5SM2laNtMgtdeDQCbvHShndVod7+htQYHLg3j9LUWzlOiOihk1f10Ha888/H9u3b3c9lpmZie+++w4LFy7EihUr0KtXr7psAlGdCw0NQVRMNHQ9e8IQFlZv1visS/7rqlP70rr/oMRaNpCbZNlKBu0rw6ah1FqKT7d9rnJLiYhIbZGNIqAPi4C+U1e1m0LkYdGiRbj66qtRXFxcac0cPnwYDz/8MJ555hn8/PPPuPjii7n2SDWNGoXD0TQK2o5d6lWm99pbw1x1aif/WYIit8oG7SI1ePPCshrtjy4rxZE8h1rNJCLyG1VX764lL774oitIO3z4cPz666+YMmWKMn3ixAnccccddfnyAaVp164Y9Nhj6Ne/N2KiywYWocDQqWNbjLriUoz96is07dwZ9cW0da9gweE/EKQPwv1974VRa3T9L6M4Q/lbYi1hyQMiqjVtL74YAybfgX59uiM4KIhrNoAMPqcvRt99Jy7+gvXKyb+CtOPGjUNJSYlS9kBu7pyPyf9lPpk/0LUaMQID7p6i9KOSTECBY0D/Xhg9+TblnEKrrz8VCu/8owTf7DQjxKDByxcEI0hX9nioHvj4kmBEBGnw0RYL/kosL4VARNSQndYRYOnSpXjyySexc+dOxMfHK79ES52nSZMmKf9/4YUX8O9//xszZ85UpuUXwTlz5iAuLg7jx49XMmn37t2LjRs3YvPmzRgwYAAaukatWyu3knXLALN/1OXRj7sC+jHjYF2xFNa5c2q+/CXjoR85Go6SElh++Ab23Tt8m8dohOHmO6Dr2Rv2tFRYZn4KR3YWNNExME6cAk1cC9h2boPl2y8Bi7mW3i1VlJC5VRkwrE2j1ujZrAfGd7gMPx2YyxVFRHUm7pxz0LxZU5j2JfjFWuZxkCiwyx1IJq0EYu12z0utK5L/a7VaZX5nqbZA1bx/f0THxsC0YwP8AftRWpVsw9JEGzo31WFwCx1u723AxwkWvD4ySHkss8iOgyfsuKxjeWhiaaIVJSyBQEQNVI0zalevXo2xY8cqAVaTyaRcMiS1nWbMmOExnwRx5QuSaNu2rRKkdQZthw4d6ppv1apVZ/4uqE5Yl/4Jy9zvYRg1FpqY2Botq+3QGYbxVyt19+w7EmCcdLcSgPVlHhloRde9J0zvvg7Y7DDcOFGZ33DjbXDYbMrjuu69oL9wTK2+X6raFzu+hN1hx9Wdr0K4IZyriYgaDB4HiQKX1KSVcgfegrROMp/M//XXX9d52xoS9qPk9J9/TLA7HJjSz4jIIGBcR4PyuAwiNmNUMN4bXX5rGlJ/Sj8QEdV5oPaxxx6DxVJWWGbUqFH4/fffMW3aNCUw6y4xMdF1v3nz5h7/i4mJcd0/cuQIt5q/Ki2FbdM65a5uUHlw3Rfa7r3gMJlg27IB1s3roQkLh7ZdR5/m0XbrBfuRQ3AcTYR951Zou/YA9HpoO3dTppXHEw9D26N3rb5dKnP5r1cqN6lFKw7lHcaEeVfjxgX/QqGlUHksszhLmefWP2/naiOi+ovHQaKAJFm0MnDY6XjvvfcqlUigM8B+tMFq/3GhcjOfrGiw67gdHT8pQt8vi5BnKv9/VbfUAn4GiajhqlHpg4yMDKxfXza6e1BQEL7//ns0bdoUl112mVLKQAYJcyoqKnLdN1bIpHSfdp/vbEpLS1Nu/sJaWgpzQQFMickwaBzQ+0ldopheAyDhVUvfAdj31yJ0mHI/jE2icPDDd1CalYl+73xUaZmEh+9FS70BUaUlSMjKRkhQGPpJ8N6uQXZWtmu+9tXM0zo0FEWZGdiflY3Y7By012qxs8SMQVotko9nIz0rG53z8xHaug22uj2fWpKTjyH9xBrotuxBj0mTENmmTa2/hvNzUpRehLxDZZnqDY3V+S1P9rGEBISEsO4aUX1jKiiA5cghWI6mIijIqFyKrDYeB32za9c+lKzfAd2P8zD02WfreKsQnZqMhXHo0KEaryYJ0Mpyy5cvD9jyB+bCQpiTj7IfDbDzCbFn70EUrd0K7dwFGPLss3VSp9b5I4Q5dSe0uU3REFkyDyp/pTb1li1b1G4OETUg/fv3921GRw2sXbtWenbl1r17d4//vfvuu67/vfDCC46ff/7ZNT148GCPeZ988knX/6ZOnepQg7TR2Qbeql8Hss0PHDigrLNBgwYpj82cOdMxefJkh06nc3To0KHSTR6fNm2ao6ioyGP7X3jhhR7PXd08q1atcixcuFB5XPYVm83mMBqNyt8nnnhCefyPP/5wrFy5ktuO+y/3Ae4D3Ae4D9TpPsDjID9j/IxxH+A+wH6U+wD7Ae4D3Ae4D3AfwBmuA1/V2s90UnvWndSldc/EdZeenu66365dO6hhypQpysBm/uLY2rVI+PBD2NPT0KVTO7Ru3ULtJiGkZWv0GzIEu6Y9C8uDj2Puvx+HKSsTTfv2QpdFv+LuO29Bv3c/rbRcwoNTEGQpRGhoKPa+/ToiOnWGtbAQL7doAtx0FfTh4TDnnkCjauZpkZqEuHHjsfWJB9Fu4i3I37kNy8ePRsHunXjmtltxE0zoPuw8HPv9F/xzzTio7cCBI0hMTYc2urny63dU1661/hq33XYbduzYgW639USzns3QUDNq1/57latWNjNqieqf7Z9/juQlS2DPPo6hQ/sjPCxU1fbwOOi7desTUGhzQBvVDJd+9VUdbhUi3zJqpUTb6ZKBkwM1o3b3t9/iyO+/w348C+cM6o3IyEaqtof9qO82bdqOXJMFmsZNcMlXX0FXBxm1zkG8Yx+YB21Yw8yoNSVuQvach9GhQwf88MMPajeHiKiSGvX+7kFVGURMvgQ1adJEmXaWRHDq2bMnIiMjkZeXh6SkJKSmpiI+Pl653GLdurK6p+L888+HGmRwM+cAZ/6g6fHjOBEaCrtBj26NwtE5OkrtJsFw2XjlZLl9WjI02zaj5RXXKo/bjxzEgHGXw7ZuNcwvP1Npue46AFlpsMz/BZ0n3w1HaSksX3+GPhFh0A0ZBuOtd6L0pafgyKh6HqxbAU3Hjuj94itwpB+Dec5X6BcdBc1P38I48S7lcduu7YhZvwoxfrCetGmZgMEAbWgoenfrhub9pIhD7QoLCyv7GxuGyA6nd+LwYL/7cV78ubhj0RQUWArQNLgJ7u59F/rG9IHNYcfG9I34ZNvnKLYWV7n8F2M+RfPQ8vrS4uX1r2JdWtmowqPbXIRrO1+DZsFRSCtKxzd7vsO6tLJ+4bGBj2BATD/cueQeV53bmrKWlg/92q9fPyXIT0T1i6lFC+hCQpRjYe+mjRHZKELV9vA46Lus4CDkWR3QhYX5flkXUR2R8w0Jwsj5Sk3qzUriSfv27TFy5MhKSSiBwv7333CElvWjvZo0RlRU2bmaWtiP+i43JBjHoYEmNBT9+/WDzlA22FZtkv1aPhPG+J7QNfL8Xu+rN0YGYWwHPc7/pgi5JiAmVIOXzg/CsFY6GQcaSxOteHG1CQXmyssObqHD7AmVy5el5Nsx/Luyc5CL2urw2GAj2kZqkVnkwCcJZszeXXYe8PhgIyb3MeCS74txJO/06tjai8vKyEnSB49XRBTwgVoZFGzw4MFKULa0tBQ33HADpk6dim3btmHOnDmV6tDefvvteOedd5SDwY033qgMRLZgwQLs27dPmWfgwIGuX/XI/1h+ng3ITe7PnqXcKnJkZVa7vHXhr8rNnQR3S9atPuU8MJlg+e9HsFR8rcwMmKZPO70308DFh7fAyNYjsDjxLyVIKx4d8DB6NuuBH/b9hBBDCCZ0uFy+vuHtzTOqfZ6j+cmYs6/8l+f9J8pqPPWM6oGp/e7HodxD+OzAr7iy43g8Nehx3LdsKlILj2Hewd9xQcvzcWXHCUoAl4goEPA4SBSYJBj1wAMP4OGHH67xsnJuE6hBWn/EfrR+addYgys76/H9HqsSpBXvjApSArAfbLYgwghM6m2EfIQeWXpyBjcHT9gxdUmpa3p0Wx0u72TA1syysSjaNNLgozHBSC9yYNpqE67tasDLFwTjaF4J/km14asdFtzV14CpA414uIrnJyKqD2o8Ssf06dNhOPnr3uLFi5WBxJ555hn06NGj0rwvvvgievfurdxftWoVJkyYgM8++0yZlsuJvvzyyzN/B0Tk1cVtRkOn0WFlalnpgNYRrdA7uhcO5x3Bd3tn44sdXyK7JBvDWw5DI2P1GWx55jxsytiEVamrlVtOaY7y+Lj2lyp/v9s7B38mLsLcA79Cp9Xh0nZjlccP5B5ARnEmRrcZJXkC3GJERERUpyZOnKhcfeProIQyn8x/6623cssQVeOGbgbotBr8frAsw7VTEy2Gxuux67gdMzaaMe0fM9IL7bi8ox5Ngisvn13iwPyDVtetezO5FBP4fGtZis6NPQww6DT47zYL/rfbirc2lKXl3tqrLP6QVezApnQ7LumgR2QQNxMR1U81DtRKqYKFCxcqlwlI1qzUop0xY0aVv1g3atRICdA+/vjjStkEmT8mJgY33XQTNm7ciF69etXW+yCiU1DKG9ht2J9zQJluEV5W9iOrOMs1T1bJcSWYGxsWW+3z9Ijqjh8um42fL/8eT5/zJBoZG1V4vuPK38ySLFcmr9Pe7L1oEtwY7SLL61cTERER1QVJCvn555+V7FhvwVr5v8w3d+7cgK1NS3Q2DGupg9XuwNaMsgzYtpFlCRjHCsrLEBwrdCjB3NaNTv25u7CNDh2aaLEu1YYdWfaTz1e2zLHCsunUk3/bNS5/rs3pNgTpNEoWLxFRfXRaFcqlOP/mzZs9HvuqmoEjJFj7xhtvKDciUkdcWBzyzQUw26soFuWjv5KW4ljhMZTaTBjXbizObTEEJpupylIJVWXNHi/NVv5KIFgyeYmIiIjq0sUXX6yUXbv66qtRXFxW/9K9Zq2zxIHUqpQg7ZgxY7hBiE6hTaQWuaUOmMritFXytXLI5D5G5e/nW6s/P6nqqSRjV5QFgk/RECKiAFX7Q0lSwxEWDv2IUbBt2wJHytFTzmqc8iC03XtCYzCiZOpkwFqxAi2g7dEbhutugSY4GNZli2BdNL8OG98Quf/Snab8jQmNdj0WHRINm8OG9KJ0ZdqgNcABB6z2skub3GvTnijNRf/m/dC2URvX87WPbKc8X2J+IqJDmp18/Fj5q588MWLpAyJqaMdBTWwLGO+4F5ro5nAUFcA67yfYNqypNB+Pg0R1E6xNSUnB119/jffeew+HDh1y/U8GDpOatFImQQZBJhXwfCLguA/hlXhyQK/4iPKQaotwDWx2B47mlwVUjZL46gDMZZOKns20GBKvw/4cG5YfLQ+2JuaVzRQfURaEbRGu9Xhc2E82gKWkiai+YqCWTpsmPAKGcVfCkX0cNi+BWtv+PXBYzNAPHFL1DEFBME66G7a1q2A/cgjGyffBvn+Pcp/OXHpRBlpFtFSCrxa7BUcLkrHz+C50j+qGm7veqAwmFhXSFH8nr1AybyXg+t8xn+FE6Qnc+uftSkD29p63YXPGFhRZijG6zUXK8+7J3qP8XXjkDwyLPxc3db0eTYObKIOGSamFhUcWudrQLCTqZFvKAsFERA3mOGgwwLpmBex7dsJw5Q0w3DwJti0bAGvZD2EKHgeJ6oyUM5CArAwwFh8fj7S0NMTFxeHAgQMcOExlPJ8ILMn5dqVcgQRfzTbgwAk71h+zYVCcFg8NMiqDiTUP02LefgtOlJYFcFf9KwxZxXYMnlWW1S7u7FtWc1Zq0bqbs9uC23sblJvZ5sB1Xcvm+3pH+XxxJ4O30hYiovqoxjVqiZyM9z9a9vfWOxE07c1Trhjb8sVwZKRVvyO27QBNaBism9YrJ68OswnaHn0CYmU3j2mGHv37oPeddyIstvr6rmpKyNqqDO7VuUkn12NvbnoHG9I34YqO4zG69UVKkPaT7WWD/VWUZ8qH2WbG1Z2uxL19pihB13kHf8OXu8pKnuw4vhMfJHyEMEMY7uo9GTaHHW9sehMphSmu5+jatAtyTXk4kpd4Ft4xEZH/HAcdyUmwLV8CR3oa7IcPKFeXwBhUb46DokO71uhx4QXodfvtajeFqFru9WqddWlJXTyfKNe2TUv0GD5MOafQ+DgI3tm2KtkGvVaDPjHl7Xv4r1IsTbRhch8DrulqUIK0z68yVfscknF7SXs9Movs+HW/2w+WJzN071tUihKrAy8MC0JUiAbPryzF6pTyrNv+sVoliCu1bYmI6qNay6i97bbblBudnhbnnYfxP/+M0peeQrB/HpcrsXz1KYIefRbmn/4H26Z1CH7700rzmD98C/ZD+70+lyaibFAqmEpP/jVBExGBQBAbG424mFgET5kCf7U4cQnGd7gMw+LPw67s3cpj2aXZeHn9q1XOn1mchct/vdI1fcJ0Av+pZl6nRUlLlFtVOjXuqNSm/Wn/XNjBX7+JqGp9770X3UYMh+mz9xAWGlL/joORjaG/YBRsWzYCxUX15jgoOnRoA935I2G8caLaTSFq0Hrcdhs6DjsXpven189+9BQCvR9t164VdOecC+Nt/ntOMWePBZN6GzCugx4b08pqy6YXOTDlz5PrvILUAgfaf1zo8ZgMNtblM89joLsliTYsSSyp8n/NQjQYFKfDH4esyK0+FkxEFNBY+sBPGMPCym6NIgBzYBx1HIUnD7pyspmfB9Orz1WeJ/eEb89VkF92Jzi47G9QMBwFBbXX2AYupTBVyZi9sNVIfLdnNgotnl+Y6tqEjuNRaC7E3AO/ntXXJaLAEhIVhaD4eJgiwlHvjoPhEQh68Ek48vNg/uaLyvPxOEhEtSCkaVMEtWxZP/tRb8/FfrTOHc514Jf9VlzVxYB3NpqRd5ZPWyVILMNezNh0+gMkExH5OwZq6fRZyg6QmmbRZSegz75caRbz+2/CfnAfNM1ioAkr+0Vb0zxWqeen/Nod2Vj5YmZPPAxHSTH0A4bAHtUMGqMR9t07uHVq0Ywt72MG3ldlnb656W1VXpeIyC+OgylHEfTA40q5A/OXH8sQ84DNCthsPA4SUcPG84mA88Ryk3JTw/T1ZuVGRFSfMVBLp81xIge23Tugv/hyaDt2gek/z1T7C7jxwSegjYpW7gc/8x+Yv/4c9v17Efyft2Ce/RVsq5bD/NWnMFx7M3TnDIXl95+VOn6BwGazwWGxQFdcDF1QELQ6GdqUiIjqO1+Pg1J/VtuqjTId/O9pyl/TO68qP1rWh+OgsFqtsMtlxsXFMISGqt0cIgoQPJ8oZ7XaYDeZlX5UHxLCGspERA2UxuGQiwdIbfnJyUjfuFHJtImKDEfjyJM1lsjvbdu+B/sOH4W2RUuM+fxzNO/Xr9ZfY+jQoVi3bh0GPjUYsYPj0BBZS63488b5yv2ioiKEMhBAVO9kbNmC3PVrYZn3I1q1jIPRaFS7SeSjxX+tQp7VAV3zWNy8di3XG/mtli1bIjU1FfHx8UhJKR/0tL7I2r4dORvWw/LTd4hvEYvgYM+BC8l/Lf97LY6XmKCJisZNa9dCZzDU+mvIIHpy+t/6tUPQNYpBQ1Sy92+kv3c5evbsiR07eAUnEfkfZtT6iZw9e7D+lVdgT05C397dGKglIqIG5/CCBTj4ww+wZ6ShWbOmDNQSEdVQ0l9/Yc+sr2BPO6acTzBQS0REFFi0ajeAiIiIiIiIiIiIqKFjoJaIiIiIiIiIiIhIZQzUEhEREREREREREamMgVoiIiIiIiIiIiIilTFQS0RERERERERERKQyBmqJiIiIiIiIiIiIVMZALREREREREREREZHKGKglIiIiIiIiIiIiUple7QZQGV1wMMLi4mDPyYJBz80SSDp2aIOWvXog6J6HEdmhg9rNISIKWEGRkQiLiYa9IBdajUbt5lANnDOwDxx9BsAwdjzXG5GKjBERCItpDnveCWi1zMkJJP379YS9aw8YJlwLrU6ndnOIiEgljAj6iVbDhyu3kofuAswmtZtDNRAWForwmBgE9+7N9UZEdAb6T52KvpddCtOb07geA0zjxo2ga90KRh4LiVTV+8470XPcWJj+8wy3RICJjIyArlVL9qNERA0cf2YlIiIiIiIiIiIiUhkDtUREREREREREREQqY6CW6Azl5uYj+XASkpYuRemJE3WyPnUn61TZbXY0VA639+5cH0RE5B8yMo4jeeduHF22TO2mEBEFpMysbCTv3qucUzjsdfOd3/kd2mGzoKFyvneeTxCRv2KNWj+RuXUrdn/3Hayr1qNdqzi0aNFc7SaRj5KOpmLf4aPQ7j6IMZ9/juAmTWp93UVHRyt/i9OKGux2KUwte++NGjVCUFCQ2s0hojqw94cfkLZkMWwbN6Fv3x4ICw3heg4Q23bsQV7CbuiWrcTNa9eq3RyiBuvgb78h+Y+FsK3dhF69uqJRRLjaTSIf7dq1H8c37YBm2SrctHYtdHUwGJycU6SlpcGSeQj6JvENctvIexcxMTFqN4WIqErMqPUTxZmZSF6+HKkpx1BYVKx2c8jPXHLJJcrf1JUpsFlsaIhSliV5rAsiqn9O7NuHlHXrkXosA1arVe3mEBEFnNyDB5GyZo3Sj1rMDTdrkqrm/B5duPZbOByOBreaHDYrCjfMUe7znIKI/BUzaokCwFVXXYWHHnoIBUfzsWHaWnSY0AmNuzSBzqir9+UOCo8VIfmvJCQtSlQeu+mmm9RuFhERERFRwLn55psxc+ZMFG6YDegNiDjvNhhjuwB6I+ozh6UU5qQtyFv2IcxJm2EwGHDNNdeo3SwioioxUEsUAOQypd9//x2XX345snccV24N0UsvvYQJEyao3QwiIqqoAWZmERHVrrrvRy+66CK89dZbePTRR1G45mvl1tBIkPbnn39G69at1W4KEVGVWPrAT2gNhrI7Gg1stoZ5aXugUraXRqPc1xnr7tfoUaNGYc2aNbj33nsRGxuLhiI0NBRXX301fvnlFzz//PNqN4eI6pBW+tCT/anNymNhILHJgI8aDXTO7zNEpN45xcl+1MpzioBiVfpRLTRaLbR1OHDuI488gvnz5+P6669HeHh4g0p8ueuuu7Bq1Sol+YWIyF8xo9ZPhJ0MvGkMRmQdz0E3tRtEPpPtJdtNhDav20Hg+vXrhw8//FC5mUwm5VafyWisEqjVnDzhIKIGcCw8GWSQvrVp08ZqN4l8UFJSisLCIqBpM4Q2oB8SifyR8l1Up1f60ePHc9A8ppnaTSIfmM0W5OXmA42bKNtQgrV1ady4ccpN6tSWlJTU+7rwRqMRwcHBajeDiMgnDNT6iaZduyoH5aLCAmRkZOHo0VS0atWCASo/Jl9s9u8/jLy8AmiiY9CsZ0+ENjt7X4aDgoKUGxFRfdFqxAgkvP8+NMEhSv8a2zwakZERajeLTsFisSBh6y7lgl1taChajxzJ9UWkcj+68Y03oAkNxcGDiYiLi0HTJvzRy59JkFT6UbvDAW1omLINzxZJhpCkCCIi8h8M1PoJOUh2HD8e2z//HI7SUqzbsBWHjySjb5/u2LV7v0/PMXRIf2jdfn1NTEpBamq61+XkJLhnjy4ej23dthtFRcVel23TOh4tW8a5ps1mMzZu2u5Te+W9hYWVfzHIzDyOAwfLBozyVlfonEF9PB7bt/+wkjXgTXR0FDp3aufx2PoNW336FVmWk+Wddu7ahz17D0ET0QiakFB0GD/e63MQEVH1Itu0QXTv3shKSEBJZjoWLVmJnj06IzQ0xKfjWaNG4ejVs2vtHM8sFmzcuM2nzdWndzeEh4e5prOysrH/wBGvy+n1egw+p6/HYxKglmxib6KbNUXnzu09HtuwcSssFu/Hs06d2iHG7XhWWFiMbdt3wxeDBvaB0Vhe3mDFyvXIOZEHTbMYaIOC0PbkiOJEpI6wmBi0GDoUx/75B6aMdPy19B907dIBTZpEKokgXpcPC1W+o7vbsXMv8vMLvS4bHx+Ltm1aepREWbd+i0/tlnMR9x/msrNPYO++Q16X02o1GDpkgMdjhw4nIT09y+uyctVGt64dPR7btHmHT1estW/fGnGxMR5XFmxJ2AlfDOjf0yO7c/U/m5CZlQ1NVDNoDAa0GzvWp+chIqL6iYFaP9L7zjtRmJaGw/PnA6URQPNoWFq3x7HVm3xaXtu9l0c9o4KsPBzL8R7ktYY3grZHb4/HsjbsQG5Ovtdlm/Xq5bGso7AIxxav9qm9Pdt0gLZ5tGu6xL4bxzZ4D/IGhYVWam/uoVQc86G9hhbxlZZNX/oPzCXev5C1jomDtntZAECjN6Blpx7Y9+U3ktqKHrfdhk5XXun1OYiI6NRGvPUWltxzD3K1WjhKiqFp1xEFRUU+Hc8sYRGVj2cbfTueRfXs6blscTGOLVrl0+bqIccz9xP2XXtwbL33IK8xNKTy8ezIMd+OZ3EtKh/Plq2FqbjE67KtomOh7VFeZMmWkYljf6+DTzp3g1Z+ZNVooDEEoaUxErl/r4Q2JAQXTJ+Oxu08fwwlorPv/FdewV/33YdsjQaOkhJo2rZHEYBjOXu8LtvEGFypb8netg9ZPvRLkZ27eJ4XWK049sffPrW5S6s20LYqD/KaDxzCsbUJXpfT6nWV2puXehzHcrwHeaVcS8VlM1dvRpGUIPAidkC0x7L2E7k4tnSNb6XM2neGVrKcnf1oeDMcX/QXNEFByrZr1t0zUE5ERA0LA7V+RGoRnfv882jevz+SliyBPiQEhquvheavFT4tH3TvI9Dqyzep3maA5kiK1+V0Pfsg6L5HPR7T/rMZGh/GmtOPGougiRNd0/bsbGh+/M2n9hr/dTuCOnd2TRvmz4dmk/cTW23TppXaqzuWA012rvf2DhpaaVnNzwugyffhpPjyqxHklikUZ7ejQ0Ep4s89F60vuohlKoiIakFwkyYY8+mn2D93rnIsDL14HIqzsqA5lOR1WV2P3pWPD2u2QOPw4Xh20SUImjTJNe04cQKa7+f51GbjzZMQ1LU8k9ewcCE0G7Z6XU7buHHl9mbkQZN1wuuyuoFDKh+7f/0TmhPelzVcdhWCLr20vP379kGzcKnX5ZR5J9+HoKZNXdPtk5JgiolFxyuuYHCByE8YIyIw6qOPcED60b/+QoiUJHE4oNlzwOuy2s5dK/dL2/ZBY/Kera+/4CIE3Xefa9pmNkPzzY++tfm6WxDUv79r2rBiBTSrN3hvr9FYqb36Ags0qRlel9X1HVC5H128EppU75nHhksuR9C117qmTcnJ0Pz6B3xhvG0KglqWB6XbZ2SgMKKxcnVeTB/PqwaJiKjh0Tik0Cb5JYfdDrvVCpMPQUQREhXlESw0FxXBWuI9s0ZGaA6KjPR4rPTECdh9GCnWEBqq3NzbXJLj/ZJNEdy4sUdg2VpaCnNhoU8B7RC3k0Qh60i+DHqjDwpSvry6K8nOVurNeiPLyfJERHT2yHHFIgOdBNLxzGSCuaDgtI5nspws741OghONGnk8Ju2VdntjDA+H3u2yW/muUZrr/cdOIe2t60FuiOpSy5YtkZqaivj4eKSkeE9oqA+kX5Dv2ZZi72Vg5Oo8+cHMnSkvDzaLxeuykmRiDCsvA6MMVJWd7VMbpT+Tfs1Jvtf7eg5UcYwIOZ+Q91uX/aghLAyGkBDXtBxn5HjjC1m/7ldBEhERuWOgloiIiIiIGoSGGKglIiKiwMGUCCIiIiIiIiIiIiKVMVBLREREREREREREpDIGaomIiIiIiIiIiIhUxkAtERERERERERERkcoYqCUiIiIiIiIiIiJSGQO1RERERERERERERCpjoJaIiIiIiIiIiIhIZQzUEhEREREREREREamMgVoiIiIiIiIiIiIilTFQS0RERERERERERKQyBmqJiIiIiIiIiIiIVMZALREREREREREREZHKGKglIiIiIiIiIiIiUhkDtUREREREREREREQq06vdACIif1Oam4ujy5bh6NKlKEhOhs1k8vj/uP/9DyFRUa7pfT/9hB2ff+71eRu1bYsxn37q8djKp59G5pYtXpftdPXV6HPXXa5ph92On8eO9en9nP/qq2jev79rOm3jRvzz7LPeF9RocM2ff3o8tPWTT3Dwl1+8Ltp84ECc//LLHo8tmjxZWZ/e9J4yBZ2vuso1XZSZiT9uuaVS2wzh4Yju3RttRo1C3ODB0Op03t8TEZ0Vpvx8JC9fjqSlS5GflARbaanH/8d88QUatWrlmj68cCG2vPuu1+cNbd4cl379tcdja/7v/3Dsn3+8Ltvu0ksx4MEHPR77Zfz4Sn18VYY+/zzizzvPNZ21cydWPPoofHHFvHnQBwe7pnd+9RX2zp7tdbmoHj0w8u23PR5b+sADOLF/v9dle0yciG433eSxPX6/9trK/WhYGJr17FnWjw4ZAp3B4NN7IiIi7/KTk5G0ZAlSVq1CcWYmHFar638h0dEY9+23HvOv/c9/kLpqldfnbXvJJRj48MMej/165ZWwFhd7XXbwM8+g1fDhrunju3fj7wrPVZ0Jv/wCQ2ioa3rX119jz3ffeV0uqnt3jHznHY/Hlj34IHL27vW6bPdbbkH3f/3LNW0uKsJvbucJpzJyxgxEdevmmk5euRLrK5yfaHQ6BDVurJxLtBk9Gs26d/fpuYnqEgO1RERucg8fxpK770ZpTg4cpSWA2Qw4HGW3k8wL50EfGemaNv2zEsWHDnpdj4aiQlh++9njsZJtCT4ta9qwFpbYKI9ArS/LKe1dugiWlCPl03v2+rasRlOpvdIOX5YtNegqv9fdu5Qvqd7I+rToy9e3JedE5dfUaACtFvkHDuDQb7+h1ciROP+VVxhkIPIDBSkpWHzXXWUnpRKgNZsq9aOWRQtgiYl2TZvWrvOpb9GcyK7Ut5QmbPatX9q0vtKyxQcPwCb9vBem5UtgyU4vb//hIz73wZbf58IRFFTejnX/+LRsqN1auR/duR3FySlely1duxqW8PLXtBQXV9+PHjyIwwsWoMXQoRjx1lvQGY0+vS8iIqre0b//xsonn1SCs46SYsBi8TgOOrKzqjiebTr949n+fbD68MOj+e+lsORmlU8nJvp+PJv/C+D2w6PJ1+OZzVL18SzpqG/Hs0Yh5W0oKfH9HGjJH7Ac2F3e3q3bqjwWFun0OLFnD3Z/8w363H03ek+e7NPzE9UVBmqJiE4qzsoqC9Kmp8OelQHYbDAaDNAbdNBA41pP9uWLYQ0uPwHWHk5CqNX7iX5wXjasf/7m8VhQ5jGfltUd2gfrn3bXtMPh8Gk5Zd4N/8B6xO0X66xsn5et2F7d4f0+LWtIT638XvNyfHuvu7fDWnLCNW0rLqm0nN3hgNlkhu1EDjQhoUhetgxr/+//MGzaNB/eFRHVFVNeXlmQNjUV9sz0k/2oHnqD3rMfXfkXrOFhrmlNUqpv/WhBXqW+xXAs2bd+KelQpWVDTcWw2cr71mptWQ/rsfIfvBw5ub73o0sWAvryjH/9gUM+LRt0PKNyP5qT5Vs/um8nrLYi17TNbKm0nBxHTM5+NDgEx9aswcqnnqqUxUtERDWTvmmTEqS1F+TDkX1cCdAGBxmhc7v6K7gwv/LxLPWoT328PulwpWVD5HhmtXlvXMJ6WNMTXZOOEzU7nmkM5SEk3f7DPi1rrOp4lp3p4/FsF6yOEte0zVL5eFYdx9qVsO4tT67RHMuofE5ht6PUZII9B9BENsa2Tz6BMSICXa+/3qfXIKoLGod8SyMiIuz65htsmTED9tRkNImMwMD+vdC4cSNoJOuI/I7NZkNySho2bd4OR2g4tNExuHbJEgQ1aqR204garP1z52L9K68o/WhkWAgGDuiNpk0bsx/143702LEMbNy0DbbgEGiaxeDqhQsRGl2e7VzftGzZEqmpqYiPj0dKivfsZCKimlrxxBM4+uefsKcfQ6uWcejdqyvCwspLBpB/kR8tDxxMxO49B6CJaobGvXpj/A8/qN0sasCYUUtEdJIuKAihoSEotNsx5Jy+iIgI57rxY5KV0LZNS9htdtgNRnT479cM0hKpTGpFh0WEo8BmwzmD+qJJk/JMFvLPfrRVqxaw2e2w2B3o8Pmseh2kJSI6G4KbNoXeboUmyIjB5/SFVssx3P1ZUJARPXt0VjKfG/foibZvvad2k6iBY6CWiOikrtddh/Y6G7J//oFB2gDSvn1r5W+Q2wANdZl9tmzZMvz444/YuHEjCgoKUN9FRERg0KBBuO666zBy5EiPy/aIKuo4YQJa6+w4/t0s5YoECgzyo5cIknrCRER0RgY/9RR6aS3I35bAIG0A6dmzC2DUegyYRqQGBmqJiNxZLAwuBCqT56jytc1qteKWW27BnDlz0NBs3boVn3/+OW688UZ8/fXX0Ov59YGqp7GYmUkboBwM1BIR1QqtzYrIyAiuzUDD4yD5AZ5pERG5Y9nuwFXH2+7RRx9VgrQavRatLmyNmAHNYYww1uvam1LG3pxvRuaWDCQvTcLs2bMRExODGTNmqN00IqoLPAYSEbE/JSJVMVBLREQBzWKxICMzG4a16xBhtiKqa9dafw2TyYSvvvpKud93an/En192mXBDETs4DlE9myHh7U3Kenj99dcRFBSkdrOIqJZYrTakZ2TBsH4Dwu0aNOvRg+uWiIgalKKiYpzIzUfQ8uVo2qULwlu0ULtJ1ECxqjUR0Umr/v1v/DP7B2zbvofrJIAUF5dizdrNWPXa69j/00918hp///038vPzEdQ0GC3Oi0dDJO9b3n9eXh5WrFihdnPIT6156SWs/vo7bEnYqXZTqIY/Rkk/uvLNt7Dnu++47oiITlPhsWNY8eSTWPPnXzh8+CjXYwDJyDyuHAtXPP440jZsULs51IAxo5aI6KSjy5bBlpmBxvr6eyk7nZ7k5GTlb2S7SGi0DXP/kPct7z8zpxQpKSlqN4f8VPKKFTAdTUK4ve4H9yMiIvI35oICHF26FPa0YzC2ilW7OUQUgJhRS0RE5EN5BeWgaWjYh03n+zebzWo3hYiIiIiIqN5p2GecRERERERERERERH6AgVoiIiIiIiIiIiIilTFQS0RERERERERERKQyBmqJiIiIiIiIiIiIVMZALREREREREREREZHKGKglIiIiIiIiIiIiUple7QYQERGdEQ2g02mhNRqhNRi4MomIatyPapR+VGM0QqOvn6cHxcXFKCgogM1mU6YdDofaTSIiIj+iOXks1AYFQaNlTiOpp35+EyMiOg0dxo+HNWETQrLSuf4CSGSjCFx95VgEPfYctO07qt0cogat/aWXwrR5A4ypSWo3hWogLDRE6UeNDzwOXbeeAb/uJAi7adMmrFixAps3b1buHzx40GOeY8eOoV27dhgwYIByGzZsmHKTE3UiotMVFBmJjhMmwLpiKaKCdFyRAaRd21bKLeSjWWo3hRo4BmqJiE4a8u9/wzx7FmyrlnGdEBGdhkGPPQbLL9/DumQh1x+pkjU7e/ZsfPjhh0hISPA6f2JionL7+eeflemuXbvi3nvvxa233orIyMiz0GIiqm/CYmMx9LnnUKqzwJHCHy2JqOaYz01ERERERAHLbrfj/fffR3x8PCZPnlwpSBsUFIRBgwZh/PjxHo+HhoZ6TO/duxdTp05FixYtMG3aNFgslrPSfiIiIiInBmqJiIiIiCggHTp0CCNHjlQCrLm5ua7HBw4ciI8++ghbt25VatNu2LAB8+bNg/Zk3UH5m5+fj127duG///0vhg8f7pGZ+/zzz2Pw4MHYvn27Ku+LiIiIGiYGaomIKKAVF5dg0+YdWP/Rxzi8kJdbExHVlMlkVvrRDZ9+jgO//howK/C7775D7969sXLlStdj//rXv5Sg7MaNG3HPPfegT58+MFQz0KROp0P37t1x++23K/Vsd+zYgbvvvlt5XEhmrgR833vvvbP2noiISB3Hj+cox8J1r7yCzK1buRlINaxRS0R00vcXXghbWioaa+wYOeJcrpcAYbFYcfjIUWiLFwONmyiDGRGROuZedhlKjxxCmLkUY0aXZyiSf7Nay/pRTdFfsIaGodMVV8DfSR3a+++/3zXdtm1bfPnll0p27enq2bMnPv74Y9xxxx247bbblGxbKX/w4IMP4vjx43jppZc42BgRnVLO/v1YPHky7MlJaNciBn37dOcaCxD5BYVl5xRz5yKqe3fE9O2rdpOogWKglojoJGtxMWwmM6x6/xjxWT/uCujHjFNGjbXOnVOzhTUaGK69GbpBQ+HIPQHz11/AkZzo0zza7r1huPFWaKOiYVk0H9Z5P5bNHh0D48Qp0MS1gG3nNli+/RKwmGvxHRNRoLMUF8NqMsNmt6Mh96P6K6+HfsgwwBgE+8F9MM/8BCguYj9aSz7//HOPIO2kSZOUrNfw8PBaeX7Jot28eTOeffZZvPnmm8pjUrNWat0+88wztfIaRFRPORzKsdButsBms8Ef8JyCKLCw9AERkZ+yLv0TlrnfwzBqLDQxsTVaVoIGuvMvhPmz92BPPwbjpCk+z+MoLoJ1/i+V5jfceBscNhtM774OXfde0F845gzeHRFR/e1HJSgrj5k//wDabj2hHzlaeZj96JlbunQppkwp3xZPP/20UmO2toK0ThKUnT59OmbMmOF6TAK3c+bUMOBPRKQynlMQBRYGaomI/FVpKWyb1rmCATWh7d4Ljsx02A/sg33rJmhjW0DTLManeRyJh2Bb/4/nE+p00HbuBvvOrXAcTYQ98TC0PXqf+XskIqqH/ah10XzYDx2Afc8OwGqBJjSM/WgtkEHBpCyBw+FQph955BG8/PLLdVqOQMoevPHGG67p++67D+np6XX2ekREtY7nFEQBhaUPiIj8mK7PgLK/A85RTvgN/7oD9gN7YZk9C9oOnWG879FKy5Q+MgWa8AgZHUaZdpz8C3nseKZrPl/mcQkLh0arhcNUWjZtKoUmqlmtv18iovrUj+ovnQBodbCuW81+tBY88cQTSEpKUu6PGDFCyXityyCt0+OPP45Nmzbhhx9+QE5OjjJI2dy5c1mvlogCBs8piAIHA7VERH5Mf95w2DMzlCwth9kM6+IF0LbroPzPfvQITK8+V+VyjsICaJpGKfc1QcFlDxYW1Hgel6JCOOz28vmCgpXlqW78fkV56QmT1YRjRWn4ft+P2Ji+Ce+OfBstI+LxfsJHWJy0RJlnar/7MbrNRViRvBJvbn6Hm4XID/pR3YhR0I+dAMvXn8ORnKRk1LIfPX2rV6/GJ598otwPCwtTyh1otWfv4sAPPvgAy5cvR1ZWFn799VclUHv11VeftdcnIjoTPKcgChwsfUBE5Kc0cfHQtusIy5xZSjBAN2Cwx/+1bdoj6NmXK92Efc9OaKKbQ9upK7R9B8KekQaHZHgFBwONm3iZJwSa5nFlbZBMWrnU12ZTBsTR9uoLTeu20LZtD/vuHSqslYbl7c0zMHvf92gd0QqPDnwIwfpgvJvwPmwOGyb1uBWNgxqjd7NeSpD2ROkJfLr9C7WbTORX1OpHdUOGwXDNzUoJBNv+PWVZtuxHz8jbb7/tuv/aa6+hffv2OJuio6Px8ccfu6bfeuuts/r6RESni+cURIGFGbVERH5Kf+5w2LOPw753F2wJG2G4+DLYj6VCExICW+/tSoDA9J+qR5+2bVyrBFONU6aWjUT+1Wdlz3nRJTCMuxIlUydXO4+u7wAYb72zbP5hI6Dt1gOm5x6D5X8zYZx4F4IefBK2XdthXbboLK6Nhml16hpY7BYMb3k+2ke2Q/PQ5tibsw+/HfwdV3a6Avf1vVsJ4oqPtn2KAguznIn8oh8dMkwpF2MYO165SbDWPOM19qOnKSUlBfPmzVPux8XFeQwmdjZdddVV6NWrF3bs2IG1a9ciISEB/fr1U6UtRES+4jkFUWCp00BtYmIi3nvvPaxZs0b5ImM2m5XHX3jhBbz44ot1+dJERAHP8vNsQG5yf/Ys5VaRI6uKerLCbofl+2+Umzvrgl+Vm+s1qpjHtm41SqSeYsXXysyAafq00307dBoijBGICm6K2NDmKDAXIKUwWXn8mz3/w6DYgRgSV5YduCJlFdalrec6JvKTflSCslVhP3p6PvvsM9jtduX+XXfdBYPBADVIPdx7771XqVErJMNW2kZE5M94TkEUWOq09MHWrVvxzjvvYP369a4gLRERUW3S63WIb9EcLQcPRtMuXerVyp11yX/x9ojp0Gl0+M/6V1FiLRvMTbJsJYNWlFpL8em2z1VuKREFMp2urB9tNWgQorp3h7+ZM2eOq5133ll2xYdabr75ZkRERCj3v//+e1cAmYiIAltYaGjZsXDECITHlZWBI6p3GbVS6H/06NE499xzlaCt85IlIiJ/NOzll2FZugi6fTvVbgrVQFhYKM47dyCCHnsK2vYd69W6m7buFfSP6Ydx7cfi/r734qHlj8JsL/vhM6M4Q/lbYi1hyQPyG+e+8ALMy5dAs32z2k2hGggODlL6UeMDj0HXradfrbu8vDwcOHBAuT9gwADEx8er2h4J0o4cORK//fYb8vPzcfDgQXTu3FnVNhGR/wiLi8Pw116D+X9fIaykUO3mUA00b95MuYW8+SbXGwVeoHbp0qV48sknsXPnTuXL0sMPP4zw8HBMmjTJo7SBBGnlJp566ikGaonIr7W56CKYM1Ngyy0LgKlNP+4K6MeMg3XFUljnzqn58peMh37kaDhKSmD54ZsqB/+qch6jEYab74CuZ2/Y01JhmfkpHNlZ0ETHwDhxCjRxLWDbuQ2Wb78ELLxaoi4lZG7FhvSNaNOoNXo264HxHS7DTwfm1ulrEp2JVhdcAEtOOqyZZWU61MZ+NPBt2bLFdX/gwIHwB9IOCdSKzZs3M1BLRC5BjRqhzahRKN2wEo6UJL9YMzwWEtXz0gerV6/G2LFjlS8lJpMJhw8fxgMPPIAZM2bUTQuJiBoo69I/YZn7PQyjxkITE1ujZbUdOsMw/mqlbqJ9RwKMk+5WArC+zCMD5ei694Tp3dcBmx2GGycq8xtuvA0Om015XNe9F/QXjqnV90vV+2LHl7A77Li681UIN4RzVRH5iP1o4JNzDifJqPUH7u1wbx8RkT/isZCongdqH3vsMVgsFuX+qFGj8Pvvv2PatGlKdi0REdWi0lLYNq1T7uoGDa3RotruveAwmWDbsgHWzeuhCQuHtl1Hn+bRdusF+5FDcBxNhH3nVmi79pBCsNB27qZMK48nHoa2R29u7jpy+a9XKjepRSsO5R3GhHlX48YF/0KhpewyusziLGWeW/+8nduBqDrsRwNeUlJ5Rlp3P6mf694O9/YREfklHguJ6m/pg4yMDGVgMBEUFKQU0G/atCkuu+wy7N27F9999x0CRVpamnIjInI6ceAArGvXA4ePIiIizC9WTEyvAZDwqqXvAOz7axE6TLkfxiZROPjhOyjNykS/dz6qtEzCw/eipd6AqNISJGRlIyQoDP0AJNo1yM7Kds3Xvpp5WoeGoigzA/uzshGbnYP2Wi12lpgxSKtF8vFspGdlo3N+PkJbt8FWt+dTS1FRMRISdkG7aQ/iRoxAtxtuqPXXOHr0qPLXUmRB3qFcNFTy/p3rw/1yZCKnE4cPw7p2DXAoCRGN/CP7m/2od6WlJmzatB3ajbsQc+556Dmx7EoKf5CSkuK6P27cOOj1ZzbEhnPwL/nbvHnzM3oO5/kR+0MicrKWlqIgORnm7btgLMhDSGiwX6wcHgu9S8/IwsEDidDuHI6u11+PFkNrlihD5E3//v3hE0cNrF271iGLyK179+4e/3v33Xdd/3vhhRcqLfvkk0+e8v9nm7TB2R7euA64D3Af8Nd9QPrdAwcOKP3WoEGDlMdmzpzpmDx5skOn0zk6dOhQ6SaPT5s2zVFUVKTMP3jwYGX5Cy+80OO5q5tn1apVjoULFyqPS99ts9kcRqNR+fvEE08oj//xxx+OlStXqr5+eOM64D7AfYD9KPcB9gPcB7gPcB/gPsBzCu4D7Afg5+vAV2f2k7QbjUaDQDJlyhSMHz9e7WYQkR9ZOHEi7DnZiNBpMHiw5JeqK6Rla/QbMgS7pj0Ly4OPY+6/H4cpKxNN+/ZCl0W/4u47b0G/dz+ttFzCg1MQZClEaGgo9r79OiI6dYa1sBAvt2gC3HQV9OHhMOeeQKNq5mmRmoS4ceOx9YkH0W7iLcjfuQ3Lx49Gwe6deOa2W3ETTOg+7Dwc+/0X/HPNOKitsLAYa9dtgTaqGVqNGYPekyfX+mv8+OOPeO211xDVqxm6T6zZiOhPXfwERnQeges+vwH5pflVznNeh3Nx57DJaNk4HtlF2fhuw2z8tv33KuftE98bj415FM0jYuCAAyknUvHN+m/x9/4Vyv9DjaF4cOQDGNZxGPQ6HbYc3YK3/5qBrMLjaBTcCD/cOQcrD6zCK3++WuP1sHvWTmTvOI6nn34a11xzTY2Xp/pv8ZQpMKenIdRuw7nnql9PlP2ob0pKSrH6n03QNG2KFheMQP/774e/eP311/HDDz8o95s0aQKDwXBGz3f8+HElI1ar1aJZs2an9Rw2mw3Z2WVXlFx00UV44403zqhNRFR/5CUmYvWzz8KelYWWsVHo1tWz9JgaeCz0TWpqOnbvOQhtXAv0uuMOtB45so63DFHVahSobdeuneu+DCJ24sQJ5QuTcJZECBRxcXHKjYjIaU9YGGxFhWis16BfdJTqK8Zw2XjYs4+jfVoyNNs2o+UV1yqP248cxIBxl8O2bjXMLz9TabnuOgBZabDM/wWdJ98NR2kpLF9/hj4RYdANGQbjrXei9KWn4Mioeh6sWwFNx47o/eIrcKQfg3nOV8r60Pz0LYwT71Iet+3ajpj1qxDjB+spz2hEmkEPbUgIOrZo4fslJTXgPMYZwgyI7NDY5+Xiw1vg4h5jsDjxL2jitYhE5WXjwmIx7aKXkF2Sjc93fonRbS7CY6MfQW5oHrZlba80f1CTEKzKWI2sI8cRHdoMN3a5Hi+Mew57NftRYi3Bg/3ux6g2F2Hh4T9wwpSLG7peh/+7+iU8tbpsX/k75W9c3H0Mfk2bh9TCYzVaD/L+RevWretkPVPgOxARAdOJHITbrexHA6gflRIyKQY9NCEhaBcb61ef7759+7oCte+++y5uueWWM3q+li1bIjU1VTkPcC+rUBNLlizBmDFlA2r26NHDr9YXEakrJywMKaGhsBsN6BAWymNhAB0LIwuLUCznFKGh6NGhAzqxb6dACNRKHafBgwcrJ6ylpaW44YYbMHXqVGzbtg1z5sypNH9WVhZWrCjL8Nm3b5/r8d27d+Onn35S7l9wwQWIjo4+83dCRFTPWH6eDchN7s+epdwqcmRlVru8deGvys2dBHdL1q0+5TwwmWD570ewVHytzAyYpk87vTfTQF3cZjR0Gh1Wpq6qdp5L2l4MvVaPXw/9hj8TFyGjKB3/d96LuKz9uCoDtftO7MPB3IMIM4QpgeBrOl2lvIZWo0GIPgQjW41AvikfH2//TJm/f0w/9GjWHe0j2+Fw3hGsPrYGl7YfizFtRmPmrsr7FFF9wn408A0YUJ6ZvXnz5jMO1NYGaUdV7SMi8kc8FhIFlhqXPpg+fbpyiY/FYsHixYuVm+jduze2b/c8ody1axeuvbYsA6ziJaRyE8uXL8eIESNO/x0QERH5qb4xfWCz27A/54AyLQHVMEOo6/8F5kK0CC+7uiOr+LjyN7MkS/krQdjqSPD1+aFlGbKl1lK8tXkGiizFaBfZFjqtDlklZc/lfL5u6IoW4S2UQO3+E/uVNvWL6YOZu+rojRMR1RL3QOimTZv8Yr26t4OBWiIiIqpN2poucP7552PhwoXKJT5GoxFt27bFjBkz8PDDD9dqw4iIiAJdXFgc8s0FMNvNynS3qK747tKvXTcpXVCRBt5rvktW7fP/vIjPtv9Xmb6txy1Khm1VKj6byWZGgaUQsWGxp/WeiIjOpqioKOV8Q2zcuFGpMasmuarw77//Vu5LnfeuXbuq2h4iIiKqX05rMLFRo0Z5XPIjvvrqq0rzSaaswyGDmxERETVU5cfBI3mJePafF1zTJ0pzcawwTbkfE1pWBig6pCx4e+xk/VitRqtk4tocNtgdduUxCf4mZG1Tbv1j+mJg7AD0ie6FhMxtSras8znKnq/sedNOvo7SIofdp4AwEZE/uOqqq/D222/DbDZj5syZePzxx1Vri1wV6BxI7IorroBOJ4XhiYiIiFQM1BIRkR8IC4d+xCjYtm2BI+XoKWc1TnkQ2u49oTEYUTJ1MmCtWIEW0PboDcN1t0ATHAzrskWwLppfh41vGNKLMtAqoiUMWgMsdguKLEWV6s7+mbgYEzpcrtxkntFtRimPzz+8UPl7fZdrcVPXG/DT/rmYtfsb3NnrDhRbi5FWmI7YsOboE91bCc4ezU9WBhP7O2UlLmo9Enf3vgu5plx0btoJu7P34FDeYeX5jFojGhkbIbng9AbRIWqI/agmtgWMd9wLTXRzOIoKYJ33E2wb1lSaj/1o3bjnnnuUQK34+OOP8eijj0KrrfGFgbXio48+ct2/7777VGkDEVGt4jkFkV9R5xsOERGdMU14BAzjroS2ZWuv89r271ECEdUKCoJx0t2wb98Cy/ffwDDhWmjbdeBWOkMJWVuVmrGdm3Sqdp60ojS8tvENmGwm3NV7MiKDIvHxtk+xNWtblfPnmfJwYasRuL/vPbi8/TgcyD2Ilze8hpTCVOX/n23/AsuOLseIVsOVgca2ZCRg+qa3XMtLW6RN0jaihs7nftRggHXNCpheex6OlGQYbp4E6CvkO7AfrTMdO3bExRdfrNw/cuQI/ve//0ENf/31F9atW6fc79OnD4YOHapKO4iIahPPKYj8CzNqiYgClPH+R8v+3non7OOugOm5x6qd17Z8MTShV1T7f23bDtCEhsG6aT0cSYfhME+Gtkcf2I8cgr8LCQnCgH49oZ9wDZoMORf+ZHHiEozvcBmGxZ+HXdm7q51vXdoG5VaV2Xu/V25OP+z/SblVR7Jt39nyXrX/l7ZICYXFiX/5/D6IGno/6khOgi05SblvP3wAul59AWMQYLXWi35Uxp1Q+tFLJyDSz/pRp4ceegiLFi1S7j/44INKKbbY2LNXa7ugoACTJ092TUsbNBqWkCGiwMdzijLNopoox0LjXQ8guk8flbcKNWS1Fqi97bbblBsRUaC6dulSWH74DrY1KxAILF99iqBHn4X5p//Btmkdgt/+tNI85g/fgv3Qfq/PpYloVHbHVHryrwmaiAgEAgkwdOjQBkGXXAJt+45qN8eDZLn+nbwCF7Yaie/2zEahpVDV9oQbwjGy1QisSFmJlEKWPqDad9X8+bDM+xHWZYvrZz8a2Rj6C0bBtmUjUFxUb/pRg0Gv9KPGMaOh69YT/uiSSy7B9ddfj++//x45OTm4++678csvv5y1YKnUxU1KSnKNwzFx4sSz8rpEFFiadOqE61esgGn6NGjSAuO7Fs8pyjRqFKHcQq6+WuUtQg0dM2qJiE4yhoUBwUHQGgKja3QUngz6SbAgPw+mV5+rPE/uCd+eqyC/7E5wcNnfoGA4Cgpqr7EN2Iwt72MG3oc/kEDx9QtuUrsZVI8ZQkOVfkRTH/vR8AgEPfgkHPl5MH/zReX52I/WuQ8++ADLli1DVlYW5s2bhzfeeANPPvlknb/urFmz8OmnZUH8sLAwfPnll6rVyCUi/6bRapVzCrvRCEeADDbIcwoi/xIY36KJiKgyi1n5o2kWXRZAePblSrOY338T9oP7oGkWA01YWWaXpnksHNnHy7K+IhsrAQp74mE4SoqhHzAE9qhm0BiNsO/ewbVORPWbr/1oylEEPfC4Uu7A/OXHUnMFsFkBm4396FnUrFkzfPLJJ7j6ZLbTU089hdDQUDzwwAN19ppz5szB7bff7pqW4HC7du3q7PWIiM46nlMQ+RUGaomIApTjRA5su3dAf/Hl0HbsAtN/nqk2E8z44BPQRkUr94Of+Q/MX38O+/69CP7PWzDP/gq2Vcth/upTGK69GbpzhsLy+89KHcZAYLPZUFxcAtOxYwiKbIKQqCi1m0RE9awflfqz2lZtlOngf09T/preeVX50as+9KN2ux1FRcUwHEtDUHQsQps1g7+66qqr8PLLL+OZZ8q21dSpU5GWloaXXnoJBoOhVtfJO++8o5Q8cDgcymMSEL7nnntq7TWIiPwBzynKmC0WmEpNsBw9iuCmTWEMD1d5y1BDpXE4v3kQETVw27/4AtZ1/8CYcgQd2pedkJP/y8srwKIlK6FtHoeO11+Poc8+W+uv8fHHH+Pee+9F7JA4DHxyMBqqTa+vR/q6NGV9SH1Ioop2zpoF87rV0B/ah04dmXUYKCRIu+CP5dDENEe78RNw/iuvwJ/J6csLL7yAadPKguaiX79++Oqrr9C7d+9TLtuyZUukpqYiPj4eKSlV1488dOiQkkW7cuVK12N33nmnks3LkgdEdCrFx4/jwNy5sCz8DU00VrSIa84VFiAOHzmKTZt3QNu6LYY8+yw6XVH9QMxEdYnFlYiITtrxxRfYuexvHD58lOuEiOg07Jo1CzuXLMPBg2WDLhHVBRlA7P/+7//w9ttvQ3eyBmRCQgIGDhyIJ554wjXoV02lp6crzyvBXvcg7dNPP63UqGWQloi8Kc3OxvbPPsOujVuQlpbJFUZENcZALRERERERBZyHH34Y69atQ48ePZRpi8WC6dOnKzVkL7/8cvz666/IyMg45XPk5OTgjz/+wA033IBWrVopmbrFxcXK/9q2basMXvbKK68owWEiIiKiusYatUREREREFJAki3bz5s1KJqwEaSVYK6UR5s+fr9yElDkYMGAAYmNjkZubqzyWnZ2tBHQTExMrPadkzkp5l9dffx3hrFFIREREZxEDtUREREREFLCCgoKUAcZksK///ve/Si1Z9/qzUpNWbu5KS0srBWmjo6OVWrR33XUX2rRhrXoiIiI6+xioJSIiIiKigCcZs8888wyefPJJpZzBihUrlGxbuRUUFFSaPzQ0VBmETLJthw0bhvHjxytBXyIiIiK1MFBLRERERET1hl6vV2rUyk3Y7XZlgLH8/HyYTCYYjUalpIGUPnAORkZERETkDxioJSIiIiKiektqzkpQloiIiMjfadVuABEREREREREREVFDx0AtERERERERERERkcpY+oCI6KRmPXvCesCA8OJ8rpMAEh4ehnFjR8J490MwduuhdnOIGrSo7t1hgh0hucfVbgrVQEhIsNKPGm6/B8ZefbnuiIhOky44GM169YLNYUVYWCjXYwBp1bIFmsc0Q/Cr7yKocWO1m0MNGAO1REQnXfzFFzDPngXbqmVcJwFEp9MqX4SDmjeHll+qiFQ16oMPYPnle1iXLOSWCLAartKPGmNioGvaVO3mEBEFrMg2bTB25kyUvvI8HClJajeHasBg0Cu3kBYtuN5IVSx9QERERERERERERKQyBmqJiIiIiIiIiIiIVMZALRERBTSTyYwDB49g3/wFSNu4sU5eQ68vqxRkt9rRkDnfv3N9EFH9YLFYyvrRP/5E6po1ajeHiIjorMvLL1COhXu//x65hw9zC5BqeKZFRHTSosmTYT2wTxlM7JxBHEwlUJSWmpCwdTe0aSfQMb8AcYMG1fprxMbGKn8LkwvgcDig0WjQ0Mj7lvcv4uLi1G4O+am/7r8fpt07lcHEhg4ZoHZzyEdms0XpRzXHstHueA7izz2X646I6DTkJSVhzYsvwrY9AfGNw9G1SweuxwCRnX2i7Jxi+nQMefZZNG7fXu0mUQPFQC0R0UnHd+6ELTMDNn3DC8LRqV144YUICQlBcUYxjm/LQnTfmAa3yrISMpX3HxoaipEjR6rdHPJT2bt3w3Q0GeF2q9pNISIiOutspaU4vmMH7OmZaGzgBcxEVHMM1BIREXkRFhaG6667DrNmzcKm19ej/YSOiOkfC2OEEZp6/B3cYQfMBWZkbk7H4d8OKo/JepBgLREREREREdUuBmqJiCpwcI0EFMdZ2mIff/wxUlNT8ddff+HA9/uUW0MzevRofPTRR2o3gwLA2fpcEhER+SVeoEdEp4mBWiKik3RBQbBpNLBZbVwnAcTq3F5ajbIN64qUPvj999/x448/KreNGzciPz8f9V2jRo0waNAgXHvttcotODhY7SaRH9MHB8Ok0cBqZemDQGI5ub00Gm2d9qNERPWd1mhU/sp4Bq7vqBQQrBarbDjX9xkitTBQS0R0Unh8PHIyM1GQnYXi4hKEhoZw3QSAzMzjZV+q9AZExMfX6WtJkPKWW25RbkRUdT9alJSI0rxc5OcXoFGjCK6mAJCZmV12x2BQtiEREZ2esObNodXrYTMakZmV3WAHoQ1Esr00JwPtPBaSmupxZT0iopppc9FF0EjtTY0GGzdtV4K15L/ki29aWib27z/s2m6tOMgVkapaX3ghNMEhgFaLTZt3oKiomFvEz/vRjIzj2LP3IDQhocp2k21IRESnxxAairghQ6AJDUdJSSm2btsNs8XC1enHbDYb9h84opxXIDQcoTExaNajh9rNogaMGbVERCe1veQS7Jo1C+aY5sjIzMD8hctw8Zjh2LFjL0wms9f11K1rR7Ro0dw1XVhYhPUbtvq0fs87dyCCg8svN006moqDBxO9LhcWFoohg/t5PJawdRdycnK9Ltu6VQt06tTO44R92fI1PrW3b5/uiIpq4prOzj6hfBH1xUUXnucxLYHW5JQ0r8s1bdoY/fqWf2kqKCzCqn82QmMMgqZJFOLPOw/hcXE+tYGI6kabUaOw/fPPYbaYcTwzAwv+WK585uVz7suPX9InSd/kJCe5a9Zu9um1pS+UPtEpNTUde/cd8rqc9L3SB7vbvmMvsrJOZpmegvT50ve7+3vFOuWkz5tePbsgJqaZazo3Nx+bt+yALy4YPgR6vc41fehwEhITU7wuFxkZgYEDenus3xWr1gMGI7TRzRDTrx8at2/vUxuIiKhqna66CqmrV0PTpCkOHExU+uexl4zAP2s2+bTKBp/TD+Hh5cezY8cylB/UvAkKMmLYeYM8Htuxc2/5VROnEBcXg+7dOnk8tmLlOp/KN/Ts0QXNm5cfz/LyCrBp83b4Yvj5g2EwlIelDh85iiNHkr0uJ1fsDBpYfjwT8pry2t60a9sK7du3dk0nJ6cp5zGa8HBoIiLQ6corodEyp5HUw0AtEdFJctn8RR98gKX33w+LwQhHSTGCz78QuTsOosTsPSvM3K4jdAPKg6aOjEzkrPbtC5lmwGDoIhuVP5djLXJ2e/9CZo0Mgu7c4R6PFexPRk76ca/LRsfEeSwrgdqcRSt9aq+tW0/oOnYon95/EDkbfftCVrG9JXmlyDns/QuZMTyyfFmtDk3DwtAkuxh5mVlo3r8/zn/1VZ9en4jqTmh0NEZ//DGW3HMPzNKPFhcjeNgI5B1KQYHZ+8mTuVU76M4d7JrW5OYiZ8V6316870DoostPFM0bNyNnh/dB/0JDwir1S0VJGchJzfC6bJOomErLnli6tqzOnRfWTt2g69HNNW1PSkbOugT4Qjv4XI9asqaSv5Gz3/uPe9pgt/eq0aJRaBii8y3IPpqMqO7dMfLtt316fSIiql6r4cMx5JlnsO7ll5WrvvR6PTRDzkfO3+t8W219B0AXE+2aNG9OQM72vV4XCwkKqXw8S85ETor341lk08rHs5xl62A1+3A869gFul7lyRT25BTkrN0Cn49nbvVgTaUrkLPviNflNEGhlc+Bdh1CTtYJr8vGtWjlcU7R6qJgbE5/Aw6tFp2vvRa9Jk/2qe1EdYWBWiIiN9G9e+PS777DkT/+wNGlSxH6r0nQzlsITWam1/VkGDEaxgkTXNPGQ4egmf2zT+vXcO3NMMbEuHXOQdBs9J6Nq23TDsZ/3eHxmG7tFmhyvQ9ypRs4xGNZpYbWu5/41t5LxsM4ZEh5e9esgWbhEp+WrdhefWYeND5kvem6dK+0bO+QSNhMJrQZPZpF/4n8RNMuXTDu229x5M8/kfTXXwi94RZol6+GxuG9Rp9+2AgYb7rJNW1OS4Pmq9k+va7hyuthbNu2/LlCm0Dzzwavy2ljYyv3o9v3QZPh/QcvXd+BlZbVfPoVNCXes4cNoy+F0a3MgGHbNmh+mQ9fGG+8Tbm81tWOQgs0O/Z4XU7boXOl9vZsHA1TXh7ajhnj8ZxERHT6JCuzcceOyrEwPykJhiuuheazmT4ta7jiOhjdrm4wRMyDZpX3IK82Jqby8WznAWjSsrwuq+vTv9Ky2s+/hqaoyOuy+lFjYRw9ury9O3ZA8/Pv8IXxhokwhoeXt6PYBs1271fpaTt0qtzeZf9AU1Tqvb2Dz/NYVqrS9iu2oFGbNmh5/vmsKUyq0zjkzJyIiIiIiIiIiIiIVMPCG0REREREREREREQqY6CWiIiIiIiIiIiISGUM1BIRERERERERERGpjIFaIiIiIiIiIiIiIpUxUEtERERERERERESkMgZqiYiIiIiIiIiIiFTGQC0RERERERERERGRyhioJSIiIiIiIiIiIlIZA7VEREREREREREREKmOgloiIiIiIiIiIiEhlDNQSERERERERERERqYyBWiIiIiIiIiIiIiKVMVBLREREREREREREpDIGaomIiIiIiIiIiIhUxkAtERERERERERERkcoYqCUiIiIiIiIiIiJSGQO1RERERERERERERFDX/wPtWMa628/uJAAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -664,14 +673,13 @@ "source": [ "# Add T1/T2 noise to the circuit\n", "T1 = 100 # microseconds (typical for superconducting qubits)\n", - "T2 = 200\n", + "T2 = 80\n", "\n", "noisy_circuit = add_time_based_noise(\n", " circuit=vqc_circuit,\n", " num_qubits=n_qubits,\n", " T1=T1,\n", " T2=T2,\n", - " gate_durations=gate_durations\n", ")\n", "\n", "print(f\"=== NOISY CIRCUIT (T1={T1}μs, T2={T2}μs) ===\")\n", @@ -687,17 +695,37 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "id": "dd75a3bc", + "metadata": {}, + "source": [ + "---\n", + "## 4. Deep VQC Architecture\n", + "\n", + "Our deep variational quantum circuit uses multiple layers of parameterized gates." + ] + }, { "cell_type": "code", - "execution_count": 12, - "id": "3063ecb9", + "execution_count": 13, + "id": "4bcab0e6", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== DEEP VQC (3 layers) ===\n", + "Total gates: 14\n", + "Trainable parameters: 9\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABvoAAAEVCAYAAAAhPDKdAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAbaNJREFUeJzt3QWYFPUbwPH3urig4+hupEUBQUpKVAzEjj8GCjY2qIgKKiAIBrZImKCggIiEhHSXdB4czXXs/3l/xy57yQF3tze738/z7LM1u/Pb2Zl5Z+b9hZfNZrMJAAAAAAAAAAAAAEvxdnUBAAAAAAAAAAAAAFw8En0AAAAAAAAAAACABZHoAwAAAAAAAAAAACyIRB8AAAAAAAAAAABgQST6AAAAAAAAAAAAAAsi0QcAAAAAAAAAAABYEIk+AAAAAAAAAAAAwIJI9AEAAAAAAAAAAAAWRKIPAAAAAAAAAAAAsCASfQAAAICF7d69W7y8vBy3v//+u0Dm6zzPL7/8UqykcuXKjrIPGTLE1cVBIaLrsvO6XVjde++9jjK2a9cuX+bxxx9/OObRv39/yU/6G+zz0t/mqZYvX+5YDn369HF1cQAAAGARJPoAAABwUTSR5HwhXG/+/v4SHh4uVatWlY4dO8prr70m+/btc6slu3Tp0nS/efjw4dlO+9VXX6Wbdtq0aWIlVk7iFYRFixbJ/fffL7Vq1ZLQ0FAJCAiQsmXLSteuXWXcuHESGxsrVlUQCaSC9s8//0i/fv2kfv36EhERIX5+flKiRAlp06aNDB48WHbs2CHuJC/+Q5vNJi+88IJ57OPjI08//XS697///nvp27ev1KtXzyxLXaZFihSROnXqyAMPPCCrV6/Ok9/iaZo3by7XXHONeTx16lSWIwAAAHLFN3eTAQAAANlLSkoyt9OnT8uuXbtk7ty58sYbb8grr7xibt7e1q9fduWVV0rt2rVly5Yt5vk333wjzz33XJbT6nt2JUuWlG7duuVbuYoVKyYjRoxwPK9WrZoUBOd56sVpTxATEyP/+9//ZNKkSZneO3z4sGkBpbe3337bJEJatmzpknIizYkTJ0xC9pdffsm0SI4dO2YStnqbP3++oyWsrsvO63Zhpa29NHGpKlSokOff//PPP8uaNWvM4x49ephKHBkrM8yYMSPda8nJyWb/qLevv/5apkyZIjfddFOel83dDRw40KyTmmzVRPT06dNdXSQAAAAUciT6AAAAcFluu+02adasmZw6dUpWrVols2bNkpSUFHPTbhE1ATJ+/Hi3WMr33HOPo5XLhg0bTGuLxo0bp5tm//79Mm/ePMfzO+64w7R2yWuJiYnmQnBYWJg888wzUtBcMU9X0mV9++23y6+//up4rUaNGnLjjTeaVn1LliyRmTNnmte1NWvnzp1NK1Bt4QTXJGX1P1ixYoXjtTJlysgNN9wgFStWlDNnzpj9lVZKcKYt1PR2qdujtu4sCNddd5255ZePPvrI8TirLiSDg4NNa8EGDRpIqVKlTJJPW07++eef5n19/uKLL3p0ok/XMd03XCytGKL7da04o/sUjSnly5fPlzICAADATdgAAACAizBv3jybHkbab1988UW69zdt2mSrUqVKuml+//33TN+zZs0a23333WerWrWqLTAw0BYSEmK74oorbG+++abt7NmzWc771KlTtmHDhtlatGhhCwsLs/n5+dkqVKhgu+eee2wbNmzINP3gwYMdZahUqZLtxIkTtgEDBtgiIyNt/v7+tjp16tjGjBljS01NzdVvP3DggM3Hx8fxnU8++WSmad5+++10v33t2rXm9Z9++sl255132ho0aGArVaqUKbv+Zi1D//79bbt27cr0Xddcc43je/Q3rl+/3tarVy9bsWLFzGurV682n3Oen/4/djt37rQNHDjQ1rp1a1v58uVtwcHB5neXK1fO1qNHD9v06dOznV9WN12GdjmtA+rPP/+09e7d27GsQ0NDbY0bN7a9+uqrtmPHjmWaXr/b/n36v61YscLWvXt3W3h4uC0oKMj8hoULF2b63GeffWa75ZZbbLVr17YVL17c5uvra+bVqFEj23PPPWc7evToBeeVG5MmTUr3m7t27WpLSEhIN82XX36ZbpqOHTumez+nZab/r/09/R/y+jdeaHlqeXL6753XrYzrpbOM3+Ms4+eWLVtm69Chg9kOdJt49NFHbWfOnDHTTpkyxdakSROzb9D19amnnrLFx8fbcuv5559PVw7dbmJiYrLcpj/66KNLKn9W26Pdvn37zH+j+zT9rwICAsy+SqefPXt2rv73jPta531EVp+7mP8wJ3v37rV5e3ub6XXbzW5/nBVd5+3z0v8ut3Jap4YPH26WW40aNWxFixY167+ux82bN7cNHTo0Xfnatm3r+J7bb78903zGjh3reF+/Ky4uLs/iS3R0tFmHdZ+ny2/kyJFmut27d9v69etnq169ulkmui7oOn3VVVeZGKIxM6O+ffs6vlt/IwAAAJATEn0AAADI00Sf+vfff9NN07lz53Tvjxs3zlysze5idN26dW2HDh1K95lt27bZKleunO1n9OLp1KlTs70QW7JkSVv9+vWz/Ozjjz+e699/3XXXOT5XpkwZW3Jycrr369Wr53hfE1t2mvTK6QK8Xlhet25dthe/9bs0IeL8mQsl+n799dcLXvh/7bXXspzf5ST6NCmT0/fohfCMF86dE1N6oV0vsmf1H2e8KN60adMLzkuTOZeb6GvXrp3jM3oRf+vWrVlO16pVq2yTMzkts5wSPpf7G3OzPAs60afbic4/4zx0Ob/77rtZzv+uu+7K1X+VmJhokmvO22luk1W5LX9226OaMWNGuvlnvGnyvTAn+j7//HPH9M2aNcvVctMk2R9//GEStvbP6nqbWzmtU5rczuk3aeUJe4L4+++/d7yuSbXjx4+n+y7nRKAm5fIqvpQoUcIk4p0/o4m+qKgoE3tyKv/48eMzLQ+tgJLdegEAAABkRNedAAAAyHM6zlWjRo1k7dq15vmCBQtMV54+Pj6yePFieeyxxyQ1NdUx9p12QafdnOm4T9HR0bJp0ya5++67Zfbs2WYa/ax2kbh7927HuHd9+/Y149NpV6H6nQkJCeYzTZs2zTSelDp69KjpCu3hhx+WiIgI+fbbb02XaGrMmDHSu3dvueaaay742+69914zDpvSbkm1jF27djXPtSvAjRs3ppvWTuepXQlqV45FixYVf39/iYqKMmNh7d2715Rt0KBBju4fM9JuQn19feWuu+4yXUbqOFiBgYE5llWnv+KKK0zXqrrMtDs47dJQu9izdy+qYyk+8MADEhkZKY888ogZj+vZZ5/N1DWrCg8Pv+Dy0fEJ33//fcdz7QZR/7uDBw+a/1f/ywMHDpgu/XRZaRkz+vfff01XddrtqXaD+d1335nX9T8ePXp0um4FtdvAnj17mrEJdX3QdUy/X8cH03HY9PHQoUNl3Lhxcqm0zLqO2em6XbNmzSyn1eWl3Xja6RhwlStXlstxub8xN8vTPjadfqe9u0vdjnSdyI/xH/W/r1SpkimTls/e5aOOlae36tWrm2Wp27e9PBMnTjTjH5YrVy7H716+fLnZn9jp94SEhEheym573LNnj9xyyy0SGxtrpvPy8pLrr7/ebIe6D/rrr78kv+TVf7hw4ULHY/u2nx1dr3T9y0j3d7pu5QWdR/v27c36ovtOzZnrWLD6O3V/tn79erPu65ip2jWrTq/79vj4eLM/GjBggGN/rduj3X333Zdn8UXjlt46duwoV199tfmvS5cuLT/++KN5rLTsOs/ixYub/aGuM87L2pnzuKfLli0zXcNqzAAAAACyQqIPAAAA+aJWrVqORJ9ecD1+/Li5gPruu+86knw6xpOOkeXt7e24IN+iRQvzeM6cObJu3Tpp2LChzJgxw5FA0ySHJqr04rp66aWXzDh5erFX5zN27Nh0iSZnn3/+ubmAqx566CGTrElKSjLPP/3001wl+vRCsl6wPXHihHmuF5LtiT59bKfj8tnnpSZMmGDmpeO2bd++3ST29IJ0hw4d5IsvvjDTaBJAp8luTL8ffvhBevXqle41+8XpnMbx2rZtm0lM6AVn/W4dA0ovHmsyQsfS0vlqwkKXv3JO9OnnnROWF/Lee+85HmuCS5MuQUFBjqTBo48+ah5rmX777TezPDPSpIyWz57Q0XL+8ssv5rF+nzNNjOr7mlzbuXOnnD17VqpUqSKtW7eWadOmmWn0Yv3l0GSaXmi304RDdjK+d+jQIblcl/sbc7M87WPT6diT9iRRhQoV8m0sRl0PNaGn64iWR5PIui4qTWjMnz/flFfXy9q1a5vXdb+xcuXKCyb6Miae7J/Pa1ltj08//bQjyae0QoHzfkB/gyb280Ne/Yc7duxwPNbPXyxNhE2dOtUkxfLCmjVrzBiwmnDTZafJPa0wod+vlUjs678m+jT5qolNjQv2/a490af/lz326NiC9iRmXsWXJ554QkaOHJnuNefnt956a7r9o9LfottzRs5j8ul8NTF4uRUGAAAA4L5I9AEAACBfpPVUmJleRLXTC/16YTU7emFXE33On9HWF9m1prJ/JrvEgj2RpfSiqSZK7C3bNIGQGwEBAdKnTx8ZP368ea4JE209FBwcLJMmTXJMpy2wSpQo4XiurZH0QrC2+siOthrR98uWLZvpvfr162dKKlyIJgG1xVR2y8TO3rLxcmmCQ5OzdtqyyZ7kU9oixp7oU5q4yirRp7/TOZmjSWM7e4LVTi+6Dx48OMuL5Xn9++ycf9OF6Pp6uS73N17M8iwo2urJnrjQbUcrAdiTovqevbwZW6C5qry53R6dW4xpMso5yae0UkNhT9jYW6ApbdWWk1deecUk4XS/pZU2tFWzJqOvuuoqk2TTRO3l0MTc888/b1oHOifbc1r///e//8nrr79u9qeaoNMkd8uWLeX777/P1JpP5UV8US+//HKm13Rd1ladGg8//vhjk1ivW7eu2QY10agtFbXlX0ba6i/jf1LY1xsAAAC4Dok+AAAA5AttsWWnXdrZL1xqy76LveB8KZ/JSOefManofIH15MmTuZ6HtnCzJ/ri4uJMSxH9Lu2K03kaO734rUkue2uSnOjF6axcSqskTaLZW1VeyjwvliZhnBO8GS9ga8uyIkWKOBJW2SVtMl7Q1uSqnfMy1CSrtqC6kJwSBLmhyQ5NFNtbf+bUIku7bsyuZU5OifDs/oO8+I25XZ6XIre/I6OMrfKcuyV0fi9j1665Ka92Q+tMu0jMa9ltj877Km11WRDL0pW0ZbQz7QZYW07r+qjvderUScqUKXPJ3//BBx+Y7kgvxHlZadL49ttvly+//NI814RjxYoVHUlY3ZbvvPNOx/R5EV+0UkfG5JzSFuqaqNeEqO73NBbozflzmoDU1u25qSgDAAAAZIVEHwAAAPKcdhvnnGDSLjHt3XNq0uTIkSPmsbaoy6mVmrYKsX/GOWmo48plJ7tx5LT7Rfs4gXbOiTkdUyq39OKttsrQsQTtXXY6J7X0sb07T6UXcu0JCm3doWOkaYs/TXxpt4zdu3e/4DwvdoyxrVu3pvsPtGXR8OHDTRJFy6DjvmV30fpSaZem9tYrGZdvVt3U6fRZydh1qX5nVnSMLjtNIP7000/Spk0bs47omF39+/eXvKDJplatWjm6CdQx5XTZaUIhI+2y0Jmu486/w75sNEHsTLtzza/fmNvlmVv2bflifseFyuQsq3EbL4aObxYaGuoYp0//k2HDhpmWg3klu+3ReV+l48gVxLLMa84tkS+2BaXuzzXRZ/892pruYlsiZ7f+675LxzTV8Q41MaxddWaXBHz88ccdib7JkyeblqH2fbCOQ+q87eZFfMlp/6wtufv162e6bdYuQvV/1XFe9V5bQt5zzz2ZKghkTD5mta8BAAAA7Ej0AQAAIE9pgkm7tnT21FNPpUve2ccHO3z4sLkAGhYWlm56vUCsyTF7os9+bx+vSMehck6k2elFZefWSs60NZZeNLZ3pafdWjp3s3ex40lpiz290GzvgtR5vtpaxDlZoUlG5wvFOlaT/QJ/xsRQXnGep7r55psdLZ20vDkl+bTs9vHSnMcbuxBNpDRq1MiMqaX0P3zttdccXV1+/fXX6aZ3/l8v9zfquGDaekjpBX1tZZmXdD21J/p0XdIuSLWrVuf/WRO+zl376Trq3JpOk8n2xIle9Ld3Y6rji2XXdWxB/saMCbjs/nvnpLiO/aittzTxomPjffXVV+Jq+ht02b7zzjvmuXYJql1I6nh5Gbtd1bHPdKxI/X/zgiZ2NRGsNm/ebJJMzvtDTfTu27fPtDDLuCx136kti/U17Q7zww8/zLf/MCe6ni1cuNA81rJm9N9//5n/XCs7ZKTj3eVlUtl5/deuLu1juGoc+PXXX7P9XJMmTcz+RbdHrVyg+yG7+++/P920eRFfsqPrl1Yu0cof1157rbnZtxsto72FsP5O5xaBzstdk48XGpcSAAAAno1EHwAAAC6LtkzQVgmnT582Fy/1uT1JpLTFUefOnR3PtRvCadOmmQveesFYx7q66aabzIVQvbitYyrNnz/ftP7S7i6VtnjT8a70wrm9S0r9jF5o1oTHjh07TBJGW0V88cUXpsVHVvQCr17A1gvpetHf3hWjevDBBy/qd2vi4IUXXjCtBPW36AXirLrtzDgmml7I19+jF5c10Th79mzJD9WrVzfJRHsrloEDB5oEnF5Q1mWUE00I2luYvPfee+YzmiBp3LixdOjQIcfP6v9rH5dLk6nauurGG280F7ydk0A6DlZuWjLmRJfrnDlzzGMdG1C769P15PfffzeJtLyk363jLOp3K02yaescXRc1walJAE0Y2ek4izomlzNdFvb/W5OCmhjT5ZrTOlCQvzFjt5eafNT1pkKFCiaRN2DAAMfv0JZVSrdhTVhomXS8y4wJZlfR8dJ0udm7SdSWkNqqS9dF7U5VW/vpezqunI6jlleJPl1G2q2vvXWeVizQCga6T9IkrybZtZvGUaNGOZalne5DdRvTZJaOG6frR379hznR5WHfVp27mbTbsGGDWY76v+u0uq5r2XW/reNu2mmryrZt28rl0PXf3rJRty/tDlS7AtXt70JdsmqrPnvi3b5/1s9ed9116abLq/iSFf2cjpOqCWCdhybsNGbo+min/0vG1qbaKt5O1wfnrm0BAACATGwAAADARZg3b572PXjBm6+vr+2NN96wpaSkZPqODz/80Lx/oe9wtnXrVlvlypUv+JkvvvjC8ZnBgwc7Xi9durStadOmWX7m0UcfvaR1oFu3bpm+S+eR0bFjx2zlypXLct733HNPuue7du1yfO6aa65JN11WdHrnz+v/Y/fwww9nOc8OHTrYIiMjHc91OTl78skns/xc//79HdNkt8zVU089leN/pMtiw4YN6T5TqVKlbMvj/D/qdHbbt2+3hYaGZrnu3XHHHdmuSznNKydnzpyx3XrrrRdcB+vUqWNbs2ZNps/PmTPH5uXllWn64sWL21q0aOF4rv97fv7G7JanWr16tc3b2zvT/EJCQhzTREVFmTJnnEY/16VLl2zLlNP67FzejO/ltK7lJDo62tajR48L/l/Oy1u//1LK72zGjBlZ/mf228CBAx3TxsXF2WrUqJHldBn3L877Buf9hnP5c/sf5mTnzp2O9TQwMNAWExOT7v2ff/75gss0ODjYNm3atFzNL6dlu3DhwixjRZEiRWw33XRTtuuxSkxMzLTfffbZZ7Oc/+XGl6zmryZNmnTB79T9ZUZ9+/Z1vK9xFAAAAMjJ+QEBAAAAgEukXZNp640qVaqYFl/aTZq25tJWNc5jUNlpt3ra+k9b0WjLLm3NoF0gaqs+Hc/vlVdeSTe+nNLptEWTjjOnreF0fDf7fBs2bGha5GkrI3vXnBlp92fa4ujJJ580LXq0hYS2Fhk9erSMHTv2kn73fffdl+m1jK357GNAaes9bSWi3ZRqKy5tyaOtOrKaPq+MGTNGXn/9dalUqZLpzk+7C3z22WdNl3c5jYP25ptvmlZAupycxzTMLW0FqK2pevfubVqw6Lx1fDltCaP/rf6P2j1eXrRa1BYz2mJU1yGdh64/2kqrY8eOktf0+7V1ls5TW4fq+qPrnzNttaMtJ7UL04y0TLqOaksoXf+0qz5t7aOtrvRzheE36n+kXZJqGXWbyYqO76itt7R7Qy2Pjk+mXRJqa7WM3fa6ki5fXde1rA888IBZxrr96Tqt26S2stL9ScYuZS9Xt27dTGtP3dZ036TLSLcB3Ra09Zi+b6fLWP9L7c5XWxrr85YtW5r1RD+fX/9hTnQ/rq0O7S3hMnbHqfuuV1991fznuk+x7791eetYli+99JLphvT666+Xy6X/kXZtq/t87TZTuz7W5act9Ro0aJDjZ3WZP/zww+ley9htZ17Fl5zKr/tT/d+1Ral+ny4rHXNPY6WOI6j7S2cJCQmO1sEaP3UMPwAAACAnXprty3EKAAAAwKKGDBniGJtJk12afATymo412aZNG9ONpXrmmWdkxIgRLGhYlo6vqclHpRUUfvzxR7EiHSNRu7tVV155ZbquRQsrTSjqMlc9evTIcSxCAAAAQNGiDwAAAAAug477pS0Y7WOjvfvuuzJs2DCWKSxLW+NqSzY1ffp0S1WS0HFQtXWptr7V1oV2jz32mFiBtjJXXl5ejooqAAAAQE6y768HAAAAAJArlStXlj///NO0IFJJSUly5MgR080lYDXaZeTbb79tuslMTk42yetL7eK4oGnXue3bt0/3mrbms7fsK8yWL19uuppV2qJSu18FAAAALoREHwAAAADkgdq1a5vuYgF3oGMwWnmkD20Rp61te/bsaVrYZjVebGGj4x9aeZkDAADANRijDwAAAAAAAAAAALCgwl+lDQAAAAAAAAAAAEAmJPoAAAAAAAAAAAAACyLRBwAAAAAAAAAAAFgQiT4AAAAAAAAAAADAgkj0AQAAAAAAAAAAABZEog8AAAAAAAAAAACwIBJ9AAAAAAAAAAAAgAWR6AMAAAAAAAAAAAAsiEQfAAAAAAAAAAAAYEEk+gAAAAAAAAAAAAALItEHAAAAAAAAAAAAWBCJPgAAAAAAAAAAAMCCSPQBAAAAAAAAAAAAFkSiDwAAAAAAAAAAALAgEn0AAAAAAAAAAACABZHoAwAAAAAAAAAAACyIRB8AAAAAAAAAAABgQST6AAAAAAAAAAAAAAsi0QcAAAAAAAAAAABYEIk+AAAAAAAAAAAAwIJI9AEAAAAAAAAAAAAWRKIPAAAAAAAAAAAAsCASfQAAAAAAAAAAAIAFkegDAAAAAAAAAAAALIhEHwAAAAAAAAAAAGBBJPoAAAAAAAAAAAAACyLRBwAAAAAAAAAAAFgQiT4AAAAAAAAAAADAgkj0AQAAAAAAAAAAABZEog8AAAAAAAAAAACwIBJ9AAAAAAAAAAAAgAWR6AMAAAAAAAAAAAAsiEQfAAAAAAAAAAAAYEEk+gAAAAAAAAAAAAALItEHAAAAAAAAAAAAWBCJPgAAAAAAAAAAAMCCSPQBAAAAAAAAAAAAFkSiDwAAAAAAAAAAALAgEn0AAAAAAAAAAACABZHoAwAAAAAAAAAAACyIRB8AAAAAAAAAAABgQST6AAAAAAAAAAAAAAsi0QcAAAAAAAAAAABYEIk+AAAAAAAAAAAAwIJI9AEAAAAAAAAAAAAWRKIPAAAAAAAAAAAAsCASfQAAAAAAAAAAAIAFkegDAAAAAAAAAAAALIhEHwAAAAAAAAAAAGBBJPoAAAAAAAAAAAAACyLRBwAAAAAAAAAAAFgQiT4AAAAAAAAAAADAgkj0AQAAAAAAAAAAABZEog8AAAAAAAAAAACwIBJ9AAAAAAAAAAAAgAWR6AMAAAAAAAAAAAAsiEQfAAAAAAAAAAAAYEEk+gAAAAAAAAAAAAALItEHAAAAAAAAAAAAWBCJPgAAAAAAAAAAAMCCSPQBAAAAAAAAAAAAFkSiDwAAAAAAAAAAALAgEn0AAAAAAAAAAACABZHoAwAAAAAAAAAAACyIRB8AAAAAAAAAAABgQST6AAAAAAAAAAAAAAsi0QcAAAAAAAAAAABYkK+rC4D8t23bNpkyZYrMnj1bjh49KqmpqW652L29vaVkyZLSpUsXue2226RGjRquLhI8DNsaAGQtPj5eZsyYIT/88INs3rxZYmNj3XZRBQcHS/369eXmm2+Wrl27SkBAgFjV1q1bHceQ0dHRbnsM6ePjk+4Ysnr16q4uEoBCLi4uLl1c0+fuyp3i2pYtWxxx7dixY24f16677joT16pVq+bqIgEo5DSO/fbbbyau6b7SneNaSEhIurjm7+/v6iIBecLLZrPZ8uarUBj99NNP5sAuOTlZPImvr69MnTpVbrzxRlcXBR7ixx9/NNtaSkqKeNq2pgeCvXr1cnVRABRSZ86cMSdQ//zzj3ia9u3bmxNmvUhqNXoc1bdvX4+La35+fiauXX/99a4uCoBC6vTp0yaBsmTJEvE0HTp0kOnTp1syrmmCT+Oauyb3sqMXsPVctUePHq4uCoBC6tSpUyauLV26VDxNp06dZNq0aRIUFOTqogCXjUSfG1uxYoW0atXKJPmK1S0u5dtXkOAyIablmzvSA/bYwzGyf94+Ob7pmElAaJBq2rSpq4sGN/fvv//KVVddZS6Gpm1rFSW4TLB7b2uHzm1rm9O2tWXLlkmTJk1cXTQAhVDPnj1Nsss7KFxCr75XAmu1Fe+AED0MFfdjk9T4sxK39W85s+hLsSWclVtuucUkzaxEj59at26dFtfqFZfy7dw/rsUc1Li2V05sOW6SfRrbr7jiClcXDUAh1K1bN/n999/FOyhCQlvfK4E127h3XIs7kxbX/tG4FmMqN06ePFmsZPHixdKmTRuzvy9ev4SUb1dBgkp7TlzTZN/y5culYcOGri4agEJIk3yzZs1Ki2tt7pPAGhrXgj0mrmklkIkTJ7q6YMBlI9Hnxh5//HEZO3aslGxSWlq8eKV4+bjjDjozW4pN/n1ziRxdfUQGDBggo0ePdnWR4Ob69+8v48aNk1JNS0vzFzxnW0tNSZXlQ5fK0TVH5IknnpCRI0e6ukgACplDhw5JZGSkaAcS5Z6bJwGVm4mniNu+SA6P7GoqQ0RFRUmxYsXEKh5++GH5+OOPpVSz0tL8ec+Ka/++sUSi1x6Vp556St577z1XFwlAIbN//36pUKGCeVxu0HwJqOQ5Fd3iti6Qw6O7m8oQGteKFi0qVtGvXz/59NNPpXSLMtJsUEvx8vaQuJacKsteXyzH1kfLs88+K8OHD3d1kQAUMvv27ZOKFSuKeHlJuUELJKCi51R0i9vytxz+oKepDHHkyBEJDw93dZGAy+Ke1ZdgaO15VblrFY+5QKP0t+pvdl4GQH6yr2eVPGxb8/bxlkrXsa0ByN7MmTNNkk8TfJ6U5FNBNVqLf2R907OC1pC1Eh13SlXuVpW4BgBOtCWfCqja0qOSfCqoVlvxK1tHkpKSzBh3lrw2onHNQ5J8ytuX8zUAuTvuD6jWyqOSfCqodjvxK1NLEhMTZc6cOa4uDnDZSPS5scOHD5v70Iqh4mmKVAhztCQACmxbO7feeZLQimxrAC68f9QLg57Ir1xdSx6PeHRcO/eb7csAAJzZ9+f+HhrX/M/FNSvtI7XCEXHNesciAAqGff/oqXHNfp7KPhLugESfG9Ma5PZaXJ7G/pvtywDITx69rfml1YhlWwOQFfu+wcvX3yMXkJePnyX3kcQ16/1nAAqGY9/gsXHN33L7SE306c1jz9e4NgIgN+dr5/bvnsZ+nmqluAZkx/OOcgAAAAAAAAAAAAA3QKIPAAAAAAAAAAAAsCASfQAAAAAAAAAAAIAFkegDAAAAAAAAAAAALIhEHwAAAAAAAAAAAGBBJPoAAAAAAAAAAAAACyLRBwAAAAAAAAAAAFgQiT4AAAAAAAAAAADAgkj0AQAAAAAAAAAAABZEog8AAAAAAAAAAACwIBJ9AAAAAAAAAAAAgAWR6AMAAAAAAAAAAAAsiEQfAAAAAAAAAAAAYEEk+gAAAAAAAAAAAAALItEHAAAAAAAAAAAAWJCvqwsA6/v1hp8djxOSE+RgzCGZsvV7WX54hYxu/76UD42UMavHyew9c8w0Axo/Jp0qdZD5+xbIuytHurDkgLWwrQFA1nY+UsTxOC7JJntOp8qYFYny+84U89qCO4KlfFjW9duqjj/LYnUR4hoAZI24Zk3ENQDIGnENyH+06EOeeX/lKJm0dYpUDK0gTzd7QgJ9A2X06jGSYkuR++rdLREBEdKwRAOT5DsRf0I+XjeBpQ+wrQFAnnlqbrx8sCJRqhf1lpEdA6VYYNrrQxYlyIA58eb2xJ/xciQm1bw+478kln4hwDEkAGSNuGZNxDUAyBpxDcg/tOhDnll0YLEkpSZJ2/JtpGp4FSkdXFq2HN8q0//7VW6scYP0v+JhkwRU49Z+LGeSzrD0AbY1AMgzM3ckS2KKSM8avlK3hI9pxXc8PlX+2pPWsk893cJfSoV4y9bjKTJoXgJLvxDgGBIAskZcsybiGgBkjbgGWLhF3+nTp2XQoEFSrVo1CQgIkNKlS8udd94pO3bsyO9Zo4CF+odKjYjqUia4tJxJPCP7z+4zr3+z+TvZf2a/XFm2pZQrUk7m718oSw8t4/8B2NYAy7DZbBIdHS27d+829/ochU/RQC9pWNJbKoR5y8l4m+w4kdZyz65TZR95pImfnEmwyaN/xEtsssuKCiccQwIFj7hmDcQ1ayKuAQWPuGYNxDXAook+TfK1adNGhg8fLjt37pTExEQ5cuSITJw4UZo3by7r16/Pz9mjgH113WfyfrsR4uPlI0OXvSVxyfHmdW3lpy34VHxyvHy89lP+G4BtDbCEkydPyujRo6VGjRpSsmRJqVKlirnX5/q6vo/CY8ndIfLLzcHi6yXy0B9xEuPUM2eVcC9599q0vjyf/itedp0iWVtYcAwJFBzimrUQ16yJuAYUHOKatRDXAIsm+oYMGSLr1q0zj9u2bSu//PKLPPTQQ+b5iRMn5IEHHsjP2aOAvbF0mMzY+bsE+AbIY1c8Kv7e/o73omKjzH1cchxddgJsa4AlzJo1S8qXLy9PPvmkqbDkTJ/r6/q+TofC4X+/x8k3GxIlyM9L3rwmUAJ80l4P9hUZf12ghAZ4ybhVSfLn7vNdecL1OIYECgZxzXqIa9ZEXAMKBnHNeohrQCFL9M2dO1eaNWsmgYGBpkvOsWPHypdffileXl7mpgk+bb33xRdfmOn1tcmTJ0uvXr1k/PjxUrt2bfP68uXLZeXKlXn7i+Ayq4+skY/WfSIbojdKhdDycn21HvwbANsaYNmTxu7du0tcXJzpBiZjV5321/R9nY5kX+GwcF+KDF6YKMsOpkj1ot5yf0M/8/o77QOkZjEfORKTKv+dSJUe1X0dtyBGrHY5jiGB/EdcsybimjUR14D8R1yzJuIaUIgSfYsWLZKuXbuaBF1CQoKp0f7444/LqFGj0k23YcMGR3dWlStXlrJlyzqSfq1atXJMt3Dhwsv/FShUJqz/XFJtqdK75k1SxK+Iq4sDuC22NSB/6PFL7969TSIvNTX9GG8Z6fs6nU5PN56Fx9B/EiTVZpOHGvtLeIBI9+ppCb9SId4yqmOgfNDp/K1YkJeri4tziGtA/iCuWR9xzZqIa0D+IK5ZH3ENyHsXXYf5mWeekaSktAFPOnbsKAMHDpQ1a9aYVnzOdu/e7XhcunTpdO+VKlXK8XjXrl2XUm4UIj1/uTHd8x2ndkqvab3TvXYk9mim6QCwrQGF0VdffSWxsbGZWvHllOzT6b/++msZMGBAvpcPmVUdfzbd843RqVL9o5hs30fhwDEkUDCIa9ZDXLMm4hpQMIhr1kNcAwpZi76oqChZtmyZeRwQECBTpkyRHj16yMsvvyx9+vRJN21MzPmLK/7+58dqy/jceToAAABX0uTemDFjLumzH3zwQa6TgwAAFATiGgDAnRDXACAPWvQ5t77TsfmKFSvmeN6iRQuZOHGi43lISIjjsXbx6UzH78tquoJy6NAhc3N39ouNp/ecloQT6f8Ddxd/MsGxDFatWuXq4sBjtrVTknAiXjxJ/Ml4R4smtjW4gxMnTsiOHTsuaT+gn5s3b55ERETkS9ms6ODBg+Y+5Wy0JOxdI54mJea4uT9w4IAl95Gnd58S/9D0FfbcXfyJOHNPXIO7IK7lLft1hJQznh3X9u/fb5m45twNu8Y1v5C07rw9RVx0WlxLSUmxzH8G5IS4ll9x7aiHxrUTlotr8DxNmjTJ3YS2i7BkyRK9mm1udevWTffeBx984Hhv8ODBtpUrVzqeV65cOd2099xzj+O9kSNH2gqals8+f24sA9YB1gHWAdYB1gHWAdYB1gHWAdYB1gHWAdYB1gHWAdYB1gHWAdYB1gHWAdYB1gHWASlEyyC3LqpFX5UqVRyPd+7caWpRFC1a1Dy3d+lpV79+fQkPD5dTp07Jnj17TE3myMhIU+N96dKljunatGkjBe2hhx6S66+/XtydtrLUWlstXm0lAWEBF/3557s8J+1qtpNbP+0jp+NPS/GQ4vJkh4HSrFIzSUlNkcU7F8uouR9ITGLW3a9OeXCSlA0vk+61F6e9LIv++8c87l6/m9zZsq+ULFJSDp46KJ8u+kwW/rfIvPdq95elZeUW0uezO+RM/JlLatG3fOgS8fX1zbRuAnmtWbNmZt+WV9vadXW7SJ9mt0rF4pXE19tHhv3xtvyxcVa2n89p+uvqdZEXr3s+02dW71sjA6c+Kc0rNZf3bh4ub88aLjM3/H5JLfqWD10qfn5+6fbtgFXpsY2OQXyp5s6dS4s+Jx9//LF88sknEty4l0R0eSbXy/H93jWkR4MS0nL4cjkRm5zlNONvryUtK4dL6bC0FmeRL6QdQ2SlaolA+bhvHalULFC8vUUOnEiQz5cckq+Wpu/hoXGFIvLzQw3Fz8dbxv69T96atce8/mGfWtKuZlG5esQKORmXdXmycmLGMIlb/7sZu/Gee+4Rq2jatKm5bzn4qktq0Xe5x5B9m/cxx4mRRSPF28tbBkx5QtbsX+t4P8Q/RB5q8z9pU6ONhAYUkWMxx2T8go/l723zLz+unYiT5W8uk8DAQPnnn7RjVsDKiGt5a/z48TJhwgQJbnKTRHR+8pK+I2OMu6VJKXmoTaTUKBksvj5e8uT322TqqiPZfv6DW2tKuxpFJTTQR07FJcuC/07Ky9N3yOn4lAvGxztblJF3bqwut3y6XhbvPHXRZT/x61CJ2zhLnnjiCbnrrrvEKi36mjdvbh5f+drVl9Si73LjWqViFeWJawdK/XL1JC45Xv7cPFfGzR8vyanJ4u/rL8N6DZVapWtKeFC4HDp1WG6bcLvjs/1aPyh9mt0md391n+w/sf+SWvSteHuZBAUFyaJF2R8rAVZBXMtbH374oXz++ecS0vRmCe80ME/P1zrVKSbPd64kVUoESdTpRPlw/n759t/DOX5vWKCP/DmwsURGBMqqvael5/h15vWeDUrI810qSZmwAElKSZVtR2Ll7Vl7HLFs+iMNpViIn7R7f5Ukp+Z+OI3j01+X+E1z5KmnnpI77rgj158DCqOLSvSVLl1aWrZsaRIn8fHxZlw+vXCxdu1amTx5cqZx+O6//34ZOXKkuQB+++23yzPPPCMzZsyQrVu3Oi6O2y8kFKSyZcuam7vz8vIy92GVwiSwWNBFfTaySDnpUq+zzN79p3hFeku4RMhrVw+W+iXqydStP0iQX5D0qttT/EMD5P2Vo7L8Dm8/b9l7ep9M3jrV8dqBgEMSXi1C6hevJ4PaPCs7Tu6QTzd8LjdWv15e7zlE+v81QA6cPSgzD8+SjrU7yD0d75ZvNp/vEja3/M91T6HLINfNW4FLpOuZ7ufCKoVLYLHAy97WipYrKpvPbBWbn0i1iKoSXCpYwuOz7wowp+l3eu+S4cvfc0zbpXInaVSyoeyI22m2xW2y3WynD7S5T5bELZNUOd+1TW74R8eae29vb7Y1uAXdlrV7cq3QdDHj7el+oGrVqtK+fXtH/IVIuXLlzGLwKVJCAipekatFUiXCS25uEixTNidLbIn6kl31Ca+gAPlhu036nzuUzOn7/cK9ZN5BP9m9OUkiArxkYPMgGdarmqyMKyvbT6Tt9/S639hbgiUhxUv8fER8w0pLQMW0Cm1f/uctNzTylUe7N5H3/j3fBf2F+ISkdXOvld2seDwSVjlcAiICCvwYMrRkmKw8vlr8AwOkdHApCYksIuEB5+PgO22GSd3idWT+vgWy5ug6KRVcUsLKhkl4yuXHNb8jaReAiWtwF8S1vGW/juATmvu4dqEYF1baV1ZEe0uqT6rUK+kjvsUrSkDFtPiZlf3J/jJqVYrEJ6fI7XX9pHfjUnLMK0LeXpJ4wfg47YjIiwk2GdSjrtz6S9o588Wwx7Xy5ctbJq45d92pcc3/XAK0oOKaVlh5p8NbUiKohHy7+TupGl5Fbm5yk6SEpJjngT6BkuKfIgsOLpSe1XqY6yh6nmY3+/hcud27j/Tr9KC8l03czIlvcFpc8/Hxscx/BuSEuJZfca1knp6vVQrzkk/7BMvhGJu88U+i3FLbz1Q0OegTKf8cSKuYkpV3OwVIeHBausIrIMRRpuQIH5myzVuOxCZK3RLe8kCjMBl/Zz1p8WXaNakvtvjK2M6B0rdTU1Ou3PIJKWq5uAZkx/tiF82IESNMyw01e/Zs6dGjh7z00ktSr169TNMOGTJEGjZsaB4vXLhQevXqZWp1Kx2/RmsMoHDqUqmT+Hj5yIIDC83ziqEVpGHJBrLz1C6ZuGWSTFj/uRyLOyZty7eWMP/QbL/nVOIpWRG1QhYeWGRux+PT+vTvXrWbuZ+4ZbL8sXuW/LT9F/Hx9pFuVbqa17ef3C5RsUekU6WO4iVcMIXnbGtq5q4/5KN1n8iBswdy9R05Ta/bkX37+/fwcnNimZSSJL/u/M0xzT8HF0vJ4JLSpHTjPPpVgHVpku7xxx+/pM9q5SeSfJevTx0/8fH2kl//y/kEbeCfCTJmZe6SbrtP2WTk8kT5a0+yLD6QImcSMydxh7TR2qEiEzcmZXpv3ZFU2X86VW6r48tRSQEcQ2olsc82fCEn4tPGzHDWoER9k+TbGL3JXPCcv3+BfLdlsszffz6OEteA84hrhT/GfbsxWQYvTJSdJ3NXMWH0ikSZvj1ZFu9PcXzGuW5STvExMVXkz93J0qysj9QoetGXgzzS5ca1JqUaS7ki5WRF1Er5+b9pMnZNWku+HueuicSnxMuwf98x53RZOZFwQjYf2yJXl7tKivgVyedfCxR+xDVrnK/dXs9P/Hy85LO1SfLdpmRHZcm7G2TfqvrmWr5ybSVfGb40IdN7f+1JkS/WJ8mCfSmyJItE4dzdyRKfbDMVYABPddFHdtrV5syZM02WW1vtVa5cWUaNGiVPPpm524qwsDCT4Hv22WdNt586falSpaRv376yfPlyadCgQV79DuSxK0o1Ml1QbDu+3TwvVySthsfR2KOOaY7GRZsD3jIh6bvndFaveF2Z2mOS/NhzirzQYpCE+Ydl+L5oc38k7qijtpzdlmNbpGhghFQJr8z/C4/Z1vJTp0odJNQ/1JykHne6eLr52GZz37jUxddKBtyRdrEYHBxsWvTkhk6n09999935XjZP0Lq8j+luZU1U2gmcr7dI0cDzt0ut/lO9qLesvK+IzLg1WEoGe8nrixIcrfl6VPc1tyf+jJf4bM5XV0WlSIlgb6lTggujBXEMme3/GFHd3BcNLCpTe3wnP/ScLO9fM9xceLUjrgHpEdcKb4y7VN/2DJJ/7g6Rm2v7yT/7k2Xcqty3Nl95KG3ebSr4XFYZPMXlxrWM0yekJMjpxNMS4hciEQHhuSrDpmObxc/Hz7QiBEBcs8L5WuXwtHOmg2fTzrcOnLuvEpH1uZS2AHy1dYAMW6LnaFn3rHNbHT9Zfm+ITOgWJMfjbPLYrHjHewkpIhujU6V+SW8Jv/gRdQC3cElXKnTsmpUrV0pCQoLs2rVLBg7Mvg9fTfYNHz7cdIGl00dFRcnEiROlevW0k3QUTmVDysrpxDOSmJr7E4aM/twzV95bMVLeWDpMNkRvlKvKXSkPNrg/y2mzarUXHX/M3F/KRSDAk7a13NBt7PpqPc3jn7ZPy3JbK8u2Bjh6Hfjxxx9NbdELJfv0fZ3up59+Ymy+PFIp3FtOxtvMyZpqWsbHJOjst3Khl5bq23c6Ve7+NU5e+DvefH//pv5SMcxLdAi6oW0D5LuNSRKbZHOcGIYFeEmJoPPzOnTW5jgJheviWqot7SJBscCi8uGaj+SHbT9JjaI15Ikm51viEteA9IhrhTfGXapXFibIQ7/HyYK9yXJ1eV+T8Mst7UZNaQyEa+LaxfZadIzzNSAd4pr1ztcutNcb1i5Ath1PlUX7UqRMSNrU/t4i5Z2+a86uZLn3tzgZ+W+COWd7oVWASTLaHT6bKt5eXlIxjIqZ8EwXNUYfPM35GhQHzx4y9zoGil3JoJKSYkuRwzFpA6n6efuJTWymGwrlPDbfifiTplvAymGVHN+nXQjq9+0+vVtKBpU49/rB83M/1/8IXXfC/eV+HDD7tqaSUjN3L5edVuWuNIm8lVGrZO+ZvennfhHjkAGeokuXLmZc4d69e0tsbGymbcXeRWdQUJBJ8nXu3NllZXVHznulzdEpctf08+MIHY298D7L2yutZqmOw558rie0uGSRRfvTzkbrlfCRO+v7SacqvvLHzmST1Luvob+52fWt5yclgr3k4T/Saoqyqyy4Y8icHIxJO1bcfXqP/L1/voT4BcuttW423aI55s6fBWRCXCs8LvbI2/9cw7vElPRdSquoWJu0regrt9b2lS/W5e7cQGOjYkjhgolr9ulLBpcy9wE+AaaXlZikGDmZcCqX/5l9/iRnATviWuE+X9t9Ki1ORYZq0i1FyhVJS77ZX/fxEvHxFklJFUmxiVQI9ZbyYd4y744Qx/fouLW/3RIsV3we46iocjgmxXTf2aO6nzQq7SO1i3nLhujU9PEt/38+UCiR6EOWDsdESYXQ8uYAVZMJe8/sM63ydEyUO2rfbgacLh5UTP7eN9/UbtOD3M86f2LGUrn7j/tNQu/++veapEJMUqzpMtC5K6WZu36X1pFXSd/at5ka2TdW72W6w5i5a5ajDCWCip8rS9rBMuAJ25qqFl5VqkVUdbRmrVe8Xtq4EPsXmTEcfro+LYl+0/RbzWcuNL3SbUzpeJgZ6cDwpiyxUQX0qwHrnDzu379fvv76a/nggw9kx44djveqVq1qxuTT7tDCw3PX7RJy3/KuWlFvc2FTL2qeTpQsB2zvXs03Xbcst9bxlaMxNpm3N0VurOkrI64NlF+3J5mxih5t4ifhAV6y/XiqFAvykp410g6Bt0SnyrE4m/Sfdf7EtFs1X+le3U9m7UyWT9acr71ftkjaKeO+01SOyM9jSHvX79qde/i5Ls2al24m5ULKyuw9f8qqqNXmoqnGvuur9ZDIIpFmmrVH1znKQFwDskZcK3wxTtUr4S31Sno7WiC0KOtjLn7+tj1ZYpNFtvRLG5et9idnTVdoTzb3N+PzJaTYHC35Nh9LzVV8dI5ne4lnBRLXVh1Ji1vNSjcx52RVwquIr7dvuvOyzpU6SkRAhHkc5BNonh84e1A2HttkXrNXjI6K5doI4Iy4VnjP1yZvSpL7G/qZW2KKTW49F6++Xp923euxpv4ysLm/fLQqUYYvSzQt1YPPZSlqFPOWJ5oHyK6TqaYrTzWqY4A5lzsUY5O6xb3NNDFJNtlz+nz8K1vE21SM2Hcmd2PeAu6GRB+ytProGqkcXklqFq3hOLh8d8VIebhRP7mh+vWm2yQ9kP1o3SdZfv5UwmlJTEmU3jVuNANG6wDS0/6bLt9snmjeXx+9QcauHic317xJ+jV80Bw8D1/xruw/u9/xHbWL1TI13Had2s2/BI/a1lqUbS59a/dxTKOJcr2tObpW4mPP90Fud6HpdVvS238nd8i66PWZPq/vmbIcWZNPvxKwdrcwmtB7/PHHJTIyUg4dOiRly5aV7du3O1r1IW8t3JcitYr7SKNS3rL8UPYnaYOu9De1Pu3ebhcoSw+kyLy955N2dtGxaRdD767vJYmpaTVJ9STTfkL6+87zJ6Y1i6U1ndATy9VR5+ffuIyPRMelyiani6nI+2NIpTGsQ8VrHc9vqnGDuddEn7aYGLpsmDzUsJ/cXfdOiU2KM93Ff77hK8f0xDUge8S1whfjOlb2NRc77W6p42du/+yPkdgz6SuXnE20SakQL3mmpb/4+6bFt282JMqIpYm5jo/axZrS7tGQ/3FN339z2VvSr+H/5M46fSU+JUF+2zlTJm2d4pjm8cb9HY/DAsLM87l7/3LMT+OaJhnXH93IXwZkQFwrnOdru09pZcp4ebqlvwxuHSBHYmzy6oJ4Rw8rGc0/VxlFHT932etkgk3m7k57/VSCzfTIUjTQS84mahmS5YMViXLmXPjTpKNWnNFx+k5kvmwGeIQ8S/Tde++95gb3MHv3HFNLunXk1Y6DS+0XXg9Qs3Ik9qj0/OVGx3NN7A3NZlq7WXvmmFtWakRUN62TdNyVVOGCGjxrW5u0ZYq5Zcd5W8vN9FuOb830GWc676Ox0aYFLoCsOY/XZx+XD/lj8uYkua+hn2mRsPxQ9uPhtJ2Y1qVqVn7cmiw/bj3reD51S7K55cboFYnm5qzhuZYWWuPU3iUM8ucYUo1aNcbcsrPvzH55+Z9Xs32fuAZcGHGt8MS4rOKOs6rjz8ezg2dt0vunzBVachsfdbwjTSyujkqRrcc5zy6ouKatAHOKWzmdq2lLP23p/s/BxXIm6Uyuygx4IuJa4Ttfm7M7Rebszjpm5RT7lh1MSRf71OCFieaWnQ6VfCTIz0umbMr9EDeAu2F0SmRp/9kDplbatRXamxZ5Ba1X9evlbOLZLLsZBNyJq7e1xqWukEphFWXS1smmtikAuNrOkzb5eVuy3FRLu9uUQuGBRn6mFqlzV57IGnENAApvjOtd21ciAr3kvWXEM6vENU0y6nh/322ZXODzBoDCGMuycn8jf9Nry/e5rNwJuCO67kS2TG1qyb42dX56d8X7Lpkv4GnbmnbXmVMNUgBwhefmJZhbYaHj/IkUnvIUdsQ1ACicMW7SpmSZtCl9KwkU7rj29aZvzQ0ACpPCdr52y885t3YHPAEt+gAAAAAAAAAAAAALItEHAAAAAAAAAAAAWBCJPgAAAAAAAAAAAMCCSPQBAAAAAAAAAAAAFkSiDwAAAAAAAAAAALAgEn0AAAAAAAAAAACABZHoAwAAAAAAAAAAACyIRB8AAAAAAAAAAABgQST6AAAAAAAAAAAAAAsi0QcAAAAAAAAAAABYEIk+AAAAAAAAAAAAwIJI9AEAAAAAAAAAAAAWRKIPAAAAAAAAAAAAsCASfQAAAAAAAAAAAIAFkegDAAAAAAAAAAAALIhEnxvz8vIy97ZUm3ga+2+2LwMgP7Gtsa0ByHn/KKkpnrmIUlMteTzi0XHt3Kpqtf8MQMHw9LhmO7eTtOo+0iPjGtdGAOTmuN9+EOxpzsVzb29SJLA+1mI3FhERYe7jo+PF08QfizP3RYsWdXVR4Enb2rn1zpPERbOtAbjw/jH55EGPXEzJJ/Zb8njEk+Max5AAcmLfnyefOOCRC8qKcU0v3oaFhZnHxDUAyPq4P8VT49rJA5aLa0B2SPS5sfbt25v7A4vSDsY9ycFzv9m+DID8ZF/PDv7jeQdGBxem/Wa2NQBZse8b4rb+LSlnjnrUQtLkZvyOxZbcRzriGseQAJDl/jFe49rZaI9aOsnH90vCjqXmcbt27cRKuDZivWMRAAV8vrb5L0k5e8yjFnvSsb2SsHOZJeMakBUSfW6sT58+5n73jJ2yZeImiTkcIzab+3ZVob9Nf6P+1t0zd5nXbrvtNlcXCx60re36dYds/W6zxEZ5yLb27SbZ8wfbGoDs1a9fX+rWrSuSnCiHx/SS2I2zJTXJvXsaSE2Mk9j1v5vfq13BNG3aVKpVqyZWYj9+2jl9h2yd5CFx7VCMbP5mo+yZtdu8xjEkgKw0bNhQatWqJbakeDn8gca1OWJLSnD/uLZuZlpcs6VKixYtpEqVKmLF87Wd0/6TbVO2SOwRT4hrZ2Xz1xtl75w95jXiGoCsNG7cWGrUqCG2pDg5POYGid30p0fEtZh1MyRq7A26w5RWrVpJxYoVXV0s4LJ52dz56MbD6V/79NNPy8iRI8+/6C3i5W3N/vRz1fd82lA4hv72ESNGWHb8AFhrW3vyySdl9OjRHrmtPfvss/LOO++wrcHtlS9fXg4cOCCRkZGyf7/ntZa/VJs2bTI1RY8cOXL+RW9fHRBC3I4eVqcmO57qujJv3jxz8my1uDZgwAAZO3asR8a1QYMGyVtvvUVcg9sjrl2aDRs2yLXXXitHjx71uLim64zGterVq4vV4tpjjz0m48aN84y4lmITcbrS9+KLL8rQoUOJa3B7xLVLs379ehPXoqOjPS6uVahQQf7++2+pWrWqS4sF5AUSfW5OD2i/+OIL+fbbb2X+/PmSmup0FcMNaf/72tz6zjvvlHvvvZcDWRTotvb555/LxIkT2dYAN8WJ46Xbvn27qQzxww8/SFRUlLi7cuXKyc033ywDBw607EmjxrUJEybId999JwsWLPCIY0hNSN91111y9913cwwJj0Bcu3Rbt26VDz74QH788UePiGtacaV3797yxBNPWK41n3Nc+/TTTx1xzd3rvPv4+Djimt6oAA1PQFy7vLim52sa19JV0HTjuKbnaxrXKleu7OriAHmCRJ8HiY+Pl5MnT0pKSoq464GsDiIbGBjo6qLAw+m2duLECbe9KMq2Bk/FiePl0/3iqVOnJDY2VtxVcHCwhIeHm8SRuyCuAe6JuHb5PCGuhYSEmLjmTokiT4hrRYsWlYCAAFcXBShQxLXLp/tFvXYcFxcn7sod4xqgfFkMnkMTYGXKlHF1MQCP2NbKli3r6mIAQKGjyS+98KQ3WAdxDQCyRlyzJuIaAGQf14oVK8biASzIfaoaAwAAAAAAAAAAAB6ERB8AAAAAAAAAAABgQST6AAAAAAAAAAAAAAsi0QcAAAAAAAAAAABYEIk+AAAAAAAAAAAAwIJI9AEAAAAAAAAAAAAWRKIPAAAAAAAAAAAAsCASfQAAAAAAAAAAAIAFkegDAAAAAAAAAAAALIhEHwAAAAAAAAAAAGBBJPoAAAAAAAAAAAAACyLRBwAAAAAAAAAAAFgQiT4AAAAAAAAAAADAgkj0AQAAAAAAAAAAABZEog8AAAAAAAAAAACwIBJ9AAAAAAAAAAAAgAWR6AMAAAAAAAAAAAAsiEQfAAAAAAAAAAAAYEEk+gAAAAAAAAAAAAALItEHAAAAAAAAAAAAWBCJPgAAAAAAAAAAAMCCSPQBAAAAAAAAAAAAFkSiDwAAAAAAAAAAALAgX1cXAEDWjhw5Ij///LNs2rRJ4uLi3HYxBQUFSb169eTGG2+UkiVLuro48EBsawAAdxIVFWWOITdv3uz2x5D169eXG264gWNIAHBjhw8fdsS1+Ph4cVfBwcGOuFaiRAlXFwcAYDFeNpvN5upCADhPN8nnn39e3n33XUlNTfWYRePt7S3PPfecDBs2TLy8vFxdHHjItjZo0CB57733PGpb8/HxMdvam2++ybZ2kcqXLy8HDhyQyMhI2b9/f/78QQBwGXHtmWeekVGjRnlcXHvhhRfk9ddfJ65dJOIagMIe15566ikZPXq0eexJce2ll16SIUOGENcuEnENgCejRR9QyLzyyisyfPhw8zi8eoSUaFBSfIPcd1NNjkuW6HVH5dSOk/L222+Lv7+/vPbaa64uFjzAyy+/LCNGjPCYbS0pNkmOrY8229pbb70lAQEBMnjwYFcXCwCQRzTZ9f7773tWXNNjyJ2nZOjQoeYYUo+jAQDuQSsnauUVFVGjqBSvX8Lt45peGzm985SpvKLnay+++KKriwUAsAha9AGFSGxsrOl6SO/rP9RIKl9XRTzFrpk7ZeOn66RIkSKmK0XtjgnILzExMWZb0y7NGjzUSCp50rY2Y4dsnLBeQkNDzbYWGBjo6iJZBjVEARRWZ8+eNXFNuzRr8MgVUqlzZfEUO3/9TzZ9vkHCwsJMXNMLo8gd4hqAwur06dNSqlQpSUhIkIb9G0vFjpXEU+yYtl02f7lRIiIiTHfcWpEFuUNcA+DJvF1dAADn/fHHHybJF1QqWCp18ZwLNKpy1yoSWCLIXKiaM2eOq4sDD9jWNMkXXDpYKnrctlZVAosHyZkzZ+TPP/90dXEAAHlg5syZJskXXDZEKnbynIuhqkr3ahJQLNBcFJ47d66riwMAyAMzZswwSb6QyCJSoUNFj1qmVXtUl4CIADl58qTMmzfP1cUBAFgEiT6gENmxY4e5L1anmMf1xa6/t1jtYumWA5Bf7OtY0TrFPW9b8/Yy+xj133//ubo4AIA8PYb00LhWi2NIAHAnHh3XfLykKHENAHCRSPQBhYjWWFM+Ae7b73xOfAJ8zL3WSAcKZFvzT1vnPI33ud/NtgYA7sHj4xrHkADgptdGPPN8jWsjAICLRaIPQOHhYTX1AFdhSwMAuBPiGgDArRDYAAAXiUQfAAAAAAAAAAAAYEEk+gAAAAAAAAAAAAALItEHAAAAAAAAAAAAWBCJPgAAAAAAAAAAAMCCSPQBAAAAAAAAAAAAFuTr6gIAAAAUZgcPHpR9+/ZJQkKCeZ6YmCiHDx+WMmXKuLpoAABcUlzbu3cvcQ0AYHk2my3L87WoqCgpXbq0q4sHAAWGRB8AAICT//77T7777jtZvny5rFy5Ug4dOpRu+Rw9elTKli0r5cqVk6ZNm0qLFi2kb9++UrVqVZYjAKDQ2bZtm0yaNMkR17SySlZxLTIyMl1cq1KlisvKDADA5cQ1rZTpHNfuuOMOqVy5MgsVgNsi0QcAADxeSkqKzJgxQ8aNGyezZs3K1fLQmqN6+/XXX+XVV1+Vrl27yqOPPirXXXed+Pj4ePwyBQC4TnJysolrH374ocyZMydXnzlw4IC5TZ8+XV555RXp1q2bI655ezPqBwDAtXFNz7v0fO3PP/+8pLjWvXt3E9e6dOlCXAPgdjhaBwAAHm3NmjWmpmevXr0yJfkiIiLk2muvlccee0y8vLzMa3rfvn17CQsLS9dlzMyZM6VHjx6mxuj69esL/HcAAKBWrVolTZo0kRtuuCFTkk/jWocOHTLFtXbt2mWKa5oo1IuiLVu2lI0bN7JwAQAusWLFCmncuLHcdNNNmZJ8OcW10NDQdHHtt99+M5VYWrVqJZs2bSrw3wEA+YlEHwAA8Eg6dsPgwYOlefPmsnbtWsfr2lXZ8OHDZfv27XL8+HGZO3eujBkzJt2J419//SUnTpww3ca89dZbUqlSpXQXWDVx+Oabb5qapwAAFFRc0xYLGSucaNfSI0aMMF1Ta1zTi6QZ49q8efNMXNu6dauJXxUqVEh3gVUThxrviGsAgIKiY+699NJLcuWVV8qGDRscr1erVk3effdd2bFjR45x7eTJk7JlyxYZOnRourj277//msThO++8Q1wD4DZI9AEAAI+jJ4Ray/P11193nNw1bNjQtF7QC6HPPvusVK9e3XGymBXtxqxGjRry/PPPm5PMadOmSd26dc17SUlJ8vLLL5vapadOnSqw3wUA8EzHjh2Ttm3bmouZ2h21atSokWltrhVXnnnmGXNh9EJxrWbNmvLiiy/Krl275JdffpE6deo4koj6eqdOneT06dMF9rsAAJ4pOjpa2rRpI8OGDXPENU3O/f7776ay5dNPP20qslwortWqVcskC3fu3Ck///yz1K5d2xHX9Dyuc+fOcubMmQL7XQCQX0j0AQAAj6KDs2uSb8mSJea5r6+vGWNPB3PXrlwuZRwiHZPv+uuvN4PB6wmj/TsWLFhguvnUxCIAAPkV16655hpZtmyZI64NGTLEtFjQ8WMvNa5pl9baSn3QoEGO7/j7779Nl9baSgIAgPwQFRVl4pqenyk/Pz9TQVPj3KWOG6uxUbu01rimlTrt36Et/6icCcAdkOgDAAAeQ1sh6EVPe5dmpUuXNgm/1157Tfz9/S/7+wMDA03XZosWLZISJUqY11avXm3GODp79uxlfz8AAM601XiXLl0cY+iVKVNGli5darqmzqu49vbbb8vChQulePHi5jWt1KJxLSYmhj8DAJCntCKJxjX7GHply5Y1CT7tmloTfpcrKCjIDNMwf/58KVasmHlNE4o61npsbOxlfz8AuAqJPgAA4DF0kHa9QKnKlStnEnLNmjXL8/noAO/amq9UqVLmuV50feqpp/J8PgAAz/boo4+aCiUqMjLSxDUdJzavXXXVVSaulSxZ0jxfvHix6Q4UAIC89MgjjzjGT9dx9TSuaZedea1169Ym2WevnKnzee655/J8PgBQUEj0AQAAj/Drr7/KN998Yx6Hh4fLnDlzzDh8+UXHNZo9e7YUKVLEPP/000/NcwAA8oKOoffdd9+ZxxERESau6Th8+UXHoZ01a5YEBweb5x999JHMnTs33+YHAPAsP/30k0yePNk8Llq0qIlrOg5ffqlfv76Ja9rKT3344YemK08AsCJfVxcAgGv8esPPjscJyQlyMOaQTNn6vSw/vEJGt39fyodGypjV42T2njlmmgGNH5NOlTrI/H0L5N2VI/nbALY1Szlx4oQ89NBDjuejRo0yFyzzW6NGjWTEiBGmZqp68MEHZcOGDRIWFpbv8waA/MAxZOFw7Ngxefjhhx3PR48ebSqY5DdtVaFdnmkLefXAAw+Y7rBDQ0Pzfd4AkB+Ia4VDdHS045xJjRkzRmrVqpXv823SpInponrgwIGOuLZu3TpHZU0AsApa9AEe7v2Vo2TS1ilSMbSCPN3sCQn0DZTRq8dIii1F7qt3t0QEREjDEg1Mku9E/An5eN0EVxcZsCS2Ndd655135NChQ+axjit0zz33FNi8+/XrJ9dee615vG/fPnnvvfcKbN4AkF+Ia66lFyWjoqLMYx1X6K677iqweeuF2Hbt2pnHe/bskZEjqQQIwPqIa641bNgwOXLkiHncq1cv6du3b4HNWyuvtG3b1jzetWuXqTwDAFaTr4m+3bt3m/ForrzySgkICBAvLy9zGzJkSH7OFsBFWHRgsfy4/WfZc2av+Hn7Seng0rLl+FaZ/t+vUsS/iPS/4mFzU+PWfixnks6wfIFLwLbmOvHx8fLZZ5+ZxzqAu3Y1pscjBcXb29t02+nj42Oe6+OkpKQCmz8A5AfimuvExcXJ559/bh77+/u7JK5NmDDB3KtPPvlEkpOTC2z+AJAfiGuuExsbK1988YV5rNePx48f75LzNfs8P/74Y+IaAMvJ10TfmjVrTO2+ZcuWSWJiYn7OCsAlCvUPlRoR1aVMcGk5k3hG9p/dZ17/ZvN3sv/MfrmybEspV6SczN+/UJYeWsZyBtjWLOeHH34wXcGoW265RcqXL1/gZdCxJbRmqtKWhdOmTSvwMgBAXuIY0nWmTp0qx48fN49vu+02iYyMLPAy6FiAPXv2NI8PHDhgxsEFACsjrrmOjst38uRJ87hPnz5StmzZAi9DzZo1Tc8v9l5YZsyYUeBlAIBCm+gLCQmRTp06yeDBgx0XtwAULl9d95m8326E+Hj5yNBlb0lccrx5PSk1ybTgU/HJ8fLx2k9dXFLA2tjWXEdrZNo9+uijLiuH87y19QUAWBlxzXWIawCQ94hrrkNcAwAXJfrmzp0rzZo1k8DAQFOTb+zYsfLll19m6ppTk3yzZ882z2vXrp0HxQWQ195YOkxm7PxdAnwD5LErHhV/b3/He1GxaeN+xCXH0WUnwLZm2W47ly5d6qiledVVV7msLDpOX6VKlczjxYsX0x0MAEvjGNJ13Xb++++/5nGdOnWkZcuWLiqJSMeOHR2t5BctWiQpKSkuKwsAXC7immvExMTIihUrzON69epJ8+bNXVQSkS5duki5cuUccS01NdVlZQGAfE/06Y6ua9eusnLlSklISJCdO3fK448/LqNGjbromQNwvdVH1shH6z6RDdEbpUJoebm+Wg9XFwlwS2xrrrF+/XpHQq1Vq1YFOtZDRjpvHbfYfqF28+bNLisLAFwu4pprrF271pFQc3Vc0zGN7HFNx1fasmWLy8oCAJeLuOYaOuyTPaFWGOKavQLN2bNnZdu2bS4rCwDke6LvmWeekaSkJEcNPu2L/4033pANGzZc9MwBFB4T1n8uqbZU6V3zJiniV8TVxQHcFttawbLXDlVNmzYVV3Mug3PZAMCqiGsFqzDHNa0MDABWR1wrWIU5rnG+BsBKfC9m4qioKFm2bJl5HBAQIFOmTJFixYpJjx49TO29iRMn5lc5AeSxnr/cmO75jlM7pde03uleOxJ7NNN0ANjWrGTjxo2Ox40bNxZXa9KkieMxlaQAWBHHkK5FXAOAvEVcc63CHNecywYAbpXo27Vrl+Oxjs2nST67Fi1aWCbRd+jQIXMDCpuDBw+a+8TTCXJqx0nxNPq71YEDB2TVqlWuLg7cmMdva2cSPWZb27Nnj+Nxr169xNf3og590rF3KaP3pUuXvqTvsHcjqnbv3u32yx9AwbCf2ySc8uy4tn//fo+Kaz179hQfHx+XxjV7bz+KuAYgrxDXPCeu7d271/G4e/fuhSqu6XVwd1/+AAo/5woIObJdhCVLltj0I3qrW7duuvc++OADx3uDBw/O9NlBgwbl+H5B0vnby8KNZcA6wDrAOsA6wDrAOsA6wDrAOsA6wDrAOsA6wDrAOsA6wDrAOsA6wDrAOsA6wDrAOiCFaBnk1kVVa69SpYrj8c6dO+XEiRNStGhR89zepacVPPTQQ3L99de7uhhAJhMmTJDx48dLmSvLSo2ba+V6CT3f5TlpV7Od3PppHzkdfzrLaa6udpX8r/WDUj4iUo7FHJOJ/06S6et+zXLaRpEN5ZnOT0vp0FJiE5vsP3FAvln2rfy9bb55P9g/WAa2f1xaV28tvj4+smrvKnn/z1Fy9Gy0hAWGydT/TZYF2xfKsD/euqh/edvULRL172Hp37+/3H///Rf1WeBifPrpp/LRRx9d9LaW03ZXPKS4PNlhoDSr1ExSUlNk8c7FMmruBxKTGJPl50fd8r7UKFVdAv0C5UTsSVn430IZN/8jSUpJq0HYvX43ubNlXylZpKQcPHVQPl30mSz8b5F579XuL0vLyi2kz2d3yJn4Mxdd9m1TtkjU8sPy2GOPyX333SfubMiQIWY8YaU9EVxOi77o6GhTO1QHaS9RosQl1xDV4yd18803ywsvvHDJ5QEAu48//lg++eQTKdOqnNToXTNPjyGH9HjVHBsWL1LcPG/7Xvtsv69u2TryUJt+UqV4ZQnyC5IDpw7Kt8smyp9b5jqmubPFHXLDFb0kIihcdkbvkrF/fyjrDqw37427faxEBEXIXV/eY2Jpbm2dtFmOrIySAQMGyD333CPu7NVXX5UZM2YUyrh26623yqBBgy65PABgN27cOPnss8+kbOtIqX5DDZfFNTsfbx/5qO84qVW6phyLOS43fpQ27Im/r78M6zXUvB4eFC6HTh2W2ybc7vhcv9YPSp9mt8ndX90n+0/sz/Xv2PLdJjm66og8+eSTcuedd4o7e/nll+X33383j4sXL35ZLfryOq7dfvvt8swzz1xyeQCgIF3UWYE2e27ZsqVJ6sXHx0ufPn3MydTatWtl8uTJmaY/evSozJ+flhjYunWr4/VNmzbJDz/8YB5fc801UrJkSSlIZcuWNTegsClXrpy59w8LkPBqEbn6TGSRctKlXmeZvftP8Yr0lnDJ/LmyIWXkjQ6vybG4Y/Lphs+lU6UO8kynp+Rk8ClZe3RdpukDigbJwqhFcnRXtJQMLiG317pNBnd/RbZ4bZO45DgZ2Pgx6Vipg8zc+bucSDgpfWrfKq/3fk2eX/SS+fzf+/+WLnU7yy+HpsmBs2ndkeaG/m7zmyIjc98sGSigbe1C291rVw+W+iXqydStP5iLm73q9hT/0AB5f+WoLL9jX+I++WfzElNB54bqvaR345vkiHe0zNz1u9QvXk8GtXlWdpzcYbbZG6tfL6/3HCL9/xpgtqmZh2dJx9od5J6Od8s3my++22z/UH+P2dZq1jx/wfu7776TLl26XPJ3lS9f3nR3qscQ2o3OpZg+fbrpQtReNndf/gAKhv3cJiA8b48hlW+Ir8w9ME9urXWzeZ7T99eqUFt8An3k+x0/ir+3v/St3Ude6vaCHA06JrtP75ZrK7SXfk0flDVH1sqPO38y77/T+y15cPbDcjbprMzYP1MGtXhWbmp3k8zeM+ei45rup919v1qjxvkL3lOmTJGOHTu6NK79/PPPctNNN5nHxDUA7hbX7O6td7dUKFbBPPb28XJ8JtAnUFL8U2TBwYXSs1oP8fbzTvd9s4/Pldu9+0i/Tg/Ke9mcF3p6XKtevbrj8dSpU+Xaa691aVzT69W33HKLeUxcA2Al3hf7gREjRoifn595PHv2bOnRo4e89NJLUq9evUzT6qClunPU2y+//OJ4/fvvv3e8zsCmwOXpUqmT+Hj5yIIDC7Od5rrKXcTX21d+2TFd/tg9S77dlJYY6FG1e5bTbz2xVX7Y9pOsiFop646ul6TUJEm1pYq3l5cE+QZJ+wrt5HTCaRm/7hOZvHWqbDu+XeqVqCtVw9Na/S46uNiUqXOlTvy98IjtrmJoBWlYsoHsPLVLJm6ZJBPWf24S623Lt5Yw/9Asv2PChi9k8cElsvboejkSe+Tcq9oqX6R71W7mfuKWyWab/Wn7L6YWabcqXc3r209ul6jYI9KpUkfxEq8C+c1WdcUVVzger1y50qVlyViGwjDYPADPlZtjSDVixfvmeC839Lte+udVmb7jN/lhe9qxpM6jSngl836PqmlxbMKGz2Xmrj9k1u45EuIXIh0qprWm+PfwCklISZDrKnMMacW45u4XowF4XlxTDUs0kBuqXS8TNnyW6b34lHgZ9u87JqZl5UTCCdl8bItcXe4qKeJXJNfz9CSFOa5xvgbArRN9bdq0kZkzZ5qDeH9/f6lcubKMGjXKNCcHUPCuKNXIdG2kyTalB7aaWLDfNAlQrkhabbijsdHm/kjcUUeNt+w0KdVYJnb7Soa3Tet+U2ufxSTFSpmQ0ibhcDQu7bucv6/cue/bdmKbKVPjUo3y7XcDhWm7O7+NpW0L5nFctNkey4SUyfZ7Pu74oUzo/JE0Ld1E5u2bb2qfpv++7LfZLce2SNHACKkSXjlffqO7aNq0aaE6cVyxYkWWZQOAwngMebGSU5Mdj8P9w6VWsZqSmJIom45tNq+VPRfH7PHtaIZjyMTURNl5cpdUi6jGBdFsENcAoODiWqhfqDzVdKD8/N+0LHtDyg2NgX4+fqb3F2RGXAOAvHFJHfpr9yAZL5Z9+eWXmaZr166djhZ46aUDcEFlQ8rK6cQz5sKIqlO8trzVeqjj/Qdm98v0mdwc4Gqrvlf/GSLlQyvI3XXvkHvr3SVrjq7NctqM35aQkihnks7mmOAA3Gm7u1Ra+7NoQITcWOMGaRvZWpYeWiqLDy7N1TYbHX/M3Ot2pi0JkTXtbqVIkSJy9uxZWbRokRlzwd4zQUHTbs+XLFniGFdJK0sBQGE+hjziVIHlYhQPLC5DWr0iYf5h8t6KkaYVetYyx7dj8cfE28vbVC777+TZS5q/O6tdu7YEBwdLbGysLFy40KVxLS4uTpYuTTtu0bGQKlRI69YOANwlrt1f/x7Tw9HcvfOkVFAp85rGKB0e5XBMlNjO9ciSE41raeXj+khW6tatK4GBgeZcacGCBZKcnHxZ489eDo2tOlyVffgqHeoCANy2RR+Awuj8weWuU7vl5X8GO24n4k/KwbOHzHulgtPGwywZlDYo8cFz4+fpgaqft5+5t9MD5NVH18qvO3+TDdEbTTKhUckG5mBWa8nZvyPt+9K+99C5+ZgS2VLpUhAes91l3Mbs20WKLUUOxxw2z3Ub0y50nW08tsl0dfvzua45O1RMG4/gQtusmfu5ijR03ZkzHczdPi7fkSNH0nUlXtB0zAn7wO5du3YVLy+6XQVQuI8hL8Rb0o4htdWEXaWwijKi7dsmUffmsrdNnLM7dC6OZY5v548htbt4RXzLml787Ny5s3l8+PBhM/arq+gYgadOnTKPu3XrRlwD4HZxrXRIaXMtZHzHMfJWm7SkYXhAuHzSabwE+wXlqkSpjgYQHPtnRSurdOqU1mX3oUOH5LfffhNXmTRpkpw5c8Y85nwNgNW4pooEgDyjibcKoeXNwajWNItJisnUpcQfu2dLr2o9zU2n0XG91G87Z5r722rdIn1r9zHj8n216Rv5X4MHJDY5Vg6dPWwu0jQq2dAk9/ae3idxyXHy9/4FZiyVhxv2k5MJJ6VmsRqmO4odp3aa7/P39jc1uPedubTBjwGrbXd7z+wzCfG6xevIHbVvlyC/ICkeVEz+3jffJM31guZnnT+RE/En5O4/7jdd415Tvo1sPr7FnPD1PDcmn56Mqpm7fpfWkVdJ39q3SbHAonJj9V5mG5y5a5ajDCWCip8rS1oiEdl79NFH5ccffzSPx40b5xhcvaDpvJ3LBACF/RhStY68Ol03mp0rdZTj8SfM+HvtK14jTzQZIAv2LzRjHml30sNaD5UifiHyy3/TzdjObSJby57Te2Xvmb0yY9cf8kTRGvJA/ftkyaGl0qVyJ4lNipW/9s5zfH+JoBIm2RcVG1Vgy8JqNIbYK65obOndu7dLykFcA+Duce27zZMlLCDMTBfuHyaPXvGwnE08K2PWjJP45ATH5yMCIszjIJ9A8/zA2YOmUqdzpZaoWM7bcoprv/76qyO23HDDDVLQtCLthx9+mK5MAGAlJPoAi1t9dI1UDq8kNYvWcBxIZnQo5pC8vXy43FXnDunX8EFzEDt+7cfZdsV5KuGUufBSNKCoJKQkyPaT/8kP23+S/WcPmPc/WTfB1EVrV6Gt+Hr5yqqo1TJu7UeOz2tZtHWSlg3wlO3u3RUj5eFG/eSG6tebC5Sa5Pto3SdZfv504mmpFFZJrix7pfh4e8uxuOPy/bYfZdKWKeb99dEbZOzqcXJzzZvMNqsnrcNXvCv7z55PntcuVktOJpxyJAeRvfbt20utWrVk69at8vfff5vuM1u1alWgi2zevHmObmAaNWpU4PMHgEs5hlT31rtbSgendVemHm/c38QpvSCaUdXwKibJpzQe2n23ZbLs3bJX5u79y1RU6Vq5i9Qrcb9JAH62/gs5k5RWe14vzlYLr2q6pNaKMshahw4dpEaNGrJ9+3b566+/TPeZV155ZYEurrlz58ry5cvN4yZNmkiLFi0KdP4AUBBxbcOxjY7H9tbomkRcfHBJus/baVJQn2u8s5dBz9v0M+uPnv8upKct1atVqyY7duyQOXPmmPjSvHnzAl1MOt/Vq1ebx82aNSvw+QNAoUn03XvvveYGoGDN3j1Hrq/Ww9RKy+lgdumhf80tK5pcsCcY1NRtP5hbdrS138hVH2T7vpZFEx2zd/+Z698BWH2707EX3lz2VpbT61gQPX+50fH8v5M75Im/n85xHrP2zDG3rNSIqG66kNFWuKmS1sUZsqddZA4YMED69087Cb/vvvvMSVxQUO6627lcMTEx8sADDzieP/7443RvBsAyx5APzn4o2/d0zCK9Zfc8K1O2fm9uWWlRprkE+AbIrN1Zxz+k8fb2NrFEY5u6//77ZdWqVWaMo4Kg494++OCDjufENQDuGtdyOqezy+o1O23pV694Xfnn4GJHpRZkH9eeeOIJx/naypUrJSAgoEAW1+nTp+V///uf47k9vgKAlTBGH2Bx2spOWw5dW6F9uu4nXEXL0L5CO5m/f0G61keAO3H1dter+vWmy5iftrtuvDmr6devn6O1gbbsGzx4cIHN+/nnn5ddu3aZx61btzYnrgDg6bEsK9rNvI7X9+eeua4uSqH3yCOPSNOmTc3jzZs3y5AhQwps3oMGDZLdu9N6FLjmmmvk7rvvLrB5A4CV4pomHm1iMy3bkTPtKrNx48bm8caNG+X1118vsEX23HPPyd69ex29wdxxxx0FNm8AyCt03Qm4gVGrxsgoGSOFwdmks3LbjL6uLgbg1tvduyved8l8rczX11e++OILc/KYmJgo7777rkn83Xzzzfk632+//VbGjh1rHmsLQi2D1lgFgMKgMB1DqucWvuDqIlgqrn355Zcm2adxbcSIESau3XTTTfk636+//toxNl9wcLB8/vnnxDUAhUZhi2tfb/rW3HBhfn5+Jq5pt5lJSUny9ttvm+4z83u8Pp3nxx9/bB6HhITIZ599RlwDYElcaQIAAB6hbt268sYbbzgGW+/bt6/88kv+tYqcOnVqum7N9WS1evXq+TY/AIBnqV+/vqMlX2pqqvTp00emT5+eb/ObPHmy6SbUbvjw4VK1atV8mx8AwLM0bNhQXn31VUdcu+222+S3337Lt/lNnDgx3RALWhm0SpUq+TY/AMhPJPoAAIDHePbZZx0XKbWmqLboGz16tDmRzCspKSnmJFEvuOpje1c0Ou4EAAB53Y2mvVKJxjVt0TdmzJg8j2vvvPOOqSBjj2sa0zS2AQCQl1588UW56667zGNtsX7jjTfKhx9+mOdx7a233jLzsX/vwIED5aGHsh+/EQAKOxJ9AADAY3h5ecknn3ziOHnUkzwd9P3aa6+VnTt3Xvb3b9u2Tdq2bWsSitpqUGktUb3oqvMGACAvaXfQn376qWM8IY1rAwYMkI4dOzrGh70cOq5tmzZtzHiz9rim496OGjWKuAYAyJe4pt1Ca6VJlZycLI899ph06tTJMT7s5diyZYtcffXVJqFoj2sPP/ywvP/++8Q1AJZGog8AAHgUHx8fMxbD008/7Xht/vz50qBBAzMQ+6Uk/DTB99RTT0mjRo1k8eLFjtdfeOEFcwGWcfkAAPk5Xp+Onffkk086Xps3b56Ja9ri71Ljmn7fFVdcIUuWLDGvaYWVl19+WT766CPiGgAgX+OajnWuFVfs/vrrL9NltVY8uZSKLFpxRSt4alxbtmyZI6698sorZuxZztcAWB2JPgAA4HH0RE6715w7d65UqlTJvBYbGysjRoww4+h169ZNJkyYIKtXrzZdxmSkr61atcq0DuzcubPUqlVLRo4cKfHx8eb9atWqmeThsGHDqBkKACiQuKatEebMmSMVK1Y0r8XExJhx9DSude/eXT777DNZs2aN6eIzq7i2cuVKE9e01YTGNW21Z49r+h0LFiwwY93SQh0AUBCVM3WIhVmzZkmFChUccU27ktZzrR49euQY1xISEkxc+/jjj00r99q1a5vv09dVjRo1ZOHChfL6668T1wC4BV9XFwAAAMBVtMvO9evXO1re6YVO7cLl999/Nzfl7+9vTgSPHDlinkdFRUloaGiWCcCAgAB55JFHZOjQoRISElLgvwcA4Nn0YuaGDRtMiweNa3rxU+PazJkzzc0eqzRx5xzXihQpkuWFUp1Wx+LTuBYcHFzgvwcA4Nm0UqXGNW2hrok9e1ybMWOGudljVVbna1nFtcDAQOnfv79J8BHXALgTWvQBAACPpieBY8eOlX379plB2e0t/Ow0obdx40bHiaKOE5ExyVe1alXTamL//v2mZR9JPgCAK+Pahx9+aOKatiy3t/Cz09YMGeNaxouhGte0lfuBAwdMS0EuhgIAXCUsLEzGjx9v4tqbb77paOHnHNc0GZhTXNMKLu+9956Ja9qzC3ENgLuhRR8AAICIlCpVyrSAePbZZ804e8uXLzfdvaxYsUL27t3r6L5Mx4zQE8WmTZuaW/PmzeWqq65iXAcAQKFSunRp02Jdx5/9559/HHFNb1nFtWbNmjniWqtWrYhrAIBCF9defPFFR1zT8zT7+ZomAZ3jmrbws5+vtWjRQq688kriGgC3RqIPAAAgw3gQbdq0MTdn2kWMYmwiAIDV4lrbtm3NzVlqaqqJacQ1AICVaCLvmmuuMTdnxDUAnoxEHwAAQC5wIRQA4E68vRnJAwDgPohrADwZR/YAAAAAAAAAAACABZHoAwAAAAAAAAAAACyIRB8AAAAAAAAAAABgQST6AAAAAAAAAAAAAAsi0QcAAAAAAAAAAABYEIk+oDCy2cQjeervBgoYWxoAwJ0Q1wDATXnqNQIP/dkAgEtHog8oREJCQsx94tkk8USJZxLNfZEiRVxdFHjItpZ0Nm2d8zRJ57a10NBQVxcFAJAHiGscQwKAO+HaCHENAHBxSPQBhUiTJk3M/bF1RyU1KVU8SUpSihzbEJ1uOQD5xb6ORXvitpbItgYA7hrXjq49KqnJHhbXElLk2MZj5jHHkADgZudra45IaoqnxbVkOb6JuAYAuDgk+oBCpHXr1lK6dGlJikmStR+ukkQPaW2kLfnWjl0tybHJEhkZKa1atXJ1keDm2rRpk7atnU2SteNWe962Fpcs5cuXl5YtW7q6SACAPHDNNddIiRIlTIvtdeNWS1KMh8S10xrXVklKfLJUrFhRWrRo4eoiAQDyQPv27aVYsWJmP79+/BqPimtrRq8ylVgqV64sTZs2dXWRAAAW4WWzeWqH10Dh9OOPP8ptt90mKSkp4uXrJeFVIsQ3yFfES9yPTUzC4dTOk2JLsYmvr698//33csMNN7i6ZPAAnr6t/fDDD9KrVy9XlwwAkEemTp0qffv2PR/XqkaIb6D7xrWk2CQ5veuUiWt+fn4mrvfs2dPVJQMA5JHJkyfLHXfcIampqZ4T13aeEluqTfz9/eWnn36S7t27u7pkAACLINEHFELTpk2Tl19+WTZs2CCeokGDBvLmm29ygQYF6pdffpFXXnnFo7a1hg0bmm2tR48eri4KACCP6UXBV199VTZu3Ogxy7ZRo0YmrnExFADcj1ZOHDx4sGzatEk8xRVXXCHDhg2Trl27urooAAALIdEHFGJbtmyRzZs3S2xsrLir4OBgqVu3rtSqVcvVRYEHY1sDALgTPX7U2Obux5D16tWTmjVrurooAIB8pok+jWtxcXFuu6xDQkJMXKtRo4ariwIAsCASfQAAAAAAAAAAAIAFebu6AAAAAAAAAAAAAAAuHok+AAAAAAAAAAAAwIJI9AEAAAAAAAAAAAAWRKIPAAAAAAAAAAAAsCASfQAAAAAAAAAAAIAFkegDAAAAAAAAAAAALIhEHwAAAAAAAAAAAGBBJPoAAAAAAAAAAAAACyLRBwAAAAAAAAAAAFgQiT4AAAAAAAAAAADAgkj0AQAAAAAAAAAAABZEog8AAAAAAAAAAACwIBJ9AAAAAAAAAAAAgAWR6AMAAAAAAAAAAAAsiEQfAAAAAAAAAAAAYEEk+gAAAAAAAAAAAAALItEHAAAAAAAAAAAAWBCJPgAAAAAAAAAAAMCCSPQBAAAAAAAAAAAAFkSiDwAAAAAAAAAAALAgEn0AAAAAAAAAAACAWM//AbI2cdcRtwdhAAAAAElFTkSuQmCC", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -705,50 +733,186 @@ } ], "source": [ - "# Compare measurement outcomes: Ideal vs Noisy\n", + "# Build a 3-layer deep VQC circuit\n", + "depth = 3\n", + "x_input = torch.tensor([0.5, -0.3])\n", + "theta = torch.randn(depth * 3) # 3 parameters per layer\n", + "\n", + "# Construct the full circuit\n", + "deep_vqc = []\n", + "\n", + "# Encoding layer\n", + "deep_vqc += param_gate_layer(\"RY\", x_input)\n", + "\n", + "# Variational layers\n", + "idx = 0\n", + "for layer in range(depth):\n", + " deep_vqc.append((\"RY\", [0], theta[idx].item()))\n", + " deep_vqc.append((\"RY\", [1], theta[idx+1].item()))\n", + " deep_vqc.append((\"CNOT\", [0, 1]))\n", + " deep_vqc.append((\"RZ\", [0], theta[idx+2].item()))\n", + " idx += 3\n", + "\n", + "print(f\"=== DEEP VQC ({depth} layers) ===\")\n", + "print(f\"Total gates: {len(deep_vqc)}\")\n", + "print(f\"Trainable parameters: {len(theta)}\")\n", + "\n", + "draw_circuit(deep_vqc, n_qubits, \n", + " title=f\"Deep Variational Quantum Circuit ({depth} layers)\",\n", + " figsize=(18, 3))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "7668b7f8-af10-4103-83e3-900e752d2a41", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=== NOISY DEEP VQC (T1=100μs, T2=80μs) ===\n", + "Original gates: 14\n", + "With noise operations: 28\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABvwAAACqCAYAAABhyejOAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAsZxJREFUeJzs3Qd4U9X7B/BvdndLB2WUvfcGkSVb2YIioCIqAi4QcS/kjwKigusnigtxMFREkC17772hjEL33tn/5z0hadKVtLTN6Pt5nkCT3JvcJPfcc+95z3mPxGg0GsEYY4wxxhhjjDHGGGOMMcYYc0tSZ28AY4wxxhhjjDHGGGOMMcYYY6z0OODHGGOMMcYYY4wxxhhjjDHGmBvjgB9jjDHGGGOMMcYYY4wxxhhjbowDfowxxhhjjDHGGGOMMcYYY4y5MQ74McYYY4wxxhhjjDHGGGOMMebGOODHGGOMMcYYY4wxxhhjjDHGmBvjgB9jjDHGGGOMMcYYY4wxxhhjbowDfowxxhhjjDHGGGOMMcYYY4y5MQ74McYYY4wxxhhjjDHGGGOMMebGOODHGGOMMcZYISQSieW2ZMmSCl+fuab77rvP8rtOmDABrkatVqNOnTpi+8LCwpCTk1Nu70X7tfV+zhhjrmzw4MHiWCWTyXDu3Dlnbw5jjDHGWJnjgB9jjDHGKrUdO3bYNFjTTalUIjAwEPXr10e/fv0wa9YsREVFwZMcOHDA5jPPnz+/yGV//vlnm2X/+ecfm+f1ej2WLVuGkSNHonbt2vD29oavr6/4/saMGYM1a9bAaDQWuz25ubn47rvvMGzYMNSqVUu8hpeXF+rWrSte96effkJ2djZcRUUH8+h7yL+f2rvRvk3Onz+Pd955B/fffz9CQ0NLvO1XrlwRy1KZuPfee0u8Heb32LhxI15//XX06NED9erVg4+Pj9hPmjZtihdeeAHXrl27q2CTn58f4uPjbZY5c+ZMpQu8fv3117h586b4m75XKkvWv+WLL74ofseIiAhLOatZsyYeeOAB8f1QeWblL//+68iNgs1mdLx86qmn0KpVK8jlcssydKwoT3/88QemTJmCjh07QqVSlSjgu3LlSlGnhoSEiHVpW59++mlcvny5yHUuXboklqFlaR06hvXv31+8ljuhzgEl/b3ff/99se7evXsxc+ZM9O3bFw0bNhTHOiq7DRo0wJNPPomTJ0+W23YnJibi3XffFb93UFCQ2NfMx+1nnnkGp0+fLrJOp/OKDh06ICAgQKzTsmVLURelpaXBWV599VXxv8FgwFtvveW07WCMMcYYKzdGxhhjjLFKbPv27RSJsnuTyWTG999/36jX642eomnTppbP17JlyyKX69u3r2W5sLAwo0ajsTx39epVY9u2be1+fz179jTGxMQU+vo7d+40RkRE2H2Nn376yViRPv74Y8vtzJkzNs85sl1lue116tRxaD+1vtG+TRYuXHhX3+n8+fPFsmPGjDH26tWrxNthfg+VSlXscj4+PpZtdgS9bv7XmDp1qs0yp0+fLvN9aPny5Zb9YsOGDUZXkpubK8oofVa5XG6Mj4+3ef6PP/6w+3uNHDmy1L8BM97V/mvvRuXPLDAwsNBl6FhRntq0aVPk9hXFYDAYn3jiiSLX8/LyMq5bt67AevQYPVfUevSa9NruoLjPX9Rt5syZYt0mTZoUuxyV9d9//73Mt/nGjRvGGjVqFPveCoXC+O+//9qsl5iYaGzXrl2R69StW9cYGRlpdJbWrVtbtuXo0aNO2w7GGGOMsfIgL79QImOMMcaY+3nkkUdET3bqgX7s2DFs2rRJjHihG/W2j42NxaJFi+AJnnjiCbz55puWkVDHjx9Hu3btbJa5desWtm/fbrn/6KOPQqFQWHr+04iD69evW56n0Vv0mFarxbp163DixAnx+K5du8QIs3379omRXWa7d+/GgAEDRBpCs3vuuQe9e/cWoxiio6Oxbds2MUqtor3yyitwFW+//bbNqIiUlBTMmTPHcp9GvND3aI1Gf5hVqVIF7du3F48tXry4RO+9evVq8f+IESPE/0OGDCl0xAShskNlyFqnTp0sf0ulUvTs2VOMMKOUav/++6/Y7wiN4KR9kkb60XKl8e2332LGjBlipGl5yf/5XMlff/2FhIQE8TeVQ0rpaY2+12bNmqFLly6oUaOGGHVD3/eKFSuQkZEhllm1apUYAUzlsDJKT08XI5LKG5WLjz/+2OYx+h2OHDliuZ//eRr9bEblh35LKnM0ysp8rC1vNPKMjiP0vlQf7ty50+46X331lRgpbkYjv5s3b47ly5eLtIo0GmzcuHE4e/asGG1Kbt++jbFjx4rnCC1P69HytB6h16Tv8fnnn4ero22nEW7W6BhOx3JCI+KfffZZm+fpOGmNPiuN8qRyS/Wy+bvX6XSYNGmSGKVLo/DKykcffSTqYDOqA+h3pxGZS5cuFSP3qa6nLAiUKtOMtsV8XKeRiJMnTxYjiWlUalJSkjhnoO9j//79pT7W3w1671OnTlnqDLoxxhhjjHmMcgkjMsYYY4y56Qi//COAzp07Z6xXr57NMoWN6jlx4oTxySefNNavX1+MSPD19RUj3z788ENjZmZmoe+dlpZmnDNnjrFz587GgIAA0VO+Vq1aYiRA/hFlhHr7W4/iSElJESOaatasaVQqlcZmzZoZv/zyS4dHPNy+fVuMXDS/5vTp0wssM2/ePJvPfvLkSctzkydPtnlu9uzZNuvSaMinnnrKZpkPPvjAZjQS9fQ3PyeVSo1Lly4tdFv/++8/465du+x+JuvRhrNmzbI8fvHiRcvjwcHBNt/R/fffb3luypQplscL2y/sjXCzHl2Tf30aydinTx+jn5+fuNH7FvY7O+LatWuFjgQpTHZ2dpHr2RvxFhsbK34X2r/S09MLXSb/iJui0P5CI0Lz7yO9e/e2eY1Tp04Z72aEFJXDkozwO3LkiPHxxx8X+yKNQqSy26JFC+PLL79sjIqKKrC89T6Q//PSPjpixAgxKobKM70W7RP0W9NvlJqaWuDz0z7fv39/MTKP1gkNDTUOGjSo0BFP9vTr18+ybYsXL3Z4vV9//dXme6JRjHc7wo+OrVT+aaRPtWrVxD7k7e1tbNCggXHChAk2v/OPP/5oeQ1aJv/3RMc6+m6K2r41a9YYhw0bJt6HlgsKChL7FX2u/MfD/GWAtvP7778X20nHbhrBRrRarRgde88994jRdHSspGNH8+bNxf6ybNkyY3mPAiuOdbm2Xq+8R/hZv691nVTU9tL3WL16dcsy48aNszyXlJRk9Pf3tzz32muvWZ579dVXLY/TMrSsGb2G+TkqazqdzvJcccdF6+/JerQkSUhIMM6YMUP8vjTamPaj8PBwY6dOnYzPP/+8cf/+/cayZj1yO//2WKPtsq57C/s8dKNyUJYGDhxYZBaAIUOG2IzYMzt79qzNNlkfhzZv3mzz3Pr16x3ah/Ofp1EZzn8cou8vJCREjHak8t+4cWPj6NGjjf/73/8KfK5Lly7Z7Fs5OTll8n0xxhhjjLkCDvgxxhhjrFKzF/Ajhw4dsllmwIABNs9//fXXopGpqCAQNSDmT2dJDU7Wwa78Nwo8rFy50mYd68ZVCg5QA1xh67744osOf37rYBc1lls3nBIKfJifpwZxM2ogs061RkFRatjNj1J7UXCrsIY8arQv7XYXhYKW5tejIIoZNehbv5c50EYBFwq2mh+3/s7LMuBH20KBs/zLUwNl/rSLZR3wK249ewE/aqyl5R544IEil3E04FcUClJbvwYF4EoTbKL9l/6nwMz58+cdCvhRQKew38V8o0BP/jSjRQX8KChtHUAv7GbeLnPgxDpAV9iNgo6OojJJQbX8+3hxKOhO2zR8+HCb96Xv7W4DfhSkKO6z0bZu2bLFsu1UFszP5W+ktw4IVqlSRWy3ufxS8K2493n44Ydtjmv5y0CPHj1s7psDfvZSMHbp0sXozIBfUesVF/AraRpRe8FDRwJ+FCizXuavv/6yeX7o0KGW5yjNtJl1Gktaxhq9hvVrHjhwwPJcaQJ+tP/ZS5v5+uuvG50V8CvK2rVrbbbxzz//vKs0ovmP39b1KQXG9uzZY1Sr1eL4QJ2TCusoM3fuXJvXtA7UUvDdur61Xq+0Ab/8+2D+GwVtC0MdK8zLlCSVNGOMMcaYq+OUnowxxhhjdlAarTZt2uDkyZOW9JSU4pNSqlGKyhdeeAEGg0E8R2nwKHUlpcejdGOU9pJSkI0fPx6bN28Wy9C6Dz74oCUVJqXdo3RmwcHBIoUovSaluKR1OnToIFJ95Udp+yj13JQpU0QKr19//VWk3yRffvklRo0ahV69etn9bSdMmICNGzeKvyk9G20jpQUjlNKUUqxZL2tGaefMqdbMqb7k8oKnliEhIejXr58lLeSNGzfEdkZERGDr1q02yz711FO4W5QKdOHCheJvShdm/p0odag1+g1btGghflP6Hs2p6ihdWnEo5RqltLROY2lOA0sCAwMLXW/Lli1o2rQpRo4cKVLvrV+/XjxO6c1++OEHvPHGG3BFf//9t006z/Jw4cIFy9/+/v7ieyqNd955R5RF+s3fffdd/PHHH8UuT/vAyy+/LNLSEUoDSikEMzMz8dNPP4kUo5RGlcrSlStXRFrU4lCqVHpvQp/h4YcfFmXi5s2b4jen8mRt+vTp+O+//8TfSqVSpJlr1KiRSM9I207btWDBAnEMoOODPYcOHYJGoxF/U8o/SvdY3Hf14YcfFvoc7dv5Uw+WBm0DHYNatWoljm2U2o/2d0r1Syl6aVunTp0qjo+U7u+ZZ57BvHnzxLrff/89nnvuOctrWf+W9F2oVCrx9/z58/HLL79Yyi/9VnSspjSl9DilG6R127Zti7feeqvQ7aRjQ506dcS6lG44Pj5e7AN0TDWj5yglLu0PdAxzJI0lMzGnTjTLX59Z37906ZIlvTP97cg65vegNLWlRekxL168KP6mffHpp58WqUWpTqSy76q/t/Wxk1Jj0rGiLL322muirqLvhs5punfvbvM8lUM6T/nkk08K/b2pPqSyb0ZltF69epZzqfz7RmlYp1incw2qw7OyshAVFYU9e/YgJyen0PWozjaf+9AxwF7dzxhjjDHmLjjgxxhjjDHmgCZNmlgaqSjQlZycLAJ11NBlDvZRgxEFscxz0lAgqHPnzpaADzVutW7dWjR4mwNpFIzau3evaOg3z9VG8+hRoz+9D819RI3+hfnxxx8tgQCaI6dx48aigZvQXDmOBPwokEOBDPM8QtRIbg74mRvSCc3bZx10sJ7Xh1CDeVHyPxcTEyMCfjRHk7XSBnqs0Wem75QCL9RoT/MIUcOeOeBHAUgKOtB9Ct5R0MeMghz55zwrav4264AfBXitg6GFobm3KCBDAS1CwQPzHEeHDx+GK6IGXpo/kfbnYcOGlct70O9gPacgzb9HgaLS/vY0jyEFrWkuOwqwUSCtKFSuzME++l3od6hataq4T/NRDRo0SPxNZZ2C9y+99FKx728dAJ85c6YI4Fmj4IF5bjh6TQr0mn3zzTd48sknLfdDQ0Px9ddfi7/pGONIwO/q1auWv2l+vpLOjUXByblz54rfoCzQvF50bKTOARTgS01NRXh4uDi+mOfkpP+pYZ7KB5VHmrOOyi6VDfr9qJzQsckcGLXuGECv/emnn1oepyAvvaf18YQCFubfmoLqhX0nFICg97Ke+4ze0xy8pd/s999/t9mXaL+xnrvUXRQ2b2BxiurAUBK0r1vLPz+i+Zho/k3NdZG5bNpbh9Ax/W5Yl106jlC9a42CkNR5x9WCfdbzuFLgrW7dunbnDSxO/mWrVauGgwcP4rHHHhPzreZHdSs9Z33Mtv69C5sL0/q3u9vfLf9vR+cstM3WIiMjC12PzkEKO3YyxhhjjLk7DvgxxhhjjDnAuvHRGgXrzHbs2CGCTUWhkXsU8LNehxqVKVBX3DqFoQCcOfhEqKGPet/TSAVy9OhROIJ66FOjoLmXPI3Eo0APjXRZtmyZZbmhQ4eKIERRaPSOo8wN6eWBGhgpSGAOolEPfxqpYW70oxFFFIwxBwCtR/7R6MDy8vjjj9s0dNJvbg74mRu4Xc2GDRtEQ3fXrl0LNKKWhTVr1ohAljlITfshBW3uBjWAU3CdyiuN6LIeeZIfjQC1Dtqag32EglIU/KWRtOZl7QX8evToIT4ToQDwt99+K35n6izQrVs3EfynES6EGtF1Op1NEKuoEa40OpBGG1KZLI55W4n1qJrC0OejABeVdRphR9tNI+4okE1lhkbF0THmbtDvMHHiRDHCsTg04pcCfjTCcvjw4Vi1apWl0wIdl+iYZN5H6PhJ5ZvQqCPrIMz//d//iVthKLBAI8YK61Tw/PPP2wT7CHWCoBHA1DGDRgBTUJCCZdQxg0Ys9u3bVzzmbugz0c2V6tKi6ta7Xack6LelupCOdzTKnr4j2teo/FIHHPq9qR5xFXQ8orJirjsoSGnuIGCNjmt0Ky3qlEMdH8wj8ahDBR3LqFzQMYLOZfr06SMC4qNHjy6wfmG/U1n/dnTcpU5U5oAljfSkckq/IdXpDRs2LHQ96vxT2LGTMcYYY8zdccCPMcYYY8wB1unFKOWXubEo/+iF4pgblUqzTn70/vmDizR6xoxG0ziKghPmgB+lv/rzzz/Fa8XFxdksYy1/AKi4Rn1KgVdYz/r8Dag0YoFS790taoA0B/wooEejnQj9/8QTT4iAHwUZKO0fBTes1ysv+UdemFMSEvMIUVdjTsNK6WfLGqVdfeWVVyyfnYJdNNKvpKPS8qOUdpQ2lUb4UcN9cSMTrcuhddmxfsxc/hwJylJAkBrGqfGbAgfUAYBuZtQYTaMPq1evXqJjADWQU8DKXsCvJKjRnm5mVE569uwp/v7nn39E8GDatGmlfn0aAUyjhylQaY85haM5IG8O+FGHAxrBt3LlSsvz1kHRknyHhH7LwgJ+RY0spt+RUrxSQJQ+D30vZrSf0vdT1OhrV0WBGgrkl2SEH6VavRvWgRVCQeai7tP3ak6dS8Fxc3CouHVIcZ1RHEF10pIlS/Diiy9a0nDTzczPz08EoPOP2nWGFStWiPrYPLKNAnIUfCus0w2lrDxz5ozDr03HKOsAIe3j5mAfBc/omGpGo/oo9TF14KHUyOaAn/Xvnf93yv/Y3f5uhM5d6L0PHDggjpPmdNlm9BwdS/LXLWUdeGSMMcYYcxUc8GOMMcYYs4NS0pnTeZp705sbj2gkDc35RGiEHfW6L8q9995rWcc6eDh79uwSp1Sjhi3z/HRm1gG6/CNWikMjj5o3b25p4KS0WNYBEHMavqJGRBBqZPvggw8KvDY1ylvP1UeBL3PAj0ZNUCOqGTW4fvbZZ7hb1DD50Ucfib8poGcO+NHvQ+lFaTQRpRGkecLM3xn9no6kQC2t/KOlzCO9XBWNqDI3nJbl/H20z1KjuvW8S5SG8b333iuz96DyRMFKeq/iypZ12bUuO2bWj9mbv8+cEnPp0qUiSEUjc2kEGt1oHkQKGFLDO6WVpPSg+Ufg0Xx+5v20tKkVrRvPSzpqlEbJWKf2pUDl3QT81q5daxPso++E5kWjz0HHmaJGmZnn/KOUxjRfHo2SNB8/KKXmo48+alk2/3dIwfzi0hfmD7qbFZVClkZ4UYCMtoVSfl6+fFn8TwEzClRT0JpGPpfnyOCyRh0hrNMR20PHy7sN+NH3aI1GW1t37LBOp0gj6sydIWhkrHmOuvxpGfOnYKR9pjDmOS0LCy7nR8E8mquRUi/Tb06/N42Yp5HYlB6a9l+av5WCf85C827SKGhzsGrSpEn43//+V+j8uWT58uXieOMoKkPWAT/rupvq/PzpPCngZx4JSIFSOgbR703BckJlmM5VzEFAKjfU0aYsfzeqz2nEI821SL8d/W70+1GAnkZRU4cB+kzWKZPzdxiwl8qbMcYYY8ydcMCPMcYYY6wY1GCfv1c/9Wa3DuKZR0LRHF3UAJd/3hoaNUc98M0BP/P/hHrpU+N3/oCaOe2f9Uiw/AEZ6ulvntuL5pOyHq1GI51KgkYMmOe7osZ+6/elOXryNyjSaAJKU0lBM0KNop9//rlNkIAaJV9//XWbHv00T5cZBZKoQdk8ApDmTaLgY2HzlVHDIzX4U2DCHgrsUYCNviMK6FCjJzGvS/9TgyQ1lJpR2raSBEnp+zCnZHRkFJO7obn7qLGWAsHm+SXvFqVGpNEW5lEi9HvSPJTWQZyy0KxZM7FvUgCZymRRrMsujYShfcWc1pOCOtaja63LbHHHCmp8psZj68A/BaHMxwwKGBFKO2eea5LQ/kojHvOjck2vW9hcWPnVr1/f8jc1wFPjev5RLZT6jhq/848OpgZz6yDh3Qak88/NRY3t5qCl9Yi9wlBAmI6jhNKymtN55k8rTAEh85yc5uNsYd8h/a6UepB+m5KgVKoUmKKghHVgok2bNpZRT/R7mgN+dAw1B1cocGk9urMyo8AQBbPN877S6FsahUsoSGT9PVmXGxqdaw740TIUoDEHeak+NaOR4vQehbGeH5XKg3Wqa+vU0vTaVE9RfWQ9+pXKhPk96ThPZdFct1IA2Vx30ajx999/H+WFAmBUJsz7F5VPmm+T6tfyZP0d5Z9rljpCmdH2UOclczmljg1mNGLXHDSmY7/1+UBRHaSos4V5bk9Cgbyitos6Y1H5pNSd1uk76bXNKZapnOYP+NHrF3bsZIwxxhhzdxzwY4wxxhizQg3/1AhJwQkKYtF967m2aL4nmsfGbMaMGaInOQW3qIc5Ne5TYyaNiqOACfU037lzJ7KysjB+/HixzuDBg0VQ4vz585bAF61DwRVqlKTRC7t27RKNidSDvqg0l5TejlLxUaDq119/tTSME5o7qyQoQPLmm2+KhjT6LOZ0YYWl8zSjEX2UotCczpNSGlIDGzV207ZQcME8Tx2hhnEayWRGQUUKygwcOFA0aNJ7U/CHAn+0LI2koMAFBZ/ou6LvwpGAH43YocChea5E8zxf+QN+9PtYb1tJUCOzubGXRi9R0IGCoOb5nlwJNcyag560X1ujoLE55RuN4DDPC2kOhJXl6D5qRLdOL0eBp5iYmALz7FHw+27nGaPGd/qN848UsUb7ornsUiM0fX4KNtNoHgpEmlGDP418sYdGfNHoWPP8bnQMoEACjfozMweV6TWp/JpHuM6fP1/8ThRYpIZz2u8pRR2VH3pvKiP20D5vDnTT8aawOeuofFG569+/vxhNRQ31FFShUYjWaCTT3aBgnDU65tHvSoEyShlcHNpGCmRQsMX6OJS/wZ6CmRRIffvtty2BRBoJRp+N5sukYC99p9RxgjoBlDQ17T333CMCVXS8oP8p6ErBBXOwj5Skk0BZo/kqzaOUrIMv9L1ZBz7p+zGPUKVjeVHHc0fR6FzzCLv8c8xavy917mjQoIEILlPdQoFcQuWS6jmq7yjVIu2rhALClNLVjP7+5ptvxDGLyif9DtT5hkaIWgeN6bWLmjv3v//+E787HZepHqHRX9YB3XfeeUcElams0FyldAyggC793tSpg+p/a876vWnk4b///mtzLKXPnP/YSccP684JVL/SrbTuu+8+MVqX0GhHOg5RWaLjuHXQld7TPPKRflfaXgrsEuoERPU3HddoxK718cr6XMoa7R+UYptS6lLHC+vjsXlUOB0/afuozqK6nOpwqpfp2Er7p3Vqz8J+N+vgryPnFYwxxhhjbsPIGGOMMVaJbd++nXJj2b3J5XLj7NmzjXq9vsBr/O9//xPP23sNaxcvXjTWrVvX7jo//fSTZZ2ZM2daHg8PDzd26NCh0HWee+65Un0XgwYNKvBa9B7FuXz5srF169Z2P8fgwYONycnJhb7Gtm3bjDVq1CjRd2HPu+++a7NuYGCg5bc7c+ZMgddev359gdco7r2nT59e6DY+//zzDq3/xBNPWJ7r1auXsaSuXbtm8/q0bxSF3tuRfZy2iRgMBsvvcfjwYbvbUthr2FuuLH7n/J/r9OnTNs+/+OKLdl974cKFRqlUWuS20H5Dxwhr9HsV9nknT55c7Oei9/n7778ty2dlZRn79evn8O/iCOtt+/HHHws8T5/H3vs9/vjjYh8ozW9gptFojK1atSry81jfz//9kldeecVmmerVqxt1Ol2B5ahM0/ba+0zWZSx/2Sns/YlKpSr2NevVq2dMTU0tszKd/zWsv8/C1KlTx6HyRJ+3LFnvY8XdrL9X2p/yfzbrm5eXl3HdunUF3uvff/8t9neg18y/rxa3TX5+fsbQ0FCbx1JSUoz79++3+3lGjhxZ5Pdf3PG3ONavUdw+4+hvXdrtKMqFCxeMVatWLfY9g4KCjMePH7dZLzEx0di2bdsi16HPc/XqVZt1its/zOXN+j4du0mTJk2KXS84ONh4/fp1m/e6dOmSzT6RnZ1dpt8bY4wxxpgz2eZ4YYwxxhhjouc8jRChUTo0Wod6k1NqPRoNkD9FHnnuuefESBxKuUWjZnx8fMToABrhQ6PdaM4d6zkACS1HI0VoZA/1jqcRGOb3pTlwaIQejbopLL0lod7y1OOeRinRnHiUHpFG1VBaTRohVxr5R9AQe6NBKIUW9ZSnURs0SrF27dqW1F5m1BOfRicUNQ8a9cynkRc0moNGAlEvfXoN+kyUYu3hhx8WownMo88ckX/EHn3H5t+ORiBYz/9Fv1VJe/jTXEo0coG++6JGl7grGhFF6ffosxWVKs8d0MimouZnM6NRqfR5aYQr7Wu0z9FITRqBS2WLRujSKBJH0BxfNDKtZ8+eIhWdeR+mv2kfppG+1iMm6ThBKe6o7AwaNEgcL2hfpPenkVEPPfQQFi9ejAULFjj8mamsmRU2ku7jjz8Wo6ToWGE+5tB3RCMBaQTyli1bxIjEu03pSSMNaUQVHT8o7SaNKqTRz/R5HEl9SCOprY+1tG2FlTNahraXRhPTqCLzsZDej35PSi9I84LSSLLSjGSjYyIdjylNK/02NIqJ7lP6Y9pvrOdWNM8HaU7ZyvLQ/kQjzWikMY3con3PXDboO6b6kcpAflQfUD1Jy9CytA6tS69Bo5PpNYvbV6lOohHyVBZp5B7tJ7/99puo2+kxGsVJ+wqVBxqpTctT3Uy/K+1v9F40mo7qVfMoaUKj0a3T1nrq703fC43mo1GQ7du3F6Nc6XsxlwPKcEDzXObPQkBlnkZ/zps3T4yupGMMHdeo7qXXotGVxaXRrF69uhjZTCPzKM0ypUylUaw0wpB+LzrPoN+JUGrTKVOmiFSr1apVE8ceOrbSMY3Ozej8hI4F1qyPjTSKkLaNMcYYY8xTSCjq5+yNYIwxxhhj9lFDOQUfCTVgURDSVVGqUWqco3m1qIGQ0nsVNV8Pcy00/9JHH30kgi6lDR4z56DyRoERCkZQwzelTKXGd3dDqTyp8d6cdpfSjuZPE+pKKABEwSFKPUkdFmh7zSkOWcWyDgCW19x6NKecOchHcw1SamB2d6znwCzv8xvreThpbkJ37tjCGGOMMZYfj/BjjDHGGGNljkbMUZCPgg7UGE6j82hEInN95TF/H6sYNFKF5jQjNJcfjVJzJzRvIc2bRiMVzcG+fv36uXSwjxw7dkwE+wiNFONgn2ej0brm8kaj/5j72LFjhyXYR8FaDvYxxhhjzNPInb0BjDHGGGPMMz3wwANYs2aNaMQnlPaU0h16WgpMT0Ojk5j7euGFF/DFF1/g5s2b4n9Ku+cuKeso3eiNGzcs9ymFI6U9dpcAEKWALknqYeaezL83Bdfr1q3r7M1hJUBpjc3pgOfMmcPfHWOMMcY8Dgf8GGOMMcZYubn//vvFjTFWMWiOK+ugmTuiuUxp7q8PPvhA/O/qXnnlFXFjlQPNScvcE83jyBhjjDHmyXgOP8YYY4wxxhhjjDHGGGOMMcbcGM/hxxhjjDHGGGOMMcYYY4wxxpgb44AfY4wxxhhjjDHGGGOMMcYYY26MA36MMcYYY4wxxhhjjDHGGGOMuTEO+DHGGGOMMcYYY4wxxhhjjDHmxjjgxxhjjDHGGGOMMcYYY4wxxpgb44AfY4wxxhhjjDHGGGOMMcYYY26MA36MMcYYY4wxxhhjjDHGGGOMuTEO+DHGGGOMMcYYY4wxxhhjjDHmxjjgxxhjjDHGGGOMMcYYY4wxxpgb44AfY4wxxhhjjDHGGGOMMcYYY26MA36MMcYYY4wxxhhjjDHGGGOMuTEO+DHGGGOMMcYYY4wxxhhjjDHmxjjgxxhjjDHGGGOMMcYYY4wxxpgb44AfY4wxxhhjjDHGGGOMMcYYY26MA36MMcYYY4wxxhhjjDHGGGOMuTEO+DHGGGOMMcYYY4wxxhhjjDHmxjjgxxhjjDHGGGOMMcYYY4wxxpgb44AfY4wxxhhjjDHGGGOMMcYYY26MA36MMcYYY4wxxhhjjDHGGGOMuTEO+DHGGGOMMcYYY4wxxhhjjDHmxjjgxxhjjDHGGGOMMcYYY4wxxpgb44AfY4wxxhhjjDHGGGOMMcYYY26MA36MMcYYY4wxxhhjjDHGGGOMuTEO+DHGGGOMMcYYY4wxxhhjjDHmxjjgxxhjjDHGGGOMMcYYY4wxxpgb44AfY4wxxhhjjDHGGGOMMcYYY26MA36MMcYYY4wxxhhjjDHGGGOMuTEO+DHGGGOMMcYYY4wxxhhjjDHmxjjgxxhjjDHGGGOMMcYYY4wxxpgb44AfY4wxxhhjjDHGGGOMMcYYY26MA36MMcYYY4wxxhhjjDHGGGOMuTEO+DHGGGOMMcYYY4wxxhhjjDHmxjjgxxhjjDHGGGOMMcYYY4wxxpgb44AfY4wxxhhjjDHGGGOMMcYYY26MA36MMcYYY4wxxhhjjDHGGGOMuTEO+DHGGGOMMcYYY4wxxhhjjDHmxuTO3gBXc33LFmgzM9HowQdtHj/6+edIuXzZ7vp1BwxAw2HDLPf1Wi22T5/u0Hu3nzoVwY0bW+4nnDqFk4sX211PKpejz2ef2Tx2YeVK3Nq1y+YxrypVEN6+PRqOGAGJROLQNjHmapIuXMCNzZtFebF2beNGXP33X7vrB9Sujc6vvWbz2JGFC5F69arddesNHIgGQ4da7us1Gmx/+WWHtrvDSy+hSsOGlvvxJ0/i1Hff2Syj8PFBYL16aPnkk5B7eTn0uoy5GnV6Os789BOajB4Nv+rVLY+nXruGI59+6tBr9Pr4Yyi8vS33I9evFzd7AuvWRadXXrF57PCnnyLt2jW769Z74AE0GDzYcl+Xm4sd+V6L6lu/GjXQdMwYcSxhzB0ZDQacX7ZM1Dc1773X5jmq06hus6f1xImo2rat5X5qZCSOLFjg0Pvf9+mnkKtUlvtX163DtQ0b7K4XVL8+Ouarcw99/DHSb9yw3KfzW5+qVVG7b98Cn40xdxK1axeyoqNFfWONrg3pGtGeiO7dC6xL16R0bWpPm0mTENa6teV+ypUrOJrvWrMovRcsgEyptNy/smYNrm/ebLOMKjBQvD6dJ/A1KXNXdF57+a+/RL0kkeb1o4/auRMX//jD7vo+YWG4d+ZMm8dOfPMNEs+csbtuRM+eaDp6tM1j26ZNg0Gvt7tum8mTEdaqleV+8qVLOPbFFzbL0HVoQJ064ppU6edn9zUZc0Xa7GxxTVpv0CAE1atneTwrLg77Z8926DW6zZoF75AQy/2b27fj0l9/2V2PzkXvfe89m8eOf/01ks6ds7turfvuQ5OHHrJ5bOvUqeL83Uwqk8G3Rg00HjXKpo2JMcbMOOBn5eKff+LQvHkIrV8P9etEUIuI5bmEndsRf+Ei7Kni4wV9zXDLfbqoit62FY5ofk8n6DNSLPezjx13aF2ZXA790YM2j6Xu3onobdtsHpPI5KJBJTs+Hq0nTeILLOZ2Es+dw3/PPQdtaiqad+4AhSLvEJa+d7dD5UVdrx70fXvZvi6V70v2A/rBft7Q16hqua9Tqx0u3y26doY+LclyP/vI0YLrSqWQqLyQcPq0aDDhoB9zx2Dff88+i+Tz5xEa6A/vVi3ynrtyxeHyojtyAFIfH8v9NAfLt6ZBfeh797B5LHHnDiRcuWJ33ZAAP+irheZtQ25uwfeUSCBRqsTF3oBvv+WgH3M71FhwcO5cXP77bzTqcx+qqageNVqej9m+TdRt9jRo2Qx6fd5yuZcul6h8S6w6taTt2eXQutqbN6Dv1c3msYSdO5AUGWn1iAQShUJ0AOo5dy5q9+nj0DYx5kqoE9ve996Df1goGjVpCBjyGvGTdu1A9LHjdl/DFwboG+U1cBIqZ44E/Bq2ao5gbY7lfs6FC46Xb7omtQr4pe8rpP6WyXB90yZkREWh44wZfE3K3A51ctkyZQpyE+LRtEM7+ATkBcUy9u9xqLz4h4dDP+R+m8eSdu1E9IkTdtf1kwL6BnVsHqP3dCTg16hNS+g12Zb7OefOF3lNGnfsGPp++SUH/ZhbBvu2TZ2K+OPH4Scxwr9LJ8tz6uhoh+s0zZD7oQwLs9zP2OdY+Q6oVg36wQNtHhP196nTdtf1l0uhr1fL5rHorVthtGqfNl2TKkVH+P7ffIMqjRo59HkYY5UHB/zuoJMZCvYZM9KRuncPchd7QWrVU8tw4RyMicl2v1Dd/t3QZCZY7uv1ehgT8+4XR/vPH9Dsy+s9oouOc2hdg1QCzQ9f2zymP36mwLrUnCMJCBSjiqhXN41GZMxdUOO7CPYlJcEQH4ukz+YjODgo7/nzlx0rL3pNwfJy8TyMSSn2t2HfLmjS4/Pu60pQvlevhCYsr3xrb8cWvq5KhdiDB3H4k0/Q9Z13HHptxlwFNVAmnz8HQ1wskpb+gKpN83ocapNSHC4vmqXfAQqF5b7+3CXHyrdBW7B8X6bynWp3Xd3endCkxuRtr1ZX6HsapVLkGAzY+sILeHDNGgc+DWOu48Ly5SLYZ0xKQMq6tVBnxNs0thtjY2B0oMFQt/4faE4dstzXJiY7Xr6XLIbRqsOO/uxFh9bVGwuWb8PlCzCmpBU83w0Jw64338TQFSvEyF/G3AWNtqG61JCejvQb15DzzWeQyWSW5/VnTjpWXo4cgMaQZfOYMS7WZoRAseX7ZF5nUl1CkuPnu0u+hcFqe3VnLhS+rp+/OB4F1q+PxiNHOvTajLkCKkPUuS03NlZckyZ+9SmqhecFBHRXrjt2zpqbVbBOO+tg+T68Hxpdhu12xcfBaMzrwFMU3brV0Bzfn3c/PrHw812lEoknjWIkVK+PPrL7uoy5EurcFn/smCgXSb8vRcSZw5bntOmZjtdpy36GxjevE6ru8jUHy3d2wWvSc6cdK9+H9kGjyXdum0jlu+A1qVqvx5Znn8VDmzaJUX+MMWYmMTpyVlAJnPvtNxxdsACGqBuoWSMc93btYNMAotPpHDqBoiCh9UUZrUPrOoLWswkyGgwiYOgIhVXDKKH1aP287QBOn7mAq5E3Ia0RgeZPPokO06bBUXPnzsWSJUsQE5PXGFpR5HI56tSpg48++ggDOEhZaVE6oX/HjBGNkT5yKfr17Q6VSlnkPl80ic3IQFcp3/TuiQnJ2LPvCCTBIQhu3wFDfv8djtq8eTNef/113Lhxw+FtKkvVq1fHhAkT8Oabb1b4ezPX8ceAAci5FgljWir69elmE5QvSZ1Gx33rOtjR8k3r0LrlVb6zc3Kxfft+aBUKSEKrYvTWrSI1Gaucli1bhjlz5iAqKsrB+qfs0L4eERGBl156Cc8884zD6+155x1E/rNaNPy3btkUTZs2sHle68Don7s9Zy3P8q03GLBv31EkpqRBGlEbPebMcbiDm0ajwbPPPoutW7ciOdl+J7+y5uXlhSZNmuDHH39EI+6pXWlRCsz9//d/4pq0amgwevXsku+aVG/by9/BOs1VyjeV1osXr+L8hauQVquOhqMf4Q5ulVhmZiaefPJJHDhwAGlptg3cFcHHxwetW7fG0qVLUa1aNYfWoXSAqwYPFoEEpVGP/n27w8cnLw29Xm+AwWpUbsmuSV2jfCcnp2Hn7oOQBFWBf9NmJergtm/fPkydOhXXrl1zeJvKUnh4OEaPHo0PPviARw9XYv+MHIm0s2dgTElG7173IMyq43VJ2nBKe85a3uU7V63Bjh37kUuZLapWw4jVq+EfEeHAdjFPtHbtWrz77ruiLdDR87WyQuWjRo0a4nr0ZQenO2IVg0f43aFJT6ejt/i7Qf06BU4O8jcwOIpeJ38wzlF0oLc+GSsJqiDyVxING9YVAT/6nOoSnFC///77mDVrFpwpJSUFw4cPx5o1a9C/f3+nbgtzYhkVvSr1iIioaRPsK2qfd5SrlO8aNcLh5aUUPbXMn9cRW7ZsEeUjNzcXzpKRkYG33noLarVaHDNY5a5Lg4ICbIJ95VGnOaN8ByoUqF69Km7GJYr7VJdywK9y+v333/H4449XeKDP2rlz5zBp0iRxYTdlyhSH0+5Cb9rm+vVt0wURVzlnLW35pq2vX682EpNO5n1eB4N9jzzyCFavXg1n1qMJCQno3bs3tm/fzkG/SkqTkUEt8KK3ZoP6tQu5JqWyUrry4irlm661KeBn1BtKdL7LPC/Y98ADD2DPnj1OPe7SdZT5uOtI0M+yzxr0qFkz3CbYR2QyaqwvXXlxlfIdHh6KAH9fZJSw3YiCfQMHDhS/rTN/U+qMlZWVhYULF3LQrzLXpXo9fH28bYJ9d9uGc3fnrGVXvul+zZrVcOVmNCR3znf9S/XKzBOCfaNGjXJKBwuz9PR0zJgxQ2wDDUJgroEDfoWxva6q1KjgmoN9DUc1RkTv2pBIK/YL0qt1OPvDaSSdSRS9FjjgxzyZpBQHoHfeeUcE+0JahqLF060gE3MyVRyjwYhb22/iyl+XxPGCKnt/fz7lrMy4GmWeji5mKNjn0244qgx5BxK5bSeU8mY06JC2aQEyD/yG1157DZMnT+ZGrQIHIMeTmOzdu9cS7GvzQjsENw+p8COZOiUXJ744itu3b+Pzzz/HV199VaHvz1yQh1am+YOYrHL6559/RLBPovBC2BPfQRnRSsxLVZF0idcRv2QiLly4IEZXU+fFkvHkfbnkn42uAynYF9S4ClpNagO5T+mCKqVFI7di90fjwq/nRD36yiuviGwIrBLz5CLKGIC3335bBNq8m/dD8MgPRZ1aoQx6pO/6HunbvxZ16PTp06G0msuZOQ8H/CoRP19fDH6gN5RTpkHZtIVD69y8eVP8L/eRo+ljzeEszZ5ogT2v7sT169edtg2MVYQ+fbpB1vcBKPs/4PA6NHTfXE4C6jonvSAdH65viIQuWye2p2XLlk7ZDsbKW5s2zdAqoi5Uk6fCp2pV/sIrIUoDdOvWLfF3yOhPIA90LA1YWQsd+7kI+FFvdsqEEBwc7JTtcDU1a1TD4AeCofrgU6iCbXt126tHQ1uHoVbfOnAG3+q+aDCiEU5/e5LPd5lHoywddE2qmDAZyjbtnb05zEnMx13fdg/Ct/0Ip2yDIqw+Aro/hdQNH/FxN5+ePTpDeu99UAwZUeLftMm4ZghsYJvpo6JQJ/Ubm64hJyFH/KYc8GOeqkXzxmjSoxu8XnoD3qGhzt4c5iTm427wqLlQVm/qlG0Ifmge0nd/D4NOI66R69ev75TtYLY44FdC8sEjIB8wGLqdW6FbtbxkK9PQ8YcfhaxTVxhTU6BZ+j2MUdcdW8bPH8onJkFavxEMkZehWfItkJUJSZ16UD72tMivTpO7av/83TRhXyEotYSvrw9U4eGQVqni0Cab8/9W9Iih/GQq09D3is5HzNyPO5dRQmkn5CHBUDg4j4RNOVU6d6JmOk5QwI/LKXOnMqqc/paY6wtGA/QH9pjKaDG8VCpIAwOgqlGDf+hKynrOOIlC5bTtsH7vsj7uunNdSnOm0M2rRg1IZI6dv5q/P6mydGnYygqf77LKUJdS+kC6JlVWrQoZd1SotMzHXYmygkcj5CNRmlJycj1qi1KVyoOrQFGC811Xuia13h7GPK0eNXee8QrwF+e7rPKy1KUVPbIvX+YGqcJbBPz4uOs6nHtV64Z0WzdCu2oFFP0eEJOjlgQd6GU9+kCz+AsYYqOhfHKyw8soRjwMSWhVqBd8KP5XDHtIPK58copYjpaX9ewLWYcuZfRJGXNPXEYZc22uVkbpwose023bDHmfgZA2ck7POMZciauVUz7fZcy1yyjXpYy5dhnlepQx1y6jXI8yxsoSB/xKKjcX+iMHLAfwEn3ZzVvBGB8Lw+WLMJw4Amm1GuIA78gysmatYLh4FsbbUTBcPAdpy9aQhFWFtGo1GI4fEcsbE+IgbdG6xB+JMY/CZZQx1+ZCZZRQ70nx2PnTphfw9S2rT8qY+3Khcsrnu4y5dhklXJcy5rpllOtRxly7jBKuRxljZYlTepaCrE0H0/8dOosGQsVjT8Nw+QK0y36GtEFjKJ+fUWCd3JcnQ+LnD6jV4r7xzv80nBuJ8ZblilzGzx9Gde6dx3PFcmLZO/eFO48XRaPR4MbN21D8uw5B99yL6p07l+bjM+by3LWMkmvXomDctQdeeikaDB16918GYy7IVcqohVQG+ZCRMCQlwHD+TLHbHhuXgMwMNRQrVqD+oEFQ+hdfphlzV+5al6anZyAuPhGKlStRrVNnVGnYsGy+EMZcjKuU0ZLWpVqtDtdvREG+YSMCUzNQs1u3svg6GHM57nxNev3GLRj27odCqkLjkSPv/stgzAW5ShktzTVpQkIS0pLSxTVpnf794c0pshljVjjgd0ebyZPR6qFRUL/3CuyRd+sJQ3yc6KFh1Gig27wO0noNxHOGm9egnvtuoesZMzMgCQ4Rf0tUd/LrZmY4tgw9rjLll5d4eYnl6Ga+L6i8YIyNKXK7c3LVOH7iHKQxKWiQml4uAb+1I/62/K3WqRGdFYMVF//A4dgj+Lz3AkT418SXx7/G5htbxDJT272A/nX6YmfULnxydGGZbw/zHFXbtcNjhw4h9/3XxWhWTyyj5MzZi8i9chN+Z86XS8CPyygrT+P27YPm9yXQ793hFmXUdEcCxZOTIa1dF+qFcy0XZkW5ceM2bsadhOT8FdTo2pUDfsyuyGf9LH/naI24kW7Al0c02BBpmnNh16M+iAgoPOlG/UWZZfoN9/nsM+iPH4Hm+6/sLuuudWlySprpfPfTT9H5jTfLJeDHdSkrL83GjkXTEcOR+8pzblNGS1qX6nQ6UUYlt5NQJz6RA37MrerRoIYNxTWpet4sGKKueew16YULV5Fx4RqUx06WS8CP61FWnh7atAna1X9At2WdW5TR0lyTRt2KwZWb0ZBejUJoq1Yc8GNuVZey8scBvzskUqnpJpEU+4VJqteEtF5DqL+YD+VTz4o584xxeSdL0jr1oXyxYNAwd9ozoocGLU/zA0nbdoQhLgZG6gFCJ15e3kBqSpHL6C+chbRpc0giakPapDkMZ0/DmJhgqpzadoIxPR2SsHAYNqyBK1hw9DMEewXj8WaPYkbHlzBh40R8fvxLzOvxIZ5sMR6HYg+jtn8tEexLyU3Bt6e+d/YmMxcnyqZEYvm/yOW4jDqEyyhzVl3qSmWUUE9OWev20Py0CMbsLNNr5d7pAc1YGXp5ay7CfSSY0UWJhf28cHBpFpJzgff3qOGjMJUZqQR4q6sSVX2lWHdFW+bfP5/vli2uS1l5lFG42TUp4bqUVZp61HxNKr1zXeoGZZTbjVhlw9ekjLl2Xco8IOCXnp6ODz/8EH/++Sdu3bqFoKAg9O/fH7NmzUKDBqaeE+5Efm9PGJISYbhwFvrjh6EYOASG6NuQeHtD3/qUOPFSf/B2oevqD++HtG59KCdPhTE1BZoli02v2fd+KAY/iJypE4tcRrt6JZQTJkM1/S0Yrl2Bds2fgNEIzZJvoKTGyslTod+93ZKD2tn23N4HrUGLnhE9UD+wHsJ9wnEh+SLWXFmLBxuNwPNtp4iAH/n65LfI0Nr2hmGstLiMchllrs2lyiit27WH+F81aappuXV/Q7dudQV9Gyw/o9GIpKQkZGZmws/PDyEhIXYbvt3F+qs6aPTA0EZyNA+ViR6UybkGbLth6lVJZnQ2XVhdTNbj9e3F9+ytNOWUz3cZc+0yynWpS+F6lOtRrkcZs4/rUcZ1qetfkzIXDfhRsK9Hjx44deqU5bH4+Hj89ttvWL9+PXbu3IlWrVrBnWj/WgbQjf5e9rO45WdMyMvbbMNggHbFL+JmjRoWrRsXC1sGGenQfPlxwfe6HlnkxZwz+Sv9EeIVjGo+4cjQZOBWZpR4/Jfzv6NTtY64p3oXcX/nrd04EHPQyVvLPAmXUcdwGWXO4mplNOe5J0r5SVhZSk1Nxc8//4wvv/wSV69etTxOncNefPFFPPHEE6LTmDur4iURvSlrBUiRmmvE1RSDzfP968rwbHsFMtRGPLcxF9k6p22qy5VTPt9lzLXLKNelzsf1KNejAtejjDmE61HGdanrX5Oy0is8OWsZef/99y3Bvp49e2L16tWYPHmyuJ+SkoKnn34aruL2vn049s03OHnyHDIyODft3fr5/h+w4L6PIZPI8MHBucjRmdKj0ag/GtFHcnW5+Pbkd3f9XqxyyLh9G0c/+wwnDhxBdEzxc/gx+7iMsvJw7IsvcHzDZly6FMlfMHPYpk2bEBERgenTpyMy0nbfofv0OD1Py7mz/eN9sfohH8glwOSNOciyyo5SL1CCT/qY5veYsS0X19KM5bINl1evxrHffhfnuzpdXi9OVjpcl7KyFnfsGI5+9ZUoo6mp6fwFM4dwPVpx9Wh2QoLpmnTPATGHFrs7XI+y8nBy8WIcX7sO5y9c4S+YOYzr0oqrS5mLBvy2bt2Kjh07wsvLS/S8/uqrr7BkyRKRcoluFOjTaDT46aefxPL02PLlyzF8+HAsWrQITZs2FY8fPnwYR48ehStIOHkS5//4ExcvX0NWdo6zN8ftzT4wB+siN0AlV+GFts9BKVVanovLNgVrcnQ5nMqTOSw7Lg7nfv0VF0+fQ0JCMn9zXEaZCzr/+++4uHc/bty87exNYW50YTV48GDk5OSINGR0s2Z+jJ6n5dw56PfMhhz8ckYDb4UEH/bygkpmetxHDiy63wv+Kgm+PqbFf9fLLxB3c9s2nF+/UZzvGgwc8LtbfL7LylrS+fM4v2y5KKMZmdwJldnH9WjF1qPq1FTTNemJU4iLS+Rd9C5xPcrKw6U//sCFnbsRee0mf8HMIVyXVmxdylwwpeeePXvwwAMPQKvVWnpeU6qlNm3a2Cx35swZkVaC1K1bF9WrV7cE/7p27YoLFy6I+7t370aHDh3gLuSDR0A+YDB0O7dCt2p5yde/fxjkvfvDmJMD7cpfYDh32rFllEooHn0aspatYYi5De1P38KYlABJWFUon5gMSfUa0J85Ce2vPwJaDZztePwJHIo9jDoBtdEytAWGNRiCPy+vcvZmsUqAy6hjuIwyZ3G1Mirr2gOKYQ9BEhgEzbIlYj5cVjHoPHHUqFEioGcw2KYSyY+el0qlYnnznNDuZneUHluv69E4WIYuNWR4qrUCi45r8VFvlXgsPsuAKykGDGmYd3q+9boOObrKXUZd9VyXcF3KnMXVyinXpc7B9ahr1qOuWEZdtS7lepQ5i6uVUa5HnYfrUtetS1kFjvB75ZVXLMG+fv36Ye3atZg9e7YI8Fm7fv265e/w8HCb56pWrWr5+9q1a3Anuq0boV21Aop+D0BStVqJ1pU2aAzFsFFiLgTD6eNQPjlFHOwdWYYmUZc1bwn15x8BegMUY01zDinGToBRrxePy5q3grzPALiS70//CIPRgFGNR8JP4efszWGVAJfRkuEyyip7GTWmpkC7eV2ZfkbmGJqzLzs7226wz4yWo+WXLl3q1l/xB3vVMBiNmNxOiUAVMLihQjxOE6N/1s8LX/TPuwV7S1DZy6irn+sSrktZZS+nXJc6B9ejrlmPumIZdfW6lOtRVtnLKNejzsN1qevWpayCRvjFxcXh4MGD4m+VSoUVK1YgODgYQ4YMESP2fvvtN8uyWVlZlr+V+Q581vetl3MLubnQHzkAPPI4ZJ26Qrfub4dXlTZvBaNaDf2xQzAkJ4oDvbReQxgunrO7jLRZKxiuXYXx5nUYzpyAfPjDgFwOaeNm0P3zh+nx65GQtmgNbPoXzjJ09YM296+mRWL4P6NsHovPTiiwHGNlhstosbiMMqdzpTIqlcFw/gwkcbHAw4+W0wdmhaFRfV9++WWpvpwvvvhCZJegrBHuoP4i27R8ZxMNaPhNVpHPO50rlVEXPNclXJcyp3Olcsp1qVNwPerC9airlVEXrEu5HmVO50pllOtRp+G61MXrUlYxAT/r0Xg0dx8F+8w6d+5sE/Dz9fW1/K1Wq21eh+b3K2y50oiJiRG3u3Xx5k1cp17mWh2CU9IQIy168GPVVh3QEIC2bQdc/G8TGkx+AcoqIbjyv4XITYhHu4VfF1jn+PTnECFXICQ3B8cTkuCt8kU7GglpkCApIcmyXP0ilqnt44Os+DhcSkhCtaRk1JdKcSZHg05SKaISkxCbkITG6enwqV0HJ6xez1p2dg4SFApI/Hwhy86G17Fjdr+XS5cuif8NOgPSrppStDpDVpzpIKTT6XDMge1mnjmniamMaoHMLBiK2M/duYySGJkUWm8fZCiVDu/rVC5IRlQGDFrHRsqUBzpOkPPnz0Ov53zfldG1rCwY1Gr46yQIdYcyqtZAm5oKFWSg5OJRGVmIK2a7yQ2dDgleKkgDAnDq/Hn4JPL8LaWRkpKCq1evluqijNbbvn2709J6mo+5RHPrNKReAXC2U6dOoUqVKnaXuxwfj3iaL1Grw4nEZCgUpp6cnlSPxmdmm853/QNwKTYWWQ7UpTdu3BD/a7O0Tj3fzY7PFv+npaXx+W4lFXntmuWaNCA1HYkqVZHLumtdqlFrTGWU2gHUat7XK2E9SqKjo8X/+sxEqG+ecNp26FJN25GYmOjQvph+p93IqNFCk5UNmTuc75aiLr0tlSBX5Q2Fj4/DZTQ3N1f8n3k7EzLlnYmKnUCv0Vvasvz9/Z22Hcx5ItPTRTu0l14ryognXpNe12iRoFSKa9Izly4h4E75Y5WrLjW3u2miz8GQ7bxrGOOdueHPnj2LjIwMp21HZdC+fXvHFjSWwP79+420Ct2aN29u89wXX3xheW7mzJnGo0ePWu7XrVvXZtknnnjC8tzChQuNd4Pey/xaFXWj7+Hy5cvi/Tt16iQe++mnn4wTJ040ymQyY4MGDQrc6PHZs2cbs7KyxPJdunQR6/fp08fmtYtaZvfu3cb169eLx19//XWjXq83KpVK8f9rr70mHt+wYYNx165dFf598I2/A1fbB7iMOv834Bt/B+5QRuVyubhfp04dsdzkyZN53+V9l/cBFyqjfK7L+yMfk7gu5X2AjwPuug9wXer834Bv/B24Qxnla1LeT/lYxfsAHPwOHFWiEX716tWz/B0ZGSki4ebexOZUn2YtW7ZEYGCg6KFKvWZv376NmjVriij4gQMHLMv16NEDd2Py5MkYNmwY7tbFP/7Alb/+giEhHu3btUBISOG9pL0jaqPdPffg7Ox3oJ32Kla99SrUCfEIbtsKTTatxpRnHke7z78tsN7xaZOh0mbCx8cHFxZ8BP9GjaHLzMSHNaoA40ZC7ucHTWoKAopYpsbtG6g+eBhOvDYN9Z54HOlnTmL7sP7IOHcGb08Yj3FQo3n3bohe+zf2PjS42M+qfHwipBG1HfpeqFfU2LFjseSXJXh49GiM/m4M0nPTEeIbgul9p6FjnY7QG/TYF7kPn239AlmawlO0rpi4DNUDbfNiv/XPO9hzZa/4e3DLQXisyziE+YUhOi0a3+35Abuv7BHPvTf4HXSu3Ql1I+qK/Wfr1q0ObTvzvBF+Bz78EIaEONStWQ2NGuUdjzytjMp79IG8+30Ofzd9+/bFggUL8Mi4RzD6+7GijN7ffCDGdByN2iF1IJfKMGfjPGw8u6nI1yhu+ftbDMRb979R8DuLOoFpK6ejU51O+PSh+XjmuUn4ftF3WLZsGRo3buzw9jPPsf6JJ2BIToK/TIIuXagfo2uX0Z0jBkLuHwDfOqbjyVu9e2CiRA1NYkKxn1Naqw6Ujz1dRt9a5UTnkDQXdGnRuYCzelPWqlUL3t7eqFOnDpTjfyl0hN+isU3QpW4gwgNMaexrvmk6pylM/VAvfDuuGeoEe4ESTNxOUePH/TH4+YBtBot2tfzw9+TWUMik+GpHFOZuuoHoeT3w+++/46GHHsK5c+fsjq4+NH8+4g8eFPOE3NerS6Ej/DyhHiWq196DRObYpc7q1avFnOS/rfoNIwY/WOrz3XGdxohz2ppVakIqkWLqipdw4tZJy/O+Sl9M7vEMejTqAX+VH5KykrBo17fYcWmnpS596qmnxFQJX331lUPbzjxL5Pr1OP/rrzDExaJ1qyYIDw8rdDlPqEsVox+HrEGjMvrmKh93rkfJd999h2+++QZLV2/ByPt7o8v8w0jJ1uHh9lUxuUdNNArzgVwmwfQ/LmHlsfgiX+eL0Y1xX6Mq8PeSIS1Hh11XUvHOmqtIz9XbrY8f61wNHz3YEL1790ZAQABmzpzp0Ai/3W+9BWNiAmpUDUHzZjQ+yEOvSTvdC3m/++Go4cOH4//+7/9srklLWo/WCa6Nl/pMQ8saLZCjy8V/57fi652LoDPooJQrMWf4B2gS3hiB3oGISYvFI9+Ptaw7qftEjOn4CNp374DTB05h8eLF6NCBxkuxymbLs89CHX1bjPDr3q2Tx9ajkrBwqCY+X0bfWuXkznUpXYvSdGv0v3z0IsiDahRYpn+zYLwxoA7qhXojLl2D/+28hV8PxRb7ugFeMvw3rR1qBnnh2M10DF10Sjw+tFUo3hhYB9UCVNDqDbgUn415m25gX2QaYhY+gL3bN6NVq1aWTIHMuUoU8AsPD0eXLl1EcI+G648ZMwZTp07FyZMnsXz58gLz9NEF68KFC0WQhoJGr7zyCtatW4eLFy+KZTp27HjXFXD16tXF7W5JDx6EzscHBoUcLasEolpYSKHLKYYMgyEpEfVjoiA5eRQRIx4WjxuuXUGHwUOhP7AHmg/fLrBec8pokBAD7b9/o/HEKTDm5kK7dDHa+PtCdk93KMc/g9xZb8AYV/gyOLATkoYN0fr9OTDGRkOzfAnahYVA8uevUD4xSTyuP3sKVQ/uRtUitt1M1bIFpPUdu7iSyWSi4f6xsY9h883/IKkpRSCCMKvbTLQMbYGVF/+Et8Ibw5sPhdJfhQVHPyv8+1VIcTM9CssvrrQ8dlsVg8AGQWgZ0gKv93gVV1Ov4rszP+LBhsPwf0Pfx/PbpuJ2ZjTWx25Cv6Z9MWPGDHz22WeOD19lHiUOQKwoowo08fNFGw8uo/KGDaAowX7epEkTjB8/HuvOrbeU0So1quB8xkUYFUCDoPrwqeqDwNyiT0SKWz5Seg3zD39qWXZg3f5oE9YaV3MiRRm+hMuifL/31rv48dsf0KxZM7Rp08bh7Wee47yvL/RZmQiSS8T+7w5lVD54BBSDTfPK1n7kUdRs1x6az+YV+zmlETWh4rrortC5IaWHpw5k9LejaN6++vXri8Y5Z83hR9v77bffIjk5GbUjWkHmU7CTmMRbhT8vG/H8ndNcVe22Rb6eIlCC7dEKXD+vRZBKgmmdvDFneAMczamOyymmVMm+CuCrh32g1kugkAHygHCoapvel8616TzbkeNuStWq8PH2hjErA21DgwvMs+0p9Sjxat/e4YDf8ePHxfnuI8MeuavzXf+wABxNPg6llwrhPlXhW9MPgaq8uvejHnPQPKQZdkbtwomEU6jqE4aA6gEI1Jvq0sjYSLz//vt49tln+Xy3kvI6fx45d65JWwQFoJYH16XK5s0go3nEWKWrR0mNGjXEcXfckD5YcUGP7NCWoAS2AeFyHEmUwiAzoEWYDPKQ2lDVLtiIaXZLp8Rnx/TI1ekxtrkCo9pVRZIkCPP2a+zWx//EA29m5uCDDz7Ajz/+6NBxN8XfH1E+PjAqFajn6+M257uluiatX69E16R0DUjXpGtP/luqepQ6ynzUdy5CvUPx6/nfUT+wHh5qPxJ6X7247yXzgl6px67o3RjaYIhoY6JrUbPNyVsxVjoGb7/2NsaMfETsX9x2VDldDQhATlIifPSefU0qqVFNnO+yyluX/vDDD+KaNKJGcyhC69o8VydAgu/G+CA2y4jZezV4uKlCdHKJltXE3ttFdxL9pL8KgT6mayiJytdSb+qCZFhxSYr4bA2ah0rxdJsALHqsBTovyYZEKhPXpCtXruTjrjsG/MjHH38sRpNotVps3rxZ3Ejr1q3F/CHW6IKVot30+O7du8XNjCLgdFLlbrR/LQPoRn8v+1nc8jMmFN0DTbd+tbhZo4ok58CeYpeh+Q20P3wNbf73io+D+uPZKE/PPPOMCPztum36/Wr710LrsFa4knoVv10wfRfda9yLnhHd8f3pH5CuKTxfb5omDUfijoieWtYG1x8k/v/twnIcjj0Co9GAF9o9h0H1HsB3p3/A5dTLiE2PxcSJE/H555+X62dl7q8yltHHH39clNFtl7YDd6ZLWH9to/j/1Y4viwCePcUtH5cdL25EJVPh2TaToNVrsTYyb6L3vdH7MLbpI7j/fsd7gbLKydXKqG7danFjFYsujF588UVMnz69xOtSZzNnXljRe+fv6JbftP/UoOlrnu9QMKCW3/U0IxYe1iBQBVTzleKpNkb4KW0/3/s9qCcl8NtZLSa3s33Nw4cPi5F9VA94YhmtiHq0rM53zR3bmgY3EQE/a61CW4pg39nEc/j06GeQS+XQGmw/7ZYT/2Hy/ZN4RAJzu3LKdWnFc+d61Pa4K8XaK2rLY7+eNc2T+3k/lQj42fP5EQ38lYCfQoIuNWRoX00G6zbb4upjjQHYcOgixvbpho0bTddCnlpGK6IuHT16tKhHaVQefEtej7av2g41/GpgX/R+/H3lH3Hd2b1mNwypP0gE/HL1uZhz6CNE+NUUAb/8UtQpOJ90ASMGDXdoXmNWublaGeV61DncvS79888/i3xubAsFFDIJfjipwe/ndLiZbsTSod4Y30pRZMDvoSZy9Kkjx9z9avxfTy+b57bd0GPPLT38lRKkqY14Ol9f07Vr18JgMEBKKWuY05X4V6AUnOvXrxcRW+oVXLduXTHqqrDCQWkRKMj36quvinSgtHzVqlUxbtw40ThBQz1dhV/NmqjWvj3Cq4ZAqSyY3sgTZGXnYPeew9g++0OcX2aq2BzRv39/6HQ6XEq+LO7X8DONqEzIzhtenpCTCJlEhmq+tmk7rbUIaY6VQ5bhr6Er8Gbn1xGgDMj3eoni//gc0+vW9MvryXcm5qwYYUqpYlnlpPT3R7XOnRFeszr8/XzhqQ4eOoGdi7/HvlmzHF6nV69eooyeiz2P8ta/Tl/4K/1Fg2hyborl8fNJpvceMGBAuW8Dc13VOnVCeIN6CA52Xoqo8nbxUiR2rV6HbS+9hKz4oi8CmX1PPPGESHXj6EUBLUfLU+9xZ6Len+ZU9nIpUMUr71baS76GVaQ4+qQf1o32QZiPBP+3R20Z3TekoVzcXvovF7mmdtACqCOeI4KbNEG1ls3F+a5E4pkXY3Fxiabz3Zdfxu29ptTxFXm+W5SGQaa0b1W8qmDlkN/x59DlWNBrvmgQNTsRaUr/ySMSKi/fatVQrWNHUUa9VDTeyfOo1RpRRnfMm4/TbtgB2JW4az1qe9zV40Rc8emo7fl1qDf2jvfFQ00V2HtLh6+PmUb3OeLQhSjxf4sWLRxaXu7jY7omjaiJABqt46GOHjuNnT8txa43Ck7rUJRu3bqJevRs9LlS1aP5l1fr1UjXpMNX4YsgVaBD23Au6bxIcUfXx6zyqtquHcIbNURoSDA81dXIG9i9fou4JqVUw6xy1qUUWynqmrRuoOnzRGearilv3/m/XlDhn5NGBL7XXYU5++k6tPDRjo80U+DwBF98P8gbyTlGvLApb0APZYJUq/M68DA3G+FHKL/t0aNHbR5bsmRJoctS0G/+/Pni5soaDhuG+t3uhfrdGfBUdPIVExsP6ZGj8K5nf8SPWcOGDZGUnASNwfET5/z+u7EV0ZnRyNWrMbjeA7i3xj3iBK6wVA6SQprLEjJNwUAKMLPKqUqjRuj/9dfInfkajAmU4NMzxccnIjctC346x9MJUIeKpKQkaPQaqGDbC6csUdkc1mCo+HvV5X9snkvMTRL/UzoEVnn1/fJLaH5fAv2e7fBUqanpiIlLhCRbDX2u7Yh1VjKU7eGvv/7C4MGDxYUT9QgsCj1PPShXrVrl1DmHrC9oSMcaKqx4xM/yeI9fs3A7w/Hjt1lUugHj1+agpr8EMzorxUiEbTd0SMk14oOeKvx+VotsrVGMAiQBKglCvSW4dmf94r47a+2efx76e7tA892X8FQ5ubmm8929e1GzR88Sne+mpKXc1flucQxG028U7FUF/zvxDWr5R2B0k4fwUvsX8fLO18Rz8amm85uymK6Auac6ffui9r1dkTvjWXgqOl5RGZXoj0NevehUjcyz61HzcTc5PRNq/d2NUH93txrhPhI82kKBnrXlIvD30ynHOsLcTkoX/4eFFT5fZn7+NWuKa1L1vPdhuGmuhT1PQkIyMhJSoczMdngdmkdKXJPqyq4eLaxtqDhJfE3KqEP0/PnQrv4Dus15GYk8TVpaBqJvRkOq2YPWkyY5e3Pcmkdck9byxR/jba9J87N3NJ1znwqXkg3YE6VH23BTvayUAhH+Ety6c3275ZoON9IMaFNViqkdlXizqwoPr86xiTswNw74sWL4+kF+Xz/oTx6D8VbxvSxk9/a05GjWrl0F/YHdpVqmIljnMo7OjBH/07wjZmHeYdAb9YjNMk3+qZAqYIRRTK5MrOfuS8lNRfvwdqgbUMfyepSfnV7vevp1hHmH3nk8Ou/9YTrgOnu4NPMAlaCMOoLKKMmfTqw4XWvcg+q+1XA07hhuZtws9P25jDJXKqOSajWgfPo5MaE5zVmm++dP6A/t4x/JhQwcOFDM7zxq1ChkZ2cXOJ6Zjyne3t7iwsrVRhGfS9Dg8TV5FzkJ2faPxVKJqRemwQjo7lxP5uggUqSQFqEyPNZSgf715NgYqRPBvSdbK8XNbFwLBUJ9JBgIJ/HUuhR3d75bnOgs03nt9fQb2HFrJ3wVPiLgR+nLzAxcl7KywnVppeHu9WgJL2FEek6isRoUeCreVJnGZRtFwG90U7nDAT+jwUnXMJ5aj95Fu5F5+bA7KbEppSdllsnSZiFVnebQ+3M9ysoM16OVirvXpefjcgpck15PM9WNNf1pRJ8eNfxMI/vMj8skgEwK6A2A3gjU8pciIkCK7Y/mjV6n1Nr/PuyDtj+aAog0H2Bslh67ovQY0lCBNuEyNA2W4moFf15mHwf8ypjEz1+caBmTEqEv5sRNEhwKxdgJ0P29QtxXPDoBhotnYUxJLtEyFYEmL6UJmOlkjIIDNzOicCbxrJiH5NGmY8XkyyHewdgRtVPkYacTuh8GLEZKbgrGb3xKBPaeajlBBAmytNkiJaB1CsD11zage817Ma7pI6LX84MNh0Nv0GP9tU2WbQjzM50kXr9+vUI/O/M8nlhGb9y4ISYlV8ry0hE3CKwv5uIzp0tpEdJCpE/ZdWuPmP9g1TBTEH7kmtGiXNtbnlDZJKsuF5zvjCZXNx8vIiIiKuBTM09VlmUUCgV0+3bCcP4MFA+OgeLRJ6E/doi6nlXER2EluMC6desWli5dii+++AJXr+ZdMtBk6DQ/AqVaCQx0LJ1TRaB0UZSyJF1tLHQOhMEN5JbReGR0MzkSsozYflOPBxvL8XEfL6y9rBVzCz3XXoFAlQSXkw0I9pZgaCPT6fmFRAOScox4flPexdugBnIMbqjApkgdFp/I60Ff0XMleGJderfnu+b09ZSSPvBO6rFO4R1Rw7c6Nt/4D8fijovGTKpvhzUYgpp+NcUyJxPy5kAPrxIu/o+NNTWEMlZaXJdWLu5Yj+Ydd5tDKcuxBPBahErRIkyK2gGmeq1zdZlokPz3sg7ZOuDCJNMIhqaLM0W6sumdlNh3Sw+13ihG9pHzSQaH6mNSM9T0nSQk5KWdrAieWI9GRUWJbC9KmamDUknr0WPxpnqyY3h7cd1ZL7CemO/W+tpzQJ1+CFKZRtV4y7zE/duZ0TibZEojau48TvsWY3eD69HKx12vSbOyspCWayhwTbr8nBZPtVaIm0ZvxOg7deTS06YOMS90UGJaJyW+OabB/IMaMVre506UqFGwFC91UuFaqkGk+CSf9VOJ69WYLCOah0jFMllaI26k59W5cjmHmVyFZ07e4UTKF0wpQZXjn4Fq9idFLidt2gISmQy6Q/ugO7wfEpkc0mYtS7xMRdi8ebMotI2rNLI89smRhTgUewQjGg5D/9p9xUnbN6cWF7p+mjpdpBoc1ehBPNdmMkK9Q/DPlTX48awpDezpxDP46vjXIjf7pNYToTcaMP/IJ7iVecvyGi2qNUd8fDzOnDlTAZ+YeTJPLKM7duwQZbRpeFPLY52rd8KL7Z63lFsKtNP9AJV/oa9hb/mmwU3EjSZdP5V4usD69Jz5eMGYq5RRY9QN6LdvgTE2BobIy5AolIDSM+dEcneUEoUuoi5fvmxJZ0j/03163JUurKiHZ+fOnYtd5vV7lPigV16K5Xn3eeGZtnkj9KwlZhvFaL7ZPVUilefNdANe3ZYrLtpozr4NkXrL7cqd+RTo4ut4XN7FlUJRsfNPe2Jderfnu9Z1J42GJyMbjRD3CY1o+ODgHJxLvoDxzR9D1+r3iJT3Xx1fZFm/Tb3W4v9jx46V4ydllQHXpZWPO9WjtsddmUgNZtavrlzUmTRqgDzcTCHuV/EuOAIvU2NEVV8JXumixKyeKlT3k+CXMxq8t0vtcH3cuampo+LZs2dRkTyxHt2zZ4+oR5vVaFaqepRSX394cC7OJ1/EY83GoUN4e/wbuR7LLpoCmYTq1MebPyr+DlAFiPvmDuXma1KNRiOujxm7G1yPVk7uVpd27NixyOeup1HH0Vzk6IyY2V2FEG8J3tuVa8kqk9/Om3nXnAejTdeZqWojtl43LZ+mNoosNHN6qTCisQK7o3SY8G8OMjR5wUe6MddQZqHXCRMmiJu7urByJS79/jsMZ06gQ4fWCA2pUqrX0S75FqoZ70Dz5+/QHzkArwXfFlhG879PIfG/0+hOE1pK8nqQWHNkmYrw3Xff4aWXXkL3mt0sPacoNzqdjBUmPjsBQ1eb0kmQFHUKPihiWbNNN7aIW2EaBTVEjcAamDdvnsNz1DDPk3juHPbPmgX9mZOoVz0MjRs7Pg+lp5fRX375BZMnT0bvRvfh2rWfxWPLLqwQt6JYl1FHlr+QfLHAOtbo+HDr9i1s2LABH3zwQak+B3N//44bB33kFfhrctD1nvZOL6MWgUGQ9+oH/bHDQHbBfPYMLhVMM49WM8+R4Goovcvo0aOxe3fR6bJ6/lb0nDd/XdThr4uZlvsrL+jEzRGfH9GIW/4LPZnMsfmPDs6di7jt20QAvHfve6EsZaDQE+vSuz3fJZ8d+1LcihKVcQvv7H2vyOf7t+0nRkgcPny41J+Duber69bh7E8/wXDiCNq0bo5q1RybVyw/rksrL3eoR22Pu9PFKLzDMZoi6zlr9Rfl1Z/RmUaMWpU3Cr6k9THNTfRA56Y4cOAAbt++7dA2p9+8iZ2vvgr9+bOICPZHi+aNURqeWI+uXLlStAn2bdYbS6J+KVU9SqMCi6sni7sepZF/NNL+739XIzm5Ykc3MteyedIk5Jw7A6/0FPTsXnwnvaJwPVq5uUtdOnLkyGI73W+5rseW64XXk8XVtwej9Tb1LZm5WyNuRRk6dGiFZ51hReOxlnfkJiUh7fp1GNIz72qSSWPmnQJBDYrpaVDPfbfgMqkpkISbegrAy4uOJHfWzbBdLiPD7jIV4eLFi/h9xe8Y9fBD+O38MmRqbQt9eRvecBgycjPw8ccf88GjEtPn5iL16lUYUlKRUyWg1K/jiWX0ypUrIug3etxorLz1V4WX0XZV26JOQG1MeWcK9PrCewuxyiEtMhL6+ARI5BKXKKOCnz9U016HMT0Nml++L/V2MWbZ/4xGkc7lvfeKbpCqSC+//LLoEOXIBVZmTAxSb92GMT2z5BMnVYLz3T82/IlhA4c55XyX6tKG1Rvi6aef5g5ulZg6NVXUpXRNqtU5Ps9yflyXMndAx93lm/dhZN9uWHhYg7S8gXkVYlRTOar4e+Htt99G3bp1HVpHr1aLa1JjcjJyvAsfuV9Z61FKoymuSceOxp+xf1d4PUrpsmk+wDmfflih78tcT9q1a8iJjYNWX3Rwwh6uR5k7GDduHN588024gunTp4sR1kpl6etGVnY44FfWtKYKRRIaZmpkfKfgyYbmy09MOdUNBsi7dBMNLka9HoYLZynhrVgPmRlFL+MEz7wwCSt9VjnlvT85sgAZUemil1ZoqCknO2Ol5qFl9Mknn8SS9F/gX7v0wdDSOh5/QvS23PLrxgp/b+aByrCMQq6A6sVXRRpPzY+LaJZtQK/jOfzYXaGODQEBpmNtxfefL/xCr1+/fggLK91IoFLx0Lp02qxp+E233CnvTXVpu2kdcOLHY7j//vudsg3Mg3BdytzEs3N+xLvX2zrlvZed02HRwllI2bYNTz1lmou1wnjwNel3MT8iuFlIhb/30nO/itvlyCsV/t7MA3E9ytwApRulOfx8nb0hALp164ZLly6hUaO86RGY83DAr4zRxMj6c6chHzgU0oZNoP7g7YLLpKYAWi20y5aIiZoJ/W1MToK0UVOopr8J9VefwHDudKHLMMa4jDLmqcqyHqVlpLXqiOe93pot/lcvnAvD5QsV/KkY8yx8vsuYa+O6lDHXxvUoY66N61HGmDvjgF9ZMxqhoUZGB+j37hQ3a9QImfPcE8UuwxjjMsqYxyrjetT6b8ZYGeHzXcZcG9eljLk2rkcZc21cjzLG3BgH/CoRpUKBhg3qQN6zL8I6dSrRukZD6ed5KQvm93fViVIZKyt160ZA37ApvDt3LfG6XE4ZK3/h4aFQVqsOec8+UPj58Vde2RmcN2+p0eq9+fwoj7+/n+l8d/jDCGrQoITfKZyKz3dZZSCTy0QZld3bEyH33uvszWFOZl2XOYXBdODnetRW7do1oImoC2XHLiX+SvmalLHyFxYWAklAIOR974dXlSr8lVd2Tq5LzXU516WuQ+rsDWAVx9vbC+3btUSnyc+g/gMPOLROjRo1xP+aNDXijsbCGYxGI25sum6zPYx5qlYtm6LjQyPRdsoUh9cxl4sbm6+L8uIMdHyg44T19jDmierWiUCHPj3R+bXX4B0c7OzNYU6gUCgscwpn7FnitONuxt6fxf8qlQrBvC9ahAQHifPdzq++gvB27Rz6Ls31VvLZRGTeyoAz6DV6RG27abM9jHlqJ1RxTfrUk2g0YoSzN4c5Sc2aNcX/OWc2Qpdy2ynbYMhJQ+bRP8XffNy11bxZI3QcPhQdpk0r8W96k65JndRhPOlcIrKiM8Xf/JsyT1Yrojra9+gqrkn9qld39uYwJzEf5zL2/Oi0a9KsY6thVGda5hRkroFH+LFiUYPW8OHD8c8//+DwBwcg95FDIq3YUXb6XD0MOlPPu6effrpC35sxdzBx4kRMnToVNzZcQ9SWG5B5ySr0/emCTpetE3/T8SIkpOInaWeMsYr0zDPPYO7cuUhZMwupmz6BRKas0Pc36rWWC6unnnoKUin34bsbXbt2RfPmzXHu3DnseHErFL4KoIKTSmgztZYA7qOPPlqxb84YYxVswIABqFWrFqKiohD1dlNIvYNoaECFboMhO0X8HxgYiFGjRlXoe3siaqvZuXMnbu+6hei9tyH3ljvtmrRPnz6oW7duhb4/Y4w545r0tddeQ9p/XyB952JIFN4VPrLPmJsu/h47dix8fX0r9P1Z0TjgZ/4ivL2BO40lSUkpqBYeBk+j1eqgUMgBLx+H16HhuCtXrsQjjzyC1atXW06gKhptx8cff4wXX3zRKe/PXKSMEqlUlFHqveJpw8XNZVRi/qwOonKh0Wjw6quviuC4IdM5OclGjBiBFStWeNzvwkpWTvVSKdLS06HRaKFUKjzq6zMYDOLYI/V2vB5lnunDDz+EVqvFJ598AqM6C0ZkOWU7Jk2ahK+++qqE57umY3RSciqqV6sKTyPqUh8fSGSOX+YEBQVh+/bt6NevH06fPg1tlin4VtG8vb3x999/o3fv3k55f+Za16SJiSmoFeF5oz1Le77LPEtERIQ47vbt2xc3btyAISfVKdtRpUoVbNq0CW3atCn5NWmy516TyuUyqpRKtN7jjz8OtVqNKVOmQK/XWzqyVDSqy6nDulzOzZ2VvS7NSs9Bbq4aXl4qeBI67lAZU/I1aaVHbYB03H3vvfdg1OaKmzOMGTMGS5curfS/hyvhGvCOgDp1RIUguRONPnrsNOLjkxzKbd6ieWObxzZt2QWD3n6DO6UyobmAzKjh5dChEw79cAP694BMljeK5+KlSERGmtIAFcYIIzIzs3Hf+EdRO7waSkKpVIrGh7S0NMTExKCi0Yka9f6jHs+s8vKPiICEyqh/AGjXv3Y9ChcvRtpdz9fXGz172M49cOToaSQk2C/fdWrXRPPmjWwe27h5p0MpSjq0b4mqVa3Kd1IKDh0+Wew6GZlZaNmpHdq16YCSmjFjBl544QXRS1anq/jAPA3dp96xrHLzr10bmuQkqAw6JKek4vjxsw6td1+ve0TaabPr12/h/IUrdtfz9fNBz+6dbR47cvQUEhKS7a5bp05Nka7I2sZNO2h+9iJl5+QgNCwEfZ6dbvf1mWczd0SaNWsWbt26JYLBFf3+1Fha0l6UdL4rUXlB4uUlzlW379iH3FyN3fVatWyCiIi8FC0ZGZnYs/eIQ+/Z+76uNg0t165F4cLFq3bX8/f3RfdutnNOHz5yUgRBiqLT62HQ6zHg/ZkoaSihatWqOHmSXj8RSUn2zxHKmpeXl/hNuYGycguoXVv8T+e7VM5PnT6P27fj7K5XvXpVtG3T3Oaxbdv3Qa12oHy3aoqImnnXh+npmdi7z8Hy3bsrvKyu0SKv3bR7fk7nuz0eGoF6EXUceg/muRo0aIBr164hNjZWtDVUNKpDKQ1lSUbJ+1arBplSCZ1fAORGLW7ejMa585ftrqdUKdC3dzebx06eOo/oaPvlu0aNcLRp3czmsa3b9orOdfbQerS+WVp6BvbtO2q3jDZp1QydOtieYzuaeWb8+PHimpQ6RlW08PBwEcRllRtdk2bevAGlRo309Axs37HfofW6deuIAP+8Odpv3Y7F6dMX7K6nUinRp7ftnLQnTp5DTEy83XVr1qyG1q2a2jz239Y9IvBelJzcXAQGBqDv+Gfsvj7zfO+88w5eeeUVcdylQHBFonNVSivq7+9foe/L7OOA3x21evVCwxEj4BMaihYtmmDnx58gM9F+LzOayFjez3Y+vKxt+6E32m9wN7btAHmLvAszSeQ1ZB457cDPBsj73A8Zjda7Q6fdjMzrxeW+l0BSJRh79x2G3+XLCGlqW6E4ghrzuUGfOYvS3x/3vv8+rm3YgO5PjseVZb8j8/INu+tJfAMKlFH1zXhkJjlQvmsXLN+Z/+2FEfYbdo1tO0HePK+cGa9cRebRM8Vva2AQzt1OgO9/W9F09GiUFAXFGzZsWOL1GCsr986cib3vvotuL02D7vQJZJ60f4FEpN17Q14lyHJft3svMi9ds79eIeU790YcMpPsNxrp6tQvsG7G5j2ApJiIn18A4o0y7P3ld/RuW/LAPPM8Pj4+aNzYtuOXK2s5YQISTp5EkxHDUUMOHH/9LeRo7F8YGlq0hrxTR8t9SWwcMvcfd+g9pT16Q27VIUS/czcyL5vmZi6OrLDyfS0GmcnpxbyZHPBRYPvfazFk9DioAgJQ0ovWsLAwcWPMGcI7dEDzxx4Tgeu2XTth/+dfIDMm0e56mmoRBa9J9x1HrtaR8t0G8o7tLfcl0THIPOBY+Zb17Au5VSOPfscuO+fnpmvS/UdOwffMGYS3z3tfVjnRcZc6DrrLvD9SuRw95s7F+d9+Q89nJ+Pm36uQ6UAnVJXSu0AZ1SRkIDPWgfJdvVbB8r3nGNR3pj0pjp7Kd4e8+Wwlt24j88AJu9eklxPT4btuA1qVYkoV6jBOwVzGnKXLG29g1xupuOfF56G4dhWZJ95zaD1Jl+6Q18g7FhkOH0XmWfsBfZ3Kp2CbU1waMuPsdyDT1CikfO8+Ao0+p+iVfPyQLFNi9y/L0L9bL48bZcxK13GwUSPbzsyscuOA3x00cuiet9+2HCiVG/+DKiPb7heo7NAZipFjbB/75kcYHOjNpOwzEIpueb28FCdPQrVus0M/nOLB0aJnmeW1kjKgulJ846hXcLC4qAriky/mpuoPGoR6DzwgyqniehRUR+yPiFVFRBQso4dPQpVlf6i7quM9BdZVff09jA70mlH2HQhF1655948dg2rDf8WuI/fxQVD9+qjVs6fd12fMFdH+O+jXX0UZTasaDtUvyxxaTzHkQSjC83ofKw1yqE4UHyAXy9WuXbB8HzwOVbba/nsWVr6/Wkw5UopcR6pQwK9mTTR56CG7r8+YK6JUl/2/+cZyvqta/BMMifYbGxU9+kAxaFDe/chIqP5Y7dh7DhkJhVUATaGTQnXqnN31VPXqFSzf+49ClVvMObZEAt/wcNQdOFB0FGLM3VDZbD9tmuVv1c69UDmQdUbZrkPBOu3XlTCmpNhft1dfKAYOzLt/9SpUf61xaHsVQ0dBERycd19thOr0+WLXUQUFIbRVK4Q0tx2RyJg7dRaP6NlTlFFlQhJUu/fZXYf2+wJ12vmrUBUzar3Y8r10OeDAqEjlff2g6N/fcl9x6RJUf/9rNx0iZQSoY7UeY+6WHWrQL7+IMprTsDFU3/7g0HrKQcOhqF8/775PEFQH7I94VwUHFyyjZy9DlexAGW3XseC6S36HJCOjyHUkMpm4Jm36yCMc7GOMFUpipOS/jDHGGGOMuQBKa3j79m2RZovSZTLGGGOM61HGGGOsovA1KXNnjicrZ4wxxhhjjDHGGGOMMcYYY4y5HA74McYYY4wxxhhjjDHGGGOMMebGOODHGGOMMcYYY4wxxhhjjDHGmBvjgB9jjDHGGGOMMcYYY4wxxhhjbowDfowxxhhjjDHGGGOMMcYYY4y5MbmzN4Cx8mY0GukfSKR58W2DXo/suDiH1vcOC4NMobDc12ZnQ52aanc9iUwG3/Bwm8dykpOhz821u67cxwdeQUE2j2XGxIjPYXl9uRzeISGQymQOfQ7GXJnRYLApoyQrPh5Gnc7uusrAQCh9fS33DTodsuPjHXpfn6pVIZXLS16+5XL4Vq1qt3x7hYRArlI5tC3Mg/bduDgY9Xq766qCgqDw8bHc12u1yElIcOh9fcLDbY7/msxMaNLTS7fvJiVBr1ZbLSQR9YtMqXRoWxhjzkfHIiq7EonE8pg2JwfqlBT7K0sk8Kte3eah3NRU6LKz7a4q8/KCd3Bwqerv/MfAwupvmUoFr+Bgm8/FPL8evZvrrdyUFOhycuyuK/f2hleVKjaPZcXGmspSSetvjQY5iYkFyga9Pu+7jLn38Sg7IQEGrdbuukp/f3Gzfi06pjjCOzTU5rzb0fqbttW3WjW79TfVo3IvL4e2hVXC9pSAACj9/FyyvZTbUxgrHQ74MY+WcOoUdsyYgS5vvonaffpYHqcG1b+HDXPoNYb+8QeC6tWz3L++aRMOfPihQ42xo9ats3ns0Lx5uLltm911G44Yga7vvGPz2L+PPCIqT2sUqGj26KNo98ILfDHJ3BKd1G2fNg0hLVqgyxtv2Dz335QpSL950+5rdHr1VTR95BHLfWosdLR8D1+1CgG1a1vuX9uwAQfnzrW7nl+NGnhwzRqbxw7OmYOoHTsKLFutc2fc98knNg1DzP3RBdS2F19EzW7d0H7qVJvnNowfL4Jo9tw7cyYaDB1quZ9+/Tr+HTvWofcftXEjfEJDLfcvr1qFY198YXe9oIYNMXT5cpvH9rz7LmIPHbJdUCJBRPfu6DFvHgetGXNxV9aswaGPPsKwP/+0CdzF7N+Pna+9Znd9agQcu2ePzWMnvv5aHFfsqdW7N+77+GObxzY9/TSyqKOaHV3eeguNR4603M+4fRtrRo0quH3e3rjn7bdR7/777b4mcy8XVqzAsc8/F3WaKiDA8jhdL+17/32761Mj9sObN9s8dviTT8T1mj31Bw9Gt1mzbB77d9w4hzrPdP/gA5v9MeXKFVH350fnft1mz0atXr3sviZjzHmo49z26dNFZ9Ae+dp6qD0p6dw5u6/RZsoUtJ440eY1Hb0mfeDnnxHaooXl/u3du7H7rbfsrkcBxke2b7d5jI6pV9euLbBsWOvW6P3ZZzbHWub+KMC7bepUBDdpIs6VrP333HPi+tKeji+/jGbjxrlse2m1jh1x34IF3J7CWAlwwI95dLBv6wsvQJOSjOSlPyL81GHLc+r0DBjjHOttpfnxG6hD8noua0+dcWhdQ3Ym1J99ZPOY/shBh9bV79tVYF3D7SgYNVY9yyQS6L28cPbnn8XIv3YvvshBP+ZWqAf2f88+i9RLlyCLjoLaW2ozilV/5RKMKfZ7h2nX/wN1TN6JrDot3fHy/cMiqKvkjabVnjztWPnOzS5Yvo8esl2XBiPIFYg9cECchPf54gs+SfWgYN+WyZORce0afNKSoTbm2uy7hhvXYMyyPzJG+8+fUF/Na0DQJCQ6vu9+8wVkfnkjW7WHjzq27xq0BeuXU8cL7rsKBW7t2iUaOe779FMO+jHmwsG+/bNnw5iZgaSFH0FRIy/gp7l8xbHjgkJe4Lig27vLsXPWo4cKHlMir8CYnmF3Xe2/f0N983Le9ianFHxPqQRaXz/sfe89cZeDfp4V7Dv88cemfXf+bIRYdWLRnj3v2L6bkV7wfOzQfofW1R3YW2BdY9QNGHOtRrwXQfv3SqgvnMy7HxtXyL4rhcbXTwTde82fz0E/xlwUBeb+e/55JJ0+jSAfFdSfz7e9Jj1P7T/2s8fo/tsAdWZehz9Nbq7j5/VLf4C6et5oJ+2FS44dA9NSCtbf+/cUPK+XyZFw4rgIAPX7+msO+nlQsI/aU1IuXIA06gbUfgrba9LLF2FMtj9SVLthLdTxUa7XXiraU+SiYyq17fb96ituT2HMQRzwYx7r5OLF0Kamwhgfh4zzZ2HwyUt9JlVrEBFmm8KlKLKoazAk5VU6PunJDq2rUilhuGTbEyxEagAcWDfIoCmwbs3gQOitUsTlqtVISEim1lucXboUzR57rEBKpeJcu3YNZ86cQWZmJiqan58fWrZsiXpWPYFY5UM9D1OvXIEhLgYZKYnQXzhjE7Su7u+NHLn9FF6+GSk25UWaq3a4fEtvRsKQkJfexDc9pfTlW2aExGpdg8GA6Og4GDUaxJ84gaidO1H/gQfgqOTkZBw/fhzxDqYnLUtKpRL169dH27ZtuSNBIWjUS8aNGzDExyIjKw36C9VtvqcaQX7Q+NhP5eqTlmSzH8mysh3edyXXL8NglfrHPyvdoXV9fFQF9t1QhQQKq3X1d/ZdaLWIOXAAMQcPolbPng5tF2OsYh397DMRMDEmJSLj1AlUzcxr2PFKTnXouCCTSQscF6oYHKtLg6WGAutWD/CBWmX/MtM3Ldn2GJiTW+A909MzkJaYAAMkYhRzSQN+p0+fxuXLl6G2TltcQUJCQtCuXTuEhYVV+Hu7Q+oxGoUi9t3kJGScPIEqtWpYnvdJTXJo/1MoFAX2v2CJDgZH9l1oC7neCoBWaz/9mXdKAgyX8q7L5JkF6+/U1HRkJMbDIJXg+FdfccCPMRd1Y8sWJJ09C0NcLDJhLHBNGu6tgK8DxxT/7AybY4pRq3P4vF4ecxOGjLxgoVeKY9ekcrm84DHQqIXOal2a4uZ2dBwMGjWSpVJc27gRTUePhqPS0tJw7NgxxDqYnrQs0eerW7cuOnToAGm+dJUMiFy3DimXLpmuSZMTCuy71fy8ECizvx/5Zabatqe4SHup2Hdvx4r2FBrQcXP7djQYPNih7WKssuOAH/NYmbdvw5ibYxr91jYvPYK5cul6T/tSvW541VBxK43GjeujtDp3alPgsX37j+JWfBIkQVWQeeuWwwG/tWvXYtSoUdA6kIu+vNAF+qpVqzBkyBCnbQNzrszoaBFQgE6Hdp0LBpbatmleqtf18lKVvnyHh4pbaTQppHxfvXoDR4+fgUSvF8ckR0VGRqJ379646UBK0/L02muvYd68eRz0K2TfNWo1Yt9t37ZFge+nQ/tWpfq+fX19Sr3v1qgRLm6l0bxZowKPXbh4FadOX4DEaBT1C2PM9WiyskzpB3NyEODvh/r18lJUk5DgoFIfU+i18r+eo9q3a1mq9by9vQpsLzX2rN+wHdk52SJlN82V5uj8oh9++CHeyZciv6KFh4dj27ZtaN68dOc0nio7MVH8lsjORnCVQNSKsJ1DMiwsRNxKo1HDeuJWGh07tC7Ven5+PoXuu2vWboEmJ6dE54CMMSdck9I8Z1oN2nZsU+C8vlXLpqV6XYVCXuo6ODSkiriVRoMGdcTN2s2oaBw4eBzQ6kp0PIqJicF9992HS5cuwZkmTZqERYsWcdAvH/Fb6rSiTaVtx9Zl1p7iSu2lkZE3ceTY6RK3pzBW2XHAj3ksMbGy0QgvLyVksrzRfZ6ELi4RZ5og3uDAZLzkwIEDlmCfd5g3fKvnTc5bUbJiMpGTkIORI0di165duOeeeyp8G5jrlFHiS/uyB/Izp1w0Gh2a7J1kZGRYgn1ybzkCGwRBIrU/0rEsaTM1SItMw/z58xEaGopXX321Qt/fnfZdH99KsO86WL8wxiqWpV4xGuDn5++RnTPoM9H5bnZmrrhv0OvhyFn94sWLLcE+/7oBUAXYH3VdlijYk34tDXFxcaJOp6waPNLP6vsx1ytGo6hvPHXfpY48Gq0eeid2smSMOX5eL9pXPJCf+XqlBNek1F5kDvZJlTJUaVylwq9JdTk6pF5OEXU6jZqfM2dOhb6/qxPXaOZ912OvSc37rsHhfZcxxgE/xtwaXSBXq1kdss5dxITNjqBexnTyFtSoCu6d2wNSWcWnRjDoDdj35m5x8rZ9+3YO+DGPpVQqRA83WYf28I+IcGid8+fPi2CfVCHFfV/1g1dwXsrRinR+6Vlc/fsyNm7cyAG/SshLpTTtux07wre67cgLxhirSEFBgZBUrQZZs5aQOtiJj+ouUntAXbR+ti2cQZOuwfbntojU3CdOnED//v2dsh3MeYKDg6D0C4SsCY/wZIw5D402FOf17doioG5dh6eAMY/s6/V5H/hWy5s7vCJd+esSLvx6Dps2beKAXyVEU42Ifbd9e/jXquXszWHMbfAIP1apyQePgHzAYOh2boVu1fKSrSyRQPHwo5B16gpjago0S7+HMeq6Y8v4+UP5xCRI6zeCIfIyNEu+BbIyIalTD8rHnhYpOvWH9kH75+82k+7mR6mWGnTuBK9Z8x3e7KQkU2744BYhTgn2EXrfkJahIuCXmGgaociYJ5bTKlUC0atnF6hmz4c0JLREZdSvlr/Tgn0ktHWYCPhxGfWcfVc5/S1II2qLHpL6A3tM+24RQkODxb7r9fECSHwrfiQ4Y8xzj0UlPd9t07oZZB26QPn0cw5vtrkupbrMWZQBSgTUD0TS6USuSythPWpObyvrdh+Ujz5Zik/PGHMl7lyX+vv7ma5J35ptOoaVoB71CfdxWrDPuh7na9LKWZcGBQWY9t1Z8yANK930FYxVRjzrKavUdFs3QrtqBRT9HhA9h0uCKjNZjz7QLP4ChthoKJ+c7PAyihEPQxJaFeoFH4r/FcMeEo8rn5wilqPlZT37isaN8uKJqXOYZ6qs5dTpJdTpG+D+XG3fpQsveky3bTPkfQZC2qh0c5IwxtxLZT7fdTY+3/asfZfrUcYqL1c7HlWaupSvST1u3+W6lLHyxwE/Vrnl5kJ/5IClkioJafNWMMbHwnD5IgwnjkBarYaoxBxZRtasFQwXz8J4OwqGi+cgbdkakrCqkFatBsPxI2J5Y0IcpC1KN3E8Yx6FyylzVy607xLqPSkeO3/a9AK+zuutyxirnMciPt9l7rrvEq5HGavEXOh4xHUpc9d9l3Bdylj545SerNKTtekgvgNZh86iEVTx2NMwXL4A7bKfIW3QGMrnZxT4jnJfngyJnz+gVov7xjv/05B1JMZblityGT9/GNW5dx7PFcuJZe/cF+48zhgDl1PmtlyljrGQyiAfMhKGpAQYzp+BqzAYDDhw4ABu376NrKws8Vhubq5IJxQSEuLszWPM7bnKsYjPd5m77ruuXo+ShIQEHDx4ENnZ2eJ+Tk6OqFu7dOnCo00Z86DjEdelzF33XVevS41GIw4fPoybN2/aXJPGxcUhPJxTijL3wQE/5rHqDhiAnOBAyK6aJhouirxbTxji40QvFKNGA93mdZDWayCeM9y8BvXcdwtdz5iZAUmwqRFSorozz1ZmhmPL0OMqb9PjXl5iObqZ7wsqLxhjY4rd9kuXInFt50FIz1/Hve+/j9DmZT8h/NoRf1v+VuvUiM6KwYqLf+Bw7BF83nsBIvxr4svjX2PzjS1imantXkD/On2xM2oXPjm6sMy3h3mOqu3awZiSDP3eHVDI5R5ZThOTUnDk6CnIop9G47Hj0PSRR1DWuIxWvGqdOkGelQn9wT2Qy2Ruse+a7kigeHIypLXrQr1wruXCrDBxcYk4fvIsZLHj0XzCBDQcNgzlITk5GUuWLMGiRYtw5coVm+co2FezZk2MGTMGzz//PDp16lQu28CYu5IplWg4YoSYuycgN9Njz3cPHzmF5MOnId20A4OWLoXcvG4Z4Xq04sl9fEz77r5dqGLQusW+W9J6lOw/cAzpR89BtmYjhq5YgfJqnKSg3v/+9z/88ccf0Gg0NnVs165d0bRpUzz77LMYP348goKCymU7GHNXoS1bosH9A6HfsQUqL5VH1qVpaRnYf/AYZFHPod6DI9HqqadQ1rgurXhV27aFISkR+j3boVQq3GLfLWldmpScisNHTkJ2+xk0GjMWzcaORXlIT0/HL7/8gq+//hrnzp2z3YakJNSqVQsPPfQQnnvuOXTr1o070TCXxwE/5rHaT50K7fp/oPt3VZHLSKrXhLReQ6i/mA/lU8+KvOfGuLwTJWmd+lC++EqB9XKnPSN6odDyNAeStG1HGOJiYKReLnTS5eUNpKYUuYz+wllImzaHJKI2pE2aw3D2NIyJCaYKuG0nGNPTIQkLh2HDmmI/Y65ajbSUVEgjI6HPvTMysJwsOPoZgr2C8XizRzGj40uYsHEiPj/+Jeb1+BBPthiPQ7GHUdu/lgj2peSm4NtT35fr9jD312DIENRr3gTq3ORil3PncqrX6ZGengnp9RvITS7+c94tLqMVp/HIkWjQtBE0unS32XcJ9eSUtW4PzU+LYMzOMr1WEXWHVqe7s+9ehzo1FWVNp9Ph9ddfFxdV1GuyKGq1Gj///LO4UcCPgoPNy6FzC2PuSOHjg67vvAP1os9gOH3cY893abRSemYuJEapCG6UF65HK45XUJBp3/1sHgyXzrvFvlvSepRkZWUjXZsBiQHl4uTJk5gwYQJOnDhR7HIXLlzAtGnT8Oabb+Kll17C//3f/0Fmp8MSY5VFnX79UKtFc6gz4opdzq2vSfV3rklv3EROYiLKE9elFaf+oEGo27wp1DlJbrPvlrQu1ZuvSW+UT3sKZZmZNWsWPv30U8uIvsJotVosW7ZM3Fq3bo0ff/wRHTqYRk0y5oo44McqNfm9PUWPGMOFs9AfPwzFwCEwRN+GxNsb+tanRMWl/uDtQtfVH94Pad36UE6eCmNqCjRLFptes+/9UAx+EDlTJxa5jHb1SignTIZq+lswXLsC7Zo/qXsmNEu+gZIqv8lTod+93ZJn2xXsub0PWoMWPSN6oH5gPYT7hONC8kWsubIWDzYagefbThEBP/L1yW+RobXt9cNYaXE55TLqrlxq36V1u/YQ/6smTTUtt+5v6NatRkWji6nRo0dj/fr1No/37dsXAwYMwBtvvCEa9SUSCQIDA5F6J+BI6VWoR+Xq1avRq1evCt9uxtyVSx2LXPh8l891XY9L7bsuVI+SLVu2YNSoUcjIyLvmCg4OxuOPP44vvvjCUo/27NkTO3futATP58yZg/Pnz+O3336Dt7dp5AVjzM2OR1yXMnfdd12oLqWOpTTyfeXKlTaPd+/eHUOGDBGdZMx1KU0xkXgnWH7q1ClxLUrrDRo0qMK3mzFHSIzl2E3y+vXr4mRz3759OH78uCW9xMyZM/H++++X19syZmFvhJ+7O3X6PC5cvQlpjQgMWLwY4e3b211nxowZWLBgARo82AjNxrdwODXDExufRohXMD7oNgt6ox5Pb56EHF0uFFIFvhCpPSPEcjtv7cYnRxbYfd3zS8/i6t+X8fLLL4veNKxyMkRehvqTD+CpKC3izt0HRRltNXky2j77rN11NmzYIE4cA+sHosenvZ1WRhNOxuPg+/tEDzbqQc5s6c+dhuarTzz2a7l1Oxb79h+FNKI22r/0ElqMH19mI/uGDx9uCfYpFAqRZoxulHKM0KgD6m0plUpFQ+by5cvx8ccfixEKxNfXF7t27UJ7B+o8xioDeyP83N3OXQcQTyP8QsMwZvduKBwIUlBDjDhOvNIJNbrVdEo9Sg7M3IvEUwn4/fffMbac0lC5M3sj/Nzdf1v3IEWrhyQkDI8fPlxmr0vtK9RJxjxCvmXLlnj11Vfx8MMPiyCedT1KI3vOnj0rRtR/++234j6hYCE1VtIyjFV2hphoqGe/CU+VnJyK/7btFekcmzz2GDq/9prddfbv3497770XPuE+6PPNALvLl1ddmnolBXte3YnatWvjxo0bDn3eysRwPRLq+bPgqeLjE7FjF7Wn1ETLZyah3fPPl8nrUh356KOPiutMQnXhM888I1J2UvsHsa5LqcPqn3/+iU8++cTSNqJUKvHff/+hRw9TAJMxV1KuZ3eUWmLhwoVi4mjrXPKMMffz8/0/YMF9H0MmkeGDg3PFSRuhUX80oo/k6nLx7cnvnLyljFVOXEaZO6CekuZgX0BAADZt2oTPP//cEuzLz8fHB0899ZQY3Xf//feLx+iCa/DgwWJuIsYYKytcjzJ3EBsbi2HDhlmCfdSJhtpbaJRCUSP2WrRoIeb4W7duneg0Q/766y+RxowxxsoS16XMHcybN88S7KO6859//sE333xjCfbl5+Xlhccee0zMmUtz+RGKc1AdfPv27QrddsacHvCjk8n+/fuLEX1UCBirSGsefhh/vPYW1m/Yzl98GZh9YA7WRW6ASq7CC22fg1KqtDwXl23Kd5+jy+FUnsxhBz/6CCvGjMOq1RuRns4pYLmMuo+9M2di5fgJYt/Nzs5x9ua4jZSUFNHgaB7ZR6k5e/e2P4qV+Pn54e+//xYpPc0Nnj/99FO5bi9jrk6dloblPXvirwVfYv+Bo87eHLfH57oVJzM62rTvfvktDh/hLAIlsXjxYiQlmeZr6tOnjxilR51jHDFw4ED88ccflvn7Pvvss2LnLGKsMjj+9ddY8eBIcV6fmJTi7M1xe1yXVpxDH3+MFaPHiH03LY3bUxyVk5NjyTJGo/co8EcpPB1BgT/K2kD1qfn6lgKFjHlEwG/r1q3o2LGj2NEbNGiAr776CkuWLBF5belmTtdJwb7NmzeL+0X13GasvOhycqBTq6HT6/hLLgPH40/gm1OLcSbxLGr5R2BYA8cqRMaKYtBooMvJhU6nR7nllq5EuIxWHL1GA20u77sl9fPPP4sLLDJ58mSHg31mdN5JE6SbLVq0SKRZYayyopkZtNnZ0Gk00Ou5LNwtrkcrlmnf1fK+W5LvTKsVaTnNjZTU8YVSipXEAw88gCeeeEL8nZ6eLhouGavMTNekOeKalObGY3eH69KKY9Bqocs17bvlOFuXx6GOMuZMMePGjROj5kuCOq7SNalcLhf3v/vuO85qyFyOae8sgT179oiTRDrZJJGRkXjxxRfRpk2b8tg+xsqVfPAIyAcMhm7nVuhWLS/5+vcPg7x3fxhzcqBd+QsM5047toxSCcWjT0PWsjUMMbeh/elbGJMSIAmrCuUTkyGpXgP6Myeh/fVHQOta6XC/P/2jSO05qvFIbLy+GZnaTGdvEvNwXE5Lhsuoa3C1/VbWtQcUwx6CJDAImmVLoN9dsaPfKTBH8weZ0fwIpdG4cWPRoWzLli24evWq6FhmTvXJGHOP45Grn+9yPeo6XG3fdXZdunbtWkRHR4u/hw4dKua0Ko3nn3/e0oGGRt5PnDhRdNxmjLnP8YjrUuau+66z61JzxhlzfVgaNWrUwIMPPihGzcfFxWHVqlUYM2ZMGW4lYxU8wu+VV16xBPv69esnTjpnz56NM2fO3OWmMFbxdFs3QrtqBRT9HoCkarUSrStt0BiKYaOgXfELDKePQ/nkFFGhObKMvO/9kDVvCfXnHwF6AxRjTb0sFWMnwKjXi8dlzVtB3sf+5MjlbejqB8WN5uojV9MiMfyfURi77jFLsC8+O0EsM37jU07eWuaJuJwWj8uoa3K1/daYmgLt5nVwFpqD7/Lly+JvGtnXrFmzUr+WdbBw6dKlZbJ9jHkyVzseudr5LtejrsvV9l1n16W//PLLXXecIe3bt0eXLl3E3ydPnsTp0wUbbxljrn084rqUueu+68y69OLFi+K6lLRr185SF5YGX5Myjwn4UdSaJoQmKpUKK1asEHlu33nnHY5kM/eUmwv9kQPiT1mnriVaVdq8FYxqNfTHDkF39CAkvn6Q1mvo0DLSZq1guHYVxpvXYThzAtKmLQC5HNLGzcR98fj1SEhbFD5hLGOVCpdT5o5cab+VymA4fwaGk8fgLNaTmdMIvbsxYEBecMA80oEx5ibHIz7fZe6677pQXUqj8fr27XtXr8V1KWNufDziupS5677r5Lo0/zXp3Yxu79Wrl0jvSfialLl1Ss9r165Z/qa5+4KDgy33O3fujN9++w0VLSYmRtwYyy8yLQ3ZuWootVocTzBNbF6Yqq06gKorbdsOuPjfJjSY/AKUVUJw5X8LkZsQj3YL81KQmR2f/hwi5AqE5OaI1/ZW+aIdgOsGCZKs3qt+EcvU9vFBVnwcLiUkoVpSMupLpTiTo0EnqRRRiUmITUhC4/R0+NSugxPFbHuKSgVVk4ai58yVpCTcPnbMocA9UafmIu1qqtN2HHp/8/Ycc2C7mee5GB2NqJwcGLQ6nEpOhZ9a43HlNEethrJuLcj63o/EKlUc2tevXLki/ter9U4to1nRphG82dnZXEbzuRQbi+icHBi1OpxMSoF3VrZr77dqDbSpqVBBhg4AojKyEFdM3SJ+d61W7Lvy+wcj1tsb6rs8Tp86dcry99y5c/HZZ58Vuax5Xj76Pzw8vNjXpXNArkNYZaXOyMD17GwYNRpkZufA10PPd3OCg6BqWBWyjl1w8vRpSO/MmVKcjIwM8X92XJZT61JdttZyHc3HqjzZCQmWfTcnOwcqd9h3S1GXasJCoKoWAVnb9mXy+5uv46iBkdKJ3U09Sud3ZidOnEDVqlXvevsYc0cXoqLE8YiuSU+npCGomLnQ3LUu1ag1pmvSXn2QUq2aQ8cjGglFDFqDU+vRzFum+lyj0XA9ms/F27dx06o9xf9ONj5PqktzzPtun4EOt6cUx3p9Su25ZMmSu6pLdTqd+D8+Pp73T1YhKEuDQ4wlsH//fqr5xK158+Y2z33xxReW52bOnFlg3ddff73Y50uLXsv8unzj76A0+wDt15cvXxb7U6dOncRjP/30k3HixIlGmUxmbNCgQYEbPT579mxjVlaWWL5Lly5i/T59+ti8dlHL7N6927h+/XrxOJUNvV5vVCqV4v/XXntNPL5hwwbjrl27eL/m/Zr3AS6nvA+46XHAVeoXuVwu7tepU0csN3nyZKd/N3zj74D3gcp5POLzXS777rrvcl3K+y7XW7wPuMrxiOtS3he5LuV9gOukyrkPOKpEI/zq1atn+TsyMhIpKSmoUqWKuG9O9VnRJk+ejGHDhjnlvZlr2zZtGrKvX4dSm4uePQrPy+wdURvt7rkHZ2e/A+20V7HqrVehTohHcNtWaLJpNaY88zjaff5tgfWOT5sMlTYTPj4+uLDgI/g3agxdZiY+rFEFGDcScj8/aFJTEFDEMjVu30D1wcNw4rVpqPfE40g/cxLbh/VHxrkzeHvCeIyDGs27d0P02r+x96HBxX5OSZUQqKZMc/h7yczMFD0Cuj52L6r0CCl0mW4N7sUz3SciIqgmkrKS8NuhZVhzam2hy7ap2RqvDJiBcP+qMMKIWym38cvBX7Hj0k7xvI/SB9N6v4juDbtDLpPh2M1jWPDfZzi04iCyT2aJIfVZWVm4ceOGw5+BeYZT332HqC1bYEhKRNeu7eHn6+Ox5VT57HRIg0z1pT179+7F1KlT8cvyXzDywVEY/d0YpOemI8Q3BNP7TkPHOh2hN+ixL3IfPtv6BbI0WYW+zmcPL0Cjqg3hpfBCSnYqdl/Zja93fgOt3tTzb3DLQXisyziE+YUhOi0a3+35Abuv7BHPvTf4HXSu1Ql1a9VFSEiISOHN8hz78ktE79oJY3IyunfvBG8vlUvvtztHDITcPwC+dUzncW/17oGJEjU0iQl2f1bVS29A4l142SyJffv24cUXXxR/e3l5ISAgoMhlExMTRU9KqVSK0NDQQntSJicni7+7deuGL7744q63jzF3HeH337PPwpiShFA/H7Rt26LQ5TyhHpU1awnFiNEOfS916tSBt7c3atWqhaqDqyGsTcGRS+8PeU+cw4b4mc6Fe37au8jXa169GSb3mIR6IXXhrfDG7bRo/HrwN/x3Yatlmcc6P4oRbYcjyDsQkYnX8NWO/+HU7dM4/c0JrF+6Hk2aNMH169cd2v7KMsJv+/TpMCYlIjw4EK1aNnH5fbe0damsTUcoBpVNe8WkSZNw9OhR8Tedn8lkslLVoyQ9PR25uaaMK999953jPcYZ8zDnf/sNkWvWwJCYgE4dWyMoKMBzr0mfehbS8OoOfS/+/v6oXr06mrRtggbPNi50mZLUpWYyqQzfjPsaTcIbIykrGQ9+M8q0bXIl5gz/QDwe6B2ImLRYPPL9WGREpePE58fE+f4LL7yAc+fOQa1WO/QZPN3pH37Azc2bYEhMxD1d2sHf39dj61LllGmQVgm5++/s9GlMmDDBMlVZYGBgkcvaq0v1ej2SkkyjE1u3bo2ffvrprrePsbJSooAfDWGlCS0puEcnh2PGjBGNkjTR8/Llywssn5CQgJ07d9oMByd0gP7zzz8tOW/DwsJK/QGoAqIbY/ldDwxEppcKKoke7cIKrxgUQ4aJYEP9mChITh5FxIiHxeOGa1fQYfBQ6A/sgebDtwus15yurRJioP33bzSeOAXG3Fxoly5GG39fyO7pDuX4Z5A76w0Y4wpfBgd2QtKwIVq/PwfG2Gholi8R2yj581con5gkHtefPYWqB3ejahHbbiYJC4dXCS7QqMJavHgxcqS5qNsgqMDz1X2rYXbfWUjKScJ3Z35E/zp98Ur/l5Hqk4aTCXkp2cxUVbyxO24PEq4lIswnFGObPIKZg9/FBckl5OhyMK3dC+hXpy/WR25AijoVY5qOxv+NmoXhm0bgVnKUuGilBlu6aGWVi7pGDci8vWFQyNE6OAiBAf4eW05VbdpAGlJ4g0th6ZoaN26MsQ+Nxeab/0FSU4pABGFWt5loGdoCKy/+KRochzcfCqW/CguOFp4aMUoThb3n94uOQCMaDseodiMRL03E+msb0DKkBV7v8Squpl4V5fzBhsPwf0Pfx/PbpuJ2ZjTWx25Cv6Z9MWPGDKxcuZIbgfLJrFYNSm9vGBVytAmpAl8fb5ffb+WDR0Ax+EHxHrUfeRQ127WH5rN5dvdHr7ZtxTwMd6t+/fp4/fXXRQoxSkVGqWupIaEwERERojMInd/dunWrwPMvvfQSPv/8c/H3yJEjef9klVZuaiqu+PjAmJWB6j7eHn2+K6tTG8oSnO/+888/omNA3fAGCCzkfFfuK8fW29sxuslD4n5hy5g1qdUUMi8Z/rj6F5RSJcY1HYO3B72JBO8kXE+/jj61emNSh4k4EX8Sf0WuEs9/NGouJm6egvM+Z7Fw4UJRl1pPh1HZZUZH4xrtuxlK1HKjfbc0damsXp0S7bvFGTFihCXgR8G/OXPmlKoepbJRs2ZN8Tc1do4dOxa+voU3FDPm6Yy7dsHg4yOuSVtVCURoaLDnXpO2agVpRG3HvhejEd9++y1SM1OLrCNLUpeaTWgxHrWCa4m/pTKJZR0vmRf0Sj12Re/G0AZDIFVIxXO0HWTp0qWi82CLFoV3bqqMNBs3QmrVnlJUsNoT6lJV69aQhhU/1YMjmjdvjpdfflnUg7RvUQCwqJTW9urS999/H7NmzRJ/Dx8+nK9JmUuR0DC/kqywe/duMUG0Nl9uYIpmm+dnmTlzptjxd+zYgd69i+/hsX37dtx3332l2XbGirVqyBBkXrwAlTobw4b098hvS6PVQh9YBarXZsIrKAgypdKh9ajM3QqORrPxBU+WnmzxBEY2GoFvT32HfyPXo11YG/xft/dxIOYQPjw4t9DXk0lk8FX4oqZfDfzfvTPF/cc3ToDBaMSyQb8gS5uFRzc8IZad32MumoU0xbAZw7F2wRqRN/u55567y2+CuaP9s2fjysqVMMTFYOCAnkUG/NwZ9fpSqzVQvTELylq1oXSgMWXDhg04e/YsXnnlFby55x2cSTyL2v618L++X+BK6lVM3/GKWG7JwO8R5BWE8RueRLrGNLdBfn4KP1E2n20zCR3C22PRyW+x/tpGvN7pVXSveS/+78CHOBx7BAPr9McL7Z7Dmqv/4rvTP4h1F9/3NaRqKQYOHCjmdmF5dr35Jq6vXQNjfBwGD+pTaMDPU/Zdr5kfQRkeDoXP3Y/yo8ZJGkVAFi1ahClTphR7cUWNkfkvrmhEOD2elpYmRgrSctyIzipzwO+Pfv1gTIhD9SB/dO/WCZ6IjkVo2RaKR5+ET2goJFKp3XWmTZsmRgO0f6UTanQzBTbyU0gVWDVspfh76GpTw1Nh5FI5dAbTHC3krc6vo2uNe0SHm+1RO7Gg13w0qtIIL2ybhhvpN/F4s0dF4+f3p3/Em4+9gcxLGWJOQbkDcw9WpoDf38OGwRgXi1pVg8XIBE+Um6uGpGNXKB4aC98ymCMvNjZWjFylke7UaToqKkqMUChJPUoWLFggOnWZy0px8+oy5umOfvYZzv30Ewwxt9Hnvq5FBvzcmV5vEKPiKHOHskEjKIvodFdYu9HhC4fR55sBRS7jaF1KWoe2Eu1F/zu5CFPbvYCU3BSM3/iUzTIRfjWxqN9XiMuOx8TNk5F6JQV7Xt2J2rVrc1aofA7MmYPLy5fBEBuDAf16FBnw84j2lNfeg7J2XSj97r4j6muvvYaPP/7YMrf8G2+8UehyxdWlFBOhjBI0nzyNtqcsDrQ8Y67C/tVSPj169MD69etF5FqpVKJu3briBHH69Onls4WMlVKXN99EtyfHo2P71h77HV64cAVrf/8LqwYNQuKZMw5XmOYUvBSYC1D6W24SSFDDzzRiNiE7Ufwfn2MaWk/BvKK0r9oOvw36GfN7mgKCnx79DFnabFTzDRcpGxJyTK9l/Xp1a5iG8N+8ebOUn565u0ajRqHHa6+g6z3t4e3tBU+UmJiCf9dvw99jxuLc0qUOr9e/f3/RmHMp+bK4n1cu81JdULmiMlzNt1qRr/Ntv//h+wHfiGAfNUpuvv5fvtcrupyfijotRvZTGjJmq9m4cejx8kti31U52NHC3cTEJoh9d9WoUbh0JyvD3bLu3PHpp5+KoF1J0TmneT0akcDBPlaZUSC+50cf4d4RQ9G0SQN4qgMHj2HN51+L812dg2m8KKMMkUsLnuuWlHWwL1AZiCbBjaHRa3Au6bx4rPqdutNcpybcqVNr3HmcMuPQVBgsj6pKFdO+O/R+NGpY12O/mj17D2PNJwuxanDxafYcVa1aNYwaNcqSTenrr78u8WtQ+jHzKHny7LPPlsm2Meau6g8ejB5vvyXO6/397z6Y4IrS0tJN16TjJ+DEokUOrUNjQ4prNyopf4U/Xu4wDX9f+afQzFGs5Bo9+CB6vP6a2Hd9PLADKklKutOeMu5RnP355zKbGkwiMe3DX375pahPS4qyplGwj9A0YxzsY66mVN0M+/XrZ0klYbZkyZJCe4OUcAAhY2WmZrdu0KYlQnfrKn+rViidmnm+BhppN7f7B5bnnt48qcB35cjJ3MWUi3hv7/uI8K+F8c0fxYQWj+NEwslCl83/avlHC7PKI7R5cwR7KaDev83Zm+JyGjZsiOTUZGgMmrt6nTmHPkIVVRAebDQCPWt2x4GYA9gXfcChcp6Qbjrx5ZPXgsJatUKwDNAcMc15yBzTtm1b3HvvvWI+P0rpSY2Wa9asEXM+OOL333/HO++8Y7nPo8NZZUeZHer07Qv1pdMwaAufz7Wy0mhM9Webum2weNA3Nue68VadZ0oixCsE73d9FwHKAHx6ZKEYfVC4gnVqTk5Oqd7TUym8vU377unDMFzia4GSoLrPPLcyZYOgEQaU3toRNNKU0oKaO1xSuw537GKVXZVGjRDo5wv1jvXO3hSXQu001G7kE+hTaLtRSevSp1o+Aa1Bi603t6Oqt2nEs1QiFVPKxGbFwQhuOy6pkGbNUMVbBfVeU6de5pgGDRrggQceEIOZoqOjMXToUGzatKnY+fys/fvvv2J0vNnzzz/PXz1zOZxXhLHi+PpBfl8/6E8eg/FW8SPRZPf2tOSh1q5dBf2B3aVaprxZB+GvpV3HO3tnWu6n5KYiOtPUS6Wqj2luzTBv07xj0ZnRlpMy6uGlN+phMBrEY5RO8HjCSXFrX7UtOlbrgDZhrXA8/iT0Br3lNUyvZ3rdGzHXK+TzskrAA8tp/rKav1yayxKVw9isWEs6FbpQsh6JcDbJNMKBvN75VfSt3UcE/Oj16gfWE69H8w/lL+fEXL7Nvd+Ya++7kmo1oHz6OTGvK83npfvnT+gP7XO5n40mM+/atauYN2Hr1q0i9fuPP/5Y7HwcmZmZYmTfu+++a3mMUsd37NixgraaMQ/nofUouRRzucC5rj1SSEWGCqoHqZ4ldQJqY+Y978Jf6YcPD87Dkbi8zq8xmdEipaepTr1hVaea6m7CnWDLSSWsR3v27IlXX31VpCOjudkffvhhzJs3TzQ4FteB5uTJk5gwYYIlTTtlcTCn2WaMlQEPrksLazcqaV0a7hsuMtMs6velZZlAVSAW91+EMeseFRmimJNUwrr0m2++wT333CMCfjSStXv37mKeyHbtik4xTp23aD2qgylzmnlueZr2jDFXwwE/xooh8fMXlZkxKRH6Yio+SXAoFGMnQPe3qbel4tEJMFw8C2NKcomWqQg0Ibt5rgeaWy9/OoWN1zdjeIOh4kY9sPrX6Scep/n8yCNNHsa4pmPw56VV+PncL3im1dPI1mUjJjNWpPBsE9ZaBPlupkchR5eDHbd2oW/t3pjSehJS1aloHNxIpEA6G3kn1RLPZ8LukieW08jISDRr1kwE8agc3syIEnP5NQ9phkebjoW3whsh3sHYEbVTBNypkfGHAYst8yBQmt1eET1wPvmCGGkwtP4gy8UaWX9tg5jDb1zTRxDsVQUPNhwuyu36a5ss2xAeYJoUu7C5X5jr7btQKKDbtxOG82egeHCMmOtKf+wQoMsLALuCxo0bY+3atbj//vvFSINDhw6hZcuW6NWrlxi1QHNGWvcsnjp1Kn7++Wekp6fbzAX43nvvOekTMOZ5PLEepaknSEZORqGpw7rX7CbmuTUbUKcfknNTRCCvd+1eeKn9VOy6tRsfH1mAeoF1Maf7B/BT+GL1lTXwlnujR83uYr6+mxk3se7aRrxUpRGebvkk9sccwMC6/ZGtzca2m9str+/oSGZWMpWxHiUU4KP5/H755RcR9KP5iObMmYMnn3wSEydOtAk00+h4Sv25d+9ey+NVqlTBunXrxPQsjLGy4Wl1qUKhKLbdqKR16e/nlyNAZZpjLlAZgOfaTkGmJhNfnvgauTq1Zf0gVZD421vmJe5fzL2IPdhZQZ+6cqqMdSnNh0sj/ChYR6muz5w5I6YuoyAgXZMOGTLEsixNtUIj6qmTqnWK9jFjxuCTTz5x0idgrIzn8GPMXSSdP4+Ea9eRnGy/91FRlC+YJjNXjn8GqtlFH8ilTVtAIpNBd2gfdIf3QyKTQ9qsZYmXqQg0oWznzp2LfD4mKwbzDs+HWq/GpNYTRa+rRSe/LTJFZ5o6DX1q3YcX2j6LofUH43LqFXx4aB5uZd4Wzy8+9b1o8LivVk881GgkjsUdx8dHPrWsT5Mvs8opPSoKCRcuIDEpBTqdqYdUaXhiOd28ebMIhjeu0sjy2CdHFuJQ7BGMaDgM/Wv3FcG+b04tLnT9dE066gTUwZMtJmBiqychlyrwx6W/sOyC6eT8dOIZfHX8a/gqfEU51xsNmH/kE9zKzAvutazVAvHx8bh48WIFfGL3knbjBhIuXhL7rrl3n7P3XWPUDei3b4ExNgaGyMuQKJSA0nSR7mooreeePXvEBOhmO3fuxCOPPIKgoCAxOTqh/Y/mVbAO9s2aNUv0rOSRp4wBBp0OCadOIfFWNNLTM0r9lXhiPdq0adNin5/QYjyebzvFcv/Fds9jZKMRhS5LI+Ip2EeoDn6t0wxx61azq3hs681t+PX876jlH4GJrZ4Sc+zOPjAHGVrTb0INphRgYXn0Go1p342OQUZGZqm/mspaj0qlUjGlyhtvvGF5LDU1FQsXLhQj5s31KI1cePTRR22CfRTko9TaHTp0cMq2M+ZqMqOjkXDunDivv5vpRjytLqVz7eLajUpal55JOot90fvF7Wj8MfEYdWyl++bR9LT+480fFX9TcJDuD25p6rjKCsq4dQsJ583tKaUPqFXWurRNmzbYv3+/SPFpduDAAYwfP17ME2+uS+Pi4sT889bBvhkzZuC3334T7auMefQIP0oPQTfGXMXOV19F5sULUKmzMWxI/1K9hnbJt1DNeAeaP3+H/sgBeC34tsAymv99Com/v+mOWm2ZtoN6yVhzZJmKQL1AR48ejc+2fVHkMgdiDolbYShgYA4akJWX/hS3otDov4XHvih2TidWOZ1dsgRXVq6EIS4GAwf0RGBA6cqDJ5ZTSrFE6SGo16Q5LWdSbhI+PDi30OVpDoWhq02pNciV1Kt4aYfpxL0om25sEbfCNApqiJpVaooe5HTMYLZOfvMNrq9dA2N8HAYP6gPfUk6SXpb7rkVgEOS9+kF/7DCQ7bpzerVu3Vr0pKTUKTTyoLjAsre3t2iwfPbZZ0XPS8aYiSYzExufegrGhDhUD/JH926dSvXVeGI9SumCv/rqqyKfn7h5cpHP0fxCdCvqfmFWXPxD3ApDc8NwRgtbOYmJpn03Lha1qgbjni5Fp9AqTmWuRynoN3fuXDF/H9Wjy5Ytg5o+XxEoEEijFh5//HH4m78PxhgurlyJcz/9BEPMbfS5rytCQ4NL9a14Wl1KI4Sp3ejoB3kprO+mLi3u2tWssMdSr5iCLGFheVNbMJOzS5fi8vJlMMTGYEC/HggKMo2gLKnKXJc2atRIpLqm4N3//vc/nD59utjsEdRBlepSGgnImCvjlJ6MFcOYeafHKVVQ6WlQz3234DKpKZCEVzfd8fKirlB31rXtaW3MyLC7TEU4evQonnjiCfx06Gc4G/V25t6l7G55Yjml4MeK1SswYtiD+O38MmRqS9/7vTSGNxyG9Jx0MT9MREREhb53ZVKW+67g5w/VtNdhTE+D5pfv4epoNB+l7HzxxRexfft2EfyjnpQ0SsHLy0vUEX369BF1Fo+OYaz8eGI9SmmDXeW4MX36dJHCmIMsZa+y16OkU6dOYn5cSitG/+/atUuMQsjNzRX1LKUto47ZPXr04NHxjJUjT6tLExISxDn4vK/mwRVQymJWPip7Xern54fJkyeLaSNoBDzVpTdv3hR1qTlLA83x99RTT3HgmbkNDvgxVhytRvwnCQ0zVVrvfFhgEc2Xn5jyVhsMkHfpRl2hYNTrYbhwliaoE+shM6PoZSrY8uXLsWDBAjR4sBFqwLkN+VSBvv3222J4PGOl5oHllDz32nNYJit8tEB5++TIAiScjEdycjIH/Nxk34VcAdWLr4qUKZofF9GwOECvc7n5EopKGUSBPboxxpzAA+vRBx54QJxn1oPzdevWTcyjNnbsWGdviufhetQiJCREzDFEN8aYex+PXKEuvXr1qkjD7xPuGnPQzp8/H88//7yzN8MzcV1quSalcza6MebuOODHWDFo8ln9udOQDxwKacMmUH/wdsFlUlMArRbaZUvERLeE/jYmJ0HaqClU09+E+qtPYPj/9u40uKryjuP47567Zd/3DbNxQ8IWomwFxLogLRZBTKeC+gatrXafTq0tg9Kp2pbWtuNMX7TTqX3BlPqiY2vHYXAU1IqURaxLMewlCMEQyEb2pHNOyHJBcs61NDf35vuZuZOcQ/45D/Cc8+zP+eDdT/wZAP8b7lNEqmuZd82fMQqnWH8e89iPrK9dzzyl/kMHx/lvBSDSUI4iUlGOApgoKEsRqShLgejDgB8wloEBdZsdqQ70/WOn9RnN7Gjt+Or9Y/4MgP8R9yki1TXOu6O/B4BwPYuo72LcUI4CmCgoSxGpKEuBqMOAHxDBppYX67rZs+T/5qOKz8tzFGPuQW3qar76S93HQ/el6w+lB4hGaWkpWnbrEvm+9X3FlpSGdo+2dFsvSze3lggH7tHJLTsr3cq7/kcfV2xBYbiTA2ASu75mpvorpstXu04eh/XGobJ0qCwLl6H6NvXdyWn+vGoNzL5BvpVrwp0UAJNYcnLiYJv0K99STKAitHK0tVsD/QNyGeFpk1KOTm6pqZf6U77xPcWWloU7OUDEYMAPiGAxMTGKTUtVTKmzgQRTeXm59fXUjpOKy4pTQkGixltbfavqd5wMSg8Qjbxej9XA8hcXy0hLcxRTVjZYke1s7NCBX+5T9g05wy/FHi897T2q+9PgVpDco5OT1+tVcrJXMSUlcsUnhDs5ACax+Pg4ubMy5Quxvrt9+3Z9eKks8yWP/wSzxnfOqvVEy3B6MPkkJMTLnZ0VUt4FgGvN7XYPtkmvmyIjM9NRTElJiQzDUO/FXu396T+Vvyh/3NukvR29OvRn2qST2Uh/ynUy0tPDnRwgYjDgh6jX3zegqBZipevee+/VSy+9pOeff364Qz9camtrrfQA5qzBaBbKjMiioiI9++yzeuSRR3TqtXrrEy6BQECbNzvb5m2yiva8O94NewCfhkv9/f3R/U/nMkL68U2bNunNN9/UgQMH9N5v/6VwevLJJzVjxoywpmHCcmkS5F3KUSBSRP3zKAQpKSl67rnndP/996th92nrEy5D7WNcXf9AlOfdEOuBwGTHgB+iVmxGhtqOeNXd06PTp8/K7XE7iktNSbJWNgzp7OxSS2ubbZzZlMvMDJ5x0tLSps4u+62E/H6fkpOCV9o1njs/ZoWzs6NTXp9X+dNC60DweDzasmWLpk2bpn379qm1tVXjLTExUTU1NdqwYYOVHkxOMeYMrUv//0eOnlBxcaF6e/ts4+LjYq3Z/kPM+8S8X/6v97fLpcyMtJDu7/6+frW2tausolxKSlYoHn74YauR9cILL6ihoUHjzefzqbS0VBs3blRubu64X3+ii01Pl8vtkTnUd/TYCeXn56qvzz7vJsTHKS4udvjYjDnXdMHRNdNSU+QZVY51dHRa+cuOOTM3Iz016Fxzc6u6uruvGmOm6+LFDpVOr5QrLt5R+gCMP39SkgyvV30ej840NOrChRar3uuEWaaN3jK6ra1dFzs6beN8Xq9SUpKCzjU1XVCvg2egWXabZfiQvr5+nWsau/w2n1fZWRlKS89QKNLT0/Xyyy9b5VhdXZ26HNTHr7WMjAwtX75c69evH/drT3QxQ7seeDw69VGDmlta1dV19XJprPZWa2ubOjodtLd8PmuVwGjnzp1Xn4MO/svLb7O+2nR+7PL7wvlm5efnKDnD2WoaAOFvkx49dtJqBzkpS+NiY6xVvEPMVzF83Njk6JopyYnWdYaYzz/zOehE1uXPwLZ2q10w1uTE5uYWlQfK5Ep1tuPMkHXr1ik+Pl5bt27V6dPjP+BnttuLi4v12GOPWV9xZZtU7kt59+hJuUpc6untnZj9KZ+iv3SwP6VNZYFyuZJTHKUPwCB62hG18hYuVON77ym3qECpqcn664svO4q7+aaFSh/VOfrxx+e0a/fbtnFej0er7lwWdO7DuiM6dtx+dU5hQY4WzK8JOrfrrf1jVtxMhs+nmx78ugoUGnOQ7YknnggxCri2cufN0/t/+IMSAhWqKM3Xrl171XS+2TZuetVUVU4b2Rqrt7dXO3a+5eiat3z2M9Z79YacPduot/55wFEH550rbws6d/DDwzp+4tTYgS6XeuctUrXhbMLBaGvXrrU+mHhy58/Xwa1blVQxTeWl+dqxc5ejwbfZsyqtd6+ObiA5zbu333ajkpJGttb86HSD9u1/zzYuLi5GKz53c9C59z+oU/2pM2MHulzqX3qbZjpKHYBwcBmG8ubPV/1rr6liZpXVYbjz9d2OYtesXh404Hfk6H/0Yd1RRx2NS2+cH3Ru775/6UKzfUflzBkVqgiMbG3Y09Pt6BkYm5amZRufVmhTZwYH/VgRMDF5YmKUPWeOGvbuVdWcmWprbdc/du2zjXMbhu5avTzoXN2hY1b+tZOXl61FC68POvfW7rfVfrHDNnZO9XSVlU4ZPu7o6HCUdw81NGnZj2ZopGsUwESTXVMjt98vf2m5KqcW6u1976jh7DnbuEB5sWbNqgw657Rev2TxXOVkj0wGMCcQvP7GHts4s9S+e83ng84dPnxchw4ft43tqJqteZ9iIt+qVausDyaenBtu0Lu//70SAgFVlORr9+79jiaTVlWWq6py6vCxOWnLad4d9/5Sl0vd1y9UDQsFgJAw4IeoNfOBB6xVfqUrVqi3qUnG/uDC5Wq8X/m2/JXTRo537pRx8se2ca64OPkf/2nQOffPfy5j2zbbWPdnlsi/4YdB54y6e2Q0No5xQZc1m+fAc39U/m3LrE4fIJLk1NToxs2blVpWpviMdBnr1smoq7ON83zhbvnX3jNyorVVxt4PHF3T9/B35A8Eho+9r74qo/4p2zgjIfHK+/tnP5OxffsYUeY96tbBV3ao/KGPlJif7yiNmPgKFi3SkqefVubMmYpNTJSxZo2M+sH3ko7Fe9c98q8eaTD3NDTIeMc+z5t833xU/qKikd/197/LOPMr2zgjM+vKvLtpk4w33rDNux+8tE1l6x9UXEZoK2sAjJ/FTz2l49u2qeSOO3Tm1VdkHPmOozj/xp/IcI9MRvH89ncy2v5sG+eePfuKZ4px+iEZx+wHC72rvih/be3wcb9VP7fZXt5lqMvt1vtbtmjhxo2210DkWPrMMzr5yisqWbFCJ1/8m4wTG2xjXF7fFfnP86tfy+h80TbWs2CB/I8HT3g0jtwno+GMfd6tXSf/HXcMH3fV18t497BNYg11uN3699atmvvd79peA0B4ZFRWaukvfqH4nBwl5eXJ/dCXZezfbxvnuf0L8n/5weHjgf5+GbvecXRN3/qvyV8zZ+R4zx4ZR39gH+hyXfkM/M1vZFz8i229/sjuPQocPqxU3ikbNcyJM0s3b1ZySYkSMjNk3HefjIP2r+3xrLhL/vtGXq3jam+Xsef9CdhfOph363a+rqn19UoqLHSURgAM+CGKmbOWp65ePXiQlqaq9Q84ikuoqJCRlT18nDK72lGs2+cLijMVLrtdsYUjHbRXYw54XB4bWLtOPe1XXzFidtIk5OUpf/FiBvsQsQqXLBn+vnTN3co9e9Y2JmvevKD7xZuU7Pj+jguY93fW8HFK9RxHsR6//xPv77gp1419vcxMqyLOYF/0mXLzyKq5qV/6kjrP22+DkrFgQVA+8sfEOs67MSWlMoa2QDNXrsyd5yjWZw5IXpZ3iz73eWt14ljlZ2xmpjVrlME+YOKvlCpbudL6PmFqwPEzxZ2dE1R/zL3pJhnJ9mvoEgsKrnimlNXWquOc/WqIzIULg2J9CYm26TXr1+Y1p9xyi+3vR2Txxcer9NIgWlLVdEd512z/XJ7/8m69VT4H24+nlJR8QntrrbpaWmxjzTJ3dGyMz2+bXrPumFhUFFRfADAxmavlhxSvvFPpc4J3X/ok2dXVQc8Fc8DPaRmcWFUVFJs4fYajWLOOfsUz8LM3y2Oz7bW59WPmrFkM9kWhgsWLh78vvWuNchy8DiR77tzg/pTu7gnbX2r2p2RVVzPYB4TINWBuNA0AAAAAAAAAAAAgIrEHIAAAAAAAAAAAABDBGPADAAAAAAAAAAAAIhgDfgAAAAAAAAAAAEAEY8APAAAAAAAAAAAAiGAM+AEAAAAAAAAAAAARjAE/AAAAAAAAAAAAIIIx4AcAAAAAAAAAAABEMAb8AAAAAAAAAAAAgAjGgB8AAAAAAAAAAAAQwRjwAwAAAAAAAAAAACIYA34AAAAAAAAAAABABGPADwAAAAAAAAAAAFDk+i/dL1a2o2NDnAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Add T1/T2 noise to the deep VQC circuit\n", + "T1 = 100 # microseconds (typical for superconducting qubits)\n", + "T2 = 80 # Less than 2*T1 to see pure dephasing (λ2)\n", + "\n", + "noisy_deep_vqc = add_time_based_noise(\n", + " circuit=deep_vqc,\n", + " num_qubits=n_qubits,\n", + " T1=T1,\n", + " T2=T2,\n", + ")\n", + "\n", + "print(f\"\\n=== NOISY DEEP VQC (T1={T1}μs, T2={T2}μs) ===\")\n", + "print(f\"Original gates: {len(deep_vqc)}\")\n", + "print(f\"With noise operations: {len(noisy_deep_vqc)}\")\n", + "# print(\"\\nNoise operations:\")\n", + "# for op in noisy_deep_vqc:\n", + "# if op[0] == 'T1T2_NOISE':\n", + "# print(f\" {op[0]} on q{op[1][0]}: λ1={op[2]:.4f}, λ2={op[3]:.6f}, idle={op[4]:.1f}μs\")\n", + "# else:\n", + "# print(f\" {op}\")\n", + "\n", + "draw_circuit(noisy_deep_vqc, n_qubits, \n", + " title=f\"Deep VQC with T1/T2 Noise ({depth} layers, T1={T1}μs, T2={T2}μs)\",\n", + " figsize=(18, 4))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "abf17878-649d-4348-a969-e75987bc3ddd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Since this circuit is so small, errors have little time to happen. See the gate times (μs): {'CNOT': 0.2, 'RY': 0.025, 'H': 0.025}\n" + ] + } + ], + "source": [ + "# Compare measurement outcomes: Ideal vs Noisy (Deep VQC)\n", "SHOTS = 5000\n", + "T1 = 50\n", + "T2 = 50\n", "\n", - "# Ideal execution\n", "init_state = zero_state(n_qubits)\n", - "ideal_state = apply_circuit_to_ket(init_state, vqc_circuit, n_qubits)\n", - "ideal_counts = measure(ideal_state, shots=SHOTS)\n", "\n", - "# Noisy execution (using density matrix)\n", + "clean_circuit = [op for op in deep_vqc if op[0] != \"T1T2_NOISE\"]\n", + "ideal_density = run_noisy_circuit_density(\n", + " initial_state=init_state,\n", + " circuit=clean_circuit,\n", + " num_qubits=n_qubits,\n", + " T1=0,\n", + " T2=0,\n", + ")\n", + "# # Ideal execution (noise OFF: T1 inf\n", + "# ideal_density = run_noisy_circuit_density(\n", + "# initial_state=init_state,\n", + "# circuit=deep_vqc,\n", + "# num_qubits=n_qubits,\n", + "# T1=10e90,\n", + "# T2=10e90,\n", + "# )\n", + "\n", + "# Sample from ideal density matrix\n", + "probs_ideal = torch.real(torch.diag(ideal_density)).numpy()\n", + "probs_ideal = np.maximum(probs_ideal, 0)\n", + "probs_ideal = probs_ideal / probs_ideal.sum()\n", + "\n", + "ideal_counts = {}\n", + "outcomes = np.random.choice(2**n_qubits, size=SHOTS, p=probs_ideal)\n", + "for o in outcomes:\n", + " bitstr = format(o, f'0{n_qubits}b')\n", + " ideal_counts[bitstr] = ideal_counts.get(bitstr, 0) + 1\n", + "\n", + "# Noisy execution (with T1/T2 decoherence)\n", "noisy_density = run_noisy_circuit_density(\n", " initial_state=init_state,\n", - " circuit=vqc_circuit,\n", + " circuit=deep_vqc,\n", " num_qubits=n_qubits,\n", " T1=T1,\n", " T2=T2,\n", - " gate_durations=gate_durations\n", ")\n", "\n", "# Sample from noisy density matrix\n", "probs_noisy = torch.real(torch.diag(noisy_density)).numpy()\n", - "probs_noisy = np.maximum(probs_noisy, 0) # Ensure non-negative\n", - "probs_noisy = probs_noisy / probs_noisy.sum() # Normalize\n", + "probs_noisy = np.maximum(probs_noisy, 0)\n", + "probs_noisy = probs_noisy / probs_noisy.sum()\n", "\n", "noisy_counts = {}\n", - "outcomes = np.random.choice(4, size=SHOTS, p=probs_noisy)\n", + "outcomes = np.random.choice(2**n_qubits, size=SHOTS, p=probs_noisy)\n", "for o in outcomes:\n", - " bitstr = format(o, '02b')\n", + " bitstr = format(o, f'0{n_qubits}b')\n", " noisy_counts[bitstr] = noisy_counts.get(bitstr, 0) + 1\n", "\n", + "# Calculate fidelity\n", + "fidelity = torch.real(torch.trace(ideal_density @ noisy_density)).item()\n", + "\n", "# Plot comparison\n", - "fig, axes = plt.subplots(1, 2, figsize=(12, 4))\n", - "basis_labels = ['00', '01', '10', '11']\n", + "basis_labels = [format(i, f'0{n_qubits}b') for i in range(2**n_qubits)]\n", + "fig, axes = plt.subplots(1, 3, figsize=(18, 4), constrained_layout=True)\n", "\n", "# Ideal\n", "ax = axes[0]\n", "values = [ideal_counts.get(b, 0) / SHOTS for b in basis_labels]\n", "ax.bar(basis_labels, values, color='#4CAF50', edgecolor='black', alpha=0.8)\n", - "ax.set_title('Ideal Circuit\\n(No Noise)', fontsize=12, fontweight='bold')\n", + "ax.set_title('Ideal Circuit\\n(T1=∞, T2=∞)', fontsize=12, fontweight='bold')\n", "ax.set_ylabel('Probability')\n", "ax.set_xlabel('Measurement Outcome')\n", "ax.set_ylim(0, 1)\n", - "for i, v in enumerate(values):\n", - " if v > 0.01:\n", - " ax.text(i, v + 0.02, f'{v:.3f}', ha='center', fontsize=10)\n", "\n", "# Noisy\n", "ax = axes[1]\n", @@ -758,26 +922,43 @@ "ax.set_ylabel('Probability')\n", "ax.set_xlabel('Measurement Outcome')\n", "ax.set_ylim(0, 1)\n", - "for i, v in enumerate(values):\n", - " if v > 0.01:\n", - " ax.text(i, v + 0.02, f'{v:.3f}', ha='center', fontsize=10)\n", "\n", - "plt.suptitle('Effect of T1/T2 Noise on Measurement Distributions', fontsize=14, fontweight='bold', y=1.02)\n", - "plt.tight_layout()\n", - "plt.show()" + "# Difference\n", + "ax = axes[2]\n", + "ideal_probs = [ideal_counts.get(b, 0) / SHOTS for b in basis_labels]\n", + "noisy_probs = [noisy_counts.get(b, 0) / SHOTS for b in basis_labels]\n", + "diffs = [abs(i - n) for i, n in zip(ideal_probs, noisy_probs)]\n", + "colors = ['#FF9800' if d > 0.05 else '#FFC107' for d in diffs]\n", + "ax.bar(basis_labels, diffs, color=colors, edgecolor='black', alpha=0.8)\n", + "ax.set_title(f'Probability Difference\\nFidelity={fidelity:.4f}', fontsize=12, fontweight='bold')\n", + "ax.set_ylabel('|ΔP|')\n", + "ax.set_xlabel('Measurement Outcome')\n", + "\n", + "fig.suptitle('Effect of T1/T2 Noise on Deep VQC (Same Simulation Method)', fontsize=14, fontweight='bold')\n", + "plt.show()\n", + "\n", + "from constants import DEFAULT_GATE_DURATIONS\n", + "print(\"Since this circuit is so small, errors have little time to happen. See the gate times (μs):\", DEFAULT_GATE_DURATIONS)" ] }, { "cell_type": "code", - "execution_count": 13, - "id": "f31a5bca", + "execution_count": 16, + "id": "373efff2-e22f-4fe3-9561-03abec549463", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "check fidel: 1.0000004768371582\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -788,153 +969,342 @@ "output_type": "stream", "text": [ "\n", - "=== FIDELITY SUMMARY ===\n", - "T1= 10μs, T2= 20μs → Fidelity = 0.9888\n", - "T1= 50μs, T2= 100μs → Fidelity = 0.9976\n", - "T1= 100μs, T2= 200μs → Fidelity = 0.9988\n", - "T1= 500μs, T2=1000μs → Fidelity = 0.9998\n", - "T1=1000μs, T2=2000μs → Fidelity = 0.9999\n" + "============================================================\n", + "FIDELITY SUMMARY (Deep VQC: Ideal T1=∞ vs Noisy T1=T2)\n", + "============================================================\n", + "T1=1.00e+00μs, T2=1.00e+00μs → F=0.5104 (degradation: 49.0%)\n", + "T1=1.00e+01μs, T2=1.00e+01μs → F=0.9260 (degradation: 7.4%)\n", + "T1=1.00e+02μs, T2=1.00e+02μs → F=0.9922 (degradation: 0.8%)\n", + "T1=5.00e+02μs, T2=5.00e+02μs → F=0.9984 (degradation: 0.2%)\n", + "T1=1.00e+03μs, T2=1.00e+03μs → F=0.9992 (degradation: 0.1%)\n", + "T1=1.00e+06μs, T2=1.00e+06μs → F=1.0000 (degradation: 0.0%)\n", + "T1=1.00e+09μs, T2=1.00e+09μs → F=1.0000 (degradation: -0.0%)\n", + "============================================================\n" ] } ], "source": [ - "# Sweep over different noise levels\n", - "T1_values = [10, 50, 100, 500, 1000] # Different T1 times\n", + "# Sweep over different noise levels (Deep VQC)\n", + "T1_values = [1, 10, 100, 500, 1000, 1e6, 1e9] # μs\n", + "T2_values = T1_values # T2 = T1 for simplicity\n", "fidelities = []\n", "\n", - "for T1 in T1_values:\n", - " T2 = 2 * T1 # T2 is typically ≤ 2*T1\n", - " \n", + "init_state = zero_state(n_qubits)\n", + "\n", + "# # Reference: ideal state (noise OFF, T1,T2 = \\inf)\n", + "# ideal_density = run_noisy_circuit_density(\n", + "# initial_state=init_state,\n", + "# circuit=deep_vqc,\n", + "# num_qubits=n_qubits,\n", + "# T1=10e90,\n", + "# T2=10e90,\n", + "# )\n", + "clean_circuit = [op for op in deep_vqc if op[0] != \"T1T2_NOISE\"]\n", + "ideal_density = run_noisy_circuit_density(\n", + " initial_state=init_state,\n", + " circuit=clean_circuit,\n", + " num_qubits=n_qubits,\n", + " T1=0,\n", + " T2=0,\n", + ")\n", + "for T1, T2 in zip(T1_values, T2_values):\n", " noisy_density = run_noisy_circuit_density(\n", " initial_state=init_state,\n", - " circuit=vqc_circuit,\n", + " circuit=deep_vqc,\n", " num_qubits=n_qubits,\n", " T1=T1,\n", " T2=T2,\n", - " gate_durations=gate_durations\n", " )\n", - " \n", - " # Calculate fidelity with ideal state\n", - " ideal_density = state_to_density(ideal_state)\n", " fidelity = torch.real(torch.trace(ideal_density @ noisy_density)).item()\n", " fidelities.append(fidelity)\n", "\n", + "print(f\"check fidel: {torch.real(torch.trace(ideal_density @ ideal_density)).item()}\")\n", + "\n", "# Plot fidelity vs T1\n", - "fig, ax = plt.subplots(figsize=(8, 5))\n", - "ax.plot(T1_values, fidelities, 'o-', markersize=10, linewidth=2, color='#2196F3')\n", - "ax.axhline(y=1.0, color='green', linestyle='--', alpha=0.5, label='Ideal (F=1)')\n", - "ax.set_xlabel('T1 (μs)', fontsize=12)\n", - "ax.set_ylabel('Fidelity with Ideal State', fontsize=12)\n", - "ax.set_title('State Fidelity vs Coherence Time T1', fontsize=14, fontweight='bold')\n", + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "ax.plot(T1_values, fidelities, 'o-', markersize=8, linewidth=2.5,\n", + " color='#2196F3', label='Noisy vs Ideal')\n", + "# ax.axhline(y=1.0, color='green', linestyle='--', alpha=0.6, linewidth=2,\n", + "# label='Perfect Fidelity (F=1)')\n", + "# ax.axhline(y=0.9, color='orange', linestyle=':', alpha=0.5, linewidth=1.5,\n", + "# label='Good Fidelity (F=0.9)')\n", + "\n", + "ax.set_xlabel('T1 = T2 (μs)', fontsize=12)\n", + "ax.set_ylabel('State Fidelity', fontsize=12)\n", + "ax.set_title('State Fidelity vs Coherence Time (Deep VQC)', fontsize=14, fontweight='bold')\n", "ax.set_xscale('log')\n", - "ax.set_ylim(0, 1.1)\n", - "ax.grid(True, alpha=0.3)\n", - "ax.legend()\n", + "# ax.set_ylim(0.1, 1.01)\n", + "ax.grid(True, alpha=0.3, which='both')\n", + "ax.legend(fontsize=11, loc='lower right')\n", "\n", "for x, y in zip(T1_values, fidelities):\n", - " ax.annotate(f'{y:.3f}', (x, y), textcoords=\"offset points\", xytext=(0, 10), ha='center')\n", + " if y < 0.95:\n", + " ax.annotate(f'{y:.3f}', (x, y), textcoords=\"offset points\",\n", + " xytext=(0, 10), ha='center', fontsize=9)\n", "\n", "plt.tight_layout()\n", "plt.show()\n", "\n", - "print(\"\\n=== FIDELITY SUMMARY ===\")\n", - "for t1, f in zip(T1_values, fidelities):\n", - " print(f\"T1={t1:4d}μs, T2={2*t1:4d}μs → Fidelity = {f:.4f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "dd75a3bc", - "metadata": {}, - "source": [ - "---\n", - "## 4. Deep VQC Architecture\n", - "\n", - "Our deep variational quantum circuit uses multiple layers of parameterized gates." + "print(\"\\n\" + \"=\"*60)\n", + "print(\"FIDELITY SUMMARY (Deep VQC: Ideal T1=∞ vs Noisy T1=T2)\")\n", + "print(\"=\"*60)\n", + "for (t1, t2), f in zip(zip(T1_values, T2_values), fidelities):\n", + " deg_pct = (1 - f) * 100\n", + " print(f\"T1={t1:>8.2e}μs, T2={t2:>8.2e}μs → F={f:.4f} (degradation: {deg_pct:5.1f}%)\")\n", + "print(\"=\"*60)" ] }, { "cell_type": "code", - "execution_count": 14, - "id": "4bcab0e6", + "execution_count": 17, + "id": "dc50f732-9664-4260-88d6-de4bfb1a8ac6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "=== DEEP VQC (3 layers) ===\n", - "Total gates: 14\n", - "Trainable parameters: 9\n" + "check fidel: 1.0000005960464478\n" ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "# Build a 3-layer deep VQC circuit\n", "depth = 3\n", "x_input = torch.tensor([0.5, -0.3])\n", - "theta = torch.randn(depth * 3) # 3 parameters per layer\n", + "theta = torch.randn(depth * 3)\n", "\n", - "# Construct the full circuit\n", - "deep_vqc = []\n", + "deep_vqc_clean = []\n", + "deep_vqc_clean += param_gate_layer(\"RY\", x_input)\n", "\n", - "# Encoding layer\n", - "deep_vqc += param_gate_layer(\"RY\", x_input)\n", - "\n", - "# Variational layers\n", "idx = 0\n", "for layer in range(depth):\n", - " deep_vqc.append((\"RY\", [0], theta[idx].item()))\n", - " deep_vqc.append((\"RY\", [1], theta[idx+1].item()))\n", - " deep_vqc.append((\"CNOT\", [0, 1]))\n", - " deep_vqc.append((\"RZ\", [0], theta[idx+2].item()))\n", + " deep_vqc_clean.append((\"RY\", [0], theta[idx].item()))\n", + " deep_vqc_clean.append((\"RY\", [1], theta[idx+1].item()))\n", + " deep_vqc_clean.append((\"CNOT\", [0, 1]))\n", + " deep_vqc_clean.append((\"RZ\", [0], theta[idx+2].item()))\n", " idx += 3\n", "\n", - "print(f\"=== DEEP VQC ({depth} layers) ===\")\n", - "print(f\"Total gates: {len(deep_vqc)}\")\n", - "print(f\"Trainable parameters: {len(theta)}\")\n", + "# NOW use this for ideal\n", + "ideal_density = run_noisy_circuit_density(\n", + " initial_state=zero_state(n_qubits),\n", + " circuit=deep_vqc_clean,\n", + " num_qubits=n_qubits,\n", + " T1=0,\n", + " T2=0,\n", + ")\n", "\n", - "draw_circuit(deep_vqc, n_qubits, \n", - " title=f\"Deep Variational Quantum Circuit ({depth} layers)\",\n", - " figsize=(18, 3))\n", - "plt.show()" + "print(f\"check fidel: {torch.real(torch.trace(ideal_density @ ideal_density)).item()}\")" ] }, { - "cell_type": "markdown", - "id": "37b24106", + "cell_type": "code", + "execution_count": 18, + "id": "de989167-3a6b-4787-8188-9b3f6e596d6a", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Purity of H|00⟩: 0.9999998807907104\n" + ] + } + ], "source": [ - "---\n", - "## Summary\n", + "trivial_circuit = [(\"H\", [0])] # Just one Hadamard\n", "\n", - "This demo covered:\n", + "test_density = run_noisy_circuit_density(\n", + " initial_state=zero_state(2),\n", + " circuit=trivial_circuit,\n", + " num_qubits=2,\n", + " T1=0,\n", + " T2=0,\n", + ")\n", "\n", - "| Component | Description |\n", - "|-----------|-------------|\n", - "| **Angle Encoding** | Maps N features to N qubits via RY rotations |\n", - "| **Amplitude Encoding** | Maps 2^N amplitudes directly to N qubit state |\n", - "| **Quantum Kernel** | Uses feature map + inner product for similarity |\n", - "| **T1/T2 Noise** | Models thermal relaxation in real quantum hardware |\n", - "| **Deep VQC** | Multi-layer variational circuit for classification |\n", + "purity = torch.real(torch.trace(test_density @ test_density)).item()\n", + "print(f\"Purity of H|00⟩: {purity}\") # Should be ~1.0" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "db01a416-84e0-4108-8d78-859f4959fbba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First 10 ops in deep_vqc_clean:\n", + " 0: ('RY', [0], tensor(0.5000))\n", + " 1: ('RY', [1], tensor(-0.3000))\n", + " 2: ('RY', [0], 1.0908966064453125)\n", + " 3: ('RY', [1], 0.7662184238433838)\n", + " 4: ('CNOT', [0, 1])\n", + " 5: ('RZ', [0], -0.38620418310165405)\n", + " 6: ('RY', [0], -1.9084150791168213)\n", + " 7: ('RY', [1], 2.223785638809204)\n", + " 8: ('CNOT', [0, 1])\n", + " 9: ('RZ', [0], -1.0458203554153442)\n", + "\n", + "Total ops: 14\n" + ] + } + ], + "source": [ + "print(\"First 10 ops in deep_vqc_clean:\")\n", + "for i, op in enumerate(deep_vqc_clean[:10]):\n", + " print(f\" {i}: {op}\")\n", + " # Check for NaN/Inf in parameters\n", + " if len(op) > 2 and op[2] is not None:\n", + " param = op[2]\n", + " if isinstance(param, torch.Tensor):\n", + " if torch.isnan(param).any() or torch.isinf(param).any():\n", + " print(f\" ⚠ BAD PARAM: {param}\")\n", + " elif isinstance(param, float):\n", + " if math.isnan(param) or math.isinf(param):\n", + " print(f\" ⚠ BAD PARAM: {param}\")\n", "\n", - "The noise model shows how hardware imperfections degrade quantum state fidelity, motivating our noise-aware training approach." + "print(f\"\\nTotal ops: {len(deep_vqc_clean)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "7e9e11cf-98c4-42c7-8222-3fad4cd5f9dc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Encoding layer (2 ops):\n", + " ('RY', [0], tensor(0.5000))\n", + " ('RY', [1], tensor(-0.3000))\n" + ] + } + ], + "source": [ + "# What does the encoding layer look like?\n", + "encoding = param_gate_layer(\"RY\", torch.tensor([0.5, -0.3]))\n", + "print(f\"Encoding layer ({len(encoding)} ops):\")\n", + "for op in encoding:\n", + " print(f\" {op}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "dd6307c5-0207-462a-bf20-83b52a6a6f23", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Purity after 2 CNOTs: 1.0\n" + ] + } + ], + "source": [ + "# Test: 2 CNOTs\n", + "two_cnots = [(\"CNOT\", [0, 1]), (\"CNOT\", [0, 1])]\n", + "test_density = run_noisy_circuit_density(\n", + " initial_state=zero_state(2),\n", + " circuit=two_cnots,\n", + " num_qubits=2,\n", + " T1=0,\n", + " T2=0,\n", + ")\n", + "purity = torch.real(torch.trace(test_density @ test_density)).item()\n", + "print(f\"Purity after 2 CNOTs: {purity}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "a96936e9-09d3-4f4b-9afb-d78a6fa33480", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Purity after 1 RY: 1.000000238418579\n", + "Purity after RY+RY: 1.000000238418579\n", + "Purity after RY+CNOT: 1.000000238418579\n" + ] + } + ], + "source": [ + "# Test: one RY\n", + "one_ry = [(\"RY\", [0], 0.5)]\n", + "test_density = run_noisy_circuit_density(\n", + " initial_state=zero_state(2),\n", + " circuit=one_ry,\n", + " num_qubits=2,\n", + " T1=0,\n", + " T2=0,\n", + ")\n", + "purity = torch.real(torch.trace(test_density @ test_density)).item()\n", + "print(f\"Purity after 1 RY: {purity}\")\n", + "\n", + "# Test: two RYs in sequence\n", + "two_rys = [(\"RY\", [0], 0.5), (\"RY\", [1], -0.3)]\n", + "test_density = run_noisy_circuit_density(\n", + " initial_state=zero_state(2),\n", + " circuit=two_rys,\n", + " num_qubits=2,\n", + " T1=0,\n", + " T2=0,\n", + ")\n", + "purity = torch.real(torch.trace(test_density @ test_density)).item()\n", + "print(f\"Purity after RY+RY: {purity}\")\n", + "\n", + "# Test: RY then CNOT\n", + "ry_cnot = [(\"RY\", [0], 0.5), (\"CNOT\", [0, 1])]\n", + "test_density = run_noisy_circuit_density(\n", + " initial_state=zero_state(2),\n", + " circuit=ry_cnot,\n", + " num_qubits=2,\n", + " T1=0,\n", + " T2=0,\n", + ")\n", + "purity = torch.real(torch.trace(test_density @ test_density)).item()\n", + "print(f\"Purity after RY+CNOT: {purity}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "dcc190ff-ee94-4f4e-98ff-c76d0995f1d3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Purity after 1 RY: 1.000000238418579\n" + ] + } + ], + "source": [ + "one_ry = [(\"RY\", [0], 0.5)]\n", + "test_density = run_noisy_circuit_density(\n", + " initial_state=zero_state(2),\n", + " circuit=one_ry,\n", + " num_qubits=2,\n", + " T1=0,\n", + " T2=0,\n", + ")\n", + "purity = torch.real(torch.trace(test_density @ test_density)).item()\n", + "print(f\"Purity after 1 RY: {purity}\") # Should now be ~1.0" ] }, { "cell_type": "code", "execution_count": null, - "id": "ad7fa1b4-ca93-4d3f-a645-e87d35238280", + "id": "dcc23318-452e-4fea-b6c7-e286ea61997b", "metadata": {}, "outputs": [], "source": [] @@ -942,7 +1312,7 @@ { "cell_type": "code", "execution_count": null, - "id": "5f90b8a0-e3ae-49c3-abe9-cc47a3f688de", + "id": "15a43128-e918-4a06-ba0e-f51102a9439c", "metadata": {}, "outputs": [], "source": [] @@ -964,7 +1334,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.12" + "version": "3.11.14" } }, "nbformat": 4, diff --git a/error_kraus.py b/error_kraus.py index 6a09112..1816cc6 100644 --- a/error_kraus.py +++ b/error_kraus.py @@ -1,6 +1,7 @@ from typing import List, Tuple, Dict import math import torch +from constants import DEFAULT_GATE_DURATIONS # ============================================================ # Notes on Realistic Superconducting Transmon Parameters @@ -176,7 +177,7 @@ def add_time_based_noise( num_qubits: int, T1: float, T2: float, - gate_durations: Dict[str, float], + gate_durations: Dict[str, float] | None = None, gate_noise_fraction: float = 1.0, ) -> List[Tuple]: """ @@ -199,6 +200,9 @@ def add_time_based_noise( Returns: Extended circuit with T1T2_NOISE operations inserted. """ + if gate_durations is None: + gate_durations = dict(DEFAULT_GATE_DURATIONS) + gate_noise_fraction = max(0.0, min(1.0, gate_noise_fraction)) # clamp to [0, 1] accounted_for_time = [0.0] * num_qubits @@ -221,11 +225,12 @@ def add_time_based_noise( for q in acted_on: if accounted_for_time[q] < max_time: idle = max_time - accounted_for_time[q] - if idle in relax_cache: - λ1, λ2 = relax_cache[idle] + cache_key = (idle, T1, T2) + if cache_key in relax_cache: + λ1, λ2 = relax_cache[cache_key] else: λ1, λ2 = thermal_relaxation_error_rate(T1, T2, idle) - relax_cache[idle] = (λ1, λ2) + relax_cache[cache_key] = (λ1, λ2) if λ1 > 0.0 or λ2 > 0.0: noisy_circuit.append( ("T1T2_NOISE", [q], λ1, λ2, idle) @@ -236,11 +241,12 @@ def add_time_based_noise( # This models T1/T2 relaxation that occurs even while a gate is applied if gate_noise_fraction > 0.0 and time_to_elapse > 0.0: noise_time = time_to_elapse * gate_noise_fraction - if noise_time in relax_cache: - λ1, λ2 = relax_cache[noise_time] + cache_key = (noise_time, T1, T2) + if cache_key in relax_cache: + λ1, λ2 = relax_cache[cache_key] else: λ1, λ2 = thermal_relaxation_error_rate(T1, T2, noise_time) - relax_cache[noise_time] = (λ1, λ2) + relax_cache[cache_key] = (λ1, λ2) if λ1 > 0.0 or λ2 > 0.0: for q in acted_on: noisy_circuit.append( @@ -257,11 +263,12 @@ def add_time_based_noise( for q in range(num_qubits): if accounted_for_time[q] < end_time: idle = end_time - accounted_for_time[q] - if idle in relax_cache: - λ1, λ2 = relax_cache[idle] + cache_key = (idle, T1, T2) + if cache_key in relax_cache: + λ1, λ2 = relax_cache[cache_key] else: λ1, λ2 = thermal_relaxation_error_rate(T1, T2, idle) - relax_cache[idle] = (λ1, λ2) + relax_cache[cache_key] = (λ1, λ2) if λ1 > 0.0 or λ2 > 0.0: noisy_circuit.append( ("T1T2_NOISE", [q], λ1, λ2, idle) diff --git a/quantum_simulator.py b/quantum_simulator.py index 4b1db8a..44005b2 100644 --- a/quantum_simulator.py +++ b/quantum_simulator.py @@ -279,50 +279,55 @@ def apply_single_qubit_gate_density( ) -> torch.Tensor: """ Apply single-qubit unitary U to qubit q on density matrix. - ρ' = (U ⊗ I) ρ (U† ⊗ I), implemented via tensor contractions. - """ - # Cache permutation orders to reduce Python overhead per gate application - key = (num_qubits, q) - if not hasattr(apply_single_qubit_gate_density, "_perm_cache"): - apply_single_qubit_gate_density._perm_cache = {} - perm_cache = apply_single_qubit_gate_density._perm_cache - - if key in perm_cache: - row_order, final_order = perm_cache[key] - else: - remaining_rows = [i for i in range(num_qubits) if i != q] - row_order = [] - for i in range(num_qubits): - if i == q: - row_order.append(0) # U_out - else: - idx = remaining_rows.index(i) - row_order.append(1 + idx) + # ρ' = (U ⊗ I) ρ (U† ⊗ I), implemented via tensor contractions. + # """ + # # Cache permutation orders to reduce Python overhead per gate application + # key = (num_qubits, q) + # if not hasattr(apply_single_qubit_gate_density, "_perm_cache"): + # apply_single_qubit_gate_density._perm_cache = {} + # perm_cache = apply_single_qubit_gate_density._perm_cache + + # if key in perm_cache: + # row_order, final_order = perm_cache[key] + # else: + # remaining_rows = [i for i in range(num_qubits) if i != q] + # row_order = [] + # for i in range(num_qubits): + # if i == q: + # row_order.append(0) # U_out + # else: + # idx = remaining_rows.index(i) + # row_order.append(1 + idx) + + # remaining_cols = [i for i in range(num_qubits) if i != q] + # final_order = list(range(1, 1 + num_qubits)) # rows stay in order + # for i in range(num_qubits): + # if i == q: + # final_order.append(0) # Uc_out + # else: + # idx = remaining_cols.index(i) + # final_order.append(1 + num_qubits + idx) + + # perm_cache[key] = (row_order, final_order) + + # # Reshape density into (row qubits, column qubits) + # ρ = density.reshape([2]*num_qubits + [2]*num_qubits) + + # # Left multiply on row axis q: contract U(in) with row[q] + # tmp = torch.tensordot(U, ρ, dims=([1], [q])) # U_out + row_rem + col + # tmp = tmp.permute(row_order + list(range(num_qubits, num_qubits + num_qubits))) + + # # Right multiply on column axis q + # U_dag = U.conj().transpose(0, 1) + # tmp2 = torch.tensordot(U_dag, tmp, dims=([1], [num_qubits + q])) # Uc_out + row + col_rem + + # ρ_final = tmp2.permute(final_order).reshape(2**num_qubits, 2**num_qubits) + # return ρ_final + # ρ' = (U ⊗ I) ρ (U† ⊗ I), via full unitary embedding for correctness. + # Build full unitary and apply via Kraus (known working path) + U_full = build_full_unitary(U, [q], num_qubits) + return kraus_operator(density, [(U_full, 1.0)]) - remaining_cols = [i for i in range(num_qubits) if i != q] - final_order = list(range(1, 1 + num_qubits)) # rows stay in order - for i in range(num_qubits): - if i == q: - final_order.append(0) # Uc_out - else: - idx = remaining_cols.index(i) - final_order.append(1 + num_qubits + idx) - - perm_cache[key] = (row_order, final_order) - - # Reshape density into (row qubits, column qubits) - ρ = density.reshape([2]*num_qubits + [2]*num_qubits) - - # Left multiply on row axis q: contract U(in) with row[q] - tmp = torch.tensordot(U, ρ, dims=([1], [q])) # U_out + row_rem + col - tmp = tmp.permute(row_order + list(range(num_qubits, num_qubits + num_qubits))) - - # Right multiply on column axis q - U_dag = U.conj().transpose(0, 1) - tmp2 = torch.tensordot(U_dag, tmp, dims=([1], [num_qubits + q])) # Uc_out + row + col_rem - - ρ_final = tmp2.permute(final_order).reshape(2**num_qubits, 2**num_qubits) - return ρ_final def apply_two_qubit_gate_density( @@ -484,7 +489,7 @@ def run_noisy_circuit_density( num_qubits: int, T1: float, T2: float, - gate_durations: Dict[str, float], + gate_durations: Dict[str, float]| None = None, gate_noise_fraction: float = 1.0, ) -> torch.Tensor: """ @@ -504,6 +509,9 @@ def run_noisy_circuit_density( Output: density matrix ρ_final (2^n x 2^n) """ + if gate_durations is None: + gate_durations = dict(DEFAULT_GATE_DURATIONS) + # Convert to density matrix density = state_to_density(initial_state) diff --git a/tests/test_quantum_simulator.py b/tests/test_quantum_simulator.py index ab2483e..24eb810 100644 --- a/tests/test_quantum_simulator.py +++ b/tests/test_quantum_simulator.py @@ -480,6 +480,45 @@ def test_add_time_based_noise_two_qubits(self): self.assertEqual(noisy[2][0], "CNOT") self.assertEqual(noisy[2][1], [0, 1]) + def test_add_time_based_noise_respects_T1_T2_cache(self): + """Ensure cached relaxation rates are keyed by T1/T2 so different times yield different λ values.""" + circuit = [("H", [0])] + num_qubits = 1 + gate_durations = {"H": 1.0} + + # Two distinct coherence settings with same idle time (from gate duration) + T1_a, T2_a = 10.0, 12.0 + T1_b, T2_b = 50.0, 80.0 + + noisy_a = add_time_based_noise( + circuit=circuit, + num_qubits=num_qubits, + T1=T1_a, + T2=T2_a, + gate_durations=gate_durations, + gate_noise_fraction=1.0, # ensures one noise op during gate + ) + + noisy_b = add_time_based_noise( + circuit=circuit, + num_qubits=num_qubits, + T1=T1_b, + T2=T2_b, + gate_durations=gate_durations, + gate_noise_fraction=1.0, + ) + + # Both should have: noise op then H + self.assertEqual(noisy_a[0][0], "T1T2_NOISE") + self.assertEqual(noisy_b[0][0], "T1T2_NOISE") + + λ1_a, λ2_a = noisy_a[0][2], noisy_a[0][3] + λ1_b, λ2_b = noisy_b[0][2], noisy_b[0][3] + + # Different T1/T2 must yield different noise parameters + self.assertNotAlmostEqual(λ1_a, λ1_b) + self.assertNotAlmostEqual(λ2_a, λ2_b) + def test_gate_times_realistic_superconducting(self): """Verify gate durations match realistic superconducting transmon hardware (all times in μs).""" # Realistic values in microseconds (1 ns = 0.001 μs) @@ -672,6 +711,53 @@ def test_run_noisy_circuit_density_trace_preserving_high_err(self): tr_final = torch.trace(ρ_final).real.item() self.assertAlmostEqual(tr_final, 1.0, places=6) + def test_single_qubit_gate_density_purity_preserved(self): + """ + Regression test: applying a single-qubit gate to a pure density matrix + should preserve purity (trace of ρ²). + Tests that apply_single_qubit_gate_density doesn't corrupt the state. + """ + n_qubits = 2 + init_state = zero_state(n_qubits) + + # Test single RY gate + circuit = [("RY", [0], 0.5)] + ρ_final = run_noisy_circuit_density( + initial_state=init_state, + circuit=circuit, + num_qubits=n_qubits, + T1=0, + T2=0, + ) + + purity = torch.real(torch.trace(ρ_final @ ρ_final)).item() + self.assertGreater(purity, 0.999, + f"RY gate degraded purity to {purity}; should be ~1.0 for pure state") + + def test_multiple_single_qubit_gates_purity(self): + """ + Verify purity is preserved through multiple single-qubit gate applications. + """ + n_qubits = 2 + init_state = zero_state(n_qubits) + + circuit = [ + ("RY", [0], 0.5), + ("RY", [1], -0.3), + ("RX", [0], 0.7), + ] + ρ_final = run_noisy_circuit_density( + initial_state=init_state, + circuit=circuit, + num_qubits=n_qubits, + T1=0, + T2=0, + ) + + purity = torch.real(torch.trace(ρ_final @ ρ_final)).item() + self.assertGreater(purity, 0.999, + f"Multi-gate circuit degraded purity to {purity}; should be ~1.0") + if __name__ == '__main__': unittest.main() diff --git a/visualizer.py b/visualizer.py index 2d54698..5b0644d 100644 --- a/visualizer.py +++ b/visualizer.py @@ -480,7 +480,8 @@ def plot_accuracy_vs_t1(noise_sweep_results, dataset_name, epochs=None, save=Fal ax.set_ylim(0, 1.05) # Use log scale for x-axis if range is large - if len(t1_values) > 1 and max(t1_values) / min(t1_values) > 10: + nonzero_t1 = [t for t in t1_values if t > 0] + if len(nonzero_t1) > 1 and max(nonzero_t1) / min(nonzero_t1) > 10: ax.set_xscale('log') ax.set_xlabel('T1 Relaxation Time (μs, log scale)', fontsize=12) @@ -680,7 +681,25 @@ def plot_accuracy_vs_epoch(results, dataset, epochs, save=False, T1_filter=None) title += f" (T1={T1_filter} µs)" plt.title(title, fontsize=14, fontweight='bold') - plt.legend(loc='best', fontsize=9, framealpha=0.9) + # Improved legend: place outside plot, organized by model type + ax = plt.gca() + handles, labels = ax.get_legend_handles_labels() + + # Sort labels by model type for better organization + model_order = {'Deep VQC': 0, 'Noise-Aware QNN': 1, 'Quantum Kernel': 2} + def sort_key(item): + label = item[1] + for model_name, order in model_order.items(): + if model_name in label: + return order + return 999 + + sorted_items = sorted(zip(handles, labels), key=sort_key) + handles, labels = zip(*sorted_items) if sorted_items else ([], []) + + ax.legend(handles, labels, loc='upper left', bbox_to_anchor=(1.02, 1), + fontsize=10, framealpha=0.95, edgecolor='black', title='Models', + title_fontsize=11) plt.grid(True, alpha=0.3) plt.tight_layout() From 07614aef05805d1c6ea3d3518820755d996a8d47 Mon Sep 17 00:00:00 2001 From: xoth42 Date: Sat, 20 Dec 2025 15:50:46 -0500 Subject: [PATCH 4/4] demo shows error examples, purity based on noise, circuit examples, runner example --- demos/circuit_visualization.ipynb | 380 +++++------------------------- 1 file changed, 62 insertions(+), 318 deletions(-) diff --git a/demos/circuit_visualization.ipynb b/demos/circuit_visualization.ipynb index ca2f340..5860e00 100644 --- a/demos/circuit_visualization.ipynb +++ b/demos/circuit_visualization.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 24, "id": "757f849c-268c-4ee4-8f6f-6abe39da656a", "metadata": {}, "outputs": [], @@ -26,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 47, "id": "51311e81", "metadata": {}, "outputs": [ @@ -34,27 +34,26 @@ "name": "stdout", "output_type": "stream", "text": [ - "MOONS | NOISE_AWARE | Epoch 01 | Loss 1.3874 | Acc 0.520\n", - "MOONS | NOISE_AWARE | Epoch 02 | Loss 1.3634 | Acc 0.527\n", - "MOONS | NOISE_AWARE | Epoch 03 | Loss 1.3407 | Acc 0.527\n", - "MOONS | NOISE_AWARE | Epoch 04 | Loss 1.3194 | Acc 0.527\n", - "MOONS | NOISE_AWARE | Epoch 05 | Loss 1.2995 | Acc 0.520\n", - "MOONS | NOISE_AWARE | Epoch 06 | Loss 1.2810 | Acc 0.547\n", - "MOONS | NOISE_AWARE | Epoch 07 | Loss 1.2640 | Acc 0.540\n", - "MOONS | NOISE_AWARE | Epoch 08 | Loss 1.2483 | Acc 0.520\n", - "MOONS | NOISE_AWARE | Epoch 09 | Loss 1.2341 | Acc 0.520\n", - "MOONS | NOISE_AWARE | Epoch 10 | Loss 1.2212 | Acc 0.527\n", - "MOONS | NOISE_AWARE | Epoch 11 | Loss 1.2095 | Acc 0.547\n", - "MOONS | NOISE_AWARE | Epoch 12 | Loss 1.1990 | Acc 0.547\n", - "MOONS | NOISE_AWARE | Epoch 13 | Loss 1.1895 | Acc 0.560\n", - "MOONS | NOISE_AWARE | Epoch 14 | Loss 1.1810 | Acc 0.567\n", - "MOONS | NOISE_AWARE | Epoch 15 | Loss 1.1734 | Acc 0.567\n", - " Plot saved: noise_aware_moons_t1200_t2250_eprange(1, 16)_20_1347.png\n" + "MOONS | NOISE_AWARE | Epoch 01 | Loss 1.4617 | Acc 0.500\n", + "MOONS | NOISE_AWARE | Epoch 02 | Loss 1.3499 | Acc 0.507\n", + "MOONS | NOISE_AWARE | Epoch 03 | Loss 1.2426 | Acc 0.513\n", + "MOONS | NOISE_AWARE | Epoch 04 | Loss 1.1419 | Acc 0.540\n", + "MOONS | NOISE_AWARE | Epoch 05 | Loss 1.0494 | Acc 0.553\n", + "MOONS | NOISE_AWARE | Epoch 06 | Loss 0.9662 | Acc 0.580\n", + "MOONS | NOISE_AWARE | Epoch 07 | Loss 0.8926 | Acc 0.633\n", + "MOONS | NOISE_AWARE | Epoch 08 | Loss 0.8286 | Acc 0.680\n", + "MOONS | NOISE_AWARE | Epoch 09 | Loss 0.7736 | Acc 0.707\n", + "MOONS | NOISE_AWARE | Epoch 10 | Loss 0.7269 | Acc 0.753\n", + "MOONS | NOISE_AWARE | Epoch 11 | Loss 0.6877 | Acc 0.773\n", + "MOONS | NOISE_AWARE | Epoch 12 | Loss 0.6550 | Acc 0.787\n", + "MOONS | NOISE_AWARE | Epoch 13 | Loss 0.6280 | Acc 0.807\n", + "MOONS | NOISE_AWARE | Epoch 14 | Loss 0.6057 | Acc 0.813\n", + "MOONS | NOISE_AWARE | Epoch 15 | Loss 0.5874 | Acc 0.820\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -87,7 +86,7 @@ " dataset=\"moons\",\n", " model_type=\"noise_aware\",\n", " title=\"Noise-aware demo\",\n", - " save=True,\n", + " save=False,\n", " T1=T1,\n", " T2=T2,\n", " epochs=epochs,\n", @@ -96,7 +95,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 26, "id": "bb14f9fa", "metadata": {}, "outputs": [], @@ -132,7 +131,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 27, "id": "b61c06cf", "metadata": {}, "outputs": [], @@ -275,7 +274,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 28, "id": "0c31ca5c", "metadata": {}, "outputs": [ @@ -323,7 +322,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 29, "id": "595f3d78", "metadata": {}, "outputs": [ @@ -392,13 +391,13 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 30, "id": "711f939e", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -461,7 +460,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 31, "id": "c03f26fa", "metadata": {}, "outputs": [ @@ -510,7 +509,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 32, "id": "48dee4a6", "metadata": {}, "outputs": [ @@ -595,7 +594,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 33, "id": "73880b24", "metadata": {}, "outputs": [ @@ -640,7 +639,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 34, "id": "50aa648a", "metadata": {}, "outputs": [ @@ -708,7 +707,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 35, "id": "4bcab0e6", "metadata": {}, "outputs": [ @@ -723,7 +722,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABvoAAAEVCAYAAAAhPDKdAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAbLdJREFUeJzt3QWYFPUbwPH3uunulO4SBQEpERBbxI4/Bgo2NliooAJSoggWEiYoKCAigiLSXXJ0HBx5nft/3t+xy15yB3e3N7vfz/PsszW789vZmXln5v2Fl81mswkAAAAAAAAAAAAAS/F2dQEAAAAAAAAAAAAA5B2JPgAAAAAAAAAAAMCCSPQBAAAAAAAAAAAAFkSiDwAAAAAAAAAAALAgEn0AAAAAAAAAAACABZHoAwAAAAAAAAAAACyIRB8AAAAAAAAAAABgQST6AAAAAAAAAAAAAAsi0QcAAAAAAAAAAABYEIk+AAAAwML27t0rXl5ejtsff/xRKPN1nudnn30mVlKjRg1H2YcPH+7q4qAI0XXZed0uqu69915HGTt37lwg8/j1118d8xg0aJAUJP0N9nnpb/NUq1atciyH/v37u7o4AAAAsAgSfQAAAMgTTSQ5XwjXm7+/vxQvXlxq1aol3bp1k9dee00OHDjgVkv2n3/+SfebR44cme20n3/+ebpp58yZI1Zi5SReYVi+fLncf//9Uq9ePQkLC5OAgACpWLGi9OrVSyZOnCixsbFiVYWRQCpsf/31lwwcOFAaN24sJUqUED8/PylTpox07NhRhg0bJrt37xZ3kh//oc1mkxdeeME89vHxkaeffjrd+998840MGDBAGjVqZJalLtPQ0FBp0KCBPPDAA7Ju3bp8+S2epk2bNtKpUyfzePbs2SxHAAAA5Ipv7iYDAAAAspeUlGRuZ8+elT179sjixYvljTfekFdeecXcvL2tX7/s8ssvl/r168v27dvN8y+//FKee+65LKfV9+zKli0r1157bYGVq1SpUjJq1CjH89q1a0thcJ6nXpz2BDExMfK///1PZsyYkem9o0ePmhZQenvnnXdMIqRdu3YuKSfSnDp1yiRkf/zxx0yL5MSJEyZhq7elS5c6WsLquuy8bhdV2tpLE5eqatWq+f79P/zwg6xfv9487tOnj6nEkbEyw7x589K9lpycbPaPevviiy9k1qxZcuONN+Z72dzdkCFDzDqpyVZNRM+dO9fVRQIAAEARR6IPAAAAl+S2226T1q1by5kzZ2Tt2rWyYMECSUlJMTftFlETIJMmTXKLpXzPPfc4Wrls3rzZtLZo0aJFumkOHjwoS5YscTy/4447TGuX/JaYmGguBBcrVkyeeeYZKWyumKcr6bK+/fbb5aeffnK8VrduXbnhhhtMq74VK1bI/PnzzevamrVHjx6mFai2cIJrkrL6H6xevdrxWoUKFeT666+XatWqSVRUlNlfaaUEZ9pCTW8Xuz1q687CcM0115hbQfnoo48cj7PqQjI4ONi0FmzSpImUK1fOJPm05eRvv/1m3tfnL774okcn+nQd031DXmnFEN2va8UZ3adoTKlSpUqBlBEAAABuwgYAAADkwZIlS2x6GGm/TZs2Ld37W7dutdWsWTPdNL/88kum71m/fr3tvvvus9WqVcsWGBhoCwkJsTVv3tz21ltv2aKjo7Oc95kzZ2wjRoywtW3b1lasWDGbn5+frWrVqrZ77rnHtnnz5kzTDxs2zFGG6tWr206dOmUbPHiwrXLlyjZ/f39bgwYNbOPGjbOlpqbm6rcfOnTI5uPj4/jOJ598MtM077zzTrrfvmHDBvP6999/b7vzzjttTZo0sZUrV86UXX+zlmHQoEG2PXv2ZPquTp06Ob5Hf+OmTZts/fr1s5UqVcq8tm7dOvM55/np/2MXHh5uGzJkiK1Dhw62KlWq2IKDg83vrlSpkq1Pnz62uXPnZju/rG66DO1yWgfUb7/9ZrvpppscyzosLMzWokUL26uvvmo7ceJEpun1u+3fp//b6tWrbb1797YVL17cFhQUZH7DsmXLMn3u008/td1yyy22+vXr20qXLm3z9fU182rWrJntueeesx0/fvyC88qNGTNmpPvNvXr1siUkJKSb5rPPPks3Tbdu3dK9n9My0//X/p7+D/n9Gy+0PLU8Of33zutWxvXSWcbvcZbxcytXrrR17drVbAe6TTz66KO2qKgoM+2sWbNsLVu2NPsGXV+feuopW3x8vC23nn/++XTl0O0mJiYmy236o48+uqjyZ7U92h04cMD8N7pP0/8qICDA7Kt0+oULF+bqf8+4r3XeR2T1ubz8hznZv3+/zdvb20yv2252++Os6Dpvn5f+d7mV0zo1cuRIs9zq1q1rK1mypFn/dT1u06aN7c0330xXvquuusrxPbfffnum+YwfP97xvn5XXFxcvsWXyMhIsw7rPk+X3+jRo810e/futQ0cONBWp04ds0x0XdB1+oorrjAxRGNmRgMGDHB8t/5GAAAAICck+gAAAJCviT7177//ppumR48e6d6fOHGiuVib3cXohg0b2o4cOZLuMzt37rTVqFEj28/oxdPZs2dneyG2bNmytsaNG2f52ccffzzXv/+aa65xfK5ChQq25OTkdO83atTI8b4mtuw06ZXTBXi9sLxx48ZsL37rd2lCxPkzF0r0/fTTTxe88P/aa69lOb9LSfRpUian79EL4RkvnDsnpvRCu15kz+o/znhRvFWrVheclyZzLjXR17lzZ8dn9CL+jh07spyuffv22SZnclpmOSV8LvU35mZ5FnaiT7cTnX/Geehyfu+997Kc/1133ZWr/yoxMdEk15y309wmq3Jb/uy2RzVv3rx088940+R7UU70TZ061TF969atc7XcNEn266+/moSt/bO63uZWTuuUJrdz+k1aecKeIP7mm28cr2tS7eTJk+m+yzkRqEm5/IovZcqUMYl4589ooi8iIsLEnpzKP2nSpEzLQyugZLdeAAAAABnRdScAAADynY5z1axZM9mwYYN5/ueff5quPH18fOTvv/+Wxx57TFJTUx1j32kXdNrNmY77FBkZKVu3bpW7775bFi5caKbRz2oXiXv37nWMezdgwAAzPp12FarfmZCQYD7TqlWrTONJqePHj5uu0B5++GEpUaKEfPXVV6ZLNDVu3Di56aabpFOnThf8bffee68Zh01pt6Raxl69epnn2hXgli1b0k1rp/PUrgS1K8eSJUuKv7+/REREmLGw9u/fb8o2dOhQR/ePGWk3ob6+vnLXXXeZLiN1HKzAwMAcy6rTN2/e3HStqstMu4PTLg21iz1796I6luIDDzwglStXlkceecSMx/Xss89m6ppVFS9e/ILLR8cn/OCDDxzPtRtE/e8OHz5s/l/9Lw8dOmS69NNlpWXM6N9//zVd1Wm3p9oN5tdff21e1/947Nix6boV1G4D+/bta8Ym1PVB1zH9fh0fTMdh08dvvvmmTJw4US6WllnXMTtdty+77LIsp9Xlpd142ukYcDVq1JBLcam/MTfL0z42nX6nvbtL3Y50nSiI8R/1v69evbopk5bP3uWjjpWntzp16phlqdu3vTzTp0834x9WqlQpx+9etWqV2Z/Y6feEhIRIfspue9y3b5/ccsstEhsba6bz8vKS6667zmyHug/6/fffpaDk13+4bNkyx2P7tp8dXa90/ctI93e6buUHnUeXLl3M+qL7Ts2Z61iw+jt1f7Zp0yaz7uuYqdo1q06v+/b4+HizPxo8eLBjf63bo919992Xb/FF45beunXrJldeeaX5r8uXLy/fffedeay07DrP0qVLm/2hrjPOy9qZ87inK1euNF3DaswAAAAAskKiDwAAAAWiXr16jkSfXnA9efKkuYD63nvvOZJ8OsaTjpHl7e3tuCDftm1b83jRokWyceNGadq0qcybN8+RQNMkhyaq9OK6eumll8w4eXqxV+czfvz4dIkmZ1OnTjUXcNVDDz1kkjVJSUnm+SeffJKrRJ9eSNYLtqdOnTLP9UKyPdGnj+10XD77vNSUKVPMvHTctl27dpnEnl6Q7tq1q0ybNs1Mo0kAnSa7Mf2+/fZb6devX7rX7BencxrHa+fOnSYxoRec9bt1DCi9eKzJCB1LS+erCQtd/so50aefd05YXsj777/veKwJLk26BAUFOZIGjz76qHmsZfr555/N8sxIkzJaPntCR8v5448/msf6fc40Marva3ItPDxcoqOjpWbNmtKhQweZM2eOmUYv1l8KTabphXY7TThkJ+N7R44ckUt1qb8xN8vTPjadjj1pTxJVrVq1wMZi1PVQE3q6jmh5NIms66LShMbSpUtNeXW9rF+/vnld9xtr1qy5YKIvY+LJ/vn8ltX2+PTTTzuSfEorFDjvB/Q3aGK/IOTXf7h7927HY/18XmkibPbs2SYplh/Wr19vxoDVhJsuO03uaYUJ/X6tRGJf/zXRp8lXTWxqXLDvd+2JPv2/7LFHxxa0JzHzK7488cQTMnr06HSvOT+/9dZb0+0flf4W3Z4zch6TT+ericFLrTAAAAAA90WiDwAAAAUirafCzPQiqp1e6NcLq9nRC7ua6HP+jLa+yK41lf0z2SUW7IkspRdNNVFib9mmCYTcCAgIkP79+8ukSZPMc02YaOuh4OBgmTFjhmM6bYFVpkwZx3NtjaQXgrXVR3a01Yi+X7FixUzvNW7cOFNS4UI0CagtprJbJnb2lo2XShMcmpy105ZN9iSf0hYx9kSf0sRVVok+/Z3OyRxNGtvZE6x2etF92LBhWV4sz+/fZ+f8my5E19dLdam/MS/Ls7Boqyd74kK3Ha0EYE+K6nv28mZsgeaq8uZ2e3RuMabJKOckn9JKDUU9YWNvgaa0VVtOXnnlFZOE0/2WVtrQVs2ajL7iiitMkk0TtZdCE3PPP/+8aR3onGzPaf3/3//+J6+//rrZn2qCTpPc7dq1k2+++SZTaz6VH/FFvfzyy5le03VZW3VqPJw8ebJJrDds2NBsg5po1JaK2vIvI231l/E/KerrDQAAAFyHRB8AAAAKhLbYstMu7ewXLrVlX14vOF/MZzLS+WdMKjpfYD19+nSu56Et3OyJvri4ONNSRL9Lu+J0nsZOL35rksvemiQnenE6KxfTKkmTaPZWlRczz7zSJIxzgjfjBWxtWRYaGupIWGWXtMl4QVuTq3bOy1CTrNqC6kJyShDkhiY7NFFsb/2ZU4ss7boxu5Y5OSXCs/sP8uM35nZ5Xozc/o6MMrbKc+6W0Pm9jF275qa82g2tM+0iMb9ltz0676u01WVhLEtX0pbRzrQbYG05reujvte9e3epUKHCRX//hx9+aLojvRDnZaVJ49tvv10+++wz81wTjtWqVXMkYXVbvvPOOx3T50d80UodGZNzSluoa6JeE6K639NYoDfnz2kCUlu356aiDAAAAJAVEn0AAADId9ptnHOCSbvEtHfPqUmTY8eOmcfaoi6nVmraKsT+GeekoY4rl53sxpHT7hft4wTaOSfmdEyp3NKLt9oqQ8cStHfZ6ZzU0sf27jyVXsi1Jyi0dYeOkaYt/jTxpd0y9u7d+4LzzOsYYzt27Ej3H2jLopEjR5okipZBx33L7qL1xdIuTe2tVzIu36y6qdPps5Kx61L9zqzoGF12mkD8/vvvpWPHjmYd0TG7Bg0aJPlBk03t27d3dBOoY8rpstOEQkbaZaEzXcedf4d92WiC2Jl251pQvzG3yzO37NtyXn7HhcrkLKtxG/NCxzcLCwtzjNOn/8mIESNMy8H8kt326Lyv0nHkCmNZ5jfnlsh5bUGp+3NN9Nl/j7amy2tL5OzWf9136ZimOt6hJoa1q87skoCPP/64I9E3c+ZM0zLUvg/WcUidt938iC857Z+1JffAgQNNt83aRaj+rzrOq95rS8h77rknUwWBjMnHrPY1AAAAgB2JPgAAAOQrTTBp15bOnnrqqXTJO/v4YEePHjUXQIsVK5Zuer1ArMkxe6LPfm8fr0jHoXJOpNnpRWXn1krOtDWWXjS2d6Wn3Vo6d7OX1/GktMWeXmi2d0HqPF9tLeKcrNAko/OFYh2ryX6BP2NiKL84z1PdfPPNjpZOWt6cknxadvt4ac7jjV2IJlKaNWtmxtRS+h++9tprjq4uv/jii3TTO/+vl/obdVwwbT2k9IK+trLMT7qe2hN9ui5pF6TaVavz/6wJX+eu/XQddW5Np8lke+JEL/rbuzHV8cWy6zq2MH9jxgRcdv+9c1Jcx37U1luaeNGx8T7//HNxNf0Numzfffdd81y7BNUuJHW8vIzdrurYZzpWpP6/+UETu5oIVtu2bTNJJuf9oSZ6Dxw4YFqYZVyWuu/UlsX6mnaHOWHChAL7D3Oi69myZcvMYy1rRv/995/5z7WyQ0Y63l1+JpWd13/t6tI+hqvGgZ9++inbz7Vs2dLsX3R71MoFuh+yu//++9NNmx/xJTu6fmnlEq38cfXVV5ubfbvRMtpbCOvvdG4R6LzcNfl4oXEpAQAA4NlI9AEAAOCSaMsEbZVw9uxZc/FSn9uTREpbHPXo0cPxXLshnDNnjrngrReMdayrG2+80VwI1YvbOqbS0qVLTesv7e5SaYs3He9KL5zbu6TUz+iFZk147N692yRhtFXEtGnTTIuPrOgFXr2ArRfS9aK/vStG9eCDD+bpd2vi4IUXXjCtBPW36AXirLrtzDgmml7I19+jF5c10bhw4UIpCHXq1DHJRHsrliFDhpgEnF5Q1mWUE00I2luYvP/+++YzmiBp0aKFdO3aNcfP6v9rH5dLk6nauuqGG24wF7ydk0A6DlZuWjLmRJfrokWLzGMdG1C769P15JdffjGJtPyk363jLOp3K02yaescXRc1walJAE0Y2ek4izomlzNdFvb/W5OCmhjT5ZrTOlCYvzFjt5eafNT1pmrVqiaRN3jwYMfv0JZVSrdhTVhomXS8y4wJZlfR8dJ0udm7SdSWkNqqS9dF7U5VW/vpezqunI6jll+JPl1G2q2vvXWeVizQCga6T9IkrybZtZvGMWPGOJalne5DdRvTZJaOG6frR0H9hznR5WHfVp27mbTbvHmzWY76v+u0uq5r2XW/reNu2mmryquuukouha7/9paNun1pd6DaFahufxfqklVb9dkT7/b9s372mmuuSTddfsWXrOjndJxUTQDrPDRhpzFD10c7/V8ytjbVVvF2uj44d20LAAAAZGIDAAAA8mDJkiXa9+AFb76+vrY33njDlpKSkuk7JkyYYN6/0Hc427Fjh61GjRoX/My0adMcnxk2bJjj9fLly9tatWqV5WceffTRi1oHrr322kzfpfPI6MSJE7ZKlSplOe977rkn3fM9e/Y4PtepU6d002VFp3f+vP4/dg8//HCW8+zatautcuXKjue6nJw9+eSTWX5u0KBBjmmyW+bqqaeeyvE/0mWxefPmdJ+pXr16tuVx/h91Ortdu3bZwsLCslz37rjjjmzXpZzmlZOoqCjbrbfeesF1sEGDBrb169dn+vyiRYtsXl5emaYvXbq0rW3bto7n+r8X5G/MbnmqdevW2by9vTPNLyQkxDFNRESEKXPGafRzPXv2zLZMOa3PzuXN+F5O61pOIiMjbX369Lng/+W8vPX7L6b8zubNm5flf2a/DRkyxDFtXFycrW7dullOl3H/4rxvcN5vOJc/t/9hTsLDwx3raWBgoC0mJibd+z/88MMFl2lwcLBtzpw5uZpfTst22bJlWcaK0NBQ24033pjteqwSExMz7XefffbZLOd/qfElq/mrGTNmXPA7dX+Z0YABAxzvaxwFAAAAcnJ+QAAAAADgImnXZNp6o2bNmqbFl3aTpq25tFWN8xhUdtqtnrb+01Y02rJLWzNoF4jaqk/H83vllVfSjS+ndDpt0aTjzGlrOB3fzT7fpk2bmhZ52srI3jVnRtr9mbY4evLJJ02LHm0hoa1Fxo4dK+PHj7+o333fffdlei1jaz77GFDaek9biWg3pdqKS1vyaKuOrKbPL+PGjZPXX39dqlevbrrz0+4Cn332WdPlXU7joL311lumFZAuJ+cxDXNLWwFqa6qbbrrJtGDReev4ctoSRv9b/R+1e7z8aLWoLWa0xaiuQzoPXX+0lVa3bt0kv+n3a+ssnae2DtX1R9c/Z9pqR1tOahemGWmZdB3VllC6/mlXfdraR1td6eeKwm/U/0i7JNUy6jaTFR3fUVtvafeGWh4dn0y7JNTWahm77XUlXb66rmtZH3jgAbOMdfvTdVq3SW1lpfuTjF3KXqprr73WtPbUbU33TbqMdBvQbUFbj+n7drqM9b/U7ny1pbE+b9eunVlP9PMF9R/mRPfj2urQ3hIuY3ecuu969dVXzX+u+xT7/luXt45l+dJLL5luSK+77jq5VPofade2us/XbjO162NdftpSr0mTJjl+Vpf5ww8/nO61jN125ld8yan8uj/V/11blOr36bLSMfc0Vuo4grq/dJaQkOBoHazxU8fwAwAAAHLipdm+HKcAAAAALGr48OGOsZk02aXJRyC/6ViTHTt2NN1YqmeeeUZGjRrFgoZl6fiamnxUWkHhu+++EyvSMRK1u1t1+eWXp+tatKjShKIuc9WnT58cxyIEAAAAFC36AAAAAOAS6Lhf2oLRPjbae++9JyNGjGCZwrK0Na62ZFNz5861VCUJHQdVW5dq61ttXWj32GOPiRVoK3Pl5eXlqKgCAAAA5CT7/noAAAAAALlSo0YN+e2330wLIpWUlCTHjh0z3VwCVqNdRr7zzjumm8zk5GSTvL7YLo4Lm3ad26VLl3SvaWs+e8u+omzVqlWmq1mlLSq1+1UAAADgQkj0AQAAAEA+qF+/vukuFnAHOgajlUf60BZx2tq2b9++poVtVuPFFjU6/qGVlzkAAABcgzH6AAAAAAAAAAAAAAsq+lXaAAAAAAAAAAAAAGRCog8AAAAAAAAAAACwIBJ9AAAAAAAAAAAAgAWR6AMAAAAAAAAAAAAsiEQfAAAAAAAAAAAAYEEk+gAAAAAAAAAAAAALItEHAAAAAAAAAAAAWBCJPgAAAAAAAAAAAMCCSPQBAAAAAAAAAAAAFkSiDwAAAAAAAAAAALAgEn0AAAAAAAAAAACABZHoAwAAAAAAAAAAACyIRB8AAAAAAAAAAABgQST6AAAAAAAAAAAAAAsi0QcAAAAAAAAAAABYEIk+AAAAAAAAAAAAwIJI9AEAAAAAAAAAAAAWRKIPAAAAAAAAAAAAsCASfQAAAAAAAAAAAIAFkegDAAAAAAAAAAAALIhEHwAAAAAAAAAAAGBBJPoAAAAAAAAAAAAACyLRBwAAAAAAAAAAAFgQiT4AAAAAAAAAAADAgkj0AQAAAAAAAAAAABZEog8AAAAAAAAAAACwIBJ9AAAAAAAAAAAAgAWR6AMAAAAAAAAAAAAsiEQfAAAAAAAAAAAAYEEk+gAAAAAAAAAAAAALItEHAAAAAAAAAAAAWBCJPgAAAAAAAAAAAMCCSPQBAAAAAAAAAAAAFkSiDwAAAAAAAAAAALAgEn0AAAAAAAAAAACABZHoAwAAAAAAAAAAACyIRB8AAAAAAAAAAABgQST6AAAAAAAAAAAAAAsi0QcAAAAAAAAAAABYEIk+AAAAAAAAAAAAwIJI9AEAAAAAAAAAAAAWRKIPAAAAAAAAAAAAsCASfQAAAAAAAAAAAIAFkegDAAAAAAAAAAAALIhEHwAAAAAAAAAAAGBBJPoAAAAAAAAAAAAACyLRBwAAAAAAAAAAAFgQiT4AAAAAAAAAAADAgkj0AQAAAAAAAAAAABZEog8AAAAAAAAAAACwIBJ9AAAAAAAAAAAAgAWR6AMAAAAAAAAAAAAsiEQfAAAAAAAAAAAAYEEk+gAAAAAAAAAAAAALItEHAAAAAAAAAAAAWBCJPgAAAAAAAAAAAMCCSPQBAAAAAAAAAAAAFkSiDwAAAAAAAAAAALAgEn0AAAAAAAAAAACABZHoAwAAAAAAAAAAACyIRB8AAAAAAAAAAABgQST6AAAAAAAAAAAAAAsi0QcAAAAAAAAAAABYEIk+AAAAAAAAAAAAwIJI9AEAAAAAAAAAAAAWRKIPAAAAAAAAAAAAsCASfQAAAAAAAAAAAIAF+bq6ACh4O3fulFmzZsnChQvl+PHjkpqa6paL3dvbW8qWLSs9e/aU2267TerWrevqIsHDsK0BQNbi4+Nl3rx58u2338q2bdskNjbWbRdVcHCwNG7cWG6++Wbp1auXBAQEiFXt2LHDcQwZGRnptseQPj4+6Y4h69Sp4+oiASji4uLi0sU1fe6u3Cmubd++3RHXTpw44fZx7ZprrjFxrXbt2q4uEoAiTuPYzz//bOKa7ivdOa6FhISki2v+/v6uLhKQL7xsNpstf74KRdH3339vDuySk5PFk/j6+srs2bPlhhtucHVR4CG+++47s62lpKSIp21reiDYr18/VxcFQBEVFRVlTqD++usv8TRdunQxJ8x6kdRq9DhqwIABHhfX/Pz8TFy77rrrXF0UAEXU2bNnTQJlxYoV4mm6du0qc+fOtWRc0wSfxjV3Te5lRy9g67lqnz59XF0UAEXUmTNnTFz7559/xNN0795d5syZI0FBQa4uCnDJSPS5sdWrV0v79u1Nkq9Uw9JSpUtVCa4QYlq+uSM9YI89GiMHlxyQk1tPmASEBqlWrVq5umhwc//++69cccUV5mJo2rZWTYIrBLv3tnbk3La2LW1bW7lypbRs2dLVRQNQBPXt29cku7yDikvYlfdKYL2rxDsgRA9Dxf3YJDU+WuJ2/CFRyz8TW0K03HLLLSZpZiV6/NShQ4e0uNaotFTp7P5xLeawxrX9cmr7SZPs09jevHlzVxcNQBF07bXXyi+//CLeQSUkrMO9EnhZR/eOa3FRaXHtL41rMaZy48yZM8VK/v77b+nYsaPZ35duXEaqdK4qQeU9J65psm/VqlXStGlTVxcNQBGkSb4FCxakxbWO90lgXY1rwR4T17QSyPTp011dMOCSkehzY48//riMHz9eyrYsL21fvFy8fNxxB52ZLcUm/761Qo6vOyaDBw+WsWPHurpIcHODBg2SiRMnSrlW5aXNC56zraWmpMqqN/+R4+uPyRNPPCGjR492dZEAFDFHjhyRypUri3YgUem5JRJQo7V4irhdy+Xo6F6mMkRERISUKlVKrOLhhx+WyZMnS7nW5aXN854V1/59Y4VEbjguTz31lLz//vuuLhKAIubgwYNStWpV87jS0KUSUN1zKrrF7fhTjo7tbSpDaFwrWbKkWMXAgQPlk08+kfJtK0jroe3Ey9tD4lpyqqx8/W85sSlSnn32WRk5cqSriwSgiDlw4IBUq1ZNxMtLKg39UwKqeU5Ft7jtf8jRD/uayhDHjh2T4sWLu7pIwCVxz+pLMLT2vKrRq6bHXKBR+lv1NzsvA6Ag2dez6h62rXn7eEv1a9jWAGRv/vz5JsmnCT5PSvKpoLodxL9yY9OzgtaQtRIdd0rVuLYWcQ0AnGhLPhVQq51HJflUUL2rxK9iA0lKSjJj3Fny2ojGNQ9J8ilvX87XAOTuuD+gdnuPSvKpoPqdxa9CPUlMTJRFixa5ujjAJSPR58aOHj1q7sOqhYmnCa1azNGSACi0be3ceudJwqqxrQG48P5RLwx6Ir9KDS15POLRce3cb7YvAwBwZt+f+3toXPM/F9estI/UCkfENesdiwAoHPb9o6fGNft5KvtIuAMSfW5Ma5Dba3F5Gvtvti8DoCB59Lbml1Yjlm0NQFbs+wYvX3+PXEBePn6W3EcS16z3nwEoHI59g8fGNX/L7SM10ac3jz1f49oIgNycr53bv3sa+3mqleIakB3PO8oBAAAAAAAAAAAA3ACJPgAAAAAAAAAAAMCCSPQBAAAAAAAAAAAAFkSiDwAAAAAAAAAAALAgEn0AAAAAAAAAAACABZHoAwAAAAAAAAAAACyIRB8AAAAAAAAAAABgQST6AAAAAAAAAAAAAAsi0QcAAAAAAAAAAABYEIk+AAAAAAAAAAAAwIJI9AEAAAAAAAAAAAAWRKIPAAAAAAAAAAAAsCASfQAAAAAAAAAAAIAFkegDAAAAAAAAAAAALIhEHwAAAAAAAAAAAGBBvq4uAKzvp+t/cDxOSE6QwzFHZNaOb2TV0dUytssHUiWssoxbN1EW7ltkphnc4jHpXr2rLD3wp7y3ZrQLSw5YC9saAGQt/JFQx+O4JJvsO5sq41Ynyi/hKea1P+8IlirFsq7fVmtSNIvVRYhrAJA14po1EdcAIGvENaDg0aIP+eaDNWNkxo5ZUi2sqjzd+gkJ9A2UsevGSYotRe5rdLeUCCghTcs0MUm+U/GnZPLGKSx9gG0NAPLNU4vj5cPViVKnpLeM7hYopQLTXh++PEEGL4o3tyd+i5djManm9Xn/JbH0iwCOIQEga8Q1ayKuAUDWiGtAwaFFH/LN8kN/S1JqklxVpaPUKl5TygeXl+0nd8jc/36SG+peL4OaP2ySgGrihskSlRTF0gfY1gAg38zfnSyJKSJ96/pKwzI+phXfyfhU+X1fWss+9XRbfykX4i07TqbI0CUJLP0igGNIAMgacc2aiGsAkDXiGmDhFn1nz56VoUOHSu3atSUgIEDKly8vd955p+zevbugZ41CFuYfJnVL1JEKweUlKjFKDkYfMK9/ue1rORh1UC6v2E4qhVaSpQeXyT9HVvL/AGxrgGXYbDaJjIyUvXv3mnt9jqKnZKCXNC3rLVWLecvpeJvsPpXWcs+uew0feaSln0Ql2OTRX+MlNtllRYUTjiGBwkdcswbimjUR14DCR1yzBuIaYNFEnyb5OnbsKCNHjpTw8HBJTEyUY8eOyfTp06VNmzayadOmgpw9Ctnn13wqH3QeJT5ePvLmyrclLjnevK6t/LQFn4pPjpfJGz7hvwHY1gBLOH36tIwdO1bq1q0rZcuWlZo1a5p7fa6v6/soOlbcHSI/3hwsvl4iD/0aJzFOPXPWLO4l712d1pfn07/Hy54zJGuLCo4hgcJDXLMW4po1EdeAwkNcsxbiGmDRRN/w4cNl48aN5vFVV10lP/74ozz00EPm+alTp+SBBx4oyNmjkL3xzwiZF/6LBPgGyGPNHxV/b3/HexGxEeY+LjmOLjsBtjXAEhYsWCBVqlSRJ5980lRYcqbP9XV9X6dD0fC/X+Lky82JEuTnJW91CpQAn7TXg31FJl0TKGEBXjJxbZL8tvd8V55wPY4hgcJBXLMe4po1EdeAwkFcsx7iGlDEEn2LFy+W1q1bS2BgoOmSc/z48fLZZ5+Jl5eXuWmCT1vvTZs2zUyvr82cOVP69esnkyZNkvr165vXV61aJWvWrMnfXwSXWXdsvXy08WPZHLlFqoZVketq9+HfANjWAMueNPbu3Vvi4uJMNzAZu+q0v6bv63Qk+4qGZQdSZNiyRFl5OEXqlPSW+5v6mdff7RIgl5XykWMxqfLfqVTpU8fXcQtixGqX4xgSKHjENWsirlkTcQ0oeMQ1ayKuAUUo0bd8+XLp1auXSdAlJCSYGu2PP/64jBkzJt10mzdvdnRnVaNGDalYsaIj6de+fXvHdMuWLbv0X4EiZcqmqZJqS5WbLrtRQv1CXV0cwG2xrQEFQ49fbrrpJpPIS01NP8ZbRvq+TqfT041n0fHmXwmSarPJQy38pXiASO86aQm/ciHeMqZboHzY/fytVJCXq4uLc4hrQMEgrlkfcc2aiGtAwSCuWR9xDch/ea7D/Mwzz0hSUtqAJ926dZMhQ4bI+vXrTSs+Z3v37nU8Ll++fLr3ypUr53i8Z8+eiyk3ipC+P96Q7vnuM+HSb85N6V47Fns803QA2NaAoujzzz+X2NjYTK34ckr26fRffPGFDB48uMDLh8xqTYpO93xLZKrU+Sgm2/dRNHAMCRQO4pr1ENesibgGFA7imvUQ14Ai1qIvIiJCVq5caR4HBATIrFmzpE+fPvLyyy9L//79000bE3P+4oq///mx2jI+d54OAADAlTS5N27cuIv67Icffpjr5CAAAIWBuAYAcCfENQDIhxZ9zq3vdGy+UqVKOZ63bdtWpk+f7ngeEhLieKxdfDrT8fuymq6wHDlyxNzcnf1i49l9ZyXhVPr/wN3Fn05wLIO1a9e6ujjwmG3tjCScihdPEn863tGiiW0N7uDUqVOye/fui9oP6OeWLFkiJUqUKJCyWdHhw4fNfUp0pCTsXy+eJiXmpLk/dOiQJfeRZ/eeEf+w9BX23F38qThzT1yDuyCu5S/7dYSUKM+OawcPHrRMXHPuhl3jml9IWnfeniIuMi2upaSkWOY/A3JCXCuouHbcQ+PaKcvFNXieli1b5m5CWx6sWLFCr2abW8OGDdO99+GHHzreGzZsmG3NmjWO5zVq1Eg37T333ON4b/To0bbCpuWzz58by4B1gHWAdYB1gHWAdYB1gHWAdYB1gHWAdYB1gHWAdYB1gHWAdYB1gHWAdYB1gHWAdUCK0DLIrTy16KtZs6bjcXh4uKlFUbJkSfPc3qWnXePGjaV48eJy5swZ2bdvn6nJXLlyZVPj/Z9//nFM17FjRylsDz30kFx33XXi7rSVpdbaavtqewkoFpDnzz/f8znpfFlnufWT/nI2/qyUDiktT3YdIq2rt5aU1BT5O/xvGbP4Q4lJzLr71VkPzpCKxSuke+3FOS/L8v/+Mo97N75W7mw3QMqGlpXDZw7LJ8s/lWX/LTfvvdr7ZWlXo630//QOiYqPuqgWfaveXCG+vr6Z1k0gv7Vu3drs21y1rY255QOpW66OBPoFyqnY07Lsv2UycelHkpSSNp6qCg0IkWl3fyrli5WXLYe3yiMzBpnXr2vaV57p/pQMmf2krDuw/qJa9K168x/x8/NLt28HrEqPbXQM4ou1ePFiWvQ5mTx5snz88ccS3KKflOj5TK6X4wc31ZU+TcpIu5Gr5FRscpbTdG9QSp7vUV1qlgmSiLOJMmHpQfnq36NZTtuuRjEZeUMdqVwiwBwp74mMkw+XHJCfN59wTNO1Xkl5sms1aVAhRBJTUmXzoWi5Zcpm897cR5pKqRA/6fzBWklOzX33rKfmjZC4Tb+YsRvvuecesYpWrVqZ+3bDrrioFn2XGtd6NbpG+re+TSoVryiJKYmyI2KnjP9jooRHhpv3Q/xD5KGO/5OOdTtKWEConIg5IZP+nCx/7Fwqbaq3kfdvHinvLBgp8zf/clEt+la9tVICAwPlr7/SjlkBKyOu5a9JkybJlClTJLjljVKix5Mui2uBvt7y6V0NpFmVUCkZ7CcHTsXL5SNXO9739faSl3rVkBubl5XQAF9Zu/+svDQ3XHYeizXv/f1sK9l/MkFu/mRTnn7/qZ/elLgtC+SJJ56Qu+66S6zSoq9Nmzbm8eWvXXlRLfoK8trIFbXay13t7pSqJauIn6+f7D2xT6Ys/1RW7Uv7Pwd2eNDExLs/v08Onjp4US36Vr+zUoKCgmT58rTrLYCVEdfy14QJE2Tq1KkS0upmKd59iMvimnqoQ2W56/IKUrFYgOw9ESfvLNwni7altSSvVDxAxt5SV5pUDpWwQF/5O/yM3OIUwyb0ryedLyspV45aLafjsi5PVk7OfV3ity6Sp556Su64445cfw4oivKU6Ctfvry0a9fOJE7i4+PNuHx64WLDhg0yc+bMTOPw3X///TJ69GhzAfz222+XZ555RubNmyc7duxwXBy3X0goTBUrVjQ3d+fl5WXui1UvJoGlgvL02cqhlaRnox6ycO9v4lXZW4pLCXntymHSuEwjmb3jWwnyC5J+DfuKf1iAfLBmTJbf4e3nLfvPHpCZO2Y7XjsUcESK1y4hjUs3kqEdn5Xdp3fLJ5unyg11rpPX+w6XQb8PlkPRh2X+0QXSrX5Xuafb3fLltvNdwuaW/7nuKXQZ5Lp5K3CRdD3T/Vyx6sUlsFRgoW9rBxIPyF/bVpiKHtfX6Sc3tbhRjnlHyvw95y9wDm3zjIQFFTOPfQJ9zHao/opbIQ8nRstDXQfK0GUv5vm3+0fGmntvb2+2NbgF3Za1e3Kt0JSX8fZ0P1CrVi3p0qWLI/5CpFKlSmYx+ISWkYBqzXO1SGqW8JKbWwbLrG3JElumsWRVfaJ6MS/5pH+wHI2xyRt/Jcot9f3k3RvqyGGfyvLXoZTM/09Zb5m710cORydJpVAvGdw6RCbcXl9WTI2R6CSRjlV9ZFrvQDkea5P3VyVJTKJN2lQMcZR52nZfGd8jUAZ0b2XKlVs+IWnd3GtlNysejxSrUVwCSgQUalwrH1xeXugxVGKT4uTTLdPkspJ1pVv1rjK0z7Py3LIXzDTvdhwhDUs3kKUH/pT1xzdKueCyUqxiMSmeUkJ2yi5z/PlAx/tkRdxKSZXzXbblht+xtAvAxDW4C+Ja/rJfR/AJc21cC/IVSfANlDn/pcq9TUW8fPzTlWdwaz8Z2CZAfv4vSdZHJMnTbYvL5w80l24zYiU5VeTLbV7yfPvi0vWKVrL8YObvv1Bcq1KlimXimnPXnRrX/Iv5F6lrI03qNZEor2iZvnOmlA0qIzdfdqOMuP5NeWDhQ3Im8YwsPLlYbvfuLwO7PyjvZ/P9OfENTotrPj4+lvnPgJwQ1woqrpV1aVzr38BXXu0cKCsPp8jkvxJlcKsg+eSOBnLNrFjZc8YmYcW95ESqvyzYa5Ob64t4B4SmK+9n/3nL9c185dHeLeX9f88PGXYhPiElLRfXgOx453XRjBo1yrTcUAsXLpQ+ffrISy+9JI0aNco07fDhw6Vp06bm8bJly6Rfv36mVrfS8Wu0xgCKpp7Vu4uPl4/8eWiZeV4trKo0LdtEws/skenbZ8iUTVPlRNwJuapKBynmH5bt9+iB6eqI1bLs0HJzOxmfVhOjd61rzf307TPl170L5PtdP4qPt49cW7OXeX3X6V0SEXtMulfvJl7CBVO4r/zY1qZsniZ/H14hG45vkmOxx869ej5B0bXa1dKmfGv5fOsXmT6bnJosK4+uMhdMdd6Ap9Mk3eOPP35Rn9XKTyT5Ll3/Bn7i4+0lP/2XfULt9kZ+4ufjJZ9uSJKvtyY7TububpJ1Lf11Eany0bok+WNfsqw4lCKJKSIpNv2/095/tKW/eHt5ydOLE+SrzUkyc1uyPP37+fGNF+9Nlvhkm9ze0LPG9XFFXNP/IdWWKnHJsSaJt/1kWgXB6KRoc9+kTGMTs7ZEbjUXPJce/FO+3j5Tlh5Mm5/66/DfUja4rLQs36LQfjdQVBHX3DOuaeOJRxbEy1dbzvfg4eyuxv6SarPJS0sTZOrGJFm0N1mqFfOWq6v7mPfn704rS3/imsuvjXy763t5a+XbppLm51u/lN2nwyXAN0Aqh6VVljqVcEq2ndguV1a6QkL9Qi9cYMDNEdfcM651rp7WFmnqhkSZvS1Z5u5KNp+3n3/tPWOTIb8lyM/ZzHPjsVQ5eDZVbmvgy1VkeKw8J/q0q8358+ebLLe22qtRo4aMGTNGnnwyc7cVxYoVMwm+Z5991nT7qdOXK1dOBgwYIKtWrZImTZrk1+9APmterpnpgmLnyV3meaXQtBoex2OPO6Y5HhdpDngrhKTvgsJZo9INZXafGfJd31nyQtuhUsy/WIbvizT3x+KOO2rL2W0/sV1KBpaQmsVr8P/CbeXXtja52wSZ0uMjaVW+pSw5sNTUOFUVQyrIwCYPyqebp8n+qANZfnbbiW3mvkW53NXeAtyddrEYHBxsWvTkhk6n0999990FXjZP0KGKj+kec31EWk1PX2+RkoHnb5qbq1E87b85HJ1WS//QufuaJbL/z66q6iOr7wuVb24INs+f+i1eos5V9mxSNu1zL13hL9sGhsrGB0LkiTbna/wnpIhsiUyVxmW9pXjee2j2KJca147EHJUJ6z+SYgHF5OPuE+WxFo/KnjN7Zczaceb9OiXqmPuSgSVldp+v5du+M+WDTiPTVVYhrgHpEdfcM65lR3tcLh3kZWKcPc4dikqrBFjz3HwORtkkIiZVrqySlviD666NaMVLu0ohlaRKaGU5k3BG9pzZ43h964lt4ufjZ1oRAiCuuWNci4xNi1NXVPExPbC0qpgWn6qf+57cWBuRImWCvaVBmbzHTsAdXNSar2PXrFmzRhISEmTPnj0yZEj2ffhqsm/kyJGmCyydPiIiQqZPny516qSdpKNoqhhSUc4mRkliau6bO2f0277F8v7q0fLGPyNkc+QWuaLS5fJgk/uznDarVnuR8Wnj5uR0sAxYXX5sa2rEv+/Ku/+Okp2ndslVlTtI24qtzeuPNX9U9kftl/XHN0jpwNLmNT9vPykfXM7xWbY1ID3tdeC7774ztUUvlOzT93W677//nrH58omezJ2Ot5nkmmpVwUfW3BfquFUKy3zMkJu2/+siUuTun+Lk9eVpLfWGtg8Qe+9d2rrPXlP0oV/iTBeeg1v7S5dq5y+AHo1ONa3NtEUECi6uaWuFWy67UeKS42XkqvdNt2ha6WtQ84fN+9raT5UKLGkSgt/u/F7qlqwrT7R8PFNc08ouAIhr7hrX8iKr7zsabZPiAV7moixcf22kWlg1efPK1yTFlipv/zvSxEG7E8Q1IB3O19wvro1fkyj/nUqVe5r4y/K7QqReqbRzLu88BMQj0TZHt6GAJ8rTGH3wNOe7/jscfcTc6xgodmWDykqKLUWOxhx1JA9sYnPUSHPuf/5U/GnTfVKNYtUd31ereE3zfXvP7jV90ae9fvj83M+NjUTXnXB/l7atqS0ntjoeD237rOmu8+/D/0j5kPImqfdx90mO92uXqCVjunwgt8+7M23ubGtAJj179jTjCt90000SG5s2FqXzmH32LjqDgoJMkq9Hjx4sxXzkPDritsgUuWtu2ti7SpNwe8+kJXsqh+kJYIpUCk07EbS/7uMl4uMtkpJ6Pol3Kl7MOER609Z92j2M1hj9NTzFfK5JWR+ZtS1J/jyQIpdXTpaaJfxNjdMl+9POYFPPfQ+njQUb17Q7NK3k9c+Rf03XZiuP/Cu31rtZ2lZok/Z9MWnHinvP7pM/Di6VEL9g834lp14h8jK+JuApiGvuF9eyo634TsTZTAJPW/fpc/tFV/v3Kfsj4pprr40oban3UrsXzPQv//Wq7Dr9X7q5azes/FtAesQ194prOpZfr1mxUreUt/h6iXSp7iNPtg2QzcdzP942pwDwdCT6kKWjMRFSNayKOUBNSk0yXf5pzTMdE+WO+rebAadLB5WSPw4sNbXb9CD30x4fy6n4U3L3r/ebg9b7G98rayLWSkxSrHSv3jVdV0ra/3yHylfIgPq3mRrZN9TpZ7rDmL9ngaMMZYLSWh/ZD5YBd3Sp21rLci2kU5WOsu3kdnOa3vfc+JfazZmatH6yGeNBabdmdzS4XQ5FH5apmz9zlKHMuUT70Vi2NSDjyePBgwfliy++kA8//FB2797teK9WrVpmTD7tDq148eIsuHx04Gyq1C7pLf4+YsbSO5somQZsn7k1Se5v6mduiSk2ubV+2tgNX2xKG6vosVb+MqSNv3y0NlFGrkyUV670l+hEkX1nU02LvPbnupvZeTLtxFHH5Xu3i4880MxPKoR4Sc+avub9fw6fn2/FUG9zoe1AVO5PNj3RpcY1vYCqrfaalmksvWv2kmrFqpnv3Xd2v7lfG7HOTFO7eC25rnYfqRxa2by+4fjGLOJahEuWAVBUEdfcJ66pWxv4StmgtDRdsJ+Xeb7ndKqsOpIq07ckmZbpb3UKkPURqdK9hq8px+/7nOJaiJecTbCZijBw3bURPZ97ud0L4u3lLV/vmmkqu+ht56mdEnFu/HV7xegIzteAdIhr7hPXahT3klvq+8nu06mm288HmvpJZFxaPFPBviJ96vrKZSXTEoblQtLi3pbjqWaIBVUxNC0mHjhLpT94JhJ9yNK64+ulRvHqclnJuo6WQu+tHi0PNxso19e5zlyA0QPZjzZ+nOXnzySclcSURLmp7g2mCyYdQHrOf3Ply23TzfubIjfL+HUT5ebLbpSBTR80B88jV78nB6MPOr6jfql6ctr0TZ+WsADc0aVua2cTz0r1YtXl8oqXi4+3t5yIOynf7PxOZmyfZd5fc2zt+WnLnDX3UYlR8u/RVY7XG5Sql1aWY+sL9LcCVu0WRhN6jz/+uFSuXFmOHDkiFStWlF27djla9SF/LTuQIvVK+0izct7mYmVWtIvNQQvi5el2/jKsQ4Aci7HJq3/Gm9Z6WTkZZ5P+Df2kTLCXxCeLbDqWKh+tS5Tw02kngd9sT5ZywQlyRyM/Gd4xQMJPp8obfyXI1nMnjXoS26iMtzmJ5IJowcY17enhw3UTTCWw+xrdY7pKW310jRlrVmmLiTdXjpCHmg6UuxveKbFJcaZLtKmbP093DGnKQlwDMiGuuUdcU+90Pt/nZqkgL/P82+1JsupIgkxYk2ha811X10+61xBZfyxVhi9LkKRzs9fxjyqEesuv4cnpWmWg8K+N1Ct1mRl/T93V8A7H58as/VAi9h9zxDVNMm46voW/CMiAuOYecU1b43Wv6Sv3h3mZWPX3oRQZsSJBIuPSolTJc3HOrlYJb/N87KpE2RKZVgGmRQUfkxzceoKKmfBM+Zbou/fee80N7mHh3kWmlnSHylc6Dma1X/i3Vr6d5fTHYo9L3x9vcDzXg9c3s5nWbsG+ReaWlbol6phabDruSqqjUxHA/Vzqtvbf6d3yxB9P52peWvPU+bPK19tX2lVsK9tP7nC0lgCQmfN4ffZx+VAwZm5Lkvua+knv2r6y6kj24+Es2psii/ae7yLG2djVieZmN2FtkrnlJKdpulb3kSA/L5m1NefvwKXHNbV4/+/mlp0DUQdN12bZ0Xkfj400rScAZI24Zu24pmpNis72u/Qi6Rt/JZpbVnrX8XW0uIBrr41oBU17Jc2slAgoIY1KN5S/Dv8tUUlR/F1ANohr1o5r+87apMfMtCEzsnIoypZj3Gta1tv03KItBO1DLgCeJu2KFZDBwehDplba1VW7mFpnha1fneskOjFavt/1I/8N3Jqrt7Vu1a6WMP8w+XJrWo1SAHA1bWX3w85kubGenxRP63nY5e5v5m/Gk9CWfyjaca1FueZSvVg1mbFjpmllAQCuVtTimq+3yN2N/eTfwylmXFoU7bimSUYd7+/r7TMLfd4AYIW4pnQIhjMJNvl4ffaJR8Dd0XUnsjVm7TgZI+NcsoTeW/2BS+YLeNq29uveheYGAEXJc0sSzK2ouOWHrGuioujFNe2uM2MLQQBwtaIU15JTRTp+lX2rCRStuPbF1q/MDQCKkqIU19SQ37QsRac8gCvQog8AAAAAAAAAAACwIBJ9AAAAAAAAAAAAgAWR6AMAAAAAAAAAAAAsiEQfAAAAAAAAAAAAYEEk+gAAAAAAAAAAAAALItEHAAAAAAAAAAAAWBCJPgAAAAAAAAAAAMCCSPQBAAAAAAAAAAAAFkSiDwAAAAAAAAAAALAgEn0AAAAAAAAAAACABZHoAwAAAAAAAAAAACyIRB8AAAAAAAAAAABgQST6AAAAAAAAAAAAAAsi0QcAAAAAAAAAAABYEIk+AAAAAAAAAAAAwIJI9LkxLy8vc29LtYmnsf9m+zIAChLbGtsagJz3j5Ka4pmLKDXVkscjHh3Xzq2qVvvPABQOT49rtnM7SavuIz0yrnFtBEBujvvtB8Ge5lw89/YmRQLrYy12YyVKlDD38ZHx4mniT8SZ+5IlS7q6KPCkbe3ceudJ4iLZ1gBceP+YfPqwRy6m5FMHLXk84slxjWNIADmx78+TTx3yyAVlxbimF2+LFStmHhPXACDr4/4UT41rpw9ZLq4B2SHR58a6dOli7g8tTzsY9ySHz/1m+zIACpJ9PTv8l+cdGB1elvab2dYAZMW+b4jb8YekRB33qIWkyc343X9bch/piGscQwJAlvvHeI1r0ZEetXSSTx6UhN3/mMedO3cWK+HaiPWORQAU8vnatt8lJfqERy32pBP7JSF8pSXjGpAVEn1urH///uZ+77xw2T59q8QcjRGbzX27qtDfpr9Rf+ve+XvMa7fddpuriwUP2tb2/LRbdny9TWIjPGRb+2qr7PuVbQ1A9ho3biwNGzYUSU6Uo+P6SeyWhZKa5N49DaQmxknspl/M79WuYFq1aiW1a9cWK7EfP4XP3S07ZnhIXDsSI9u+3CL7Fuw1r3EMCSArTZs2lXr16oktKV6OfqhxbZHYkhLcP65tnJ8W12yp0rZtW6lZs6ZY8XwtfM5/snPWdok95glxLVq2fbFF9i/aZ14jrgHISosWLaRu3bpiS4qTo+Oul9itv3lEXIvZOE8ixl+vO0xp3769VKtWzdXFAi6Zl82dj248nP61Tz/9tIwePfr8i94iXt7W7E8/V33Ppw2FY+hvHzVqlGXHD4C1trUnn3xSxo4d65Hb2rPPPivvvvsu2xrcXpUqVeTQoUNSuXJlOXjQ81rLX6ytW7eamqLHjh07/6K3rw4IIW5HD6tTkx1PdV1ZsmSJOXm2WlwbPHiwjB8/3iPj2tChQ+Xtt98mrsHtEdcuzubNm+Xqq6+W48ePe1xc03VG41qdOnXEanHtsccek4kTJ3pGXEuxiThd6XvxxRflzTffJK7B7RHXLs6mTZtMXIuMjPS4uFa1alX5448/pFatWi4tFpAfSPS5OT2gnTZtmnz11VeydOlSSU11uorhhrT/fW1ufeedd8q9997LgSwKdVubOnWqTJ8+nW0NcFOcOF68Xbt2mcoQ3377rURERIi7q1Spktx8880yZMgQy540alybMmWKfP311/Lnn396xDGkJqTvuusuufvuuzmGhEcgrl28HTt2yIcffijfffedR8Q1rbhy0003yRNPPGG51nzOce2TTz5xxDV3r/Pu4+PjiGt6owI0PAFx7dLimp6vaVxLV0HTjeOanq9pXKtRo4ariwPkCxJ9HiQ+Pl5Onz4tKSkp4q4HsjqIbGBgoKuLAg+n29qpU6fc9qIo2xo8FSeOl073i2fOnJHY2FhxV8HBwVK8eHGTOHIXxDXAPRHXLp0nxLWQkBAT19wpUeQJca1kyZISEBDg6qIAhYq4dul0v6jXjuPi4sRduWNcA5Qvi8FzaAKsQoUKri4G4BHbWsWKFV1dDAAocjT5pRee9AbrIK4BQNaIa9ZEXAOA7ONaqVKlWDyABblPVWMAAAAAAAAAAADAg5DoAwAAAAAAAAAAACyIRB8AAAAAAAAAAABgQST6AAAAAAAAAAAAAAsi0QcAAAAAAAAAAABYEIk+AAAAAAAAAAAAwIJI9AEAAAAAAAAAAAAWRKIPAAAAAAAAAAAAsCASfQAAAAAAAAAAAIAFkegDAAAAAAAAAAAALIhEHwAAAAAAAAAAAGBBJPoAAAAAAAAAAAAACyLRBwAAAAAAAAAAAFgQiT4AAAAAAAAAAADAgkj0AQAAAAAAAAAAABZEog8AAAAAAAAAAACwIBJ9AAAAAAAAAAAAgAWR6AMAAAAAAAAAAAAsiEQfAAAAAAAAAAAAYEEk+gAAAAAAAAAAAAALItEHAAAAAAAAAAAAWBCJPgAAAAAAAAAAAMCCSPQBAAAAAAAAAAAAFuTr6gIAyNqxY8fkhx9+kK1bt0pcXJzbLqagoCBp1KiR3HDDDVK2bFlXFwceiG0NAOBOIiIizDHktm3b3P4YsnHjxnL99ddzDAkAbuzo0aOOuBYfHy/uKjg42BHXypQp4+riAAAsxstms9lcXQgA5+km+fzzz8t7770nqampHrNovL295bnnnpMRI0aIl5eXq4sDD9nWhg4dKu+//75HbWs+Pj5mW3vrrbfY1vKoSpUqcujQIalcubIcPHiwYP4gALiEuPbMM8/ImDFjPC6uvfDCC/L6668T1/KIuAagqMe1p556SsaOHWsee1Jce+mll2T48OHEtTwirgHwZLToA4qYV155RUaOHGkeF69TQso0KSu+Qe67qSbHJUvkxuNyZvdpeeedd8Tf319ee+01VxcLHuDll1+WUaNGecy2lhSbJCc2RZpt7e2335aAgAAZNmyYq4sFAMgnmuz64IMPPCuu6TFk+Bl58803zTGkHkcDANyDVk7UyiuqRN2SUrpxGbePa3pt5Gz4GVN5Rc/XXnzxRVcXCwBgEbToA4qQ2NhY0/WQ3jd+qJnUuKameIo988NlyycbJTQ01HSlqN0xAQUlJibGbGvapVmTh5pJdU/a1ubtli1TNklYWJjZ1gIDA11dJMughiiAoio6OtrENe3SrMkjzaV6jxriKcJ/+k+2Tt0sxYoVM3FNL4wid4hrAIqqs2fPSrly5SQhIUGaDmoh1bpVF0+xe84u2fbZFilRooTpjlsrsiB3iGsAPJm3qwsA4Lxff/3VJPmCygVL9Z6ec4FG1ehVUwLLBJkLVYsWLXJ1ceAB25om+YLLB0s1j9vWaklg6SCJioqS3377zdXFAQDkg/nz55skX3DFEKnW3XMuhqqavWtLQKlAc1F48eLFri4OACAfzJs3zyT5QiqHStWu1TxqmdbqU0cCSgTI6dOnZcmSJa4uDgDAIkj0AUXI7t27zX2pBqU8ri92/b2l6pdKtxyAgmJfx0o2KO1525q3l9nHqP/++8/VxQEA5OsxpIfGtXocQwKAO/HouObjJSWJawCAPCLRBxQhWmNN+QS4b7/zOfEJ8DH3WiMdKJRtzT9tnfM03ud+N9saALgHj49rHEMCgJteG/HM8zWujQAA8opEH4Ciw8Nq6gGuwpYGAHAnxDUAgFshsAEA8ohEHwAAAAAAAAAAAGBBJPoAAAAAAAAAAAAACyLRBwAAAAAAAAAAAFgQiT4AAAAAAAAAAADAgkj0AQAAAAAAAAAAABbk6+oCAAAAFGWHDx+WAwcOSEJCgnmemJgoR48elQoVKri6aAAAXFRc279/P3ENAGB5Npsty/O1iIgIKV++vKuLBwCFhkQfAACAk//++0++/vprWbVqlaxZs0aOHDmSbvkcP35cKlasKJUqVZJWrVpJ27ZtZcCAAVKrVi2WIwCgyNm5c6fMmDHDEde0skpWca1y5crp4lrNmjVdVmYAAC4lrmmlTOe4dscdd0iNGjVYqADcFok+AADg8VJSUmTevHkyceJEWbBgQa6Wh9Yc1dtPP/0kr776qvTq1UseffRRueaaa8THx8fjlykAwHWSk5NNXJswYYIsWrQoV585dOiQuc2dO1deeeUVufbaax1xzdubUT8AAK6Na3repedrv/3220XFtd69e5u41rNnT+IaALfD0ToAAPBo69evNzU9+/XrlynJV6JECbn66qvlscceEy8vL/Oa3nfp0kWKFSuWrsuY+fPnS58+fUyN0U2bNhX67wAAQK1du1Zatmwp119/faYkn8a1rl27ZoprnTt3zhTXNFGoF0XbtWsnW7ZsYeECAFxi9erV0qJFC7nxxhszJflyimthYWHp4trPP/9sKrG0b99etm7dWui/AwAKEok+AADgkXTshmHDhkmbNm1kw4YNjte1q7KRI0fKrl275OTJk7J48WIZN25cuhPH33//XU6dOmW6jXn77belevXq6S6wauLwrbfeMjVPAQAorLimLRYyVjjRrqVHjRpluqbWuKYXSTPGtSVLlpi4tmPHDhO/qlatmu4CqyYONd4R1wAAhUXH3HvppZfk8ssvl82bNzter127trz33nuye/fuHOPa6dOnZfv27fLmm2+mi2v//vuvSRy+++67xDUAboNEHwAA8Dh6Qqi1PF9//XXHyV3Tpk1N6wW9EPrss89KnTp1HCeLWdFuzOrWrSvPP/+8OcmcM2eONGzY0LyXlJQkL7/8sqldeubMmUL7XQAAz3TixAm56qqrzMVM7Y5aNWvWzLQ214orzzzzjLkweqG4dtlll8mLL74oe/bskR9//FEaNGjgSCLq6927d5ezZ88W2u8CAHimyMhI6dixo4wYMcIR1zQ598svv5jKlk8//bSpyHKhuFavXj2TLAwPD5cffvhB6tev74hreh7Xo0cPiYqKKrTfBQAFhUQfAADwKDo4uyb5VqxYYZ77+vqaMfZ0MHftyuVixiHSMfmuu+46Mxi8njDav+PPP/803XxqYhEAgIKKa506dZKVK1c64trw4cNNiwUdP/Zi45p2aa2t1IcOHer4jj/++MN0aa2tJAAAKAgREREmrun5mfLz8zMVNDXOXey4sRobtUtrjWtaqdP+Hdryj8qZANwBiT4AAOAxtBWCXvS0d2lWvnx5k/B77bXXxN/f/5K/PzAw0HRttnz5cilTpox5bd26dWaMo+jo6Ev+fgAAnGmr8Z49ezrG0KtQoYL8888/pmvq/Ipr77zzjixbtkxKly5tXtNKLRrXYmJi+DMAAPlKK5JoXLOPoVexYkWT4NOuqTXhd6mCgoLMMA1Lly6VUqVKmdc0oahjrcfGxl7y9wOAq5DoAwAAHkMHadcLlKpSpUomIde6det8n48O8K6t+cqVK2ee60XXp556Kt/nAwDwbI8++qipUKIqV65s4pqOE5vfrrjiChPXypYta57//fffpjtQAADy0yOPPOIYP13H1dO4pl125rcOHTqYZJ+9cqbO57nnnsv3+QBAYSHRBwAAPMJPP/0kX375pXlcvHhxWbRokRmHr6DouEYLFy6U0NBQ8/yTTz4xzwEAyA86ht7XX39tHpcoUcLENR2Hr6DoOLQLFiyQ4OBg8/yjjz6SxYsXF9j8AACe5fvvv5eZM2eaxyVLljRxTcfhKyiNGzc2cU1b+akJEyaYrjwBwIp8XV0AAK7x0/U/OB4nJCfI4ZgjMmvHN7Lq6GoZ2+UDqRJWWcatmygL9y0y0wxu8Zh0r95Vlh74U95bM5q/DWBbs5RTp07JQw895Hg+ZswYc8GyoDVr1kxGjRplaqaqBx98UDZv3izFihUr8HkDQEHgGLJoOHHihDz88MOO52PHjjUVTAqatqrQLs+0hbx64IEHTHfYYWFhBT5vACgIxLWiITIy0nHOpMaNGyf16tUr8Pm2bNnSdFE9ZMgQR1zbuHGjo7ImAFgFLfoAD/fBmjEyY8csqRZWVZ5u/YQE+gbK2HXjJMWWIvc1ultKBJSQpmWamCTfqfhTMnnjFFcXGbAktjXXevfdd+XIkSPmsY4rdM899xTavAcOHChXX321eXzgwAF5//33C23eAFBQiGuupRclIyIizGMdV+iuu+4qtHnrhdjOnTubx/v27ZPRo6kECMD6iGuuNWLECDl27Jh53K9fPxkwYEChzVsrr1x11VXm8Z49e0zlGQCwmgJN9O3du9eMR3P55ZdLQECAeHl5mdvw4cMLcrYA8mD5ob/lu10/yL6o/eLn7Sflg8vL9pM7ZO5/P0mof6gMav6wuamJGyZLVFIUyxe4CGxrrhMfHy+ffvqpeawDuGtXY3o8Uli8vb1Nt50+Pj7muT5OSkoqtPkDQEEgrrlOXFycTJ061Tz29/d3SVybMmWKuVcff/yxJCcnF9r8AaAgENdcJzY2VqZNm2Ye6/XjSZMmueR8zT7PyZMnE9cAWE6BJvrWr19vavetXLlSEhMTC3JWAC5SmH+Y1C1RRyoEl5eoxCg5GH3AvP7ltq/lYNRBubxiO6kUWkmWHlwm/xxZyXIG2NYs59tvvzVdwahbbrlFqlSpUuhl0LEltGaq0paFc+bMKfQyAEB+4hjSdWbPni0nT540j2+77TapXLlyoZdBxwLs27eveXzo0CEzDi4AWBlxzXV0XL7Tp0+bx/3795eKFSsWehkuu+wy0/OLvReWefPmFXoZAKDIJvpCQkKke/fuMmzYMMfFLQBFy+fXfCofdB4lPl4+8ubKtyUuOd68npSaZFrwqfjkeJm84RMXlxSwNrY119EamXaPPvqoy8rhPG9tfQEAVkZccx3iGgDkP+Ka6xDXAMBFib7FixdL69atJTAw0NTkGz9+vHz22WeZuubUJN/ChQvN8/r16+dDcQHktzf+GSHzwn+RAN8Aeaz5o+Lv7e94LyI2bdyPuOQ4uuwE2NYs223nP//846ilecUVV7isLDpOX/Xq1c3jv//+m+5gAFgax5Cu67bz33//NY8bNGgg7dq1c1FJRLp16+ZoJb98+XJJSUlxWVkA4FIR11wjJiZGVq9ebR43atRI2rRp46KSiPTs2VMqVarkiGupqakuKwsAFHiiT3d0vXr1kjVr1khCQoKEh4fL448/LmPGjMnzzAG43rpj6+WjjR/L5sgtUjWsilxXu4+riwS4JbY119i0aZMjoda+fftCHeshI523jltsv1C7bds2l5UFAC4Vcc01NmzY4EiouTqu6ZhG9rim4ytt377dZWUBgEtFXHMNHfbJnlArCnHNXoEmOjpadu7c6bKyAECBJ/qeeeYZSUpKctTg077433jjDdm8eXOeZw6g6Jiyaaqk2lLlpstulFC/UFcXB3BbbGuFy147VLVq1UpczbkMzmUDAKsirhWuohzXtDIwAFgdca1wFeW4xvkaACvxzcvEERERsnLlSvM4ICBAZs2aJaVKlZI+ffqY2nvTp08vqHICyGd9f7wh3fPdZ8Kl35yb0r12LPZ4pukAsK1ZyZYtWxyPW7RoIa7WsmVLx2MqSQGwIo4hXYu4BgD5i7jmWkU5rjmXDQDcKtG3Z88ex2Mdm0+TfHZt27a1TKLvyJEj5gYUNYcPHzb3iWcT5Mzu0+Jp9HerQ4cOydq1a11dHLgxj9/WohI9Zlvbt2+f43G/fv3E1zdPhz7p2LuU0fvy5ctf1HfYuxFVe/fudfvlD6Bw2M9tEs54dlw7ePCgR8W1vn37io+Pj0vjmr23H0VcA5BfiGueE9f279/veNy7d+8iFdf0Ori7L38ARZ9zBYQc2fJgxYoVNv2I3ho2bJjuvQ8//NDx3rBhwzJ9dujQoTm+X5h0/vaycGMZsA6wDrAOsA6wDrAOsA6wDrAOsA6wDrAOsA6wDrAOsA6wDrAOsA6wDrAOsA6wDrAOSBFaBrmVp2rtNWvWdDwODw+XU6dOScmSJc1ze5eeVvDQQw/Jdddd5+piAJlMmTJFJk2aJBUuryh1b66X6yX0fM/npPNlneXWT/rL2fizWU5zZe0r5H8dHpQqJSrLiZgTMv3fGTJ3409ZTtusclN5psfTUj6snNjEJgdPHZIvV34lf+xcat4P9g+WIV0elw51Ooivj4+s3b9WPvhtjByPjpRigcVk9v9myp+7lsmIX9/O07+8c/Z2ifj3qAwaNEjuv//+PH0WyItPPvlEPvroowLZ1ob3edVsQ6VDS5vnV73fJcfvvND0d7a9Q65v3k9KBBWX8Mg9Mv6PCbLx0Cbz3sTbx0uJoBJy12f3SEpqSq5/x85Z2yVi1VF57LHH5L777hN3Nnz4cDOesNKeCC6lRV9kZKSpHaqDtJcpU+aia4jq8ZO6+eab5YUXXrjo8gCA3eTJk+Xjjz+WCu0rSd2bLruoBZMxxpUOKS1Pdh0irau3NjHm7/C/ZcziDyUmMSbb7+jf+la5rmlfKV+svETFR8kvW36Vycs+Me81rtRIHus8SOqUrS1n4s7I3I0/y+f/fGHe08880/0pGTL7SVl3YH2ey75jxjY5tiZCBg8eLPfcc4+4s1dffVXmzZtXJOParbfeKkOHDr3o8gCA3cSJE+XTTz+Vih0qS53r6+ZLXLumYU8Tp6qVri6+3j4y4td35NctC7L9/NhbR0uLqs3TvTZuyXj5Zu13FzyPu9S4tv3rrXJ87TF58skn5c477xR39vLLL8svv/xiHpcuXfqSWvTld1y7/fbb5Zlnnrno8gBAYcrTWYE2e27Xrp1J6sXHx0v//v3NydSGDRtk5syZmaY/fvy4LF2alhjYsWOH4/WtW7fKt99+ax536tRJypYtK4WpYsWK5gYUNZUqVTL3/sUCpHjtErn6TOXQStKzUQ9ZuPc38arsLcUl8+cqhlSQN7q+JifiTsgnm6dK9+pdzUHn6eAzsuH4xkzTB5QMkmURy+X4nkgpG1xGbq93mwzr/Yps99opcclxMqTFY9KteleZH/6LnEo4Lf3r3yqv3/SaPL/8JfP5Pw7+IT0b9pAfj8yRQ9Fp3ZHmhv5u85sqV859s2SgCG1ryjfEVxYfWiK31rvZPL/Q9+c0/dVVu8jAVg/K+mMb5Lvw72VA/f7y7k1vy4MLH5bopGiZd3C+DG37rNzY+UZZuG9Rrn+/f5i/x2xrl112/oL3119/LT179rzo76pSpYrp7lSPIbQbnYsxd+5c04WovWzuvvwBFA77uU1A8dzHtQvFuNeuHCaNyzSS2Tu+lSC/IOnXsK/4hwXIB2vGZPkddzW4w8SyHSd3yuSNn0igb6CEFgs15QnxC5aR3d8xFcg+3fKZtK3QWh648j6JDY6Vhft+k7/iVsjDidHyUNeBMnTZi3kuvz2u6X7a3ferdeuev+A9a9Ys6datm0vj2g8//CA33nijeUxcA1CU41rJSiVlW9QOsfmJ1C5RS4LLBUvx+Oy/2zfIV84knJHJG6c4XtudHO4oT07nccS13KtTp47j8ezZs+Xqq68WV8Y1vV59yy23mMfENQBW4p3XD4waNUr8/PzM44ULF0qfPn3kpZdekkaNGmWaVgct1Z2j3n788UfH6998843jdQY2BS5Nz+rdxcfLR/48tCzbaa6p0VN8vX3lx91z5de9C+SrrWnjafap1TvL6Xec2iHf7vxeVkeskY3HN0lSapKk2lLF28tLgnyDpEvVznI24axM2vixzNwxW3ae3CWNyjSUWsXTWv0uP/y3KVOP6t35e+FR25oatfoDs13kVk7T96nVy9xP2TxV5u/5VRbsXSQhfiHStVpabdF/j66WhJQEuaYG21p2mjc/Xwt3zZo14mrOZSgKg80DQFYxrlpYVWlatomEn9kj07fPkCmbppoKY1dV6SDF/MMyLbQAH3/pV7uvxCbFybAVr8kfB5fKnN0/mc+qTlU6Sah/qPy2/3eZv+cX+Xjjp+b1PrWuNffJqcmy8ugqaVi6gZk3rBnX3D3JCsDa5256PvXRxo/lUPShXH9PfEqCrDq6Wv469LcsO7RcDsccztV5HHHNPeIa52sA3DrR17FjR5k/f745iPf395caNWrImDFjTHNyAIWveblmpjslTbYpPZjVCzD2m5d4SaXQtNpwx2Mjzf2xuOOOWm7ZaVmuhUy/9nMZeVVa95vvrxkjMUmxUiGkvPh4+8jxuLTvcv6+Sue+b+epnaZMLco1K7DfDRTFbS2/VTy3Tdm33eMZtrXE1EQJP71HapeoLaF+ofk+f3fQqlWrInXiuHr16izLBgBFKcadP3ZMizvmcVykiX0VQipk+ny1sGoS4BsgyalJMv7qsfJt31kytccn0r7i5Rm+z34seizt9ZDzx6LbTmwz9y3Kpe8mDekR1wAg73HtYpUNKiPf9J0h3103S9688jXTW1JuEddyh7gGAPnjojr01+5BMl4s++yzzzJN17lzZx0t8OJLB+CCKoZUlLOJUeaCv2pQur683eFNx/sPLByY6TO5SUhoq75X/xouVcKqyt0N75B7G90l649vyHLajN+WkJIoUUnRWV4IAtx5WzvmdEG0YGTedk/EnxBvL2+ThP/vdHQBz996tLuV0NBQiY6OluXLl5sxF+w9ExQ27fZ8xYoVjnGVtLIUABTFGJdX2vODKhZQTL7ePlOOxkTIY80fkWdaPyn3/vpgro5FI+NPmHuOH3NWv359CQ4OltjYWFm2bJlL41pcXJz8888/5rGOhVS1Kq0xAbhHXFMrDq+URfsWS3RitGnR3rlqJ3mi5eBcdzFNXMudhg0bSmBgoDlX+vPPPyU5OfmSxp+9FBpbdbgq+/BVOtQFALhtiz4ARdH5hPqeM3vl5b+GOW6n4k/L4egj5r1ywWUdtdLU4XPj52mSwM/bz9zb6UHxuuMb5Kfwn2Vz5BZz0aVZ2Sbmwo3WjLN/R9r3pX3vkXPzMSWypRZICyegKG9rF+ItaduatojIjSPnttHM2+6RTBdX2d6ypoO528flO3bsWLquxAubjjlhH9i9V69e4uXFPhJA0YxxGY8d7cd7KbYUORpz1DzXeKZdw6ujsUfNe0q7f19y4A85GH1I/H38zXjPmY9F0+4PxzgfO6bNn3iWM7342aNHj7TlfvSoGfvVVXSMwDNnzpjH1157LXENQBGTt4YHGtf0ZqfXQjSerYpYLVM2TTOv1ShWPfdzJ67lbrn7+Un37mlDURw5ckR+/vlncZUZM2ZIVFSUecz5GgCrIdEHWJwm3or5F3MckMYkxciG4xsdNx1f79e9C01yTsdOuaZGD7mz4R1m2p/D55v72+rdIt9fN1vuapD2+v+aPCB3NLhdrq7aRQbU7y/NyjY1n99/9oDEJcfJHwf/NDW2H246UPrXu1UuK1VXtp7YJrvPhJvP+3v7mzJp2QBP2tZUh8pXStdq5wcQ71G9m7Qun9ZFY5dqncy29lSrIY73c5p+3p5fzf0Dje+Ta2teIz1rdJfYpFj5ff8Sx/RlgsqYZF9ELNtbdh599FHH44kTJ4qrOM/buUwAUNRi3P6oA6aiV83iNeWO+rfLg03ul9JBpWTZweWmMpgm7DSeTe3xsZleu3dfeuBP8/i+RndLv9rXmbH2dFy/A1EHZenBPyU6KcaMMXttzV4ysOkD6Y5F7fHMlCU2LZGI7BHXACBvcU3VLl7LnGvZW443Kt3IPA/0CTTPNa7pTT8T7BssIzu+LTfWud7EriEtHzPT6HWP3JzHEdesF9c0MTthwoQsywQAVuCattAA8s264+ulRvHqclnJurLlxNYspzkSc0TeWTXSJPIGNn1QTsafkkkbJmfbFeeZhDMmoVAyoKQkpCTIrtP/ybe7vjc1s9XHG6eYtnqdq14lvl6+sjZinUzc8JHj81oWHcdPywZ40ram7m10t5QPLud4/niLQbIpcrOsjliT5+kX7/9dygSVll41ekqjMvfLvrP75dNN0yQqKa2WoZ6E6glr+Jk95sIrstalSxepV6+e7NixQ/744w/TfWb79u0LdXEtWbLE0Q1Ms2bNCn3+AJDXGPfe6tHycLOBcn2d60yFkj8OLJWPNqYl9rIyeeMU03aiS7Uu5jhRY9nUzZ+ZijB6e2PFW/Jgk/vMLSoxynTxuXDfIsfnG5Sql1aWYxw/XkjXrl2lbt26smvXLvn9999N95mXX542HmJhWbx4saxatco8btmypbRt27ZQ5w8AeY1rbSu2MRWZ7bpX72puel0kPjY+3ec1bkXGRUrf2r2luH9xc66l3Xh+tuWLXJ/3EddyT1uq165dW3bv3i2LFi0y8aVNmzaFupLrfNetW2cet27dutDnDwBFJtF37733mhuAwrVw7yK5rnYfU5ssp+TDP0f+NbeszNg+y9zsZu/81tyyE5scK6PXfpjt+1oWvSC0cO9vuf4dgLtsaw8ufCjb9xbvX2JuuZ1ezdrxjbllpW2FNhLgGyAL9p6/UIrMtIvMwYMHy6BBg8zz++67z5zEBQUFFcriiomJkQceSGu9oh5//HG6NwNQ5GOcjgH71sq3s5xex6Tt++MNmY4Px+RwfLj15DZ5aulzWb6nXYC2q9hWtp/cYSq1IGfe3t4mlmhsU/fff7+sXbvWjHFUGHTc2wcfPD/2InENgBXiWsbrHhlljGsjV7+f4zxyOo8jrl1cXHviiScc52tr1qyRgIAAKQxnz56V//3vf47n9vgKAFZC152AxWkrO61hrd1shvqFuro4pgxdqnY2XTQdjD7o6uIAbrutKe2OV8c9+m3fYlcXpcgbOHCgo7WBtuwbNmxYoc37+eeflz179pjHHTp0MCeuAFCUuDrGdat2tYT5h8mXW6cX+ryt6pFHHpFWrdK6iNu2bZsMHz680OY9dOhQ2bt3r3ncqVMnufvuuwtt3gCQG8Q169GuMlu0aGEeb9myRV5//fVCm/dzzz0n+/fvd/QGc8cdacPaAICV0HUn4AbGrB0nY2ScFAXRSdFy27wBri4G4Pbbmnpu2QuuLoJl+Pr6yrRp08zJY2Jiorz33nsm8XfzzTcX6Hy/+uorGT9+vHmsLQi1DFpjFQCKGlfGOB1PWm/IW1z77LPPTLJP49qoUaNMXLvxxhsLdDF+8cUXjvGTgoODZerUqcQ1AEUScc1a/Pz8TFzTbjOTkpLknXfeMd1nXn/99QU6X53n5MmTzeOQkBD59NNPiWsALIkrTQAAwCM0bNhQ3njjDcdg6wMGDJAff/yxwOY3e/bsdN2a68lqnTp1Cmx+AADP0rhxY0dLvtTUVOnfv7/MnTu3wOY3c+ZM002o3ciRI6VWrVoFNj8AgGdp2rSpvPrqq464dtttt8nPP/9cYPObPn16uiEWtDJozZo1C2x+AFCQSPQBAACP8eyzzzouUmpNUW3RN3bsWHMimV9SUlLMSaJecNXH9q5odNwJAADyuxtNe6USjWvaom/cuHH5HtfeffddU0HGHtc0pmlsAwAgP7344oty1113mcfaYv2GG26QCRMm5Htce/vtt8187N87ZMgQeeih7MddBICijkQfAADwGF5eXvLxxx87Th71JE8Hfb/66qslPDz8kr9/586dctVVV5mEorYaVFpLVC+66rwBAMhP2h30J5984hhPSOPa4MGDpVu3bo7xYS+FjmvbsWNHM96sPa7puLdjxowhrgEACiSuabfQWmlSJScny2OPPSbdu3d3jA97KbZv3y5XXnmlSSja49rDDz8sH3zwAXENgKWR6AMAAB7Fx8fHjMXw9NNPO15bunSpNGnSxAzEfjEJP03wPfXUU9KsWTP5+++/Ha+/8MIL5gIs4/IBAApyvD4dO+/JJ590vLZkyRIT17TF38XGNf2+5s2by4oVK8xrWmHl5Zdflo8++oi4BgAo0LimY51rxRW733//3XRZrRVPLqYii1Zc0QqeGtdWrlzpiGuvvPKKGXuW8zUAVkeiDwAAeBw9kdPuNRcvXizVq1c3r8XGxsqoUaPMOHrXXnutTJkyRdatW2e6jMlIX1u7dq1pHdijRw+pV6+ejB49WuLj4837tWvXNsnDESNGUDMUAFAocU1bIyxatEiqVatmXouJiTHj6Glc6927t3z66aeyfv1608VnVnFtzZo1Jq5pqwmNa9pqzx7X9Dv+/PNPM9YtLdQBAIVROVOHWFiwYIFUrVrVEde0K2k91+rTp0+OcS0hIcHEtcmTJ5tW7vXr1zffp6+runXryrJly+T1118nrgFwC76uLgAAAICraJedmzZtcrS80wud2oXLL7/8Ym7K39/fnAgeO3bMPI+IiJCwsLAsE4ABAQHyyCOPyJtvvikhISGF/nsAAJ5NL2Zu3rzZtHjQuKYXPzWuzZ8/39zssUoTd85xLTQ0NMsLpTqtjsWncS04OLjQfw8AwLNppUqNa9pCXRN79rg2b948c7PHqqzO17KKa4GBgTJo0CCT4COuAXAntOgDAAAeTU8Cx48fLwcOHDCDsttb+NlpQm/Lli2OE0UdJyJjkq9WrVqm1cTBgwdNyz6SfAAAV8a1CRMmmLimLcvtLfzstDVDxriW8WKoxjVt5X7o0CHTUpCLoQAAVylWrJhMmjTJxLW33nrL0cLPOa5pMjCnuKYVXN5//30T17RnF+IaAHdDiz4AAAARKVeunGkB8eyzz5px9latWmW6e1m9erXs37/f0X2ZjhmhJ4qtWrUytzZt2sgVV1zBuA4AgCKlfPnypsW6jj/7119/OeKa3rKKa61bt3bEtfbt2xPXAABFLq69+OKLjrim52n28zVNAjrHNW3hZz9fa9u2rVx++eXENQBujUQfAABAhvEgOnbsaG7OtIsYxdhEAACrxbWrrrrK3JylpqaamEZcAwBYiSbyOnXqZG7OiGsAPBmJPgAAgFzgQigAwJ14ezOSBwDAfRDXAHgyjuwBAAAAAAAAAAAACyLRBwAAAAAAAAAAAFgQiT4AAAAAAAAAAADAgkj0AQAAAAAAAAAAABZEog8AAAAAAAAAAACwIBJ9QFFks4lH8tTfDRQytjQAgDshrgGAm/LUawQe+rMBABePRB9QhISEhJj7xOgk8USJUYnmPjQ01NVFgYdsa0nRaeucp0k6t62FhYW5uigAgHxAXOMYEgDcCddGiGsAgLwh0QcUIS1btjT3JzYel9SkVPEkKUkpcmJzZLrlABQU+zoW6YnbWiLbGgC4a1w7vuG4pCZ7WFxLSJETW06YxxxDAoCbna+tPyapKZ4W15Ll5FbiGgAgb0j0AUVIhw4dpHz58pIUkyQbJqyVRA9pbaQt+TaMXyfJsclSuXJlad++vauLBDfXsWPHtG0tOkk2TFznedtaXLJUqVJF2rVr5+oiAQDyQadOnaRMmTKmxfbGieskKcZD4tpZjWtrJSU+WapVqyZt27Z1dZEAAPmgS5cuUqpUKbOf3zRpvUfFtfVj15pKLDVq1JBWrVq5ukgAAIvwstk8tcNroGj67rvv5LbbbpOUlBTx8vWS4jVLiG+Qr4iXuB+bmITDmfDTYkuxia+vr3zzzTdy/fXXu7pk8ACevq19++230q9fP1eXDACQT2bPni0DBgw4H9dqlRDfQPeNa0mxSXJ2zxkT1/z8/Exc79u3r6tLBgDIJzNnzpQ77rhDUlNTPSeuhZ8RW6pN/P395fvvv5fevXu7umQAAIsg0QcUQXPmzJGXX35ZNm/eLJ6iSZMm8tZbb3GBBoXqxx9/lFdeecWjtrWmTZuaba1Pnz6uLgoAIJ/pRcFXX31VtmzZ4jHLtlmzZiaucTEUANyPVk4cNmyYbN26VTxF8+bNZcSIEdKrVy9XFwUAYCEk+oAibPv27bJt2zaJjY0VdxUcHCwNGzaUevXquboo8GBsawAAd6LHjxrb3P0YslGjRnLZZZe5uigAgAKmiT6Na3FxcW67rENCQkxcq1u3rquLAgCwIBJ9AAAAAAAAAAAAgAV5u7oAAAAAAAAAAAAAAPKORB8AAAAAAAAAAABgQST6AAAAAAAAAAAAAAsi0QcAAAAAAAAAAABYEIk+AAAAAAAAAAAAwIJI9AEAAAAAAAAAAAAWRKIPAAAAAAAAAAAAsCASfQAAAAAAAAAAAIAFkegDAAAAAAAAAAAALIhEHwAAAAAAAAAAAGBBJPoAAAAAAAAAAAAACyLRBwAAAAAAAAAAAFgQiT4AAAAAAAAAAADAgkj0AQAAAAAAAAAAABZEog8AAAAAAAAAAACwIBJ9AAAAAAAAAAAAgAWR6AMAAAAAAAAAAAAsiEQfAAAAAAAAAAAAYEEk+gAAAAAAAAAAAAALItEHAAAAAAAAAAAAWBCJPgAAAAAAAAAAAECs5///hD/Lhk5gLgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -765,7 +764,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 36, "id": "7668b7f8-af10-4103-83e3-900e752d2a41", "metadata": {}, "outputs": [ @@ -781,7 +780,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -820,13 +819,13 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 37, "id": "abf17878-649d-4348-a969-e75987bc3ddd", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -943,20 +942,13 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 46, "id": "373efff2-e22f-4fe3-9561-03abec549463", "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "check fidel: 1.0000004768371582\n" - ] - }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAJOCAYAAACqS2TfAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAeJJJREFUeJzt3Qd4U/X+x/Fv0slo2S0tQxAuXEDZLaJeUURR/LsHbtTrFud1oyguHFfFq3gd1z2uOHEjgnARQaaLqSiCzLIpozPn/3x/mPQkTdu0Tdrk5P16nkBOcpKcnPySns/5LZdlWZYAAAAAAICwc4f/KQEAAAAAAKEbAAAAAIAIoqYbAAAAAIAIIXQDAAAAABAhhG4AAAAAACKE0A0AAAAAQIQQugEAAAAAiBBCNwAAAAAAEULoBgAAAAAgQgjdAFDPfv/9d3G5XL7L9OnTQ3qcrmd/nD5PbVT2fBdccIHv9sMPP7xWr4PwfCaIXvbP7OWXX5ZY9Mwzz/jewyOPPFLfm4Naeuedd3yf56233sr+BOoYoRtAWL311lsydOhQyczMlKSkJGnSpIl07NjRBLVrr71Wvvjiizo7QL377rt9z9uhQwepj5BU0UVDrFPEayAvKCiQ559/Xk444QRp166dNGjQQFJTU01ZO+WUU+Sll16SPXv21Pdmoob0cwzlu1yTE2bRTsvtPffcY67rb/hll13md3/g+05MTJTGjRtL27Zt5eCDD5ZrrrlG5s+fL077vjdr1sz3nocNG1bhunpyzO12+9a9/vrry60zc+ZMueiii6Rr166SlpYmKSkpkpWVJccee6w8/fTTVf52WJYln332mZx33nnSpUsXSU9PN39z9W/vkUceKQ899JCsX7/et77+JnXq1Mlc/9e//iXr1q2r1f4AUD2J1VwfACp0/vnny2uvveZ3286dO81FD0L+97//yapVq0woR5nmzZv71SR5D4yiyZlnnikHHHCAua4BM97NmDFDzjnnHFmzZk25+7SM6+WDDz5w3AkWhMb+fc7JyYnJWm5vYNPyq4GuMqWlpbJ7925zWbt2rcyePVuefPJJE/T+85//mLAa6/SE2vDhw+XZZ581y5MnT5aNGzeakBvo9ddfN6HYy/4boPvokksukf/+97/lHrdhwwaZNGmSuTz44IOmdnrAgAHl1vvjjz/k7LPPNsE9UF5ennz11VfmsnTpUt+J7ISEBLnqqqvkhhtukL1795rn1/ANoG4QugGEhR4k2AN3v379TLjW2o9NmzbJwoULzYFYvNGDtP79+5e73RtglR7Q3njjjRLNjjnmGHOByNdffy1HH320FBYW+nbHQQcdJEcccYQp71qD5D3gdRI9eVZV+HKSUaNGyY4dO3zL27ZtkwceeMC3fNRRR5lyYOc9YRbt3+eqeIOl94RbZfT3TX/ntGb2l19+kY8//ti3395//31zwlW/Mw0bNpRYp+HZu2/0RMObb74ZtBbb/rewd+/e0qtXL3Ndg/hZZ51l9pHXX/7yFzn55JNNbbf+jdTaa2+w1vL17bffSrdu3Xzra9AfNGiQrFy50nebtibTFjd6AkDLqT4mWCA/44wz5B//+IfZDt1GrQ3XFjoA6oAFAGFw/fXX62l9c+ncubNVUlJSbp0dO3ZYM2fO9C0PGjTI95hgl/3228+37gsvvGCdfvrp1l//+lerRYsWVmJiopWWlmb16tXLuvnmm61Nmzb51p02bVqlz6uXl156yW/bPvroI+uEE06wWrdubSUlJVlNmza1jjjiCOv111+3PB5PyPsh8LUDXyeYlStX+j1Gn8Nu8+bN1mWXXWZlZGRYqampVr9+/ay33nqr3Gvp89iVlpZar776qnXUUUdZrVq1Mu+rZcuW1rBhw6xPP/20ym23P9+IESN8t+vnpvS9VbWf9TkPO+ww3/JZZ51V7nWfeuop3/3NmjWz9u7dW+G+mjJlit/z//bbb+Xec1ZWlu/+++67z3efbq9uu7f86GfcpUsX64wzzrDGjx9vhaKgoMDq0KGD7/ndbrfZxxVt64wZM/xu27Nnj/XYY49ZBx98sHl9/Uz0cz322GOtCRMmVPmZ6Pt9/vnnTblPSUkxn+vf//53a+vWrUG3QV9/+PDhVrt27azk5GTznTnooIPMPi8qKiq3fmDZnThxojVw4ECrUaNGVpMmTcL63JMnT7YOP/xw89yNGze2jjnmGGvRokVB38cff/xhvue9e/c2r6PvXV/3xBNPNM8TKFzf58q+p3fddVeF61b0GxD4ndm+fbt19dVXm+1s2LCh2R9z5swx6/7666/WqaeearZd98/QoUOtn376Kejr6br6PPr7qM+jvxPdunWzbrnlFr/fxlDob7R3+9q0aRN0f9nfg/422G3bts18lvZ1dDsCbdiwwbrttttMWdb3p59pp06drCuvvNJatWpV0G2r7W+a7qfHH3/c7Bt9vezsbPO3a+fOnSHvH93H3ufr06dPufu//fZbv9d84oknfPf997//9btPv/eFhYV+j3/55Zf91hkyZIjf/Weeeabf/VdccYVVXFxcbjt+/vlnU94D6W+P97HB7gcQGYRuAGGhB3zeP+R6ELRixYoqH1Od0K1Bs7J19eBw7dq11Q7dehB33nnnVbquhv1gJxHqInTrAaz9IM9+Oe644yoMyRru9GCtsvd1ww031Enofuedd3zLGgYCA6I9lOsBd2U0AGi58K7/wAMP+N0/depUv0CsYU1pQKpsOzMzM61Q6MkO++O03Idq/fr1Vo8ePSrdDg1Z9gPowM9Eg1ewx+k+DHT77bdX+lp/+9vfrF27dvk9JvB++7I9dNf2uQ855BDL5XKVe5yeEMnLy/N7nIYpDdoVvda1117rWzfc3+dIh+5gv2v6Hfnwww+t5s2bh7R/9MSIBu3KfhuXLFkS8vscPXq077GnnXZale8vMHSr/Px8853yrqOh2h4uZ82aZf5OVLTNWtaCnbCq7W/a4MGDgz4uJyen0pN9dg8++KDfYwNPFF111VW++/SkgP2kh55Usf8+LV++POhr6ImuYL/F69at8/ve6EkoLfPV8Y9//KPSzw5AZBC6AYRF4MGkHlD07dvX1NA+99xz1i+//BI0wDzyyCN+j9OaM71NL/o4L60ROP74463rrrvOuueee6z777/fBDQ9CLWf8VerV682j9faEHsNqvd59eI9UBo7dqxvHT2Y0YPMe++917rooovMAZP3Pn29UAQe5Nnfj/2i2xhK6LYfwHkDrx4UH3nkkeUOHO0hWfe793athTz//PPN+9JaXftB2xtvvFHj0K37UN9L//79ffftv//+5d6nhsi2bdsGrfnRIKplxXvfvHnzqhUKDjjgAL/7tNbXHlC9tDbZe7seuGsNuNaynXvuuabmOtTQfckll/jto++++84KVeABv5Y1fS+BB9hjxozxPSbYCST97O+8807rwAMP9Lt99uzZFdao6b7Q742WJw1A3tv1/dgFvpYGo5EjR5qA6Q1g4XpuPZmk4V1rKe2363fS6/fff/cLlFp2tXZbt0e///oc9tAd7u9zpEO3ln3dT1rbat8+vWhrDH2PF198cYX7R1s+NGjQwHefntS54447zH61n5zSmt1QTzRoiwDv4zRgVvX+Kgpu+rnY1/vmm298LZ7s30fdTm3FoPvTflJKa7K1JUA4f9P0ouVHv3catCv63lVGT+4mJCT4Hqfb7qUtPOx/k04++WTffbr/dbsrqyX3GjdunN+2vfbaa+Z2fW/227XWvrrsJw719xpA3SB0AwgLDVb28BXscuihh1rff/99yAeogXbv3m2a7GoY1ya6Gur0AKqiAwh77aa91txLawjstS16IGb38MMP++7TA6lQahRCqWUPDNYVhW7dp/YQo7WZ3m3QGt+jjz46aEjesmWLOWD33v7iiy/6baMeyAc78Ktu6A7lPi8NOd51NCx6Pfnkk0Fvr4wGDftBtrfJrdak6ckV7+325trp6em+2zXoB9Jmp6EIDIih1o5pOLc/zn6grgfj9uCtNZzezznwM9GDeG9zX/2c7Qf///rXv3zPqZ+r93YNJ3Zvv/22X7DT5/Gyv5bus2DNfMPx3No03N6k1/6cp5xyiu92rbm0P84eqJTuJ285jcT3OdKh2979Qbte2O/T3zcvbbYfbP/Yu/VoVwl7edRaUXv50NrzULRv377C/V2d0P3000/7radlQ+lJN+9t+n21lxFtHaFhO/AEXbh+0+wngjQg20O+nhgMlZ4Etrck8JYlbXVgfz37Pt+4caPffSeddFKFz//BBx/4ratlN7AM6+Xzzz+3qsvefUBP+lT3ewCgZpgyDEBY6JQxOnjUbbfdFnQ0V6UDu+jgQzqwWnU99thj5nmHDBkil156qRmB9aabbpIPP/zQt06wkaQrs3z5ctm8ebNvWafIsU+Dc/PNN/vu27Jli/z8889Sl5YtWya7du3yLesAPDoNjdLt09Gzg5kzZ46UlJT4lnVaGvv70ulovL7//vs6mdZKR+vVKXHUTz/9ZLZR6ei8XhdeeGFIz+Wdgs7LOwqwDuangwh5R4Q/8cQTfev87W9/8xvE7rjjjpPrrrvOTPm1YsUK2X///SWSAgcRHDFihO+6jip87rnn+pa3bt1qymYwV1xxhfkMve+xZcuWvvu8710/T/1cvV599VW/z18HU/LScjJ37twKZyNo3769323hem6d5kgHjvLSKY8C34eyDwalg0npiM12+n3wTgcY7d/nYOyfe+C0hvZ9aZ/RwL5/vvnmG991fT86KJb3/WZnZ5vBvrxmzZoV0jbZf5+1jNWUffRuO/s263tp0aKFb5u9A28GbnO4ftO03Hnp9Fr2fax/P3SQslDYRyPX0dqnTZtWbgA1/XtV2bRi1RnAzP451pbuby+Px2O+CwAij9ANIGz0IFpH99WpZhYtWiQvvPCCCRf2g2s9oAqcVqwqEydONCOu2gNoMEVFRdV6Xg031VGTkwU6V/OfrYr8LqHMZ719+3a/5YyMDL/lik5uVOd96bbUxUFXq1atzEkDL51GSMuJN1TpAbA9gFRFD7oDQ7eOJOyl4cwb8tW///1vM8K40verIwQ/8cQT5gSOjh6soy/rAWhV2rRpU+7ESCgCP5PAzy5w2R6s7AKDmf09erdfH1tR4KlOuf7rX/9a7rZwPXco7yNwv+nJlvr+PoebBmOv5OTkCu/Tk5pV7Z9oe7+BJzW8352abHO4ftOq+g0N/M2tiJ7Qs0+Dpief9LvxySef+G7Tk6L2z01PYOjvnNfq1asrfH6dctBO5z+vze+PXXW+vwDChynDAISd1jz06NHDXDQc3X333aamxnuwqNPKVMeECRN817UmRKeh0ZpLnTdVazh07tGaCKzF0RME9qm8qgoKkda0adNy86/aVVQrE/i+dEob+wF8oCZNmkhduPrqq31zxr711lt+ZeL//u//TDAP1amnnmo+d53GSqfOmTJlit80PIG15jq3uNY2a6221r5qGdQad20poTVob7/9tpkSrara9iOPPNLUjnvp+xk3blyV2xv4mehnZ69xCvwsK5rX2H7Qrry13pWVG51KyF7TH6hv375Bb2/UqFHEnjuU9xG43+xTJFW1bjR+n0PZD3b2wBbKe9bf28rmhK9sX9hp6wmdrqqykz9V0bmo7b/beuLVO3WifZuzsrJMq6WK6Pc28DG1+U3T39CuXbtW+L0LLN8V0ZNEOpWansxT+jdJpwWzTyMY+Fno5zlw4ECZMWOGWdbfIT2pEOx3T3+P7A499FDzv05LqN8Vb3DWsH/NNdf4WkCFwn4CQx9n/x0CEDmEbgBh8corr0hBQYGpzQycy1cP3vWPuzdgBR7Y6MGIt+lgsGaB9loLbQasTdSVPt+7774b0gFtsOfVgy894PA+/969e4POr6sHatok0nsAWFe0plFPMnhr+LVGV2tmdV/qQdcbb7wR9HEDBgwwTZa9TRJ1PwR7Xzp/rjbJre3cy1XtZ3sAO/jgg02TUX1PY8aMCVpzHQptmqkHvc8995xZ1v3ifW09+A0Mez/88IMceOCB0rlzZ3Ox11h99NFH5rrOJV9V6D7ppJNkv/3289VEPfXUU5Kbm1uu2bOaOnWqqb3UUKrvO/D7onPkKv2cXn/9dd99GjDswaC69PumcwN7m4Fr+b722mvLBTydS/nzzz83YS0anjsYDRveJuo677merLHPG63fAw2I2gw+2r/PkaDlyrt/tOWI/v4G1obqb6uekNLfhVDob6w3dHv/rw49Eabfhw0bNvhuGzlypK8mX7fZGyo1dOpc1D179vR7Dv1c9fvjbVYfrt80bWXlPUlUXFzsF251v1XUeigY/a3whm79Pbvzzjt99/Xr18/83gTS3ylv6NbXv/LKK83vuv0Ei26jvSvAscce6ztBpCcptEm894TGd999Z75/euJP94+dnljUshHYDcn+mepvWXUCO4CaI3QDCAuthdIQpf1k9UBZD8w1POgBsAZje388rVG004Mdb4h59NFHzWM0VPXp08fULOrB9Jdffmnu//HHH82Bpfbv1IP6b7/9tsJtsh986sGdHiR1797d1BRoLam+htayjBo1yqyjB2C//fabCfVaM6MHjfPnzzf9CfU9nXzyyXVaWvRATPvVevsr6sHa4MGDZdCgQSY06EFpMLrfNcR6a2Qffvhh8z70YFdbB2gfRN1vesCmtYFDhw6t1Xba9/OCBQvMQaAGGj3I1lqYwNpu7wGlnqRRrVu3LlcmQqGfpzd022tBgwVnbT6uQVBrinR7dR/9+uuvppl5dWq5tIZLa7d1n2l3Bg0BelCr4VufW0+S6P7V8Q00JGr3Aj3I1xMBWpa9n5l+JlrWNJROnjzZr8+37r/aHgjreAfeg20tKxpqjj/+eFODrt8v/ey1ab8exNtDbH0/dyAtPxpsNEArDXMaOPT3RWthp0+fbrpqaOjQfRbN3+dI0O/TM888Y75LWoOp++X000833z8NgkuWLDH7SJtN63ekohYUdocccoj873//852IqsrixYvln//8p9kGbVKuAd/eTDsnJ8cvkGoN8H333Wf63+vfBX093WY9GaY1xRqadZu1Flr7Smu3gnD9punj9W+Blln9+6Hbbh93ojr0fen31/sc9hOOFbU40L9derJUX1vp30Z9vJ7Ma9iwoSmb9ibq+h169tln/Z7j8ccfN+/VfuJPn0+/g3rSQMuBPs/XX39t/n4Ehm7db16VtVIBEGY1HIANAPxUNQ9ysNFjg43Aa7/oFERKpxsLNk+vjmZ7zjnn+N1mp6NUVzR/rXfu1FDm9a1sVO5Iz9Otc1rrqMTBtsk+52vgaOM60ntVc9oGjjxc09HLdWRu+7Rf3kujRo3KvVcdMTg7O9tvvZtuusmqKZ0Kyf5cOiXP5s2by63XtWvXSveDjhiu01OF6quvvir3PoJd7J+/lsfu3bvXap5u+2ei7NNCBY6mrVOiVbV9gaP6h1p2w/3clZWvcM/TXZ3vc6RHL6/sNzTU/aMjXet3rar3HFh2KmIvczqSeVXvr6o50e3Tfnnp9GGVzdMd7LcwHL9pxx13XNDH6HzpOg94dQWOJu79DbKPyB5sDnOd5qyq96G/bcFm+1D6WxU41WBV+8Lr4IMPLjcVGYDII3QDCItt27ZZ7777rpm6JTc31xys6fyxegCiU6qccMIJ1nvvvRf0sXqwowfOOmWLfYobb+j2BjudIktDtE6jpQee//vf/yo9iFVTp061DjnkkHIHpd7QbT+w18Cj26DbnJKSYkKDzg2uc6bq9Dv1EbpVXl6eOVmhU+nodvXq1cs8b1WBTAPIm2++aaa50nmo9SSFfiadOnUy8xfr1Gv2g8Oahm6l03PpvOypqamVhm6lczrbX2fp0qVWTQUe9OpnGMz7779vXX755ebgunXr1mZOZC1LOs+zltlQA4mdhoBnnnnGHMhrGdf3rmVHy42GjXfeeafcgbw+5tFHHzUHzE2aNDGfiX6uxxxzjJk/N1BtQrc33Ohc5B07djRlR9+3bqt+lx544AFrxYoVfutXp+yG87mrKl8637uenOnZs6f5/utr6UkP3fdffPFFufXD9X2OhdDt3TadXk2n3dP9o7+jOi2aljPdb945skOhU9Lpb4T39ebOnVvp+9OLnnTT3xb9TPQ1r776amvBggWVvo5OoaXzzet3Uqen021u2rSpWda54b/88sty01nV9jdNpxt86qmnzMkvLRNZWVnmb4/OHV4TeiLN/jerst+gQDNmzDDzx+sJwcCTShq4dQrEqj6njz/+2Jx47ty5s/m91f2hc6DryYnx48ebfWy3Zs0a33SL+vujv0cA6oZL/wl37TkAABXRfrnekcx1RPHA6bQA1K9HHnnEN8WaNtnXbj+xSJupa7cPL21iHw0D6AWj3R+0ubcO9qi0z7p+DuGkTdO9A9dpP/snn3wyrM8PoGKMngAAiDjt46kHwNof19vn1nvgByC66ABfOtaCevHFFyU/P7++N8nxdH/r2CXeMTK0n7xOwRkuOv7E+PHjzXUdz+TWW28N23MDqBoDqQEAIk5Hu7bXOHlrue1zdwOIDjpK/ejRo0341hNmOphXsNHCEV5aC6/TH2prIO8I5zrafuD84jWh05rp4JHeAQoDR7kHEFk0LwcA1FkzTx05Xmt0dKRdrcVhjlgAkf7diYXm5QCcjdANAAAAAECE0KcbAAAAAIAIIXQDAAAAABAhcT+QmsfjkXXr1klaWprpawgAAAAAQFV09m2d4SE7O1vc7orrs+M+dGvgbteuXZU7FAAAAACAQH/88Ye0bdtWKhL3oVtruL07Kj09vcIdhfhrAbFp0yZp1apVpWetgFhFGYfTUcbhdJRxOJknRo7Fd+7caSpwvZmyInEfur1NyjVwE7ph/6IXFBSYMhHNX3SgpijjcDrKOJyOMg4n88TYsXhV3ZSj/x0AAAAAABCjCN0AAAAAAEQIoRsAAAAAgAghdAMAAAAAECGEbgAAAAAAIoTQDQAAAABAhBC6AQAAAACIEEI3AAAAAAARQugGAAAAACBCCN0AAAAAAEQIoRsAAAAAgAghdAMAAAAAECGEbgAAAAAAIoTQDQAAAABAhCRG6okBAADgbIUllnz2a4lMXlki2wstaZrikqM7JsqwTomSkuiq780DEMO/KXn5qZKRVuiI35SoqumeMWOGHH/88ZKdnS0ul0smTpxY5WOmT58uffv2lZSUFOncubO8/PLLdbKtABCuPy4fLC+WKybtlbM+3GP+12W9PZKvd9XkQrnq61TzfyRfD4BzTVlZIgNe3S3/+KpQvlxZKnPWecz/uqy3T/29pL43EUAM/6Z8tznRMb8pURW6d+/eLb169ZLx48eHtP7KlSvluOOOkyOOOEK+//57ue666+Tiiy+WL774IuLbCgCxdsDq5D9mAOqW/p5cNqlA8gv3LXvE/3+9/dLPC8x6ABDvvykuy7KisnpDa7o/+OADOemkkypc55ZbbpFPP/1UFi1a5LvtzDPPlO3bt8ukSZNCep2dO3dKkyZNZMeOHZKenh6WbUfs83g8kpeXJxkZGeJ2R9W5KTjsj4sK9iPsbUD17DGpMqRjYsy9HlDf+B2PHG0Zoyfq9CC4soNI/V1JSxGZc36jmG4WGq0o43CKwhj+TQk1S8b0kdXs2bNlyJAhfrcNHTrU1HgDQDT/cblxWsUB2Hu7/jnR9ea0q9kfF49lSXGpyM5CS/7xVWivd/3UAnlhWKokuV2+272P0VO09uv2x3rP3+67brs92PoBz+O7HmS9ULbB/p50Oypa13+98q9Z0etIBdtY/rFlC1Vtg/m/guep7HX81in33FYFn03V79W+X8K5DYH7PFyfe8WfpX85LCxMleTkQt9ZpVC2IfCzqWo/+n2Otvdfl2WvOtsQ9LlD3BfedfYUW5JfJFXS9XcWiuS8vFtSEqLjANlJ9LP2eBqK271HXL5Tp0DsKSy1ZFdx6L8pn/9WIid1SZJYEtOhe8OGDZKZmel3my7rGYe9e/dKgwYNyj2msLDQXLx0Xe/ZQr0A3vKgB2+UCUTCx78Umz8aof5xOfujPZLR0C1FpZYUe0SKSuXP/y3bdf3/z+VSkSKPSEk1f9L09XYXi5z54b6ADsQ+Pcwpre+NiHt6ML2r2H7qAeHjbY3H/kX8lPgvfiuREzonSDQINSvEdOiuibFjx8qYMWPK3b5p0yYpKOBAE2VfIG0mosGb5uUIhQbf7YUu2Vrokm36f8Gf/9tu8142F2iNROi1Et9t1IMpggMAAIhvHhHJyy+UvLwdEg3y8/OdH7pbt24tGzdu9LtNl7U9fbBabnXbbbfJDTfc4FfT3a5dO2nVqhV9uuEXunVcAS0XhO46mBrit1KZ8nupbC+wpGmqS4Z0SJBh+yfUa38dPeGitb5b9lq+y2bzv/z5v3d532VHCDXXQG14vw0uV/Dr3mXvun7XA+4v9zwVPLby1923ZP61Pbaq57avG+n3VFJSIomJieJ2uUJ8T1JH78kV1s8pcH9V+J6qfO7y2xVsH/xvdamszg+9ZnW/dJccsV901Eo5imXJnr17paEe89o/MCDGTFtVKqt2WiHXdGekpUhGRnSMxZWamur80D1w4ED57LPP/G778ssvze0V0anF9BJIgxXhCnZ68EG5iCwd3Ev7LGsTavefZy9Ns6GVpXLvLJFHB6fKkR3C9zOlfZy3F2ho9sjmPf7BudzyXksKomSAzMZJIh2auCUpQSQ5QUx/633/6/K+6/surj9v87/+/vJiWbalrK9zZfSwrX9rt1yXm2w70HZVOwT51nfVNrS4KgwPFT53Ba9TbtsreKx9X1QYjqoZdkJ5r8FfhwPpmmKQqcjRaQZ11oNQXZuTHHP9L2OnjO+QjIymHMMiph3YKvTfFD1WHLp/YtSU+VC3I6pC965du2TFihV+U4LpVGDNmzeX9u3bm1rqtWvXyquvvmruv/zyy+Wpp56Sm2++WS666CL56quv5O233zYjmgOIbvbRtCubGqKq0bR18I2t3rC8Z9//FQVpXa+0jru9NU4WadnAJS0auHz/b9prmam6QnXPYSm1OmBtnuoK+Y+Z7p6zeiTJwDZR9ecBQBQZ1ilRxnxTGPJIw8fuz+8JgPj+TYmqLZ4/f76Zc9vL2wx8xIgR8vLLL8v69etl9erVvvs7duxoAvb1118vTzzxhLRt21b+85//mBHMAcT+6N3quikFcuNByaY2fF+I9uwL1n8G6p0hjKAbTjqod7NU/xDdsqH/dft9qUGayFd3aoza/nGJhz9mAOqOdv3Rlkh6YlR/N4L9rnh/+XS9aJnaB0B0SomD35Sonae7rjBPN4KhWWJ0NU2MNG2CXVFobhlwmwbuhD+n06qNqb+XmD8uUsUfl+eODU8T+7p+PaC+8Ttef12E9P/0lPB3EYI/yjicZkoM/qbExTzdAGLT5JUlvh/RSElLliCh2R00WOu6dd13Vv9oaNP5iv64pIX5j0tdvx4A59OuP3PaNTJz5uoUPtsLLWma4jL9LbXFTCzWRgGInt+UvPxCM2iaE35TOLoCUOd0lPLqBm6tXNa+yUFrowObd6e6YuKHua4PWJ38xwxA/dDfDR1zgoHSAITzN+WEzgl/DhSYHjWDptUGoRtAnVq90yO/bAs9cmsMPHy/BHnumNSwNOuO9wNWp/4xAwAAiFaEbgB1QqfrevWnYnlkTpHsrcZUXNr/+PjOiY4M3AAAAHA+QjeAiPttu0dumVYgCzZUr1E5o2kDAAAg1hG6AURMqceSF38slsfmFklhwLTUXZq75Jet+8bRduLUEAAAAIAidAOIiF+2euTmaQXyQ55/7XbDRJFbBqbIOT0S5avfSxlNGwAAAI5G6AYQVsWlljz3fbE8Ob9IigJakx/SNkHGDkqRtun7Bu5iuhkAAAA4HaEbQNgs3Vwqt0wrlEWb/dN242SRUQNT5IxuieXmw2a6GQAAADgZoRtArRWVWvL0wiJ5emGxlATUbg9qnyD3D0qR7MZMSwUAAID4Q+gGUCs/bSqVm78qlOVb/dN2erLI6ENT5OQu5Wu3AQAAgHhB6AZQI4UllvxrfpHpv10aMPz4UR0S5N7DUiSjEbXbAAAAiG+EbgDV9t2GUrlleoGs2Oaftpulitx9aIr8X2dqtwEAAABCN4Bq2VtsyePziszc256A2u1hnRLl7kOTpWVDarcBAAAAL2q6AYRk7rp9tdurdvin7RYNXHLP31Lk2E78nAAAAACBOEoGUKndxZb8c06RvPpTsQRUbstJXRLlzkNSpFkqA6UBAAAAwRC6AVRo1poSuW16ofyR7x+3Mxu55L7DUuTIDvyEAAAAAJXhiBlAOflFljw4u1D+u6Sk3H2n/zVRRh2cIukp1G4DAAAAVSF0A/Dzv9Ulcvv/CmX9Lv/a7ezGLhl7eIr8rR0/GwAAAECoOHoGYOwotOS+bwrlveXla7fP7p4otwxMkbRkarcBAACA6iB0A5Cpv5fIqP8VSt4e/9rtdmn7arcPbstPBQAAAFATHEkDcWxbgSVjZhbKR7/4125rffaIA5PkxgHJ0jCJ2m0AAACgpgjdQJz6/NcSGf11oWzZ61+73aGJSx46IlVyshLqbdsAAAAApyB0A3Fm8x6P3PV1oXz+W6nf7W6XyN97Jsn1ucmSmkjtNgAAABAOhG4gTliWJR+vKDHNybcV+N/3l2ZueeiIFOmdSe02AAAAEE6EbiAO5O32yJ0zCuXL3/1rtxNcIpf1SZKr+ydLii4AAAAACCtCN+Dw2m2dAkynAttZ5H/fX1u45eEjUuSAVtRuAwAAAJFC6AYcat0uj5kG7H+r/Wu3E90iV/VNliv6JkkytdsAAABARBG6AQfWbk9YWiIPzCqUXcX+9x3Qal/f7W4tqN0GAAAA6gKhG3CQNTs9cuv0Qpm11r92O9ktck1OslzaO0kSdZhyAAAAAHWC0A04gMey5PXFxfLw7CLZU+J/X59Mrd1Olc7N3PW1eQAAAEDcInQDMe73HR65dVqBzF3v8bs9JUHkH7nJcmHPJEmgdhsAAACoF4RuIEaVeix56adieWxukRQE1G7nZLnlwcNTpWNTarcBAACA+kToBmLQr9s8csu0Alm40b92u2GiyM0HJcu5BySJ20XfbQAAAKC+EbqBGFLiseT574vliflFUuQ/VpoMbJMgDx6eIu3Sqd0GAAAAogWhG4gRy7aUyi3TCuWnTf61242TRG47OEXO7JYoLmq3AQAAgKhC6AaiXHGpJf/+rljGLyiSYv+8LYe1S5D7B6VImzRqtwEAAIBoROgGotjiTaVy87RCWbrFP22nJYvceUiKnNqV2m0AAAAgmhG6gShUWGrJU/OL5JnviqXU8r/vyP0S5L5BKZLZiNptAAAAINpx1A7HKi4ulpEjR0qzZs2kefPmcvXVV0tJScDcWn/69ddf5dhjjzXrtmnTRh555BHffXl5eXLOOedI27ZtJT09Xfr06SMfffSR3+Mty5KxY8dKhw4dpFGjRtKlSxeZM2dOjbb7h42lcuI7e2X8Qv/A3TRF5PEjU+S5Y1MJ3AAAAECMIHTDse677z6ZOXOmLFmyRBYvXixff/21PPDAA+XWKy0tlRNOOEH69u1rAvZXX30l48ePl/fff9/cv2vXLhO0v/32W9m+fbvcc889ctZZZ5nn9Ro1apR8+umnMmXKFLP+l19+Ke3bt6/W9haUWPLg7EI59YO98vM2/+bkx+yfIF+c2VBO7JLEYGkAAABADHFZWkUXx3bu3ClNmjSRHTt2mFpMOEe7du3k8ccfl9NOO80sv/POO3LjjTfKqlWr/NbT8NyzZ0/Zs2ePJCcnm9vuvvtumTx5sgntbnf5c1Ma0LUW/aKLLpKtW7dKdna2/Pjjj6aGuybmr9eRyQtk5Q7/r2OLVJeMOSxFhnWiJwjCy+PxmJNMGRkZQcs4EOso43A6yjiczBMjxymhZsnofQdALWzbtk3WrFkjvXv39t2m11evXm2+FIFfamU//6S3LV26NOhz6w+A3qdBXWkNeEpKivz3v/814VubmN9yyy1SVFRU5XbuKbbknpmFMnzi3nKB+/jOiaZ2m8ANAAAAxC5CNxxJm3irpk2b+m7zXs/Pz/dbt2vXriYojx49WgoLC01T9JdeeqncekqD9JlnnilnnHGG9O/f39ymNd16luuXX36Rn3/+WWbMmCGff/65PPTQQ5Vu47drS2TY23vk5Z+KxR63Mxq65NljUuWJo1KleQNXrfYDAAAAgPpF6IYjNW7c2Pxvr9X2Xk9LS/NbNykpST788EP57rvvzCBqOmjaBRdcYAZVCwzc2lS9YcOG8vzzz5d7rTFjxpjr2pf72muvlY8//jjotu0qsuTOGQVy9kcFsnqnf+22TgGmtdtHdaQ5OQAAAOAEhG44kgZmHW38+++/992m17Wft/a7CNSjRw/Th3vz5s1mPa3xHjhwoF/gPv30083/7733nq/vt+rVq1fI2/X1HyVyzIQ98sZi/1HUsxq55MVhqfLI4FRpkkLtNgAAAOAUhG441oUXXij333+/bNiwwVx05PKLL7446Lo6CNru3btNqNZRy7V5+XXXXeebekybk+v9EydONP237Tp27ChDhgwxo5rrYGzr1q2TJ598Uk488UTfOjsLLbl1WoGM+KRA1u3yr90+q3uifD68oRy+H7XbAAAAgNMQuuFYd955p6mt7tatm7kccsghcvvtt5v7Lr/8cnPxevvtt02zcK0h/+c//2mCd/fu3c19s2bNMs3Pv/nmG2nZsqVpQq4X+/Rjb7zxhmm+npmZKTk5OTJ06FC5+eabzX1frdpXu/32Mv/a7bZpLnnt+FS5f1CqpFO7DQAAADgSU4YxZRgiNE3B9gJL7v2mUD742T9sq/MPSJKbDkqWRkk0JUf9iJWpOICaoozD6SjjcDJPjBynhJolac8KRMAXv5XInTMKZfNe/6bk+zVxyUOHp0pudgL7HQAAAIgDhG4gjLbstWTMzEL5ZIV/7bbWZ1/UK0luyEmWBtRuAwAAAHGD0A2EgWVZ8umvJXL314WytcD/vk5NXfLQEanStzW12wAAAEC8IXQDtbRpj8c0JZ+8stTvdrdL5NLeSXJt/2RJSaTvNgAAABCPCN1ALWq3J/5cIvd8Uyg7Cv3v69LcLQ8fkSI9M6jdBgAAAOIZoRuogQ27PDJqRqFMW+Vfu53oFrmiT5Jc1S9ZkhOo3QYAAADiHaEbqGbtts63ff+sQtlV5H9fj5ZueeiIFOnektptAAAAAPsQugGbwhJLPvu1RCavLJG8/FTJSCuUozsmyrBOiWb6r9umF8rMNf6128lukav7J5v+20nUbgMAAACwIXQDf5qyskRunFYgOwtF3CLikURxby6VL1aWmqbkliVS6J+3pWfGvr7bXZpTuw0AAACgPEI38GfgvmxS2VxfnoD/C/yn3ZbkBDFzbuvc24k6TDkAAAAABEHoRtzTJuVaw62sEPZGn0yXPHJEA9m/mdaHAwAAAEDFCN2Ie9qHW5uUh+qc7skEbgAAAAAhoaoOcU8HTQv1i6Drffl7QFtzAAAAAKgAoRtxb3uh5eu7XRXPn+sDAAAAQCgI3Yh7TVNc1arp1vUBAAAAIBSEbsQ9nYe7OjXdQ/dnKAQAAAAAoSF0I+4N65Qo6SkiVdVf6/263rGEbgAAAAAhInQj7qUkuuTRwamV7gdvINf1dH0AAAAACAWhGxCRIzskyjPHpJSr7fZ+QdJSRJ47NtWsBwAAAAChIkEAf+rUNEHs45K3beSRHhlJpg+3NimnhhsAAABAdRG6gT/NXV/qty/GDiiQgX9pLG43DUIAAAAA1AxpAggSupukiHRMD3VMcwAAAAAIjtAN/GnuurLQ3b91grgZLw0AAABALRG6ARFZm++RdbvKenTnZPHVAAAAAFB7JAsgoJZb5RK6AQAAAIQBoRsI6M/dMFGke0u+GgAAAABqj2QBBNR098tKkEQ6dAMAAAAIA0I34t6mPR5ZuaOsP3duVkLc7xMAAAAA4UHoRtybt95/arAcQjcAAACAMCF0I+7Ns/XnTk4Q6ZXB1wIAAABAeJAuEPfs/bl7Z7glJZEJugEAAACEB6EbcW1HoSXLtpQ1L8/Npj83AAAAAAeH7vHjx0uHDh0kNTVVBgwYIHPnzq1w3eLiYrnnnnukU6dOZv1evXrJpEmT6nR7Edvmry+VsiHU6M8NAAAAwMGhe8KECXLDDTfIXXfdJQsXLjQheujQoZKXlxd0/TvuuEOeffZZefLJJ2XJkiVy+eWXy8knnyzfffddnW87Yr8/d4JLpG9raroBAAAAODR0P/bYY3LJJZfIhRdeKN27d5dnnnlGGjZsKC+++GLQ9V977TW5/fbbZdiwYbL//vvLFVdcYa4/+uijdb7tiP3+3D1auaVREv25AQAAADgwdBcVFcmCBQtkyJAhvtvcbrdZnj17dtDHFBYWmmbldg0aNJCZM2dGfHsR+3YXW7Jos60/N1OFAQAAAAizRIkSmzdvltLSUsnMzPS7XZeXLVsW9DHa9Fxrxw877DDTr3vq1Kny/vvvm+epiAZ1vXjt3LnT/O/xeMwF8WPh+lIpsX3k/Vu7fGVA/7csizIBx6KMw+ko43A6yjiczBMjx+Khbl/UhO6aeOKJJ0xz9L/+9a/icrlM8Nam6RU1R1djx46VMWPGlLt906ZNUlBQEOEtRjSZviJZZ+b2LXdI3Cre4QP0C7Rjxw7zZdcWF4DTUMbhdJRxOB1lHE7miZFj8fz8/JDWi5rQ3bJlS0lISJCNGzf63a7LrVu3DvqYVq1aycSJE01Y3rJli2RnZ8utt95q+ndX5LbbbjODtdlrutu1a2eeKz09PYzvCNFu8bd6kmXf2amuzV3SuW2G3xddT+RouYjmLzpQU5RxOB1lHE5HGYeTeWLkWDywq3PUh+7k5GTp16+faSJ+0kkn+Xa2Lo8cObLKN9umTRszhdh7770nZ5xxRoXrpqSkmEsg/TCj+QNFeBWWWvJ9nn1+7sRyn79+0SkXcDLKOJyOMg6no4zDyVwxcCwe6rZFTehWWgM9YsQI6d+/v+Tm5sq4ceNk9+7dpsm4Ov/880241ibias6cObJ27Vrp3bu3+f/uu+82Qf3mm2+u53eCaPdjnkeKbF3/c7Oi98sMAAAAIHZFVegePny46Vs9evRo2bBhgwnTkyZN8g2utnr1ar+zCdqsXOfq/u2336Rx48ZmujCdRqxp06b1+C4Qa1OFqRxGLgcAAADg9NCttCl5Rc3Jp0+f7rc8aNAgWbJkSR1tGZxk3vqy0N2hiUsyGlHTDQAAACD8SBqIOyUeSxZsKAvdzM8NAAAAIFII3Yg7SzZ7ZHdx2XJudkJ9bg4AAAAAByN0I+7MtTUtV9R0AwAAAIgUQjfizjzbIGpZjV3SJs1Vr9sDAAAAwLkI3YgrHsvyG0RNa7l1DkAAAAAAiARCN+LKL1s9sr2wbJn+3AAAAAAiidCNuDJvvcdvmf7cAAAAACKJ0I24HUStRapL9m9K03IAAAAAkUPoRtywAvpz52S76c8NAAAAIKII3Ygbq3dasnG35VvOyWJ+bgAAAACRRehG3GB+bgAAAAB1jdCNuDHXNj9342SRv7ag+AMAAACILFIH4oa9P3f/1gmS4GYQNQAAAACRRehGXFi/y2P6dHsxPzcAAACAukDoRtzVcivm5wYAAABQFwjdiLv+3KmJIge0ougDAAAAiDySB+LCvPUe3/U+mQmSnEB/bgAAAACRR+iG423Za8kv28pCN03LAQAAANQVQjccb35gf+5sij0AAACAukH6gOPNtYXuJLdI74yEet0eAAAAAPGD0A3Hm2cbRK1nhlsaJNGfGwAAAEDdIHTD0XYWWrJkS1l/7pwsarkBAAAA1B1CNxxt4YZS8VhlywyiBgAAAKAuEboRN/253S6Rvq2p6QYAAABQdwjdcLR5ttDdvYVb0lPozw0AAACg7hC64VgFJZb8mGfrz51NLTcAAACAukXohmN9v7FUissyN/25AQAAANQ5Qjcca+56W+IWkf6MXA4AAACgjhG64VhzbfNzd27mkhYN6M8NAAAAoG4RuuFIRaWWLNxYFrqZnxsAAABAfSB0w5EWb/JIQUnZMvNzAwAAAKgPhG44fn5uxcjlAAAAAOoDoRuOD93t0lyS3ZiiDgAAAKDukUTgOKUeS+bbQncu83MDAAAAqCeEbjjO8q0eyS8qW2YQNQAAAAD1hdANR08VpqjpBgAAAFBfCN1wdH/ujIYu2S+d+bkBAAAA1A9CNxzFsiyZt87jV8vtchG6AQAAANQPQjcc5bftlmwpsHzL9OcGAAAAUJ8I3XD0/Ny5WRRxAAAAAPWHRALHDqLWNEXkL80p4gAAAADqD4kEjurPbQ/d2rTcTX9uAAAAAPWI0A3HWJtvyfrdtv7c2Qn1uj0AAAAAQOiGg/tzE7oBAAAA1C9CNxzD3rS8UZJI95YUbwAAAAD1i1QCR9Z092udIIlu5ucGAAAAUL8I3XCETXs88vsO5ucGAAAAEF0I3XCEees9fss6cjkAAAAA1DdCNxzXnzs5QaRXBkUbAAAAQP0jmcBx/bl7Z7glJZH+3AAAAADqH6EbMW97gSXLt5Q1L89lfm4AAAAAUYLQjZi3YEOplA2hRn9uAAAAANGD0A1H9edOcIn0bc0gagAAAACiA6EbjurPfUArtzRKoj83AAAAgOhA6EZM211syaJNtv7cTBUGAAAAIIoQuhHTFm4olVJbh24GUQMAAAAQTQjdiGnzbE3LtVF5f2q6AQAAAEQRQjccM4ha1xZuaZJCf24AAAAA0YPQjZhVWGLJ93n05wYAAAAQvQjdiFk/5HmkqKyim/7cAAAAAKIOoRuO6M+tcrIozgAAAACiCykFjpifu2MTl7RqSHEGAAAAEF1IKYhJJR5LFthCN1OFAQAAAIhGhG7EpMWbPbKnpGw5l6nCAAAAAEQhQjdi0jzbVGGKmm4AAAAA0YjQjZjvz53d2CVt0ijKAAAAAKIPSQUxx2NZMt8WunNoWg4AAAAgShG6EXN+2eqR7YVlyzQtBwAAABCtCN2IOXPXe/yWGUQNAAAAQLQidCPmzLM1LW+R6pL9m7rqdXsAAAAAoCKEbsQUy7Jkrm3k8pxst7hchG4AAAAA0YnQjZiyaqcleXss3zJNywEAAABEM0I3Yoq9llsxiBoAAACAaEboRsz2505LFunanCIMAAAAIHrVKLEce+yx8uabb8revXvDv0VAiDXd/bMSJMFNf24AAAAADgvdv/32m5x77rmSmZkpI0aMkClTppgBroBIWrfLI3/k058bAAAAgMND9/Lly2XOnDly4YUXyuTJk2Xo0KHStm1buemmm+T7778P/1YC2rQ8sD93VgL7BQAAAEBUq3GH2JycHHniiSdk7dq18tlnn8ngwYPl2WeflX79+skBBxwgDz/8sKxZsya8W4u4NtfWn7tBokiPVvTnBgAAABDdap1a3G63qel+7bXXZPXq1XLaaafJkiVL5NZbb5UOHTrIkCFD5NNPPw3P1iKu2QdR65OZIMkJ9OcGAAAAEN3CUlU4c+ZMufzyy6Vz587yzjvv+Gq6H330Udm0aZOccMIJMnr06HC8FOLU5j0eWbHN1p87m6blAAAAAKJfYk0fqLXZr7/+uvz3v/81NdwZGRlmULXzzjtPevfu7Vvv2muvlUsvvVTGjx8v99xzT7i2G3Fm/gaP33JuFk3LAQAAAES/GiUXDdUHHnigjBs3Tg466CD55JNPTN9urdm2B26vI444QrZt2xbSc2s412bpqampMmDAAJk7d26l6+s2dO3aVRo0aCDt2rWT66+/XgoKCmrythAjU4UluUV6Z1LTDQAAAMChNd1NmzaV5557Tk4//XRJT0+vcv0TTzxRVq5cWeV6EyZMkBtuuEGeeeYZE7g1UGt/cR0tXWvSA+lc4dp3/MUXX5SDDz5Yfv75Z7ngggvE5XLJY489VpO3hhjoz90zwy2pifTnBgAAAODQmu5XX31Vzj777AoD9969e02Tc6+GDRvKfvvtV+XzalC+5JJLzFRk3bt3N+FbH6uhOphZs2bJIYccYrZFa8ePPvpoOeuss6qsHUds2VloyZLNZc3LmSoMAAAAgKNDd8eOHeWDDz6o8P6PPvrIrFMdRUVFsmDBAjPauW/j3G6zPHv27KCP0dptfYw3ZP/2229m+rJhw4ZV67UR3RZsKJWyIdQYRA0AAACAw5uXW5Y9ApVXXFxsAnN1bN68WUpLSyUzM9Pvdl1etmxZ0MdoDbc+7tBDDzXbVFJSYkZRv/322yt8ncLCQnPx2rlzp/nf4/GYC6LPnHUlvutul0jvDFfEPyt9fi1TlAk4FWUcTkcZh9NRxuFknhg5Fg91+0IO3RpOt2/f7lvesmWLXxNyL13nrbfekqysLIm06dOnywMPPCBPP/206QO+YsUKM1r6vffeK3feeWfQx4wdO1bGjBlT7nad2owB2KLT7NUNRGTfwGl/aVIqe7dvkr118AXasWOH+bJX9wQSEAso43A6yjicjjIOJ/PEyLF4fn5+eEP3448/7pvySwcqu+6668wlGN059913n1RHy5YtJSEhQTZu3Oh3uy63bt066GM0WOsUZRdffLFZ1hHVd+/ebaYoGzVqVNAP6LbbbjODtdlPJuio561atQppUDjUrb3FlizbXhaxB7ZLkYyMtDr5oms513IRzV90oKYo43A6yjicjjIOJ/PEyLG4zrgV1tCtg5Q1btzYBOqbb77ZDFjWt29fv3V0xzRq1Ej69esn/fv3r9YGJycnm8dNnTpVTjrpJN/O1uWRI0cGfcyePXvKfQga3CtrAp+SkmIugfR5ovkDjVc/bi6RYlurjQHZiXX2OWl5plzAySjjcDrKOJyOMg4nc8XAsXio2xZy6B44cKC5KK1NPuWUU0zNcjhpDfSIESNMYM/NzTVThulr6Wjm6vzzz5c2bdqYJuLq+OOPNyOe9+nTx9e8XGu/9XZv+EZsm7vOv59E/yw+VwAAAAAOH0jtrrvuCv+WiMjw4cNN3+rRo0fLhg0bpHfv3jJp0iTf4Grah9x+NuGOO+4wZ0D0/7Vr15rmBxq477///ohsH+reXNv83H9p5pYWDZifGwAAAEDscFlVDUUuYvpya7j19pP29u2u9IldrgoHM4sm2qe7SZMmpqM+fbqjS1GpJb1f3C0Ffw5efnb3RLlvUGj9JmpLuzbk5eVJRkZGVDdpAWqKMg6no4zD6SjjcDJPjByLh5olQ6rpvvvuu02IvuWWW0zfa112SuhG9Fq0yeML3Co3m6blAAAAAGJLYk3mH4v2+dLgvKblKof+3AAAAABiTPTW1SPuzV1XFrrbp7skqzHFFQAAAEBsIcUgKpV6LJm/oSx0U8sNAAAAwLHNyzt27Gj6aFeHrv/rr7/WdLsQ55Zt8ciuorJl+nMDAAAAcGzoHjRoULVDNxDO/ty59OcGAAAA4NTQ/fLLL0d+S4AK+nNnNnKZPt0AAAAAEGvo042oo1PHz1vv35+blhYAAAAA4ip060TgDz74oAwdOlT69Okjc+fONbdv3bpVHnvsMVmxYkU4txNx5NftlmwtKFumaTkAAAAARzcvD7RmzRrTz/uPP/6Qv/zlL7Js2TLZtWuXua958+by7LPPyqpVq+SJJ54I9/YizpqWq9xsGmQAAAAAiKPQfdNNN0l+fr58//33kpGRYS52J510knzyySfh2kbE8SBqzVJFOjcjdAMAAACITTVKM5MnT5ZrrrlGunfvHrSv7f77729qwYGa9Oe213Rrf243I+cDAAAAiKfQvXfvXmnVqlWF92stOFATa/It2bDb8i33Z6owAAAAAPEWurWGe8aMGRXeP3HiRDO4GlDr/tyEbgAAAADxFrqvu+46eeutt+Shhx6SHTt2mNs8Ho8Zsfy8886T2bNny/XXXx/ubUUcsE8V1ihJpHtL+nMDAAAAiLOB1M4991wzOvkdd9who0aNMrcdc8wxpj+u2+2WBx54wAymBtRmELV+rRMk0V1+zAAAAAAAcHToVhq2tVb7vffeMzXcWtPdqVMnOeWUU8xAakB15e32yO87LL9B1AAAAAAgLkO3at++Pc3IEZGm5So3m9ANAAAAILbRYRZRY+56j+96coJIzwyKJwAAAIA4qOnWftrB5uOuSmmpf80lEOrI5X0y3ZKSQH9uAAAAAHEQukePHl0udH/wwQeyePFiGTp0qHTt2tXctmzZMpk8ebIccMABDKSGatleYMnyrWU13UwVBgAAACBuQvfdd9/tt/zcc89JXl6eLFq0yBe4vZYuXSqDBw+W7Ozs8G4pHG1+QH/uHPpzAwAAAHCAGnWafeSRR2TkyJHlArfq1q2bue/hhx8Ox/YhDqcKS3SL9M1kEDUAAAAAcRq616xZI0lJSRXer/fpOkBNQvcBLd3SMIn+3AAAAADiNHRrn+2nn35a1q5dW+4+Ddt634EHHhiO7UMc2FVkyeJNtv7cNC0HAAAAEM/zdD/++ONmALUuXbrIySefLJ07dza3//LLLzJx4kSxLEtef/31cG8rHOq7jaVSapUt52TRtBwAAABAHIfuQw89VObMmSN33nmnGcV879695vYGDRqYMD5mzBhqulGjqcK0UXl/QjcAAACAeA7d3ibmGrg9Ho9s2rTJ3NaqVSszpzdQ0/7cf23hliYp9OcGAAAAEOeh20tDdmZmZni2BnGnsMSSHzbSnxsAAABAHIfue+65R1wul4waNcqEbF2uiq6vzc+ByvyQ55GissxNf24AAAAAjuKydNSzKmjQ1hCtfbeTk5NDakKu65eWljUbjlY7d+6UJk2ayI4dOyQ9Pb2+NyfuPLWgSB6bW+RbnjOiobRqWP9dFLTbRF5enmRkZNBlAo5EGYfTUcbhdJRxOJknRo7FQ82SiaG+6cqWgXAMotaxiSsqAjcAAAAAhEvICefss8+WWbNm+d22evVqKSoqq6UEqqO41JKFG8pCN/NzAwAAAIjb0P3WW2/J77//7lvesmWLdOzYUWbOnBmpbYPDLdnskT0lZcu5TBUGAAAAwGFq1ZY3hO7gQIXm2aYKU9R0AwAAAHAaOtAiKubnzm7skjZpFEcAAAAAzkLKQb3wWJZfTTe13AAAAACcKKTRy73mz58vqamp5np+fr6ZFkz7dG/fvj3o+qecckp4thKO8/NWj+woLFumPzcAAAAAiffQPW7cOHOxu/vuu2N6nm7Uf9NyRegGAAAAENehe9q0aZHdEsSVeevK5npv0cAlHZu66nV7AAAAAKBeQ/egQYMisgGIPzrqvb2mOzfLbVpGAAAAAIDTMJAa6tzvOyzZtKdsujkGUQMAAADgVIRu1Dn6cwMAAACIF4Ru1Ll568qalqcni3RpTjEEAAAA4EykHdRrTXf/rARJcNOfGwAAAIAzEbpRp9bme2RNvq0/d1YCnwAAAAAAxyJ0o07NC5yfO5vQDQAAAMC5ahy6V69eLZdffrl07dpVmjdvLjNmzDC3b968Wa655hr57rvvwrmdcGDobpAo0qMl530AAAAAOFfI83TbLVmyRP72t7+Jx+ORAQMGyIoVK6SkpMTc17JlS5k5c6bs3r1bXnjhhXBvL2LcXNsgan1bJ0hSAv25AQAAADhXjUL3zTffLE2bNpVvv/1WXC6XZGRk+N1/3HHHyYQJE8K1jXCIzXs88ut2+nMDAAAAiB81aturTcmvuOIKadWqlQndgdq3by9r164Nx/bBQeat9/gt058bAAAAgNPVKHRrs/KGDRtWeP+mTZskJSWlNtsFh/fnTnKL9MqgPzcAAAAAZ6tR6unbt698+umnQe/Tvt1vvfWWHHTQQbXdNjh4fu6eGW5JTaQ/NwAAAABnq1Hovu2222TSpEmmifmiRYvMbRs3bpQpU6bI0UcfLUuXLpVbb7013NuKGLaz0JKlm8ualzM/NwAAAIB4UKOB1I499lh5+eWX5dprr5XnnnvO3HbuueeKZVmSnp4ur776qhx22GHh3lbEsAUbSqVsCDX6cwMAAACIDzUK3eq8886TU045Rb788kv55ZdfTD/vTp06ydChQyUtLS28WwlHNS13u/ZNFwYAAAAATpdY09HLu3XrZkYvP+mkk8rdv3nzZjOXN7Xd8Jpnm5+7e0u3pCXTnxsAAACA89WoT/cRRxxhargrMnXqVLMOoPYWW/LjJvpzAwAAAIg/NQrd2ne7MoWFhZKQQPNh7PPdxlIpsU3RzfzcAAAAAOJFyM3LV69eLb///rtvedmyZaaZeaDt27fLs88+K/vtt1/4thKO6c+t+tOfGwAAAECcCDl0v/TSSzJmzBhxuVzmcv/995tLsFpwreXW4A2oeevKqrm7NHNL8wb05wYAAAAQH0IO3WeccYYccMABJlTr9WuuuUb+9re/+a2jYbxRo0bSu3dvyczMjMT2IsYUlVqycGNZTXdOdo16NAAAAACAs0O3jlauF2+t96BBg6RDhw6R3DY4wE+bPFJoa12em0VffwAAAADxo0ZTho0YMSL8WwJHmmubKkzlELoBAAAAxJEahW5VUFAg7733nixcuFB27NghHo+nXFPzF154IRzbCIcMorZfuktaN6Z5OQAAAID4UaPQvWrVKjMPt45m3rRpUxO6mzdvbkYuLy0tlZYtW0rjxo3Dv7WIKaUeSxbYQndONk3LAQAAAMSXGlU73nTTTSZof/vtt/Lzzz+bwdUmTJggu3btkoceekgaNGggX3zxRfi3FjFl6RaP7CouW6Y/NwAAAIB4U6PQ/dVXX8mVV14pubm54nbvewoN3ikpKSaQH3nkkXLdddeFe1sR4/25c6npBgAAABBnahS69+zZ4xu5PD093fTf1ppvr4EDB8rMmTPDt5WI+f7crRu5pF0a83MDAAAAiC81Ct3t27eXNWvWmOuJiYnSpk0b09Tca8mSJZKamhq+rUTM0ZYP8+z9ubMSzMkZAAAAAIgnNRpIbfDgwfLhhx/KXXfdZZYvuOACGTt2rGzbts2MYv7aa6/J+eefH+5tRQxZsc2SbQVly0wVBgAAACAe1Sh033rrrTJv3jwpLCw0/bhvv/12Wbdunbz77ruSkJAgZ599tjz66KPh31rEZNNylZvNVGEAAAAA4k9iTZuX68VLm5L/5z//MRcgcBC1ZqkinZsRugEAAADEnxoloYsuukjmzJlT4f1z58416yA+BevP7aY/NwAAAIA4VKPQ/fLLL8uvv/5a4f0rV66UV155pTbbhRi2Jt+SDbst3zL9uQEAAADEq4i0+dX+3Q0aNIjEUyMGMD83AAAAAFSzT7eOVq4Xr+eee06mTJlSbr3t27eb23NyckJ9ajh4ELXGSSLdWtCfGwAAAEB8Cjl069zb77zzjrmu8y1rn+4FCxb4raO3N2rUSA477DB57LHHwr+1iLnQ3a91giS6mZ8bAAAAQHwKOXTfdttt5qLcbre88MILZmowwG7jbo+s2mHrz52dwA4CAAAAELdqNGWYx+MJ/5bAEeyjlqvcLEI3AAAAgPhVo9AdaNmyZabp+fr166Vr165y4YUXSnp6ejieGjFm7rqyEzIpCSIHZtCfGwAAAED8CjkRPfXUU9KlSxfZvHmz3+0ff/yx9O7dW+666y555pln5Prrr5e+ffuWW686xo8fLx06dJDU1FQZMGCAmfe7IocffrjpSx54Oe6442r8+ghPf+4+mQmSkkB/bgAAAADxK+TQ/dFHH0mnTp2kZcuWvttKSkrk4osvloSEBHnppZfkp59+kgcffFBWrVol999/f402aMKECXLDDTeYEL9w4ULp1auXDB06VPLy8oKu//7775sadu9l0aJFZntOP/30Gr0+am5bgSU/by2r6c7JopYbAAAAQHxzV2f08oMOOsjvtmnTpsmmTZtM7faIESOkR48ecvPNN8sZZ5whn332WY02SEc9v+SSS0wT9e7du5va84YNG8qLL74YdP3mzZtL69atfZcvv/zSrE/ornvzA/tzM4gaAAAAgDgXcp/uLVu2SLt27fxumzp1qmnKffLJJ/vdfsghh5ga6OoqKioy05B5R0n3jpQ+ZMgQmT17dkjPoaOqn3nmmWbqsmAKCwvNxWvnzp2+weEYIK525qwr8V1PdIv0auWK2X2q221ZVsxuP1AVyjicjjIOp6OMw8k8MXIsHur2hRy6MzMzZcOGDX63ff3116ZWWZuA2yUnJ5tLdWk/8NLSUvNaga+tg7VVRft+a/NyDd4VGTt2rIwZM6bc7VpjX1BQUO1tRplZqxuIyL7Ryrs2KZVd2zbJrhjdQfoF2rFjh/my64kfwGko43A6yjicjjIOJ/PEyLF4fn5+eEN3//795ZVXXpGrr75a0tLSZPHixSbknnjiiZKY6P80GpDbtm0rdU3D9oEHHii5ubkVrqO16Npn3F7TrTX4rVq1YsT1WthVZMnPO/b6lg9pnyIZGWkSy190bcWh5SKav+hATVHG4XSUcTgdZRxO5omRY3Ed+DusoVsHNsvJyZG//OUvpu+2NgPXHWFvCu71wQcfyODBg6u3xSJmkDYdBG3jxo1+t+uy9teuzO7du+Wtt96Se+65p9L1UlJSzCWQfpjR/IFGu+/zSsRjlS3ntkmM+f2p5ZtyASejjMPpKONwOso4nMwVA8fioW5byO9Aa5C/+uor6devn6xbt84MqqaDpemy3fTp02s8kJk2Sdfn077i9rMcujxw4MBKH6vzhGtf7XPPPbfar4vwThWmk4T1b72vmTkAAAAAxLOQa7rVwQcfLJ9++mml6+i82Tp1WE1p028dCV2bs2sz8XHjxplabB3NXJ1//vnSpk0b0zc7sGn5SSedJC1atKjxa6Pm5q4rC91/beGW9BTm5wYAAACAaoXuujB8+HAzqNno0aPNwG29e/eWSZMm+QZXW716dblq/OXLl8vMmTNl8uTJ9bTV8a2gxJIf88pG7mOqMAAAAACI0tCtRo4caS7BaPP1QF27djUj26F+/JDnkSLbaPk5WTQtBwAAAAAVvb3SEZNNy1VOFsUKAAAAABTpCLU2zzaI2v5NXdKqIcUKAAAAAAjdqLXiUksWbigL3bk0LQcAAAAAH6okUStLNntkT0nZMoOoAQAAAEAZQjfCNj+3YhA1AAAAAChD6EbYBlFrk+aSNmkUKQAAAADwIiGhxjyW5TeIGv25AQAAAMAfoRs1tnyrR3YWlS0TugEAAADAH6EbNTYvcH7u7AT2JgAAAADYELpRY3PXe3zXWzZwSccmLvYmAAAAANgQulEjlmX5DaKmU4W5XIRuAAAAALAjdKNGVu6wZPNey7ecm0VRAgAAAIBAJCXUCP25AQAAAKBqhG7UyFzbVGHpySJdm1OUAAAAACAQSQm1Dt05WQnipj83AAAAAJRD6Ea1rc33yNp8W39upgoDAAAAgKAI3ai2ebZabm9NNwAAAACgPEI3qs0+VViDRJEeLSlGAAAAABAMaQm16s/dt3WCJCUwPzcAAAAABEPoRrVs2uOR37bb5+emaTkAAAAAVITQjWqZt97jt8wgagAAAABQMUI3qmW+rWl5slukVwZFCAAAAAAqQmJCjftz98xwS2oi/bkBAAAAoCKEboRsZ6ElSzeXNS+naTkAAAAAVI7QjZDN31AqZUOoMYgaAAAAAFSF0I0azc/tdu2bLgwAAAAAUDFCN0I2z9afu0dLtzROpj83AAAAAFSG0I2Q7Cm25KdN9OcGAAAAgOogdCMk320slRLbFN25WTQtBwAAAICqELpR7f7cqj+hGwAAAACqROhGSOatL6vm7tLcLc1S6c8NAAAAAFUhdKNKhaWWaV7uRdNyAAAAAAgNoRtV+inPI4W21uW52RQbAAAAAAgF6QlVmmubKkzl0J8bAAAAAEJC6EaV5tkGUduviUsyG1FsAAAAACAUpCdUqsRjyYINZaGbWm4AAAAACB2hG5VausUju4rLlhlEDQAAAABCR+hGtebnzs1OYI8BAAAAQIgI3ajUPNsgaq0buaRdGvNzAwAAAECoCN2okMey/EK39ud2uQjdAAAAABAqQjcqtGKbR7YVlC3TtBwAAAAAqofQjQrNW+/xW2YQNQAAAACoHkI3QhpErXmqSOdmNC0HAAAAgOogdCMoK6A/d3/6cwMAAABAtRG6EdQf+ZZs2G35lmlaDgAAAADVR+hGUMzPDQAAAAC1R+hGUHNtTcsbJ4l0a0FRAQAAAIDqIkkhqHm2QdT6ZSVIgptB1AAAAACgugjdKGfDLo+s2kl/bgAAAACoLUI3yrGPWq5ysxPYSwAAAABQA4RuVNqfOyVB5MBWFBMAAAAAqAnSFMqZt87ju943M0GSE+jPDQAAAAA1QeiGn617Lfl5W1nozsmmiAAAAABATZGo4Gf+hoD+3Fn05wYAAACAmiJ0w89c21RhiW6RPpmEbgAAAACoKUI3KhxETQdQa5BEf24AAAAAqClCN3zyiyxZstnWn5um5QAAAABQK4Ru+CzcUCoeq2yZ+bkBAAAAoHYI3Qjan1sblfdvTX9uAAAAAKgNQjeC9ufu1tIt6Sn05wYAAACA2iB0wygoseTHvLL+3EwVBgAAAAC1R+iG8UOeR4rLMjeDqAEAAABAGBC6Ua4/t8rJomgAAAAAQG2RrFCuP3enpi5p2ZCiAQAAAAC1RbKCFJdaZrowL6YKAwAAAIDwIHRDFm/2yN6Ssh2Rk8VUYQAAAAAQDoRulOvPTU03AAAAAIQHoRt+/bnbprkkuzHFAgAAAADCgXQV50o9lsyzhW7m5wYAAACA8CF0x7mft3okv6hsOSeb/twAAAAAEC6E7jhnb1quqOkGAAAAgPAhdMc5+yBqrRq6pEMTV71uDwAAAAA4CaE7jlmWJXPXe/xquV0uQjcAAAAAhAuhO46t3G7Jlr2Wbzkni+IAAAAAAOFEyopjgf25GUQNAAAAAMKL0B3H7KE7PVmka3OKAwAAAACEEykrjtkHUcvJShA3/bkBAAAAIKwI3XFqbb5H1u0q68+dy/zcAAAAABB2hO44Za/lVszPDQAAAADhR+iOU/b+3A0TRbq3pCgAAAAAQLiRtOKUvaa7b+sESUpgfm4AAAAAcHzoHj9+vHTo0EFSU1NlwIABMnfu3ErX3759u1x11VWSlZUlKSkp0qVLF/nss8/qbHtj0aY9Hlm5g/7cAAAAABBpiRJFJkyYIDfccIM888wzJnCPGzdOhg4dKsuXL5eMjIxy6xcVFclRRx1l7nv33XelTZs2smrVKmnatGm9bH+smLfe47dMf24AAAAAiIPQ/dhjj8kll1wiF154oVnW8P3pp5/Kiy++KLfeemu59fX2rVu3yqxZsyQpKcncprXkqNw8W3/uZLdIr4yoa/AAAAAAAI4QNaFba60XLFggt912m+82t9stQ4YMkdmzZwd9zEcffSQDBw40zcs//PBDadWqlZx99tlyyy23SEJCQtDHFBYWmovXzp07zf8ej8dc4sHcdSW+6xq4k9yWeDxlzc2xrzxYlhU3ZQLxhzIOp6OMw+ko43AyT4wci4e6fVETujdv3iylpaWSmZnpd7suL1u2LOhjfvvtN/nqq6/knHPOMf24V6xYIVdeeaUUFxfLXXfdFfQxY8eOlTFjxpS7fdOmTVJQUCBOt7NIZNmWRiKyb+C07k0KJC9v34kH+H+BduzYYb7sevIHcBrKOJyOMg6no4zDyTwxciyen58fW6G7ph+G9ud+7rnnTM12v379ZO3atfLII49UGLq1Jl37jdtrutu1a2dqydPT08XpFq0qFUvKavoP75QmGRnBWwXEMy1bLpfLlIto/qIDNUUZh9NRxuF0lHE4mSdGjsV18O+YCt0tW7Y0wXnjxo1+t+ty69atgz5GRyzXvtz2puTdunWTDRs2mObqycnJ5R6jI5zrJZB+mNH8gYbL/A3Fvus6S1i/rERxu5kuLBj9osdLuUB8oozD6SjjcDrKOJzMFQPH4qFuW9S8Aw3IWlM9depUvzMcuqz9toM55JBDTJNye1v6n3/+2YTxYIEb/vNz92jllsbJBG4AAAAAiJSoCd1Km30///zz8sorr8jSpUvliiuukN27d/tGMz///PP9BlrT+3X08muvvdaEbR3p/IEHHjADq6G83cWWLNpcdoKCqcIAAAAAILKipnm5Gj58uBnQbPTo0aaJeO/evWXSpEm+wdVWr17tV4WvfbG/+OILuf7666Vnz55mnm4N4Dp6Ocr7bmOplNgG2CN0AwAAAEAchW41cuRIcwlm+vTp5W7TpufffvttHWxZ7Jtna1qu+mcxgBoAAAAAxE3zckTW3PVlobtLc7c0TaU/NwAAAABEEqE7ThSWWvLdRvpzAwAAAEBdInTHiR/zPFJka12em81HDwAAAACRRvKKw6nCVA79uQEAAAAg4gjdcWKerT/3fk1cktmIjx4AAAAAIo3kFQdKPJYs2FAWupkqDAAAAADqBqE7DizZ7JHdxWXLhG4AAAAAqBuE7jibKkzlZjM/NwAAAADUBUJ3HJhnG0Qtq5FL2qYxPzcAAAAA1AVCt8N5LEvm2/pz52QniMtF6AYAAACAukDodrgV2zyyraBsmf7cAAAAAFB3CN0ON3edx2+Z/twAAAAAUHcI3XE0iFrzVJFOTWlaDgAAAAB1hdDtYJZlyTxb6M7Joj83AAAAANQlQreDrd5pycbdlm+ZpuUAAAAAULcI3fE0P3cW83MDAAAAQF0idDvYXNv83I2TRf7ago8bAAAAAOoSKczB7P25+7dOkAQ3g6gBAAAAQF0idDvU+l0e06fbi/7cAAAAAFD3CN1xUMvtHbkcAAAAAFC3CN1x0J87JUHkwFZ81AAAAABQ10hiDjVvvcd3vW9mgiQn0J8bAAAAAOoaoduBtuy15JdtZaE7J5uPGQAAAADqA2nMgeYzPzcAAAAARAVCtwPNtYXuRLdIn0wGUQMAAACA+kDodqB5tkHUerZyS4Mk+nMDAAAAQH0gdDvMzkJLlmyx9+emlhsAAAAA6guh22EWbigVj1W2nMv83AAAAABQbwjdDu7PrY3K+7WmphsAAAAA6guh22Hm2UJ395ZuSU+hPzcAAAAA1BdCt4MUlFjyY56tPzdNywEAAACgXhG6HeT7jaVSXJa5JZdB1AAAAACgXhG6HWTuelvipqYbAAAAAOododtB5trm5+7czCUtGtCfGwAAAADqE6HbIYpKLVm4sSx0058bAAAAAOofodshFm/ySEFJ2TLzcwMAAABA/SN0O3B+bpXDIGoAAAAAUO8I3Q4M3e3SXJLdmI8WAAAAAOobycwBSj2WzLeFbvpzAwAAAEB0IHQ7wPKtHskvKlumaTkAAAAARAdCt8OmClMMogYAAAAA0YHQ7bD+3K0auqRDE+bnBgAAAIBoQOiOcZZlybx1Hr9abpeL0A0AAAAA0YDQHeN+227JlgLLt5yTzUcKAAAAANGChOaw+bnpzw0AAAAA0YPQ7aBB1JqkiHRpzkcKAAAAANGChBbj/bntoVvn53bTnxsAAAAAogahO4atzbdk/e6y/tw0LQcAAACA6ELodlB/7pzshHrbFgAAAABAeYTuGDbPFrobJor0aMnHCQAAAADRhJQWw+z9uftlJUiim/m5AQAAACCaELpj1KY9Hlm5g/7cAAAAABDNCN0xat56j9+yjlwOAAAAAIguhO46VFxcLCNHjpRmzZpJ8+bN5eqrr5aSkpKg615wwQWSnJwsjRs39l1mz57tu/+pJ5+StQ8eJiuvaSGbnj1TemX4f5Q7d+6Us88+W9LT0yUzM1PuvffeiL8/AAAAAIA/Qncduu+++2TmzJmyZMkSWbx4sXz99dfywAMPVLj+lVdeKbt27fJdBg4c6LtvQ0KmND3mJkk75AJpkuKSlET//twa6Ldu3SqrV682r/P888/Lq6++GtH3BwAAAADwR+iuQy+++KLccccdkpWVZS6jRo2SF154odrPs73Akh2dj5dGvY+XhEYtpGmqf+Des2ePvPXWWybkN23aVLp06WJCeE1eCwAAAABQc4TuOrJt2zZZs2aN9O7d23ebXtea6B07dgR9jNZMazP0Hj16yKOPPioez75+3As2lErZEGoizQJC9/Lly6WoqKjca/34449hf18AAAAAgIoRuuuINg9XWvPs5b2en59fbv1rrrnGhOdNmzaZGuonnnjCXAKnCnO5RJqmuMq9VqNGjSQxMdHvtYK9DgAAAAAgcgjddUQHQlP2Wm3v9bS0tHLr9+3bV1q1aiUJCQly0EEHya233ioTJkww981dXxa6Mxq6JMFd/rW0ibl9kDZ9rWCvAwAAAACIHEJ3HdERy9u2bSvff/+97za93q5dO2nSpEmVj3e7931Uu4stWbSpbLqwNmn+tdyqa9eukpSUJD/88IPfax144IFheCcAAAAAgFARuuvQhRdeKPfff79s2LDBXHTk8osvvjjoum+//baZ9suyLJk/f748+OCDcuqpp8rCDaVSaolYpSXiKS6Q1g08pq93QUGB6cetGjZsKMOHD5c777zT1HD/8ssv8uSTT1b4WgAAAACAyCjr9IuI0xC8ZcsW6datm1k+99xz5fbbbzfXL7/8cvP/M888Y/5/6qmn5NJLLzVNxNu0aWOmD/vHP/4h4+YXm/u3f/6wbP9srKz687kbNGgggwYNkunTp/sef9lll5nadb1P5wc///zz+ZQBAAAAoA65LK1KjWNam6zNu7VGOD09XaLdmRP3yNz1+5qXd23uls+HN6zvTXIkbT2Ql5cnGRkZvqb9gJNQxuF0lHE4XbyV8dLSUiku3lf5hPgo31u2bJEWLVrUW/nW7ro6vlY4siQ13TGksMSS7/PK+nPnZldeCAAAAIBYpvWD2i1z+/bt9b0pqOPP3ePxmNmXXDpdUz3RGaBat25d620gdMeQH/I8UlQ2cLnkZjn/rCYAAADilzdwa42+jltUnwEMdRu6S0pKzBTI9fGZ6+vrbFDamkRlZWXV6vkI3TFknm2qMJWTRU03AAAAnNuk3Bu4tZkx4odVz6Fb6bhYytuNo6qm5pWhqjSG2Ofn7tDEJRmN+PgAAADgTN4+3FrDDdQHb9mr7XgCpLYYUeKxZIEtdOdSyw0AAIA4QJNyxHrZI3THiMWbPbKnpGyZQdQAAAAAIPoRumO0Pzc13QAAAEBsuPvuu02t6WGHHVbuvuuuu046dOhQ7efUx4wcOVJi1eGHHy7/93//V+V6vXv3lgsuuKBet6G2GEgtBqYJ++zXEvnP90W+25qkiLTc168fAAAAQDWOqyevLJHthZY0TXHJ0R0TZVinRElJrJvBur7++muZPn26CXu19cEHH0izZs3Csl2ILEJ3FJuyskRunFYgOwv9b99RKHLQa3vk0cGpcmQHPkIAAAAg1ONqberr+bPJ7xcrS2XMN4V1clzdqFEj6dGjh9x7771hCd19+vQJy3Yh8mheHsU/DJdNKpD8gMDtpbdf+nmBWQ8AAABAaMfVGrjt/9flcfWdd94pX331lcyaNavS9VatWiWnnXaaNGnSxIT1oUOHyk8//VRp8/LFixfLsGHDzPRqOup2165d5eGHHzb3ffzxx6Z5+y+//OL3HNu2bTNTYz399NMVNotv3rx5udG7Fy1aZJ7viy++MMvffPONaTqv25uWliYHHnigvPLKK9XcO2L2S79+/cw2abPyzz//POh6s2fPlsGDB5t9o6959tln++bU9rr11lvNdjRu3FjatGkjZ511lqxfv17qA6E7Spu+6Jk4ZVWwjvd2XU/XBwAAABDdx9Xaf1hrqMeMGVPhOvn5+aYm/LvvvpNnnnlGXn/9ddmyZYsJtX/88UeFjzv++ONNiH7hhRfk008/lRtvvFF2795t7tMwrsHzxRdf9HvMm2++af7X0BqMBlV9Tm+49vrvf/9r5q4eMmSI7Ny5U4477jhJT083t0+cOFEuvfRSM8d6dWzYsMGcXEhJSZEJEybIDTfcIFdeeaWsXbu2XODW/aNhW9d77rnnZN68eXLiiSf6rach/Pbbbzf74oknnpDff/9dBg0aZOb/rmu0TY5C2tcksEl5MPqToOt9/luJnNQlqS42DQAAAKg3OwstWb7VW0ddtRmrq3dcPX5hkfytXWgRqWtzt6SnVL8v+B133CGnnnqqzJ07V3Jzc8vd/9JLL5mabq257tatm7lNw2L79u1l3Lhx8uijj5Z7zObNm2XlypUmXGr4VkcccYTv/oSEBLnwwgtN6L7vvvvMstLlU045RZo2bRr8PXbtak4SaJi2Dzj21ltvyemnn26e5+eff5YdO3bI2LFjTc2yOvLII6u9X8aNG2dqz7V2WwO8hmOtzddgH1iD3b9/f3n//fd9U3rp6x5wwAHy2WefmRMM3vfmVVpaKgMHDpS2bdualgZHH3201CVCdxTSwR28fU2qYvqiELoBAAAQBzRwD5+4N2LP/9SCYnMJxYSTGkhO1r7wWh0nn3yyCYj33HOPfPLJJ0EHW9P7vYFbaRPvo446SmbOnBn0ObVJ+X777Se33XabbN261YReDZh2f//73+X++++XSZMmmZrpH3/8URYuXCiPPPJIpdurtd26rXv37jXNvvVkwW+//WZuV506dTIh+YorrpBrrrnGhP1WrVpVe7/MmTPHPFZrsC1rX4sDbUKu791rz549pin7P//5TxOkvbp06SLt2rUzNd7e0K3hXfvP68kLrY330pMEdR26aV4ehXQ0xVDP33n+XB8AAABA9NPa2VGjRplmzxp6A2lz7szMzHK3620aqCt6zsmTJ5ugftVVV5kAqrXBM2bM8K2jtcYa3LX5ubcmuGPHjn414sGceeaZppm69gtXWuutAf/ggw82yzqC+pdffmn6cp933nnSunVr0/w7sA96VbS/tTZZD2S/TfeNhu3rr79ekpKS/C6rV6/2Nb/X8H3CCSdIdna2vPbaa6ZJ+rfffmvuKyjY192gLhG6o5BOXxDqB+P+c30AAAAAseGMM84wTbe1JjaQ1uwGDgqmNm7c6FfrG0hre9955x0TTHVaMu0brU3Nd+3a5VvnkksuMbXr2k/6jTfeME3OvU20K6IB/pBDDjFNyj0ej7z99tsmiNsfp83ktWZZ+3FrONftP+mkk6qxR0SysrKCvm/7bdoM3nvSQoN14EWb7nunU9Mac91WDd8HHXSQORlQX2heHoV0vkCdviDUmu6h+/MxAgAAwPm0H7U2665On+7xC0NrLq5G9kuqVp/umnK73SY4jhgxotz0YYceeqi8++67snz5chPMlQbpKVOmmAHKqqK1vtoHXPs+a+Bct26dCeRKBxvTmmkdOE1rzS+44IKQtlebkuvAZhrY9fm8TcsDafNzbd7966+/yrXXXmtqlVNTU0N6DQ3u//73v03/cG2urrT/tb12X0cr177ZS5cuNX3TK6JN4XU/2E8M6EmG+kJai0LDOiWa+QJ1+oLKGo5rEUpLETmW0A0AAIA4oAOXVacfdc9WbnltcXHIx9VX9U2WlMS6aUWqwVdHMZ82bZppru2ltc+PP/646XetwVJDq/bFTkxMlOuuuy7oc2n/7H/84x8yfPhw08faO7CZNinXZS8Nohr0tR+3jhSutdih0EHTNERrv+3u3btLr169fPdpM3ltsq591XWwNx2F/MknnzS146EGbqXvbfz48XLsscfKLbfcYgaH05YA2l/dTrdd+3rre9Uadz2JsGbNGtPEXfednsTQZvQ6MNvVV19ttkubl2sz8/pC8/IopF/0RwfvK6AVfeW9t+t6dfXDAAAAAMSSaD6u1pG/deCzQNo3WpuHa7DVmu1zzjnHBEvtn11RSNam03rRoK2h9bLLLjPraj9v70jlXhpC1UUXXRTyturAaDo4W7Ba7s6dO/tq7jXIa424Bm5t6l7d5uWff/65qaXW5vc6WNpTTz1VbkA47UuuA8pps3kN2VqzrgO96dzkui1Kb3vooYfkww8/NLX9uu+CDVpXV1yWd2i4KKJnOPQMhp4l0cKmZ0qCDaevXn75ZbOz7bT/Qqgd5HUkO23vb2/GEC2mrCwx8wXq9AXe0cy9/6en7PthOLIDjRUiQfuraP8RHbhBf0QAp6GMw+ko43C6eCjjejyv02DpYF/VqTENhuPqMqNHj5ann37a9OvW3BSNLMsyU4Zp7X5Vfc7rswyGmiWjLrF5J0LXieAHDBhgmgXoGRPt0xBsNDulb1Dv96rPDyachnRMlDntGpl5uHVaMB2lXAdN0z7c2qScGm4AAACA4+pQaF7Si1Zo6gjn0Rq4nSjqQvdjjz1mRtXz1l5r+NZ+AjqkvQ4GEIyG7PocjS6SNFif1CXJXAAAAABwXF0T2uRcp8065phjgjZrR5yE7qKiIlmwYIFfIdDmMkOGDDGd3yui7fl18AFtZtO3b1954IEHpEePHkHXLSwsNBcv70Tp+li9AN7yoM1aKBNwKso4nI4yDqeLhzLufY/eC2pHB2yzi/Z9av25ffW5nd6yV1FWDPX7F1WhW0eo08nOAyeD1+Vly5YFfYwOo6+14D179jRt6bXDvXauX7x4cblO90oHF9BRAgNt2rSpXiZKR3TSL5CWJ/2SObWfFOIbZRxORxmH08VDGS8uLjbvU/v26gXxw7Iskwvru+uwljstg1u2bDEjvwfKz8+PvdBdEzpPm168NHB369ZNnn322aCTzWstuvYZt9d068h+OiJftA2khvqjXy79gmu5cOofMsQ3yjicjjIOp4uHMq4VYhpqdDAtvSD+JAUJunVJy51+v3TasmADqYU6wF9Uld6WLVuaIe03btzod7suh9pnWz+YPn36yIoVK4LerwMGBBs0QHemU3+wUDP6h4xyASejjMPpKONwOqeXcX1f3lpOpwyUjNBruqPls6/sexbqdy+qvqHJycnSr18/mTp1qt9ZPF2212ZXRpsh/PTTT2aeNwAAAACxXcu5Z8+e+t4UxKk9f5a92ta4R1VNt9Km3yNGjJD+/fububl1yrDdu3f7RjM///zzpU2bNqZvttKJ0A866CAzEfr27dvN/N6rVq2Siy++uJ7fCQAAAICa0hawTZs2NfORq4YNG9Z7rSfiY55uy7JM4Nayp2VQy6KjQvfw4cPNoGY6afuGDRukd+/eMmnSJN/gaqtXr/arxt+2bZuZYkzXbdasmakpnzVrlnTv3r0e3wUAAACA2vJ2MfUGb8QH688Rw+1dDOqDBu5wTE3tsqJ9rPgI04HUmjRpYkZ/ZCA1eOmXXH/cMzIyHNtPCvGNMg6no4zD6eKtjGsXUh3NHPHB8+eI4TqAWX2Vb21SXlUNd6hZMupqugEAAADATsNPbZv4IrZCd1JSkhkd3AknlWL/HQAAAAAAEKUI3QAAAAAARAihGwAAAACACCF0AwAAAAAQIXE/kJp38HYdeQ6wD96Qn5/vmMEbgECUcTgdZRxORxmHk3li5FjcmyGrmhAs7kO3fpiqXbt2dfLBAAAAAACclSl16rCKxP083XoWZd26dZKWllavE68j+s5a6YmYP/74g/nb4UiUcTgdZRxORxmHk8VK+dYabg3c2dnZldbIx31Nt+6ctm3b1umHg9ihX/Jo/qIDtUUZh9NRxuF0lHE4WXoMHItXVsPtFb0N5AEAAAAAiHGEbgAAAAAAIoTQDQSRkpIid911l/kfcCLKOJyOMg6no4zDyVIcdiwe9wOpAQAAAAAQKdR0AwAAAAAQIYRuAAAAAAAihNANAAAAAECEELoBAAAAAIgQQjdQAyeffLI0a9ZMTjvtNPYfHGX79u3Sv39/6d27txxwwAHy/PPP1/cmAWHXoUMH6dmzpynnRxxxBHsYjrJ8+XJTtr2XBg0ayMSJE+t7s4Cw+uc//yk9evQwxyqvv/66RDtGLwdqYPr06ZKfny+vvPKKvPvuu+xDOEZpaakUFhZKw4YNZffu3eaP2fz586VFixb1vWlAWEP3okWLpHHjxuxVONquXbtMeV+1apU0atSovjcHCIuffvpJRowYIbNmzRLLsszJ00mTJknTpk0lWlHTDdTA4YcfLmlpaew7OE5CQoIJ3ErDt/4x0wsAIPZ89NFHcuSRRxK44ShLly6VgQMHSmpqqmnJ0atXLxO6oxmhG3FnxowZcvzxx0t2dra4XK6gTa7Gjx9vzgzrl3nAgAEyd+7cetlWoD7KtzYx1z9gbdu2lZtuuklatmzJBwFHlXF93KBBgyQnJ0feeOONOtx6oG6PU95++20ZPnw4ux2OKuMHHHCAaXWqxyvbtm0z19euXSvRjNCNuKNNZjVQ6Jc5mAkTJsgNN9wgd911lyxcuNCsO3ToUMnLy6vzbQXqo3xr86wffvhBVq5cKW+++aZs3LiRDwKOKuMzZ86UBQsWmFrABx54QH788cc6fAdA3Ryn7Ny50zS/HTZsGLscjirj3bt3l2uuuUYGDx4sp5xyihx00EGmpV5Us4A4pl+BDz74wO+23Nxc66qrrvItl5aWWtnZ2dbYsWP91ps2bZp16qmn1tm2AnVZvr2uuOIK65133mHnw7Fl/MYbb7ReeumliG8rUNdl/NVXX7XOOeccdjwc/zv+97//3frkk0+saEZNN2BTVFRkaj+GDBniu83tdpvl2bNns6/g+PKttdo6SKDasWOHaQLWtWvXettmINxlXGtYvGVcB5n66quvzAi4gNOOU2haDieX8bw/a711tH5teq414dEssb43AIgmmzdvNqM3Z2Zm+t2uy8uWLfMt6xdfm9/qwZv2e33nnXfMgA5ArJdvHeH20ksv9Q2gdvXVV8uBBx5YT1sMhL+M64klnfZR6bqXXHKJ6dsNOOk4RU+aahB577336mErgciX8RNPPNGUcx2V/6WXXpLExOiOtdG9dUCUmjJlSn1vAhARubm58v3337N34Vj777+/OWkKOFmTJk0YjwOONjvGWqDSvByw0VGadSCGwIGjdLl169bsK8Q0yjecjjIOp6OMw+laOvRYnNAN2CQnJ0u/fv1k6tSpvts8Ho9Zpvk4Yh3lG05HGYfTUcbhdMkOPRaneTnijg6cs2LFCt+yToukzWmbN28u7du3N1MUjBgxQvr372+a2o4bN8703b7wwgvrdbuBUFC+4XSUcTgdZRxOtysej8Xre/h0oK7pVF9a9AMvI0aM8K3z5JNPWu3bt7eSk5PNtAXffvstHxRiAuUbTkcZh9NRxuF00+LwWNyl/9R38AcAAAAAwIno0w0AAAAAQIQQugEAAAAAiBBCNwAAAAAAEULoBgAAAAAgQgjdAAAAAABECKEbAAAAAIAIIXQDAAAAABAhhG4AAAAAACKE0A0AAAAAQIQQugEAQL34448/JDU1Vb755puIPP8zzzwj7du3l8LCwog8PwAAoSB0AwAQZi6XK6TL9OnTzfr//ve/5fTTTzcBUW+/4IIL6vwzOfzww0Pa5rvvvlv27Nkj48ePl6OPPlqysrIkLS1N+vTpY95HaWlpyK95zz33yIABA+SQQw6JyHvS/VhUVCTPPvtsRJ4fAIBQuCzLskJaEwAAhOT111/3W3711Vflyy+/lNdee83v9qOOOkoyMzOlQ4cOkp+fL7m5uTJlyhQ555xz5OWXX67Tva3bt3HjRt/yvHnz5F//+pfcfvvt0q1bN9/tPXv2FLfbbf4/8sgjTfBOT0+XL774Qj744AM5//zz5ZVXXqny9TZt2iRt2rQx65511lkRe1+33HKLTJgwQVauXGlOGgAAUNcI3QAARNjIkSNNzXBF57lXrVrlq+Vu3LixnHbaaXUeugO9++67pvZ92rRpphbcbvPmzSag9+jRw+/2iy66SF566SX55ZdfpHPnzpU+/+OPPy6jRo2SvLw8854jZcGCBdK/f3+ZOnWqDB48OGKvAwBARWheDgBAPdtvv/1iqha2ZcuW5QK3Ovnkk83/S5curfI5Jk6caJqWBwZurfUP1rxeg39g+H/yySfNdjRs2FCaNWtmwvWbb77pt06/fv2kefPm8uGHH4b8/gAACKfEsD4bAACoUx6PR7Zu3RrSuk2aNJGkpKSIbcuGDRt8obwyxcXFpvn6FVdcUePXev755+Waa64xrQKuvfZaKSgokB9//FHmzJkjZ599tt+6ffv2jdhgbQAAVIXQDQBADFu9erV07NgxpHWDNRUPFx2wbNy4cWZbcnJyqtzmvXv3hrzdwXz66aemlvudd96pct3999+/XH96AADqCqEbAIAY1rp1azMIWih69eoV0X7rS5YsMWE4MbHyw4stW7aY/7VJeE01bdpU1qxZY2rMqwr5+joa8nXUdW2KDgBAXSJ0AwAQw3Se6yFDhtTrNjzyyCOmufe9994rw4YNC/lxtZlARUcl15HedcR3HbRNR1HXZuXBph/zvk4s9ZsHADgHoRsAgBim82Lr9Fuh0AHFkpOTw/r6Osq6BuDLL79c7rjjjpAe06JFC/P/tm3bQn4dDc720KzTmC1fvlw++eQTmTRpkrz33nvy9NNPy+jRo2XMmDF+j9XX0RruBg0ahPx6AACEC6EbAIAY9scff9Rbn24dEfziiy+WU045xUyJFiqdHk0DsM6dHYzOWR5IpyjTpvR2jRo1kuHDh5uL9inX7bj//vvltttuMy0AvPR17HONAwBQlwjdAADEsPrq0z1jxgw588wz5bDDDpM33nhD3O7QZyHVEdR1eq/58+cHvX/27NlmNHJvcF68eLGZ+zszM9OvX7i3xlxpDX737t3l888/N6Oj20P3woUL5ZxzzqnhOwUAoHYI3QAA1LOPP/5YfvjhB3NdA6NOfXXfffeZ5RNOOEF69uwZVX26V61aZbZLm3vrlF2BI4jr9la2zerEE0+UUaNGyc6dOyU9Pd3vvu3bt8vgwYNNUNb7dT7utLQ0WbRokTz77LNy2WWXmT7cesJB+3BrGNe5wZ966ik57rjjzLpeCxYsMFOq6esBAFAfCN0AANQz7Y/8yiuv+Ja/++47c1Ft27atMsDWNW2uvWPHDnP9qquuKnf/XXfdVeU2n3feeXLrrbfKRx99JOeee67ffdpMXIOzNhPXWvErr7zSDJimIfz99983oVsvWsP+2GOPya5du8x+0nm7A/uV6wkBbc6uIR4AgPrgsmozdCgAAEAN/f3vf5eff/5Zvv76a99tHTp0MP3OdYC22iosLDTPp+H+2muv5XMCANSL0DtgAQAAhJHWiOs82998801E9utLL71kasp1ZHUAAOoLNd0AACBqhLOmGwCAaEBNNwAAAAAAEUJNNwAAAAAAEUJNNwAAAAAAEULoBgAAAAAgQgjdAAAAAABECKEbAAAAAIAIIXQDAAAAABAhhG4AAAAAACKE0A0AAAAAQIQQugEAAAAAiBBCNwAAAAAAEhn/Dx2kJNSM2ZnzAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -972,33 +964,37 @@ "============================================================\n", "FIDELITY SUMMARY (Deep VQC: Ideal T1=∞ vs Noisy T1=T2)\n", "============================================================\n", - "T1=1.00e+00μs, T2=1.00e+00μs → F=0.5104 (degradation: 49.0%)\n", - "T1=1.00e+01μs, T2=1.00e+01μs → F=0.9260 (degradation: 7.4%)\n", - "T1=1.00e+02μs, T2=1.00e+02μs → F=0.9922 (degradation: 0.8%)\n", - "T1=5.00e+02μs, T2=5.00e+02μs → F=0.9984 (degradation: 0.2%)\n", - "T1=1.00e+03μs, T2=1.00e+03μs → F=0.9992 (degradation: 0.1%)\n", - "T1=1.00e+06μs, T2=1.00e+06μs → F=1.0000 (degradation: 0.0%)\n", - "T1=1.00e+09μs, T2=1.00e+09μs → F=1.0000 (degradation: -0.0%)\n", + "T1=1.00e+00μs, T2=1.00e+00μs → F=0.8439 (degradation: 15.6%)\n", + "T1=2.33e+00μs, T2=2.33e+00μs → F=0.9176 (degradation: 8.2%)\n", + "T1=5.43e+00μs, T2=5.43e+00μs → F=0.9613 (degradation: 3.9%)\n", + "T1=1.26e+01μs, T2=1.26e+01μs → F=0.9828 (degradation: 1.7%)\n", + "T1=2.95e+01μs, T2=2.95e+01μs → F=0.9925 (degradation: 0.8%)\n", + "T1=6.87e+01μs, T2=6.87e+01μs → F=0.9968 (degradation: 0.3%)\n", + "T1=1.60e+02μs, T2=1.60e+02μs → F=0.9986 (degradation: 0.1%)\n", + "T1=3.73e+02μs, T2=3.73e+02μs → F=0.9994 (degradation: 0.1%)\n", + "T1=8.69e+02μs, T2=8.69e+02μs → F=0.9997 (degradation: 0.0%)\n", + "T1=2.02e+03μs, T2=2.02e+03μs → F=0.9999 (degradation: 0.0%)\n", + "T1=4.71e+03μs, T2=4.71e+03μs → F=1.0000 (degradation: 0.0%)\n", + "T1=1.10e+04μs, T2=1.10e+04μs → F=1.0000 (degradation: 0.0%)\n", + "T1=2.56e+04μs, T2=2.56e+04μs → F=1.0000 (degradation: 0.0%)\n", + "T1=5.96e+04μs, T2=5.96e+04μs → F=1.0000 (degradation: 0.0%)\n", + "T1=1.39e+05μs, T2=1.39e+05μs → F=1.0000 (degradation: 0.0%)\n", + "T1=3.24e+05μs, T2=3.24e+05μs → F=1.0000 (degradation: 0.0%)\n", + "T1=7.54e+05μs, T2=7.54e+05μs → F=1.0000 (degradation: 0.0%)\n", "============================================================\n" ] } ], "source": [ "# Sweep over different noise levels (Deep VQC)\n", - "T1_values = [1, 10, 100, 500, 1000, 1e6, 1e9] # μs\n", + "from numpy import linspace\n", + "T1_values = [10**i for i in linspace(0, 6, 50)] # 25 points, log-spaced\n", "T2_values = T1_values # T2 = T1 for simplicity\n", "fidelities = []\n", "\n", "init_state = zero_state(n_qubits)\n", "\n", "# # Reference: ideal state (noise OFF, T1,T2 = \\inf)\n", - "# ideal_density = run_noisy_circuit_density(\n", - "# initial_state=init_state,\n", - "# circuit=deep_vqc,\n", - "# num_qubits=n_qubits,\n", - "# T1=10e90,\n", - "# T2=10e90,\n", - "# )\n", "clean_circuit = [op for op in deep_vqc if op[0] != \"T1T2_NOISE\"]\n", "ideal_density = run_noisy_circuit_density(\n", " initial_state=init_state,\n", @@ -1007,6 +1003,7 @@ " T1=0,\n", " T2=0,\n", ")\n", + "\n", "for T1, T2 in zip(T1_values, T2_values):\n", " noisy_density = run_noisy_circuit_density(\n", " initial_state=init_state,\n", @@ -1018,7 +1015,6 @@ " fidelity = torch.real(torch.trace(ideal_density @ noisy_density)).item()\n", " fidelities.append(fidelity)\n", "\n", - "print(f\"check fidel: {torch.real(torch.trace(ideal_density @ ideal_density)).item()}\")\n", "\n", "# Plot fidelity vs T1\n", "fig, ax = plt.subplots(figsize=(10, 6))\n", @@ -1048,271 +1044,19 @@ "print(\"\\n\" + \"=\"*60)\n", "print(\"FIDELITY SUMMARY (Deep VQC: Ideal T1=∞ vs Noisy T1=T2)\")\n", "print(\"=\"*60)\n", - "for (t1, t2), f in zip(zip(T1_values, T2_values), fidelities):\n", + "stride = max(1, len(T1_values)//15)\n", + "for (t1, t2), f in zip(zip(T1_values[::stride], T2_values[::stride]), fidelities[::stride]):\n", + "\n", + "# for (t1, t2), f in zip(zip(T1_values, T2_values), fidelities):\n", " deg_pct = (1 - f) * 100\n", " print(f\"T1={t1:>8.2e}μs, T2={t2:>8.2e}μs → F={f:.4f} (degradation: {deg_pct:5.1f}%)\")\n", "print(\"=\"*60)" ] }, - { - "cell_type": "code", - "execution_count": 17, - "id": "dc50f732-9664-4260-88d6-de4bfb1a8ac6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "check fidel: 1.0000005960464478\n" - ] - } - ], - "source": [ - "depth = 3\n", - "x_input = torch.tensor([0.5, -0.3])\n", - "theta = torch.randn(depth * 3)\n", - "\n", - "deep_vqc_clean = []\n", - "deep_vqc_clean += param_gate_layer(\"RY\", x_input)\n", - "\n", - "idx = 0\n", - "for layer in range(depth):\n", - " deep_vqc_clean.append((\"RY\", [0], theta[idx].item()))\n", - " deep_vqc_clean.append((\"RY\", [1], theta[idx+1].item()))\n", - " deep_vqc_clean.append((\"CNOT\", [0, 1]))\n", - " deep_vqc_clean.append((\"RZ\", [0], theta[idx+2].item()))\n", - " idx += 3\n", - "\n", - "# NOW use this for ideal\n", - "ideal_density = run_noisy_circuit_density(\n", - " initial_state=zero_state(n_qubits),\n", - " circuit=deep_vqc_clean,\n", - " num_qubits=n_qubits,\n", - " T1=0,\n", - " T2=0,\n", - ")\n", - "\n", - "print(f\"check fidel: {torch.real(torch.trace(ideal_density @ ideal_density)).item()}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "de989167-3a6b-4787-8188-9b3f6e596d6a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Purity of H|00⟩: 0.9999998807907104\n" - ] - } - ], - "source": [ - "trivial_circuit = [(\"H\", [0])] # Just one Hadamard\n", - "\n", - "test_density = run_noisy_circuit_density(\n", - " initial_state=zero_state(2),\n", - " circuit=trivial_circuit,\n", - " num_qubits=2,\n", - " T1=0,\n", - " T2=0,\n", - ")\n", - "\n", - "purity = torch.real(torch.trace(test_density @ test_density)).item()\n", - "print(f\"Purity of H|00⟩: {purity}\") # Should be ~1.0" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "db01a416-84e0-4108-8d78-859f4959fbba", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "First 10 ops in deep_vqc_clean:\n", - " 0: ('RY', [0], tensor(0.5000))\n", - " 1: ('RY', [1], tensor(-0.3000))\n", - " 2: ('RY', [0], 1.0908966064453125)\n", - " 3: ('RY', [1], 0.7662184238433838)\n", - " 4: ('CNOT', [0, 1])\n", - " 5: ('RZ', [0], -0.38620418310165405)\n", - " 6: ('RY', [0], -1.9084150791168213)\n", - " 7: ('RY', [1], 2.223785638809204)\n", - " 8: ('CNOT', [0, 1])\n", - " 9: ('RZ', [0], -1.0458203554153442)\n", - "\n", - "Total ops: 14\n" - ] - } - ], - "source": [ - "print(\"First 10 ops in deep_vqc_clean:\")\n", - "for i, op in enumerate(deep_vqc_clean[:10]):\n", - " print(f\" {i}: {op}\")\n", - " # Check for NaN/Inf in parameters\n", - " if len(op) > 2 and op[2] is not None:\n", - " param = op[2]\n", - " if isinstance(param, torch.Tensor):\n", - " if torch.isnan(param).any() or torch.isinf(param).any():\n", - " print(f\" ⚠ BAD PARAM: {param}\")\n", - " elif isinstance(param, float):\n", - " if math.isnan(param) or math.isinf(param):\n", - " print(f\" ⚠ BAD PARAM: {param}\")\n", - "\n", - "print(f\"\\nTotal ops: {len(deep_vqc_clean)}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "7e9e11cf-98c4-42c7-8222-3fad4cd5f9dc", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Encoding layer (2 ops):\n", - " ('RY', [0], tensor(0.5000))\n", - " ('RY', [1], tensor(-0.3000))\n" - ] - } - ], - "source": [ - "# What does the encoding layer look like?\n", - "encoding = param_gate_layer(\"RY\", torch.tensor([0.5, -0.3]))\n", - "print(f\"Encoding layer ({len(encoding)} ops):\")\n", - "for op in encoding:\n", - " print(f\" {op}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "dd6307c5-0207-462a-bf20-83b52a6a6f23", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Purity after 2 CNOTs: 1.0\n" - ] - } - ], - "source": [ - "# Test: 2 CNOTs\n", - "two_cnots = [(\"CNOT\", [0, 1]), (\"CNOT\", [0, 1])]\n", - "test_density = run_noisy_circuit_density(\n", - " initial_state=zero_state(2),\n", - " circuit=two_cnots,\n", - " num_qubits=2,\n", - " T1=0,\n", - " T2=0,\n", - ")\n", - "purity = torch.real(torch.trace(test_density @ test_density)).item()\n", - "print(f\"Purity after 2 CNOTs: {purity}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "a96936e9-09d3-4f4b-9afb-d78a6fa33480", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Purity after 1 RY: 1.000000238418579\n", - "Purity after RY+RY: 1.000000238418579\n", - "Purity after RY+CNOT: 1.000000238418579\n" - ] - } - ], - "source": [ - "# Test: one RY\n", - "one_ry = [(\"RY\", [0], 0.5)]\n", - "test_density = run_noisy_circuit_density(\n", - " initial_state=zero_state(2),\n", - " circuit=one_ry,\n", - " num_qubits=2,\n", - " T1=0,\n", - " T2=0,\n", - ")\n", - "purity = torch.real(torch.trace(test_density @ test_density)).item()\n", - "print(f\"Purity after 1 RY: {purity}\")\n", - "\n", - "# Test: two RYs in sequence\n", - "two_rys = [(\"RY\", [0], 0.5), (\"RY\", [1], -0.3)]\n", - "test_density = run_noisy_circuit_density(\n", - " initial_state=zero_state(2),\n", - " circuit=two_rys,\n", - " num_qubits=2,\n", - " T1=0,\n", - " T2=0,\n", - ")\n", - "purity = torch.real(torch.trace(test_density @ test_density)).item()\n", - "print(f\"Purity after RY+RY: {purity}\")\n", - "\n", - "# Test: RY then CNOT\n", - "ry_cnot = [(\"RY\", [0], 0.5), (\"CNOT\", [0, 1])]\n", - "test_density = run_noisy_circuit_density(\n", - " initial_state=zero_state(2),\n", - " circuit=ry_cnot,\n", - " num_qubits=2,\n", - " T1=0,\n", - " T2=0,\n", - ")\n", - "purity = torch.real(torch.trace(test_density @ test_density)).item()\n", - "print(f\"Purity after RY+CNOT: {purity}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "dcc190ff-ee94-4f4e-98ff-c76d0995f1d3", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Purity after 1 RY: 1.000000238418579\n" - ] - } - ], - "source": [ - "one_ry = [(\"RY\", [0], 0.5)]\n", - "test_density = run_noisy_circuit_density(\n", - " initial_state=zero_state(2),\n", - " circuit=one_ry,\n", - " num_qubits=2,\n", - " T1=0,\n", - " T2=0,\n", - ")\n", - "purity = torch.real(torch.trace(test_density @ test_density)).item()\n", - "print(f\"Purity after 1 RY: {purity}\") # Should now be ~1.0" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "dcc23318-452e-4fea-b6c7-e286ea61997b", - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": null, - "id": "15a43128-e918-4a06-ba0e-f51102a9439c", + "id": "e5d36160-42f4-47c0-bae5-fdb4a58a8899", "metadata": {}, "outputs": [], "source": []