From 6e9a614e2f5244efa67112b2d0b6b8fed35c7b5c Mon Sep 17 00:00:00 2001 From: Haimeng Zhang Date: Wed, 11 Sep 2024 11:08:40 -0400 Subject: [PATCH 01/19] submit job via SamplerV2 --- _common/qiskit/execute.py | 35 ++++++++++++++++++++++------------- 1 file changed, 22 insertions(+), 13 deletions(-) diff --git a/_common/qiskit/execute.py b/_common/qiskit/execute.py index 7981ec5c..8d15d14d 100644 --- a/_common/qiskit/execute.py +++ b/_common/qiskit/execute.py @@ -147,9 +147,12 @@ def __init__(self, qiskit_result): self.metadata = qiskit_result.metadata def get_counts(self, qc=0): - counts= self.qiskit_result.quasi_dists[0].binary_probabilities() - for key in counts.keys(): - counts[key] = int(counts[key] * self.qiskit_result.metadata[0]['shots']) + # counts= self.qiskit_result.quasi_dists[0].binary_probabilities() + # for key in counts.keys(): + # counts[key] = int(counts[key] * self.qiskit_result.metadata[0]['shots']) + register_name = list(self.qiskit_result[qc].data.keys())[0] + bitvals = getattr(self.qiskit_result[qc].data, register_name) + counts = bitvals.get_counts() return counts # Special Job object class to hold job information for custom executors @@ -375,7 +378,7 @@ def set_execution_target(backend_id='qasm_simulator', # if use sessions, setup runtime service, Session, and Sampler if use_sessions: - from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Session, Options + from qiskit_ibm_runtime import QiskitRuntimeService, Session, Options, SamplerV2 as Sampler service = QiskitRuntimeService() session_count += 1 @@ -423,11 +426,11 @@ def set_execution_target(backend_id='qasm_simulator', ############################### # otherwise, assume the backend_id is given only and assume it is IBM Cloud device else: - from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Session, Options + from qiskit_ibm_runtime import QiskitRuntimeService, Session, SamplerOptions as Options, SamplerV2 as Sampler # create the Runtime Service object - service = QiskitRuntimeService() - + service = QiskitRuntimeService(instance=f'{hub}/{group}/{project}') + print(f'setting instance {hub}/{group}/{project}') # obtain a backend from the service backend = service.backend(backend_id) @@ -449,8 +452,8 @@ def set_execution_target(backend_id='qasm_simulator', # get Sampler resilience level and transpiler optimization level from exec_options options = Options() - options.resilience_level = exec_options.get("resilience_level", 1) - options.optimization_level = exec_options.get("optimization_level", 3) + # options.resilience_level = exec_options.get("resilience_level", 1) + # options.optimization_level = exec_options.get("optimization_level", 3) # special handling for ibmq_qasm_simulator to set noise model if backend_id == "ibmq_qasm_simulator": @@ -751,7 +754,8 @@ def execute_circuit(circuit): st = time.time() if use_sessions: - job = sampler.run(trans_qc, shots=shots, **backend_exec_options_copy) + # turn circuit to pub-like + job = sampler.run([trans_qc], shots=shots, **backend_exec_options_copy) else: job = backend.run(trans_qc, shots=shots, **backend_exec_options_copy) @@ -1106,7 +1110,7 @@ def job_complete(job): # get job result (DEVNOTE: this might be different for diff targets) result = None - if job.status() == JobStatus.DONE: + if job.status() == JobStatus.DONE or job.status() == 'DONE': result = job.result() # print("... result = ", str(result)) @@ -1132,7 +1136,12 @@ def job_complete(job): result = BenchmarkResult(result) #counts = result.get_counts() - actual_shots = result.metadata[0]['shots'] + # actual_shots = result.metadata[0]['shots'] + # get the name of the classical register + register_name = list(result.qiskit_result[qc].data.keys())[0] + # get the + bitvals = getattr(result.qiskit_result[qc].data, register_name) + actual_shots = bitvals.num_shots result_obj = result.metadata[0] results_obj = result.metadata[0] else: @@ -1494,7 +1503,7 @@ def check_jobs(completion_handler=None): if hasattr(job, "error_message"): print(f" job = {job.job_id()} {job.error_message()}") - if status == JobStatus.DONE or status == JobStatus.CANCELLED or status == JobStatus.ERROR: + if status == JobStatus.DONE or status == JobStatus.CANCELLED or status == JobStatus.ERROR or status == 'DONE' or status =='CANCELLED' or status == 'ERROR': #if verbose: print("Job status is ", job.status() ) active_circuit = active_circuits[job] From dede326168bf3238ca31627416a1c2db7589622b Mon Sep 17 00:00:00 2001 From: Haimeng Zhang Date: Wed, 11 Sep 2024 15:40:49 -0400 Subject: [PATCH 02/19] get counts and timing info from job results --- _common/qiskit/execute.py | 28 +++++++++++++++++++--------- 1 file changed, 19 insertions(+), 9 deletions(-) diff --git a/_common/qiskit/execute.py b/_common/qiskit/execute.py index 8d15d14d..5a62fe4a 100644 --- a/_common/qiskit/execute.py +++ b/_common/qiskit/execute.py @@ -150,8 +150,9 @@ def get_counts(self, qc=0): # counts= self.qiskit_result.quasi_dists[0].binary_probabilities() # for key in counts.keys(): # counts[key] = int(counts[key] * self.qiskit_result.metadata[0]['shots']) - register_name = list(self.qiskit_result[qc].data.keys())[0] - bitvals = getattr(self.qiskit_result[qc].data, register_name) + qc_index = 0 # this should point to the index of the circuit in a pub + register_name = list(self.qiskit_result[qc_index].data.keys())[0] + bitvals = getattr(self.qiskit_result[qc_index].data, register_name) counts = bitvals.get_counts() return counts @@ -754,7 +755,7 @@ def execute_circuit(circuit): st = time.time() if use_sessions: - # turn circuit to pub-like + # turn input into pub-like job = sampler.run([trans_qc], shots=shots, **backend_exec_options_copy) else: job = backend.run(trans_qc, shots=shots, **backend_exec_options_copy) @@ -1138,12 +1139,13 @@ def job_complete(job): # actual_shots = result.metadata[0]['shots'] # get the name of the classical register - register_name = list(result.qiskit_result[qc].data.keys())[0] - # get the - bitvals = getattr(result.qiskit_result[qc].data, register_name) + # TODO: need to rewrite to allow for submit multiple circuits in one job + register_name = list(result.qiskit_result[0].data.keys())[0] + # get DataBin associated with the classical register + bitvals = getattr(result.qiskit_result[0].data, register_name) actual_shots = bitvals.num_shots - result_obj = result.metadata[0] - results_obj = result.metadata[0] + result_obj = result.metadata # not sure how to update to be V2 compatible + results_obj = result.metadata else: result_obj = result.to_dict() results_obj = result.to_dict()['results'][0] @@ -1178,6 +1180,14 @@ def job_complete(job): elif "time_taken" in results_obj: exec_time = results_obj["time_taken"] + elif 'execution' in result_obj: + # read execution time for the first circuit + time_dict = result_obj['execution']['execution_spans']['__value__']['spans'][0]['__value__'] + start = time_dict['start'] + stop = time_dict['stop'] + duration = stop - start + exec_time = duration.total_seconds() + # override the initial value with exec_time returned from successful execution metrics.store_metric(active_circuit["group"], active_circuit["circuit"], 'exec_time', exec_time) @@ -1282,7 +1292,7 @@ def process_step_times(job, result, active_circuit): if verbose: print(f"... job.metrics() = {job.metrics()}") - print(f"... job.result().metadata[0] = {result.metadata[0]}") + print(f"... job.result().metadata[0] = {result.metadata}") # occasionally, these metrics come back as None, so try to use them try: From b11fdab52dba9befc446832de8d94c5a78631f0a Mon Sep 17 00:00:00 2001 From: Takashi Imamichi Date: Thu, 12 Sep 2024 19:20:47 +0900 Subject: [PATCH 03/19] simplify duration --- _common/qiskit/execute.py | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/_common/qiskit/execute.py b/_common/qiskit/execute.py index 5a62fe4a..434c850c 100644 --- a/_common/qiskit/execute.py +++ b/_common/qiskit/execute.py @@ -1182,12 +1182,8 @@ def job_complete(job): elif 'execution' in result_obj: # read execution time for the first circuit - time_dict = result_obj['execution']['execution_spans']['__value__']['spans'][0]['__value__'] - start = time_dict['start'] - stop = time_dict['stop'] - duration = stop - start - exec_time = duration.total_seconds() - + exec_time = result_obj['execution']['execution_spans'][0].duration + # override the initial value with exec_time returned from successful execution metrics.store_metric(active_circuit["group"], active_circuit["circuit"], 'exec_time', exec_time) From a658f06496be635c43a2203c74d930e3706f1cb9 Mon Sep 17 00:00:00 2001 From: Takashi Imamichi Date: Fri, 13 Sep 2024 15:59:34 +0900 Subject: [PATCH 04/19] update fake backend import --- _common/qiskit/execute.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_common/qiskit/execute.py b/_common/qiskit/execute.py index 434c850c..87c718f8 100644 --- a/_common/qiskit/execute.py +++ b/_common/qiskit/execute.py @@ -300,7 +300,7 @@ def set_execution_target(backend_id='qasm_simulator', elif 'fake' in backend_id: backend = getattr( importlib.import_module( - f'qiskit.providers.fake_provider.backends.{backend_id.split("_")[-1]}.{backend_id}' + f'qiskit_ibm_runtime.fake_provider.backends.{backend_id.split("_")[-1]}.{backend_id}' ), backend_id.title().replace('_', '') ) From 443d49e383ac687fccc8b47641cc61cded856af6 Mon Sep 17 00:00:00 2001 From: Haimeng Zhang Date: Tue, 17 Sep 2024 09:36:49 -0400 Subject: [PATCH 05/19] get benchmark results from ibm_brisbane --- benchmarks-qiskit.ipynb | 267 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 258 insertions(+), 9 deletions(-) diff --git a/benchmarks-qiskit.ipynb b/benchmarks-qiskit.ipynb index 44bc6e4b..9db16f36 100644 --- a/benchmarks-qiskit.ipynb +++ b/benchmarks-qiskit.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -22,10 +22,10 @@ "max_circuits=3\n", "num_shots=1000\n", "\n", - "backend_id=\"qasm_simulator\"\n", + "backend_id=\"ibm_brisbane\"\n", "#backend_id=\"statevector_simulator\"\n", "\n", - "hub=\"ibm-q\"; group=\"open\"; project=\"main\"\n", + "hub=\"your_hub\"; group=\"your_group\"; project=\"your_project\"\n", "provider_backend = None\n", "exec_options = {}\n", "\n", @@ -80,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -108,11 +108,143 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": { "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Deutsch-Jozsa Benchmark Program - Qiskit\n", + "... execution starting at Sep 17, 2024 13:17:36 UTC\n", + "setting instance client-enablement/solutions/demo-testing\n", + "************\n", + "Executing [2] circuits with num_qubits = 3\n", + "************\n", + "Executing [2] circuits with num_qubits = 4\n", + "************\n", + "Executing [2] circuits with num_qubits = 5\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 8, 0.083\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 8, 0.071, 1.0\n", + "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.001, 32.14, 1.27 secs\n", + "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.93, 0.906\n", + "\n", + "************\n", + "Executing [2] circuits with num_qubits = 6\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 8, 0.088\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 8, 0.071, 1.5\n", + "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.001, 63.055, 1.272 secs\n", + "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.87, 0.851\n", + "\n", + "************\n", + "Executing [2] circuits with num_qubits = 7\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 8, 0.1\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 8, 0.077, 2.0\n", + "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.0, 41.148, 1.284 secs\n", + "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.637, 0.613\n", + "\n", + "************\n", + "Executing [2] circuits with num_qubits = 8\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 10, 0.107\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 10, 0.079, 3.0\n", + "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.001, 22.303, 1.292 secs\n", + "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.502, 0.495\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 9, 0.1\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 9, 0.076, 2.5\n", + "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.001, 83.751, 1.298 secs\n", + "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.486, 0.469\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 10, 0.106\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 10, 0.078, 3.5\n", + "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.001, 29.976, 1.301 secs\n", + "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.449, 0.444\n", + "\n", + "... execution complete at Sep 17, 2024 13:21:01 UTC in 205.013 secs\n", + "\n", + "Sample Circuit:\n", + " ┌───┐ ░ ┌─────┐ ░ ┌───┐ ░ ┌─┐ \n", + "q239_0: ┤ H ├──────░─┤0 ├─░─┤ H ├──────░─┤M├────────────\n", + " ├───┤ ░ │ │ ░ ├───┤ ░ └╥┘┌─┐ \n", + "q239_1: ┤ H ├──────░─┤1 ├─░─┤ H ├──────░──╫─┤M├─────────\n", + " ├───┤ ░ │ │ ░ ├───┤ ░ ║ └╥┘┌─┐ \n", + "q239_2: ┤ H ├──────░─┤2 ├─░─┤ H ├──────░──╫──╫─┤M├──────\n", + " ├───┤ ░ │ Uf │ ░ ├───┤ ░ ║ ║ └╥┘┌─┐ \n", + "q239_3: ┤ H ├──────░─┤3 ├─░─┤ H ├──────░──╫──╫──╫─┤M├───\n", + " ├───┤ ░ │ │ ░ ├───┤ ░ ║ ║ ║ └╥┘┌─┐\n", + "q239_4: ┤ H ├──────░─┤4 ├─░─┤ H ├──────░──╫──╫──╫──╫─┤M├\n", + " ├───┤┌───┐ ░ │ │ ░ ├───┤┌───┐ ░ ║ ║ ║ ║ └╥┘\n", + "q239_5: ┤ X ├┤ H ├─░─┤5 ├─░─┤ H ├┤ X ├─░──╫──╫──╫──╫──╫─\n", + " └───┘└───┘ ░ └─────┘ ░ └───┘└───┘ ░ ║ ║ ║ ║ ║ \n", + " c19: 5/═════════════════════════════════════╩══╩══╩══╩══╩═\n", + " 0 1 2 3 4 \n", + "\n", + "Constant Oracle 'Uf' =\n", + " \n", + "q_0: ─────\n", + " \n", + "q_1: ─────\n", + " \n", + "q_2: ─────\n", + " \n", + "q_3: ─────\n", + " \n", + "q_4: ─────\n", + " ┌───┐\n", + "q_5: ┤ X ├\n", + " └───┘\n", + "\n", + "Balanced Oracle 'Uf' =\n", + " ┌───┐ ░ ░ ┌───┐\n", + "q_0: ┤ X ├─░───■───────────────────────░─┤ X ├\n", + " └───┘ ░ │ ░ └───┘\n", + "q_1: ──────░───┼────■──────────────────░──────\n", + " ┌───┐ ░ │ │ ░ ┌───┐\n", + "q_2: ┤ X ├─░───┼────┼────■─────────────░─┤ X ├\n", + " └───┘ ░ │ │ │ ░ └───┘\n", + "q_3: ──────░───┼────┼────┼────■────────░──────\n", + " ┌───┐ ░ │ │ │ │ ░ ┌───┐\n", + "q_4: ┤ X ├─░───┼────┼────┼────┼────■───░─┤ X ├\n", + " └───┘ ░ ┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐ ░ └───┘\n", + "q_5: ──────░─┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├─░──────\n", + " ░ └───┘└───┘└───┘└───┘└───┘ ░ \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import sys\n", "sys.path.insert(1, \"deutsch-jozsa/qiskit\")\n", @@ -132,9 +264,126 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bernstein-Vazirani (1) Benchmark Program - Qiskit\n", + "... execution starting at Sep 17, 2024 13:28:22 UTC\n", + "setting instance client-enablement/solutions/demo-testing\n", + "************\n", + "Executing [3] circuits with num_qubits = 3\n", + "************\n", + "Executing [3] circuits with num_qubits = 4\n", + "************\n", + "Executing [3] circuits with num_qubits = 5\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 6, 0.111\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 6, 0.091, 1.0\n", + "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.002, 54.169, 1.421 secs\n", + "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.891, 0.854\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 7, 0.141\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 7, 0.106, 1.667\n", + "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.002, 40.193, 1.306 secs\n", + "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.796, 0.767\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 6\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 7, 0.118\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 7, 0.083, 1.667\n", + "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.003, 68.289, 1.324 secs\n", + "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.772, 0.757\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 7\n", + "************\n", + "Executing [3] circuits with num_qubits = 8\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 8, 0.157\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 8, 0.107, 2.667\n", + "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.002, 95.101, 1.31 secs\n", + "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.682, 0.671\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 7, 0.127\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 7, 0.082, 2.333\n", + "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.003, 74.843, 1.297 secs\n", + "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.793, 0.79\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 8, 0.156\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 8, 0.1, 3.333\n", + "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.004, 81.488, 1.304 secs\n", + "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.488, 0.484\n", + "\n", + "... execution complete at Sep 17, 2024 13:35:32 UTC in 429.721 secs\n", + "\n", + "Sample Circuit:\n", + " ┌───┐ ░ ┌─────┐ ░ ┌───┐ ░ ┌─┐ \n", + "q467_0: ┤ H ├──────░─┤0 ├─░─┤ H ├──────░─┤M├────────────\n", + " ├───┤ ░ │ │ ░ ├───┤ ░ └╥┘┌─┐ \n", + "q467_1: ┤ H ├──────░─┤1 ├─░─┤ H ├──────░──╫─┤M├─────────\n", + " ├───┤ ░ │ │ ░ ├───┤ ░ ║ └╥┘┌─┐ \n", + "q467_2: ┤ H ├──────░─┤2 ├─░─┤ H ├──────░──╫──╫─┤M├──────\n", + " ├───┤ ░ │ Uf │ ░ ├───┤ ░ ║ ║ └╥┘┌─┐ \n", + "q467_3: ┤ H ├──────░─┤3 ├─░─┤ H ├──────░──╫──╫──╫─┤M├───\n", + " ├───┤ ░ │ │ ░ ├───┤ ░ ║ ║ ║ └╥┘┌─┐\n", + "q467_4: ┤ H ├──────░─┤4 ├─░─┤ H ├──────░──╫──╫──╫──╫─┤M├\n", + " ├───┤┌───┐ ░ │ │ ░ ├───┤┌───┐ ░ ║ ║ ║ ║ └╥┘\n", + "q467_5: ┤ X ├┤ H ├─░─┤5 ├─░─┤ H ├┤ X ├─░──╫──╫──╫──╫──╫─\n", + " └───┘└───┘ ░ └─────┘ ░ └───┘└───┘ ░ ║ ║ ║ ║ ║ \n", + " c34: 5/═════════════════════════════════════╩══╩══╩══╩══╩═\n", + " 0 1 2 3 4 \n", + "\n", + "Quantum Oracle 'Uf' =\n", + " \n", + "q468_0: ──────────\n", + " \n", + "q468_1: ──■───────\n", + " │ \n", + "q468_2: ──┼───────\n", + " │ \n", + "q468_3: ──┼───────\n", + " │ \n", + "q468_4: ──┼────■──\n", + " ┌─┴─┐┌─┴─┐\n", + "q468_5: ┤ X ├┤ X ├\n", + " └───┘└───┘\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import sys\n", "sys.path.insert(1, \"bernstein-vazirani/qiskit\")\n", From e8d7421cbe0b3b315b88c3e2f4494279364ccc25 Mon Sep 17 00:00:00 2001 From: Haimeng Zhang Date: Tue, 17 Sep 2024 10:00:37 -0400 Subject: [PATCH 06/19] get more benchmark results from ibm_brisbane --- benchmarks-qiskit.ipynb | 230 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 219 insertions(+), 11 deletions(-) diff --git a/benchmarks-qiskit.ipynb b/benchmarks-qiskit.ipynb index 9db16f36..b64696df 100644 --- a/benchmarks-qiskit.ipynb +++ b/benchmarks-qiskit.ipynb @@ -404,11 +404,112 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": { "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bernstein-Vazirani (2) Benchmark Program - Qiskit\n", + "... execution starting at Sep 17, 2024 13:38:15 UTC\n", + "setting instance client-enablement/solutions/demo-testing\n", + "************\n", + "Executing [3] circuits with num_qubits = 3\n", + "************\n", + "Executing [3] circuits with num_qubits = 4\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 10, 0.162\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 12, 0.135, 1.333\n", + "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.001, 38.881, 1.323 secs\n", + "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.878, 0.837\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 5\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 11, 0.125\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 12, 0.111, 1.0\n", + "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.001, 77.081, 1.336 secs\n", + "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.687, 0.643\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 6\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 16, 0.159\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 19, 0.128, 2.0\n", + "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.001, 34.117, 1.434 secs\n", + "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.733, 0.715\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 7\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 18, 0.147\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 21, 0.12, 2.0\n", + "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.002, 29.33, 1.51 secs\n", + "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.578, 0.565\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 8\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 21, 0.148\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 25, 0.119, 2.333\n", + "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.001, 54.928, 1.688 secs\n", + "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.464, 0.455\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 25, 0.163\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 30, 0.128, 3.0\n", + "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.002, 56.218, 1.767 secs\n", + "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.524, 0.52\n", + "\n", + "... execution complete at Sep 17, 2024 13:43:42 UTC in 327.135 secs\n", + "\n", + "Sample Circuit:\n", + " ░ ┌───┐ ┌───┐┌─┐ ┌───┐ ┌───┐┌─┐ ┌─┐ ┌─┐»\n", + "q764_0: ───────────░─┤ H ├──■──┤ H ├┤M├─|0>─┤ H ├──■──┤ H ├┤M├─|0>─┤M├─|0>─┤M├»\n", + " ┌───┐┌───┐ ░ └───┘┌─┴─┐└───┘└╥┘ └───┘┌─┴─┐└───┘└╥┘ └╥┘ └╥┘»\n", + "q764_1: ┤ X ├┤ H ├─░──────┤ X ├──────╫───────────┤ X ├──────╫───────╫───────╫─»\n", + " └───┘└───┘ ░ └───┘ ║ └───┘ ║ ║ ║ »\n", + " c52: 5/═════════════════════════════╩══════════════════════╩═══════╩═══════╩═»\n", + " 0 1 2 3 »\n", + "« ┌───┐ ┌───┐┌─┐ \n", + "«q764_0: ─|0>─┤ H ├──■──┤ H ├┤M├─|0>─\n", + "« └───┘┌─┴─┐└───┘└╥┘ \n", + "«q764_1: ──────────┤ X ├──────╫──────\n", + "« └───┘ ║ \n", + "« c52: 5/═════════════════════╩══════\n", + "« 4 \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import sys\n", "sys.path.insert(1, \"bernstein-vazirani/qiskit\")\n", @@ -429,9 +530,123 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hidden Shift Benchmark Program - Qiskit\n", + "... execution starting at Sep 17, 2024 13:49:47 UTC\n", + "setting instance client-enablement/solutions/demo-testing\n", + "************\n", + "Executing [3] circuits with num_qubits = 2\n", + "************\n", + "Executing [3] circuits with num_qubits = 4\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 2 qubit group = 8, 0.189\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 2 qubit group = 16, 0.091, 2.0\n", + "Average Creation, Elapsed, Execution Time for the 2 qubit group = 0.002, 30.318, 1.288 secs\n", + "Average Transpiling, Validating, Running Times for group 2 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 2 qubit group = 0.891, 0.855\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 6\n", + "************\n", + "Executing [3] circuits with num_qubits = 8\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 8, 0.215\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 17, 0.089, 4.0\n", + "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.003, 31.414, 1.29 secs\n", + "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.79, 0.776\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 8, 0.22\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 17, 0.09, 6.0\n", + "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.002, 30.008, 1.3 secs\n", + "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.767, 0.764\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 8, 0.223\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 17, 0.092, 8.0\n", + "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.004, 35.892, 1.303 secs\n", + "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.716, 0.715\n", + "\n", + "... execution complete at Sep 17, 2024 13:52:29 UTC in 162.35 secs\n", + "\n", + "Sample Circuit:\n", + " ┌───┐ ░ ┌─────┐ ░ ┌───┐ ░ ┌─────┐ ░ ┌───┐ ░ ┌─┐ \n", + "q1023_0: ┤ H ├─░─┤0 ├─░─┤ H ├─░─┤0 ├─░─┤ H ├─░─┤M├───────────────\n", + " ├───┤ ░ │ │ ░ ├───┤ ░ │ │ ░ ├───┤ ░ └╥┘┌─┐ \n", + "q1023_1: ┤ H ├─░─┤1 ├─░─┤ H ├─░─┤1 ├─░─┤ H ├─░──╫─┤M├────────────\n", + " ├───┤ ░ │ │ ░ ├───┤ ░ │ │ ░ ├───┤ ░ ║ └╥┘┌─┐ \n", + "q1023_2: ┤ H ├─░─┤2 ├─░─┤ H ├─░─┤2 ├─░─┤ H ├─░──╫──╫─┤M├─────────\n", + " ├───┤ ░ │ Uf │ ░ ├───┤ ░ │ Ug │ ░ ├───┤ ░ ║ ║ └╥┘┌─┐ \n", + "q1023_3: ┤ H ├─░─┤3 ├─░─┤ H ├─░─┤3 ├─░─┤ H ├─░──╫──╫──╫─┤M├──────\n", + " ├───┤ ░ │ │ ░ ├───┤ ░ │ │ ░ ├───┤ ░ ║ ║ ║ └╥┘┌─┐ \n", + "q1023_4: ┤ H ├─░─┤4 ├─░─┤ H ├─░─┤4 ├─░─┤ H ├─░──╫──╫──╫──╫─┤M├───\n", + " ├───┤ ░ │ │ ░ ├───┤ ░ │ │ ░ ├───┤ ░ ║ ║ ║ ║ └╥┘┌─┐\n", + "q1023_5: ┤ H ├─░─┤5 ├─░─┤ H ├─░─┤5 ├─░─┤ H ├─░──╫──╫──╫──╫──╫─┤M├\n", + " └───┘ ░ └─────┘ ░ └───┘ ░ └─────┘ ░ └───┘ ░ ║ ║ ║ ║ ║ └╥┘\n", + " c67: 6/═════════════════════════════════════════════╩══╩══╩══╩══╩══╩═\n", + " 0 1 2 3 4 5 \n", + "\n", + "Quantum Oracle 'Uf' =\n", + " \n", + "q1024_0: ──────■──────\n", + " ┌───┐ │ ┌───┐\n", + "q1024_1: ┤ X ├─■─┤ X ├\n", + " ├───┤ ├───┤\n", + "q1024_2: ┤ X ├─■─┤ X ├\n", + " └───┘ │ └───┘\n", + "q1024_3: ──────■──────\n", + " \n", + "q1024_4: ──■──────────\n", + " │ \n", + "q1024_5: ──■──────────\n", + " \n", + "\n", + "Quantum Oracle 'Ug' =\n", + " \n", + "q1025_0: ─■─\n", + " │ \n", + "q1025_1: ─■─\n", + " \n", + "q1025_2: ─■─\n", + " │ \n", + "q1025_3: ─■─\n", + " \n", + "q1025_4: ─■─\n", + " │ \n", + "q1025_5: ─■─\n", + " \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import sys\n", "sys.path.insert(1, \"hidden-shift/qiskit\")\n", @@ -740,13 +955,6 @@ "\n", "metrics.plot_all_app_metrics(backend_id, do_all_plots=False, include_apps=None)" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 52f106bbaeb464078252b4a5eb0930d8b95d541b Mon Sep 17 00:00:00 2001 From: Haimeng Zhang Date: Tue, 17 Sep 2024 10:55:53 -0400 Subject: [PATCH 07/19] rename qft gate name, collect qft benchmark data --- benchmarks-qiskit.ipynb | 203 +++++++++++++++++- .../qiskit/qft_benchmark.py | 4 +- 2 files changed, 203 insertions(+), 4 deletions(-) diff --git a/benchmarks-qiskit.ipynb b/benchmarks-qiskit.ipynb index b64696df..3a3fb9ce 100644 --- a/benchmarks-qiskit.ipynb +++ b/benchmarks-qiskit.ipynb @@ -666,9 +666,208 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quantum Fourier Transform (1) Benchmark Program - Qiskit\n", + "... execution starting at Sep 17, 2024 14:49:06 UTC\n", + "setting instance client-enablement/solutions/demo-testing\n", + "************\n", + "Executing [3] circuits with num_qubits = 2\n", + "... number of gates, depth = 12, 8\n", + "************\n", + "Executing [3] circuits with num_qubits = 3\n", + "... number of gates, depth = 19, 14\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 2 qubit group = 9, 0.224\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 2 qubit group = 18, 0.211, 4.0\n", + "Average Creation, Elapsed, Execution Time for the 2 qubit group = 0.001, 34.872, 1.296 secs\n", + "Average Transpiling, Validating, Running Times for group 2 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 2 qubit group = 0.843, 0.791\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 4\n", + "... number of gates, depth = 30, 22\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 15, 0.376\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 35, 0.3, 12.0\n", + "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.001, 25.924, 1.323 secs\n", + "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.732, 0.694\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 5\n", + "... number of gates, depth = 42, 32\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 23, 0.474\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 58, 0.346, 24.0\n", + "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.001, 44.758, 1.301 secs\n", + "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.117, 0.058\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 6\n", + "... number of gates, depth = 57, 44\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 33, 0.551\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 87, 0.376, 40.0\n", + "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.001, 60.011, 1.42 secs\n", + "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.067, 0.037\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 7\n", + "... number of gates, depth = 73, 58\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 45, 0.604\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 122, 0.396, 60.0\n", + "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.002, 34.068, 1.37 secs\n", + "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.026, 0.011\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 8\n", + "... number of gates, depth = 92, 74\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 59, 0.643\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 163, 0.409, 84.0\n", + "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.001, 32.255, 1.409 secs\n", + "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.008, 0.002\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 75, 0.675\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 210, 0.419, 112.0\n", + "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.001, 54.696, 1.471 secs\n", + "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.004, 0.001\n", + "\n", + "... execution complete at Sep 17, 2024 14:54:27 UTC in 320.262 secs\n", + "\n", + "Sample Circuit:\n", + " ░ ┌───────────┐ ░ ┌───────┐ ░ ┌───────────────┐ ░ ┌─┐ »\n", + "q1368_0: ──────░─┤0 ├─░──┤ Rz(π) ├───░─┤0 ├─░─┤M├──────»\n", + " ░ │ │ ░ ┌┴───────┴┐ ░ │ │ ░ └╥┘┌─┐ »\n", + "q1368_1: ──────░─┤1 ├─░─┤ Rz(π/2) ├──░─┤1 ├─░──╫─┤M├───»\n", + " ┌───┐ ░ │ │ ░ ├─────────┤ ░ │ │ ░ ║ └╥┘┌─┐»\n", + "q1368_2: ┤ X ├─░─┤2 qft_gate ├─░─┤ Rz(π/4) ├──░─┤2 inv_qft_gate ├─░──╫──╫─┤M├»\n", + " ├───┤ ░ │ │ ░ ├─────────┤ ░ │ │ ░ ║ ║ └╥┘»\n", + "q1368_3: ┤ X ├─░─┤3 ├─░─┤ Rz(π/8) ├──░─┤3 ├─░──╫──╫──╫─»\n", + " └───┘ ░ │ │ ░ ├─────────┴┐ ░ │ │ ░ ║ ║ ║ »\n", + "q1368_4: ──────░─┤4 ├─░─┤ Rz(π/16) ├─░─┤4 ├─░──╫──╫──╫─»\n", + " ░ └───────────┘ ░ └──────────┘ ░ └───────────────┘ ░ ║ ║ ║ »\n", + " c106: 5/════════════════════════════════════════════════════════════╩══╩══╩═»\n", + " 0 1 2 »\n", + "« \n", + "«q1368_0: ──────\n", + "« \n", + "«q1368_1: ──────\n", + "« \n", + "«q1368_2: ──────\n", + "« ┌─┐ \n", + "«q1368_3: ┤M├───\n", + "« └╥┘┌─┐\n", + "«q1368_4: ─╫─┤M├\n", + "« ║ └╥┘\n", + "« c106: 5/═╩══╩═\n", + "« 3 4 \n", + "\n", + "QFT Circuit =\n", + " ░ ░ ░ »\n", + "q1369_0: ──────░──────────────────░─────────────────────────────░────────────»\n", + " ░ ░ ░ »\n", + "q1369_1: ──────░──────────────────░─────────────────────────────░──────■─────»\n", + " ░ ░ ┌───┐ ░ │ »\n", + "q1369_2: ──────░──────────────────░──────■──────────■─────┤ H ├─░──────┼─────»\n", + " ░ ┌───┐ ░ │ ┌────┴────┐└───┘ ░ │ »\n", + "q1369_3: ──────░──────■─────┤ H ├─░──────┼─────┤ Rz(π/2) ├──────░──────┼─────»\n", + " ┌───┐ ░ ┌────┴────┐└───┘ ░ ┌────┴────┐└─────────┘ ░ ┌────┴────┐»\n", + "q1369_4: ┤ H ├─░─┤ Rz(π/2) ├──────░─┤ Rz(π/4) ├─────────────────░─┤ Rz(π/8) ├»\n", + " └───┘ ░ └─────────┘ ░ └─────────┘ ░ └─────────┘»\n", + "« ░ »\n", + "«q1369_0: ────────────────────────────░──────■───────────■──────────■─────»\n", + "« ┌───┐ ░ │ │ │ »\n", + "«q1369_1: ─────■──────────■─────┤ H ├─░──────┼───────────┼──────────┼─────»\n", + "« │ ┌────┴────┐└───┘ ░ │ │ ┌────┴────┐»\n", + "«q1369_2: ─────┼─────┤ Rz(π/2) ├──────░──────┼───────────┼─────┤ Rz(π/4) ├»\n", + "« ┌────┴────┐└─────────┘ ░ │ ┌────┴────┐└─────────┘»\n", + "«q1369_3: ┤ Rz(π/4) ├─────────────────░──────┼──────┤ Rz(π/8) ├───────────»\n", + "« └─────────┘ ░ ┌────┴─────┐└─────────┘ »\n", + "«q1369_4: ────────────────────────────░─┤ Rz(π/16) ├──────────────────────»\n", + "« ░ └──────────┘ »\n", + "« ┌───┐ ░ \n", + "«q1369_0: ─────■─────┤ H ├─░─\n", + "« ┌────┴────┐└───┘ ░ \n", + "«q1369_1: ┤ Rz(π/2) ├──────░─\n", + "« └─────────┘ ░ \n", + "«q1369_2: ─────────────────░─\n", + "« ░ \n", + "«q1369_3: ─────────────────░─\n", + "« ░ \n", + "«q1369_4: ─────────────────░─\n", + "« ░ \n", + "\n", + "Inverse QFT Circuit =\n", + " ┌───┐ ░ »\n", + "q1370_0: ┤ H ├─────■───────────■───────────■────────────■───────░──────»\n", + " └───┘┌────┴─────┐ │ │ │ ░ ┌───┐»\n", + "q1370_1: ─────┤ Rz(-π/2) ├─────┼───────────┼────────────┼───────░─┤ H ├»\n", + " └──────────┘┌────┴─────┐ │ │ ░ └───┘»\n", + "q1370_2: ─────────────────┤ Rz(-π/4) ├─────┼────────────┼───────░──────»\n", + " └──────────┘┌────┴─────┐ │ ░ »\n", + "q1370_3: ─────────────────────────────┤ Rz(-π/8) ├──────┼───────░──────»\n", + " └──────────┘┌─────┴─────┐ ░ »\n", + "q1370_4: ─────────────────────────────────────────┤ Rz(-π/16) ├─░──────»\n", + " └───────────┘ ░ »\n", + "« ░ »\n", + "«q1370_0: ─────────────────────────────────────░──────────────────────────────»\n", + "« ░ »\n", + "«q1370_1: ─────■───────────■───────────■───────░──────────────────────────────»\n", + "« ┌────┴─────┐ │ │ ░ ┌───┐ »\n", + "«q1370_2: ┤ Rz(-π/2) ├─────┼───────────┼───────░─┤ H ├─────■───────────■──────»\n", + "« └──────────┘┌────┴─────┐ │ ░ └───┘┌────┴─────┐ │ »\n", + "«q1370_3: ────────────┤ Rz(-π/4) ├─────┼───────░──────┤ Rz(-π/2) ├─────┼──────»\n", + "« └──────────┘┌────┴─────┐ ░ └──────────┘┌────┴─────┐»\n", + "«q1370_4: ────────────────────────┤ Rz(-π/8) ├─░──────────────────┤ Rz(-π/4) ├»\n", + "« └──────────┘ ░ └──────────┘»\n", + "« ░ ░ ░ \n", + "«q1370_0: ─░───────────────────░───────░─\n", + "« ░ ░ ░ \n", + "«q1370_1: ─░───────────────────░───────░─\n", + "« ░ ░ ░ \n", + "«q1370_2: ─░───────────────────░───────░─\n", + "« ░ ┌───┐ ░ ░ \n", + "«q1370_3: ─░─┤ H ├─────■───────░───────░─\n", + "« ░ └───┘┌────┴─────┐ ░ ┌───┐ ░ \n", + "«q1370_4: ─░──────┤ Rz(-π/2) ├─░─┤ H ├─░─\n", + "« ░ └──────────┘ ░ └───┘ ░ \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import sys\n", "sys.path.insert(1, \"quantum-fourier-transform/qiskit\")\n", diff --git a/quantum-fourier-transform/qiskit/qft_benchmark.py b/quantum-fourier-transform/qiskit/qft_benchmark.py index a7c52c0f..488b37c4 100644 --- a/quantum-fourier-transform/qiskit/qft_benchmark.py +++ b/quantum-fourier-transform/qiskit/qft_benchmark.py @@ -131,7 +131,7 @@ def QuantumFourierTransform (num_qubits, secret_int, method=1): def qft_gate(input_size): global QFT_, num_gates, depth - qr = QuantumRegister(input_size); qc = QuantumCircuit(qr, name="qft") + qr = QuantumRegister(input_size); qc = QuantumCircuit(qr, name="qft_gate") # Generate multiple groups of diminishing angle CRZs and H gate for i_qubit in range(0, input_size): @@ -164,7 +164,7 @@ def qft_gate(input_size): def inv_qft_gate(input_size): global QFTI_, num_gates, depth - qr = QuantumRegister(input_size); qc = QuantumCircuit(qr, name="inv_qft") + qr = QuantumRegister(input_size); qc = QuantumCircuit(qr, name="inv_qft_gate") # Generate multiple groups of diminishing angle CRZs and H gate for i_qubit in reversed(range(0, input_size)): From 540919cc944d334f8778ad6574ef364816906326 Mon Sep 17 00:00:00 2001 From: Haimeng Zhang Date: Tue, 17 Sep 2024 11:48:33 -0400 Subject: [PATCH 08/19] remove qiskit runtime service instance printing --- _common/qiskit/execute.py | 1 - 1 file changed, 1 deletion(-) diff --git a/_common/qiskit/execute.py b/_common/qiskit/execute.py index 87c718f8..64f6096f 100644 --- a/_common/qiskit/execute.py +++ b/_common/qiskit/execute.py @@ -431,7 +431,6 @@ def set_execution_target(backend_id='qasm_simulator', # create the Runtime Service object service = QiskitRuntimeService(instance=f'{hub}/{group}/{project}') - print(f'setting instance {hub}/{group}/{project}') # obtain a backend from the service backend = service.backend(backend_id) From 55f4d320ff3be06739c1dfe7fe90c18061035339 Mon Sep 17 00:00:00 2001 From: Haimeng Zhang Date: Tue, 17 Sep 2024 11:49:07 -0400 Subject: [PATCH 09/19] collect data for qft method 2 --- benchmarks-qiskit.ipynb | 155 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 153 insertions(+), 2 deletions(-) diff --git a/benchmarks-qiskit.ipynb b/benchmarks-qiskit.ipynb index 3a3fb9ce..25d4bc62 100644 --- a/benchmarks-qiskit.ipynb +++ b/benchmarks-qiskit.ipynb @@ -888,9 +888,160 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quantum Fourier Transform (2) Benchmark Program - Qiskit\n", + "... execution starting at Sep 17, 2024 14:56:06 UTC\n", + "setting instance client-enablement/solutions/demo-testing\n", + "************\n", + "Executing [3] circuits with num_qubits = 2\n", + "... number of gates, depth = 9, 5\n", + "************\n", + "Executing [3] circuits with num_qubits = 3\n", + "... number of gates, depth = 15, 8\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 2 qubit group = 6, 0.143\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 2 qubit group = 8, 0.262, 2.0\n", + "Average Creation, Elapsed, Execution Time for the 2 qubit group = 0.0, 25.19, 1.274 secs\n", + "Average Transpiling, Validating, Running Times for group 2 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 2 qubit group = 0.915, 0.886\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 4\n", + "... number of gates, depth = 22, 12\n", + "************\n", + "Executing [3] circuits with num_qubits = 5\n", + "... number of gates, depth = 30, 17\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 13, 0.333\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 27, 0.357, 12.0\n", + "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.0, 28.729, 1.3 secs\n", + "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.649, 0.625\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 6\n", + "... number of gates, depth = 39, 23\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 9, 0.25\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 16, 0.327, 6.0\n", + "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.0, 108.494, 1.304 secs\n", + "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.858, 0.838\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 18, 0.4\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 41, 0.382, 20.0\n", + "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.001, 94.863, 1.351 secs\n", + "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.166, 0.142\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 7\n", + "... number of gates, depth = 49, 30\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 24, 0.455\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 58, 0.398, 30.0\n", + "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.001, 31.311, 1.381 secs\n", + "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.046, 0.031\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 8\n", + "... number of gates, depth = 60, 38\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 31, 0.5\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 78, 0.41, 42.0\n", + "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.001, 35.733, 1.391 secs\n", + "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.025, 0.019\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 39, 0.538\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 101, 0.42, 56.0\n", + "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.001, 29.93, 1.456 secs\n", + "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.008, 0.004\n", + "\n", + "... execution complete at Sep 17, 2024 15:02:33 UTC in 387.111 secs\n", + "\n", + "Sample Circuit:\n", + " ┌───┐┌─────────┐ ┌───────────────┐┌─┐ \n", + "q1770_0: ┤ H ├┤ Rz(12π) ├─┤0 ├┤M├────────────\n", + " ├───┤└┬────────┤ │ │└╥┘┌─┐ \n", + "q1770_1: ┤ H ├─┤ Rz(6π) ├─┤1 ├─╫─┤M├─────────\n", + " ├───┤ ├────────┤ │ │ ║ └╥┘┌─┐ \n", + "q1770_2: ┤ H ├─┤ Rz(3π) ├─┤2 inv_qft_gate ├─╫──╫─┤M├──────\n", + " ├───┤┌┴────────┴┐│ │ ║ ║ └╥┘┌─┐ \n", + "q1770_3: ┤ H ├┤ Rz(3π/2) ├┤3 ├─╫──╫──╫─┤M├───\n", + " ├───┤├──────────┤│ │ ║ ║ ║ └╥┘┌─┐\n", + "q1770_4: ┤ H ├┤ Rz(3π/4) ├┤4 ├─╫──╫──╫──╫─┤M├\n", + " └───┘└──────────┘└───────────────┘ ║ ║ ║ ║ └╥┘\n", + " c127: 5/═══════════════════════════════════╩══╩══╩══╩══╩═\n", + " 0 1 2 3 4 \n", + "\n", + "Inverse QFT Circuit =\n", + " ┌───┐ ░ »\n", + "q1771_0: ┤ H ├─────■───────────■───────────■────────────■───────░──────»\n", + " └───┘┌────┴─────┐ │ │ │ ░ ┌───┐»\n", + "q1771_1: ─────┤ Rz(-π/2) ├─────┼───────────┼────────────┼───────░─┤ H ├»\n", + " └──────────┘┌────┴─────┐ │ │ ░ └───┘»\n", + "q1771_2: ─────────────────┤ Rz(-π/4) ├─────┼────────────┼───────░──────»\n", + " └──────────┘┌────┴─────┐ │ ░ »\n", + "q1771_3: ─────────────────────────────┤ Rz(-π/8) ├──────┼───────░──────»\n", + " └──────────┘┌─────┴─────┐ ░ »\n", + "q1771_4: ─────────────────────────────────────────┤ Rz(-π/16) ├─░──────»\n", + " └───────────┘ ░ »\n", + "« ░ »\n", + "«q1771_0: ─────────────────────────────────────░──────────────────────────────»\n", + "« ░ »\n", + "«q1771_1: ─────■───────────■───────────■───────░──────────────────────────────»\n", + "« ┌────┴─────┐ │ │ ░ ┌───┐ »\n", + "«q1771_2: ┤ Rz(-π/2) ├─────┼───────────┼───────░─┤ H ├─────■───────────■──────»\n", + "« └──────────┘┌────┴─────┐ │ ░ └───┘┌────┴─────┐ │ »\n", + "«q1771_3: ────────────┤ Rz(-π/4) ├─────┼───────░──────┤ Rz(-π/2) ├─────┼──────»\n", + "« └──────────┘┌────┴─────┐ ░ └──────────┘┌────┴─────┐»\n", + "«q1771_4: ────────────────────────┤ Rz(-π/8) ├─░──────────────────┤ Rz(-π/4) ├»\n", + "« └──────────┘ ░ └──────────┘»\n", + "« ░ ░ ░ \n", + "«q1771_0: ─░───────────────────░───────░─\n", + "« ░ ░ ░ \n", + "«q1771_1: ─░───────────────────░───────░─\n", + "« ░ ░ ░ \n", + "«q1771_2: ─░───────────────────░───────░─\n", + "« ░ ┌───┐ ░ ░ \n", + "«q1771_3: ─░─┤ H ├─────■───────░───────░─\n", + "« ░ └───┘┌────┴─────┐ ░ ┌───┐ ░ \n", + "«q1771_4: ─░──────┤ Rz(-π/2) ├─░─┤ H ├─░─\n", + "« ░ └──────────┘ ░ └───┘ ░ \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import sys\n", "sys.path.insert(1, \"quantum-fourier-transform/qiskit\")\n", From e8bc152fe3b8a0213d166e021c58411f50a9165d Mon Sep 17 00:00:00 2001 From: Haimeng Zhang Date: Tue, 17 Sep 2024 12:03:49 -0400 Subject: [PATCH 10/19] collect data for grover --- benchmarks-qiskit.ipynb | 166 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 162 insertions(+), 4 deletions(-) diff --git a/benchmarks-qiskit.ipynb b/benchmarks-qiskit.ipynb index 25d4bc62..b606f07a 100644 --- a/benchmarks-qiskit.ipynb +++ b/benchmarks-qiskit.ipynb @@ -1062,9 +1062,156 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Grover's Search Benchmark Program - Qiskit\n", + "... execution starting at Sep 17, 2024 15:49:12 UTC\n", + "************\n", + "Executing [3] circuits with num_qubits = 2\n", + "************\n", + "Executing [3] circuits with num_qubits = 3\n", + "************\n", + "Executing [3] circuits with num_qubits = 4\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 2 qubit group = 13, 0.116\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 2 qubit group = 13, 0.123, 2.0\n", + "Average Creation, Elapsed, Execution Time for the 2 qubit group = 0.002, 61.534, 1.297 secs\n", + "Average Transpiling, Validating, Running Times for group 2 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 2 qubit group = 0.897, 0.863\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 25, 0.085\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 51, 0.308, 24.0\n", + "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.002, 25.612, 1.346 secs\n", + "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.77, 0.663\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 5\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 38, 0.07\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 167, 0.393, 84.0\n", + "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.005, 26.146, 1.405 secs\n", + "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.208, 0.026\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 6\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 50, 0.057\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 607, 0.372, 288.0\n", + "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.005, 40.576, 1.668 secs\n", + "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.041, 0.001\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 7\n", + "************\n", + "Executing [3] circuits with num_qubits = 8\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 66, 0.052\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 1699, 0.404, 1008.0\n", + "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.01, 54.917, 3.044 secs\n", + "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.032, 0.003\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 93, 0.043\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 3323, 0.423, 2240.0\n", + "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.015, 38.692, 4.826 secs\n", + "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.031, 0.008\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 130, 0.042\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 8787, 0.419, 5280.0\n", + "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.022, 53.184, 10.182 secs\n", + "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.005, 0.0\n", + "\n", + "... execution complete at Sep 17, 2024 15:54:48 UTC in 335.961 secs\n", + "\n", + "Sample Circuit:\n", + " ┌───┐ ░ ┌─────────┐┌───────────┐ ░ ┌─────────┐┌───────────┐ ░ »\n", + "q2225_0: ┤ H ├─░─┤0 ├┤0 ├─░─┤0 ├┤0 ├─░─»\n", + " ├───┤ ░ │ ││ │ ░ │ ││ │ ░ »\n", + "q2225_1: ┤ H ├─░─┤1 ├┤1 ├─░─┤1 ├┤1 ├─░─»\n", + " ├───┤ ░ │ ││ │ ░ │ ││ │ ░ »\n", + "q2225_2: ┤ H ├─░─┤2 oracle ├┤2 diffuser ├─░─┤2 oracle ├┤2 diffuser ├─░─»\n", + " ├───┤ ░ │ ││ │ ░ │ ││ │ ░ »\n", + "q2225_3: ┤ H ├─░─┤3 ├┤3 ├─░─┤3 ├┤3 ├─░─»\n", + " ├───┤ ░ │ ││ │ ░ │ ││ │ ░ »\n", + "q2225_4: ┤ H ├─░─┤4 ├┤4 ├─░─┤4 ├┤4 ├─░─»\n", + " └───┘ ░ └─────────┘└───────────┘ ░ └─────────┘└───────────┘ ░ »\n", + " c148: 5/══════════════════════════════════════════════════════════════»\n", + " »\n", + "« ┌─────────┐┌───────────┐ ░ ┌─────────┐┌───────────┐ ░ ┌─┐ \n", + "«q2225_0: ┤0 ├┤0 ├─░─┤0 ├┤0 ├─░─┤M├────────────\n", + "« │ ││ │ ░ │ ││ │ ░ └╥┘┌─┐ \n", + "«q2225_1: ┤1 ├┤1 ├─░─┤1 ├┤1 ├─░──╫─┤M├─────────\n", + "« │ ││ │ ░ │ ││ │ ░ ║ └╥┘┌─┐ \n", + "«q2225_2: ┤2 oracle ├┤2 diffuser ├─░─┤2 oracle ├┤2 diffuser ├─░──╫──╫─┤M├──────\n", + "« │ ││ │ ░ │ ││ │ ░ ║ ║ └╥┘┌─┐ \n", + "«q2225_3: ┤3 ├┤3 ├─░─┤3 ├┤3 ├─░──╫──╫──╫─┤M├───\n", + "« │ ││ │ ░ │ ││ │ ░ ║ ║ ║ └╥┘┌─┐\n", + "«q2225_4: ┤4 ├┤4 ├─░─┤4 ├┤4 ├─░──╫──╫──╫──╫─┤M├\n", + "« └─────────┘└───────────┘ ░ └─────────┘└───────────┘ ░ ║ ║ ║ ║ └╥┘\n", + "« c148: 5/═══════════════════════════════════════════════════════╩══╩══╩══╩══╩═\n", + "« 0 1 2 3 4 \n", + "\n", + "Oracle =\n", + " ┌───┐ ░ ┌───┐\n", + "q2232_0: ┤ X ├───────■────────░─┤ X ├\n", + " ├───┤ │ ░ ├───┤\n", + "q2232_1: ┤ X ├───────■────────░─┤ X ├\n", + " └───┘ │ ░ └───┘\n", + "q2232_2: ────────────■────────░──────\n", + " ┌───┐ │ ░ ┌───┐\n", + "q2232_3: ┤ X ├───────■────────░─┤ X ├\n", + " ├───┤┌───┐┌─┴─┐┌───┐ ░ ├───┤\n", + "q2232_4: ┤ X ├┤ H ├┤ X ├┤ H ├─░─┤ X ├\n", + " └───┘└───┘└───┘└───┘ ░ └───┘\n", + "\n", + "Diffuser =\n", + " ┌───┐┌───┐ ░ ┌───┐┌───┐\n", + "q2233_0: ┤ H ├┤ X ├───────■────────░─┤ X ├┤ H ├\n", + " ├───┤├───┤ │ ░ ├───┤├───┤\n", + "q2233_1: ┤ H ├┤ X ├───────■────────░─┤ X ├┤ H ├\n", + " ├───┤├───┤ │ ░ ├───┤├───┤\n", + "q2233_2: ┤ H ├┤ X ├───────■────────░─┤ X ├┤ H ├\n", + " ├───┤├───┤ │ ░ ├───┤├───┤\n", + "q2233_3: ┤ H ├┤ X ├───────■────────░─┤ X ├┤ H ├\n", + " ├───┤├───┤┌───┐┌─┴─┐┌───┐ ░ ├───┤├───┤\n", + "q2233_4: ┤ H ├┤ X ├┤ H ├┤ X ├┤ H ├─░─┤ X ├┤ H ├\n", + " └───┘└───┘└───┘└───┘└───┘ ░ └───┘└───┘\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import sys\n", "sys.path.insert(1, \"grovers/qiskit\")\n", @@ -1084,9 +1231,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Phase Estimation Benchmark Program - Qiskit\n", + "... execution starting at Sep 17, 2024 16:03:20 UTC\n", + "************\n", + "Executing [3] circuits with num_qubits = 3\n" + ] + } + ], "source": [ "import sys\n", "sys.path.insert(1, \"phase-estimation/qiskit\")\n", From b3e02704b333e6236a9be2b66bb3b415b3af47b6 Mon Sep 17 00:00:00 2001 From: Haimeng Zhang Date: Tue, 17 Sep 2024 12:23:24 -0400 Subject: [PATCH 11/19] collect data for phase estimation --- benchmarks-qiskit.ipynb | 143 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 140 insertions(+), 3 deletions(-) diff --git a/benchmarks-qiskit.ipynb b/benchmarks-qiskit.ipynb index b606f07a..05cc0efb 100644 --- a/benchmarks-qiskit.ipynb +++ b/benchmarks-qiskit.ipynb @@ -1241,8 +1241,136 @@ "Phase Estimation Benchmark Program - Qiskit\n", "... execution starting at Sep 17, 2024 16:03:20 UTC\n", "************\n", - "Executing [3] circuits with num_qubits = 3\n" + "Executing [3] circuits with num_qubits = 3\n", + "************\n", + "Executing [3] circuits with num_qubits = 4\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 16, 0.316\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 19, 0.261, 6.0\n", + "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.006, 33.621, 1.356 secs\n", + "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.841, 0.788\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 5\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 27, 0.353\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 31, 0.3, 12.0\n", + "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.009, 36.936, 1.31 secs\n", + "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.411, 0.327\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 6\n", + "************\n", + "Executing [3] circuits with num_qubits = 7\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 41, 0.377\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 45, 0.326, 19.333\n", + "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.013, 66.297, 1.326 secs\n", + "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.074, 0.023\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 58, 0.395\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 63, 0.348, 29.333\n", + "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.015, 26.614, 1.827 secs\n", + "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.024, 0.0\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 8\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 78, 0.408\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 84, 0.365, 41.333\n", + "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.011, 31.955, 1.356 secs\n", + "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.019, 0.004\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 101, 0.418\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 108, 0.378, 55.333\n", + "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.015, 42.38, 1.382 secs\n", + "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.007, 0.0\n", + "\n", + "... execution complete at Sep 17, 2024 16:07:55 UTC in 274.317 secs\n", + "\n", + "Sample Circuit:\n", + " ┌───┐ ░ ░ ┌──────────┐ ░ ┌─┐ \n", + "q7889_0: ┤ H ├─░─────────────────────────■────░─┤0 ├─░─┤M├─────────\n", + " ├───┤ ░ │ ░ │ │ ░ └╥┘┌─┐ \n", + "q7889_1: ┤ H ├─░──────────────────■──────┼────░─┤1 ├─░──╫─┤M├──────\n", + " ├───┤ ░ │ │ ░ │ inv_qft │ ░ ║ └╥┘┌─┐ \n", + "q7889_2: ┤ H ├─░───────────■──────┼──────┼────░─┤2 ├─░──╫──╫─┤M├───\n", + " ├───┤ ░ │ │ │ ░ │ │ ░ ║ ║ └╥┘┌─┐\n", + "q7889_3: ┤ H ├─░────■──────┼──────┼──────┼────░─┤3 ├─░──╫──╫──╫─┤M├\n", + " ├───┤ ░ ┌──┴──┐┌──┴──┐┌──┴──┐┌──┴──┐ ░ └──────────┘ ░ ║ ║ ║ └╥┘\n", + "q7889_4: ┤ X ├─░─┤ U^1 ├┤ U^2 ├┤ U^4 ├┤ U^8 ├─░──────────────░──╫──╫──╫──╫─\n", + " └───┘ ░ └─────┘└─────┘└─────┘└─────┘ ░ ░ ║ ║ ║ ║ \n", + " c166: 4/═══════════════════════════════════════════════════════╩══╩══╩══╩═\n", + " 0 1 2 3 \n", + "\n", + "Phase Operator 'U' = \n", + " ┌────────┐\n", + "q: ┤ P(π/2) ├\n", + " └────────┘\n", + "\n", + "Inverse QFT Circuit =\n", + " ┌───┐ ░ »\n", + "q7960_0: ┤ H ├─────■───────────■───────────■────────────■───────░──────»\n", + " └───┘┌────┴─────┐ │ │ │ ░ ┌───┐»\n", + "q7960_1: ─────┤ Rz(-π/2) ├─────┼───────────┼────────────┼───────░─┤ H ├»\n", + " └──────────┘┌────┴─────┐ │ │ ░ └───┘»\n", + "q7960_2: ─────────────────┤ Rz(-π/4) ├─────┼────────────┼───────░──────»\n", + " └──────────┘┌────┴─────┐ │ ░ »\n", + "q7960_3: ─────────────────────────────┤ Rz(-π/8) ├──────┼───────░──────»\n", + " └──────────┘┌─────┴─────┐ ░ »\n", + "q7960_4: ─────────────────────────────────────────┤ Rz(-π/16) ├─░──────»\n", + " └───────────┘ ░ »\n", + "« ░ »\n", + "«q7960_0: ─────────────────────────────────────░──────────────────────────────»\n", + "« ░ »\n", + "«q7960_1: ─────■───────────■───────────■───────░──────────────────────────────»\n", + "« ┌────┴─────┐ │ │ ░ ┌───┐ »\n", + "«q7960_2: ┤ Rz(-π/2) ├─────┼───────────┼───────░─┤ H ├─────■───────────■──────»\n", + "« └──────────┘┌────┴─────┐ │ ░ └───┘┌────┴─────┐ │ »\n", + "«q7960_3: ────────────┤ Rz(-π/4) ├─────┼───────░──────┤ Rz(-π/2) ├─────┼──────»\n", + "« └──────────┘┌────┴─────┐ ░ └──────────┘┌────┴─────┐»\n", + "«q7960_4: ────────────────────────┤ Rz(-π/8) ├─░──────────────────┤ Rz(-π/4) ├»\n", + "« └──────────┘ ░ └──────────┘»\n", + "« ░ ░ ░ \n", + "«q7960_0: ─░───────────────────░───────░─\n", + "« ░ ░ ░ \n", + "«q7960_1: ─░───────────────────░───────░─\n", + "« ░ ░ ░ \n", + "«q7960_2: ─░───────────────────░───────░─\n", + "« ░ ┌───┐ ░ ░ \n", + "«q7960_3: ─░─┤ H ├─────■───────░───────░─\n", + "« ░ └───┘┌────┴─────┐ ░ ┌───┐ ░ \n", + "«q7960_4: ─░──────┤ Rz(-π/2) ├─░─┤ H ├─░─\n", + "« ░ └──────────┘ ░ └───┘ ░ \n" ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -1264,9 +1392,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HHL Benchmark Program - Qiskit\n", + "... execution starting at Sep 17, 2024 16:22:57 UTC\n" + ] + } + ], "source": [ "import sys\n", "sys.path.insert(1, \"hhl/qiskit\")\n", From 58a3f60a6735b5edade8e33c27c75aa852378077 Mon Sep 17 00:00:00 2001 From: Haimeng Zhang Date: Tue, 17 Sep 2024 12:26:58 -0400 Subject: [PATCH 12/19] collect data for hhl --- benchmarks-qiskit.ipynb | 210 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 209 insertions(+), 1 deletion(-) diff --git a/benchmarks-qiskit.ipynb b/benchmarks-qiskit.ipynb index 05cc0efb..2709449e 100644 --- a/benchmarks-qiskit.ipynb +++ b/benchmarks-qiskit.ipynb @@ -1400,8 +1400,216 @@ "output_type": "stream", "text": [ "HHL Benchmark Program - Qiskit\n", - "... execution starting at Sep 17, 2024 16:22:57 UTC\n" + "... execution starting at Sep 17, 2024 16:22:57 UTC\n", + "************\n", + "Executing 3 circuits with 4 qubits, using 1 input qubits and 1 clock qubits\n", + "************\n", + "Executing 3 circuits with 5 qubits, using 1 input qubits and 2 clock qubits\n", + "************\n", + "Executing 3 circuits with 6 qubits, using 1 input qubits and 3 clock qubits\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 76, 0.252\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 114, 0.307, 50.0\n", + "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.003, 43.899, 1.378 secs\n", + "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.937, 0.374\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 148, 0.263\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 212, 0.317, 100.0\n", + "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.003, 26.937, 1.484 secs\n", + "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.9, 0.107\n", + "\n", + "************\n", + "Executing 3 circuits with 7 qubits, using 2 input qubits and 2 clock qubits\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 225, 0.275\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 315, 0.323, 152.0\n", + "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.004, 33.367, 1.604 secs\n", + "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.889, 0.008\n", + "\n", + "************\n", + "Executing 3 circuits with 8 qubits, using 2 input qubits and 3 clock qubits\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 151, 0.26\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 272, 0.329, 176.0\n", + "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.004, 34.468, 1.578 secs\n", + "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.41, 0.0\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 237, 0.262\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 411, 0.331, 264.0\n", + "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.005, 34.718, 1.684 secs\n", + "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.451, 0.016\n", + "\n", + "... execution complete at Sep 17, 2024 16:26:33 UTC in 215.678 secs\n", + "\n", + "Sample Circuit:\n", + " ┌───┐ ░ ┌───────────┐ ░ ░ ░ »\n", + " input: ┤ X ├─░─┤0 ├─░──────────░───────────────────────────░────────»\n", + " └───┘ ░ │ │ ░ ░ ░ »\n", + " in_anc: ──────░─┤1 ├─░──────────░───────────────────────────░────────»\n", + " ┌───┐ ░ │ e^{0iAt} │ ░ ┌──────┐ ░ ┌──────────┐ ░ ┌─────┐»\n", + " clock: ┤ H ├─░─┤2 ├─░─┤ IQFT ├─░──────┤0 ├─────────░─┤ QFT ├»\n", + " └───┘ ░ │ │ ░ └──────┘ ░ │ INV_ROT │┌─┐ ░ └─────┘»\n", + "ancilla: ──────░─┤3 ├─░──────────░──|0>─┤1 ├┤M├─|0>──░────────»\n", + " ░ └───────────┘ ░ ░ └──────────┘└╥┘ ░ »\n", + " c176: 1/═════════════════════════════════════════════════════╬════════════════»\n", + " ║ »\n", + " c177: 1/═════════════════════════════════════════════════════╩════════════════»\n", + " 0 »\n", + "« ░ ┌────────────┐ ░ ░ ┌─┐\n", + "« input: ─░─┤0 ├─░───────░─┤M├\n", + "« ░ │ │ ░ ░ └╥┘\n", + "« in_anc: ─░─┤1 ├─░───────░──╫─\n", + "« ░ │ e^{-0iAt} │ ░ ┌───┐ ░ ║ \n", + "« clock: ─░─┤2 ├─░─┤ H ├─░──╫─\n", + "« ░ │ │ ░ └───┘ ░ ║ \n", + "«ancilla: ─░─┤3 ├─░───────░──╫─\n", + "« ░ └────────────┘ ░ ░ ║ \n", + "« c176: 1/═════════════════════════════╩═\n", + "« 0 \n", + "« c177: 1/═══════════════════════════════\n", + "« \n", + "\n", + "U Circuit =\n", + " ┌───┐ ┌───┐ ┌───────────┐┌──────────┐┌───────────┐ »\n", + "q8162: ┤ X ├────■───────┤ X ├───┤ Rz(-3π/2) ├┤ Ry(-π/2) ├┤ Rz(-3π/2) ├──■──»\n", + " └───┘ ┌─┴─┐ ┌─┴───┴──┐└┬──────────┤└┬────────┬┘└───────────┘┌─┴─┐»\n", + "q8163: ───────┤ X ├───┤ Rz(-π) ├─┤ Ry(-π/2) ├─┤ Rz(-π) ├──────────────┤ X ├»\n", + " └───┘ └────────┘ └──────────┘ └────────┘ └───┘»\n", + "q8164: ──────■─────────────────────────────────────────────────────────────»\n", + " ┌───┐ │P(3π/2) ┌───┐ »\n", + "q8165: ┤ X ├─■──────────┤ X ├──────────────────────────────────────────────»\n", + " └───┘ └───┘ »\n", + "« ┌──────────┐┌───────────┐ ┌───┐»\n", + "«q8162: ─┤ Rx(-π/2) ├┤ Rz(-3π/2) ├──■──────────────────────────┤ X ├»\n", + "« ┌┴──────────┤└─┬────────┬┘┌─┴─┐┌──────────┐┌──────────┐└─┬─┘»\n", + "«q8163: ┤ Rz(-7π/4) ├──┤ Rx(-π) ├─┤ X ├┤ Ry(-π/2) ├┤ Rx(-π/4) ├──■──»\n", + "« └───────────┘ └────────┘ └───┘└──────────┘└──────────┘ »\n", + "«q8164: ────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q8165: ────────────────────────────────────────────────────────────»\n", + "« »\n", + "« ┌───────────┐ ┌───────────┐┌──────────┐┌───────────┐»\n", + "«q8162: ┤ Rz(-3π/2) ├──■────────────■──┤ Rz(-3π/2) ├┤ Ry(-π/2) ├┤ Rz(-3π/2) ├»\n", + "« └───┬───┬───┘ │ │ └───┬───┬───┘└┬────────┬┘└┬──────────┤»\n", + "«q8163: ────┤ X ├──────■────────────■──────┤ X ├─────┤ Rz(-π) ├──┤ Ry(-π/2) ├»\n", + "« └───┘ │ │ └───┘ └────────┘ └──────────┘»\n", + "«q8164: ───────────────┼───■────────┼────────────────────────────────────────»\n", + "« ┌─┴─┐ │P(-π) ┌─┴─┐ »\n", + "«q8165: ─────────────┤ X ├─■──────┤ X ├──────────────────────────────────────»\n", + "« └───┘ └───┘ »\n", + "« ┌──────────┐┌───────────┐ »\n", + "«q8162: ────────────■───┤ Rx(-π/2) ├┤ Rz(-3π/2) ├──■──────────────────────────»\n", + "« ┌────────┐┌─┴─┐┌┴──────────┤└─┬────────┬┘┌─┴─┐┌──────────┐┌──────────┐»\n", + "«q8163: ┤ Rz(-π) ├┤ X ├┤ Rz(-7π/4) ├──┤ Rx(-π) ├─┤ X ├┤ Ry(-π/2) ├┤ Rx(-π/4) ├»\n", + "« └────────┘└───┘└───────────┘ └────────┘ └───┘└──────────┘└──────────┘»\n", + "«q8164: ──────────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q8165: ──────────────────────────────────────────────────────────────────────»\n", + "« »\n", + "« ┌───┐┌───────────┐┌───┐ ┌───┐\n", + "«q8162: ┤ X ├┤ Rz(-3π/2) ├┤ X ├──■──┤ X ├\n", + "« └─┬─┘└───────────┘└───┘┌─┴─┐└───┘\n", + "«q8163: ──■────────────────────┤ X ├─────\n", + "« └───┘ \n", + "«q8164: ─────────────────────────────────\n", + "« \n", + "«q8165: ─────────────────────────────────\n", + "« \n", + "\n", + "U^-1 Circuit =\n", + " ┌───┐ ┌───┐ ┌───────────┐┌──────────┐┌───────────┐ »\n", + "q8170: ┤ X ├─────■───────┤ X ├───┤ Rz(-3π/2) ├┤ Ry(-π/2) ├┤ Rz(-3π/2) ├──■──»\n", + " └───┘ ┌─┴─┐ ┌─┴───┴──┐└┬──────────┤└┬────────┬┘└───────────┘┌─┴─┐»\n", + "q8171: ────────┤ X ├───┤ Rz(-π) ├─┤ Ry(-π/2) ├─┤ Rz(-π) ├──────────────┤ X ├»\n", + " └───┘ └────────┘ └──────────┘ └────────┘ └───┘»\n", + "q8172: ──────■──────────────────────────────────────────────────────────────»\n", + " ┌───┐ │P(-3π/2) ┌───┐ »\n", + "q8173: ┤ X ├─■───────────┤ X ├──────────────────────────────────────────────»\n", + " └───┘ └───┘ »\n", + "« ┌──────────┐┌───────────┐ ┌───┐»\n", + "«q8170: ─┤ Rx(-π/2) ├┤ Rz(-3π/2) ├──■──────────────────────────┤ X ├»\n", + "« ┌┴──────────┤└─┬────────┬┘┌─┴─┐┌──────────┐┌──────────┐└─┬─┘»\n", + "«q8171: ┤ Rz(-7π/4) ├──┤ Rx(-π) ├─┤ X ├┤ Ry(-π/2) ├┤ Rx(-π/4) ├──■──»\n", + "« └───────────┘ └────────┘ └───┘└──────────┘└──────────┘ »\n", + "«q8172: ────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q8173: ────────────────────────────────────────────────────────────»\n", + "« »\n", + "« ┌───────────┐ ┌───────────┐┌──────────┐┌───────────┐»\n", + "«q8170: ┤ Rz(-3π/2) ├──■───────────■──┤ Rz(-3π/2) ├┤ Ry(-π/2) ├┤ Rz(-3π/2) ├»\n", + "« └───┬───┬───┘ │ │ └───┬───┬───┘└┬────────┬┘└┬──────────┤»\n", + "«q8171: ────┤ X ├──────■───────────■──────┤ X ├─────┤ Rz(-π) ├──┤ Ry(-π/2) ├»\n", + "« └───┘ │ │ └───┘ └────────┘ └──────────┘»\n", + "«q8172: ───────────────┼───■───────┼────────────────────────────────────────»\n", + "« ┌─┴─┐ │P(π) ┌─┴─┐ »\n", + "«q8173: ─────────────┤ X ├─■─────┤ X ├──────────────────────────────────────»\n", + "« └───┘ └───┘ »\n", + "« ┌──────────┐┌───────────┐ »\n", + "«q8170: ────────────■───┤ Rx(-π/2) ├┤ Rz(-3π/2) ├──■──────────────────────────»\n", + "« ┌────────┐┌─┴─┐┌┴──────────┤└─┬────────┬┘┌─┴─┐┌──────────┐┌──────────┐»\n", + "«q8171: ┤ Rz(-π) ├┤ X ├┤ Rz(-7π/4) ├──┤ Rx(-π) ├─┤ X ├┤ Ry(-π/2) ├┤ Rx(-π/4) ├»\n", + "« └────────┘└───┘└───────────┘ └────────┘ └───┘└──────────┘└──────────┘»\n", + "«q8172: ──────────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q8173: ──────────────────────────────────────────────────────────────────────»\n", + "« »\n", + "« ┌───┐┌───────────┐┌───┐ ┌───┐\n", + "«q8170: ┤ X ├┤ Rz(-3π/2) ├┤ X ├──■──┤ X ├\n", + "« └─┬─┘└───────────┘└───┘┌─┴─┐└───┘\n", + "«q8171: ──■────────────────────┤ X ├─────\n", + "« └───┘ \n", + "«q8172: ─────────────────────────────────\n", + "« \n", + "«q8173: ─────────────────────────────────\n", + "« \n", + "\n", + "QFT Circuit =\n", + " ┌───┐ ░ \n", + "q8169: ┤ H ├─░─\n", + " └───┘ ░ \n", + "\n", + "Inverse QFT Circuit =\n", + " ┌───┐ ░ \n", + "q8166: ┤ H ├─░─\n", + " └───┘ ░ \n", + "\n", + "Hamiltonian Phase Estimation Circuit =\n", + " ... too large!\n", + "\n", + "Controlled Rotation Circuit =\n", + " \n", + "q8167: ─────────────────■────────────────────■──\n", + " ┌─────────────┐┌─┴─┐┌──────────────┐┌─┴─┐\n", + "q8168: ┤ Ry(0.77628) ├┤ X ├┤ Ry(-0.27092) ├┤ X ├\n", + " └─────────────┘└───┘└──────────────┘└───┘\n" ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ From 0036eb45c72cbcab086635604bec04706a6cbe0d Mon Sep 17 00:00:00 2001 From: Haimeng Zhang Date: Tue, 17 Sep 2024 12:46:11 -0400 Subject: [PATCH 13/19] collect data for amplitude estimation --- benchmarks-qiskit.ipynb | 169 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 165 insertions(+), 4 deletions(-) diff --git a/benchmarks-qiskit.ipynb b/benchmarks-qiskit.ipynb index 2709449e..570cfa20 100644 --- a/benchmarks-qiskit.ipynb +++ b/benchmarks-qiskit.ipynb @@ -1635,9 +1635,153 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Amplitude Estimation Benchmark Program - Qiskit\n", + "... execution starting at Sep 17, 2024 16:27:00 UTC\n", + "************\n", + "Executing [2] circuits with num_qubits = 3\n", + "************\n", + "Executing [3] circuits with num_qubits = 4\n", + "************\n", + "Executing [3] circuits with num_qubits = 5\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 72, 0.422\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 58, 0.387, 29.0\n", + "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.008, 31.814, 1.342 secs\n", + "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.567, 0.133\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 208, 0.432\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 165, 0.398, 84.0\n", + "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.01, 22.432, 1.435 secs\n", + "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.416, 0.002\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 6\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 479, 0.436\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 375, 0.404, 192.667\n", + "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.008, 31.11, 1.62 secs\n", + "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.181, 0.034\n", + "\n", + "************\n", + "Executing [3] circuits with num_qubits = 7\n", + "************\n", + "Executing [3] circuits with num_qubits = 8\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 1017, 0.438\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 836, 0.407, 426.0\n", + "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.015, 46.93, 1.955 secs\n", + "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.105, 0.025\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 2086, 0.439\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 1701, 0.408, 868.0\n", + "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.019, 37.824, 2.729 secs\n", + "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.067, 0.006\n", + "\n", + "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 4214, 0.44\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 3417, 0.409, 1744.0\n", + "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.038, 42.769, 4.161 secs\n", + "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.026, 0.0\n", + "\n", + "... execution complete at Sep 17, 2024 16:30:50 UTC in 230.245 secs\n", + "\n", + "Sample Circuit:\n", + " ┌───┐ ┌──────┐┌──────┐┌──────┐┌──────┐ ░ »\n", + "q9259_0: ┤ H ├─────────────────────────┤0 ├┤0 ├┤0 ├┤0 ├─░─»\n", + " ├───┤ ┌──────┐┌──────┐│ ││ ││ ││ │ ░ »\n", + "q9259_1: ┤ H ├─────────┤0 ├┤0 ├┤ ├┤ ├┤ ├┤ ├─░─»\n", + " ├───┤ ┌──────┐│ ││ ││ ││ ││ ││ │ ░ »\n", + "q9259_2: ┤ H ├─┤0 ├┤ ├┤ ├┤ c_Q ├┤ c_Q ├┤ c_Q ├┤ c_Q ├─░─»\n", + " ├───┴┐│ ││ c_Q ││ c_Q ││ ││ ││ ││ │ ░ »\n", + "q9258_0: ┤0 ├┤1 c_Q ├┤1 ├┤1 ├┤1 ├┤1 ├┤1 ├┤1 ├─░─»\n", + " │ A ││ ││ ││ ││ ││ ││ ││ │ ░ »\n", + "q9258_1: ┤1 ├┤2 ├┤2 ├┤2 ├┤2 ├┤2 ├┤2 ├┤2 ├─░─»\n", + " └────┘└──────┘└──────┘└──────┘└──────┘└──────┘└──────┘└──────┘ ░ »\n", + " c213: 3/═════════════════════════════════════════════════════════════════»\n", + " »\n", + "« ┌───────────────┐ ░ ┌─┐ \n", + "«q9259_0: ┤0 ├─░─┤M├──────\n", + "« │ │ ░ └╥┘┌─┐ \n", + "«q9259_1: ┤1 inv_qft_gate ├─░──╫─┤M├───\n", + "« │ │ ░ ║ └╥┘┌─┐\n", + "«q9259_2: ┤2 ├─░──╫──╫─┤M├\n", + "« └───────────────┘ ░ ║ ║ └╥┘\n", + "«q9258_0: ──────────────────░──╫──╫──╫─\n", + "« ░ ║ ║ ║ \n", + "«q9258_1: ──────────────────░──╫──╫──╫─\n", + "« ░ ║ ║ ║ \n", + "« c213: 3/═════════════════════╩══╩══╩═\n", + "« 0 1 2 \n", + "\n", + "Controlled Quantum Operator 'cQ' =\n", + " \n", + "q9608: ──■───\n", + " ┌─┴──┐\n", + " q_0: ┤0 ├\n", + " │ Q │\n", + " q_1: ┤1 ├\n", + " └────┘\n", + "\n", + "Quantum Operator 'Q' =\n", + " ┌───────┐┌───┐ ┌───┐ ┌────┐\n", + "q_0: ───────────────┤0 ├┤ X ├───────■──┤ X ├─────┤0 ├\n", + " ┌───┐┌───┐┌───┐│ A_dg │├───┤┌───┐┌─┴─┐├───┤┌───┐│ A │\n", + "q_1: ┤ X ├┤ Z ├┤ X ├┤1 ├┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├┤1 ├\n", + " └───┘└───┘└───┘└───────┘└───┘└───┘└───┘└───┘└───┘└────┘\n", + "\n", + "Amplitude Generator 'A' =\n", + " ┌───┐\n", + "q_0: ────────────────────────┤ X ├\n", + " ┌────────────┐┌───┐┌───┐└─┬─┘\n", + "q_1: ┤ Ry(2.0624) ├┤ X ├┤ X ├──■──\n", + " └────────────┘└───┘└───┘ \n", + "\n", + "Inverse QFT Circuit =\n", + " ┌───┐ ░ ░ ░ \n", + "q9266_0: ┤ H ├─────■───────────■───────░───────────────────░───────░─\n", + " └───┘┌────┴─────┐ │ ░ ┌───┐ ░ ░ \n", + "q9266_1: ─────┤ Rz(-π/2) ├─────┼───────░─┤ H ├─────■───────░───────░─\n", + " └──────────┘┌────┴─────┐ ░ └───┘┌────┴─────┐ ░ ┌───┐ ░ \n", + "q9266_2: ─────────────────┤ Rz(-π/4) ├─░──────┤ Rz(-π/2) ├─░─┤ H ├─░─\n", + " └──────────┘ ░ └──────────┘ ░ └───┘ ░ \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import sys\n", "sys.path.insert(1, \"amplitude-estimation/qiskit\")\n", @@ -1657,9 +1801,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/haimengzhang/Documents/QC-App-Oriented-Benchmarks/monte-carlo/qiskit/mc_benchmark.py:123: SyntaxWarning: invalid escape sequence '\\s'\n", + " \"\"\"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Monte Carlo Sampling (2) Benchmark Program - Qiskit\n", + "... execution starting at Sep 17, 2024 16:44:50 UTC\n" + ] + } + ], "source": [ "import sys\n", "sys.path.insert(1, \"monte-carlo/qiskit\")\n", From 2648d60f32a7b52bb0c02ba1adaec4b2c4c1f641 Mon Sep 17 00:00:00 2001 From: Takashi Imamichi Date: Wed, 18 Sep 2024 18:43:21 +0900 Subject: [PATCH 14/19] complate all tests with sampler --- _common/qiskit/execute.py | 26 ++++++++++--------- monte-carlo/qiskit/mc_benchmark.py | 4 +-- .../qiskit/qft_benchmark.py | 3 ++- shors/qiskit/shors_benchmark.py | 2 +- 4 files changed, 19 insertions(+), 16 deletions(-) diff --git a/_common/qiskit/execute.py b/_common/qiskit/execute.py index 87c718f8..6cce88e4 100644 --- a/_common/qiskit/execute.py +++ b/_common/qiskit/execute.py @@ -149,10 +149,9 @@ def __init__(self, qiskit_result): def get_counts(self, qc=0): # counts= self.qiskit_result.quasi_dists[0].binary_probabilities() # for key in counts.keys(): - # counts[key] = int(counts[key] * self.qiskit_result.metadata[0]['shots']) + # counts[key] = int(counts[key] * self.qiskit_result.metadata[0]['shots']) qc_index = 0 # this should point to the index of the circuit in a pub - register_name = list(self.qiskit_result[qc_index].data.keys())[0] - bitvals = getattr(self.qiskit_result[qc_index].data, register_name) + bitvals = next(iter(self.qiskit_result[qc_index].data.values())) counts = bitvals.get_counts() return counts @@ -254,6 +253,7 @@ def set_execution_target(backend_id='qasm_simulator', provider_name='Quantinuum') """ global backend + global sampler global session global use_sessions global session_count @@ -295,7 +295,11 @@ def set_execution_target(backend_id='qasm_simulator', # handle Statevector simulator specially elif backend_id == 'statevector_simulator': backend = Aer.get_backend("statevector_simulator") - + + elif backend_id == "statevector_sampler": + from qiskit.primitives import StatevectorSampler + sampler = StatevectorSampler() + # handle 'fake' backends here elif 'fake' in backend_id: backend = getattr( @@ -310,7 +314,6 @@ def set_execution_target(backend_id='qasm_simulator', # otherwise use the given providername or backend_id to find the backend else: global service - global sampler # if provider_module name and provider_name are provided, obtain a custom provider if provider_module_name and provider_name: @@ -434,7 +437,7 @@ def set_execution_target(backend_id='qasm_simulator', print(f'setting instance {hub}/{group}/{project}') # obtain a backend from the service backend = service.backend(backend_id) - + # DEVNOTE: here we assume if the sessions flag is set, we use Sampler # however, we may want to add a use_sampler option so that we can separate these @@ -679,7 +682,7 @@ def execute_circuit(circuit): #************************************************ # Initiate execution (with noise if specified and this is a simulator backend) - if this_noise is not None and not use_sessions and backend_name.endswith("qasm_simulator"): + if this_noise is not None and not sampler and backend_name.endswith("qasm_simulator"): logger.info(f"Performing noisy simulation, shots = {shots}") # if the noise model has associated QV value, copy it to metrics module for plotting @@ -754,9 +757,9 @@ def execute_circuit(circuit): logger.info(f'Running trans_qc, shots={shots}') st = time.time() - if use_sessions: + if sampler: # turn input into pub-like - job = sampler.run([trans_qc], shots=shots, **backend_exec_options_copy) + job = sampler.run([trans_qc], shots=shots) else: job = backend.run(trans_qc, shots=shots, **backend_exec_options_copy) @@ -1133,16 +1136,15 @@ def job_complete(job): # if we are using sessions, structure of result object is different; # use a BenchmarkResult object to hold session result and provide a get_counts() # that returns counts to the benchmarks in the same form as without sessions - if use_sessions: + if sampler: result = BenchmarkResult(result) #counts = result.get_counts() # actual_shots = result.metadata[0]['shots'] # get the name of the classical register # TODO: need to rewrite to allow for submit multiple circuits in one job - register_name = list(result.qiskit_result[0].data.keys())[0] # get DataBin associated with the classical register - bitvals = getattr(result.qiskit_result[0].data, register_name) + bitvals = next(iter(result.qiskit_result[0].data.values())) actual_shots = bitvals.num_shots result_obj = result.metadata # not sure how to update to be V2 compatible results_obj = result.metadata diff --git a/monte-carlo/qiskit/mc_benchmark.py b/monte-carlo/qiskit/mc_benchmark.py index c69a91dd..50c8f161 100644 --- a/monte-carlo/qiskit/mc_benchmark.py +++ b/monte-carlo/qiskit/mc_benchmark.py @@ -120,7 +120,7 @@ def square_on_objective(qc, qr): qc.cx(control, num_state_qubits) def state_prep(qc, qr, target_dist, num_state_qubits): - """ + r""" Use controlled Ry gates to construct the superposition Sum \sqrt{p_i} |i> """ r_probs = mc_utils.region_probs(target_dist, num_state_qubits) @@ -505,7 +505,7 @@ def get_args(): parser.add_argument("--skip_qubits", "-k", default=1, help="Number of qubits to skip", type=int) parser.add_argument("--max_circuits", "-c", default=3, help="Maximum circuit repetitions", type=int) parser.add_argument("--method", "-m", default=1, help="Algorithm Method", type=int) - parser.add_argument("--num_state_qubits", "-nsq", default=0.0, help="Number of State Qubits", type=int) + parser.add_argument("--num_state_qubits", "-nsq", default=1, help="Number of State Qubits", type=int) parser.add_argument("--nonoise", "-non", action="store_true", help="Use Noiseless Simulator") parser.add_argument("--verbose", "-v", action="store_true", help="Verbose") return parser.parse_args() diff --git a/quantum-fourier-transform/qiskit/qft_benchmark.py b/quantum-fourier-transform/qiskit/qft_benchmark.py index a7c52c0f..75da3be0 100644 --- a/quantum-fourier-transform/qiskit/qft_benchmark.py +++ b/quantum-fourier-transform/qiskit/qft_benchmark.py @@ -131,7 +131,8 @@ def QuantumFourierTransform (num_qubits, secret_int, method=1): def qft_gate(input_size): global QFT_, num_gates, depth - qr = QuantumRegister(input_size); qc = QuantumCircuit(qr, name="qft") + # avoid name "qft" as workaround of https://github.com/Qiskit/qiskit/issues/13174 + qr = QuantumRegister(input_size); qc = QuantumCircuit(qr, name="qft_") # Generate multiple groups of diminishing angle CRZs and H gate for i_qubit in range(0, input_size): diff --git a/shors/qiskit/shors_benchmark.py b/shors/qiskit/shors_benchmark.py index fa25337e..a7d10585 100644 --- a/shors/qiskit/shors_benchmark.py +++ b/shors/qiskit/shors_benchmark.py @@ -338,7 +338,7 @@ def analyze_and_print_result(qc, result, num_qubits, order, num_shots, method): # Execute program with default parameters def run (min_qubits=3, max_circuits=1, max_qubits=18, num_shots=100, method = 1, - verbose=verbose, backend_id='qasm_simulator', provider_backend=None, + verbose=verbose, backend_id='statevector_sampler', provider_backend=None, hub="ibm-q", group="open", project="main", exec_options=None, context=None): From 4951a6e2d5ea003b44901693ade7615cd6d650e0 Mon Sep 17 00:00:00 2001 From: Haimeng Zhang Date: Mon, 23 Sep 2024 12:32:17 -0400 Subject: [PATCH 15/19] remove instance argument in runtime service instantiation --- _common/qiskit/execute.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_common/qiskit/execute.py b/_common/qiskit/execute.py index 64f6096f..8dd5dbfa 100644 --- a/_common/qiskit/execute.py +++ b/_common/qiskit/execute.py @@ -430,7 +430,7 @@ def set_execution_target(backend_id='qasm_simulator', from qiskit_ibm_runtime import QiskitRuntimeService, Session, SamplerOptions as Options, SamplerV2 as Sampler # create the Runtime Service object - service = QiskitRuntimeService(instance=f'{hub}/{group}/{project}') + service = QiskitRuntimeService() # obtain a backend from the service backend = service.backend(backend_id) From 29b7846ef0b007b41f559bee513b3ba6fa22e8bf Mon Sep 17 00:00:00 2001 From: Haimeng Zhang Date: Mon, 23 Sep 2024 13:10:56 -0400 Subject: [PATCH 16/19] revert changing inv_qft circuit name --- quantum-fourier-transform/qiskit/qft_benchmark.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/quantum-fourier-transform/qiskit/qft_benchmark.py b/quantum-fourier-transform/qiskit/qft_benchmark.py index 0ba311a3..75da3be0 100644 --- a/quantum-fourier-transform/qiskit/qft_benchmark.py +++ b/quantum-fourier-transform/qiskit/qft_benchmark.py @@ -165,7 +165,7 @@ def qft_gate(input_size): def inv_qft_gate(input_size): global QFTI_, num_gates, depth - qr = QuantumRegister(input_size); qc = QuantumCircuit(qr, name="inv_qft_gate") + qr = QuantumRegister(input_size); qc = QuantumCircuit(qr, name="inv_qft") # Generate multiple groups of diminishing angle CRZs and H gate for i_qubit in reversed(range(0, input_size)): From d6ca6dacc4b87c0c00d29c8f59e4944e76fb6c1c Mon Sep 17 00:00:00 2001 From: Haimeng Zhang Date: Mon, 30 Sep 2024 14:47:23 -0400 Subject: [PATCH 17/19] revert notebook change --- benchmarks-qiskit.ipynb | 165 ++++++++++++++++++++++++++-------------- 1 file changed, 107 insertions(+), 58 deletions(-) diff --git a/benchmarks-qiskit.ipynb b/benchmarks-qiskit.ipynb index 570cfa20..a80c8d6a 100644 --- a/benchmarks-qiskit.ipynb +++ b/benchmarks-qiskit.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -80,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -108,7 +108,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 33, "metadata": { "tags": [] }, @@ -118,95 +118,107 @@ "output_type": "stream", "text": [ "Deutsch-Jozsa Benchmark Program - Qiskit\n", - "... execution starting at Sep 17, 2024 13:17:36 UTC\n", - "setting instance client-enablement/solutions/demo-testing\n", + "... execution starting at Sep 23, 2024 17:34:44 UTC\n", "************\n", "Executing [2] circuits with num_qubits = 3\n", "************\n", - "Executing [2] circuits with num_qubits = 4\n", + "Executing [2] circuits with num_qubits = 4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:urllib3.connectionpool:Retrying (PostForcelistRetry(total=4, connect=3, read=None, redirect=None, status=None)) after connection broken by 'RemoteDisconnected('Remote end closed connection without response')': /runtime/jobs/cvrtdhy55th0008rvr5g?exclude_params=true\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "************\n", "Executing [2] circuits with num_qubits = 5\n", "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 8, 0.083\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 8, 0.071, 1.0\n", - "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.001, 32.14, 1.27 secs\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 7, 0.083\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 7, 0.071, 1.0\n", + "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.001, 12480.319, 1.296 secs\n", "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.93, 0.906\n", + "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.874, 0.831\n", "\n", "************\n", "Executing [2] circuits with num_qubits = 6\n", "************\n", "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 8, 0.088\n", "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 8, 0.071, 1.5\n", - "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.001, 63.055, 1.272 secs\n", + "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.001, 6281.223, 1.753 secs\n", "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.87, 0.851\n", + "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.908, 0.895\n", "\n", "************\n", "Executing [2] circuits with num_qubits = 7\n", "************\n", "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 8, 0.1\n", "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 8, 0.077, 2.0\n", - "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.0, 41.148, 1.284 secs\n", + "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.001, 106.898, 1.671 secs\n", "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.637, 0.613\n", + "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.808, 0.795\n", "\n", "************\n", "Executing [2] circuits with num_qubits = 8\n", "************\n", + "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 8, 0.1\n", + "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 8, 0.076, 2.5\n", + "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.0, 131.608, 1.458 secs\n", + "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", + "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.448, 0.43\n", + "\n", + "************\n", "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 10, 0.107\n", "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 10, 0.079, 3.0\n", - "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.001, 22.303, 1.292 secs\n", + "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.001, 146.66, 1.686 secs\n", "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.502, 0.495\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 9, 0.1\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 9, 0.076, 2.5\n", - "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.001, 83.751, 1.298 secs\n", - "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.486, 0.469\n", + "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.444, 0.435\n", "\n", "************\n", "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 10, 0.106\n", "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 10, 0.078, 3.5\n", - "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.001, 29.976, 1.301 secs\n", + "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.001, 195.339, 1.279 secs\n", "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.449, 0.444\n", + "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.423, 0.418\n", "\n", - "... execution complete at Sep 17, 2024 13:21:01 UTC in 205.013 secs\n", + "... execution complete at Sep 23, 2024 21:10:11 UTC in 12927.288 secs\n", "\n", "Sample Circuit:\n", - " ┌───┐ ░ ┌─────┐ ░ ┌───┐ ░ ┌─┐ \n", - "q239_0: ┤ H ├──────░─┤0 ├─░─┤ H ├──────░─┤M├────────────\n", - " ├───┤ ░ │ │ ░ ├───┤ ░ └╥┘┌─┐ \n", - "q239_1: ┤ H ├──────░─┤1 ├─░─┤ H ├──────░──╫─┤M├─────────\n", - " ├───┤ ░ │ │ ░ ├───┤ ░ ║ └╥┘┌─┐ \n", - "q239_2: ┤ H ├──────░─┤2 ├─░─┤ H ├──────░──╫──╫─┤M├──────\n", - " ├───┤ ░ │ Uf │ ░ ├───┤ ░ ║ ║ └╥┘┌─┐ \n", - "q239_3: ┤ H ├──────░─┤3 ├─░─┤ H ├──────░──╫──╫──╫─┤M├───\n", - " ├───┤ ░ │ │ ░ ├───┤ ░ ║ ║ ║ └╥┘┌─┐\n", - "q239_4: ┤ H ├──────░─┤4 ├─░─┤ H ├──────░──╫──╫──╫──╫─┤M├\n", - " ├───┤┌───┐ ░ │ │ ░ ├───┤┌───┐ ░ ║ ║ ║ ║ └╥┘\n", - "q239_5: ┤ X ├┤ H ├─░─┤5 ├─░─┤ H ├┤ X ├─░──╫──╫──╫──╫──╫─\n", - " └───┘└───┘ ░ └─────┘ ░ └───┘└───┘ ░ ║ ║ ║ ║ ║ \n", - " c19: 5/═════════════════════════════════════╩══╩══╩══╩══╩═\n", - " 0 1 2 3 4 \n", + " ┌───┐ ░ ┌─────┐ ░ ┌───┐ ░ ┌─┐ \n", + "q9928_0: ┤ H ├──────░─┤0 ├─░─┤ H ├──────░─┤M├────────────\n", + " ├───┤ ░ │ │ ░ ├───┤ ░ └╥┘┌─┐ \n", + "q9928_1: ┤ H ├──────░─┤1 ├─░─┤ H ├──────░──╫─┤M├─────────\n", + " ├───┤ ░ │ │ ░ ├───┤ ░ ║ └╥┘┌─┐ \n", + "q9928_2: ┤ H ├──────░─┤2 ├─░─┤ H ├──────░──╫──╫─┤M├──────\n", + " ├───┤ ░ │ Uf │ ░ ├───┤ ░ ║ ║ └╥┘┌─┐ \n", + "q9928_3: ┤ H ├──────░─┤3 ├─░─┤ H ├──────░──╫──╫──╫─┤M├───\n", + " ├───┤ ░ │ │ ░ ├───┤ ░ ║ ║ ║ └╥┘┌─┐\n", + "q9928_4: ┤ H ├──────░─┤4 ├─░─┤ H ├──────░──╫──╫──╫──╫─┤M├\n", + " ├───┤┌───┐ ░ │ │ ░ ├───┤┌───┐ ░ ║ ║ ║ ║ └╥┘\n", + "q9928_5: ┤ X ├┤ H ├─░─┤5 ├─░─┤ H ├┤ X ├─░──╫──╫──╫──╫──╫─\n", + " └───┘└───┘ ░ └─────┘ ░ └───┘└───┘ ░ ║ ║ ║ ║ ║ \n", + " c236: 5/═════════════════════════════════════╩══╩══╩══╩══╩═\n", + " 0 1 2 3 4 \n", "\n", "Constant Oracle 'Uf' =\n", - " \n", - "q_0: ─────\n", - " \n", - "q_1: ─────\n", - " \n", - "q_2: ─────\n", - " \n", - "q_3: ─────\n", - " \n", - "q_4: ─────\n", - " ┌───┐\n", - "q_5: ┤ X ├\n", - " └───┘\n", + " \n", + "q_0: \n", + " \n", + "q_1: \n", + " \n", + "q_2: \n", + " \n", + "q_3: \n", + " \n", + "q_4: \n", + " \n", + "q_5: \n", + " \n", "\n", "Balanced Oracle 'Uf' =\n", " ┌───┐ ░ ░ ┌───┐\n", @@ -226,7 +238,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk4AAAPxCAYAAAAMsiLhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD8+klEQVR4nOzdd1hT1/8H8HfYe4ksRUHAPVAUxIUDxS1u1FZU1Npqq1K1WhXFUVfdonytrdq6tZVarDjQ1qq4cS9U3GUIAjJEIff3h7+kxgRMIoT1fj0Pj+bcc+/95CQhH8499xyRIAgCiIiIiOiDtEo6ACIiIqKygokTERERkZKYOBEREREpiYkTERERkZKYOBEREREpiYkTERERkZKYOBEREREpiYkTERERkZKYOBEREREpiYkTlYi//voLIpEIe/bsKelQlDJ79myIRCI8f/68pEMpFiKRCLNnzy7pMCocJycndO/evaTDKNckn11VKPv7adOmTRCJRHjw4MFHREhlDROnckjyYX73x8bGBu3atcOBAwdKOrwK5/3XQ0dHB1WqVMGwYcPw9OnTkg5PoVOnTmH27NlIS0srkfO3bdtW2l5aWlowMzNDrVq18Omnn+Lw4cMaieHZs2eYPXs2Ll26pJHzqau8J/WKnDx5Er1794atrS309fXh5OSEMWPG4PHjxyUdGtauXYtNmzaVdBhUjJg4lWNz5szBL7/8gp9//hlTpkxBcnIyunbtisjIyJIOrUKSvB7h4eHo0qULtmzZAh8fH7x69aqkQ5Nz6tQphIaGlljiBABVq1aVvn+XLFmCnj174tSpU+jUqRMGDhyIN2/eFOv5nz17htDQ0FKfOFU0q1evRuvWrXH16lV8+eWXWLt2Lfr164cdO3agYcOGOH36tEz9GTNmICcnp1hi+fTTT5GTk4Pq1atLy5g4lX86JR0AFZ8uXbqgadOm0sdBQUGwtbXF9u3beXlASVlZWTA2Ni6SY737eowcORLW1tZYtGgR9u3bhwEDBhTJOcoTc3NzfPLJJzJlCxcuxFdffYW1a9fCyckJixYtKqHoqCScPHkSEyZMQKtWrRAVFQUjIyPpts8//xwtW7ZE3759cf36dVhYWAAAdHR0oKNTPF912tra0NbWLpZjU+nFHqcKxMLCAoaGhnK/RMRiMVasWIF69erBwMAAtra2+Oyzz/DixQuZepLxGCdOnICnpycMDAxQo0YN/Pzzz3LnSktLw8SJE+Hk5AR9fX1UrVoVQ4cOlbucIBaLMX/+fFStWhUGBgbo0KED7t69K1Onbdu2qF+/Pq5cuQIfHx8YGRnB1dVVOv7g77//hpeXFwwNDVGrVi0cOXJEZv+HDx/iiy++QK1atWBoaIhKlSqhf//+cuMSJJfU/v77b3zxxRewsbFB1apVC2zPhw8fwtXVFfXr10diYmKB9QrSunVrAMC9e/dkym/duoV+/frBysoKBgYGaNq0Kfbt2ydT582bNwgNDYWbmxsMDAxQqVIltGrVSuYyVtu2bdG2bVu58w4bNgxOTk4FxjV79mxMnjwZAODs7Cy9ZCZpr8OHD6NVq1awsLCAiYkJatWqhW+//Vbl568ObW1trFq1CnXr1sWaNWuQnp4us33Lli3w8PCAoaEhrKysEBAQIHf5xsnJCcOGDZM79rvt9ddff6FZs2YAgOHDh0vbQNKTEBcXh759+8LOzg4GBgaoWrUqAgICFMbj6ekJIyMjWFpaok2bNjh06JDcuZX5TKlq9+7d0rawtrbGJ598InNpWDKOR9HPu++P8+fPw8/PD9bW1jA0NISzszNGjBghc67vv/8eLVq0QKVKlWBoaAgPD49iGb84d+5ciEQibN68WSZpAgAXFxcsXrwYz549w/r166XlisY4qfMezs3NRffu3WFubo5Tp04BkB/j5OTkhOvXr+Pvv/+WtqWizyCVbexxKsfS09Px/PlzCIKApKQkrF69GpmZmXJ/xX/22WfYtGkThg8fjq+++grx8fFYs2YNYmNjcfLkSejq6krr3r17F/369UNQUBACAwPx008/YdiwYfDw8EC9evUAAJmZmWjdujVu3ryJESNGoEmTJnj+/Dn27duHJ0+ewNraWnq8hQsXQktLC5MmTUJ6ejoWL16MIUOG4MyZMzIxvnjxAt27d0dAQAD69++PdevWISAgAFu3bsWECRMwZswYDB48GEuWLEG/fv3w+PFjmJqaAgDOnTuHU6dOISAgAFWrVsWDBw+wbt06tG3bFjdu3JD7BfzFF1+gcuXKCAkJQVZWlsK2vXfvHtq3bw8rKyscPnxY5jkpS/LL1tLSUlp2/fp1tGzZElWqVMHUqVNhbGyMXbt2wd/fH7/++it69+4N4O2XwYIFCzBy5Eh4enoiIyMD58+fx8WLF9GxY0eVY3lXnz59cOfOHWzfvh3Lly+XPrfKlSvj+vXr6N69Oxo2bIg5c+ZAX18fd+/excmTJz/qnKrQ1tbGoEGDMHPmTJw4cQLdunUDAMyfPx8zZ87EgAEDMHLkSCQnJ2P16tVo06YNYmNjpT0QyqhTpw7mzJmDkJAQjB49WprktmjRAq9fv4afnx9yc3Px5Zdfws7ODk+fPkVkZCTS0tJgbm4OAAgNDcXs2bPRokULzJkzB3p6ejhz5gyOHj2KTp06Sc+lzGdKVZLPc7NmzbBgwQIkJiZi5cqVOHnypLQt6tSpg19++UVmv7S0NAQHB8PGxgYAkJSUhE6dOqFy5cqYOnUqLCws8ODBA/z2228y+61cuRI9e/bEkCFD8Pr1a+zYsQP9+/dHZGSk9PX5WNnZ2YiOjkbr1q3h7OyssM7AgQMxevRo/PHHH5gyZYrCOuq8h3NyctCrVy+cP38eR44ckSbV71uxYgW+/PJLmJiYYPr06QAAW1tbFZ8plXoClTsbN24UAMj96OvrC5s2bZKp+88//wgAhK1bt8qUR0VFyZVXr15dACAcP35cWpaUlCTo6+sLX3/9tbQsJCREACD89ttvcrGJxWJBEATh2LFjAgChTp06Qm5urnT7ypUrBQDC1atXpWU+Pj4CAGHbtm3Sslu3bgkABC0tLeH06dPS8oMHDwoAhI0bN0rLsrOz5eKIiYkRAAg///yzXLu1atVKyMvLk6k/a9YsAYCQnJws3Lx5U3BwcBCaNWsmpKamyh37fZLjHjlyREhOThYeP34s7NmzR6hcubKgr68vPH78WFq3Q4cOQoMGDYRXr17JtFmLFi0ENzc3aVmjRo2Ebt26FXpeHx8fwcfHR648MDBQqF69ukwZAGHWrFnSx0uWLBEACPHx8TL1li9fLm2H4uTj4yPUq1evwO179+4VAAgrV64UBEEQHjx4IGhrawvz58+XqXf16lVBR0dHprx69epCYGCgwnO+217nzp2Tey8JgiDExsYKAITdu3cXGF9cXJygpaUl9O7dW8jPz5fZJvkMSGJR5jNVmHffm4IgCK9fvxZsbGyE+vXrCzk5OdJ6kZGRAgAhJCRE4XHEYrHQvXt3wcTERLh+/bogCP+187lz5wqN4f3P2OvXr4X69esL7du3V+o5KOPSpUsCAGH8+PGF1mvYsKFgZWUlfSxpHwll3sOS30+7d+8WXr58Kfj4+AjW1tZCbGysTD3JZ/vdz0m9evUUfu6o/OClunIsLCwMhw8fxuHDh7Flyxa0a9cOI0eOlPlrcffu3TA3N0fHjh3x/Plz6Y+HhwdMTExw7NgxmWPWrVtX+tc38LYXolatWrh//7607Ndff0WjRo2kvSPver/LfPjw4dDT05M+lhz73eMBgImJCQICAqSPa9WqJf2r2cvLS1ou+f+7+xsaGkr//+bNG6SkpMDV1RUWFha4ePGiXIyjRo0qcNzCtWvX4OPjAycnJxw5ckSmt+hDfH19UblyZTg6OqJfv34wNjbGvn37pJcDU1NTcfToUQwYMAAvX76UvhYpKSnw8/NDXFyc9FKLhYUFrl+/jri4OKXPXxQkvTa///47xGKxRs/9LhMTEwDAy5cvAQC//fYbxGIxBgwYIPM+trOzg5ubm9z7+GNIepQOHjyI7OxshXUiIiIgFosREhICLS3ZX7PvfwaU+Uyp4vz580hKSsIXX3wBAwMDaXm3bt1Qu3Zt7N+/X+F+c+fORWRkJDZt2oS6desC+O/1joyMLHQw/rufsRcvXiA9PR2tW7dW+PlSl+S1lvQkF8TU1FRaVxFV3sPp6eno1KkTbt26hb/++gvu7u4qxUzlExOncszT0xO+vr7w9fXFkCFDsH//ftStWxfjxo3D69evAbwdq5Geng4bGxtUrlxZ5iczMxNJSUkyx6xWrZrceSwtLWXGQ927dw/169dXKsb3jydJRN4fX1W1alW5Lxxzc3M4OjrKlb2/f05ODkJCQuDo6Ah9fX1YW1ujcuXKSEtLkxuTAqDAywAA0KNHD5iamuLgwYMwMzNT4hn+R5LI7tmzB127dsXz58+hr68v3X737l0IgoCZM2fKvRazZs0CAOnrMWfOHKSlpaFmzZpo0KABJk+ejCtXrqgUjzoGDhyIli1bYuTIkbC1tUVAQAB27dr1wS+g1NRUJCQkSH8UtbsqMjMzAfz3JRoXFwdBEODm5ibXdjdv3pR7H38MZ2dnBAcHY8OGDbC2toafnx/CwsJkntO9e/egpaUlTUAK86HPVH5+vkzbJSQkSD+/ijx8+BDA2z8u3le7dm3p9ndFRUUhNDQU06ZNQ9++faXlPj4+6Nu3L0JDQ2FtbY1evXph48aNyM3Nldk/MjISzZs3h4GBAaysrFC5cmWsW7fug69zZmamzPNKTk4usK7ktS4sKZJsl1xqVESV9/CECRNw7tw5HDlyRO3LplT+cIxTBaKlpYV27dph5cqViIuLQ7169SAWi2FjY4OtW7cq3Kdy5coyjwvqiREEQa2YlD1eQfWU2f/LL7/Exo0bMWHCBHh7e8Pc3BwikQgBAQEKf1m++9fz+/r27YvNmzdj69at+Oyzzwqsp4inp6f0rjp/f3+0atUKgwcPxu3bt2FiYiKNZdKkSfDz81N4DFdXVwBAmzZtcO/ePfz+++84dOgQNmzYgOXLlyM8PBwjR44E8LZnQ9Hrkp+fr1Lc7zI0NMTx48dx7Ngx7N+/H1FRUdi5cyfat2+PQ4cOFfh69OnTB3///bf0cWBg4Efdsn3t2jUA/7WHWCyGSCTCgQMHFMYg6aEC5Ht8JPLz85W+Q2rp0qUYNmyYtP2/+uorLFiwAKdPny70hgJFPvQefvz4sVwyf+zYsSIbdBwfH48hQ4agY8eOmDdvnsw2ySSQp0+fxh9//IGDBw9ixIgRWLp0KU6fPg0TExP8888/6NmzJ9q0aYO1a9fC3t4eurq62LhxI7Zt21boub///nuEhoZKH1evXr3AySTd3Nygo6NT6B8Iubm5uH37Njw9PQuso8p7uFevXtixYwcWLlyIn3/+Wa73kComJk4VTF5eHoD//mJ3cXHBkSNH0LJly0ITBlW4uLhIv9hKgz179iAwMBBLly6Vlr169UqtOYqWLFkCHR0dfPHFFzA1NcXgwYPViklbWxsLFixAu3btsGbNGkydOhU1atQAAOjq6sLX1/eDx7CyssLw4cMxfPhwZGZmok2bNpg9e7Y0cbK0tFR4uUdRj8P7CptpWUtLCx06dECHDh2wbNkyfPfdd5g+fTqOHTtWYNxLly6V6QV0cHD4YAwFyc/Px7Zt22BkZIRWrVoBePueEwQBzs7OqFmzZqH7W1paKnztHz58KH0NgMLbAAAaNGiABg0aYMaMGTh16hRatmyJ8PBwzJs3Dy4uLhCLxbhx48ZHX96xs7OTm/SzUaNGBdaXzCl0+/ZttG/fXmbb7du3ZeYcysnJQZ8+fWBhYYHt27cXmBg0b94czZs3x/z587Ft2zYMGTIEO3bswMiRI/Hrr7/CwMAABw8elOlB3bhx4wef29ChQ6WvIVD4Hy1GRkbo0KEDjhw5gocPH8o8D4ldu3YhNzcX/fv3L/S8yr6H/f390alTJwwbNgympqZYt27dB5+TqrOUU9nD9LkCefPmDQ4dOgQ9PT3UqVMHADBgwADk5+dj7ty5cvXz8vLUSi769u2Ly5cvY+/evXLb1O2Z+hja2tpy5129erVaPS8ikQjr169Hv379EBgYKDdNgCratm0LT09PrFixAq9evYKNjQ3atm2L//3vf/j333/l6r97GSMlJUVmm4mJCVxdXWUuobi4uODWrVsy+12+fFmpO+Akc1e9//qnpqbK1ZUkBu9fvnmXh4eH9LKxr6+vUpewFMnPz8dXX32Fmzdv4quvvpJeLu3Tpw+0tbURGhoq91oLgiDTXi4uLjh9+rTM5a7IyEi5aQsKaoOMjAzpHyASDRo0gJaWlrQN/P39oaWlhTlz5sj1aqr6GTAwMJBpO19f30LH1jVt2hQ2NjYIDw+XeU0OHDiAmzdvytzlNmbMGNy5cwd79+5VeMwXL17Ixfv+662trQ2RSCTzeXrw4AEiIiI++Nxq1Kgh87xatmxZaP0ZM2ZAEAQMGzZMblLL+Ph4TJkyBY6Ojvj0008LPIaq7+GhQ4di1apVCA8PxzfffPPB52RsbFyiE8dS8WOPUzl24MAB3Lp1C8DbsTHbtm1DXFwcpk6dKv3C8fHxwWeffYYFCxbg0qVL6NSpE3R1dREXF4fdu3dj5cqV6Nevn0rnnTx5Mvbs2YP+/ftjxIgR8PDwQGpqKvbt24fw8PBC/1ouDt27d8cvv/wCc3Nz1K1bFzExMThy5AgqVaqk1vG0tLSwZcsW+Pv7Y8CAAfjzzz/l/rJX1uTJk9G/f39s2rQJY8aMQVhYGFq1aoUGDRpg1KhRqFGjBhITExETE4MnT57g8uXLAN4OKG7bti08PDxgZWWF8+fPY8+ePRg3bpz02CNGjMCyZcvg5+eHoKAgJCUlITw8HPXq1UNGRkahcXl4eAAApk+fjoCAAOjq6qJHjx6YM2cOjh8/jm7duqF69epISkrC2rVrUbVqVZmeg6KQnp6OLVu2AHh7K/rdu3fx22+/4d69ewgICJBJ9l1cXDBv3jxMmzYNDx48gL+/P0xNTREfH4+9e/di9OjRmDRpEoC3k4/u2bMHnTt3xoABA3Dv3j1s2bIFLi4uMud3cXGBhYUFwsPDYWpqCmNjY3h5eeHy5csYN24c+vfvj5o1ayIvLw+//PILtLW1peODXF1dMX36dMydOxetW7dGnz59oK+vj3PnzsHBwQELFiwo0rZ6l66uLhYtWoThw4fDx8cHgwYNkk5H4OTkhIkTJwIA9u/fj59//hl9+/bFlStXZC6BmZiYwN/fH5s3b8batWvRu3dvuLi44OXLl/jhhx9gZmaGrl27Ang76HzZsmXo3LkzBg8ejKSkJISFhcHV1bXIx921atUKy5cvx4QJE9CwYUMMGzYM9vb2uHXrFn744QdoaWkhIiKi0Kkn1HkPjxs3DhkZGZg+fTrMzc0LnfPJw8MD69atw7x58+Dq6gobGxu1fz9QKVUCd/JRMVM0HYGBgYHg7u4urFu3TuZ2aIn169cLHh4egqGhoWBqaio0aNBAmDJlivDs2TNpnerVqyu8BV7Rbe8pKSnCuHHjhCpVqgh6enpC1apVhcDAQOH58+eCIMje7vuu+Ph4uVvAC7o1vaB4AAhjx46VPn7x4oUwfPhwwdraWjAxMRH8/PyEW7duyd2WLmk3Rbdev3/LtyC8vQXbx8dHMDExkZkS4X2FHTc/P19wcXERXFxcpFMg3Lt3Txg6dKhgZ2cn6OrqClWqVBG6d+8u7NmzR7rfvHnzBE9PT8HCwkIwNDQUateuLcyfP194/fq1zPG3bNki1KhRQ9DT0xPc3d2FgwcPKjUdgSAIwty5c4UqVaoIWlpa0luuo6OjhV69egkODg6Cnp6e4ODgIAwaNEi4c+dOgc9fHZIpKCQ/JiYmgpubm/DJJ58Ihw4dKnC/X3/9VWjVqpVgbGwsGBsbC7Vr1xbGjh0r3L59W6be0qVLhSpVqgj6+vpCy5YthfPnzyt8H//+++9C3bp1BR0dHen78v79+8KIESMEFxcXwcDAQLCyshLatWsnHDlyRC6en376SWjcuLGgr68vWFpaCj4+PsLhw4el21X5TBVEMv3H+1Nj7Ny5U3puKysrYciQIcKTJ0+k2wuatgSA9P1x8eJFYdCgQUK1atUEfX19wcbGRujevbtw/vx5mXP9+OOPgpubm6Cvry/Url1b2Lhxo9w0AEXpn3/+EXr16iVYW1sLIpFIACDY2NgI//77r1zd9+NQ5j1c0O+nKVOmCACENWvWCIKgeDqChIQEoVu3boKpqakAgFMTlEMiQSiBaydERFQkgoODsXLlSrx69UpmstqKZO7cuQgJCcH06dPlBrgTFTVeqiMiKsPOnTsHV1fXCps0AcDMmTPx7NkzzJ8/H9WqVcPo0aNLOiQqx9jjRERUBm3cuBFHjx7Fli1bMH/+fI2tF0hU0TFxIiIqg7S0tGBnZ4dPP/0U3333ndJzUBHRx2HiRERERKQkzuNEREREpCQmTkRERERKYuJUTm3atAkikajAdZ9KyuzZs+WWJBCJRDITN5YkJycndO/e/aOOoU7bP3jwACKRCN9///1HnZuIiIoXE6diIPnilPwYGBjAwcEBfn5+WLVq1QdX9yYqD5KTkzF+/HjUrl0bhoaGsLGxgaenJ7755hvpWomadPv2bUycOBEtWrSAgYFBgcntX3/9JfP5ff9n/vz5Kp87OzsbYWFh6NSpE+zt7WFqaorGjRtj3bp1Cpf+EYvFWLx4MZydnWFgYICGDRti+/btcnU2bdqEnj17wtHREcbGxqhfvz7mzZuHV69eFRrPiRMnpM/n+fPnH4w/MzMTs2bNQufOnWFlZQWRSFTgIs0//PADfHx8YGtrC319fTg7O2P48OFK/yFx7tw5jBs3DvXq1YOxsTGqVauGAQMG4M6dO3J1z549iy+++AIeHh7Q1dVVa5243NxcfPPNN3BwcIChoSG8vLzk1gYEgEOHDiEoKAj169eHtrY2nJyclD7Hh/4w+v7776Xvx/e/Pwr6eff8ly5dwieffAJHR0fo6+vDysoKvr6+2Lhx40ct6k2KcR6nYjRnzhw4OzvjzZs3SEhIwF9//YUJEyZg2bJl2LdvHxo2bFhs5/70008REBAgs+hmaTBjxgxMnTq1pMMoVqW17TUpNTUVTZs2RUZGBkaMGIHatWsjJSUFV65cwbp16/D555/DxMREozHFxMRg1apVqFu3LurUqYNLly4prFenTh388ssvcuW//PILDh06hE6dOql87vv37+PLL79Ehw4dEBwcDDMzMxw8eBBffPEFTp8+jc2bN8vUnz59OhYuXIhRo0ahWbNm+P333zF48GCIRCIEBAQAeJuMDR8+HM2bN8eYMWNgY2ODmJgYzJo1C9HR0Th69KjCREIsFuPLL7+EsbExsrKylIr/+fPnmDNnDqpVq4ZGjRrhr7/+KrBubGwsnJ2d0bNnT1haWiI+Ph4//PADIiMjcfny5Q8u8Lxo0SKcPHkS/fv3R8OGDZGQkIA1a9agSZMmOH36NOrXry+t++eff2LDhg1o2LAhatSooTC5+pBhw4Zhz549mDBhAtzc3LBp0yZ07doVx44dk1mCZdu2bdi5cyeaNGnyUYtUf0ibNm3k3n8jR46Ep6enzPxUks/Phg0bMGbMGNja2uLTTz+Fm5sbXr58iejoaAQFBeHff//lVBVFreQmLS+/CltiIzo6WjA0NBSqV68uZGdnl0B0pQ/eWyKlJBW0BIYyMjMz1T6vZKmZJUuWqH2M0mTx4sUCAOHkyZNy29LT04WcnByNx5SSkiJkZGQIgiAIS5YskVsq40NcXV0FNzc3tc6dnJwsXLt2Ta58+PDhAgAhLi5OWvbkyRNBV1dX5jMhFouF1q1bC1WrVpUuzZObm6uwfUNDQwUAMku7vGvdunVCpUqVhPHjx8stI1SQV69eSZczOXfunNyySB9y/vx5AYCwYMGCD9Y9efKkkJubK1N2584dQV9fXxgyZIhMeUJCgvT36NixY1Ve4uXMmTNyn7ucnBzBxcVF8Pb2lqn79OlT6ZJG3bp1k1u2qDAf+nx/6P1obGwsszyURExMjKCtrS20atVK+t5+17lz51R6nUg5vFSnYe3bt8fMmTPx8OFD6QKmErdu3UK/fv1gZWUFAwMDNG3aFPv27ZNuP3/+PEQikdxfpwBw8OBBiEQiREZGAih4nM2BAwfg4+MDU1NTmJmZoVmzZti2bZtMnTNnzqBz584wNzeHkZERfHx8cPLkySJ5/orGOEls3boVtWrVgoGBATw8PHD8+HGF+965cweffPIJzM3NUblyZcycOROCIODx48fo1asXzMzMYGdnh6VLl6od56FDh+Du7g4DAwPUrVsXv/32m8x2Sfv+/fff+OKLL2BjY4OqVavKbHu37c+fPw8/Pz9YW1vD0NAQzs7OGDFihMJzL1++HNWrV4ehoSF8fHxw7do1me1XrlzBsGHDUKNGDRgYGMDOzg4jRoxASkqKwva6e/cuhg0bBgsLC5ibm2P48OHIzs6WO++WLVvg4eEBQ0NDWFlZISAgAI8fP1an+XDv3j1oa2ujefPmctvMzMxgYGAgU6bMe07yfG7duoUBAwbAzMwMlSpVwvjx4z94aQoArKysYGpqqtbzOXv2LO7evYshQ4aotb+1tTXq1asnV967d28AwM2bN6Vlv//+O968eYMvvvhCWiYSifD555/jyZMniImJAQDo6emhRYsWSh1TIjU1FTNmzMCcOXMKXQj3ffr6+rCzs1O6/vskl5XS0tJkyh89eiRdiFyiRYsW0NPTkylzc3NDvXr15J6Tra0tDA0NlYpB0bn27NkDbW1tmZ4cAwMDBAUFISYmRub97+DgUOpmZw8NDYVIJMLWrVsVvrebNm2KYcOGaT6wco6JUwn49NNPAbz9cpa4fv06mjdvjps3b2Lq1KlYunQpjI2N4e/vj7179wJ4+yGoUaMGdu3aJXfMnTt3wtLSEn5+fgWed9OmTejWrRtSU1Mxbdo0LFy4EO7u7oiKipLWOXr0KNq0aYOMjAzMmjUL3333HdLS0tC+fXucPXtWWu/Nmzd4/vy5Uj9isfiDbfL3339jwoQJ+OSTTzBnzhykpKSgc+fOckkDAAwcOBBisRgLFy6El5cX5s2bhxUrVqBjx46oUqUKFi1aBFdXV0yaNEku+VJGXFwcBg4ciC5dumDBggXQ0dFB//79FY57+OKLL3Djxg2EhIQUeAkyKSkJnTp1woMHDzB16lSsXr0aQ4YMwenTp+Xq/vzzz1i1ahXGjh2LadOm4dq1a2jfvj0SExOldQ4fPoz79+9j+PDhWL16NQICArBjxw507doVgoJp2QYMGICXL19iwYIFGDBgADZt2oTQ0FCZOvPnz8fQoUPh5uaGZcuWYcKECYiOjkabNm3kvuyUUb16deTn5yu85PU+Zd9z7z6fV69eYcGCBejatStWrVpV7EtsbN26FQDUTpwKkpCQAOBtYiURGxsLY2Nj1KlTR6aup6endLuqx5SYOXMm7Ozs8Nlnn31U3MpISUlBUlISzp8/j+HDhwMAOnToIFNn6NChcs9TEUEQkJiYqPA5KUvRuWJjY1GzZk2YmZnJlEvauqDLuaVBdna29DNarVq1kg6nYinhHq9yqbBLdRLm5uZC48aNpY87dOggNGjQQHj16pW0TCwWCy1atJC5PDBt2jRBV1dXZiX03NxcwcLCQhgxYoRcDJKu37S0NMHU1FTw8vKSu0wiFoul/7q5uQl+fn7SMkEQhOzsbMHZ2Vno2LGjtEyyergyP+92PytaMV1S790V1x8+fCgYGBgIvXv3ltt39OjR0rK8vDyhatWqgkgkEhYuXCgtf/HihWBoaKiwe7sw1atXFwAIv/76q7QsPT1dsLe3l3m9JO3bqlUr6aWT97dJnvfevXs/+H6QdOUbGhrKrGAvuZQwceJEaZmiS7zbt28XAAjHjx+Xlkna6933hSAIQu/evYVKlSpJHz948EDQ1tYW5s+fL1Pv6tWrgo6Ojly5MhISEoTKlSsLAITatWsLY8aMEbZt2yakpaXJ1FPlPSd5Pj179pQ5xhdffCEAEC5fvqx0fKpcqsvLyxNsbW0FT09PpY+vjNzcXKFu3bqCs7Oz8ObNG2l5t27dhBo1asjVz8rKEgAIU6dOLfS4vr6+gpmZmfDixQuZ8suXLwva2trCwYMHBUH4rz2VuVT3LmUv1enr60s/25UqVRJWrVolV8fHx0epy2u//PKLAED48ccfC6zzoUt1is5Vr149oX379nJ1r1+/LgAQwsPDFR6rNFyqu3z5sgBAGD9+vNJxUNFgj1MJMTExkd5dl5qaiqNHj0p7BiQ9NSkpKfDz80NcXByePn0K4G1vy5s3b2QuHR06dAhpaWkYOHBggec7fPgwXr58ialTp8pdJpFcOrt06RLi4uIwePBgpKSkSOPIyspChw4dcPz4cWnvUaNGjXD48GGlfpTp4vf29oaHh4f0cbVq1dCrVy8cPHhQ7q6QkSNHSv+vra2Npk2bQhAEBAUFScstLCxQq1Yt3L9//4Pnfp+Dg4P0cgfw9tLS0KFDERsbK/1rXmLUqFEfXOpCckkkMjISb968KbSuv78/qlSpIn3s6ekJLy8v/Pnnn9Kydy9NvHr1Cs+fP5deErt48aLcMceMGSPzuHXr1khJSUFGRgYA4LfffoNYLMaAAQNkegrt7Ozg5uaGY8eOFRqzIra2trh8+TLGjBmDFy9eIDw8HIMHD4aNjQ3mzp0r7RlT5T0nMXbsWJnHX375JQDItFFRio6ORmJiYpH3No0bNw43btzAmjVroKPz3306OTk5Cm8skHxuc3JyCjzmd999hyNHjmDhwoVyl+K++uordOnSRa3B7eo4cOAA/vzzTyxduhTVqlVTOBD9r7/+UthL+q5bt25h7Nix8Pb2RmBgoNrxKDrXx7R1SZN8ftW9/Ezq4111JSQzMxM2NjYAgLt370IQBMycORMzZ85UWD8pKQlVqlRBo0aNULt2bezcuVOaKOzcuRPW1tZo3759gee7d+8eAMjckfK+uLg4ACj0l1N6ejosLS1haWkJX1/fwp+kCtzc3OTKatasiezsbCQnJ8skX+93S5ubm8PAwECuG9/c3Fxu3I8yXF1d5cZh1axZE8Db24rfjcXZ2fmDx/Px8UHfvn0RGhqK5cuXo23btvD398fgwYPlfmkX1A7vXp5NTU1FaGgoduzYgaSkJJm66enpcvu/316WlpYAgBcvXsDMzAxxcXEQBEHhuQGoPa7D3t4e69atw9q1axEXF4eDBw9i0aJFCAkJgb29PUaOHKnSe07i/ThdXFygpaVVbHOWbd26Fdra2oX+YaKqJUuW4IcffsDcuXPRtWtXmW2GhobIzc2V20cyjqugMT07d+7EjBkzEBQUhM8//1xu26lTpxRe+i4u7dq1AwB06dIFvXr1Qv369WFiYqLSnG0JCQno1q0bzM3NpeORipK6bV1cVJlOQXJ5kdPbaB4TpxLw5MkTpKenw9XVFQCkf1FPmjSpwDFKkrrA216n+fPn4/nz5zA1NcW+ffswaNAgmb9a1SGJY8mSJXB3d1dYR3IL7OvXr5GamqrUcStXrlykv/AUHaug43/or9mPpcwvVpFIhD179uD06dP4448/cPDgQYwYMQJLly7F6dOnVb4tf8CAATh16hQmT54Md3d3mJiYQCwWo3PnzgrHk32obcRiMUQiEQ4cOKCw7sdOGyASiVCzZk3UrFkT3bp1g5ubG7Zu3YqRI0eq9J4r7PjFJScnB3v37oWvry9sbW2L5JibNm3CN998gzFjxmDGjBly2+3t7XHs2DEIgiDz3P79918AUHgr/OHDhzF06FB069YN4eHhctsnT56M/v37Q09PT5pgSsauPX78GK9fvy7WW+xdXFzQuHFjbN26VenEKT09HV26dEFaWhr++eefYonP3t5e2pv/rsLaWh0f6sGS3Kzx/tWAwri6ukJHRwdXr179+ABJJUycSoBkwKwkSapRowaAt3/ZK9OLM3DgQISGhuLXX3+Fra0tMjIypHO7FMTFxQUAcO3aNZkkTFEdMzOzD8Zx6tQp6V+UHxIfH//ByeIkPQ/vunPnDoyMjFC5cmWlzlNUJD2A735pSeaHUWXSu/c1b94czZs3x/z587Ft2zYMGTIEO3bskLn0WFA7SM774sULREdHIzQ0FCEhIYXupywXFxcIggBnZ2dpz1pxqVGjBiwtLaVfTKq85yTi4uJkevru3r0LsVj8Ua9NQfbt24eXL18W2WW633//HSNHjkSfPn0QFhamsI67uzs2bNiAmzdvom7dutLyM2fOSLe/68yZM+jduzeaNm2KXbt2KfwD6vHjx9i2bZvcHbQA0KRJEzRq1KjYB0Ln5OQo7N1R5NWrV+jRowfu3LmDI0eOyLRDUXJ3d8exY8eQkZEhM0C8oLZWV+XKlWFkZITbt28r3H779m0YGRmpNPjdyMgI7du3x9GjR/H48WM4OjoWSaz0YRzjpGFHjx7F3Llz4ezsLP1lbGNjg7Zt2+J///uf9AvlXcnJyTKP69SpgwYNGmDnzp3YuXMn7O3t0aZNm0LP26lTJ5iammLBggVyt25Leh48PDzg4uKC77//XuHMzu/GUdRjnGJiYmTG5zx+/Bi///47OnXqVOTd8x/y7Nkz6Z2MwNuxBD///DPc3d3VuiX7xYsXcj1fkl/I73+RREREyPwFfPbsWZw5cwZdunQB8F/v0fvHW7FihcpxSfTp0wfa2toIDQ2VO64gCGpd7jxz5ozCMS1nz55FSkoKatWqBUC195zE+wnH6tWrAUDaRkVp27ZtMDIykhnzpq7jx48jICAAbdq0wdatW6GlpfjXb69evaCrq4u1a9dKywRBQHh4OKpUqSIzBcHNmzfRrVs3ODk5ITIyssAe0L1798r9SC49/vzzz1i+fPlHPz8AyMvLw4sXL+TKz549i6tXr6Jp06Yy5YqmCMjPz8fAgQMRExOD3bt3w9vbu0hiU3Sufv36IT8/H+vXr5eW5ebmYuPGjfDy8iqyZERbWxudOnXCH3/8gUePHsnF9ccff6j1u27WrFkQBAGffvqpws/PhQsXFE5fQx+HPU7F6MCBA7h16xby8vKQmJiIo0eP4vDhw6hevTr27dsn0y0bFhaGVq1aoUGDBhg1ahRq1KiBxMRExMTE4MmTJ7h8+bLMsQcOHIiQkBDpnCMF/RKWMDMzw/LlyzFy5Eg0a9YMgwcPhqWlJS5fvozs7Gxs3rwZWlpa2LBhA7p06YJ69eph+PDhqFKlCp4+fYpjx47BzMwMf/zxBwAU+Rin+vXrw8/PD1999RX09fWlXxrv3zavCTVr1kRQUBDOnTsHW1tb/PTTT0hMTMTGjRvVOt7mzZuxdu1a9O7dGy4uLnj58iV++OEHmJmZyY1vcXV1RatWrfD5558jNzcXK1asQKVKlTBlyhQAb1/HNm3aYPHixXjz5g2qVKmCQ4cOIT4+Xu3n6+Lignnz5mHatGl48OAB/P39YWpqivj4eOzduxejR4/GpEmTVDrmL7/8gq1bt6J3797w8PCAnp4ebt68iZ9++gkGBgbSmYxVec9JxMfHo2fPnujcuTNiYmKwZcsWDB48GI0aNSo0pvT0dGmSJZkjas2aNbCwsICFhYXcJaTU1FQcOHAAffv2LfBy4YMHD+Ds7IzAwMAClyABgIcPH6Jnz54QiUTo168fdu/eLbO9YcOG0pUEqlatigkTJmDJkiV48+YNmjVrhoiICPzzzz/S8VbA27Etfn5+ePHiBSZPnoz9+/fLHNPFxUWadPj7+8vFJOlh6tKli1I9HWvWrEFaWhqePXsGAPjjjz/w5MkTAG8H6JubmyMzMxOOjo4YOHCgdMmUq1evYuPGjTA3N5cbwzl06FD8/fffMgn7119/jX379qFHjx5ITU2Vm+/uk08+kWlXSQ/++fPnAQDz5s0D8HZKDMnULwWdy8vLC/3798e0adOQlJQEV1dXbN68GQ8ePMCPP/4oc94rV65I59W7e/cu0tPTpedq1KgRevToUWj7fffdd2jevDmaNGmC0aNHw8nJCQ8ePMD69eshEonw3XffFbq/Ii1atEBYWBi++OIL1K5dW2bm8L/++gv79u2TxkhFSLM38VUMktvRJT96enqCnZ2d0LFjR2HlypUKZ3gVBEG4d++eMHToUMHOzk7Q1dUVqlSpInTv3l3Ys2ePXN24uDjp8U+cOFFgDO/f3rpv3z6hRYsWgqGhoWBmZiZ4enoK27dvl6kTGxsr9OnTR6hUqZKgr68vVK9eXRgwYIAQHR2tfqP8v4KmIxg7dqywZcsWwc3NTdDX1xcaN24sHDt2TOG+798+HRgYKBgbG8udy8fHR6hXr55K8UlmDj948KDQsGFDQV9fX6hdu7awe/dumXqFTTnxfttfvHhRGDRokFCtWjVBX19fsLGxEbp37y4z/cK7tysvXbpUcHR0FPT19YXWrVvL3Wb/5MkToXfv3oKFhYVgbm4u9O/fX3j27JkAQJg1a9YH26ug98avv/4qtGrVSjA2NhaMjY2F2rVrC2PHjhVu376tUhsKgiBcuXJFmDx5stCkSRPByspK0NHREezt7YX+/fsLFy9elKuvzHtO8nxu3Lgh9OvXTzA1NRUsLS2FcePGKTUTuaSNFf0ourU8PDxcACDs27evwGNevXpVqSkCPjR9x7uvmyAIQn5+vvDdd98J1atXF/T09IR69eoJW7ZsUfr5APjgVByqTkcgmapD0Y/kvZSbmyuMHz9eaNiwoWBmZibo6uoK1atXF4KCghTeaq9oigBJWUE/yrarj4/PB88lCG9nCp80aZJgZ2cn6OvrC82aNROioqLk6r3/e12Vtpa4efOmMHDgQMHGxkbQ0dERbGxshICAAOHmzZuF7lfQzOESFy5cEAYPHiw4ODgIurq6gqWlpdChQwdh8+bNQn5+vlKxkfJEglDMo2eJiIrA7NmzERoaiuTk5I+aCLEorV27FlOmTMG9e/eKbPA4EZVuHONERKSmY8eO4auvvmLSRFSBcIwTVQjJyclyE2m+S09PD1ZWVhqMiMqD98cqEVH5x8SJKoRmzZrh4cOHBW738fHBX3/9pbmAiIioTOIYJ6oQTp48WejyCZaWljJLvhARESnCxImIiIhISRwcTkRERKQkJk5ERERESmLiRERERKQkJk5ERERESmLiRERERKQkJk5ERERESmLiRERERKQkJk5ERERESmLiRERERKSkEk+cwsLC4OTkBAMDA3h5eeHs2bOF1t+9ezdq164NAwMDNGjQAH/++afM9t9++w2dOnVCpUqVIBKJcOnSJbljvHr1CmPHjkWlSpVgYmKCvn37IjExsSifFhEREZVDJZo47dy5E8HBwZg1axYuXryIRo0awc/PD0lJSQrrnzp1CoMGDUJQUBBiY2Ph7+8Pf39/XLt2TVonKysLrVq1wqJFiwo878SJE/HHH39g9+7d+Pvvv/Hs2TP06dOnyJ8fERERlS8luladl5cXmjVrhjVr1gAAxGIxHB0d8eWXX2Lq1Kly9QcOHIisrCxERkZKy5o3bw53d3eEh4fL1H3w4AGcnZ0RGxsLd3d3aXl6ejoqV66Mbdu2oV+/fgCAW7duoU6dOoiJiUHz5s2L4ZkSERFReaBTUid+/fo1Lly4gGnTpknLtLS04Ovri5iYGIX7xMTEIDg4WKbMz88PERERSp/3woULePPmDXx9faVltWvXRrVq1QpNnHJzc5Gbmyt9LBaLkZqaKr0kSERERGWTIAh4+fIlHBwcoKVV+MW4Ekucnj9/jvz8fNja2sqU29ra4tatWwr3SUhIUFg/ISFB6fMmJCRAT08PFhYWKh1nwYIFCA0NVfo8REREVLY8fvwYVatWLbROiSVOZc20adNkervS09NRrVo1xMfHw8zMrAQjIyIioo+RkZEBZ2dnmJqafrBuiSVO1tbW0NbWlrubLTExEXZ2dgr3sbOzU6l+Qcd4/fo10tLSZHqdPnQcfX196Ovry5VbWVkxcSIiIirDdHTepkPKDL0psbvq9PT04OHhgejoaGmZWCxGdHQ0vL29Fe7j7e0tUx8ADh8+XGB9RTw8PKCrqytznNu3b+PRo0cqHYeIiIgqnhK9VBccHIzAwEA0bdoUnp6eWLFiBbKysjB8+HAAwNChQ1GlShUsWLAAADB+/Hj4+Phg6dKl6NatG3bs2IHz589j/fr10mOmpqbi0aNHePbsGYC3SRHwtqfJzs4O5ubmCAoKQnBwsLS36Msvv4S3tzfvqCMiIqJClWjiNHDgQCQnJyMkJAQJCQlwd3dHVFSUdAD4o0ePZEa3t2jRAtu2bcOMGTPw7bffws3NDREREahfv760zr59+6SJFwAEBAQAAGbNmoXZs2cDAJYvXw4tLS307dsXubm58PPzw9q1azXwjImIiKgsK9F5nMqyjIwMmJubIz09nWOciIiIyjBVvtNLfMkVIiIiorKCiRMRERGRkpg4ERERESmJiRMRERGRkpg4ERERESmJiRMRERGRkpg4ERERESmJiRMRERGRkpg4ERERESmJiRMRERGRkpg4ERERESmJiRMRERGRkpg4ERERESlJR5XKN2/exI4dO/DPP//g4cOHyM7ORuXKldG4cWP4+fmhb9++0NfXL65YiYiIiEqUSBAE4UOVLl68iClTpuDEiRNo2bIlPD094eDgAENDQ6SmpuLatWv4559/kJGRgSlTpmDChAnlPoHKyMiAubk50tPTYWZmVtLhEBERkZpU+U5Xqsepb9++mDx5Mvbs2QMLC4sC68XExGDlypVYunQpvv32W5WCJiIiIirtlOpxevPmDXR1dZU+qKr1yyL2OBEREZUPqnynKzU4XNUkqLwnTURERFQxqXxX3VdffYVVq1bJla9ZswYTJkwoipiIiIiISiWVE6dff/0VLVu2lCtv0aIF9uzZUyRBEREREZVGKidOKSkpMDc3lys3MzPD8+fPiyQoIiIiotJI5cTJ1dUVUVFRcuUHDhxAjRo1iiQoIiIiotJIpQkwASA4OBjjxo1DcnIy2rdvDwCIjo7G0qVLsWLFiqKOj4iIiKjUUDlxGjFiBHJzczF//nzMnTsXAODk5IR169Zh6NChRR4gERERUWmh1DxOBUlOToahoSFMTEyKMqYygfM4ERERlQ9FPo/T+/Ly8nDkyBH89ttvkORdz549Q2ZmpjqHIyIiIioTVL5U9/DhQ3Tu3BmPHj1Cbm4uOnbsCFNTUyxatAi5ubkIDw8vjjiJiIiISpzKPU7jx49H06ZN8eLFCxgaGkrLe/fujejo6CINjoiIiKg0UbnH6Z9//sGpU6egp6cnU+7k5ISnT58WWWBEREREpY3KPU5isRj5+fly5U+ePIGpqanKAYSFhcHJyQkGBgbw8vLC2bNnC62/e/du1K5dGwYGBmjQoAH+/PNPme2CICAkJAT29vYwNDSEr68v4uLiZOrcuXMHvXr1grW1NczMzNCqVSscO3ZM5diJiIioYlE5cerUqZPMfE0ikQiZmZmYNWsWunbtqtKxdu7cieDgYMyaNQsXL15Eo0aN4Ofnh6SkJIX1T506hUGDBiEoKAixsbHw9/eHv78/rl27Jq2zePFirFq1CuHh4Thz5gyMjY3h5+eHV69eSet0794deXl5OHr0KC5cuIBGjRqhe/fuSEhIUK0xiIiIqEJReTqCJ0+ewM/PD4IgIC4uDk2bNkVcXBysra1x/Phx2NjYKH0sLy8vNGvWDGvWrAHwtjfL0dERX375JaZOnSpXf+DAgcjKykJkZKS0rHnz5nB3d0d4eDgEQYCDgwO+/vprTJo0CQCQnp4OW1tbbNq0CQEBAXj+/DkqV66M48ePo3Xr1gCAly9fwszMDIcPH4avr69SsXM6AiIiovJBle90lcc4Va1aFZcvX8bOnTtx+fJlZGZmIigoCEOGDJEZLP4hr1+/xoULFzBt2jRpmZaWFnx9fRETE6Nwn5iYGAQHB8uU+fn5ISIiAgAQHx+PhIQEmeTH3NwcXl5eiImJQUBAACpVqoRatWrh559/RpMmTaCvr4///e9/sLGxgYeHR4Hx5ubmIjc3V/o4IyMDwNupGfLy8pR+3kRERFS6qPI9rnLiBAA6OjoYMmQIhgwZos7uAIDnz58jPz8ftra2MuW2tra4deuWwn0SEhIU1pdcYpP8W1gdkUiEI0eOwN/fH6amptDS0oKNjQ2ioqJgaWlZYLwLFixAaGioXPnp06dhbGz8gWdLREREpVVWVpbSdVVOnDZv3gxra2t069YNADBlyhSsX78edevWxfbt21G9enVVD6lRgiBg7NixsLGxwT///ANDQ0Ns2LABPXr0wLlz52Bvb69wv2nTpsn0dmVkZMDR0RHNmzfnpToiIqIyTHIVSRkqJ07fffcd1q1bB+DtpbM1a9ZgxYoViIyMxMSJE/Hbb78pdRxra2toa2sjMTFRpjwxMRF2dnYK97Gzsyu0vuTfxMREmQQoMTER7u7uAICjR48iMjISL168kCY8a9euxeHDh7F582aFY6sAQF9fH/r6+nLlOjo60NFRq+OOiIiISgFVvsdVvqvu8ePHcHV1BQBERESgX79+GD16NBYsWIB//vlH6ePo6enBw8NDZtJMsViM6OhoeHt7K9zH29tbbpLNw4cPS+s7OzvDzs5Opk5GRgbOnDkjrZOdnQ3g7Xiqd2lpaUEsFisdPxEREVU8KidOJiYmSElJAQAcOnQIHTt2BAAYGBggJydHpWMFBwfjhx9+wObNm3Hz5k18/vnnyMrKwvDhwwEAQ4cOlRk8Pn78eERFRWHp0qW4desWZs+ejfPnz2PcuHEA3o5fmjBhAubNm4d9+/bh6tWrGDp0KBwcHODv7w/gbfJlaWmJwMBAXL58GXfu3MHkyZMRHx8vvfxIREREpIjK15g6duyIkSNHonHjxrhz54507qbr16/DyclJpWMNHDgQycnJCAkJQUJCAtzd3REVFSUd3P3o0SOZnqEWLVpg27ZtmDFjBr799lu4ubkhIiIC9evXl9aZMmUKsrKyMHr0aKSlpaFVq1aIioqCgYEBgLeXCKOiojB9+nS0b98eb968Qb169fD777+jUaNGqjYHERERVSAqz+OUlpaGGTNm4PHjx/j888/RuXNnAMCsWbOgp6eH6dOnF0ugpQ3ncSIiIiofVPlOVzlxoreYOBEREZUPqnynKzXG6dGjRyoFwMV+iYiIqDxSKnFq1qwZPvvsM5w7d67AOunp6fjhhx9Qv359/Prrr0UWIBEREVFpodTg8Bs3bmD+/Pno2LEjDAwM4OHhAQcHBxgYGODFixe4ceMGrl+/jiZNmmDx4sUqL/ZLREREVBaoNMYpJycH+/fvx4kTJ/Dw4UPk5OTA2toajRs3hp+fn8zdbeUdxzgRERGVDxwcrgFMnIiIiMqHIh8cTkRERERMnIiIiIiUxsSJiIiISElMnIiIiIiUxMSJiIiISElqJU6//PILWrZsCQcHBzx8+BAAsGLFCvz+++9FGhwRERFRaaJy4rRu3ToEBweja9euSEtLQ35+PgDAwsICK1asKOr4iIiIiEoNlROn1atX44cffsD06dOhra0tLW/atCmuXr1apMERERERlSYqJ07x8fFo3LixXLm+vj6ysrKKJCgiIiKi0kjlxMnZ2RmXLl2SK4+KikKdOnWKIiYiIiKiUkmpRX7fFRwcjLFjx+LVq1cQBAFnz57F9u3bsWDBAmzYsKE4YiQiIiIqFVROnEaOHAlDQ0PMmDED2dnZGDx4MBwcHLBy5UoEBAQUR4xEREREpcJHLfKbnZ2NzMxM2NjYFGVMZQIX+SUiIiofVPlOV7nH6V1GRkYwMjL6mEMQERERlRkqJ04pKSkICQnBsWPHkJSUBLFYLLM9NTW1yIIjIiIiKk1UTpw+/fRT3L17F0FBQbC1tYVIJCqOuIiIiIhKHZUTp3/++QcnTpxAo0aNiiMeIiIiolJL5XmcateujZycnOKIhYiIiKhUUzlxWrt2LaZPn46///4bKSkpyMjIkPkhIiIiKq9UvlRnYWGBjIwMtG/fXqZcEASIRCLpor9ERERE5Y3KidOQIUOgq6uLbdu2cXA4ERERVSgqJ07Xrl1DbGwsatWqVRzxEBEREZVaKo9xatq0KR4/flwcsRARERGVaionTl9++SXGjx+PTZs24cKFC7hy5YrMj6rCwsLg5OQEAwMDeHl54ezZs4XW3717N2rXrg0DAwM0aNAAf/75p8x2QRAQEhICe3t7GBoawtfXF3FxcXLH2b9/P7y8vGBoaAhLS0v4+/urHDsRERFVMIKKRCKR3I+Wlpb0X1Xs2LFD0NPTE3766Sfh+vXrwqhRowQLCwshMTFRYf2TJ08K2trawuLFi4UbN24IM2bMEHR1dYWrV69K6yxcuFAwNzcXIiIihMuXLws9e/YUnJ2dhZycHGmdPXv2CJaWlsK6deuE27dvC9evXxd27typUuzp6ekCACE9PV2l/YiIiKh0UeU7XeVFfh8+fFjo9urVqyt9LC8vLzRr1gxr1qwBAIjFYjg6OuLLL7/E1KlT5eoPHDgQWVlZiIyMlJY1b94c7u7uCA8PhyAIcHBwwNdff41JkyYBANLT02Fra4tNmzYhICAAeXl5cHJyQmhoKIKCgpSO9X1c5JeIiKh8KNZFflVJjArz+vVrXLhwAdOmTZOWaWlpwdfXFzExMQr3iYmJQXBwsEyZn58fIiIiAADx8fFISEiAr6+vdLu5uTm8vLwQExODgIAAXLx4EU+fPoWWlhYaN26MhIQEuLu7Y8mSJahfv36B8ebm5iI3N1f6WDJnVV5eHvLy8lR+/kRERFQ6qPI9rlTitG/fPnTp0gW6urrYt29foXV79uyp1ImfP3+O/Px82NraypTb2tri1q1bCvdJSEhQWD8hIUG6XVJWUJ379+8DAGbPno1ly5bByckJS5cuRdu2bXHnzh1YWVkpPPeCBQsQGhoqV3769GkYGxt/6OkSERFRKZWVlaV0XaUSJ39/fyQkJMDGxqbQQdRlYQJMsVgMAJg+fTr69u0LANi4cSOqVq2K3bt347PPPlO437Rp02R6uzIyMuDo6IjmzZvzUh0REVEZpsrKJ0olTmKxGI8ePYIgCNLE42NZW1tDW1sbiYmJMuWJiYmws7NTuI+dnV2h9SX/JiYmwt7eXqaOu7s7AEjL69atK92ur6+PGjVq4NGjRwXGq6+vD319fblyHR0d6OiofMWTiIiISglVvseVno7A2dkZycnJagWkiJ6eHjw8PBAdHS0tE4vFiI6Ohre3t8J9vL29ZeoDwOHDh6X1nZ2dYWdnJ1MnIyMDZ86ckdbx8PCAvr4+bt++La3z5s0bPHjwoMjGbxEREVH5pHSKpeLNd0oJDg5GYGAgmjZtCk9PT6xYsQJZWVkYPnw4AGDo0KGoUqUKFixYAAAYP348fHx8sHTpUnTr1g07duzA+fPnsX79egBvLxVOmDAB8+bNg5ubG5ydnTFz5kw4ODhILzGamZlhzJgxmDVrFhwdHVG9enUsWbIEANC/f/8if45ERERUfqh0jamo16UbOHAgkpOTERISIr27LSoqSjq4+9GjR9DS+q9TrEWLFti2bRtmzJiBb7/9Fm5uboiIiJC5G27KlCnIysrC6NGjkZaWhlatWiEqKgoGBgbSOkuWLIGOjg4+/fRT5OTkwMvLC0ePHoWlpWWRPj8iIiIqX5Sex0lLSwujR4+GkZFRofWWLVtWJIGVdpzHiYiIqHwotnmcrl69Cj09vQK3F3WPFBEREVFpolLitHfvXtjY2BRXLERERESlmtJ31bE3iYiIiCo6pROn4rirjoiIiKgsUTpx2rhxI8zNzYszFiIiIqJSTekxToGBgcUZBxEREVGpp3SPExEREVFFx8SJiIiISElMnIiIiIiUpNI8Tu96/fo1kpKSIBaLZcqrVav20UERERERlUYqJ05xcXEYMWIETp06JVMuCAJEIhHy8/OLLDgiIiKi0kTlxGnYsGHQ0dFBZGQk7O3tOTEmERERVRgqJ06XLl3ChQsXULt27eKIh4iIiKjUUnlweN26dfH8+fPiiIWIiIioVFM5cVq0aBGmTJmCv/76CykpKcjIyJD5ISIiIiqvRIKKi9Bpab3Ntd4f21TRBodnZGTA3Nwc6enpMDMzK+lwiIiISE2qfKerPMbp2LFjagdGREREVJapnDj5+PgURxxEREREpZ5aE2CmpaXhxx9/xM2bNwEA9erVw4gRI2Bubl6kwRERERGVJioPDj9//jxcXFywfPlypKamIjU1FcuWLYOLiwsuXrxYHDESERERlQoqDw5v3bo1XF1d8cMPP0BH522HVV5eHkaOHIn79+/j+PHjxRJoacPB4UREROWDKt/pKidOhoaGiI2NlZsA88aNG2jatCmys7NVj7gMYuJERERUPqjyna7ypTozMzM8evRIrvzx48cwNTVV9XBEREREZYbKidPAgQMRFBSEnTt34vHjx3j8+DF27NiBkSNHYtCgQcURIxEREVGpoPJddd9//z1EIhGGDh2KvLw8AICuri4+//xzLFy4sMgDJCIiIiotVB7jJJGdnY179+4BAFxcXGBkZFSkgZV2HONERERUPhTrzOESRkZGaNCggbq7ExEREZU5SiVOffr0waZNm2BmZoY+ffoUWve3334rksCIiIiIShulEidzc3Ppor5mZmZyC/wSERERVQhCKbBmzRqhevXqgr6+vuDp6SmcOXOm0Pq7du0SatWqJejr6wv169cX9u/fL7NdLBYLM2fOFOzs7AQDAwOhQ4cOwp07dxQe69WrV0KjRo0EAEJsbKzSMaenpwsAhPT0dKX3ISIiotJHle90lacjaN++PdLS0uTKMzIy0L59e5UTt507dyI4OBizZs3CxYsX0ahRI/j5+SEpKUlh/VOnTmHQoEEICgpCbGws/P394e/vj2vXrknrLF68GKtWrUJ4eDjOnDkDY2Nj+Pn54dWrV3LHmzJlChwcHFSOm4iIiCogVbMykUgkJCYmypUnJiYKOjo6qh5O8PT0FMaOHSt9nJ+fLzg4OAgLFixQWH/AgAFCt27dZMq8vLyEzz77TBCEt71NdnZ2wpIlS6Tb09LSBH19fWH79u0y+/35559C7dq1hevXr7PHiYiIqIJS5Ttd6bvqrly5Iv3/jRs3kJCQIH2cn5+PqKgoVKlSRaWk7fXr17hw4QKmTZsmLdPS0oKvry9iYmIU7hMTE4Pg4GCZMj8/P0RERAAA4uPjkZCQAF9fX+l2c3NzeHl5ISYmBgEBAQCAxMREjBo1ChEREUpNpZCbm4vc3Fzp44yMDABv1+mTzGdFREREZY8q3+NKJ07u7u4QiUQQiUQKL8kZGhpi9erVSp8YAJ4/f478/HzY2trKlNva2uLWrVsK90lISFBYX5LISf4trI4gCBg2bBjGjBmDpk2b4sGDBx+MdcGCBQgNDZUrP336NIyNjT+4PxEREZVOWVlZStdVOnGKj4+HIAioUaMGzp49i8qVK0u36enpwcbGBtra2qpFWkJWr16Nly9fyvR0fci0adNkeroyMjLg6OiI5s2bcwJMIiKiMkxyFUkZSidO1atXBwCIxWLVIyqAtbU1tLW1kZiYKFOemJgIOzs7hfvY2dkVWl/yb2JiIuzt7WXquLu7AwCOHj2KmJgY6OvryxynadOmGDJkCDZv3ix3Xn19fbn6AKCjowMdHbXnESUiIqISpsr3uMp31UncuHEDUVFR2Ldvn8yPKvT09ODh4YHo6GhpmVgsRnR0NLy9vRXu4+3tLVMfAA4fPiyt7+zsDDs7O5k6GRkZOHPmjLTOqlWrcPnyZVy6dAmXLl3Cn3/+CeDtHX7z589X6TkQERFRxaFyV8n9+/fRu3dvXL16FSKRCML/L3UnmRQzPz9fpeMFBwcjMDAQTZs2haenJ1asWIGsrCwMHz4cADB06FBUqVIFCxYsAACMHz8ePj4+WLp0Kbp164YdO3bg/PnzWL9+vTSOCRMmYN68eXBzc4OzszNmzpwJBwcH+Pv7AwCqVasmE4OJiQmAt2vuVa1aVdUmISIiogpC5cRp/PjxcHZ2RnR0NJydnXH27FmkpKTg66+/xvfff69yAAMHDkRycjJCQkKQkJAAd3d3REVFSQd3P3r0CFpa/3WMtWjRAtu2bcOMGTPw7bffws3NDREREahfv760zpQpU5CVlYXRo0cjLS0NrVq1QlRUFAwMDFSOj4iIiEhCJEi6jJRkbW2No0ePomHDhjA3N8fZs2dRq1YtHD16FF9//TViY2OLK9ZSRZWVlImIiKj0UuU7XeUxTvn5+TA1NQXwNol69uwZgLeDx2/fvq1GuERERERlg8qX6urXr4/Lly/D2dkZXl5eWLx4MfT09LB+/XrUqFGjOGIkIiIiKhVUTpxmzJghnShqzpw56N69O1q3bo1KlSph586dRR4gERERUWmh8hgnRVJTU2FpaSm9s64i4BgnIiKi8qFYxzhJ3L17FwcPHkROTg6srKzUPQwRERFRmaFy4pSSkoIOHTqgZs2a6Nq1K/79918AQFBQEL7++usiD5CIiIiotFA5cZo4cSJ0dXXx6NEjGBkZScsHDhyIqKioIg2OiIiIqDRReXD4oUOHcPDgQbkZtt3c3PDw4cMiC4yIiIiotFG5xykrK0ump0kiNTVV4SK4REREROWFyolT69at8fPPP0sfi0QiiMViLF68GO3atSvS4IiIiIhKE5Uv1S1evBgdOnTA+fPn8fr1a0yZMgXXr19HamoqTp48WRwxEhEREZUKKvc41a9fH3fu3EGrVq3Qq1cvZGVloU+fPoiNjYWLi0txxEhERERUKqjU4/TmzRt07twZ4eHhmD59enHFRERERFQqqdTjpKuriytXrhRXLERERESlmsqX6j755BP8+OOPxRELERERUamm8uDwvLw8/PTTTzhy5Ag8PDxgbGwss33ZsmVFFhwRERFRaaJy4nTt2jU0adIEAHDnzh2ZbRVpkV8iIiKqeFROnI4dO1YccRARERGVekqPccrPz8eVK1eQk5Mjty0nJwdXrlyBWCwu0uCIiIiIShOlE6dffvkFI0aMgJ6entw2XV1djBgxAtu2bSvS4IiIiIhKE6UTpx9//BGTJk2Ctra23DYdHR1MmTIF69evL9LgiIiIiEoTpROn27dvo3nz5gVub9asGW7evFkkQRERERGVRkonTllZWcjIyChw+8uXL5GdnV0kQRERERGVRkonTm5ubjh16lSB20+cOAE3N7ciCYqIiIioNFI6cRo8eDBmzJihcMmVy5cvIyQkBIMHDy7S4IiIiIhKE5EgCIIyFd+8eYNOnTrhxIkT8PX1Re3atQEAt27dwpEjR9CyZUscPnwYurq6xRpwaZGRkQFzc3Okp6fDzMyspMMhIiIiNanyna504gS8TZ6WL1+Obdu2IS4uDoIgoGbNmhg8eDAmTJigcKqC8oqJExERUflQbIkT/YeJExERUfmgyne60mOciIiIiCo6Jk5ERERESioViVNYWBicnJxgYGAALy8vnD17ttD6u3fvRu3atWFgYIAGDRrgzz//lNkuCAJCQkJgb28PQ0ND+Pr6Ii4uTrr9wYMHCAoKgrOzMwwNDeHi4oJZs2bh9evXxfL8iIiIqHwo8cRp586dCA4OxqxZs3Dx4kU0atQIfn5+SEpKUlj/1KlTGDRoEIKCghAbGwt/f3/4+/vj2rVr0jqLFy/GqlWrEB4ejjNnzsDY2Bh+fn549eoVgLd3AorFYvzvf//D9evXsXz5coSHh+Pbb7/VyHMmIiKisqnEB4d7eXmhWbNmWLNmDQBALBbD0dERX375JaZOnSpXf+DAgcjKykJkZKS0rHnz5nB3d0d4eDgEQYCDgwO+/vprTJo0CQCQnp4OW1tbbNq0CQEBAQrjWLJkCdatW4f79+8rFTcHhxMREZUPqnyn66h68ODgYIXlIpEIBgYGcHV1Ra9evWBlZfXBY71+/RoXLlzAtGnTpGVaWlrw9fVFTEyMwn1iYmLkYvDz80NERAQAID4+HgkJCfD19ZVuNzc3h5eXF2JiYgpMnNLT0wuNOTc3F7m5udLHkuVn8vLykJeXV/gTJSIiolJLle9xlROn2NhYXLx4Efn5+ahVqxYA4M6dO9DW1kbt2rWxdu1afP311zhx4gTq1q1b6LGeP3+O/Px82NraypTb2tri1q1bCvdJSEhQWD8hIUG6XVJWUJ333b17F6tXr8b3339fYKwLFixAaGioXPnp06dhbGxc4H5ERERUumVlZSldV+XESdKbtHHjRml3Vnp6OkaOHIlWrVph1KhRGDx4MCZOnIiDBw+qeniNe/r0KTp37oz+/ftj1KhRBdabNm2aTE9XRkYGHB0d0bx5c16qIyIiKsMkV5GUoXLitGTJEhw+fFgmWTA3N8fs2bPRqVMnjB8/HiEhIejUqdMHj2VtbQ1tbW0kJibKlCcmJsLOzk7hPnZ2doXWl/ybmJgIe3t7mTru7u4y+z179gzt2rVDixYtsH79+kJj1dfXh76+vly5jo4OdHRUbkYiIiIqJVT5Hlf5rrr09HSFd7wlJydLMzYLCwulbu3X09ODh4cHoqOjpWVisRjR0dHw9vZWuI+3t7dMfQA4fPiwtL6zszPs7Oxk6mRkZODMmTMyx3z69Cnatm0LDw8PbNy4EVpaJX6DIREREZVyal2qGzFiBJYuXYpmzZoBAM6dO4dJkybB398fAHD27FnUrFlTqeMFBwcjMDAQTZs2haenJ1asWIGsrCwMHz4cADB06FBUqVIFCxYsAACMHz8ePj4+WLp0Kbp164YdO3bg/Pnz0h4jkUiECRMmYN68eXBzc4OzszNmzpwJBwcHaXySpKl69er4/vvvkZycLI2noJ4uIiIiIggqevnypTBy5EhBT09P0NLSErS0tAQ9PT1h1KhRQmZmpiAIghAbGyvExsYqfczVq1cL1apVE/T09ARPT0/h9OnT0m0+Pj5CYGCgTP1du3YJNWvWFPT09IR69eoJ+/fvl9kuFouFmTNnCra2toK+vr7QoUMH4fbt29LtGzduFAAo/FFWenq6AEBIT09Xeh8iIiIqfVT5Tld7HqfMzEzpnEc1atSAiYlJkSRyZQXncSIiIiofinWR3y1btiA7OxsmJiZo2LAhGjZsWOGSJiIiIqqYVE6cJk6cCBsbGwwePBh//vkn8vPziyMuIiIiolJH5cTp33//xY4dOyASiTBgwADY29tj7NixOHXqVHHER0RERFRqfNRaddnZ2di7dy+2bduGI0eOoGrVqrh3715RxldqcYwTERFR+VCsa9W9y8jICH5+fnjx4gUePnyImzdvfszhiIiIiEo1tWZ9zM7OxtatW9G1a1dUqVIFK1asQO/evXH9+vWijo+IiIio1FC5xykgIACRkZEwMjLCgAEDMHPmzAJn+SYiIiIqT1ROnLS1tbFr1y74+flBW1tbZtu1a9dQv379IguOiIiIqDRROXHaunWrzOOXL19i+/bt2LBhAy5cuMDpCYiIiKjcUntl2+PHjyMwMBD29vb4/vvv0b59e5w+fbooYyMiIiIqVVRKnBISErBw4UK4ubmhf//+MDMzQ25uLiIiIrBw4ULpor9UdqWkpODr0FCkpKSUdChlDtuONI3vOfWw3dTHtlMhcerRowdq1aqFK1euYMWKFXj27BlWr15dnLGRhqWkpCBw+nQcc3ZG4PTpFfqDoSq2HWka33PqYbupj233ltKJ04EDBxAUFITQ0FB069ZNbmA4lW2SD0RK794wb9gQKb17V+gPhirYdqRpfM+ph+2mPrbdf5QeHH7ixAn8+OOP8PDwQJ06dfDpp58iICCgOGOr0Jym7i/W46ef+RXZcf+NScsTciAePBCiew+Bew8BAIKpBWwaNoWOyFBaz8itOcy9+hZbXA8Wdvuo/Yu73YDy23akHr7n1FdRf88BH9d2fM+VLKUTp+bNm6N58+ZYsWIFdu7ciZ9++gnBwcEQi8U4fPgwHB0dYWpqWpyxUhEy9+or8+bOz8nA83O7IXZzh6hSZQgpydA6dwfW/b6DtiGXlHkX2440je859bDd1Me2K5jKd9UZGxtjxIgROHHiBK5evYqvv/4aCxcuhI2NDXr27FkcMZIGaBuawbpRf2ht2wXxnRvQ2rYL1o36V7gPhDrYdqRpfM+ph+2mPrbdf9SejgAAatWqhcWLF+PJkyfYvn17UcVEJUTywTCIvlBhPxDqYtuRpvE9px62m/rYdm991CK/Etra2vD394e/v39RHI5KkLahGaya9i/pMMokth1pGt9z6mG7qY9t95E9TkREREQVCRMnIiIiIiUxcSIiIiJSEhMnIiIiIiUxcSIiIiJSEhMnIiIiIiUxcSIiIiJSEhMnIiIiIiUxcSIiIiJSEhMnIiIiIiUxcSIiIiJSUqlInMLCwuDk5AQDAwN4eXnh7NmzhdbfvXs3ateuDQMDAzRo0AB//vmnzHZBEBASEgJ7e3sYGhrC19cXcXFxMnVSU1MxZMgQmJmZwcLCAkFBQcjMzCzy50ZERETlR4knTjt37kRwcDBmzZqFixcvolGjRvDz80NSUpLC+qdOncKgQYMQFBSE2NhY6eLC165dk9ZZvHgxVq1ahfDwcJw5cwbGxsbw8/PDq1evpHWGDBmC69ev4/Dhw4iMjMTx48cxevToYn++RCQrJSUFX4eGIiUlpaRDISL6oBJPnJYtW4ZRo0Zh+PDhqFu3LsLDw2FkZISffvpJYf2VK1eic+fOmDx5MurUqYO5c+eiSZMmWLNmDYC3vU0rVqzAjBkz0KtXLzRs2BA///wznj17hoiICADAzZs3ERUVhQ0bNsDLywutWrXC6tWrsWPHDjx79kxTT52owktJSUHg9Ok45uyMwOnTmTwRUamnU5Inf/36NS5cuIBp06ZJy7S0tODr64uYmBiF+8TExCA4OFimzM/PT5oUxcfHIyEhAb6+vtLt5ubm8PLyQkxMDAICAhATEwMLCws0bdpUWsfX1xdaWlo4c+YMevfuLXfe3Nxc5ObmSh+np6cDeHvJLy8vT/UnTwqlpqaWdAhlVllru9TUVIxdsAAveveGsa0tkqysMHjKFIRNmwYrK6uSDo+UUNbec6UJ2049xdVuGRkZAN52vnxIiSZOz58/R35+PmxtbWXKbW1tcevWLYX7JCQkKKyfkJAg3S4pK6yOjY2NzHYdHR1YWVlJ67xvwYIFCA0NlSt3dnYu6OmRGiotKukIyq4y13ZmZsCwYUBc3NsfADAxgZuHB/D/v8SodCtz77lShG2nnuJut5cvX8Lc3LzQOiWaOJUl06ZNk+npEovFSE1NRaVKlSASiUowsqKVkZEBR0dHPH78GGZmZiUdTpnCtlOPXLvNnVvSIZUZfM+ph+2mvvLadoIg4OXLl3BwcPhg3RJNnKytraGtrY3ExESZ8sTERNjZ2Sncx87OrtD6kn8TExNhb28vU8fd3V1a5/3B53l5eUhNTS3wvPr6+tDX15cps7CwKPwJlmFmZmbl6kOhSWw79bDd1Me2Uw/bTX3lse0+1NMkUaKDw/X09ODh4YHo6GhpmVgsRnR0NLy9vRXu4+3tLVMfAA4fPiyt7+zsDDs7O5k6GRkZOHPmjLSOt7c30tLScOHCBWmdo0ePQiwWw8vLq8ieHxEREZUvJX6pLjg4GIGBgWjatCk8PT2xYsUKZGVlYfjw4QCAoUOHokqVKliwYAEAYPz48fDx8cHSpUvRrVs37NixA+fPn8f69esBACKRCBMmTMC8efPg5uYGZ2dnzJw5Ew4ODvD39wcA1KlTB507d8aoUaMQHh6ON2/eYNy4cQgICFCqm46IiIgqphJPnAYOHIjk5GSEhIQgISEB7u7uiIqKkg7ufvToEbS0/usYa9GiBbZt24YZM2bg22+/hZubGyIiIlC/fn1pnSlTpiArKwujR49GWloaWrVqhaioKBgYGEjrbN26FePGjUOHDh2gpaWFvn37YtWqVZp74qWUvr4+Zs2aJXdZkj6Mbacetpv62HbqYbupj20HiARl7r0jIiIiopKfAJOIiIiorGDiRERERKQkJk5ERERESmLiRERERKQkJk5ERERESmLiRERERKQkJk5ERERESmLiRERERKQkJk5ERERESmLiRERERKQkJk5ERERESmLiRERERKQkJk5ERERESmLiRERERKQkJk5ERERESmLiRERERKQkJk5ERERESmLiRERERKQkJk5ERERESmLiRERERKQkJk5EREREStIp6QDKKrFYjGfPnsHU1BQikaikwyEiIiI1CYKAly9fwsHBAVpahfcpMXFS07Nnz+Do6FjSYRAREVERefz4MapWrVpoHSZOajI1NQXwtpHNzMxKOBoiIiJSV0ZGBhwdHaXf7YVh4qQmyeU5MzMzJk5ERETlgDJDbzg4nIiIiEhJTJyIiIiIlMTEiYiIiEhJHONUzPLz8/HmzZuSDoPUoKen98HbUomIqGJh4lRMBEFAQkIC0tLSSjoUUpOWlhacnZ2hp6dX0qEQEVEpwcSpmEiSJhsbGxgZGXGSzDJGMsHpv//+i2rVqvH1IyIiABU4cXr8+DE+/fRTJCUlQUdHBzNnzkT//v2L5Nj5+fnSpKlSpUpFckzSvMqVK+PZs2fIy8uDrq5uSYdDRESlQIVNnHR0dLBixQq4u7sjISEBHh4e6Nq1K4yNjT/62JIxTUZGRh99LCo5kkt0+fn5TJyIiAhABU6c7O3tYW9vDwCws7ODtbU1UlNTiyRxkuDlnbKNrx8REb2vzN4ydPz4cfTo0QMODg4QiUSIiIiQqxMWFgYnJycYGBjAy8sLZ8+eVXisCxcuID8/n2vPERERUaHKbOKUlZWFRo0aISwsTOH2nTt3Ijg4GLNmzcLFixfRqFEj+Pn5ISkpSaZeamoqhg4divXr12si7DKvoCS1tCkrcRIRUdlSZi/VdenSBV26dClw+7JlyzBq1CgMHz4cABAeHo79+/fjp59+wtSpUwEAubm58Pf3x9SpU9GiRYtCz5ebm4vc3Fzp44yMDABAXl4e8vLyZOrm5eVBEATpj8Tm22kqPcePFVjLQuV9hg8fjs2bN8uV+/n54cCBAwAg97xKq4+NU7K/oteYiIjKD1V+x5dI4pSbmwt9ff1iO/7r169x4cIFTJs2TVqmpaUFX19fxMTEAHj7pThs2DC0b98en3766QePuWDBAoSGhsqVnz59Wm5clEgkgqmpKbKzs2VejHyxWN2npJbMzEyV93nz5g18fX2xbt06mXI9PT3p8V69eqXWsTXtY+N8/fo1cnNzcfHixTKRKBIRkXqysrKUrquRxOnAgQPYsWMH/vnnHzx+/BhisRjGxsZo3LgxOnXqhOHDh8PBwaHIzvf8+XPk5+fD1tZWptzW1ha3bt0CAJw8eRI7d+5Ew4YNpZd0fvnlFzRo0EDhMadNm4bg4GDp44yMDDg6OqJ58+YwMzOTqfvq1Ss8evQIRkZGMDAwkJZra6UVwbNTnomJicr76OrqwtjYGC4uLgXWMTAwkB77m2++QUREBJ48eQI7OzsMHjwYISEh0rvQZs+ejd9//x1jxozB/PnzkZKSgu7du2P9+vUwNzcHAPz111/45ptvcP36dejq6qJevXrYunUrqlevDgD4/fffMWfOHNy4cQMODg4YOnQopk+fDh2dt2/fuLg4jBw5EmfPnkWNGjWwYsUKuTjV8erVK+jr68PNzU3mdSQiovJFchVJGcWaOO3duxfffPMNXr58ia5du+Kbb76Bg4MDDA0NkZqaimvXruHIkSOYO3cuhg0bhrlz56Jy5crFGZJUq1atIFahB0hfX19hL5mOjo70C/zdMpFIJP35j2bv0vqYu8IK2/fd52VmZoZNmzbBwcEBV69exahRo2BmZoYpU6ZI6969exe7d+/GH3/8gYyMDAQFBWHs2LHYunUr8vLy0Lt3b4waNQrbt2/H69evcfbsWWhpaUEkEuGff/5BYGAgVq1ahdatW+PevXsYPXo0RCIRZs2aBbFYjL59+8LW1hZnzpxBeno6JkyYIBenum0gEokUvsZERFR+qPI7vli/DRYvXozly5ejS5cuCtf8GjBgAADg6dOnWL16NbZs2YKJEyd+9Hmtra2hra2NxMREmfLExETY2dl99PHLu8jISLmemm+//RbffvutXN0ZM2ZI/+/k5IRJkyZhx44d0sQJeNtz8/PPP6NKlSoAgNWrV6Nbt25YunQp9PT0kJ6eju7du0t7uerUqSPdNzQ0FFOnTkVgYCAAoEaNGpg7dy6mTJmCWbNm4ciRI7h16xYOHjwo7bX87rvvCh3/RlRepKSk4Ls1a/DtuHGcbJdIQ4o1cZKMJ/qQKlWqYOHChUV2Xj09PXh4eCA6Ohr+/v4A3i6hER0djXHjxn3UscPCwhAWFob8/PwiiLR0ateundwYJysrK4V1d+7ciVWrVuHevXvIzMxEXl6e3KXLatWqSZMmAPD29oZYLMbt27fh4+ODYcOGwc/PDx07doSvry8GDBggnWPr8uXLOHnyJObPny/dPz8/H69evUJ2djZu3rwJR0dHmUu93t7eH90GRKVdSkoKAqdPx7MWLXB7+nRsnj+fyRORBpTZ6QgyMzNx6dIlXLp0CQAQHx+PS5cu4dGjRwCA4OBg/PDDD9i8eTNu3ryJzz//HFlZWdK77NQ1duxY3LhxA+fOnfvYp1BqGRsbw9XVVeZHUeIUExODIUOGoGvXroiMjERsbCymT5+O169fq3S+jRs3IiYmBi1atMDOnTtRs2ZNnD59GsDb1zk0NFT6Wl+6dAlXr15FXFwcxx1RhSVJmlJ694Z5w4ZI6d377eOUlJIOjajc09jAjb59+8LT0xPffPONTPnixYtx7tw57N69W6XjnT9/Hu3atZM+lgzcDgwMxKZNmzBw4EAkJycjJCQECQkJcHd3R1RUlNyAcVLfqVOnUL16dUyfPl1a9vDhQ7l6jx49wrNnz6S9QqdPn4aWlhZq1aolrdO4cWM0btwY06ZNg7e3N7Zt24bmzZujSZMmuH37NlxdXRXGUKdOHTx+/Bj//vuvtJdKknQRadKmW2nFduwDP67Cxej90sfJL9Pwql9faD1+Ajx+AgAQW1rBpXkLVDa1kNZr0qEbugR9VeTxDKtt8cE6ROWVxhKn48ePY/bs2XLlXbp0wdKlS1U+Xtu2bT94i/i4ceM++tJcRZSbm4uEhASZMh0dHVhbW8uUubm54dGjR9ixYweaNWuG/fv3Y+/evXLHMzAwQGBgIL7//ntkZGTgq6++woABA2BnZ4f4+HisX78ePXv2hIODA27fvo24uDgMHToUABASEoLu3bujWrVq6NevH7S0tHD58mVcu3YN8+bNg6+vL2rWrInAwEAsWbIEGRkZMokcUXnQJegrmQQo80UqNoR9h0yvltC1scWbpESY/BWDkT8fgIml4svqRFQ0NJY4ZWZmShdNfZeurq5KtwGWtI8Z41RW/kqLioqS9t5I1KpVSzqVg0TPnj0xceJEjBs3Drm5uejWrRtmzpwplyC7urqiT58+6Nq1K1JTU9G9e3esXbsWwNuFkG/duoXNmzcjJSUF9vb2GDt2LD777DMAbyfejIyMxJw5c7Bo0SLo6uqidu3aGDlyJIC383Pt3bsXQUFB8PT0hJOTE1atWoXOnTsXU+sQlTwTSyuMHPstNoR9h7Q2LWFx/CRGjv2WSRORBogEDc3s5+npie7duyMkJESmfPbs2fjjjz9w4cIFTYRRZDIyMmBubo709HSF8zjFx8fD2dm5wo/DmT17NiIiIqRj0coSvo6kiuK8VFeQzBepiNz5I7oPDNJo0lRW/ggkUlZh3+nv01iP08yZM9GnTx/cu3cP7du3BwBER0dj+/btKo9vIiKitz1PAWMml3QYRBWKxhKnHj16ICIiAt999x327NkDQ0NDNGzYEEeOHIGPj4+mwiAiIiJSm8Yu1ZU3vFRX/vF1JFWUxKW6ksJLdVTeqHKpTqPzOKWlpWHDhg349ttvkZqaCgC4ePEinj59qskwPkpYWBjq1q2LZs2alXQoREREpGEaS5yuXLmCmjVrYtGiRViyZAnS0tIAAL/99humTZumqTA+WkWYAJPUk5KSgq9DQzkJIRFROaaxMU7BwcEYNmwYFi9eDFNTU2l5165dMXjwYE2FQfTRoqOjcfToUZmy7Oxs/H7hAlLatsXe3r3Ry8MDRkZGMnXat2+PDh06aDJUIiIqYhpLnM6dO4f//e9/cuVVqlSRm2yRqDTr0KGDTAIkWf7CPDgYL168gHmTJoiLisLmGTO4dhgRUTmjscRJX19f4USXd+7cQeXKlTUVBlUQz3PyPvoYb3LzkPlGjL33M5Cr9arAejvCl+FWEy9om1bC65RUZJhWwosmXhgyd5lGbhXnQF0iIs3R2Binnj17Ys6cOXjz5g0AQCQS4dGjR/jmm2/Qt29fTYVBVOS6DwyCxfGTyEtOAgDkJSfB4vhJdB8YVMKRERFRUdNYj9PSpUvRr18/2NjYICcnBz4+PkhISIC3tzfmz5+vqTA+2scsuULlw42Yv3HzzHGZMlsdPTxdsRxi33bIPnIMtWs3xMHNYTJ16ni1QV1vzllGRFSWaXwep5MnT+Ly5cvIzMxEkyZN4Ovrq8nTFxl15nFymrr//cMUqwcLu6m13+PHjzFr1ixERUXh+fPnsLe3h7+/P0JCQjQ+Zqdt27Zwd3fHihUrVNqvaC7VvcKTRw9xV6cycrXk11l8H5e/qNg4jxNR2VUql1yRaNmyJVq2bAkA0ikJqPS4f/8+vL29UbNmTWzfvh3Ozs64fv06Jk+ejAMHDuD06dOwsuJCoopw+QsiovJPY2OcFi1ahJ07d0ofDxgwAJUqVUKVKlVw+fJlTYVBHzB27Fjo6enh0KFD8PHxQbVq1dClSxccOXIET58+xfTp0wG8HaMWEREhs6+FhQU2bdokffzNN9+gZs2aMDIyQo0aNTBz5kzpGDfg7QLA7u7u+OWXX+Dk5ARzc3MEBATg5cuXAIBhw4bh77//xsqVKyESiSASifDgwQNs2rQJFhYWMueOiIiASCSSPl48bw7aenlg6+aNcK9ZA9UrW2DK+HHIz8/H6mXfo65TVdSp7oBlixYUbQMSEVG5prEep/DwcGzduhUAcPjwYRw+fBgHDhzArl27MHnyZBw6dEhToVABUlNTcfDgQcyfPx+GhoYy2+zs7DBkyBDs3LkTa9euVep4pqam2LRpExwcHHD16lWMGjUKpqammDJlirTOvXv3EBERgcjISLx48QIDBgzAwoULMX/+fKxcuRJ37txB/fr1MWfOHABQ6Q7MB/H3EX3oIHb+HokH9+9jxJCBeBAfDxc3N+w7FI2zp2Mwfswo+LRrDw9PL6WPS+pRNP8VAOTk5CAuLg5ubm5y7zuA818RUemiscQpISEBjo6OAIDIyEgMGDAAnTp1gpOTE7y8+KVVGsTFxUEQBNSpU0fh9jp16uDFixdITk5W6ngzZsyQ/t/JyQmTJk3Cjh07ZBInsViMTZs2SSdF/fTTTxEdHY358+fD3Nwcenp6MDIygp2dncrPRxCLsSr8B5iYmqJWnbpo2aYt7sXdwY6IP6ClpQXXmrWwetn3OHH8byZOGvD+/FcScXFxGD16ND7//HO4ubmVQGRERMrTWOJkaWmJx48fw9HREVFRUZg3bx4AQBAE3qFWynzofgE9vQ8PlAaAnTt3YtWqVbh37x4yMzORl5cnN+jOyclJZiZ5e3t7JCUlqR60Ao7VnWDyzrEr29pAW1sbWlr/XaGubGOD58lFcz4iIir/NDbGqU+fPhg8eDA6duyIlJQUdOnSBQAQGxsLV1dXTYXx0crzIr+urq4QiUS4efOmwu03b95E5cqVYWFhAZFIJJdgvTt+KSYmBkOGDEHXrl0RGRmJ2NhYTJ8+Ha9fv5bZR1dXV+axSCSCWCwuNE4tLa1Czy2hoyP7d4FIJFLrfERERBIaS5yWL1+OcePGoW7dujh8+DBMTEwAAP/++y+++OILTYXx0crzIr+VKlVCx44dsXbtWuTk5MhsS0hIwNatWzFs2DAAb8ca/fvvv9LtcXFxyM7Olj4+deoUqlevjunTp6Np06Zwc3PDw4cPVY5JT09PrkeycuXKePnyJbKysqRlly5dUvnYREREqtLYpTpdXV1MmjRJrnzixImaCoGUsGbNGrRo0QJ+fn6YN2+ezHQENWvWREhICIC3A3bXrFkDb29v5Ofn45tvvpHpzXFzc8OjR4+wY8cONGvWDPv378fevXtVjsfJyQlnzpzBgwcPYGJiAisrK3h5ecHIyAjffvstvvrqK5w5c0bmbj4iIqLiUqyJ0+nTp9G8eXOl6mZnZyM+Ph716tUrzpBKlLoTUmqSm5sbzp07h9mzZ2PAgAFISkqCIAjo06cPfvnlFxgZGQF4OxP88OHD0bp1azg4OGDlypW4cOGC9Dg9e/bExIkTMW7cOOTm5qJbt26YOXMmZs+erVI8kyZNQmBgIOrWrYucnBzEx8fDyckJW7ZsweTJk/HDDz+gQ4cOmD17NkaPHl2UTUFERCSnWGcOd3NzQ40aNTBy5Eh07doVxsbGcnVu3LiBLVu2YOPGjVi0aBGGDh1aXOEUKXVmDi+rZs2ahWXLluHw4cNKJ8IlrSRmDi8pZX0W57Nnz6LviBH49aef4OnpWdLhqI0zhxOVXarMHF6sY5xu3LiBbt26YcaMGbCwsEC9evXQsWNH9OjRA61atYK1tTWaNGmC+Ph4HDp0qMwkTRVNaGgoVq1ahdOnT3MgNRWplJQUfLN6NdL8/fHN6tVISUkp6ZCIiAqlsbXqzp8/jxMnTuDhw4fIycmBtbU1GjdujHbt2pXJJTwqUo9TWcQep9IvJSUFgdOn42nnznjw4gWcLC1RJSoKm+fP1/iaiEWBPU5EZVepXKuuadOmaNq0qaZOR0Rq0lQCsCN8GW418YK2aSW8TklFhmklvGjihSFzl2lszT8mAESkKo1NR1BelOd5nIg0qfvAIFgcP4m8/5+ANC85CRbHT6L7wKASjoyIqGBMnFSkyjxOGroKSsVE8vLxVSweJpZWGDn2Wxju3oP8e/dguHsPRo79FiaWZe/SPRFVHEycioFkPqN3J4Sksic/7zXEApAv0i7pUMotE0sr9B84Eka/7kX/gSOZNBFRqaexMU4Viba2NiwsLKRrrhkZGUEkEpVwVBXLm9yPGxwuCALSUp7jJfSQz78vipWxmQVsLSrB2MyipEMhIvqgEkmcXr16Ve7vNrOzswOAIluwllST+ebjp014LQYS9GwBJr1ERPT/NJY4icVizJ8/H+Hh4UhMTMSdO3dQo0YNzJw5E05OTggKKl8DQkUiEezt7WFjY6NwAdrS6sWLF1i/dStGDxkCS0vLkg5HbXvvZ3zU/gJEeCPSgcCkiYiI3qGxxGnevHnYvHkzFi9ejFGjRknL69evjxUrVpS7xElCW1sb2tqlb4xMdHQ0jh49KlOWnZ2N3y9cQErbttg8cCB6eXhIl1iRaN++PTp06KDJUNWSq/WqpEMgIqJySGOJ088//4z169ejQ4cOGDNmjLS8UaNGuHXrlqbCoP/XoUMHmQRIMhmheXAwXrx4AfMmTRAXFYXNM2aUyckIiYhIfYr+uAaAnJwcxMXFwc3NDYaGhnLby8of1x9DY4nT06dP4erqKlcuFovL1KUsTasokxFyIkIiotLj/T+uJSRrS86cObNMry35MTR2u1DdunXxzz//yJXv2bMHjRs31lQYVABORkhERIXh2pJvaazHKSQkBIGBgXj69CnEYjF+++033L59Gz///DMiIyM1FQYVQDIZ4ZrvpyO/Vg0Y3r6PkZPmc14dIiKSDudI69sXOi9eIK1pUwROn15m15b8GBpLnHr16oU//vgDc+bMgbGxMUJCQtCkSRP88ccf6Nixo6bC+GhhYWEICwtDfn5+SYfyUW7E/I2bZ47LldvrGCJ1XyTs63ng4OYwue11vNqgrrePJkIkIqJCaHJhaQ7n+I9G53Fq3bo1Dh8+rMlTFrmxY8di7Nix0pWUy6q63j5MgIiISCndBwYhIew7vDAzA/B2OIfl8ZPoPvbbEo5M80pkAszMzEyIxbITFJr9/4tBROVTQb2cr3NyoG9kjGPbf4Segrt02MtJVPI4nOM/Gkuc4uPjMW7cOPz111949eq/OXYEQYBIJCrzl76IqHDs5SQq2yRrS4bN/BL9566ukEkToMHE6ZNPPoEgCPjpp59ga2vLtduIiIjKGK4tqcHE6fLly7hw4QJq1aqlqVMSERGRGnhpvWAaS5yaNWuGx48fM3EiIiIq5XhpvWAaS5w2bNiAMWPG4OnTp6hfvz50dXVltjds2FBToRARERGpRWOJU3JyMu7du4fhw4dLy0QiEQeHExFRsShovbXU1FQcPH0afs2bw8pKfoBzRVhvjdSnscRpxIgRaNy4MbZv387B4UREVOwUrbeWkpKCfhMmILlbN9x6+BB75s2rcDNf08fRWOL08OFD7Nu3T+FCv0RERMWNy4ZQUdBY4tS+fXtcvnyZiRMREcnQ1NIhJb1sCFC6lg4h9WgscerRowcmTpyIq1evokGDBnKDw3v27KmpUIiIqALisiFUFDSWOI0ZMwYAMGfOHLltHBxORETFjcuGUFHQ0tSJxGJxgT9MmoiISBMky4YY/boX/QeOZNJEKiuRRX7LsrCwMISFhTHZIyIq5Qqb/bqaQzWc3f8rLh39U257RZj9mtRXrInTqlWrMHr0aBgYGGDVqlWF1v3qq6+KM5QiM3bsWIwdOxYZGRkwNzcv6XCIiKgAnP2aikOxJk7Lly/HkCFDYGBggOXLlxdYTyQSlZnEiYiIiCquYk2c4uPjcfz4cbRo0QLx8fHFeSoiIiKiYlfsg8PbtWuH1NTU4j4NERERUbEr9sRJEITiPgURERGRRmhkOgKuS0dERETlgUamIxg2bBj09fULrfPbb79pIhQiIiIitWkkcTI1NYWhoaEmTkVERERUbDSSOK1atQo2NjaaOBURERFRsSn2MU4c30RERETlBe+qIyIiIlJSsSdOx44dg5UVF1EkIiKisq/Yxzj5+HCdICIiIiofNDKPExEREVF5wMSJiIiISElMnIiIiIiUpJF5nCTEYjHu3r2LpKQkiMVimW1t2rTRZChEREREKtNY4nT69GkMHjwYDx8+lJuiQCQSIT8/X1OhEBEREalFY4nTmDFj0LRpU+zfvx/29vacGJOIiIjKHI0lTnFxcdizZw9cXV01dUoiIiKiIqWxweFeXl64e/eupk6nlN69e8PS0hL9+vUr6VCIiIioDNBYj9OXX36Jr7/+GgkJCWjQoAF0dXVltjds2FBToUiNHz8eI0aMwObNmzV+biIiIip7NJY49e3bFwAwYsQIaZlIJIIgCCU2OLxt27b466+/NH5eIiIiKps0dqkuPj5e7uf+/fvSf1V1/Phx9OjRAw4ODhCJRIiIiJCrExYWBicnJxgYGMDLywtnz54tgmdCREREFZXGepyqV69epMfLyspCo0aNMGLECPTp00du+86dOxEcHIzw8HB4eXlhxYoV8PPzw+3bt2FjY1OksRAREVHFoNEJMO/du4cVK1bg5s2bAIC6deti/PjxcHFxUflYXbp0QZcuXQrcvmzZMowaNQrDhw8HAISHh2P//v346aefMHXqVJXPl5ubi9zcXOnjjIwMAEBeXh7y8vJUPp6yBAgfrlQOFHUbVpR2A9h2H6Mo247tpj62nXrYbiVzfI0lTgcPHkTPnj3h7u6Oli1bAgBOnjyJevXq4Y8//kDHjh2L7FyvX7/GhQsXMG3aNGmZlpYWfH19ERMTo9YxFyxYgNDQULny06dPw9jYWO1YPyTTuEaxHbs0OXnySpEer6K0G8C2+xhF2XZsN/Wx7dTDdis6WVlZStfVWOI0depUTJw4EQsXLpQr/+abb4o0cXr+/Dny8/Nha2srU25ra4tbt25JH/v6+uLy5cvIyspC1apVsXv3bnh7eys85rRp0xAcHCx9nJGRAUdHRzRv3hxmZmZFFvv77t99WWzHLk1aurcs0uNVlHYD2HYfoyjbju2mPradethuRUdyFUkZGkucbt68iV27dsmVjxgxAitWrNBUGDKOHDmidF19fX3o6+vLlevo6EBHp/iaUYSKMcN6UbdhRWk3gG33MYqy7dhu6mPbqYftVjLH19hddZUrV8alS5fkyi9dulTkg7Wtra2hra2NxMREmfLExETY2dkV6bmIiIio4tBYj9OoUaMwevRo3L9/Hy1atADwdozTokWLZC6BFQU9PT14eHggOjoa/v7+AACxWIzo6GiMGzfuo44dFhaGsLAwLkpMRERUAWkscZo5cyZMTU2xdOlS6aBtBwcHzJ49G1999ZXKx8vMzJRZwiU+Ph6XLl2ClZUVqlWrhuDgYAQGBqJp06bw9PTEihUrkJWVJb3LTl1jx47F2LFjkZGRAXNz8486FhEREZUtGkucRCIRJk6ciIkTJ+Lly7cD2kxNTdU+3vnz59GuXTvpY0mvVWBgIDZt2oSBAwciOTkZISEhSEhIgLu7O6KiouQGjBMREREpS6PzOEl8TMIk0bZtWwhC4XNYjBs37qMvzRERERFJFGvi1KRJE0RHR8PS0hKNGzeGSFTwHQAXL14szlCKDMc4ERERVVzFmjj16tVLegt/r169Ck2cygqOcSIiIqq4ijVxmjVrlvT/s2fPLs5TERERERU7jc3jVKNGDaSkpMiVp6WloUaNijNtPBEREZVdGkucHjx4oHBcUG5uLp48eaKpMIiIiIjUVux31e3bt0/6/4MHD8qMC8rPz0d0dDScnZ2LO4wiw8HhREREFVexJ06SmbtFIhECAwNltunq6sLJyQlLly4t7jCKDAeHExERVVzFnjiJxWIAgLOzM86dOwdra+viPiURERFRsdDYBJjx8fGaOhURERFRsdBY4jRnzpxCt4eEhGgoEiIiIiL1aCxx2rt3r8zjN2/eID4+Hjo6OnBxcWHiRERERKWexhKn2NhYubKMjAwMGzYMvXv31lQYH4131REREVVcGpvHSREzMzOEhoZi5syZJRmGSsaOHYsbN27g3LlzJR0KERERaViJJk4AkJ6ejvT09JIOg4iIiOiDNHapbtWqVTKPBUHAv//+i19++QVdunTRVBhEREREatNY4rR8+XKZx1paWqhcuTICAwMxbdo0TYVBREREpDbO40RERESkJI2NcUpPT0dqaqpceWpqKjIyMjQVBhEREZHaNJY4BQQEYMeOHXLlu3btQkBAgKbC+GhhYWGoW7cumjVrVtKhEBERkYZpLHE6c+YM2rVrJ1fetm1bnDlzRlNhfDROR0BERFRxaSxxys3NRV5enlz5mzdvkJOTo6kwiIiIiNSmscTJ09MT69evlysPDw+Hh4eHpsIgIiIiUpvG7qqbN28efH19cfnyZXTo0AEAEB0djXPnzuHQoUOaCoOIiIhIbRrrcWrZsiViYmJQtWpV7Nq1C3/88QdcXV1x5coVtG7dWlNhEBEREalNYz1OAODu7o5t27Zp8pRERERERUaja9Xdu3cPM2bMwODBg5GUlAQAOHDgAK5fv67JMIiIiIjUorHE6e+//0aDBg1w5swZ/Prrr8jMzAQAXL58GbNmzdJUGB+N8zgRERFVXBpLnKZOnYp58+bh8OHD0NPTk5a3b98ep0+f1lQYH43zOBEREVVcGkucrl69it69e8uV29jY4Pnz55oKg4iIiEhtGkucLCws8O+//8qVx8bGokqVKpoKg4iIiEhtGl2r7ptvvkFCQgJEIhHEYjFOnjyJSZMmYejQoZoKg4iIiEhtGkucvvvuO9SuXRuOjo7IzMxE3bp10aZNG7Ro0QIzZszQVBhEREREatPYPE56enr44YcfEBISgqtXryIzMxONGzeGm5ubpkIgIiIi+iga63E6duwYAMDR0RFdu3bFgAEDpEnT//73P02FQURERKQ2jSVOnTt3xuTJk/HmzRtp2fPnz9GjRw9MnTpVU2EQERERqU2jPU579+5Fs2bNcOPGDezfvx/169dHRkYGLl26pKkwiIiIiNSmscSpRYsWuHTpEurXr48mTZqgd+/emDhxIv766y9Ur15dU2EQERERqU2ja9XduXMH58+fR9WqVaGjo4Pbt28jOztbkyF8NC65QkREVHFpLHFauHAhvL290bFjR1y7dg1nz55FbGwsGjZsiJiYGE2F8dG45AoREVHFpbHEaeXKlYiIiMDq1athYGCA+vXr4+zZs+jTpw/atm2rqTCIiIiI1KaxeZyuXr0Ka2trmTJdXV0sWbIE3bt311QYRERERGrTWI/T+0nTu+rUqaOpMIiIiIjUVuyJk5GREZKTk6WPu3XrJrPYb2JiIuzt7Ys7DCIiIqKPVuyJ06tXryAIgvTx8ePHkZOTI1Pn3e1EREREpZVGpyMoiEgkKukQiIiIiD6oVCRORERERGVBsSdOIpFIpkfp/cdEREREZUWxT0cgCAJq1qwpTZYyMzPRuHFjaGlpSbcTERERlQXFnjht3LixuE9BREREpBHFnjgFBgYW9ymIiIiINIKDw4mIiIiUxMSJiIiISElMnIiIiIiUxMRJRWFhYahbty6aNWtW0qEQERGRhjFxUtHYsWNx48YNnDt3rqRDISIiIg0r9rvqJIKDgxWWi0QiGBgYwNXVFb169YKVlZWmQiIiIiJSicYSp9jYWFy8eBH5+fmoVasWAODOnTvQ1tZG7dq1sXbtWnz99dc4ceIE6tatq6mwiIiIiJSmsUt1vXr1gq+vL549e4YLFy7gwoULePLkCTp27IhBgwbh6dOnaNOmDSZOnKipkIiIiIhUorHEacmSJZg7dy7MzMykZebm5pg9ezYWL14MIyMjhISE4MKFC5oKiYiIiEglGkuc0tPTkZSUJFeenJyMjIwMAICFhQVev36tqZCIiIiIVKLRS3UjRozA3r178eTJEzx58gR79+5FUFAQ/P39AQBnz55FzZo1NRUSERERkUo0Njj8f//7HyZOnIiAgADk5eW9PbmODgIDA7F8+XIAQO3atbFhwwZNhURERESkEo0lTiYmJvjhhx+wfPly3L9/HwBQo0YNmJiYSOu4u7trKhwiIiIilWnsUt2WLVuQnZ0NExMTNGzYEA0bNpRJmoiIiIhKO40lThMnToSNjQ0GDx6MP//8E/n5+Zo6NREREVGR0Fji9O+//2LHjh0QiUQYMGAA7O3tMXbsWJw6dUpTIRARERF9FI0lTjo6OujevTu2bt2KpKQkLF++HA8ePEC7du3g4uKiqTCIqJTJfJGKHeFLkPkitaRDKXPYduphu6mPbVdCi/waGRnBz88PXbp0gZubGx48eFASYZAC/FCoj22nuswXqdgQ9h1u1XXFhrDv2HYqYNuph+2mPrbdWxq7qw4AsrOzsXfvXmzduhXR0dFwdHTEoEGDsGfPHk2GQQWQfCjS2rREQth3GDn2W5hYctFlZbDtVCdps8x+vWFoY4tMGxtsYNsphW2nHrab8m7E/I2bZ45LH79+lYNLcdeQO2gQ8nS1kNbcA3MnDYO7W33oGRhK69XxaoO63j4lEbLGaCxxCggIQGRkJIyMjDBgwADMnDkT3t7emjo9vYcfiqJT0X4Zz950Uq39ch5cwqtHV/57/CIe+X26QfQ8FUJCAkQ6ehCqOyJ4RAAMLZ2l9QyqNYShk7t6sQ5rqdZ+xUHddgOA9DO/IjvutPRxnpAD8eCBED17Cjx7CgAQ7K0xvl8H6Ij++7wauTWHuVdf1WMtRe0G8D2nro95z+U8uIZXj57891jSdgYmEHJfQ2RggpdtO+DYb/tl2u5s2jUY3lY9tShN7fYhGkuctLW1sWvXLvj5+UFbW1tm27Vr11C/fn1NhVJulKUPBVC6Phj8Eit5+iYOyNm3H8KnQwAzEwipqRDt2w99E4eSDq3UMffqK/Peyc/JwPNzuyF2c4eoUmUIKcnQOncH1v2+g7ahWSFHqtj4nlOeoZO7TPJolpOB5yd3Q1y9FkSVHd6+505ehnWniRXuPaexxGnr1q0yj1++fInt27djw4YNuHDhAqcn0DB+KNTHLzH1vP+eA/6/7f7cjXy/dtA++Des2/P9pgxtQzNYN+qP59t2/X/bHYN1o/5su/fwPVd0+J77j8YHhx8/fhyBgYGwt7fH999/j/bt2+P06dMf3pGKleRDobVtF8R3bkBr264K+6FQFdtOfZK2M4i+wDZTEdtOPWw39bHt3tJI4pSQkICFCxfCzc0N/fv3h5mZGXJzcxEREYGFCxeiWbNmmghDTmRkJGrVqgU3NzeukQd+KD4G20592oZmsGrKNlMH2049bDf1se00kDj16NEDtWrVwpUrV7BixQo8e/YMq1evLu7TflBeXh6Cg4Nx9OhRxMbGYsmSJUhJSSnpsEocPxTqY9sREZV/xZ44HThwAEFBQQgNDUW3bt3kBoaXlLNnz6JevXqoUqUKTExM0KVLFxw6dKikwyIiIqJSrNgTpxMnTuDly5fw8PCAl5cX1qxZg+fPn3/0cY8fP44ePXrAwcEBIpEIERERcnXCwv6vvTuPq6L6/wf+GkD2XVnEUDBFxARUXIBScYn8mLmkuJUoLmniEpqJJogb5hZuablnbn00LUvpqySuuOGeWyjmxqKiXAFBgfn94Y/5eL2Al+3OBV7Px+M+cs6cOfOe08377syZM8vh5OQEQ0NDtG7dGidPnpT23b9/H3Xq1JG269Spg3v37pU5LiIiIqq6KjxxatOmDVatWoWkpCR89tln2Lp1KxwcHJCfn499+/bh6dOnpWo3MzMTHh4eWL58eaH7t23bhpCQEISHh+PMmTPw8PCAv78/UlNTy3I5REREVI1pbDkCExMTBAUFISgoCNeuXcOaNWswd+5cTJ48GZ07d8Zvv/1Wova6dOmCLl26FLl/0aJFGD58OIYMGQIAWLlyJf744w+sXbsWkydPhoODg9II071799CqVasi28vJyUFOTo60rVAoALycK5Wbm1ui2EtChFhhbWtacddS3n1YXfoNYN8VR5N9x36ruPNVJvzOlY6mv3NlaV+jr1wp0KhRI8ybNw+RkZHYvXs31q5dW67tP3/+HPHx8QgNDZXKdHR00KlTJ8TFxQEAWrVqhUuXLuHevXuwsLDA3r17MW3atCLbjIyMREREhEr58ePHYWJiUq7xvyrDpH6Fta1pGRkZRe47evRCkftKda5q0m8A+644muw79lsZzse+K9252G/lJjMzU+26siROBXR1ddGjRw/06NGjXNt9+PAh8vLyYGdnp1RuZ2eHq1evAgD09PSwcOFC+Pn5IT8/H5MmTULNmjWLbDM0NBQhISHStkKhgKOjI9q0aQNz84p7iupmQuluZWojU1PTIvf5epbv6tjVpd8A9l1xNNl37LfSY9+VDvut/BTcRVKHrImT3D766CN89NFHatU1MDCAgYGBSrmenh709CquGwUIFda2phV3LeXdh9Wl3wD2XXE02Xfst4o7X2XC71zpaPo7V5b2Nb5yuCbUqlULurq6SElJUSpPSUmBvb29TFERERFRZVclEyd9fX20aNECMTExUll+fj5iYmLg7e1dpraXL18ONzc32VY7JyIiIvlU2lt1GRkZSEhIkLYTExNx7tw5WFtbo27duggJCUFgYCC8vLzQqlUrREVFITMzU3rKrrRGjx6N0aNHQ6FQwMLCoqyXQURERJVIpU2cTp8+DT8/P2m7YOJ2YGAg1q9fj759++LBgwcICwtDcnIyPD09ER0drTJhnIiIiEhdlTZxat++PUSx+HUfgoODERwcrKGIiIiIqKqrknOcKhLnOBEREVVfTJxKaPTo0bh8+TJOnToldyhERESkYUyciIiIiNRUaec4ya1gflVJVhstjbz8vAptX5OKu5by7sfq0m8A+644muw79lvFna8y4XeudDT9nSuq/TfNnQYAQVSnFqm4e/cuHB0d5Q6DiIiIysmdO3fw1ltvFVuHiVMp5efn4/79+zAzM4MgVJ1l7wvewXfnzp0KfQdfVcS+Kx32W+mx70qH/VZ6VbXvRFHE06dP4eDgAB2d4mcx8VZdKeno6LwxK63MzM3Nq9R/FJrEvisd9lvpse9Kh/1WelWx79Rd1JqTw4mIiIjUxMSJiIiISE1MnEiJgYEBwsPDYWBgIHcolQ77rnTYb6XHvisd9lvpse84OZyIiIhIbRxxIiIiIlITEyciIiIiNTFxIiIiIlITEyciIiIiNTFxIiIiIlITEyciIiIiNTFxIiIiIlITEyciIiIiNTFxIiIiIlITEyciIiIiNTFxIiIiIlITEyciIiIiNTFxIiIiIlITEyciIiIiNTFxIiIiIlITEyciIiIiNTFxIiIiIlITEyciIiIiNTFxIiIiIlITEyciIiIiNTFxIiIiIlKTntwBVFb5+fm4f/8+zMzMIAiC3OEQERFRKYmiiKdPn8LBwQE6OsWPKTFxKqX79+/D0dFR7jCIiIionNy5cwdvvfVWsXWYOJWSmZkZgJedbG5uLnM0REREVFoKhQKOjo7Sb3txmDiVUsHtOXNzcyZOREREVYA6U284OZyIiIhITUyciIiIiNTExImIiIhITZzjRERE1UpeXh5evHghdxikQTVq1ICurm65tMXEiYiIqgVRFJGcnIwnT57IHQrJwNLSEvb29mVee5GJExERVQsFSZOtrS2MjY25eHE1IYoisrKykJqaCgCoXbt2mdpj4kRERFVeXl6elDTVrFlT7nBIw4yMjAAAqampsLW1LdNtO04OJyKiKq9gTpOxsbHMkZBcCv7dl3V+GxMnIiKqNnh7rvoqr3/3TJyIiIiI1MTEiYiIqBpwcnJCVFSUtC0IAnbt2gUAuHXrFgRBwLlz52SJrTKpEpPDDx06hPnz5yM+Ph5JSUnYuXMnevToUewxsbGxCAkJwd9//w1HR0d8/fXXGDx4sEbiJSIi7bH+6hONnWuwq2XJjxk8GE+ePJGSnAKxsbHw8/PD48ePYWlZ8nZf5ejoiKSkJNSqVatM7VQHVWLEKTMzEx4eHli+fLla9RMTE9G1a1f4+fnh3LlzGD9+PIYNG4Y///yzgiMlIiLSPrq6urC3t4eenvzjKdq+OGmVSJy6dOmCWbNmoWfPnmrVX7lyJZydnbFw4UI0btwYwcHB6N27N7799tsKjpSIiKhiHDlyBO+99x6MjIzg6OiIsWPHIjMzU61jX79VFxsbC0EQEBMTAy8vLxgbG8PHxwfXrl1TOm7WrFmwtbWFmZkZhg0bhsmTJ8PT01OpzurVq9G4cWMYGhrC1dUV3333ncp5t23bhnbt2sHQ0BCbNm0qUz9UNPlTSxnExcWhU6dOSmX+/v4YP358kcfk5OQgJydH2lYoFACA3Nxc5ObmVkicRERUPnJzcyGKovRR9vp2xVE9d+mPLdgWRREJCQn44IMPMHPmTKxZswYPHjzAmDFjEBwcjLVr1yod82o7r/fJ69tTp07FggULYGNjg1GjRiEoKAhHjhwBAGzatAmzZ8/G8uXL4evri61bt2LRokVwdnaWjt+0aRPCwsKwdOlSNGvWDGfPnsWIESNgbGyMwMBAqd7kyZOxYMECNGvWDIaGhmXqp+L6TxTFQn+3S/I7Xi0Tp+TkZNjZ2SmV2dnZQaFQ4NmzZ9JCWa+KjIxERESESvnx48dhYmJSYbESEVHZCYIAMzMzZGVlqfxI5uXnayyOjIyMEh/z4sUL/P777zAzM1Mqz8vLk9qcOXMmAgICMGzYMAAvV8eeO3cuunTpgnnz5knJSE5OjlIM2dnZyMjIkEamsrKykJGRgWfPngF4mTi1aNECADB27Fj06dMHDx8+hKGhIRYvXoxPP/0Uffr0AQCEhIQgOjoamZmZ0jnCwsIwa9YsvP/++wCA999/H59//jlWrFiBjz/+WDrvyJEjpTql7ac3ef78OXJycnDmzBmVxEzdkTmgmiZOpREaGoqQkBBpW6FQwNHREW3atIG5ubmMkRER0ZtkZ2fj9u3bMDY2hqGhodI+XZ0nGovD1NS0xMfUqFEDfn5+Sre4AODEiRP49NNPYWpqisuXL+PChQv4+eefpf2iKCI/Px8PHjxA48aNIQgCDAwMlGIwNDSEqampNABgbGwMU1NTaQChdevWUv369esDeJlc1apVCwkJCQgODlZqr02bNjhw4ABMTU2RmZmJxMREBAcHY+zYsVKd3NxcWFhYKJ3X19e3VH1TEtnZ2TAwMEDDhg1VvgMFd5HUUS0TJ3t7e6SkpCiVpaSkwNzcvNDRJgAwMDCAgYGBSrmenp5WTKYjIqKi6enpQRAE6aNMc4tilnYRRhMTEzRs2FCp7N69e1KbGRkZ+Oyzz5QSlAJ169aVzvv69b/eJ69v6+vrS3/W0Xk5LVoUxWLbK/hnwSjOqlWr0Lp1a6WYdHV1lY41NTWt8MVJC85X2O92SX7Hq+Uvvre3N/bs2aNUtm/fPnh7e8sUERERUek1b94cly9fRoMGDTR2zkaNGuHUqVMYNGiQVHbq1Cnpz3Z2dnBwcMDNmzcxcOBAjcVV0apE4pSRkYGEhARpOzExEefOnYO1tTXq1q2L0NBQ3Lt3Dz/++COAl/dSly1bhkmTJiEoKAh//fUXfv75Z/zxxx9yXQIREVGpffXVV2jTpg2Cg4MxbNgwmJiY4PLly9i3bx+WLVtWIeccM2YMhg8fDi8vL/j4+GDbtm24cOGCdEsPACIiIjB27FhYWFjggw8+QE5ODk6fPo3Hjx8rTX+pTKpE4nT69Gn4+flJ2wX/MgIDA7F+/XokJSXh9u3b0n5nZ2f88ccf+OKLL7B48WK89dZbWL16Nfz9/TUeOxERUVm5u7vj4MGDmDp1Kt577z2Iooi3334bffv2rbBzDhw4EDdv3sTEiRORnZ2NgIAADB48GCdPnpTqDBs2DMbGxpg/fz6+/PJLmJiYoGnTpsU+xa7tBLEinvmrBhQKBSwsLJCens7J4UREWi47OxuJiYlwdnZWmRhM5adz586wt7fHxo0b5Q5FRXHfgZL8pleJESciIiLSrKysLKxcuRL+/v7Q1dXFli1bsH//fuzbt0/u0CoUEyciIiIqMUEQsGfPHsyePRvZ2dlo1KgRduzYobLAdFXDxImIiIhKzMjICPv375c7DI1j4lRNxcTE4K+//lIpT0tLw5/Hj8O/TRtYW1ur7O/QoQM6duyoiRCJiIi0DhOnaqpjx44qCdCjR4/Qe/x4POjaFVf//RfbZ81CzZo1ZYqQiIhI++jIHQBph0ePHiFw6lQ8+fhj6L39Np58/DECp07Fo0eP5A6NiIhIa3DESUutv/qkQtu/HHcQV04ckrb//vssHvl3Ap6+fMHjTT0D3HyrLlr26IMmTZpJ9Rq3bgs373YVFtdgV8sKa5uIiKismDhVU27e7ZQSIP/HaVi9fA5S6zkhQwRMANhevYlh81bD1Ep1rhMREVF1xFt1BAAwtbLGsNFToP/TZuT/ewv6P23GsNFTmDQRERG9gokTKRHz84GzZ1/+k4iIqBRiY2MhCAKePHkCAFi/fj0sLS0r9JyDBw9Gjx49KvQcAG/VVVuvz3F6nv0M5/65hKy+faAjAGkiMHPiYHg2fAf6hkZSvYqe40REpGlOkzX3gvdbc7uW+JjBgwdjw4YNiIyMxOTJk6XyXbt2oWfPnqgMb07r27cv/vOf/8gdRrlg4lSJTV9/tAxH6wGWHaSttNP/RfaHfSDYvQ0x7R6eW9dBzod9EBcTD2uv//2HfvEagGulO+/0wb5liJeIqPoyNDTEN998g88++wxWVlbl0ubz58+hr69fLm29iZGREYyMjN5csRLgrToCAFg08YfunwcgPnoIABAfPYTunwdg0cRf5siIiKhTp06wt7dHZGRkkXV27NiBJk2awMDAAE5OTli4cKHSficnJ8ycORODBg2Cubk5RowYId1C+/3339GoUSMYGxujd+/eyMrKwoYNG+Dk5AQrKyuMHTsWeXl5UlsbN26El5cXzMzMYG9vjwEDBiA1NbXI2F6/Vefk5ARBEFQ+Be7cuYOAgABYWlrC2toa3bt3x61bt6T9eXl5CAkJgaWlJWrWrIlJkyZpbOSNiRMBAHSNzFHLow90ftoKMfEmdH7ailoefaBrVPxboomIqOLp6upizpw5WLp0Ke7evauyPz4+HgEBAejXrx8uXryI6dOnY9q0aVi/fr1SvQULFsDDwwNnz57FtGnTALx8We+SJUuwdetWREdHIzY2Fj179sSePXuwZ88ebNy4Ed9//z22b98utfPixQvMnDkT58+fx65du3Dr1i0MHjxY7es5deoUkpKSkJSUhLt376JNmzZ47733pLb9/f1hZmaGw4cP4+jRozA1NcUHH3yA58+fAwAWLlyI9evXY+3atThy5AjS0tKwc+fOEvZq6ch2qy48PBxBQUGoV6+eXCHQa3SNzGHVoBNSNy+HVYfRTJpK6NGjR5izbBmmBAdzxXUiKnc9e/aEp6cnwsPDsWbNGqV9ixYtQseOHaVkyMXFBZcvX8b8+fOVEpoOHTpgwoQJ0vbhw4fx4sULrFixAm+//TYAoHfv3ti4cSNSUlJgamoKNzc3+Pn54cCBA+jbty8AICgoSGqjfv36WLJkCVq2bImMjAyYmpq+8VpsbGykP48bNw5JSUk4deoUAGDbtm3Iz8/H6tWrpVGodevWwdLSErGxsXj//fcRFRWF0NBQ9OrVCwCwcuVK/Pnnn2r3ZVnIljj9+uuvmD17Ntq1a4ehQ4fi448/hoGBgVzhVDvPbp1D9u0LKuXiixwYGNZE5pVDyEo4obLfsK47jJw8NRBh5VKw8vp9Hx9cmzoVG2bPZvJEROXum2++QYcOHTBx4kSl8itXrqB79+5KZb6+voiKikJeXh50dXUBAF5eXiptGhsbS0kTANjZ2cHJyUkpAbKzs1O6FRcfH4/p06fj/PnzePz4MfL//5PYt2/fhpubm9rX88MPP2DNmjU4duyYlEydP38eCQkJMDMzU6qbnZ2NGzduID09HUlJSWjdurW0T09PD15eXhq5XSdb4nTu3DmcPXsW69atw7hx4zB69Gj069cPQUFBaNmypVxhVRtGTp5MgErp9RckZ2VlYffZs8js3x8vACQ1a4bWH3+Mbs2awdjYWKrHFyQTUVm1bdsW/v7+CA0NLdGtsQImJiYqZTVq1FDaFgSh0LKC5CgzMxP+/v7w9/fHpk2bYGNjg9u3b8Pf31+6laaOAwcOYMyYMdiyZQvc3d2l8oyMDLRo0QKbNm1SOebVkSq5yPpUXbNmzdCsWTMsXLgQu3fvxrp16+Dr6wtXV1cMHToUgwcPhoWFhZwhUiVT0a+qAQDUaYGGn7aQNreunI/cAYEwfrsBkm/9A4sGbsgdEIgrlxPQ79MvpXp3Kjg+vq6GqHqYO3cuPD090ahRI6mscePGOHpU+Ynno0ePwsXFRRptKi9Xr17Fo0ePMHfuXDg6OgIATp8+XaI2EhIS0Lt3b0yZMkW63VagefPm2LZtG2xtbWFuXviUkdq1a+PEiRNo27YtACA3Nxfx8fFo3rx5Ka6oZLRiOQJRFPHixQs8f/4coijCysoKy5Ytw7Rp07Bq1SrpniqRNnh9DSwx+xmebViH7L598cJQHw//vgDDbdsgNnwHO6JmSvW4BhYRlYemTZti4MCBWLJkiVQ2YcIEtGzZEjNnzkTfvn0RFxeHZcuW4bvvviv389etWxf6+vpYunQpRo4ciUuXLmHmzJlvPvD/e/bsGbp164ZmzZphxIgRSE5OlvbZ29tj4MCBmD9/Prp3744ZM2bgrbfewr///otffvkFkyZNwltvvYVx48Zh7ty5aNiwIVxdXbFo0SJpsc2KJmviFB8fj3Xr1mHLli0wMDDAoEGDsHz5cjRo0AAAsHTpUowdO5aJE2mV19/zBwAdbt3A7OljgIA+EH/+L0KmL4Wd09tFtEBEVDYzZszAtm3bpO3mzZvj559/RlhYGGbOnInatWtjxowZpbqd9yY2NjZYv349pkyZgiVLlqB58+ZYsGABPvroI7WOT0lJwdWrV3H16lU4ODgo7RNFEcbGxjh06BC++uor9OrVC0+fPkWdOnXQsWNHaQRqwoQJSEpKQmBgIHR0dBAUFISePXsiPT293K/3dYIo05KjTZs2xdWrV/H+++9j+PDh6Natm8pw4sOHD2FrayvdV9UmCoUCFhYWSE9PL3IosSzUuaVTtgUwNU+dBTDLertJE7fqilp1/dlH3fAs/jSMWnjB6LfdGl91nbfqiIqWnZ2NxMREODs7w9DQUO5wSAbFfQdK8psu24hTQEAAgoKCUKdOnSLr1KpVSyuTJqr8KmTVdae3kWduiRzrOsj+0LDcVl3niutERNpDtsSpYC7T6549e4b58+cjLCxMhqiI3uz1pRzEFznI37wR4qcDIZibIvfffyBs3gTR0AGPD/0o1eNSDkRElZ9siVNERARGjhyp9Lg28PLR7oiICCZOpLUKW8oh75kCD/f8F3n+ftD98yBqdfiCC4gSEVVBsr1yRRRFpffSFDh//jysra1liIio9ApeWWMYE89X1RARVWEaH3GysrKSXubn4uKilDzl5eUhIyMDI0eO1HRYRGWma2QOa68+codBRMWQ6Xko0gLl9e9e44lTVFQURFFEUFAQIiIilBa41NfXh5OTE7y9vUvc7vLlyzF//nwkJyfDw8MDS5cuRatWrYqNY8WKFbh9+zZq1aqF3r17IzIykk9bEBFVQQUrYWdlZcHIyOgNtakqysrKAqC6UnpJaTxxCgwMBAA4OzvDx8enzBcAvHwhYEhICFauXInWrVsjKioK/v7+uHbtGmxtbVXqb968GZMnT8batWvh4+OD69evY/DgwRAEAYsWLSpzPEREpF10dXVhaWkpvW/N2Ni40OkiVPWIooisrCykpqbC0tKyzCupazRxUigU0voIzZo1w7Nnz/Ds2bNC65ZkbaRFixZh+PDhGDJkCICXb0n+448/sHbtWkyePFml/rFjx+Dr64sBAwYAAJycnNC/f3+cOKH6UlsiIqoa7O3tAUDpZbVUfVhaWkrfgbLQaOJkZWWFpKQk2NrawtLSstBsv2DSeF5enlptPn/+HPHx8QgNDZXKdHR00KlTJ8TFxRV6jI+PD3766SecPHkSrVq1ws2bN7Fnzx58+umnRZ4nJycHOTk50rZCoQDw8v04ubm5asVaEiKq3n14da6prH1ZXfsNKHvfEVUHNjY2sLa2Rm5uLuc7VROCIEBPTw+6urpF5hYl+ftTo4nTX3/9JT0xd+DAgXJp8+HDh8jLy4OdnZ1SuZ2dHa5evVroMQMGDMDDhw/x7rvvQhRF5ObmYuTIkZgyZUqR54mMjERERIRK+fHjxwt923RZZZjUL/c25ZaRkfHGOkePXnhjnWLPUU37DSh73xERVVeZmZlq19Vo4tSuXbtC/6xpsbGxmDNnDr777ju0bt0aCQkJGDduHGbOnIlp06YVekxoaChCQkKkbYVCAUdHR7Rp06ZCXrlyM+FpubcpN1NT0zfW8fUs2yrZ1bXfgLL3HRFRdVVwF0kdGk2cLlxQ//+I3d3d1apXq1Yt6OrqIiUlRak8JSWlyHuZ06ZNw6effophw4YBePnevMzMTIwYMQJTp06Fjo7q8lYGBgYwMDBQKdfT04OeXvl3o4CqN2lRnWsqa19W134Dyt53RETVVUn+/tTo37Senp4QBOGN95VLMsdJX18fLVq0QExMDHr06AEAyM/PR0xMDIKDgws9JisrSyU5Kphlz3veREREVBSNJk6JiYkV0m5ISAgCAwPh5eWFVq1aISoqCpmZmdJTdoMGDUKdOnUQGRkJAOjWrRsWLVqEZs2aSbfqpk2bhm7dupX5MUUiIiKqujSaONWrV69C2u3bty8ePHiAsLAwJCcnw9PTE9HR0dKE8du3byuNMH399dcQBAFff/017t27BxsbG3Tr1g2zZ8+ukPiIiIioapB1UsTGjRuxcuVKJCYmIi4uDvXq1UNUVBScnZ3RvXv3ErUVHBxc5K252NhYpW09PT2Eh4cjPDy8tKETUQnFxMTgr7/+Uil/9uwZ/vnnHzRs2LDQFZ07dOiAjh07aiJEIqI3ki1xWrFiBcLCwjB+/HjMnj1bmtNkaWmJqKioEidORKTdOnbsWGgC9M8//2DEiBEYNWoUGjZsKENkRETqU318TEOWLl2KVatWYerUqUrziry8vHDx4kW5wiIiIiIqkmwjTomJiWjWrJlKuYGBQYkWoiKiyqGoW3X379/HxYsXMWfOHDg4OKjs5606ItImsiVOzs7OOHfunMqE8ejoaDRu3FimqIioohR1q27fvn3YtWsXBgwYgM6dO8sQGRGR+mRLnEJCQjB69GhkZ2dDFEWcPHkSW7ZsQWRkJFavXi1XWERERERFki1xGjZsGIyMjPD1118jKysLAwYMgIODAxYvXox+/frJFRYRERFRkWRdjmDgwIEYOHAgsrKykJGRAVtbWznDISIiIiqWVrzcytjYGMbGxnKHQUREVQjXDqOKoNHEqVmzZhAE9V5YeubMmQqOhoiIqqPHjx8jLi4OtWrVKjRxIiqORhOngpfwAkB2dja+++47uLm5wdvbGwBw/Phx/P333/j88881GRYREVVBfJKTKoJGE6dXX3EybNgwjB07FjNnzlSpc+fOHU2GRUSk1XjLiUh7yLZy+H//+18MGjRIpfyTTz7Bjh07ZIiIiKhyKbjl9PjxY7lDIao2ZJscbmRkhKNHj6q8m+ro0aMwNDSUKSoiIu3DW05E2kO2xGn8+PEYNWoUzpw5g1atWgEATpw4gbVr12LatGlyhUVERFTt8fZw0WRLnCZPnoz69etj8eLF+OmnnwAAjRs3xrp16xAQECBXWERERFQEPpEo8zpOAQEBTJKIiIi0DG8PF022yeFERERElY1GR5ysra1x/fp11KpVC1ZWVsUuhpmWlqbByIiIiIjeTKOJ07fffgszMzMAQFRUlCZPTURERFRmGk2cAgMDERYWhsmTJyMwMBDAy4lmVlZWmgyDiIiIqFQ0Psdp9uzZyMjIkLbr1auHmzdvajoMItISCoUCWTVqQKFQyB0KEdEbaTxxEkWx2G0iqj4ePXqE+Vu2IO+TTzB/yxY8evRI7pCIiIrFp+qISBaPHj1C4NSpUPTpA8HZGYo+fRA4dSqTJyLSahpfx0kQBDx9+hSGhoYQRRGCICAjI0NlmN7c3FzToRFVa+uvPtHo+bauXISrzVsj39wa+SmpyDC3xqXmrTFw5iL0G/mlRmMZ7Gqp0fMRUeWl8cRJFEW4uLgobTdr1kxpWxAE5OXlaTo0ItKgD/sORfLyOUju1A6ijoDnKcmwP3QUH46eIndoRERF0njidODAAU2fkoi0kKmVNfp/MgoRUz6D2LsXFGvX44s538PUylru0IiIiqTxxKldu3YV0u7y5csxf/58JCcnw8PDA0uXLpVeHlyYJ0+eYOrUqfjll1+QlpaGevXqISoqCv/5z38qJD4iUpbxOA1bfloB82HD8ez/omE+bDi2/LQCw0ZPYfJERFpL1nfVlZdt27YhJCQEK1euROvWrREVFQV/f39cu3YNtra2KvWfP3+Ozp07w9bWFtu3b0edOnXw77//wtLSUvPBE1Uy09cfLZd20k7/F9kdWwAWdoCfH9Is7JDWxANTps2AtVefcjnH9MG+5dIOEVGBKvFU3aJFizB8+HAMGTIEbm5uWLlyJYyNjbF27dpC669duxZpaWnYtWsXfH194eTkhHbt2sHDw0PDkRNVXxZN/KH75wGIjx4CAMRHD6H75wFYNPGXOTIioqJV+hGn58+fIz4+HqGhoVKZjo4OOnXqhLi4uEKP+e233+Dt7Y3Ro0fj119/hY2NDQYMGICvvvoKurq6hR6Tk5ODnJwcabvgKcDc3Fzk5uaW4xW9JKLqrW+lzjWVtS+ra78Bla/vdI3MUcujD1J/Wg34ekDn6HnU8h4GXaPye6JWU30nl9zcXIiiWGF/D1VV7LfSq6p9V5JrqfSJ08OHD5GXlwc7Ozulcjs7O1y9erXQY27evIm//voLAwcOxJ49e5CQkIDPP/8cL168QHh4eKHHREZGIiIiQqX8+PHjMDExKfuFvCbDpH65tym3V1eML8rRoxfKdo5q2m9A5ew7XSNzmDu0wsMNq2Dedni5Jk2A5vpOLpcvX0ZeXh4uX74MY2NjucOpNNhvpVdV+y4zM1PturIlTkFBQVi8eLH00t8CmZmZGDNmTJG32cpDfn4+bG1t8cMPP0BXVxctWrTAvXv3MH/+/CITp9DQUISEhEjbCoUCjo6OaNOmTYWsOXUz4Wm5tyk3U1PTN9bx9SzbnJTq2m9A5e07HQNjCFnZ0DEo/7+ENdV3csnKyoKuri7c3Nzg61s5r0EO7LfSq6p9V5JXPsmWOG3YsAFz585VSZyePXuGH3/8Ue3EqVatWtDV1UVKSopSeUpKCuzt7Qs9pnbt2qhRo4bSbbnGjRsjOTkZz58/h76+vsoxBgYGMDAwUCnX09ODnl75d6MAodzblJs611TWvqyu/Qaw7wqjqb6Ti56eHgRBqLC/h6oq9lvpVdW+K8m1aHxyuEKhQHp6OkRRxNOnT6FQKKTP48ePsWfPnkKfhCuKvr4+WrRogZiYGKksPz8fMTEx8Pb2LvQYX19fJCQkID8/Xyq7fv06ateuXWjSRERERATIMOJkaWkJQRAgCILSCuIFBEEodC5RcUJCQhAYGAgvLy+0atUKUVFRyMzMxJAhQwAAgwYNQp06dRAZGQkAGDVqFJYtW4Zx48ZhzJgx+OeffzBnzhyMHTu27BdIREREVZYsK4eLoogOHTpgx44dsLb+30J3+vr6qFevHhwcHErUZt++ffHgwQOEhYUhOTkZnp6eiI6OliaM3759Gzo6/xtcc3R0xJ9//okvvvgC7u7uqFOnDsaNG4evvvqqfC6SiIiIqiTZVg5PTExE3bp1IQjlM68iODgYwcHBhe6LjY1VKfP29sbx48fL5dxERERUPWg0cbpwQfmR34sXLxZZ193dvaLDISIiIioRjSZOnp6eEAQBolj8onSCICAvL09DURERERGpR6OJU2JioiZPR0RERFSuNJo41atXT5OnIyIiIipXsq1e9eOPPxa7f9CgQRqKhIiIiEg9siVO48aNU9p+8eIFsrKyoK+vD2NjYyZOREREpHU0vnJ4gcePHyt9MjIycO3aNbz77rvYsmWLXGERERERFUm2xKkwDRs2xNy5c1VGo4iIiIi0gVYlTsDLF+3dv39f7jCIiKiKUigUyKpRAwqFQu5QqBKSbY7Tb7/9prQtiiKSkpKwbNky+Pr6yhQVEVWUZ7fOIfv2BZXyvKePAEEHmZcPIvvOJZX9hnXdYeTkqYEIqTp49OgR5mzciOeffoo5Gzeiffv2qFmzptxhUSUiW+LUo0cPpW1BEGBjY4MOHTpg4cKF8gRFRBXGyMmz0AToRdo95CpSYeEdgBrWdTQfWCXGkZOSefToEfpPmoRrHToADg64Vq8e+k+ahC3z5jF5IrXJljjl5+fLdWoiokrv0aNHmL9lC/I++QTzt2yplCMn668+0ej5foyajbi6Tsh3aQTkvsALl0Y4/DgdfabOxqDxYRqNZbCrpUbPR+VHtsTpdXl5ebh48SLq1asHKysrucMhItJajx49QuDUqVD06QMhNRWK1q0ROHUqNsyeXemSJ3VMX3+0XNp5dOU+chIuQ3z7bcDSHM8fPoJw+ChOvbDEzXI6x/TBnGpS1cmWOI0fPx5NmzbF0KFDkZeXh7Zt2yIuLg7Gxsb4/fff0b59e7lCIyJSm6ZHTQBg68pFuNq8NfLNrZGfkooMc2tcat4aA2cuQr+RX2osjso2amLp2R0vTv+EnJ9+Ajp1APb/Bf1nurD06i53aFSJyPZU3fbt2+Hh4QEA2L17N27duoWrV6/iiy++wNSpU+UKi4hI633YdygsDx3F85RkiDoCnqckw/LQUXzYd6jcoWk1XSNz2Hh9ghqpGcAfe1AjNQM2Xp9A18hc7tCoEpFtxOnhw4ewt7cHAOzZswd9+vSBi4sLgoKCsHjxYrnCIqIKUtRTdeKLHOjUMMTTs3sg1DBQ2c+n6lSZWlmj/yejEDHlM4i9e0Gxdj2+mPM9TK2s5Q5N6+kamcOiri8eHloFi7bDmTRRicmWONnZ2eHy5cuoXbs2oqOjsWLFCgBAVlYWdHV15QqLiCpIUU/VUcllPE7Dlp9WwHzYcDz7v2iYDxuOLT+twLDRU5g8qUHHwBhCVjZ0DIzlDoUqIdkSpyFDhiAgIAC1a9eGIAjo1KkTAODEiRNwdXWVKywiogpRXhOcASDt9H+R3bEFYGEH+PkhzcIOaU08MGXaDFh79Slz+5zgTEXhEhgyznGaPn06Vq9ejREjRuDo0aMwMHg5RK+rq4vJkyfLFRYRkdazaOIP3T8PQHz0EAAgPnoI3T8PwKKJv8yRUVX2+uKhjx49kjskWci6HEHv3r0BANnZ2VJZYGCgXOEQEVUKukbmqOXRB6k/rQZ8PaBz9DxqeQ/jfB2qMFw89H9kS5zy8vIwZ84crFy5EikpKbh+/Trq16+PadOmwcnJCUOH8ukQIqKi6BqZw9yhFR5uWAVzTnKuVuRYAkNbFg/VhiUwZEucZs+ejQ0bNmDevHkYPny4VP7OO+8gKiqKiRMR0RtwkjMVpzzn1VX04qGVaV6dbHOcfvzxR/zwww8YOHCg0lN0Hh4euHr1qlxhERER0WssPbtD/5ku8NNPwNWrwE8/vVw81LP6LR4qW+J07949NGjQQKU8Pz8fL168kCEiIiIiKgwXD/0f2RInNzc3HD58WKV8+/btaNasmQwRERERUVEKFg/F+QuwqOtbLZMmQMbEKSwsDMHBwfjmm2+Qn5+PX375BcOHD8fs2bMRFlbyiWbLly+Hk5MTDA0N0bp1a5w8eVKt47Zu3QpBENCjR48Sn5OIiKg64bw6GROn7t27Y/fu3di/fz9MTEwQFhaGK1euYPfu3ejcuXOJ2tq2bRtCQkIQHh6OM2fOwMPDA/7+/khNTS32uFu3bmHixIl47733ynIpREREVE3IljgBwHvvvYd9+/YhNTUVWVlZOHLkCN5//32cPn26RO0sWrQIw4cPx5AhQ+Dm5oaVK1fC2NgYa9euLfKYvLw8DBw4EBEREahfv35ZL4WIiIiqAdmWI8jIyICuri6MjIyksnPnzmHatGnYs2cP8vLy1Grn+fPniI+PR2hoqFSmo6ODTp06IS4ursjjZsyYAVtbWwwdOrTQuVavy8nJQU5OjrRdsNx8bm4ucnNz1Yq1JESI5d6m3NS5prL2ZXXtN4B9VxhN9B37reLPU5nwO1c6mvrOlUe7Gk+c7ty5g4CAAJw8eRK6uroIDg7GrFmzMHLkSGzbtg09e/bEsWPH1G7v4cOHyMvLg52dnVK5nZ1dkcsaHDlyBGvWrMG5c+fUPk9kZCQiIiJUyo8fPw4TExO121FXhknVGwXLyMh4Y52jRy+U7RzVtN8A9l1hNNF37LcynId9V7pzsN/KXWZmptp1NZ44ffnll8jOzsbixYvxyy+/YPHixTh8+DBat26NGzdu4K233qrQ8z99+hSffvopVq1ahVq1aql9XGhoKEJCQqRthUIBR0dHtGnTBubm5f9kwc2Ep+XeptxMTU3fWMfXs2yLoFXXfgPYd4XRRN+x30qPfVc67LfyV5KXFms8cTp06BB++eUXtGnTBgEBAbC3t8fAgQMxfvz4UrVXq1Yt6OrqIiUlRak8JSUF9vb2KvVv3LiBW7duoVu3blJZfn4+AEBPTw/Xrl3D22+/rXKcgYGB9CLiV+np6UFPr/y7UYBQ7m3KTZ1rKmtfVtd+A9h3hdFE37HfKv48lQm/c6Wjqe9cebSr8cnhKSkpcHZ2BgDY2trC2NgYXbp0KXV7+vr6aNGiBWJiYqSy/Px8xMTEwNvbW6W+q6srLl68iHPnzkmfjz76CH5+fjh37hwcHR1LHQsRERFVbbJMDtfR0VH6s76+fpnaCwkJQWBgILy8vNCqVStERUUhMzMTQ4YMAQAMGjQIderUQWRkJAwNDfHOO+8oHW9paQkAKuVEREREr9J44iSKIlxcXCAIL4flMjIy0KxZM6VkCgDS0tLUbrNv37548OABwsLCkJycDE9PT0RHR0sTxm/fvq3SPhEREVFJaTxxWrduXYW0GxwcjODg4EL3xcbGFnvs+vXryz8gIiIiqnI0njgFBgZq+pRERERE5YL3r4iIiIjUxMSJiIiISE1MnIiIiIjUxMSJiIiISE1MnIiIiIjUJMsCmACU3vv2KkEQYGhoiAYNGqB79+6wtrbWcGREREREhZMtcTp79izOnDmDvLw8NGrUCABw/fp16OrqwtXVFd999x0mTJiAI0eOwM3NTa4wiYiIiCSy3arr3r07OnXqhPv37yM+Ph7x8fG4e/cuOnfujP79++PevXto27YtvvjiC7lCJCIiIlIiW+I0f/58zJw5E+bm5lKZhYUFpk+fjnnz5sHY2BhhYWGIj4+XK0QiIiIiJbIlTunp6UhNTVUpf/DgARQKBYCXL999/vy5pkMjIiIiKpSst+qCgoKwc+dO3L17F3fv3sXOnTsxdOhQ9OjRAwBw8uRJuLi4yBUiERERkRLZJod///33+OKLL9CvXz/k5ua+DEZPD4GBgfj2228BAK6urli9erVcIRIREREpkS1xMjU1xapVq/Dtt9/i5s2bAID69evD1NRUquPp6SlTdERERESqZLtV99NPPyErKwumpqZwd3eHu7u7UtJEREREpG1kG3H64osvMHLkSHz00Uf45JNP4O/vD11dXbnCISKiKubZrXPIvn1BpTzv6SNA0EHm5YPIvnNJZb9hXXcYOXlqIEKqjGRLnJKSkhAdHY0tW7YgICAAxsbG6NOnDwYOHAgfHx+5wiIioirCyMmz0AToRdo95CpSYeEdgBrWdTQfGFVqsiVOenp6+PDDD/Hhhx8iKysLO3fuxObNm+Hn54e33noLN27ckCs0IiKqAooacRJf5ECnhiGent0DoYaByn6OOFFxZEucXmVsbAx/f388fvwY//77L65cuSJ3SEREWoO3nEqnqBEnorKQNXEqGGnatGkTYmJi4OjoiP79+2P79u1yhkVEpFV4y4lIe8iWOPXr1w+///47jI2NERAQgGnTpsHb21uucIiIiIjeSLbESVdXFz///HOhT9NdunQJ77zzjkyRERERERVOtsRp06ZNSttPnz7Fli1bsHr1asTHxyMvL0+myIiIiIgKJ/vk8EOHDmHNmjXYsWMHHBwc0KtXLyxfvlzusIiItAafDiPSHrIkTsnJyVi/fj3WrFkDhUKBgIAA5OTkYNeuXXBzc5MjJCIircWnw4i0h8ZfudKtWzc0atQIFy5cQFRUFO7fv4+lS5dqOgwiIiKiEtN44rR3714MHToUERER6Nq1a7m9ZmX58uVwcnKCoaEhWrdujZMnTxZZd9WqVXjvvfdgZWUFKysrdOrUqdj6RERERIAMidORI0fw9OlTtGjRAq1bt8ayZcvw8OHDMrW5bds2hISEIDw8HGfOnIGHhwf8/f2RmppaaP3Y2Fj0798fBw4cQFxcHBwdHfH+++/j3r17ZYqDiIiIqjaNJ05t2rTBqlWrkJSUhM8++wxbt26Fg4MD8vPzsW/fPjx9+rTEbS5atAjDhw/HkCFD4ObmhpUrV8LY2Bhr164ttP6mTZvw+eefw9PTE66urli9ejXy8/MRExNT1ssjIiKiKky2p+pMTEwQFBSEoKAgXLt2DWvWrMHcuXMxefJkdO7cGb/99pta7Tx//hzx8fEIDQ2VynR0dNCpUyfExcWp1UZWVhZevHgBa2vrIuvk5OQgJydH2lYoFACA3Nxc5ObmqnWekhAhlnubclPnmsral9W13wD2XWE00Xfst4o/T2VSVb5zmn7Nj6a+c+XRruzLEQBAo0aNMG/ePERGRmL37t1FjhQV5uHDh8jLy4OdnZ1SuZ2dHa5evapWG1999RUcHBzQqVOnIutERkYiIiJCpfz48eMwMTFRO151ZZjUL/c25ZaRkfHGOkePqv6HWqJzVNN+A9h3hdFE37HfynAe9l3pziFjv+kYmsKwjit0DE3LtV1NfeeKkpmZqXZdrUicCujq6qJHjx7o0aOHxs45d+5cbN26FbGxsTA0NCyyXmhoKEJCQqRthUIBR0dHtGnTBubm5uUe182Ekt+y1Hampm/+D83X07dM56iu/Qaw7wqjib5jv5Ue+650NNFvml4CQ1PfuaIU3EVSh1YlTqVRq1Yt6OrqIiUlRak8JSUF9vb2xR67YMECzJ07F/v374e7u3uxdQ0MDGBgoLrAnJ6eHvT0yr8bBQjl3qbc1LmmsvZlde03gH1XGE30Hfut4s9TmfA7Vzqa+s6VR7sanxxe3vT19dGiRQulid0FE72Le2nwvHnzMHPmTERHR8PLy0sToRIREVElV+lHnAAgJCQEgYGB8PLyQqtWrRAVFYXMzEwMGTIEADBo0CDUqVMHkZGRAIBvvvkGYWFh2Lx5M5ycnJCcnAzg5VChusOFREREVP1UicSpb9++ePDgAcLCwpCcnAxPT09ER0dLE8Zv374NHZ3/Da6tWLECz58/R+/evZXaCQ8Px/Tp0zUZOhEREVUiVSJxAoDg4GAEBwcXui82NlZp+9atWxUfEBEREVU5lX6OExEREZGmMHEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1VZnEafny5XBycoKhoSFat26NkydPFlv/v//9L1xdXWFoaIimTZtiz549GoqUiIiIKqsqkTht27YNISEhCA8Px5kzZ+Dh4QF/f3+kpqYWWv/YsWPo378/hg4dirNnz6JHjx7o0aMHLl26pOHIiYiIqDKpEonTokWLMHz4cAwZMgRubm5YuXIljI2NsXbt2kLrL168GB988AG+/PJLNG7cGDNnzkTz5s2xbNkyDUdORERElYme3AGU1fPnzxEfH4/Q0FCpTEdHB506dUJcXFyhx8TFxSEkJESpzN/fH7t27SryPDk5OcjJyZG209PTAQBpaWnIzc0twxUULjcvv9zblFtu3pv7KS0trYznqJ79BrDvCqOJvmO/leU87LvSnYP9Vt4UCgUAQBTFN1cWK7l79+6JAMRjx44plX/55Zdiq1atCj2mRo0a4ubNm5XKli9fLtra2hZ5nvDwcBEAP/zwww8//PBTRT937tx5Y95R6UecNCU0NFRplCo/Px9paWmoWbMmBEGQMbLypVAo4OjoiDt37sDc3FzucCoV9l3psN9Kj31XOuy30quqfSeKIp4+fQoHB4c31q30iVOtWrWgq6uLlJQUpfKUlBTY29sXeoy9vX2J6gOAgYEBDAwMlMosLS1LF3QlYG5uXqX+o9Ak9l3psN9Kj31XOuy30quKfWdhYaFWvUo/OVxfXx8tWrRATEyMVJafn4+YmBh4e3sXeoy3t7dSfQDYt29fkfWJiIiIgCow4gQAISEhCAwMhJeXF1q1aoWoqChkZmZiyJAhAIBBgwahTp06iIyMBACMGzcO7dq1w8KFC9G1a1ds3boVp0+fxg8//CDnZRAREZGWqxKJU9++ffHgwQOEhYUhOTkZnp6eiI6Ohp2dHQDg9u3b0NH53+Caj48PNm/ejK+//hpTpkxBw4YNsWvXLrzzzjtyXYLWMDAwQHh4uMptSXoz9l3psN9Kj31XOuy30mPfAYIoqvPsHRERERFV+jlORERERJrCxImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITVUycYqMjETLli1hZmYGW1tb9OjRA9euXVOqk52djdGjR6NmzZowNTXFxx9/jJSUFJkiJiIiosqgSiZOBw8exOjRo3H8+HHs27cPL168wPvvv4/MzEypzhdffIHdu3fjv//9Lw4ePIj79++jV69eMkZNRERE2k4QRVGUO4iK9uDBA9ja2uLgwYNo27Yt0tPTYWNjg82bN6N3794AgKtXr6Jx48aIi4tDmzZtZI6YiIiItJGe3AFoQnp6OgDA2toaABAfH48XL16gU6dOUh1XV1fUrVu3yMQpJycHOTk50nZ+fj7S0tJQs2ZNCIJQwVdAREREFUUURTx9+hQODg7Q0Sn+ZlyVT5zy8/Mxfvx4+Pr64p133gEAJCcnQ19fH5aWlkp17ezskJycXGg7kZGRiIiIqOhwiYiISCZ37tzBW2+9VWydKp84jR49GpcuXcKRI0fK1E5oaChCQkKk7fT0dNStWxeJiYkwNzcva5hEREQkE4VCAWdnZ5iZmb2xbpVOnIKDg/H777/j0KFDShmkvb09nj9/jidPniiNOqWkpMDe3r7QtgwMDGBgYKBSbm1tzcSJiIioEtPTe5kOqTP1pko+VSeKIoKDg7Fz50789ddfcHZ2VtrfokUL1KhRAzExMVLZtWvXcPv2bXh7e2s6XCIiIqokquSI0+jRo7F582b8+uuvMDMzk+YtWVhYwMjICBYWFhg6dChCQkKkEaMxY8bA29ubT9QRERFRkarkcgRFDbWtW7cOgwcPBvByAcwJEyZgy5YtyMnJgb+/P7777rsib9W9TqFQwMLCAunp6bxVR0REVImV5De9SiZOmqBuJ+fl5eHFixcajIyo9GrUqAFdXV25wyAi0qiSJE5V8ladNhBFEcnJyXjy5IncoRCViKWlJezt7bk+GRFRIZg4VZCCpMnW1hbGxsb8ESKtJ4oisrKykJqaCgCoXbu2zBEREWkfJk4VIC8vT0qaatasKXc4RGozMjICAKSmpsLW1pa37YiIXlMllyOQW8GcJmNjY5kjISq5gu8t5+YREali4lSBeHuOKiN+b4mIisbEiYiIiEhNTJyoRGJjYyEIgkaeFlT3XE5OToiKiir38w8ePBg9evQo93Y16datWxAEAefOnZM7FCKiKoGTwzXIafIfGj3frbldS3VcXFwc3n33XXzwwQf44w/NxvwqHx8fJCUlwcLCAgCwfv16jB8/XmNLPCxevBhlWeZs8ODB2LBhA4CX70GytraGu7s7+vfvj8GDB0NHp3z/v2Xw4MF48uQJdu3aVa7tEhHR/3DEiVSsWbMGY8aMwaFDh3D//n1ZYnjx4gX09fVlXU/IwsJC6SXQpfHBBx8gKSkJt27dwt69e+Hn54dx48bhww8/RG5ubvkESkREGsPEiZRkZGRg27ZtGDVqFLp27Yr169e/8ZhVq1bB0dERxsbG6NmzJxYtWqSScKxYsQJvv/029PX10ahRI2zcuFFpvyAIWLFiBT766COYmJhg9uzZSrfqYmNjMWTIEKSnp0MQBAiCgOnTp0vHZ2VlISgoCGZmZqhbty5++OEHaV/B7aqff/4Z7733HoyMjNCyZUtcv34dp06dgpeXF0xNTdGlSxc8ePBAOu71W3X5+fmYN28eGjRoAAMDA9StWxezZ88utm8MDAxgb2+POnXqoHnz5pgyZQp+/fVX7N27V6lvnzx5gmHDhsHGxgbm5ubo0KEDzp8/L+2fPn06PD098f3330t9HRAQgPT0dGn/hg0b8Ouvv0r9ExsbKx1/8+ZN+Pn5wdjYGB4eHoiLiys2biIiKhwTJ1Ly888/w9XVFY0aNcInn3yCtWvXFnu76ujRoxg5ciTGjRuHc+fOoXPnzirJxM6dOzFu3DhMmDABly5dwmeffYYhQ4bgwIEDSvWmT5+Onj174uLFiwgKClLa5+Pjg6ioKJibmyMpKQlJSUmYOHGitH/hwoXw8vLC2bNn8fnnn2PUqFG4du2aUhvh4eH4+uuvcebMGejp6WHAgAGYNGkSFi9ejMOHDyMhIQFhYWFFXmtoaCjmzp2LadOm4fLly9i8eTPs7Oze2Kev69ChAzw8PPDLL79IZX369EFqair27t2L+Ph4NG/eHB07dkRaWppUJyEhAT///DN2796N6Oho6VoBYOLEiQgICJBGuJKSkuDj4yMdO3XqVEycOBHnzp2Di4sL+vfvzxEvIqJS4BwnUrJmzRp88sknAF7eZkpPT8fBgwfRvn37QusvXboUXbp0kZIYFxcXHDt2DL///rtUZ8GCBRg8eLD0Ix8SEoLjx49jwYIF8PPzk+oNGDAAQ4YMkbZv3rwp/VlfXx8WFhYQBKHQFzH/5z//kdr/6quv8O233+LAgQNo1KiRVGfixInw9/cHAIwbNw79+/dHTEwMfH19AQBDhw4tcoTt6dOnWLx4MZYtW4bAwEAAwNtvv41333230Ppv4urqigsXLgAAjhw5gpMnTyI1NRUGBgYAXvbZrl27sH37dowYMQLAyxdT//jjj6hTpw6Al33ftWtXLFy4EPb29jAyMkJOTk6h/TNx4kR07fpyzltERASaNGmChIQEuLq6lip+IqLqiiNOJLl27RpOnjyJ/v37A3g5oblv375Ys2ZNsce0atVKqez17StXrkjJSQFfX19cuXJFqczLy6vUsbu7u0t/LkiuCl4dUlidgpGipk2bKpW9fkyBK1euICcnBx07dix1jK8SRVGau3X+/HlkZGSgZs2aMDU1lT6JiYm4ceOGdEzdunWlpAkAvL29kZ+frzKyVphXr73gVSpFXSsRERWNI04kWbNmDXJzc+Hg4CCViaIIAwMDLFu2THq6raKYmJiU+tgaNWoobQuCgPz8/CLrFCQtr5e9fkyBgleRlJcrV67A2dkZwMt5ZbVr11aak1SgrJPTCxR27UVdKxERFY0jTgQAyM3NxY8//oiFCxfi3Llz0uf8+fNwcHDAli1bCj2uUaNGOHXqlFLZ69uNGzfG0aNHlcqOHj0KNze3EsWor6+PvLy8Eh1TXho2bAgjIyPExMSUua2//voLFy9exMcffwwAaN68OZKTk6Gnp4cGDRoofWrVqiUdd/v2baWnHI8fPw4dHR3pdqSc/UNEVF1wxIkAAL///jseP36MoUOHqowsffzxx1izZg1GjhypctyYMWPQtm1bLFq0CN26dcNff/2FvXv3Ki0h8OWXXyIgIADNmjVDp06dsHv3bvzyyy/Yv39/iWJ0cnJCRkYGYmJi4OHhAWNjY429D9DQ0BBfffUVJk2aBH19ffj6+uLBgwf4+++/MXTo0CKPy8nJQXJyMvLy8pCSkoLo6GhERkbiww8/xKBBgwAAnTp1gre3N3r06IF58+bBxcUF9+/fxx9//IGePXtKtzANDQ0RGBiIBQsWQKFQYOzYsQgICJDmNDk5OeHPP//EtWvXULNmzQofISQiqo444kQAXt6m69SpU6E/th9//DFOnz4tTWZ+la+vL1auXIlFixbBw8MD0dHR+OKLL2BoaCjV6dGjBxYvXowFCxagSZMm+P7777Fu3boiJ5wXxcfHByNHjkTfvn1hY2ODefPmlfg6y2LatGmYMGECwsLC0LhxY/Tt2/eN84Sio6NRu3ZtODk54YMPPsCBAwewZMkS/Prrr9DV1QXw8tbZnj170LZtWwwZMgQuLi7o168f/v33X6Wn9ho0aIBevXrhP//5D95//324u7vju+++k/YPHz4cjRo1gpeXF2xsbFRG+YiIqOwEsSxLI1djCoUCFhYWSE9Ph7m5udK+7OxsJCYmwtnZWSmBqC6GDx+Oq1ev4vDhw3KHUmVMnz4du3bt0sirU6r795eIqp/iftNfx1t1VGYLFixA586dYWJigr1792LDhg1KIyFERERVBRMnKrOTJ09i3rx5ePr0KerXr48lS5Zg2LBhcodFRERU7nirrpR4q46qKn5/iai6KcmtOk4OJyIiIlITEyciIiIiNTFxIiIiIlITEyciIiIiNTFxIiIiIlITEyciIiIiNTFxokovNjYWgiDgyZMnAID169fD0tKyQs85ePBg9OjRo0LPUR7at2+P8ePHyx0GEVGVwQUwNcj+wDmNni/Zz7NE9QcPHowNGzYgMjISkydPlsp37dqFnj17orIs+dW3b1/85z//kTWG2NhY+Pn5AXj5LjozMzPUr18fnTt3xhdffIHatWtXyPkeP35c4UkjEVF1xhEnUmJoaIhvvvkGjx8/Ltd2nz9/Xq7tFcfIyAi2trYaO19xrl27hvv37+PUqVP46quvsH//frzzzju4ePGi3KEREVEpMHEiJZ06dYK9vT0iIyOLrbdjxw40adIEBgYGcHJywsKFC5X2Ozk5YebMmRg0aBDMzc0xYsQI6Rba77//jkaNGsHY2Bi9e/dGVlYWNmzYACcnJ1hZWWHs2LHIy8uT2tq4cSO8vLxgZmYGe3t7DBgwAKmpqUXG9vqtOicnJwiCoPIpcOfOHQQEBMDS0hLW1tbo3r07bt26Je3Py8tDSEgILC0tUbNmTUyaNEnt0TdbW1vY29vDxcUF/fr1w9GjR2FjY4NRo0Yp1Vu9ejUaN24MQ0NDuLq6Kr3r79atWxAEAVu3boWPjw8MDQ3xzjvv4ODBg9L+gtEtKysrCIKAwYMHS8fn5+dj0qRJsLa2hr29PaZPn65W7EREpIqJEynR1dXFnDlzsHTpUty9e7fQOvHx8QgICEC/fv1w8eJFTJ8+HdOmTcP69euV6i1YsAAeHh44e/Yspk2bBgDIysrCkiVLsHXrVkRHRyM2NhY9e/bEnj17sGfPHmzcuBHff/89tm/fLrXz4sULzJw5E+fPn8euXbtw69YtpcTgTU6dOoWkpCQkJSXh7t27aNOmDd577z2pbX9/f5iZmeHw4cM4evQoTE1N8cEHH0ijZAsXLsT69euxdu1aHDlyBGlpadi5c2cJevV/jIyMMHLkSBw9elRK/jZt2oSwsDDMnj0bV65cwZw5czBt2jRs2LBB6dgvv/wSEyZMwNmzZ+Ht7Y1u3brh0aNHcHR0xI4dOwC8HOFKSkrC4sWLpeM2bNgAExMTnDhxAvPmzcOMGTOwb9++UsVPRFTdcY4TqejZsyc8PT0RHh6ONWvWqOxftGgROnbsKCVDLi4uuHz5MubPn6+U0HTo0AETJkyQtg8fPowXL15gxYoVePvttwEAvXv3xsaNG5GSkgJTU1O4ubnBz88PBw4cQN++fQEAQUFBUhsFLxFu2bIlMjIyYGpq+sbrsbGxkf48btw4JCUl4dSpUwCAbdu2IT8/H6tXr5ZGodatWwdLS0vExsbi/fffR1RUFEJDQ9GrVy8AwMqVK/Hnn3+q1ZeFcXV1BfBypMjW1hbh4eFYuHCh1L6zszMuX76M77//HoGBgdJxwcHB+PjjjwEAK1asQHR0NNasWSONJgEvR7hen+Pk7u6O8PBwAEDDhg2xbNkyxMTEoHPnzqW+BiKi6oojTlSob775Bhs2bMCVK1dU9l25cgW+vr5KZb6+vvjnn3+UbrF5eXmpHGtsbCwlTQBgZ2cHJycnpQTIzs5O6VZcfHw8unXrhrp168LMzAzt2rUDANy+fbtE1/TDDz9gzZo1+O2336Rk6vz580hISICZmRlMTU1hamoKa2trZGdn48aNG0hPT0dSUhJat24ttaOnp1fotamr4DafIAjIzMzEjRs3MHToUOn8pqammDVrFm7cuKF0nLe3t0oMhf37eZ27u7vSdu3atYu91UlEREXjiBMVqm3btvD390doaGiJbou9ysTERKWsRo0aStuCIBRalp+fDwDIzMyEv78//P39sWnTJtjY2OD27dvw9/cv0YTzAwcOYMyYMdiyZYtSIpGRkYEWLVpg06ZNKse8OlJVngqSHScnJ2RkZAAAVq1apZScAS9vm5aH4vqXiIhKhokTFWnu3Lnw9PREo0aNlMobN26Mo0ePKpUdPXoULi4u5fZjX+Dq1at49OgR5s6dC0dHRwDA6dOnS9RGQkICevfujSlTpki3wwo0b94c27Ztg62tLczNzQs9vnbt2jhx4gTatm0LAMjNzUV8fDyaN29e4ut59uwZfvjhB7Rt21ZKzBwcHHDz5k0MHDiw2GOPHz+uEkNwcDAAQF9fHwCURvyIiKj88VYdFalp06YYOHAglixZolQ+YcIExMTEYObMmbh+/To2bNiAZcuWYeLEieUeQ926daGvr4+lS5fi5s2b+O233zBz5ky1j3/27Bm6deuGZs2aYcSIEUhOTpY+ADBw4EDUqlUL3bt3x+HDh5GYmIjY2FiMHTtWmhw/btw4zJ07F7t27cLVq1fx+eefS4ttvklqaiqSk5Pxzz//YOvWrfD19cXDhw+xYsUKqU5ERAQiIyOxZMkSXL9+HRcvXsS6deuwaNEipbaWL1+OnTt34urVqxg9ejQeP34szf+qV68eBEHA77//jgcPHkgjWUREVL6YOFGxZsyYoXJbp3nz5vj555+xdetWvPPOOwgLC8OMGTNKfUuvODY2Nli/fj3++9//ws3NDXPnzsWCBQvUPj4lJQVXr15FTEwMHBwcULt2bekDvJxzdejQIdStWxe9evVC48aNMXToUGRnZ0sjUBMmTMCnn36KwMBAeHt7w8zMDD179lTr/I0aNYKDgwNatGiBuXPnolOnTrh06RLc3NykOsOGDcPq1auxbt06NG3aFO3atcP69evh7Oys1NbcuXMxd+5ceHh44MiRI/jtt99Qq1YtAECdOnUQERGByZMnw87OThqJIiKi8iWIlWU5aC2jUChgYWGB9PR0lVs82dnZSExMhLOzMwwNDWWKkKqKW7duwdnZGWfPnoWnp2eFn4/fXyKqbor7TX8dR5yIiIiI1FQlE6dDhw6hW7ducHBwgCAI2LVrl9L+wYMHq6wi/cEHH8gTLBEREVUaVfKpuszMTHh4eCAoKEjlKaoCH3zwAdatWydtGxgYaCo8ohJxcnKqNC9YJiKq6qpk4tSlSxd06dKl2DoGBgawt7fXUERERERUFVTJxEkdsbGxsLW1hZWVFTp06IBZs2ahZs2aRdbPyclBTk6OtK1QKAC8XE8nNzdXqW5ubi5EUZQ+RJVJwfe2sO82EVFVVJK/66pl4vTBBx+gV69ecHZ2xo0bNzBlyhR06dIFcXFxRS7gGBkZiYiICJXy48ePq6yQLQgCzMzMkJGRwR8eqnSys7ORk5ODM2fOMPEnomohMzNT7bpVfjkCQRCwc+dO9OjRo8g6N2/exNtvv439+/ejY8eOhdYpbMTJ0dERjx49Unl0MT8/Hzdv3oSuri5sbW1Ro0YN6QWyRNpKFEW8ePECqampyMvLQ/369aGjUyWfHyEiUqJQKFCzZk21liOoliNOr6tfvz5q1aqFhISEIhMnAwODQieQ6+npQU9PtRvr16+PpKQk3L9/v9zjJapIxsbGqF27tvQaFyKiqq6w3/Ei61ZgHJXG3bt38ejRI2k16fKgr6+PunXrIjc3l+8Po0pDV1cXenp6HCElIipClUycMjIykJCQIG0nJibi3LlzsLa2hrW1NSIiIvDxxx/D3t4eN27cwKRJk9CgQQP4+/uXaxyCIKBGjRoqb6cnIiKiyqlKJk6nT5+Gn5+ftB0SEgIACAwMxIoVK3DhwgVs2LABT548gYODA95//33MnDmTazkRERFRsbRqcvg///yDAwcOIDU1VeXFsmFhYTJFVbiSvNeGiIiItFdJftO1ZsRp1apVGDVqFGrVqgV7e3ulORaCIGhd4kRERETVj9YkTrNmzcLs2bPx1VdfyR0KERERUaG0ZpGWx48fo0+fPnKHQURERFQkrUmc+vTpg//7v/+TOwwiIiKiIsl6q27JkiXSnxs0aIBp06bh+PHjaNq0qcoj/GPHjtV0eERERERKZH2qztnZWa16giDg5s2bFRxNyfCpOiIioqqh0jxVl5iYKOfpiYiIiEpEa+Y4zZgxA1lZWSrlz549w4wZM2SIiIiIiEiZ1iyAqauri6SkJNja2iqVP3r0CLa2tlr3vjfeqiMiIqoaSvKbrjUjTqIoFvpi0fPnz8Pa2lqGiIiIiIiUyb4AppWVFQRBgCAIcHFxUUqe8vLykJGRgZEjR8oYIREREdFLsidOUVFREEURQUFBiIiIgIWFhbRPX18fTk5O8Pb2ljFCIiIiopdkT5wCAwMBvFyawMfHR2X9JiIiIiJtIXviVKBdu3bIy8vD9u3bceXKFQCAm5sbunfvDj09rQmTiIiIqjGtyUj+/vtvfPTRR0hOTkajRo0AAN988w1sbGywe/duvPPOOzJHSERERNWd1jxVN2zYMDRp0gR3797FmTNncObMGdy5cwfu7u4YMWKE3OERERERac+I07lz53D69GlYWVlJZVZWVpg9ezZatmwpY2REREREL2nNiJOLiwtSUlJUylNTU9GgQQMZIiIiIiJSpjWJU2RkJMaOHYvt27fj7t27uHv3LrZv347x48fjm2++gUKhkD5EREREctCaV67o6PwvhytYBLMgtFe3BUHQitev8JUrREREVUNJftO1Zo7TgQMH5A6BiIiIqFhakzi1a9dO7hCIiIiIiqU1c5wA4PDhw/jkk0/g4+ODe/fuAQA2btyII0eOyBwZERERkRYlTjt27IC/vz+MjIxw5swZ5OTkAADS09MxZ84cmaMjIiIi0qLEadasWVi5ciVWrVql9L46X19fnDlzRsbIiIiIiF7SmsTp2rVraNu2rUq5hYUFnjx5ovmAiIiIiF6jNYmTvb09EhISVMqPHDmC+vXryxARERERkTKtSZyGDx+OcePG4cSJExAEAffv38emTZswceJEjBo1Su7wiIiIiLRnOYLJkycjPz8fHTt2RFZWFtq2bQsDAwNMnDgRY8aMkTs8IiIiIu1ZObzA8+fPkZCQgIyMDLi5ucHU1FTukArFlcOJiIiqhkq5cjjw8pUqCoUCdnZ2cHNzkzscIiIiIiVaMccpOTkZgwYNgpWVFezs7GBrawsrKysEBQUhJSVF7vCIiIiIAGjBiJNCoYCPjw8yMjIwZMgQuLq6QhRFXL58GVu2bMGRI0dw5swZrb1lR0RERNWH7InT4sWLoauri7///hs2NjZK+77++mv4+vpiyZIlmDJlikwREhEREb0k+626P/74A1OmTFFJmgDA1tYWoaGh2L17twyRERERESmTPXG6fv06fHx8itzv4+ODa9euaTAiIiIiosLJnjgpFApYWloWud/S0hIKhUJzAREREREVQfbESRRF6OgUHYYgCNCypaaIiIiompJ9crgoinBxcYEgCEXuJyIiItIGsidO69atK/c2Dx06hPnz5yM+Ph5JSUnYuXMnevToIe0XRRHh4eFYtWoVnjx5Al9fX6xYsQINGzYs91iIiIio6pA9cQoMDCz3NjMzM+Hh4YGgoCD06tVLZf+8efOwZMkSbNiwAc7Ozpg2bRr8/f1x+fJlGBoalns8REREVDXInjhVhC5duqBLly6F7hNFEVFRUfj666/RvXt3AMCPP/4IOzs77Nq1C/369dNkqERERFSJVMnEqTiJiYlITk5Gp06dpDILCwu0bt0acXFxRSZOOTk5yMnJkbYLnvTLzc1Fbm5uxQZNREREFaYkv+PVLnFKTk4GANjZ2SmV29nZSfsKExkZiYiICJXy48ePw8TEpHyDJCKqBgL3ZpSofrZ/nQqKpOwM/7xXovobupT+NWLst/KXmZmpdt1qlziVVmhoKEJCQqRthUIBR0dHtGnTBubm5jJGRkRUSe39U+4IZOPr61v6g9lv5a4k60VqTeI0Y8YMTJw4EcbGxkrlz549w/z58xEWFlYu57G3twcApKSkoHbt2lJ5SkoKPD09izzOwMAABgYGKuV6enrQ09OabiQiokqAvxulU1H9VpJ2ZV8As0BERAQyMlSHH7Oysgq9RVZazs7OsLe3R0xMjFSmUChw4sQJeHt7l9t5iIiIqOrRmpRXFMVCF8E8f/48rK2tS9RWRkYGEhISpO3ExEScO3cO1tbWqFu3LsaPH49Zs2ahYcOG0nIEDg4OSms9EREREb1O9sTJysoKgiBAEASVFcTz8vKQkZGBkSNHlqjN06dPw8/PT9oumJsUGBiI9evXY9KkScjMzMSIESPw5MkTvPvuu4iOjuYaTkRERFQs2ROnqKgoiKKIoKAgREREwMLCQtqnr68PJyenEt9Ca9++fbGvahEEATNmzMCMGTNKHTcRERFVP7InTgUrhzs7O8PHxwc1atSQOSIiIiKiwsmaOCkUCulR/mbNmuHZs2d49uxZoXX5yD8RERHJTdbEycrKCklJSbC1tYWlpWWhk8MLJo3n5eXJECERERHR/8iaOP3111/SE3MHDhyQMxQiolJxmvxHiepXpVWcb83tWkGREGkvWROndu3aFfpnIiIiIm0k++TwAocOHSp2f9u2bTUUCREREVHhtCZxat++vUrZ62s6EREREclJa1658vjxY6VPamoqoqOj0bJlS/zf//2f3OERERERac+I06sLXxbo3Lkz9PX1ERISgvj4eBmiIiIiIvofrRlxKoqdnR2uXbsmdxhERERE2jPidOHCBaVtURSRlJSEuXPnwtPTU56giIiIiF6hNYmTp6cnBEFQecdcmzZtsHbtWpmiIiIiIvofrUmcEhMTlbZ1dHRgY2MDQ0NDmSIiIiIiUqY1iVO9evXkDkGrlGQ1Ym1eiRgo2WrEZV2JmKs4l151/c4BXAGbiNSnNZPDx44diyVLlqiUL1u2DOPHj9d8QERERESv0ZrEaceOHfD19VUp9/Hxwfbt22WIiIiIiEiZ1iROjx49KnQtJ3Nzczx8+FCGiIiIiIiUaU3i1KBBA0RHR6uU7927F/Xr15chIiIiIiJlWjM5PCQkBMHBwXjw4AE6dOgAAIiJicHChQsRFRUlb3BERERE0KLEKSgoCDk5OZg9ezZmzpwJAHBycsKKFSswaNAgmaMjIiIi0pLEKTc3F5s3b0avXr0watQoPHjwAEZGRjA1NZU7NCIiIiKJVsxx0tPTw8iRI5GdnQ0AsLGxYdJEREREWkcrEicAaNWqFc6ePSt3GERERERF0opbdQDw+eefY8KECbh79y5atGgBExMTpf3u7u4yRUZERET0ktYkTv369QPwcgXxAgUv/RUEAXl5eXKFRkRERARAixKn11/yS0RERKRttCZx4kt+iYiISNvJmjj99ttv6NKlC2rUqIHffvut2LofffSRhqIiIiIiKpysiVOPHj2QnJwMW1tb9OjRo8h6nONERERE2kDWxCk/P7/QPxMRERFpI61Zx4mIiIhI28meOP31119wc3ODQqFQ2Zeeno4mTZrg0KFDMkRGREREpEz2xCkqKgrDhw+Hubm5yj4LCwt89tln+Pbbb2WIjIiIiEiZ7InT+fPn8cEHHxS5//3330d8fLwGIyIiIiIqnOyJU0pKCmrUqFHkfj09PTx48ECDEREREREVTvbEqU6dOrh06VKR+y9cuIDatWtrMCIiIiKiwsmeOP3nP//BtGnTkJ2drbLv2bNnCA8Px4cffihDZERERETKZH/lytdff41ffvkFLi4uCA4ORqNGjQAAV69exfLly5GXl4epU6fKHCURERGRFiROdnZ2OHbsGEaNGoXQ0FCIogjg5Wrh/v7+WL58Oezs7GSOkoiIiEgLbtUBL1/wu2fPHjx8+BAnTpzA8ePH8fDhQ+zZswfOzs7lfr7p06dDEASlj6ura7mfh4iIiKoW2UecXmVlZYWWLVtq5FxNmjTB/v37pW09Pa3qCiIiItJC1TZb0NPTg729vdxhEBERUSVSbROnf/75Bw4ODjA0NIS3tzciIyNRt27dIuvn5OQgJydH2i54RUxubi5yc3MrPN7qgn1Zeuy70mPflQ77rfTYd6VTUf1WknarZeLUunVrrF+/Ho0aNUJSUhIiIiLw3nvv4dKlSzAzMyv0mMjISERERKiUHz9+HCYmJhUdcrVx9OhRuUOotNh3pce+Kx32W+mx70qnovotMzNT7brVMnHq0qWL9Gd3d3e0bt0a9erVw88//4yhQ4cWekxoaChCQkKkbYVCAUdHR7Rp06bQ9+yV2d4/y7/NSsDX17dsDVTTfgPYd2VRpr5jv5Ue+6502G/lruAukjqqZeL0OktLS7i4uCAhIaHIOgYGBjAwMFAp19PT48TycsS+LD32Xemx70qH/VZ67LvSqah+K0m7WrEcgdwyMjJw48YNvtqFiIiIilUtE6eJEyfi4MGDuHXrFo4dO4aePXtCV1cX/fv3lzs0IiIi0mLVcqzw7t276N+/Px49egQbGxu8++67OH78OGxsbOQOjYiIiLRYtUyctm7dKncIREREVAlVy1t1RERERKXBxImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITdU6cVq+fDmcnJxgaGiI1q1b4+TJk3KHRERERFqs2iZO27ZtQ0hICMLDw3HmzBl4eHjA398fqampcodGREREWqraJk6LFi3C8OHDMWTIELi5uWHlypUwNjbG2rVr5Q6NiIiItJSe3AHI4fnz54iPj0doaKhUpqOjg06dOiEuLq7QY3JycpCTkyNtp6enAwDS0tKQm5tbsQFXI2lpaXKHUGmx70qPfVc67LfSY9+VTkX1m0KhAACIovjmymI1dO/ePRGAeOzYMaXyL7/8UmzVqlWhx4SHh4sA+OGHH3744YefKvq5c+fOG3OIajniVBqhoaEICQmRtvPz85GWloaaNWtCEAQZIytfCoUCjo6OuHPnDszNzeUOp1Jh35UO+6302Helw34rvarad6Io4unTp3BwcHhj3WqZONWqVQu6urpISUlRKk9JSYG9vX2hxxgYGMDAwECpzNLSsqJClJ25uXmV+o9Ck9h3pcN+Kz32Xemw30qvKvadhYWFWvWq5eRwfX19tGjRAjExMVJZfn4+YmJi4O3tLWNkREREpM2q5YgTAISEhCAwMBBeXl5o1aoVoqKikJmZiSFDhsgdGhEREWmpaps49e3bFw8ePEBYWBiSk5Ph6emJ6Oho2NnZyR2arAwMDBAeHq5yW5LejH1XOuy30mPflQ77rfTYd4Agiuo8e0dERERE1XKOExEREVFpMHEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJwIArFixAu7u7tKiZt7e3ti7d6/cYVU6c+fOhSAIGD9+vNyhaL3p06dDEASlj6urq9xhVQr37t3DJ598gpo1a8LIyAhNmzbF6dOn5Q5L6zk5Oal85wRBwOjRo+UOTavl5eVh2rRpcHZ2hpGREd5++23MnDlTvfe6VUHVdjkCUvbWW29h7ty5aNiwIURRxIYNG9C9e3ecPXsWTZo0kTu8SuHUqVP4/vvv4e7uLncolUaTJk2wf/9+aVtPj38lvcnjx4/h6+sLPz8/7N27FzY2Nvjnn39gZWUld2ha79SpU8jLy5O2L126hM6dO6NPnz4yRqX9vvnmG6xYsQIbNmxAkyZNcPr0aQwZMgQWFhYYO3as3OFpHP+WIgBAt27dlLZnz56NFStW4Pjx40yc1JCRkYGBAwdi1apVmDVrltzhVBp6enpFvuaICvfNN9/A0dER69atk8qcnZ1ljKjysLGxUdqeO3cu3n77bbRr106miCqHY8eOoXv37ujatSuAlyN3W7ZswcmTJ2WOTB68VUcq8vLysHXrVmRmZvIVNGoaPXo0unbtik6dOskdSqXyzz//wMHBAfXr18fAgQNx+/ZtuUPSer/99hu8vLzQp08f2NraolmzZli1apXcYVU6z58/x08//YSgoKAq9aL2iuDj44OYmBhcv34dAHD+/HkcOXIEXbp0kTkyeXDEiSQXL16Et7c3srOzYWpqip07d8LNzU3usLTe1q1bcebMGZw6dUruUCqV1q1bY/369WjUqBGSkpIQERGB9957D5cuXYKZmZnc4WmtmzdvYsWKFQgJCcGUKVNw6tQpjB07Fvr6+ggMDJQ7vEpj165dePLkCQYPHix3KFpv8uTJUCgUcHV1ha6uLvLy8jB79mwMHDhQ7tBkwZXDSfL8+XPcvn0b6enp2L59O1avXo2DBw8yeSrGnTt34OXlhX379klzm9q3bw9PT09ERUXJG1wl8+TJE9SrVw+LFi3C0KFD5Q5Ha+nr68PLywvHjh2TysaOHYtTp04hLi5OxsgqF39/f+jr62P37t1yh6L1tm7dii+//BLz589HkyZNcO7cOYwfPx6LFi2qlsk6R5xIoq+vjwYNGgAAWrRogVOnTmHx4sX4/vvvZY5Me8XHxyM1NRXNmzeXyvLy8nDo0CEsW7YMOTk50NXVlTHCysPS0hIuLi5ISEiQOxStVrt2bZX/mWncuDF27NghU0SVz7///ov9+/fjl19+kTuUSuHLL7/E5MmT0a9fPwBA06ZN8e+//yIyMpKJE9Gr8vPzkZOTI3cYWq1jx464ePGiUtmQIUPg6uqKr776iklTCWRkZODGjRv49NNP5Q5Fq/n6+uLatWtKZdevX0e9evVkiqjyWbduHWxtbaXJzlS8rKws6OgoT4nW1dVFfn6+TBHJi4kTAQBCQ0PRpUsX1K1bF0+fPsXmzZsRGxuLP//8U+7QtJqZmRneeecdpTITExPUrFlTpZyUTZw4Ed26dUO9evVw//59hIeHQ1dXF/3795c7NK32xRdfwMfHB3PmzEFAQABOnjyJH374AT/88IPcoVUK+fn5WLduHQIDA7n8hZq6deuG2bNno27dumjSpAnOnj2LRYsWISgoSO7QZMFvDQEAUlNTMWjQICQlJcHCwgLu7u74888/0blzZ7lDoyrq7t276N+/Px49egQbGxu8++67OH78uMoj46SsZcuW2LlzJ0JDQzFjxgw4OzsjKiqq2k7ULan9+/fj9u3b1fZHvzSWLl2KadOm4fPPP0dqaiocHBzw2WefISwsTO7QZMHJ4URERERq4jpORERERGpi4kRERESkJiZORERERGpi4kRERESkJiZORERERGpi4kRERESkJiZORERERGpi4kRERESkJiZORFpAEATs2rWrQs8RGxsLQRDw5MmTCj1PgTdd061btyAIAs6dO1dsO+3bt8f48eNLfP7nz5+jQYMGOHbsWImPrSjTp0+Hp6en3GEo+eGHH+Do6AgdHR1ERUVV+PnU6YPBgwejR48epT7Hw4cPYWtri7t375a6DaKiMHEiqmDJyckYM2YM6tevDwMDAzg6OqJbt26IiYmR6iQlJaFLly4VGoePj4/0Sh0AWL9+PSwtLYs95urVqxAEAcePH1cqb9OmDQwNDZGdnS2VZWdnw9DQEGvWrAFQ8msq78Ru5cqVcHZ2ho+Pj1QmCAIMDQ3x77//KtXt0aMHBg8eXC7nrUwUCgWCg4Px1Vdf4d69exgxYkSRdX///Xe0a9cOZmZmMDY2RsuWLbF+/foKiWvx4sVKbZc0ea5VqxYGDRqE8PDw8g+Oqj0mTkQV6NatW2jRogX++usvzJ8/HxcvXkR0dDT8/PwwevRoqZ69vT0MDAyKbOfFixdljkVfXx/29vYQBEHtY1xdXWFvb4/Y2Fip7OnTpzhz5gxsbGyUEqq4uDjk5OSgQ4cOAN58TRVJFEUsW7YMQ4cOVdknCEKVe8dWab8ft2/fxosXL9C1a1fUrl0bxsbGhdZbunQpunfvDl9fX5w4cQIXLlxAv379MHLkSEycOLEsoRfKwsLijUn9mwwZMgSbNm1CWlpa+QRF9P8xcSKqQJ9//jkEQcDJkyfx8ccfw8XFBU2aNEFISIhS0vHqba2CW1jbtm1Du3btYGhoiE2bNgEA1q5diyZNmsDAwAC1a9dGcHCw0jGv3vZ68uQJBEGQkp5XR3RiY2MxZMgQpKenQxAECIKA6dOnF3oNfn5+SonTkSNH4OLigm7duimVx8bGol69enB2dla5JgA4efIkmjVrBkNDQ3h5eeHs2bPSvlu3bsHPzw8AYGVlBUEQlEaA8vPzMWnSJFhbW8Pe3r7IWAvEx8fjxo0b6Nq1q8q+4OBg/PTTT7h06VKRxzs5OanctvL09FQ6ryAI+P777/Hhhx/C2NgYjRs3RlxcHBISEtC+fXuYmJjAx8cHN27cUGn/+++/h6OjI4yNjREQEID09HSl/atXr0bjxo1haGgIV1dXfPfdd9K+4r4fr7t9+za6d+8OU1NTmJubIyAgACkpKQBejjg2bdoUAFC/fn0IgoBbt26ptHHnzh1MmDAB48ePx5w5c+Dm5oYGDRpgwoQJmD9/PhYuXIgTJ05Ibb6e8OzatavQZL24Pnj1Vt3gwYNx8OBBLF68WPqu3rp1C48fP8bAgQNhY2MDIyMjNGzYEOvWrZPaaNKkCRwcHLBz585C+4aotJg4EVWQtLQ0REdHY/To0TAxMVHZ/6b/o548eTLGjRuHK1euwN/fHytWrMDo0aMxYsQIXLx4Eb/99hsaNGhQqth8fHwQFRUFc3NzJCUlISkpqciRAz8/Pxw5cgS5ubkAgAMHDqB9+/Zo164dDhw4INU7cOCAlPy8LiMjAx9++CHc3NwQHx+P6dOnK53P0dERO3bsAABcu3YNSUlJWLx4sbR/w4YNMDExwYkTJzBv3jzMmDED+/btK/L6Dh8+DBcXF5iZmans8/X1xYcffojJkycX00PqmTlzJgYNGoRz587B1dUVAwYMwGeffYbQ0FCcPn0aoihKyW2BhIQE/Pzzz9i9ezeio6Nx9uxZfP7559L+TZs2ISwsDLNnz8aVK1cwZ84cTJs2DRs2bFBq5/Xvx+vy8/PRvXt3pKWl4eDBg9i3bx9u3ryJvn37AgD69u2L/fv3A3iZ1CYlJcHR0VGlne3bt+PFixeFfj8+++wzmJqaYsuWLSXqtzf1wasWL14Mb29vDB8+XPquOjo6Ytq0abh8+TL27t2LK1euYMWKFahVq5bSsa1atcLhw4dLFBvRm+jJHQBRVZWQkABRFOHq6lqq48ePH49evXpJ27NmzcKECRMwbtw4qaxly5alaltfXx8WFhYQBAH29vbF1vXz80NmZiZOnToFb29vxMbG4ssvv8S7776LwMBAZGdnQxRFnDx5EsOGDSu0jc2bNyM/Px9r1qyBoaEhmjRpgrt372LUqFEAAF1dXVhbWwMAbG1tVZJKd3d3ab5Kw4YNsWzZMsTExKBz586Fnu/ff/+Fg4NDkdcUGRkJd3d3HD58GO+9916x11+cIUOGICAgAADw1VdfwdvbG9OmTZMSmXHjxmHIkCFKx2RnZ+PHH39EnTp1ALy8Dda1a1csXLgQ9vb2CA8Px8KFC6V/987Ozrh8+TK+//57BAYGSu28/v14XUxMDC5evIjExEQpIfrxxx/RpEkTnDp1Ci1btkTNmjUBADY2NkV+D65fvw4LCwvUrl1bZZ++vj7q16+P69evq9Vf6vbBqywsLKCvrw9jY2Olfbdv30azZs3g5eUF4OUo4escHByURjaJygNHnIgqiCiKZTq+4AcBAFJTU3H//n107NixrGGVWIMGDfDWW28hNjYWCoUCZ8+eRbt27VC7dm3UrVsXcXFx0vymokacrly5And3dxgaGkpl3t7easfg7u6utF27dm2kpqYWWf/Zs2dK53qdm5sbBg0aVOZRp1fjsrOzAwDp9ldBWXZ2NhQKhVRWt25dKWEAXvZDfn4+rl27hszMTNy4cQNDhw6Fqamp9Jk1a5bKLb9Xvx+FuXLlChwdHZVGkdzc3GBpaYkrV66U7oKLoK+vX6L6xfWBukaNGoWtW7fC09MTkyZNKvTpSSMjI2RlZZUoNqI34YgTUQVp2LAhBEHA1atXS3X8q7f3jIyMiq2ro/Py/4FeTdbKY0J5gfbt2+PAgQNwd3dHw4YNYWtrCwDS7TpRFNGgQYNCb/WUhxo1aihtC4KA/Pz8IuvXqlULFy9eLLbNiIgIuLi4FLpkgo6OjkriW1h/vhpXwTyewsqKi/VVGRkZAIBVq1ahdevWSvt0dXWVtgu7/VsRGjZsiPT0dNy/f19lFO/58+e4ceOGNMKmbr+Vhy5duuDff//Fnj17sG/fPnTs2BGjR4/GggULpDppaWmwsbGpkPNT9cURJ6IKYm1tDX9/fyxfvhyZmZkq+0vy2L2ZmRmcnJyUljB4VcGPQ1JSklT2pvWR9PX1kZeXp9b5/fz8cOzYMezbtw/t27eXytu2bYvY2FjExsYWOdoEAI0bN8aFCxeUli94fYmDglELdWMqTrNmzXD16tViR/0cHR0RHByMKVOmqJzTxsZGqS8VCgUSExPLHBfw8hbT/fv3pe3jx49DR0cHjRo1gp2dHRwcHHDz5k00aNBA6VMw6V5djRs3xp07d3Dnzh2p7PLly3jy5Anc3NzUbqd3797Q09PDwoULVfatXLkSWVlZGDRoEICX/fb06VOl73th38Pi+qAwRX1XbWxsEBgYiJ9++glRUVH44YcflPZfunQJzZo1U+s6idTFxImoAi1fvhx5eXlo1aoVduzYgX/++QdXrlzBkiVLSnSrCni5cODChQuxZMkS/PPPPzhz5gyWLl0K4OWIVJs2bTB37lxcuXIFBw8exNdff11se05OTsjIyEBMTAwePnxY7C2NgnlOa9euRbt27aTydu3a4cSJEzh58mSxidOAAQMgCAKGDx+Oy5cvY8+ePUojAwBQr149CIKA33//HQ8ePJBGX0rDz88PGRkZ+Pvvv4utFxoaivv370uTpAt06NABGzduxOHDh3Hx4kUEBgaqjPiUlqGhIQIDA3H+/HkcPnwYY8eORUBAgDR/JyIiApGRkViyZAmuX7+OixcvYt26dVi0aFGJztOpUyc0bdoUAwcOxJkzZ3Dy5EkMGjQI7dq1e+NtvlfVrVsX8+bNQ1RUFKZOnYqrV6/ixo0bWLRoESZNmoRZs2bhnXfeAQC0bt0axsbGmDJlCm7cuIHNmzcXutbTm/rgdU5OTjhx4gRu3bqFhw8fIj8/H2FhYfj111+RkJCAv//+G7///jsaN24sHZOVlYX4+Hi8//77Jeo3ojcSiahC3b9/Xxw9erRYr149UV9fX6xTp4740UcfiQcOHJDqABB37twpiqIoJiYmigDEs2fPqrS1cuVKsVGjRmKNGjXE2rVri2PGjJH2Xb58WfT29haNjIxET09P8f/+7/9EANJ5Dhw4IAIQHz9+LB0zcuRIsWbNmiIAMTw8vNjrqFevnghATEpKUip3cnISAYj3799XKn/1mkRRFOPi4kQPDw9RX19f9PT0FHfs2KFynTNmzBDt7e1FQRDEwMBAURRFsV27duK4ceOU2u7evbu0vygBAQHi5MmTi41JFEVxzpw5IgCl9tLT08W+ffuK5ubmoqOjo7h+/XrRw8NDqY9eb6uwf2+v93l4eLjo4eEhfvfdd6KDg4NoaGgo9u7dW0xLS1OKadOmTaKnp6eor68vWllZiW3bthV/+eWXIs9TlH///Vf86KOPRBMTE9HMzEzs06ePmJycLO0/e/asCEBMTEx8Y1u7du0S33vvPdHExEQEIAIQt2zZolJv586dYoMGDUQjIyPxww8/FH/44Qfx1Z8adfogMDBQ7N69u7R97do1sU2bNqKRkZEU78yZM8XGjRuLRkZGorW1tdi9e3fx5s2b0jGbN28WGzVq9MbrIiopQRTLOIOViEgLXbhwAZ07d8aNGzdgamoqdzhVSlpaGjp27Ahzc3Ps3bu3yIUz5dSmTRuMHTsWAwYMkDsUqmJ4q46IqiR3d3d888035TY3if7H2toa+/fvR8eOHREXFyd3OCoePnyIXr16oX///nKHQlUQR5yIiIiI1MQRJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1/T+dQprUxJH0VQAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -236,7 +248,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1817,7 +1829,44 @@ "output_type": "stream", "text": [ "Monte Carlo Sampling (2) Benchmark Program - Qiskit\n", - "... execution starting at Sep 17, 2024 16:44:50 UTC\n" + "... execution starting at Sep 17, 2024 16:44:50 UTC\n", + "************\n", + "Executing [3] circuits with num_qubits = 4\n", + "************\n", + "Executing [3] circuits with num_qubits = 5\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[30], line 4\u001b[0m\n\u001b[1;32m 2\u001b[0m sys\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39minsert(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmonte-carlo/qiskit\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmc_benchmark\u001b[39;00m\n\u001b[0;32m----> 4\u001b[0m \u001b[43mmc_benchmark\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmin_qubits\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmin_qubits\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmax_qubits\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_qubits\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mskip_qubits\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mskip_qubits\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_circuits\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_circuits\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_shots\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_shots\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mbackend_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbackend_id\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprovider_backend\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprovider_backend\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[43m \u001b[49m\u001b[43mhub\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhub\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgroup\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mproject\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mproject\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mexec_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mexec_options\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/monte-carlo/qiskit/mc_benchmark.py:472\u001b[0m, in \u001b[0;36mrun\u001b[0;34m(min_qubits, max_qubits, skip_qubits, max_circuits, num_shots, epsilon, degree, num_state_qubits, method, backend_id, provider_backend, hub, group, project, exec_options, context)\u001b[0m\n\u001b[1;32m 465\u001b[0m ex\u001b[38;5;241m.\u001b[39msubmit_circuit(qc2, num_qubits, mu, num_shots)\n\u001b[1;32m 467\u001b[0m \u001b[38;5;66;03m# if method is 2, we only have one type of circuit, so break out of loop\u001b[39;00m\n\u001b[1;32m 468\u001b[0m \u001b[38;5;66;03m#if method == 2:\u001b[39;00m\n\u001b[1;32m 469\u001b[0m \u001b[38;5;66;03m# break\u001b[39;00m\n\u001b[1;32m 470\u001b[0m \n\u001b[1;32m 471\u001b[0m \u001b[38;5;66;03m# Wait for some active circuits to complete; report metrics when groups complete\u001b[39;00m\n\u001b[0;32m--> 472\u001b[0m \u001b[43mex\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mthrottle_execution\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmetrics\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfinalize_group\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 474\u001b[0m \u001b[38;5;66;03m# Wait for all active circuits to complete; report metrics when groups complete\u001b[39;00m\n\u001b[1;32m 475\u001b[0m ex\u001b[38;5;241m.\u001b[39mfinalize_execution(metrics\u001b[38;5;241m.\u001b[39mfinalize_group)\n", + "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/_common/qiskit/execute.py:1392\u001b[0m, in \u001b[0;36mthrottle_execution\u001b[0;34m(completion_handler)\u001b[0m\n\u001b[1;32m 1389\u001b[0m done = False\n\u001b[1;32m 1390\u001b[0m pollcount = 0\n\u001b[1;32m 1391\u001b[0m while not done:\n\u001b[0;32m-> 1392\u001b[0m \n\u001b[1;32m 1393\u001b[0m # check if any jobs complete\n\u001b[1;32m 1394\u001b[0m check_jobs(completion_handler)\n\u001b[1;32m 1396\u001b[0m # return only when all jobs complete\n", + "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/_common/qiskit/execute.py:1469\u001b[0m, in \u001b[0;36mcheck_jobs\u001b[0;34m(completion_handler)\u001b[0m\n\u001b[1;32m 1465\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcheck_jobs\u001b[39m(completion_handler\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m 1467\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m job, circuit \u001b[38;5;129;01min\u001b[39;00m active_circuits\u001b[38;5;241m.\u001b[39mitems():\n\u001b[0;32m-> 1469\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1470\u001b[0m \u001b[38;5;66;03m#status = job.status()\u001b[39;00m\n\u001b[1;32m 1471\u001b[0m status \u001b[38;5;241m=\u001b[39m get_job_status(job, circuit) \u001b[38;5;66;03m# use this version, robust to network failure \u001b[39;00m\n\u001b[1;32m 1472\u001b[0m \u001b[38;5;66;03m#print(\"Job status is \", status)\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/_common/qiskit/execute.py:843\u001b[0m, in \u001b[0;36mget_job_status\u001b[0;34m(job, active_circuit)\u001b[0m\n\u001b[1;32m 841\u001b[0m status \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 842\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m retry_count \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m3\u001b[39m:\n\u001b[0;32m--> 843\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 844\u001b[0m retry_count \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 845\u001b[0m \u001b[38;5;66;03m#print(f\"... calling job.status()\")\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/qiskit_ibm_runtime/runtime_job.py:193\u001b[0m, in \u001b[0;36mRuntimeJob.status\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 187\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mstatus\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m JobStatus:\n\u001b[1;32m 188\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Return the status of the job.\u001b[39;00m\n\u001b[1;32m 189\u001b[0m \n\u001b[1;32m 190\u001b[0m \u001b[38;5;124;03m Returns:\u001b[39;00m\n\u001b[1;32m 191\u001b[0m \u001b[38;5;124;03m Status of this job.\u001b[39;00m\n\u001b[1;32m 192\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 193\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_set_status_and_error_message\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 194\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_status\n", + "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/qiskit_ibm_runtime/base_runtime_job.py:207\u001b[0m, in \u001b[0;36mBaseRuntimeJob._set_status_and_error_message\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 205\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Fetch and set status and error message.\"\"\"\u001b[39;00m\n\u001b[1;32m 206\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_status \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mJOB_FINAL_STATES:\n\u001b[0;32m--> 207\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_api_client\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mjob_get\u001b[49m\u001b[43m(\u001b[49m\u001b[43mjob_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mjob_id\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 208\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_set_status(response)\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_set_error_message(response)\n", + "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/qiskit_ibm_runtime/api/clients/runtime.py:115\u001b[0m, in \u001b[0;36mRuntimeClient.job_get\u001b[0;34m(self, job_id, exclude_params)\u001b[0m\n\u001b[1;32m 106\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mjob_get\u001b[39m(\u001b[38;5;28mself\u001b[39m, job_id: \u001b[38;5;28mstr\u001b[39m, exclude_params: \u001b[38;5;28mbool\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Dict:\n\u001b[1;32m 107\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Get job data.\u001b[39;00m\n\u001b[1;32m 108\u001b[0m \n\u001b[1;32m 109\u001b[0m \u001b[38;5;124;03m Args:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 113\u001b[0m \u001b[38;5;124;03m JSON response.\u001b[39;00m\n\u001b[1;32m 114\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 115\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_api\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprogram_job\u001b[49m\u001b[43m(\u001b[49m\u001b[43mjob_id\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[43mexclude_params\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mexclude_params\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 116\u001b[0m logger\u001b[38;5;241m.\u001b[39mdebug(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mRuntime job get response: \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, response)\n\u001b[1;32m 117\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m response\n", + "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/qiskit_ibm_runtime/api/rest/program_job.py:59\u001b[0m, in \u001b[0;36mProgramJob.get\u001b[0;34m(self, exclude_params)\u001b[0m\n\u001b[1;32m 57\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m exclude_params:\n\u001b[1;32m 58\u001b[0m payload[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mexclude_params\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtrue\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m---> 59\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msession\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_url\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mself\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpayload\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mjson(\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m=\u001b[39mRuntimeDecoder)\n", + "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/requests/sessions.py:602\u001b[0m, in \u001b[0;36mSession.get\u001b[0;34m(self, url, **kwargs)\u001b[0m\n\u001b[1;32m 594\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Sends a GET request. Returns :class:`Response` object.\u001b[39;00m\n\u001b[1;32m 595\u001b[0m \n\u001b[1;32m 596\u001b[0m \u001b[38;5;124;03m:param url: URL for the new :class:`Request` object.\u001b[39;00m\n\u001b[1;32m 597\u001b[0m \u001b[38;5;124;03m:param \\*\\*kwargs: Optional arguments that ``request`` takes.\u001b[39;00m\n\u001b[1;32m 598\u001b[0m \u001b[38;5;124;03m:rtype: requests.Response\u001b[39;00m\n\u001b[1;32m 599\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 601\u001b[0m kwargs\u001b[38;5;241m.\u001b[39msetdefault(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mallow_redirects\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[0;32m--> 602\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mGET\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/qiskit_ibm_runtime/api/session.py:328\u001b[0m, in \u001b[0;36mRetrySession.request\u001b[0;34m(self, method, url, bare, **kwargs)\u001b[0m\n\u001b[1;32m 326\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 327\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_log_request_info(final_url, method, kwargs)\n\u001b[0;32m--> 328\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfinal_url\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 329\u001b[0m response\u001b[38;5;241m.\u001b[39mraise_for_status()\n\u001b[1;32m 330\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m RequestException \u001b[38;5;28;01mas\u001b[39;00m ex:\n\u001b[1;32m 331\u001b[0m \u001b[38;5;66;03m# Wrap the requests exceptions into a IBM Q custom one, for\u001b[39;00m\n\u001b[1;32m 332\u001b[0m \u001b[38;5;66;03m# compatibility.\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/requests/sessions.py:589\u001b[0m, in \u001b[0;36mSession.request\u001b[0;34m(self, method, url, params, data, headers, cookies, files, auth, timeout, allow_redirects, proxies, hooks, stream, verify, cert, json)\u001b[0m\n\u001b[1;32m 584\u001b[0m send_kwargs \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 585\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtimeout\u001b[39m\u001b[38;5;124m\"\u001b[39m: timeout,\n\u001b[1;32m 586\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mallow_redirects\u001b[39m\u001b[38;5;124m\"\u001b[39m: allow_redirects,\n\u001b[1;32m 587\u001b[0m }\n\u001b[1;32m 588\u001b[0m send_kwargs\u001b[38;5;241m.\u001b[39mupdate(settings)\n\u001b[0;32m--> 589\u001b[0m resp \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprep\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43msend_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 591\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m resp\n", + "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/requests/sessions.py:703\u001b[0m, in \u001b[0;36mSession.send\u001b[0;34m(self, request, **kwargs)\u001b[0m\n\u001b[1;32m 700\u001b[0m start \u001b[38;5;241m=\u001b[39m preferred_clock()\n\u001b[1;32m 702\u001b[0m \u001b[38;5;66;03m# Send the request\u001b[39;00m\n\u001b[0;32m--> 703\u001b[0m r \u001b[38;5;241m=\u001b[39m \u001b[43madapter\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrequest\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 705\u001b[0m \u001b[38;5;66;03m# Total elapsed time of the request (approximately)\u001b[39;00m\n\u001b[1;32m 706\u001b[0m elapsed \u001b[38;5;241m=\u001b[39m preferred_clock() \u001b[38;5;241m-\u001b[39m start\n", + "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/requests/adapters.py:667\u001b[0m, in \u001b[0;36mHTTPAdapter.send\u001b[0;34m(self, request, stream, timeout, verify, cert, proxies)\u001b[0m\n\u001b[1;32m 664\u001b[0m timeout \u001b[38;5;241m=\u001b[39m TimeoutSauce(connect\u001b[38;5;241m=\u001b[39mtimeout, read\u001b[38;5;241m=\u001b[39mtimeout)\n\u001b[1;32m 666\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 667\u001b[0m resp \u001b[38;5;241m=\u001b[39m \u001b[43mconn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43murlopen\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 668\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 669\u001b[0m \u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 670\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 671\u001b[0m \u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 672\u001b[0m \u001b[43m \u001b[49m\u001b[43mredirect\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 673\u001b[0m \u001b[43m \u001b[49m\u001b[43massert_same_host\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 674\u001b[0m \u001b[43m \u001b[49m\u001b[43mpreload_content\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 675\u001b[0m \u001b[43m \u001b[49m\u001b[43mdecode_content\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 676\u001b[0m \u001b[43m \u001b[49m\u001b[43mretries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmax_retries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 677\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 678\u001b[0m \u001b[43m \u001b[49m\u001b[43mchunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunked\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 679\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 681\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (ProtocolError, \u001b[38;5;167;01mOSError\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[1;32m 682\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mConnectionError\u001b[39;00m(err, request\u001b[38;5;241m=\u001b[39mrequest)\n", + "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/urllib3/connectionpool.py:789\u001b[0m, in \u001b[0;36mHTTPConnectionPool.urlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, preload_content, decode_content, **response_kw)\u001b[0m\n\u001b[1;32m 786\u001b[0m response_conn \u001b[38;5;241m=\u001b[39m conn \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m release_conn \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 788\u001b[0m \u001b[38;5;66;03m# Make the request on the HTTPConnection object\u001b[39;00m\n\u001b[0;32m--> 789\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_request\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 790\u001b[0m \u001b[43m \u001b[49m\u001b[43mconn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 791\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 792\u001b[0m \u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 793\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout_obj\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 794\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 795\u001b[0m \u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 796\u001b[0m \u001b[43m \u001b[49m\u001b[43mchunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunked\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 797\u001b[0m \u001b[43m \u001b[49m\u001b[43mretries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mretries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 798\u001b[0m \u001b[43m \u001b[49m\u001b[43mresponse_conn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mresponse_conn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 799\u001b[0m \u001b[43m \u001b[49m\u001b[43mpreload_content\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpreload_content\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 800\u001b[0m \u001b[43m \u001b[49m\u001b[43mdecode_content\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdecode_content\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 801\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mresponse_kw\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 802\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 804\u001b[0m \u001b[38;5;66;03m# Everything went great!\u001b[39;00m\n\u001b[1;32m 805\u001b[0m clean_exit \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/urllib3/connectionpool.py:536\u001b[0m, in \u001b[0;36mHTTPConnectionPool._make_request\u001b[0;34m(self, conn, method, url, body, headers, retries, timeout, chunked, response_conn, preload_content, decode_content, enforce_content_length)\u001b[0m\n\u001b[1;32m 534\u001b[0m \u001b[38;5;66;03m# Receive the response from the server\u001b[39;00m\n\u001b[1;32m 535\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 536\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[43mconn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgetresponse\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 537\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (BaseSSLError, \u001b[38;5;167;01mOSError\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 538\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_raise_timeout(err\u001b[38;5;241m=\u001b[39me, url\u001b[38;5;241m=\u001b[39murl, timeout_value\u001b[38;5;241m=\u001b[39mread_timeout)\n", + "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/urllib3/connection.py:464\u001b[0m, in \u001b[0;36mHTTPConnection.getresponse\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 461\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mresponse\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m HTTPResponse\n\u001b[1;32m 463\u001b[0m \u001b[38;5;66;03m# Get the response from http.client.HTTPConnection\u001b[39;00m\n\u001b[0;32m--> 464\u001b[0m httplib_response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgetresponse\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 466\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 467\u001b[0m assert_header_parsing(httplib_response\u001b[38;5;241m.\u001b[39mmsg)\n", + "File \u001b[0;32m~/.pyenv/versions/3.12.4/lib/python3.12/http/client.py:1428\u001b[0m, in \u001b[0;36mHTTPConnection.getresponse\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1426\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1427\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1428\u001b[0m \u001b[43mresponse\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbegin\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1429\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mConnectionError\u001b[39;00m:\n\u001b[1;32m 1430\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mclose()\n", + "File \u001b[0;32m~/.pyenv/versions/3.12.4/lib/python3.12/http/client.py:331\u001b[0m, in \u001b[0;36mHTTPResponse.begin\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 329\u001b[0m \u001b[38;5;66;03m# read until we get a non-100 response\u001b[39;00m\n\u001b[1;32m 330\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[0;32m--> 331\u001b[0m version, status, reason \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_read_status\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 332\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m status \u001b[38;5;241m!=\u001b[39m CONTINUE:\n\u001b[1;32m 333\u001b[0m \u001b[38;5;28;01mbreak\u001b[39;00m\n", + "File \u001b[0;32m~/.pyenv/versions/3.12.4/lib/python3.12/http/client.py:292\u001b[0m, in \u001b[0;36mHTTPResponse._read_status\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 291\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_read_status\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m--> 292\u001b[0m line \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mstr\u001b[39m(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreadline\u001b[49m\u001b[43m(\u001b[49m\u001b[43m_MAXLINE\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124miso-8859-1\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 293\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(line) \u001b[38;5;241m>\u001b[39m _MAXLINE:\n\u001b[1;32m 294\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m LineTooLong(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstatus line\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m~/.pyenv/versions/3.12.4/lib/python3.12/socket.py:708\u001b[0m, in \u001b[0;36mSocketIO.readinto\u001b[0;34m(self, b)\u001b[0m\n\u001b[1;32m 706\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[1;32m 707\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 708\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_sock\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrecv_into\u001b[49m\u001b[43m(\u001b[49m\u001b[43mb\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 709\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m timeout:\n\u001b[1;32m 710\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_timeout_occurred \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[0;32m~/.pyenv/versions/3.12.4/lib/python3.12/ssl.py:1252\u001b[0m, in \u001b[0;36mSSLSocket.recv_into\u001b[0;34m(self, buffer, nbytes, flags)\u001b[0m\n\u001b[1;32m 1248\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m flags \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 1249\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 1250\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnon-zero flags not allowed in calls to recv_into() on \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m\n\u001b[1;32m 1251\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m)\n\u001b[0;32m-> 1252\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnbytes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbuffer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1253\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1254\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39mrecv_into(buffer, nbytes, flags)\n", + "File \u001b[0;32m~/.pyenv/versions/3.12.4/lib/python3.12/ssl.py:1104\u001b[0m, in \u001b[0;36mSSLSocket.read\u001b[0;34m(self, len, buffer)\u001b[0m\n\u001b[1;32m 1102\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1103\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m buffer \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1104\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_sslobj\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbuffer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1105\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1106\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sslobj\u001b[38;5;241m.\u001b[39mread(\u001b[38;5;28mlen\u001b[39m)\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], @@ -1987,7 +2036,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.4" } }, "nbformat": 4, From c1184519e1f80d92078596e332a90430601732e4 Mon Sep 17 00:00:00 2001 From: Haimeng Zhang Date: Mon, 30 Sep 2024 14:52:10 -0400 Subject: [PATCH 18/19] revert notebook change --- benchmarks-qiskit.ipynb | 1588 +-------------------------------------- 1 file changed, 34 insertions(+), 1554 deletions(-) diff --git a/benchmarks-qiskit.ipynb b/benchmarks-qiskit.ipynb index a80c8d6a..44bc6e4b 100644 --- a/benchmarks-qiskit.ipynb +++ b/benchmarks-qiskit.ipynb @@ -12,7 +12,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -22,10 +22,10 @@ "max_circuits=3\n", "num_shots=1000\n", "\n", - "backend_id=\"ibm_brisbane\"\n", + "backend_id=\"qasm_simulator\"\n", "#backend_id=\"statevector_simulator\"\n", "\n", - "hub=\"your_hub\"; group=\"your_group\"; project=\"your_project\"\n", + "hub=\"ibm-q\"; group=\"open\"; project=\"main\"\n", "provider_backend = None\n", "exec_options = {}\n", "\n", @@ -80,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -108,155 +108,11 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Deutsch-Jozsa Benchmark Program - Qiskit\n", - "... execution starting at Sep 23, 2024 17:34:44 UTC\n", - "************\n", - "Executing [2] circuits with num_qubits = 3\n", - "************\n", - "Executing [2] circuits with num_qubits = 4\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:urllib3.connectionpool:Retrying (PostForcelistRetry(total=4, connect=3, read=None, redirect=None, status=None)) after connection broken by 'RemoteDisconnected('Remote end closed connection without response')': /runtime/jobs/cvrtdhy55th0008rvr5g?exclude_params=true\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "************\n", - "Executing [2] circuits with num_qubits = 5\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 7, 0.083\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 7, 0.071, 1.0\n", - "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.001, 12480.319, 1.296 secs\n", - "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.874, 0.831\n", - "\n", - "************\n", - "Executing [2] circuits with num_qubits = 6\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 8, 0.088\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 8, 0.071, 1.5\n", - "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.001, 6281.223, 1.753 secs\n", - "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.908, 0.895\n", - "\n", - "************\n", - "Executing [2] circuits with num_qubits = 7\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 8, 0.1\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 8, 0.077, 2.0\n", - "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.001, 106.898, 1.671 secs\n", - "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.808, 0.795\n", - "\n", - "************\n", - "Executing [2] circuits with num_qubits = 8\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 8, 0.1\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 8, 0.076, 2.5\n", - "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.0, 131.608, 1.458 secs\n", - "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.448, 0.43\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 10, 0.107\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 10, 0.079, 3.0\n", - "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.001, 146.66, 1.686 secs\n", - "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.444, 0.435\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 10, 0.106\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 10, 0.078, 3.5\n", - "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.001, 195.339, 1.279 secs\n", - "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.423, 0.418\n", - "\n", - "... execution complete at Sep 23, 2024 21:10:11 UTC in 12927.288 secs\n", - "\n", - "Sample Circuit:\n", - " ┌───┐ ░ ┌─────┐ ░ ┌───┐ ░ ┌─┐ \n", - "q9928_0: ┤ H ├──────░─┤0 ├─░─┤ H ├──────░─┤M├────────────\n", - " ├───┤ ░ │ │ ░ ├───┤ ░ └╥┘┌─┐ \n", - "q9928_1: ┤ H ├──────░─┤1 ├─░─┤ H ├──────░──╫─┤M├─────────\n", - " ├───┤ ░ │ │ ░ ├───┤ ░ ║ └╥┘┌─┐ \n", - "q9928_2: ┤ H ├──────░─┤2 ├─░─┤ H ├──────░──╫──╫─┤M├──────\n", - " ├───┤ ░ │ Uf │ ░ ├───┤ ░ ║ ║ └╥┘┌─┐ \n", - "q9928_3: ┤ H ├──────░─┤3 ├─░─┤ H ├──────░──╫──╫──╫─┤M├───\n", - " ├───┤ ░ │ │ ░ ├───┤ ░ ║ ║ ║ └╥┘┌─┐\n", - "q9928_4: ┤ H ├──────░─┤4 ├─░─┤ H ├──────░──╫──╫──╫──╫─┤M├\n", - " ├───┤┌───┐ ░ │ │ ░ ├───┤┌───┐ ░ ║ ║ ║ ║ └╥┘\n", - "q9928_5: ┤ X ├┤ H ├─░─┤5 ├─░─┤ H ├┤ X ├─░──╫──╫──╫──╫──╫─\n", - " └───┘└───┘ ░ └─────┘ ░ └───┘└───┘ ░ ║ ║ ║ ║ ║ \n", - " c236: 5/═════════════════════════════════════╩══╩══╩══╩══╩═\n", - " 0 1 2 3 4 \n", - "\n", - "Constant Oracle 'Uf' =\n", - " \n", - "q_0: \n", - " \n", - "q_1: \n", - " \n", - "q_2: \n", - " \n", - "q_3: \n", - " \n", - "q_4: \n", - " \n", - "q_5: \n", - " \n", - "\n", - "Balanced Oracle 'Uf' =\n", - " ┌───┐ ░ ░ ┌───┐\n", - "q_0: ┤ X ├─░───■───────────────────────░─┤ X ├\n", - " └───┘ ░ │ ░ └───┘\n", - "q_1: ──────░───┼────■──────────────────░──────\n", - " ┌───┐ ░ │ │ ░ ┌───┐\n", - "q_2: ┤ X ├─░───┼────┼────■─────────────░─┤ X ├\n", - " └───┘ ░ │ │ │ ░ └───┘\n", - "q_3: ──────░───┼────┼────┼────■────────░──────\n", - " ┌───┐ ░ │ │ │ │ ░ ┌───┐\n", - "q_4: ┤ X ├─░───┼────┼────┼────┼────■───░─┤ X ├\n", - " └───┘ ░ ┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐ ░ └───┘\n", - "q_5: ──────░─┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├─░──────\n", - " ░ └───┘└───┘└───┘└───┘└───┘ ░ \n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import sys\n", "sys.path.insert(1, \"deutsch-jozsa/qiskit\")\n", @@ -276,126 +132,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Bernstein-Vazirani (1) Benchmark Program - Qiskit\n", - "... execution starting at Sep 17, 2024 13:28:22 UTC\n", - "setting instance client-enablement/solutions/demo-testing\n", - "************\n", - "Executing [3] circuits with num_qubits = 3\n", - "************\n", - "Executing [3] circuits with num_qubits = 4\n", - "************\n", - "Executing [3] circuits with num_qubits = 5\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 6, 0.111\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 6, 0.091, 1.0\n", - "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.002, 54.169, 1.421 secs\n", - "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.891, 0.854\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 7, 0.141\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 7, 0.106, 1.667\n", - "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.002, 40.193, 1.306 secs\n", - "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.796, 0.767\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 6\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 7, 0.118\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 7, 0.083, 1.667\n", - "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.003, 68.289, 1.324 secs\n", - "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.772, 0.757\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 7\n", - "************\n", - "Executing [3] circuits with num_qubits = 8\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 8, 0.157\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 8, 0.107, 2.667\n", - "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.002, 95.101, 1.31 secs\n", - "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.682, 0.671\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 7, 0.127\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 7, 0.082, 2.333\n", - "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.003, 74.843, 1.297 secs\n", - "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.793, 0.79\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 8, 0.156\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 8, 0.1, 3.333\n", - "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.004, 81.488, 1.304 secs\n", - "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.488, 0.484\n", - "\n", - "... execution complete at Sep 17, 2024 13:35:32 UTC in 429.721 secs\n", - "\n", - "Sample Circuit:\n", - " ┌───┐ ░ ┌─────┐ ░ ┌───┐ ░ ┌─┐ \n", - "q467_0: ┤ H ├──────░─┤0 ├─░─┤ H ├──────░─┤M├────────────\n", - " ├───┤ ░ │ │ ░ ├───┤ ░ └╥┘┌─┐ \n", - "q467_1: ┤ H ├──────░─┤1 ├─░─┤ H ├──────░──╫─┤M├─────────\n", - " ├───┤ ░ │ │ ░ ├───┤ ░ ║ └╥┘┌─┐ \n", - "q467_2: ┤ H ├──────░─┤2 ├─░─┤ H ├──────░──╫──╫─┤M├──────\n", - " ├───┤ ░ │ Uf │ ░ ├───┤ ░ ║ ║ └╥┘┌─┐ \n", - "q467_3: ┤ H ├──────░─┤3 ├─░─┤ H ├──────░──╫──╫──╫─┤M├───\n", - " ├───┤ ░ │ │ ░ ├───┤ ░ ║ ║ ║ └╥┘┌─┐\n", - "q467_4: ┤ H ├──────░─┤4 ├─░─┤ H ├──────░──╫──╫──╫──╫─┤M├\n", - " ├───┤┌───┐ ░ │ │ ░ ├───┤┌───┐ ░ ║ ║ ║ ║ └╥┘\n", - "q467_5: ┤ X ├┤ H ├─░─┤5 ├─░─┤ H ├┤ X ├─░──╫──╫──╫──╫──╫─\n", - " └───┘└───┘ ░ └─────┘ ░ └───┘└───┘ ░ ║ ║ ║ ║ ║ \n", - " c34: 5/═════════════════════════════════════╩══╩══╩══╩══╩═\n", - " 0 1 2 3 4 \n", - "\n", - "Quantum Oracle 'Uf' =\n", - " \n", - "q468_0: ──────────\n", - " \n", - "q468_1: ──■───────\n", - " │ \n", - "q468_2: ──┼───────\n", - " │ \n", - "q468_3: ──┼───────\n", - " │ \n", - "q468_4: ──┼────■──\n", - " ┌─┴─┐┌─┴─┐\n", - "q468_5: ┤ X ├┤ X ├\n", - " └───┘└───┘\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import sys\n", "sys.path.insert(1, \"bernstein-vazirani/qiskit\")\n", @@ -416,112 +155,11 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Bernstein-Vazirani (2) Benchmark Program - Qiskit\n", - "... execution starting at Sep 17, 2024 13:38:15 UTC\n", - "setting instance client-enablement/solutions/demo-testing\n", - "************\n", - "Executing [3] circuits with num_qubits = 3\n", - "************\n", - "Executing [3] circuits with num_qubits = 4\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 10, 0.162\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 12, 0.135, 1.333\n", - "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.001, 38.881, 1.323 secs\n", - "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.878, 0.837\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 5\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 11, 0.125\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 12, 0.111, 1.0\n", - "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.001, 77.081, 1.336 secs\n", - "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.687, 0.643\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 6\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 16, 0.159\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 19, 0.128, 2.0\n", - "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.001, 34.117, 1.434 secs\n", - "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.733, 0.715\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 7\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 18, 0.147\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 21, 0.12, 2.0\n", - "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.002, 29.33, 1.51 secs\n", - "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.578, 0.565\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 8\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 21, 0.148\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 25, 0.119, 2.333\n", - "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.001, 54.928, 1.688 secs\n", - "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.464, 0.455\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 25, 0.163\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 30, 0.128, 3.0\n", - "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.002, 56.218, 1.767 secs\n", - "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.524, 0.52\n", - "\n", - "... execution complete at Sep 17, 2024 13:43:42 UTC in 327.135 secs\n", - "\n", - "Sample Circuit:\n", - " ░ ┌───┐ ┌───┐┌─┐ ┌───┐ ┌───┐┌─┐ ┌─┐ ┌─┐»\n", - "q764_0: ───────────░─┤ H ├──■──┤ H ├┤M├─|0>─┤ H ├──■──┤ H ├┤M├─|0>─┤M├─|0>─┤M├»\n", - " ┌───┐┌───┐ ░ └───┘┌─┴─┐└───┘└╥┘ └───┘┌─┴─┐└───┘└╥┘ └╥┘ └╥┘»\n", - "q764_1: ┤ X ├┤ H ├─░──────┤ X ├──────╫───────────┤ X ├──────╫───────╫───────╫─»\n", - " └───┘└───┘ ░ └───┘ ║ └───┘ ║ ║ ║ »\n", - " c52: 5/═════════════════════════════╩══════════════════════╩═══════╩═══════╩═»\n", - " 0 1 2 3 »\n", - "« ┌───┐ ┌───┐┌─┐ \n", - "«q764_0: ─|0>─┤ H ├──■──┤ H ├┤M├─|0>─\n", - "« └───┘┌─┴─┐└───┘└╥┘ \n", - "«q764_1: ──────────┤ X ├──────╫──────\n", - "« └───┘ ║ \n", - "« c52: 5/═════════════════════╩══════\n", - "« 4 \n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk4AAAPxCAYAAAAMsiLhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1gU1/s28HvpRXrHBioWbCgqdiwY7GIF9avYY8RK7AXF2HsjGk1iL0SNJSZiEE1MFHuPDRW7IEVBEBHY8/7hu/tz3QV3ERbU+3NdXLpnzsw8cxh2nz1z5oxECCFARERERB+kU9QBEBEREX0qmDgRERERqYmJExEREZGamDgRERERqYmJExEREZGamDgRERERqYmJExEREZGamDgRERERqYmJExEREZGamDh94f766y9IJBLs2rWrqENRy4wZMyCRSJCYmFjUoRQKiUSCGTNmFHUY9P/JzrdPWVEfw4YNGyCRSHDv3j216g8bNgytWrXK174mTpwILy+vfK1bGPr16wcXFxeN1pG119mzZ/OsV9S/1y8ZE6dCJPsDePfH3t4ezZs3x8GDB4s6vC/O+78PPT09lCxZEv369cPjx4+LOjyVTpw4gRkzZuDFixdFsv9mzZoptJmBgQFcXV0xZMgQPHz4sEhiUte1a9cwY8YMtT+wC1uNGjVQpkwZ5PWUq0aNGsHBwQHZ2dlajKz4iI2NxY8//ojJkyfLyx4+fIjQ0FDUq1cPVlZWsLW1RbNmzXD48GGl9UePHo1Lly5h//79hRbjgQMH0Lp1a9jY2MDIyAgVK1bEuHHjkJycXGj7VNecOXOwd+/eog7js8fESQtmzpyJzZs3Y9OmTRg/fjwSEhLQtm1bHDhwoKhD+yLJfh9r1qxBmzZtsGXLFnh7e+P169dFHZqSEydOIDQ0tMgSJwAoVaoUNm/eLG+zrl27Ytu2bWjcuDFevXpVZHF9yLVr1xAaGvpRidPUqVORkZFRIPH07t0bDx8+xD///KNy+b179xAdHQ1/f3/o6ekVyD6Bgj2G/OjTpw8yMjJQtmzZD9Zdvnw5XF1d0bx5c3nZvn37MH/+fFSoUAGzZs3CtGnT8PLlS7Rq1Qrr169XWN/R0RGdOnXCokWLCvw4AGDs2LHo0KED4uLiMGHCBKxatQo+Pj5YuXIlPDw8EBMTo1B/3bp1uHnzZqHEour3ysRJOwrur5Ny1aZNG9SpU0f+euDAgXBwcMD27dvRvn37Iozs05Geng5TU9MC2da7v49BgwbB1tYW8+fPx/79+9GjR48C2cfnxMLCAv/73/8UylxdXTF8+HAcP34835dV3vX69WsYGBhAR6d4fZfT09MrsCSmV69emDRpErZt24amTZsqLd++fTuEEOjdu3eB7E9GnWOQSqV48+YNjIyMCnTfAKCrqwtdXd0P1svKysLWrVsxdOhQhfLmzZvjwYMHsLW1lZcNHToUHh4eCAkJQf/+/RXq9+jRA927d8fdu3dRrly5gjkIvP39LF68GP7+/ti6davCMfXr1w/NmzdH9+7dcfbsWXl76+vrF9j+31eQ5yZppni9S30hLC0tYWxsrHTSS6VSLFu2DFWrVoWRkREcHBzw9ddf4/nz5wr1XFxc0L59e/z777+oV68ejIyMUK5cOWzatElpXy9evMCYMWPg4uICQ0NDlCpVCn379lUaIySVSjF79myUKlUKRkZGaNmyJW7fvq1Qp1mzZqhWrRouX74Mb29vmJiYoEKFCvLxUX///Te8vLxgbGyMSpUqKXWl379/H8OGDUOlSpVgbGwMGxsbdO/eXalHQHZJ7e+//8awYcNgb2+PUqVK5dqe9+/fR4UKFVCtWjXEx8fnWi83TZo0AQDcuXNHofzGjRvo1q0brK2tYWRkhDp16ihdAsjKykJoaCjc3NxgZGQEGxsbNG7cGJGRkQrt1qxZM6X9fmj8w4wZMzBu3DgAbxMV2eUyWXtFRkaicePGsLS0RIkSJVCpUiWFSxyFydHREQCUzuHHjx9jwIABcHBwgKGhIapWrYqff/5ZoY5sXN2OHTswdepUlCxZEiYmJkhNTUW/fv1QokQJPH78GH5+fihRogTs7OwwduxY5OTkKGxnx44d8PT0hJmZGczNzVG9enUsX74cwNtzqHv37gDefvDK2u6vv/6Sr3/w4EE0adIEpqamMDMzQ7t27fDff/8p7EPVOBKJRILhw4dj7969qFatmvw4IyIi8myz0qVLo2nTpti1axeysrKUlm/btg3ly5eHl5eX2n8r7w8FePdHVjevY9i6dSuqVq0KQ0NDefyLFi1Cw4YNYWNjA2NjY3h6eqocA6luO6g7xunff/9FYmIifHx8FMqrVq2qkDQBgKGhIdq2bYtHjx7h5cuXCstk6+/bty/P/WkqNDQUVlZWWLt2rVIiWK9ePUyYMAGXLl3Cr7/+Ki9X9Tee13mbm+fPn6NevXooVaqUvAfr/d+rRCJBeno6Nm7cKD8H+vXr93EHTSoxXdWClJQUJCYmQgiBZ8+eYeXKlUhLS1P6Fv/1119jw4YN6N+/P0aOHInY2FisWrUKFy5cwPHjxxW+vdy+fRvdunXDwIEDERgYiJ9//hn9+vWDp6cnqlatCgBIS0tDkyZNcP36dQwYMAC1a9dGYmIi9u/fj0ePHim8Gc2bNw86OjoYO3YsUlJSsGDBAvTu3RunTp1SiPH58+do3749AgIC0L17d6xevRoBAQHYunUrRo8ejaFDh6JXr15YuHAhunXrhocPH8LMzAwAcObMGZw4cQIBAQEoVaoU7t27h9WrV6NZs2a4du0aTExMFPY1bNgw2NnZISQkBOnp6Srb9s6dO2jRogWsra0RGRmp9AarDtkbupWVlbzsv//+Q6NGjVCyZElMnDgRpqam+OWXX+Dn54fdu3ejc+fOAN6+ec2dOxeDBg1CvXr1kJqairNnz+L8+fMf3RPTpUsX3Lp1C9u3b8fSpUvlx2ZnZ4f//vsP7du3R40aNTBz5kwYGhri9u3bOH78+EftU5WcnBx5op2VlYXr169j+vTpqFChAho1aiSvFx8fj/r168s/UO3s7HDw4EEMHDgQqampGD16tMJ2v/vuOxgYGGDs2LHIzMyEgYGBfH++vr7w8vLCokWLcPjwYSxevBjly5fHN998A+Bt0tizZ0+0bNkS8+fPBwBcv34dx48fx6hRo9C0aVOMHDkSK1aswOTJk1GlShUAkP+7efNmBAYGwtfXF/Pnz8erV6+wevVqNG7cGBcuXPjggN5///0Xv/76K4YNGwYzMzOsWLECXbt2xYMHD2BjY5Prer1798aQIUNw6NAhhd7mK1eu4OrVqwgJCQGg/t/K5s2blfYxdepUPHv2DCVKlMjzGI4cOYJffvkFw4cPh62trfyYly9fjo4dO6J379548+YNduzYge7du+PAgQNo165dgbSDKidOnIBEIkGtWrXUqh8XFwcTExOl9w0LCwuUL18ex48fx5gxYzSKITcxMTG4efMm+vXrB3Nzc5V1+vbti+nTp+O3337Ltef6Q+etKomJiWjVqhWSk5Px999/o3z58irrbd68Wf4+NGTIEADItS59JEGFZv369QKA0o+hoaHYsGGDQt1//vlHABBbt25VKI+IiFAqL1u2rAAgjh07Ji979uyZMDQ0FN9++628LCQkRAAQv/76q1JsUqlUCCHE0aNHBQBRpUoVkZmZKV++fPlyAUBcuXJFXubt7S0AiG3btsnLbty4IQAIHR0dcfLkSXn5oUOHBACxfv16edmrV6+U4oiOjhYAxKZNm5TarXHjxiI7O1uh/vTp0wUAkZCQIK5fvy6cnZ1F3bp1RXJystK23yfb7uHDh0VCQoJ4+PCh2LVrl7CzsxOGhobi4cOH8rotW7YU1atXF69fv1Zos4YNGwo3Nzd5Wc2aNUW7du3y3K+3t7fw9vZWKg8MDBRly5ZVKAMgpk+fLn+9cOFCAUDExsYq1Fu6dKm8HQqT7Hf+/k+VKlXE3bt3FeoOHDhQODk5icTERIXygIAAYWFhIf/9y865cuXKKZ0TgYGBAoCYOXOmQnmtWrWEp6en/PWoUaOEubm50vnxrp07dwoA4ujRowrlL1++FJaWlmLw4MEK5XFxccLCwkKhXHa+vQuAMDAwELdv35aXXbp0SQAQK1euzDUeIYRITk4WhoaGomfPngrlEydOFADEzZs3hRDq/628b8GCBUp1cjsGHR0d8d9//ylt4/19v3nzRlSrVk20aNFCaRvqtIPs7+79c/h9//vf/4SNjU2edWRiYmKEkZGR6NOnj8rlX331lahSpYpa21LH3r17BQCxdOnSPOuZm5uL2rVry1+//zeuznkra68zZ86Ip0+fiqpVq4py5cqJe/fuKdRT9Xs1NTUVgYGBah8X5Q8v1WlBWFgYIiMjERkZiS1btqB58+YYNGiQQpfuzp07YWFhgVatWiExMVH+4+npiRIlSuDo0aMK23R3d5dfYgLe9kJUqlQJd+/elZft3r0bNWvWlPeOvOv9rvv+/fvLv/ED/3f56t3tAUCJEiUQEBAgf12pUiVYWlqiSpUqCrcBy/7/7vrGxsby/2dlZSEpKQkVKlSApaUlzp8/rxTj4MGDcx0bcfXqVXh7e8PFxQWHDx9W6C36EB8fH9jZ2aF06dLo1q0bTE1NsX//fvnlwOTkZBw5cgQ9evTAy5cv5b+LpKQk+Pr6IiYmRn4XnqWlJf777z+lQaGFzdLSEsDbyxFSqbRQ9+Xi4iI/fw8ePIhly5YhJSUFbdq0QUJCAgBACIHdu3ejQ4cOEEIonMO+vr5ISUlR+h0HBgYqnBPven+cS5MmTRTOJUtLS6SnpytcElVXZGQkXrx4gZ49eyrEqaurCy8vL6W/NVV8fHwUvs3XqFED5ubmSn8v77OyskLbtm2xf/9+eS+qEAI7duxAnTp1ULFiRQCa/60AwNGjRzFp0iSMGDECffr0+eAxeHt7w93dXan83X0/f/4cKSkpaNKkicr95rcdVElKSlLr7/jVq1fo3r07jI2NMW/ePJV1rKysCnTKEtnlQFnveW7MzMyULh2+S5Pz9tGjR/D29kZWVhaOHTum1uB60g5eqtOCevXqKQwO79mzJ2rVqoXhw4ejffv2MDAwQExMDFJSUmBvb69yG8+ePVN4XaZMGaU6VlZWCuOh7ty5g65du6oV4/vbk72BvT++qlSpUkpJl4WFBUqXLq1U9v76GRkZmDt3LtavX4/Hjx8r3JadkpKiFJOrq2uu8Xbo0AEODg44dOjQBy9JvC8sLAwVK1ZESkoKfv75Zxw7dgyGhoby5bdv34YQAtOmTcO0adNUbuPZs2coWbIkZs6ciU6dOqFixYqoVq0aWrdujT59+qBGjRoaxaQpf39//Pjjjxg0aBAmTpyIli1bokuXLujWrVueA6yTk5Px5s0b+WtjY2P57yo3pqamCuNOWrdujcaNG6NOnTqYN28eFi9ejISEBLx48QJr167F2rVrVW7n/XM4t9+vkZER7OzsFMreP7eHDRuGX375BW3atEHJkiXx1VdfoUePHmjdunWexwJAnuS2aNFC5fLcLsW860N/f2/evFG6Pd3Ozg66urro3bs39uzZg3379qFXr144ceIE7t27p3CpRtO/lUePHsHf3x+NGjXCkiVLPhg/kHv7HzhwALNmzcLFixeRmZkpL1c1Z5A670OaEHlM1QC8vYwbEBCAa9eu4eDBg3B2ds51Ox+a4yglJUXhrjQDAwNYW1urrCtLmPJKimTL87rMq8l526dPH+jp6eH69evyMYVUPDBxKgI6Ojpo3rw5li9fjpiYGFStWhVSqRT29vbYunWrynXe/yDJrSfmQ288uVF3e7nVU2f9ESNGYP369Rg9ejQaNGgACwsLSCQSBAQEqOw1ya03AgC6du2KjRs3YuvWrfj6669zrafKu4msn58fGjdujF69euHmzZsoUaKEPJaxY8fC19dX5TYqVKgAAGjatCnu3LmDffv24c8//8SPP/6IpUuXYs2aNRg0aBCAtx84qn4v7w921oSxsTGOHTuGo0eP4vfff0dERATCw8PRokUL/Pnnn7n+Prp06YK///5b/jowMBAbNmzQeP+enp6wsLDAsWPHAEDeZv/73/8QGBiocp33k8ncfr/q3IFlb2+Pixcv4tChQzh48CAOHjyI9evXo2/fvti4cWOe68pi3bx5s8oPJHXuVPrQ+X7ixAmFW+qBt3MUyW7ssLCwwLZt29CrVy9s27YNurq6Cj25mvytvHnzBt26dYOhoSF++eUXte+0UtX+//zzDzp27IimTZvi+++/h5OTE/T19bF+/Xps27ZN43bQhI2NzQcTrsGDB+PAgQPYunVrrokv8PYL24fGO44aNUrhXPH29la4eeBdsp65y5cv57q9+/fvIzU1Nc87+TQ5b7t06YJNmzZh+fLlmDt3bp7HQtrFxKmIyCa4S0tLA/B2EN/hw4fRqFGjPBMGTZQvXx5Xr14tkG0VhF27diEwMBCLFy+Wl71+/TpfcxQtXLgQenp68kGpvXr1yldMurq6mDt3Lpo3b45Vq1Zh4sSJ8jc+fX19pTt8VLG2tkb//v3Rv39/pKWloWnTppgxY4Y8cbKyslJ56eL+/fsf3HZe35p1dHTQsmVLtGzZEkuWLMGcOXMwZcoUHD16NNe4Fy9erPDhlNs3dnXk5OTIz187OzuYmZkhJydHrTYrCAYGBujQoQM6dOgAqVSKYcOG4YcffsC0adNQoUKFXNtOdmnJ3t6+0GKtWbOm0uUYWZJmaGiIbt26YdOmTYiPj8fOnTvRokULhSROk7+VkSNH4uLFizh27BgcHBw+Ku7du3fDyMgIhw4dUuiFfX++pMJQuXJlbN26FSkpKSp7QceNG4f169dj2bJl6NmzZ57bio2NRc2aNfOsM378eIUbdPK6TOjm5oZKlSph7969WL58ucpLdrK7mmV3c+bmQ+etzIgRI1ChQgWEhITAwsICEydOzHO7QN7vF1RwOMapCGRlZeHPP/+EgYGB/C6fHj16ICcnB999951S/ezs7HwlF127dsWlS5ewZ88epWX57Zn6GLq6ukr7XblyZb56XiQSCdauXYtu3bohMDDwo2YKbtasGerVq4dly5bh9evXsLe3R7NmzfDDDz/g6dOnSvVl43qAt+My3lWiRAlUqFBB4RJH+fLlcePGDYX1Ll26pNYdcLK5q97//auapdjDwwMAFPb9Pk9PT/j4+Mh/VI1xUcfRo0eRlpYm/3DS1dVF165dsXv3bpXJ+rvHXhDeb3cdHR15j5bs+HNrO19fX5ibm2POnDkqpwUoiFitrKwU2tnHx0dhjqTevXsjKysLX3/9NRISEpTmblL3b2X9+vX44YcfEBYWhnr16n103Lq6upBIJAr7uXfvnlYmVWzQoAGEEDh37pzSsoULF2LRokWYPHlyrnefyaSkpODOnTto2LBhnvXc3d0Vfj+enp551p8+fTqeP3+OoUOHKv0ezp07h/nz56NWrVpo06ZNrttQ57x917Rp0zB27FhMmjQJq1evzjM+4O05X5ST5X4p2OOkBQcPHsSNGzcAvB3nsW3bNsTExGDixIny8RTe3t74+uuvMXfuXFy8eBFfffUV9PX1ERMTg507d2L58uXo1q2bRvsdN24cdu3ahe7du2PAgAHw9PREcnIy9u/fjzVr1nzwG1lBa9++PTZv3gwLCwu4u7sjOjoahw8f1vi2ZRkdHR1s2bIFfn5+6NGjB/744488u+/zMm7cOHTv3h0bNmzA0KFDERYWhsaNG6N69eoYPHgwypUrh/j4eERHR+PRo0e4dOkSgLdvvs2aNYOnpyesra1x9uxZ7Nq1C8OHD5dve8CAAViyZAl8fX0xcOBAPHv2DGvWrEHVqlWRmpqaZ1yyN/MpU6YgICAA+vr66NChA2bOnIljx46hXbt2KFu2LJ49e4bvv/8epUqVQuPGjfPVBrlJSUnBli1bALxN4m/evInVq1fD2NhY4VvwvHnzcPToUXh5eWHw4MFwd3dHcnIyzp8/j8OHDxfoIykGDRqE5ORktGjRAqVKlcL9+/flszfLvox4eHhAV1cX8+fPR0pKCgwNDdGiRQvY29tj9erV6NOnD2rXro2AgADY2dnhwYMH+P3339GoUSOsWrWqwGJVxdvbG6VKlcK+fftgbGyMLl26KCxX528lMTERw4YNg7u7OwwNDeW/I5nOnTtrPGlsu3btsGTJErRu3Rq9evXCs2fPEBYWhgoVKuR5maogNG7cGDY2Njh8+LDC3/GePXswfvx4uLm5oUqVKkrH2apVK4WetsOHD0MIgU6dOhVofD179sTZs2exZMkSXLt2Db1794aVlRXOnz+Pn3/+GXZ2dti1a1eel0rVOW/ft3DhQqSkpCAoKAhmZmZK09i8y9PTE4cPH8aSJUvg7OwMV1fXYvXsvs+Glu/i+6Komo7AyMhIeHh4iNWrV8unBHjX2rVrhaenpzA2NhZmZmaievXqYvz48eLJkyfyOmXLllV5C7yq296TkpLE8OHDRcmSJYWBgYEoVaqUCAwMlN8yLrs1fOfOnQrrxcbGKk0n4O3tLapWraq039ziASCCgoLkr58/fy769+8vbG1tRYkSJYSvr6+4ceOGKFu2rMIttO/ejvu+d6cjkHn16pXw9vYWJUqUUJgS4X15bTcnJ0eUL19elC9fXn6r8J07d0Tfvn2Fo6Oj0NfXFyVLlhTt27cXu3btkq83a9YsUa9ePWFpaSmMjY1F5cqVxezZs8WbN28Utr9lyxZRrlw5YWBgIDw8PMShQ4fUmo5ACCG+++47UbJkSaGjoyO/rTsqKkp06tRJODs7CwMDA+Hs7Cx69uwpbt26levx58f70xFIJBJhbW0tOnbsKM6dO6dUPz4+XgQFBYnSpUsLfX194ejoKFq2bCnWrl0rr5PbOSfE29u3TU1Nlcrfv/V6165d4quvvhL29vbCwMBAlClTRnz99dfi6dOnCuutW7dOlCtXTujq6ipNTXD06FHh6+srLCwshJGRkShfvrzo16+fOHv2bK77FUL5vJZ5/zz+kHHjxgkAokePHkrL1Plbkf2N5vYju/1fk2MQQoiffvpJuLm5CUNDQ1G5cmWxfv36j2oHdacjEEKIkSNHigoVKiiUyfad28/70034+/uLxo0bf3Bf+bV//37h4+MjLC0t5TFUrVpVpKSkKNV9/29cnfNW1ftUTk6O6Nmzp9DT0xN79+4VQqj+vd64cUM0bdpUGBsbCwCcmqCQSIQogms2RERE77l79y4qV66MgwcPomXLlhqvHxcXB1dXV+zYsaPAe5xyM2jQIPz0009Yt26dfFwjfd6YOBERUbHxzTff4Pbt2/mao2vixIk4cuQITp8+XQiRqZaTkwM/Pz9ERERg3759aNu2rdb2TUWDiRMRERGRmnhXHREREZGamDgRERERqYmJExEREZGamDgRERERqYmJ02dqw4YNkEgkuHfvXlGHomDGjBlKjwWQSCQKE0YWJdmzxD5Gftr+3r17kEgkWLRo0Uftm4iIChcTp0Ig++CU/RgZGcHZ2Rm+vr5YsWLFB5+wTfQ5SEhIwKhRo1C5cmUYGxvD3t4e9erVw4QJE+TPuNOmmzdvYsyYMWjYsCGMjIxyTW7/+usvhb/f939mz56t8b5fvXqFsLAwfPXVV3BycoKZmRlq1aqF1atXq3zkkFQqxYIFC+Dq6gojIyPUqFED27dvV6qzYcMGdOzYEaVLl4apqSmqVauGWbNm4fXr13nG8++//8qPJzEx8YPxp6WlYfr06WjdujWsra0hkUhyfTj0unXr4O3tDQcHBxgaGsLV1RX9+/fP95e42bNnQyKRoFq1akrL5syZg/r168POzg5GRkZwc3PD6NGj8/3YnMGDB0MikSh9eUpKSsLChQvRtGlT2NnZwdLSEvXr10d4eLha25WdU7t27VK5fPjw4fIvlLIvlx/6adasmcL2u3TpAkdHRxgYGMDe3h4dOnTAr7/+mq92oLzxkSuFaObMmXB1dUVWVhbi4uLw119/YfTo0ViyZAn279+v9LT4gtSnTx8EBAQoPKizOJg6dapaD6v8lBXXttem5ORk1KlTB6mpqRgwYAAqV66MpKQkXL58GatXr8Y333yDEiVKaDWm6OhorFixAu7u7qhSpQouXryosl6VKlWwefNmpfLNmzfjzz//xFdffaXxvu/evYsRI0agZcuWCA4Ohrm5OQ4dOoRhw4bh5MmT2Lhxo0L9KVOmYN68eRg8eDDq1q2Lffv2oVevXpBIJAgICADwNhnr378/6tevj6FDh8Le3h7R0dGYPn06oqKicOTIEZUPfZVKpRgxYgRMTU2Rnp6uVvyJiYmYOXMmypQpg5o1a+Kvv/7Kte6FCxfg6uqKjh07wsrKCrGxsVi3bh0OHDiAS5cuafRg6UePHmHOnDm5Pjrm3Llz8PDwQEBAAMzMzHD9+nWsW7cOv//+Oy5evKjRI2fOnj2LDRs2KDxTUCY6OhpTpkxB27ZtMXXqVOjp6WH37t0ICAjAtWvXEBoaqvZ+PqRLly4KD/tNS0vDN998g86dOys8mkf2mJnp06dj5syZcHNzw9dff42yZcsiKSkJf/zxB7p27YqtW7fm+yHolIuinLb8c5XXoz2ioqKEsbGxKFu2rHj16lURRFf8II/HP2hbbo+PUUdaWlq+9yt7fMbChQvzvY3iZMGCBQKAOH78uNKylJQUkZGRofWYkpKSRGpqqhBCiIULF6r9GBCZChUqCDc3t3ztOyEhQVy9elWpvH///gKAiImJkZc9evRI6OvrK/xNSKVS0aRJE1GqVCn5I4EyMzNVtm9oaKgAICIjI1XGsnr1amFjYyNGjRql9Pii3Lx+/Vr+WJAzZ84oPY7pQ86ePSsAiLlz56q9jhBvH5/SokWLXB/3pMquXbsEALF9+3a19yOVSkWDBg3EgAEDVL4H3L17V9y7d09pnRYtWghDQ8MP/u3n9ZghIYQICgpSenyKTEJCgspHMQkhxM6dOwUA0a1bN6XHPAkhREREhPjtt9/yjI00x0t1WtaiRQtMmzYN9+/fV3pY5Y0bN9CtWzdYW1vDyMgIderUwf79++XLz549C4lEovTtFAAOHToEiUSCAwcOAMh9nM3Bgwfh7e0NMzMzmJubo27duti2bZtCnVOnTqF169awsLCAiYkJvL29cfz48QI5flVjnGS2bt2KSpUqwcjICJ6enjh27JjKdW/duoX//e9/sLCwgJ2dHaZNmwYhBB4+fIhOnTrB3Nwcjo6OWLx4cb7j/PPPP+Hh4QEjIyO4u7srdXnL2vfvv//GsGHDYG9vj1KlSikse7ftz549C19fX9ja2sLY2Biurq4YMGCAyn0vXboUZcuWhbGxMby9vXH16lWF5ZcvX0a/fv1Qrlw5GBkZwdHREQMGDFB68rqsvW7fvo1+/frB0tISFhYW6N+/P169eqW03y1btsDT0xPGxsawtrZGQEAAHj58mJ/mw507d6Crq4v69esrLTM3N1f6Vq/OOSc7nhs3bqBHjx4wNzeHjY0NRo0a9cFLUwBgbW0NMzOzfB3P6dOncfv2bfTu3Ttf69va2qJq1apK5Z07dwYAXL9+XV62b98+ZGVlYdiwYfIyiUSCb775Bo8ePUJ0dDQAwMDAAA0bNlRrmzLJycmYOnUqZs6cCUtLS7XjNzQ0hKOjo9r13+fi4gIAePHihUL5gwcP5A9Af9+xY8ewa9cuLFu2rED2defOHdy5c0flOps3b8bVq1dzvQzr6uqKsmXLKpRJJBL4+fkhMzMTd+/e1SjGgjJt2jRYW1vj559/hr6+vtJyX1/fjx6zScqYOBWBPn36AHj74Szz33//oX79+rh+/TomTpyIxYsXw9TUFH5+ftizZw8AoE6dOihXrhx++eUXpW2Gh4fDysoKvr6+ue53w4YNaNeuHZKTkzFp0iTMmzcPHh4eiIiIkNc5cuQImjZtitTUVEyfPh1z5szBixcv0KJFC4XHGGRlZSExMVGtH6lU+sE2+fvvvzF69Gj873//w8yZM5GUlITWrVsrJQ0A4O/vD6lUinnz5sHLywuzZs3CsmXL0KpVK5QsWRLz589HhQoVMHbsWKXkSx0xMTHw9/dHmzZtMHfuXOjp6aF79+4qHwExbNgwXLt2DSEhIblegnz27Bm++uor3Lt3DxMnTsTKlSvRu3dvnDx5Uqnupk2bsGLFCgQFBWHSpEm4evUqWrRogfj4eHmdyMhI3L17F/3798fKlSsREBCAHTt2oG3bthAqHgTQo0cPvHz5EnPnzkWPHj2wYcMGpUsLs2fPRt++feHm5oYlS5Zg9OjRiIqKQtOmTZU+gNRRtmxZ5OTkqLzk9T51z7l3j+f169eYO3cu2rZtixUrVmDIkCEax6iJrVu3AkC+E6fcxMXFAXibWMlcuHABpqamqFKlikLdevXqyZdruk2ZadOmwdHREV9//fVHxa2OpKQkPHv2DGfPnkX//v0BQOn5c3379lU6TuDtY0xGjBiBQYMGoXr16nnuRwiBxMRExMXF4Z9//sHIkSOhq6urMAZItm9Vz797+fIlJkyYgMmTJ2ucHObV1oUtJiYGN27cgJ+fX76/EFA+FXGP12cpr0t1MhYWFqJWrVry1y1bthTVq1cXr1+/lpdJpVLRsGFDhcsDkyZNEvr6+iI5OVlelpmZKSwtLcWAAQOUYpBdinjx4oUwMzMTXl5eSpdJpFKp/F83Nzfh6+srLxNCiFevXglXV1fRqlUreZms61mdn3cvh+T2lHUACk+lv3//vjAyMhKdO3dWWnfIkCHysuzsbFGqVCkhkUjEvHnz5OXPnz8XxsbGGj8dvGzZsgKA2L17t7wsJSVFODk5Kfy+ZO3buHFj+aWT95fJjnvPnj0fPB9kl+qMjY3Fo0eP5OWnTp0SAMSYMWPkZaou8W7fvl0AEMeOHZOXydrr3fNCCCE6d+4sbGxs5K/v3bsndHV1xezZsxXqXblyRejp6SmVqyMuLk7Y2dkJAKJy5cpi6NChYtu2beLFixcK9TQ552TH07FjR4VtDBs2TAAQly5dUjs+TS7VZWdnCwcHB1GvXj21t6+OzMxM4e7uLlxdXUVWVpa8vF27dqJcuXJK9dPT0wUAMXHixDy36+PjI8zNzcXz588Vyi9duiR0dXXFoUOHhBD/157qXKp7l7qX6gwNDeV/2zY2NmLFihVKdby9vVVeolq1apWwsLAQz549k9fL7VLd06dPFd5vSpUqJcLDw5XqlS1bVpQtW1apfOzYscLV1VX+3qvu5fqkpCRhb28vmjRp8sG6hXGpbt++fQKAWLp06Qf3TwWLPU5FpESJEvK765KTk3HkyBF5z4CspyYpKQm+vr6IiYnB48ePAbztbcnKylK4dPTnn3/ixYsX8Pf3z3V/kZGRePnyJSZOnKh0mUR26ezixYuIiYlBr169kJSUJI8jPT0dLVu2xLFjx+S9RzVr1kRkZKRaP+p8i2vQoAE8PT3lr8uUKYNOnTrh0KFDSncdvfsEcl1dXdSpUwdCCAwcOFBebmlpiUqVKuWrC93Z2Vl+uQN4e2mpb9++uHDhgvwbpszgwYOhq6ub5/Zkl0QOHDiArKysPOv6+fmhZMmS8tf16tWDl5cX/vjjD3mZsbGx/P+vX79GYmKi/JLY+fPnlbY5dOhQhddNmjRBUlISUlNTAQC//vorpFIpevToodBT6OjoCDc3Nxw9ejTPmFVxcHDApUuXMHToUDx//hxr1qxBr169YG9vj++++07eM6bJOScTFBSk8HrEiBEAoNBGBSkqKgrx8fEF3ts0fPhwXLt2DatWrYKe3v/dp5ORkaHyxgLZ321GRkau25wzZw4OHz6MefPmKV2KGzlyJNq0aZOvwe35cfDgQfzxxx9YvHgxypQpo3Ig+l9//aXUS5qUlISQkBBMmzYNdnZ2H9yPtbU1IiMj8dtvv2HmzJmwtbVVedfmvXv3lIYu3Lp1C8uXL8fChQs1uplDKpWid+/eePHiBVauXKn2egVJ9vfL3ibt4111RSQtLQ329vYAgNu3b0MIgWnTpmHatGkq6z979gwlS5ZEzZo1UblyZYSHh8sThfDwcNja2qJFixa57k92bV/VLb0yMTExAIDAwMBc66SkpMDKygpWVlbw8fHJ+yA14ObmplRWsWJFvHr1CgkJCQrJV5kyZRTqWVhYwMjISKm73MLCQmncjzoqVKigNA6rYsWKAN6++b4bi6ur6we35+3tja5duyI0NBRLly5Fs2bN4Ofnh169eim9WefWDu9enk1OTkZoaCh27NiBZ8+eKdRNSUlRWv/99rKysgIAPH/+HObm5oiJiYEQQuW+AagcO6EOJycnrF69Gt9//z1iYmJw6NAhzJ8/HyEhIXBycsKgQYM0Oudk3o+zfPny0NHRKbQ5y7Zu3QpdXd08v5hoauHChVi3bh2+++47tG3bVmGZsbExMjMzldaRjeN6N3F+V3h4OKZOnYqBAwfim2++UVp24sQJlZe+C0vz5s0BAG3atEGnTp1QrVo1lChR4oNztk2dOhXW1tbyhPhDDAwM5O9F7du3R8uWLdGoUSPY29t/cHzPqFGj0LBhQ3Tt2lWtfcmMGDECERER2LRpE2rWrKnRugXF3NwcADi9TRFg4lQEHj16hJSUFPktp7Jv1GPHjs11jNK7t6f6+/tj9uzZSExMhJmZGfbv34+ePXsqfGvND1kcCxcuhIeHh8o6slvI37x5g+TkZLW2a2dn98FeGU2o2lZu23//22xBy+1D7F2y+VtOnjyJ3377DYcOHcKAAQOwePFinDx5UuPb8nv06IETJ05g3Lhx8PDwQIkSJSCVStG6dWuV48k+1DZSqRQSiQQHDx5UWfdjpw2QSCSoWLEiKlasiHbt2sHNzQ1bt27FoEGDNDrn8tp+YcnIyMCePXvg4+Mjv/37Y23YsAETJkzA0KFDMXXqVKXlTk5OOHr0KIQQCsf29OlTAFB5O39kZCT69u2Ldu3aYc2aNUrLx40bh+7du8PAwECeYMrGrj18+BBv3rzRaJoATZUvXx61atXC1q1b80ycYmJisHbtWixbtgxPnjyRl79+/RpZWVm4d+8ezM3NYW1tnes2GjZsCCcnJ2zdujXPxOnIkSOIiIjAr7/+qpB0Z2dnIyMjA/fu3YO1tbU8QZEJDQ3F999/j3nz5snHq37Ih3oLX716pXIahLxUrlwZAHDlyhWN1qOPx8SpCMgGzMqSpHLlygF4+81enV4cf39/hIaGYvfu3XBwcEBqaqp8bpfclC9fHgBw9epVhSRMVR1zc/MPxnHixAn5N8oPiY2Nld/pkhtZz8O7bt26BRMTE7W66wuSrAfw3Q+tW7duAcAHjyMv9evXR/369TF79mxs27YNvXv3xo4dOxQuPebWDrL9Pn/+HFFRUQgNDUVISEie66mrfPnyEELA1dVV3rNWWMqVKwcrKyt5EqDJOScTExOj0NN3+/ZtSKXSj/rd5Gb//v14+fJlgV2m27dvHwYNGoQuXbogLCxMZR0PDw/8+OOPuH79Otzd3eXlp06dki9/16lTp9C5c2fUqVMHv/zyi8ovUA8fPsS2bduU7qAFgNq1a6NmzZq5zmtVUDIyMlT2pL3r8ePHkEqlGDlyJEaOHKm03NXVFaNGjfrgnXavX79W2fv6rgcPHgCAwtxI78bh6uqKpUuXYvTo0fLysLAwzJgxA6NHj8aECRPy3P67ZHfk3bx5U+XymzdvKt219yEVK1ZEpUqVsG/fPixfvlzr86J9yTjGScuOHDmC7777Dq6urvI3Y3t7ezRr1gw//PCD/APlXe/PglulShVUr14d4eHhCA8Ph5OTE5o2bZrnfr/66iuYmZlh7ty5Srduy3oePD09Ub58eSxatEjlGIF34yjoMU7R0dEK43MePnyIffv24auvvirQ3ip1PHnyRH4nI/B2LMGmTZvg4eGRr1uynz9/rtTzJfvwe/+DZO/evfLxbMDb2+BPnTqFNm3aAPi/3qP3t6fpLdvv6tKlC3R1dREaGqq0XSFEvi53njp1SuWYltOnTyMpKQmVKlUCoNk5J/N+wiEbYyJro4K0bds2mJiYKIx5y69jx44hICAATZs2xdatW6Gjo/rtt1OnTtDX18f3338vLxNCYM2aNShZsqTCFATXr19Hu3bt4OLiggMHDuTaA7pnzx6lH9mlx02bNmHp0qUffXzA296a58+fK5WfPn0aV65cQZ06dRTK35+OoFq1aipjrVq1KsqUKYM9e/bIhyikp6ernFZj9+7deP78udK+3p+OoEWLFir3ZWdnhzp16mDPnj3o0KGDvH54eDhGjhyJ3r17Y8mSJRq1i5OTEzw8PLBlyxalu1TPnTuHkydP5uv8DQ0NRVJSEgYNGoTs7Gyl5X/++ad8ihoqOOxxKkQHDx7EjRs3kJ2djfj4eBw5cgSRkZEoW7Ys9u/fr9A1GxYWhsaNG6N69eoYPHgwypUrh/j4eERHR+PRo0e4dOmSwrb9/f0REhICIyMjDBw4MNc3YRlzc3MsXboUgwYNQt26ddGrVy9YWVnh0qVLePXqFTZu3AgdHR38+OOPaNOmDapWrYr+/fujZMmSePz4MY4ePQpzc3P89ttvAFDgY5yqVasGX19fjBw5EoaGhvIPjYKckVddFStWxMCBA3HmzBk4ODjg559/Rnx8PNavX5+v7W3cuBHff/89OnfujPLly+Ply5dYt24dzM3Nlca3VKhQAY0bN8Y333yDzMxMLFu2DDY2Nhg/fjyAt7/Hpk2bYsGCBcjKykLJkiXx559/IjY2Nt/HW758ecyaNQuTJk3CvXv35Lc3x8bGYs+ePRgyZAjGjh2r0TY3b96MrVu3onPnzvD09ISBgQGuX7+On3/+GUZGRpg8eTIAaHTOycTGxqJjx45o3bo1oqOjsWXLFvTq1euDY01SUlLkSZZsjqhVq1bB0tISlpaWSpeQkpOTcfDgQXTt2jXXb/P37t2Dq6srAgMDc30ECQDcv38fHTt2hEQiQbdu3bBz506F5TVq1JA/SaBUqVIYPXo0Fi5ciKysLNStWxd79+7FP//8Ix9vBbwd2+Lr64vnz59j3Lhx+P333xW2Wb58eTRo0ADA25sO3ifrYWrTpo1at9OvWrUKL168kF9C++233/Do0SMAb8f8WFhYIC0tDaVLl4a/vz+qVq0KU1NTXLlyBevXr4eFhYXSGM6+ffvi77//lifstra2KmOVfTF4d1lMTAx8fHzg7++PypUrQ0dHB2fPnsWWLVvg4uKCUaNGKWxDNhWB7LJcmTJllMb/AcDo0aPh4OCgsK/Tp0+jb9++sLGxQcuWLeXTU8g0bNhQfuUgN0uWLIGvry88PDzQr18/ODs74/r161i7di2cnJwwadKkPNdXxd/fH1euXMHs2bNx4cIF9OzZUz5zeEREBKKiolT2MtJH0vp9fF8A2e3osh8DAwPh6OgoWrVqJZYvXy6fvfh9d+7cEX379hWOjo5CX19flCxZUrRv317s2rVLqW5MTIx8+//++2+uMbx/u/X+/ftFw4YNhbGxsTA3Nxf16tVTmmH3woULokuXLsLGxkYYGhqKsmXLih49eoioqKj8N8r/l9t0BEFBQWLLli3Czc1NGBoailq1aomjR4+qXPf926cDAwOFqamp0r40mW1YRnYr8qFDh0SNGjWEoaGhqFy5stJtxHlNOfF+258/f1707NlTlClTRhgaGgp7e3vRvn17hekX3p05fPHixaJ06dLC0NBQNGnSROk2+0ePHonOnTsLS0tLYWFhIbp37y6ePHmidMtybu2V27mxe/du0bhxY2FqaipMTU1F5cqVRVBQkLh586ZGbSiEEJcvXxbjxo0TtWvXFtbW1kJPT084OTmJ7t27i/PnzyvVV+eckx3PtWvXRLdu3YSZmZmwsrISw4cPV2smclkbq/pRdZv6mjVrBACxf//+XLd55coVtaYI+ND0He/fap6TkyPmzJkjypYtKwwMDETVqlXFli1b1D4eAB+cikPT6QhkU3Wo+pGdS5mZmWLUqFGiRo0awtzcXOjr64uyZcuKgQMHqpz6IbfpCFTVe/9vOSEhQQwZMkRUrlxZmJqaCgMDA+Hm5iZGjx6t8phym45AVb33pyN4/z39/R91Z1E/efKkaN++vbCyshJ6enqiZMmSYtCgQQpTkLwvr5nDZaKiokSnTp2Evb290NPTE3Z2dqJDhw5i3759asVFmpEIUcijZ4mICsCMGTMQGhqKhISEIplwUJXvv/8e48ePx507dwps8DgRFW8c40RElE9Hjx7FyJEjmTQRfUE4xom+CAkJCUoTab7LwMAgz1uciVR5f6wSEX3+mDjRF6Fu3bq4f/9+rsu9vb3x119/aS8gIiL6JHGME30Rjh8/nuejKqysrBQe+UJERKQKEyciIiIiNXFwOBEREZGamDgRERERqYmJExEREZGamDgRERERqYmJExEREZGamDgRERERqYmJExEREZGamDgRERERqYmJExEREZGaijxxCgsLg4uLC4yMjODl5YXTp0/nWX/nzp2oXLkyjIyMUL16dfzxxx8Ky3/99Vd89dVXsLGxgUQiwcWLF5W28fr1awQFBcHGxgYlSpRA165dER8fX5CHRURERJ+hIk2cwsPDERwcjOnTp+P8+fOoWbMmfH198ezZM5X1T5w4gZ49e2LgwIG4cOEC/Pz84Ofnh6tXr8rrpKeno3Hjxpg/f36u+x0zZgx+++037Ny5E3///TeePHmCLl26FPjxERER0eelSJ9V5+Xlhbp162LVqlUAAKlUitKlS2PEiBGYOHGiUn1/f3+kp6fjwIED8rL69evDw8MDa9asUah77949uLq64sKFC/Dw8JCXp6SkwM7ODtu2bUO3bt0AADdu3ECVKlUQHR2N+vXrF8KREhER0edAr6h2/ObNG5w7dw6TJk2Sl+no6MDHxwfR0dEq14mOjkZwcLBCma+vL/bu3av2fs+dO4esrCz4+PjIyypXrowyZcrkmThlZmYiMzNT/loqlSI5OVl+SZCIiIg+TUIIvHz5Es7OztDRyftiXJElTomJicjJyYGDg4NCuYODA27cuKFynbi4OJX14+Li1N5vXFwcDAwMYGlpqdF25s6di9DQULX3Q0RERJ+Whw8folSpUnnWKbLE6VMzadIkhd6ulJQUlClTBrGxsTA3Ny/CyIiIiOhjpKamwtXVFWZmZh+sW2SJk62tLXR1dZXuZouPj4ejo6PKdRwdHTWqn9s23rx5gxcvXij0On1oO4aGhjA0NFQqt7a2ZuJERET0CdPTe5sOqTP0psjuqjMwMICnpyeioqLkZVKpFFFRUWjQoIHKdRo0aKBQHwAiIyNzra+Kp6cn9PX1FbZz8+ZNPHjwQKPtEBER0ZenSC/VBQcHIzAwEHXq1EG9evWwbNkypKeno3///gCAvn37omTJkpg7dy4AYNSoUfD29sbixYvRrl077NixA2fPnsXatWvl20xOTsaDBw/w5MkTAG+TIuBtT5OjoyMsLCwwcOBABAcHy3uLRowYgQYNGvCOOiIiIspTkSZO/v7+SEhIQEhICOLi4uDh4YGIiAj5APAHDx4ojG5v2LAhtm3bhqlTp2Ly5Mlwc3PD3r17Ua1aNXmd/fv3yxMvAAgICAAATJ8+HTNmzAAALF26FDo6OujatSsyMzPh6+uL77//XgtHTERERJ+yIp3H6VOWmpoKCwsLpKSkcIwTERHRJ0yTz/Qif+QKERER0aeCiRMRERGRmpg4EREREamJiRMRERGRmpg4EREREamJiRMRERGRmpg4EREREamJiRMRERGRmpg4EREREamJiRMRERGRmpg4EREREamJiRMRERGRmpg4EREREamJiRMRERGRmpg4EREREalJT5PK169fx44dO/DPP//g/v37ePXqFezs7FCrVi34+vqia9euMDQ0LKxYiYiIiIqURAghPlTp/PnzGD9+PP799180atQI9erVg7OzM4yNjZGcnIyrV6/in3/+QWpqKsaPH4/Ro0d/9glUamoqLCwskJKSAnNz86IOh4iIiPJJk890tXqcunbtinHjxmHXrl2wtLTMtV50dDSWL1+OxYsXY/LkyRoFTURERFTcqdXjlJWVBX19fbU3qmn9TxF7nIiIiD4PmnymqzU4XNMk6HNPmoiIiOjLpPFddSNHjsSKFSuUyletWoXRo0cXRExERERExZLGidPu3bvRqFEjpfKGDRti165dBRIUERERUXGkceKUlJQECwsLpXJzc3MkJiYWSFBERERExZHGiVOFChUQERGhVH7w4EGUK1euQIIiIiIiKo40mgATAIKDgzF8+HAkJCSgRYsWAICoqCgsXrwYy5YtK+j4iIiIiIoNjROnAQMGIDMzE7Nnz8Z3330HAHBxccHq1avRt2/fAg+QiIiIqLhQax6n3CQkJMDY2BglSpQoyJg+CZzHiYiI6PNQ4PM4vS87OxuHDx/Gr7/+Clne9eTJE6SlpeVnc0RERESfBI0v1d2/fx+tW7fGgwcPkJmZiVatWsHMzAzz589HZmYm1qxZUxhxEhERERU5jXucRo0ahTp16uD58+cwNjaWl3fu3BlRUVEFGhwRERFRcaJx4vTPP/9g6tSpMDAwUCh3cXHB48ePNQ4gLCwMLi4uMDIygpeXF06fPp1n/Z07d6Jy5cowMjJC9erV8ccffygsF0IgJCQETk5OMDY2ho+PD2JiYhTq3Lp1C506dYKtrS3Mzc3RuHFjHD16VOPYiYiI6MuiceIklUqRk5OjVP7o0SOYmZlptK3w8HAEBwdj+vTpOH/+PGrWrAlfX188e/ZMZf0TJ06gZ8+eGDhwIC5cuAA/Pz/4+fnh6tWr8joLFizAihUrsGbNGpw6dQqmpqbw9fXF69ev5XXat2+P7OxsHDlyBOfOnUPNmjXRvn17xMXFaRQ/ERERfWGEhnr06CEGDx4shBCiRIkS4u7du+Lly5eiRYsWol+/fhptq169eiIoKEj+OicnRzg7O4u5c+fmuu927doplHl5eYmvv/5aCCGEVCoVjo6OYuHChfLlL168EIaGhmL79u1CCCESEhIEAHHs2DF5ndTUVAFAREZGqh17SkqKACBSUlLUXoeIiIiKH00+0zUeHL548WL4+vrC3d0dr1+/Rq9evRATEwNbW1ts375d7e28efMG586dw6RJk+RlOjo68PHxQXR0tMp1oqOjERwcrFDm6+uLvXv3AgBiY2MRFxcHHx8f+XILCwt4eXkhOjoaAQEBsLGxQaVKlbBp0ybUrl0bhoaG+OGHH2Bvbw9PT89c483MzERmZqb8dWpqKoC3dxhmZ2erfdxERERUvGjyOa5x4lSqVClcunQJ4eHhuHTpEtLS0jBw4ED07t1bYbD4hyQmJiInJwcODg4K5Q4ODrhx44bKdeLi4lTWl11ik/2bVx2JRILDhw/Dz88PZmZm0NHRgb29PSIiImBlZZVrvHPnzkVoaKhS+cmTJ2FqavqBoyUiIqLiKj09Xe26GidOAKCnp4fevXujd+/e+Vm9SAkhEBQUBHt7e/zzzz8wNjbGjz/+iA4dOuDMmTNwcnJSud6kSZMUertSU1NRunRp1K9fnxNgEhERfcJkV5HUoXHitHHjRtja2qJdu3YAgPHjx2Pt2rVwd3fH9u3bUbZsWbW2Y2trC11dXcTHxyuUx8fHw9HRUeU6jo6OedaX/RsfH6+QAMXHx8PDwwMAcOTIERw4cADPnz+XJzzff/89IiMjsXHjRkycOFHlvg0NDWFoaKhUrqenBz29fOWfREREVAxo8jmu8V11c+bMkV+Si46OxqpVq7BgwQLY2tpizJgxam/HwMAAnp6eCnM/SaVSREVFoUGDBirXadCggdJcUZGRkfL6rq6ucHR0VKiTmpqKU6dOyeu8evUKwNvxVO/S0dGBVCpVO34iIiL6Amk68tzY2Fjcv39fCCHE+PHjRZ8+fYQQQly9elXY2tpqtK0dO3YIQ0NDsWHDBnHt2jUxZMgQYWlpKeLi4oQQQvTp00dMnDhRXv/48eNCT09PLFq0SFy/fl1Mnz5d6OvriytXrsjrzJs3T1haWop9+/aJy5cvi06dOglXV1eRkZEhhHh7V52NjY3o0qWLuHjxorh586YYO3as0NfXFxcvXlQ7dt5VR0RE9Hko1LvqSpQogaSkJJQpUwZ//vmnfNyPkZERMjIyNNqWv78/EhISEBISgri4OHh4eCAiIkI+uPvBgwcKPUMNGzbEtm3bMHXqVEyePBlubm7Yu3cvqlWrJq8zfvx4pKenY8iQIXjx4gUaN26MiIgIGBkZAXh7iTAiIgJTpkxBixYtkJWVhapVq2Lfvn2oWbOmps1BREREXxCJEP//Kb1q6t27N27cuIFatWph+/btePDgAWxsbLB//35MnjxZYTLKz5kmT1ImIiKi4kuTz3SNxziFhYWhQYMGSEhIwO7du2FjYwMAOHfuHHr27Jm/iImIiIg+ARr3ONFb7HEiIiL6PBR4j9ODBw80CiA/D/slIiIiKu7USpzq1q2Lr7/+GmfOnMm1TkpKCtatW4dq1aph9+7dBRYgERERUXGh1l11165dw+zZs9GqVSsYGRnB09MTzs7OMDIywvPnz3Ht2jX8999/qF27NhYsWIC2bdsWdtxEREREWqfRGKeMjAz8/vvv+Pfff3H//n1kZGTA1tYWtWrVgq+vr8K0AJ87jnEiIiL6PGjymc7B4fnExImIiOjzUKjTERARERF9qZg4EREREamJiRMRERGRmpg4EREREamJiRMRERGRmvKVOG3evBmNGjWCs7Mz7t+/DwBYtmwZ9u3bV6DBERERERUnGidOq1evRnBwMNq2bYsXL14gJycHAGBpaYlly5YVdHxERERExYbGidPKlSuxbt06TJkyBbq6uvLyOnXq4MqVKwUaHBEREVFxonHiFBsbi1q1aimVGxoaIj09vUCCIiIiIiqONE6cXF1dcfHiRaXyiIgIVKlSpSBiIiIiIiqW1HrI77uCg4MRFBSE169fQwiB06dPY/v27Zg7dy5+/PHHwoiRiIiIqFjQOHEaNGgQjI2NMXXqVLx69Qq9evWCs7Mzli9fjoCAgMKIkYiIiKhY+KiH/L569QppaWmwt7cvyJg+CXzILxER0edBk890jXuc3mViYgITE5OP2QQRERHRJ0PjxCkpKQkhISE4evQonj17BqlUqrA8OTm5wIIjIiIiKk40Tpz69OmD27dvY+DAgXBwcIBEIimMuIiIiIiKHY0Tp3/++Qf//vsvatasWRjxEBERERVbGs/jVLlyZWRkZBRGLERERETFmsaJ0/fff48pU6bg77//RlJSElJTUxV+iIiIiD5XGl+qs7S0RGpqKlq0aKFQLoSARCKRP/SXiIiI6HOjceLUu3dv6OvrY9u2bRwcTkRERF8UjROnq1ev4sKFC6hUqVJhxENERERUbGk8xqlOnTp4+PBhYcRCREREVKxpnDiNGDECo0aNwoYNG3Du3DlcvnxZ4UdTYWFhcHFxgZGREby8vHD69Ok86+/cuROVK1eGkZERqlevjj/++ENhuRACISEhcHJygrGxMXx8fBATE6O0nd9//x1eXl4wNjaGlZUV/Pz8NI6diIiIvjBCQxKJROlHR0dH/q8mduzYIQwMDMTPP/8s/vvvPzF48GBhaWkp4uPjVdY/fvy40NXVFQsWLBDXrl0TU6dOFfr6+uLKlSvyOvPmzRMWFhZi79694tKlS6Jjx47C1dVVZGRkyOvs2rVLWFlZidWrV4ubN2+K//77T4SHh2sUe0pKigAgUlJSNFqPiIiIihdNPtM1fsjv/fv381xetmxZtbfl5eWFunXrYtWqVQAAqVSK0qVLY8SIEZg4caJSfX9/f6Snp+PAgQPysvr168PDwwNr1qyBEALOzs749ttvMXbsWABASkoKHBwcsGHDBgQEBCA7OxsuLi4IDQ3FwIED1Y71fXzILxER0eehUB/yq0lilJc3b97g3LlzmDRpkrxMR0cHPj4+iI6OVrlOdHQ0goODFcp8fX2xd+9eAEBsbCzi4uLg4+MjX25hYQEvLy9ER0cjICAA58+fx+PHj6Gjo4NatWohLi4OHh4eWLhwIapVq5ZrvJmZmcjMzJS/ls1ZlZ2djezsbI2Pn4iIiIoHTT7H1Uqc9u/fjzZt2kBfXx/79+/Ps27Hjh3V2nFiYiJycnLg4OCgUO7g4IAbN26oXCcuLk5l/bi4OPlyWVlude7evQsAmDFjBpYsWQIXFxcsXrwYzZo1w61bt2Btba1y33PnzkVoaKhS+cmTJ2FqavqhwyUiIqJiKj09Xe26aiVOfn5+iIuLg729fZ6DqD+FCTClUikAYMqUKejatSsAYP369ShVqhR27tyJr7/+WuV6kyZNUujtSk1NRenSpVG/fn1eqiMiIvqEafLkE7USJ6lUigcPHkAIIU88PpatrS10dXURHx+vUB4fHw9HR0eV6zg6OuZZX/ZvfHw8nJycFOp4eHgAgLzc3d1dvtzQ0BDlypXDgwcPco3X0NAQhoaGSuV6enrQ09P4iicREREVE5p8jqs9HYGrqysSEhLyFZAqBgYG8PT0RFRUlLxMKpUiKioKDRo0ULlOgwYNFOoDQGRkpLy+q6srHB0dFeqkpqbi1KlT8jqenp4wNDTEzZs35XWysrJw7969Ahu/RURERJ8ntVMsDW++U0twcDACAwNRp04d1KtXD8uWLUN6ejr69+8PAOjbty9KliyJuXPnAgBGjRoFb29vLF68GO3atcOOHTtw9uxZrF27FsDbS4WjR4/GrFmz4ObmBldXV0ybNg3Ozs7yS4zm5uYYOnQopk+fjtKlS6Ns2bJYuHAhAKB79+4FfoxERET0+dDoGlNBP5fO398fCQkJCAkJkd/dFhERIR/c/eDBA+jo/F+nWMOGDbFt2zZMnToVkydPhpubG/bu3atwN9z48eORnp6OIUOG4MWLF2jcuDEiIiJgZGQkr7Nw4ULo6emhT58+yMjIgJeXF44cOQIrK6sCPT4iIiL6vKg9j5OOjg6GDBkCExOTPOstWbKkQAIr7jiPExER0eeh0OZxunLlCgwMDHJdXtA9UkRERETFiUaJ0549e2Bvb19YsRAREREVa2rfVcfeJCIiIvrSqZ04FcZddURERESfErUTp/Xr18PCwqIwYyEiIiIq1tQe4xQYGFiYcRAREREVe2r3OBERERF96Zg4EREREamJiRMRERGRmjSax+ldb968wbNnzyCVShXKy5Qp89FBERERERVHGidOMTExGDBgAE6cOKFQLoSARCJBTk5OgQVHREREVJxonDj169cPenp6OHDgAJycnDgxJhEREX0xNE6cLl68iHPnzqFy5cqFEQ8RERFRsaXx4HB3d3ckJiYWRixERERExZrGidP8+fMxfvx4/PXXX0hKSkJqaqrCDxEREdHnSiI0fAidjs7bXOv9sU1f2uDw1NRUWFhYICUlBebm5kUdDhEREeWTJp/pGo9xOnr0aL4DIyIiIvqUaZw4eXt7F0YcRERERMVevibAfPHiBX766Sdcv34dAFC1alUMGDAAFhYWBRocERERUXGi8eDws2fPonz58li6dCmSk5ORnJyMJUuWoHz58jh//nxhxEhERERULGg8OLxJkyaoUKEC1q1bBz29tx1W2dnZGDRoEO7evYtjx44VSqDFDQeHExERfR40+UzXOHEyNjbGhQsXlCbAvHbtGurUqYNXr15pHvEniIkTERHR50GTz3SNL9WZm5vjwYMHSuUPHz6EmZmZppsjIiIi+mRonDj5+/tj4MCBCA8Px8OHD/Hw4UPs2LEDgwYNQs+ePQsjRiIiIqJiQeO76hYtWgSJRIK+ffsiOzsbAKCvr49vvvkG8+bNK/AAiYiIiIoLjcc4ybx69Qp37twBAJQvXx4mJiYFGlhxxzFOREREn4dCnTlcxsTEBNWrV8/v6kRERESfHLUSpy5dumDDhg0wNzdHly5d8qz766+/FkhgRERERMWNWomThYWF/KG+5ubmSg/4JSIiIvoS5HuM05eOY5yIiIg+D4U6j1OLFi3w4sULlTtt0aKFppsDAISFhcHFxQVGRkbw8vLC6dOn86y/c+dOVK5cGUZGRqhevTr++OMPheVCCISEhMDJyQnGxsbw8fFBTEyMym1lZmbCw8MDEokEFy9ezFf8RERE9GXQOHH666+/8ObNG6Xy169f459//tE4gPDwcAQHB2P69Ok4f/48atasCV9fXzx79kxl/RMnTqBnz54YOHAgLly4AD8/P/j5+eHq1avyOgsWLMCKFSuwZs0anDp1CqampvD19cXr16+Vtjd+/Hg4OztrHDcRERF9edS+VHf58mUAgIeHB44cOQJra2v5spycHEREROCHH37AvXv3NArAy8sLdevWxapVqwAAUqkUpUuXxogRIzBx4kSl+v7+/khPT8eBAwfkZfXr14eHhwfWrFkDIQScnZ3x7bffYuzYsQCAlJQUODg4YMOGDQgICJCvd/DgQQQHB2P37t2oWrUqLly4AA8PD7Xi5qU6IiKiz0OhTEcgu5wlkUhUXpIzNjbGypUrNQr0zZs3OHfuHCZNmiQv09HRgY+PD6Kjo1WuEx0djeDgYIUyX19f7N27FwAQGxuLuLg4+Pj4yJdbWFjAy8sL0dHR8sQpPj4egwcPxt69e9WagyozMxOZmZny16mpqQDePuBYNhEoERERfXo0+RxXO3GKjY2FEALlypXD6dOnYWdnJ19mYGAAe3t76OrqahRoYmIicnJy4ODgoFDu4OCAGzduqFwnLi5OZf24uDj5cllZbnWEEOjXrx+GDh2KOnXqqNVLNnfuXISGhiqVnzx5Eqamph9cn4iIiIqn9PR0teuqnTiVLVsWwNtLaZ+6lStX4uXLlwo9XR8yadIkhZ6u1NRUlC5dGvXr1+elOiIiok+Y7CqSOvI9c/i1a9fw4MEDpYHiHTt2VHsbtra20NXVRXx8vEJ5fHw8HB0dVa7j6OiYZ33Zv/Hx8XByclKoIxu/dOTIEURHR8PQ0FBhO3Xq1EHv3r2xceNGpf0aGhoq1QcAPT096OnluxmJiIioiGnyOa7xJ/7du3fRuXNnXLlyBRKJBLKx5bJJMXNyctTeloGBATw9PREVFQU/Pz8Ab3u0oqKiMHz4cJXrNGjQAFFRURg9erS8LDIyEg0aNAAAuLq6wtHREVFRUfJEKTU1FadOncI333wDAFixYgVmzZolX//Jkyfw9fVFeHg4vLy81I6fiIiIviwaJ06jRo2Cq6sroqKi4OrqitOnTyMpKQnffvstFi1apHEAwcHBCAwMRJ06dVCvXj0sW7YM6enp6N+/PwCgb9++KFmyJObOnSvfv7e3NxYvXox27dphx44dOHv2LNauXQvgbQI3evRozJo1C25ubnB1dcW0adPg7OwsT87KlCmjEEOJEiUAvH1YcalSpTQ+BiIiIvoyaJw4RUdH48iRI7C1tYWOjg50dHTQuHFjzJ07FyNHjsSFCxc02p6/vz8SEhIQEhKCuLg4eHh4ICIiQj64+8GDB9DR+b/ppho2bIht27Zh6tSpmDx5Mtzc3LB3715Uq1ZNXmf8+PFIT0/HkCFD8OLFCzRu3BgREREwMjLS9HCJiIiI5DR+5IqVlRXOnz8PV1dXlC9fHj/++COaN2+OO3fuoHr16nj16lVhxVqscB4nIiKiz0OhzOMkU61aNVy6dAmurq7w8vLCggULYGBggLVr16JcuXL5DpqIiIiouNM4cZo6dap8voOZM2eiffv2aNKkCWxsbBAeHl7gARIREREVFxpfqlMlOTkZVlZW8jvrvgS8VEdERPR50OQzXeOH/Mrcvn0bhw4dQkZGhsJz64iIiIg+VxonTklJSWjZsiUqVqyItm3b4unTpwCAgQMH4ttvvy3wAImIiIiKC40TpzFjxkBfXx8PHjxQeDiuv78/IiIiCjQ4IiIiouJE48Hhf/75Jw4dOqQ0UaSbmxvu379fYIERERERFTca9zilp6cr9DTJJCcnq3yWGxEREdHnQuPEqUmTJti0aZP8tUQigVQqxYIFC9C8efMCDY6IiIioONH4Ut2CBQvQsmVLnD17Fm/evMH48ePx33//ITk5GcePHy+MGImIiIiKBY17nKpVq4Zbt26hcePG6NSpE9LT09GlSxdcuHAB5cuXL4wYiYiIiIoFjXqcsrKy0Lp1a6xZswZTpkwprJiIiIiIiiWNepz09fVx+fLlwoqFiIiIqFjT+FLd//73P/z000+FEQsRERFRsabx4PDs7Gz8/PPPOHz4MDw9PWFqaqqwfMmSJQUWHBEREVFxonHidPXqVdSuXRsAcOvWLYVlX9JDfomIiOjLo3HidPTo0cKIg4iIiKjYU3uMU05ODi5fvoyMjAylZRkZGbh8+TKkUmmBBkdERERUnKidOG3evBkDBgyAgYGB0jJ9fX0MGDAA27ZtK9DgiIiIiIoTtROnn376CWPHjoWurq7SMj09PYwfPx5r164t0OCIiIiIihO1E6ebN2+ifv36uS6vW7curl+/XiBBERERERVHaidO6enpSE1NzXX5y5cv8erVqwIJioiIiKg4UjtxcnNzw4kTJ3Jd/u+//8LNza1AgiIiIiIqjtROnHr16oWpU6eqfOTKpUuXEBISgl69ehVocERERETFiUQIIdSpmJWVha+++gr//vsvfHx8ULlyZQDAjRs3cPjwYTRq1AiRkZHQ19cv1ICLi9TUVFhYWCAlJQXm5uZFHQ4RERHlkyaf6WonTsDb5Gnp0qXYtm0bYmJiIIRAxYoV0atXL4wePVrlVAWfKyZOREREn4dCS5zo/zBxIiIi+jxo8pmu9hgnIiIioi8dEyciIiIiNTFxIiIiIlJTsUicwsLC4OLiAiMjI3h5eeH06dN51t+5cycqV64MIyMjVK9eHX/88YfCciEEQkJC4OTkBGNjY/j4+CAmJka+/N69exg4cCBcXV1hbGyM8uXLY/r06Xjz5k2hHB8RERF9Hoo8cQoPD0dwcDCmT5+O8+fPo2bNmvD19cWzZ89U1j9x4gR69uyJgQMH4sKFC/Dz84Ofnx+uXr0qr7NgwQKsWLECa9aswalTp2BqagpfX1+8fv0awNspFKRSKX744Qf8999/WLp0KdasWYPJkydr5ZiJiApCUlISvg0NRVJSUlGHQl8InnP5uKsuODhY9YYkEhgZGaFChQro1KkTrK2t1dqel5cX6tati1WrVgEApFIpSpcujREjRmDixIlK9f39/ZGeno4DBw7Iy+rXrw8PDw+sWbMGQgg4Ozvj22+/xdixYwEAKSkpcHBwwIYNGxAQEKAyjoULF2L16tW4e/euWnHzrjoiKkpJSUkInDIFTxo2hPOJE9g4ezZsbGyKOiz6jH3O55wmn+l6mm78woULOH/+PHJyclCpUiUAwK1bt6Crq4vKlSvj+++/x7fffot///0X7u7ueW7rzZs3OHfuHCZNmiQv09HRgY+PD6Kjo1WuEx0drZS8+fr6Yu/evQCA2NhYxMXFwcfHR77cwsICXl5eiI6OzjVxSklJyTPZy8zMRGZmpvy17Ll92dnZyM7OzvM4iYgKUlJSEgaEhCC5c2eYOzggyd4efSdPxs8zZ342H2RUvHzu55wmn+MaJ06y3qT169fLs7KUlBQMGjQIjRs3xuDBg9GrVy+MGTMGhw4dynNbiYmJyMnJgYODg0K5g4MDbty4oXKduLg4lfXj4uLky2VludV53+3bt7Fy5UosWrQo11jnzp2L0NBQpfKTJ0/C1NQ01/WI6PMWeDCt0PeRcmo3XsWclL/OFhmQ9vKH5O4D4O4DAIAwt4Jz7frQkxjL65m41YeFV9dCi2tjmxKFtm3KHc+5gpeenq52XY0Tp4ULFyIyMlKhK8vCwgIzZszAV199hVGjRiEkJARfffWVppsuEo8fP0br1q3RvXt3DB48ONd6kyZNUujpSk1NRenSpVG/fn1eqiP6kh3M+wtiQbDw6qrwYZSTkYrEMzshdfOAxMYOIikBOmduwbbbHOgaa+/9qFGjRlrbF72D51yBk11FUofGiVNKSgqePXumdBkuISFBvmNLS0u17lCztbWFrq4u4uPjFcrj4+Ph6Oioch1HR8c868v+jY+Ph5OTk0IdDw8PhfWePHmC5s2bo2HDhli7dm2esRoaGsLQ0FCpXE9PD3p6GjcjEVG+6Rqbw7ZmdyRu+wU5vs2he+gobGt21+oHGAC+931BPvdzTpPtanxXXadOnTBgwADs2bMHjx49wqNHj7Bnzx4MHDgQfn5+AIDTp0+jYsWKH9yWgYEBPD09ERUVJS+TSqWIiopCgwYNVK7ToEEDhfoAEBkZKa/v6uoKR0dHhTqpqak4deqUwjYfP36MZs2awdPTE+vXr4eOTpHfYEhEpDbZB5lR1Lki+QCjLw/Pubc0Tt1++OEHjBkzBgEBAfLBVHp6eggMDMTSpUsBAJUrV8aPP/6o1vaCg4MRGBiIOnXqoF69eli2bBnS09PRv39/AEDfvn1RsmRJzJ07FwAwatQoeHt7Y/HixWjXrh127NiBs2fPynuMJBIJRo8ejVmzZsHNzQ2urq6YNm0anJ2d5YmdLGkqW7YsFi1ahISEBHk8ufV0EREVN7rG5rCu072ow6AvCM+5fCROJUqUwLp167B06VL5rfvlypVDiRL/N2Dr/UtiefH390dCQgJCQkIQFxcHDw8PREREyAd3P3jwQKE3qGHDhti2bRumTp2KyZMnw83NDXv37kW1atXkdcaPH4/09HQMGTIEL168QOPGjREREQEjIyMAb3uobt++jdu3b6NUqVIK8fCZx0RERJQbjedx2rJlC7p06QITE5PCiumTwHmciAgAXCb+XtQhFJl789oVdQhfJJ5zBU+Tz3SNB/aMGTMG9vb26NWrF/744w/k5OTkO1AiIiKiT4nGidPTp0+xY8cOSCQS9OjRA05OTggKCsKJEycKIz4iIiKiYkPjxElPTw/t27fH1q1b8ezZMyxduhT37t1D8+bNUb58+cKIkYiIiKhY+KgJEUxMTODr64vnz5/j/v37uH79ekHFRURERFTs5GvyolevXmHr1q1o27YtSpYsiWXLlqFz587477//Cjo+IiIiomJD4x6ngIAAHDhwACYmJujRowemTZuW62SVRERERJ8TjRMnXV1d/PLLL/D19YWurq7CsqtXryrMp0RERET0OdE4cdq6davC65cvX2L79u348ccfce7cOU5PQERERJ+tfD+g7dixYwgMDISTkxMWLVqEFi1a4OTJkwUZGxEREVGxolGPU1xcHDZs2ICffvoJqamp6NGjBzIzM7F37164u7sXVoxERERExYLaPU4dOnRApUqVcPnyZSxbtgxPnjzBypUrCzM2KgJJSUn4NjQUSUlJRR3KJ4dtlz9sN9I2nnP0MdROnA4ePIiBAwciNDQU7dq1UxoYTp++pKQkBE6ZgqOurgicMoVvKhpg2+UP2420jeccfSy1E6d///0XL1++hKenJ7y8vLBq1SokJiYWZmykRbI3k6TOnWFRowaSOnfmm4qa2Hb5w3YjbeM5RwVB7TFO9evXR/369bFs2TKEh4fj559/RnBwMKRSKSIjI1G6dGmYmZkVZqxflMJ++nXKqd14FfN/g/mzRQakvfwhuXMfuHMfACDMLGFfow70JMbyeiZu9WHh1bXQ4vrYJ19r46nhbLv8Ka7tBhTeE9cpbzzn6FOk8XQEpqamGDBgAAYMGICbN2/ip59+wrx58zBx4kS0atUK+/fvL4w4qYBZeHVVeGPIyUhF4pmdkLp5QGJjB5GUAJ0zt2DbbQ50jc2LMNLih22XP2w30jaec1QY8j0dAQBUqlQJCxYswKNHj7B9+/aCiomKgK6xOWxrdofOtl8gvXUNOtt+gW3N7nwzUQPbLn/YbqRtPOeoIHxU4iSjq6sLPz8/9jZ94mRvKkZR5/hmoiG2Xf6w3UjbeM7Rx9L4Uh193nSNzWFdp3tRh/FJYtvlD9uNtI3nHH2MAulxIiIiIvoSMHEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUhMTJyIiIiI1MXEiIiIiUlOxSJzCwsLg4uICIyMjeHl54fTp03nW37lzJypXrgwjIyNUr14df/zxh8JyIQRCQkLg5OQEY2Nj+Pj4ICYmRqFOcnIyevfuDXNzc1haWmLgwIFIS0sr8GMjIiKiz0eRJ07h4eEIDg7G9OnTcf78edSsWRO+vr549uyZyvonTpxAz549MXDgQFy4cAF+fn7w8/PD1atX5XUWLFiAFStWYM2aNTh16hRMTU3h6+uL169fy+v07t0b//33HyIjI3HgwAEcO3YMQ4YMKfTjJSIiok9XkSdOS5YsweDBg9G/f3+4u7tjzZo1MDExwc8//6yy/vLly9G6dWuMGzcOVapUwXfffYfatWtj1apVAN72Ni1btgxTp05Fp06dUKNGDWzatAlPnjzB3r17AQDXr19HREQEfvzxR3h5eaFx48ZYuXIlduzYgSdPnmjr0ImIiOgTo1eUO3/z5g3OnTuHSZMmyct0dHTg4+OD6OholetER0cjODhYoczX11eeFMXGxiIuLg4+Pj7y5RYWFvDy8kJ0dDQCAgIQHR0NS0tL1KlTR17Hx8cHOjo6OHXqFDp37qy038zMTGRmZspfp6SkAHh7yS87O1vzgyeVkpOTizqETxbbLv/YdvnDdss/tl3+FFa7paamAnjb+fIhRZo4JSYmIicnBw4ODgrlDg4OuHHjhsp14uLiVNaPi4uTL5eV5VXH3t5eYbmenh6sra3ldd43d+5chIaGKpW7urrmdniUDzbzizqCTxfbLv/YdvnDdss/tl3+FHa7vXz5EhYWFnnWKdLE6VMyadIkhZ4uqVSK5ORk2NjYQCKRFGFkBSs1NRWlS5fGw4cPYW5uXtThfFLYdvnDdss/tl3+sN3y73NtOyEEXr58CWdn5w/WLdLEydbWFrq6uoiPj1coj4+Ph6Ojo8p1HB0d86wv+zc+Ph5OTk4KdTw8POR13h98np2djeTk5Fz3a2hoCENDQ4UyS0vLvA/wE2Zubv5Z/VFoE9suf9hu+ce2yx+2W/59jm33oZ4mmSIdHG5gYABPT09ERUXJy6RSKaKiotCgQQOV6zRo0EChPgBERkbK67u6usLR0VGhTmpqKk6dOiWv06BBA7x48QLnzp2T1zly5AikUim8vLwK7PiIiIjo81Lkl+qCg4MRGBiIOnXqoF69eli2bBnS09PRv39/AEDfvn1RsmRJzJ07FwAwatQoeHt7Y/HixWjXrh127NiBs2fPYu3atQAAiUSC0aNHY9asWXBzc4OrqyumTZsGZ2dn+Pn5AQCqVKmC1q1bY/DgwVizZg2ysrIwfPhwBAQEqNVNR0RERF+mIk+c/P39kZCQgJCQEMTFxcHDwwMRERHywd0PHjyAjs7/dYw1bNgQ27Ztw9SpUzF58mS4ublh7969qFatmrzO+PHjkZ6ejiFDhuDFixdo3LgxIiIiYGRkJK+zdetWDB8+HC1btoSOjg66du2KFStWaO/AiylDQ0NMnz5d6bIkfRjbLn/YbvnHtssftlv+se0AiVDn3jsiIiIiKvoJMImIiIg+FUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNTExImIiIhITXpFHcCnSiqV4smTJzAzM4NEIinqcIiIiCifhBB4+fIlnJ2doaOTd58SE6d8evLkCUqXLl3UYRAREVEBefjwIUqVKpVnHSZO+WRmZgbgbSObm5sXcTRERESUX6mpqShdurT8sz0vTJzySXZ5ztzcnIkTERHRZ0CdoTccHE5ERESkJiZORERERGpi4kRERESkJo5xKmQ5OTnIysoq6jAoHwwMDD54WyoREX1ZvtjE6eHDh+jTpw+ePXsGPT09TJs2Dd27dy+w7QshEBcXhxcvXhTYNkm7dHR04OrqCgMDg6IOhYiIigmJEEIUdRBF4enTp4iPj4eHhwfi4uLg6emJW7duwdTUVK31U1NTYWFhgZSUFJV31T19+hQvXryAvb09TExMOEnmJ0Y2wam+vj7KlCnD3x8R0WfsQ5/p7/pie5ycnJzg5OQEAHB0dIStrS2Sk5PVTpzykpOTI0+abGxsPnp7VDTs7Ozw5MkTZGdnQ19fv6jDISKiYuCTHcBx7NgxdOjQAc7OzpBIJNi7d69SnbCwMLi4uMDIyAheXl44ffq0ym2dO3cOOTk5BTYTuGxMk4mJSYFsj4qG7BJdTk5OEUdCRETFxSebOKWnp6NmzZoICwtTuTw8PBzBwcGYPn06zp8/j5o1a8LX1xfPnj1TqJecnIy+ffti7dq1BR4jL+982vj7IyKi932yl+ratGmDNm3a5Lp8yZIlGDx4MPr37w8AWLNmDX7//Xf8/PPPmDhxIgAgMzMTfn5+mDhxIho2bJjn/jIzM5GZmSl/nZqaCgDIzs5Gdna2Qt3s7GwIIeQ/9GmS/f5U/Y6JiOjzocl7/CebOOXlzZs3OHfuHCZNmiQv09HRgY+PD6KjowG8/VDs168fWrRogT59+nxwm3PnzkVoaKhS+cmTJ5XGRUkkEpiZmeHVq1ef3Qeuubk5tm3bhvbt2xd1KHkqiDjfvHmDzMxMnD9/ngkwEdFnLD09Xe26n2XilJiYiJycHDg4OCiUOzg44MaNGwCA48ePIzw8HDVq1JCPj9q8eTOqV6+ucpuTJk1CcHCw/LXsgYD169dXGoH/+vVrPHjwACYmJjAyMpKXb7z5ogCOTn2BlSw1Xqd///7YuHGjUrmvry8OHjwIADAyMkKJEiU+NrxC97Fxvn79GoaGhnBzc1P4PRIR0edFdhVJHZ9l4qSOxo0bQyqVql3f0NAQhoaGSuV6enrQ09NTKpNIJPKf/6PdMTP5HaPTunVrrF+/XqHM0NBQvj3l4yqePjZO2fqqfsdERPT50OQ9/pMdHJ4XW1tb6OrqIj4+XqE8Pj4ejo6ORRTVp8PQ0BCOjo4KP1ZWVirrTpgwARUrVoSJiQnKlSuHadOmKcyUPmPGDHh4eOCHH35A6dKlYWJigh49eiAlJUVe56+//kK9evVgamoKS0tLNGrUCPfv35cv37dvH2rXrg0jIyOUK1cOoaGhCpdAY2Ji0LRpUxgZGcHd3R2RkZGF0CpERERFlDi9O8i6MBgYGMDT0xNRUVHyMqlUiqioKDRo0OCjth0WFgZ3d3fUrVv3Y8P8LJiZmWHDhg24du0ali9fjnXr1mHp0qUKdW7fvo1ffvkFv/32GyIiInDhwgUMGzYMwNsBeX5+fvD29sbly5cRHR2NIUOGyHuK/vnnH/Tt2xejRo3CtWvX8MMPP2DDhg2YPXs2gLe/1y5dusDAwACnTp3CmjVrMGHCBO02AhERfTG0kjgdPHgQgYGBKFeuHPT19WFiYgJzc3N4e3tj9uzZePLkicbbTEtLw8WLF3Hx4kUAQGxsLC5evIgHDx4AAIKDg7Fu3Tps3LgR169fxzfffIP09HT5XXb5FRQUhGvXruHMmTMftZ3i7MCBAyhRooTCz5w5c1TWnTp1Kho2bAgXFxd06NABY8eOxS+//KJQ5/Xr19i0aRM8PDzQtGlTrFy5Ejt27EBcXBxSU1ORkpKC9u3bo3z58qhSpQoCAwNRpkwZAEBoaCgmTpwoP39atWqF7777Dj/88AMA4PDhw7hx4wY2bdqEmjVromnTprnGSkRE9LEKdeDGnj17MGHCBLx8+RJt27bFhAkT4OzsDGNjYyQnJ+Pq1as4fPgwvvvuO/Tr1w/fffcd7Ozs1Nr22bNn0bx5c/lr2cDtwMBAbNiwAf7+/khISEBISAji4uLg4eGBiIgIpQHjpKx58+ZYvXq1Qpm1tbXKuuHh4VixYgXu3LmDtLQ0ZGdnKw2WL1OmDEqWLCl/3aBBA0ilUty8eRPe3t7o168ffH190apVK/j4+KBHjx7yWd0vXbqE48ePy3uYgLcTUr5+/RqvXr3C9evXUbp0aTg7OytsvzBFRUXhyJEjSuUZGRmIiYmBm5sbjI2NlZa3aNECLVu2LNTYiIiocBVq4rRgwQIsXboUbdq0UfmU+R49egAAHj9+jJUrV2LLli0YM2aMWttu1qzZB28RHz58OIYPH6554F84U1NTVKhQ4YP1oqOj0bt3b4SGhsLX1xcWFhbYsWMHFi9erNH+1q9fj5EjRyIiIgLh4eGYOnUqIiMjUb9+faSlpSE0NBRdunRRWq+o7nRr2bKlygTo9OnT6DpgAKZNm4Z69eoVQWRERFTYCjVxks2Z9CElS5bEvHnzCjOUAhMWFoawsDA+hgPAiRMnULZsWUyZMkVe9u6gbpkHDx7gyZMn8l6hkydPQkdHB5UqVZLXqVWrFmrVqoVJkyahQYMG2LZtG+rXr4/atWvj5s2buSZyVapUwcOHD/H06VN5L9XJkycL8jDVkpSUhAkrV+KFnx8mrFyJXcuW8TmFRESfId5jraGgoCAEBQXJn6T8OcrMzERcXJxCmZ6eHmxtbRXK3Nzc8ODBA+zYsQN169bF77//jj179ihtz8jICIGBgVi0aBFSU1MxcuRI9OjRA46OjoiNjcXatWvRsWNHODs74+bNm4iJiUHfvn0BACEhIWjfvj3KlCmDbt26QUdHB5cuXcLVq1cxa9Ys+Pj4oGLFiggMDMTChQuRmpqqkMhpQ1JSEgKnTMGLrl2h9/w5XtSpg8ApU7Bx9mwmT0REnxmtJU5du3ZFvXr1lO54WrBgAc6cOYOdO3dqKxT6gIiICHnvjUylSpXkk4fKdOzYEWPGjMHw4cORmZmJdu3aYdq0aZgxY4ZCvQoVKqBLly5o27YtkpOT0b59e3z//fcA3j4I+caNG9i4cSOSkpLg5OSEoKAgfP311wDeTrx54MABzJw5E/Pnz4e+vj4qV66MQYMGAXg7I/yePXswcOBA1KtXDy4uLlixYgVat26N1MwcJGbkf+b2rMxspGVJseduKjJ1Xudab8eaJbhR2wu6ZjZ4k5SMVDMbPK/thd7fLUHA0HH53r+6+lW2LPR9EBHRWxKhpWdJ2NnZ4ciRI0ozc1+5cgU+Pj5Kcy4Vd7Iep5SUFJUzh8fGxsLV1fWLn3F6xowZ2Lt3r/zuR235mIRJJivzNR49uI/benbI1DHItV7a82T8GDYHz9u3QWJ6CmxNLWB14CAGBU1GCSvVg+oLEhMnIqKPk9dn+vu0No9TWloaDAyUP3z09fU1muqcqLgpYWWNQUGTYbxzF3Lu3IHxzl1aS5qIiEi7tJY4Va9eHeHh4UrlO3bsgLu7u7bCICoUJays0d1/EEx270F3/0FMmoiIPlNaG+M0bdo0dOnSBXfu3EGLFi0AvJ0PZ/v27Z/U+CbeVaeZGTNmKI15+tRdi/4b108dUyp/k5GBMs5lcPr33bh45A+l5VW8msK9gbc2QiQi+iicry53WhvjBAC///475syZg4sXL8LY2Bg1atTA9OnT4e396X2YcIxT8abNMU5FjWOciEhbYmJiMGTIEKxduxZubm5FHU6B0WSMk1anI2jXrh3atWunzV0SEdEXir0mVBi0mji9ePECu3btwt27dzF27FhYW1vj/PnzcHBwUHgkBxER0cfKbZZ/Wa/JN99881n1mpB2aC1xunz5Mnx8fGBhYYF79+5h0KBBsLa2xq+//ooHDx5g06ZN2gqFiIiIKF+0dlddcHAw+vXrh5iYGIVxP23btsWxY8oDbYmIiKh4ef78OW4nJOD58+dFHUqR0VridObMGfls0O8qWbKk0uM9irOwsDC4u7ujbt26RR0KERHlAz/88+f9Z3ImJSUVdUhFQmuJk6GhocqJLm/dugU7OztthfHRgoKCcO3aNZw5c6aoQyEiIg3xwz9/FJ7JWb48XnTtisApU77I9tPaGKeOHTti5syZ+OWXXwAAEokEDx48wIQJE9C1a1dthVGkXCb+rtX93ZvHOxiJiGQ+twdyb7jxQmv74jM5/4/WEqfFixejW7dusLe3R0ZGBry9vREXF4cGDRpg9uzZ2gqD1PDw4UNMnz4dERERSExMhJOTE/z8/BASEqL1N5dmzZrBw8MDy5Yt0+p+iUh7tJUAFPWHP1C8EgBNtPcfiLiwOXj+/+c4yk54Bqtjx9E+aHIRR6Z9WkucLCwsEBkZiePHj+PSpUtIS0tD7dq14ePjo60QSA13795FgwYNULFiRWzfvh2urq7477//MG7cOBw8eBAnT56EtTUfJ0JEnx5++Oef7JmcqxZNQU6lcjC+eReDxs7+Ih8vpbUxTjKNGjXCsGHDMH78eNSpU0fbu6cPCAoKgoGBAf788094e3ujTJkyaNOmDQ4fPozHjx9jypQpAN5eat27d6/CupaWltiwYYP89YQJE1CxYkWYmJigXLlymDZtGrKysuTLZ8yYAQ8PD2zevBkuLi6wsLBAQEAAXr58CQDo168f/v77byxfvhwSiQQSiQT37t3Dhg0bYGlpqbDvvXv3QiKRyF8vmDUTzbw8sXXjenhULIeydpYYP2o4cnJysHLJIri7lEKVss5YMn9uwTYgERVbfCD3x+EzOd/SWuI0f/58hYf89ujRAzY2NihZsiQuXbqkrTAoD8nJyTh06BCGDRumNJuuo6MjevfujfDwcKj7lB4zMzNs2LAB165dw/Lly7Fu3TosXbpUoc6dO3ewd+9eHDhwAAcOHMDff/+NefPmAQCWL1+OBg0aYPDgwXj69CmePn2K0qVLq30892LvIurPQwjfdwBrN2zB1o3r0bNzRzx5/Aj7/4zCtO/mYG5oCM6dPqX2Nono08YP/49jam4JB0sbmJpbFnUoRUZridOaNWvkH3qRkZGIjIzEwYMH0aZNG4wbp51rywXhc56OICYmBkIIVKlSReXyKlWq4Pnz50hISFBre1OnTkXDhg3h4uKCDh06YOzYsfKbA2SkUik2bNiAatWqoUmTJujTpw+ioqIAvL28a2BgABMTEzg6OsLR0RG6urpqH4+QSrFizTpUquIO33bt0ahpM9yJuYXZC5egQsVK6NW3HypUrIR/j/2t9jaJ6NPHD3/6GFob4xQXFydPnA4cOIAePXrgq6++gouLC7y8vLQVxkcLCgpCUFCQ/IGAn6MP9SgZGKj3wNvw8HCsWLECd+7cQVpaGrKzs5Uenuji4gIzMzP5aycnJzx79kzzoFUoXdYFJd7Ztp2DPXR1daGj83/fF+zs7ZGYUDD7IyKiz5/WepysrKzw8OFDAEBERIR8ULgQAjk5OdoKg/JQoUIFSCQSXL9+XeXy69evw87ODpaWlpBIJEoJ1rvjl6Kjo9G7d2+0bdsWBw4cwIULFzBlyhS8efNGYR19fX2F1xKJBFKpNM84dXR08ty3jJ6e4vcCiUSSr/0RERHJaC1x6tKlC3r16oVWrVohKSkJbdq0AQBcuHABFSpU0FYYlAcbGxu0atUK33//PTIyMhSWxcXFYevWrejXrx8AwM7ODk+fPpUvj4mJwatXr+SvT5w4gbJly2LKlCmoU6cO3NzccP/+fY1jMjAwUEqs7ezs8PLlS6Snp8vLLl68qPG2iYiINKW1xGnp0qUYPnw43N3dERkZiRIlSgAAnj59imHDhmkrDPqAVatWITMzE76+vjh27BgePnyIiIgItGrVChUrVkRISAgAoEWLFli1ahUuXLiAs2fPYujQoQq9OW5ubnjw4AF27NiBO3fuYMWKFdizZ4/G8bi4uODUqVO4d+8eEhMTIZVK4eXlBRMTE0yePBl37tzBtm3bFO7mIyIiKixaG+Okr6+PsWPHKpWPGTNGWyEUuU9hJm83NzecOXMGM2bMQI8ePfDs2TMIIdClSxds3rwZJiYmAN5OaNq/f380adIEzs7OWL58Oc6dOyffTseOHTFmzBgMHz4cmZmZaNeuHaZNm4YZM2ZoFM/YsWMRGBgId3d3ZGRkIDY2Fi4uLtiyZQvGjRuHdevWoWXLlpgxYwaGDBlSkE1BRJ+4a9F/4/op5YfIv8nIgKGJKY5u/wkG791BDABVvJrCvYG3NkKkT5BEqHtveT6cPHkS9evXV6vuq1evEBsbi6pVqxZWOAVKNjg8JSVFacDz69evERsbC1dXVxgZGRVRhHlLTU2Vz5f0LqlUitevX8PIyEg+iHrRokVYt24dtm3bhmbNmikdb3GUmJH90dvIynyNRw/u47aeHTJ11BsQXxQ+1ZmIiWS0+eiQolaQf6+F2W55JZ3xD+7CoUw5rSadhf0+l9dn+vsKtcepT58+KFeuHAYNGoS2bdvC1NRUqc61a9ewZcsWrF+/HvPnz/9kEqdPnbm5ucqTIz09HXfu3YOzs7P897V06VLUqFEDd+/eRfv27bUdKhERaZl7A2/2uuWiUBOna9euYfXq1Zg6dSp69eqFihUrwtnZGUZGRnj+/Dlu3LiBtLQ0dO7cGX/++SeqV69emOHQB2RnZ+NRfDyyLS3xKD4e5cuUkd+Z1r9//yKOjoiIqOgVauKkr6+PkSNHYuTIkTh79iz+/fdf3L9/HxkZGahZsybGjBmD5s2bf1LPPgsLC0NYWNhnN4VCdnY2Yh8/Ro6VFSQ5OcgxMUHs48dwLVlS6bZ+IiKiL5XWPhHr1KnzWTybTtsTYBbEWB11JCfE47WJKSS6ehDZOcjR1UO2iSnuPomHtZ1Doe/f1pjJGRERFX9af8jvl+RTmljR0toWui/TILLfJmoiOxu6L9NgaW1bxJEVHdl9E4V29wQREX1y+DW/EBgYGEBHRwdPnjyBnZ0dDAwMIJFI8rWtrEzt9DgBgKWFNZIS4iEMDYDMN7C0dUBOdhZyspVn5S5oryUFeyp+bLsJIfDyeTKyBJBdwLGRoqSkJMxZtQqThw+HjY1NUYdDRJQnfiIUAh0dHbi6uuLp06d48uTJR20rLUu7vVbZb97g5cNkmFlaIzPzzYdXKCAv9Au287Mg2i1LAA/1bCCVsGO2IERFReHIkSMKZa9evcK+c+eQ1KwZ9nTujE6envK5wmRatGiBli1bajNUIqJcMXEqJAYGBihTpgyys7M/aiD5nrupBRjVhyXEP8Teld/Db8Rk2JW009p+O7sW7NxQH9tuAm97mpg0FZyWLVsqJEBJSUkInDIFFsHBeP78OSxq10ZMRAQ2Tp3KniciKraKJHGSTbD4uZM9VPb9B8tqIlPndQFG9H/ymtws+WU6ft+i3Rl1C/p8KKx2+xJoazLCHWuW4EZtL+ia2eBNUjJSzWzwvLYXen+3BAFDx2klBk4eSkSa0lriJJVKMXv2bKxZswbx8fG4desWypUrh2nTpsHFxQUDBw7UVigETm5GRa+9/0DEhc3B8/8/EWt2wjNYHTuO9kGTizgyIqLcaS1xmjVrFjZu3IgFCxZg8ODB8vJq1aph2bJlTJyIPnOqejkd9AzweNlSSH2a49Xho6hcuQYObQxTqMPnhqkeHwYAGRkZiImJgZubG4xV9BBzfBhRwdNa4rRp0yasXbsWLVu2xNChQ+XlNWvWxI0bN7QVBhEVkdx6OTs8T8aB8J/QfukmlLD6dCbD1ab3x4fJnD59Gl0HDMC0adNQr169IoiM6MujtZGvjx8/RoUKFZTKpVIpsrIK/3Z3IiqeSlhZI2DoOCZNGkpKSsKElSvxws8PE1auRFJSUlGHRPRF0Fri5O7ujn/++UepfNeuXahVq5a2wvhoYWFhcHd3R926dYs6FCL6QsnuSHzRtSv0ypfHi65dEThlCpMnIi3Q2qW6kJAQBAYG4vHjx5BKpfj1119x8+ZNbNq0CQcOHNBWGB9N249cIaJPg7buRgSK/o5E3o1IXzKt9Th16tQJv/32Gw4fPgxTU1OEhITg+vXr+O2339CqVStthUFE9Mlr7z8QlseOIzvhGYC3dyRaHjuO9v68yYaosGl1HqcmTZogMjJSm7skIvrslLCyxqCgyVi1aApyKpWD8c27GDR2NseJEWlBkUyLnJaWhtTUVIUfIiJSXwkra3T3HwST3XvQ3X8QkyYiLdFa4hQbG4t27drB1NQUFhYWsLKygpWVFSwtLWFlZaWtMIiIPhum5pZwsLSBqbllUYdC9MXQ2qW6//3vfxBC4Oeff4aDgwMkEom2dk1E9EnL6xFJhiamOLpdu49IIvqSaS1xunTpEs6dO4dKlSppa5dERJ8FPiKJqPjQ2qW6unXr4uHDh9raHREREVGB01qP048//oihQ4fi8ePHqFatGvT19RWW16hRQ1uhEBEREeWL1hKnhIQE3LlzB/3795eXSSQSCCEgkUiQk5OjrVCIiIiI8kVridOAAQNQq1YtbN++nYPDiYiI6JOktcTp/v372L9/v8oH/RIRERF9CrQ2OLxFixa4dOmStnZHREREVOC01uPUoUMHjBkzBleuXEH16tWVBod37NhRW6EQERER5YvWEqehQ4cCAGbOnKm0jIPDiYiI6FOgtUt1Uqk0159PKWkKCwuDu7s76tatW9ShEBERkZYVyUN+P2VBQUG4du0azpw5U9ShEBERkZYV6qW6FStWYMiQITAyMsKKFSvyrDty5MjCDIWIiIjooxVq4rR06VL07t0bRkZGWLp0aa71JBIJEyciIiIq9go1cYqNjcWxY8fQsGFDxMbGFuauiIiIiApdoY9xat68OZKTkwt7N0RERESFrtATJyFEYe+CiIiISCu0clcdn0tHREREnwOtTIDZr18/GBoa5lnn119/1UYoRERERPmmlcTJzMwMxsbG2tgVERERUaHRSuK0YsUK2Nvba2NXRERERIWm0Mc4cXwTERERfS54Vx0RERGRmgo9cTp69Cisra0LezdEREREha7Qxzh5e3sX9i6IiIiItEIr8zgRERERfQ6YOBERERGpiYkTERERkZq0Mo+TjFQqxe3bt/Hs2TNIpVKFZU2bNtVmKEREREQa01ridPLkSfTq1Qv3799XmqJAIpEgJydHW6EQERER5YvWEqehQ4eiTp06+P333+Hk5MSJMYmIiOiTo7XEKSYmBrt27UKFChW0tUsiIiKiAqW1weFeXl64ffu2tnanls6dO8PKygrdunUr6lCIiIjoE6C1HqcRI0bg22+/RVxcHKpXrw59fX2F5TVq1NBWKHKjRo3CgAEDsHHjRq3vm4iIiD49WkucunbtCgAYMGCAvEwikUAIUWSDw5s1a4a//vpL6/slIiKiT5PWLtXFxsYq/dy9e1f+r6aOHTuGDh06wNnZGRKJBHv37lWqExYWBhcXFxgZGcHLywunT58ugCMhIiKiL5XWepzKli1boNtLT09HzZo1MWDAAHTp0kVpeXh4OIKDg7FmzRp4eXlh2bJl8PX1xc2bN2Fvb1+gsRAREdGXQasTYN65cwfLli3D9evXAQDu7u4YNWoUypcvr/G22rRpgzZt2uS6fMmSJRg8eDD69+8PAFizZg1+//13/Pzzz5g4caLG+8vMzERmZqb8dWpqKgAgOzsb2dnZGm9PXQLiw5U+AwXdhl9KuwFsu49RkG3Hdss/tl3+sN2KZvtaS5wOHTqEjh07wsPDA40aNQIAHD9+HFWrVsVvv/2GVq1aFdi+3rx5g3PnzmHSpEnyMh0dHfj4+CA6Ojpf25w7dy5CQ0OVyk+ePAlTU9N8x/ohaablCm3bxcnx45cLdHtfSrsBbLuPUZBtx3bLP7Zd/rDdCk56erradbWWOE2cOBFjxozBvHnzlMonTJhQoIlTYmIicnJy4ODgoFDu4OCAGzduyF/7+Pjg0qVLSE9PR6lSpbBz5040aNBA5TYnTZqE4OBg+evU1FSULl0a9evXh7m5eYHF/r67t18W2raLk0YejQp0e19KuwFsu49RkG3Hdss/tl3+sN0Kjuwqkjq0ljhdv34dv/zyi1L5gAEDsGzZMm2FoeDw4cNq1zU0NIShoaFSuZ6eHvT0Cq8ZJfgyZlgv6Db8UtoNYNt9jIJsO7Zb/rHt8oftVjTb19pddXZ2drh48aJS+cWLFwt8sLatrS10dXURHx+vUB4fHw9HR8cC3RcRERF9ObTW4zR48GAMGTIEd+/eRcOGDQG8HeM0f/58hUtgBcHAwACenp6IioqCn58fAEAqlSIqKgrDhw//qG2HhYUhLCyMDyUmIiL6AmktcZo2bRrMzMywePFi+aBtZ2dnzJgxAyNHjtR4e2lpaQqPcImNjcXFixdhbW2NMmXKIDg4GIGBgahTpw7q1auHZcuWIT09XX6XXX4FBQUhKCgIqampsLCw+KhtERER0adFa4mTRCLBmDFjMGbMGLx8+XZAm5mZWb63d/bsWTRv3lz+WtZrFRgYiA0bNsDf3x8JCQkICQlBXFwcPDw8EBERoTRgnIiIiEhdWp3HSeZjEiaZZs2aQYi857AYPnz4R1+aIyIiIpIp1MSpdu3aiIqKgpWVFWrVqgWJJPc7AM6fP1+YoRQYjnEiIiL6chVq4tSpUyf5LfydOnXKM3H6VHCMExER0ZerUBOn6dOny/8/Y8aMwtwVERERUaHT2jxO5cqVQ1JSklL5ixcvUK7clzNtPBEREX26tJY43bt3T+W4oMzMTDx69EhbYRARERHlW6HfVbd//375/w8dOqQwLignJwdRUVFwdXUt7DCIiIiIPlqhJ06ymbslEgkCAwMVlunr68PFxQWLFy8u7DAKDO+qIyIi+nIVeuIklUoBAK6urjhz5gxsbW0Le5eFinfVERERfbm0NgFmbGystnZFREREVCi0ljjNnDkzz+UhISFaioSIiIgof7SWOO3Zs0fhdVZWFmJjY6Gnp4fy5cszcSIiIqJiT2uJ04ULF5TKUlNT0a9fP3Tu3FlbYRARERHlm9bmcVLF3NwcoaGhmDZtWlGGoZGwsDC4u7ujbt26RR0KERERaVmRJk4AkJKSgpSUlKIOQ21BQUG4du0azpw5U9ShEBERkZZp7VLdihUrFF4LIfD06VNs3rwZbdq00VYYRERERPmmtcRp6dKlCq91dHRgZ2eHwMBATJo0SVthEBEREeUb53EiIiIiUpPWxjilpKQgOTlZqTw5ORmpqanaCoOIiIgo37SWOAUEBGDHjh1K5b/88gsCAgK0FQYRERFRvmktcTp16hSaN2+uVN6sWTOcOnVKW2F8NE5HQERE9OXSWuKUmZmJ7OxspfKsrCxkZGRoK4yPxukIiIiIvlxaS5zq1auHtWvXKpWvWbMGnp6e2gqDiIiIKN+0dlfdrFmz4OPjg0uXLqFly5YAgKioKJw5cwZ//vmntsIgIiIiyjet9Tg1atQI0dHRKFWqFH755Rf89ttvqFChAi5fvowmTZpoKwwiIiKifNNajxMAeHh4YNu2bdrcJREREVGB0eqz6u7cuYOpU6eiV69eePbsGQDg4MGD+O+//7QZBhEREVG+aC1x+vvvv1G9enWcOnUKu3fvRlpaGgDg0qVLmD59urbCICIiIso3rSVOEydOxKxZsxAZGQkDAwN5eYsWLXDy5ElthUFERESUb1pLnK5cuYLOnTsrldvb2yMxMVFbYXw0ToBJRET05dJa4mRpaYmnT58qlV+4cAElS5bUVhgfjRNgEhERfbm0+qy6CRMmIC4uDhKJBFKpFMePH8fYsWPRt29fbYVBRERElG9aS5zmzJmDypUro3Tp0khLS4O7uzuaNm2Khg0bYurUqdoKg4iIiCjftDaPk4GBAdatW4eQkBBcuXIFaWlpqFWrFtzc3LQVAhEREdFH0VqP09GjRwEApUuXRtu2bdGjRw950vTDDz9oKwwiIiKifNNa4tS6dWuMGzcOWVlZ8rLExER06NABEydO1FYYRERERPmm1R6nPXv2oG7durh27Rp+//13VKtWDampqbh48aK2wiAiIiLKN60lTg0bNsTFixdRrVo11K5dG507d8aYMWPw119/oWzZstoKg4iIiCjftPqsulu3buHs2bMoVaoU9PT0cPPmTbx69UqbIRARERHlm9YSp3nz5qFBgwZo1aoVrl69itOnT+PChQuoUaMGoqOjtRUGERERUb5pLXFavnw59u7di5UrV8LIyAjVqlXD6dOn0aVLFzRr1kxbYXw0PnKFiIjoy6W1eZyuXLkCW1tbhTJ9fX0sXLgQ7du311YYHy0oKAhBQUFITU2FhYVFUYdDREREWqS1Hqf3k6Z3ValSRVthEBEREeVboSdOJiYmSEhIkL9u166dwsN+4+Pj4eTkVNhhEBEREX20Qk+cXr9+DSGE/PWxY8eQkZGhUOfd5URERETFlVanI8iNRCIp6hCIiIiIPqhYJE5EREREn4JCT5wkEolCj9L7r4mIiIg+FYU+HYEQAhUrVpQnS2lpaahVqxZ0dHTky4mIiIg+BYWeOK1fv76wd0FERESkFYWeOAUGBhb2LoiIiIi0goPDiYiIiNTExImIiIhITUyciIiIiNTExImIiIhITUyciIiIiNRU6HfVyQQHB6ssl0gkMDIyQoUKFdCpUydYW1trK6R8CQsLQ1hYGHJycoo6FCIiItIyrSVOFy5cwPnz55GTk4NKlSoBAG7dugVdXV1UrlwZ33//Pb799lv8+++/cHd311ZYGgsKCkJQUBBSU1NhYWFR1OEQERGRFmntUl2nTp3g4+ODJ0+e4Ny5czh37hwePXqEVq1aoWfPnnj8+DGaNm2KMWPGaCskIiIi0kDa82TsWLMQac+TizqUIqO1xGnhwoX47rvvYG5uLi+zsLDAjBkzsGDBApiYmCAkJATnzp3TVkhERESkprTnyfgxbA5uuFfAj2FzvtjkSWuX6lJSUvDs2TOly3AJCQlITU0FAFhaWuLNmzfaComIiL5Aac+TcSD8J7T3H4gSVsV7XO3/a+++w6K41j+AfweQ3pVqUDACVsSICpLYDTHR2LHlij0asaExEoNdMUYNtqixx2g0ajTNchXFjgXFEisqsdCsrHSB+f3hj7muC7gssEP5fp6H5zpnZs6882avvJ45e0YuV08dwbXTR6XtrIx0RN+6gsy+fZFdRQfPvZtg1sSB8HRtAH1DI+m4us1bop5PKzlC1hqtFU5dunTB4MGDsXDhQjRt2hQAcPbsWUycOBFdu3YFAJw5cwZubm7aComIiCqZvFGT5y19kbB8LoaO+rrCFk/TN5woxtl6gGVbaevpue3I6NQLgk1NvHz6EFVsaiKtUy+cCo+Ctdcn0nGXbwC4UfTrTh/oW4xYtUtrhdOqVaswfvx49OnTB9nZ2a8urqeHgIAAfP/99wCAOnXqYM2aNdoKiYiIKjCOmmguPTYaGfcuSdviy0zkbtkE8T/9IZibIvvfWxC2bIZo6IhnR3+SjjOs4QEjZ08ZItYerRVOpqamWL16Nb7//nvcuXMHAFCrVi2YmppKx3h6emorHCIiKic0HznR7qgJUL5GTgpj5OypUgDlpCvweM925Pi1ge7+I6jWdjx0jczz76AC01rh9PPPP6N79+4wNTWFh4eHti5LRFRhca5O4ThqUrJ0jcxRrVEvJIfvh0WjXpWyaAK0WDiNHz8eI0aMwKefforPPvsMfn5+0NXV1dbliYgqlMo0V0dTHDUpebpG5rD26iV3GLLS2nIE8fHx2Lp1KwRBgL+/PxwcHDBq1CicPHlSWyEQURnEdWGKLq9oSunZDUYNGiKlZ7dK/fXwosgbNTEMj0K1SjxqQprT2oiTnp4eOnXqhE6dOiEtLQ27du3Cli1b0KZNG7zzzju4ffu2tkIhojKiMo2aFOcbTm8+ckp/dhc53T+B8PgpxIQECHr6EGs6IWhwHxhZuUjHafrIqaLM0ykIR02oOGR5ya+xsTH8/PzQsWNHuLq6IjY2Vo4wiEhGHDXRnIGpI4Q//ob49FWuxKdPIfzxNwxMHWWOjKji09qIEwBppGnz5s0IDw+Hk5MT+vbtix07dmgzDKJSUVkm6mo6cqLtUROg4oyccK4OUdmhtRGnPn36wNbWFuPHj0etWrUQERGBmJgYzJo1C3Xq1NFWGPQWnG+iGb6KoOg4alI8nKtDJA+tjTjp6uri119/zffbdFeuXEGDBg20FQoVoDLNNylJSo+cbO2QYmuLNcyfCo6alDzO1SHSPq0VTps3b1bafvHiBX755ResWbMGUVFRyMnJ0VYoBK6oW5yJusmndyLtVqS0nS2mI7dfbwhxD4G4hwAA0aEaxvZsBz3hf7kzdvWGRfMeRY+1gjxuyg/XhSGi8karc5wA4OjRo1i7di127twJR0dHdO/eHcuXL9d2GBVC8b6lcwUZ9x78bztvvomhKcTMLAiGpnjRuh0O//a30nyTM8+vwOiGZh+bilIAWDTvoVQA5aQr8PjsduS6ekKoagPxySPonL2Jaj3nshBQA0dNiKg80UrhlJCQgA0bNmDt2rVQKBTw9/dHZmYmdu/ejXr16mkjBHrDm49NzNMVeHxiO3JrukOwcXz1y//ERVT7kI9O3iZv1OTxll///5HTYc45ISKqoEp9cnjnzp3h7u6OS5cuISwsDHFxcVi6dGlpX5aKKO+Xv86WX5F78yp0tvzKX/5FwIm6RESVQ6mPOO3duxdjxozByJEj4erqWtqXo2LgfJPi4SMnIqKKr9RHnI4fP44XL16gSZMmaN68OZYtW4bHjx+X9mVJQ3m//Fk0ERERqSr1wsnb2xurV69GfHw8Pv/8c2zduhWOjo7Izc3FgQMH8OLFi9IOoUB//fUX3N3d4erqijVr1sgWBxEREZUPWlsA08TEBIMHD8bx48dx+fJlTJgwAfPmzYOtrS0+/fRTbYUhyc7ORlBQEA4dOoQLFy7gu+++w5MnT7QeBxEREZUfsryrzt3dHfPnz8eDBw/wyy+/yBECzpw5g/r166N69eowNTVFx44d8d///leWWIiIiKh8kKVwyqOrq4uuXbvijz/+KPK5R48eRefOneHo6AhBELB7926VY5YvXw5nZ2cYGhqiefPmOHPmjLQvLi4O1atXl7arV6+Ohw8fanQfREREVDnIWjgVR2pqKho1alTg4pnbtm1DUFAQpk2bhvPnz6NRo0bw8/NDUlKSliMlIiKiikLrK4eXlI4dO6Jjx44F7l+0aBGGDRuGQYMGAQBWrlyJv//+G+vWrcPkyZPh6OioNML08OFDNGvWrMD+MjMzkZmZKW0rFAoAr+ZKZWdnF/d2CiRCLLW+ta2weynpHFaWvAHMXWG0mTvmrfSuV57wM6cZbX/mitN/uS2cCpOVlYWoqCgEBwdLbTo6Omjfvj1OnToFAGjWrBmuXLmChw8fwsLCAnv37kVISEiBfYaGhmLGjBkq7ZGRkTAxMSn5m/h/KSa1Sq1vbUtJSSlw34kTl0r2WpUkbwBzVxht5o55K8b1mDvNrsW8lZjU1FS1j62QhdPjx4+Rk5MDOzs7pXY7Oztcv34dAKCnp4eFCxeiTZs2yM3NxaRJk1C1atUC+wwODkZQUJC0rVAo4OTkBG9vb5ibl96aR3di5FuuoaSZmpoWuM/Xs2TfY1dZ8gYwd4XRZu6YN80xd5ph3kpO3lMkdVTIwkldn376qdpLIRgYGMDAwEClXU9PD3p6pZdGAUKp9a1thd1LSeewsuQNYO4Ko83cMW+ld73yhJ85zWj7M1ec/svt5PDCVKtWDbq6ukhMTFRqT0xMhL29vUxRERERUXlXIQsnfX19NGnSBOHh4VJbbm4uwsPD4ePjU6y+ly9fjnr16qFp06bFDZOIiIjKmXL7qC4lJQUxMTHS9t27dxEdHQ1ra2vUqFEDQUFBCAgIgJeXF5o1a4awsDCkpqZK37LT1KhRozBq1CgoFApYWFgU9zaIiIioHCm3hdO5c+fQpk0baTtv4nZAQAA2bNiA3r1749GjR5g6dSoSEhLg6emJffv2qUwYJyIiIlJXuS2cWrduDVEsfN2HwMBABAYGaikiIiIiqugq5Byn0sQ5TkRERJUXC6ciGjVqFK5evYqzZ8/KHQoRERFpWbl9VCe3vMeERVk0SxM5uTml2r82FXYvJZ3HypI3gLkrjDZzx7yV3vXKE37mNKPtz1xB/b9tChAACKI6R5GKBw8ewMnJSe4wiIiIqITcv38f77zzTqHHsHDSUG5uLuLi4mBmZgZBqDirt+a9Sub+/ful+iqZioi50wzzpjnmTjPMm+Yqau5EUcSLFy/g6OgIHZ3CZzHxUZ2GdHR03lqVlmfm5uYV6v8U2sTcaYZ50xxzpxnmTXMVMXfqrs3IyeFEREREamLhRERERKQmFk6kxMDAANOmTYOBgYHcoZQ7zJ1mmDfNMXeaYd40x9xxcjgRERGR2jjiRERERKQmFk5EREREamLhRERERKQmFk5EREREamLhRERERKQmFk5EREREamLhRERERKQmFk5EREREamLhRERERKQmFk5EREREamLhRERERKQmFk5EREREamLhRERERKQmFk5EREREamLhRERERKQmPbkDKK9yc3MRFxcHMzMzCIIgdzhERESkIVEU8eLFCzg6OkJHp/AxJRZOGoqLi4OTk5PcYRAREVEJuX//Pt55551Cj2HhpCEzMzMAr5Jsbm4uczRERESkKYVCAScnJ+l3e2FYOGko7/Gcubk5CyciIqIKQJ2pN5wcTkRERKQmFk5EREREamLhRERERKQmznEiIqJKJScnBy9fvpQ7DNKiKlWqQFdXt0T6YuFERESVgiiKSEhIwPPnz+UOhWRgaWkJe3v7Yq+9yMKJiIgqhbyiydbWFsbGxly8uJIQRRFpaWlISkoCADg4OBSrPxZORERU4eXk5EhFU9WqVeUOh7TMyMgIAJCUlARbW9tiPbbj5HAiIqrw8uY0GRsbyxwJySXvv31x57excCIiokqDj+cqr5L6b8/CiYiIiEhNLJyIiIgqAWdnZ4SFhUnbgiBg9+7dAIDY2FgIgoDo6GhZYitPODmciIgqtQ3Xn2vtWgPrWBb9nIED8fz5c6nIyRMREYE2bdrg2bNnsLQser+vc3JyQnx8PKpVq1asfiqDCjHidPToUXTu3BmOjo5KFXRhIiIi8N5778HAwAC1a9fGhg0bSj1OIiKiskhXVxf29vbQ05N/PKWsL05aIQqn1NRUNGrUCMuXL1fr+Lt37+KTTz5BmzZtEB0djXHjxmHo0KHYv39/KUdKRERUOo4fP44PPvgARkZGcHJywpgxY5CamqrWuW8+qouIiIAgCAgPD4eXlxeMjY3RokUL3LhxQ+m82bNnw9bWFmZmZhg6dCgmT54MT09PpWPWrFmDunXrwtDQEHXq1MEPP/ygct1t27ahVatWMDQ0xObNm4uVh9JWIQqnjh07Yvbs2ejWrZtax69cuRIuLi5YuHAh6tati8DAQPTs2RPff/99KUdKRERU8m7fvo2PPvoIPXr0wKVLl7Bt2zYcP34cgYGBxep3ypQpWLhwIc6dOwc9PT0MHjxY2rd582bMmTMH3377LaKiolCjRg2sWLFC6fzNmzdj6tSpmDNnDq5du4a5c+ciJCQEGzduVDpu8uTJGDt2LK5duwY/P79ixVza5B+Tk8GpU6fQvn17pTY/Pz+MGzeuwHMyMzORmZkpbSsUCgBAdnY2srOzSyVOIiIqGdnZ2RBFUfpR9uZ26VG9tnr++usvmJqaKrXl5ORIfc6dOxf9+vXD2LFjAQC1a9fG4sWL0bp1a/zwww8wNDSUjn09hjdz8ub27Nmz0bJlSwDAV199hU6dOiE9PR2GhoZYunQpBg8ejIEDBwIAQkJC8N///hcpKSnS+dOmTcOCBQukgQ1nZ2f8888/WLVqFQYMGCAdN3bsWKXBD03zVJi8+8rv93ZRfo9XysIpISEBdnZ2Sm12dnZQKBRIT0+XVhh9XWhoKGbMmKHSHhkZCRMTk1KLlYiIik8QBJiZmSEtLU3ll2RObq7W4khJSSnyOS9fvkTLli2xaNEipfZz585h2LBhSElJwYULF/DPP/9gy5Yt0n5RFJGbm4t//vkH7u7uEEURmZmZSjFkZGQgJSVFeqSXlpaGlJQUpKenAwDeffdd6XgLCwsAr6a7ODk54caNGxg0aJBSf56enjh69KjU5+3btzF06FAMHz5cOiY7Oxvm5uZK161fv75GuSmKrKwsZGZm4vz58yqFmbqPNIFKWjhpIjg4GEFBQdK2QqGAk5MTvL29YW5uLmNkRET0NhkZGbh37x6MjY2l0Zc8ujrPtRbHm6NG6qhSpQrMzc3RqFEjpfZnz55Jfaanp2P48OEYM2aMyvk1atSAvr4+BEGAgYGBUgyGhoYwNTWVBgCMjY1hamoqDSBYWlpKx+cdY2RkJLXlnf96rDo6OjA1NZWKkR9//BHNmzdXiklXV1fputWqVdMoN0WRkZEBAwMDuLq6qnwG8p4iqaNSFk729vZITExUaktMTIS5uXm+o00AYGBgAAMDA5V2PT29MvEtBCIiKpienh4EQZB+lGlvNfHirF795rl524Ig4L333sO1a9fg6ur61j5e7+fNnBS0/eb1BEGAu7s7zp07h4CAAKm/c+fOScfY29vD0dERd+/exWeffVboPeX/36Vk5V0jv9/bRfk9Xil/4/v4+GDPnj1KbQcOHICPj49MEREREWnuq6++gre3NwIDAzF06FCYmJjg6tWrOHDgAJYtW1Yq1xw9ejSGDRsGLy8vtGjRAtu2bcOlS5dQq1Yt6ZgZM2ZgzJgxsLCwwEcffYTMzEycO3cOz549U3qKU55UiMIpJSUFMTEx0vbdu3cRHR0Na2tr1KhRA8HBwXj48CF++uknAMCIESOwbNkyTJo0CYMHD8ahQ4fw66+/4u+//5brFoiIiDTm4eGBI0eOYMqUKfjggw8giiLeffdd9O7du9Su2b9/f9y5cwcTJ05ERkYG/P39MXDgQJw5c0Y6ZujQoTA2NsZ3332HL7/8EiYmJmjYsGGhX8Yq6wSxNKaua1ne6qlvCggIwIYNGzBw4EDExsYiIiJC6Zzx48fj6tWreOeddxASEiJ9M0AdCoUCFhYWSE5O5hwnIqIyLiMjA3fv3oWLi4vK/BYqOR06dIC9vT02bdokdygqCvsMFOV3eoUYcWrdunWhX13Mb1Xw1q1b48KFC6UYFRERUcWVlpaGlStXws/PD7q6uvjll19w8OBBHDhwQO7QSlWFKJyIiIhIuwRBwJ49ezBnzhxkZGTA3d0dO3fuVFknsaJh4URERERFZmRkhIMHD8odhtZViFeuEBEREWkDCyciIiIiNbFwIiIiIlITCyciIiIiNbFwIiIiIlITCyciIiIiNbFwIiIiohIVEREBQRDw/PlzAK8Wora0tCzVaw4cOBBdu3Yt1WsAXMep0goPD8ehQ4dU2tPT03Hr1i24urrCyMhIZX/btm3Rrl07bYRIRKQVzpO1957S2HmfFPmcgQMHYuPGjQgNDcXkyZOl9t27d6Nbt26FvjmjrOjduzc+/vhjucMoESycKql27drlWwDdunULw4cPx8iRI+Hq6ipDZERE9CZDQ0N8++23+Pzzz2FlZVUifWZlZUFfX79E+nobIyOjfP8xXh7xUR0REVEZ1759e9jb2yM0NLTAY3bu3In69evDwMAAzs7OWLhwodJ+Z2dnzJo1CwMGDIC5uTmGDx8uPUL766+/4O7uDmNjY/Ts2RNpaWnYuHEjnJ2dYWVlhTFjxiAnJ0fqa9OmTfDy8oKZmRns7e3Rr18/JCUlFRjbm4/qnJ2dIQiCyk+e+/fvw9/fH5aWlrC2tkaXLl0QGxsr7c/JyUFQUBAsLS1RtWpVTJo0SWsjbyyciIiIyjhdXV3MnTsXS5cuxYMHD1T2R0VFwd/fH3369MHly5cxffp0hISEqLzkfsGCBWjUqBEuXLiAkJAQAK9e1rtkyRJs3boV+/btQ0REBLp164Y9e/Zgz5492LRpE1atWoUdO3ZI/bx8+RKzZs3CxYsXsXv3bsTGxmLgwIFq38/Zs2cRHx+P+Ph4PHjwAN7e3vjggw+kvv38/GBmZoZjx47hxIkTMDU1xUcffYSsrCwAwMKFC7FhwwasW7cOx48fx9OnT7Fr164iZlUzfFRHSp49e4aYR4/w7NkzuUMhIqLXdOvWDZ6enpg2bRrWrl2rtG/RokVo166dVAy5ubnh6tWr+O6775QKmrZt22LChAnS9rFjx/Dy5UusWLEC7777LgCgZ8+e2LRpExITE2Fqaop69eqhTZs2OHz4MHr37g0AGDx4sNRHrVq1sGTJEjRt2hQpKSkwNTV9673Y2NhIfx47dizi4+Nx9uxZAMC2bduQm5uLNWvWSKNQ69evh6WlJSIiIvDhhx8iLCwMwcHB6N69OwBg5cqV2L9/v9q5LA4WTpVUfpPD09LSsCMyEvF+fugxdix6envD2NhY6RhODiciks+3336Ltm3bYuLEiUrt165dQ5cuXZTafH19ERYWhpycHOjq6gIAvLy8VPo0NjaWiiYAsLOzg7Ozs1IBZGdnp/QoLioqCtOnT8fFixfx7Nkz5ObmAgDu3buHevXqqX0/P/74I9auXYuTJ09KxdTFixcRExMDMzMzpWMzMjJw+/ZtJCcnIz4+Hs2bN5f26enpwcvLSyuP62QrnKZNm4bBgwejZs2acoVQqb05OfzJkycImDIFZuPGISEpCWbNmuHW4cPY+M03qFq1qoyREhFRnpYtW8LPzw/BwcFFejSWx8TERKWtSpUqStuCIOTbllccpaamws/PD35+fti8eTNsbGxw7949+Pn5SY/S1HH48GGMHj0av/zyCzw8PKT2lJQUNGnSBJs3b1Y55/WRKrnIVjj9/vvvmDNnDlq1aoUhQ4agR48eMDAwkCucMmfD9edavd7WlYtw/b3myDW3Rm5iElLMrXHlveboP2sR+oz4UmtxDKxjqbVrERGVR/PmzYOnpyfc3d2ltrp16+LEiRNKx504cQJubm7SaFNJuX79Op48eYJ58+bByckJAHDu3Lki9RETE4OePXvi66+/lh635Xnvvfewbds22NrawtzcPN/zHRwccPr0abRs2RIAkJ2djaioKLz33nsa3FHRyDY5PDo6GmfPnkX9+vUxduxY2NvbY+TIkdIzTtKuTr2HwPLoCWQ/fgQAyH78CJZHT6BT7yEyR0ZERK9r2LAh+vfvjyVLlkhtEyZMQHh4OGbNmoWbN29i48aNWLZsmcojvZJQo0YN6OvrY+nSpbhz5w7++OMPzJo1S+3z09PT0blzZzRu3BjDhw9HQkKC9AMA/fv3R7Vq1dClSxccO3YMd+/eRUREBMaMGSNNjB87dizmzZuH3bt34/r16/jiiy+kxTZLm6zfqmvcuDGWLFmCuLg4rF27Fg8ePICvry88PDywePFiJCcnyxlepWJqZY2ho76G4dZfIcbeheHWXzF01NcwtbKWOzQiInrDzJkzpUdnwKtRml9//RVbt25FgwYNMHXqVMycOVOjx3lvY2Njgw0bNmD79u2oV68e5s2bhwULFqh9fmJiIq5fv47w8HA4OjrCwcFB+gFezbk6evQoatSoge7du6Nu3boYMmQIMjIypBGoCRMm4D//+Q8CAgLg4+MDMzMzdOvWrcTvNT+CWAaWHM3KysKuXbuwbt06HDp0CC1atEBcXBwSExOxevVqaRZ/WaJQKGBhYYHk5OQChxKLQ9uP6vKc3f8Hfpw9EcO/WYCmfp9q/fp8VEdEpSEjIwN3796Fi4sLDA0N5Q6HZFDYZ6Aov9NlHXGKiopCYGAgHBwcMH78eDRu3BjXrl3DkSNHcOvWLcyZMwdjxoyRM8RKx8jUDPqZWTAyNXv7wURERJWMbIVTw4YN4e3tjbt372Lt2rW4f/8+5s2bh9q1a0vH9O3bF48ePZIrxEopPeUFsgz0kZ7yQu5QiIiIyhzZvlXn7++PwYMHo3r16gUeU61aNaVnuFS6Up49xd7//oac/3yGvf/9DXWbvc85TkRERK+RrXASRTHfFxWmp6fju+++w9SpU2WIqvK4euoIrp0+Km1nZaQj+tYVpPXuBUEAHjm7YNbEgfB0bQB9w/+9mLFu85ao59NKjpCJiIhkJ9vkcF1dXcTHx8PW1lap/cmTJ7C1tVV6mWBZVBYmh0/fcOKtx6jr6bntyGjXBEKtd/Hy6UNUsa4O8c5tGIZHwdqrV4lcY/pA37cew8nhRFQaODmcyv3kcFEUld6EnOfixYuwtubjIW2zqO8H3f2HIT55DAAQnzyG7v7DsKjvJ3NkREQlh9M/Kq+S+m+v9Ud1VlZWEAQBgiDAzc1NqXjKyclBSkoKRowYUeR+ly9fju+++w4JCQlo1KgRli5dimbNmhV4fFhYGFasWIF79+6hWrVq6NmzJ0JDQyvtv0R0jcxRrVEvPPp5E8T3G0Hn+EVUa/of6BqV/GgaEZG26evrQ0dHB3FxcbCxsYG+vn6+/3inikcURWRlZeHRo0fQ0dGBvr5+sfrTeuEUFhYGURQxePBgzJgxAxYWFtI+fX19ODs7w8fHp0h9btu2DUFBQVi5ciWaN2+OsLAw+Pn54caNGyqPAgFgy5YtmDx5MtatW4cWLVrg5s2bGDhwIARBwKJFi4p9j+WVrpE5rGq3R9KW5bBqO4pFExFVGDo6OnBxcUF8fDzi4uLkDodkYGxsjBo1akBHp3gP27ReOAUEBAAAXFxc0KJFC5UXCWpi0aJFGDZsGAYNGgQAWLlyJf7++2+sW7cOkydPVjn+5MmT8PX1Rb9+/QAAzs7O6Nu3L06fPl3sWMo7HUNTVNE1gY6h6dsPJiIqR/T19VGjRg1kZ2eX+Xm0VLJ0dXWhp6dXIqOMWi2cFAqFNOmqcePGSE9PR3p6er7HqjvhOisrC1FRUQgODpbadHR00L59e5w6dSrfc1q0aIGff/4ZZ86cQbNmzXDnzh3s2bMH//nPfwq8TmZmJjIzM5XuBXj1YsHs7Gy1Yi0KEbIv6F7i1Lmn0sglEdHrBEGAnp5sXyonmRRWLBfld49WPzlWVlbSN+ksLS3zrfzyJo2r+6+Bx48fIycnB3Z2dkrtdnZ2uH79er7n9OvXD48fP8b7778PURSRnZ2NESNG4Ouvvy7wOqGhoZgxY4ZKe2RkJExMTNSKtShSTGqVeJ9yS0lJeesxJ05c0kIkRERE/5Oamqr2sVotnA4dOiR9Y+7w4cPavLSSiIgIzJ07Fz/88AOaN2+OmJgYjB07FrNmzUJISEi+5wQHByMoKEjaVigUcHJygre3d6ksR3AnpuKt3G1q+vbHf76eb1+ygIiIqCTlPUVSh1YLp1atWuX75+KoVq0adHV1kZiYqNSemJgIe3v7fM8JCQnBf/7zHwwdOhTAq9e/pKamYvjw4ZgyZUq+E8cMDAxgYGCg0q6np1cqQ74CKt63PdS5Jw6fExGRthXld49Wf0tduqT+YxgPDw+1jtPX10eTJk0QHh6Orl27Ani1VkN4eDgCAwPzPSctLU2lONLV1QXw6lFhZZAeG42Me6r/PcSXmdCpYogXF/ZAqKJaKBrW8ICRs6cWIiQiIip7tFo4eXp6QhCEtxYnRZnjBABBQUEICAiAl5cXmjVrhrCwMKSmpkrfshswYACqV6+O0NBQAEDnzp2xaNEiNG7cWHpUFxISgs6dO0sFVEVn5OzJAoiIiKiItFo43b17t1T67d27Nx49eoSpU6ciISEBnp6e2LdvnzRh/N69e0ojTN988w0EQcA333yDhw8fwsbGBp07d8acOXNKJT4iIiKqGGR7V115V9HeVacNfFcdERGVReXiXXUAsGnTJvj6+sLR0RH//vsvgFcri//+++9yhkVERESUL9m+wrRixQpMnToV48aNw5w5c6Q5TZaWlggLC0OXLl3kCo2ISkF4eDgOHTqk0p6eno5bt27B1dUVRkZGKvvbtm2Ldu3aaSNEIqK3kq1wWrp0KVavXo2uXbti3rx5UruXlxcmTpwoV1hEVEratWuXbwF069YtDB8+HCNHjoSrq6sMkRERqU+2wunu3bto3LixSruBgUGRVvAkovKhoBGnO3fuIPLqVUydOhW1aqmumM8RJyIqS2QrnFxcXBAdHY2aNWsqte/btw9169aVKSoiKi35jTg9efIEn3z+OV7274+79+5hWVAQqlatKlOERERvJ1vhFBQUhFGjRiEjIwOiKOLMmTP45ZdfEBoaijVr1sgVFhFpyZMnTxAwZQoUvXpBSEqConlzBEyZgo1z5rB4IqIyS7bCaejQoTAyMsI333yDtLQ09OvXD46Ojli8eDH69OkjV1hElZY6S2CUpK0rF+H6e83x0sQCOcIjJJtY4Mp7zdF/1iL0GfGlVmPhMhhEpC5ZlyPo378/bt26hZSUFCQkJODBgwcYMmSInCERkZZ06j0EpuGH8STmBkR7ezyJuQHT8MPo1Jt/BxBR2SVr4ZTH2NgYtra2codBRNqWmwscPAjExr7639xcuSMiIiqUVh/VNW7cGIIgqHXs+fPnSzkaItJESa1Y//TcdmS0aw7RygLY+xtyOvXCzWfJ+DpkJqy9epXINdRZrZ6IqCi0Wjh17dpV+nNGRgZ++OEH1KtXDz4+PgCAyMhI/PPPP/jiiy+0GRYRycCivh9e7t+O7O4fA23bAllZ0N1/GBaNSqZoIiIqDVotnKZNmyb9eejQoRgzZgxmzZqlcsz9+/e1GRZRkXAFbM2kx0Yj494lpTa9l7l4uWIZ8FFbiPsOQc/UGYqzu5WOMazhASNnT+0FSkRUCNm+Vbd9+3acO3dOpf2zzz6Dl5cX1q1bJ0NURG9X0ArYZ86cQY/BgxESEoJmzZrJEFnZZuTsmW8BlBl3A0nbl8Om7SgYOLprPzAioiKQbXK4kZERTpxQnStx4sQJGBoayhARkeaePHmCr5YuxfOuXfHV0qV48uSJ3CGVGzqGpqiiawIdQ1O5QyEieivZRpzGjRuHkSNH4vz589K/zk+fPo1169YhJCRErrCIiixvIcfnPXpA79kzPPfy4kKOREQVlGyF0+TJk1GrVi0sXrwYP//8MwCgbt26WL9+Pfz9/eUKi8o5bS/iCPxvIUdds6rIevIUCrOqeCbDQo5lfRHH/OY4AYD4MhM6VQzx4sIeCFUMVPZzjhMRlSWyFU4A4O/vzyKJyr1OvYcgYflcPDM3BwBkP0qC1dET6DTqa5kjK1sKmuNERFSelIkFMInKM1Mrawwd9TWMtu9Azu3bMNq+A0NHfQ1TK2u5QyMiohKm1REna2tr3Lx5E9WqVYOVlVWhi2E+ffpUi5ERqe/qqSO4dvqoSruDnhGe/vEXHOo3wf6Ny1X2123eEvV8WmkjRCIiKiVaLZy+//57mJmZAQDCwsK0eWmiUqdvaAhHGwfo81uhREQVllYLp4CAAEydOhWTJ09GQEAAAODZs2ewsrLSZhhExVLPp1W+I0e3L0VhechodB75Jd71aCJDZEREVNq0Psdpzpw5SElJkbZr1qyJO3fuaDsMohKV8uwptm9bg7Qe3bB92xqkPOOjZiKiikjrhZMoioVuE5U3Kc+eYs3yuUjv1RO6776L9F49sWb5XBZPREQVkKzLERDJZfoG1VXrNfX03HZktGsCQTDCy6ynSDA1Qnz9Rvg6ZCasvYr/wtrpA31LIEoiIioJWi+cBEHAixcvYGhoCFEUIQgCUlJSoFAolI4z//81cYjKOov6fni5fzty/C0AARCfPIbu/sOwaFT8oomIiMoWrRdOoijCzc1Nabtx48ZK24IgICcnR9uhEWlE18gc1Rr1wqOfN0F8vxF0jl9Etab/ga4Ri38ioopG64XT4cOHtX1JolKna2QOq9rtkbRlOazajmLRRERUQWm9cGrVqnQWAFy+fDm+++47JCQkoFGjRli6dKn08uD8PH/+HFOmTMFvv/2Gp0+fombNmggLC8PHH39cKvFRxVHYO9cMDKsi9dpRpMWcVtnPd64REZV/FWJy+LZt2xAUFISVK1eiefPmCAsLg5+fH27cuAFbW1uV47OystChQwfY2tpix44dqF69Ov79919YWlpqP3gqd/jONSKiyqtCFE6LFi3CsGHDMGjQIADAypUr8ffff2PdunWYPHmyyvHr1q3D06dPcfLkSVSpUgUA4OzsrM2QiYjUFh4ejkOHDqm0p6en49atW3B1dYWRkZHK/rZt26Jdu3baCJGo0ij3hVNWVhaioqIQHBwsteno6KB9+/Y4depUvuf88ccf8PHxwahRo/D777/DxsYG/fr1w1dffQVdXd18z8nMzERmZqa0nfctwOzsbGRnZ5fgHb0iouKtb6XOPRU3l5U1bwBzlx9t5a60tWrVKt9pDrdu3cLIkSMxbNgwuLq65ntuWb83orKgKP8/KfeF0+PHj5GTkwM7Ozuldjs7O1y/fj3fc+7cuYNDhw6hf//+2LNnD2JiYvDFF1/g5cuXmDZtWr7nhIaGYsaMGSrtkZGRMDExKf6NvCHFpFaJ9ym311eML8iJE6pzh4p0jUqaN4C5y4+2clfaoqKicOHCBZX2R48e4cKFCxg/fjxsbGxU9jdu3BhNmvD1P0Rvk5qaqvaxshVOgwcPxuLFi6WX/uZJTU3F6NGjsW7dulK7dm5uLmxtbfHjjz9CV1cXTZo0wcOHD/Hdd98VWDgFBwcjKChI2lYoFHBycoK3t3eprDl1J+ZFifcpN1NT07ce4+tZvMUeK2veAOYuP9rKXWnz9c0/vp07d+Lw+fMYNGgQevTooeWoiCqON9eSLIxshdPGjRsxb948lcIpPT0dP/30k9qFU7Vq1aCrq4vExESl9sTERNjb2+d7joODA6pUqaL0WK5u3bpISEhAVlYW9PX1Vc4xMDCAgYGBSruenh709Eo+jQKEEu9TburcU3FzWVnzBjB3+dFW7uTw5MkTfL99O3I++wzfb9+O9u3bo2rVqnKHRVQuFeXvAK2/q06hUCA5ORmiKOLFixdQKBTSz7Nnz7Bnz558vwlXEH19fTRp0gTh4eFSW25uLsLDw+Hj45PvOb6+voiJiUFubq7UdvPmTTg4OORbNBERlSVPnjxBwJQpeNa9O3Jr1cKz7t0RMGUKnjx5IndoRBWe1v+ZZWlpCUEQIAiC0grieQRByHcuUWGCgoIQEBAALy8vNGvWDGFhYUhNTZW+ZTdgwABUr14doaGhAICRI0di2bJlGDt2LEaPHo1bt25h7ty5GDNmTPFvkIgqlQ3Xn2v9mltXLsI/Hk3wODsHor097qWlI82jCfrPWoQ+I77UWhwD61hq7VpEZYUsK4eLooi2bdti586dsLa2lvbp6+ujZs2acHR0LFKfvXv3xqNHjzB16lQkJCTA09MT+/btkyaM37t3Dzo6/xtcc3Jywv79+zF+/Hh4eHigevXqGDt2LL766quSuUkiolLU5qPuODl9NHJGfQEYGiInPQPJP61Hm+lL5Q6NqMKTbeXwu3fvokaNGhCEkplXERgYiMDAwHz3RUREqLT5+PggMjKyRK5NRPQ20zecKLG+np7bjvQOnyLn1x1Aq/eRfeQ40jt8ijkLlsLaq/gvl54+sGxPlieSk1YLp0uXlL/ye/ny5QKP9fDwKO1wiIjKJYv6fnh5bDtEv9bIORYBnRatobf/KCwaFb9oIqLCabVw8vT0hCAIEMXCF6UTBAE5OTlaioqIqHzRNTJHtUa9kLRrDXJ8G0F315+o5jOUL5cm0gKtFk53797V5uWIiCosXSNzmDs2w+ONq2HechiLJipRfM1PwbRaONWsWVOblyMiqhDSY6ORcU91dfOcF08gpGch/fZZZCXdUdlvWMODL6SmEvXs2TOcOnUK1apVy7dwqgxkW/Xtp59+KnT/gAEDtBQJEVHZZuTsmW8B9PLpQ2QrkmDh448q1tW1HxhVWO3atct35Gjnzp3Y8vff6NSpU6VdrV62wmns2LFK2y9fvkRaWhr09fVhbGzMwomIiKgMefLkCeZu2oSs//wHczdtQuvWrSvlavWyFU7Pnj1Tact70/eXX2pvATciorKuoEd14stM6FQxxIsLeyBUUX0lFB/VUUl58uQJ+k6ahBtt2wKOjrhRsyb6TpqEX+bPr3TFU5l6QZOrqyvmzZuHzz77DNevX5c7HCKiMqGgR3VUOcmxWv1PYXNwqoYzct3cgeyXeOnmjmPPktFryhwMGDdVa3GUhdXqy1ThBLx60V5cXJzcYRAREZVrJbno6pNrcciMuQrx3XcBS3NkPX4C4dgJnH1piTslcJ3ytOiqbIXTH3/8obQtiiLi4+OxbNky+PqWnwQSERFVdJaeXfDy3M/I/PlnoH1b4OAh6KfrwtKri9yhaZ1shVPXrl2VtgVBgI2NDdq2bYuFCxfKExQRERGp0DUyh43XZ0g8tgIv/96DKsnZsPlgZKVcP0y2wik3N1euSxMREVER6RqZw6KGLx4fXQ2LSrzoapmZ45STk4PLly+jZs2asLKykjscIiKiSiv59E6k3YpUaRezs6CTmY3kyO1QnPtdZb+xqzcsmlfs9Z1kK5zGjRuHhg0bYsiQIcjJyUHLli1x6tQpGBsb46+//kLr1q3lCo2IiKhSs2jeo8IXQJqSrXDasWMHPvvsMwDAn3/+idjYWFy/fh2bNm3ClClTcOJEyX0bgIiIKh++b41Kg2yF0+PHj2Fvbw8A2LNnD3r16gU3NzcMHjwYixcvlissIiKqIAp6bciZM2fQY/BghISEoFmzZjJERuWZbIWTnZ0drl69CgcHB+zbtw8rVqwAAKSlpUFXV1eusIiIqILIb8QpLS0NOyIjEe/nhx5jx6KntzeMjY2VjuGIExVGtsJp0KBB8Pf3h4ODAwRBQPv27QEAp0+fRp06deQKi4iIKog3R5yePHmCgClTYDx6NHKfPoVxkya4dfQoNn7zTaV7bQhpTrbCafr06WjQoAHu37+PXr16wcDg1XuWdHV1MXnyZLnCIiIiLdH2q0O2rlyEfzya4HF2DkR7e9xLS0eaRxP0n7UIfUZo9x2pZeHVIaQZWZcj6NmzJwAgIyNDagsICJArHCIiqsDafNQdJ6ePRs6oLwBDQ+SkZyD5p/VoM32p3KFROSJb4ZSTk4O5c+di5cqVSExMxM2bN1GrVi2EhITA2dkZQ4YMkSs0IiIqQ0rqnWtPz21HeodPkfPrDqDV+8g+chzpHT7FnAVLYe3Vq0SuUZ7euUaa0ZHrwnPmzMGGDRswf/586OvrS+0NGjTAmjVr5AqLiIgqKIv6ftA7dgY6LVoDx45Dp0Vr6B07A4v6fnKHRuWIbCNOP/30E3788Ue0a9cOI0aMkNobNWqE69evyxUWERFVEOmx0ci4d0mpTe9lLl7+tAH4qC3w0wbomTpDcXa30jGGNTxg5OyptTipfJGtcHr48CFq166t0p6bm4uXL1/KEBEREVUkRs6e+RZAmXE3kLR9OWzajoKBo7v2A6NyTbbCqV69ejh27Bhq1qyp1L5jxw40btxYpqiIiKiiyG/ECQDEl5kwMKyK1GtHkRZzWmU/R5yoMLIVTlOnTkVAQAAePnyI3Nxc/Pbbb7hx4wZ++ukn/PXXX3KFRUREFURBI05ExSHb5PAuXbrgzz//xMGDB2FiYoKpU6fi2rVr+PPPP9GhQ4ci97d8+XI4OzvD0NAQzZs3x5kzZ9Q6b+vWrRAEAV27di3yNYmIiKhykXUdpw8++AAHDhxQaT937hy8vLzU7mfbtm0ICgrCypUr0bx5c4SFhcHPzw83btyAra1tgefFxsZi4sSJ+OCDDzSKn4iIiCoX2UacUlJSkJ6ertQWHR2Nzp07o3nz5kXqa9GiRRg2bBgGDRqEevXqYeXKlTA2Nsa6desKPCcnJwf9+/fHjBkzUKtWLY3ugYiIiCoXrY843b9/H/7+/jhz5gx0dXURGBiI2bNnY8SIEdi2bRu6deuGkydPqt1fVlYWoqKiEBwcLLXp6Oigffv2OHXqVIHnzZw5E7a2thgyZAiOHTv21utkZmYiMzNT2lYoFACA7OxsZGdnqx2vukSIJd6n3NS5p+LmsrLmDWDu8qON3DFvpX+d8oSfOc1o6zNXEv1qvXD68ssvkZGRgcWLF+O3337D4sWLcezYMTRv3hy3b9/GO++8U6T+Hj9+jJycHNjZ2Sm129nZFbge1PHjx7F27VpER0erfZ3Q0FDMmDFDpT0yMhImJiZFilkdKSYVbxQsJSXlrcecOKH6DZgiXaOS5g1g7vKjjdwxb8W4DnOn2TWYtxKXmpqq9rFaL5yOHj2K3377Dd7e3vD394e9vT369++PcePGaeX6L168wH/+8x+sXr0a1apVU/u84OBgBAUFSdsKhQJOTk7w9vaGubl5icd5J+ZFifcpN1NT07ce4+tZvNcVVNa8AcxdfrSRO+ZNc8ydZpi3kpf3FEkdWi+cEhMT4eLiAgCwtbWFsbExOnbsqHF/1apVg66uLhITE1WuY29vr3L87du3ERsbi86dO0ttubm5AAA9PT3cuHED7777rsp5BgYGMDAwUGnX09ODnl7Jp1GAUOJ9yk2deypuLitr3gDmLj/ayB3zVvrXKU/4mdOMtj5zJdGvLJPDdXR0lP78+rvqikpfXx9NmjRBeHi41Jabm4vw8HD4+PioHF+nTh1cvnwZ0dHR0s+nn36KNm3aIDo6Gk5OThrHQkRERBWb1kecRFGEm5sbBOFVdZmSkoLGjRsrFVMA8PTpU7X7DAoKQkBAALy8vNCsWTOEhYUhNTUVgwYNAgAMGDAA1atXR2hoKAwNDdGgQQOl8y0tLQFApZ2IiIjodVovnNavX1/iffbu3RuPHj3C1KlTkZCQAE9PT+zbt0+aMH7v3j2VwoyIiIioqLReOAUEBJRKv4GBgQgMDMx3X0RERKHnbtiwoeQDIiIiogqHwzBEREREamLhRERERKQmFk5EREREamLhRERERKQmFk5EREREatL6t+ryvP76ktcJggBDQ0PUrl0bXbp0gbW1tZYjIyIiIsqfbIXThQsXcP78eeTk5MDd3R0AcPPmTejq6qJOnTr44YcfMGHCBBw/fhz16tWTK0wiIiIiiWyP6rp06YL27dsjLi4OUVFRiIqKwoMHD9ChQwf07dsXDx8+RMuWLTF+/Hi5QiQiIiJSIlvh9N1332HWrFkwNzeX2iwsLDB9+nTMnz8fxsbGmDp1KqKiouQKkYiIiEiJbIVTcnIykpKSVNofPXoEhUIB4NU75LKysrQdGhEREVG+ZH1UN3jwYOzatQsPHjzAgwcPsGvXLgwZMgRdu3YFAJw5cwZubm5yhUhERESkRLbJ4atWrcL48ePRp08fZGdnvwpGTw8BAQH4/vvvAQB16tTBmjVr5AqRiIiISIlshZOpqSlWr16N77//Hnfu3AEA1KpVC6amptIxnp6eMkVHREREpEq2R3U///wz0tLSYGpqCg8PD3h4eCgVTURERERljWyF0/jx42Fra4t+/fphz549yMnJkSsUIiIiIrXIVjjFx8dj69atEAQB/v7+cHBwwKhRo3Dy5Em5QiIiIiIqlGyFk56eHjp16oTNmzcjKSkJ33//PWJjY9GmTRu8++67coVFREREVCDZJoe/ztjYGH5+fnj27Bn+/fdfXLt2Te6QiIiIiFTINuIEAGlpadi8eTM+/vhjVK9eHWFhYejWrRv++ecfOcMiIiIiypdsI059+vTBX3/9BWNjY/j7+yMkJAQ+Pj5yhUNERET0VrIVTrq6uvj111/h5+cHXV1dpX1XrlxBgwYNZIqMiIiIKH+yFU6bN29W2n7x4gV++eUXrFmzBlFRUVyegIiIiMocWec4AcDRo0cREBAABwcHLFiwAG3btkVkZKTcYRERERGpkGXEKSEhARs2bMDatWuhUCjg7++PzMxM7N69G/Xq1ZMjJCIiIqK30vqIU+fOneHu7o5Lly4hLCwMcXFxWLp0qbbDICIiIioyrY847d27F2PGjMHIkSPh6uqq7csTERERaUzrI07Hjx/Hixcv0KRJEzRv3hzLli3D48ePi93v8uXL4ezsDENDQzRv3hxnzpwp8NjVq1fjgw8+gJWVFaysrNC+fftCjyciIiICZCicvL29sXr1asTHx+Pzzz/H1q1b4ejoiNzcXBw4cAAvXrwocp/btm1DUFAQpk2bhvPnz6NRo0bw8/NDUlJSvsdHRESgb9++OHz4ME6dOgUnJyd8+OGHePjwYXFvj4iIiCow2b5VZ2JigsGDB+P48eO4fPkyJkyYgHnz5sHW1haffvppkfpatGgRhg0bhkGDBqFevXpYuXIljI2NsW7dunyP37x5M7744gt4enqiTp06WLNmDXJzcxEeHl4St0ZEREQVVJl4V527uzvmz5+P0NBQ/PnnnwUWPPnJyspCVFQUgoODpTYdHR20b98ep06dUquPtLQ0vHz5EtbW1gUek5mZiczMTGlboVAAALKzs5Gdna12vOoSIZZ4n3JT556Km8vKmjeAucuPNnLHvJX+dcoTfuY0o63PXEn0WyYKpzy6urro2rUrunbtqvY5jx8/Rk5ODuzs7JTa7ezscP36dbX6+Oqrr+Do6Ij27dsXeExoaChmzJih0h4ZGQkTExO141VXikmtEu9TbikpKW895sSJS8W7RiXNG8Dc5UcbuWPeinEd5k6zazBvJS41NVXtY8tU4SSHefPmYevWrYiIiIChoWGBxwUHByMoKEjaVigUcHJygre3N8zNzUs8rjsxRZ/rVdaZmpq+9RhfT99iXaOy5g1g7vKjjdwxb5pj7jTDvJW8vKdI6ij3hVO1atWgq6uLxMREpfbExETY29sXeu6CBQswb948HDx4EB4eHoUea2BgAAMDA5V2PT096OmVfBoFCCXep9zUuafi5rKy5g1g7vKjjdwxb6V/nfKEnznNaOszVxL9yv7KleLS19dHkyZNlCZ250309vHxKfC8+fPnY9asWdi3bx+8vLy0ESoRERGVc+V+xAkAgoKCEBAQAC8vLzRr1gxhYWFITU3FoEGDAAADBgxA9erVERoaCgD49ttvMXXqVGzZsgXOzs5ISEgA8GqoUN3hQiIiIqp8KkTh1Lt3bzx69AhTp05FQkICPD09sW/fPmnC+L1796Cj87/BtRUrViArKws9e/ZU6mfatGmYPn26NkMnIiKicqRCFE4AEBgYiMDAwHz3RUREKG3HxsaWfkBERERU4ZT7OU5ERERE2sLCiYiIiEhNLJyIiIiI1MTCiYiIiEhNLJyIiIiI1MTCiYiIiEhNLJyIiIiI1MTCiYiIiEhNLJyIiIiI1MTCiYiIiEhNLJyIiIiI1MTCiYiIiEhNLJyIiIiI1MTCiYiIiEhNLJyIiIiI1MTCiYiIiEhNLJyIiIiI1MTCiYiIiEhNLJyIiIiI1MTCiYiIiEhNLJyIiIiI1MTCiYiIiEhNLJyIiIiI1MTCiYiIiEhNLJyIiIiI1MTCiYiIiEhNLJyIiIiI1FRhCqfly5fD2dkZhoaGaN68Oc6cOVPo8du3b0edOnVgaGiIhg0bYs+ePVqKlIiIiMqrClE4bdu2DUFBQZg2bRrOnz+PRo0awc/PD0lJSfkef/LkSfTt2xdDhgzBhQsX0LVrV3Tt2hVXrlzRcuRERERUnlSIwmnRokUYNmwYBg0ahHr16mHlypUwNjbGunXr8j1+8eLF+Oijj/Dll1+ibt26mDVrFt577z0sW7ZMy5ETERFReaIndwDFlZWVhaioKAQHB0ttOjo6aN++PU6dOpXvOadOnUJQUJBSm5+fH3bv3l3gdTIzM5GZmSltJycnAwCePn2K7OzsYtxB/rJzcku8T7ll57w9T0+fPi3mNSpn3gDmLj/ayB3zVpzrMHeaXYN5K2kKhQIAIIri2w8Wy7mHDx+KAMSTJ08qtX/55Zdis2bN8j2nSpUq4pYtW5Tali9fLtra2hZ4nWnTpokA+MMf/vCHP/zhTwX9uX///lvrjnI/4qQtwcHBSqNUubm5ePr0KapWrQpBEGSMrGQpFAo4OTnh/v37MDc3lzuccoW50wzzpjnmTjPMm+Yqau5EUcSLFy/g6Oj41mPLfeFUrVo16OrqIjExUak9MTER9vb2+Z5jb29fpOMBwMDAAAYGBkptlpaWmgVdDpibm1eo/1NoE3OnGeZNc8ydZpg3zVXE3FlYWKh1XLmfHK6vr48mTZogPDxcasvNzUV4eDh8fHzyPcfHx0fpeAA4cOBAgccTERERARVgxAkAgoKCEBAQAC8vLzRr1gxhYWFITU3FoEGDAAADBgxA9erVERoaCgAYO3YsWrVqhYULF+KTTz7B1q1bce7cOfz4449y3gYRERGVcRWicOrduzcePXqEqVOnIiEhAZ6enti3bx/s7OwAAPfu3YOOzv8G11q0aIEtW7bgm2++wddffw1XV1fs3r0bDRo0kOsWygwDAwNMmzZN5bEkvR1zpxnmTXPMnWaYN80xd4Agiup8946IiIiIyv0cJyIiIiJtYeFEREREpCYWTkRERERqYuFEREREpCYWTkRERERqYuFEREREpCYWTkRERERqYuFEREREpCYWTkRERERqYuFEREREpCYWTkRERERqYuFEREREpCYWTkRERERqYuFEREREpCYWTkRERERq0pM7gPIqNzcXcXFxMDMzgyAIcodDREREGhJFES9evICjoyN0dAofU2LhpKG4uDg4OTnJHQYRERGVkPv37+Odd94p9BgWThoyMzMD8CrJ5ubmMkdDREREmlIoFHBycpJ+txeGhZOG8h7PmZubs3AiIiKqANSZesPJ4URERERqYuFEREREpCYWTkRERERqqpBznFasWIEVK1YgNjYWAFC/fn1MnToVHTt2BABkZGRgwoQJ2Lp1KzIzM+Hn54cffvgBdnZ2JR5LTk4OXr58WeL9EpWGKlWqQFdXV+4wiIjKrApZOL3zzjuYN28eXF1dIYoiNm7ciC5duuDChQuoX78+xo8fj7///hvbt2+HhYUFAgMD0b17d5w4caLEYhBFEQkJCXj+/HmJ9UmkDZaWlrC3t+f6ZERE+RBEURTlDkIbrK2t8d1336Fnz56wsbHBli1b0LNnTwDA9evXUbduXZw6dQre3t5q9adQKGBhYYHk5OR8v1UXHx+P58+fw9bWFsbGxvwlRGWeKIpIS0tDUlISLC0t4eDgIHdIRERa8bbf6a+rkCNOr8vJycH27duRmpoKHx8fREVF4eXLl2jfvr10TJ06dVCjRo1CC6fMzExkZmZK2wqFAgCQnZ2N7OxslWs+e/YMtra2sLa2LoW7IiodhoaGEEURSUlJsLa25mM7IqoU3vw9XpgKWzhdvnwZPj4+yMjIgKmpKXbt2oV69eohOjoa+vr6sLS0VDrezs4OCQkJBfYXGhqKGTNmqLRHRkbCxMREqU0QBGkRrZSUlOLfDJGWZWZm4vTp06gkA9JEFVrvXAu5QyjQNp1kuUMAAKSmpqp9bIUtnNzd3REdHY3k5GTs2LEDAQEBOHLkiMb9BQcHIygoSNrOW2XU29tbZVgvIyMD9+7dg4mJCQwNDTW+JpEc9PT0YGBgAFdXV35+iSqCY1fkjqBAvr6+cocA4H9PkdRRYQsnfX191K5dGwDQpEkTnD17FosXL0bv3r2RlZWF58+fK406JSYmwt7evsD+DAwMYGBgoNKup6cHPT09lTZBEKQfovIk73Ob32ebiKgklZW/Y4oSR6VZxyk3NxeZmZlo0qQJqlSpgvDwcGnfjRs3cO/ePfj4+MgYYfkQEREBQRC08m1Bda/l7OyMsLCwEr/+wIED0bVr1xLvV5tiY2MhCAKio6PlDoWIqEIoG6VeCQsODkbHjh1Ro0YNvHjxAlu2bEFERAT2798PCwsLDBkyBEFBQbC2toa5uTlGjx4NHx8ftb9RpynnyX+Xav9vip33iUbnnTp1Cu+//z4++ugj/P23dmN+XYsWLRAfHw8Li1fP5zds2IBx48ZpbYmHxYsXF2uOz8CBA7Fx40YAr/41Y21tDQ8PD/Tt2xcDBw6Ejk7J/rtl4MCBeP78OXbv3l2i/RIR0f9UyBGnpKQkDBgwAO7u7mjXrh3Onj2L/fv3o0OHDgCA77//Hp06dUKPHj3QsmVL2Nvb47fffpM56rJj7dq1GD16NI4ePYq4uDhZYnj58iX09fVlXU/IwsJC5UsERfXRRx8hPj4esbGx2Lt3L9q0aYOxY8eiU6dORfoWBxERlQ0VsnBau3YtYmNjkZmZiaSkJBw8eFAqmoBXX7levnw5nj59itTUVPz222+Fzm+qTFJSUrBt2zaMHDkSn3zyCTZs2PDWc1avXg0nJycYGxujW7duWLRokUrBsWLFCrz77rvQ19eHu7s7Nm3apLRfEASsWLECn376KUxMTDBnzhylR3UREREYNGgQkpOTpTk406dPl85PS0vD4MGDYWZmhho1auDHH3+U9uU9rvr111/xwQcfwMjICE2bNsXNmzdx9uxZeHl5wdTUFB07dsSjR4+k8958VJebm4v58+ejdu3aMDAwQI0aNTBnzpxCc2NgYAB7e3tUr14d7733Hr7++mv8/vvv2Lt3r1Junz9/jqFDh8LGxgbm5uZo27YtLl68KO2fPn06PD09sWrVKinX/v7+SE5OlvZv3LgRv//+u5SfiIgI6fw7d+6gTZs2MDY2RqNGjXDq1KlC4yYiovxVyMKJNPfrr7+iTp06cHd3x2effYZ169YV+rjqxIkTGDFiBMaOHYvo6Gh06NBBpZjYtWsXxo4diwkTJuDKlSv4/PPPMWjQIBw+fFjpuOnTp6Nbt264fPkyBg8erLSvRYsWCAsLg7m5OeLj4xEfH4+JEydK+xcuXAgvLy9cuHABX3zxBUaOHIkbN24o9TFt2jR88803OH/+PPT09NCvXz9MmjQJixcvxrFjxxATE4OpU6cWeK/BwcGYN28eQkJCcPXqVWzZskWj1/S0bdsWjRo1Uhrl7NWrF5KSkrB3715ERUXhvffeQ7t27fD06VPpmJiYGPz666/4888/sW/fPuleAWDixInw9/eXRrji4+PRokUL6dwpU6Zg4sSJiI6OhpubG/r27csRLyIiDVTIOU6kubVr1+Kzzz4D8OoxU3JyMo4cOYLWrVvne/zSpUvRsWNHqYhxc3PDyZMn8ddff0nHLFiwAAMHDpR+yQcFBSEyMhILFixAmzZtpOP69euHQYMGSdt37tyR/qyvrw8LCwsIgpDv6ODHH38s9f/VV1/h+++/x+HDh+Hu7i4dM3HiRPj5+QEAxo4di759+yI8PFz6OuyQIUMKHGF78eIFFi9ejGXLliEgIAAA8O677+L999/P9/i3qVOnDi5dugQAOH78OM6cOYOkpCTpm5sLFizA7t27sWPHDgwfPhzAq2UufvrpJ1SvXh3Aq9x/8sknWLhwIezt7WFkZITMzMx88zNx4kR88smrOW8zZsxA/fr1ERMTgzp16mgUPxFRZcURJ5LcuHEDZ86cQd++fQG8mtDcu3dvrF27ttBzmjVrptT25va1a9dU1urw9fXFtWvXlNq8vLw0jt3Dw0P6c15xlZSUVOAxeSNFDRs2VGp785w8165dQ2ZmJtq1a6dxjK8TRVGau3Xx4kWkpKSgatWqMDU1lX7u3r2L27dvS+fUqFFDKpoAwMfHB7m5uSoja/l5/d7zXqVS0L0SEVHBOOJEkrVr1yI7OxuOjo5SmyiKMDAwwLJly6Rvt5WWN1dgL4oqVaoobQuCgNzc3AKPySta3mx785w8RkZGGseWn2vXrsHFxQXAq3llDg4OSnOS8hR3cnqe/O69oHslIqKCccSJALx6T89PP/2EhQsXIjo6Wvq5ePEiHB0d8csvv+R7nru7O86ePavU9uZ23bp1ceLECaW2EydOoF69ekWKUV9fHzk5OUU6p6S4urrCyMhIaf0vTR06dAiXL19Gjx49AADvvfceEhISoKenh9q1ayv9VKtWTTrv3r17St9yjIyMhI6OjvQ4Us78EBFVFhxxIgDAX3/9hWfPnmHIkCEqI0s9evTA2rVrMWLECJXzRo8ejZYtW2LRokXo3LkzDh06hL179yotIfDll1/C398fjRs3Rvv27fHnn3/it99+w8GDB4sUo7OzM1JSUhAeHo5GjRrB2NgYxsbGmt1wERkaGuKrr77CpEmToK+vD19fXzx69Aj//PMPhgwZUuB5mZmZSEhIQE5ODhITE7Fv3z6EhoaiU6dOGDBgAACgffv28PHxQdeuXTF//ny4ubkhLi4Of//9N7p16yY9wjQ0NERAQAAWLFgAhUKBMWPGwN/fX5rT5OzsjP379+PGjRuoWrVqqY8QEhFVRhxxIgCvHtO1b98+31+2PXr0wLlz56TJzK/z9fXFypUrsWjRIjRq1Aj79u3D+PHjld5x1rVrVyxevBgLFixA/fr1sWrVKqxfv77ACecFadGiBUaMGIHevXvDxsYG8+fPL/J9FkdISAgmTJiAqVOnom7duujdu/db5wnt27cPDg4OcHZ2xkcffYTDhw9jyZIl+P3336Grqwvg1aOzPXv2oGXLlhg0aBDc3NzQp08f/Pvvv0rf2qtduza6d++Ojz/+GB9++CE8PDzwww8/SPuHDRsGd3d3eHl5wcbGRmWUj4iIik8Q+fpzjSgUClhYWCA5OTnfl/zevXsXLi4ulfIlqcOGDcP169dx7NgxuUOpMKZPn47du3dr5dUplf3zS1TR2B+OljuEAiW08ZQ7BACF/05/Ex/VUbEtWLAAHTp0gImJCfbu3YuNGzcqjYQQERFVFCycqNjOnDmD+fPn48WLF6hVqxaWLFmCoUOHyh0WERFRiWPhRMX266+/yh1ChTd9+nSlV8wQEZE8ODmciIiISE0snIiIiIjUxMKJiIiISE0snIiIiIjUxMKJiIiISE0snIiIiIjUxMKJyr2IiAgIgoDnz58DADZs2ABLS8tSvebAgQPRtWvXUr1GSWjdujXGjRsndxhERBUG13HSIm0ve1/UpewHDhyIjRs3IjQ0FJMnT5bad+/ejW7duqG8vJ2nd+/e+Pjjj2WNISIiAm3atAHw6l10ZmZmqFWrFjp06IDx48fDwcGhVK737NmzUi8aiYgqM444kRJDQ0N8++23ePbsWYn2m5WVVaL9FcbIyAi2trZau15hbty4gbi4OJw9exZfffUVDh48iAYNGuDy5ctyh0ZERBpg4URK2rdvD3t7e4SGhhZ63M6dO1G/fn0YGBjA2dkZCxcuVNrv7OyMWbNmYcCAATA3N8fw4cOlR2h//fUX3N3dYWxsjJ49eyItLQ0bN26Es7MzrKysMGbMGOTk5Eh9bdq0CV5eXjAzM4O9vT369euHpKSkAmN781Gds7MzBEFQ+clz//59+Pv7w9LSEtbW1ujSpQtiY2Ol/Tk5OQgKCoKlpSWqVq2KSZMmqT36ZmtrC3t7e7i5uaFPnz44ceIEbGxsMHLkSKXj1qxZg7p168LQ0BB16tRRetdfbGwsBEHA1q1b0aJFCxgaGqJBgwY4cuSItD9vdMvKygqCIGDgwIHS+bm5uZg0aRKsra1hb2/PFciJiIqBhRMp0dXVxdy5c7F06VI8ePAg32OioqLg7++PPn364PLly5g+fTpCQkKwYcMGpeMWLFiARo0a4cKFCwgJCQEApKWlYcmSJdi6dSv27duHiIgIdOvWDXv27MGePXuwadMmrFq1Cjt27JD6efnyJWbNmoWLFy9i9+7diI2NVSoM3ubs2bOIj49HfHw8Hjx4AG9vb3zwwQdS335+fjAzM8OxY8dw4sQJmJqa4qOPPpJGyRYuXIgNGzZg3bp1OH78OJ4+fYpdu3YVIav/Y2RkhBEjRuDEiRNS8bd582ZMnToVc+bMwbVr1zB37lyEhIRg48aNSud++eWXmDBhAi5cuAAfHx907twZT548gZOTE3bu3Ang1QhXfHw8Fi9eLJ23ceNGmJiY4PTp05g/fz5mzpyJAwcOaBQ/EVFlVyELp9DQUDRt2hRmZmawtbVF165dcePGDaVjWrdurTICMWLECJkiLlu6desGT09PTJs2Ld/9ixYtQrt27RASEgI3NzcMHDgQgYGB+O6775SOa9u2LSZMmIB3330X7777LoBXhcqKFSvQuHFjtGzZEj179sTx48exdu1a1KtXD506dUKbNm1w+PBhqZ/BgwejY8eOqFWrFry9vbFkyRLs3bsXKSkpat2PjY0N7O3tYW9vj/nz5yM+Pl4qNLZt24bc3FysWbMGDRs2RN26dbF+/Xrcu3cPERERAICwsDAEBweje/fuqFu3LlauXAkLC4uiplVSp04dAJBGtaZNm4aFCxeie/fucHFxQffu3TF+/HisWrVK6bzAwED06NEDdevWxYoVK2BhYYG1a9dCV1cX1tbWAP43wvV6fB4eHpg2bRpcXV0xYMAAeHl5ITw8XOP4iYgqswpZOB05cgSjRo1CZGQkDhw4gJcvX+LDDz9Eamqq0nHDhg2TRiLi4+Mxf/58mSIue7799lts3LgR165dU9l37do1+Pr6KrX5+vri1q1bSo/YvLy8VM41NjaWiigAsLOzg7OzM0xNTZXaXn8UFxUVhc6dO6NGjRowMzNDq1atAAD37t0r0j39+OOPWLt2Lf744w/Y2NgAAC5evIiYmBiYmZnB1NQUpqamsLa2RkZGBm7fvo3k5GTEx8ejefPmUj96enr53pu68h7zCYKA1NRU3L59G0OGDJGub2pqitmzZ+P27dtK5/n4+KjEkN9/nzd5eHgobTs4OBT6qJOIiApWIb9Vt2/fPqXtDRs2wNbWFlFRUWjZsqXUbmxsDHt7e22HVy60bNkSfn5+CA4OLtJjsdeZmJiotFWpUkVpWxCEfNtyc3MBAKmpqfDz84Ofnx82b94MGxsb3Lt3D35+fkWacH748GGMHj0av/zyi1IhkZKSgiZNmmDz5s0q5+QVVyUtr9hxdnaWRs1Wr16tVJwBrx6bloTC8ktEREVTIQunNyUnJwOA9Dgjz+bNm/Hzzz/D3t4enTt3RkhICIyNjfPtIzMzE5mZmdK2QqEAAGRnZyM7O1vp2OzsbIiiKP3IRdNr550XGhqKxo0bw83NTam9bt26OHHihFL/x48fh5ubG3R0dKT2N+//9fbC2l7fd+3aNTx58gShoaFwcnIC8GrO0uv9v3m9N/uMiYlBz549ERwcrLKsQuPGjbFt2zbY2NjA3Nw833w4ODggMjJSmheVnZ2NqKgovPfeewXmuKAcpKen48cff0TLli1RrVo1AICjoyNu376Nfv365dtP3vmnTp1SiWHUqFEQRVEqjvI+ewX1kV+MBV0zv882EVFJKit/xxQljgpfOOXm5mLcuHHw9fVFgwYNpPZ+/fqhZs2acHR0xKVLl/DVV1/hxo0b+O233/LtJzQ0FDNmzFBpj4yMVBlZyVu3Jy0tTdYPhbpzgPK8fPkS2dnZ0nkuLi7w9/fH0qVLlfobMWIEWrdujZCQEHTv3h1nzpzB8uXLsWjRIukYURSRmZmpFENe4fl6W1ZWFnJzc5XaXo+jatWq0NfXx6JFizB48GBcu3YNM2fOBPBqonlKSgrS09OlfvX09JSuk56ejk6dOsHDwwP9+/dXevxlZ2eHLl26YP78+ejcuTOmTJkCR0dH3L9/H3/88QfGjRuH6tWrY8SIEZg3bx6cnJzg5uaGZcuW4fnz50q5elNeTHfv3oW5uTlevHiB6OhoLF68GI8ePcKmTZukc4ODgzFp0iQYGhqiffv2yMrKwoULF/D8+XMEBgZKj5iXL18OJycnuLu7Y/ny5Xj27Bl69+6NlJQUVKtWDYIgYMeOHfDz84OhoSFMTU2Rk5ODly9fKsWZnZ2t0va6rKwsZGZm4vz58+Vm7S6qHHrnaj63sLRt00nW2rUC9hbt73b4VS+dQEpA7W/2F+n4jR1N336QBt6cylOYCl84jRo1CleuXMHx48eV2ocPHy79uWHDhnBwcEC7du1w+/ZtpTk4eYKDgxEUFCRtKxQKODk5wdvbW2WkIiMjA/fu3YOxsTEMDQ1L+I7U9/q8IXVUqVIFenp6SufNnTtXKibz2t9//31s27YN06ZNw/z58+Hg4IAZM2bg888/l84TBAEGBgZKfRkYGKjEpa+vDx0dHaW21+MwNTXF+vXrMWXKFKxcuRLvvfceFi5ciC5dusDY2BimpqYwMjKS+jU1NVW6zuPHj3Hz5k3cvHlTGjnLk5ubC1NTUxw7dgyTJ0/GZ599hhcvXqB69epo27YtHBwcYGpqiuDgYDx58gQjRoyAjo4OBg0ahG7duiE5ObnAHOfF1KRJEwiCAFNTU2kBzKCgIKVHxKNGjYKVlRUWLFiAkJAQmJiYoGHDhhg7dixMTU2lwnzevHlYvHgxoqOjUbt2bfz++++oWbMmAMDNzQ3Tp0/HjBkz8MUXX2DAgAFYv349dHV1UaVKFaU49fT0VNpel5GRAQMDA7i6usr6+SVSceyK3BEU6M15n6Vqb9GKjYqktPKc9xRJHYJYgf9JGRgYiN9//x1Hjx6Fi4tLocempqbC1NQU+/btg5+f31v7VigUsLCwQHJycr6F0927d+Hi4sJfPFRssbGxcHFxwYULF+Dp6Vnq1+Pnl8oqbb99oSiK+qaG4nCe/HeRjs8owyNOhvsfFun42HmflEochf1Of1OFHHESRRGjR4/Grl27EBER8daiCQCio6MBoMRfhUFEREQVR4UsnEaNGoUtW7bg999/h5mZGRISEgAAFhYWMDIywu3bt7FlyxZ8/PHHqFq1Ki5duoTx48ejZcuWKl/dJiIiIspTIQunFStWAHi1yOXr1q9fj4EDB0JfXx8HDx5EWFgYUlNT4eTkhB49euCbb76RIVqiwjk7O3OSNhFRGVEhC6e3/ZJxcnKS3vNFREREpK4KuXI4ERERUWlg4VSKuDozlUf83BIRFaxCPqqTW97aRHFxcbCxsYG+vj4EQZA7LKJCiaKIrKwsPHr0CDo6OtDX15c7JCKiMoeFUynQ0dGBi4sL4uPjERcXJ3c4REVibGyMGjVqQEeHA9JERG9i4VRK9PX1UaNGDWRnZyMnJ0fucIjUoqurCz09PY6QEhEVgIVTKRIEAVWqVFF5Oz0RERGVTxyLJyIiIlITCyciIiIiNbFwIiIiIlJTmZrjdOvWLRw+fBhJSUkqa8lMnTpVpqiIiIiIXikzhdPq1asxcuRIVKtWDfb29krf6hEEgYUTERERya7MFE6zZ8/GnDlz8NVXX8kdChEREVG+yswcp2fPnqFXr15yh0FERERUoDJTOPXq1Qv//e9/5Q6DiIiIqECyPqpbsmSJ9OfatWsjJCQEkZGRaNiwocqikWPGjNF2eERERERKZC2cvv/+e6VtU1NTHDlyBEeOHFFqFwSBhRMRERHJTtbC6e7du3JenoiIiKhIyswcp5kzZyItLU2lPT09HTNnzpQhIiIiIiJlZaZwmjFjBlJSUlTa09LSMGPGDBkiIiIiIlJWZtZxEkVRadHLPBcvXoS1tbUMERERlTz7w9Fyh1CghDaeWr2e8+S/i3aCX/XSCaQEFPVeYud9UkqRUGmTvXCysrKCIAgQBAFubm5KxVNOTg5SUlIwYsQIGSMkIiIiekX2wiksLAyiKGLw4MGYMWMGLCwspH36+vpwdnaGj49PkfoMDQ3Fb7/9huvXr8PIyAgtWrTAt99+C3d3d+mYjIwMTJgwAVu3bkVmZib8/Pzwww8/wM7OrsTujYiIiCoW2QungIAAAICLiwtatGihsn6TJo4cOYJRo0ahadOmyM7Oxtdff40PP/wQV69ehYmJCQBg/Pjx+Pvvv7F9+3ZYWFggMDAQ3bt3x4kTJ4p9fSIiIqqYZC+c8rRq1Qo5OTnYsWMHrl27BgCoV68eunTpAj29ooW5b98+pe0NGzbA1tYWUVFRaNmyJZKTk7F27Vps2bIFbdu2BQCsX78edevWRWRkJLy9vUvmpoiIiKhCKTOF0z///INPP/0UCQkJ0iO1b7/9FjY2Nvjzzz/RoEEDjftOTk4GAGmSeVRUFF6+fIn27dtLx9SpUwc1atTAqVOn8i2cMjMzkZmZKW0rFAoAQHZ2NrKzszWOjYiorODfZdrDXGumtPJWlH7LTOE0dOhQ1K9fH+fOnYOVlRWAVy/+HThwIIYPH46TJ09q1G9ubi7GjRsHX19fqfhKSEiAvr4+LC0tlY61s7NDQkJCvv2EhobmuyxCZGSk9PiPiOjtLN5+iEw4VUF7mGvNlFbeUlNT1T62zBRO0dHRSkUT8Oobd3PmzEHTpk017nfUqFG4cuUKjh8/Xqz4goODERQUJG0rFAo4OTnB29sb5ubmxeqbiCqRY1fkjqBAvr6+2r3g3v3avV4ZUqxcM28lLu8pkjrKTOHk5uaGxMRE1K9fX6k9KSkJtWvX1qjPwMBA/PXXXzh69Cjeeecdqd3e3h5ZWVl4/vy50qhTYmIi7O3t8+3LwMAABgYGKu16enpFnoNFRFQW8e8y7WGuNVNaeStKv2Vm5fDQ0FCMGTMGO3bswIMHD/DgwQPs2LED48aNw7fffguFQiH9vI0oiggMDMSuXbtw6NAhuLi4KO1v0qQJqlSpgvDwcKntxo0buHfvXpGXPiAiIqLKo8yUvJ06dQIA+Pv7S4tgiqIIAOjcubO0LQgCcnJyCu1r1KhR2LJlC37//XeYmZlJ85YsLCxgZGQECwsLDBkyBEFBQbC2toa5uTlGjx4NHx8ffqOOiIiIClRmCqfDhw+XWF8rVqwAALRu3Vqpff369Rg4cCAA4Pvvv4eOjg569OihtAAmERERUUHKTOHUqlWrEusrb6SqMIaGhli+fDmWL19eYtclIiKiiq3MFE4AcOzYMaxatQp37tzB9u3bUb16dWzatAkuLi54//335Q6PiP5fWX5RLaD9l9USUeVRZiaH79y5E35+fjAyMsL58+elxSaTk5Mxd+5cmaMjIiIiKkOF0+zZs7Fy5UqsXr1a6X11vr6+OH/+vIyREREREb1SZgqnGzduoGXLlirtFhYWeP78ufYDIiIiInpDmSmc7O3tERMTo9J+/Phx1KpVS4aIiIiIiJSVmcJp2LBhGDt2LE6fPg1BEBAXF4fNmzdj4sSJGDlypNzhEREREZWdb9VNnjwZubm5aNeuHdLS0tCyZUsYGBhg4sSJGD16tNzhERHly3ny30U7wa966QRSAop6L7HzPimlSIjKrjJTOAmCgClTpuDLL79ETEwMUlJSUK9ePZiamsodGhERERGAMlQ4Aa8WrlQoFLCzs0O9evXkDoeIiIhISZmY45SQkIABAwbAysoKdnZ2sLW1hZWVFQYPHozExES5wyMiIiICUAZGnBQKBVq0aIGUlBQMGjQIderUgSiKuHr1Kn755RccP34c58+f5yM7IiIikp3shdPixYuhq6uLf/75BzY2Nkr7vvnmG/j6+mLJkiX4+uuvZYqQiIiI6BXZH9X9/fff+Prrr1WKJgCwtbVFcHAw/vzzTxkiIyIiIlIme+F08+ZNtGjRosD9LVq0wI0bN7QYEREREVH+ZC+cFAoFLC0tC9xvaWkJhUKhvYCIiIiICiB74SSKInR0Cg5DEASIoqjFiIiIiIjyJ/vkcFEU4ebmBkEQCtxPREREVBbIXjitX79e7hCIiIiI1CJ74RQQECB3CERERERqkb1wIqKyoUgveC3DL6oF+LJaIio9sk8OJyIiIiovWDgRERERqalCFk5Hjx5F586d4ejoCEEQsHv3bqX9AwcOhCAISj8fffSRPMESERFRuVFmCqeZM2ciLS1NpT09PR0zZ84sUl+pqalo1KgRli9fXuAxH330EeLj46WfX375pcgxExERUeVSZgqnGTNmICUlRaU9LS0NM2bMKFJfHTt2xOzZs9GtW7cCjzEwMIC9vb30Y2VlVeSYiYiIqHIpM9+qE0Ux30UwL168CGtr6xK/XkREBGxtbWFlZYW2bdti9uzZqFq1aoHHZ2ZmIjMzU9rOew1MdnY2srOzSzw+ItIe/n9YM8yb5pg7zZRW3orSr+yFk5WVlTTP6M0VxHNycpCSkoIRI0aU6DU/+ugjdO/eHS4uLrh9+za+/vprdOzYEadOnYKurm6+54SGhuY78hUZGQkTE5MSjY+ItOvEiRNyh1AuMW+aY+40U1p5S01NVftY2QunsLAwiKKIwYMHY8aMGbCwsJD26evrw9nZGT4+PiV6zT59+kh/btiwITw8PPDuu+8iIiIC7dq1y/ec4OBgBAUFSdsKhQJOTk7w9vaGubl5icZHJIu9++WOQDa+vr6an8y8aY650wzzVuLyniKpQ/bCKW/lcBcXF7Ro0QJVqlTRegy1atVCtWrVEBMTU2DhZGBgAAMDA5V2PT096OnJnkYiKgb+f1gzzJvmmDvNlFbeitKvrP/lFAqFNFrTuHFjpKenIz09Pd9jS3NU58GDB3jy5AkcHBxK7RpERERU/slaOFlZWSE+Ph62trawtLTMd3J43qTxnJwctftNSUlBTEyMtH337l1ER0fD2toa1tbWmDFjBnr06AF7e3vcvn0bkyZNQu3ateHn51ci90VEREQVk6yF06FDh6RvzB0+fLjE+j137hzatGkjbefNTQoICMCKFStw6dIlbNy4Ec+fP4ejoyM+/PBDzJo1K99HcURERER5ZC2cWrVqle+fi6t169YQRbHA/fv3V96JdURERKS5MjM77ejRo4Xub9mypZYiISIiIspfmSmcWrdurdL25ppORERERHIqM69cefbsmdJPUlIS9u3bh6ZNm+K///2v3OERERERlZ0Rp9cXvszToUMH6OvrIygoCFFRUTJERURERPQ/ZWbEqSB2dna4ceOG3GEQERERlZ0Rp0uXLilti6KI+Ph4zJs3D56envIERURERPSaMlM4eXp6QhAElWUEvL29sW7dOpmiIiIiIvqfMlM43b17V2lbR0cHNjY2MDQ0lCkiIiIiImVlpnCqWbOm3CEQERERFarMTA4fM2YMlixZotK+bNkyjBs3TvsBEREREb2hzBROO3fuhK+vr0p7ixYtsGPHDhkiIiIiIlJWZgqnJ0+e5LuWk7m5OR4/fixDRERERETKyswcp9q1a2Pfvn0IDAxUat+7dy9q1aolU1Tlg/3haLlDKFRCG0+5QyhQWc5dWc4bEVFlVWYKp6CgIAQGBuLRo0do27YtACA8PBwLFy5EWFiYvMERERERoQwVToMHD0ZmZibmzJmDWbNmAQCcnZ2xYsUKDBgwQOboiIiIiMpI4ZSdnY0tW7age/fuGDlyJB49egQjIyOYmprKHRoRERGRpExMDtfT08OIESOQkZEBALCxsWHRRERERGVOmSicAKBZs2a4cOGC3GEQERERFahMPKoDgC+++AITJkzAgwcP0KRJE5iYmCjt9/DwkCkyIiIiolfKTOHUp08fAK9WEM+T99JfQRCQk5MjV2hUjjhP/rtoJ/hVL51ASkBR7yV23ielFAkREeUpM4XTmy/5JSIiIiprykzhxJf8EhERUVkna+H0xx9/oGPHjqhSpQr++OOPQo/99NNP1e736NGj+O677xAVFYX4+Hjs2rULXbt2lfaLoohp06Zh9erVeP78OXx9fbFixQq4urpqeitERERUCchaOHXt2hUJCQmwtbVVKmzeVNQ5TqmpqWjUqBEGDx6M7t27q+yfP38+lixZgo0bN8LFxQUhISHw8/PD1atXYWhoqMmtEBERUSUga+GUm5ub75+Lq2PHjujYsWO++0RRRFhYGL755ht06dIFAPDTTz/Bzs4Ou3fvliapExEREb2pzMxx0pa7d+8iISEB7du3l9osLCzQvHlznDp1qsDCKTMzE5mZmdK2QqEA8GrV8+zs7NINupxjfrSDedYcc6cZ5k1zzJ1mSitvRelX9sLp0KFDCAwMRGRkJMzNzZX2JScno0WLFlixYgVatmxZItdLSEgAANjZ2Sm129nZSfvyExoaihkzZqi0R0ZGqqw5VRIC9qaof3AZ/ko9ANT+Zr/ax27syBXjNXXixAm5Qyi3mDvNMG+aY+40U1p5S01NVftY2QunsLAwDBs2TKVoAl6NBH3++ef4/vvvS6xw0lRwcDCCgoKkbYVCAScnJ3h7e+cbe7HtVb/YqEh8fX2L10ElzRvA3BVHsXLHvGmOudMM81bi8p4iqUP2wunixYv49ttvC9z/4YcfYsGCBSV2PXt7ewBAYmIiHBwcpPbExER4enoWeJ6BgQEMDAxU2vX09KCnJ3saKwzmUnPMneaYO80wb5pj7jRTWnkrSr+yv6suMTERVapUKXC/np4eHj16VGLXc3Fxgb29PcLDw6U2hUKB06dPw8fHp8SuQ0RERBWP7CVv9erVceXKFdSuXTvf/ZcuXVIaGVJHSkoKYmJipO27d+8iOjoa1tbWqFGjBsaNG4fZs2fD1dVVWo7A0dGx0CURiIiIiGQvnD7++GOEhITgo48+UllDKT09HdOmTUOnTp2K1Oe5c+fQpk0baTtvblJAQAA2bNiASZMmITU1FcOHD8fz58/x/vvvY9++fVzDiYiIiAole+H0zTff4LfffoObmxsCAwPh7u4OALh+/TqWL1+OnJwcTJkypUh9tm7dGqIoFrhfEATMnDkTM2fOLFbsREREVLnIXjjZ2dnh5MmTGDlyJIKDg6WCRxAE+Pn5Yfny5SpLBxARERHJQfbCCXj1gt89e/bg2bNniImJgSiKcHV1hZWVldyhEREREUnKROGUx8rKCk2bNpU7DCIiIqJ8yb4cAREREVF5wcKJiIiISE0snIiIiIjUxMKJiIiISE0snIiIiIjUxMKJiIiISE0snIiIiIjUxMKJiIiISE0snIiIiIjUxMKJiIiISE0snIiIiIjUxMKJiIiISE0snIiIiIjUxMKJiIiISE0snIiIiIjUxMKJiIiISE0snIiIiIjUxMKJiIiISE2VsnCaPn06BEFQ+qlTp47cYREREVEZpyd3AHKpX78+Dh48KG3r6VXaVBAREZGaKm21oKenB3t7e7nDICIionKk0hZOt27dgqOjIwwNDeHj44PQ0FDUqFGjwOMzMzORmZkpbSsUCgBAdnY2srOzSz3eyoK51BxzpznmTjPMm+aYO82UVt6K0m+lLJyaN2+ODRs2wN3dHfHx8ZgxYwY++OADXLlyBWZmZvmeExoaihkzZqi0R0ZGwsTEpLRDrjROnDghdwjlFnOnOeZOM8yb5pg7zZRW3lJTU9U+tlIWTh07dpT+7OHhgebNm6NmzZr49ddfMWTIkHzPCQ4ORlBQkLStUCjg5OQEb29vmJubl3yQe/eXfJ/lgK+vb/E6qKR5A5i74ihW7pg3zTF3mmHeSlzeUyR1VMrC6U2WlpZwc3NDTExMgccYGBjAwMBApV1PT48Ty0sQc6k55k5zzJ1mmDfNMXeaKa28FaXfSrkcwZtSUlJw+/ZtODg4yB0KERERlWGVsnCaOHEijhw5gtjYWJw8eRLdunWDrq4u+vbtK3doREREVIZVyrHCBw8eoG/fvnjy5AlsbGzw/vvvIzIyEjY2NnKHRkRERGVYpSyctm7dKncIREREVA5Vykd1RERERJpg4URERESkJhZORERERGpi4URERESkJhZORERERGpi4URERESkJhZORERERGpi4URERESkJhZORERERGpi4URERESkJhZORERERGpi4URERESkJhZORERERGpi4URERESkJhZORERERGpi4URERESkJhZORERERGpi4URERESkJhZORERERGpi4URERESkJhZORERERGpi4URERESkpkpdOC1fvhzOzs4wNDRE8+bNcebMGblDIiIiojKs0hZO27ZtQ1BQEKZNm4bz58+jUaNG8PPzQ1JSktyhERERURlVaQunRYsWYdiwYRg0aBDq1auHlStXwtjYGOvWrZM7NCIiIiqj9OQOQA5ZWVmIiopCcHCw1Kajo4P27dvj1KlT+Z6TmZmJzMxMaTs5ORkA8PTpU2RnZ5duwJXI06dP5Q6h3GLuNMfcaYZ50xxzp5nSyptCoQAAiKL49oPFSujhw4ciAPHkyZNK7V9++aXYrFmzfM+ZNm2aCIA//OEPf/jDH/5U0J/79++/tYaolCNOmggODkZQUJC0nZubi6dPn6Jq1aoQBEHGyEqWQqGAk5MT7t+/D3Nzc7nDKVeYO80wb5pj7jTDvGmuouZOFEW8ePECjo6Obz22UhZO1apVg66uLhITE5XaExMTYW9vn+85BgYGMDAwUGqztLQsrRBlZ25uXqH+T6FNzJ1mmDfNMXeaYd40VxFzZ2FhodZxlXJyuL6+Ppo0aYLw8HCpLTc3F+Hh4fDx8ZExMiIiIirLKuWIEwAEBQUhICAAXl5eaNasGcLCwpCamopBgwbJHRoRERGVUZW2cOrduzcePXqEqVOnIiEhAZ6enti3bx/s7OzkDk1WBgYGmDZtmspjSXo75k4zzJvmmDvNMG+aY+4AQRTV+e4dEREREVXKOU5EREREmmDhRERERKQmFk5EREREamLhRERERKQmFk4EAFixYgU8PDykRc18fHywd+9eucMqd+bNmwdBEDBu3Di5Qynzpk+fDkEQlH7q1Kkjd1jlwsOHD/HZZ5+hatWqMDIyQsOGDXHu3Dm5wyrznJ2dVT5zgiBg1KhRcodWpuXk5CAkJAQuLi4wMjLCu+++i1mzZqn3XrcKqNIuR0DK3nnnHcybNw+urq4QRREbN25Ely5dcOHCBdSvX1/u8MqFs2fPYtWqVfDw8JA7lHKjfv36OHjwoLStp8e/kt7m2bNn8PX1RZs2bbB3717Y2Njg1q1bsLKykju0Mu/s2bPIycmRtq9cuYIOHTqgV69eMkZV9n377bdYsWIFNm7ciPr16+PcuXMYNGgQLCwsMGbMGLnD0zr+LUUAgM6dOyttz5kzBytWrEBkZCQLJzWkpKSgf//+WL16NWbPni13OOWGnp5ega85ovx9++23cHJywvr166U2FxcXGSMqP2xsbJS2582bh3fffRetWrWSKaLy4eTJk+jSpQs++eQTAK9G7n755RecOXNG5sjkwUd1pCInJwdbt25FamoqX0GjplGjRuGTTz5B+/bt5Q6lXLl16xYcHR1Rq1Yt9O/fH/fu3ZM7pDLvjz/+gJeXF3r16gVbW1s0btwYq1evljuscicrKws///wzBg8eXKFe1F4aWrRogfDwcNy8eRMAcPHiRRw/fhwdO3aUOTJ5cMSJJJcvX4aPjw8yMjJgamqKXbt2oV69enKHVeZt3boV58+fx9mzZ+UOpVxp3rw5NmzYAHd3d8THx2PGjBn44IMPcOXKFZiZmckdXpl1584drFixAkFBQfj6669x9uxZjBkzBvr6+ggICJA7vHJj9+7deP78OQYOHCh3KGXe5MmToVAoUKdOHejq6iInJwdz5sxB//795Q5NFlw5nCRZWVm4d+8ekpOTsWPHDqxZswZHjhxh8VSI+/fvw8vLCwcOHJDmNrVu3Rqenp4ICwuTN7hy5vnz56hZsyYWLVqEIUOGyB1OmaWvrw8vLy+cPHlSahszZgzOnj2LU6dOyRhZ+eLn5wd9fX38+eefcodS5m3duhVffvklvvvuO9SvXx/R0dEYN24cFi1aVCmLdY44kURfXx+1a9cGADRp0gRnz57F4sWLsWrVKpkjK7uioqKQlJSE9957T2rLycnB0aNHsWzZMmRmZkJXV1fGCMsPS0tLuLm5ISYmRu5QyjQHBweVf8zUrVsXO3fulCmi8ufff//FwYMH8dtvv8kdSrnw5ZdfYvLkyejTpw8AoGHDhvj3338RGhrKwonodbm5ucjMzJQ7jDKtXbt2uHz5slLboEGDUKdOHXz11VcsmoogJSUFt2/fxn/+8x+5QynTfH19cePGDaW2mzdvombNmjJFVP6sX78etra20mRnKlxaWhp0dJSnROvq6iI3N1emiOTFwokAAMHBwejYsSNq1KiBFy9eYMuWLYiIiMD+/fvlDq1MMzMzQ4MGDZTaTExMULVqVZV2UjZx4kR07twZNWvWRFxcHKZNmwZdXV307dtX7tDKtPHjx6NFixaYO3cu/P39cebMGfz444/48ccf5Q6tXMjNzcX69esREBDA5S/U1LlzZ8yZMwc1atRA/fr1ceHCBSxatAiDBw+WOzRZ8FNDAICkpCQMGDAA8fHxsLCwgIeHB/bv348OHTrIHRpVUA8ePEDfvn3x5MkT2NjY4P3330dkZKTKV8ZJWdOmTbFr1y4EBwdj5syZcHFxQVhYWKWdqFtUBw8exL179yrtL31NLF26FCEhIfjiiy+QlJQER0dHfP7555g6darcocmCk8OJiIiI1MR1nIiIiIjUxMKJiIiISE0snIiIiIjUxMKJiIiISE0snIiIiIjUxMKJiIiISE0snIiIiIjUxMKJiIiISE0snIjKAEEQsHv37lK9RkREBARBwPPnz0v1Onnedk+xsbEQBAHR0dGF9tO6dWuMGzeuyNfPyspC7dq1cfLkySKfW1qmT58OT09PucNQ8uOPP8LJyQk6OjoICwsr9eupk4OBAweia9euGl/j8ePHsLW1xYMHDzTug6ggLJyISllCQgJGjx6NWrVqwcDAAE5OTujcuTPCw8OlY+Lj49GxY8dSjaNFixbSK3UAYMOGDbC0tCz0nOvXr0MQBERGRiq1e3t7w9DQEBkZGVJbRkYGDA0NsXbtWgBFv6eSLuxWrlwJFxcXtGjRQmoTBAGGhob4999/lY7t2rUrBg4cWCLXLU8UCgUCAwPx1Vdf4eHDhxg+fHiBx/71119o1aoVzMzMYGxsjKZNm2LDhg2lEtfixYuV+i5q8VytWjUMGDAA06ZNK/ngqNJj4URUimJjY9GkSRMcOnQI3333HS5fvox9+/ahTZs2GDVqlHScvb09DAwMCuzn5cuXxY5FX18f9vb2EARB7XPq1KkDe3t7RERESG0vXrzA+fPnYWNjo1RQnTp1CpmZmWjbti2At99TaRJFEcuWLcOQIUNU9gmCUOHesaXp5+PevXt4+fIlPvnkEzg4OMDY2Djf45YuXYouXbrA19cXp0+fxqVLl9CnTx+MGDECEydOLE7o+bKwsHhrUf82gwYNwubNm/H06dOSCYro/7FwIipFX3zxBQRBwJkzZ9CjRw+4ubmhfv36CAoKUio6Xn+slfcIa9u2bWjVqhUMDQ2xefNmAMC6detQv359GBgYwMHBAYGBgUrnvP7Y6/nz5xAEQSp6Xh/RiYiIwKBBg5CcnAxBECAIAqZPn57vPbRp00apcDp+/Djc3NzQuXNnpfaIiAjUrFkTLi4uKvcEAGfOnEHjxo1haGgILy8vXLhwQdoXGxuLNm3aAACsrKwgCILSCFBubi4mTZoEa2tr2NvbFxhrnqioKNy+fRuffPKJyr7AwED8/PPPuHLlSoHnOzs7qzy28vT0VLquIAhYtWoVOnXqBGNjY9StWxenTp1CTEwMWrduDRMTE7Ro0QK3b99W6X/VqlVwcnKCsbEx/P39kZycrLR/zZo1qFu3LgwNDVGnTh388MMP0r7CPh9vunfvHrp06QJTU1OYm5vD398fiYmJAF6NODZs2BAAUKtWLQiCgNjYWJU+7t+/jwkTJmDcP2vZtgAACrtJREFUuHGYO3cu6tWrh9q1a2PChAn47rvvsHDhQpw+fVrq882CZ/fu3fkW64Xl4PVHdQMHDsSRI0ewePFi6bMaGxuLZ8+eoX///rCxsYGRkRFcXV2xfv16qY/69evD0dERu3btyjc3RJpi4URUSp4+fYp9+/Zh1KhRMDExUdn/tn9RT548GWPHjsW1a9fg5+eHFStWYNSoURg+fDguX76MP/74A7Vr19YothYtWiAsLAzm5uaIj49HfHx8gSMHbdq0wfHjx5GdnQ0AOHz4MFq3bo1WrVrh8OHD0nGHDx+Wip83paSkoFOnTqhXrx6ioqIwffp0pes5OTlh586dAIAbN24gPj4eixcvlvZv3LgRJiYmOH36NObPn4+ZM2fiwIEDBd7fsWPH4ObmBjMzM5V9vr6+6NSpEyZPnlxIhtQza9YsDBgwANHR0ahTpw769euHzz//HMHBwTh37hxEUZSK2zwxMTH49ddf8eeff2Lfvn24cOECvvjiC2n/5s2bMXXqVMyZMwfXrl3D3LlzERISgo0bNyr18+bn4025ubno0qULnj59iiNHjuDAgQO4c+cOevfuDQDo3bs3Dh48COBVURsfHw8nJyeVfnbs2IGXL1/m+/n4/PPPYWpqil9++aVIeXtbDl63ePFi+Pj4YNiwYdJn1cnJCSEhIbh69Sr27t2La9euYcWKFahWrZrSuc2aNcOxY8eKFBvR2+jJHQBRRRUTEwNRFFGnTh2Nzh83bhy6d+8ubc+ePRsTJkzA2LFjpbamTZtq1Le+vj4sLCwgCALs7e0LPbZNmzZITU3F2bNn4ePjg4iICHz55Zd4//33ERAQgIyMDIiiiDNnzmDo0KH59rFlyxbk5uZi7dq1MDQ0RP369fHgwQOMHDkSAKCrqwtra2sAgK2trUpR6eHhIc1XcXV1xbJlyxAeHo4OHTrke71///0Xjo6OBd5TaGgoPDw8cOzYMXzwwQeF3n9hBg0aBH9/fwDAV199BR8fH4SEhEiFzNixYzFo0CClczIyMvDTTz+hevXqAF49Bvvkk0+wcOFC2NvbY9q0aVi4cKH0397FxQVXr17FqlWrEBAQIPXz5ufjTeHh4bh8+TLu3r0rFUQ//fQT6tevj7Nnz6Jp06aoWrUqAMDGxqbAz8HNmzdhYWEBBwcHlX36+vqoVasWbt68qVa+1M3B6ywsLKCvrw9jY2Olfffu3UPjxo3h5eUF4NUo4ZscHR2VRjaJSgJHnIhKiSiKxTo/7xcCACQlJSEuLg7t2rUrblhFVrt2bbzzzjuIiIiAQqHAhQsX0KpVKzg4OKBGjRo4deqUNL+poBGna9euwcPDA4aGhlKbj4+P2jF4eHgobTs4OCApKanA49PT05Wu9aZ69ephwIABxR51ej0uOzs7AJAef+W1ZWRkQKFQSG01atSQCgbgVR5yc3Nx48YNpKam4vbt2xgyZAhMTU2ln9mzZ6s88nv985Gfa9euwcnJSWkUqV69erC0tMS1a9c0u+EC6OvrF+n4wnKgrpEjR2Lr1q3w9PTEpEmT8v32pJGREdLS0ooUG9HbcMSJqJS4urpCEARcv35do/Nff7xnZGRU6LE6Oq/+DfR6sVYSE8rztG7dGocPH4aHhwdcXV1ha2sLANLjOlEUUbt27Xwf9ZSEKlWqKG0LgoDc3NwCj69WrRouX75caJ8zZsyAm5tbvksm6OjoqBS++eXz9bjy5vHk11ZYrK9LSUkBAKxevRrNmzdX2qerq6u0nd/j39Lg6uqK5ORkxMXFqYziZWVl4fbt29IIm7p5KwkdO3bEv//+iz179uDAgQNo164dRo0ahQULFkjHPH36FDY2NqVyfaq8OOJEVEqsra3h5+eH5cuXIzU1VWV/Ub52b2ZmBmdnZ6UlDF6X98shPj5eanvb+kj6+vrIyclR6/pt2rTByZMnceDAAbRu3Vpqb9myJSIiIhAREVHgaBMA1K1bF5cuXVJavuDNJQ7yRi3UjakwjRs3xvXr1wsd9XNyckJgYCC+/vprlWva2Ngo5VKhUODu3bvFjgt49YgpLi5O2o6MjISOjg7c3d1hZ2cHR0dH3LlzB7Vr11b6yZt0r666devi/v37uH//vtR29epVPH/+HPXq1VO7n549e0JPTw8LFy5U2bdy5UqkpaVhwIABAF7l7cWLF0qf9/w+h4XlID8FfVZtbGwQEBCAn3/+GWFhYfjxxx+V9l+5cgWNGzdW6z6J1MXCiagULV++HDk5OWjWrBl27tyJW7du4dq1a1iyZEmRHlUBrxYOXLhwIZYsWYJbt27h/PnzWLp0KYBXI1Le3t6YN28erl27hiNHjuCbb74ptD9nZ2ekpKQgPDwcjx8/LvSRRt48p3Xr1qFVq1ZSe6tWrXD69GmcOXOm0MKpX79+EAQBw4YNw9WrV7Fnzx6lkQEAqFmzJgRBwF9//YVHjx5Joy+aaNOmDVJSUvDPP/8UelxwcDDi4uKkSdJ52rZti02bNuHYsWO4fPkyAgICVEZ8NGVoaIiAgABcvHgRx44dw5gxY+Dv7y/N35kxYwZCQ0OxZMkS3Lx5E5cvX8b69euxaNGiIl2nffv2aNiwIfr374/z58/jzJkzGDBgAFq1avXWx3yvq1GjBubPn4+wsDBMmTIF169fx+3bt7Fo0SJMmjQJs2fPRoMGDQAAzZs3h7GxMb7++mvcvn0bW7ZsyXetp7fl4E3Ozs44ffo0YmNj8fjxY+Tm5mLq1Kn4/fffERMTg3/++Qd//fUX6tatK52TlpaGqKgofPjhh0XKG9FbiURUquLi4sRRo0aJNWvWFPX19cXq1auLn376qXj48GHpGADirl27RFEUxbt374oAxAsXLqj0tXLlStHd3V2sUqWK6ODgII4ePVrad/XqVdHHx0c0MjISPT09xf/+978iAOk6hw8fFgGIz549k84ZMWKEWLVqVRGAOG3atELvo2bNmiIAMT4+Xqnd2dlZBCDGxcUptb9+T6IoiqdOnRIbNWok6uvri56enuLOnTtV7nPmzJmivb29KAiCGBAQIIqiKLZq1UocO3asUt9dunSR9hfE399fnDx5cqExiaIozp07VwSg1F9ycrLYu3dv0dzcXHRychI3bNggNmrUSClHb/aV33+3N3M+bdo0sVGjRuIPP/wgOjo6ioaGhmLPnj3Fp0+fKsW0efNm0dPTU9TX1xetrKzEli1bir/99luB1ynIv//+K3766aeiiYmJaGZmJvbq1UtMSEiQ9l+4cEEEIN69e/etfe3evVv84IMPRBMTExGACED85ZdfVI7btWuXWLt2bdHIyEjs1KmT+OOPP4qv/6pRJwcBAQFily5dpO0bN26I3t7eopGRkRTvrFmzxLp164pGRkaitbW12KVLF/HOnTvSOVu2bBHd3d3fel9ERSWIYjFnsBIRlUGXLl1Chw4dcPv2bZiamsodToXy9OlTtGvXDubm5ti7d2+BC2fKydvbG2PGjEG/fv3kDoUqGD6qI6IKycPDA99++22JzU2i/7G2tsbBgwfRrl07nDp1Su5wVDx+/Bjdu3dH37595Q6FKiCOOBERERGpiSNORERERGpi4URERESkJhZORERERGpi4URERESkJhZORERERGpi4URERESkJhZORERERGpi4URERESkJhZORERERGr6P0HWNB5jCRLPAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import sys\n", "sys.path.insert(1, \"bernstein-vazirani/qiskit\")\n", @@ -542,123 +180,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hidden Shift Benchmark Program - Qiskit\n", - "... execution starting at Sep 17, 2024 13:49:47 UTC\n", - "setting instance client-enablement/solutions/demo-testing\n", - "************\n", - "Executing [3] circuits with num_qubits = 2\n", - "************\n", - "Executing [3] circuits with num_qubits = 4\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 2 qubit group = 8, 0.189\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 2 qubit group = 16, 0.091, 2.0\n", - "Average Creation, Elapsed, Execution Time for the 2 qubit group = 0.002, 30.318, 1.288 secs\n", - "Average Transpiling, Validating, Running Times for group 2 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 2 qubit group = 0.891, 0.855\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 6\n", - "************\n", - "Executing [3] circuits with num_qubits = 8\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 8, 0.215\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 17, 0.089, 4.0\n", - "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.003, 31.414, 1.29 secs\n", - "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.79, 0.776\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 8, 0.22\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 17, 0.09, 6.0\n", - "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.002, 30.008, 1.3 secs\n", - "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.767, 0.764\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 8, 0.223\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 17, 0.092, 8.0\n", - "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.004, 35.892, 1.303 secs\n", - "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.716, 0.715\n", - "\n", - "... execution complete at Sep 17, 2024 13:52:29 UTC in 162.35 secs\n", - "\n", - "Sample Circuit:\n", - " ┌───┐ ░ ┌─────┐ ░ ┌───┐ ░ ┌─────┐ ░ ┌───┐ ░ ┌─┐ \n", - "q1023_0: ┤ H ├─░─┤0 ├─░─┤ H ├─░─┤0 ├─░─┤ H ├─░─┤M├───────────────\n", - " ├───┤ ░ │ │ ░ ├───┤ ░ │ │ ░ ├───┤ ░ └╥┘┌─┐ \n", - "q1023_1: ┤ H ├─░─┤1 ├─░─┤ H ├─░─┤1 ├─░─┤ H ├─░──╫─┤M├────────────\n", - " ├───┤ ░ │ │ ░ ├───┤ ░ │ │ ░ ├───┤ ░ ║ └╥┘┌─┐ \n", - "q1023_2: ┤ H ├─░─┤2 ├─░─┤ H ├─░─┤2 ├─░─┤ H ├─░──╫──╫─┤M├─────────\n", - " ├───┤ ░ │ Uf │ ░ ├───┤ ░ │ Ug │ ░ ├───┤ ░ ║ ║ └╥┘┌─┐ \n", - "q1023_3: ┤ H ├─░─┤3 ├─░─┤ H ├─░─┤3 ├─░─┤ H ├─░──╫──╫──╫─┤M├──────\n", - " ├───┤ ░ │ │ ░ ├───┤ ░ │ │ ░ ├───┤ ░ ║ ║ ║ └╥┘┌─┐ \n", - "q1023_4: ┤ H ├─░─┤4 ├─░─┤ H ├─░─┤4 ├─░─┤ H ├─░──╫──╫──╫──╫─┤M├───\n", - " ├───┤ ░ │ │ ░ ├───┤ ░ │ │ ░ ├───┤ ░ ║ ║ ║ ║ └╥┘┌─┐\n", - "q1023_5: ┤ H ├─░─┤5 ├─░─┤ H ├─░─┤5 ├─░─┤ H ├─░──╫──╫──╫──╫──╫─┤M├\n", - " └───┘ ░ └─────┘ ░ └───┘ ░ └─────┘ ░ └───┘ ░ ║ ║ ║ ║ ║ └╥┘\n", - " c67: 6/═════════════════════════════════════════════╩══╩══╩══╩══╩══╩═\n", - " 0 1 2 3 4 5 \n", - "\n", - "Quantum Oracle 'Uf' =\n", - " \n", - "q1024_0: ──────■──────\n", - " ┌───┐ │ ┌───┐\n", - "q1024_1: ┤ X ├─■─┤ X ├\n", - " ├───┤ ├───┤\n", - "q1024_2: ┤ X ├─■─┤ X ├\n", - " └───┘ │ └───┘\n", - "q1024_3: ──────■──────\n", - " \n", - "q1024_4: ──■──────────\n", - " │ \n", - "q1024_5: ──■──────────\n", - " \n", - "\n", - "Quantum Oracle 'Ug' =\n", - " \n", - "q1025_0: ─■─\n", - " │ \n", - "q1025_1: ─■─\n", - " \n", - "q1025_2: ─■─\n", - " │ \n", - "q1025_3: ─■─\n", - " \n", - "q1025_4: ─■─\n", - " │ \n", - "q1025_5: ─■─\n", - " \n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import sys\n", "sys.path.insert(1, \"hidden-shift/qiskit\")\n", @@ -678,208 +202,9 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Quantum Fourier Transform (1) Benchmark Program - Qiskit\n", - "... execution starting at Sep 17, 2024 14:49:06 UTC\n", - "setting instance client-enablement/solutions/demo-testing\n", - "************\n", - "Executing [3] circuits with num_qubits = 2\n", - "... number of gates, depth = 12, 8\n", - "************\n", - "Executing [3] circuits with num_qubits = 3\n", - "... number of gates, depth = 19, 14\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 2 qubit group = 9, 0.224\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 2 qubit group = 18, 0.211, 4.0\n", - "Average Creation, Elapsed, Execution Time for the 2 qubit group = 0.001, 34.872, 1.296 secs\n", - "Average Transpiling, Validating, Running Times for group 2 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 2 qubit group = 0.843, 0.791\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 4\n", - "... number of gates, depth = 30, 22\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 15, 0.376\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 35, 0.3, 12.0\n", - "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.001, 25.924, 1.323 secs\n", - "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.732, 0.694\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 5\n", - "... number of gates, depth = 42, 32\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 23, 0.474\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 58, 0.346, 24.0\n", - "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.001, 44.758, 1.301 secs\n", - "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.117, 0.058\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 6\n", - "... number of gates, depth = 57, 44\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 33, 0.551\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 87, 0.376, 40.0\n", - "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.001, 60.011, 1.42 secs\n", - "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.067, 0.037\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 7\n", - "... number of gates, depth = 73, 58\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 45, 0.604\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 122, 0.396, 60.0\n", - "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.002, 34.068, 1.37 secs\n", - "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.026, 0.011\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 8\n", - "... number of gates, depth = 92, 74\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 59, 0.643\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 163, 0.409, 84.0\n", - "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.001, 32.255, 1.409 secs\n", - "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.008, 0.002\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 75, 0.675\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 210, 0.419, 112.0\n", - "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.001, 54.696, 1.471 secs\n", - "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.004, 0.001\n", - "\n", - "... execution complete at Sep 17, 2024 14:54:27 UTC in 320.262 secs\n", - "\n", - "Sample Circuit:\n", - " ░ ┌───────────┐ ░ ┌───────┐ ░ ┌───────────────┐ ░ ┌─┐ »\n", - "q1368_0: ──────░─┤0 ├─░──┤ Rz(π) ├───░─┤0 ├─░─┤M├──────»\n", - " ░ │ │ ░ ┌┴───────┴┐ ░ │ │ ░ └╥┘┌─┐ »\n", - "q1368_1: ──────░─┤1 ├─░─┤ Rz(π/2) ├──░─┤1 ├─░──╫─┤M├───»\n", - " ┌───┐ ░ │ │ ░ ├─────────┤ ░ │ │ ░ ║ └╥┘┌─┐»\n", - "q1368_2: ┤ X ├─░─┤2 qft_gate ├─░─┤ Rz(π/4) ├──░─┤2 inv_qft_gate ├─░──╫──╫─┤M├»\n", - " ├───┤ ░ │ │ ░ ├─────────┤ ░ │ │ ░ ║ ║ └╥┘»\n", - "q1368_3: ┤ X ├─░─┤3 ├─░─┤ Rz(π/8) ├──░─┤3 ├─░──╫──╫──╫─»\n", - " └───┘ ░ │ │ ░ ├─────────┴┐ ░ │ │ ░ ║ ║ ║ »\n", - "q1368_4: ──────░─┤4 ├─░─┤ Rz(π/16) ├─░─┤4 ├─░──╫──╫──╫─»\n", - " ░ └───────────┘ ░ └──────────┘ ░ └───────────────┘ ░ ║ ║ ║ »\n", - " c106: 5/════════════════════════════════════════════════════════════╩══╩══╩═»\n", - " 0 1 2 »\n", - "« \n", - "«q1368_0: ──────\n", - "« \n", - "«q1368_1: ──────\n", - "« \n", - "«q1368_2: ──────\n", - "« ┌─┐ \n", - "«q1368_3: ┤M├───\n", - "« └╥┘┌─┐\n", - "«q1368_4: ─╫─┤M├\n", - "« ║ └╥┘\n", - "« c106: 5/═╩══╩═\n", - "« 3 4 \n", - "\n", - "QFT Circuit =\n", - " ░ ░ ░ »\n", - "q1369_0: ──────░──────────────────░─────────────────────────────░────────────»\n", - " ░ ░ ░ »\n", - "q1369_1: ──────░──────────────────░─────────────────────────────░──────■─────»\n", - " ░ ░ ┌───┐ ░ │ »\n", - "q1369_2: ──────░──────────────────░──────■──────────■─────┤ H ├─░──────┼─────»\n", - " ░ ┌───┐ ░ │ ┌────┴────┐└───┘ ░ │ »\n", - "q1369_3: ──────░──────■─────┤ H ├─░──────┼─────┤ Rz(π/2) ├──────░──────┼─────»\n", - " ┌───┐ ░ ┌────┴────┐└───┘ ░ ┌────┴────┐└─────────┘ ░ ┌────┴────┐»\n", - "q1369_4: ┤ H ├─░─┤ Rz(π/2) ├──────░─┤ Rz(π/4) ├─────────────────░─┤ Rz(π/8) ├»\n", - " └───┘ ░ └─────────┘ ░ └─────────┘ ░ └─────────┘»\n", - "« ░ »\n", - "«q1369_0: ────────────────────────────░──────■───────────■──────────■─────»\n", - "« ┌───┐ ░ │ │ │ »\n", - "«q1369_1: ─────■──────────■─────┤ H ├─░──────┼───────────┼──────────┼─────»\n", - "« │ ┌────┴────┐└───┘ ░ │ │ ┌────┴────┐»\n", - "«q1369_2: ─────┼─────┤ Rz(π/2) ├──────░──────┼───────────┼─────┤ Rz(π/4) ├»\n", - "« ┌────┴────┐└─────────┘ ░ │ ┌────┴────┐└─────────┘»\n", - "«q1369_3: ┤ Rz(π/4) ├─────────────────░──────┼──────┤ Rz(π/8) ├───────────»\n", - "« └─────────┘ ░ ┌────┴─────┐└─────────┘ »\n", - "«q1369_4: ────────────────────────────░─┤ Rz(π/16) ├──────────────────────»\n", - "« ░ └──────────┘ »\n", - "« ┌───┐ ░ \n", - "«q1369_0: ─────■─────┤ H ├─░─\n", - "« ┌────┴────┐└───┘ ░ \n", - "«q1369_1: ┤ Rz(π/2) ├──────░─\n", - "« └─────────┘ ░ \n", - "«q1369_2: ─────────────────░─\n", - "« ░ \n", - "«q1369_3: ─────────────────░─\n", - "« ░ \n", - "«q1369_4: ─────────────────░─\n", - "« ░ \n", - "\n", - "Inverse QFT Circuit =\n", - " ┌───┐ ░ »\n", - "q1370_0: ┤ H ├─────■───────────■───────────■────────────■───────░──────»\n", - " └───┘┌────┴─────┐ │ │ │ ░ ┌───┐»\n", - "q1370_1: ─────┤ Rz(-π/2) ├─────┼───────────┼────────────┼───────░─┤ H ├»\n", - " └──────────┘┌────┴─────┐ │ │ ░ └───┘»\n", - "q1370_2: ─────────────────┤ Rz(-π/4) ├─────┼────────────┼───────░──────»\n", - " └──────────┘┌────┴─────┐ │ ░ »\n", - "q1370_3: ─────────────────────────────┤ Rz(-π/8) ├──────┼───────░──────»\n", - " └──────────┘┌─────┴─────┐ ░ »\n", - "q1370_4: ─────────────────────────────────────────┤ Rz(-π/16) ├─░──────»\n", - " └───────────┘ ░ »\n", - "« ░ »\n", - "«q1370_0: ─────────────────────────────────────░──────────────────────────────»\n", - "« ░ »\n", - "«q1370_1: ─────■───────────■───────────■───────░──────────────────────────────»\n", - "« ┌────┴─────┐ │ │ ░ ┌───┐ »\n", - "«q1370_2: ┤ Rz(-π/2) ├─────┼───────────┼───────░─┤ H ├─────■───────────■──────»\n", - "« └──────────┘┌────┴─────┐ │ ░ └───┘┌────┴─────┐ │ »\n", - "«q1370_3: ────────────┤ Rz(-π/4) ├─────┼───────░──────┤ Rz(-π/2) ├─────┼──────»\n", - "« └──────────┘┌────┴─────┐ ░ └──────────┘┌────┴─────┐»\n", - "«q1370_4: ────────────────────────┤ Rz(-π/8) ├─░──────────────────┤ Rz(-π/4) ├»\n", - "« └──────────┘ ░ └──────────┘»\n", - "« ░ ░ ░ \n", - "«q1370_0: ─░───────────────────░───────░─\n", - "« ░ ░ ░ \n", - "«q1370_1: ─░───────────────────░───────░─\n", - "« ░ ░ ░ \n", - "«q1370_2: ─░───────────────────░───────░─\n", - "« ░ ┌───┐ ░ ░ \n", - "«q1370_3: ─░─┤ H ├─────■───────░───────░─\n", - "« ░ └───┘┌────┴─────┐ ░ ┌───┐ ░ \n", - "«q1370_4: ─░──────┤ Rz(-π/2) ├─░─┤ H ├─░─\n", - "« ░ └──────────┘ ░ └───┘ ░ \n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import sys\n", "sys.path.insert(1, \"quantum-fourier-transform/qiskit\")\n", @@ -900,160 +225,9 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Quantum Fourier Transform (2) Benchmark Program - Qiskit\n", - "... execution starting at Sep 17, 2024 14:56:06 UTC\n", - "setting instance client-enablement/solutions/demo-testing\n", - "************\n", - "Executing [3] circuits with num_qubits = 2\n", - "... number of gates, depth = 9, 5\n", - "************\n", - "Executing [3] circuits with num_qubits = 3\n", - "... number of gates, depth = 15, 8\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 2 qubit group = 6, 0.143\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 2 qubit group = 8, 0.262, 2.0\n", - "Average Creation, Elapsed, Execution Time for the 2 qubit group = 0.0, 25.19, 1.274 secs\n", - "Average Transpiling, Validating, Running Times for group 2 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 2 qubit group = 0.915, 0.886\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 4\n", - "... number of gates, depth = 22, 12\n", - "************\n", - "Executing [3] circuits with num_qubits = 5\n", - "... number of gates, depth = 30, 17\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 13, 0.333\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 27, 0.357, 12.0\n", - "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.0, 28.729, 1.3 secs\n", - "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.649, 0.625\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 6\n", - "... number of gates, depth = 39, 23\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 9, 0.25\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 16, 0.327, 6.0\n", - "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.0, 108.494, 1.304 secs\n", - "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.858, 0.838\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 18, 0.4\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 41, 0.382, 20.0\n", - "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.001, 94.863, 1.351 secs\n", - "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.166, 0.142\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 7\n", - "... number of gates, depth = 49, 30\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 24, 0.455\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 58, 0.398, 30.0\n", - "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.001, 31.311, 1.381 secs\n", - "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.046, 0.031\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 8\n", - "... number of gates, depth = 60, 38\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 31, 0.5\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 78, 0.41, 42.0\n", - "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.001, 35.733, 1.391 secs\n", - "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.025, 0.019\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 39, 0.538\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 101, 0.42, 56.0\n", - "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.001, 29.93, 1.456 secs\n", - "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.008, 0.004\n", - "\n", - "... execution complete at Sep 17, 2024 15:02:33 UTC in 387.111 secs\n", - "\n", - "Sample Circuit:\n", - " ┌───┐┌─────────┐ ┌───────────────┐┌─┐ \n", - "q1770_0: ┤ H ├┤ Rz(12π) ├─┤0 ├┤M├────────────\n", - " ├───┤└┬────────┤ │ │└╥┘┌─┐ \n", - "q1770_1: ┤ H ├─┤ Rz(6π) ├─┤1 ├─╫─┤M├─────────\n", - " ├───┤ ├────────┤ │ │ ║ └╥┘┌─┐ \n", - "q1770_2: ┤ H ├─┤ Rz(3π) ├─┤2 inv_qft_gate ├─╫──╫─┤M├──────\n", - " ├───┤┌┴────────┴┐│ │ ║ ║ └╥┘┌─┐ \n", - "q1770_3: ┤ H ├┤ Rz(3π/2) ├┤3 ├─╫──╫──╫─┤M├───\n", - " ├───┤├──────────┤│ │ ║ ║ ║ └╥┘┌─┐\n", - "q1770_4: ┤ H ├┤ Rz(3π/4) ├┤4 ├─╫──╫──╫──╫─┤M├\n", - " └───┘└──────────┘└───────────────┘ ║ ║ ║ ║ └╥┘\n", - " c127: 5/═══════════════════════════════════╩══╩══╩══╩══╩═\n", - " 0 1 2 3 4 \n", - "\n", - "Inverse QFT Circuit =\n", - " ┌───┐ ░ »\n", - "q1771_0: ┤ H ├─────■───────────■───────────■────────────■───────░──────»\n", - " └───┘┌────┴─────┐ │ │ │ ░ ┌───┐»\n", - "q1771_1: ─────┤ Rz(-π/2) ├─────┼───────────┼────────────┼───────░─┤ H ├»\n", - " └──────────┘┌────┴─────┐ │ │ ░ └───┘»\n", - "q1771_2: ─────────────────┤ Rz(-π/4) ├─────┼────────────┼───────░──────»\n", - " └──────────┘┌────┴─────┐ │ ░ »\n", - "q1771_3: ─────────────────────────────┤ Rz(-π/8) ├──────┼───────░──────»\n", - " └──────────┘┌─────┴─────┐ ░ »\n", - "q1771_4: ─────────────────────────────────────────┤ Rz(-π/16) ├─░──────»\n", - " └───────────┘ ░ »\n", - "« ░ »\n", - "«q1771_0: ─────────────────────────────────────░──────────────────────────────»\n", - "« ░ »\n", - "«q1771_1: ─────■───────────■───────────■───────░──────────────────────────────»\n", - "« ┌────┴─────┐ │ │ ░ ┌───┐ »\n", - "«q1771_2: ┤ Rz(-π/2) ├─────┼───────────┼───────░─┤ H ├─────■───────────■──────»\n", - "« └──────────┘┌────┴─────┐ │ ░ └───┘┌────┴─────┐ │ »\n", - "«q1771_3: ────────────┤ Rz(-π/4) ├─────┼───────░──────┤ Rz(-π/2) ├─────┼──────»\n", - "« └──────────┘┌────┴─────┐ ░ └──────────┘┌────┴─────┐»\n", - "«q1771_4: ────────────────────────┤ Rz(-π/8) ├─░──────────────────┤ Rz(-π/4) ├»\n", - "« └──────────┘ ░ └──────────┘»\n", - "« ░ ░ ░ \n", - "«q1771_0: ─░───────────────────░───────░─\n", - "« ░ ░ ░ \n", - "«q1771_1: ─░───────────────────░───────░─\n", - "« ░ ░ ░ \n", - "«q1771_2: ─░───────────────────░───────░─\n", - "« ░ ┌───┐ ░ ░ \n", - "«q1771_3: ─░─┤ H ├─────■───────░───────░─\n", - "« ░ └───┘┌────┴─────┐ ░ ┌───┐ ░ \n", - "«q1771_4: ─░──────┤ Rz(-π/2) ├─░─┤ H ├─░─\n", - "« ░ └──────────┘ ░ └───┘ ░ \n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import sys\n", "sys.path.insert(1, \"quantum-fourier-transform/qiskit\")\n", @@ -1074,156 +248,9 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Grover's Search Benchmark Program - Qiskit\n", - "... execution starting at Sep 17, 2024 15:49:12 UTC\n", - "************\n", - "Executing [3] circuits with num_qubits = 2\n", - "************\n", - "Executing [3] circuits with num_qubits = 3\n", - "************\n", - "Executing [3] circuits with num_qubits = 4\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 2 qubit group = 13, 0.116\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 2 qubit group = 13, 0.123, 2.0\n", - "Average Creation, Elapsed, Execution Time for the 2 qubit group = 0.002, 61.534, 1.297 secs\n", - "Average Transpiling, Validating, Running Times for group 2 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 2 qubit group = 0.897, 0.863\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 25, 0.085\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 51, 0.308, 24.0\n", - "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.002, 25.612, 1.346 secs\n", - "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.77, 0.663\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 5\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 38, 0.07\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 167, 0.393, 84.0\n", - "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.005, 26.146, 1.405 secs\n", - "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.208, 0.026\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 6\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 50, 0.057\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 607, 0.372, 288.0\n", - "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.005, 40.576, 1.668 secs\n", - "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.041, 0.001\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 7\n", - "************\n", - "Executing [3] circuits with num_qubits = 8\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 66, 0.052\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 1699, 0.404, 1008.0\n", - "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.01, 54.917, 3.044 secs\n", - "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.032, 0.003\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 93, 0.043\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 3323, 0.423, 2240.0\n", - "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.015, 38.692, 4.826 secs\n", - "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.031, 0.008\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 130, 0.042\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 8787, 0.419, 5280.0\n", - "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.022, 53.184, 10.182 secs\n", - "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.005, 0.0\n", - "\n", - "... execution complete at Sep 17, 2024 15:54:48 UTC in 335.961 secs\n", - "\n", - "Sample Circuit:\n", - " ┌───┐ ░ ┌─────────┐┌───────────┐ ░ ┌─────────┐┌───────────┐ ░ »\n", - "q2225_0: ┤ H ├─░─┤0 ├┤0 ├─░─┤0 ├┤0 ├─░─»\n", - " ├───┤ ░ │ ││ │ ░ │ ││ │ ░ »\n", - "q2225_1: ┤ H ├─░─┤1 ├┤1 ├─░─┤1 ├┤1 ├─░─»\n", - " ├───┤ ░ │ ││ │ ░ │ ││ │ ░ »\n", - "q2225_2: ┤ H ├─░─┤2 oracle ├┤2 diffuser ├─░─┤2 oracle ├┤2 diffuser ├─░─»\n", - " ├───┤ ░ │ ││ │ ░ │ ││ │ ░ »\n", - "q2225_3: ┤ H ├─░─┤3 ├┤3 ├─░─┤3 ├┤3 ├─░─»\n", - " ├───┤ ░ │ ││ │ ░ │ ││ │ ░ »\n", - "q2225_4: ┤ H ├─░─┤4 ├┤4 ├─░─┤4 ├┤4 ├─░─»\n", - " └───┘ ░ └─────────┘└───────────┘ ░ └─────────┘└───────────┘ ░ »\n", - " c148: 5/══════════════════════════════════════════════════════════════»\n", - " »\n", - "« ┌─────────┐┌───────────┐ ░ ┌─────────┐┌───────────┐ ░ ┌─┐ \n", - "«q2225_0: ┤0 ├┤0 ├─░─┤0 ├┤0 ├─░─┤M├────────────\n", - "« │ ││ │ ░ │ ││ │ ░ └╥┘┌─┐ \n", - "«q2225_1: ┤1 ├┤1 ├─░─┤1 ├┤1 ├─░──╫─┤M├─────────\n", - "« │ ││ │ ░ │ ││ │ ░ ║ └╥┘┌─┐ \n", - "«q2225_2: ┤2 oracle ├┤2 diffuser ├─░─┤2 oracle ├┤2 diffuser ├─░──╫──╫─┤M├──────\n", - "« │ ││ │ ░ │ ││ │ ░ ║ ║ └╥┘┌─┐ \n", - "«q2225_3: ┤3 ├┤3 ├─░─┤3 ├┤3 ├─░──╫──╫──╫─┤M├───\n", - "« │ ││ │ ░ │ ││ │ ░ ║ ║ ║ └╥┘┌─┐\n", - "«q2225_4: ┤4 ├┤4 ├─░─┤4 ├┤4 ├─░──╫──╫──╫──╫─┤M├\n", - "« └─────────┘└───────────┘ ░ └─────────┘└───────────┘ ░ ║ ║ ║ ║ └╥┘\n", - "« c148: 5/═══════════════════════════════════════════════════════╩══╩══╩══╩══╩═\n", - "« 0 1 2 3 4 \n", - "\n", - "Oracle =\n", - " ┌───┐ ░ ┌───┐\n", - "q2232_0: ┤ X ├───────■────────░─┤ X ├\n", - " ├───┤ │ ░ ├───┤\n", - "q2232_1: ┤ X ├───────■────────░─┤ X ├\n", - " └───┘ │ ░ └───┘\n", - "q2232_2: ────────────■────────░──────\n", - " ┌───┐ │ ░ ┌───┐\n", - "q2232_3: ┤ X ├───────■────────░─┤ X ├\n", - " ├───┤┌───┐┌─┴─┐┌───┐ ░ ├───┤\n", - "q2232_4: ┤ X ├┤ H ├┤ X ├┤ H ├─░─┤ X ├\n", - " └───┘└───┘└───┘└───┘ ░ └───┘\n", - "\n", - "Diffuser =\n", - " ┌───┐┌───┐ ░ ┌───┐┌───┐\n", - "q2233_0: ┤ H ├┤ X ├───────■────────░─┤ X ├┤ H ├\n", - " ├───┤├───┤ │ ░ ├───┤├───┤\n", - "q2233_1: ┤ H ├┤ X ├───────■────────░─┤ X ├┤ H ├\n", - " ├───┤├───┤ │ ░ ├───┤├───┤\n", - "q2233_2: ┤ H ├┤ X ├───────■────────░─┤ X ├┤ H ├\n", - " ├───┤├───┤ │ ░ ├───┤├───┤\n", - "q2233_3: ┤ H ├┤ X ├───────■────────░─┤ X ├┤ H ├\n", - " ├───┤├───┤┌───┐┌─┴─┐┌───┐ ░ ├───┤├───┤\n", - "q2233_4: ┤ H ├┤ X ├┤ H ├┤ X ├┤ H ├─░─┤ X ├┤ H ├\n", - " └───┘└───┘└───┘└───┘└───┘ ░ └───┘└───┘\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAArIAAAHPCAYAAACvLTkCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADB0klEQVR4nOzdd1hT1/8H8HcgEIZMZYMM9wYH7lkVrXW1iqt11VFHrdpata27Vq3batW666hW62wVVx111L2LG7egiIJskpzfH/6SrzEJJIFA0Pfree7T5t5zP+fkGsKHc889RyKEECAiIiIiKmSsCroBRERERESmYCJLRERERIUSE1kiIiIiKpSYyBIRERFRocREloiIiIgKJSayRERERFQoMZElIiIiokKJiSwRERERFUpMZImIiIioUGIiS5SNO3fuQCKRYOXKlQXdlDxX2N9bo0aN0KhRI4PK9uzZE0FBQWZtz8qVKyGRSHDnzh2z1kNkiIMHD0IikWDTpk0F3RQis2IiS2+NNm3awMHBAS9fvtRbplu3brC1tcWzZ8/ysWXmt3PnTowfP77A6lclxarN2toaxYsXR/v27XH+/Pl8acOjR48wfvz4fKuvsIuJicHgwYNRunRpODg4wMHBAeXLl8egQYNw8eLFgm5ergQFBeXpz8OOHTvQsGFDeHp6wsHBASEhIYiMjERUVFSe1UFEpmEiS2+Nbt26IS0tDVu2bNF5PDU1Fdu2bUOLFi1QtGjRfG6dee3cuRMTJkww6pzAwECkpaXhk08+ybN2dOnSBatXr8by5cvRtWtX/P3336hVq5ZZkss9e/Zgz5496tePHj3ChAkTdNa1ZMkSXLt2Lc/b8LpPPvkEaWlpCAwMNGs9eeHPP/9ExYoVsXr1ajRt2hSzZ8/G3Llz0bJlS+zcuROhoaG4e/duQTfTIsyYMQNt2rSBRCLB6NGjMXv2bHz00Ue4ceMG1q9fX9DNI3rnSQu6AUR5pU2bNnBycsK6devQvXt3rePbtm1DSkoKunXrVgCtsxxyuRxKpRK2traws7PL09hVq1bFxx9/rH5dt25dtGnTBgsXLsTixYvztC5bW1uDy9rY2ORp3bpYW1vD2tra7PXk1q1bt9C5c2cEBgZi//798PHx0Tg+bdo0/Pzzz7Cyyr6fIyUlBY6OjuZsqlGEEEhPT4e9vX2exZTL5Zg0aRKaNWum8UeTypMnT/KsLkOY4z0SFXbskaW3hr29PT788EPs379f5y+YdevWwcnJCW3atAEA3L59Gx07doS7uzscHBxQq1Yt/PXXXznWo29s5pvjMFW322fMmIEFCxYgJCQEDg4OaN68Oe7fvw8hBCZNmgR/f3/Y29ujbdu2SEhI0Iq7a9cu1K9fH46OjnByckKrVq1w5coVjXoXLFgAABq3999sw5w5c1CiRAnIZDL8999/esfIXr16FZGRkfDw8IC9vT3KlCmDb7/9NsfrokuTJk0AvLqNrbJx40ZUq1YN9vb2KFasGD7++GM8fPhQ47zY2Fj06tUL/v7+kMlk8PHxQdu2bTXGn77+73Dw4EHUqFEDANCrVy/1NVC9N11jZFNSUvDll18iICAAMpkMZcqUwYwZMyCE0CgnkUgwePBgbN26FRUrVoRMJkOFChW0bivrGiMbFBSEDz74AEeOHEF4eDjs7OwQEhKCX3/9VetaXbx4EQ0bNoS9vT38/f3x/fffY8WKFXk+7vbHH39ESkoKVqxYoZXEAoBUKsWQIUMQEBCg3tezZ08UKVIEt27dwvvvvw8nJyf1H4SGXMeKFSuicePGWnUplUr4+fmhQ4cOGvvmzJmDChUqwM7ODl5eXujfvz+eP3+uca7q2u7evRvVq1eHvb293j+WsrKyMGHCBJQqVQp2dnYoWrQo6tWrh71792Z7reLj45GUlIS6devqPO7p6anxOiMjA+PGjUPJkiUhk8kQEBCAr7/+GhkZGRrlVqxYgSZNmsDT0xMymQzly5fHwoULteJn9x5fvHiBYcOGISgoCDKZDP7+/ujevTvi4+M1YiiVSkyePBn+/v6ws7PDe++9h5s3b2b7vokKE/bI0lulW7duWLVqFX7//XcMHjxYvT8hIQG7d+9Gly5dYG9vj7i4ONSpUwepqakYMmQIihYtilWrVqFNmzbYtGkT2rdvn2dtWrt2LTIzM/H5558jISEBP/74IyIjI9GkSRMcPHgQI0eOxM2bN/HTTz/hq6++wvLly9Xnrl69Gj169EBERASmTZuG1NRULFy4EPXq1cO5c+cQFBSE/v3749GjR9i7dy9Wr16tsw0rVqxAeno6+vXrB5lMBnd3dyiVSq1yFy9eRP369WFjY4N+/fohKCgIt27dwo4dOzB58mSj3/utW7cAQD2UY+XKlejVqxdq1KiBKVOmIC4uDnPnzsXRo0dx7tw5uLq6AgA++ugjXLlyBZ9//jmCgoLw5MkT7N27F/fu3dP50Fa5cuUwceJEjB07Fv369UP9+vUBAHXq1NHZLiEE2rRpgwMHDuDTTz9FaGgodu/ejREjRuDhw4eYPXu2RvkjR45g8+bNGDhwIJycnDBv3jx89NFHuHfvXo7DVG7evIkOHTrg008/RY8ePbB8+XL07NkT1apVQ4UKFQAADx8+ROPGjdW3rx0dHbF06VLIZDKDr7Wh/vzzT5QsWRI1a9Y06jy5XI6IiAjUq1cPM2bMgIODg8HXsVOnThg/fjxiY2Ph7e2tjnnkyBE8evQInTt3Vu/r37+/+nMyZMgQxMTEYP78+Th37hyOHj2q0bt+7do1dOnSBf3790ffvn1RpkwZnW0fP348pkyZgj59+iA8PBxJSUk4ffo0zp49i2bNmul9z56enrC3t8eOHTvw+eefw93dXW9ZpVKJNm3a4MiRI+jXrx/KlSuHS5cuYfbs2bh+/Tq2bt2qLrtw4UJUqFABbdq0gVQqxY4dOzBw4EAolUoMGjRII66u95icnIz69esjOjoavXv3RtWqVREfH4/t27fjwYMHKFasmPr8qVOnwsrKCl999RUSExPx448/olu3bjhx4oTe90JUqAiit4hcLhc+Pj6idu3aGvsXLVokAIjdu3cLIYQYOnSoACD++ecfdZmXL1+K4OBgERQUJBQKhRBCiJiYGAFArFixQl2uYcOGomHDhlp19+jRQwQGBqpfq8718PAQL168UO8fPXq0ACCqVKkisrKy1Pu7dOkibG1tRXp6uro9rq6uom/fvhr1xMbGChcXF439gwYNErp+nFVtcHZ2Fk+ePNF57PX31qBBA+Hk5CTu3r2rUVapVGrF1hVrwoQJ4unTpyI2NlYcPHhQhIWFCQDijz/+EJmZmcLT01NUrFhRpKWlqc/9888/BQAxduxYIYQQz58/FwDE9OnTs63zzX+HU6dOab0flTf/bbZu3SoAiO+//16jXIcOHYREIhE3b95U7wMgbG1tNfZduHBBABA//fSTet+KFSsEABETE6PeFxgYKACIw4cPq/c9efJEyGQy8eWXX6r3ff7550IikYhz586p9z179ky4u7trxcyNxMREAUC0a9dO69jz58/F06dP1Vtqaqr6WI8ePQQAMWrUKI1zDL2O165d07peQggxcOBAUaRIEXVd//zzjwAg1q5dq1EuKipKa7/q2kZFReX4vqtUqSJatWqVYzldxo4dKwAIR0dH0bJlSzF58mRx5swZrXKrV68WVlZWGt8pQvzvu+fo0aPqfa9fW5WIiAgREhKisU/fe1S1afPmzVpxVD+rBw4cEABEuXLlREZGhvr43LlzBQBx6dIlA949keXj0AJ6q1hbW6Nz5844fvy4xu3YdevWwcvLC++99x6AVw9HhYeHo169euoyRYoUQb9+/XDnzh38999/edamjh07wsXFRf1a1RP28ccfQyqVauzPzMxU32bfu3cvXrx4gS5duiA+Pl69WVtbo2bNmjhw4IDBbfjoo4/g4eGRbZmnT5/i8OHD6N27N4oXL65xTDVUISfjxo2Dh4cHvL290ahRI9y6dQvTpk3Dhx9+iNOnT+PJkycYOHCgxtjcVq1aoWzZsuphHfb29rC1tcXBgwe1bifnlZ07d8La2hpDhgzR2P/ll19CCIFdu3Zp7G/atClKlCihfl25cmU4Ozvj9u3bOdZVvnx5dQ8xAHh4eKBMmTIa50ZFRaF27doIDQ1V73N3d8/z8dxJSUkAXn3W39SoUSN4eHioN9VwldcNGDBA47Wh17F06dIIDQ3Fhg0b1GUUCgU2bdqE1q1bq8d8bty4ES4uLmjWrJnGZ75atWooUqSI1mc+ODgYEREROb5vV1dXXLlyBTdu3Mix7JsmTJiAdevWISwsDLt378a3336LatWqoWrVqoiOjlaX27hxI8qVK4eyZctqtF01vOb1tr8+xjUxMRHx8fFo2LAhbt++jcTExBzf4x9//IEqVarovHP05s9qr169NMaTqz6Lhnx2iQoDJrL01lH98l+3bh0A4MGDB/jnn3/QuXNn9cM4d+/e1Xkbsly5curjeeXNpFCV1L4+BvH1/arkTfVLt0mTJhoJhoeHB/bs2WPUgybBwcE5llH9YqtYsaLBcd/Ur18/7N27F/v378eZM2fw5MkTfP311wD+d011XfeyZcuqj8tkMkybNg27du2Cl5cXGjRogB9//BGxsbEmt+tNd+/eha+vL5ycnDT26/v3f/PfEADc3NwMSrQNOffu3bsoWbKkVjld+96UlpaG2NhYjU0f1ftNTk7WOrZ48WLs3bsXa9as0XmuVCqFv7+/xj5jrmOnTp1w9OhR9R9qBw8exJMnT9CpUyd1mRs3biAxMRGenp5an/nk5GStz7whn2sAmDhxIl68eIHSpUujUqVKGDFihMYUYzldwy5duuCff/7B8+fPsWfPHnTt2hXnzp1D69atkZ6erm77lStXtNpdunRpAJoPhh09ehRNmzaFo6MjXF1d4eHhgW+++QYAdCayb7p165bBP6dvfv7c3NwAwGx/JBLlN46RpbdOtWrVULZsWfz222/45ptv8Ntvv0EIkWe9WxKJROuBIOBVD5Mu+p5k17dfFVs1hnX16tUa4wpVXu/NzUl+PeVcqlQpNG3aNNdxhg4ditatW2Pr1q3YvXs3xowZgylTpuDvv/9GWFhYHrTUODn9W5nrXENs2LABvXr1Mii2i4sLfHx8cPnyZa1jqjsF+h4sk8lkOc5kkJ1OnTph9OjR2LhxI4YOHYrff/8dLi4uaNGihbqMUqmEp6cn1q5dqzPGm3cVDP1cN2jQALdu3cK2bduwZ88eLF26FLNnz8aiRYvQp08fg6+hs7MzmjVrhmbNmsHGxgarVq3CiRMn0LBhQyiVSlSqVAmzZs3S2QbVH663bt3Ce++9h7Jly2LWrFkICAiAra0tdu7cidmzZ2uNXc/tz665P39EBY2JLL2VunXrhjFjxuDixYtYt24dSpUqpX6qHXg1h6queUWvXr2qPq6Pm5ubzttyeT3vpupWtqenZ47JoaG3/rMTEhICADqTnLyguqbXrl1T325VuXbtmtY1L1GiBL788kt8+eWXuHHjBkJDQzFz5ky9PYbGXIPAwEDs27cPL1++1OhNNOTf3xwCAwN1PkluyNPlEREROT59/7pWrVph6dKlOHnyJMLDw41q55uMuY7BwcEIDw/Hhg0bMHjwYGzevBnt2rXTeKCtRIkS2LdvH+rWrZvnf3y5u7ujV69e6NWrF5KTk9GgQQOMHz8effr0MfoaAkD16tWxatUqPH78WN32Cxcu4L333sv2s7hjxw5kZGRg+/btGr2lxgwVKlGihNl+TokKGw4toLeSqvd17NixOH/+vFZv7Pvvv4+TJ0/i+PHj6n0pKSn45ZdfEBQUhPLly+uNXaJECVy9ehVPnz5V77tw4QKOHj2ap+8hIiICzs7O+OGHH5CVlaV1/PX6VfN5vnjxwuT6PDw80KBBAyxfvhz37t3TOJYXvTfVq1eHp6cnFi1apDEd0a5duxAdHY1WrVoBeLVwhep2rUqJEiXg5OSkNY3R64y5Bu+//z4UCgXmz5+vsX/27NmQSCRo2bKloW8rT0REROD48eMaizkkJCTo7Zl8nY+PD5o2baqxZefrr7+Gg4MDevfujbi4OK3jxvxbG3sdO3XqhH///RfLly9HfHy8xrACAIiMjIRCocCkSZO06pLL5SZ/vt9cya9IkSIoWbKk+vOk7xqmpqZqfEe8TjX+VzVUJjIyEg8fPsSSJUu0yqalpSElJQXA/3pIX7/OiYmJWLFihcHv56OPPsKFCxd0Lv7CnlZ617BHlt5KwcHBqFOnDrZt2wYAWonsqFGj8Ntvv6Fly5YYMmQI3N3dsWrVKsTExOCPP/7I9hZq7969MWvWLERERODTTz/FkydPsGjRIlSoUEH9ME1ecHZ2xsKFC/HJJ5+gatWq6Ny5Mzw8PHDv3j389ddfqFu3rjqBqFatGgBgyJAhiIiIUD/0Zqx58+ahXr16qFq1Kvr164fg4GDcuXMHf/31V65X57KxscG0adPQq1cvNGzYEF26dFFPvxUUFIRhw4YBAK5fv4733nsPkZGRKF++PKRSKbZs2YK4uLhs31OJEiXg6uqKRYsWwcnJCY6OjqhZs6bOMYatW7dG48aN8e233+LOnTuoUqUK9uzZg23btmHo0KEaD3blh6+//hpr1qxBs2bN8Pnnn6un3ypevDgSEhLypMddpVSpUli3bh26dOmCMmXKoFu3bqhSpQqEEIiJicG6detgZWWlNR5WF2OvY2RkJL766it89dVXcHd310q6GzZsiP79+2PKlCk4f/48mjdvDhsbG9y4cQMbN27E3LlzNeacNVT58uXRqFEjVKtWDe7u7jh9+jQ2bdqkMUWfLqmpqahTpw5q1aqFFi1aICAgAC9evMDWrVvxzz//oF27duqhLp988gl+//13fPbZZzhw4ADq1q0LhUKBq1ev4vfff1fPBdu8eXPY2tqidevW6N+/P5KTk7FkyRJ4enqqe3dzMmLECGzatAkdO3ZE7969Ua1aNSQkJGD79u1YtGgRqlSpYvQ1Iiq0CmCmBKJ8sWDBAgFAhIeH6zx+69Yt0aFDB+Hq6irs7OxEeHi4+PPPPzXK6JqiSggh1qxZI0JCQoStra0IDQ0Vu3fv1jv91pvTSKmmxdm4caPGftX0TadOndIqHxERIVxcXISdnZ0oUaKE6Nmzpzh9+rS6jFwuF59//rnw8PAQEolEPRWXvjZk994uX74s2rdvr74uZcqUEWPGjNF5DXN6r7ps2LBBhIWFCZlMJtzd3UW3bt3EgwcP1Mfj4+PFoEGDRNmyZYWjo6NwcXERNWvWFL///rtGHF3ToG3btk2UL19eSKVSjff25r+NEK+mNxs2bJjw9fUVNjY2olSpUmL69OlaU40BEIMGDdJ6H4GBgaJHjx7q1/qm39I17ZOutp87d07Ur19fyGQy4e/vL6ZMmSLmzZsnAIjY2FitGLl18+ZNMWDAAFGyZElhZ2cn7O3tRdmyZcVnn30mzp8/r1G2R48ewtHRUWccQ6+jSt26dQUA0adPH71t++WXX0S1atWEvb29cHJyEpUqVRJff/21ePTokbqMvmury/fffy/Cw8OFq6ur+n1OnjxZZGZmZnteVlaWWLJkiWjXrp0IDAwUMplMODg4iLCwMDF9+nSNaa2EECIzM1NMmzZNVKhQQchkMuHm5iaqVasmJkyYIBITE9Xltm/fLipXrizs7OxEUFCQmDZtmli+fLnBnx8hXk3PNnjwYOHn5ydsbW2Fv7+/6NGjh4iPjxdC6P+e0fdzT1RYSYTgfQgiIks0dOhQLF68GMnJyYVi+VsiovzGMbJERBYgLS1N4/WzZ8+wevVq1KtXj0ksEZEeHCNLRGQBateujUaNGqFcuXKIi4vDsmXLkJSUhDFjxhR004iILBYTWSIiC/D+++9j06ZN+OWXXyCRSFC1alUsW7YMDRo0KOimERFZLI6RJSIiIqJCiWNkiYiIiKhQYiJLRERERIUSE1myeCtXroREItG7BnxBGT9+vNZE9RKJJMdJ1vNLUFAQPvjgg1zFMOXa37lzBxKJBDNmzMhV3URERDlhIkvZUiUyqs3Ozg6+vr6IiIjAvHnz8PLly4JuIpHZPX36FF988QXKli0Le3t7eHp6Ijw8HCNHjkRycnK+t+fatWsYNmwY6tSpAzs7O71/bBw8eFDj5/fNbfLkyUbXnZqaigULFqB58+bw8fGBk5MTwsLCsHDhQigUCq3ySqUSP/74I4KDg2FnZ4fKlSvjt99+0yqzcuVKtGnTBgEBAXB0dETFihXx/fffay1X/KYjR46o3098fHyO7U9OTsa4cePQokULuLu7QyKRYOXKlTrL9uzZU+d1K1u2bI71ANrfn69vsbGxes+7deuW+t/19OnTBtX1uqysLJQvX17vH5Q3b95Ehw4d4ObmBgcHB9SrVw8HDhwwKHbPnj1RpEgRvceLFCmCnj17Anj1x3R2nz/Vprr+6enpmD17NmrWrAkXFxfY2dmhdOnSGDx4MK5fv270daB3A2ctIINMnDgRwcHByMrKQmxsLA4ePIihQ4di1qxZ2L59OypXrmy2uj/55BN07twZMpnMbHWY4rvvvsOoUaMKuhlmZanXPj8lJCSgevXqSEpKQu/evVG2bFk8e/YMFy9exMKFCzFgwIBsf7Gbw/HjxzFv3jyUL18e5cqV07t8cLly5bB69Wqt/atXr8aePXvQvHlzo+u+ffs2Pv/8c7z33nsYPnw4nJ2dsXv3bgwcOBD//vsvVq1apVH+22+/xdSpU9G3b1/UqFED27ZtQ9euXSGRSNRLDqempqJXr16oVasWPvvsM3h6euL48eMYN24c9u/fj7///lvnMr1KpVK9pG9KSopB7Y+Pj8fEiRNRvHhxVKlSBQcPHsy2vEwmw9KlSzX2ubi4GFSXiur783Wurq56yw8bNgxSqRQZGRlG1aPy008/4d69ezqP3b9/H7Vr14a1tTVGjBgBR0dHrFixAs2bN8f+/fvzdJaMOXPmaPyht3PnTvz222+YPXs2ihUrpt5fp04dxMfHo0WLFjhz5gw++OADdO3aFUWKFMG1a9ewfv16/PLLL8jMzMyzttFbpGAXFiNLp2/ZVCGE2L9/v7C3txeBgYEiNTW1AFpneaBnOdOCYMwSnm9KTk42uV5jlqstDH788UcBQBw9elTrWGJiokhLS8v3Nj179kwkJSUJIYSYPn261tKmOSlZsqQoVaqUSXU/ffpUXL58WWt/r169BABx48YN9b4HDx4IGxsbjZ8JpVIp6tevL/z9/YVcLhdCCJGRkaHz+k6YMEEAEHv37tXZloULF4qiRYuKL774QgAQT58+zbH96enp4vHjx0IIIU6dOpXtcq3ZLc1riOy+P/WJiooStra24rvvvjP6XCGEiIuLEy4uLmLixIk6fw4HDhwopFKpuHr1qnpfSkqKCAgIEFWrVs0xfk7XxNHRUWPp5tdl91lt1aqVsLKyEps2bdI6lp6eLr788ssc20bvJg4tIJM1adIEY8aMwd27d7FmzRqNY1evXkWHDh3g7u4OOzs7VK9eHdu3b1cfP336NCQSiVbvDQDs3r0bEokEf/75JwD94zR37dqFhg0bwsnJCc7OzqhRowbWrVunUebEiRNo0aIFXFxc4ODggIYNG+Lo0aN58v51jZFVWbt2LcqUKQM7OztUq1YNhw8f1nnu9evX8fHHH8PFxQUeHh4YM2YMhBC4f/8+2rZtC2dnZ3h7e2PmzJkmt3PPnj0IDQ2FnZ0dypcvj82bN2scV13fQ4cOYeDAgfD09IS/v7/Gsdev/enTpxEREYFixYrB3t4ewcHB6N27t866Z8+ejcDAQNjb26Nhw4a4fPmyxvGLFy+iZ8+eCAkJgZ2dHby9vdG7d288e/ZM5/W6efMmevbsCVdXV7i4uKBXr15ITU3VqnfNmjWoVq0a7O3t4e7ujs6dO+P+/fumXD7cunUL1tbWqFWrltYxZ2dn2NnZaewz5DOnej9Xr15FZGQknJ2dUbRoUXzxxRc53koHAHd3dzg5OZn0fk6ePImbN2+iW7duJp1frFgxVKhQQWt/+/btAQDR0dHqfdu2bUNWVhYGDhyo3ieRSDBgwAA8ePAAx48fBwDY2tqiTp06BsVUSUhIwHfffYeJEydm27v5JplMBm9vb4PLA4BCoUBSUlK2ZW7duoVbt27pPf7y5UudQy9el5WVhS+++AJffPEFSpQoobfM1atX8fjxY53HR40ahTJlyuDjjz/Wefyff/5BWFgYypQpo97n4OCANm3a4OzZs7hx40a2bTSHEydO4K+//sKnn36Kjz76SOu4TCbjmHvSi4ks5conn3wC4FWypHLlyhXUqlUL0dHRGDVqFGbOnAlHR0e0a9cOW7ZsAQBUr14dISEh+P3337VibtiwAW5uboiIiNBb78qVK9GqVSskJCRg9OjRmDp1KkJDQxEVFaUu8/fff6NBgwZISkrCuHHj8MMPP+DFixdo0qQJTp48qS6XlZWF+Ph4gzalUpnjNTl06BCGDh2Kjz/+GBMnTsSzZ8/QokULrSQOADp16gSlUompU6eiZs2a+P777zFnzhw0a9YMfn5+mDZtGkqWLImvvvpKKxk2xI0bN9CpUye0bNkSU6ZMgVQqRceOHbF3716tsgMHDsR///2HsWPH6h0y8eTJEzRv3hx37tzBqFGj8NNPP6Fbt274999/tcr++uuvmDdvHgYNGoTRo0fj8uXLaNKkCeLi4tRl9u7di9u3b6NXr1746aef0LlzZ6xfvx7vv/8+hI4priMjI/Hy5UtMmTIFkZGRWLlyJSZMmKBRZvLkyejevTtKlSqFWbNmYejQoepbpi9evDDyCgKBgYFQKBQ6b9G/ydDP3OvvJz09HVOmTMH777+PefPmoV+/fka30Rhr164FAJMTWX1UYz5fv2V87tw5ODo6oly5chplw8PD1ceNjakyZswYeHt7o3///rlqd05SU1Ph7OwMFxcXuLu7Y9CgQTrHRb/33nt47733dMZo3LgxnJ2d1QmjvmRxzpw5eP78Ob777ju97Xn48CHKlSuH0aNHax07efIkVq1ahTlz5uj9IzsjIwP29vZa+x0cHAAAZ86c0Vu3uag6OVS/T4iMUtBdwmTZDLk15uLiIsLCwtSv33vvPVGpUiWRnp6u3qdUKkWdOnU0bmeOHj1a2NjYiISEBPW+jIwM4erqKnr37q3VBtXtqBcvXggnJydRs2ZNrdu6SqVS/d9SpUqJiIgI9T4hhEhNTRXBwcGiWbNm6n0HDhwQAAzaXr8lNm7cOPHmj5Cq3OnTp9X77t69K+zs7ET79u21zu3Xr596n1wuF/7+/kIikYipU6eq9z9//lzY29vrvV2nT2BgoAAg/vjjD/W+xMRE4ePjo/Hvpbq+9erVU9/qffOY6n1v2bIlx8+DamiBvb29ePDggXr/iRMnBAAxbNgw9T5dQ1J+++03AUAcPnxYvU91vV7/XAghRPv27UXRokXVr+/cuSOsra3F5MmTNcpdunRJSKVSrf2GiI2NFR4eHgKAKFu2rPjss8/EunXrxIsXLzTKGfOZU72fNm3aaMQYOHCgACAuXLhgcPuMGVogl8uFl5eXCA8PNzi+ITIyMkT58uVFcHCwyMrKUu9v1aqVCAkJ0SqfkpIiAIhRo0ZlG7dp06bC2dlZPH/+XGP/hQsXhLW1tdi9e7cQ4n/X05ChBa/LaWjBqFGjxMiRI8WGDRvEb7/9Jnr06CEAiLp162q8TyFe/bwFBgZq7NuwYYPo2bOnWLVqldiyZYv47rvvhIODgyhWrJi4d++eRtnHjx8LJycnsXjxYiGE/u9e1c/Xm98HSqVShIeHiy5dumiUe3NoQevWrYWrq6t6aIpK7dq1BQAxY8YMvddLCPMMLWjfvr0AoPXvTGQI9shSrhUpUkQ9e0FCQgL+/vtvdc+Zqifz2bNniIiIwI0bN/Dw4UMAr3ojs7KyNG5179mzBy9evECnTp301rd37168fPkSo0aN0rqtq+qFOH/+PG7cuIGuXbvi2bNn6nakpKTgvffew+HDh9W9q1WqVMHevXsN2gy5JVm7dm1Uq1ZN/bp48eJo27Ytdu/erXVrsU+fPur/t7a2RvXq1SGEwKeffqre7+rqijJlyuD27ds51v0mX19f9e1Z4NWt8O7du+PcuXNaT0337dsX1tbW2cZT3cL9888/kZWVlW3Zdu3awc/PT/06PDwcNWvWxM6dO9X7Xu8ZSk9PR3x8vPoW/tmzZ7VifvbZZxqv69evj2fPnqlv+27evBlKpRKRkZEaPene3t4oVaqUwU9mv87LywsXLlzAZ599hufPn2PRokXo2rUrPD09MWnSJHXPsTGfOZVBgwZpvP78888BQOMa5aX9+/cjLi4uz3tjBw8ejP/++w/z58+HVPq/Z4jT0tJ0Piio+rlNS0vTG/OHH37Avn37MHXqVK2hA0OGDEHLli1NeljNGFOmTMHUqVMRGRmJzp07Y+XKlZg8eTKOHj2KTZs2aZS9c+eO1vCnyMhIrFixAt27d0e7du0wadIk7N69G8+ePdOaMWLkyJEICQnR+E7QJSgoCEIIrZkWVq5ciUuXLmHatGnZnj9gwAD1d+y5c+dw/fp1DB06VD07Qnb/Juai+vk1dbgMvds4awHlWnJyMjw9PQG8mtZFCIExY8ZgzJgxOss/efIEfn5+qFKlCsqWLYsNGzaoE7cNGzagWLFiaNKkid76VOPQKlasqLeM6tZdjx499JZJTEyEm5sb3Nzc0LRp0+zfpBFKlSqlta906dJITU3F06dPNZLh4sWLa5RTTTnz5q1UFxcXrXGjhihZsqTWLcbSpUsDePWL9/W2vPlUtS4NGzbERx99hAkTJmD27Nlo1KgR2rVrh65du2olLPquw+vDSRISEjBhwgSsX78eT5480SibmJiodf6b18vNzQ0A8Pz5czg7O+PGjRsQQuisGwBsbGxyfI+6+Pj4YOHChfj5559x48YN7N69G9OmTcPYsWPh4+ODPn36GPWZU3mznSVKlICVlZXZ5kxeu3YtrK2ts/1D0VjTp0/HkiVLMGnSJLz//vsax+zt7XU+ea8aB6zrFjfw6nvgu+++w6effooBAwZoHTt27JjOoTr5YdiwYRgzZgz27dunnnXBGPXq1UPNmjWxb98+9b5///0Xq1evxv79+2FlZXz/UlJSEkaPHo0RI0YgICAg27ItW7bETz/9hFGjRqFq1aoAXn1PTJ48GV9//XWezMChb1iDPs7OzgBejSM2ZrwzEcBElnLpwYMHSExMRMmSJQFA3eP01Vdf6R3jqioLvOqVnTx5MuLj4+Hk5ITt27ejS5cuGr06plC1Y/r06QgNDdVZRvWFnZmZiYSEBIPienh45NhraQxdsfTFFzrGjOYlfUnF6yQSCTZt2oR///0XO3bswO7du9G7d2/MnDkT//77r9G/BCMjI3Hs2DGMGDECoaGhKFKkCJRKJVq0aKFzPHJO10apVEIikWDXrl06y+b2l7REIkHp0qVRunRptGrVCqVKlcLatWvRp08foz5z2cU3l7S0NGzZsgVNmzaFl5dXnsRcuXIlRo4cic8++0znuE4fHx8cOHAAQgiN96Z6UMnX11frnL1796J79+5o1aoVFi1apHV8xIgR6NixI2xtbdUJv2rs8/3795GZmakzbl6xt7dH0aJFDf7O0CUgIADXrl1Tv/76669Rv359BAcHq9+Tak7cx48f4969e1p/xL1uxowZyMzMRKdOndTnP3jwAMCrP/Lu3LkDX19f2NraAnjVg96rVy9cvHgRtra2CA0NxbJlywD87w9dfezs7JCRkaH1bwq8+jlMT0/XulOWE9W8vJcuXUL9+vWNOpeIiSzliuoBGFXSGhISAuBVz5chvZydOnXChAkT8Mcff8DLywtJSUk59nKonua9fPmyRlKsq4yzs3OO7Th27BgaN26cY1sBICYmBkFBQdmW0fUgx/Xr1+Hg4AAPDw+D6skrqh7y13/hqCYWz+l9ZKdWrVqoVasWJk+ejHXr1qFbt25Yv369xm1RfddBVe/z58+xf/9+TJgwAWPHjs32PEOVKFECQggEBwfn+As5t0JCQuDm5qZOyoz5zKncuHFDoyf85s2bUCqVufq30Wf79u14+fJlng0r2LZtG/r06YMPP/wQCxYs0FkmNDQUS5cuRXR0NMqXL6/ef+LECfXx1504cQLt27dH9erV8fvvv+v8g/b+/ftYt26d1gwlAFC1alVUqVJF77y6eUE1ZCo3P8u3b9/WOP/evXu4e/euzrsibdq0gYuLS7YPKt67dw/Pnz/XOZvEDz/8gB9++AHnzp3TuN6Ojo6oXbu2+vW+fftgb2+PunXrZtv2wMBAyOVy3Lp1S+v79+bNm1AoFAgMDMw2xptat26NKVOmYM2aNUxkyWgcI0sm+/vvvzFp0iQEBwerfzl6enqiUaNGWLx4sc7pYZ4+farxuly5cqhUqRI2bNiADRs2wMfHJ8cJuZs3bw4nJydMmTJFa6oiVc9ctWrVUKJECcyYMUPnE8avtyOvx8geP35cY3zn/fv3sW3bNjRv3jxPe3MN8ejRI/VMEcCrW5C//vorQkNDjZ6CCHiVfL7ZM6z65fjmLeStW7eqx0MDr56oPnHiBFq2bAngf72rb8abM2eO0e1S+fDDD2FtbY0JEyZoxRVCmDQ848SJEzon2z958iSePXumnsbImM+cypsJ4E8//QQA6muUl9atWwcHBweNMdOmOnz4MDp37owGDRpg7dq1em+Ht23bFjY2Nvj555/V+4QQWLRoEfz8/DSm3IqOjkarVq0QFBSEP//8U+8dgi1btmhtqqESv/76K2bPnp3r9we8Gv6ga+VC1bjoFi1aaOzXNf2Wrn/znTt34syZMxrn//LLL1rvSTVeesaMGeqZJgDd028NGTJE6/zFixcDeLUS15YtW7IdOnTs2DFs3rwZn376aY6LPag+m/Pnz9c6pvo8G/v5rV27Nlq0aIGlS5di69atWsczMzPx1VdfGRWT3h3skSWD7Nq1C1evXoVcLkdcXBz+/vtv7N27F4GBgdi+fbvGraQFCxagXr16qFSpEvr27YuQkBDExcXh+PHjePDgAS5cuKARu1OnThg7dizs7Ozw6aef5jhGzNnZGbNnz0afPn1Qo0YNdO3aFW5ubrhw4QJSU1OxatUqWFlZYenSpWjZsiUqVKiAXr16wc/PDw8fPsSBAwfg7OyMHTt2AECej5GtWLEiIiIiMGTIEMhkMvUv8TenicoPpUuXxqeffopTp07By8sLy5cvR1xcHFasWGFSvFWrVuHnn39G+/btUaJECbx8+RJLliyBs7Oz1vjIkiVLol69ehgwYAAyMjIwZ84cFC1aFF9//TWAV/+ODRo0wI8//oisrCz4+flhz549iImJMfn9lihRAt9//z1Gjx6NO3fuoF27dnByckJMTAy2bNmCfv36Gf0LcfXq1Vi7di3at2+PatWqwdbWFtHR0Vi+fDns7OzwzTffAIBRnzmVmJgYtGnTBi1atMDx48exZs0adO3aFVWqVMm2TYmJieqkVzVH7fz58+Hq6gpXV1cMHjxYo3xCQgJ27dqFjz76SO/whjt37iA4OBg9evTQu2QrANy9exdt2rSBRCJBhw4dsHHjRo3jlStXVq/05+/vj6FDh2L69OnIyspCjRo1sHXrVvzzzz/q8brAq17OiIgIPH/+HCNGjMBff/2lEbNEiRLq3sN27dpptUnVA9uyZUudU3W9af78+Xjx4gUePXoEANixY4f6Vvznn38OFxcXxMbGIiwsDF26dFHf+t69ezd27tyJFi1aoG3bthoxVVNvvT6+uU6dOggLC0P16tXh4uKCs2fPYvny5QgICFB/bgDofGhN1QPbsGFDVK9eXb1fNf3W6/9OVatWVY93VVG1o0KFChrX7O7du4iMjESbNm3g7e2NK1euYNGiRahcuTJ++OGHHK9daGgo+vTpg7lz5+LGjRto1qwZgFdDQnbu3Ik+ffrk+PnV5ddff0Xz5s3x4YcfonXr1njvvffg6OiIGzduYP369Xj8+DHnkiXd8nmWBCpkVFPAqDZbW1vh7e0tmjVrJubOnas1hYvKrVu3RPfu3YW3t7ewsbERfn5+4oMPPtC5asuNGzfU8Y8cOaK3DW9O2bJ9+3ZRp04dYW9vL5ydnUV4eLj47bffNMqcO3dOfPjhh6Jo0aJCJpOJwMBAERkZKfbv32/6Rfl/+qbfGjRokFizZo0oVaqUkMlkIiwsTBw4cEDnuW9OF6RvapuGDRuKChUqGNU+1cpeu3fvFpUrVxYymUyULVtWbNy4UaNcdlOsvXntz549K7p06SKKFy8uZDKZ8PT0FB988IHGdGOvT/szc+ZMERAQIGQymahfv77WtFIPHjwQ7du3F66ursLFxUV07NhRPHr0SAAQ48aNy/F66fts/PHHH6JevXrC0dFRODo6irJly4pBgwaJa9euGXUNhRDi4sWLYsSIEaJq1arC3d1dSKVS4ePjIzp27CjOnj2rVd6Qz5zq/fz333+iQ4cOwsnJSbi5uYnBgwcbtFKY6hrr2t6cAkoIIRYtWiQAiO3bt+uNeenSJYOmxMppurrX/92EEEKhUIgffvhBBAYGCltbW1GhQgWxZs0ag98PdEw19SZjp99STU2na1N9lp4/fy4+/vhjUbJkSeHg4CBkMpmoUKGC+OGHH0RmZqbOmG9e+2+//VaEhoYKFxcXYWNjI4oXLy4GDBggYmNjc2yjsdNvvUnf9FsJCQmibdu2wtvbW9ja2org4GAxcuRIvd/luigUCjF37lxRpUoVYWdnJ+zs7ESVKlXEvHnzhEKh0HteTlPFpaamihkzZogaNWqIIkWKCFtbW1GqVCnx+eefi5s3bxrcPnq3SIQw8xMkRESkYfz48ZgwYQKePn1qUA9ifvj555/x9ddf49atW3n2MBgRkblxjCwREeHAgQMYMmQIk1giKlQ4RpaokHn69Gm2a7bb2trC3d09H1tEb4M3x7oSERUGTGSJCpkaNWrg7t27eo83bNgQBw8ezL8GERERFRCOkSUqZI4ePZrtMpJubm4aS+QSERG9rZjIEhEREVGhxIe9iIiIiKhQYiJLRERERIUSE1kiIiIiKpSYyBIRERFRocREloiIiIgKpbd+HlmlUolHjx7ByckJEomkoJtDREREhZwQAi9fvoSvry+srNgnWJDe+kT20aNHCAgIKOhmEBER0Vvm/v378Pf3L+hmvNPe+kTWyckJwKsPm7OzcwG3hoiIiAq7pKQkBAQEqHMMKjhvfSKrGk7g7OzMRJaIiIjyDIcsFjwO7CAiIiKiQomJLBEREREVSkxkiYiIiKhQYiJLRERERIUSE1kiIiIiKpSYyBIRERFRocREloiIiIgKJSayRERERFQoMZElIiIiokKJiSwRERERFUpMZImIiIioUGIiS0RERESFEhNZIiIiIiqUmMgSERERUaHERJaIiIiICiVpQTegsLh8+TKysrJMOtfGxgYVK1Ys0Pi5qcPc8Q2tg9fIMq5RdHQ05HK50fGlUinKlStnStOIiIh0YiJroKysLHh7e5t0bmxsbIHHz00d5o5vaB28RpZxjeRyOSpVqmR0/EuXLhl9DhERUXY4tICIiIiICqUCTWQPHz6M1q1bw9fXFxKJBFu3blUfy8rKwsiRI1GpUiU4OjrC19cX3bt3x6NHjwquwURERERkMQo0kU1JSUGVKlWwYMECrWOpqak4e/YsxowZg7Nnz2Lz5s24du0a2rRpUwAtJSIiIiJLU6BjZFu2bImWLVvqPObi4oK9e/dq7Js/fz7Cw8Nx7949FC9ePD+aSEREREQWqlA97JWYmAiJRAJXV1e9ZTIyMpCRkaF+nZSUlA8tIyIiIqL8Vmge9kpPT8fIkSPRpUsXODs76y03ZcoUuLi4qLeAgIB8bCURERER5ZdCkchmZWUhMjISQggsXLgw27KjR49GYmKiert//34+tZKIiIiI8pPFDy1QJbF3797F33//nW1vLADIZDLIZLJ8ah0RERERFRSLTmRVSeyNGzdw4MABFC1atKCbREREREQWokAT2eTkZNy8eVP9OiYmBufPn4e7uzt8fHzQoUMHnD17Fn/++ScUCoV65SF3d3fY2toWVLOJiIiIyAIUaCJ7+vRpNG7cWP16+PDhAIAePXpg/Pjx2L59OwAgNDRU47wDBw6gUaNG+dVMIiIiIrJABZrINmrUCEIIvcezO0ZERERE77ZCMWsBEREREdGbLPphL0tiY2OjHqNryrkFHT83dZg7vqF18BpZxjWSSqW4dOmS0fGlUn7dEBFR3pKIt/z+fVJSElxcXJCYmJjj1F1EREREOWFuYTk4tICIiIiICiUmskRERERUKHHQmg5yuRwKhaKgm0FkUaytrTnOlYiILAp/K71BLpfjwYMHnPqL6A0SiQT+/v5MZomIyGJwaMEbFAoFk1giHYQQvFNBREQWhYksERERERVKTGSJiIiIqFBiIktEREREhRKf2jBQfHy8yWNnJRIJihUrVqDxc1OHueMbWgevkWVco+joaMjlcqPjS6VSlCtXzpSmERER6cRE1kBCCAQEBJh07v379ws8fm7qMHd8Q+vgNbKMaySXy1GpUiWj45uyrC0REVF2OLSAiIiIiAolJrJEREREVCgVaCJ7+PBhtG7dGr6+vpBIJNi6davG8c2bN6N58+YoWrQoJBIJzp8/XyDtJCIiIiLLU6CJbEpKCqpUqYIFCxboPV6vXj1MmzYtn1tGRERERJauQB/2atmyJVq2bKn3+CeffAIAuHPnTj61iIiIiIgKi7du1oKMjAxkZGSoXyclJRVga4iIiIjIXN66h72mTJkCFxcX9WbqVEREREREZNneukR29OjRSExMVG+Gzo1JRERERIXLWze0QCaTQSaTFXQziIiIiMjM3roeWSIiIiJ6NxRoj2xycjJu3rypfh0TE4Pz58/D3d0dxYsXR0JCAu7du4dHjx4BAK5duwYA8Pb2hre3d4G0mYiIiIgsQ4H2yJ4+fRphYWEICwsDAAwfPhxhYWEYO3YsAGD79u0ICwtDq1atAACdO3dGWFgYFi1aVGBtJiIiIiLLUKA9so0aNYIQQu/xnj17omfPnvnXICIiIiIqNDhGloiIiIgKpbdu1gJzkUgkJk/lJZFICjx+buowd3xD6+A1soxrJJVKcenSJaPjS6X8uiEiorwlEdnd238LJCUlwcXFBYmJiXB2ds6xfEZGhvrhMiLS5Ovry+ntiOidZ2xuQebDoQVEREREVCgxkSUiIiKDCCEQHR2N2NhYAIBSqcz2oW2yXIcPH0br1q3h6+sLiUSCrVu35njOwYMHUbVqVchkMpQsWRIrV640eztzwkSWiIiIDHLmzBl89913iIqKAvBqbL2h4+vJsqSkpKBKlSpYsGCBQeVjYmLQqlUrNG7cGOfPn8fQoUPRp08f7N6928wtzR6fviAiIqJsKRQKWFtbIyQkBMHBwXj48CGAV4ns+fPnkZWVhRo1ahRwK8kYLVu2RMuWLQ0uv2jRIgQHB2PmzJkAgHLlyuHIkSOYPXs2IiIizNXMHDGRJSIiIi0KhQJWVlaQSCSwtrYGALi7u8Pb2xsPHjzAwYMHsWzZMsTFxcHGxgYffPABunXrxoefzCA9PR2ZmZk5lhNCaPWQy2SyPHlI9/jx42jatKnGvoiICAwdOjTXsXODQwuIiIgICoVCY7yrtbU1JBIJ4uPjsXfvXvz3338AgBIlSiA+Ph5r165Ft27dsGfPHnz44Yc4dOgQDh06BAAcN5uH0tPT4ebmDRcXlxw3f39/rX1TpkzJk3bExsbCy8tLY5+XlxeSkpKQlpaWJ3WYgj2yRERE7yilUgkrq1d9WqpeV9UwggsXLmD27Nm4desWfH190apVK5QtWxaVKlXCb7/9Bnt7e7Ro0QIA0KFDB9y8eRPHjh1D69atOW42D2VmZiI9PRHtW86FjY293nJZWWnYsusL3L9/X6NX/G2fMpGJLBER0Tvg9aECKqok9sWLFzh48CDWrVuHDz/8EB06dMDixYvh5+eHGTNmwMHBAUlJSbCysoKfnx8CAwM1euFcXFwQGBiI48eP4/nz53Bzc8v39/e2E0WKQNg46D+e9eoPEWdnZ7MM7/D29kZcXJzGvri4ODg7O8PeXn+CbW5MZA0UHx9v8q0SiUSCYsWKFWj83NRh7viG1sFrZBnXKDo6GnK53Oj4UqkU5cqVM6VpRGQi1ffB6+NcX3fnzh388MMP8Pb2hlKpROfOnREeHo6zZ8/izJkz2Lp1q/p7wcHhVRJlb2+PoKAgXLhwAQ8ePIC/vz8AICgoCEeOHMGVK1dQr149neM1qfCqXbs2du7cqbFv7969qF27dgG16BUmsgYSQiAgIMCkcw1ZMtTc8XNTh7njG1oHr5FlXCO5XI5KlSoZHd+UZW2JyHCvJ60qqv9/8eIF/vnnH8TFxaFu3brqPyr9/Pwgl8tx4MABjB8/Hu+99x4AICoqCiVKlICdnZ06thACSqUSUqkUpUqVwqlTp3Dt2jV1IluiRAk4Ozvj/PnzTGTNQCG1gpWN/kebFMK4x56Sk5Nx8+ZN9euYmBicP38e7u7uKF68OEaPHo2HDx/i119/BQB89tlnmD9/Pr7++mv07t0bf//9N37//Xf89ddfpr2hPMKHvYiIiCyUEELrIaw3KZVKALrndE1LS8OMGTPQtWtXrF69GpcvX0b//v0RFRWFzMxM2NjYoHz58nB2dkaZMmXU5xUpUgSOjo64ceOGug4rKytIpa/6v0qXLg1HR0dcu3ZNfY6Pjw8cHR1x9+5dAP8btkCW6fTp0wgLC0NYWBgAYPjw4QgLC8PYsWMBAI8fP8a9e/fU5YODg/HXX39h7969qFKlCmbOnImlS5cW6NRbQAH3yB4+fBjTp0/HmTNn8PjxY2zZsgXt2rVTHxdCYNy4cViyZAlevHiBunXrYuHChShVqlTBNZqIiCifvD4k4PHjx7h79y78/f3VvaDA/xLGy5cv4+rVq6hRowYCAgLU+52cnDBp0iRUq1YNALB06VLs2LEDnp6eqFq1KkqVKoVz584hJiZGHTcsLAz79u3DgQMHEB4erm7D5cuX4eHhAX9/f8hkMpw7dw5yuRxSqRRFihTBqFGjULRo0Xy7Pu+SLFspYKs/bcsyMqVr1KhRtn8g6Vq1q1GjRjh37pxR9ZhbgSayqlUlevfujQ8//FDr+I8//oh58+Zh1apVCA4OxpgxYxAREYH//vtPfbuDiIjobXX37l2sW7cOBw4cgEQiQWBgIBo0aIDIyEjY2toCAM6dO4eZM2ciLi4OxYsXx9q1a9G6dWv07t0b9vb26NatG4oUKYKzZ8/i+PHj2LNnD5KTk3Hx4kVUrVoVlSpVwsaNG3Hnzh3Ur18fAFCqVCl8+OGHGD9+PNLT01G7dm1cv34dZ8+exZAhQ+Dl5YXIyEgUKVJE3UsLgEks5bsCTWSzW1VCCIE5c+bgu+++Q9u2bQEAv/76K7y8vLB161Z07tw5P5tKRESUr+RyOZYvX47k5GSMHTsWZcqUwfPnz2FjY6NOHlNSUrBhwwaUK1cOa9asAQDs27cP69atQ9GiRdG2bVvY2dlh5syZOHbsGEJCQtC5c2f8888/6mEBISEhcHNzw71795Cenq7uKHr//fdhbW2NQ4cOYf78+QgMDETHjh3V42tr1apVAFfl3SW3sYIkmzGyciPHyL4tLPZhr5iYGMTGxmqsIuHi4oKaNWvi+PHjehPZjIwMZGRkqF8nJSWZva1ERER5bffu3Th//jxGjx6tTho9PDw0yly/fh23b9/G77//jri4OJw4cQJ///03rly5ggoVKgB4tSLTrl27MHHiRNSqVQtWVlY4duwY7t27h4cPH8LPzw8hISG4dOkS7t69qzFWNiIiAg0bNuRdULJYFpvIxsbGAoDOVSRUx3SZMmUKJkyYYNa2ERERmUqpVEKpVKpXztJ13MrKCra2tkhNTUWRIkXU+xMSEuDq6qrukZXJZIiJiUGbNm2QmJgIf39/VK9eHd26dUP58uUBANeuXUOJEiXg6+sLKysrXL58GY8fP0ZKSgrOnTsHPz8/VKxYEc+ePVPHff1BLSaxlkFuaw3ItKdQUx+H/mNvM4tNZE01evRoDB8+XP06KSnJ5OmIiIiIciMzMxNJSUkoVqyYOkFVbcCrKZBUiaqKqlzt2rXV0yA5OjrC1tYWHh4eUCgUqFWrFtq1awcbGxsUK1YMzZs3R58+fTSSzvT0dABAxYoVsXv3bsyaNQvly5fH1atXUb9+faSkpKjLN2vWDM2aNcunq0KUdyw2kfX29gbwatUIHx8f9f64uDiEhobqPU8mk731y7EREZHlUiWiSUlJmD9/PjIzMzF+/Hj1XKwnTpzA9u3bceXKFXh7e2P8+PHw8fFRz7uq6hUtUqQIZs6ciaioKKSlpcHe3h7Jycm4fPkyFi9eDIVCgW7dusHf3x+3bt1ST8MFvOqFPXz4MBo1aoRatWrh22+/xapVq3Dp0iVERESgefPm7GktZBRSK0ik2cwjq+AYWYsSHBwMb29v7N+/X524JiUl4cSJExgwYEDBNo6IiOg1qsUCrK2t1b2tjo6OKFGiBI4dOwYAsLa2xrlz5zBv3jyULl0aw4YN01g0QCKRICEhAYcPH0ZcXBxatmyJ4sWLq58JUSgU6mmwJk+ejJ07d6Jbt27o378/Jk2ahH79+qFZs2a4evUqrl+/jjJlyqBNmzYAgNDQ0Gw7gYgKqwJNZHNaVWLo0KH4/vvvUapUKfX0W76+vhpzzRIREeU3Va+rypvzvW7duhXVq1dHQEAAnj9/jqtXr6Js2bJYsWIFPD09MX78eK2Ya9aswdy5cxEcHIzmzZvDyclJ47gqfkJCAh49egRHR0cAQPXq1fHTTz9h7969OHXqFLy9vTFy5EjUqFGDK2u9RTJlVlBmO0aWPbL57vTp02jcuLH6tWpsa48ePbBy5Up8/fXXSElJQb9+/fDixQvUq1cPUVFRvB1CRET5TjU04PUxrirp6emYMWMGKlSogOvXr+PChQuoUaMG3N3dUaFCBaSlpQF4NT/rwYMHsXjxYtjb28Pf3x/FihVDpUqV8P7776NJkybw9fXViH3hwgXY2trCzc0Nz549w759+5CUlIQRI0YAeNVTW7x4cfTu3ZuJK71zCjSRzWlVCYlEgokTJ2LixIn52CoiIqJXCaKVlZXGrX+JRIKMjAycPn0aMpkMFStWhJ2dHZRKJZ48eYJt27bh448/xrp16wC8Sn5HjhypjvnJJ58gLS0NZ8+ehZeXF/bt24fr169j6NCh6NixI9zd3dVlVcMOtm/fjjt37iA+Ph4vXrxAlSpV0L9/f1SsWBHA/3pqmcS+3eQ21hC2+ntkFUrOWkBERET/T5UgqqSnp2Pp0qXYuHEjXFxcULRoUdjb22PChAnw8PBA3bp1cfr0aXzwwQfqc1TJpWp8q6urK77++msAwNOnT+Hh4YHJkyfj4MGDaNy4Mby8vNQJrOq/ffr0QUxMDDw8PLhEO9EbmMgaSCKR4P79+yafW9Dxc1OHueMbWgevkWVcI6lUikuXLhkd//VlLIkKg4cPH2Lp0qXo1KkTypYti3///RcHDx7E/PnzUalSJTx//hyTJ0/GTz/9hIkTJ6JChQrIysqCQqHQivV6Upyeno6UlBR4eHggIyMD8fHxKF68ODw9PTUe/lINX/Dx8dGYvYfeTQobKyCblb04awFlq1ixYoU6fn7UUdjj50cdhT0+APXylESFjRACCoVC48EsVeKYkpKChIQEBAQEqB/kevnyJf788091D+qWLVvQs2dPVKpUCVevXsWpU6dw+fJlCCHw6NEjBAUFwcvLC6dPn0bp0qU1ktLX2/Dvv/9ix44dSElJQXR0NEqXLo3+/ftzaACRCZjIEhFRoaV6zkJXEvj6w1mqMqo7A0qlEnK5HLa2tpDL5Zg0aRLu3r2LX3/9FTY2NgCAR48eISQkBAkJCfDz88OjR4+wePFi/PTTT5DL5ShTpgw+/vhj1KpVC76+vsjKykJYWBj++ecfdO3aVWciK5FIULp0aYSEhMDd3R0jR45EcHCwOS8RvSWsZQJSmf7nipDNM0dvMyayRERUqKgm/n/9QazXyeVySKVS9cNZKunp6di6dSu2bNmCtLQ0hIeHIzIyEqVLl8bgwYPRv39//Prrr+jWrRvs7OwQExMDNzc39SI7YWFhOHr0KGbOnImgoCCNFbnS09NhZ2eHmjVrYvr06RoJ9Jt8fX0xaNCgvLwkRO+sd3NABRERFVqq6a+Sk5Oxf/9+LF26FIcOHUJycjKA/43HTkxMxG+//YalS5ciIyMD+/btw5YtW/DBBx/g66+/xpUrVzBt2jScPn0a/v7++Pjjj3Hw4EHs3r0bAGBjY4Nnz56hWLFiEEKgatWqSEhIgJ2dnTqJzcjIwK5du7Bz504olUqULl0aqampuH79esFcHHprSa2VkEqz2ayVOQd5C7FHloiICpVz585h2bJlOHfuHIKCglC5cmVcvHgRsbGx6NSpE1asWIGXL19CIpHg7NmzaNWqFZ4+fYrt27ejbNmy+OSTTwAAgYGBmD59OjZu3Ijq1aujRYsWiI+Px7Jly9CyZUukp6fDzc0NwKshAS1atEBUVBQGDx6M9u3bw9bWFqdOncKLFy/Qo0cPAEBISAj27t0LV1fXgro8RO8UJrJERFRo3LlzB/PmzYO/vz9WrVqFkiVLIisrCwkJCfDy8gLwaqqr1atXo169epg9ezZcXV3V87B27NhRHcvHxwe1atXChg0bAABubm749NNP8ddff+G3337D+fPnUbFiRWRkZKiHF4wfPx6HDh3CkSNH8OzZM9SqVQvNmzdHUFAQgFe9xUxiyRxsZUpIZdozYqhYKdkjS0REZJFUD06tWrUK8fHxmDlzpjphtLGxgZeXF5RKJdLT0/HBBx9g8eLFCAsLU5cJCgpCUlISUlJS1GNopVIp3N3dIZVKcevWLZQoUQIODg7o06cP/vnnH5w6dQply5aFTCZTL47g6uqKtm3bom3btgV3MYhIjWNkiYjI4kkkEsTGxuLYsWNo1KgR3N3dYWVlBaVSiV9++QXdu3dHkyZN8OOPP8Lb2xsuLi7IzMyEXC5XPxxWpkwZnDhxQj2WFgBu3boFR0dHFC1aVL2vTZs2qFq1KmxsbFCiRAkAr+aB5fRYVJCkNsoct3cRE1kiIioUnJyc8OLFC/j5+UGhUKhnBnj+/DlatWqF2rVr48mTJ8jMzESNGjVw6dIlZGRkqGcPaNeuHe7cuYPp06cjPj4e//33H86cOYNq1appDAewtbXFxx9/jGPHjqFVq1YF9G6JyBAcWmCg+Ph49XyFxpJIJDlOVG/u+Lmpw9zxDa2D18gyrlF0dDTkcrnR8aVSKRdToFyxtraGj48P7ty5g6ysLNjZ2QEARo4cCeDVGNdVq1bh+vXraNasGSZPnoznz5/D0dERANC4cWNIpVIsXboUvXr1wrNnz9CgQQN07dpVZ11ElsTGRgEbW/1jZCVy/cfeZkxkDSSEQEBAgEnnGrJkqLnj56YOc8c3tA5eI8u4RnK5HJUqVTI6vinL2hK9ztbWFqGhoTh58iTi4uIQGBiosehBlSpVkJWVhVOnTiEyMhJJSUm4c+cO/P39Abz6Y6px48YoX748nj17hrJly+qd65WICgf+BBMRUaFgZWWF9u3b4/79+1izZo3GfuDVSlzp6emwtraGo6MjHBwccPv2bfUYWRUvLy+UL1+eSSwVKjY2yhy3dxF7ZImIqNCoUqUK+vbti6VLl+Lq1auIiIgAAJw6dQqPHz9G48aN0b59ewDAtm3bOBUW0VvO4hPZly9fYsyYMdiyZQuePHmCsLAwzJ07FzVq1CjophERUQHo168fypcvj5MnT+LQoUPIyMhAWFgY+vfvj/LlywN4NcyGSSy9TWxlStjI9Pe6ShTskbVIffr0weXLl7F69Wr4+vpizZo1aNq0Kf777z/4+fkVdPOIiKgA1KtXD/Xq1YNCodD5YBanyiJ6N1j0AKG0tDT88ccf+PHHH9GgQQOULFkS48ePR8mSJbFw4cKCbh4RERUwzi5A7wobWwVsZfq37GY0eJtZdI+sXC6HQqFQT7GiYm9vjyNHjug8JyMjAxkZGerXSUlJZm0jERERERUMi+6RdXJyQu3atTFp0iQ8evQICoUCa9aswfHjx/H48WOd50yZMgUuLi7qzdSpiIiIiIgshVSqzHEzxYIFCxAUFAQ7OzvUrFkTJ0+ezLb8nDlzUKZMGdjb2yMgIADDhg1Denq6SXXnBYtOZAFg9erVEELAz88PMpkM8+bNQ5cuXfROmzJ69GgkJiaqN0PnxiQiIsuhWrmLiMxnw4YNGD58OMaNG4ezZ8+iSpUqiIiIwJMnT3SWX7duHUaNGoVx48YhOjoay5Ytw4YNG/DNN9/kc8v/x+IT2RIlSuDQoUNITk7G/fv3cfLkSWRlZSEkJERneZlMBmdnZ42NiIgKj6SkJJw/fx7Xr18v6KYQWYzsxseqNmPNmjULffv2Ra9evVC+fHksWrQIDg4OWL58uc7yx44dQ926ddG1a1cEBQWhefPm6NKlS469uAAwbtw43L171+g25sTiE1kVR0dH+Pj44Pnz59i9ezfatm1b0E0iIqI89vTpU9y4cQMATFoKmehdl5SUpLG9/tzQ6zIzM3HmzBk0bdpUvc/KygpNmzbF8ePHdZ5Tp04dnDlzRp243r59Gzt37sT777+fY7u2bduGEiVK4L333sO6dev0tstYFp/I7t69G1FRUYiJicHevXvRuHFjlC1bFr169SrophERUR4RQuDevXu4d+8eAMDV1RXlypUr4FYRWQ4bq5w3AAgICNB4VmjKlCk648XHx0OhUMDLy0tjv5eXF2JjY3We07VrV0ycOBH16tWDjY0NSpQogUaNGhk0tOD8+fM4deoUKlSogC+++ALe3t4YMGAATp06ZdyFeIPFJ7KJiYkYNGgQypYti+7du6NevXrYvXs3bGxsCrppRESUBxQKBa5evYqnT58CAHx9fRESEsIlZIlMcP/+fY1nhUaPHp1nsQ8ePIgffvgBP//8M86ePYvNmzfjr7/+wqRJkww6PywsDPPmzcOjR4+wbNkyPHjwAHXr1kXlypUxd+5cJCYmGt0mi55+CwAiIyMRGRlZ0M0gIiIzyMjIwH///Qel8tUT1yEhIXBzcyvgVhFZHjtrQJbNtMlW/3/M0OeDihUrBmtra8TFxWnsj4uLg7e3t85zxowZg08++QR9+vQBAFSqVAkpKSno168fvv32W4P/+BRCICsrC5mZmRBCwM3NDfPnz8eYMWOwZMkSdOrUyaA4QCHokSUiordTcnIyLl++rE5iy5YtyySWKJ/Y2tqiWrVq2L9/v3qfUqnE/v37Ubt2bZ3npKamaiWrqkVJDJll5MyZMxg8eDB8fHwwbNgwhIWFITo6GocOHcKNGzcwefJkDBkyxKj3YfE9spZCIpGYPJWXIUslmjt+buowd3xD6+A1soxrJJVKcenSJaPjS6X8uqH/efbsGe7cuQPg1S/C8uXLw9bWtmAbRWTBbCT/Gweri9KEVZmHDx+OHj16oHr16ggPD8ecOXOQkpKifg6pe/fu8PPzU4+zbd26NWbNmoWwsDDUrFkTN2/exJgxY9C6descV9mrVKkSrl69iubNm2PZsmU6z+nSpQu++OILo94Df7MYqFixYoU6fn7UUdjj50cdhT0+AD6AQ7kihMCjR4/UD5MUKVIEJUuW5FKzRAWgU6dOePr0KcaOHYvY2FiEhoYiKipK/QDYvXv3NHpgv/vuO0gkEnz33Xd4+PAhPDw80Lp1a0yePDnHuiIjI9G7d2/4+fnpLVOsWDH1HRpDMZElIqJ8oVQqcevWLfXS4V5eXvDz8zP4bgDRu0wmBeyyy9pMzOgGDx6MwYMH6zx28OBBzSqkUowbNw7jxo0zuh7VWNg3paWlYfr06Rg7dqzRMQGOkSUionyQlZWFS5cuqZPYwMBA+Pv7M4klekdMmDABycnJWvtTU1MxYcIEk+OyR5aIiMwqNTUV0dHR6telS5eGk5NTAbaIqPB5fa5YXRQW3jUphND5h+uFCxfg7u5uclwmskREBADYtGkT0tPT8zRmkSJFEBAQAODVfLFVqlSBTCbL0zqIyHK5ublBIpFAIpGgdOnSGsmsQqFAcnIyPvvsM5PjM5ElIiIAQHp6Olq0aJEnsYQQSEpKwosXLwC8Glt37do1hIeH50l8oneNvbWAnbX+Ka4k2RwrSHPmzIEQAr1798aECRPg4uKiPmZra4ugoCC9030ZgoksERHlWmZmJmxsbCCRSCCEQHx8PFJTUwEAjo6OKFq0qEnTthFR4dajRw8AQHBwMOrUqZPnK7MykSUiolxJT09HXFwcHBwc4O7ujsePH0OhUAB4dVvRkFWGiCh7MutXq3vpIyxwBrukpCT1z39YWBjS0tKQlpams6yp3xNMZImIyGSq3tdnz54BgLoXFgA8PT1hb29fUE0jogLm5uaGx48fw9PTE66urjof9lI9BKb649dYTGQNFB8fb9Dya7pIJJIcJ6o3d/zc1GHu+IbWwWtkGdcoOjoacrnc6PhSqZSLKbyF0tLSoFAoMHbsWFSsWBEDBgwAAPj4+HClLqI8lNOsBXILnLXg77//Vs9IcODAAbPUwUTWQEII9ZO3xjJkyVBzx89NHeaOb2gdvEaWcY3kcjkqVapkdHyOj3z7qHpjz5w5gxMnTuDEiRMoVaoUmjRpUtBNIyIL0LBhQ53/n5eYyBIRkUlSUlIghMC8efMAABUqVEBCQgKsrKwQHx8PX1/fAm4h0dsjpzGySgscI3vx4kWDy1auXNmkOkxKZPfv34/9+/fjyZMnWmviLl++3KSGEBFR4aHqjY2JiUHTpk0xffp0eHp6QqlUokiRIlzwgIgQGhqqnskkO/k6RnbChAmYOHEiqlevDh8fH7MuL6hQKDB+/HisWbMGsbGx8PX1Rc+ePfHdd99xWUMiogKUnJwMiUSCkJAQBAUFwdnZGY6OjpDJZPx+JjIDWwlgm90YWQv8sYuJiTF7HUYnsosWLcLKlSvxySefmKM9GqZNm4aFCxdi1apVqFChAk6fPo1evXrBxcUFQ4YMMXv9RESkm1QqhZOTExwcHJi8EpFOgYGBZq/D6GfcMjMzUadOHXO0RcuxY8fQtm1btGrVCkFBQejQoQOaN2+OkydP5kv9RESkm729Pdzd3WFnZ8ckligfyKwBmbXIZivoFuZs9erVqFu3Lnx9fXH37l0Ar1b+2rZtm8kxjU5k+/Tpg3Xr1plcoTHq1KmD/fv34/r16wCACxcu4MiRI2jZsqXeczIyMpCUlKSxEREREVHBWbhwIYYPH473338fL168UI+JdXV1xZw5c0yOa9DQguHDh6v/X6lU4pdffsG+fftQuXJlraXGZs2aZXJj3jRq1CgkJSWhbNmysLa2hkKhwOTJk9GtWze950yZMgUTJkzIszYQERERFTSplYDUSv9DU9kdswQ//fQTlixZgnbt2mHq1Knq/dWrV8dXX31lclyDEtlz585pvA4NDQUAXL582eSKDfH7779j7dq1WLduHSpUqIDz589j6NCh8PX1Va/d+6bRo0drJN5JSUkmz6tJRERERLkXExODsLAwrf0ymQwpKSkmxzUokTXXagw5GTFiBEaNGoXOnTsDACpVqoS7d+9iypQpehNZmUwGmUyWn80kIiIiMitbayVk1kq9x+XZHLMEwcHBOH/+vNYDYFFRUbla9dHoMbK9e/fGy5cvtfanpKSgd+/eJjdEl9TUVFhZaTbR2tpaa+5aIiIiIrJcw4cPx6BBg7BhwwYIIXDy5ElMnjwZo0ePxtdff21yXKOn31q1ahWmTp2qNdl1Wloafv311zxdEKF169aYPHkyihcvjgoVKuDcuXOYNWtWnifMRERERJZMNTuBPvJsjlmCPn36wN7eHt999x1SU1PRtWtX+Pr6Yu7cueo776YwOJFNSkqCEAJCCLx8+RJ2dnbqYwqFAjt37oSnp6fJDdHlp59+wpgxYzBw4EA8efIEvr6+6N+/P8aOHZun9RARERGReXXr1g3dunVDamoqkpOT8yRvNDiRdXV1hUQigUQiQenSpbWOSySSPJ8twMnJCXPmzMnVtAxEREREhZ2NlYBNNjMTZHfM0jg4OMDBwSFPYhmcyB44cABCCDRp0gR//PEH3N3d1cdsbW0RGBgIX1/fPGmUJZJIJLh//77J5xZ0/NzUYe74htbBa2QZ10gqleLSpUtGx5dKjR7JREREhVhYWJjBv1vOnj1rUh0G/2Zp2LAhgFfTJxQvXvydW8mlWLFihTp+ftRR2OPnRx2FPT6AXD1dSkREprHNYYxslgWOkW3Xrp36/9PT0/Hzzz+jfPnyqF27NgDg33//xZUrVzBw4ECT6zAokb148aLG6+x6YypXrmxyY4iIiIjo7TBu3Dj1//fp0wdDhgzBpEmTtMqYeicRMDCRDQ0NhUQigRAix55Y1ZJjRERERJQ3pBCQSrJZ2QuW1yP7uo0bN+L06dNa+z/++GNUr17d5FmvDJpHNiYmBrdv30ZMTAz++OMPBAcH4+eff8a5c+dw7tw5/PzzzyhRogT++OMPkxpBRERERG8ve3t7HD16VGv/0aNHNWbCMpZBPbKvr8LQsWNHzJs3D++//756X+XKlREQEIAxY8ZojIcgIqKcbdq0Cenp6WaLb2dnhw4dOhhULioqyqztICLTyHJY2SvLwlf2Gjp0KAYMGICzZ88iPDwcAHDixAksX74cY8aMMTmu0Y8RX7p0CcHBwVr7g4OD8d9//5ncECKid1V6ejpatGhhtviGJqeGJLtERKYYNWoUQkJCMHfuXKxZswbAq4eHV6xYgcjISJPjGr1Ebbly5TBlyhRkZmaq92VmZmLKlCl8mpmIiIjIDKT/P4+svk1q4jyyCxYsQFBQEOzs7FCzZk2cPHky2/IvXrzAoEGD4OPjA5lMhtKlS2Pnzp0G1RUZGYmjR48iISEBCQkJOHr0aK6SWMCEHtlFixahdevW8Pf3V89QcPHiRUgkEuzYsSNXjSEiIiKi/LFhwwYMHz4cixYtQs2aNTFnzhxERETg2rVrOlfdyszMRLNmzeDp6YlNmzbBz88Pd+/ehaura/43/v8ZnciGh4fj9u3bWLt2La5evQoA6NSpE7p27QpHR8c8byARERHRu06WwzyymSbMIztr1iz07dsXvXr1AvCqs/Kvv/7C8uXLMWrUKK3yy5cvR0JCAo4dOwYbGxsAQFBQkN747u7uuH79OooVKwY3N7dsZ75KSEgwuv2ACYksADg6OqJfv34mVVhYxcfHQwjTuu0lEkmOE9WbO35u6jB3fEPr4DWyjGsUHR0NuVxudHypVMrhR0REZpaUlKTxWiaTQSaTaZXLzMzEmTNnMHr0aPU+KysrNG3aFMePH9cZe/v27ahduzYGDRqEbdu2wcPDA127dsXIkSNhbW2tVX727NlwcnICAMyZMycX70o/gxLZ7du3o2XLlrCxscH27duzLdumTZs8aZilEUIgICDApHMNmejX3PFzU4e54xtaB6+RZVwjuVyOSpUqGR3flGVtiYjoFSuJNawk2sni68cBaP0OGDduHMaPH69VPj4+HgqFAl5eXhr7vby81Hfc33T79m38/fff6NatG3bu3ImbN29i4MCByMrK0lj8QKVHjx4YO3YsRo0ahR49egAAnj9/Djc3t2zfqzEMSmTbtWuH2NhYeHp6Zju9lkQi4YIIRERERAXk/v37cHZ2Vr/W1RtrKqVSCU9PT/zyyy+wtrZGtWrV8PDhQ0yfPl1nIgsAkydPxuDBg+Hg4ADg1ZSu58+fR0hISJ60yaBEVqlU6vx/IiIiIjI/a4kNrCU22Rx/NeTL2dlZI5HVp1ixYrC2tkZcXJzG/ri4OHh7e+s8x8fHBzY2NhrDCMqVK4fY2FhkZmbC1tZW65w3h7uZOvxNH4On31qxYgXu3r2bp5UbIigoCBKJRGsbNGhQvreFiIiI6G1ga2uLatWqYf/+/ep9SqUS+/fvR+3atXWeU7duXdy8eVOjU/P69evw8fHRmcTmB4MT2YEDByIkJAQhISH49NNPsWbNGjx8+NCcbQMAnDp1Co8fP1Zve/fuBfBqhTEiIiKid4GVxBrWEqneLbvxs/oMHz4cS5YswapVqxAdHY0BAwYgJSVFPYtB9+7dNR4GGzBgABISEvDFF1/g+vXr+Ouvv/DDDz9k27kokUjw8uVLJCUlITExERKJBMnJyUhKStLYTGXwrAUvXrzAsWPHcOjQIRw4cADr1q1DZmYmSpYsicaNG6Nx48Zo1KiR1qDh3PLw8NB4PXXqVJQoUQINGzbM03qIiIiI3iWdOnXC06dPMXbsWMTGxiI0NBRRUVHqXO7evXuwsvpfn2dAQAB2796NYcOGoXLlyvDz88MXX3yBkSNH6q1DCIHSpUtrvA4LC9N4nZtnrAxOZGUymTphHT9+PNLT03H8+HEcOHAABw8exKpVq5CVlWXStDyGyszMxJo1azB8+HC9c5FlZGQgIyND/To3WT4RERGRJTB01gJjDR48GIMHD9Z57ODBg1r7ateujX///dfg+AcOHDCpXYYyaR5Z4NVcY1ZWVuoxq0IIFC9ePC/bpmXr1q148eIFevbsqbfMlClTMGHCBLO2g4iIiIhyZu476AaPkc3MzMThw4cxceJENGrUCC4uLujfvz8eP36Mvn374saNG7h9+7Y524ply5ahZcuW8PX11Vtm9OjRSExMVG+Gzo1JREREZKlUsxZkt72LDO6RdXFxgaenJ1q3bo1BgwZh/fr1eqdnMIe7d+9i37592Lx5c7bl9K1gQURERERvF4MT2SpVquDcuXM4fPiwelhBo0aNULRoUXO2T23FihXw9PREq1at8qU+IiIiIkthrjGyhZ3BQwv+/fdfPHv2DD/++CPs7e3x448/wsfHBxUrVsTgwYOxceNGPHnyxCyNVCqVWLFiBXr06AGp1ORhvURERET0FjE4kQWAIkWKoEWLFpg2bRpOnDihTmxtbGzQt2/fbMeu5sa+fftw79499O7d2yzxiYiIiCxZYR8j27t3b7x8+VJrf0pKSq7yO6MSWRWlUokTJ07g559/xrx587B06VIkJSUhICDA5IZkp3nz5lrzkBERERFR4bBq1SqkpaVp7U9LS8Ovv/5qclyD79OfPHkSBw8exMGDB3HkyBEkJyfD398fjRo1wrx589C4cWMEBQWZ3BAiIiIi0s1KYpXDGFmT+ibNLikpCUIICCHw8uVL2NnZqY8pFArs3LkTnp6eJsc3OJGtVasWvL290bhxY8yaNQuNGzdGiRIlTK64sJFIJCZP5aVv8Yb8jJ+bOswd39A6eI0s4xpJpVJcunTJ6Pgc305E9O5xdXVVrzmg6866RCLJ1fz/Bv9miY6ORpkyZUyuqLArVqxYoY6fH3UU9vj5UUdhjw8A5cqVM3sdRESkyVoihbVEf9qW3bGCdODAAQgh0KRJE/zxxx9wd3dXH7O1tUVgYGCunrEy+F2/y0ksERERERlPtbJXTEwMihcvbvDdP0NZZvpORERERGqFcR7ZixcvarzOblha5cqVTaqDiSwRERER5bnQ0FBIJBIIIbItJ5FIoFAoTKqDiSwRUQ42bdqE9PR0s8V/+fIl1q9fD1dXV7PEf/0pYSIqpBTyV1t2xy1MTEyM2eswOpGdOHEivvrqKzg4OGjsT0tLw/Tp0zF27Ng8axwRkSVIT09HixYtzFpHVFQUPv74Y7PWQUSUnwIDA81eh9GJ7IQJE/DZZ59pJbKpqamYMGECE1kiIiKivCbPAuSZ2R+3YDktetC9e3eT4hqdyAohdD5xduHCBY0pFYiIiIiIAOCLL77QeJ2VlYXU1FTY2trCwcHB/Imsm5ubxoS2ryezCoUCycnJ+Oyzz0xqBBERERFlQyl/tWV33II9f/5ca9+NGzcwYMAAjBgxwuS4Bieyc+bMgRACvXv3xoQJE+Di4qI+Zmtri6CgINSuXdvkhli6+Pj4HJ+600cikeQ4Ub254+emDnPHN7QOXiPLuEaXL19GVpbxt7BsbGxQsWLFHMtFR0dDLjftC1kqlXLBBiKiQqJUqVKYOnUqPv74Y1y9etWkGAYnsj169AAABAcHo06dOrCxsTGpwsJKCIGAgACTzjVkyVBzx89NHeaOb2gdvEaWcY2ysrLg7e1tdPzY2FiDysnlclSqVMno+ED2cxQSERVq8kxAnk3alt34WQsmlUrx6NEj0883pFBSUhKcnZ0BAGFhYUhLS0NaWprOsqpyREREREQAsH37do3XQgg8fvwY8+fPR926dU2Oa1Ai6+bmhsePH8PT0xOurq46H/ZSPQRm6oS2RERERKRHIR8j265dO43XEokEHh4eaNKkCWbOnGlyXIMS2b///ls9I8GBAwdMrswUDx8+xMiRI7Fr1y6kpqaiZMmSWLFiBapXr56v7SAiIiIi0yiVSrPENSiRbdiwoc7/N7fnz5+jbt26aNy4MXbt2gUPDw/cuHEDbm5u+dYGIiIiooImFJkQcutsjxcmCoUCly5dQmBgYK7yOqPnkT18+HC2xxs0aGByY940bdo0BAQEYMWKFep9wcHBeRafiIiIiMxv6NChqFSpEj799FMoFAo0aNAAx48fh4ODA/788080atTIpLhGJ7K6KnpzTtm8sn37dkRERKBjx444dOgQ/Pz8MHDgQPTt21fvORkZGcjIyFC/TkpKyrP2EBERERWIQj5GdtOmTepluHfs2IE7d+7g6tWrWL16Nb799lscPXrUpLhWxp7w/Plzje3JkyeIiopCjRo1sGfPHpMaoc/t27excOFClCpVCrt378aAAQMwZMgQrFq1Su85U6ZMgYuLi3ozdSoiIiIiIsob8fHx6qkbd+7ciY4dO6J06dLo3bt3rqZONLpH9vWFEFSaNWsGW1tbDB8+HGfOnDG5MW9SKpWoXr06fvjhBwCvpv66fPkyFi1apJ7X9k2jR4/G8OHD1a+TkpKYzBIREVHhJs8Eshkja+nzyHp5eeG///6Dj48PoqKisHDhQgBAamoqrK2zeV85MDqRza6B165dy6twAAAfHx+UL19eY1+5cuXwxx9/6D1HJpNBJpPlaTuIiIiIyHS9evVCZGQkfHx8IJFI0LRpUwDAiRMnULZsWZPjGj204OLFixrbhQsXEBUVhc8++wyhoaEmN0SXunXraiXH169fR2BgYJ7WQ0RERGTR5Fn/3yurbzN+6XAAWLBgAYKCgmBnZ4eaNWvi5MmTBp23fv16SCQSrflh9Rk/fjyWLl2Kfv364ejRo+pOR2tra4waNcqktgMm9MiGhoZCIpForedeq1YtLF++3OSG6DJs2DDUqVMHP/zwAyIjI3Hy5En88ssv+OWXX/K0HiIiIqJ3zYYNGzB8+HAsWrQINWvWxJw5cxAREYFr167B09NT73l37tzBV199hfr16xtVX4cOHQAA6enp6n36hooayuge2ZiYGNy+fRsxMTGIiYnB3bt3kZqaimPHjuWqa1iXGjVqYMuWLfjtt99QsWJFTJo0CXPmzEG3bt3ytB4iIiIii6aatSC7zUizZs1C37590atXL5QvXx6LFi2Cg4NDth2TCoUC3bp1w4QJExASEmJwXQqFApMmTYKfnx+KFCmC27dvAwDGjBmDZcuWGd12FaMT2cDAQI0tICAAdnZ2JjcgJx988AEuXbqE9PR0REdHZzv1FhEREdG7LCkpSWN7fUrS12VmZuLMmTPqsaoAYGVlhaZNm+L48eN640+cOBGenp749NNPjWrX5MmTsXLlSvz444+wtbVV769YsSKWLl1qVKzXGT20YMiQIShZsiSGDBmisX/+/Pm4efMm5syZY3JjLJlEIsH9+/dNPreg4+emDnPHN7QOXiPLuEY2NjaIjY01Or6NjY1B5aRSqclTsUilefb8KhGRZcnKAjKzebo/69UY2Tdnaho3bhzGjx+vVTw+Ph4KhQJeXl4a+728vHD16lWdVRw5cgTLli3D+fPnjWo6APz666/45Zdf8N577+Gzzz5T769SpYre+gxh9Lf+H3/8ge3bt2vtr1OnDqZOnfrWJrLFihUr1PHzo47CHj8/6ijs8YFXfz2bU7ly5cwan4jobXb//n04OzurX+fVTE4vX77EJ598giVLlpj0u+bhw4coWbKk1n6lUomsLNMeVANMSGSfPXumcy5ZZ2dnxMfHm9wQIiIiItJDrni1ZXccr/Kx1xNZfYoVKwZra2vExcVp7I+Li1MvXPC6W7du4c6dO2jdurV6n1KpBPDqbti1a9dQokQJvfWVL18e//zzj9bMU5s2bUJYWFiO7dXH6ES2ZMmSiIqKwuDBgzX279q1y6hBv0RERERUMGxtbVGtWjXs379fPYWWUqnE/v37tXI8AChbtqzWsK/vvvsOL1++xNy5c3NcfGrs2LHo0aMHHj58CKVSic2bN+PatWv49ddf8eeff5r8PoxOZIcPH47Bgwfj6dOnaNKkCQBg//79mDlz5ls7rICIiIioQGXKgcxsbsFnGj9rwfDhw9GjRw9Ur14d4eHhmDNnDlJSUtCrVy8AQPfu3eHn54cpU6bAzs5Oa2iZq6srAMOGnLVt2xY7duzAxIkT4ejoiLFjx6Jq1arYsWMHmjVrZnTbVYxOZHv37o2MjAxMnjwZkyZNAgAEBQVh4cKF6N69u8kNISJS2bRpk8Y8g3nNzs5OPZ+hoeWjoqLM1h5VHURE+alTp054+vQpxo4di9jYWISGhiIqKkr9ANi9e/dgZWX0BFd61a9fH3v37tXaf/r0aVSvXt2kmEYlsnK5HOvWrcOHH36IAQMG4OnTp7C3t0eRIkVMqpyISJf09HS0aNHCbPGNTUqNSXqJiMzCwDGyxho8eLDOoQQAcPDgwWzPXblypcH1JCcnw9raGvb29up958+fx5gxY7Bz504oFKa136g0WyqV4rPPPlP3lHh4eDCJJSIiIiKd7t+/j9q1a8PFxQUuLi4YPnw4UlNT0b17d9SsWROOjo44duyYyfGNHloQHh6Oc+fOaT11RkRERETmIeRZEFn6+x+F3PQprMxpxIgRSE9Px9y5c7F582bMnTsX//zzD2rWrIlbt27B398/V/GNTmQHDhyIL7/8Eg8ePEC1atXg6Oiocbxy5cq5ahARERERvR0OHz6MzZs3o1atWoiMjIS3tze6deuGoUOH5kl8oxPZzp07A4DGyl4SiQRCCEgkEpPHOFi6+Ph4CCFMOlcikeQ4ebC54+emDnPHN7QOXiPLuEaXL182afJqGxsbg55sjY6O1rukIhHRO0suB+TZrOwlN37WgvwQFxeH4OBgAICnpyccHBzQsmXLPItvdCIbExOTZ5UXJkKIHOdI08eQJUPNHT83dZg7vqF18BpZxjXKysrSOVl2Tgxd1lYul+fZSjRERFTwXp/5wMrKCra2tnkW2+hElmNjiYiIiPJZphywyeYZfRPmkc0PQgiULl0aEokEwKvZC8LCwrSm9UpISDApvkGJ7Pbt29GyZUvY2Nhg+/bt2ZZt06aNSQ0hIiIiorfLihUrzBrfoES2Xbt2iI2Nhaenp3oZM13MMUZ2/PjxmDBhgsa+MmXK4OrVq3laDxEREZHFyswCbCTZH7dAPXr0MGt8gxJZpVKp8//zS4UKFbBv3z71a6nU6BERRERERPSWKRQZoVQqNenhEiIiIqK3giKHlb3e0lmjcmLwyl5///03ypcvj6SkJK1jiYmJqFChAg4fPpynjVO5ceMGfH19ERISgm7duuHevXt6y2ZkZCApKUljIyIiIqK3j8GJ7Jw5c9C3b184OztrHXNxcUH//v0xe/bsPG0cANSsWRMrV65EVFQUFi5ciJiYGNSvXx8vX77UWX7KlCnqZdBcXFxMnoqIiIiIyGJkZuW8vYMMTmQvXLiAFi1a6D3evHlznDlzJk8a9bqWLVuiY8eOqFy5MiIiIrBz5068ePECv//+u87yo0ePRmJionozdG5MIiIiIipcDB4jGxcXBxsbG/2BpFI8ffo0TxqVHVdXV5QuXRo3b97UeVwmk3EydSIiInqriCwlRJb+B+6zO2YJhg8frnO/RCKBnZ0dSpYsibZt28Ld3d2ouAYnsn5+frh8+TJKliyp8/jFixfh4+NjVOWmSE5Oxq1bt/DJJ5+YvS4iIiIiyr1z587h7NmzUCgUKFOmDADg+vXrsLa2RtmyZfHzzz/jyy+/xJEjR1C+fHmD4xo8tOD999/HmDFjkJ6ernUsLS0N48aNwwcffGBwxYb66quvcOjQIdy5cwfHjh1D+/btYW1tjS5duuR5XURERESWSGQoIdIV+rcMy+6Rbdu2LZo2bYpHjx7hzJkzOHPmDB48eIBmzZqhS5cuePjwIRo0aIBhw4YZFdfgHtnvvvsOmzdvRunSpTF48GB1Nn316lUsWLAACoUC3377rXHvygAPHjxAly5d8OzZM3h4eKBevXr4999/4eHhked1EREREVHemz59Ovbu3asxaYCLiwvGjx+P5s2b44svvsDYsWPRvHlzo+IanMh6eXnh2LFjGDBgAEaPHg0hBIBXYxsiIiKwYMECeHl5GVW5IdavX5/nMYmIiIgKE5GlgJDqv5Eusix7HtnExEQ8efJEa9jA06dP1VOlurq6IjMz06i4Ri2IEBgYiJ07d+L58+e4efMmhBAoVaoU3NzcjKqUiIiIiN4dbdu2Re/evTFz5kzUqFEDAHDq1Cl89dVXaNeuHQDg5MmTKF26tFFxTVrZy83NTd2Id4VEIjF5Ki+JJJu1kfMpfm7qMHd8Q+vgNbKMa2RjY4PY2Fij42c368nrpFIpMjIyjI5PRPQ2E+kKCEk2PbLplt0ju3jxYgwbNgydO3eGXC4H8Or7vkePHup1CMqWLYulS5caFbdQLFFrCYoVK1ao4+dHHYU9fn7UUdjjA0DFihXNGr9cuXJmmZOaiIgKTpEiRbBkyRLMnj0bt2/fBgCEhISgSJEi6jKhoaFGx2UiS0RERGTp5AogK5vJpuSW3SO7Zs0afPjhhyhSpAgqV66cZ3ENnn6LiIiIiMgUw4YNg6enJ7p27YqdO3dCocibxJuJLBEREZGFy3YO2f/fLNnjx4+xfv16SCQSREZGwsfHB4MGDcKxY8dyFZdDC4jeckf++QdZRk5noo+1VAqrNx4Ks3dwQIeOHfMkvoqdnR2ioqLyNOab8YmIKP9IpVJ88MEH+OCDD5CamootW7Zg3bp1aNy4Mfz9/XHr1i3T4uZxO4nIwmRlZqJZvYZmi3/wRO7+mtalQ4cOeR6TiKgwU2bKocxmdhllpjwfW5M7Dg4OiIiIwPPnz3H37l1ER0ebHItDC4iIiIjI7FJTU7F27Vq8//778PPzw5w5c9C+fXtcuXLF5JjskSUiIiKydFlKwEqZ/XEL1rlzZ/z5559wcHBAZGQkxowZg9q1a+c6LhNZIiIiIjIra2tr/P7774iIiIC1tbXGscuXL5s8RzkTWQPFx8dDCGHSuRKJJMeJ6s0dPzd1mDu+oXXwGpl2jeR5NMWJPunpGTh37lyO5WxsbAz6ooqOjlav+mIsqVSKcuXKmXQuEZElE+kKCKF/jKzIMO27fsGCBZg+fTpiY2NRpUoV/PTTTwgPD9dZdsmSJfj1119x+fJlAEC1atXwww8/6C3/urVr12q8fvnyJX777TcsXboUZ86cMXk6LiayBhJCICAgwKRzDVky1Nzxc1OHueMbWgevkWnX6MqlSybVZyip1Bre3t45ljN0WVu5XI5KlSqZ1JZLZn6vRERvkw0bNmD48OFYtGgRatasiTlz5iAiIgLXrl2Dp6enVvmDBw+iS5cuqFOnDuzs7DBt2jQ0b94cV65cgZ+fn0F1Hj58GMuWLcMff/wBX19ffPjhh1iwYIHJ74EPexERERFZOCFXQmRls8mNHyM7a9Ys9O3bF7169UL58uWxaNEiODg4YPny5TrLr127FgMHDkRoaCjKli2LpUuXQqlUYv/+/dnWExsbi6lTp6JUqVLo2LEjnJ2dkZGRga1bt2Lq1KmoUaOG0W1XYSJLRERE9JZISkrS2DIyMnSWy8zMxJkzZ9C0aVP1PisrKzRt2hTHjx83qK7U1FRkZWXB3d1db5nWrVujTJkyuHjxIubMmYNHjx7hp59+Mu5NZaNQJbJTp06FRCLB0KFDC7opRERERPlGninJcQOAgIAAuLi4qLcpU6bojBcfHw+FQgEvLy+N/V5eXgYPBRs5ciR8fX01kuE37dq1C59++ikmTJiAVq1aaT3olVuFZozsqVOnsHjxYlSuXLmgm0JERERkke7fvw9nZ2f1a5lMZpZ6pk6divXr1+PgwYPZrpZ45MgRLFu2DNWqVUO5cuXwySefoHPnznnWjkLRI5ucnIxu3bphyZIlcHNzK+jmEBEREeUrpUKS4wYAzs7OGpu+RLZYsWKwtrZGXFycxv64uLgcH+CdMWMGpk6dij179uTYwVirVi0sWbIEjx8/Rv/+/bF+/Xr4+vpCqVRi7969ePnypRFXQVuhSGQHDRqEVq1aZdt1rZKRkaE1PoSIiIiI/sfW1hbVqlXTeFBL9eBWdgsV/Pjjj5g0aRKioqJQvXp1g+tzdHRE7969ceTIEVy6dAlffvklpk6dCk9PT7Rp08bk92Hxiez69etx9uxZvWM83jRlyhSNsSGmTnVEREREZCkUmVaQZ7MpMo1P6YYPH44lS5Zg1apViI6OxoABA5CSkoJevXoBALp3747Ro0ery0+bNg1jxozB8uXLERQUhNjYWMTGxiI5OdmoesuUKYMff/wRDx48wG+//WZ0u19n0WNk79+/jy+++AJ79+7NdvzF60aPHo3hw4erXyclJTGZJSIiInpDp06d8PTpU4wdOxaxsbEIDQ1FVFSU+gGwe/fuwcrqfwnywoULkZmZiQ4dOmjEGTduHMaPH290/dbW1mjXrh3atWtn8nuw6ET2zJkzePLkCapWrarep1AocPjwYcyfPx8ZGRlaT7/JZDKzDWwmIiIiKggKuQQKif6VvRRy/ceyM3jwYAwePFjnsYMHD2q8vnPnjkl1mJNFJ7Lvvfee1ko9vXr1QtmyZTFy5Mg8n8KBiIiIiAoPi05knZyctNZmd3R0RNGiRQ1as52IiIjobaC0c4bS1kb/ceusfGyN5bDoRJaIiIiIAIXMCQpbW/3HJZn52BrLUegS2TfHaxARERHRu6nQJbIFRSKR4P79+yafW9Dxc1OHueMbWgevkWnXKEsuN6k+Q8nlCoOWM7Sx0X9L7HVSqVRrbLyhpFJ+pRHR20lpVwTKbB5mV1pl5GNrLAe/9Q1UrFixQh0/P+oo7PHzo46CiC8180ORdnYyhIWF5Vm8cuXK5VksIiJ6uzGRJSIiIrJwwq4IRDY9skJi2F2vt43Fr+xFRERERKQLe2SJiIiILJywc4TIZpVTIXk3U7p3810T5YF/ju5HpjzVrHXYSh1Qv+57uYphY2uLvUcO5Ul7rKVSWL3x0Jm9g0OexCYiIjIWE1kiE2XKU9Gwvb1Z6zi0JfeJcr369fOgJa/4+vpyCWgiogKgtLOH0k7/7xwlTFuitrDjGFkiIiIiKpTYI0tERERk4YSdPYS9/h5ZkY9tsSTskSUiIiKiQok9sgaKj4+HEKb9vSORSHKcCN/c8XNTh7njG1qHpV0jhVxhUluMoZAr8PTpUwCWc40uX76MrKwso+Pb2NigYsWKZotvaB3R0dGQm7jamVQq5YINRFQwZDIImf5ZC6BU5l9bLAgTWQMJIRAQEGDSuYYsSWru+Lmpw9zxDa3D0q7RpWjzTz4ttbFRt8dSrlFWVha8vb2Njm/IMra5iW9oHXK5HJUqVTIpvqlL5xIRkXkwkSUiIiKycMLOLvt5ZMW72SPLMbJEREREVChZfCK7cOFCVK5cGc7OznB2dkbt2rWxa9eugm4WERERUb6R2NtD4pDNls2MBm8zi09k/f39MXXqVJw5cwanT59GkyZN0LZtW1y5cqWgm0ZEREREBcjix8i2bt1a4/XkyZOxcOFC/Pvvv6hQoUIBtYqIiIgoH9nbQeKQTa/rOzpG1uIT2dcpFAps3LgRKSkpqF27ts4yGRkZyMjIUL9OSkrKr+YRERERUT4qFInspUuXULt2baSnp6NIkSLYsmULypcvr7PslClTMGHChHxuIREREZH5WDnaw8pRf4+sFd7NHlmLHyMLAGXKlMH58+dx4sQJDBgwAD169MB///2ns+zo0aORmJio3gydG5OIiIiICpdC0SNra2uLkiVLAgCqVauGU6dOYe7cuVi8eLFWWZlMBplMlt9NJCIiIjIbK3s7WGUzRtZKaf7VJi1RoeiRfZNSqdQYB0tERERE7x6L75EdPXo0WrZsieLFi+Ply5dYt24dDh48iN27dxd004iIiIjyhbWjPayzGSNrLd7NHlmLT2SfPHmC7t274/Hjx3BxcUHlypWxe/duNGvWrKCbRkREREQFyOKHFixbtgx37txBRkYGnjx5gn379jGJJSIioneK1MEOUkd7/ZuDnUlxFyxYgKCgINjZ2aFmzZo4efJktuU3btyIsmXLws7ODpUqVcLOnTtNqjevWHwiS0RERER5b8OGDRg+fDjGjRuHs2fPokqVKoiIiMCTJ090lj927Bi6dOmCTz/9FOfOnUO7du3Qrl07XL58OZ9b/j8WP7TAUkgkEpOn8pJIJAUePzd1mDu+oXVY2jWSZ2UBMO8MGfKsLHV7LOUa2djYIDY21uj4NjY2Zo1vaB1SqRSXLl0yKb5Uyq9MIioYNvZ2sLHX3+tqI88yOuasWbPQt29f9OrVCwCwaNEi/PXXX1i+fDlGjRqlVX7u3Llo0aIFRowYAQCYNGkS9u7di/nz52PRokVG158X+K1soGLFihXq+PlRR2GPb2wd1lJrM7bkf3V4eHgYXD4/rlHFihULdfxy5cqZNT4RkTm8fPnSoONvrmiqb1rSzMxMnDlzBqNHj1bvs7KyQtOmTXH8+HGddRw/fhzDhw/X2BcREYGtW7ca8hbMgoksERERkYWytbWFt7c3qlSpkmPZIkWKICAgQGPfuHHjMH78eK2y8fHxUCgU8PLy0tjv5eWFq1ev6owfGxurs7ypd9HyAhNZIiIiIgtlZ2eHmJgYZGZm5lhWCKE1TOxtXySKiSwRERGRBbOzs4OdnWmzEuhTrFgxWFtbIy4uTmN/XFwcvL29dZ7j7e1tVPn8wESWCkzUwb/xMiPdrHU4yezQolETs8S2lTrg0JZUs8R+vQ4iIqK8Zmtri2rVqmH//v1o164dgFcrp+7fvx+DBw/WeU7t2rWxf/9+DB06VL1v7969qF27dj60WDcmslRgXmakI7qkeR9OKncz3myx69d9z2yxiYiIzG348OHo0aMHqlevjvDwcMyZMwcpKSnqWQy6d+8OPz8/TJkyBQDwxRdfoGHDhpg5cyZatWqF9evX4/Tp0/jll18K7D0wkSUiIiJ6B3Xq1AlPnz7F2LFjERsbi9DQUERFRakf6Lp37x6srP635ECdOnWwbt06fPfdd/jmm29QqlQpbN261eyzzWRHIoQQBVZ7PkhKSoKLiwsSExPh7OycY/mMjAw8evQoH1pGG3fvzJce2Y4R75u1jneJr6/vW//gABFRTozNLch8uLIXERERERVKHFpgoPj4eJjaeS2RSHKcqN7c8XNTh7niK+QKo9tiLIVcgadPnxbaa2RsHfnxObp8+TKysoxfQcbGxsag20+mxje0DnPHB4Do6GjI5XKj40ulUi7YQERkBCayBhJCaE0ybChDlgw1d/zc1GGu+NJzp41ui7GkNlIEBAQU2mtkbB358TnKysoyaaoVQyfMNjW+oXWYOz4AyOVyVKpUyej4pi6dS0T0ruLQAiIiIiIqlJjIEhEREVGhZPGJ7JQpU1CjRg04OTnB09MT7dq1w7Vr1wq6WURERERUwCx+jOyhQ4cwaNAg1KhRA3K5HN988w2aN2+O//77D46OjgXdPCIiesslJiYiNdW8q/jRKw4ODnBxcSnoZlAhYvGJbFRUlMbrlStXwtPTE2fOnEGDBg0KqFVERPQuSExMxIIFC0ye6YKMY2Njg0GDBjGZJYNZfCL7psTERACAu7u7zuMZGRnIyMhQv05KSsqXdhER0dsnNTUVWVlZaNy4Mdzc3Aq6OW+158+f48CBA0hNTWUiSwYrVImsUqnE0KFDUbduXb1zOU6ZMgUTJkzI55YREdHbzM3NzaB5lokof1n8w16vGzRoEC5fvoz169frLTN69GgkJiaqN0PnxiQiIiKiwqXQ9MgOHjwYf/75Jw4fPgx/f3+95WQyGdeCJyIiInoHWHwiK4TA559/ji1btuDgwYMIDg4u6CYRERERkQWw+ER20KBBWLduHbZt2wYnJyf1EpEuLi6wt7cv4NYRERERUUGx+ER24cKFAIBGjRpp7F+xYgV69uyZ/w0iIiJ6w927d7Fp0yZcvHgRSUlJcHZ2RuXKldGxY0cUL14cADBp0iScP38eq1evhoODg844M2bMwNGjR7Fq1So4Ozub1JanT59i3759OHXqFB49egQrKysEBgaiU6dOCA0N1SqfnJyMlStX4vjx48jIyEDp0qXRu3dvlCxZUm8djx8/xqBBg5CVlYVZs2ahVKlSGsdv3ryJtWvX4ubNm0hPT4e3tzeaNWuGVq1awdra2qT3RaSLxT/sJYTQuTGJJSIiS3Ds2DEMHToUFy5cQNOmTTFgwAA0a9YMFy9exNChQ/Hvv/8CeNUhk5mZqX79pvT0dJw4cQJVq1Y1OYkFgBMnTmDTpk3w8fHBJ598gs6dOyMtLQ1jxozBvn37NMoqlUpMnDgRhw4dwgcffIBevXrhxYsX+Oabb/Do0SO9dSxdulRvQnrz5k2MGDECT548wUcffYTevXvDy8sLS5YswbJly0x+X0S6WHyPrKWQSCQmz4AgkUgKPH5u6jBXfHmW3Oi2GEueJcf9+/cL7TUyto78+BzZ2Nioh/gYw8bGxqzxDa3D3PEBQCqV4tKlS0bHl0r5lVzYPH78GLNmzYK3tzemTp2qMf9p69atMWrUKMyaNQvz5s1DeHg47O3tcejQITRp0kQr1okTJ5Cenq51B9JYlSpVwvLlyzXa0rJlSwwZMgRr165F06ZN1fuPHj2K6OhojBo1CnXr1gUA1KtXD/3798fatWsxYsQIrfhnz57F2bNn8dFHH2HDhg1ax1ULGU2dOhVOTk7q+keNGoX9+/ejX79+uXp/RK/jt6aBzD1/YH7MT2hp78Faav7bS9ZSa3h4eBhc3tKukaXFB6B3DmfG/59y5cqZvQ6yDJs3b0ZGRgYGDx6sNYm/i4sLBg0ahNGjR2Pz5s0YOHAgateujUOHDuHFixdwdXXVKH/o0CHY29sjPDw8V20KDAzU2mdjY4Pq1atj69atSE1NVQ9tOHr0KFxdXVG7dm2NdterVw8HDx5EVlaWxh9wcrkcv/zyC9q0aQNvb2+d9aempsLW1lZrGXl3d3c8fPgwV++N6E0WP7SAiIjIUp08eRKenp6oUKGCzuMVK1aEp6cnTp06BeDV8AKFQoEjR45olHv58iXOnTuH2rVra0whmZycrDE3ur4tPT09x7Y+f/5ca4rK27dvo0SJErCy0kwHSpcujYyMDK3Ec/v27UhJSUGnTp301lOpUiWkpqZiwYIFuH//Pp48eYJdu3bh+PHj6NixY47tJDIGe2SJiIhMkJKSgoSEBNSsWTPbcsHBwThx4gRSU1NRuXJluLu7q8ekqhw5cgRyuRwNGzbUOPeLL77AkydPcmxLly5d0LVrV73HHz16hOPHj6Nu3boaY1ufP3+u8y6Fahn4hIQEBAUFqcuuX78evXv31vuwGgA0b94c9+7dQ1RUFPbs2QMAsLKywmeffYaWLVvm+F6IjMFEloiIyARpaWkAkONUkKrjaWlpcHBwQP369bFt2zbExcXBy8sLwKthBa6urqhSpYrGuV9++SUyMzNzbIu+2/zAq4fIpk2bBltbW/To0UPjWGZmps6x2arhBBkZGep9K1euhLe3N5o3b55tW6ytreHt7Y2wsDDUq1cPNjY2OHz4MBYvXqw1jIEot5jIUoFxktmh3M14s9dBRGQOryeo2UlLS4NEIlHPRNCoUSNs27YNhw4dQmRkJOLj4/Hff/+hdevWWjMBlC9fPldtVCgUmD59Ou7du4fx48ejaNGiGsdtbW0hl2s/eJuVlQUA6mEIV69exYEDB/D9999rDUN408aNG7Fjxw4sXrxYfY3q16+Pb775BosWLUJ4eDin4KI8w0SWCkyLRtpP7RIRFRaOjo5wd3fHnTt3si0XExODokWLqns5S5YsCX9/fxw+fBiRkZE4fPgwhBBawwoAIDExEUqlMse22NnZ6ewZnj9/Pk6dOoUvv/xSq7cXANzc3JCQkKC1X7VPNcRg5cqVKF++PLy8vBAXFwcASEpKAvBqyMGTJ0/g6ekJANi5cycqV66s1Z7w8HAsW7YMcXFx8PX1zfE9ERmCiSwREZGJwsPDERUVhStXruh84OvKlSt48uQJ2rVrp7G/UaNGWLNmDWJiYnDo0CH4+vqidOnSWucPHz7c5DGyy5cvx759+9C3b1+dSTIAhISE4MqVK1AqlRo9rdevX4dMJoOfnx+AV4ssPHnyBH369NGKMWnSJDg6OmL9+vUAgBcvXuhMvhUKhcZ/ifICE1kiIiITtW/fHgcOHMCCBQswdepUjYUMXr58iQULFsDBwQGtWrXSOK9hw4ZYs2YN1q5di9u3b+t9UMvUMbKbN2/Gli1b0LFjR7Rp00bveXXr1sXRo0fVD4IBr3qBjxw5gvDwcHUv8qBBgzTGywLAxYsX8eeff6J3797w9/dX7/fz88P58+fVK5wBUM/UYG9vDx8fnxzfD5GhmMgSERGZyNfXF8OGDcOMGTPw+eefo1mzZurb73v37kVycjK+/vprrUTT29sb5cqVw4kTJwBAb4+pKWNkjx8/jhUrVsDX1xcBAQE4cOCAxvHQ0FC4ubkBAOrUqYMyZcpg7ty5uHfvHpydnbFz504olUqN5Lpq1apa9aSkpAB4NcXY60vUdujQATNnzsRXX32FiIgI2Nra4vDhw7h58yY+/vhjLvxBeYqfJiIiolyoW7cu/P39sXHjRuzZs0c9rtXW1hazZ89G8eLFdZ7XsGFDREdHo3Tp0nk6ZjQmJgbAqym3Zs2apXX8hx9+UCey1tbWGD9+PJYvX44dO3YgMzMTpUqVwtChQzV6WY3RqFEjODs7Y+PGjdi8eTNSU1Ph7++PgQMHcvotynMSIYQo6EaYU1JSElxcXJCYmGjQ2tUZGRk615eOj4+HqZdKIpHkuOKSuePnpg5zxze0Dl6jgr9Gvr6+uHHjhvqJZmPY2NgYtKrW5cuXTYpvaB3mjp+bOgyNHx0drfNJc0NIpVKuPGaE/2vvzuNjuv7/gb9uJovskSALIYgtQQRBYm2QhAhFLEHtfJTag2iiQe1iK1pLrUUsLb5t1VZFLVV8JEhCEmKNbGLJJsks798ffnM/GVRmkhmMvp+PRx+VO3fe58ydu7zPueeeSUtLw4YNG9CrVy+Nfjnvjz/+wMqVK9GhQwdMmTJFhzX8eDx+/Bj79+/H6NGjP/jhB5rmFkx3uEdWTUQEZ2fnMr33wYMH7z1+ecrQdXx1y+Bt9GFsI6lU+tY5K/9Jenq6TuOrW4au45enDHXjy2QyNGrUSOP4AHD9+vUyvY9pxtfXF0+ePMG2bdtQqVIlDB48+H1XibGPEieyjDHGmA4EBwcjODj4fVeDsY/a22c1/gD8+eefCAoKgpOTEwRBwMGDB993lRhjjDHG2Afgg09k8/Pz4eHhgbVr177vqjDGGGOMsQ/IBz+0oEuXLvyUI2OMMcYYe80Hn8hqqqioSGXSZuVP6DHGGGOMsY/LR5fILly4EHPmzHnf1WCMMfYRefr06fuuwkePtzEri48ukZ05c6bKnH05OTllno6IMcbYv5uZmRmMjIxe+3UsphtGRkYwMzN739VgeuSjS2RNTExgYmLyvqvBGGPsI2BtbY1x48ahoKDgfVflX8HMzAzW1tbvuxpMj3x0iSxjjDGmTdbW1pxcMfaB+uAT2by8PNy6dUv8+86dO4iNjYWtre0//n41Y4wxxhj7+H3wiezly5fxySefiH8rx78OGTIEW7dufU+1Yowxxhhj79sHn8h26NABRPS+q8EYY4wxxj4wH/wvezHGGGOMMfYmH3yP7IdCEAQ8ePCgzO993/HLU4au46tbBm+jD2MbGRkZIT09XeP4RkZGOo2vbhm6jl+eMtSNb2hoiOvXr2scX/lexhj7WAj0kd+3z8nJgbW1NZ4/fw4rK6tS1y8qKsKjR4/eQc0Y0z9OTk48vR1j7F9P09yC6Q4PLWCMMcYYY3qJE1nGGGOMMaaXOJFljDHGGGN6iRPZV0gkErUfemHs30QQBEgkkvddDcYYY0zEj6++wtDQENWqVYNcLn/fVWHsgyKRSPiJd8YYYx8Uviq9gaGhIV+wGWOMMcY+cDy0gDHGGGOM6SVOZBljjDHGmF7iRJYxxhhjjOklTmQZY4wxxphe4kSWMcYYY4zpJU5kGWOMMcaYXuJEljHGGGOM6SVOZBljjDHGmF7iRJYxxhhjjOmlj/7nq4gIAJCTk/Oea8IYY4yxj4Eyp1DmGOz9+egT2dzcXACAs7Pze64JY4wxxj4mubm5sLa2ft/V+FcT6CNvTigUCjx69AiWlpYQBEHr8XNycuDs7IwHDx7AyspK6/HfRRn6Hv9dlKHv8d9FGfoe/12Uoe/x30UZ+h7/XZSh7/HfRRm6jk9EyM3NhZOTEwwMeJTm+/TR98gaGBigWrVqOi/HyspKZwf8uypD3+O/izL0Pf67KEPf47+LMvQ9/rsoQ9/jv4sy9D3+uyhDl/G5J/bDwM0IxhhjjDGmlziRZYwxxhhjeokT2XIyMTFBZGQkTExM9LYMfY//LsrQ9/jvogx9j/8uytD3+O+iDH2P/y7K0Pf476KMd/EZ2Ifho3/YizHGGGOMfZy4R5YxxhhjjOklTmQZY4wxxphe4kSWMcYYY4zpJU5kGWOMMcaYXuJElrEPCD97+XF7/Pgx8vLy9DY+AKSlpeHRo0c6LYMxxtTFiaye0FWCk5aWhoSEBJ3EZuorKioCAAiCoNNkVlexHz58iEuXLukkdkm63DaJiYk4dOiQzsp48OABmjRpguTkZL2MDwDp6elo1KgRkpKSdFaGVCrVWeyEhASsXr1a5/vR77//rrP4AJCbm6vT+Ddv3sTq1at1WobynKcrOTk5KC4u1mkZ7MPAiWw5yOVyncbPz89Hbm4ucnJyIAiC1uOnpqaiUaNGiIiIwOXLl7UeH3iZ4Ozduxf79+/H9evXtR7/1q1bOHDgwDs7YeniApiYmIiRI0fi5MmTALSfzD59+hS3bt3CgwcPdLIfXbt2Db6+vvjpp5+QkZGh9fjA/4415f8VCoVW4xcVFSE4OBjx8fE62UYAcOfOHRgZGaFRo0Z6GR8Anj17BjMzM52VER8fjwkTJmi9V5mIIJPJMHbsWKSmpursOy4oKEBwcDDi4uJ0Eh94ec7z9fVFamqq1s9Hyu00fPhwnfa637hxA6NHj0Z+fr7Wj2Xg5Tk1MDAQGzdu1HnCzN4/TmTLKCkpCStXrkRaWppO4ickJKBXr15o3749GjRogJ07dwLQbiKVnJyM58+f4/nz51i9ejWuXLkivqaNcq5fv442bdpg6dKlGDt2LMLDw3H79u1yx1W6du0afHx8cPjwYTx+/FhrcZXu37+PLVu2YPny5WIPi7YvgFKpFOHh4di5cye2bduG8+fPi+Vo4zuIi4tDp06d8Omnn6JWrVpYv349AO3tR7du3UKnTp0QFBSEefPmwd7eXitxS0pKSsKUKVMQHByMcePG4f79+zAwMNDqBdDQ0BBSqRTVqlXTWsxXKRukBga6Oe3qOr6yDIVCASMjI63GVe6PGzZswJMnT2BhYaHV+IIgwNDQEDKZDNbW1iplapOpqSmKiorg5OSk9dhKJ06cQFFREapWrar185FyOwmCADs7OwDabzQCwLfffousrCyYm5trfX+VSqWIiIjAuXPncPToUWzfvp2T2Y8cJ7JlcOvWLXh7e2PatGlYvXq11pOohIQEtGvXDu7u7ggNDUX//v0xbNgwxMbGavXE1bhxY3Tt2hX9+vVDXFwcli9fjvj4eADlP8nfu3cPXbp0QUhICE6dOoUtW7bg0qVLyM7O1kbVcf/+fQQFBWHo0KHYsGHDGy8c5fkM169fR7t27bBp0yZs2rQJXbt2xfbt28tT5TcyMjJCkyZN0LVrV/z9999YuHAhzpw5A6D8SXNSUhJ8fX3RqVMnbNu2DeHh4Zg8eTKePn2qtUT5wIED8PPzw7JlyyAIAr777jtERkZi+fLlWumdjYuLg4+PD3Jzc2FkZITk5GQEBwfjyZMnWr0AFhUVwdjYWOsJSG5uLgoLC8UyioqKUFhYqLXkQNfxAeDJkyd4/vw5ACAvLw95eXlaTwyU+/qzZ88gkUi0Ghv437mgqKgINjY2KmVqU35+PgRBgKOjo9ZjlyxDV79WpdxvpFIprKysAOhuOynja7tBYWRkhJCQEFhaWuLhw4fYsWMHduzYwcMMPmKcyGooPz8fCxcuRPfu3bFmzRosWrQIS5Ys0Voy++TJE0yePBkDBw7E8uXLMWDAACxbtgytW7fG5s2bAWjnwJfL5ZDL5bh58yYCAwMRERGBpKQkrFq1Cq1bt0bfvn3LFf/o0aOoU6cOFixYAHNzc3Tp0gVNmzZFbGwstm/fLt5GL6tr166hYcOGWLJkidgC79mzJ0aNGiUmnGVN1u7cuYOgoCD0798fJ06cwOnTpxEREYGVK1ciPT1daydeZRxzc3O0bNkShw8fRnJyMlasWIEbN24gLCyszGMRiQirV69G+/btsXjxYjRr1gxjxoyBr68vsrKykJiYiJycnHJ/hqSkJFhYWICI0K5dO2zduhVnz57F7NmzERISIvYwl8WjR4/w2WefYcSIEdi8eTOio6MRGRmJFy9eiA2u8khNTcWRI0cAAAYGBsjOztZqApiWloYuXbqI+6NEIoG5uTnMzMwgCAJkMpnKUAlNy3706JFO4wNAVlYW+vTpg/nz56OoqAgWFhZiGQBeK6Msx0bJIVolE01tSE5OFs81MpkMz58/h7m5uco65T2eHz58iHPnzoGIIJFIdDIUTCaTif8WBEHsES+5vDySk5Nx5swZGBgYoKCgAI8fP4apqalYnrYZGxuLPb7aHKKn3Mc7d+6MQYMGYdSoUahatSrWrFnDyexHjBNZDRkYGKBZs2YICAjA2LFjsXv3bkRFRWktmZVKpXj27BmCg4MB/O/ArFmzJp48eQJAOycWAwMDVK5cGV5eXoiLi0PPnj0xe/ZsHDhwANevX0e3bt3KFZ+IcP/+fcTGxgIA5s+fj8OHD2Pfvn1Ys2YN+vfvj61bt5Y5/pUrV8Tt0bVrV5w7dw41atTAvXv3sGLFCnz55ZcANN9WMpkMW7ZsQZMmTcTf6a5UqRK8vb2RlpYGItLaiV0Zp3379rh8+TJcXFzw448/IjExEQEBAfj222/Fi6ymF1tBEJCRkQFLS0uV27bHjh1Dnz590KpVK0yaNAk3btwoU91lMhmICObm5igsLMSpU6dgaWmJo0eP4sSJE0hJSUFWVhbmz59fpvjAy+/YxsYGI0aMED9D+/btoVAoyp3IFhcX44svvsDcuXNx5MgRGBkZqfXdavI9ODo6wsLCAmvWrMGuXbuQnJyM6tWrA/jfLVxl76OBgQGePXum0WdwcnKCmZmZzuIDQOXKlVGnTh2cOnUKUVFRiImJgaurKwwNDcV1lNvMwMBA43GVKSkpWLJkifiAWkFBASpWrKiyjlwuL/NxsGbNGnTs2BHHjh0T61yhQgWVdcpzPMtkMgwcOBChoaE4f/68ToZ23Lt3D507dxa3UV5enpiMKxvrZd0+wMtrzNq1a9G+fXucPHkSZmZmkMvlYiKrDSkpKRg9erT4d2ZmphhfG9srPz8fBQUFMDAwABHB0tISJiYm+PXXX7Fr1y40atQI3377LSezHynD0ldhJZmammLIkCHiiaRv374gIoSEhICIEBYWBjs7OygUCty7dw81a9bUKL69vT127NiBOnXqAHh5EjcwMEDVqlVx7949lXXz8vLKPJZMefKWSCQ4deoU/P39sX//fsjlcjg7O+PMmTNwc3NDixYtyhTfz88P27dvR9++feHh4YH9+/fjwIED6N69u5jgbNu2DUFBQbC1tdX4YuLj44PTp09j06ZNEAQBO3bsQNWqVfH8+XOsWrUKhw8fRkJCAtzc3DSKa2hoiEaNGqFChQoqJ/IWLVrAyMgIjx8/Ltdtw4KCAhgaGsLY2FhcJpFIkJCQgJycHDRs2BC1a9fGkSNH0Lp1a/Hp5LJcbBs2bIhFixbB2toaOTk52LlzJ3bt2oX27dvj4sWLGD9+PLy8vNCgQQO1Yz579gw2NjZiUtCvXz+0b98eCQkJaNCgAaytrSGXy1GpUiXs2bMHnp6euHjxYpn2I1dXV4wYMQJ169YF8DJpMDQ0hKWl5RufbFcoFGpfFI2NjREeHo7w8HCsWLECd+/eha2tLYqKihATEwO5XA4TExPxzkVWVhbq1q2LWrVqqRVfLpdDIpHgyJEj6NOnD7755hvY2trijz/+EIdKWFhYQC6Xo6ioCAqFAlWrVsW+fftgaWn51thpaWnIyspC48aNcezYMQQHB2s1/qvWrVuHKVOm4NixY1AoFDh37hyaNm2K3NxcGBsbg4jE7VSlShUcP34ctra2asU+duwY5s6di4KCAkyePBkKhULs7VUqOdRA0+Ng5cqVePHiBYKDg7F3717Y2dnh6tWrcHFxQXZ2NgwMDGBubo6ioiLcv38fHh4eaNq0qdrxDQ0NsXHjRgwYMACzZ8/GsGHDUKFCBeTk5CAuLg5yuVzlzlB6ejpq164NV1dXtcswNTXF7du3ERISgp9++glZWVnibflXh2EIgoDCwsLXkvW3MTAwQHh4OAoLC9G1a1ccPHgQ9evXR0JCAmJiYvD48WOYmJjAzMwMBQUFePjwITw9PTU6b1y9ehU7d+5EQUHBa8lkeRPZmzdvYuTIkXBxccGMGTNQq1YtmJubY/HixWjevDn27NmDjRs3YtCgQVi3bh0MDAwQEhKis+EZ7N0TiCeuLDNlkikIAnbv3o0BAwYgNDQUkyZNQlRUFO7du4cffvjhtROzukpemJUzCyhvhS5cuBAmJiaYMGGCSu+IupS9T9u2bcOdO3eQmZmJgwcP4ty5c4iNjcW0adPQuXNnrFixQqOTYkl37tzBpUuXkJCQgPj4eOzbt098bfHixYiOjsaFCxfUiq9MDJRu3ryJjh07wsbGBk5OTjh+/Lj42oMHD1C/fn18//33CAkJUauuT548QUZGBoyMjFClShWV8VuCICA/Px8NGjTAwYMHxQvd33//jZYtW6oVH3g53jMsLAzTp09Hy5YtxRNpUVERQkJCsGvXLowdOxbHjx/H0qVLsWDBAtjZ2WHx4sVlblDMnj0beXl5uHLlCry8vLB48WLxtcDAQBgaGuLgwYNqJQixsbEYP3481q5di8aNG4OIUFRUhMjISKxbtw4dO3bE/v37xfXj4+MxcOBA/PTTT6hdu7badX5Tz2jJYyEgIACdO3fG1KlTAQBLly5F3759UaNGjVJjv7ofxcbGYurUqcjNzcXly5dhbGwMKysrFBYWQiqVQiKRwMTEBBKJBH///XepDVPlU9hEJO5DADBgwADs3r0brVq1Qrt27WBubi4mgQUFBbCwsEBgYCDc3d3fGj81NRUeHh5o164dpk2bBm9vbwBA//79sXfv3nLHB17eKj9//jwMDQ1Rs2ZNeHp6AgCmT5+OnTt3wsHBAcHBwXBwcBC/p4KCApiZmaFVq1aoX79+qWWUtHr1aixatAjjx4/H3r174eTkBH9/f+Tm5kIikUAikUAul+Px48eoU6eOSs+euoYNG4Zt27YBAGxtbWFpaYns7GwIgiB+30SECxcuqJVkpqenQyKRwNbWFhKJBCkpKfj0008BQJyxwNHREfn5+Xjx4gUqVKggNl4vX76s1r5aUkZGBvz8/GBubg5XV1f89ddfaNmyJYqLi2Fra4vi4mLk5eVBoVCgdu3amDdvnsYP5GVlZWHmzJniEDYXFxcUFBQgJycHRkZGMDMzw4sXL2BkZIQLFy5odEzn5+fj0KFDmDJlCtq1aweJRAIiQsOGDQEANjY2KC4uRn5+PgoLC1GvXj0MGDCg1LhSqRT9+vXDwYMH4ezsDCJCr169UKdOHYwbNw5hYWGQSqVYtmwZXrx4geHDh+Py5cuIjIzEoEGDNNo+7ANGrFwUCgXJ5XIiItq9ezcZGRlRvXr1yNDQkGJiYrQSn4goPDycunTpQkREs2bNIkEQKDY2ttzxT58+TYIgkIODA12+fFlcfuDAAUpJSSl3fCKijRs3UmBgIBUVFYnLJk+eTD169KC8vLxS35+YmEhRUVH06NEjleW//vorGRoaUpUqVej8+fPi8qKiIvL19aUjR46oVb/r16+Tp6cnNWzYkExMTOjrr78muVwufq9SqZTS09PJycmJbty4QUREM2fOJEEQKDMzU60y4uLiyMbGhv7zn//Q/fv3VV5TKBTUoUMHMjc3JwcHB7p06RIREf33v/8lLy+v19Z/k5SUFFq+fDlNmTKFdu/e/drrffr0odWrVxMRUXFxMRER9erVi2bOnCnuY28TGxtLRkZGNG3atNdeu3r1Ko0YMYIEQaDw8HDKzMykZ8+e0dy5c6lhw4aUkZFRanwiosePH4v/Vm77N+nUqRMtXryYiP53LFy9erXU+P+0H129epV8fX2pefPmNGfOHHr06BFlZGRQfHw83b59mzIyMl57z5vEx8eTn58feXp6kpOTE+3YsYOkUqn4+oABA6hRo0a0e/duKiwsLDXem5w8eZIMDQ3J19eXBg8eTBcuXBBf69evHzVo0KBc8a9du0Y1atSg5s2bk729PQUFBdHNmzfF10NDQ6lFixa0YMECevbsWZnKSE5Opv3791NBQYG4LCoqiuzt7cnQ0JBsbGyoY8eOVLduXapXrx61bNmSmjRpQu7u7hQfH19q7FmzZtGgQYNow4YN4nKZTEbTp08nQRBo/fr1lJGRQWlpaeJ3nZGRQU+ePFGr/teuXSMXFxdatmwZ5ebmkkwmI6KXx6CXlxfVr1+fli5dSsnJyfTgwQOKjY2l5ORkevjwoVr7kZJcLlc5NtPS0sjb25sEQaC2bdtSSEgIde/enUJCQqh///7Us2dPGjRokFrXhfv379O2bdvo22+/pcOHD4vL09PTKSwsjARBoE2bNlF+fj6lpqbSo0ePKDU1ldLS0lSO07dJT09X+Ts/P5+io6Opfv36JAgCNWnShLy9valmzZrk5uZG7u7u5O7uTk2aNKFr166puZVeHr9+fn40dOhQGj9+PK1Zs4aqVq1KQ4cOpf79+5MgCHTy5EkiInrx4gUNHTpUa9c29mHgRFYLFAqFeMLx9fUlW1tbjQ7Et1Fe0CMjI2n06NG0dOlSMjExof/+979aiV9cXEybNm0SEwF1khpNxcfHk7W1NS1ZsoS2b99O06dPJxsbG7W2UXJyMtna2pIgCDRz5kzKyspSeT06OpoMDAzI39+foqOjKTk5mcLCwsjJyUmtBDA+Pp7s7OwoNDSU4uPjKSoqigRBUHmvQqGgzMxMcnJyopSUFJo7dy5ZWFjQxYsX1fr8eXl55OfnR59//rm47MaNGxQTE0N37twhIqKtW7dSQECA2JhQfu/qJCTXrl2jatWqUceOHcnHx4cMDAxoyZIlKutMmDCBnJyc6M6dO3Tz5k2aM2cOVa5cWUzM3yYuLo5MTU3pq6++ErdHdnY23bp1S1zn7t27NG/ePKpQoQK5uLhQ48aNydHRka5cuVJqfKKX34NEIqFx48aJy17dF5UJg7e3N61bt45WrVql9rFQ2n6kTGa7dOlCv/zyi7j8bQn1q/W3s7OjyZMn086dO2nKlClkZGT0WmO2d+/e5ObmRj/88APl5uaqFbuk7Oxs6t69O61fv56aNm1KAwcOVClj2LBhVL9+/TLFv3v3LlWtWpXCwsIoLy+PfvvtN3JwcKC///5bZb2JEydS06ZN6euvv1Y7qVG6evUqVa5cmUaNGkWpqakq23f9+vVUpUoVmjRpknj8KRtdCoVC/PfbYjs6OlJgYCD16NGDJBIJfffdd+LrUqmUhg8fTjY2NirJmyYSExPJzs6Opk6d+to+RER069YtatSoEXXt2pVOnz5dpjKSk5PFc8uryeyjR4+oTZs21KhRI0pLSytT/GvXrlH16tWpbdu25OrqSlWrVqW1a9eKr2dkZNCoUaPIzMyMfv/9d3G5useC8jMIgkC9e/dWWZ6Xl0e7du0iDw8PCgwMFJeX/G5LNnD+ifJcoPTf//6XfH19qUePHnTkyBGxIT1o0CASBEHlc7CPDyeyWiKTyWjy5Mlq9w5pat68eSQIAllbW4s9dtqiyQmqrP744w+qXbs21alThzp06KDWNsrLy6Phw4fT0KFDae3atSQIAk2bNu21C8jvv/9O3t7eZG9vT/Xr16e6deuqlUBlZWVRu3btaOLEieIyhUJBAQEBdP78eYqJiaEHDx4Q0cuE0t3dnTp16kTGxsYqvdelKSwspDZt2tCVK1dIJpORv78/eXl5kaWlJbVs2ZK2b99ORPTGpKC0hsXdu3fJ1dWVpk+fLn6PmzZtInt7e0pKShKX3bhxg3x9fUkQBHJ3d6f69eurdcfg8ePH5OrqSp6enuKyYcOGUbNmzcjR0ZHatGmj0gOUlJREP/zwAx08eJDu3r1banwiotTUVGrRogU1b96cLCwsaPz48W/9/N27dycbGxsyNzdXqzGh7n4UExNDvr6+FBgYSHv37lWr7kQvk0s/Pz+aMGGCyvIOHTqIn6Xk3YiQkBBydHSkPXv2qF0G0ctzTGZmJtWtW5cePnxI+/fvJy8vLxo1ahR5eXnR8OHDiehlz6yTk5PG8devX08dOnRQ2eZdu3al9evX07Zt2+jYsWPi8tDQUKpVqxYtXrxY7fPHvXv3qHr16m/s1VdaunQpVatWjcLDw9VqiColJydT9erVaebMmWJ9Ro0aRREREa+tO3ToUKpYsSL9/PPPasdXCg0NpZCQECJ6ed78v//7P1q6dCmdOHGC7t27R0Qvk93GjRtTly5d1L4rpJSYmEimpqYqvYhv6plt2LAhNW7cWOxZVL5e2vkiJSWFatSoQdOnT6fCwkK6c+cORUREkJ+fn8r5Jzs7m0aMGEEWFhYafwYiojNnzpCjoyNVrFiRunXrpvJabm4u7d69m+zt7alfv37icmWjvbTP8E93Vq5cuUK+vr7UqVMncdspl7OPGyeyWiKTyej777/XynCCN7l06RIJglDqrbUPWXZ2NqWnp9PTp0/VWr+goIDWrl0r3irfs2fPPyYhjx8/pqSkJIqJiXljT8mbPH78mBYsWEBJSUnisrlz54q3vapVq0b+/v50+vRpyszMJEEQyMTEROOGSnp6OlWuXJmOHTtGkydPJn9/f7p69SodPnyYQkNDyd7enn766SeNYhK9vMAtWrSIAgICVG7zKntoS94SJnp5oTh48CCdPXtWo1ucX3zxBbVp04YiIyPJy8uLAgICaMOGDXTgwAHy9vam6tWrU3Jyssb1V36GnTt3Up8+fejcuXO0Z88eMjU1VUlmX02U+vbtSxUqVKDr16+rVYYm+9HVq1epWbNm1KtXL7V7NNPT06lFixb0559/qtR32LBhNHDgQHG9kr1IQ4YModu3b6sVX0l5gR84cKCYXBw6dIgqVapElpaWtHHjRnHdwYMHaxx/3bp1VKtWLfHCr2w8d+rUiby8vKhKlSoqZURERGh0i/aXX36hrl27EtHLHrjw8HD69NNPaeTIkbR582ZxvaioKKpRowZNnjyZHj58WGpcqVRKU6dOpZEjR9KLFy/E5YMGDaIuXbpQQEAAffnllyrn5j59+pCzs7NaQ5tKCggIoOXLlxMRUevWrcnHx4eqVatGDRs2JD8/P4qLiyOilz2zzs7O1KtXL7V6GIleNqy7detGgYGBNGDAAKpYsSKdOHGCiN6czDZr1oxcXFzEBLo0UqmUvvrqK+rRowfl5+eLyw8dOkQ2NjZio10pOzub+vXrRw4ODirrl0ahUNDFixepTZs2dPLkSXJycqIePXqIryuHGu3evZtq1aql0jNbmtLurMTGxpKvry/5+/vTgQMHxOXvorOGvT+cyGqRLm7Ll6TpSfdj8Opn3r17NwmCQKGhoWIPglQqFW/RayonJ0f8d3R0NAmCQHv27KHs7Gw6ffo0eXl5UWRkJBERrVixokwNCYVCQf3796cvvviCunXrptLD8eDBAxo0aBCNGTOGZDKZxvvQ6dOnKSwsTGWZXC4nFxcXsVeirPtlyZP/lClTyN7engIDA18b++bu7k5DhgzROL4ysbt3755K71h0dPRryWzJseh//fWX2r29SursR8XFxZSfn093797VOH7JxpDyNmlERAR99tlnKuupOw7zbQYPHix+5yNGjKCKFSuSm5sbDR8+nM6ePVvmuCkpKeTj40Ourq7Uu3dvEgSBDh48SAqFgjIyMmjChAnUoUOH175/dc2ZM4datWpFRC/HOXfo0IEmTpxInTt3piZNmtD06dPFdefPn09ubm5qj0FPTk6mU6dOiX/PmzePDAwMaNy4cTRnzhyqVKkS9ezZU+UWtiaNOaVRo0bRxIkTacGCBeTn50cPHz4kuVxO+/fvJ39/fxo6dKjYALpz545GjYlr167RwIED6dixY5ScnEzDhg2jihUrirfFX72drhxmoG4ZUqmUdu7cSatWrVJZnpWVRc7OzpSQkPDae7Kyssq0nYqLiykgIIDu3r1LR48epSpVqlDfvn1p5MiRNGXKFJLJZFRQUEDbtm2jhg0bqtVgUffOijKZ7datG+3bt0/jujP9w4ks0wslkzxlwjlt2jRKTU2lyZMnU69evSgvL69cjYm7d+++Nt4yMDCQgoKCiKh8rfpLly6Rubk5CYLw2i3NqVOnUrt27dSu+6sXNCXl++VyOdWsWVPlVvDvv/+u9kNXeXl5lJOTQ8+fP1dZHhUVRT/99JNYjrIevXv3puDgYLViK8XExFBgYOAbG2cymYx2796tkszKZDLatm2bWmN63+Zt+9GkSZOoR48eKsMANFVyHwkPDyd/f3/x7wULFtCyZcuouLi4TPup8j1bt26lyMhI+vzzz8nR0ZFSUlJo//79VLt2bRozZgy9ePGizMdBSkoK7dmzhyIjI1/7ThctWkQeHh4qvZ6aOH78OPn6+tL3339PnTt3FpOXZ8+eiUluybsd2dnZb42XnZ1NCQkJr915uHPnDg0cOFBlHOyFCxdIEAT666+/NKpzfn6+yv6wcOFC8vDwoN69e9OiRYtU1l21ahW5uLiofUfoTUo+N5CYmCgOgzh+/DgRvdy/ZDKZWKd/OheUlJmZKe4PJbepcllBQQHVrFlTZYhQeRpERC+3m4eHBx08eJCIXh7vyvNfyc9YUFCg0pnwNrq+s8L0FyeyTG/oeoaIkuRyOb148YL69etH8+bN00rMP//8kwRBoG7duom3IIlePog1cuTIUh9mIXrz+LCSSYtUKqW8vDxydXUVn2hXzrCQmppaavw3PXlf8mL5apKnUCgoODhY5UGw0sTGxpKpqSnNmDFDJU7JJFAqlaoMM5gwYQIZGhpq3FP6Jm/bj7Qxno5nGnnp1STrxo0b5OTkRG5ubtSpUyeV1+7fv09mZma0a9cucdnb9iXlTCONGjUiY2Nj+vrrr1XKU/Z8K7/rM2fOUOPGjTXaf65fv06BgYF0+vRpleEBbdu2JUEQaPDgwSrH7JUrV8jNze21W/Rvo1Ao3pqMJiUlicmssmc2NDSUdu7cqdaxdv36dapXrx6tWbNGZf2Sjd60tDSqUqWKeE4KDw8nQRAoIyOjTA0i5ecZO3Ys/fjjj0T0csYOOzs7srOz07jRW5Ku76ww/cSJLNMrupwh4lWzZs2i6tWrq9w2Lq/Tp0+Tk5MTtWjRgkaMGEGfffYZWVtbqzXes7TxYUT/S8Br165Nly9fprlz56r9UJS6T94rSaVSioiIIEdHR7XHyF69epXMzc1fe+DnTb2gMpmMdu3aRYIgUMWKFTV6wK40PNPI25VnphEi3U6Zp+5MIyWFhYVR+/bt1R7a8bbp8tLT06lVq1ZkYWFB69atE3s5Z8yYQc2bN1d7WrLExESaOHEiBQYG0pw5c/5xBghlMlulShXq1q2b2g8U37hxgypWrEhTpkx54zhaZZKfnp5O9vb2dPfuXZo/fz5ZWFio/UDxvXv3aPPmzbRs2TKx11hp3rx5NGnSJBo8eLDY6Dp79ixJJBIaMGCAWvH/ia7vrDD9woks0zu6niFi7969NG7cOLKzs9PJE683b96kiIgI6tSpE33++edqJbHqjg9T8vT0JC8vLzI2NlbroqTOk/clk4Njx45RUFAQOTg4qL2N0tLSyMHBQbzdLpPJaNKkSRQYGEj169enFStWqAwdkMlkNGLECLK0tHzj+L3y4plG3q4sM40Q6XbKPHVmGikZ49atWxQREUGWlpZqJ+HqTJeXl5dHvr6+VKdOHXJwcKDOnTuTnZ2d2neGrl27RlWqVKHg4GD6z3/+Q8bGxjR79myVdUp+x/Hx8eTs7Ey2trZq9erL5XIaPXo0DRs2TPz7zz//pM2bN1NiYqLKA7cFBQXk4eFB/v7+ap8vlJ+hRo0a1Lp1a3JzcyMjIyPatm2b+PqePXvIzMyM6tSpo9KIO3PmDCUmJqpVxtvo+s4K0x+cyDK9o+sZIuLi4qhv3746SZ5KKvmjC6VRd3yYTCaj7Oxssra2JolEovbFW90n74leXkCSk5NpxowZGo1ZTUtLo549e1Lz5s3p4MGDFBAQQB07dqSpU6fSuHHjqGbNmjRixAix9+jw4cNUu3ZtrSeBSjzTSOk0nWlE11PmqTvTyNmzZ+n27dvUr18/qlu3rkbfcWnT5a1bt05c98iRI7RixQrasmWL2g9dpaSkkIuLC82cOVNcNnv2bBo7duxrw4uUPY+TJk0iIyMjtWfqkMlk1KZNGzGxbN++PTVr1oysra2pdu3aKj3NDx48IEEQyNjYWO3GinIarxkzZlBhYSFlZWXRnDlzyNPTU5zftrCwkGbOnKmV4TT/5F3eoWMfLk5kmV7S9QwR6oxXfdfUncEhKyuLjhw5ojIOVx3qPnmvnIpHnQdNXvXo0SMaPHgwmZqaUufOnVVup+7cuZNsbGzot99+I6KXyXVZJ31XF880ol26njKPSL2ZRubMmUPFxcV05swZtaenUnrbdHnTpk0jBwcHio6O1iimkkwmo6VLl9Lnn3+u8jDlyJEjydvbm7y8vGjMmDEqD4QmJiZSYGCgxr2MvXr1olWrVtGsWbPIz8+Pbt26RVKplFauXEk+Pj40Z84cksvlVFBQQAsXLlS7UVpcXEyzZs2iHj16qIwdPnbsGDk4OJRploPy0PWdFfbh40SWMT1T2gwOPXv21Gjex1eV9uR9VFSUyk+vaio1NZVmzpwpzpFZMpl0dXWl0NDQMsdm75+up8wrqbSZRspC3enypFJpmYZ4PHjwQGX2hK+//pokEgmFh4fTN998Q15eXuTr66vSiNPkyXtlncaMGUNNmjShgQMH0vr161XWCQ0NpQYNGogNVnUb7srG6969e2n+/Pkqrz179oycnZ3feY+oru+ssA+fIRhjekUikYCIoFAo0L9/fwiCgM8++ww///wzbt26hcuXL8PMzKzM8Q0MDEBEEARB/BsAvvrqK8ybNw8xMTEwNCz7qcPJyQlhYWGoUKECAEAQBBARnjx5gsqVK8PT07PMsdn7Z25uDgCQy+UwMDBAv379QEQYMGAABEHApEmTEBUVhXv37mH79u0wMzMT9zVN1ahRAzVq1AAAKBQKFBcXw8LCAo0bNy5z/QVBwNSpU9GhQwcUFBRg9OjR4mvVqlWDvb09Ll26BIlEona95XI5JBKJGKNatWoAgOzsbGRnZ+PXX39FQEAAAKBTp05wd3dHbGysuMzCwuKt8fPz86FQKEBEsLKyAgAsW7YMPj4+2LVrl7iNlPz8/HD8+HHk5eWhYsWKMDIyKvUzxMbGYtasWdi7dy+CgoLE41d5rlCeE6RSqfiev//+Gy1btiw1dnlIJBIMHz68zPsQ038G77sCjDHNCYIgJoD9+vVD27ZtkZWVhZiYGDRp0qTc8YkIAGBoaAhnZ2dERUVhyZIluHz5Mjw8PMod38rKCsbGxuLfgiDgm2++wePHj9G6detyx2fvnzJxUza4oqOjsXLlSvj6+mL16tWYNWsWzM3NtZaAGBgYYMGCBfjrr7/Qp0+fcsVq3rw5Dh8+DADYsGED4uPjxdekUinq1q0LmUymVqykpCSsXLkSaWlpr71mZ2eH+fPnIyAgQGycymQyeHp6omrVqmrFT0hIQK9evdC+fXs0aNAAO3fuhFwuh5mZGdavXw93d3dER0fj6NGjyM/PBwAcPXoUNjY2MDExUauMq1evwsfHB25ubjA1NRWTWLlcDkEQIJVKkZeXJ5YLAF9++SW8vb2RlZWlVhnlwUnsv9x76wtmjJWbPj95rxQdHU2jR4+mihUr8tPGH6F38UCOrmYaKc90eURvn8FBuU1eHaf95ZdfUsuWLdX6VbN/mjJPuQ3kcjnFxcWRp6cnVa9enTw8PCgoKIhsbGzUfghLnSnzFAoFZWVlkZOTE6WkpNDcuXPJwsJCrWn/GCsvTmQZ02Mfw5P3V69epcDAQI0fTmP6Q9cNLl3ONFKW6fKINJ8yLz4+niIiIsjKykqtbaTplHkbNmygr776ihYtWqT29FfqTJmn/GW1wsJCatiwIXXq1ImMjY21Ou8zY28jEP3/e4iMMb1EJcaz6kJ+fr447lFXiouLVYYasI+LXC7H1q1b0axZM60MfXkTqVSq1ljPslIoFAD+N2a8NC9evMCWLVtgZ2eHfv36Ye/evejfvz9CQ0Mxffp0VKpUSVz3/v37mDRpEm7evIno6Gi1hu9kZGSge/fuiIqKQtu2baFQKGBgYIDhw4ejuLgYO3bsAKA6PldT6enpGDt2LB48eICIiAisW7cOUqkUTZo0QWFhIX777Tf4+voiIiIChoaGqF69OoyNjXHx4sVyjVNmTBOcyDLGGNM5XTe4PkSvNgL37NmDkJAQTJ06FWFhYbCzs4NcLkd2djaKi4sBQHwQTB3JycmoU6cOgP8l8rNmzRIfpFPKzc2FpaUlAM2/h7S0NISFhWHfvn1o06YNoqOjYWdnBwDYtWsXxo0bhx07diAwMBCrVq1C586d4ebmpnZ8xsqLZy1gjDGmc/+2JBZQfwaHO3fuIDo6WnyISl3KJFahUIi90USEzMxMcZ2FCxfCxMQEEyZMgKGhocbfg6OjIxYuXIiqVauiU6dOsLOzE5PhAQMGIDIyEqdPn0ZgYCC++OKLMvf+MlZWnMgyxhhjOvS2KfNu376NixcvapzElvS+p8xTDiPgJJa9Dzz9FmOMMaZj/zRl3pUrV7QydzK9xynz2rZtW+74jJUV98gyxhhj74AgCJDL5Zg2bRpOnjyJ2NhYNGrUSCuxlb2wRkZG2LhxI6ysrHD27Fk0bdpUK/FL2r17N06ePIl9+/bhxIkTr/3gAmPvEvfIMsYYY++Qu7s7rly5opMn+/39/QEA58+fR/PmzbUeHwDc3NyQmpqKM2fO8C/xsfeOZy1gjDHG3iGeMo8x7eFEljHGGGOM6SUeWsAYY4wxxvQSJ7KMMcYYY0wvcSLLGGOMMcb0EieyjDHGGGNML3EiyxhjjDHG9BInsoyx904QBBw8eFCnZZw6dQqCIODZs2c6LUdXXFxcsHLlyvddDcYY+6BwIssY06n09HSMHz8etWrVgomJCZydnREUFIQTJ06I66SlpaFLly46rYePjw/S0tJgbW0NANi6dStsbGxKfd/WrVvFnxeVSCSoWLEiWrZsiblz5+L58+dar6e69WKMMcY/UcsY06G7d++idevWsLGxwdKlS9GoUSNIpVIcPXoU48aNw82bNwEADg4Ob40jlUphZGRUrroYGxuXWs4/sbKyQmJiIogIz549w/nz57Fw4UJs2bIF586dg5OTU7nqxhhjrGy4R5YxpjNjx46FIAi4ePEievfujbp168Ld3R1TpkzBhQsXxPVKDi24e/cuBEHAnj170L59e1SoUAE7d+4EAGzevBnu7u4wMTGBo6MjvvjiC5X3xMbGijGfPXsGQRBw6tQpAKpDC06dOoVhw4bh+fPnYm/r7Nmz//FzCIIABwcHODo6okGDBhgxYgTOnz+PvLw8TJ8+XVxPoVBg4cKFqFmzJkxNTeHh4YEff/xRfF1Zh0OHDqFx48aoUKECWrVqhbi4OPH1t9WroKAAw4cPh6WlJapXr44NGzaU5WthjLGPBieyjDGdePLkCY4cOYJx48a98ecyS7t9HhYWhokTJ+LGjRvw9/fHd999h3HjxmH06NG4fv06fv75Z7i6upapbj4+Pli5ciWsrKyQlpaGtLQ0hIaGahSjSpUqGDhwIH7++WfI5XIAwMKFC7F9+3asW7cO8fHxmDx5MgYNGoTTp0+rvHfatGlYtmwZLl26hMqVKyMoKAhSqbTUei1btgzNmzdHTEwMxo4di88//xyJiYll2gaMMfYx4KEFjDGduHXrFogI9evXL9P7J02ahF69eol/z5s3D1OnTsXEiRPFZV5eXmWKbWxsDGtra7Gntazq16+P3NxcZGdnw9raGgsWLMDvv/8Ob29vAECtWrVw9uxZrF+/Hu3btxffFxkZic6dOwMAtm3bhmrVquHAgQPo27fvW+vVtWtXjB07FgAwY8YMrFixAidPnkS9evXK/BkYY0yfcSLLGNMJIirX+5s3by7+OzMzE48ePULHjh3LWy2tUn5GQRBw69YtFBQUiAmqUnFxMTw9PVWWKRNdALC1tUW9evVw48aNUstr3Lix+G9lspuZmVmej8AYY3qNE1nGmE7UqVMHgiCID3RpquRwBFNT07eua2DwcpRUyeRZKpWWqVxN3LhxA1ZWVrCzs0NKSgoA4NChQ6hatarKeiYmJlop79UH3gRBgEKh0EpsxhjTRzxGljGmE7a2tvD398fatWuRn5//2uuazOdqaWkJFxcXlSm7SqpcuTKAl9N4KZV88OtNjI2NxbGtZZGZmYldu3bh008/hYGBAdzc3GBiYoL79+/D1dVV5T9nZ2eV95Z80O3p06dISkpCgwYNtFIvxhj7N+EeWcaYzqxduxatW7dGixYtMHfuXDRu3BgymQzHjx/Hd999p9btdKXZs2djzJgxqFKlCrp06YLc3FycO3cO48ePh6mpKVq1aoVFixahZs2ayMzMRERExFvjubi4IC8vDydOnICHhwfMzMxgZmb2xnWJCOnp6eL0W3/99RcWLFgAa2trLFq0CMDLZDs0NBSTJ0+GQqFAmzZt8Pz5c5w7dw5WVlYYMmSIGG/u3Lmws7ODvb09wsPDUalSJXz66aca14sxxv7tuEeWMaYztWrVwpUrV/DJJ59g6tSpaNiwITp37owTJ07gu+++0yjWkCFDsHLlSnz77bdwd3dHt27dkJycLL6+efNmyGQyNGvWDJMmTcK8efPeGs/HxwdjxoxBv379ULlyZSxZsuQf183JyYGjoyOqVq0Kb29vrF+/HkOGDEFMTAwcHR3F9b7++mvMmjULCxcuRIMGDRAQEIBDhw6hZs2aKvEWLVqEiRMnolmzZkhPT8cvv/wCY2NjjevFGGP/dgKV94kMxhhjajl16hQ++eQTPH36lH+9izHGtIB7ZBljjDHGmF7iRJYxxhhjjOklHlrAGGOMMcb0EvfIMsYYY4wxvcSJLGOMMcYY00ucyDLGGGOMMb3EiSxjjDHGGNNLnMgyxhhjjDG9xIksY4wxxhjTS5zIMsYYY4wxvcSJLGOMMcYY00ucyDLGGGOMMb30/wBfx8YCa5jg9wAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import sys\n", "sys.path.insert(1, \"grovers/qiskit\")\n", @@ -1243,148 +270,9 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Phase Estimation Benchmark Program - Qiskit\n", - "... execution starting at Sep 17, 2024 16:03:20 UTC\n", - "************\n", - "Executing [3] circuits with num_qubits = 3\n", - "************\n", - "Executing [3] circuits with num_qubits = 4\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 16, 0.316\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 19, 0.261, 6.0\n", - "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.006, 33.621, 1.356 secs\n", - "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.841, 0.788\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 5\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 27, 0.353\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 31, 0.3, 12.0\n", - "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.009, 36.936, 1.31 secs\n", - "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.411, 0.327\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 6\n", - "************\n", - "Executing [3] circuits with num_qubits = 7\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 41, 0.377\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 45, 0.326, 19.333\n", - "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.013, 66.297, 1.326 secs\n", - "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.074, 0.023\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 58, 0.395\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 63, 0.348, 29.333\n", - "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.015, 26.614, 1.827 secs\n", - "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.024, 0.0\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 8\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 78, 0.408\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 84, 0.365, 41.333\n", - "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.011, 31.955, 1.356 secs\n", - "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.019, 0.004\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 101, 0.418\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 108, 0.378, 55.333\n", - "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.015, 42.38, 1.382 secs\n", - "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.007, 0.0\n", - "\n", - "... execution complete at Sep 17, 2024 16:07:55 UTC in 274.317 secs\n", - "\n", - "Sample Circuit:\n", - " ┌───┐ ░ ░ ┌──────────┐ ░ ┌─┐ \n", - "q7889_0: ┤ H ├─░─────────────────────────■────░─┤0 ├─░─┤M├─────────\n", - " ├───┤ ░ │ ░ │ │ ░ └╥┘┌─┐ \n", - "q7889_1: ┤ H ├─░──────────────────■──────┼────░─┤1 ├─░──╫─┤M├──────\n", - " ├───┤ ░ │ │ ░ │ inv_qft │ ░ ║ └╥┘┌─┐ \n", - "q7889_2: ┤ H ├─░───────────■──────┼──────┼────░─┤2 ├─░──╫──╫─┤M├───\n", - " ├───┤ ░ │ │ │ ░ │ │ ░ ║ ║ └╥┘┌─┐\n", - "q7889_3: ┤ H ├─░────■──────┼──────┼──────┼────░─┤3 ├─░──╫──╫──╫─┤M├\n", - " ├───┤ ░ ┌──┴──┐┌──┴──┐┌──┴──┐┌──┴──┐ ░ └──────────┘ ░ ║ ║ ║ └╥┘\n", - "q7889_4: ┤ X ├─░─┤ U^1 ├┤ U^2 ├┤ U^4 ├┤ U^8 ├─░──────────────░──╫──╫──╫──╫─\n", - " └───┘ ░ └─────┘└─────┘└─────┘└─────┘ ░ ░ ║ ║ ║ ║ \n", - " c166: 4/═══════════════════════════════════════════════════════╩══╩══╩══╩═\n", - " 0 1 2 3 \n", - "\n", - "Phase Operator 'U' = \n", - " ┌────────┐\n", - "q: ┤ P(π/2) ├\n", - " └────────┘\n", - "\n", - "Inverse QFT Circuit =\n", - " ┌───┐ ░ »\n", - "q7960_0: ┤ H ├─────■───────────■───────────■────────────■───────░──────»\n", - " └───┘┌────┴─────┐ │ │ │ ░ ┌───┐»\n", - "q7960_1: ─────┤ Rz(-π/2) ├─────┼───────────┼────────────┼───────░─┤ H ├»\n", - " └──────────┘┌────┴─────┐ │ │ ░ └───┘»\n", - "q7960_2: ─────────────────┤ Rz(-π/4) ├─────┼────────────┼───────░──────»\n", - " └──────────┘┌────┴─────┐ │ ░ »\n", - "q7960_3: ─────────────────────────────┤ Rz(-π/8) ├──────┼───────░──────»\n", - " └──────────┘┌─────┴─────┐ ░ »\n", - "q7960_4: ─────────────────────────────────────────┤ Rz(-π/16) ├─░──────»\n", - " └───────────┘ ░ »\n", - "« ░ »\n", - "«q7960_0: ─────────────────────────────────────░──────────────────────────────»\n", - "« ░ »\n", - "«q7960_1: ─────■───────────■───────────■───────░──────────────────────────────»\n", - "« ┌────┴─────┐ │ │ ░ ┌───┐ »\n", - "«q7960_2: ┤ Rz(-π/2) ├─────┼───────────┼───────░─┤ H ├─────■───────────■──────»\n", - "« └──────────┘┌────┴─────┐ │ ░ └───┘┌────┴─────┐ │ »\n", - "«q7960_3: ────────────┤ Rz(-π/4) ├─────┼───────░──────┤ Rz(-π/2) ├─────┼──────»\n", - "« └──────────┘┌────┴─────┐ ░ └──────────┘┌────┴─────┐»\n", - "«q7960_4: ────────────────────────┤ Rz(-π/8) ├─░──────────────────┤ Rz(-π/4) ├»\n", - "« └──────────┘ ░ └──────────┘»\n", - "« ░ ░ ░ \n", - "«q7960_0: ─░───────────────────░───────░─\n", - "« ░ ░ ░ \n", - "«q7960_1: ─░───────────────────░───────░─\n", - "« ░ ░ ░ \n", - "«q7960_2: ─░───────────────────░───────░─\n", - "« ░ ┌───┐ ░ ░ \n", - "«q7960_3: ─░─┤ H ├─────■───────░───────░─\n", - "« ░ └───┘┌────┴─────┐ ░ ┌───┐ ░ \n", - "«q7960_4: ─░──────┤ Rz(-π/2) ├─░─┤ H ├─░─\n", - "« ░ └──────────┘ ░ └───┘ ░ \n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import sys\n", "sys.path.insert(1, \"phase-estimation/qiskit\")\n", @@ -1404,226 +292,9 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "HHL Benchmark Program - Qiskit\n", - "... execution starting at Sep 17, 2024 16:22:57 UTC\n", - "************\n", - "Executing 3 circuits with 4 qubits, using 1 input qubits and 1 clock qubits\n", - "************\n", - "Executing 3 circuits with 5 qubits, using 1 input qubits and 2 clock qubits\n", - "************\n", - "Executing 3 circuits with 6 qubits, using 1 input qubits and 3 clock qubits\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 76, 0.252\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 114, 0.307, 50.0\n", - "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.003, 43.899, 1.378 secs\n", - "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.937, 0.374\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 148, 0.263\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 212, 0.317, 100.0\n", - "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.003, 26.937, 1.484 secs\n", - "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.9, 0.107\n", - "\n", - "************\n", - "Executing 3 circuits with 7 qubits, using 2 input qubits and 2 clock qubits\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 225, 0.275\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 315, 0.323, 152.0\n", - "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.004, 33.367, 1.604 secs\n", - "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.889, 0.008\n", - "\n", - "************\n", - "Executing 3 circuits with 8 qubits, using 2 input qubits and 3 clock qubits\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 151, 0.26\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 272, 0.329, 176.0\n", - "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.004, 34.468, 1.578 secs\n", - "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.41, 0.0\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 237, 0.262\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 411, 0.331, 264.0\n", - "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.005, 34.718, 1.684 secs\n", - "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.451, 0.016\n", - "\n", - "... execution complete at Sep 17, 2024 16:26:33 UTC in 215.678 secs\n", - "\n", - "Sample Circuit:\n", - " ┌───┐ ░ ┌───────────┐ ░ ░ ░ »\n", - " input: ┤ X ├─░─┤0 ├─░──────────░───────────────────────────░────────»\n", - " └───┘ ░ │ │ ░ ░ ░ »\n", - " in_anc: ──────░─┤1 ├─░──────────░───────────────────────────░────────»\n", - " ┌───┐ ░ │ e^{0iAt} │ ░ ┌──────┐ ░ ┌──────────┐ ░ ┌─────┐»\n", - " clock: ┤ H ├─░─┤2 ├─░─┤ IQFT ├─░──────┤0 ├─────────░─┤ QFT ├»\n", - " └───┘ ░ │ │ ░ └──────┘ ░ │ INV_ROT │┌─┐ ░ └─────┘»\n", - "ancilla: ──────░─┤3 ├─░──────────░──|0>─┤1 ├┤M├─|0>──░────────»\n", - " ░ └───────────┘ ░ ░ └──────────┘└╥┘ ░ »\n", - " c176: 1/═════════════════════════════════════════════════════╬════════════════»\n", - " ║ »\n", - " c177: 1/═════════════════════════════════════════════════════╩════════════════»\n", - " 0 »\n", - "« ░ ┌────────────┐ ░ ░ ┌─┐\n", - "« input: ─░─┤0 ├─░───────░─┤M├\n", - "« ░ │ │ ░ ░ └╥┘\n", - "« in_anc: ─░─┤1 ├─░───────░──╫─\n", - "« ░ │ e^{-0iAt} │ ░ ┌───┐ ░ ║ \n", - "« clock: ─░─┤2 ├─░─┤ H ├─░──╫─\n", - "« ░ │ │ ░ └───┘ ░ ║ \n", - "«ancilla: ─░─┤3 ├─░───────░──╫─\n", - "« ░ └────────────┘ ░ ░ ║ \n", - "« c176: 1/═════════════════════════════╩═\n", - "« 0 \n", - "« c177: 1/═══════════════════════════════\n", - "« \n", - "\n", - "U Circuit =\n", - " ┌───┐ ┌───┐ ┌───────────┐┌──────────┐┌───────────┐ »\n", - "q8162: ┤ X ├────■───────┤ X ├───┤ Rz(-3π/2) ├┤ Ry(-π/2) ├┤ Rz(-3π/2) ├──■──»\n", - " └───┘ ┌─┴─┐ ┌─┴───┴──┐└┬──────────┤└┬────────┬┘└───────────┘┌─┴─┐»\n", - "q8163: ───────┤ X ├───┤ Rz(-π) ├─┤ Ry(-π/2) ├─┤ Rz(-π) ├──────────────┤ X ├»\n", - " └───┘ └────────┘ └──────────┘ └────────┘ └───┘»\n", - "q8164: ──────■─────────────────────────────────────────────────────────────»\n", - " ┌───┐ │P(3π/2) ┌───┐ »\n", - "q8165: ┤ X ├─■──────────┤ X ├──────────────────────────────────────────────»\n", - " └───┘ └───┘ »\n", - "« ┌──────────┐┌───────────┐ ┌───┐»\n", - "«q8162: ─┤ Rx(-π/2) ├┤ Rz(-3π/2) ├──■──────────────────────────┤ X ├»\n", - "« ┌┴──────────┤└─┬────────┬┘┌─┴─┐┌──────────┐┌──────────┐└─┬─┘»\n", - "«q8163: ┤ Rz(-7π/4) ├──┤ Rx(-π) ├─┤ X ├┤ Ry(-π/2) ├┤ Rx(-π/4) ├──■──»\n", - "« └───────────┘ └────────┘ └───┘└──────────┘└──────────┘ »\n", - "«q8164: ────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q8165: ────────────────────────────────────────────────────────────»\n", - "« »\n", - "« ┌───────────┐ ┌───────────┐┌──────────┐┌───────────┐»\n", - "«q8162: ┤ Rz(-3π/2) ├──■────────────■──┤ Rz(-3π/2) ├┤ Ry(-π/2) ├┤ Rz(-3π/2) ├»\n", - "« └───┬───┬───┘ │ │ └───┬───┬───┘└┬────────┬┘└┬──────────┤»\n", - "«q8163: ────┤ X ├──────■────────────■──────┤ X ├─────┤ Rz(-π) ├──┤ Ry(-π/2) ├»\n", - "« └───┘ │ │ └───┘ └────────┘ └──────────┘»\n", - "«q8164: ───────────────┼───■────────┼────────────────────────────────────────»\n", - "« ┌─┴─┐ │P(-π) ┌─┴─┐ »\n", - "«q8165: ─────────────┤ X ├─■──────┤ X ├──────────────────────────────────────»\n", - "« └───┘ └───┘ »\n", - "« ┌──────────┐┌───────────┐ »\n", - "«q8162: ────────────■───┤ Rx(-π/2) ├┤ Rz(-3π/2) ├──■──────────────────────────»\n", - "« ┌────────┐┌─┴─┐┌┴──────────┤└─┬────────┬┘┌─┴─┐┌──────────┐┌──────────┐»\n", - "«q8163: ┤ Rz(-π) ├┤ X ├┤ Rz(-7π/4) ├──┤ Rx(-π) ├─┤ X ├┤ Ry(-π/2) ├┤ Rx(-π/4) ├»\n", - "« └────────┘└───┘└───────────┘ └────────┘ └───┘└──────────┘└──────────┘»\n", - "«q8164: ──────────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q8165: ──────────────────────────────────────────────────────────────────────»\n", - "« »\n", - "« ┌───┐┌───────────┐┌───┐ ┌───┐\n", - "«q8162: ┤ X ├┤ Rz(-3π/2) ├┤ X ├──■──┤ X ├\n", - "« └─┬─┘└───────────┘└───┘┌─┴─┐└───┘\n", - "«q8163: ──■────────────────────┤ X ├─────\n", - "« └───┘ \n", - "«q8164: ─────────────────────────────────\n", - "« \n", - "«q8165: ─────────────────────────────────\n", - "« \n", - "\n", - "U^-1 Circuit =\n", - " ┌───┐ ┌───┐ ┌───────────┐┌──────────┐┌───────────┐ »\n", - "q8170: ┤ X ├─────■───────┤ X ├───┤ Rz(-3π/2) ├┤ Ry(-π/2) ├┤ Rz(-3π/2) ├──■──»\n", - " └───┘ ┌─┴─┐ ┌─┴───┴──┐└┬──────────┤└┬────────┬┘└───────────┘┌─┴─┐»\n", - "q8171: ────────┤ X ├───┤ Rz(-π) ├─┤ Ry(-π/2) ├─┤ Rz(-π) ├──────────────┤ X ├»\n", - " └───┘ └────────┘ └──────────┘ └────────┘ └───┘»\n", - "q8172: ──────■──────────────────────────────────────────────────────────────»\n", - " ┌───┐ │P(-3π/2) ┌───┐ »\n", - "q8173: ┤ X ├─■───────────┤ X ├──────────────────────────────────────────────»\n", - " └───┘ └───┘ »\n", - "« ┌──────────┐┌───────────┐ ┌───┐»\n", - "«q8170: ─┤ Rx(-π/2) ├┤ Rz(-3π/2) ├──■──────────────────────────┤ X ├»\n", - "« ┌┴──────────┤└─┬────────┬┘┌─┴─┐┌──────────┐┌──────────┐└─┬─┘»\n", - "«q8171: ┤ Rz(-7π/4) ├──┤ Rx(-π) ├─┤ X ├┤ Ry(-π/2) ├┤ Rx(-π/4) ├──■──»\n", - "« └───────────┘ └────────┘ └───┘└──────────┘└──────────┘ »\n", - "«q8172: ────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q8173: ────────────────────────────────────────────────────────────»\n", - "« »\n", - "« ┌───────────┐ ┌───────────┐┌──────────┐┌───────────┐»\n", - "«q8170: ┤ Rz(-3π/2) ├──■───────────■──┤ Rz(-3π/2) ├┤ Ry(-π/2) ├┤ Rz(-3π/2) ├»\n", - "« └───┬───┬───┘ │ │ └───┬───┬───┘└┬────────┬┘└┬──────────┤»\n", - "«q8171: ────┤ X ├──────■───────────■──────┤ X ├─────┤ Rz(-π) ├──┤ Ry(-π/2) ├»\n", - "« └───┘ │ │ └───┘ └────────┘ └──────────┘»\n", - "«q8172: ───────────────┼───■───────┼────────────────────────────────────────»\n", - "« ┌─┴─┐ │P(π) ┌─┴─┐ »\n", - "«q8173: ─────────────┤ X ├─■─────┤ X ├──────────────────────────────────────»\n", - "« └───┘ └───┘ »\n", - "« ┌──────────┐┌───────────┐ »\n", - "«q8170: ────────────■───┤ Rx(-π/2) ├┤ Rz(-3π/2) ├──■──────────────────────────»\n", - "« ┌────────┐┌─┴─┐┌┴──────────┤└─┬────────┬┘┌─┴─┐┌──────────┐┌──────────┐»\n", - "«q8171: ┤ Rz(-π) ├┤ X ├┤ Rz(-7π/4) ├──┤ Rx(-π) ├─┤ X ├┤ Ry(-π/2) ├┤ Rx(-π/4) ├»\n", - "« └────────┘└───┘└───────────┘ └────────┘ └───┘└──────────┘└──────────┘»\n", - "«q8172: ──────────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q8173: ──────────────────────────────────────────────────────────────────────»\n", - "« »\n", - "« ┌───┐┌───────────┐┌───┐ ┌───┐\n", - "«q8170: ┤ X ├┤ Rz(-3π/2) ├┤ X ├──■──┤ X ├\n", - "« └─┬─┘└───────────┘└───┘┌─┴─┐└───┘\n", - "«q8171: ──■────────────────────┤ X ├─────\n", - "« └───┘ \n", - "«q8172: ─────────────────────────────────\n", - "« \n", - "«q8173: ─────────────────────────────────\n", - "« \n", - "\n", - "QFT Circuit =\n", - " ┌───┐ ░ \n", - "q8169: ┤ H ├─░─\n", - " └───┘ ░ \n", - "\n", - "Inverse QFT Circuit =\n", - " ┌───┐ ░ \n", - "q8166: ┤ H ├─░─\n", - " └───┘ ░ \n", - "\n", - "Hamiltonian Phase Estimation Circuit =\n", - " ... too large!\n", - "\n", - "Controlled Rotation Circuit =\n", - " \n", - "q8167: ─────────────────■────────────────────■──\n", - " ┌─────────────┐┌─┴─┐┌──────────────┐┌─┴─┐\n", - "q8168: ┤ Ry(0.77628) ├┤ X ├┤ Ry(-0.27092) ├┤ X ├\n", - " └─────────────┘└───┘└──────────────┘└───┘\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import sys\n", "sys.path.insert(1, \"hhl/qiskit\")\n", @@ -1647,153 +318,9 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Amplitude Estimation Benchmark Program - Qiskit\n", - "... execution starting at Sep 17, 2024 16:27:00 UTC\n", - "************\n", - "Executing [2] circuits with num_qubits = 3\n", - "************\n", - "Executing [3] circuits with num_qubits = 4\n", - "************\n", - "Executing [3] circuits with num_qubits = 5\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 3 qubit group = 72, 0.422\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 3 qubit group = 58, 0.387, 29.0\n", - "Average Creation, Elapsed, Execution Time for the 3 qubit group = 0.008, 31.814, 1.342 secs\n", - "Average Transpiling, Validating, Running Times for group 3 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 3 qubit group = 0.567, 0.133\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 4 qubit group = 208, 0.432\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 4 qubit group = 165, 0.398, 84.0\n", - "Average Creation, Elapsed, Execution Time for the 4 qubit group = 0.01, 22.432, 1.435 secs\n", - "Average Transpiling, Validating, Running Times for group 4 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 4 qubit group = 0.416, 0.002\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 6\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 5 qubit group = 479, 0.436\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 5 qubit group = 375, 0.404, 192.667\n", - "Average Creation, Elapsed, Execution Time for the 5 qubit group = 0.008, 31.11, 1.62 secs\n", - "Average Transpiling, Validating, Running Times for group 5 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 5 qubit group = 0.181, 0.034\n", - "\n", - "************\n", - "Executing [3] circuits with num_qubits = 7\n", - "************\n", - "Executing [3] circuits with num_qubits = 8\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 6 qubit group = 1017, 0.438\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 6 qubit group = 836, 0.407, 426.0\n", - "Average Creation, Elapsed, Execution Time for the 6 qubit group = 0.015, 46.93, 1.955 secs\n", - "Average Transpiling, Validating, Running Times for group 6 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 6 qubit group = 0.105, 0.025\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 7 qubit group = 2086, 0.439\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 7 qubit group = 1701, 0.408, 868.0\n", - "Average Creation, Elapsed, Execution Time for the 7 qubit group = 0.019, 37.824, 2.729 secs\n", - "Average Transpiling, Validating, Running Times for group 7 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 7 qubit group = 0.067, 0.006\n", - "\n", - "************\n", - "Average Circuit Algorithmic Depth, ξ (xi) for the 8 qubit group = 4214, 0.44\n", - "Average Normalized Transpiled Depth, ξ (xi), 2q gates for the 8 qubit group = 3417, 0.409, 1744.0\n", - "Average Creation, Elapsed, Execution Time for the 8 qubit group = 0.038, 42.769, 4.161 secs\n", - "Average Transpiling, Validating, Running Times for group 8 = 0.001, 0.001, 0.001 secs\n", - "Average Hellinger, Normalized Fidelity for the 8 qubit group = 0.026, 0.0\n", - "\n", - "... execution complete at Sep 17, 2024 16:30:50 UTC in 230.245 secs\n", - "\n", - "Sample Circuit:\n", - " ┌───┐ ┌──────┐┌──────┐┌──────┐┌──────┐ ░ »\n", - "q9259_0: ┤ H ├─────────────────────────┤0 ├┤0 ├┤0 ├┤0 ├─░─»\n", - " ├───┤ ┌──────┐┌──────┐│ ││ ││ ││ │ ░ »\n", - "q9259_1: ┤ H ├─────────┤0 ├┤0 ├┤ ├┤ ├┤ ├┤ ├─░─»\n", - " ├───┤ ┌──────┐│ ││ ││ ││ ││ ││ │ ░ »\n", - "q9259_2: ┤ H ├─┤0 ├┤ ├┤ ├┤ c_Q ├┤ c_Q ├┤ c_Q ├┤ c_Q ├─░─»\n", - " ├───┴┐│ ││ c_Q ││ c_Q ││ ││ ││ ││ │ ░ »\n", - "q9258_0: ┤0 ├┤1 c_Q ├┤1 ├┤1 ├┤1 ├┤1 ├┤1 ├┤1 ├─░─»\n", - " │ A ││ ││ ││ ││ ││ ││ ││ │ ░ »\n", - "q9258_1: ┤1 ├┤2 ├┤2 ├┤2 ├┤2 ├┤2 ├┤2 ├┤2 ├─░─»\n", - " └────┘└──────┘└──────┘└──────┘└──────┘└──────┘└──────┘└──────┘ ░ »\n", - " c213: 3/═════════════════════════════════════════════════════════════════»\n", - " »\n", - "« ┌───────────────┐ ░ ┌─┐ \n", - "«q9259_0: ┤0 ├─░─┤M├──────\n", - "« │ │ ░ └╥┘┌─┐ \n", - "«q9259_1: ┤1 inv_qft_gate ├─░──╫─┤M├───\n", - "« │ │ ░ ║ └╥┘┌─┐\n", - "«q9259_2: ┤2 ├─░──╫──╫─┤M├\n", - "« └───────────────┘ ░ ║ ║ └╥┘\n", - "«q9258_0: ──────────────────░──╫──╫──╫─\n", - "« ░ ║ ║ ║ \n", - "«q9258_1: ──────────────────░──╫──╫──╫─\n", - "« ░ ║ ║ ║ \n", - "« c213: 3/═════════════════════╩══╩══╩═\n", - "« 0 1 2 \n", - "\n", - "Controlled Quantum Operator 'cQ' =\n", - " \n", - "q9608: ──■───\n", - " ┌─┴──┐\n", - " q_0: ┤0 ├\n", - " │ Q │\n", - " q_1: ┤1 ├\n", - " └────┘\n", - "\n", - "Quantum Operator 'Q' =\n", - " ┌───────┐┌───┐ ┌───┐ ┌────┐\n", - "q_0: ───────────────┤0 ├┤ X ├───────■──┤ X ├─────┤0 ├\n", - " ┌───┐┌───┐┌───┐│ A_dg │├───┤┌───┐┌─┴─┐├───┤┌───┐│ A │\n", - "q_1: ┤ X ├┤ Z ├┤ X ├┤1 ├┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├┤1 ├\n", - " └───┘└───┘└───┘└───────┘└───┘└───┘└───┘└───┘└───┘└────┘\n", - "\n", - "Amplitude Generator 'A' =\n", - " ┌───┐\n", - "q_0: ────────────────────────┤ X ├\n", - " ┌────────────┐┌───┐┌───┐└─┬─┘\n", - "q_1: ┤ Ry(2.0624) ├┤ X ├┤ X ├──■──\n", - " └────────────┘└───┘└───┘ \n", - "\n", - "Inverse QFT Circuit =\n", - " ┌───┐ ░ ░ ░ \n", - "q9266_0: ┤ H ├─────■───────────■───────░───────────────────░───────░─\n", - " └───┘┌────┴─────┐ │ ░ ┌───┐ ░ ░ \n", - "q9266_1: ─────┤ Rz(-π/2) ├─────┼───────░─┤ H ├─────■───────░───────░─\n", - " └──────────┘┌────┴─────┐ ░ └───┘┌────┴─────┐ ░ ┌───┐ ░ \n", - "q9266_2: ─────────────────┤ Rz(-π/4) ├─░──────┤ Rz(-π/2) ├─░─┤ H ├─░─\n", - " └──────────┘ ░ └──────────┘ ░ └───┘ ░ \n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import sys\n", "sys.path.insert(1, \"amplitude-estimation/qiskit\")\n", @@ -1813,63 +340,9 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/haimengzhang/Documents/QC-App-Oriented-Benchmarks/monte-carlo/qiskit/mc_benchmark.py:123: SyntaxWarning: invalid escape sequence '\\s'\n", - " \"\"\"\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Monte Carlo Sampling (2) Benchmark Program - Qiskit\n", - "... execution starting at Sep 17, 2024 16:44:50 UTC\n", - "************\n", - "Executing [3] circuits with num_qubits = 4\n", - "************\n", - "Executing [3] circuits with num_qubits = 5\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[30], line 4\u001b[0m\n\u001b[1;32m 2\u001b[0m sys\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39minsert(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmonte-carlo/qiskit\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmc_benchmark\u001b[39;00m\n\u001b[0;32m----> 4\u001b[0m \u001b[43mmc_benchmark\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmin_qubits\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmin_qubits\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmax_qubits\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_qubits\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mskip_qubits\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mskip_qubits\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mmax_circuits\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_circuits\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_shots\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_shots\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43mbackend_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbackend_id\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprovider_backend\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprovider_backend\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 7\u001b[0m \u001b[43m \u001b[49m\u001b[43mhub\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhub\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgroup\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mproject\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mproject\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mexec_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mexec_options\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/monte-carlo/qiskit/mc_benchmark.py:472\u001b[0m, in \u001b[0;36mrun\u001b[0;34m(min_qubits, max_qubits, skip_qubits, max_circuits, num_shots, epsilon, degree, num_state_qubits, method, backend_id, provider_backend, hub, group, project, exec_options, context)\u001b[0m\n\u001b[1;32m 465\u001b[0m ex\u001b[38;5;241m.\u001b[39msubmit_circuit(qc2, num_qubits, mu, num_shots)\n\u001b[1;32m 467\u001b[0m \u001b[38;5;66;03m# if method is 2, we only have one type of circuit, so break out of loop\u001b[39;00m\n\u001b[1;32m 468\u001b[0m \u001b[38;5;66;03m#if method == 2:\u001b[39;00m\n\u001b[1;32m 469\u001b[0m \u001b[38;5;66;03m# break\u001b[39;00m\n\u001b[1;32m 470\u001b[0m \n\u001b[1;32m 471\u001b[0m \u001b[38;5;66;03m# Wait for some active circuits to complete; report metrics when groups complete\u001b[39;00m\n\u001b[0;32m--> 472\u001b[0m \u001b[43mex\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mthrottle_execution\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmetrics\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfinalize_group\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 474\u001b[0m \u001b[38;5;66;03m# Wait for all active circuits to complete; report metrics when groups complete\u001b[39;00m\n\u001b[1;32m 475\u001b[0m ex\u001b[38;5;241m.\u001b[39mfinalize_execution(metrics\u001b[38;5;241m.\u001b[39mfinalize_group)\n", - "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/_common/qiskit/execute.py:1392\u001b[0m, in \u001b[0;36mthrottle_execution\u001b[0;34m(completion_handler)\u001b[0m\n\u001b[1;32m 1389\u001b[0m done = False\n\u001b[1;32m 1390\u001b[0m pollcount = 0\n\u001b[1;32m 1391\u001b[0m while not done:\n\u001b[0;32m-> 1392\u001b[0m \n\u001b[1;32m 1393\u001b[0m # check if any jobs complete\n\u001b[1;32m 1394\u001b[0m check_jobs(completion_handler)\n\u001b[1;32m 1396\u001b[0m # return only when all jobs complete\n", - "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/_common/qiskit/execute.py:1469\u001b[0m, in \u001b[0;36mcheck_jobs\u001b[0;34m(completion_handler)\u001b[0m\n\u001b[1;32m 1465\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcheck_jobs\u001b[39m(completion_handler\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m 1467\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m job, circuit \u001b[38;5;129;01min\u001b[39;00m active_circuits\u001b[38;5;241m.\u001b[39mitems():\n\u001b[0;32m-> 1469\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1470\u001b[0m \u001b[38;5;66;03m#status = job.status()\u001b[39;00m\n\u001b[1;32m 1471\u001b[0m status \u001b[38;5;241m=\u001b[39m get_job_status(job, circuit) \u001b[38;5;66;03m# use this version, robust to network failure \u001b[39;00m\n\u001b[1;32m 1472\u001b[0m \u001b[38;5;66;03m#print(\"Job status is \", status)\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/_common/qiskit/execute.py:843\u001b[0m, in \u001b[0;36mget_job_status\u001b[0;34m(job, active_circuit)\u001b[0m\n\u001b[1;32m 841\u001b[0m status \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 842\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m retry_count \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m3\u001b[39m:\n\u001b[0;32m--> 843\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 844\u001b[0m retry_count \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 845\u001b[0m \u001b[38;5;66;03m#print(f\"... calling job.status()\")\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/qiskit_ibm_runtime/runtime_job.py:193\u001b[0m, in \u001b[0;36mRuntimeJob.status\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 187\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mstatus\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m JobStatus:\n\u001b[1;32m 188\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Return the status of the job.\u001b[39;00m\n\u001b[1;32m 189\u001b[0m \n\u001b[1;32m 190\u001b[0m \u001b[38;5;124;03m Returns:\u001b[39;00m\n\u001b[1;32m 191\u001b[0m \u001b[38;5;124;03m Status of this job.\u001b[39;00m\n\u001b[1;32m 192\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 193\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_set_status_and_error_message\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 194\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_status\n", - "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/qiskit_ibm_runtime/base_runtime_job.py:207\u001b[0m, in \u001b[0;36mBaseRuntimeJob._set_status_and_error_message\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 205\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Fetch and set status and error message.\"\"\"\u001b[39;00m\n\u001b[1;32m 206\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_status \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mJOB_FINAL_STATES:\n\u001b[0;32m--> 207\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_api_client\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mjob_get\u001b[49m\u001b[43m(\u001b[49m\u001b[43mjob_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mjob_id\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 208\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_set_status(response)\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_set_error_message(response)\n", - "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/qiskit_ibm_runtime/api/clients/runtime.py:115\u001b[0m, in \u001b[0;36mRuntimeClient.job_get\u001b[0;34m(self, job_id, exclude_params)\u001b[0m\n\u001b[1;32m 106\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mjob_get\u001b[39m(\u001b[38;5;28mself\u001b[39m, job_id: \u001b[38;5;28mstr\u001b[39m, exclude_params: \u001b[38;5;28mbool\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Dict:\n\u001b[1;32m 107\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Get job data.\u001b[39;00m\n\u001b[1;32m 108\u001b[0m \n\u001b[1;32m 109\u001b[0m \u001b[38;5;124;03m Args:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 113\u001b[0m \u001b[38;5;124;03m JSON response.\u001b[39;00m\n\u001b[1;32m 114\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 115\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_api\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprogram_job\u001b[49m\u001b[43m(\u001b[49m\u001b[43mjob_id\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[43mexclude_params\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mexclude_params\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 116\u001b[0m logger\u001b[38;5;241m.\u001b[39mdebug(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mRuntime job get response: \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, response)\n\u001b[1;32m 117\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m response\n", - "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/qiskit_ibm_runtime/api/rest/program_job.py:59\u001b[0m, in \u001b[0;36mProgramJob.get\u001b[0;34m(self, exclude_params)\u001b[0m\n\u001b[1;32m 57\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m exclude_params:\n\u001b[1;32m 58\u001b[0m payload[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mexclude_params\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtrue\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m---> 59\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msession\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_url\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mself\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpayload\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mjson(\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m=\u001b[39mRuntimeDecoder)\n", - "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/requests/sessions.py:602\u001b[0m, in \u001b[0;36mSession.get\u001b[0;34m(self, url, **kwargs)\u001b[0m\n\u001b[1;32m 594\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Sends a GET request. Returns :class:`Response` object.\u001b[39;00m\n\u001b[1;32m 595\u001b[0m \n\u001b[1;32m 596\u001b[0m \u001b[38;5;124;03m:param url: URL for the new :class:`Request` object.\u001b[39;00m\n\u001b[1;32m 597\u001b[0m \u001b[38;5;124;03m:param \\*\\*kwargs: Optional arguments that ``request`` takes.\u001b[39;00m\n\u001b[1;32m 598\u001b[0m \u001b[38;5;124;03m:rtype: requests.Response\u001b[39;00m\n\u001b[1;32m 599\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 601\u001b[0m kwargs\u001b[38;5;241m.\u001b[39msetdefault(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mallow_redirects\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[0;32m--> 602\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mGET\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/qiskit_ibm_runtime/api/session.py:328\u001b[0m, in \u001b[0;36mRetrySession.request\u001b[0;34m(self, method, url, bare, **kwargs)\u001b[0m\n\u001b[1;32m 326\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 327\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_log_request_info(final_url, method, kwargs)\n\u001b[0;32m--> 328\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfinal_url\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 329\u001b[0m response\u001b[38;5;241m.\u001b[39mraise_for_status()\n\u001b[1;32m 330\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m RequestException \u001b[38;5;28;01mas\u001b[39;00m ex:\n\u001b[1;32m 331\u001b[0m \u001b[38;5;66;03m# Wrap the requests exceptions into a IBM Q custom one, for\u001b[39;00m\n\u001b[1;32m 332\u001b[0m \u001b[38;5;66;03m# compatibility.\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/requests/sessions.py:589\u001b[0m, in \u001b[0;36mSession.request\u001b[0;34m(self, method, url, params, data, headers, cookies, files, auth, timeout, allow_redirects, proxies, hooks, stream, verify, cert, json)\u001b[0m\n\u001b[1;32m 584\u001b[0m send_kwargs \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 585\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtimeout\u001b[39m\u001b[38;5;124m\"\u001b[39m: timeout,\n\u001b[1;32m 586\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mallow_redirects\u001b[39m\u001b[38;5;124m\"\u001b[39m: allow_redirects,\n\u001b[1;32m 587\u001b[0m }\n\u001b[1;32m 588\u001b[0m send_kwargs\u001b[38;5;241m.\u001b[39mupdate(settings)\n\u001b[0;32m--> 589\u001b[0m resp \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprep\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43msend_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 591\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m resp\n", - "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/requests/sessions.py:703\u001b[0m, in \u001b[0;36mSession.send\u001b[0;34m(self, request, **kwargs)\u001b[0m\n\u001b[1;32m 700\u001b[0m start \u001b[38;5;241m=\u001b[39m preferred_clock()\n\u001b[1;32m 702\u001b[0m \u001b[38;5;66;03m# Send the request\u001b[39;00m\n\u001b[0;32m--> 703\u001b[0m r \u001b[38;5;241m=\u001b[39m \u001b[43madapter\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrequest\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 705\u001b[0m \u001b[38;5;66;03m# Total elapsed time of the request (approximately)\u001b[39;00m\n\u001b[1;32m 706\u001b[0m elapsed \u001b[38;5;241m=\u001b[39m preferred_clock() \u001b[38;5;241m-\u001b[39m start\n", - "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/requests/adapters.py:667\u001b[0m, in \u001b[0;36mHTTPAdapter.send\u001b[0;34m(self, request, stream, timeout, verify, cert, proxies)\u001b[0m\n\u001b[1;32m 664\u001b[0m timeout \u001b[38;5;241m=\u001b[39m TimeoutSauce(connect\u001b[38;5;241m=\u001b[39mtimeout, read\u001b[38;5;241m=\u001b[39mtimeout)\n\u001b[1;32m 666\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 667\u001b[0m resp \u001b[38;5;241m=\u001b[39m \u001b[43mconn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43murlopen\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 668\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 669\u001b[0m \u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 670\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 671\u001b[0m \u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 672\u001b[0m \u001b[43m \u001b[49m\u001b[43mredirect\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 673\u001b[0m \u001b[43m \u001b[49m\u001b[43massert_same_host\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 674\u001b[0m \u001b[43m \u001b[49m\u001b[43mpreload_content\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 675\u001b[0m \u001b[43m \u001b[49m\u001b[43mdecode_content\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m 676\u001b[0m \u001b[43m \u001b[49m\u001b[43mretries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmax_retries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 677\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 678\u001b[0m \u001b[43m \u001b[49m\u001b[43mchunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunked\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 679\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 681\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (ProtocolError, \u001b[38;5;167;01mOSError\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[1;32m 682\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mConnectionError\u001b[39;00m(err, request\u001b[38;5;241m=\u001b[39mrequest)\n", - "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/urllib3/connectionpool.py:789\u001b[0m, in \u001b[0;36mHTTPConnectionPool.urlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, preload_content, decode_content, **response_kw)\u001b[0m\n\u001b[1;32m 786\u001b[0m response_conn \u001b[38;5;241m=\u001b[39m conn \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m release_conn \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 788\u001b[0m \u001b[38;5;66;03m# Make the request on the HTTPConnection object\u001b[39;00m\n\u001b[0;32m--> 789\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_request\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 790\u001b[0m \u001b[43m \u001b[49m\u001b[43mconn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 791\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 792\u001b[0m \u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 793\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout_obj\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 794\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 795\u001b[0m \u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 796\u001b[0m \u001b[43m \u001b[49m\u001b[43mchunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunked\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 797\u001b[0m \u001b[43m \u001b[49m\u001b[43mretries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mretries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 798\u001b[0m \u001b[43m \u001b[49m\u001b[43mresponse_conn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mresponse_conn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 799\u001b[0m \u001b[43m \u001b[49m\u001b[43mpreload_content\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpreload_content\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 800\u001b[0m \u001b[43m \u001b[49m\u001b[43mdecode_content\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdecode_content\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 801\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mresponse_kw\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 802\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 804\u001b[0m \u001b[38;5;66;03m# Everything went great!\u001b[39;00m\n\u001b[1;32m 805\u001b[0m clean_exit \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", - "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/urllib3/connectionpool.py:536\u001b[0m, in \u001b[0;36mHTTPConnectionPool._make_request\u001b[0;34m(self, conn, method, url, body, headers, retries, timeout, chunked, response_conn, preload_content, decode_content, enforce_content_length)\u001b[0m\n\u001b[1;32m 534\u001b[0m \u001b[38;5;66;03m# Receive the response from the server\u001b[39;00m\n\u001b[1;32m 535\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 536\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[43mconn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgetresponse\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 537\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (BaseSSLError, \u001b[38;5;167;01mOSError\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 538\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_raise_timeout(err\u001b[38;5;241m=\u001b[39me, url\u001b[38;5;241m=\u001b[39murl, timeout_value\u001b[38;5;241m=\u001b[39mread_timeout)\n", - "File \u001b[0;32m~/Documents/QC-App-Oriented-Benchmarks/.venv/lib/python3.12/site-packages/urllib3/connection.py:464\u001b[0m, in \u001b[0;36mHTTPConnection.getresponse\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 461\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mresponse\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m HTTPResponse\n\u001b[1;32m 463\u001b[0m \u001b[38;5;66;03m# Get the response from http.client.HTTPConnection\u001b[39;00m\n\u001b[0;32m--> 464\u001b[0m httplib_response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgetresponse\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 466\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 467\u001b[0m assert_header_parsing(httplib_response\u001b[38;5;241m.\u001b[39mmsg)\n", - "File \u001b[0;32m~/.pyenv/versions/3.12.4/lib/python3.12/http/client.py:1428\u001b[0m, in \u001b[0;36mHTTPConnection.getresponse\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1426\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1427\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1428\u001b[0m \u001b[43mresponse\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbegin\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1429\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mConnectionError\u001b[39;00m:\n\u001b[1;32m 1430\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mclose()\n", - "File \u001b[0;32m~/.pyenv/versions/3.12.4/lib/python3.12/http/client.py:331\u001b[0m, in \u001b[0;36mHTTPResponse.begin\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 329\u001b[0m \u001b[38;5;66;03m# read until we get a non-100 response\u001b[39;00m\n\u001b[1;32m 330\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[0;32m--> 331\u001b[0m version, status, reason \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_read_status\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 332\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m status \u001b[38;5;241m!=\u001b[39m CONTINUE:\n\u001b[1;32m 333\u001b[0m \u001b[38;5;28;01mbreak\u001b[39;00m\n", - "File \u001b[0;32m~/.pyenv/versions/3.12.4/lib/python3.12/http/client.py:292\u001b[0m, in \u001b[0;36mHTTPResponse._read_status\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 291\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_read_status\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m--> 292\u001b[0m line \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mstr\u001b[39m(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreadline\u001b[49m\u001b[43m(\u001b[49m\u001b[43m_MAXLINE\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124miso-8859-1\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 293\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(line) \u001b[38;5;241m>\u001b[39m _MAXLINE:\n\u001b[1;32m 294\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m LineTooLong(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstatus line\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "File \u001b[0;32m~/.pyenv/versions/3.12.4/lib/python3.12/socket.py:708\u001b[0m, in \u001b[0;36mSocketIO.readinto\u001b[0;34m(self, b)\u001b[0m\n\u001b[1;32m 706\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[1;32m 707\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 708\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_sock\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrecv_into\u001b[49m\u001b[43m(\u001b[49m\u001b[43mb\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 709\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m timeout:\n\u001b[1;32m 710\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_timeout_occurred \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", - "File \u001b[0;32m~/.pyenv/versions/3.12.4/lib/python3.12/ssl.py:1252\u001b[0m, in \u001b[0;36mSSLSocket.recv_into\u001b[0;34m(self, buffer, nbytes, flags)\u001b[0m\n\u001b[1;32m 1248\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m flags \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m 1249\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 1250\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnon-zero flags not allowed in calls to recv_into() on \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m\n\u001b[1;32m 1251\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m)\n\u001b[0;32m-> 1252\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnbytes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbuffer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1253\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1254\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39mrecv_into(buffer, nbytes, flags)\n", - "File \u001b[0;32m~/.pyenv/versions/3.12.4/lib/python3.12/ssl.py:1104\u001b[0m, in \u001b[0;36mSSLSocket.read\u001b[0;34m(self, len, buffer)\u001b[0m\n\u001b[1;32m 1102\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1103\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m buffer \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1104\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_sslobj\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbuffer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1105\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1106\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_sslobj\u001b[38;5;241m.\u001b[39mread(\u001b[38;5;28mlen\u001b[39m)\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ "import sys\n", "sys.path.insert(1, \"monte-carlo/qiskit\")\n", @@ -2018,6 +491,13 @@ "\n", "metrics.plot_all_app_metrics(backend_id, do_all_plots=False, include_apps=None)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -2036,7 +516,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.4" + "version": "3.10.12" } }, "nbformat": 4, From 7bb7dcb4c6cd31757e41dfa6ab79caa424c681cc Mon Sep 17 00:00:00 2001 From: Haimeng Zhang Date: Mon, 30 Sep 2024 14:58:09 -0400 Subject: [PATCH 19/19] remove and execution options for Sampler when is True --- _common/qiskit/execute.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/_common/qiskit/execute.py b/_common/qiskit/execute.py index 4fa1f656..1a63c65b 100644 --- a/_common/qiskit/execute.py +++ b/_common/qiskit/execute.py @@ -392,8 +392,8 @@ def set_execution_target(backend_id='qasm_simulator', # get Sampler resilience level and transpiler optimization level from exec_options options = Options() - options.resilience_level = exec_options.get("resilience_level", 1) - options.optimization_level = exec_options.get("optimization_level", 3) + # options.resilience_level = exec_options.get("resilience_level", 1) + # options.optimization_level = exec_options.get("optimization_level", 3) # special handling for ibmq_qasm_simulator to set noise model if backend_id == "ibmq_qasm_simulator":