From 8694619d386d3a2ab44f03fa85861c7f2ff9db33 Mon Sep 17 00:00:00 2001 From: strongchris Date: Wed, 3 May 2023 03:11:13 +0000 Subject: [PATCH 01/11] add skm-tea benchmarking scripts --- scripts/dicom_vs_dimble.py | 64 ++++++++++++++++++++++++++++++++++++ scripts/skm_tea_to_dimble.py | 18 ++++++++++ 2 files changed, 82 insertions(+) create mode 100644 scripts/dicom_vs_dimble.py create mode 100644 scripts/skm_tea_to_dimble.py diff --git a/scripts/dicom_vs_dimble.py b/scripts/dicom_vs_dimble.py new file mode 100644 index 0000000..e32fc98 --- /dev/null +++ b/scripts/dicom_vs_dimble.py @@ -0,0 +1,64 @@ +from typing import Optional +from pathlib import Path +import dimble +from tqdm import tqdm +import pydicom +import time +import numpy as np +import torch +import plac + +def dimble_loading(dimble_files, cuda=False, verbose=True): + for file in tqdm(dimble_files, desc="DIMBLE", disable=not verbose): + data = dimble.load_dimble(file, ["7FE00010"]) + if cuda: + data = data["7FE00010"].cuda() + +def dicom_loading(dicom_files, cuda=False, verbose=True): + for file in tqdm(dicom_files, desc="DICOM", disable=not verbose): + data = pydicom.dcmread(str(file)) + data = torch.from_numpy(data.pixel_array.astype(np.int32)) + if cuda: + data = data.cuda() + +@plac.annotations( + dicom_dir=("Path to DICOM directory", "positional", None, Path), + dimble_dir=("Path to DIMBLE directory", "positional", None, Path), + n=("Number of files to load", "option", "n", int), + cuda=("Use CUDA", "flag", "c", bool), +) +def main(dicom_dir: Path, dimble_dir: Path, n: Optional[int], cuda: bool = False): + if n is None: + n = -1 + dicom_files = list(dicom_dir.rglob("*.dcm"))[:n] + dimble_files = list(dimble_dir.rglob("*.dimble"))[:n] + assert len(dimble_files) == len(dicom_files), "Number of files in DICOM and DIMBLE directories must match" + print("Loading", len(dicom_files), "files") + + # warmup + dimble_loading(dimble_files[:5], cuda=cuda, verbose=False) + dimble_loading(dimble_files[:5], cuda=cuda, verbose=False) + torch.cuda.synchronize() + + # DICOM + dicom_start = time.perf_counter() + dicom_loading(dicom_files, cuda=cuda) + torch.cuda.synchronize() + dicom_end = time.perf_counter() + dicom_elapsed = dicom_end - dicom_start + + # DIMBLE + dimble_start = time.perf_counter() + dimble_loading(dimble_files, cuda=cuda) + torch.cuda.synchronize() + dimble_end = time.perf_counter() + dimble_elapsed = dimble_end - dimble_start + + # RESULTS + print() + print(f"DICOM loaded {len(dicom_files)} files in {dicom_elapsed:.2f} seconds, {len(dicom_files)/dicom_elapsed:.2f} images/second") + print(f"DIMBLE loaded {len(dimble_files)} files in {dimble_elapsed:.2f} seconds, {len(dimble_files)/dimble_elapsed:.2f} images/second") + print(f"DIMBLE is {dicom_elapsed/dimble_elapsed:.2f}x faster than DICOM") + +if __name__ == "__main__": + plac.call(main) diff --git a/scripts/skm_tea_to_dimble.py b/scripts/skm_tea_to_dimble.py new file mode 100644 index 0000000..6773d24 --- /dev/null +++ b/scripts/skm_tea_to_dimble.py @@ -0,0 +1,18 @@ +from pathlib import Path +import dimble +from tqdm import tqdm +import plac + +@plac.annotations( + skm_tea_dicom_path=("Path to SKM-TEA DICOM directory", "positional", None, Path), + skm_tea_dimble_path=("Path to SKM-TEA DIMBLE directory", "positional", None, Path), +) +def main(skm_tea_dicom_path: Path, skm_tea_dimble_path: Path): + dicom_files = list(skm_tea_dicom_path.glob("**/*.dcm")) + for dicom_file in tqdm(dicom_files): + dimble_file = skm_tea_dimble_path / dicom_file.relative_to(skm_tea_dicom_path).with_suffix(".dimble") + dimble_file.parent.mkdir(parents=True, exist_ok=True) + dimble.dicom_to_dimble(dicom_file, dimble_file) + +if __name__ == "__main__": + plac.call(main) \ No newline at end of file From b993b5969ba5be76b19263820778b318e5aa7fe6 Mon Sep 17 00:00:00 2001 From: strongchris Date: Wed, 3 May 2023 03:14:49 +0000 Subject: [PATCH 02/11] fmt --- scripts/brats_to_dimble.py | 15 +++++++++++---- scripts/dicom_vs_dimble.py | 31 ++++++++++++++++++++++--------- scripts/nifiti_vs_dimble.py | 36 ++++++++++++++++++++++++------------ scripts/skm_tea_to_dimble.py | 14 ++++++++++---- test/test_sq.py | 1 + 5 files changed, 68 insertions(+), 29 deletions(-) diff --git a/scripts/brats_to_dimble.py b/scripts/brats_to_dimble.py index 6e5b836..6557d78 100644 --- a/scripts/brats_to_dimble.py +++ b/scripts/brats_to_dimble.py @@ -1,7 +1,11 @@ +# ruff: noqa: E501 from pathlib import Path -import dimble -from tqdm import tqdm + import plac +from tqdm import tqdm + +import dimble + @plac.annotations( brats_nifti_dir=("Path to BRATS NIFTI directory", "positional", None, Path), @@ -10,9 +14,12 @@ def main(brats_nifti_dir: Path, brats_dimble_dir: Path): # traverse brats dir and convert all nifti files to dimble and save them with same structure in dimble dir for nifti_file in tqdm(list(brats_nifti_dir.glob("**/*.nii.gz"))): - dimble_file = brats_dimble_dir / nifti_file.relative_to(brats_nifti_dir).with_suffix(".dimble") + dimble_file = brats_dimble_dir / nifti_file.relative_to( + brats_nifti_dir + ).with_suffix(".dimble") dimble_file.parent.mkdir(parents=True, exist_ok=True) dimble.nifti_to_dimble(nifti_file, dimble_file) + if __name__ == "__main__": - plac.call(main) \ No newline at end of file + plac.call(main) diff --git a/scripts/dicom_vs_dimble.py b/scripts/dicom_vs_dimble.py index e32fc98..1c048e5 100644 --- a/scripts/dicom_vs_dimble.py +++ b/scripts/dicom_vs_dimble.py @@ -1,12 +1,16 @@ -from typing import Optional -from pathlib import Path -import dimble -from tqdm import tqdm -import pydicom +# ruff: noqa: E501 import time +from pathlib import Path +from typing import Optional + import numpy as np -import torch import plac +import pydicom +import torch +from tqdm import tqdm + +import dimble + def dimble_loading(dimble_files, cuda=False, verbose=True): for file in tqdm(dimble_files, desc="DIMBLE", disable=not verbose): @@ -14,6 +18,7 @@ def dimble_loading(dimble_files, cuda=False, verbose=True): if cuda: data = data["7FE00010"].cuda() + def dicom_loading(dicom_files, cuda=False, verbose=True): for file in tqdm(dicom_files, desc="DICOM", disable=not verbose): data = pydicom.dcmread(str(file)) @@ -21,6 +26,7 @@ def dicom_loading(dicom_files, cuda=False, verbose=True): if cuda: data = data.cuda() + @plac.annotations( dicom_dir=("Path to DICOM directory", "positional", None, Path), dimble_dir=("Path to DIMBLE directory", "positional", None, Path), @@ -32,7 +38,9 @@ def main(dicom_dir: Path, dimble_dir: Path, n: Optional[int], cuda: bool = False n = -1 dicom_files = list(dicom_dir.rglob("*.dcm"))[:n] dimble_files = list(dimble_dir.rglob("*.dimble"))[:n] - assert len(dimble_files) == len(dicom_files), "Number of files in DICOM and DIMBLE directories must match" + assert len(dimble_files) == len( + dicom_files + ), "Number of files in DICOM and DIMBLE directories must match" print("Loading", len(dicom_files), "files") # warmup @@ -56,9 +64,14 @@ def main(dicom_dir: Path, dimble_dir: Path, n: Optional[int], cuda: bool = False # RESULTS print() - print(f"DICOM loaded {len(dicom_files)} files in {dicom_elapsed:.2f} seconds, {len(dicom_files)/dicom_elapsed:.2f} images/second") - print(f"DIMBLE loaded {len(dimble_files)} files in {dimble_elapsed:.2f} seconds, {len(dimble_files)/dimble_elapsed:.2f} images/second") + print( + f"DICOM loaded {len(dicom_files)} files in {dicom_elapsed:.2f} seconds, {len(dicom_files)/dicom_elapsed:.2f} images/second" + ) + print( + f"DIMBLE loaded {len(dimble_files)} files in {dimble_elapsed:.2f} seconds, {len(dimble_files)/dimble_elapsed:.2f} images/second" + ) print(f"DIMBLE is {dicom_elapsed/dimble_elapsed:.2f}x faster than DICOM") + if __name__ == "__main__": plac.call(main) diff --git a/scripts/nifiti_vs_dimble.py b/scripts/nifiti_vs_dimble.py index 465f143..98f7f7e 100644 --- a/scripts/nifiti_vs_dimble.py +++ b/scripts/nifiti_vs_dimble.py @@ -1,19 +1,23 @@ -from typing import Optional -from pathlib import Path -import dimble -from tqdm import tqdm -import SimpleITK as sitk +# ruff: noqa: E501 import time +from pathlib import Path +from typing import Optional + import numpy as np -import torch import plac +import SimpleITK as sitk +import torch +from tqdm import tqdm + +import dimble + def dimble_loading(dimble_files, cuda=False, verbose=True): for file in tqdm(dimble_files, desc="DIMBLE", disable=not verbose): data = dimble.load_dimble(file, ["7FE00010"]) if cuda: data = data["7FE00010"].cuda() - + def nifti_loading(nifti_files, cuda=False, verbose=True): for file in tqdm(nifti_files, desc="NIFTI", disable=not verbose): @@ -23,6 +27,7 @@ def nifti_loading(nifti_files, cuda=False, verbose=True): if cuda: data = data.cuda() + @plac.annotations( nifti_dir=("Path to NIFTI directory", "positional", None, Path), dimble_dir=("Path to DIMBLE directory", "positional", None, Path), @@ -31,10 +36,12 @@ def nifti_loading(nifti_files, cuda=False, verbose=True): ) def main(nifti_dir: Path, dimble_dir: Path, n: Optional[int], cuda: bool = False): if n is None: - n = -1 # load all + n = -1 # load all nifti_files = list(nifti_dir.rglob("*.nii.gz"))[:n] dimble_files = list(dimble_dir.rglob("*.dimble"))[:n] - assert len(dimble_files) == len(nifti_files), "Number of files in NIFTI and DIMBLE directories must match" + assert len(dimble_files) == len( + nifti_files + ), "Number of files in NIFTI and DIMBLE directories must match" print("Loading", len(nifti_files), "files") # warmup @@ -58,9 +65,14 @@ def main(nifti_dir: Path, dimble_dir: Path, n: Optional[int], cuda: bool = False # RESULTS print() - print(f"NIFTI loaded {len(nifti_files)} files in {nifti_elapsed:.4f} seconds, {len(nifti_files)/nifti_elapsed:.2f} images/second") - print(f"DIMBLE loaded {len(dimble_files)} files in {dimble_elapsed:.4f} seconds, {len(dimble_files)/dimble_elapsed:.2f} images/second") + print( + f"NIFTI loaded {len(nifti_files)} files in {nifti_elapsed:.4f} seconds, {len(nifti_files)/nifti_elapsed:.2f} images/second" + ) + print( + f"DIMBLE loaded {len(dimble_files)} files in {dimble_elapsed:.4f} seconds, {len(dimble_files)/dimble_elapsed:.2f} images/second" + ) print(f"Speedup: {nifti_elapsed/dimble_elapsed:.2f}x") + if __name__ == "__main__": - plac.call(main) \ No newline at end of file + plac.call(main) diff --git a/scripts/skm_tea_to_dimble.py b/scripts/skm_tea_to_dimble.py index 6773d24..46c7e48 100644 --- a/scripts/skm_tea_to_dimble.py +++ b/scripts/skm_tea_to_dimble.py @@ -1,7 +1,10 @@ from pathlib import Path -import dimble -from tqdm import tqdm + import plac +from tqdm import tqdm + +import dimble + @plac.annotations( skm_tea_dicom_path=("Path to SKM-TEA DICOM directory", "positional", None, Path), @@ -10,9 +13,12 @@ def main(skm_tea_dicom_path: Path, skm_tea_dimble_path: Path): dicom_files = list(skm_tea_dicom_path.glob("**/*.dcm")) for dicom_file in tqdm(dicom_files): - dimble_file = skm_tea_dimble_path / dicom_file.relative_to(skm_tea_dicom_path).with_suffix(".dimble") + dimble_file = skm_tea_dimble_path / dicom_file.relative_to( + skm_tea_dicom_path + ).with_suffix(".dimble") dimble_file.parent.mkdir(parents=True, exist_ok=True) dimble.dicom_to_dimble(dicom_file, dimble_file) + if __name__ == "__main__": - plac.call(main) \ No newline at end of file + plac.call(main) diff --git a/test/test_sq.py b/test/test_sq.py index 61e8468..195ec6b 100644 --- a/test/test_sq.py +++ b/test/test_sq.py @@ -1,3 +1,4 @@ +# ruff: noqa: E501 import json from pathlib import Path From 94401e45759dfc4cb5e53b4f9d114cb4b7882d95 Mon Sep 17 00:00:00 2001 From: strongchris Date: Wed, 3 May 2023 04:42:23 +0000 Subject: [PATCH 03/11] remove dead code --- src/dimble_to_ir.rs | 139 -------------------------------------------- src/ir_to_dimble.rs | 139 -------------------------------------------- src/lib.rs | 116 ------------------------------------ 3 files changed, 394 deletions(-) diff --git a/src/dimble_to_ir.rs b/src/dimble_to_ir.rs index 9feef39..45b0fca 100644 --- a/src/dimble_to_ir.rs +++ b/src/dimble_to_ir.rs @@ -32,23 +32,6 @@ fn headerfield_and_bytes_to_dicom_fields( DicomValue::SeqField(sq_data) }) .collect::>(); - // for sq in sqs { - // let mut sq_data: DicomJsonData = DicomJsonData::new(); - // for (tag, header_field) in sq.iter() { - // let field: DicomField = - // headerfield_and_bytes_to_dicom_fields(tag, header_field, dimble_buffer); - // sq_data.insert(tag.to_string(), field); - // } - // seq_fields.push(DicomValue::SeqField(sq_data)); - // } - // let mut sq_data: DicomJsonData = DicomJsonData::new(); - - // let sq = sq.first().expect("should be at least one element"); - // for (tag, header_field) in sq.iter() { - // let field: DicomField = - // headerfield_and_bytes_to_dicom_fields(tag, header_field, dimble_buffer); - // sq_data.insert(tag.to_string(), field); - // } DicomField { value: Some(seq_fields), @@ -169,128 +152,6 @@ pub fn dimble_to_dicom_json(dimble_path: &str, json_path: &str) { serde_json::to_writer_pretty(json_file, &json_dicom).unwrap(); // TODO don't write pretty (this is for debugging) } -// pub fn dimble_to_dicom_json_old(dimble_path: &str, json_path: &str) { -// let dimble_file = fs::File::open(dimble_path).unwrap(); -// let dimble_buffer = unsafe { MmapOptions::new().map(&dimble_file).expect("mmap failed") }; - -// let (header, header_len) = deserialise_header(&dimble_buffer); - -// let mut json_dicom = DicomJsonData::new(); - -// for (tag, header_field) in header.iter() { -// match header_field { -// HeaderField::SQ(_sq) => { - -// } -// HeaderField::Deffered(field_pos, field_length, vr) => { -// let vr = String::from_utf8(vr.to_vec()).expect("expected vr to be utf8"); -// // inline_binary VRs are OB and OW. TODO support the other inline binary VRs -// let field_pos: usize = (*field_pos as usize) + header_len + 8; -// let field_length = *field_length as usize; -// let field_bytes = &dimble_buffer[field_pos..field_pos + field_length]; -// let dicom_field: DicomField = match vr.as_str() { -// "OB" | "OW" => { -// let inline_binary: String = match tag.as_str() { -// "7FE00010" => { -// // Pixel Data -// "TODO encode pixel data correctly".to_string() -// } -// _ => { -// let mut cursor = Cursor::new(field_bytes); -// let v = decode::read_value(&mut cursor).unwrap(); -// v.as_str().unwrap().to_string() -// } -// }; - -// DicomField { -// value: None, -// vr, -// inline_binary: Some(inline_binary), -// } -// } -// "PN" => { -// let mut cursor = Cursor::new(field_bytes); -// let v = decode::read_value(&mut cursor).unwrap(); -// let name = match v { -// Value::String(s) => s.into_str().unwrap(), -// _ => panic!("expected string"), -// }; -// let a = DicomValue::Alphabetic(Alphabetic { alphabetic: name }); -// DicomField { -// value: Some(vec![a]), -// vr, -// inline_binary: None, -// } -// } -// _ => { -// let mut cursor = Cursor::new(field_bytes); -// let v = decode::read_value(&mut cursor).unwrap(); -// let value: Vec = match v { -// Value::String(s) => vec![DicomValue::String(s.into_str().unwrap())], -// Value::Integer(i) => { -// if i.is_i64() { -// vec![DicomValue::Integer(i.as_i64().unwrap())] -// } else { -// vec![DicomValue::Integer(i.as_u64().unwrap() as i64)] -// } -// } -// Value::F64(f) => vec![DicomValue::Float(f)], -// Value::Array(a) => { -// let mut values = Vec::new(); -// for v in a { -// match v { -// Value::String(s) => { -// values.push(DicomValue::String(s.into_str().unwrap())) -// } -// Value::Integer(i) => { -// if i.is_i64() { -// values -// .push(DicomValue::Integer(i.as_i64().unwrap())) -// } else { -// values.push(DicomValue::Integer( -// i.as_u64().unwrap() as i64, -// )) -// } -// } -// Value::F64(f) => values.push(DicomValue::Float(f)), -// _ => { -// println!("unexpected value type: {:?}", v); -// panic!("unexpected value type") -// } -// }; -// } -// values -// } -// _ => { -// println!("unexpected value type: {:?}", v); -// panic!("unexpected value type") -// } -// }; -// DicomField { -// value: Some(value), -// vr, -// inline_binary: None, -// } -// } -// }; -// json_dicom.insert(tag.into(), dicom_field); -// } -// HeaderField::Empty(vr) => { -// let vr = String::from_utf8(vr.to_vec()).unwrap(); -// let dicom_field = DicomField { -// value: None, -// vr, -// inline_binary: None, -// }; -// json_dicom.insert(tag.into(), dicom_field); -// } -// } -// } - -// let json_file = fs::File::create(json_path).unwrap(); -// serde_json::to_writer_pretty(json_file, &json_dicom).unwrap(); // TODO don't write pretty (this is for debugging) -// } - fn deserialise_header(buffer: &[u8]) -> (HeaderFieldMap, usize) { let header_len = u64::from_le_bytes(buffer[0..8].try_into().unwrap()) as usize; let header: HeaderFieldMap = diff --git a/src/ir_to_dimble.rs b/src/ir_to_dimble.rs index d1181c2..944ae43 100644 --- a/src/ir_to_dimble.rs +++ b/src/ir_to_dimble.rs @@ -26,103 +26,6 @@ fn extend_and_make_field(data_bytes: &mut Vec, field_bytes: &[u8], vr: VR) - pub type HeaderFieldMap = HashMap; -// enum FieldBytes { -// Bytes(Vec), // TODO ensure this is zero copy -// Missing, -// NotSupported, -// } - -// fn get_field_bytes( -// tag: &str, -// dicom_field: &DicomField, -// pixel_array_safetensors_path: Option<&str>, -// ) -> FieldBytes { -// let field_bytes = match dicom_field { -// DicomField { -// value: Some(value), -// vr, -// inline_binary: None, -// } => -// //"normal case -> PACK", -// { -// match value.as_slice() { -// [DicomValue::String(s)] => to_vec(&s).unwrap(), -// [DicomValue::Integer(u)] => to_vec(&u).unwrap(), -// [DicomValue::Float(u)] => to_vec(&u).unwrap(), -// [DicomValue::Alphabetic(u)] => to_vec(&u.alphabetic).unwrap(), -// [DicomValue::SeqField(_seq)] => { -// return FieldBytes::NotSupported; -// } -// [] if vr == "SQ" => return FieldBytes::NotSupported, -// many => match many -// .first() -// .expect("This should definitely have a first element") -// { -// DicomValue::String(_) => to_vec( -// &many -// .iter() -// .map(|v| match v { -// DicomValue::String(s) => s.to_owned(), -// _ => panic!("{tag} expected only strings"), -// }) -// .collect::>(), -// ) -// .unwrap(), -// DicomValue::Integer(_) => to_vec( -// &many -// .iter() -// .map(|v| match v { -// DicomValue::Integer(i) => *i, -// _ => panic!("{tag} expected only strings"), -// }) -// .collect::>(), -// ) -// .unwrap(), -// DicomValue::Float(_) => to_vec( -// &many -// .iter() -// .map(|v| match v { -// DicomValue::Float(f) => *f, -// _ => panic!("{tag} expected only strings"), -// }) -// .collect::>(), -// ) -// .unwrap(), -// DicomValue::SeqField(_) => { -// return FieldBytes::NotSupported; -// } -// other => panic!("{tag} unexpected value type {:?}", other), -// }, -// } -// } -// DicomField { -// value: None, -// vr: _string, -// inline_binary: None, -// } => -// // "strange empty value case -> mark as missing", -// { -// return FieldBytes::Missing; -// } -// DicomField { -// value: None, -// vr: _string, -// inline_binary: Some(inline_binary), -// } => match tag { -// "7FE00010" => get_file_bytes( -// pixel_array_safetensors_path.expect("expected pixel_array_safetensors_path"), -// ), -// _ => to_vec(&inline_binary).unwrap(), -// }, -// DicomField { -// value: Some(_), -// vr: _string, -// inline_binary: Some(_), -// } => panic!("value and inline binary both present"), -// }; -// FieldBytes::Bytes(field_bytes) -// } - fn get_file_bytes(safetensors_path: &str) -> Vec { let mut f = fs::File::open(safetensors_path).unwrap(); let mut buffer = Vec::new(); @@ -276,35 +179,6 @@ fn prepare_dicom_fields_for_serialisation( (header_fields, data_bytes) } -// fn prepare_dicom_fields_for_serialisation( -// dicom_fields: DicomJsonData, -// pixel_array_safetensors_path: Option<&str>, -// ) -> (HeaderFieldMap, Vec) { -// let mut header_fields: HeaderFieldMap = HeaderFieldMap::new(); -// let mut data_bytes: Vec = Vec::new(); -// let mut offset: u64 = 0; - -// for (tag, dicom_field) in dicom_fields { -// let vr: VR = dicom_field.vr.as_bytes().try_into().unwrap(); -// match get_field_bytes(&tag, &dicom_field, pixel_array_safetensors_path) { -// FieldBytes::Bytes(bytes) => { -// let field_length = bytes.len() as u64; -// data_bytes.extend(bytes); -// header_fields.insert(tag, HeaderField::Deffered(offset, field_length, vr)); -// offset += field_length; -// } -// FieldBytes::Missing => { -// header_fields.insert(tag, HeaderField::Empty(vr)); -// } -// FieldBytes::NotSupported => { -// // TODO emit warning -// } -// } -// } - -// (header_fields, data_bytes) -// } - fn serialise_dimble_fields(header_fields: HeaderFieldMap, data_bytes: Vec, dimble_path: &str) { let mut file = fs::File::create(dimble_path).unwrap(); let mut file_copy = file.try_clone().unwrap(); // copy this because rust complains about borrowing file twice @@ -452,17 +326,4 @@ mod tests { let _decoded = rmpv::decode::read_value(&mut cursor).unwrap(); } - - // #[test] - // fn test_get_field_bytes() { - // let dicom_field = DicomField { - // vr: "CS".to_string(), - // value: Some(vec![DicomValue::String("ORIGINAL".to_string())]), - // inline_binary: None, - // }; - - // let field_bytes = get_field_bytes("00001111", &dicom_field, None); - - // assert!(matches!(field_bytes, FieldBytes::Bytes(_))); - // } } diff --git a/src/lib.rs b/src/lib.rs index b758670..86babfc 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -20,43 +20,6 @@ use std::fs::File; use std::io::Cursor; static TORCH_MODULE: GILOnceCell> = GILOnceCell::new(); - -// #[derive(Debug)] -// pub enum DimbleError { -// HeaderTooLarge, -// HeaderTooSmall, -// IoError(std::io::Error), -// MsgpackError(rmp_serde::decode::Error), -// MsgpackValueError(rmpv::decode::Error), -// JsonError(serde_json::Error), -// } - -// impl From for DimbleError { -// fn from(err: std::io::Error) -> Self { -// DimbleError::IoError(err) -// } -// } - -// impl From for DimbleError { -// fn from(err: rmp_serde::decode::Error) -> Self { -// DimbleError::MsgpackError(err) -// } -// } - -// impl From for DimbleError { -// fn from(err: rmpv::decode::Error) -> Self { -// DimbleError::MsgpackValueError(err) -// } -// } - -// impl std::fmt::Display for DimbleError { -// fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { -// write!(f, "{self:?}") -// } -// } - -// impl std::error::Error for DimbleError {} - #[pyfunction] fn dicom_json_to_dimble( json_path: &str, @@ -326,7 +289,6 @@ fn header_fields_and_buffer_to_pydict( } Some(HeaderField::SQ(sq)) => { // return all fields of the sequence (In the future we might support lazy loading of sequence items) - // let sq = sq.first().expect("sq should have at least one item"); let sq_dict = header_fields_and_buffer_to_pydict( py, @@ -415,84 +377,6 @@ fn load_dimble( Ok(dataset) } -// #[pyfunction] -// fn load_dimble( -// filename: &str, -// fields: Vec<&str>, -// device: &str, -// slices: Option>, -// ) -> PyResult { -// let file = File::open(filename) -// .map_err(|_| PyFileNotFoundError::new_err(format!("file not found: {}", filename)))?; -// let buffer = unsafe { MmapOptions::new().map(&file).expect("mmap should work") }; - -// let header_len = u64::from_le_bytes( -// buffer[0..8].try_into().map_err(|e| { -// DimbleError::new_err(format!( -// "safetensors object should have 8 byte header len: {e:?}" -// )) -// })?, // .expect("file should have 8 byte header"), -// ) as usize; - -// let header: HeaderFieldMap = -// rmp_serde::from_slice(&buffer[8..8 + header_len]).map_err(|e| { -// DimbleError::new_err(format!( -// "safetensors object should have valid msgpack header: {e:?}" -// )) -// })?; - -// Python::with_gil(|py| -> PyResult { -// let obj = PyDict::new(py); - -// for field in fields { -// match header.get(field) { -// Some(HeaderField::Deffered(field_pos, field_length, _vr)) => { - -// let field_pos = (*field_pos as usize) + header_len + 8; -// let field_length = *field_length as usize; - -// match field { -// "7FE00010" => { -// let tensor = load_pixel_array( -// filename, -// field_pos, -// field_length, -// device, -// slices.clone(), -// )?; -// obj.set_item("7FE00010", tensor) -// .expect("inserting should work"); -// } -// _ => { -// let field_bytes = &buffer[field_pos..field_pos + field_length]; -// let mut cursor = Cursor::new(field_bytes); -// let field_value = read_value(&mut cursor).expect("msg"); -// let py_field = value_to_py(py, field_value); -// obj.set_item(field, py_field) -// .expect("inserting should work"); -// } -// } -// }, -// Some(HeaderField::SQ(sq)) => { -// let sq = sq.first().expect("sq should have at least one item"); -// for (tag, sq_field) in sq.iter() { - -// } -// }, -// Some(HeaderField::Empty(_vr)) => { -// obj.set_item(field, py.None()) -// .expect("inserting should work"); -// } -// None => { -// panic!("field not found: {}", field); -// } -// } -// } - -// Ok(obj.to_object(py)) -// }) -// } - pyo3::create_exception!( dimble_rs, DimbleError, From 54de82c6f05e0664726b46d1cb10a3456d17f734 Mon Sep 17 00:00:00 2001 From: strongchris Date: Thu, 4 May 2023 06:54:25 +0000 Subject: [PATCH 04/11] integreate pytest-bench --- Makefile | 5 ++++- test/test_dicom_e2e.py | 13 +++++++------ test/test_nifti_e2e.py | 9 ++++++--- 3 files changed, 17 insertions(+), 10 deletions(-) diff --git a/Makefile b/Makefile index cdc8903..c8a7549 100644 --- a/Makefile +++ b/Makefile @@ -14,7 +14,10 @@ prep_test: test: prep_test cargo test - pytest + pytest --benchmark-disable + +bench: prep_test + pytest --benchmark-enable --benchmark-group-by=fullfunc fmt: cargo fmt diff --git a/test/test_dicom_e2e.py b/test/test_dicom_e2e.py index a9a505b..70b5719 100644 --- a/test/test_dicom_e2e.py +++ b/test/test_dicom_e2e.py @@ -42,24 +42,25 @@ @pytest.mark.parametrize("dicom_file", dicom_files, ids=dicom_files_ids) -def test_dicom_to_dimble(dicom_file: Path): +def test_dicom_to_dimble(dicom_file: Path, benchmark): dimble_file = Path("/tmp") / dicom_file.with_suffix(".dimble").name - pydicom.dcmread(dicom_file) dimble.dicom_to_dimble(dicom_file, dimble_file) + benchmark(dimble.dicom_to_dimble, dicom_file, dimble_file) + @pytest.mark.parametrize("dicom_file", dicom_files, ids=dicom_files_ids) -def test_load_dimble(dicom_file: Path): +def test_load_dimble(dicom_file: Path, benchmark): dimble_file = Path("/tmp") / dicom_file.with_suffix(".dimble").name - pydicom.dcmread(dicom_file) dimble.dicom_to_dimble(dicom_file, dimble_file) dimble.load_dimble(dimble_file, [PIXEL_ARRAY]) + benchmark(dimble.load_dimble, dimble_file, [PIXEL_ARRAY]) @pytest.mark.parametrize("dicom_file", dicom_files, ids=dicom_files_ids) -def test_dimble_to_dicom(dicom_file: Path): +def test_dimble_to_dicom(dicom_file: Path, benchmark): dimble_file = Path("/tmp") / dicom_file.with_suffix(".dimble").name - pydicom.dcmread(dicom_file) dimble.dicom_to_dimble(dicom_file, dimble_file) reconstructed_dicom_file = Path("/tmp") / dicom_file.with_suffix(".recon.dcm").name dimble.dimble_to_dicom(dimble_file, reconstructed_dicom_file) + benchmark(dimble.dimble_to_dicom, dimble_file, reconstructed_dicom_file) diff --git a/test/test_nifti_e2e.py b/test/test_nifti_e2e.py index 6f86b16..faca46e 100644 --- a/test/test_nifti_e2e.py +++ b/test/test_nifti_e2e.py @@ -19,21 +19,24 @@ @pytest.mark.parametrize("nifti_file", nifti_files, ids=nifti_files_ids) -def test_nifti_to_dimble(nifti_file: Path): +def test_nifti_to_dimble(nifti_file: Path, benchmark): dimble_file = Path("/tmp") / nifti_file.with_suffix(".dimble").name dimble.nifti_to_dimble(nifti_file, dimble_file) + benchmark(dimble.nifti_to_dimble, nifti_file, dimble_file) @pytest.mark.parametrize("nifti_file", nifti_files, ids=nifti_files_ids) -def test_load_dimble(nifti_file: Path): +def test_load_dimble(nifti_file: Path, benchmark): dimble_file = Path("/tmp") / nifti_file.with_suffix(".dimble").name dimble.nifti_to_dimble(nifti_file, dimble_file) dimble.load_dimble(dimble_file, [PIXEL_ARRAY]) + benchmark(dimble.load_dimble, dimble_file, [PIXEL_ARRAY]) @pytest.mark.parametrize("nifti_file", nifti_files, ids=nifti_files_ids) -def test_dimble_to_nifti(nifti_file: Path): +def test_dimble_to_nifti(nifti_file: Path, benchmark): dimble_file = Path("/tmp") / nifti_file.with_suffix(".dimble").name dimble.nifti_to_dimble(nifti_file, dimble_file) nifti_file = Path("/tmp") / dimble_file.with_suffix(".nii.gz").name dimble.dimble_to_nifti(dimble_file, nifti_file) + benchmark(dimble.dimble_to_nifti, dimble_file, nifti_file) From ed9c94fe630c5a14fb7c6cbb77afff756cd1f2f6 Mon Sep 17 00:00:00 2001 From: strongchris Date: Wed, 10 May 2023 04:13:33 +0000 Subject: [PATCH 05/11] add dimble comparisons --- .gitignore | 1 + Makefile | 3 + scripts/benchmark-analysis.ipynb | 840 +++++++++++++++++++++++++++++++ test/pydicom_comparisons.py | 139 +++++ 4 files changed, 983 insertions(+) create mode 100644 scripts/benchmark-analysis.ipynb create mode 100644 test/pydicom_comparisons.py diff --git a/.gitignore b/.gitignore index da6a037..6563744 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ +.benchmarks niivue-images/ pydicom-data/ downloaded_testfiles/ diff --git a/Makefile b/Makefile index c8a7549..830ce20 100644 --- a/Makefile +++ b/Makefile @@ -19,6 +19,9 @@ test: prep_test bench: prep_test pytest --benchmark-enable --benchmark-group-by=fullfunc +bench-pydicom-vs-sitk: + pytest test/pydicom_comparisons.py --benchmark-group-by=param -s --benchmark-save=pydicom_comparisons + fmt: cargo fmt isort . diff --git a/scripts/benchmark-analysis.ipynb b/scripts/benchmark-analysis.ipynb new file mode 100644 index 0000000..26cc18b --- /dev/null +++ b/scripts/benchmark-analysis.ipynb @@ -0,0 +1,840 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "38426611-7ac3-47ee-a451-9940ddd8c741", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_235664/2217170361.py:7: MatplotlibDeprecationWarning: The seaborn styles shipped by Matplotlib are deprecated since 3.6, as they no longer correspond to the styles shipped by seaborn. However, they will remain available as 'seaborn-v0_8-\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
loadertest_dimble_readtest_gdcm_readtest_pydicom_readtest_sitk_read
param
693_J2KR.dcm0.0001510.0070730.0074510.016697
693_UNCI.dcm0.0001430.0070390.0010280.007817
693_UNCR.dcm0.0001580.0065180.0008210.007838
JPEG-LL.dcm0.0001660.0023080.0036140.003468
JPEG2000_UNC.dcm0.0001590.0006930.0011480.001496
JPGLosslessP14SV1_1s_1f_8b.dcm0.0002010.0044320.0058090.005275
MR-SIEMENS-DICOM-WithOverlays.dcm0.0001660.0012850.0008770.003031
MR2_J2KI.dcm0.0002380.0194850.0217750.023439
MR2_J2KR.dcm0.0002250.0203330.0226250.025712
MR2_UNCI.dcm0.0002160.0027460.0013760.004795
MR2_UNCR.dcm0.0002100.0027530.0011720.004735
OBXXXX1A.dcm0.0001810.0006240.0014310.002794
OBXXXX1A_2frame.dcm0.0002190.0025700.0016220.004973
OBXXXX1A_expb.dcm0.0001830.0007390.0008800.003128
OBXXXX1A_expb_2frame.dcm0.0002160.0027460.0010740.005714
OBXXXX1A_rle.dcm0.0001950.0018220.0042990.005806
OBXXXX1A_rle_2frame.dcm0.0002120.0049690.0074090.011326
RG1_J2KI.dcm0.0003640.0877400.1000310.152415
RG1_J2KR.dcm0.0003620.1031280.1194140.168540
RG1_UNCI.dcm0.0003660.0424540.0031330.108674
RG1_UNCR.dcm0.0003580.0434040.0028490.107720
RG3_J2KI.dcm0.0003260.0466080.0589930.127058
RG3_J2KR.dcm0.0004400.0473060.0603420.123870
RG3_UNCI.dcm0.0003250.0204190.0024240.090956
RG3_UNCR.dcm0.0003220.0207080.0021970.094189
SC_rgb.dcm0.0000660.0001480.0006240.000944
SC_rgb_16bit.dcm0.0000660.0002480.0006060.000920
SC_rgb_16bit_2frame.dcm0.0001030.0003800.0006430.001009
SC_rgb_2frame.dcm0.0001030.0002190.0006620.000978
SC_rgb_dcmtk_ebcr_dcmd.dcm0.0000690.0001640.0006320.000989
SC_rgb_dcmtk_ebcyn1_dcmd.dcm0.0000690.0001500.0006360.000987
SC_rgb_dcmtk_ebcyn2_dcmd.dcm0.0000690.0001540.0006170.000988
SC_rgb_dcmtk_ebcynp_dcmd.dcm0.0000690.0001520.0006360.000996
SC_rgb_dcmtk_ebcys2_dcmd.dcm0.0000700.0001520.0006360.000945
SC_rgb_dcmtk_ebcys4_dcmd.dcm0.0000690.0001570.0006090.000939
SC_rgb_expb.dcm0.0000670.0001490.0006100.000954
SC_rgb_expb_16bit.dcm0.0000670.0002550.0006320.000963
SC_rgb_expb_16bit_2frame.dcm0.0001060.0003860.0006740.000964
SC_rgb_expb_2frame.dcm0.0001240.0002210.0006610.000990
SC_rgb_gdcm2k_uncompressed.dcm0.0000700.0001570.0008250.000986
US1_UNCI.dcm0.0001960.0010490.0011330.001559
US1_UNCR.dcm0.0001930.0008650.0009460.001548
color-pl.dcm0.0001100.0001250.0006080.001037
color-px.dcm0.0001080.0001220.0006000.000988
eCT_Supplemental.dcm0.0002120.0006880.0025530.001924
emri_small.dcm0.0001190.0002750.0008600.001292
emri_small_RLE.dcm0.0001190.0020060.0015920.005799
emri_small_big_endian.dcm0.0001180.0003230.0008550.001381
emri_small_jpeg_2k_lossless.dcm0.0001210.0154290.0157860.019530
emri_small_jpeg_ls_lossless.dcm0.0001190.0013120.0023060.002410
gdcm-US-ALOKA-16.dcm0.0001480.0026330.0007710.010804
gdcm-US-ALOKA-16_big.dcm0.0001540.0027690.0008190.011361
liver.dcm0.0002200.0002150.0029990.001493
liver_expb.dcm0.0002180.0002310.0008750.001517
mlut_18.dcm0.0001390.0077210.0006870.007588
vlut_04.dcm0.0001420.0005750.0006380.001076
\n", + "" + ], + "text/plain": [ + "loader test_dimble_read test_gdcm_read \n", + "param \n", + "693_J2KR.dcm 0.000151 0.007073 \\\n", + "693_UNCI.dcm 0.000143 0.007039 \n", + "693_UNCR.dcm 0.000158 0.006518 \n", + "JPEG-LL.dcm 0.000166 0.002308 \n", + "JPEG2000_UNC.dcm 0.000159 0.000693 \n", + "JPGLosslessP14SV1_1s_1f_8b.dcm 0.000201 0.004432 \n", + "MR-SIEMENS-DICOM-WithOverlays.dcm 0.000166 0.001285 \n", + "MR2_J2KI.dcm 0.000238 0.019485 \n", + "MR2_J2KR.dcm 0.000225 0.020333 \n", + "MR2_UNCI.dcm 0.000216 0.002746 \n", + "MR2_UNCR.dcm 0.000210 0.002753 \n", + "OBXXXX1A.dcm 0.000181 0.000624 \n", + "OBXXXX1A_2frame.dcm 0.000219 0.002570 \n", + "OBXXXX1A_expb.dcm 0.000183 0.000739 \n", + "OBXXXX1A_expb_2frame.dcm 0.000216 0.002746 \n", + "OBXXXX1A_rle.dcm 0.000195 0.001822 \n", + "OBXXXX1A_rle_2frame.dcm 0.000212 0.004969 \n", + "RG1_J2KI.dcm 0.000364 0.087740 \n", + "RG1_J2KR.dcm 0.000362 0.103128 \n", + "RG1_UNCI.dcm 0.000366 0.042454 \n", + "RG1_UNCR.dcm 0.000358 0.043404 \n", + "RG3_J2KI.dcm 0.000326 0.046608 \n", + "RG3_J2KR.dcm 0.000440 0.047306 \n", + "RG3_UNCI.dcm 0.000325 0.020419 \n", + "RG3_UNCR.dcm 0.000322 0.020708 \n", + "SC_rgb.dcm 0.000066 0.000148 \n", + "SC_rgb_16bit.dcm 0.000066 0.000248 \n", + "SC_rgb_16bit_2frame.dcm 0.000103 0.000380 \n", + "SC_rgb_2frame.dcm 0.000103 0.000219 \n", + "SC_rgb_dcmtk_ebcr_dcmd.dcm 0.000069 0.000164 \n", + "SC_rgb_dcmtk_ebcyn1_dcmd.dcm 0.000069 0.000150 \n", + "SC_rgb_dcmtk_ebcyn2_dcmd.dcm 0.000069 0.000154 \n", + "SC_rgb_dcmtk_ebcynp_dcmd.dcm 0.000069 0.000152 \n", + "SC_rgb_dcmtk_ebcys2_dcmd.dcm 0.000070 0.000152 \n", + "SC_rgb_dcmtk_ebcys4_dcmd.dcm 0.000069 0.000157 \n", + "SC_rgb_expb.dcm 0.000067 0.000149 \n", + "SC_rgb_expb_16bit.dcm 0.000067 0.000255 \n", + "SC_rgb_expb_16bit_2frame.dcm 0.000106 0.000386 \n", + "SC_rgb_expb_2frame.dcm 0.000124 0.000221 \n", + "SC_rgb_gdcm2k_uncompressed.dcm 0.000070 0.000157 \n", + "US1_UNCI.dcm 0.000196 0.001049 \n", + "US1_UNCR.dcm 0.000193 0.000865 \n", + "color-pl.dcm 0.000110 0.000125 \n", + "color-px.dcm 0.000108 0.000122 \n", + "eCT_Supplemental.dcm 0.000212 0.000688 \n", + "emri_small.dcm 0.000119 0.000275 \n", + "emri_small_RLE.dcm 0.000119 0.002006 \n", + "emri_small_big_endian.dcm 0.000118 0.000323 \n", + "emri_small_jpeg_2k_lossless.dcm 0.000121 0.015429 \n", + "emri_small_jpeg_ls_lossless.dcm 0.000119 0.001312 \n", + "gdcm-US-ALOKA-16.dcm 0.000148 0.002633 \n", + "gdcm-US-ALOKA-16_big.dcm 0.000154 0.002769 \n", + "liver.dcm 0.000220 0.000215 \n", + "liver_expb.dcm 0.000218 0.000231 \n", + "mlut_18.dcm 0.000139 0.007721 \n", + "vlut_04.dcm 0.000142 0.000575 \n", + "\n", + "loader test_pydicom_read test_sitk_read \n", + "param \n", + "693_J2KR.dcm 0.007451 0.016697 \n", + "693_UNCI.dcm 0.001028 0.007817 \n", + "693_UNCR.dcm 0.000821 0.007838 \n", + "JPEG-LL.dcm 0.003614 0.003468 \n", + "JPEG2000_UNC.dcm 0.001148 0.001496 \n", + "JPGLosslessP14SV1_1s_1f_8b.dcm 0.005809 0.005275 \n", + "MR-SIEMENS-DICOM-WithOverlays.dcm 0.000877 0.003031 \n", + "MR2_J2KI.dcm 0.021775 0.023439 \n", + "MR2_J2KR.dcm 0.022625 0.025712 \n", + "MR2_UNCI.dcm 0.001376 0.004795 \n", + "MR2_UNCR.dcm 0.001172 0.004735 \n", + "OBXXXX1A.dcm 0.001431 0.002794 \n", + "OBXXXX1A_2frame.dcm 0.001622 0.004973 \n", + "OBXXXX1A_expb.dcm 0.000880 0.003128 \n", + "OBXXXX1A_expb_2frame.dcm 0.001074 0.005714 \n", + "OBXXXX1A_rle.dcm 0.004299 0.005806 \n", + "OBXXXX1A_rle_2frame.dcm 0.007409 0.011326 \n", + "RG1_J2KI.dcm 0.100031 0.152415 \n", + "RG1_J2KR.dcm 0.119414 0.168540 \n", + "RG1_UNCI.dcm 0.003133 0.108674 \n", + "RG1_UNCR.dcm 0.002849 0.107720 \n", + "RG3_J2KI.dcm 0.058993 0.127058 \n", + "RG3_J2KR.dcm 0.060342 0.123870 \n", + "RG3_UNCI.dcm 0.002424 0.090956 \n", + "RG3_UNCR.dcm 0.002197 0.094189 \n", + "SC_rgb.dcm 0.000624 0.000944 \n", + "SC_rgb_16bit.dcm 0.000606 0.000920 \n", + "SC_rgb_16bit_2frame.dcm 0.000643 0.001009 \n", + "SC_rgb_2frame.dcm 0.000662 0.000978 \n", + "SC_rgb_dcmtk_ebcr_dcmd.dcm 0.000632 0.000989 \n", + "SC_rgb_dcmtk_ebcyn1_dcmd.dcm 0.000636 0.000987 \n", + "SC_rgb_dcmtk_ebcyn2_dcmd.dcm 0.000617 0.000988 \n", + "SC_rgb_dcmtk_ebcynp_dcmd.dcm 0.000636 0.000996 \n", + "SC_rgb_dcmtk_ebcys2_dcmd.dcm 0.000636 0.000945 \n", + "SC_rgb_dcmtk_ebcys4_dcmd.dcm 0.000609 0.000939 \n", + "SC_rgb_expb.dcm 0.000610 0.000954 \n", + "SC_rgb_expb_16bit.dcm 0.000632 0.000963 \n", + "SC_rgb_expb_16bit_2frame.dcm 0.000674 0.000964 \n", + "SC_rgb_expb_2frame.dcm 0.000661 0.000990 \n", + "SC_rgb_gdcm2k_uncompressed.dcm 0.000825 0.000986 \n", + "US1_UNCI.dcm 0.001133 0.001559 \n", + "US1_UNCR.dcm 0.000946 0.001548 \n", + "color-pl.dcm 0.000608 0.001037 \n", + "color-px.dcm 0.000600 0.000988 \n", + "eCT_Supplemental.dcm 0.002553 0.001924 \n", + "emri_small.dcm 0.000860 0.001292 \n", + "emri_small_RLE.dcm 0.001592 0.005799 \n", + "emri_small_big_endian.dcm 0.000855 0.001381 \n", + "emri_small_jpeg_2k_lossless.dcm 0.015786 0.019530 \n", + "emri_small_jpeg_ls_lossless.dcm 0.002306 0.002410 \n", + "gdcm-US-ALOKA-16.dcm 0.000771 0.010804 \n", + "gdcm-US-ALOKA-16_big.dcm 0.000819 0.011361 \n", + "liver.dcm 0.002999 0.001493 \n", + "liver_expb.dcm 0.000875 0.001517 \n", + "mlut_18.dcm 0.000687 0.007588 \n", + "vlut_04.dcm 0.000638 0.001076 " + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.DataFrame(data['benchmarks'])\n", + "df['median'] = df.stats.apply(lambda x: x['median'])\n", + "df['loader'] = df.name.apply(lambda x: x.split('[')[0])\n", + "df = df[['loader', 'param', 'median']]\n", + "df = df.set_index(['loader', 'param']).unstack().T.droplevel(0)\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "f1941536-3f00-480b-8c95-cab38c7f5416", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAD18AAARDCAYAAACd7wnAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeZiWZd3/8Q/DsAgIDGCCsoqAKyoZrrnbU5pmkv7UsDJyR1xwwR1UkNxSFFFUcMkl0Xa13aWex0oTN0TDVFDcEVJhFBj4/VHN80znrQIii71ex+HR3Nd1znmd91un/77H1Wjx4sWLAwAAAAAAAAAAAAAAAAAA8B+uamUfAAAAAAAAAAAAAAAAAAAAYFVg+BoAAAAAAAAAAAAAAAAAACCGrwEAAAAAAAAAAAAAAAAAAJIYvgYAAAAAAAAAAAAAAAAAAEhi+BoAAAAAAAAAAAAAAAAAACCJ4WsAAAAAAAAAAAAAAAAAAIAkhq8BAAAAAAAAAAAAAAAAAACSGL4GAAAAAAAAAAAAAAAAAABIklSv7AMsT2+88c7KPkKqqhqlXbuWeeutuVm0aPHKPs4qQZPKdClpUtKkpElJk8p0KWlS0qSkSUmTynQpaVLSpKRJSZPKdClpUtKkpElJk8p0KWlS0qSkSUmTkiaV6VLSpKRJSZOSJpXpUtKkpElJk5ImlelS0qSkSUmTkiaV6VLSpKRJSZOSJpXpUtKkpElJk5ImlelS0qS0qjVZa601P3KNN18vZ1VVjdKoUaNUVTVa2UdZZWhSmS4lTUqalDQpaVKZLiVNSpqUNClpUpkuJU1KmpQ0KWlSmS4lTUqalDQpaVKZLiVNSpqUNClpUtKkMl1KmpQ0KWlS0qQyXUqalDQpaVLSpDJdSpqUNClpUtKkMl1KmpQ0KWlS0qQyXUqalDQpaVLSpDJdSpqUVscmhq8BAAAAAAAAAAAAAAAAAABi+BoAAAAAAAAAAAAAAAAAACCJ4WsAAAAAAAAAAAAAAAAAAIAkhq8BAAAAAAAAAAAAAAAAAACSGL4GAAAAAAAAAAAAAAAAAABIYvgaAAAAAAAAAAAAAAAAAAAgieFrAAAAAAAAAAAAAAAAAACAJIavAQAAAAAAAAAAAAAAAAAAkhi+BgAAAAAAAAAAAAAAAAAASGL4GgAAAAAAAAAAAAAAAAAAIInhawAAAAAAAAAAAAAAAAAAgCSGrwEAAAAAAAAAAAAAAAAAAJIYvgYAAAAAAAAAAAAAAAAAgHqDBx+Wyy67eLV/BsvG8DUAAAAAAAAAAAAAAAAAAEAMXwMAAAAAAAAAAAAAAAAAwGqlrq4uixYtWtnH+FSqXtkHAAAAAAAAAAAAAAAAAACAVdHbb7+dyy67KP/937/PggXzs/nmn81xx52YLl26Jkn+/vc5ueSSC/LYY5PzzjvvpFu3rhk48FvZZZcv1O9RW1ubiy46Pw88cG9atGiRAw44uHjO/PnzM378lfnNb36Zd999Jz169MyRRx6Tfv22TJLcfffPMmbMxTnjjBG56qor8uKLM3LbbT9Kp07rrJgQ/0EMXwMAAAAAAAAAAAAAAAAAQAWjRg3PSy+9mO9+95K0aNEy48ZdnpNOOjbf//6kVFdXZ/78+enTZ8MMHPjNtG69ZiZP/nNGjDgzHTuuk4022iRJMnbsZXn00Udy/vkXp6amXa6+emz++tdn0qtXn/rnfO97F+SFF57LiBGj0qHDWrn//ntz4olDcsMNt9UPer/33nu5+eYbcsopZ6RNmzapqWm3Upp82lWt7AMAAAAAAAAAAAAAAAAAAMCq5sUXZ+QPf3ggp5xyRjbbbIv06tU7Z599bt544/U88MB9SZK11vpMDjro4PTq1Sfrrts5Bx98cLbeepv87ne/SZLMmzcvd931kxx99HHZcsv+6dlz/ZxxxvDU1S2sf86rr76au+/+Wc4997vZbLMtsu66nXPQQQdn0003z913/6x+3cKFC3PCCcOy6aabpWvX7mnevPkK7fGfwpuvAQAAAAAAAAAAAAAAAADg30yf/nwaN25c/wbrJGnTpm26du2W6dOfT5LU1dXlppsm5ne/+3XefPONLFy4MO+/Pz9Nm/5jMHrmzJeyYMGCBnu0bt0mXbt2q//83HPPpq6uLgceuG+D58+fPz9t2rSp/9ykSZOsv36vT+S78r8MXwMAAAAAAAAAAAAAAAAAwDK45ZabMmnSrRkyZGh69+6dtddulxEjzsnChQuWeI/a2nlp3LhxrrvuplRVNW5wb4011qj/uVmzZmnUqNFyOzuVVa3sAwAAAAAAAAAAAAAAAAAAwKqmW7ceqaury1NPPVl/7e9/n5MZM6ane/ceSZInnngs22+/Y/7rv/ZIr16906VLl8yYMaN+/brrdk51dXWDPd5+++28+OL/runVq0/q6uoye/bsdO7cpcE/7dt3WAHflP/Lm68BAAAAAAAAAAAAAAAAAODfdOnSNZ///I757ndH5qSTTkuLFi1y1VVXZK21PpPPf36nf67pknvv/W2eeOKxtG3bJj/84Q/y1ltv1Q9nt2jRIl/+8ldy5ZWXpU2bNqmpqcn48VemUaP/fb9y167d8oUvfCnnnXd2Bg8+Lr169cmcObPzl788lJ49e2XbbbdfGV//P5bhawAAAAAAAAAAAAAAAAAAqODUU8/OZZddlFNOOS4LFizIZpv1y4UXXpbq6n+M6H7zm4Py8sszc8IJx6R58+Y54ID/lx133CnvvPNO/R5HHXVsamvn5ZRTjk+LFi1zwAFfz7vvvtvgOaeddnZuuOG6XHHFpXnjjdfTpk3bbLzxptl228+v0O+L4WsAAAAAAAAAAAAAAAAAAKh3xRXj639u3bp1zjzznA9c27p1m5x//sVJkurqqtTUtMzs2XOzcOGi+jUtWrTImWeemzPP/N/fO+igbzTYp7q6OoMGHZ5Bgw6v+Jw99tgre+yx17J8HZZS1UcvAQAAAAAAAAAAAAAAAAAA+PQzfA0AAAAAAAAAAAAAAAAAABDD1wAAAAAAAAAAAAAAAAAAAEkMXwMAAAAAAAAAAAAAAAAAACQxfA0AAAAAAAAAAAAAAAAAAJDE8DUAAAAAAAAAAAAAAAAAAEASw9cAAAAAAAAAAAAAAAAAAABJDF8DAAAAAAAAAAAAAAAAAAAkMXwNAAAAAAAAAAAAAAAAAACQJKle2QcAAAAAAAAAAAAAAAAAAGDV8e3Rv1thz5owbJcV9qxP0iuvvJz99ts7P/7xj9OxY9c88sjDGTLkiNxzz71Zc801l3nfr31tr+y//4HZf/+DPnDN9ttvmVGjLsoOO+y0zM9ZWVbFs3vzNQAAAAAAAAAAAAAAAAAAq43Bgw/LZZddvNz2GzlyeE49dehy2y9JNt10s/zkJ79Iq1atluu+fPK8+RoAAAAA+FQYN/q+j1xz5LCdPvFzAAAAAAAAAAAAQJMmTdK+fYeVfYyPbcGCBWnSpMnKPsYKZfgaAAAAAAAAAAAAAAAAAIDVwsiRw/Poo4/k0UcfyaRJtyZJJk36aWpr52Xs2DF5/PHJad58jfTvv1WOOWZo2rZtmyS5997fZOLEa/LSSy+lefPm6dWrT0aPvji33HJj7rnn50mS7bffMkkyZsxV6ddvyw89x1NPPZkLLxyV6dNfSI8ePfONb3y7wf1HHnk4Q4YckXvuuTdrrrlm7r77Zxkz5uKceea5ueKK7+X111/LNttslzPOOCf33vubXHfd1Xn33XfzxS/ukWOOOSGNGzeu32vevHk5++zT8t///UBatVozBx98SAYM2P8Dz/baa6/miisuzUMP/TGNGlVls802z7HHnphOndZZor7vvvtONthgo/zwh5PStGnTTJr004/cc+rUKbn66rGZNu2ZLFy4ML169ckxx5yQjTfeqH7vF1+ckdGjz83UqVOyzjrr5thjl+/bxpcXw9cAAAAAAAAAAAAAAAAAAKwWjj32xLz44oz06NEz3/nO4UmS6urqHHroN7PXXvtkyJAT8v7772XcuMtz1lnDMmbMVXnzzTczfPjpOeqoIdlhh50zb968PPbY5CxevDgHHnhwpk9/IXPnzs1pp52VJGndus2HnmHevHk5+eTj87nPbZUzzzw3r7zyci677KKPPPt7772XO+64LSNGjMq8efNy+ukn5bTTTkyrVmvmwgsvy8svz8wZZ5ycTTfdLLvu+oX637vllpty8MGHZNCgw/PnPz+YMWMuTteuXfO5z21dPGPhwoUZOvSYbLzxphk79to0btw4N9xwXYYOPSY33HDbEr3F+uGHH0qLFi3zve+NXeI9582bly996cs5/viTs3jx4tx22/dz0knHZtKkH6empmUWLVqU008/KTU17XP11ddn7tx3M2bMxR95lpXB8DUAAAAAAAAAAAAAAAAAAKuFVq1apbq6Os2bN0/79h2SJNdff2169+6Tww8/un7dqaeelX333TMzZkxPbW1t6urqsuOOu6Rjx05Jkp49169f26xZsyxYML9+v4/y61//IosXL8qwYWemWbNmWW+9nnnjjddy0UWjP/T3Fi5cmBNPPDXrrts5SbLTTrvml7+8Oz/96a/SokWL9OixXrbYYss88sjDDYavN910sxx88LeSJF27dssTTzyWH/zglorD17/97a+yaNE/ztaoUaMkyWmnnZ0vfnGnTJ78l/TvX/7Ov1tjjTUybNiZ9YPav/zl3R+552c/+7kGe5x88un54hd3zuTJf0nnzl/KQw/9KdOnv5BLLrkiHTqslSQ57LCjc+KJQz7yPCua4WsAAAAAAAAAAAAAAAAAAFZbzz47LY888nB23/3zxb2ZM1/653Bw/3zjGwekf/+t07//1tlpp13TunXrZXre9OnPp2fPXmnWrFn9tY037vuRv9e8efP6weskadeufTp2XCctWrT4P9faZfbs2Q1+b5NNNm3weeON+2bSpFsrPuPZZ6dl5syX8oUv7NDg+vz58zNz5ksfecYkWW+9ng3ekL0ke7711qxcc824TJ78l8ye/VYWLVqU9957L6+++mqS5IUXns9nPtOxfvD6H9/ro5utDIavAQAAAAAAAAAAAAAAAABYbdXW1ma77T6fI48s36Lcvn2HNG7cOJdeOjZPPPFYHnroT7nzzh9k/PgrM3789VlnnXVX2Dmrq8ux3n+/1qhRoyxevGiZn1FbOy+9e2+Qs88+r7jXtm3NEu2xxhprLPWe5503PG+//fcce+zQrL12pzRt2jRHHHFIFi5csAzfYuUyfA0AAAAAAAAAAAAAAAAAwGqjSZMmWbSorv5z7959cv/9v0vHjp0qDjgn/xhq7tt38/Ttu3m+9a3v5Gtf2ysPPHBvDjhgYKqrm6SubskHnrt165Ff/vLuvP/++/Vvv54y5YmP96U+xL/vPWXKE+nWrXvFtb17b5Df/vbXqampScuWrZbL85dkzyeeeCxDh56SbbbZPkny2muvZs6cOfX3u3fvkddffzVvvvlmOnToUP89VkVVK/sAAAAAAAAAAAAAAAAAAACwpDp2XCdPPfVkXnnl5cyZMycDBuyft99+O8OHn56pU6dk5syX8qc/PZhRo0akrq4uU6Y8mRtvnJCnn34qr776au6//97MmTM73br1SJJ06tQpf/vbtMyY8ULmzJmThQsXfujzd9/9i2nUqFEuuOC8PP/8c3nwwT/kttu+/4l93yeeeCw333xDZsyYnjvvvD333ffb7LffgRXXfuELX0qbNm0zbNjQPPbY5Lz88sw88sjDufTSC/P6668t0/OXZM8uXbrkl7+8Oy+88HymTHky55xzZv1gepJ87nNbpUuXbhk58uxMm/bXPPbY5Iwff+UyneeT5s3XAAAAAAAAAAAAAAAAAADUmzBsl49cU11dlZqalpk9e24WLlzyt0YvDwceODAjRw7PwIH75f3338+kST/NuHHXZdy4y3P88YOzYMH8dOzYKVtttU2qqqrSsmXLPPro5Nx++62ZN29u1l67YwYPPi7bbLNdkmSvvb6ayZP/kkGDvpHa2nkZM+aq9Ou35Qc+v0WLFhk9+nu56KLz8+1vfz3du/fIkUcek9NPP/kT+b4HHDAwTz89NRMnXpOWLVtm8ODjs9VW21Rc27x584wdOz7jxl2e008/KfPmzUuHDmvls5/tn5YtWy7T85dkz2HDzswFF4zKt789MJ/5zNo5/PCjMnbsZfV7VFVVZdSoCzN69Lk57LBvpmPHTjnuuJMydOgxy3SmT5LhawAAAAAAAAAAAAAAAAAAVhtdu3bL1VdPLK6PGnVhxfXdu/fIJZdc/oH71dTU5HvfG7tUZ9hkk01z/fW3NLj2xz8+Uj+Q3q/flvnDHx6uv7fHHntljz32arB+0KDDM2jQ4Q2unX768Aaf77jjZx95lv/7nCRp375DzjhjxJJ8jcK/P39J9+zde4Nce+2NDa7tvPNuqa6uqv/ctWu3XHnltQ3W/PvZVwVVH70EAAAAAAAAAAAAAAAAAADg08+brwEAAAAAAAAAAAAAAAAA4J9uvHFCbrqpfLN2kvTtu0UuvnjMCj7R8rP77p//wHsXXTQmm222xQo8zarJ8DUAAAAAAAAAAAAAAAAAAPzTPvsMyC677F7xXrNmzVbwaZaviRNv+cB7a6211go8yarL8DUAAAAAAAAAAAAAAAAAAPxT69Zt0rp1m5V9jE9E585dVvYRVnlVK/sAAAAAAAAAAAAAAAAAAAAAqwLD1wAAAAAAAAAAAAAAAAAAADF8DQAAAAAAAAAAAAAAAAAAkMTwNQAAAAAAAAAAAAAAAAAAQBLD1wAAAAAAAAAAAAAAAAAAAEmS6pV9AAAAAAAAAAAAAAAAAAAAVh1H/+7kFfassbtcsMKetbI98sjDGTLkiNxzz71Zc801V/ZxPnEjRw7P3Lnv5pprrl7ZR1kq3nwNAAAAAAAAAAAAAAAAAMBqY/Dgw3LZZRcvt/1GjhyeU08dutz2Y/Vm+BoAAAAAAAAAAAAAAAAAAP7DLF68OAsXLlzZx1jlVK/sAwAAAAAAAAAAAAAAAAAAwJIYOXJ4Hn30kTz66COZNOnWJMmkST9Nbe28jB07Jo8/PjnNm6+R/v23yjHHDE3btm2TJPfe+5tMnHhNXnrppTRv3jy9evXJ6NEX55Zbbsw99/w8SbL99lsmScaMuSr9+m35oed44onHcvHF382MGS+kR4+e+eY3B+W0007Mj3/843Ts2DVJ8uCDf8hll12S119/LRtvvEm+9KUvF/s8/vijGT/+ykydOiVNmjTNRhttnOHDR6V169YZPPiw9Oy5fqqqGueee36eJk2a5NBDj8zuu38x3/veBbn33t+mXbt2Oe64k7LNNtt9ZLtHHnk4Q4YckQsvvCzXXDMuzz33bC655Ipsvnm/3HzzDfnpT3+UWbNmpUuXrvnWtwZl5513S5LU1dXlggtG5pFHHs6sWbOy9tpr56tf3S/7739g/d51dXW58srLctddP01VVeN8+ct7Z/HixR95plWR4WsAAAAAAAAAAAAAAAAAAFYLxx57Yl58cUZ69OiZ73zn8CRJdXV1Dj30m9lrr30yZMgJef/99zJu3OU566xhGTPmqrz55psZPvz0HHXUkOyww86ZN29eHntschYvXpwDDzw406e/kLlz5+a0085KkrRu3eZDzzB37rs55ZQTss022+bss8/Lq6++kjFjLm6w5rXXXs3pp5+cr351v3zlK1/N009PzRVXXNpgzbRpz+S4447KHnvsnWOPPTGNGzfO5MkPZ9GiRfVr7rnnrhx00MG55pob8tvf/ioXXzw6Dzxwb3bYYeccfPAh+cEPbsl5552VO++8K82bN1+ihldddUUGDz4266zTOWuuuWZuumlifvWre3Liiaemc+cueeyxyTn33LPStm1Nttjis1m8eHE+85m1c+65o9O6dZs8+eTjueCCkWnfvkN23XX3JMltt30/d9/985x66lnp1q1Hbrvt+3nggfuy5ZafW6IzrUoMXwMAAAAAAAAAAAAAAAAAsFpo1apVqqur07x587Rv3yFJcv3116Z37z45/PCj69edeupZ2XffPTNjxvTU1tamrq4uO+64Szp27JQk6dlz/fq1zZo1y4IF8+v3+yi//vUv0qhRcvLJZ6RZs2bp0WO9vPnmG/nud8+rX/PjH9+ZddbpnGOOOT5J0rVr9/ztb8/m5ptvqF9z8803pk+fDXPiicPqr623Xs8Gz1p//V751re+kyQ5+OBDcvPNN6RNm7bZe++vJkkOOeQ7+fGP78izz07LJptsukTn/853Ds/nPrd1kmT+/Pm56aaJufTSK7PJJn2TJOuu2zmPP/5ofvKTH2aLLT6b6urqDBp0eP3vr7POunnyycdz772/rh++vv32W3Pwwd/KjjvukiQ58cRT8+c//3GJzrOqMXwNAAAAAAAAAAAAAAAAAMBq69lnp+WRRx7O7rt/vrg3c+ZL6d9/63z2s/3zjW8ckP79t07//ltnp512TevWrZfpeTNmTE/Pnr3SrFmz+msbbrhxgzUvvPB8Ntqo4bV/H45+9tm/Zuedd/vQZ/Xs2av+58aNG6d16zYNBsfbtWufJJkz560lPv8GG2xU//NLL72Y9957L8cff3SDNQsWLEivXn3qP9955+25666f5vXXX83777//z/u9kyTvvvtuZs16MxtttEn9+urq6vTps+ESn2lVYvgaAAAAAAAAAAAAAAAAAIDVVm1tbbbb7vM58sghxb327TukcePGufTSsXniicfy0EN/yp13/iDjx1+Z8eOvzzrrrLsSTvwPTZs2+8g11dUNR4EbNWrU4FqjRo2SJIsWLV7i5zZvvkb9z7W1tUmSCy64NGut9ZkG65o0aZIk+c1vfpmxYy/L4MHHZZNNNk2LFi1zyy035qmnpizxM1cnVSv7AAAAAAAAAAAAAAAAAAAAsKSaNGmSRYvq6j/37t0nzz//XDp27JTOnbs0+GeNNf4xaNyoUaP07bt5Bg06PBMm3JwmTZrkgQfuTZJUVzdJXd2iJX5+167d8txzz2b+/Pn1155+uuEgcvfuPTJ1asNrU6Y82eDz+uv3ysMP/3mJn/tJ6NGjR5o2bZrXXnu1aLf22h2TJE888Vg23bRv9t13v/TuvUE6d+6SmTNn1u/RqlWrtG/fIU899b/fb+HChXnmmakr/PssD4avAQAAAAAAAAAAAAAAAABYbXTsuE6eeurJvPLKy5kzZ04GDNg/b7/9doYPPz1Tp07JzJkv5U9/ejCjRo1IXV1dpkx5MjfeOCFPP/1UXn311dx//72ZM2d2unXrkSTp1KlT/va3aZkx44XMmTMnCxcu/NDn7777F7No0eJccMHIvPDC8/nTnx7Mrbd+P8n/von6K18ZkJdeejFjx16WGTNeyK9+9Yvcc8/PGuwzcOC38vTTT+Wii0bn2WenZfr0F/KjH92ROXPmLP9oH6BFi5Y54ICBufzyS3LPPT/PzJkv5Zlnns4dd9yWe+75eZKkc+euefrpp/KnPz2YGTOm55prxhXD5vvtd0C+//0b8sAD92X69Bdy8cXfzbvvvrvCvsfyVP3RSwAAAAAAAAAAAAAAAAAA+E8xdpcLPnJNdXVVampaZvbsuVm4cMnfGr08HHjgwIwcOTwDB+6X999/P5Mm/TTjxl2XceMuz/HHD86CBfPTsWOnbLXVNqmqqkrLli3z6KOTc/vtt2bevLlZe+2OGTz4uGyzzXZJkr32+momT/5LBg36Rmpr52XMmKvSr9+WH/j8li1b5bvfvSQXXTQ6hxxyUNZbb/1861vfyYgRZ6Rp06ZJko4dO+a88y7I5Zdfkjvv/EE23HDjHHbY0Tn//HPq9+natVsuueSKjB8/Nocd9s00bdosG220SXbb7b8+2YD/5tBDj0zbtjW56aaJefnlmWnVas307r1BvvGNQ5IkX/nKvpk27ZmcffapSRplt93+K1/96n754x//p36PAw4YmFmzZmXkyLPTqFFV9txz7+yww06ZN2/uCv0uy4PhawAAAAAAAAAAAAAAAAAAVhtdu3bL1VdPLK6PGnVhxfXdu/fIJZdc/oH71dTU5HvfG7tUZ9h0081yww231n/+1a/uSXV1ddZZZ53U1tYlSbbb7vPZbrvPN/i9Pffcu8HnLbb4bMaNm1DxGVdcMb64dscdPyuu/eEPDy/Rmfv127Li2kaNGmX//Q/M/vsfWPH3mjZtmtNOOzunnXZ2g+tHHDG4/ufq6uoce+zQHHvs0AZrqqurluhsqxLD1wAAAAAAAAAAAAAAAAAAsBTuuefnWWedzllrrbXy7LPTMm7c5dl1193TvHnz1Naufm975n8ZvgYAAAAAAAAAAAAAAAAAgH+68cYJuemm8s3aSdK37xa5+OIxeeutWbnuuqvz1luz0r59h+y886456qjBFX9nRbnwwlH51a/uqXjvC1/4Uk466bQVfKLV0zINX99888257rrr8sYbb2SDDTbImWeemb59+1ZcO23atIwZMyZTpkzJzJkzc+qpp+Zb3/pWse61117LhRdemN///vepra1Nt27dMmrUqGy66abLckQAAAAAAAAAAAAAAAAAAFhq++wzILvssnvFe82aNUuSfP3r38zXv/7NBveqq6s+8bN9mO9854gceODBFe+1bNlyBZ9m9bXUw9d33313zj///IwYMSKbbbZZbrjhhgwaNCi/+MUv0r59+2J9bW1tOnfunC9+8Ys5//zzK+7597//PQceeGC22mqrXHPNNampqcn06dPTpk2bpf9GAAAAAAAAAAAAAAAAAACwjFq3bpPWrVe/GdeamnapqWm3so+x2lvq4euJEydm//33z4ABA5IkI0aMyH333Zc777wzhx12WLG+b9++9W/Fvvjiiyvuec0116Rjx44NhrO7dOmytEcDAAAAAAAAAAAAAAAAAABYZks1fD1//vxMmTIlhx9+eP21qqqqbLvttpk8efIyH+J3v/tdtt9++wwZMiQPPfRQ1l577Rx00EHZf//9l2qfqqpGqapqtMznWB4aN65q8L9o8kF0KWlS0qSkSUmTynQpaVLSpKRJSZPKdClpUtKkpElJk8p0KS2vJtXVn56m/jspaVLSpDJdSpqUNClpUtKkpEllupQ0KWlS0qSkSWW6lDQpaVLSpKRJZbqUNClpUtKkpEllupQ0KWlS0qSkSWW6lDQpaVLSpKRJZbqUNCmtjk2Wavh69uzZqaurS/v27Rtcb9++fZ577rllPsSLL76YW2+9NYccckiOOOKIPPHEEznvvPPSpEmTfPWrX13ifdq1a5lGjVbu8PW/tG69xso+wipHk8p0KWlS0qSkSUmTynQpaVLSpKRJSZPKdClpUtKkpElJk8p0KX3cJjU1LZfTSVYd/jspaVLSpDJdSpqUNClpUtKkpEllupQ0KWlS0qSkSWW6lDQpaVLSpKRJZbqUNClpUtKkpEllupQ0KWlS0qSkSWW6lDQpaVLSpKRJZbqUNCmtTk2Wavj6k7J48eJssskmOeGEE5IkG220UaZNm5bbbrttqYav33pr7irx5uvWrdfI22/Xpq5u0Uo9y6pCk8p0KWlS0qSkSUmTynQpaVLSpKRJSZPKdClpUtKkpElJk8p0KS2vJrNnz12Op1q5/HdS0qSkSWW6lDQpaVLSpKRJSZPKdClpUtKkpElJk8p0KWlS0qSkSUmTynQpaVLSpKRJSZPKdClpUtKkpElJk8p0KWlS0qSkSUmTynQpaVJa1ZosyUtclmr4uqamJo0bN86sWbMaXJ81a1Y6dOiwdKf7P9Zaa6307NmzwbX11lsvv/zlL5dqn0WLFmfRosXLfI7lqa5uURYuXPn/EaxKNKlMl5ImJU1KmpQ0qUyXkiYlTUqalDSpTJeSJiVNSpqUNKlMl9LHbfJp7Om/k5ImJU0q06WkSUmTkiYlTUqaVKZLSZOSJiVNSppUpktJk5ImJU1KmlSmS0mTkiYlTUqaVKZLSZOSJiVNSppUpktJk5ImJU1KmlSmS0mT0urUZKmGr5s2bZqNN944Dz74YHbbbbckyaJFi/Lggw9m4MCBy3yIfv365fnnn29w7YUXXsi66667zHsCAAAAAAAAAAAAAAAAALD0/vqdb62wZ/W+9voV9qzVwfbbb5lRoy7KDjvslFdeeTn77bd3Jk68Ob169VnZR1sl/N8+n5Sqpf2FQw45JLfffnt+9KMf5W9/+1uGDx+e2tra7LvvvkmSk08+ORdffHH9+vnz52fq1KmZOnVq5s+fn9deey1Tp07N9OnT69d885vfzGOPPZarrroq06dPz89+9rPcfvvtOeigg5bDVwQAAAAAAAAAAAAAAAAA4NNi8ODDctllF3/0wiU0cuTwnHrq0OW23/Lymc+snZ/85Bfp0aPnyj7Kf5SlevN1kuyxxx556623MmbMmLzxxhvZcMMNc+2116ZDhw5JkldeeSVVVf870/36669nn332qf88YcKETJgwIf37989NN92UJOnbt2+uuOKKXHLJJRk7dmw6d+6c0047LXvvvffH/HoAAAAAAAAAAAAAAAAAALD6ady4cdq377Cyj7FUFixYkCZNmqzsY3wsSz18nSQDBw7MwIEDK97710D1v3Tu3DnPPPPMR+658847Z+edd16W4wAAAAAAAAAAAAAAAAAA8B9g5MjhefTRR/Loo49k0qRbkySTJv00tbXzMnbsmDz++OQ0b75G+vffKsccMzRt27ZNktx7728yceI1eemll9K8efP06tUno0dfnFtuuTH33PPzJMn222+ZJBkz5qr067flB57hlVdezn777Z3hw0fmjjt+kL/+9emsu27nnHTSqdl11x2yePHi/L//t0++8pUBOeigg+t/b9q0Z3LIIV/Pbbf9KJ07d8mLL87I6NHnZurUKVlnnXVz7LFDKz5n4sSb06tXnyTJc8/9LVdddXkefXRyFi9enF69euf004dn3XU7Z9GiRbnhhuvy05/+KHPmzE63bj1yxBGDs/XW2zbYb8SI83PnnT/I009PzXrr9cxZZ52buXPfzUUXjc6MGS+kb98tcsYZI1JTU7NE/z7effedbLDBRvnhDyeladOmmTTpp3nttVdzxRWX5qGH/pjGjRunb9/NM2TI0HTqtE6SZOrUKbn66rGZNu2ZLFy4ML169ckxx5yQPn02qN/7o/p8UpZp+BoAAAAAAAAAAAAAAAAAAFa0Y489MS++OCM9evTMd75zeJKkuro6hx76zey11z4ZMuSEvP/+exk37vKcddawjBlzVd58880MH356jjpqSHbYYefMmzcvjz32j+HlAw88ONOnv5C5c+fmtNPOSpK0bt1mic5y5ZVjMmTICenefb384Ac358QTj8vvfvfbNGrUNHvuuXfuvvtnDYav77rrZ9l8837p3LlLFi1alNNPPyk1Ne1z9dXXZ+7cdzNmzMUf+rw33ng9gwcfli226JcxY8alRYuWeeKJx1JXtzBJMmnSrbnttu/npJNOS+/effLzn/80w4adkJtuuj1dunSt32fChKszZMjQrL12x5x//jkZMeKMtGjRIsceOzTNmzfPWWedmuuuuyonnnjqEnV4+OGH0qJFy3zve2OTJAsXLszQocdk4403zVVXXZd27dbMpZdenqFDj8kNN9yWJk2aZN68efnSl76c448/OYsXL/7nuY/Nbbf9MC1atFymPstL1Qp5CgAAAAAAAAAAAAAAAAAAfEytWrVKdXV1mjdvnvbtO6R9+w750Y/uSO/efXL44UenW7fu6d17g5x66ll55JGHM2PG9Mya9Wbq6uqy4467pFOnddKz5/rZd9/90qJFi7Ro0SLNmjVL06ZN6vdr0qTJEp1l3333y0477Zru3Xtk6NBhadWqVe64444kyR577JUXX5yep556Msk/BpJ/85tfZM89906SPPzwnzN9+gs588wR6dWrdzbfvF8OO+zoD33eD384KS1btsqIEedngw02Steu3bLnnnuna9fuSZJbb/1+vv71b2a33f4rXbt2z1FHDUmvXr1z++23NtjnwAMHZquttkn37j2y334H5JlnpuZb3/pO+vbdPL17b5A99/xKHnnk4SX+d7LGGmtk2LAzs956PbPeej3z29/+KosWLcqwYWdm/fV7pWfPnjnzzOF57bVXM3nyX5Ikn/3s5/Jf/7VHunXrnu7de+Tkk0/Pe++9l8mTH1nmPsuLN18DAAAAAAAAAAAAAAAAALDaevbZaXnkkYez++6fL+7NnPlS+vffOp/9bP984xsHpH//rdO//9bZaadd07p164/13E026Vv/c3V1dTbccKM899xzSZIOHdbKNttsl7vu+mk22miT/Pd/P5D58xdk5513S5K88MLz+cxnOqZDh7Uq7lfJtGnPZLPNNk91dTkePHfuu3nzzTey6aabNbi+6aab5dlnpzW41rNnr/qf27VrnyRZb731/8+1dpk9e/aHnuX/Wm+9ng0G1p99dlpmznwpX/jCDkmSRo0aZfHixZk/f35mznwpSfLWW7NyzTXjMnnyXzJ79ltZtGhR3nvvvbz22qtJlq3P8mL4GgAAAAAAAAAAAAAAAACA1VZtbW222+7zOfLIIcW99u07pHHjxrn00rF54onH8tBDf8qdd/4g48dfmfHjr88666z7iZ3ry1/eJ+edd1aGDDkhd931s+y66+5p3rz5Mu/XrFmz5XKuSsPb//faP4alFy3xfmussUaDz7W189K79wY5++zz0rhxo7Rp0yJ///u81NUtTtu2NUmS884bnrff/nuOPXZo1l67U5o2bZojjjgkCxcuWMZvtfxUrewDAAAAAAAAAAAAAAAAAADAkmrSpEkWLaqr/9y7d588//xz6dixUzp37tLgn38NBjdq1Ch9+26eQYMOz4QJN6dJkyZ54IF7kyTV1U1SV7fkw8b/MmXKE/U/L1y4ME8/PTXrrbde/bVtttkuzZuvkR/96I786U//kz333Lv+XvfuPfL666/mzTffrLhfJT179spjjz2ahQsXFvdatmyVDh3WyhNPPNbg+hNPPJbu3Xss9Xf7OHr33iAvvfRiampq0qVL13Tr1i1dunRN585d0qpVq/pzfe1r/y/bbLN9/Zuz58yZU7/HsvRZXgxfAwAAAAAAAAAAAAAAAACw2ujYcZ089dSTeeWVlzNnzpwMGLB/3n777QwffnqmTp2SmTNfyp/+9GBGjRqRurq6TJnyZG68cUKefvqpvPrqq7n//nszZ87sdOv2j6HkTp065W9/m5YZM17InDlzKg43V/LDH07K/fffm+nTX8gll3w377zzdgYMGFB/v3HjxvnSl76cq68emy5dumaTTfrW39tyy/7p0qVbRo48O9Om/TWPPTY548df+aHPGzBg/8yb927OPvvUPP30U3nxxRn5xS/uyowZLyRJDjro4Nx88w357W9/lRkzXsi4cZdn2rS/Zr/9DlzKwh/PF77wpbRp0zbDhg3No48+khdffDF/+cvDufTSC/P6668lSbp06ZJf/vLuvPDC85ky5cmcc86ZDd7svSx9lpfyveAAAAAAAAAAAAAAAAAAAPzH6n3t9R+5prq6KjU1LTN79twsXLj0b43+OA48cGBGjhyegQP3y/vvv59Jk36aceOuy7hxl+f44wdnwYL56dixU7baaptUVVWlZcuWefTRybn99lszb97crL12xwwefFy22Wa7JMlee301kyf/JYMGfSO1tfMyZsxV6ddvy488xxFHDM73v399nn32r1l33S658MLvpV27dpk9e279mi9/+Su56aaJ2WOPvRr8blVVVUaNujCjR5+bww77Zjp27JTjjjspQ4ce84HPa9OmbS677KpceeVlGTz4sFRVNU6vXr2z6aabJUm+9rUD8u677+aKKy7N7NlvpXv39TJ69CXp0qXrsmReZs2bN8/YseMzbtzlGTbsxMybNy9rrfWZ9Ov3ubRs2TJJMmzYmbngglH59rcH5jOfWTuHH35Uxo69rH6PZemzvBi+BgAAAAAAAAAAAAAAAABgtdG1a7dcffXE4vqoURdWXN+9e49ccsnlH7hfTU1Nvve9sUt9ju7de+Saa26o/1xdXVWsefPNN1JdXZ0vfnHP4l7Xrt1y5ZXXNrj2hz88XP9zp07rNPicJOuv3yuXXHJFxfNUVVXl298+LN/+9mEV71far1+/LYtre+yxVzEs/kFOP314xevt23fIGWeM+MAh/d69N8i1197Y4Hd23nm3Bp8/qs8nxfA1AAAAAAAAAAAAAAAAAAAsR/Pnz8+cObMzYcL47LzzbmnXrv3KPhJLyPA1AAAAAAAAAAAAAAAAAAD80403TshNN5Vv1k6Svn23yIknDvvIPX7zm19m9Ohzs/76vXPGGSOW9xFXmN13//wH3rvoojHZbLMtVuBpVgzD1wAAAAAAAAAAAAAAAAAA8E/77DMgu+yye8V7zZo1y1prfSZ/+MPDH7rHHnvslT322OuTON4KNXHiLR94b6211lqBJ1lxDF8DAAAAAAAAAAAAAAAAAMA/tW7dJq1bt1nZx1gldO7cZWUfYYWrWtkHAAAAAAAAAAAAAAAAAAAAWBUYvgYAAAAAAAAAAAAAAAAAAIjhawAAAAAAAAAAAAAAAAAAgCSGrwEAAAAAAAAAAAAAAAAAAJIYvgYAAAAAAAAAAAAAAAAAAEiSVK/sAwAAAAAAAAAAAAAAAAAAsOoYN/q+FfasI4fttMKetaJsvXW/jBp1UXbYYacPXDNy5PC8++47Of/8i1fcwZbR1762V/bf/8Dsv/9BK/soK4Q3XwMAAAAAAAAAAAAAAAAAsNoYPPiwXHbZ8htaHjlyeE49dehy2++uu36VrbfeNknyyisvZ/vtt8y0ac8st/35ZBm+BgAAAAAAAAAAAAAAAACA5aR9+w5p2rTpCnveggULVtiz/hNUr+wDAAAAAAAAAAAAAAAAAADAkhg5cngeffSRPProI5k06dYkyaRJP01t7byMHTsmjz8+Oc2br5H+/bfKMccMTdu2bZMk9977m0yceE1eeumlNG/ePL169cno0RfnlltuzD33/DxJsv32WyZJxoy5Kv36bfmBZ1iwYEEuv/yS3H//7/LOO++kpqZd9tlnQA45ZFCSZOut+2XUqIuyww47Zb/99k6SHHLI15Mkm2/eL1dcMb7Yc+rUKTnppGNzwAEDM3Dgtz60wXXXXZ3f//7+DBiwf268cUJeffWV/P73D+Wdd97J2LGX5g9/uD/z5y/IBhtsmGOOOSG9evVOksyc+VIuv/ySTJnyZN57rzbduvXI4Ycfnc99bqv6vWfPfivnn39uHn74z2nfvn0OPfTIj/pX8qlj+BoAAAAAAAAAAAAAAAAAgNXCsceemBdfnJEePXrmO985PElSXV2dQw/9Zvbaa58MGXJC3n//vYwbd3nOOmtYxoy5Km+++WaGDz89Rx01JDvssHPmzZuXxx6bnMWLF+fAAw/O9OkvZO7cuTnttLOSJK1bt/nQM0yadFv+8IcHcs45o7P22h3z2muv5fXXX6249pprbsihh34zl156ZXr0WC9NmjQp1vzlLw/l9NNPypFHDslXvrLvEnWYOfPF3Hff7zJy5AWpqmqcJDnzzFPSrFmzXHTRmLRs2So/+ckPc9xxR+bWW3+Y1q3bZN68edl66+1y2GFHpUmTpvnFL+7KKaeckFtuuTMdO3ZM8o/h9jfffDNjxlyV6urqXHbZhZk9+60lOtOnheFrAAAAAAAAAAAAAAAAAABWC61atUp1dXWaN2+e9u07JEmuv/7a9O7dJ4cffnT9ulNPPSv77rtnZsyYntra2tTV1WXHHXdJx46dkiQ9e65fv7ZZs2ZZsGB+/X4f5fXXX02XLl3Tt+/madSoUf2elbRtW5MkadOmTcX977//3px33tkZNuyM7LrrF5bo+ck/3r59xhkjUlPzj/0fe+zRTJ06JT/72a/TtGnTJMngwcfl97+/L/fe+9t85Sv7plev3vVvwU6SQw89Mg88cG/++7/vz4AB/y8zZkzPH//4P7nmmhuy4YYbJ0mGDTsrX//615b4XJ8Ghq8BAAAAAAAAAAAAAAAAAFhtPfvstDzyyMPZfffPF/dmznwp/ftvnc9+tn++8Y0D0r//1unff+vstNOuad269TI970tf2ivHH390DjxwQLbeeptsu+3n07//1ku9z1NPPZn/+Z8/5Nxzv5sddthpqX63Y8dO9YPXSfLss39NbW1t9txz1wbr3n///cyc+VKSZN68eZkwYXwefPAPmTXrzdTV1eX999/Pa6/9463d06c/n8aNG6dPnw3rf79bt+5p1WrNpf5uqzPD1wAAAAAAAAAAAAAAAAAArLZqa2uz3Xafz5FHDinutW/fIY0bN86ll47NE088loce+lPuvPMHGT/+yowff33WWWfdpX5enz4bZNKkn+SPf/yfPPzwn3PWWcOy5Zb9M3r0RUu1zzrrdE7r1m1y110/ybbbbp/q6iUf+23efI0Gn2tr56V9+w65/PKri7X/Gp4eO/bSPPTQn3L00celc+cuadasWc4445QsWLBwqc79aVe1sg8AAAAAAAAAAAAAAAAAAABLqkmTJlm0qK7+c+/effL888+lY8dO6dy5S4N/1ljjH0PKjRo1St++m2fQoMMzYcLNadKkSR544N4kSXV1k9TVLVqqM7Rs2Sq77vqFnHLKGRkx4vzcd9/v8ve//73iWZNU3L9t27YZM+aqzJz5Us48c1gWLlz2Ieg+fTbIW2/NSuPGjYsGbdu2TZI88cRj2WOPvbLjjjunZ8/1065d+7z66sv1e3Tr1j11dXV55pmp9ddmzHgh7777zjKfa3XkzdcAAAAAsBoaN/q+j1xz5LCdPvFzAAAAAAAAAAAAwIrWseM6eeqpJ/PKKy9njTVaZMCA/fOzn/04w4efnq9//Rtp3bpNXnrpxfz2t7/KKaeckaefnpq//OXP6d9/67Rt2y5PPfVk5syZnW7deiRJOnXqlD//+cHMmPFCWrdum1atWn3oW6hvu+37ad++Q3r33iCNGjXKvff+Ju3bt8+aa65ZrG3btibNmjXLn/70P/nMZz6Tpk2bpVWrVvX3a2ra5bLLxmXIkCMyfPhpGT581FK9Aftfttxyq2y88aY59dQTc9RRQ9KlS9e8+eYb+Z//+UN23HHnbLDBRuncuWvuv/932W67zydplGuvHZdFixbX79G1a/dstdW2ufDCURk69NQ0btw4Y8ZcnGbNmi31eVZnhq8BAAAAAAAAAAAAAAAAAKi3JC//qK6uSk1Ny8yePTcLFy7dW6M/rgMPHJiRI4dn4MD98v7772fSpJ9m3LjrMm7c5Tn++MFZsGB+OnbslK222iZVVVVp2bJlHn10cm6//dbMmzc3a6/dMYMHH5dtttkuSbLXXl/N5Ml/yaBB30ht7byMGXNV+vXb8gOf36JFy9xyy4156aUXU1VVlQ022DgXXnhZqqqqirXV1dU57riTMnHiNbnuuqvTt+/mueKK8Q3WtG/fIZdddlWOOeawnHPOmTn77PPSuHHjpWrSqFGjXHTRZRk//sqMGjUic+bMTrt27bP55v1SU9MuSXLMMcfn/PPPyRFHfDtt2rTN17/+zcydO7fBPqeddla++93zcswxh6Wmpl0OPfTIXHvta0t1ltWd4WsAAAAAAAAAAAAAAAAAAFYbXbt2y9VXTyyujxp1YcX13bv3yCWXXP6B+9XU1OR73xu7xM/fe++vZu+9v/qB9//4x0caDKTvtdc+2WuvfRqsOf304Q0+d+jQIbfe+sMlev6gQYdn0KDDi+stWrTMccedlOOOO6ni73XqtE7GjLmqwbUBA/Zv8Ll9+w654IJLG1z74hf3XKJzfVqUI/QAAAAAAAAAAAAAAAAAAAD/gbz5GgAAAAAAAAAAAAAAAAAA/unGGyfkppvKN2snSd++W+Tii8d8os8fOHD/vPbaKxXvnXTSafnCF770iT7/P53hawAAAAAAAAAAAAAAAAAA+Kd99hmQXXbZveK9Zs2afeLPv+iiy7Jw4cKK99q1a/eJP/8/neFrAAAAAAAAAAAAAAAAAAD4p9at26R16zYr7fkdO3Zaac8mqVrZBwAAAAAAAAAAAAAAAAAAAFgVGL4GAAAAAAAAAAAAAAAAAACI4WsAAAAAAAAAAAAAAAAAAIAkhq8BAAAAAAAAAAAAAAAAAACSGL4GAAAAAAAAAAAAAAAAAABIYvgaAAAAAAAAAAAAAAAAAAAgieFrAAAAAAAAAAAAAAAAAACAJIavAQAAAAAAAAAAAAAAAAAAkhi+BgAAAAAAAAAAAAAAAAAASGL4GgAAAAAAAAAAAAAAAAAAIInhawAAAAAAAAAAAAAAAAAAgCSGrwEAAAAAAAAAAAAAAAAAAJIYvgYAAAAAAAAAAAAAAAAAAEhi+BoAAAAAAAAAAAAAAAAAACCJ4WsAAAAAAAAAAAAAAAAAAIAkhq8BAAAAAAAAAAAAAAAAAACSGL4GAAAAAAAAAAAAAAAAAABIYvgaAAAAAAAAAAAAAAAAAAAgieFrAAAAAAAAAAAAAAAAAACAJIavAQAAAAAAAAAAAAAAAAAAkhi+BgAAAAAAAAAAAAAAAAAASGL4GgAAAAAAAAAAAAAAAAAAIInhawAAAAAAAAAAAAAAAAAAgCSGrwEAAAAAAAAAAAAAAAAAAJIYvgYAAAAAAAAAAAAAAAAAAEhi+BoAAAAAAAAAAAAAAAAAACCJ4WsAAAAAAAAAAAAAAAAAAIAkhq8BAAAAAAAAAAAAAAAAAACSGL4GAAAAAAAAAAAAAAAAAABIYvgaAAAAAAAAAAAAAAAAAAAgieFrAAAAAAAAAAAAAAAAAACAJIavAQAAAAAAAAAAAAAAAAAAkhi+BgAAAAAAAAAAAAAAAAAASGL4GgAAAAAAAAAAAAAAAAAAIInhawAAAAAAAAAAAAAAAAAAgCSGrwEAAAAAAAAAAAAAAAAAAJIYvgYAAAAAAAAAAAAAAAAAAEhi+BoAAAAAAAAAAAAAAAAAACCJ4WsAAAAAAAAAAAAAAAAAAIAkhq8BAAAAAAAAAAAAAAAAAACSGL4GAAAAAAAAAAAAAAAAAABIYvgaAAAAAAAAAAAAAAAAAAAgieFrAAAAAAAAAAAAAAAAAACAJMs4fH3zzTdnl112yaabbpr99tsvjz/++AeunTZtWo455pjssssu6dOnT66//voP3Xv8+PHp06dPRo4cuSxHAwAAAAAAAAAAAAAAAAAAWCZLPXx999135/zzz8/RRx+dH/3oR9lggw0yaNCgzJo1q+L62tradO7cOUOHDs1aa631oXs//vjjue2229KnT5+lPRYAAAAAAAAAAAAAAAAAAMDHstTD1xMnTsz++++fAQMGZP3118+IESPSvHnz3HnnnRXX9+3bN6ecckr23HPPNG3a9AP3nTt3bk466aScd955adOmzdIeCwAAAAAAAAAAAAAAAAAA4GOpXprF8+fPz5QpU3L44YfXX6uqqsq2226byZMnf6yDnHPOOdlxxx2z7bbbZty4ccu0R1VVo1RVNfpY5/i4GjeuavC/aPJBdClpUtKkpElJk8p0KWlS0qSkSUmTynQpaVLSpKRJSZPKlleX6upPT1dNSv5+SpqUNKlMl5ImJU1KmpQ0KWlSmS4lTUqalDQpaVKZLiVNSpqUNClpUpkuJU1KmpQ0KWlSmS4lTUqalDQpaVKZLiVNSpqUNClpUpkuJU1Kq2OTpRq+nj17durq6tK+ffsG19u3b5/nnntumQ9x11135amnnsodd9yxzHskSbt2LdOo0codvv6X1q3XWNlHWOVoUpkuJU1KmpQ0KWlSmS4lTUqalDQpaVKZLiVNSpqUNClpUtnH7VJT03I5nWTVoUnJ309Jk5ImlelS0qSkSUmTkiYlTSrTpaRJSZOSJiVNKtOlpElJk5ImJU0q06WkSUmTkiYlTSrTpaRJSZOSJiVNKtOlpElJk5ImJU0q06WkSWl1arJUw9efhFdeeSUjR47MhAkT0qxZs4+111tvzV0l3nzduvUaefvt2tTVLVqpZ1lVaFKZLiVNSpqUNClpUpkuJU1KmpQ0KWlSmS4lTUqalDQpaVLZ8uoye/bc5XiqlUuTkr+fkiYlTSrTpaRJSZOSJiVNSppUpktJk5ImJU1KmlSmS0mTkiYlTUqaVKZLSZOSJiVNSppUpktJk5ImJU1KmlSmS0mTkiYlTUqaVKZLSZPSqtZkSV7islTD1zU1NWncuHFmzZrV4PqsWbPSoUOHpTvdP02ZMiWzZs3KvvvuW3+trq4uDz30UG6++eY88cQTady48RLttWjR4ixatHiZzrG81dUtysKFK/8/glWJJpXpUtKkpElJk5ImlelS0qSkSUmTkiaV6VLSpKRJSZOSJpV93C6fxqaalPz9lDQpaVKZLiVNSpqUNClpUtKkMl1KmpQ0KWlS0qQyXUqalDQpaVLSpDJdSpqUNClpUtKkMl1KmpQ0KWlS0qQyXUqalDQpaVLSpDJdSpqUVqcmSzV83bRp02y88cZ58MEHs9tuuyVJFi1alAcffDADBw5cpgNsvfXW+dnPftbg2qmnnpr11lsvhx566BIPXgMAAAAAAAAAAAAAAAAAAHwcSzV8nSSHHHJITjnllGyyySbp27dvbrjhhtTW1ta/ufrkk0/O2muvnaFDhyZJ5s+fn7/97W/1P7/22muZOnVqWrRokW7duqVVq1bp3bt3g2e0aNEibdu2La4DAAAAAAAAAAAAAAAAAAB8UpZ6+HqPPfbIW2+9lTFjxuSNN97IhhtumGuvvTYdOnRIkrzyyiupqqqqX//6669nn332qf88YcKETJgwIf37989NN9308b8BAAAAAAAAAAAAAAAAAADAcrDUw9dJMnDgwAwcOLDivX8fqO7cuXOeeeaZpdrfUDYAAAAAAAAAAAAAAAAAALCiVX30EgAAAAAAAAAAAAAAAAAAgE8/w9cAAAAAAAAAAAAAAAAAAAAxfA0AAAAAAAAAAAAAAAAAAJDE8DUAAAAAAAAAAAAAAAAAAEASw9cAAAAAAAAAAAAAAAAAAABJDF8DAAAAAAAAAAAAAAAAAAAkMXwNAAAAAAAAAAAAAAAAAACQxPA1AAAAAAAAAAAAAAAAAABAEsPXAAAAAAAAAAAAAAAAAAAASQxfAwAAAAAAAAAAAAAAAAAAJDF8DQAAAAAAAAAAAAAAAAAAkMTwNQAAAAAAAAAAAAAAAAAAQBLD1wAAAAAAAAAAAAAAAAAAAEkMXwMAAAAAAAAAAAAAAAAAACQxfA0AAAAAAAAAAAAAAAAAAJDE8DUAAAAAAAAAAAAAAAAAAEASw9cAAAAAAAAAAAAAAAAAAABJDF8DAAAAAAAAAAAAAAAAAAAkMXwNAAAAAAAAAAAAAAAAAACQxPA1AAAAAAAAAAAAAAAAAABAEsPXAAAAAAAAAAAAAAAAAAAASQxfAwAAAAAAAAAAAAAAAAAAJDF8DQAAAAAAAAAAAAAAAAAAkMTwNQAAAAAAAAAAAAAAAAAAQBLD1wAAAAAAAAAAAAAAAAAAAEkMXwMAAAAAAAAAAAAAAAAAACQxfA0AAAAAAAAAAAAAAAAAAJDE8DUAAAAAAAAAAAAAAAAAAEASw9cAAAAAAAAAAAAAAAAAAABJDF8DAAAAAAAAAAAAAAAAAAAkMXwNAAAAAAAAAAAAAAAAAACQxPA1AAAAAAAAAAAAAAAAAABAEsPXAAAAAAAAAAAAAAAAAAAASQxfAwAAAAAAAAAAAAAAAAAAJDF8DQAAAAAAAAAAAAAAAAAAkMTwNQAAAAAAAAAAAAAAAAAAQBLD1wAAAAAAAAAAAAAAAAAAAEkMXwMAAAAAAAAAAAAAAAAAACQxfA0AAAAAAAAAAAAAAAAAAJDE8DUAAAAAAAAAAAAAAAAAAEASw9cAAAAAAAAAAAAAAAAAAABJDF8DAAAAAAAAAAAAAAAAAAAkMXwNAAAAAAAAAAAAAAAAAACQxPA1AAAAAAAAAAAAAAAAAABAEsPXAAAAAAAAAAAAAAAAAAAASQxfAwAAAAAAAAAAAAAAAAAAJDF8DQAAAAAAAAAAAAAAAAAAkMTwNQAAAAAAAAAAAAAAAAAAQBLD1wAAAAAAAAAAAAAAAAAAAEkMXwMAAAAAAAAAAAAAAAAAACRJqlf2AQAAAAAAgJVr3Oj7PnLNkcN2+sTPAQAAAAAAAAAAsLJ58zUAAAAAAAAAAAAAAAAAAEAMXwMAAAAAAAAAAAAAAAAAACQxfA0AAAAAAAAAAAAAAAAAAJDE8DUAAAAAAAAAAAAAAAAAAEASw9cAAAAAAAAAAAAAAAAAAABJDF8DAAAAAAAAAAAAAAAAAAAkMXwNAAAAAAAAAAAAAAAAAACQxPA1AAAAAAAAAAAAAAAAAABAEsPXAAAAAAAAAAAAAAAAAAAASQxfAwAAAAAAAAAAAAAAAAAAJDF8DQAAAAAAAAAAAAAAAAAAkMTwNQAAAAAAAAAAAAAAAAAAQBLD1wAAAAAAAAAAAAAAAAAAAEmS6pV9AAAAAAAAgFXNuNH3feSaI4ft9ImfAwAAAAAAAAAAWLG8+RoAAAAAAAAAAAAAAAAAACCGrwEAAAAAAAAAAAAAAAAAAJIYvgYAAAAAAAAAAAAAAAAAAEhi+BoAAAAAAAAAAAAAAAAAACCJ4WsAAAAAAAAAAAAAAAAAAIAkhq8BAAAAAAAAAAAAAAAAAACSGL4GAAAAAAAAAAAAAAAAAABIYvgaAAAAAAAAAAAAAAAAAAAgieFrAAAAAAAAAAAAAAAAAACAJIavAQAAAAAAAAAAAAAAAAAAkhi+BgAAAAAAAAAAAAAAAAAASLKMw9c333xzdtlll2y66abZb7/98vjjj3/g2mnTpuWYY47JLrvskj59+uT6668v1lx99dUZMGBAtthii2yzzTY56qij8txzzy3L0QAAAAAAAAAAAAAAAAAAAJbJUg9f33333Tn//PNz9NFH50c/+lE22GCDDBo0KLNmzaq4vra2Np07d87QoUOz1lprVVzz5z//OV//+tdz++23Z+LEiVm4cGEGDRqUefPmLe3xAAAAAAAAAAAAAAAAAAAAlslSD19PnDgx+++/fwYMGJD1118/I0aMSPPmzXPnnXdWXN+3b9+ccsop2XPPPdO0adOKa6677rrsu+++6dWrVzbYYIOMHj06L7/8cqZMmbK0xwMAAAAAAAAAAAAAAAAAAFgm1UuzeP78+ZkyZUoOP/zw+mtVVVXZdtttM3ny5OV2qHfeeSdJ0qZNm6X6vaqqRqmqarTczrEsGjeuavC/aPJBdClpUtKkpElJk8p0KWlS0qSkSUmTynQpaVLSpKRJSZPKlleX6upPT1dNSv5+SpqUlmcTfz8lTT7dNClpUtKkpEllupQ0KWlS0qSkSWW6lDQpaVLSpKRJZbqUNClpUtKkpEllupQ0KWlS0qSkSWW6lDQpaVLSpKRJZbqUNCmtjk2Wavh69uzZqaurS/v27Rtcb9++fZ577rnlcqBFixZl1KhR6devX3r37r1Uv9uuXcs0arRyh6//pXXrNVb2EVY5mlSmS0mTkiYlTUqaVKZLSZOSJiVNSppUpktJk5ImJU1KmlT2cbvU1LRcTidZdWhS8vdT0qS0PJr4+ylp8p9Bk5ImJU1KmlSmS0mTkiYlTUqaVKZLSZOSJiVNSppUpktJk5ImJU1KmlSmS0mTkiYlTUqaVKZLSZOSJiVNSppUpktJk9Lq1GSphq9XhBEjRmTatGm55ZZblvp333pr7irx5uvWrdfI22/Xpq5u0Uo9y6pCk8p0KWlS0qSkSUmTynQpaVLSpKRJSZPKdClpUtKkpElJk8qWV5fZs+cux1OtXJqU/P2UNCktzyb+fkqafLppUtKkpElJk8p0KWlS0qSkSUmTynQpaVLSpKRJSZPKdClpUtKkpElJk8p0KWlS0qSkSUmTynQpaVLSpKRJSZPKdClpUlrVmizJCxeWavi6pqYmjRs3zqxZsxpcnzVrVjp06LB0p6vgnHPOyX333Zfvf//76dix41L//qJFi7No0eKPfY7loa5uURYuXPn/EaxKNKlMl5ImJU1KmpQ0qUyXkiYlTUqalDSpTJeSJiVNSpqUNKns43b5NDbVpOTvp6RJaXk0+TQ29f8pJX8/JU1KmpQ0KWlSmS4lTUqalDQpaVKZLiVNSpqUNClpUpkuJU1KmpQ0KWlSmS4lTUqalDQpaVKZLiVNSpqUNClpUpkuJU1Kq1OTpRq+btq0aTbeeOM8+OCD2W233ZIkixYtyoMPPpiBAwcu8yEWL16cc889N7/+9a9z0003pUuXLsu8FwAAAADw6fTfXxnw4QvW/9YKOQcAAAAAAAAAAADw6bVUw9dJcsghh+SUU07JJptskr59++aGG25IbW1t9t133yTJySefnLXXXjtDhw5NksyfPz9/+9vf6n9+7bXXMnXq1LRo0SLdunVLkowYMSI///nPc+WVV6Zly5Z54403kiRrrrlmmjdvvly+KAAAAAAAAAAAAAAAAAAAwIdZ6uHrPfbYI2+99VbGjBmTN954IxtuuGGuvfbadOjQIUnyyiuvpKqqqn7966+/nn322af+84QJEzJhwoT0798/N910U5Lk1ltvTZIcfPDBDZ51/vnn1w91AwAAAAAAAAAAAAAAAAAAfJKWevg6SQYOHJiBAwdWvPevgep/6dy5c5555pkP3e+j7gMAAAAAAAAAAAAAAAAAAHzSqj56CQAAAAAAAAAAAAAAAAAAwKef4WsAAAAAAAAAAAAAAAAAAIAYvgYAAAAAAAAAAAAAAAAAAEhi+BoAAAAAAAAAAAAAAAAAACCJ4WsAAAAAAAAAAAAAAAAAAIAkhq8BAAAAAAAAAAAAAAAAAACSGL4GAAAAAAAAAAAAAAAAAABIYvgaAAAAAAAAAAAAAAAAAAAgieFrAAAAAAAAAAAAAAAAAACAJIavAQAAAAAAAAAAAAAAAAAAkhi+BgAAAAAAAAAAAAAAAAAASGL4GgAAAAAAAAAAAAAAAAAAIInhawAAAAAAAAAAAAAAAAAAgCSGrwEAAAAAAAAAAAAAAAAAAJIYvgYAAAAAAAAAAAAAAAAAAEhi+BoAAAAAAAAAAAAAAAAAACCJ4WsAAAAAAAAAAAAAAAAAAIAkhq8BAAAAAAAAAAAAAAAAAACSGL4GAAAAAAAAAAAAAAAAAABIYvgaAAAAAAAAAAAAAAAAAAAgieFrAAAAAAAAAAAAAAAAAACAJIavAQAAAAAAAAAAAAAAAAAAkhi+BgAAAAAAAAAAAAAAAAAASGL4GgAAAAAAAAAAAAAAAAAAIInhawAAAAAAAAAAAAAAAAAAgCSGrwEAAAAAAAAAAAAAAAAAAJIYvgYAAAAAAAAAAAAAAAAAAEhi+BoAAAAAAAAAAAAAAAAAACCJ4WsAAAAAAAAAAAAAAAAAAIAkhq8BAAAAAAAAAAAAAAAAAACSGL4GAAAAAAAAAAAAAAAAAABIYvgaAAAAAAAAAAAAAAAAAAAgieFrAAAAAAAAAAAAAAAAAACAJIavAQAAAAAAAAAAAAAAAAAAkhi+BgAAAAAAAAAAAAAAAAAASGL4GgAAAAAAAAAAAAAAAAAAIInhawAAAAAAAAAAAAAAAAAAgCSGrwEAAAAAAAAAAAAAAAAAAJIYvgYAAAAAAAAAAAAAAAAAAEhi+BoAAAAAAAAAAAAAAAAAACCJ4WsAAAAAAAAAAAAAAAAAAIAkhq8BAAAAAAAAAAAAAAAAAACSGL4GAAAAAAAAAAAAAAAAAABIklSv7AMAAAAAAPDJGTf6vg+9f+SwnVbIOQAAAAAAAAAAAGB14M3XAAAAAAAAAAAAAAAAAAAAMXwNAAAAAAAAAAAAAAAAAACQxPA1AAAAAAAAAAAAAAAAAABAkqR6ZR8AAAAAAABWpHGj7/vQ+0cO22mFnAMAAAAAAAAAAIBVjzdfAwAAAAAAAAAAAAAAAAAAxPA1AAAAAAAAAAAAAAAAAABAEsPXAAAAAAAAAAAAAAAAAAAASQxfAwAAAAAAAAAAAAAAAAAAJDF8DQAA/5+9O461ur7vP/7icst0diTXe2uTzmxOGAUt7uo2mxB1Fl0iNIYGUNPlzmEwYe5uk43u6v5wkbYLLiI1OEOyMlCQbCFRzJbg8ptjGqPYpBNnoE1dsOuWaBxcyMwcHXqvvz8Wb3d9f+VyLvdyL8fH4x/G4XOun/sMZ71p+vILAAAAAAAAAAAAAAAASYyvAQAAAAAAAAAAAAAAAAAAkhhfAwAAAAAAAAAAAAAAAAAAJDG+BgAAAAAAAAAAAAAAAAAASGJ8DQAAAAAAAAAAAAAAAAAAkMT4GgAAAAAAAAAAAAAAAAAAIInxNQAAAAAAAAAAAAAAAAAAQBLjawAAAAAAAAAAAAAAAAAAgCTG1wAAAAAAAAAAAAAAAAAAAEmMrwEAAAAAAAAAAAAAAAAAAJIYXwMAAAAAAAAAAAAAAAAAACQxvgYAAAAAAAAAAAAAAAAAAEhifA0AAAAAAAAAAAAAAAAAAJDE+BoAAAAAAAAAAAAAAAAAACCJ8TUAAAAAAAAAAAAAAAAAAECSpHOqLwAAAAAA0L9vYMwzd5+FewAAAAAAAAAAAACfbJ58DQAAAAAAAAAAAAAAAAAAEONrAAAAAAAAAAAAAAAAAACAJMbXAAAAAAAAAAAAAAAAAAAASYyvAQAAAAAAAAAAAAAAAAAAkhhfAwAAAAAAAAAAAAAAAAAAJDG+BgAAAAAAAAAAAAAAAAAASGJ8DQAAAAAAAAAAAAAAAAAAkMT4GgAAAAAAAAAAAAAAAAAAIMk4x9e7du3K4sWLs3Dhwtxyyy157bXXPvbsv/zLv+T3fu/3snjx4nz+85/PY489dsZfEwAAAAAAAAAAAAAAAAAAYKK1PL7eu3dvNmzYkP7+/uzZsyfz58/P6tWrMzg42Hj+xIkTufjii7Nu3bp85jOfmZCvCQAAAAAAAAAAAAAAAAAAMNFaHl9v3749t956a1asWJG5c+dm/fr1Oe+88/Lkk082nr/iiityzz335Mtf/nJmzZo1IV8TAAAAAAAAAAAAAAAAAABgonW2cvjkyZM5dOhQ1qxZM/JaR0dHFi1alAMHDozrAhP5NTs6ZqSjY8a47jFRZs7sGPUrmnwcXSpNKk0qTSpNmulSaVJpUmlSadJMl0qTSpNKk0qTZhPVpbNT149qpyb+nlSaVBP5/2d1qTRpb5pUmlSaVJo006XSpNKk0qTSpJkulSaVJpUmlSbNdKk0qTSpNKk0aaZLpUmlSaVJpUkzXSpNKk0qTSpNmulSaVKdi01aGl8fP348Q0ND6e7uHvV6d3d33njjjXFdYCK/5oUXXpAZM6Z2fP2h2bPPn+orTDuaNNOl0qTSpNKk0qSZLpUmlSaVJpUmzXSpNKk0qTSpNKleXLbi1Afmrhrza3R1XTAxl2kj7djkTD8/mlSaNNOl0uSTQZNKk0qTSpNmulSaVJpUmlSaNNOl0qTSpNKk0qSZLpUmlSaVJpUmzXSpNKk0qTSpNGmmS6VJpUmlSaVJM10qTapzqUlL4+vp7tixd6fFk69nzz4/77xzIkNDw1N6l+lCk2a6VJpUmlSaVJo006XSpNKk0qTSpJkulSaVJpUmlSbNJurf7nj8+LsT8nXaSTs1majPjyaVJs10qTRpb5pUmlSaVJo006XSpNKk0qTSpJkulSaVJpUmlSbNdKk0qTSpNKk0aaZLpUmlSaVJpUkzXSpNKk0qTSpNmulSaVJNtyan88CFlsbXXV1dmTlzZgYHB0e9Pjg4mJ6entZuNwlfc3j4gwwPfzCue0y0oaHhvP/+1P8lmE40aaZLpUmlSaVJpUkzXSpNKk0qTSpNmulSaVJpUmlSaTI5NK3ascmZfn40qTRppkulySeDJpUmlSaVJs10qTSpNKk0qTRppkulSaVJpUmlSTNdKk0qTSpNKk2a6VJpUmlSaVJp0kyXSpNKk0qTSpNmulSaVOdSk5YeoTNr1qxcfvnl2b9//8hrw8PD2b9/f6688spxXWAyviYAAAAAAAAAAAAAAAAAAECrWnrydZLccccdueeee/KFL3whV1xxRR5//PGcOHEiy5cvT5IMDAzks5/9bNatW5ckOXnyZA4fPjzyf7/99tv5/ve/n5/+6Z/Oz//8z5/W1wQAAAAAAAAAAAAAAAAAAJhsLY+vly5dmmPHjmXz5s05cuRIFixYkK1bt6anpydJ8tZbb6Wj4ycP1P6P//iPfOUrXxn5/bZt27Jt27ZcffXV2blz52l9TQAAAAAAAAAAAAAAAAAAgMnW8vg6Sfr6+tLX19f4Zx8Oqj908cUX5wc/+MEZfU0AAAAAAAAAAAAAAAAAAIDJ1jH2EQAAAAAAAAAAAAAAAAAAgPZnfA0AAAAAAAAAAAAAAAAAABDjawAAAAAAAAAAAAAAAAAAgCTG1wAAAAAAAAAAAAAAAAAAAEmMrwEAAAAAAAAAAAAAAAAAAJIYXwMAAAAAAAAAAAAAAAAAACQxvgYAAAAAAAAAAAAAAAAAAEhifA0AAAAAAAAAAAAAAAAAAJDE+BoAAAAAAAAAAAAAAAAAACCJ8TUAAAAAAAAAAAAAAAAAAEAS42sAAAAAAAAAAAAAAAAAAIAkxtcAAAAAAAAAAAAAAAAAAABJjK8BAAAAAAAAAAAAAAAAAACSGF8DAAAAAAAAAAAAAAAAAAAkMb4GAAAAAAAAAAAAAAAAAABIYnwNAAAAAAAAAAAAAAAAAACQxPgaAAAAAAAAAAAAAAAAAAAgifE1AAAAAAAAAAAAAAAAAABAEuNrAAAAAAAAAAAAAAAAAACAJEnnVF8AAAAAAAAAzlVbHnjulH9+173Xn5V7AAAAAAAAAAAwMTz5GgAAAAAAAAAAAAAAAAAAIMbXAAAAAAAAAAAAAAAAAAAASYyvAQAAAAAAAAAAAAAAAAAAkhhfAwAAAAAAAAAAAAAAAAAAJDG+BgAAAAAAAAAAAAAAAAAASGJ8DQAAAAAAAAAAAAAAAAAAkMT4GgAAAAAAAAAAAAAAAAAAIInxNQAAAAAAAAAAAAAAAAAAQBLjawAAAAAAAAAAAAAAAAAAgCTG1wAAAAAAAAAAAAAAAAAAAEmMrwEAAAAAAAAAAAAAAAAAAJIYXwMAAAAAAAAAAAAAAAAAACQxvgYAAAAAAAAAAAAAAAAAAEiSdE71BQAAAAAAAJj+tjzw3Jhn7rr3+km/BwAAAAAAAAAATCZPvgYAAAAAAAAAAAAAAAAAAIjxNQAAAAAAAAAAAAAAAAAAQBLjawAAAAAAAAAAAAAAAAAAgCTG1wAAAAAAAAAAAAAAAAAAAEmMrwEAAAAAAAAAAAAAAAAAAJIYXwMAAAAAAAAAAAAAAAAAACQxvgYAAAAAAAAAAAAAAAAAAEhifA0AAAAAAAAAAAAAAAAAAJDE+BoAAAAAAAAAAAAAAAAAACCJ8TUAAAAAAAAAAAAAAAAAAEAS42sAAAAAAAAAAAAAAAAAAIAkxtcAAAAAAAAAAAAAAAAAAABJjK8BAAAAAAAAAAAAAAAAAACSJJ1TfQEAAAAA+KTp3zcw5pm7z8I9AAAAAAAAAAAAABjNk68BAAAAAAAAAAAAAAAAAABifA0AAAAAAAAAAAAAAAAAAJDE+BoAAAAAAAAAAAAAAAAAACCJ8TUAAAAAAAAAAAAAAAAAAEAS42sAAAAAAAAAAAAAAAAAAIAkxtcAAAAAAAAAAAAAAAAAAABJjK8BAAAAAAAAAAAAAAAAAACSGF8DAAAAAAAAAAAAAAAAAAAkMb4GAAAAAAAAAAAAAAAAAABIYnwNAAAAAAAAAAAAAAAAAACQxPgaAAAAAAAAAAAAAAAAAAAgifE1AAAAAAAAAAAAAAAAAABAEuNrAAAAAAAAAAAAAAAAAACAJMbXAAAAAAAAAAAAAAAAAAAASYyvAQAAAAAAAAAAAAAAAAAAkhhfAwAAAAAAAAAAAAAAAAAAJDG+BgAAAAAAAAAAAAAAAAAASGJ8DQAAAAAAAAAAAAAAAAAAkMT4GgAAAAAAAAAAAAAAAAAAIInxNQAAAAAAAAAAAAAAAAAAQBLjawAAAAAAAAAAAAAAAAAAgCTG1wAAAAAAAAAAAAAAAAAAAEmMrwEAAAAAAAAAAAAAAAAAAJIYXwMAAAAAAAAAAAAAAAAAACQxvgYAAAAAAAAAAAAAAAAAAEhifA0AAAAAAAAAAAAAAAAAAJDE+BoAAAAAAAAAAAAAAAAAACCJ8TUAAAAAAAAAAAAAAAAAAECScY6vd+3alcWLF2fhwoW55ZZb8tprr53y/DPPPJObbropCxcuzM0335znn39+1J+/++67+frXv57rrrsuV1xxRZYuXZq/+qu/Gs/VAAAAAAAAAAAAAAAAAAAAxqXl8fXevXuzYcOG9Pf3Z8+ePZk/f35Wr16dwcHBxvOvvPJK1q1bl5UrV+bpp5/ODTfckP7+/rz++usjZx544IG88MILefDBB7N379781m/9Vr7xjW/kH/7hH8b/nQEAAAAAAAAAAAAAAAAAALSg5fH19u3bc+utt2bFihWZO3du1q9fn/POOy9PPvlk4/kdO3bk2muvzZ133pk5c+Zk7dq1ueyyy/LEE0+MnDlw4EC+8pWv5Itf/GIuvvji3HbbbZk/f/6YT9QGAAAAAAAAAAAAAAAAAACYKJ2tHD558mQOHTqUNWvWjLzW0dGRRYsW5cCBA43vefXVV7Nq1apRr11zzTV59tlnR35/5ZVXZt++fVm5cmUuuuiifOc738kPf/jD/PEf/3Er10tHx4x0dMxo6T0TbebMjlG/osnH0aXSpNKk0qTSpJkulSaVJpUmlSbNdKk0qTSpNKk0mVydnbp+VDs1majPjyaVJs10qTSpNKk0aW+aVJo006XSpNKk0qTSpJkulSaVJpUmlSbNdKk0qTSpNKk0aaZLpUmlSaVJpUkzXSpNKk0qTSpNmulSaVKdi01aGl8fP348Q0ND6e7uHvV6d3d33njjjcb3HD16ND09PeX80aNHR35/33335b777st1112Xzs7OzJgxI9/85jfzq7/6q61cLxdeeEFmzJja8fWHZs8+f6qvMO1o0kyXSpNKk0qTSpNmulSaVJpUmlSaNNOl0qTSpNKk0mRydHVdMNVXmHbascmZfn40qTRppkulSaVJpckngyaVJs10qTSpNKk0qTRppkulSaVJpUmlSTNdKk0qTSpNKk2a6VJpUmlSaVJp0kyXSpNKk0qTSpNmulSaVOdSk5bG15Nl586defXVV7Nly5Z87nOfy3e/+92sX78+F110URYtWnTaX+fYsXenxZOvZ88+P++8cyJDQ8NTepfpQpNmulSaVJpUmlSaNNOl0qTSpNKk0qSZLpUmlSaVJpUmk+v48Xen+grTTjs1majPjyaVJs10qTSpNKk0aW+aVJo006XSpNKk0qTSpJkulSaVJpUmlSbNdKk0qTSpNKk0aaZLpUmlSaVJpUkzXSpNKk0qTSpNmulSaVJNtyan8y/Sb2l83dXVlZkzZ2ZwcHDU64ODg+Xp1h/q6ekZ9ZTrj57/8Y9/nG9961v58z//81x//fVJkvnz5+f73/9+/vIv/7Kl8fXw8AcZHv6ghe9o8gwNDef996f+L8F0okkzXSpNKk0qTSpNmulSaVJpUmlSadJMl0qTSpNKk0qTyaFp1Y5NzvTzo0mlSTNdKk0qTSpNPhk0qTRppkulSaVJpUmlSTNdKk0qTSpNKk2a6VJpUmlSaVJp0kyXSpNKk0qTSpNmulSaVJpUmlSaNNOl0qQ6l5p0tHJ41qxZufzyy7N///6R14aHh7N///5ceeWVje/p7e3Nyy+/POq1l156Kb29vUmS999/P++9915mzBj9xOqZM2fmgw+mx5AaAAAAAAAAAAAAAAAAAABofy2Nr5PkjjvuyO7du7Nnz54cPnw4999/f06cOJHly5cnSQYGBvLQQw+NnL/99tvzwgsvZNu2bTl8+HAeeeSRHDx4MH19fUmST3/607n66qvz4IMP5jvf+U7+/d//PU899VSefvrp3HjjjRP0bQIAAAAAAAAAAAAAAAAAAJxaZ6tvWLp0aY4dO5bNmzfnyJEjWbBgQbZu3Zqenp4kyVtvvZWOjp9suq+66qps3LgxDz/8cDZt2pRLLrkkjz76aObNmzdyZtOmTdm0aVO+9rWv5T//8z/zuc99Ln/wB3+Qr371qxPwLQIAAAAAAAAAAAAAAAAAAIyt5fF1kvT19Y08ufqjdu7cWV5bsmRJlixZ8rFf7zOf+Uw2bNgwnqsAAAAAAAAAAAAAAAAAAABMiI6xjwAAAAAAAAAAAAAAAAAAALQ/42sAAAAAAAAAAAAAAAAAAIAYXwMAAAAAAAAAAAAAAAAAACQxvgYAAAAAAAAAAAAAAAAAAEhifA0AAAAAAAAAAAAAAAAAAJDE+BoAAAAAAAAAAAAAAAAAACCJ8TUAAAAAAAAAAAAAAAAAAEAS42sAAAAAAAAAAAAAAAAAAIAkxtcAAAAAAAAAAAAAAAAAAABJjK8BAAAAAAAAAAAAAAAAAACSGF8DAAAAAAAAAAAAAAAAAAAkMb4GAAAAAAAAAAAAAAAAAABIYnwNAAAAAAAAAAAAAAAAAACQxPgaAAAAAAAAAAAAAAAAAAAgifE1AAAAAAAAAAAAAAAAAABAEuNrAAAAAAAAAAAAAAAAAACAJMbXAAAAAAAAAAAAAAAAAAAASYyvAQAAAAAAAAAAAAAAAAAAkhhfAwAAAAAAAAAAAAAAAAAAJDG+BgAAAAAAAAAAAAAAAAAASGJ8DQAAAAAAAAAAAAAAAAAAkMT4GgAAAAAAAAAAAAAAAAAAIInxNQAAAAAAAAAAAAAAAAAAQBLjawAAAAAAAAAAAAAAAAAAgCTG1wAAAAAAAAAAAAAAAAAAAEmMrwEAAAAAAAAAAAAAAAAAAJIYXwMAAAAAAAAAAAAAAAAAACQxvgYAAAAAAAAAAAAAAAAAAEhifA0AAAAAAAAAAAAAAAAAAJDE+BoAAAAAAAAAAAAAAAAAACCJ8TUAAAAAAAAAAAAAAAAAAEAS42sAAAAAAAAAAAAAAAAAAIAkxtcAAAAAAAAAAAAAAAAAAABJjK8BAAAAAAAAAAAAAAAAAACSGF8DAAAAAAAAAAAAAAAAAAAkMb4GAAAAAAAAAAAAAAAAAABIYnwNAAAAAAAAAAAAAAAAAACQxPgaAAAAAAAAAAAAAAAAAAAgifE1AAAAAAAAAAAAAAAAAABAEuNrAAAAAAAAAAAAAAAAAACAJMbXAAAAAAAAAAAAAAAAAAAASYyvAQAAAAAAAAAAAAAAAAAAkhhfAwAAAAAAAAAAAAAAAAAAJDG+BgAAAAAAAAAAAAAAAAAASGJ8DQAAAAAAAAAAAAAAAAAAkMT4GgAAAAAAAAAAAAAAAAAAIInxNQAAAAAAAAAAAAAAAAAAQBLjawAAAAAAAAAAAAAAAAAAgCTG1wAAAAAAAAAAAAAAAAAAAEmMrwEAAAAAAAAAAAAAAAAAAJIYXwMAAAAAAAAAAAAAAAAAACQxvgYAAAAAAAAAAAAAAAAAAEhifA0AAAAAAAAAAAAAAAAAAJDE+BoAAAAAAAAAAAAAAAAAACCJ8TUAAAAAAAAAAAAAAAAAAEAS42sAAAAAAAAAAAAAAAAAAIAkxtcAAAAAAAAAAAAAAAAAAABJjK8BAAAAAAAAAAAAAAAAAACSGF8DAAAAAAAAAAAAAAAAAAAkMb4GAAAAAAAAAAAAAAAAAABIYnwNAAAAAAAAAAAAAAAAAACQxPgaAAAAAAAAAAAAAAAAAAAgifE1AAAAAAAAAAAAAAAAAABAEuNrAAAAAAAAAAAAAAAAAACAJMbXAAAAAAAAAAAAAAAAAAAASYyvAQAAAAAAAAAAAAAAAAAAkhhfAwAAAAAAAAAAAAAAAAAAJDG+BgAAAAAAAAAAAAAAAAAASGJ8DQAAAAAAAAAAAAAAAAAAkMT4GgAAAAAAAAAAAAAAAAAAIInxNQAAAAAAAAAAAAAAAAAAQBLjawAAAAAAAAAAAAAAAAAAgCTG1wAAAAAAAAAAAAAAAAAAAEmMrwEAAAAAAAAAAAAAAAAAAJIYXwMAAAAAAAAAAAAAAAAAACQxvgYAAAAAAAAAAAAAAAAAAEgyzvH1rl27snjx4ixcuDC33HJLXnvttVOef+aZZ3LTTTdl4cKFufnmm/P888+XM4cPH85v//Zv55d/+ZfT29ubFStW5M033xzP9QAAAAAAAAAAAAAAAAAAAFrW8vh679692bBhQ/r7+7Nnz57Mnz8/q1evzuDgYOP5V155JevWrcvKlSvz9NNP54Ybbkh/f39ef/31kTP/9m//lt/4jd/IpZdemp07d+Zv/uZv8ju/8zv5qZ/6qfF/ZwAAAAAAAAAAAAAAAAAAAC1oeXy9ffv23HrrrVmxYkXmzp2b9evX57zzzsuTTz7ZeH7Hjh259tprc+edd2bOnDlZu3ZtLrvssjzxxBMjZ771rW/luuuuy8DAQC677LL83M/9XG644YZ0d3eP/zsDAAAAAAAAAAAAAAAAAABoQWcrh0+ePJlDhw5lzZo1I691dHRk0aJFOXDgQON7Xn311axatWrUa9dcc02effbZJMnw8HCee+653HnnnVm9enW+973v5eKLL86aNWty4403tvTNdHTMSEfHjJbeM9FmzuwY9SuafBxdKk0qTSpNKk2a6VJpUmlSaVJp0kyXSpNKk0qTSpPJ1dmp60e1U5OJ+vxoUmnSrN26vLhsxakPzV015tdptyb/99fx0qTSpL1pUmnSTJdKk0qTSpNKk2a6VJpUmlSaVJo006XSpNKk0qTSpJkulSaVJpUmlSbNdKk0qTSpNKk0aaZLpUl1LjZpaXx9/PjxDA0NlSdSd3d354033mh8z9GjR9PT01POHz16NEkyODiY//7v/863v/3trF27Nl/72tfywgsv5Hd/93ezY8eOXH311ad9vwsvvCAzZkzt+PpDs2efP9VXmHY0aaZLpUmlSaVJpUkzXSpNKk0qTSpNmulSaVJpUmlSaTI5uroumOorTDvt2ORMPz+aVJo0a8cuZ6odm/j8VJpUfnarNKk0aaZLpUmlSaVJpUkzXSpNKk0qTSpNmulSaVJpUmlSadJMl0qTSpNKk0qTZrpUmlSaVJpUmjTTpdKkOpeatDS+ngzDw8NJkhtuuGHkCdkLFizIK6+8kr/+679uaXx97Ni70+LJ17Nnn5933jmRoaHhKb3LdKFJM10qTSpNKk0qTZrpUmlSaVJpUmnSTJdKk0qTSpNKk8l1/Pi7U32FaaedmkzU50eTSpNm7dZlIrRbE5+f0TSp/OxWaVJp0kyXSpNKk0qTSpNmulSaVJpUmlSaNNOl0qTSpNKk0qSZLpUmlSaVJpUmzXSpNKk0qTSpNGmmS6VJNd2anM6/SL+l8XVXV1dmzpyZwcHBUa8PDg6Wp1t/qKenZ+Qp103nu7q60tnZmTlz5ow6M2fOnPzTP/1TK9fL8PAHGR7+oKX3TJahoeG8//7U/yWYTjRppkulSaVJpUmlSTNdKk0qTSpNKk2a6VJpUmlSaVJpMjk0rdqxyZl+fjSpNGnWjl3OVDs28fmpNKn87FZpUmnSTJdKk0qTSpNKk2a6VJpUmlSaVJo006XSpNKk0qTSpJkulSaVJpUmlSbNdKk0qTSpNKk0aaZLpUl1LjVp6dEOs2bNyuWXX579+/ePvDY8PJz9+/fnyiuvbHxPb29vXn755VGvvfTSS+nt7R35mgsXLswPf/jDUWf+9V//NT/7sz/byvUAAAAAAAAAAAAAAAAAAADGraXxdZLccccd2b17d/bs2ZPDhw/n/vvvz4kTJ7J8+fIkycDAQB566KGR87fffnteeOGFbNu2LYcPH84jjzySgwcPpq+vb+TM6tWr88wzz2T37t350Y9+lCeeeCL/+I//mK9+9asT8C0CAAAAAAAAAAAAAAAAAACMrbPVNyxdujTHjh3L5s2bc+TIkSxYsCBbt25NT09PkuStt95KR8dPNt1XXXVVNm7cmIcffjibNm3KJZdckkcffTTz5s0bOfPrv/7ruf/++/MXf/EX+eY3v5lf+IVfyObNm/Mrv/IrE/AtAgAAAADAJ9eLy1aMfWjuqkm/BwAAAAAAAAAAwLmg5fF1kvT19Y16cvX/tXPnzvLakiVLsmTJklN+zZUrV2blypXjuQ4AAAAAAAAAAAAAAAAAAMAZ6xj7CAAAAAAAAAAAAAAAAAAAQPszvgYAAAAAAAAAAAAAAAAAAIjxNQAAAAAAAAAAAAAAAAAAQBLjawAAAAAAAAAAAAAAAAAAgCTG1wAAAAAAAAAAAAAAAAAAAEmMrwEAAAAAAAAAAAAAAAAAAJIYXwMAAAAAAAAAAAAAAAAAACQxvgYAAAAAAAAAAAAAAAAAAEhifA0AAAAAAAAAAAAAAAAAAJDE+BoAAAAAAAAAAAAAAAAAACCJ8TUAAAAAAAAAAAAAAAAAAEAS42sAAAAAAAAAAAAAAAAAAIAkxtcAAAAAAAAAAAAAAAAAAABJjK8BAAAAAAAAAAAAAAAAAACSGF8DAAAAAAAAAAAAAAAAAAAkMb4GAAAAAAAAAAAAAAAAAABIYnwNAAAAAAAAAAAAAAAAAACQxPgaAAAAAAAAAAAAAAAAAAAgifE1AAAAAAAAAAAAAAAAAABAEuNrAAAAAAAAAAAAAAAAAACAJMbXAAAAAAAAAAAAAAAAAAAASYyvAQAAAAAAAAAAAAAAAAAAkhhfAwAAAAAAAAAAAAAAAAAAJDG+BgAAAAAAAAAAAAAAAAAASGJ8DQAAAAAAAAAAAAAAAAAAkMT4GgAAAAAAAAAAAAAAAAAAIInxNQAAAAAAAAAAAAAAAAAAQBLjawAAAAAAAAAAAAAAAAAAgCTG1wAAAAAAAAAAAAAAAAAAAEmMrwEAAAAAAAAAAAAAAAAAAJIYXwMAAAAAAAAAAAAAAAAAACQxvgYAAAAAAAAAAAAAAAAAAEhifA0AAAAAAAAAAAAAAAAAAJDE+BoAAAAAAAAAAAAAAAAAACCJ8TUAAAAAAAAAAAAAAAAAAEAS42sAAAAAAAAAAAAAAAAAAIAkxtcAAAAAAAAAAAAAAAAAAABJjK8BAAAAAAAAAAAAAAAAAACSGF8DAAAAAAAAAAAAAAAAAAAkMb4GAAAAAAAAAAAAAAAAAABIYnwNAAAAAAAAAAAAAAAAAACQxPgaAAAAAAAAAAAAAAAAAAAgifE1AAAAAAAAAAAAAAAAAABAEuNrAAAAAAAAAAAAAAAAAACAJMbXAAAAAAAAAAAAAAAAAAAASYyvAQAAAAAAAAAAAAAAAAAAkhhfAwAAAAAAAAAAAAAAAAAAJDG+BgAAAAAAAAAAAAAAAAAASGJ8DQAAAAAAAAAAAAAAAAAAkCTpnOoLAAAAAAAATKT+fQNjnrn7LNwDAAAAAAAAAAA493jyNQAAAAAAAAAAAAAAAAAAQIyvAQAAAAAAAAAAAAAAAAAAkiSdU30BAAAAAABg/Pr3DZzyz+8+S/cAAAAAAAAAAABoB558DQAAAAAAAAAAAAAAAAAAEONrAAAAAAAAAAAAAAAAAACAJMbXAAAAAAAAAAAAAAAAAAAASYyvAQAAAAAAAAAAAAAAAAAAkhhfAwAAAAAAAAAAAAAAAAAAJDG+BgAAAAAAAAAAAAAAAAAASGJ8DQAAAAAAAAAAAAAAAAAAkMT4GgAAAAAAAAAAAAAAAAAAIInxNQAAAAAAAAAAAAAAAAAAQBLjawAAAAAAAAAAAAAAAAAAgCTG1wAAAAAAAAAAAAAAAAAAAEmMrwEAAAAAAAAAAAAAAAAAAJIYXwMAAAAAAAAAAAAAAAAAACRJOqf6AgAAAAAAcDr69w2MeWb3bVvOwk0AAAAAAAAAAABoV558DQAAAAAAAAAAAAAAAAAAEONrAAAAAAAAAAAAAAAAAACAJMbXAAAAAAAAAAAAAAAAAAAASZLOqb4AAAAAAABV/76BMc/svm3LWbgJAAAAAAAAAAAAfHJ48jUAAAAAAAAAAAAAAAAAAECMrwEAAAAAAAAAAAAAAAAAAJIYXwMAAAAAAAAAAAAAAAAAACQxvgYAAAAAAAAAAAAAAAAAAEhifA0AAAAAAAAAAAAAAAAAAJBknOPrXbt2ZfHixVm4cGFuueWWvPbaa6c8/8wzz+Smm27KwoULc/PNN+f555//2LN/8id/ks9//vN57LHHxnM1AAAAAAAAAAAAAAAAAACAcWl5fL13795s2LAh/f392bNnT+bPn5/Vq1dncHCw8fwrr7ySdevWZeXKlXn66adzww03pL+/P6+//no5+/d///f553/+51x00UWtfycAAAAAAAAAAAAAAAAAAABnoOXx9fbt23PrrbdmxYoVmTt3btavX5/zzjsvTz75ZOP5HTt25Nprr82dd96ZOXPmZO3atbnsssvyxBNPjDr39ttv5xvf+EY2btyYT33qU+P7bgAAAAAAAAAAAAAAAAAAAMaps5XDJ0+ezKFDh7JmzZqR1zo6OrJo0aIcOHCg8T2vvvpqVq1aNeq1a665Js8+++zI74eHh/NHf/RHWb16dX7xF3+xlSuN0tExIx0dM8b9/okwc2bHqF/R5OPoUmlSaVJpUmnSTJdKk0qTSpNKk2a6VJpUmlSaVJpMrs5OXT+qHZuc6edHk6odm0wEXap2ajJR/5msSaVJe9Ok0qSZLpUmlSaVJpUmzXSpNKk0qTSpNGmmS6VJpUmlSaVJM10qTSpNKk0qTZrpUmlSaVJpUmnSTJdKk+pcbNLS+Pr48eMZGhpKd3f3qNe7u7vzxhtvNL7n6NGj6enpKeePHj068vtvf/vb6ezszO23397KdYoLL7wgM2ZM7fj6Q7Nnnz/VV5h2NGmmS6VJpUmlSaVJM10qTSpNKk0qTZrpUmlSaVJpUmkyObq6LpjqK0w77djkTD8/mlTt2GQi6FK1YxOfn0qTys9ulSaVJs10qTSpNKk0qTRppkulSaVJpUmlSTNdKk0qTSpNKk2a6VJpUmlSaVJp0kyXSpNKk0qTSpNmulSaVOdSk5bG15Ph4MGD2bFjR5566qkzHk4fO/butHjy9ezZ5+edd05kaGh4Su8yXWjSTJdKk0qTSpNKk2a6VJpUmlSaVJo006XSpNKk0qTSZHIdP/7uVF9h2mnHJmf6+dGkascmE0GXqp2aTNR/JmtSadLeNKk0aaZLpUmlSaVJpUkzXSpNKk0qTSpNmulSaVJpUmlSadJMl0qTSpNKk0qTZrpUmlSaVJpUmjTTpdKkmm5NTudfpN/S+LqrqyszZ87M4ODgqNcHBwfL060/1NPTM+op1x89/93vfjeDg4P50pe+NPLnQ0ND+bM/+7Ps2LEj+/btO+37DQ9/kOHhD077/GQaGhrO++9P/V+C6USTZrpUmlSaVJpUmjTTpdKk0qTSpNKkmS6VJpUmlSaVJpND06odm5zp50eTqh2bTARdqnZs4vNTaVL52a3SpNKkmS6VJpUmlSaVJs10qTSpNKk0qTRppkulSaVJpUmlSTNdKk0qTSpNKk2a6VJpUmlSaVJp0kyXSpPqXGrS0vh61qxZufzyy7N///7ceOONSZLh4eHs378/fX19je/p7e3Nyy+/nFWrVo289tJLL6W3tzdJsmzZsixatGjUe1avXp1ly5Zl+fLlrVwPAAAAAAAAAAAAAAAAAABg3FoaXyfJHXfckXvuuSdf+MIXcsUVV+Txxx/PiRMnRobSAwMD+exnP5t169YlSW6//fb85m/+ZrZt25Zf+7Vfy969e3Pw4MF8/etfT/K/T9Pu6uoa9c/41Kc+lZ6enlx66aVn+v0BAAAAAAAAAAAAAAAAAACclpbH10uXLs2xY8eyefPmHDlyJAsWLMjWrVvT09OTJHnrrbfS0dExcv6qq67Kxo0b8/DDD2fTpk255JJL8uijj2bevHkT910AAAAAAAAAAAAAAAAAAACcoZbH10nS19eXvr6+xj/buXNneW3JkiVZsmTJaX/9ffv2jedaAAAAAAAAAAAAAAAAAAAA49Yx9hEAAAAAAAAAAAAAAAAAAID2Z3wNAAAAAAAAAAAAAAAAAAAQ42sAAAAAAAAAAAAAAAAAAIAkxtcAAAAAAAAAAAAAAAAAAABJjK8BAAAAAAAAAAAAAAAAAACSGF8DAAAAAAAAAAAAAAAAAAAkMb4GAAAAAAAAAAAAAAAAAABIYnwNAAAAAAAAAAAAAAAAAACQxPgaAAAAAAAAAAAAAAAAAAAgifE1AAAAAAAAAAAAAAAAAABAEuNrAAAAAAAAAAAAAAAAAACAJMbXAAAAAAAAAAAAAAAAAAAASYyvAQAAAAAAAAAAAAAAAAAAkhhfAwAAAAAAAAAAAAAAAAAAJDG+BgAAAAAAAAAAAAAAAAAASGJ8DQAAAAAAAAAAAAAAAAAAkMT4GgAAAAAAAAAAAAAAAAAAIInxNQAAAAAAAAAAAAAAAAAAQBLjawAAAAAAAAAAAAAAAAAAgCTG1wAAAAAAAAAAAAAAAAAAAEmMrwEAAAAAAAAAAAAAAAAAAJIYXwMAAAAAAAAAAAAAAAAAACQxvgYAAAAAAAAAAAAAAAAAAEhifA0AAAAAAAAAAAAAAAAAAJDE+BoAAAAAAAAAAAAAAAAAACCJ8TUAAAAAAAAAAAAAAAAAAEAS42sAAAAAAAAAAAAAAAAAAIAkxtcAAAAAAAAAAAAAAAAAAABJjK8BAAAAAAAAAAAAAAAAAACSGF8DAAAAAAAAAAAAAAAAAAAkMb4GAAAAAAAAAAAAAAAAAABIYnwNAAAAAAAAAAAAAAAAAACQxPgaAAAAAAAAAAAAAAAAAAAgifE1AAAAAAAAAAAAAAAAAABAEuNrAAAAAAAAAAAAAAAAAACAJMbXAAAAAAAAAAAAAAAAAAAASYyvAQAAAAAAAAAAAAAAAAAAkhhfAwAAAAAAAAAAAAAAAAAAJDG+BgAAAAAAAAAAAAAAAAAASGJ8DQAAAAAAAAAAAAAAAAAAkMT4GgAAAAAAAAAAAAAAAAAAIInxNQAAAAAAAAAAAAAAAAAAQBLjawAAAAAAAAAAAAAAAAAAgCTG1wAAAAAAAAAAAAAAAAAAAEmMrwEAAAAAAAAAAAAAAAAAAJIYXwMAAAAAAAAAAAAAAAAAACQxvgYAAAAAAAAAAAAAAAAAAEhifA0AAAAAAAAAAAAAAAAAAJDE+BoAAAAAAAAAAAAAAAAAACCJ8TUAAAAAAAAAAAAAAAAAAEAS42sAAAAAAAAAAAAAAAAAAIAkxtcAAAAAAAAAAAAAAAAAAABJjK8BAAAAAAAAAAAAAAAAAACSGF8DAAAAAAAAAAAAAAAAAAAkMb4GAAAAAAAAAAAAAAAAAABIYnwNAAAAAAAAAAAAAAAAAACQJOmc6gsAADB9bHnguTHP3HXv9ZN+DwAAAAAAAAAAAAAAAJgKnnwNAAAAAAAAAAAAAAAAAAAQ42sAAAAAAAAAAAAAAAAAAIAkxtcAAAAAAAAAAAAAAAAAAABJjK8BAAAAAAAAAAAAAAAAAACSGF8DAAAAAAAAAAAAAAAAAAAkMb4GAAAAAAAAAAAAAAAAAABIYnwNAAAAAAAAAAAAAAAAAACQxPgaAAAAAAAAAAAAAAAAAAAgSdI51RcAAJgqWx54bswzd917/aTfAwAAAAAAAAAAAAAAAJgePPkaAAAAAAAAAAAAAAAAAAAgxtcAAAAAAAAAAAAAAAAAAABJjK8BAAAAAAAAAAAAAAAAAACSJJ1TfQEAAM6eF5etOPWBuavOyj0AAAAAAAAAAAAAAABgOvLkawAAAAAAAAAAAAAAAAAAgBhfAwAAAAAAAAAAAAAAAAAAJDG+BgAAAAAAAAAAAAAAAAAASJJ0TvUFAAAmy4vLVpz6wNxVZ+UeAAAAAAAAAAAAAAAAwLnBk68BAAAAAAAAAAAAAAAAAABifA0AAAAAAAAAAAAAAAAAAJBknOPrXbt2ZfHixVm4cGFuueWWvPbaa6c8/8wzz+Smm27KwoULc/PNN+f5558f+bP33nsvDz74YG6++eb09vbmmmuuycDAQN5+++3xXA0AAAAAAAAAAAAAAAAAAGBcOlt9w969e7Nhw4asX78+v/RLv5THH388q1evzt/93d+lu7u7nH/llVeybt26/OEf/mG+9KUv5W//9m/T39+fp556KvPmzcuPf/zjfO9738tdd92V+fPn55133smf/umf5q677spTTz01Id8kAAAAAAAA/F/9+wbGPLP7ti1n4SYAAAAAAAAAAEwnLT/5evv27bn11luzYsWKzJ07N+vXr895552XJ598svH8jh07cu211+bOO+/MnDlzsnbt2lx22WV54oknkiQ/8zM/k+3bt2fp0qW59NJL09vbm/vuuy+HDh3Km2++eWbfHQAAAAAAAAAAAAAAAAAAwGlq6cnXJ0+ezKFDh7JmzZqR1zo6OrJo0aIcOHCg8T2vvvpqVq1aNeq1a665Js8+++zH/nP+67/+KzNmzMjs2bNbuV46Omako2NGS++ZaDNndoz6FU0+ji6VJpUmlSaVJs0mqkdn57nTdc3/+9qYZ+6egH/OudRkLD4/lSaVJs10qTSpNKk0qTSZXO30s9tEaccmZ/r50aRqxyYTQZfqXGpyOv+9we7btvj8NNDkJ/zsVmlSadJMl0qTSpNKk0qTZrpUmlSaVJpUmjTTpdKk0qTSpNKkmS6VJpUmlSaVJs10qTSpNKk0qTRppkulSXUuNmlpfH38+PEMDQ2lu7t71Ovd3d154403Gt9z9OjR9PT0lPNHjx5tPP8///M/2bhxY7785S/n05/+dCvXy4UXXpAZM6Z2fP2h2bPPn+orTDuaNNOl0qTSpNKk0mRydHVdMNVXmHbasYnPT6VJpUkzXSpNKk0qTSpNJkc7/ux2ptqxyZl+fjSp2rHJRNClascmPj+VJpWf3SpNKk2a6VJpUmlSaVJp0kyXSpNKk0qTSpNmulSaVJpUmlSaNNOl0qTSpNKk0qSZLpUmlSaVJpUmzXSpNKnOpSYtja8n23vvvZe77747H3zwQdavX9/y+48de3daPPl69uzz8847JzI0NDyld5kuNGmmS6VJpUmlSaVJs4n6t+EcP/7uhHyddtJOTXx+Kk0qTZrpUmlSaVJpUmkyudrpZ7eJ0o5NzvTzo0nVjk0mgi5VOzbx+ak0+Qk/u1WaVJo006XSpNKk0qTSpJkulSaVJpUmlSbNdKk0qTSpNKk0aaZLpUmlSaVJpUkzXSpNKk0qTSpNmulSaVJNtyan8y/Sb2l83dXVlZkzZ2ZwcHDU64ODg+Xp1h/q6ekpT7luOv/ee+9l7dq1efPNN/P444+3/NTrJBke/iDDwx+0/L7JMDQ0nPffn/q/BNOJJs10qTSpNKk0qTSZHJpW7djE56fSpNKkmS6VJpUmlSaVJpND06odm5zp50eTqh2bTARdqnZs4vNTaVL52a3SpNKkmS6VJpUmlSaVJs10qTSpNKk0qTRppkulSaVJpUmlSTNdKk0qTSpNKk2anarLlgeeG/P9d917/cReaBrwd6XSpNKk0qSZLpUm1bnUpKXx9axZs3L55Zdn//79ufHGG5Mkw8PD2b9/f/r6+hrf09vbm5dffjmrVq0aee2ll15Kb2/vyO8/HF7/6Ec/yo4dO9LV1dX6dwIAfKL07xsY88zdZ+EeAAAAAAAAAAAAAAAAQPvoaPUNd9xxR3bv3p09e/bk8OHDuf/++3PixIksX748STIwMJCHHnpo5Pztt9+eF154Idu2bcvhw4fzyCOP5ODBgyNj7ffeey+///u/n4MHD2bjxo0ZGhrKkSNHcuTIkZw8eXKCvk0AAAAAAAAAAAAAAAAAAIBTa+nJ10mydOnSHDt2LJs3b86RI0eyYMGCbN26NT09PUmSt956Kx0dP9l0X3XVVdm4cWMefvjhbNq0KZdcckkeffTRzJs3L0ny9ttvZ9++fUmSZcuWjfpn7dixI1/84hfH/c0BAAAAAAAAAAAAAAAAAACcrpbH10nS19c38uTqj9q5c2d5bcmSJVmyZEnj+Ysvvjg/+MEPxnMNAAAAAAAAAAAAAAAAAACACdMx9hEAAAAAAAAAAAAAAAAAAID2Z3wNAAAAAAAAAAAAAAAAAAAQ42sAAAAAAAAAAAAAAAAAAIAkxtcAAAAAAAAAAAAAAAAAAABJjK8BAAAAAAAAAAAAAAAAAACSGF8DAAAAAAAAAAAAAAAAAAAkMb4GAAAAAAAAAAAAAAAAAABIYnwNAAAAAAAAAAAAAAAAAACQJOmc6gt8Um154LlT/vld915/Vu4BAAAAAAAAAAAAAAAAAAD8L0++BgAAAAAAAAAAAAAAAAAAiPE1AAAAAAAAAAAAAAAAAABAEuNrAAAAAAAAAAAAAAAAAACAJEnnVF8AAAAAAAAAAAAAAAAAYDK8uGzFqQ/MXXVW7gEAnDuMrwEAAAAAAAAAAAAAAIBzTv++gTHP3H0W7gEAtJeOqb4AAAAAAAAAAAAAAAAAAADAdGB8DQAAAAAAAAAAAAAAAAAAEONrAAAAAAAAAAAAAAAAAACAJMbXAAAAAAAAAAAAAAAAAAAASYyvAQAAAAAAAAAAAAAAAAAAkhhfAwAAAAAAAAAAAAAAAAAAJDG+BgAAAAAAAAAAAAAAAAAASGJ8DQAAAAAAAAAAAAAAAAAAkMT4GgAAAAAAAAAAAAAAAAAAIInxNQAAAAAAAAAAAAAAAAAAQBLjawAAAAAAAAAAAAAAAAAAgCTG1wAAAAAAAAAAAAAAAAAAAEmMrwEAAAAAAAAAAAAAAAAAAJIYXwMAAAAAAAAAAAAAAAAAACQxvgYAAAAAAAAAAAAAAAAAAEhifA0AAAAAAAAAAAAAAAAAAJDE+BoAAAAAAAAAAAAAAAAAACBJ0jnVFwAAAACAsWx54Lkxz9x17/WTfg8AAAAAAAAAAAD+l/9dF9CuPPkaAAAAAAAAAAAAAAAAAAAgnnwNAAAAAAAAAAAAAAAAAKc01lOePeEZoH148jUAAAAAAAAAAAAAAAAAAECMrwEAAAAAAAAAAAAAAAAAAJIYXwMAAAAAAAAAAAAAAAAAACQxvgYAAAAAAAAAAAAAAAAAAEhifA0AAAAAAAAAAAAAAAAAAJDE+BoAAAAAAAAAAAAAAAAAACCJ8TUAAAAAAAAAAAAAAAAAAEAS42sAAAAAAAAAAAAAAAAAAIAkxtcAAAAAAAAAAAAAAAAAAABJjK8BAAAAAAAAAAAAAAAAAACSGF8DAAAAAAAAAAAAAAAAAAAkMb4GAAAAAAAAAAAAAAAAAABIknRO9QXgQ1seeG7MM3fde/2k32M60QQAAAAAAAAAAAAAAAAA4OwxvgYAAAAAAAAAAAAAAAAAgDH07xsY88zu27ac8s89tHX6M76eBC8uWzH2obmrJv0eAAAAAOcC/10KAAAAAAAAAAAAANNFx1RfAAAAAAAAAAAAAAAAAAAAYDrw5OtxGOux8HefpXtMJ2M12X3blrN0EwAAAAAAAAAAAAAAAAAAGB9PvgYAAAAAAAAAAAAAAAAAAIgnX8OkGetp4IknggMAAAAAAAAAAAAAAAAATCeefA0AAAAAAAAAAAAAAAAAABDjawAAAAAAAAAAAAAAAAAAgCRJ51RfAABa9eKyFWOembf1scm/CAAATJItDzx3yj+/697rz8o9AAAAAAAAAADOZWP9bzAS/zsMAAAq42sAAABgShkaAwAAAAAAAAAAAADTRcdUXwAAAAAAAAAAAAAAAAAAAGA68ORrANqSpycCAAAAAAAA/H/27juqqqNdA/hzBOwFW+yKBXvvNXZjVyyJiVIUxF6wUhSxUOyCqKioiDU2bMFuNGrsvWHHgl1UBGzAuX9wOeE4GyX59MyR/fzW+tbVvU+y3sydPXv2zLwzRERERERERERERERE9G8x+ZqIiIiIiIi+iS9thgJwQxQitRi0f8xn7w8zUBxERERERERERERERERERERERERERERfwuRrIiIiIqIv+FICqRqTR1kmRERERERERERERERERERERERERERERESUFjH5moiIjA5PxSMiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIhmYfE1EREREREREZEBHOnX98o9K2X3zOIiIiIiIiIiIiIiIiIiIiIiIiIiIiEiUTnYARERERERERERERERERERERERERERERERERERERERExoDJ10RERERERERERERERERERERERERERERERERERERERABMZQdARJTckU5dP3t/Xym7L/47Bjg3+TrBEBERERERERERERERERERERERERERERERERERkarw5GsiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiLw5GsiIiLVWOBz4Iu/4cnxRERE3xbfx0RE9LUd6dT1yz8qZffN4yAiIiIiIiIiIiIiIiIiIiIiSutSs1andGDQtw+EiL45Jl8TEREREanMoP1jPnt/3S8LDBRJ2sKkWiIiIiLjwIR0IiIiIiIiIiIiIiIiIiIioi/jmmIiopQx+ZqIiIiI0qwvDQgAHBQgSgmfH0oN1hMiIiIiIiIiIiIiIiIiIiL6Fr604S5PlCQion+Da92IiOjfYvI1ERlMajqrwwwQBxERERERERERERGJvnhyPE+NJyIiIiIiIiIiIiIiIkoTvjQ3uC8Vc4MDnJt8nWCIiIiMEJOviYiIiIiIiIiIiIiIiBR8MSEdYFI6ERERERERERERERERERERURrD5GsiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIvpuLPA58MXf8ETW79+g/WM+e3/dLwsMFAkRERERqQ2Tr4mIiIiIiOg/+eIJcDz9jVToS5N+ADDMAHEQERERERERERERERERERERERERERHRf8PkayKiNOBLu/dx5z4iopR9MXkUYAIpsZ4QERERERERERERERERERF9BVzrJuLpvURE/x3Xdf03fPcQEX1bbGdFLBP6HjH5mojIyHFQgIAvn6C47pcFBoqEiNSA7x4iIiIiIiIiIiIiIiIiIiIiIqLvDze5ICLgy2vPAWCYAeIgIiL6njH5mgyCCTxERERERETqxO9BIiIiIiL14eI+EXdyF7FMRCwTZWxTRCwTEZ8fEctExDJRxjZFxDIR8fkRsUxELBNlaalNSVUCz+qnX/4XqWxukPOl/w3bFBHLhIiIiIiI1MCYxlL+U/L1qlWrsGTJEjx79gxly5bF+PHjUbly5RR/v2PHDvj6+iIiIgIWFhYYNWoUGjdurLuv1Wrh5+eH9evXIyoqCtWrV4eHhwcsLCz+S3hE340vDqpxQC3N445S9LVwkJ6IiOjb+yqLCfg+JiIiIiIiIiIiIiIiIkoTuF6HgC/PI3P9H5Eyrp/9b/juodRgPSH67/j8iFgmlFrMkROxTL5//zr5OjQ0FN7e3pg4cSKqVKmC5cuXw97eHjt37kTu3LmF3585cwYjR47EiBEj0LRpU2zbtg2DBg3Cpk2bULp0aQDA4sWLsWLFCvj4+KBw4cLw9fWFvb09QkNDkSFDhv/9v5KIiIiIiOgzOBlKRERERERElDpcYCFimYhYJsq4wELEuiJimYhYJiKWiTK2syLWFRHLRMQyEbFMlLGdJaKvhe2sMrazRERERET0Pfsqh1wBRvXt86+Tr5ctW4aff/4ZXbsmfuBNnDgRBw4cwMaNG+Ho6Cj8Pjg4GI0aNYKDgwMAYPjw4fj777+xcuVKTJo0CVqtFsHBwRgwYABatGgBAJg2bRrq16+PvXv3ol27dqmOLV06DdKl0/zb/ySjZGqaTnYIRonlImKZiFgmIpaJiGWizFjKxWbK3i/+JlNtAwQClokSYykTY8IyEbFMlLFcRCwTEctExDIRsUyUGUu5sO8mYpko+1K5sExELBNlaisXlomIZaKMbcrXZ2Lydf5bvrcy6bd71Gfvf61N276ncmGZ/HtqfX4+h2UiYpmIvlaZAGmnXFgmyvj8iFgmIrWWCftuIpbJv6fW5+dzWCbfDstEWVopF/ZnlbFN+Xa+pzL5Uh8F+Dr9lO+pTAzpeyoX9mflYZmIWCYilomytFIuau3Psp8iD8tEZMgy0Wi1Wm1qf/zhwwdUrVoVfn5+ukRpABg7diyioqKwYMEC4Z9p0qQJ7OzsYGdnp7vm5+eHvXv3YuvWrbh//z5atGiBzZs3o1y5crrf9OrVC2XLlsW4ceP+438aERERERERERERERERERERERERERERERERERERERFR6v2rNO+XL18iPj4euXPn1rueO3duPH/+XPGfef78OfLkyZPi7589e6a7ltp/JxERERERERERERERERERERERERERERERERERERER0dfGc8eJiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIjwL5Ovc+bMCRMTE7x48ULv+osXL4TTrZPkyZNHOME6+e/z5s2ru5bafycREREREREREREREREREREREREREREREREREREREdHX9q+Sr9OnT48KFSrg6NGjumsJCQk4evQoqlWrpvjPVK1aFceOHdO79vfff6Nq1aoAgMKFCyNv3rx6/87o6GicP38+xX8nERERERERERERERERERERERERERERERERERERERHR1/avkq8BoHfv3li3bh1CQkJw69YteHh44O3bt+jSpQsAYMyYMZg5c6bu9zY2Njh06BCWLl2KW7duYe7cubh06RJ69eoFANBoNLCxscGCBQuwb98+XLt2DWPGjMEPP/yAFi1afKX/TCIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIios8z/bf/QNu2bREZGQk/Pz88e/YM5cqVQ2BgIPLkyQMAePToEdKl+yenu3r16pgxYwbmzJmDWbNmwcLCAvPmzUPp0qV1v+nbty/evn0Ld3d3REVFoUaNGggMDESGDBm+wn8iERERERERERERERERERERERERERERERERERERERHRl2m0Wq1WdhBERERERERERERERERERERERERERERERERERERERESypfvyT4iIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiNI+Jl8TERERERERERERERERERERERERERERERERERERERGByddEREREREREREREREREREREREREREREREREREREREQAmHxNREREREREREREREREREREREREREREREREREREREQEADCVHQARqdeTJ09w+vRpREZGIiEhQe+ejY2NpKjkev/+Pa5du4YXL14IZdK8eXNJUREREREREREREREREREREREREREREREREREREamDRqvVamUHkRZcuHABx48fV0widXFxkRQVGbOYmBh8+vhlzZpVUjSGt2nTJri7u8PMzAw5c+bUu6fRaLBv3z5Jkcnz119/YezYsXj58qVwT6PR4OrVqxKiku/ly5fw8/PD8ePH8eLFC+G5OXHihKTIiIiI1OnFixeKG8WULVtWUkTycQMdETdaUsbnRx+fHSIiIiKitEntc2ApYbno4zeyPn4jK2M90cd6oozrdUQsE2VsU0QsE31sZ5WxXEQsE6L/ju8efey3KWM7S0RfE989IrazlBqsJ0T0tX2vc6U8+forCAgIwJw5c1C8eHHkyZNH755Go5EUlVxMllR2//59TJ48GSdOnMD79+9117VareqSa319fTFo0CD069cP6dKlkx2OUZgyZQpat26NQYMGCW2Jmo0ZMwb37t1D165dkSdPHtW2q1/yvXZEvgV+7ImYAEf0771//x4rVqxIsT8bEhIiKTJ5Ll26BGdnZ9y6dUtXHhqNRpV92eS4gY7oSxstqfHdw+dHxGfn8zj5p499fKL/HccN9LGd1ccFfvQlnPMRsUxEnANTxnIR8RtZxG9kEeuJiPVEGdfriFgmIrYpIpaJiO2sMpaLiGWSMo65iTi/8Q++e0TstyljOyviGiYRx2dFrCcivnuUsZ0VabVa7Ny5M8X5Un9/f0mRycN68nn89qEv4RqMf6SFuVKefP0V1K9fH6NGjUKXLl1kh2I0+vbt+9lkSSsrK0mRydWjRw8AiYluuXPnFsqldu3aMsKSok6dOli/fj2KFi0qOxSjUb16dWzevJll8olq1aphzZo17IwqSAsdka+NH3uiLyXA7du3T1Jk8nCgURkHpfWNHDkSR44cwU8//aTYnx08eLCkyOTp2LEjihYtir59+yr2ZQsVKiQpMrlatWqFBg0acAOdZBo3bowePXpwo6Vk+PyI+Owo4+SfiH18ESf+lLGfL+K4gYjtrOhLC/yCg4MlRSYP21kR53xELBMR58CUsVxE/EYW8RtZxHoiYj1RxvU6IpaJiG2KiGUiYjurjOUiYpmIOOamjPMb+vjuEbHfpoztrIhrmEQcnxWxnoj47lHGdlY0ZcoU/P7776hTp47i8+Pt7S0pMnlYT5Tx20fEuXUR12DoSwtzpTz5+itIly4dqlevLjsMo3Lq1CkmSyq4du0aNm7ciBIlSsgORbquXbti586dcHR0lB2K0fjpp59w/PhxJl9/okSJEnj37p3sMIzS6NGjAQBeXl6KHRE14gnyIl9fXwwaNIgJcMm4urrqBhorV67MZ+f/jRkz5rOD0mpz4MABLFq0CDVq1JAditG4f/8+5s6di2LFiskOxag8f/4cvXv35nsnmXfv3qFdu3Z87yTD50fEZ0eZq6srLCws4OnpyT7+/2MfX+Tp6fnZiT+1Yj9fxHEDEdtZUXBwMLy8vLjALxm2syLO+YhYJiLOgSljuYj4jSziN7KI9UTEeqKM63VELBMR2xQRy0TEdlYZy0XEMhFxzE0Z5zf08d0jYr9NGdtZEdcwiTg+K2I9EfHdo4ztrGjr1q3w9/dH48aNZYdiNFhPlPHbR8S5dRHXYOhLC3OlTL7+CmxtbbFq1Sq4ubnJDsVoMFlSWcWKFfH48ePvutH4WkaOHIl+/frh0KFDKF26NExN9ZsjFxcXSZHJ4+7ujmHDhuH06dOKZWJjYyMpMrkmTJiAmTNnYtCgQbC0tISZmZne/axZs0qKTL600BH52vixJ2ICnIgDjco4KK0vX758yJIli+wwjEq9evUQFhbGAelPcAMdETdaEvH5EfHZUcbJPxH7+CJO/CljP1/EcQMR21kRF/iJ2M6KOOcjYpmIOAemjOUi4jeyiN/IItYTEeuJMq7XEbFMRGxTRCwTEdtZZSwXEctExDE3ZZzf0Md3j4j9NmVsZ0VcwyTi+KyI9UTEd48ytrOirFmzonDhwrLDMCqsJ8r47SPi3LqIazD0pYW5Uo026ax7+s8SEhLg6OiI8PBwlCpVSkiY9Pf3lxSZPBcuXGCypIJ79+5hwoQJ6NixIywtLYW6oqZkp/nz58PPzw/FixcXBhg1Gg2Cg4MlRSbP+vXr4eHhgfTp0yNnzpx69zQaDfbt2ycpMrnCw8MxcuRIXLlyRe+6VquFRqPB1atXJUUmn7W1NQYMGID69evLDsVouLi4oHr16ujevbvsUIzGtGnTYG5uzgS4ZNq2bYtZs2ap6r2bGl27dsX48eNRtWpV2aEYhYMHD2LFihWYOHEiChUqJDscoxAZGQlnZ2dUrlxZsS/bvHlzSZHJ9fbtWwwbNgy5cuXiBjr/Lz4+Hv369cP79++50dL/4/Mj4rOjbODAgejUqRN++ukn2aEYDfbxRc2aNcPixYtRsmRJ2aEYFfbzRRw3ELGdFS1evBhPnz7lAr9k2M6KOOcjYpmIOAemjOUi4jeyiN/IItYTEeuJMq7XEbFMRGxTRCwTEdtZZSwXEctExDE3ZZzf0Md3j4j9NmVsZ0VcwyTi+KyI9UTEd48ytrOikJAQHDp0CF5eXsiYMaPscIwC64kyfvuIOLcu4hoMfWlhrpTJ11/BpEmTsH79etSpUwd58uSBRqPRu+/t7S0pMnmYLKns3LlzGDlyJCIiInTXNBqNKsulVq1acHFxQZcuXWSHYjQaNGgAa2trODo68oTaZLp16wZTU1PY2Nggd+7cQhtbu3ZtSZHJlxY6Il8bP/ZETIATcaBRGQel9UVGRmLYsGE4deoUMmbMKJTHiRMnJEUmz/79+zFmzBhER0cL99TWl02OG+iIuNGSiM+PiM+OMk7+idjHF3HiTxn7+SKOG4jYzoq4wE/EdlbEOR8Ry0TEOTBlLBcRv5FF/EYWsZ6IWE+Ucb2OiGUiYpsiYpmI2M4qY7mIWCYijrkp4/yGPr57ROy3KWM7K+IaJhHHZ0WsJyK+e5SxnRW9e/cOgwYNwpkzZ1C4cGGh3xYSEiIpMnlYT5Tx20fEuXUR12DoSwtzpUy+/gqqVauG2bNno0mTJrJDMRpMllTWtm1blCxZEg4ODorloqaFoQ0aNMCqVatgYWEhOxSjUbt2bWzYsAFFixaVHYpRqVKlCkJCQlCiRAnZoRidtNAR+dr4sSdiApyIA43KOCitz87ODo8ePULXrl0VJ7msrKwkRSZPs2bN0KRJEwwcOFBoT9SMG+iIuNGSiM+PiM+OMk7+idjHF3HiTxn7+SKOG4jYzoq4wE/EdlbEOR8Ry0TEOTBlLBcRv5FF/EYWsZ6IWE+Ucb2OiGUiYpsiYpmI2M4qY7mIWCYijrkp4/yGPr57ROy3KWM7K+IaJhHHZ0WsJyK+e5SxnRUNGzYMx48fx08//aT4/AwePFhSZPKwnijjt4+Ic+sirsHQlxbmSk2//BP6EnNzcxQpUkR2GEblxo0bTJZU8PDhQyxYsADFihWTHYp0NjY2WLlyJcaNGyc7FKPRuXNnhIaGon///rJDMSoVK1bE48eP2Z4ocHV1Rfny5TFr1izFjogazZkzB0OGDOHHXjLLli2Dl5cXE+CSGTFiBJ4+fQonJyfFjxq1GjVqFMzMzDBz5ky2KQDOnj2L33//XZWnAabk5cuXsLOz42D0Jz5+/Ii2bdvyvZNM+vTpUb16ddlhGBU+PyI+O8qmTJmCjh07cvIvGfbxRWPHjsXly5fRsWNH9meTYT9fxHEDEdtZUUhICObOncsFfsmwnRVxzkfEMhFxDkwZy0XEb2QRv5FFrCci1hNlXK8jYpmI2KaIWCYitrPKWC4ilomIY27KOL+hj+8eEfttytjOiriGScTxWRHriYjvHmVsZ0UHDx5EYGAgatasKTsUo8F6oozfPiLOrYu4BkNfWpgrZfL1VzB48GDMnTsX3t7eyJQpk+xwjAKTJZXVrVsXYWFh33Wj8bVcuHABx44dw59//glLS0thhxN/f39JkcmTkJCAwMBAHD58GGXKlBHKxMXFRVJkcvXq1Quenp6wt7dH6dKlhXJR80BBWuiIfG382BMxAU7EgUZlHJTWV6JECbx79052GEalVatWOH78OIoWLSo7FKPCDXRE3GhJxOdHxGdHGSf/ROzjizjxp4z9fBHHDURsZ0Vc4CdiOyvinI+IZSLiHJgylouI38gifiOLWE9ErCfKuF5HxDIRsU0RsUxEbGeVsVxELBMRx9yUcX5DH989IvbblLGdFXENk4jjsyLWExHfPcrYzory58+PrFmzyg7DqLCeKOO3j4hz6yKuwdCXFuZKmXz9FaxYsQL37t1D/fr1UbhwYSExMCQkRFJk8jBZUlnTpk3h7e2N69evK5ZL8+bNJUVmeNmzZ0erVq1kh2FUrl27hnLlygEArl+/rndPzTvAODk5AUg8rSmJRqOBVquFRqPB1atXZYUmXVroiHxt/NgTMQFOxIFGZRyU1jdy5Ej4+PjAyckJpUuXhpmZmd59NQ62WVhYYObMmTh9+rRiX9bGxkZSZHJxAx0RN1oS8fkR8dlRxsk/Efv4Ik78KWM/X8RxAxHbWREX+InYzoo45yNimYg4B6aM5SLiN7KI38gi1hMR64kyrtcRsUxEbFNELBMR21llLBcRy0TEMTdlnN/Qx3ePiP02ZWxnRVzDJOL4rIj1RMR3jzK2syJnZ2dMnz4dEydOROHChWWHYxRYT5Tx20fEuXUR12DoSwtzpRqtVquVHcT37ksLxwcPHmygSIyH0kcLkyU//zGn5nIh+pyIiIjP3i9UqJCBIjE+v//+OxYsWICuXbt+tx2Rr23KlCnYvHkzypYty4+9/zdo0CAcO3YM5ubmTID7f4cPH4a/vz8HGj+xY8cO+Pv7c1D6/yX99366AYqa+7PNmjVL8Z5Go8G+ffsMGI3xsLa2TvGeRqNBcHCwAaMxDl9633p7exsoEuPB50fEZ0fZggULsHz5cjRp0oSTf/+PfXzRgQMHsGLFCk78fYL9fBHHDURsZ0WdO3fGvXv3oNVqucDv/7GdFXHOR8QyEXEOTBnLRcRvZBG/kUWsJyLWE2VcryNimYjYpohYJiK2s8pYLiKWiYhjbso4v6GP7x4R+23K2M6KuIZJxPFZEeuJiO8eZWxnRbVq1cLbt28RHx+PjBkzCmsNTpw4ISkyeVhPlPHbR8S5dRHXYOhLC3OlTL6mb4LJkvQl9+/fR3x8PCwsLPSuh4eHw9TUVJUv3jdv3iA+Ph7m5uZ611+9egVTU1NVLhKmz0sLHZGvjR97IibAiTjQqIyD0vq+NGBWu3ZtA0VCRERqwsk/Efv4Ik78KWM/X8RxAxHbWREX+InYzoo45yNimRAREREREREl4pibMs5vENHXwjVMIo7PilhPiP67LyVCWllZGSgSMnb89hFxbl3ENRhpD5Ovv4ILFy5Aq9WiSpUqetfPnz+PdOnSoVKlSpIiIzJevXr1QteuXYXO6JYtW7BhwwasWLFCUmTyODg4oGnTpujZs6fe9TVr1mD//v1YvHixpMjkWrhwIXLnzo1u3brpXd+wYQMiIyPh6OgoKTIi+l5xoFEZB6WJ/htuoCPiRkuUGnx2iP47TvwpYz+fiL4WtrNERGRo/Eam1GA9Ucb1OiKWCdF/w3ZWGctFxDIhoq+F/TZlbGeJiL4ttrOUGqwnlFqcWyc1SCc7gLRg0qRJePTokXD9yZMnmDRpkoSI5Fu4cCE2bNggXN+wYQMWLVokISLjMGXKFMUdC1euXAlPT08JEclz5coVVK9eXbhetWpVVZ66AyQOptWtW1e4Xrt2bVy4cEFCRMbh999/R4kSJYTrlpaWWLt2rYSIyJi9efMGr169Eq6/evUK0dHRhg/ICNy/fx/h4eHC9fDwcDx48MDwARmB2rVrf/Z/alWoUKHP/k9tNm7ciB07dgjXd+zY8cXBgrRqyJAhin35xYsXY+jQoRIiMg5OTk74448/hOs7duyAk5OThIjkc3FxwdmzZ4Xr58+fh4uLi4SI5OPzI+KzQ6nFPr7Iysrqs/9TK/bzif6bCxcu4Pz588L18+fP4+LFixIiko/trIhzPiKWiYhzYMpYLiJ+I4v4jSxiPRGxnijjeh0Ry0TENkXEMhGxnVXGchGxTCi1OL+hj+8eEfttytjOiriGScTxWRHriYjvHmVsZ0UHDx7EoUOHhOuHDx/GwYMHJUQkH+sJpRbn1kVcg6EvLcyVMvn6K7h16xYqVKggXC9Xrhxu3rwpISL5mCypbNeuXYoJx9WqVcOuXbskRCSPRqNBTEyMcD1plxw1+vDhA+Li4oTrcXFxePfunYSIjMOzZ8+QN29e4XquXLnw7NkzCREZj7TQEfna+LEnYgKciAONyjgorW/RokXImTOncD137twICAiQEJF8J0+eROPGjYXrP/74I06dOiUhIuPADXRE3GhJxOdHxGdHGSf/ROzjizjxp4z9fBHHDURsZ0Vc4CdiOyvinI+IZSLiHJgylouI38gifiOLWE9ErCfKuF5HxDIRsU0RsUxEbGeVsVxELBMRx9yUcX5DH989IvbblLGdFXENk4jjsyLWExHfPcrYzopmzJiBhIQE4XpCQgJmzpwpISL5WE+U8dtHxLl1Eddg6EsLc6VMvv4K0qdPj+fPnwvXnz17BlNTUwkRycdkSWWvXr1CtmzZhOtZs2bFy5cvJUQkT61atbBw4UK9ROv4+HgsWrQINWrUkBiZPJUqVcK6deuE62vXrlUcZFOLAgUK4MyZM8L106dP44cffpAQkfFICx2Rr40feyImwIk40KiMg9L6Hj58iMKFCwvXCxYsqPhRrAaxsbEwMzMTrpuamqpyZ+4k3EBHxI2WRHx+RHx2lHHyT8Q+vogTf8rYzxdx3EDEdlbEBX4itrMizvmIWCYizoEpY7mI+I0s4jeyiPVExHqijOt1RCwTEdsUEctExHZWGctFxDIRccxNGec39PHdI2K/TRnbWRHXMIk4PitiPRHx3aOM7azo7t27KFmypHC9RIkSuHfvnoSI5GM9UcZvHxHn1kVcg6EvLcyVMvn6K2jQoAFmzZqFN2/e6K5FRUVh9uzZqF+/vsTI5GGypLJixYop7urx119/oUiRIhIikmfUqFE4duwYWrduDRcXF7i4uKB169Y4efIkxowZIzs8KYYPH47169ejZ8+e8Pf3h7+/P3r27ImNGzdixIgRssOTpnv37vDy8sLGjRsRERGBiIgIbNiwAd7e3vj5559lhydVWuiIfG382BMxAU7EgUZlHJTWlzt3bly7dk24HhYWBnNzc8MHZARKly6N0NBQ4XpoaChKlSolISLjwA10RNxoScTnR8RnRxkn/0Ts44s48aeM/XwRxw1EbGdFXOAnYjsr4pyPiGUi4hyYMpaLiN/IIn4ji1hPRKwnyrheR8QyEbFNEbFMRGxnlbFcRCwTEcfclHF+Qx/fPSL225SxnRVxDZOI47Mi1hMR3z3K2M6KsmXLhvv37wvX7927h0yZMkmISD7WE2X89hFxbl3ENRj60sJcqfr+v/YNjB07Fj179kTTpk1Rrlw5AIkd1dy5c2PatGmSo5MjKVkyLi5Ot3vf0aNHMX36dPTp00dydPLY2dlh8uTJiIyM1CuXZcuWwdXVVXJ0hlWqVCls3boVq1atQlhYGDJmzIhOnTqhV69eqv3Iq1GjBn7//XcEBgZix44dyJAhA8qUKQNPT09YWFjIDk8aBwcHvHr1ChMnTsTHjx8BABkyZICDgwP69esnOTq5kjoixYoV07v+PXVEvrakj73x48frXVfzx15SAtysWbNgYmICgAlwSQONnyZmqHmgEfhnUPrT9kOtg9Lt2rWDp6cnsmTJglq1agEATpw4AS8vL7Rr105ydHIMHDgQQ4YMwf379/X6sn/88Qd8fX0lRyfP8OHD0bt3b4SFhaFevXoAEsvl4sWLWLp0qeTo5Bg1ahR69uyJ1q1bo2bNmgCAU6dOITo6GsuXL5ccnRx8fkR8dpQlTf4NHjxY77qaJ//YxxclTfx92p9V88QfwH6+Eo4biNjOipIW+M2fP1+XrK/2BX5sZ0Wc8xGxTEScA1PGchHxG1nEb2QR64mI9UQZ1+uIWCYitikilomI7awylouIZSLimJsyzm/o47tHxH6bMrazIq5hEnF8VsR6IuK7RxnbWVHz5s3h5eWFefPmoWjRogASE0p9fHzQrFkzydHJwXqijN8+Is6ti7gGQ19amCvVaLVarewg0oLY2Fhs27ZNl0RapkwZtGvXTnFXCzXQarWYMWMGVqxYISRLfvqiUZvVq1cjICAAT58+BQAUKlQIQ4YMQefOneUGRmTkYmJicOvWLWTMmBEWFhZInz697JCk27BhAyZPngx7e3vFjogaTwY/ffo0evfujUqVKil+7CUlgKnJzZs30bNnT2TPnl0xAa506dKSIzS86dOnY8eOHfDy8tIbaHRzc8NPP/2EsWPHSo5QjsWLFyMwMBBjxoxRHJRW24YXHz58wJgxY7Bz507dTmMJCQno1KkTJk6cqNr30IEDBxAQEICwsDDdRjGDBw9G7dq1ZYcm1dWrVxEYGKhXLv369VP1BjpPnjzR22ipdOnSqt5oCeDzo4TPjmj//v0YMmQI2rdvrzj516JFC8kRGh77+CJ3d3ecPXtWmPgbMmQIKlWqBE9PT8kRysF+vojjBiK2s6InT56gZ8+eePXqlbDAb9myZShQoIDkCA2P7ayIcz4ilokyzoEpY7mI+I0s4jeyiPVExHqijOt1RCwTEdsUEctExHZWGctFxDLRxzE3ZZzfEPHdI2K/TRnbWX1cwyTi+KyI9UQZ3z3K2M7qe/PmDRwcHHDp0iXky5cPQOIcao0aNeDv74/s2bNLjlAO1hMRv31EnFsXcQ2G6HufK2XyNX1TTJZMWWRkJDJkyIAsWbLIDsVgwsLCUv3bsmXLfsNIjEd0dHSqf5s1a9ZvGAl9r773jsi3wI89ERPg9HGgURkHpZXduXNH79kpVKiQ7JCIiCiN4+SfiH18fZz4U8Z+vjKOG4jYzoq4wE8f29mUcc5HxDJRpsY5sNRguRARERERUVrFMTdlnN8goq+Ja5hEHJ8VsZ4Q/TdarRZHjhzRmy9N2vSdKDl+++jj3LoyrsFQ9r3OlTL5+j/at29fqn/bvHnzbxgJ0fejbNmy0Gg00Gq10Gg0uutJzVDya1evXjV4fDIklUlqqKVMAPyrJD9/f/9vGMn343vtiBDJxIFGZRyUJvoybqAj4kZLlBp8doi+Hk78pYz9fGUcNyD6d9jOEhHRt8ZvZEoN1hNlXK8jYpkQ/TdsZ5WxXEQsEyL6WthvU8Z2lojo22I7S6nBekL/FefWKa1j8vV/9Oli8aSE0uR/T6KWhEkmSyrr3LlzqpNrQ0JCvnE0ckVEROj+fPXqVUydOhX29vaoWrUqAODcuXNYtmwZRo8ejRYtWkiK0rBOnDih+3NERARmzpwJKysrvTIJCQnByJEjYWVlJSlKw3NxcdH9WavVYs+ePciWLRsqVqwIALh8+TKioqLQqlUreHt7ywqTjAQ/9kRMgCP6b/7NOyX5uyotq1WrVqr7ssn7NWkdN9ARcaMlEZ8fEZ8dSi328YmIvi0u8KPU4JyPiGUi4hyYMpaLiN/IIn4ji1hPRKwnyrheR8QyEbFNEbFMRGxnlbFcRCwTSi3Ob+jju0fEfpsytrMirmEScXxWxHoi4rtHGdtZUXBwcKp/a2Nj8w0jMR6sJ0T/Hddg6Etrc6WmsgP4XiVPavr7778xY8YMODk5oVq1agCAs2fPYs6cORgxYoSsEA0uW7Zsuj9/KVlSTZInEb9//x6rV69GqVKldMm158+fx40bN/Dbb79JitBwkp80NGzYMIwbNw6NGzfWXStbtiwKFCgAX19f1SRf165dW/dnW1tbODs7o3379rprzZs3R+nSpbFu3TpVJV8nHxCYPn062rRpg4kTJ8LExAQAEB8fj4kTJ6rytKa01hH5GmrWrMmPvU8k1RMmwP2DA43KOCit78qVK8Lf4+PjUbx4cQBAeHg40qVLhwoVKsgITwpXV1fdn1+9eoUFCxagYcOGehvFHD58GAMHDpQUoRzJB1+/tIGOWiQfPPrSRktqwedHxGdHGSf/ROzjizjxp4z9fBHHDURsZ0WDBg3S+zsX+LGdVcI5HxHLRMQ5MGUsFxG/kUX8RhaxnohYT5RxvY6IZSJimyJimYjYzipjuYhYJiKOuSnj/IY+vntE7LcpYzsr4homEcdnRawnIr57lLGdFQUFBen9/eXLl3j79i2yZ88OAIiKikKmTJmQK1cu1cwNsp4o47ePiHPrIq7B0JfW5kp58vVX0L59e3h4eKBmzZp610+dOoXx48djx44dkiKTZ/r06Xj9+nWKyZJjx46VHKEcbm5uyJs3L4YPH6533c/PD48ePVLVCb6VK1dGSEgISpYsqXf91q1bsLKywoULFyRFJk+VKlWwZcsWWFhY6F2/c+cOOnfujPPnz8sJTLK6deti9erVKFGihN7127dv49dff8Xx48clRSZH8uTHL3VE1PJxwxPkRREREbo/fykBTi2bXVhbW+v9/XMDjf/mo/B7lzwB5UuD0mrqpwDAsmXLcPz4cUydOhU5cuQAALx+/RouLi6oWbMm+vTpIzlCwxsyZAjq1KmDXr166V1fuXIl/v77b8yfP19SZHLZ2tqie/fuehvoAMC2bduwbt06rFixQlJk8nTr1g1DhgzR22gJAA4ePAhfX19s2rRJUmTy8PkR8dn5R/Lkxy9N/tnZ2ckJ0sDYxxc1a9ZM7++fm/j7N7upfu/Yzxdx3EDEdvbzvrTAr0GDBpIjNAy2s5/HOR8Ry0TEOTBlLBcRv5FF/EYWsZ6IWE+Ucb2OiGUiYpsiYpmI2M4qY7mIWCaJOOamjPMbKeO7R8R+mzK2syKuYRJxfFbEeiLiu0cZ21nRtm3bsHr1anh6euryFW7fvo3x48fjl19+QceOHSVHaHisJ//gt4+Ic+ufxzUY+tLEXKmW/meVKlXSXrt2Tbh+9epVbaVKlSREJF+dOnW0t27dEq7funVLW7t2bQkRGYfq1atr79y5I1y/c+eOtnr16oYPSKLOnTtrR48erX3//r3u2vv377WjR4/Wdu7cWWJk8rRq1Uo7depU4frUqVO1rVq1khCRcahZs6Z2z549wvU9e/Zoa9asKSEi4+Hq6qqdPXu2cN3X11fr7Oxs+ICMgI2NjXbbtm3C9a1bt2p79eolISL5unbtqj1w4IBw/cCBA1orKysJEcm3dOlSbb9+/bSvXr3SXXv16pV2wIAB2iVLlkiMTK5p06Zp3dzctHFxcbprcXFx2vHjx2t9fHwkRiZHw4YNtdevXxeuX7t2TdugQQMJEclXtWpVbXh4uHA9PDxcW7VqVQkRGYfKlSsr9vFv376trVy5suEDMgKVKlXS3rx5U7h+8+ZN1X4j8/kR8dlRNnjwYO2KFSuE6ytWrNAOGDBAQkTysY8v2rp1q7ZHjx56Y2+3bt3S/vbbb9otW7ZIjEwu9vNFHDcQsZ0VtWvXTnvy5Enh+smTJ7WtW7eWEJF8bGdFnPMRsUxEnANTxnIR8RtZxG9kEeuJiPVEGdfriFgmIrYpIpaJiO2sMpaLiGUi4pibMs5v6OO7R8R+mzK2syKuYRJxfFbEeiLiu0cZ21lR8+bNtZcvXxauX7x4Udu0aVMJEcnHeqKM3z4izq2LuAZDX1qYK00nO/k7LahUqRJ8fHzw/Plz3bXnz59j+vTpqFy5ssTI5ImPj8ft27eF67dv30ZCQoKEiIxDxowZcebMGeH6mTNnkCFDBgkRyTNx4kQcPnwYjRs3hp2dHezs7NC4cWMcPnwYEydOlB2eFK6urli5ciU6dOgANzc3uLm5oUOHDli5ciVcXV1lhydNly5d4ObmhmXLluHUqVM4deoUli5dinHjxqFLly6yw5Nq586d6Ny5s3C9Y8eO2L17t+EDMgLnzp3TndibXMWKFXHhwgUJEcl3/fp1FC5cWLheuHBh3Lx5U0JE8i1duhQjR47U7fAIADly5MDw4cOxdOlSiZHJtXHjRvTp00e3GygAmJiYwM7OTpWn1EZHRyMyMlK4HhkZiZiYGAkRyWdubq64C92+fftgbm5u+ICMRP78+bFu3Trh+vr165E/f34JEclXsmRJLFy4EB8+fNBd+/DhAxYuXIiSJUtKjEwePj8iPjvKDh8+jEaNGgnXGzVqhKNHj0qISD728UW+vr4YP368bsdlAChRogRcXFwwZ84ceYFJxn6+iOMGIrazonv37ul2oE4ua9asiIiIkBCRfGxnRZzzEbFMRJwDU8ZyEfEbWcRvZBHriYj1RBnX64hYJiK2KSKWiYjtrDKWi4hlIuKYmzLOb+jju0fEfpsytrMirmEScXxWxHoi4rtHGdtZ0bNnzxAXFydcT0hIwIsXLyREJB/riTJ++4g4ty7iGgx9aWGu1FR2AGmBl5cXBg8ejCZNmqBAgQIAgEePHsHCwgLz5s2THJ0cScmS9+/fR6VKlQAAFy5cwKJFi1SdLGlrawsPDw9cuXJFr1w2btyIgQMHSo7OsCpXroy9e/di27Ztug/gtm3bon379sicObPk6ORo3Lgxdu/ejTVr1uDWrVsAgGbNmqFHjx66tkWNxo4dizx58mDp0qV49uwZACBv3rywt7dHnz59JEcnV1JHxMLCQu/699QR+dqSPvbGjBmjd13NH3tJCXBTpkxB+vTpATABjgONypIGpZN/AAPqHZRu2bIlXFxc4OzsrJvUOn/+PKZNm4ZWrVpJjk6OIUOGYNy4cThx4oSuTC5cuIBDhw5h8uTJkqOTx9XVFUOGDMGhQ4f0yuXu3buYO3eu5OjkmDhxIvr374/GjRujTJkyAIBr165Bo9EgICBAcnRy8PkR8dlRljT59+m3jpon/9jHF3HiTxn7+SKOG4jYzoqSFvhNmzYNefLkAcAFfmxnRZzzEbFMRJwDU8ZyEfEbWcRvZBHriYj1RBnX64hYJiK2KSKWiYjtrDKWi4hlIuKYmzLOb+jju0fEfpsytrMirmEScXxWxHoi4rtHGdtZUb169TBhwgRMmTIFFSpUAABcunQJHh4eqFevnuTo5GA9UcZvHxHn1kVcg6EvLcyVarRarVZ2EGmBVqvFkSNHdEmkJUuWRP369aHRaCRHJkdCQgKWLFmC4OBgvWRJGxsb4URFtQkNDUVwcLCurpQoUQI2NjZo27at5MiIjF90dDSAxF1fCFi0aBH8/f3x888/K3ZEHB0dJUdoeAcPHsSQIUNQrFgxxY+9xo0bS47Q8C5cuID+/ftDq9UqJsCpsRM/ZswYnDp1SnGgsWbNmpg6darkCOXw9vbG5s2b0b9/f2FQulOnTnBxcZEcoWG9ffsWU6dOxcaNG3UDAyYmJujWrRvGjBmj2s1izp8/r9iXrVKliuTI5Hr8+LHeBjolS5ZU/QY6sbGxehstlSxZUtUbLQF8fpTw2RFt2rQJ48aNw48//qg4+afGiWL28UX9+/fHkydPhIk/d3d3/PDDD6rd6IL9fBHHDURsZ0V3797F4MGDcefOHcUFfsWKFZMcoeGxnRVxzkfEMlHGOTBlLBcRv5FF/EYWsZ6IWE+Ucb2OiGUiYpsiYpmI2M4qY7mIWCb6OOamjPMbIr57ROy3KWM7q49rmEQcnxWxnijju0cZ21l9kZGRGDt2LA4dOgRT08TzTePj49GwYUP4+Pggd+7ckiOUg/VExG8fEefWRVyDIfre50qZfE3fHJMl6d94+vQp4uLiULBgQdmhEH0XvveOyLfAjz0RE+D0caBRGQellcXGxuLevXsAgKJFi6q2fhARkeFw8k/EPr4+TvwpYz9fGccNRGxnRVzgp4/t7OdxzkfEMiEiIiIiIiK145ibMs5vENHXxDVMyjg+q4/1hOi/Cw8P1/XbSpQogeLFi0uOiIwRv330cW5dGddgpC1Mvv6GLl68iHfv3qFWrVqyQyH6brRp0wbh4eG4evWq7FCMBstE2axZs/Ds2TN4e3vLDoWIvlMcaEwZB6WJ6FvgRktERF8XJ/6UsZ9PRF8L21kiIiKi7xfX64hYJkRERETfB/bbiIiIiOh7w7l1SsuYfP0NMWFSxGRJZWPHjsWjR48QHBwsOxTpLly4gHfv3qF27dqyQzEae/bsQXR0NKysrGSHYlT43BD9b5gAR/TfrFq1Ci9fvsTgwYNlh2I07OzscP/+fezbt092KEaF34MilomIz4+I9YSIiMg4cIEfpQbnfEQsExHH8pWxXET8RhbxG1nEeiJiPVHGchGxTERsU0QsExGfHWUsFxHLhOi/4btHxPZEGctFxDVMIo7PilhPRHz3KGM7K9q7dy+io6PRuXNn2aEYDdYTov+OazD0fU9zpaayA0jLgoKCEBcXJzsMo/LkyRM8evRIdhhG54cffkC6dOlkh2EUKlSogOfPn8sOw6i0bNlSdghGaerUqbJDMFrfU0fEUPixJ7K1tWWZfIIDjco4KK1v9+7dePDgAetJMi1btsTLly9lh2F0Ro4ciTdv3sgOw6hMnToV7969kx2GUeHzI+Kzo4yTfyL28UWc+FPGfr6I4wYitrOiMWPGsJ39BNtZEed8RI8fP2aZfCJfvnycA1PAchHxG1nEb2QR64mI9UQZ1+uIWCYitikilomI7awylouIZSLimJsyzm/o47tHxH6bMrazIq5hEnHMWsR6ImrRogVevXolOwyjM2LECERHR8sOw6jMmDEDd+/e5dxgMnwfK+O3j4hz6yKuwdD3Pc2V8uTrb+zixYuoVKmS7DCIvhthYWGwsrJS1Qvl3bt3OHLkCOrUqYOsWbPq3YuOjsbx48fRqFEjpE+fXlKE9L1hoqRo7969ePPmDU+QT+bChQt49+4dateuLTsUo2Fra4sHDx7w4/cTY8aMwaNHj7BixQrZoRAREakWk0dFe/bsQXR0NPv4ybRu3Rp3795V1ZhKarCfL+K4gWjlypV49eoV29lknjx5gri4OBQqVEh2KEaD7SwRERERERERUepxbkMZ5zeIiIiIiL4/8fHxOHPmDMqUKYPs2bPr3eO3j4hz6yKuwfh+Mfn6K4iJiYGJiQkyZsyou3b16lX4+vri4MGDbCzoiy5fvgw/Pz8sXLhQdijSqTH5evny5di/fz+WL1+ueN/Ozg4tWrRAr169DByZ8Th69CiCgoJw69YtAEDJkiVha2uL+vXrS46M6Pv25MkT5MuXT3YYRN+VW7duYcOGDRg7dqzsUKS5e/cu7t27h1q1aiFjxozQarXQaDSyw5LuxYsXuHPnDgCgePHiyJ07t+SI5IqKisKuXbtw79492Nvbw9zcHJcvX0aePHlU/e7h86MvLi4OJ06cwL1799C+fXtkzZoVT548QdasWZElSxbZ4dF34N27d3rjcURERESGsnnzZrRt21bYNPXDhw8IDQ1V9S7uHz58wIMHD1C0aFGYmprKDsdosFyIiL6ef3MK06ebn6dVLJPUSzoFr0CBApIjkcvFxQVubm5CfYiNjcXkyZNVu2Ebx6yVsVyIvj7ObxAAbNq0CV26dBGux8XFwdfXFyNHjpQQFRFR2hUdHY1jx46hePHiKFmypOxwpHn37h20Wi0yZcoEAIiIiMCePXtQqlQpNGzYUHJ0RMatUqVKCA0NRZEiRWSHQvTdun//PgoUKPBdzZd+P5EaoUePHmH48OG4cOECTExM0LNnTwwfPhwTJkxAaGgoWrZsibVr18oO06CCg4NT9TsbG5tvHInxOXToEP7++2+YmZmhe/fuKFKkCG7duoWZM2fizz//ZGdVxbZt24aBAwemeN/W1hbz5s1TbfL1qlWr4OXlhZ9++knXdpw/fx6Ojo5wcXFBz549JUdoPOLj43H9+nUULFgQOXLkkB0OGbFnz54hICAAGzZswPnz52WHQ0bu6dOnCAgIgLu7u+xQpImNjcUff/yBjRs34ty5cyhVqpQqk69fvnwJJycnHDt2DBqNBrt370aRIkXg6uqKHDlywNnZWXaIUkRHR2PixIkIDQ1FfHw8AMDExARt2rTBhAkTkC1bNskRGl5YWBh69+6NbNmyISIiAj///DPMzc2xe/duPHr0CNOmTZMdosHx+RFFRETAwcEBjx49wocPH9CgQQNkzZoVixcvxocPHzBp0iTZIZIR+/DhA1atWoXAwEAcOXJEdjhk5N6/f4+VK1fC3t5edihkxHbv3o25c+di27ZtskMxmNQmZ6g9MeNTO3fuROvWrWWHIQU3yNTn4uKCRo0aCRtvxcTEwMXFRZXJ12/fvsXkyZOxefNmAMCuXbtQpEgRTJ48Gfny5YOjo6PcACVhuST6N6c9+Pv7f8NIjEfnzp1TvSFbSEjIN47GOLCeiFhPlNWsWTPV5aKWTd9ZJp8XFxcHf39/rFixArGxsQCAzJkzo1evXhg8eDDMzMwkR2h4mzdvxqhRo4Rvvnfv3mHLli2qTL7mmLUylksivpPpa1Hb/Ab7+J83ZcoUHDhwAJMnT9at9bt9+zZGjRqFV69eqSr5mu2saN++fan+bfPmzb9hJMalb9++mDVrlm4tzqJFi9CjRw/dCaQvX75Ez549ERoaKjNMacLDw3H8+HG8ePECCQkJevfUeBrrsGHDUKtWLfTq1Qvv3r1D165dERERAa1Wi1mzZuGnn36SHaIUAwcORMuWLfHrr78iKioKP//8M0xNTfHy5Us4Ozvjt99+kx2iNFFRUdi5cycePnyIQoUKoXXr1qpc+wek/G7WaDRInz49ihUrBisrK9StW1dCdPJYWlriwYMHTL6mFMXHx+vakHTp0uHDhw/Yu3cvtFot6tSpgzx58sgOUbo2bdpgy5Yt39VGKEy+/h9MmzYN79+/h5ubG3bv3o3g4GCcOnUKVapUwd69e5E/f37ZIRpcUFDQF3+j0WhUl3y9fv16jB8/Hjly5EBUVBTWr18PZ2dnTJkyBW3atMH27du/q4aDvq67d++ibNmyKd4vU6YM7t69a8CIjMvChQvh4uIiJJ9Xr14dAQEBqk6+9vT0ROnSpdG9e3fEx8ejV69eOHv2LDJlyoSAgADUqVNHdogGk9oBWLUMvgLA69evMXHiRBw5cgRmZmZwdHREr169MHfuXCxduhRlypRR3aR5agel1TQgneTGjRs4fvw4zMzM0KZNG2TPnh2RkZEICAjA2rVrVTtQcPr0aWzYsAE7d+7Eu3fvYGdnB09PT9X227y9vWFiYoIDBw6gTZs2uutt27aFj4+PKpNHAWDcuHG4evUqAgICUK1aNQDA2bNn4enpCXd3d8yePVtyhIbn4+MDKysrjBkzRlcmANC4cWOMGjVKYmTy8PkReXp6omLFitiyZYtev7Vly5YYP368xMjkSO1Ep5oWnnz48AFz587FkSNHkD59ejg4OKBFixbYuHEjZs+eDRMTE9ja2soO06DCwsJS9bvPjTGkVZGRkTh//jzMzMxQr149mJiY4OPHj1i9ejUWLVqEuLg4VSVfp/Zbz8XF5RtHYlzWrl2r2xzTxsYGVapUwdGjRzF16lSEh4ejU6dOskM0qC8lZ2i1Wmg0GtUlZsTFxeH27dswMzND8eLFddf37t0LPz8/3L59W5XJ19wgU5T0jHzqyZMnql2IM3PmTISFhSE4OBh9+/bVXa9Xrx78/f1Vk2T8KZZLouTPhVarxZ49e5AtWzZUrFgRAHD58mVERUWhVatWskI0uBYtWuj+/P79e6xevRqlSpVC1apVASS2szdu3FDVYkfWExHribLkhwJERERg5syZsLKy0pXLuXPnEBISoqpkFZbJ502ePBl79uzB6NGj9crE398fr169wsSJE+UGaEDR0dHQarXQarWIiYlBhgwZdPfi4+Px119/IVeuXBIjlIdj1spYLon4TlbGuQ1lnN/4h1rHSFJr8+bNGD16NDp06ABvb2+Eh4dj+vTpaN68OTw8PGSHZ1DJ21lKNGjQoFT9Tm3j+IcPH8aHDx90fw8ICNCtdQMS+7R37tyRFZ5U69atg4eHB3LmzIk8efLojV9rNBpVJl+fOnUKAwYMAADs2bMHWq0WJ0+eREhICBYsWKDa5OvLly/r5ol37dqF3LlzY/Pmzdi1axf8/PxU1acdPHgw2rdvj9atW+PGjRuwtraGRqNBkSJFEBERAV9fXyxfvlyV60UbNWqENWvWoHTp0qhcuTIA4OLFi7h27RqsrKxw69Yt9O7dG3PnzlXVe3z48OGYOnUqhg0bhgoVKiBz5sx699W6sfnr16+xYcMGvU28u3btCnNzc7mBGVhYWBgcHBzw4sULlCpVCosWLYKjoyMePHgAADAzM0NgYKDumUrrUup7xMfHY8qUKciSJQuA72PMgMnX/4OTJ0/C398fVatWRZs2bdCgQQN06NABdnZ2skOTZv/+/bJDMErBwcEYNWoUHBwcsGvXLgwbNgxr1qzBtm3bVJek/6WFwrdv3zZQJMYjLi4OkZGRKFiwoOL9yMhIxMXFGTgq4/HmzRs0atRIuN6gQQPMmDFDQkTGY9euXejYsSMA4M8//8SDBw+wY8cObNmyBbNnz8batWslR2g4zZs3T/Xul2oxc+ZMnD17Fl26dMHhw4fh7e2NQ4cOIV26dFi+fLluElBNUjMorbYBaSAxKX3YsGG6d01gYCAmT56M4cOHo0KFCvD398ePP/4oOUrDefHiBTZt2oSNGzciOjoa7dq1Q3BwMHr06IGuXbuqciAtyZEjR7BkyRKh/2phYYGHDx9Kikq+AwcOIDAwEDVr1tRda9SoEaZMmQIHBweJkclz8eJFxZMO8uXLh2fPnkmISD4+P6LTp09jzZo1SJ8+vd71QoUK4cmTJ5KikoeLT0S+vr74/fffUb9+fZw5cwbDhg1Dly5dcO7cObi4uKB169YwMTGRHaZBJW06pdVqhXtJ19XYnz116hT69++P6OhoaDQaVKxYEd7e3hg0aBBMTEwwePBgWFlZyQ7ToK5cuSI7BKOzaNEi+Pn5oXTp0rhz5w727duH/v37Y+XKlbCxscEvv/yiO1lELZInZ1Ci69evo3///nj06BEA6BY5Dh8+HDdu3ED37t2xaNEiyVHKwQ0y/5H0PtZoNLC1tYWp6T9TrfHx8Xjw4IHieLYa7Nu3D7NnzxbGHS0tLXHv3j05QRkBlkui5JvDTJ8+HW3atMHEiRN1ffr4+HhMnDhRt9BCDZIvOnFzc4O1tTWGDx+u9xs/Pz/de0kNWE9ErCfKateurfuzra0tnJ2d0b59e9215s2bo3Tp0li3bp1qvgdZJp+3fft2zJo1C40bN9ZdK1u2LAoUKIARI0aoKvk6aSMujUajmGig0WgwZMgQCZHJxzFrZSyXRHwnK+PchjLOb/xDbYdC/FtFixbFmjVr4OXlBQcHB5iYmMDHx0evH6cWakwK/ZLUbsqsNp/OkyrNm6rVggULMHz4cNVs9pgab9680c3/HTp0CK1atUKmTJnQpEkTTJ8+XXJ08rx79043vnb48GG0atUK6dKlQ9WqVVW3hunEiRNwcnICkHgwZ4MGDeDt7Y306dPj48eP8PDwgJeXF5YsWSI5UsN7+fIlevfuLay7nj9/Ph4+fIilS5fCz88P8+fPV1XydVIbO2DAAL28BbWu1wES8yoHDBiArFmz6jZSXblyJebPn4+AgADUqlVLcoSGM336dFSvXh2DBw/G+vXrYW9vD0tLS2zatAkajQYuLi6YPXs2li1bJjtUg9i7dy9q1aqFwoULC/cyZ878XY0pMPn6f/DixQtdJcidOzcyZcqkqsQUSr379+/rTsNo1aoVTE1NMXr0aNUlXgOpXyisJpaWlvj77791nY1PHTlyBJaWlgaOyng0a9YMe/bsEZKX9u3bhyZNmsgJyki8fPkSefPmBQAcPHgQrVu3RvHixdG1a1fVLaBNzQTw06dPDRCJ8fjrr7/g7e2NevXqoWfPnmjRogXKlSuHESNGyA5NGg5KK1uwYAF+++03DBs2DOvXr4ePjw88PT2xaNEi1eyulVzTpk3x008/wc3NDQ0aNEC6dOlkh2Q0YmNjkTFjRuH6q1evhAUXamJubq44CJA1a1bdzrpqkz59ekRHRwvXw8PDVXtiBp8fUUJCAhISEoTrjx8/VtUi6iSpWXwSExNjgEiMx86dOzF16lQ0b94c169fR8eOHREXF4etW7eqbtwgyb59+2SHYJR8fX3RuHFj9OvXDyEhIVi2bBkGDRoEJycnVZ5OCwArVqz44m8+fvxogEiMx8aNGzF58mRYWVnh1KlT6NWrF86ePYvdu3cLu1GrRfLkDEo0Y8YMFC1aFOPHj8f27dvxxx9/4NatW+jWrRsCAwMV+3NqwQ0y/5G0gOTq1ato2LChXt/VzMwMhQoVUtWJrMlFRkYid+7cwvW3b9+qtv8GsFyUbNy4EatXr9ZLNjAxMYGdnR1+/fVXjB07VmJ0cuzcuRMbN24Urnfs2BFdu3ZVZcIC64mI9UTZuXPnFBNnK1asiHHjxkmISD6WiSh9+vSKi/wKFy4MMzMzCRHJExwcDK1WC1tbW8ydO1dvIzIzMzMULFgQ+fLlkxihPByzVsZyEfGd/A81/bf+G5zf+LwXL17oTqUtXry44jezmhw4cAB//PEHqlativDwcGzYsAG1atVS7fuYiP67169fo02bNrLDMCoFChTA2bNnkSNHDhw6dAizZs0CAERFRal2rQ6QuPnH3r170bJlSxw+fFh38OSLFy9Ud2rv+/fvdeMCV69exaJFi3R1w8zMDA4ODujevbvMEKXZsWMHNm3aJFxv164dunTpgilTpqBdu3aqSSJNorb8jNSYNGkS2rRpAw8PD2Ej1UmTJmHbtm2SIzScixcvYs2aNShZsiRGjhyJVatWwcfHR9fOODo6Cpudp2UzZ87EtGnT0LlzZ3Tt2lV3fevWrXByckKpUqUkRvfvMPn6f5Q8GUOj0ahuUP5TR48exeTJk7Fu3Tqh8/XmzRv06NEDHh4eqtq9AkjcIShTpkwA/qknP/zwg+So5OBCYVHXrl3h4+MDS0tLNG3aVO/e/v37ERAQAGdnZ0nRyZG8Y1qyZEkEBATgxIkTupMhzp8/jzNnzqB3796SIjQOefLkwc2bN5E3b14cOnQIHh4eABLbHLXskJrE29sbLi4uKd5/+vQprK2tsWvXLgNGJdfTp091J/QWLlwYGTJk0J2UTpTcnTt3MHPmTGTJkgXW1taYNm0aXFxcVJl4DQAFCxbE6dOnUbBgQRQsWFDVJ11/qmbNmti8ebPeLu4JCQkIDAxEnTp15AUm2YABA+Dj44Np06bpNkV59uwZpk+fjoEDB0qOTo5mzZph3rx5mDNnju7aw4cPMWPGDNUmIfD5ETVo0ADLly/H5MmTdddiYmIwd+5cvRNo1CIoKEg3oaUkOjoaDg4OWLt2reGCkuzJkye6TcpKly6N9OnTw87OTtULkwoVKiQ7BKN0/fp1TJgwAaVKlcKwYcMQFBSE0aNHq2p35U+Fhoaibdu2Kd6Pi4uDk5MT/P39DRiVXI8ePULdunUBJL6XTU1NMWTIENUmXgOJ7WxQUBAGDRqkOJY/f/582NvbI0+ePJIiNLyLFy9i6dKlKFeuHGrWrIk//vgD/fr1Q+fOnWWHJh03yPxH0ik8hQoVQtu2bZEhQwbJERmPihUr4sCBA7C2tta7vn79euHUZzVhuYji4+Nx+/ZtlChRQu/67du3FRN71CBjxow4c+YMLCws9K6fOXNGte0M64mI9URZ/vz5sW7dOowZM0bv+vr161W5GT7AMlHSs2dPzJ8/X3d6FQB8+PABCxYsUNWCR+Cfjbj27duHggULqnqs7VMcs1bGchHxnfyP+Ph43LhxAxYWFsKmdW/fvsXdu3dRunRp1W14zvkNZdHR0Zg4cSJCQ0MRHx8PIHGDpTZt2mDChAnf1alnX4u7uztCQkLg5OSE3r174/nz53B1dUXHjh0xYcKEz47zp2Xx8fEICgrCjh078OjRI2Ez2RMnTkiKzLD+TXKXjY3NN4zEuGg0GtW3pylp3bo1Dh8+jF9//VV2KEbDxsYGo0ePRubMmVGwYEHd+pyTJ0+idOnSkqOTZ9CgQRg1apTucKdq1aoBSDwsrly5cpKjM6wyZcrg2LFjKFq0KPLmzYuHDx+ifPnyuvsPHz5U7ebMGTJkwNmzZ1GsWDG962fPntV992i1WtV9A3GDc9Hdu3fh6+uruJHq5s2b5QUmgVar1ZXDp/8XSMw/VTrENK1q164dqlSpgtGjR+PAgQOYMmWK3kaQ3xMmX/8PtFotfvrpJ10nPjY2FlZWVsJgkVo+9ABg+fLl+PnnnxV3vcmWLRt++eUXBAUFqS75GkicyEpazBcfH49NmzYhZ86cer9RwwfwlxYKR0VF4eDBg6paUPzLL7/g5MmTGDBgAEqUKIHixYsDSFw8EB4ejjZt2uCXX36RHKVhBQUF6f09e/bsuHnzJm7evKm7li1bNmzcuFG1SU0A0KVLFwwfPhx58+aFRqNB/fr1ASQmp3+6GCWt27RpE8zNzTFgwADhXlLitdpO2tRqtTA1/aerly5dOtV95H7q0qVLmDp1KhYsWKC4sHzgwIFwc3ND2bJlJUUoR0xMjK48TExMkCFDBhQpUkRyVPLs3LkTp0+fxoYNG9CtWzcUL15ct3GB2gfvR48eDTs7O1y6dAkfP37E9OnTcfPmTbx+/Rpr1qyRHZ5Bde7cWa8+hIeHo2nTpihQoACAxOQeMzMzREZGokePHrLClMbZ2RlDhw5F/fr18f79e1hbW+P58+eoWrUqnJycZIcnBZ8fkbOzM+zt7dG2bVt8+PABo0aNQnh4OHLmzKnbbVhNZs2aBXNzc8XkrpiYGDg4OODVq1cGj0um+Ph4vU0OTUxMVJ0kCSS+b/z8/DBp0iTF/qyHhweGDx+uur7c69evdWNsGTNmRMaMGVU9WQ4AY8eORY4cOdCgQQPhXlxcHIYPH45z584ZPjCJPnz4oPdNbGZm9t1O6nwtQUFBiI6OTnEsPyYmBsuWLcPo0aMlRCfHy5cvdZumZsuWDZkyZVJtYiTADTK/xMrKSnYIRsfJyQl9+/bFzZs3ER8fj+DgYNy6dQtnz57FihUrZIcnDctF1KVLF7i5ueH+/fuoVKkSAODChQtYtGgRunTpIjk6OWxtbeHh4YErV67olYma58FYT0SsJ8pcXV0xZMgQHDp0SLep7IULF3D37l3MnTtXcnRysEwSJW2ak+Tvv//Gjz/+qJsHDAsLw8ePH1GvXj0Z4UkRFhamS4J88+YNrl27luJv1TZfCnDMOiUsFxHfyf/YsmULVq5cifXr1wv3zMzM4OrqCltbW3Tq1ElCdPJwfkPZuHHjcPXqVQQEBOiSvM6ePQtPT0+4u7tj9uzZkiM0vDNnzmD9+vW6927evHmxePFirFq1Cm5ubqpNvvb398f69evRp08fzJkzB/3790dERAT27t2LQYMGyQ7PYD5dQ5sSjUajirXnSbRaLZydnfU2VfLw8NAdkPbhwweZ4UlVrFgx+Pr64vz58yhdurTe2lFAHTkKn+rZsycqV66Mx48fo379+rocnyJFiugdnqA2rVu3Ro0aNfDs2TO9b7969eqpboPzgQMHYuzYsTA1NYW1tTW8vLzw8uVLlCxZEnfu3MHcuXNVe+hVr169MGHCBFy6dEn33XPx4kVs2LAB/fr1AwAcPnxYdQn7AHDq1CmsXbsWDx48gK+vL/Lly4fNmzejcOHCqFmzpuzwDK58+fIpbqSqtvGlChUqYPHixRg6dCjWr1+PwoULY+XKlfD29gYArFy5EpaWlpKjNKzChQtj1apV8Pf3R6dOnTB58uTvci2+RqumtPmvLCQkJFW/U9MCjKZNmyIwMDDFEwJv3boFe3t7HDhwwLCBSdasWbMv/kaj0fBUaCRO9lhZWeHq1auyQzG40NBQbN++HXfv3oVWq4WFhQXat2+v2kE0Sp2dO3fi8ePHaN26tW6n8pCQEGTLlk1VH8GnTp2Cg4MDxowZg99++013/dmzZ7C2tkaOHDmwdOlSZMmSRWKUhlW2bFlYWlrqBtGuXbuGEiVK6E3wAKnvz6QFI0eORIkSJVIciA8ICMDNmzcxY8YMA0cmV9myZeHj46PbRXjkyJFwdXVF7ty59X7XvHlzGeFJFRMTgz/++AObNm3CuXPnUKtWLXTo0AEtWrRQ3YYOSd68eYOVK1ciLCwMsbGxKF++PHr27KlLUFCLf3NK5KcLvNTk1KlTuHbtGmJjY1GhQgXdRjFqxedHFBcXhz/++EOvnnTo0EGVu8bu3LkTY8aMwezZs/XeubGxsbC3t0dkZCRWrFihqvpStmxZ/Pjjj7qJ8z///BN169bVTZwnUdPJvePHj0e2bNmEk6uSTJ8+XXdyhJqULVsWy5cv1yXS/vrrr5gzZw7y5csn/E4tli9fjjlz5iAoKAhVqlTRXU9ISMCwYcNw+vRpLF++XFWTOmXLlsXPP/+sa0NWrVqFjh07CqepuLi4yAhPivbt28PDwyPFCeAzZ85g/Pjx+OOPPwwcmTzlypXDrl27kCtXLmi1WjRu3BirV69G4cKF9X6nlLCeFqVmXgNQ19xG7dq1sXPnTuTKlQu1atX67MSwmjZmTu7evXtYtGiR3ndP3759UaZMGdmhScVy0ZeQkIAlS5YgODgYz549A5C4wNzGxgZ9+vTROwVATUJDQxEcHIzbt28DAEqUKAEbGxvVzhOynihjPVH2+PFjrF69WlcuJUuWRI8ePXSbZaoRy+Tffd8lLYBM68qWLYsjR44gd+7cKFu2LDQajeJpOxqNRpVrdgCOWaeE5SLiOznRb7/9hp49e6Jdu3aK90NDQ7Fq1SqsWrXKwJHJxfkNZVWrVkVgYKAwHpm05kttG4YCiUmiSfXkU0oJLGrRokULjBs3Dk2aNEG1atWwZcsWFC1aFMHBwTh//jxmzpwpO0SSKLX9fLX08ZP73Ji+msbxPyc+Ph7Xr19HwYIFVb9Jc3LR0dE4duwYihcvnmIOUFq2a9cueHl54enTp3rfyOnTp0ePHj0wduxY1Y5Fbt26FatWrcKdO3cAAMWLF0evXr3QoUMHAMC7d++g0WhUdTDYrl27MGbMGHTo0AFbtmxBaGgoihQpgpUrV+LgwYNYvHix7BANIiwsTPfn27dvY/r06ejVq5dufcr58+exatUqjBo1SlXfyRcuXEDfvn0RFRUFc3NzBAcHw83NDQ8fPoRGo0FUVBQCAgJUtRlkcqdOncLYsWPx8OFDbNu2DaVKlZIdUqox+fp/EBcXJ+wK9KmbN29+VxXif1WpUiVs374dxYoVU7x/9+5ddOjQARcuXDBwZPS9UHPyNdG/df/+fdWdaPY5Bw4cwJAhQ+Dj44N27drh2bNnsLGxQdasWbFs2TLVLIxNktpJGjUlBbZo0QL+/v4pJl1cu3YNAwcOVN1AY2qSUNS8yCLJrVu3sGHDBmzZsgWvX7/G5cuXZYdERERpzPr16+Hp6YmFCxeiTp06iI2NhYODA54/f44VK1YIiaRpnbOzc6p2ulTTxPlPP/2E6dOn606t+tSlS5cwcuRI7Nq1y8CRyfWlxcJarVaV/Vk/Pz+sWrVKt3NufHw8nJyccPLkSSxfvlx1p4NbW1un6ndqOoG0atWqCA0NRcGCBRXvP3z4EG3btlXVosek9iRJUvvx6d/V1p7QP0JCQtCuXTukT5/+ixsaqmljZqL/RXR0NAD1bGxB/w3rCRHR1xEREYGCBQtCo9EgIiLis78tVKiQgaIiou9ZvXr1dKd5Kbl//z66d++OY8eOGTgyuTi/oaxJkyZYuHChsBFZWFgYHB0d8ddff0mKTL4XL17oJTV9eliC2iQfu27YsCEWLlyIChUq4P79++jcuTNOnz4tO0Qi+k54enqidOnS6N69O+Lj49GrVy+cPXsWmTJlQkBAAOrUqSM7RCmGDRuGWrVqoVevXnj37h06deqEiIgIaLVazJo1Cz/99JPsEA0uPj4ely9fxoMHD5CQkIC8efOiQoUKHI8kQefOnWFnZ4fOnTujWrVq2Lp1K4oUKYIrV66gb9++OHLkiOwQDeJz63SSU+PcemxsLG7fvo3ixYsjS5YseP/+PbZu3Yr379+jfv36qt1gKUlMTAzu37+PEiVKpLgRlTH6fOYwfdaoUaMwZ86cFO/fvHkTtra2qmlAASBfvny4ceNGisnX165dQ968eQ0cFRF9r1auXIkLFy6gcePGaNeuHTZv3oxFixYhISEBrVq1wtChQ7+4CUZa1rJlS9SqVQvdunVD69atVbVzlJImTZrAy8sLLi4ueP/+PQIDA5E5c2YsXbpUlR/AqUmqfvr0qQEiMR5Pnjz57OnnmTNn1p2goSbJdyCjlJUsWRJjx47FyJEjsX//ftnhSPP+/Xtcu3YNL168QEJCgt49NZ6OntzFixdx69YtAECpUqVQsWJFyRHJdeHCBRw/fhyRkZFCXVHLiZL/pn1V02msyT158gSnT59WrCc2NjaSopKne/fuePXqFQYOHIj58+fDz88PT58+xcqVK1WXeA0APj4+X/xNTEyMASIxHo8ePfrsgpucOXPi8ePHBozIOKht86TUGjp0KF6/fo0+ffogODgYc+bMwYkTJxAUFKS6xGsgdUnVHz9+NEAkxiNDhgy6hfdKIiIiVDfWFBwcLDsEMnLJE6qZXJ2yFy9eKI4bqPW7JwnLRZkax+6/JCYmRliwpPZyUvt/vxLWE30ctxaxTJSpPbEpeUI1k6uVccxaGctFFBUVhV27duH+/fvo06cPzM3NcfnyZeTJk0dV4/lv377VbZSjJCYmBu/evTNgRMYhNfMbajRgwAD4+Phg2rRpujXEz549w/Tp0zFw4EDJ0ckRHR2NiRMnIjQ0FPHx8QAAExMTtGnTBhMmTEC2bNkkRyhHvnz58OzZMxQsWBBFihTBkSNHUKFCBVy8ePG7StD42h4/fox9+/bh0aNHwnyGWtZgpMatW7cwcOBA1W1WTcp27dqFjh07AgD+/PNPPHjwADt27MCWLVswe/ZsrF27VnKEcpw6dQoDBgwAAOzZswdarRYnT55ESEgIFixYoMrkaxMTE1SuXDnFjfCJkty5cwc1a9YUrmfLlg1RUVESIpKD63RSljlzZr21wxkyZED37t0lRmQc3rx5o8vRKFSo0HfXr1dvxtpXcO7cObi7u2PSpEnCvVu3bsHW1hbVqlWTEJk8jRs3hq+vLxo1aiQszHr37h3mzp2Lpk2bSopOnqNHj2Ly5MlYt26dMOn55s0b9OjRAx4eHqhVq5akCEmmT09UUaLRaHDlyhUDRWQc5s+fj8DAQDRs2BDe3t6IiIjAkiVLYGdnh3Tp0iEoKAimpqYYOnSo7FClCQkJwcaNG+Hj44PJkyejbdu26Natm6o//jp06ICoqCi4ubmhfPnyCAoKUu1AtLe392cHVp8+fQpra2tVDTTmypULd+7cSfHE+Nu3byNnzpwGjoq+R2pNqv3rr78wduxYvHz5Urinxh3qkjx+/BgjRozAmTNnkD17dgCJCy6qVauG2bNnI3/+/JIjNLyAgADMmTMHxYsXR548efTupWaX97Sic+fO3OHxMzZt2gR3d3eYmZkJ71+NRqPaBVt9+/bF69evYWdnh0KFCmHFihWqbEcAICgoCHZ2dinej46OhoODg6omRLNly4Z79+6luDj23r17qlxsz8XCKRs/fjxev36NTp06IXPmzAgKClJtgldoaCjatm2b4v24uDg4OTnB39/fgFHJVaVKFWzZsiXFMenNmzerboypdu3askMwWimdxKTRaJAhQwYULVoUzZs3h7m5uWEDkyw+Ph579uzR24irefPmqt0w9NKlS3B2dsatW7eE7yC1fvcALBclL1++hJ+fH44fP44XL14I5XLixAlJkclz//59TJ48GSdOnMD79+9117VaLesJ64kO64kyjluLWCYiJjYpu337NlauXKnrz5YsWRK9evVS7Qk8HLNWxnIRhYWFoXfv3siWLRsiIiLQvXt3mJubY/fu3Xj06BGmTZsmO0SDKVasGM6ePZvimOPp06dTPMQnLYuPj8eNGzdgYWGBjBkz6t17+/Yt7t69i9KlSyNdunSSIpRjzZo1uHv3Lpo2bYoCBQoASNx01szMDJGRkfj99991vw0JCZEVpkGNGzcOV69eRUBAgG6t+dmzZ+Hp6Ql3d3fMnj1bcoRytGzZEkePHkWVKlVgbW2N0aNHY8OGDXj48OFn5w7TsqNHj2LAgAEoUqQIbt++DUtLS90pteXLl5cdnlH5+PEj7t27JzsMaZikr+/ly5e6DT8OHjyI1q1bo3jx4ujatauqN+R98+YNcuTIAQA4dOgQWrVqhUyZMqFJkyaYPn265OiMy+vXr/Hnn3+ic+fOskMxiNq1a2Pnzp3IlSsXatWq9dl1fmocnwWAPHny4N69eyhcuLDe9dOnT6e4Nj0t4jqd/yY2NhaXL19WVd7g+vXrsWzZMt2GmEnzGcWLF0fv3r2/m8R0dc7+fyVLlixBz549YW5ujhEjRuiuJyVeV6lSBb6+vhIjNLwBAwZg9+7d+Omnn9CzZ08UL14cQOKA/erVqxEfH4/+/ftLjtLwli9fjp9//llxAWy2bNnwyy+/ICgoSBWN6Jc+Vp48eWKgSIzH5xZ1njt3DitWrBB2jlWDkJAQ+Pj4oFWrVggLC0OXLl3g4+Oj24WsRIkSmD59uqqTr8uVK4dx48bB2dkZ+/fvx6ZNm/Dbb7/BwsICXbt2RadOnZArVy7ZYRpEUnJTElNTU7x580aY6FPL4DyQOAlqbm6u26EuuaTEa7XUjyT169dHQEAAfvzxR+GeVqtFQEAA6tevLyEyuS5duoSpU6diwYIFipvEDBw4EG5ubqpN0vjUzZs3YWVlpcrFSVOmTEHr1q0xaNAgIaFWzdzc3BAXF4fQ0FDdgqTbt2/D1dUVbm5uWLJkieQIDS84OBheXl7o0qWL7FCk4g6Pn+fr64tBgwahX79+qltcomTw4MF6fzc1NUXOnDnh6empd11NSYGzZs2Cubm54iRWTEwMHBwc8OrVK4PHJVPNmjWxcuVK1KtXT/F+cHAwatSoYeCo5AsPD4efnx8mTZqk2J/18PDA8OHDVTXRlTxJMkeOHNBqtShXrpzwTaymRRZjx45Fjhw50KBBA+FeXFwchg8fjnPnzhk+MIn69OmDPn36IFu2bLC3t9f18Z8/f47AwECEhISori/75MkTBAUFYdCgQYrtyfz58/XKSk2uXLmCK1euICEhQTfvc+fOHZiYmKBEiRJYvXo1pk6ditWrV6NUqVKSozWMGzduYMCAAXj+/LmuTAIDA5EzZ04EBASgdOnSkiM0PFdXV1hYWMDT0xO5c+dW1eZbn8NyEY0ZMwb37t1D165dkSdPHpYJgNGjRwMAvLy8WE/+H+uJiPVEGcetRSwTERObRLt27cKIESNQsWJFVK1aFQBw/vx5dOjQAbNmzVLlSWccs1bGchH5+PjAysoKY8aM0TuYp3Hjxhg1apTEyAyvffv2mDNnDqpVqyasJwgLC4Ofnx8cHBwkRSfPli1bsHLlSqxfv164Z2ZmBldXV9ja2qJTp04SopOnRYsWskMwOgcOHEBgYKDe6YmNGjXClClTVPnsJEnelrZt2xYFCxbE2bNnUaxYMTRr1kxiZPLMnDkTffr0wdChQ1GtWjXMnTsXuXLlwqhRo9CoUSPZ4ZGRYJK+KE+ePLh58yby5s2LQ4cOwcPDA0DigYImJiZyg5OoQIECOHv2LHLkyIFDhw5h1qxZABIPG/neTiL91h49egQXFxfVJF+7uLjo5khdXV0lR2Ocfv75Z3h6esLLywsajQZPnjzB2bNnMXXqVAwcOFB2eNJwg7/UuXfvHmxsbFSz/jwwMBD+/v6wtrZGw4YN9dakHDlyBF5eXoiKioK9vb3kSL+Mydf/g5IlS2LRokWws7NDjhw5YG9vr0u8rlixIvz8/FTXMcuTJw/Wrl0LDw8PzJo1S7cDtUajQcOGDeHu7q7KyZ1r167pJkOVNGjQAEuXLjVgRPIEBQV98TdJOxuqhdLA4u3btzFz5kz8+eef6NChgyoTjJ8+fao7WbRs2bJIly4dypUrp7tfvnx5PH36VFZ4RsXU1BStWrVCkyZNsHr1asycORNTp07FrFmz0KZNG4waNQo//PCD7DC/qU+fo+bNm0uKxHgsWLAADg4OyJEjB3777Tfd9WfPnsHGxgbm5uYIDAyUGKHhDRgwAF26dEH37t3Ru3dvvSTJpUuXIjw8HD4+PpKjNLxly5ahbt26KW4S06BBAwQGBmLGjBkSoiNj8vz5c/Tu3VuV/fnPOXnyJNauXas3UFSiRAmMGzcOPXv2lBiZPOnSpUP16tVlhyFd0g6PHz9+hLu7OwYOHKiqxL8veffuHdq1a8fFWv/v09N12rdvLykS4zFt2jSMGTMG2bJl0+vfx8bGwsHBAS9fvsSKFSskRmh4/fr1wy+//IKhQ4fCwcFBb9PDwMBAHD58WFUngSdZsmQJ8ufPn2J/Nn/+/AgMDMTEiRMlRCfHlStX9P5etWpVxMXF6V1XW6LGqFGjMHjwYAQFBaFKlSq66wkJCXBycsKZM2ewfPlyiREaXt26deHu7g5PT08EBQUha9as0Gg0ePPmDUxNTTFu3LgUN3tIq4KCghAdHZ1iexITE4Nly5Z9dqw/rUo61drb21tXPm/evIGbmxtq1KiBn3/+GSNHjoS3t7dqkvbHjRuHUqVKYePGjboTIl6/fg1nZ2e4u7ur8p18//59zJ07V5Wnmn0Oy0V06tQprFmzhps9JnPt2jVs3LiRC5GSYT0RsZ4o47i1iGUiYmKTaPr06XB0dMSwYcP0rvv5+WH69OmqTL7mmLUylovo4sWLmDRpknA9X758ePbsmYSI5LGzs8Nff/2Frl27ol69enprMI4ePYrq1aur8pTaDRs2wN7eXnHtsKmpKRwcHLBq1SrVJV9/uhExAebm5sIcIQBkzZoV2bNnlxCRcTh58iSqVasGU9PEFIeqVavq5jlOnjypikOuPnXr1i1dcqSpqSnevXuHLFmyYNiwYRg4cKDe2kBSLybpi7p06YLhw4cjb9680Gg0uoN5zp8/r+rxFRsbG4wePRqZM2dGgQIFUKdOHQCJ7a/aNpaNjo7+n+6nNVZWVop/pn84OjoiISEBdnZ2ePv2LXr16oX06dOjT58+sLa2lh2eFNzgj1KyatUqeHl5oW3btnrXS5YsiTp16qBs2bKYNm0ak6/VoHLlypg3bx769++P2NhYrFu3DhUqVICfn5/uw09tChUqhMWLF+P169e4e/cuAKBYsWK6xSdq9Pz588/WB1NTU0RGRhowInn2798vOwSj9uTJE8ydOxebN29Gw4YNsXnzZtV9yCRJ2nGsYMGCCA8PR3x8PG7evAlLS0sAiSePqu3U3pRcvHgRGzduRGhoKDJlyoQ+ffqgW7duePLkCfz9/TFw4EBs2LBBdpjfFAfoRTVr1sScOXMwZMgQ5MiRA+3atdMlXmfLlg1LlixBlixZZIdpUEWLFsWyZcvg4uKCESNG6JINtFotSpUqhaVLl6pyEeT58+fRt2/fFO83bdpUcUfmtOpLg0bv3r0zUCTG56effsLx48dRtGhR2aEYlQIFCiAuLk64npCQkOY3P0mJra0tVq1aBTc3N9mhGAUzMzPs3r1b1btbKunatSt27twJR0dH2aEYheSn1FKi1q1b482bNxg5ciQWLlyIOnXq6BKvX7x4gRUrVqiunS1fvjz8/Pzg6uqKPXv26N0zNzfHnDlzUKFCBUnRyXPixAlMnz49xftt2rTByJEjDRiRfGrbmCA1bG1t8fr1azg6OmLlypWwtLREfHw8nJyccOrUKSxfvlw35qQmPXr0QNOmTbFjxw7cvXsXWq0WFhYWaN26NfLnzy87PINLfuqBks6dO2P8+PGqTL5esmQJli1bppeYni1bNgwZMgR9+vSBra0tBg0ahD59+kiM0rCuXr2ql3gNADly5ICTkxO6desmMTJ56tWrh7CwMFWOr30Oy0VUokQJVY+xKalYsSIeP36s6kWfn2I9EbGeKOO4tYhlImJik+jZs2eKJ3d17NhRNRsqfYpj1spYLqL06dMrJmGEh4erbh2TmZkZli5diqCgIGzfvh2nTp3SjS8NHz4ctra2MDMzkx2mwd25c0dvA8hPVapUSXcinFp5eHhg6NChqntmPjVgwAD4+Phg2rRpyJs3L4DEd/T06dNVPbdsY2ODw4cPI3fu3HrX37x5o6qTApPLnDkzPn78CADImzcv7t27p5vTePnypczQyIgwSV80ZMgQWFpa4vHjx2jdurXuVGcTE5PPrpdM63r27InKlSvj8ePHqF+/vm6jpSJFimD48OFygzOwmjVrfnbTcq1Wq7pNzZOLj4/Hnj17dH3XUqVKoXnz5qrNkwMSN7kfMGAA7O3tce/ePcTGxqJkyZKqW4+fHDf4+0ft2rU/ez8+Pt5AkRiHFy9eoEyZMineL1269HfTl1Vvq/cV1atXDzNnzsSwYcPQoEED+Pv7q3LQ6FM5cuRA5cqVZYdhFPLly4cbN26kuLDi2rVrusETNXr8+DF++OEHVe+S+ubNGwQEBGDlypUoV64cgoKC9HZdVqMOHTpg7NixaN68OY4ePQoHBwdMmzYNr169gkajQUBAgKo6Y0qWLVuGTZs24c6dO/jxxx8xdepUNG7cWO9D2MfHB82aNZMcKcnSpEkTeHl5wcXFBe/fv0dgYCAyZ86MpUuXKp7ipAaVKlXC9u3bcfXqVYSHh0Or1aJ48eIoV66c7NCkefLkyWc//DNnzqyqHbpv3ryJdu3aoXDhwor3nz59ivDwcMMGZSTc3d0xbNgwnD59GqVLlxYG0WxsbCRFJtfo0aMxefJkuLu7o1KlSgASN0bx9PTE2LFjJUcnh729PRwdHdGiRQuUKlVKqCv+/v6SIpOnRYsW2Ldvnyp390/JyJEj0a9fPxw6dEixTXFxcZEUGRmT7t2749WrVxg4cCDmz58PPz8/PH36FCtXrkS+fPlkhydF06ZN8eeff+LQoUO6RMnixYujQYMGyJQpk+zwpHj06JGwACe5nDlz4vHjxwaMiIzV0KFD8fr1a/Tp0wfBwcGYM2cOTpw4gaCgINVufggkjl2zj5LowYMHKFiwYIr38+fPj4iICANGZDyio6Px4sULlCpVSu96ZGSkbsF59uzZdQsA1cDCwgLPnz8XNm548eKFapNsp0yZAmdnZ9y4cQOWlpZCH7958+aSIpOL5SKaMGECZs6ciUGDBsHS0lKYV1fj2LWnpycmTJiAJ0+eKNYTNZ7+zHoiYj1RxnFrEctExMQmUe3atXHq1Cmh73r69GnVrlXhmLUylouoWbNmmDdvHubMmaO79vDhQ8yYMQOtWrWSF5gkZmZm6Nu3r6oTmD719u3bz56SGBMTo/qNhrZu3Qp7e3vVJ1+vWbMGd+/eRdOmTVGgQAEAiXMeZmZmiIyMxO+//677bUhIiKwwDS6lRLdXr16pdi6sSpUqOH36NEqWLInGjRtj6tSpuH79Ovbs2fPZzR7Solq1an02EVLp8AS1YJK+statWwMA3r9/r7vGE30T19GWKVMGDx48QNGiRWFqaoomTZrIDsvgsmTJgv79+6fYlt69exfu7u4Gjso43LhxAwMGDMDz589RvHhxAEBgYCBy5syJgIAA1c6vb9myBa1atUKmTJmEeVO14gZ///jw4QN+/fXXFJ+PiIgIzJs3z8BRyVOpUiUsWrQInp6ewnhSfHw8Fi9erFtzbeyYfP0/UOrAnzp1Cg0aNNC7duLECUOGJVVqBlQ1Gg28vLwMEI3xaNy4MXx9fdGoUSNkyJBB7967d+8wd+5cNG3aVFJ08rVt2xZbtmxBkSJFZIcixeLFixEYGIg8efJg5syZaNGiheyQjMLQoUORMWNGnDt3Dj///DMcHR1RtmxZTJ8+HW/fvkWzZs2EHXLUZs2aNejatSusrKxSPPEtV65c8PT0NHBkchw8eBC7d+9Gjhw50LVrV5QsWVJ37/Xr1xgyZAiCg4MlRihHhw4dEBUVBTc3N5QvXx5BQUGKO7urTbly5VSdcJ1crly5cOfOnRTfw7dv30bOnDkNHJU8lpaWqFy5coq7fV69elVVJ4Ent337dhw5cgTp06cXvnE0Go0qF2wBid9Ab9++xc8//wwTExMAiQMDJiYmcHV1haurq+63avk2nDJlCo4fP446derA3Nxc1TuAJilWrBjmzZuHM2fOoEKFCsKksBqfn4ULF+Lw4cO6Afrk1FpnwsLCsH//fuTIkQNt2rTRW3ASHR0NT09PVZ6Q3bdvX7x+/Rp2dnYoVKgQVqxYocrTWJPLmDEjWrZsKTsMo5EtWzbcu3cPhQoVUrx/7949VSZmPH36FEePHoW5uTnq1aun28kdAGJjY7F06VIMHjxYYoRyjB8/Hq9fv0anTp2QOXNmBAUFqTZJ5eTJk6n6Xa1atb5xJMYjQ4YMiIiISDEBOyIiQhjfV4tmzZrB1dUVzs7OeptOTZ06VTeefeHCBVhYWEiM8ttLvnB65MiR8PT0xODBg1G1alUAwLlz5zBv3jyMGjVKUoRynTt3DmfOnMFff/0l3NNoNKo8lQhguSjJnj07oqOjYWtrq3c9aXG1GsskMjIS9+7d05tr12g0qi4T1hMR64kyjluLWCYiJjYl2rdvn+7PzZo1w4wZM3D58mXdIvPz589j586dGDJkiKwQpeKYtTKWi8jZ2RlDhw5F/fr18f79e1hbW+P58+eoWrUqnJycZIdHRqBYsWI4e/ZsiuOOp0+fVu3GbUm0Wq3sEIwC14nqS5qz0Gg0cHZ21pvXiI+Px7Vr11CtWjVZ4Unl4uKCmJgYAIkn+cbExCA0NBQWFhZwdnaWHJ1hJV+DQ/qYpC+Kj49HQEAA1q5dixcvXmDXrl0oUqQI5syZg0KFCqF79+6yQ5Ti7du3mDx5MjZv3gwAunKZPHky8uXLB0dHR7kBGlD58uUBpHxabfbs2VXbbxk3bhxKlSqFjRs3IkeOHAAS1+I7OzvD3d0da9eulRyhHN7e3vDw8ECzZs3QsWNHNGzYULdmVK24wd8/ypYti/z586e4yUdYWJiqkq/Hjx8PBwcHNGjQALVq1dIdrPHixQucPHkSZmZmWLp0qeQoU0ejVevb4CtI7YC7mnbHGTRoUIr34uPjcfToUXz48EF1E3/Pnz+HlZUVTExM0LNnT92A9O3bt7F69WrEx8cjJCQEefLkkRypHNWqVcPWrVtVm3xdtmxZZMyYEfXq1fts50uNJwT+GzxBXd22bduGsWPHolGjRnjz5g0uXbqEKVOmoGPHjgAS2+FGjRqp6v3TuXNnvcnOmzdvokCBAsIJx2l5AcGnUtuOqi0BwcXFBXfv3sXq1auFe1qtFr/99hssLCxUk+w1ZcoUaDQauLm5Kd6/d+8e3NzcsGLFCgNHJl+DBg1gbW0NR0dHvm+T+TftqFq+DatVq4bZs2erckfUlDRr1izFexqNRm/Rm1rUqlULLi4u6NKli+xQjMLhw4fRv39/WFhYICYmBrGxsfD19UXdunUBqLM/+2mf7ODBgyhbtqxw4rWavpWTJj+/RGlH2bRs2LBhiIuLS3GCYsCAATAzM4Ofn5+BI5PnwoULsLe3R0JCAuLi4pAvXz7MmzdPt7u9GtuU5N8zcXFxWLduHWrWrCnsOKym05o+l3SeNJ6g0Whw5coVQ4UknaOjI3744QdMmTJF8b6bmxuePn2KxYsXGzgy+WJiYuDt7Y3NmzcjPj4eAGBiYgIrKyu4uLggc+bMujYlLW92V7ZsWb3xtqQp1qRryf+upjY2SbNmzdCkSRMMHDhQtfNdSlguom7dusHU1BQ2NjbInTu3kLST0kK3tKxt27YoWbIkHBwcFMskpY2G0jLWExHriTKOW4tYJqJ/M36UlucJU7v5mFr7sxyzVsZySdnp06cRFhaG2NhYVKhQAfXr15cdksE1a9bsi0n4Go0Ge/fuNVBExiHpIJbly5cLbW9YWBhsbW3h4OCgqtPC4+PjcebMGZQpUwbZs2dX/XpRUpY0Ph8SEoI2bdogY8aMuntmZma6REm1n5hOlJL79+8jJiYGZcuWRWxsLHx8fHD27Fldkr4axw38/f2xefNmDB06FOPHj8f27dtRpEgRhIaGYvny5XobcanJlClTcObMGbi6uqJv3766d/LevXt1ZaYW69atw7t371LcqO758+dYu3Ztmh4rSEnl/RXeRwABAABJREFUypWxceNG3RqDJNevX0e3bt1w4cIFSZHJFRcXh0OHDmH79u3Yv38/MmbMiNatW6NDhw6oXr267PCkWLNmDfz8/NCmTRvFDf6SHzDYvHlzWWEaREBAAOLi4lJsMx49egQ/Pz/VrMcHEjc337p1K86fP4/nz58DAPLkyYOqVauiQ4cO381hGky+JoPYu3cvZs+ejadPn6Jv376q2hEnSUREBDw8PHD48GG9BTgNGzaEu7u7qgeS1D6Y5uzsnKrdYNX0kv0vqlevrtoT1N++fYuHDx/i48ePetfVdHJT586d0aVLF90HcGhoKNzc3ODq6oru3burcmE5E41Fn0tC0Wg0uHPnDt6/f6+qegIkJhN36dIFxYsXR+/evVGiRAkAiZvELF26FOHh4di4caPqd16mxAWNGzZsQNGiRWWHQkauadOmCAwMRMmSJWWHQkasQYMGWLVqVZo/HTG1evTogTp16sDJyQlarRaBgYGYP38+fH198eOPP6qyP5vaBEg1fSt/7vRZjUaD2NhYxMfHq6qeAMCVK1fwyy+/oGnTpnBwcNDb9DAwMBAHDhzA2rVrUaFCBcmRGk7v3r2RP39+eHp6IjY2FjNmzMCOHTuwbNkylC9fXpVtirW19Rd/o9FoEBwcbIBojMObN28Ur799+xbBwcFYsWIFihQpgu3btxs4MnmOHTuGPn36wNbWFvb29rokyefPnyMwMBDBwcFYsmQJ6tWrJzlSw0paHFu6dGmYmpri/v37AIAiRYoIm/yldZ+eHPk5akwKrFatGrZs2cJxg0+wXERVqlRBSEiIbhySgKpVq2LLli0cg02G9UTEeqKM49YilgnRf8Mxa2Usl9SJiopC9uzZZYdhcMuXL0/xXkREBH7//XdVHtTz8eNH9OnTB2fOnEG9evX01mAcPXoU1atXx9KlS2FmZiY5UsOqVKkSQkNDVbm2LzU8PDwwdOhQJhYjcc1bnz59kDlzZtmhGKWYmBjhFNbvJWnFEJ4+fYqAgAC4u7vLDoWMQMuWLTFp0iTUq1dPL1fh1q1b6NGjB06ePCk7RCmaNm2K2bNno2rVqnrlcvfuXVhZWeHMmTOyQyQj0LFjR7i4uAjzokePHoWXlxe2bdsmKTLj8fbtW+zZswfbt2/H33//jfz586tu4ymAm/3R17No0SL06NHDKMdXTGUHQGnb6dOnMXPmTFy5cgU9e/aEo6MjcuTIITssKQoVKoTFixfj9evXuHv3LgCgWLFiqi2P5Pr376/qcvDx8ZEdQpqgxr1EIiMj4ezsjEOHDineV1MH9e7du2jatKnu723btkWuXLkwYMAAxMXFoWXLlhKjk0NNSdWpldKOfFevXsWMGTNw48YNdO/e3bBBGYGiRYti2bJlcHFxwYgRI/ROaypVqhSWLl3KxVwEIHEDg9DQUPTv3192KEZl06ZNirv9x8XFwdfXFyNHjpQQlVyDBw/G3Llz4e3tjUyZMskO57uipg2FbGxssHLlSowbN052KEbhxo0bmDZtGoDEwea+ffsif/78GDZsGGbNmoVKlSpJjtDw1JRUnVopTf4+ffoU/v7+2LRpkypPVylfvjz8/Pzg6uqKPXv26N0zNzfHnDlzVJV4DQCXL1+Gu7s70qVLh6xZs8LDwwMFCxaEnZ0dAgMDUbBgQdkhGtyKFStkh2B0smXLpvf3hIQEbNy4Ef7+/kiXLh3c3d1hZWUlKTo56tatC3d3d3h6eiIoKAhZs2aFRqPBmzdvYGpqinHjxqku8RpIPOG6T58+usWxatrw8VNqTKj+N1q1aoXjx48z0esTLBdRxYoV8fjxYybVJlO3bl2EhYVxHDYZ1hMR64kyjluLWCaiY8eOoW7duor31q5dix49ehg4IjJGHLNWxnIRLVq0CIULF0bbtm0BAMOGDcPu3buRJ08eLF68WFXfzba2tsK1V69eYf78+VizZg2qVKmCUaNGSYhMLjMzMyxduhRBQUHYvn07Tp06Ba1WCwsLCwwfPhy2traqS7wGAEtLSzx48EAV86D/xdatW2Fvb8/ka3DNm5L79+9j8uTJOHHiBN6/f6+7rtVqVZnIdOPGDRw/fhxmZmZo06YNsmfPjsjISAQEBGDt2rVsZ0jnyZMniuOyWq0WcXFxEiIyDpGRkcidO7dw/e3bt6k6TC6te/z4MX744QekS5dOdigGFx0drfvzyJEj4enpicGDB6Nq1aoAgHPnzmHevHmq7OMryZQpExo2bIioqCg8fPgQt27dkh2SFGFhYbJD+G45OjpiypQpeqeDq1lAQICub2dsmHz9P1q1ahX27NmDHDlyoEePHnoLbyIjI9G9e3fs27dPYoRy3Lx5EzNmzMChQ4fQqVMnzJo1C/nz55cdllHIkSMHKleuLDsMo9KvXz/ZIRB9lzw9PfHmzRusW7cONjY28Pf3x/Pnz7FgwQI4OzvLDs+gsmTJghcvXugNnNWtWxcLFy5Ev3798PjxY4nRkbG6f/8+fH19sWPHDrRs2RLbt29X7Y7dlSpVwvbt23H16lWEh4dDq9WiePHiKFeunOzQDG7OnDkYPHgwTE2VP5UePnwINzc3LFu2zMCRyZeQkIDAwEAcPnwYZcqUEcootSeUpjVTpkzBgQMHMHnyZN2GQrdv38aoUaPw6tUrVSZfr1ixAvfu3UP9+vVRuHBhoa6EhIRIisz4qWlDoQsXLuDYsWP4888/YWlpKdQTf39/SZHJkT59ekRFReld69ChA9KlSwcnJyeMHTtWUmRkzKKjo7F48WIEBwfD0tISgYGBKS4kTuuaNm2KP//8E4cOHcLdu3d1/dkGDRqodiOQ5ItvgMRJGxMTE9jb28PLy0tSVGSsdu/ejVmzZuHly5dwdHSEtbU10qdPLzssKXr06IGmTZtix44duvbEwsICrVu3VvUcBxfHpiwqKgo7d+7Ew4cPUahQIbRu3VrY3EAtLCwsMHPmTJw+fVp3UnpyNjY2kiKTi+Ui6tWrFzw9PWFvb69YJmpKVknStGlTeHt74/r164pl0rx5c0mRycN6ImI9UcZxaxHLROTg4ABra2uMGDFCl+wWGRkJV1dXnD59WlXJ148fP0b69Ol1iV2nTp3CmjVr8OjRIxQsWBA9e/ZEtWrVJEcpB8eslbFcRGvXrsWMGTMAAEeOHMHff/+NxYsXY8eOHZg2bRqWLl0qOUI53r17h2XLlmHp0qUoWLAg/P390bhxY9lhSWNmZoa+ffuib9++skMxGsOHD8fUqVMxbNgwVKhQQTjVWO0n96ppnvhLnj9/jqlTp+Lo0aOIjIwUykZticYAMHr0aACAl5cXcufOrerkyH379mHYsGG6xNnAwEBMnjwZw4cPR4UKFeDv748ff/xRcpSGU7t2bezcuRO5cuVCrVq1Pls3Tpw4YcDIjEOpUqVw6tQpFCpUSO/6zp07VbkuMknFihVx4MABWFtb611fv369LslWzdq2bauagzM+VbNmTb12RKvVYvjw4XoHOgGJBy+q8X2cJOnE623btuHo0aMoUKAA2rVrB19fX9mhGZ23b9+qds1Oapw8eVJY26NmxvxNxOTr/0FwcDBmzZqFLl264M2bN+jbty+GDBmiSyRNSEjAw4cPJUdpWI8ePYKfnx+2bt2KJk2aYOvWrShZsqTssKRLzeSVRqNRxcLHqKgobN++Hb/99huAxF1xkr8w0qVLhylTphjlbhXfSufOnRU/eLNmzYrixYvDxsYGpUqVkhAZGbvjx49j/vz5qFSpEjQaDQoWLIgGDRoga9asWLhwIZo0aSI7RIOpXLky/vrrL+HDv3bt2ggICFDtzu4HDx7E7t27kSNHDnTt2lXvnfz69WsMGTIEwcHBEiOUIzIyEvPmzcPvv/+OGjVqYM2aNdwY5f+VK1dO1QOLQOIJ6QcOHMC0adNQunRpvXtr167FtGnTUL16dUnRyXXt2jVd/bh+/brePTVP7GzevBmjR49Ghw4d4O3tjfDwcEyfPh3NmzeHh4eH7PCkaNGihewQ6DuQPXt2tGrVSnYYRqNcuXI4fvw4KlasqHe9Xbt20Gq1qttcKUlYWBj279+PHDlyoE2bNnq7/UdHR8PT01OVJ2R//PgRK1euREBAAMzNzeHt7Y3WrVvLDku6jBkzomXLlrLDMAqWlpY4e/askJBib2+PhIQEjBgxQlJkcj19+hRHjx6Fubk56tWrp5dcHBsbi6VLl6ruRI0TJ05gxowZuH79OmxsbNC3b1/VJo0mly9fPtjZ2ckOw6hwcew/Bg8ejPbt26N169a4ceMGrK2todFoUKRIEURERMDX1xfLly9X5dzY+vXrkTlzZpw4cUJYyKfRaFSZZAywXJQ4OTkBAFxdXXXXNBqNak9rAoAJEyYAAObNmyfcU2uZsJ6IWE+UcdxaxDIRBQcHY+zYsfj7778xc+ZMPHjwAG5ubihevDg2b94sOzyDGjJkCAYOHIimTZti7969GDJkCJo0aYLq1asjPDwc1tbWmDt3Lpo2bSo7VIPjmLUylovo+fPnKFCgAADgzz//RJs2bdCwYUMUKlQIP//8s+ToDC8+Ph7r1q3DvHnzkD59eri5uaFTp06qfedQyhwdHQEAAwYMEJJ61NifjY+Px5kzZ1CmTBlVrZVNDWdnZzx69AgDBw7kKYD/79q1a9i4cSNKlCghOxTpFixYgN9++w3Dhg3D+vXr4ePjA09PTyxatEiV6/9cXFx04/PJx1Ao0cCBA+Hs7IwnT55Aq9Vi9+7duHPnDjZv3oyFCxfKDk8aJycn9O3bFzdv3kR8fDyCg4Nx69YtnD17FitWrJAdnnTGnPz3ralxPfm/5eTkhAMHDiBjxoxo06YNBg4cqNpN7JLY2tpi2rRpyJcvn9718+fPY8yYMdi1a5ekyIi+Ho1WzW+H/1G7du3Qv39/dOjQAQBw5swZDBo0CD169MCwYcPw/PlzNGrUSFWDAlWqVIFGo0HPnj0/m5Sitl2XBw0alOK9+Ph4HD16FB8+fFBFXQkMDMTVq1cxc+ZMAEC1atXQqFEjZMmSBQBw9uxZtGvXDkOGDJEZpkGltAtsVFQUrly5gnPnzmH58uWoUaOGgSP7vlSrVg1bt25V1U5T1atXx9atW1G4cGE0bdoUM2bMQI0aNXD//n20b98e58+flx2iwZw4cQJnz57VbYDyqWPHjmHLli2qSszYtm0bxo4di0aNGuHNmze4dOkSpkyZgo4dOwKAKvspSYvply1bhmLFimHEiBFo2LCh7LCkS+1u5GpJQoiOjsakSZOwY8cODB48GH379sXjx4/h6uqKixcvYsyYMfjll19kh0lGJiEhAV5eXli1ahVMTEzg4+OD9u3byw6LvkNq7NNSoj179uDkyZMpTohu27YN69atU9VE1+HDh9G/f39YWFggJiYGsbGx8PX11Z3srMb+rFarxebNm+Hn54e4uDgMHjwY3bp1g4mJiezQpErtIunOnTt/0ziMyfr163HixAlMnz5d8f6iRYuwdu1a7N+/38CRyXPhwgVd8nlcXBzy5cuHefPmwdLSEoA625S+ffvi6NGj6NKlC4YMGYK8efPKDkm6kydPpup3tWrV+saRGJ/kmzmofXFs7dq1sWbNGpQsWRJ9+/ZF9uzZ4e3tjfTp0+Pjx4/w8PDA48ePsWTJEtmhEhmtiIiIz97/9CQaUifWEyL62mJiYjBhwgTs2rULWq0WQ4cORd++fVWXHJh8DPrnn39GixYtdMlwALBy5Ups3LgRISEhEqMkMm4NGzaEn58fqlevjp9++gnDhw9HmzZtcPv2bXTr1g1nzpyRHaLBhIaGwtfXF1FRUejfvz9+/fVXvQ0P1apZs2ZffL9oNBrs3bvXQBEZhy+duFq7dm0DRWI8KlWqhNDQUM4Nf6JatWpYvXq16g+PSM7a2hoDBgxA/fr1ZYciXY0aNbBp0yYUK1YM8fHxqFSpEgIDA1k2lKJTp05h3rx5CAsLQ2xsLMqXL49Bgwapft3ovXv3sGjRIr1y6du3L8qUKSM7NOm4duvf8fDwwNChQ/UOU0jLRo4ciY4dO6Jhw4aqX6uTxNHREefPn8eECRPQtm1bJCQkYN68eVi4cCF+/fVXuLm5yQ7RaLG90WfM5cGTr/8HDx480Nulonr16li+fDl69+6NuLg42NraSoxOjqQTjJcsWZLiwhK1LcQBlHefBoC9e/di9uzZSJ8+/WcTtNOSXbt26XYqTzJ69GhdA7lnzx7MmzdPVcnXX0pmmz17Nvz8/LB8+XIDRfR9UtukKAAUL14cd+7cQeHChVGmTBn8/vvvKFy4MNauXau6BbO1a9f+7CB83bp1dUkaarFkyRI4OzvrTk4JDQ2Fm5sb3r9/j+7du0uOTo6WLVsiJiYGvXr10iVFhoWFCb/79HS4tO5zE3oajQZ37tzB+/fvVZN8nTVrVkybNg2tWrXChAkTEBoaigcPHqBy5crYunUrF/WRogMHDuCPP/5A1apVER4ejg0bNqBWrVrCbn5ERClp2bLlZ0/s7dChg27zP7Xw9/eHvb09nJycoNVqERgYiAEDBsDX1xc//vij7PCk6NixI+7fv49evXrB1tYWmTJlwtu3b4Xfqen0UQDw9PRM8Z5Go0FsbCzi4+NVlXzdvXv3z373OTo66i2sVoPZs2ejRYsW8PT0RGxsLGbMmIFevXph2bJlKF++vOzwpDh06BBMTU2xY8cO7Ny5M8XffWlRZFpibW2d4r2ksUeNRoMrV64YKiSjwZ3u//H+/XuYmZkBAK5evYpFixbpFpabmZnBwcFBtWNvRKnF8TVKDdYTSq03b94gPj4e5ubmetdfvXoFU1NT1X0jAyyTlISHh+PSpUvInz8/nj59ijt37uDt27fInDmz7NAMysTEBDExMQAS1719Os72448/YsaMGTJCI/putGrVCqNGjUKxYsXw6tUr3XN09epVFCtWTHJ0hjVixAhkzJgR7dq1w8OHD3WHsXzKxcXFwJHJ9bl1wxEREfj999/x4cMHA0ZkHNSYXP0llpaWePDggVEmF8hUoEABVZ86qsTT0xMTJkzAkydPYGlpCVNT/fQPNa11i4mJ0X3TmJiYIEOGDKp+hqKjo1P9W7V+C9asWRPLli2THYbRKVq0KKZMmSI7DKPUv39/5MiRQ3YY342tW7fC3t5eNcnXKX3zqNmiRYuwatUquLq6Yt++fYiIiEBERAQCAgJUv9EFpR1Mvv4f5MyZE48fP0bhwoV110qXLo3ly5fD1tYWT58+lRidHEoJTCQ6ffo0Zs6ciStXrqBnz55wdHRUTSft/v37KF68uO7vxYsX1y1UAhIHAe7evSsjNKPVvn17rFu3TnYYBhUWFobSpUsjXbp0qf5n1DjgZmNjg2fPngFITOJ3cHDAtm3bYGZmBh8fH8nRGVZqBpFMTEyQKVMmA0RjHO7evYumTZvq/t62bVvkypULAwYMQFxc3GeTe9KqFy9eAAACAwOxZMkSvXZDo9Go8rQmIOWTAq9evYoZM2bgxo0bqlw0XLVqVZQuXRpHjx5FpkyZMGDAAC74A3Dx4kXs2LEDjx49wsePH/XupfYU9bTG3d0dISEhcHJyQu/evfH8+XO4urqiY8eOut381CY+Ph5BQUEp1hU1JfD8W2rbUGjnzp0p1hOerEI3btzAtGnTACQ+G3379kX+/PkxbNgwzJo1C5UqVZIcoeHduHEDwD/92U+ptT+b0km1T58+hb+/PzZt2sTd7gmXL1+Gu7s70qVLh6xZs8LDwwMFCxaEnZ0dAgMDUbBgQdkhGpy3t7fsEIxOSu3J27dvERwcjBUrVqh2EVdqF8eqYXf7MmXK4NixYyhatCjy5s2Lhw8f6m3i8PDhQ2TMmFFihHI9fvwY+/btU+zjq22xfXIsF30LFy5E7ty50a1bN73rGzZsQGRkpOo2iQGAKVOmoGjRorrNVJOsXLkSd+/eVeXJEKwnItYTZU5OTmjatCl69uypd33Hjh3Yv38/Fi9eLCkyeVgmokWLFsHPzw+//PILxowZg7t372LMmDHo2LEjpk+frnfwRlpXq1Yt/PHHHyhbtizKlSuHEydO6CXrHD9+XNUby3LMWhnLRZ+LiwsKFSqER48eYfTo0ciSJQsA4NmzZ/jtt98kR2dYtWrVApB4cmJK1Db3BSgnX7969Qrz58/HmjVrUKVKFYwaNUpCZPJFRUVhw4YNuHXrFoDE5OOuXbsiW7ZskiOTY/jw4Zg6dSqGDRuGChUqCJvCqDVR0tXVFTNnzsTEiRP11uerWWRkJO7du6c3jqTmtW6HDh3StRtarRZHjx7F9evX9X7TvHlzGaEZXM2aNVP9rlVbPSF9TNRPvX79+gFILLOtW7diw4YN2LRpk+SojJca8jeCg4Pxyy+/IEOGDF/csPrTsVu16NmzJx4/fozFixfD1NQUwcHBqF69uuywiL4aJl//D2rUqIHdu3ejZs2aetdLlSqFoKAg1TaclLKbN29ixowZOHToEDp16oRZs2Yhf/78ssMyqLdv3+LNmzcoUKAAAAid0djYWCQkJMgIzWilS5dOdWViZWWFw4cPI3fu3GjevDk2bNiAnDlzfvafCQ0NxQ8//GCgCI1Dp06ddH+uWLEi/vzzT9y+fRsFChRI0wsclaR2EClz5syoX78+3Nzc0nz7myVLFrx48UJvUXDdunWxcOFC9OvXD48fP5YYnRz79u2THcJ34f79+/D19cWOHTvQsmVLbN++HRYWFrLDMqjt27dj8uTJKFu2LEJDQ7Fhwwb06dMHv/32G0aOHIkMGTLIDlGKP/74A2PHjkXDhg1x+PBhNGzYEHfu3MGLFy9UuaFDkjNnzmD9+vW6xUl58+bF4sWLsWrVKri5uaky+drf3x/r169Hnz59MGfOHPTv3x8RERHYu3cvBg0aJDs8o6aGAekkwcHBmD17Nrp06YJ9+/ahS5cuuH//Pi5evCgsDFWDWrVqfbE/a2Jigjx58qBBgwYYOHAgsmfPbqDo5EifPj2ioqL0rnXo0AHp0qWDk5MTxo4dKykyeXjqaOpER0dj8eLFCA4OhqWlJQIDA1G3bl3ZYRlU586d/1Wb8ssvv+hObU3L3r9/r/d3R0dHmJiYwN7eHl5eXpKiksfKykp2CEbn00WeCQkJ2LhxI/z9/ZEuXTq4u7uz3L5ADbvbDxw4EGPHjoWpqSmsra3h5eWFly9fomTJkrhz5w7mzp2Ljh07yg5TiqNHj2LAgAEoUqQIbt++DUtLS0RERECr1eolqKsNy0X0+++/K56oaWlpCScnJ1Um1e7atQsLFiwQrlerVg2LFi1SZVIt64mI9UTZhQsXFDeyqF27NubMmWP4gIwAy0QUHByMefPmoXHjxgASD9ZYv349Zs2aBWtra1y6dElyhIYzatQo/Pbbb3j69Clq1KiB2bNn4+LFi7r+bGhoKCZOnCg7TCk4Zq2M5SIyMzODvb29cN3Ozs7wwUi2YsUK2SEYvXfv3mHZsmVYunQpChYsCH9/f937SG0uXrwIBwcHZMiQAZUrVwYALFu2DAsWLMDSpUtRoUIFyREaXtJ3zYABA/TG9NWaUJvEyckJb9++RcuWLZExY0a9w50AdW727urqivLly2PWrFnInTu3Kje2SM7Z2Vnv7+7u7np/V9Pzk3z+OCIiAjNnzoSVlRWqVq0KADh37hxCQkIwcuRISREaXmrWXiRRU3uSmjXWan//JDl27Bg2btyIPXv2IGvWrKpeF0mJgoKC0KFDB2TIkAFBQUEp/k6j0agyh/D169cYN24cjh49ikmTJuHEiROwt7fHqFGjVDtuQP9NzZo1jXZ9PpOv/wd9+/bF5cuXFe9ZWlpi+fLl2L17t4GjkiulRaDZsmWDhYWFqnaLTe7Ro0fw8/PD1q1b0aRJE2zduhUlS5aUHZYURYoUwZUrV1C6dGnF+5cuXeJudZ/Ys2cPSpUqJTsMg8qePTsePHiA3Llz6xYhfUlSQr+aZcqUSZUD0UDqkhASEhLw4sULrFq1CuPHj0/zu7pXrlwZf/31l24gLUnt2rUREBCA/v37ywlMIp5a/HmRkZGYN28efv/9d9SoUQNr1qzRTXipyZAhQ3D48GGMGDEC1tbWAIAxY8agRYsWcHFxwcGDB+Hj46PKfm1AQABcXFzQs2dPVKtWDW5ubihcuDDc3d2RN29e2eFJs2nTJsVkpZ49e6JevXoSIpJv27ZtmDJlCpo0aYK5c+eiffv2KFq0KMqUKYPz58/LDs+o3Lp1Cxs2bNAlkS5evFg1p4qsXr0akydPRvv27bFp0yb07dsXRYoUga+vL16/fi07PINzdXX94m+S+rObNm3C06dPMWvWLANEJk+5cuVw/PhxVKxYUe96u3btoNVqhUl1NUjtqaNq9fHjR6xcuRIBAQEwNzeHt7c3WrduLTssKVq0aPHF3yS1KQsWLMCtW7fg4eHx7QOTyNLSEmfPntU7zQsA7O3tkZCQgBEjRkiKTJ6UdrjPlCkTTExMDByN8dm9ezdmzZqFly9fwtHREdbW1qrYpOB/pYbNhJo0aYJJkybBy8sLT58+hVarxfjx4wEkbh7To0cPVS1kS27mzJno06cPhg4dimrVqmHu3LnIlSsXRo0ahUaNGskOTxqWi+jZs2eKY0m5cuXCs2fPJET0f+zdeUBN6f8H8PcVFUqWSIVQyr5kS5ItWyllz5Ck7BJKWkaLNpFIfQslky2UioSMbYgZCTOK7FtUVCiStvv7o19nuu4tjJn7XD3P65/vdM794+187z333HOez+dD3tu3b0VOepOTk8ObN28IJCKPvU+EsfeJaKWlpSgvLxfaXl5ejpKSEgKJyGPHRNjRo0eFGgQ1atQIjo6OGDlyJKFUZKirq+Pw4cPYsmULwsPD8fHjRxw7dgwNGzZEz549ERgY+FX3Feojds9aNHZchMXFxaFFixYYMWIEAMDf3x+HDh2ChoYGAgIC2LoEBgBQUVGBQ4cOISQkBNLS0nBxccGkSZOoLpj09fXFqFGjsH79ejRsWLV0vby8HK6urvDx8cG+ffsIJxQ/1nRXtK95bkqbly9fIjQ0FGpqaqSjEJeZmUk6gkSp+fx47ty5WLt2LSZOnMhtGz16NDQ1NXHo0CFqmsuyc4ho7Dunbrm5uThy5AiOHDmCwsJCFBYWIiAgABMmTKD6+o2pcvbsWZH/zVSZOHEi2rVrh7i4OLRv3x7Tp0/nmvtduHABO3bsIB1R7FJTU9GvXz/ud0+18vJy3LhxAwMHDgQALFq0CAoKCiQiilW3bt24wZw1vXnzBrq6ulzTD0mu7WHF19+ha9euQou1atLU1Ky1wLS+qq2TR1FREYqKitCvXz+EhoaiefPmYs1F2vjx48Hj8WBpaQltbW08efIET548EXrd6NGjxR9OzAwMDLBlyxbo6elBUVFRYN/r16+xbds2gWm+NKjtB01RUREyMjJw4cIFif4i+S+MHTsWs2fPRuvWrcHj8TBlyhQ0aNBA5Gtpm2Tr6+v71a8V1dG8vvqWIgQtLS2YmpqisLCwXk8LtLS0xI0bN0TuGzx4MEJDQ5GQkCDmVGTVdr6obhLTpk0bMSeSDMXFxdi1axciIyOhpqaGsLAw6OnpkY5FzOvXrxEXFyc07VtbWxsJCQnYtGkTdVMQqj1//pzrwi0tLY3i4mLuGnfu3LmwtbUlnJAMaWlpPHv2DLGxsXj+/DlcXFzQqlUrXLhwASoqKqTjEZGXl8f9Fm7atCmKiooAACNHjsTWrVtJRpMIxcXFOH78OGJjY3Hz5k1oaGhwxdcDBgwgnE58srOzuUYWsrKy+PDhAwBg0qRJmDFjhlB36vruWx50Dh06FFOnToWXlxeaNGnyH6Yiy9zcHKmpqSL3TZw4EXw+H4cOHRJzKrJqW0wgLy8PFRUVah/68fl8xMfHIygoCOXl5Vi1ahWmTp1KdfHosmXLvvq1EydOhIWFBZydnet1YampqSmuXr0Kc3NzoX02Njbg8/mIjo4mkIyc2jrcS0lJQVVVFfPnz8f06dMJJCPr6tWr2LRpE+7duwcLCwvY2NiILHJi6DZu3DgYGBggIyMDWVlZqKysROvWrdGjRw/IycmRjkfMw4cPuQZBDRs2RElJCZo2bYoVK1ZgyZIlmDVrFuGEZLDjIkxZWRnXr19H+/btBbanpaVRe49WTU0NFy9eFFpE/dtvvwkdJ1qw94kw9j4RrVevXjh06BDXDKVadHQ0tU2r2TER1rJlSxQWFuLUqVN49uwZ5s+fj+bNmyMjI4PKApYOHTpg8+bN4PP5yM/PR2VlJVq0aCE0VZI27J61aOy4CAsLC+MaGd64cQP79++Hk5MTzp07B19fXwQHB5MNKEa13YesXoMxbdo0oeYXNEhKSsLWrVtRWFiIRYsWwdzcvF7fe/1a6enpAoXXQNXvZGtra0yZMoVgMnJY013RaCkQ/RY6OjrIzMyk8tr1ey1YsABeXl5U3Eu4efMmPDw8hLb37NkTrq6uBBKRwc4horHvHNFOnTqFmJgYXLt2DcOGDYOjoyP09fXRr18/aGpqUrsGgxH0tbUbPB6PykESM2fOxOLFiwVqfQwNDaGtrU1VLUtNFhYWIouNi4qKYGFhwRUbL1y4kEQ8sautgXtpaekPcz+SFV9/h6/pntSwYUMoKipSU2xcVyeP58+fw8HBAVu2bKn3k1Q+9+nTJwBAREQEIiIiRL6Gx+NxJ9H6zNraGsnJyRg7diwmTZrEFTY9fvwYR48ehZKSEmxsbMiGFLPamhbIycmhU6dO2Lt3L3XTNdevX48xY8bg2bNn8PLywrRp09C0aVPSsSTC7du3v+p17Adf7Tp06IBGjRrh3bt39br4etCgQXXeMNHR0YGOjo4YE5G3dOnSWvfxeDwYGhrCy8sLjRs3FmMq8saMGYMPHz5g9uzZXOdLUde5dTUdqk/2799fa8MPWVlZuLq6Yty4cWJOJRmaNWvGLaho06YN7t+/Dy0tLRQWFuLjx4+E05Fz9epV2NjYQFtbG6mpqVi5ciVatWqFu3fvIjY2FkFBQaQjip2SkhJev34NFRUVtG/fHikpKejRowdu3bpF9cKCtLQ0xMTE4OTJkygpKYGlpSW8vb2hrq5OOhoRioqKePfuHVRVVaGsrIybN2+ia9euyMrKomJi4vdQV1eHrKws8vPz63Xx9ZgxYzBmzJha9xsbG8PY2FiMicgzNTUFj8cT+ozweDzIyMhwzVBoKzo2MTHB8+fPMXv2bMydOxeNGzcWeW1CczFcXbp37w4+n4/c3Nx6XbAxbdo0TJs2rdb9CxYswIIFC8SYiLzaGkIWFhYiIyMD/v7+kJKSomrho42NDa5cuYLJkycjJCRE5LRNhqkmJSWF3r17o3fv3qSjSIwmTZqgrKwMANC6dWs8e/YMXbp0AQCqJ7Ky4yJs2rRp8PHxQXl5OXeP+sqVK9i4cSOsrKwIpyPD0tIS69evR0FBgcAxiYyMpHZaD3ufCGPvE9Hs7Owwb948ZGZmYsiQIQCqjsutW7ewa9cuwunIYMdEWGZmJubNmwd5eXm8ePEC06dPR/PmzZGcnIzs7Gz4+/uTjkgEj8cTGppAM3bPWjR2XITl5ORwxW+//vorxo4dixkzZkBbWxtz5swhnE68amtYV1hYiEOHDiEiIgJ79+6lboDRqlWrICsrCyMjI7x8+RIBAQEiX0dbIYKcnByys7OFno1mZ2dTvS6wsLAQMTExePjwIQCgS5cumDJlCvUNIetqgF99X4UmI0eOhK+vL+7duwdNTU2hKYo0DP76p1JTU7k1/PVd27ZtcejQIaxZs0Zg++HDh9G2bVtCqcjKyMhAw4YNoaWlBaDq2u3IkSPQ0NDAsmXLqF3D9Ntvv6FJkybcgIh9+/bh0KFD0NDQwLp166iYwlpt5cqVsLGxQWBgIFtPwNSK1W7Ureba/E+fPkFGRgZA1fdSZGQkqVhE8fl8ke+Ht2/fUlWjUL0mhcfj4fDhwwLrHCsrK5GamorOnTuTivdNWPH1d6htwePneDweunbtig0bNlB3I6mm9u3bY/Xq1VQ++PuaQn1ayMnJ4cCBAwgICMDx48dRWFgIoKqYZ+LEiVi1ahV1F691NS2gmb6+PoCqH78WFhbUvS9qs2fPHtIRfni03DB5//79F18jJSVF1UV8bd/HRUVFSE9Ph6enJ0JDQ7Fq1SoxJyMrPz8fABAeHo6IiAiBa9vqa11amsQAVYteP+829jlab5IMHDgQly9fhpaWFsaPHw9vb2/8/vvvuHz5MreAi0YBAQHcYraaDXN0dHSwd+9egsnIGTNmDK5cuYI+ffpgzpw5cHBwQExMDF6+fAlLS0vS8cQqPz8fR44cQWxsLN6/fw8jIyNERUVh5syZmDJlCrWF10DVZ+Ts2bPo3r07pkyZAl9fX5w6dQrp6el1FtwyVc1AGDqdOXNG5Pbq69mtW7eiWbNmmD9/vpiTkXX//n0Af1/Pfo6269lv1bRpU6p+FzJ/q6thm4GBAVRVVbF3716qiq8vXryIhg0b4sSJEzh58mStr7t69aoYUzE/mnfv3uHcuXMwNTUlHUXs+vTpg7S0NKirq2P48OHYsGED7t27h9OnT6NPnz6k4xHDjoswa2trvH37Fh4eHlxhuoyMDKytranp8v+5qVOnorS0FGFhYfjf//4HAFBVVYW7uzuV5xOAvU9EYe8T0fr374+DBw8iPDwcJ06cgIyMDLS0tODt7c01gqcNOybCfH19YWZmhjVr1gjcxx8+fDjs7e0JJpM82dnZCAoK+uqpTvUJu2ctGjsuwpo0aYK3b99CRUUFKSkp3LMvGRkZaoq7qtV1rqisrISrqys2b96MsLAwMaYib+DAgQCqikdrQ+OaA0NDQ7i4uMDR0ZH7Pr5+/Tr8/f1hZGREOB0Zt27dgrW1NWRkZLgGf5GRkQgNDcWuXbvQo0cPwgnJYA3whbm5uQEAQkJChPaxZ2BMNWdnZyxfvhwXL17kzil//fUXnj59im3bthFOR8a6deuwYMECaGlp4fnz51i5ciXGjh2LkydP4uPHj3BxcSEdkYiNGzdyv4Xv3r0LX19fWFlZ4Y8//oCfnx9VvwenTp2Kffv24Y8//sCkSZNgaGhIVfH5v8HExKTeN9JhtRt1q6ysRGhoKKKjo5Gfn49Tp06hffv22LJlC1RVVetskl/fLFu2DMDfU9Br1qxUVFTg7t27VA3lrB5SyufzER0dLTAYrVGjRmjXrh08PDwIpfs2PD6tLQj/BS9evPjiayorK5Gfn4+IiAjk5eXhwIEDYkgmubKysmBsbIwbN26QjsJIAD6fj4KCAgBAy5Ytqbyp+E9oa2sjISGhXk8jYr6srKwMffr0QXx8PNWNPf6pfv364ejRo/X6c9S1a9evOq82adIEurq6cHFxobbDYbXffvsNPj4+dS6wro++5poWqFrERYMhQ4bAzc0N48ePF9pXUlKCTZs2ITo6Gunp6QTSkfX27Vt8+vQJSkpKqKysRHh4OK5fv46OHTti8eLF1N54rPmdUvO/s7KyMGHCBNy6dYt0ROJu3ryJGzduQE1NDaNGjSIdR6x69+6NcePGwcTEBEOHDuVuIPXo0QMJCQnQ0NAgnJCcyspKVFZWcl25jx8/zr1PZsyYQU3DnH+KhuvZgQMHfvF6VkpKCoqKihg6dCiWLFmCZs2aiSmdZDp58iRCQkJw7Ngx0lHE6muLIOsqNKUdDeeU6kaqdal5TmHfRVWLQ01NTXH9+nXSUcQmLi7uq15nZmb2Hyf5cdFwPvmSzMxMmJmZUbng8fnz5/jw4QO6du2K4uJi+Pn54caNG+jYsSPWrl1Lzb2lz7HjUrsPHz7g4cOHkJWVRceOHan/7q1WUFAAGRmZer9g7Wux94lo7H3CMN+mf//+iIuLQ4cOHQSuWV+8eIHx48ez+/g10Hw9y+5Zi8aOi7DVq1fj8ePH6NatG44fP45z586hRYsWOHPmDAIDA5GYmEg6osTIzMyEtbU1Ll26RDoKIwFKS0vh7++P6OhoVFRUAAAaNmwIc3Nz2NvbU3k+mTVrFtTU1LB+/XruPFteXg5XV1c8f/4c+/btI5yQjBkzZmD8+PFcA/zqa7e//voLy5Ytw2+//UY6IvMDoe2edU5ODvbv349Hjx4BANTV1TFz5kwoKysTTkZGzd+CO3bswB9//IGIiAikpaVh1apVuHDhAumIRPTr1w/Hjh1Du3btsG3bNty/fx9BQUHIyMjAggULkJKSQjqiWJWUlODEiROIjY3Fn3/+CT09PVy4cIGtz/9/hYWFOHnyJF6+fAlVVVWMHz8e8vLypGMxEiQ4OBjx8fGwtbXFzz//jMTERLRv3x5JSUn45ZdfcPDgQdIRxcbJyQlA1bqDCRMmCAxYadSoEVeM3rJlS1IRiZgzZw6Cg4N/6DXmbPL1d/jah+Ht27eHvb09JkyYgIKCAuo+KDXdu3cPKioqpGOIXVRUlMjt8vLy6NixI1XdK/Lz87lpkjweT2iyZHl5OW7fvs113WKEsZ4ZVZ49ewZXV9daP1/1XaNGjaCsrIzKykrSURgJ9TWfjeomMfv27cPPP/+MnTt3iiGZ5OrcuTNyc3NJxxA7mhd4imJjYwNHR0ckJyfDzc2N+7F37do1ODk5oUGDBvjll18IpxS/8vJynD9/Hnp6egCABg0aYMGCBYRTSQZ5eXm8fv1a6EHNnTt3oKSkRCgVOWVlZVi3bh2WLFnCHZO+ffuib9++ZIMRoqKigrS0NKioqEBFRYXqSdc1lZeXIywsDFOnTuWavxgZGVHb1Z4RzdnZ+Yuvqb6ePXLkCF69eoXNmzeLIZnk6tGjB7KyskjHEDtWVM18DQMDgy++pvqcEhoaiocPH8Ld3f2/DybBioqKqHtwzoqqvx8N3e3fv3//Xfvrq4qKCuTk5EBLSwtAVcNHT09PwqnIY8elbk2bNmXPA0WgeS2BKOx9Ihrt75Nv+b6Vk5P7D5NIDnZM6iYtLS3yGD158oS6z9OZM2fq3P/8+XMxJZEs7J61aOy4iObm5oYtW7Zwk+JbtGgBAMjIyKD+2HyucePGKCkpIR2DkRDS0tJwdXXF6tWruangHTp0QOPGjQknIyc9PV2g8BqoKki3trbGlClTCCYj6969e9i0aZPQ9pYtW+LNmzcEEkmmwsJC6htTM8Latm2LVatWkY4hMfh8PrfG+sqVKxgxYgQAQFlZmerzSaNGjbhrtMuXL8PU1BQAoKCgQOUzDllZWZiZmcHMzAxPnjzBkSNHkJ6eDnNzc4wYMQLjxo3D2LFjSccUm2XLlmHixIkYP3487t+/jzlz5oDH43FN7LZu3YpffvmFrYFjOAkJCVi/fj03+KqalpYW1wyEFr6+vgCq1uVbWVmhSZMmhBNJhvowPZ4VX4tJu3btICMjgw8fPtTrG/e1XXAVFRUhIyMDfn5+3AUaTXbv3i1ye1FREYqKitCvXz+EhoaiefPmYs1Fgp6eHi5dusQVXRsbG2PHjh1cV623b99ixowZVHbRZb5NcXExUlNTSccgatGiRdi8eTP8/f2pOH8w3+ZbChC0tLRgampK/U3Z58+fo02bNqRjiF1tiyyqm8TQdkysrKygr68PR0dHGBkZwdXVFdeuXcOBAwe4jss1u5HRomHDhnBzc0NSUhLpKBLHyMgImzZtwtatW8Hj8VBZWYm0tDRs2LCByt8+jRo1QnJyMpYsWUI6ikQ4efIk0tLSEBMTg6lTp6JTp04wMTEBgC9O36zPGjZsiIiICCo/I8zX+5YCuKFDh2Lq1Knw8vKi+sZ1Xl4et9CPJpmZmSK3y8vLQ0VFherzLfO3ZcuWffVrJ06cCAsLCzg7O1M5bQWoaqgTERGBPn36kI4iVrU932jcuDGkpKTEnEYyPHnyBEFBQfD09BQq0ikqKoK7uzvs7Oy4xkseHh4kYorVgAED6vxu4fP5VH73SElJwcrKCklJSVTfX/wcOy5/+5bv4uDg4P8wieQwNTX96vNFXFzcf5xGMrD3iTD2PhHtS9/HNdGy7oAdk7qNGjUKISEh2LJlC7ft5cuX2LRpE1ULqAFg6dKl4PF4dTb9p/F6lt2zFo0dF9GaNWuGdevWCW23tbUlkEaypaSkoGPHjqRjiF1t17XVazBonHRWU+PGjbkmZbSTk5NDdna2UPFSdnZ2vW9wWBfWAF/Yjh070K5dOxgaGgKo+s5JTk5G69atsXPnTnTt2pVwQkZSFBYW4q+//kJ+fr7QNT+N13Q9e/ZEaGgohgwZgtTUVK7xclZWFhQVFcmGI0hbWxu+vr7Q1tbGrVu3uN/KT5484Zou0apjx45YtWoV7OzscP78ecTExGDFihVU3Uu5evUqVq5cCQDw9/fH0KFD4evrC2lpaZSVlcHd3R0+Pj6IiIggnJSRFLm5uejQoYPQdj6fj/LycgKJyPuWZx00qJ4IXpvqonVJxoqvxYSWhTl1PdDh8XiYOnUqlRPyzp49W+u+58+fw8HBAVu2bKFimsrnP+aysrKEvlTZZGcG+PLUXhqn035u3759ePr0KYYNGwYVFRWhIgOaFlkw36dDhw5o1KgR3r17R+0iwDt37sDf3x/Dhw8nHUXsli5dWus+Ho8HQ0NDeHl5UdVtWENDA4cOHYK9vT1WrlwJWVlZREZGUj9VsXfv3rhz5w6blv6ZlStXwtPTEyNGjEBFRQWMjIxQUVGBiRMnYvHixaTjEWFgYIAzZ87A0tKSdBSJ0L9/f/Tv3x+urq44fvw4jhw5goqKCri7u8PY2BgGBgZULrDQ0dFBamoq2rVrRzoKUw+oq6tDVlYW+fn51BZfFxQUYOvWrRg8eDDpKGJXXYzw+f0kHo8HGRkZzJ07F7a2ttTcn/0naFxUXZfu3buDz+cjNzdXaHFXfVLbA7+ioiI8ePAAPB4P+/btE3Mqsmp7viElJQVVVVXMnz8f06dPJ5CMnIiICLRt21bkdER5eXm0bdsW4eHhVBRdV2vatCkWLVpUa3OCp0+filyET4MuXbogKyurXp87/wl2XKrIy8tz/83n83H69GnIy8ujZ8+eAKqmBBYWFlJVAGdgYMD996dPn7B//35oaGigb9++AIA///wT9+/fx6xZswglFD/2PhHG3iei1XyO/OLFCwQEBMDMzIw7Ljdv3kRcXBxWr15NKKH4sWNSt7Vr18LW1ha6urr49OkT5syZg7y8PPTt25dbUEyL1q1bw83NTeD8UtOdO3cwefJkMaeSDOyetWjsuIh27do1REdHIysrC1u3boWSkhLi4+PRrl07DBgwgHQ8samt0Xv1oJ6YmBh4eXmJORV5Na9rayosLMShQ4cQERGBvXv3QlNTU8zJxI81WKqboaEhXFxc4OjoiH79+gEArl+/Dn9/fxgZGRFORw5rgC8sOjqamwaekpKCK1euIDw8HCdOnIC/vz927dpFOCEjCc6ePQt7e3sUFxdDTk5O4HkHj8ej8vPj7OwMBwcH/Prrr1i0aBHU1NQAAKdOneLOuzRat24dPDw8cOrUKbi5uXGNLX777TcMGzaMcDrxSkpK4hpb1NSgQQOMGjUK+vr61K3/+/TpExo1agSg6h7Bjh07uIbljRo1grW1NaZNm0YyIiNhNDQ0cO3aNaF1xSdPnkS3bt0IpSJr1KhRda7Dqe23dH1VWFgo8Hd5eTnu37+PwsJC6OjoEEr1bVjxNfOvqq1YUk5ODmpqalR3Y6tN+/btsXr1ajg7O5OOIjHYgk8GAHx8fNC6dWvuAv5zZWVlYk4keWp7IMp82YABAyAjI0M6hsSgZZLXwIEDRX7HFBcXo6KiArq6ulR2o65tUmBRURHS09Ph6emJ0NBQrFq1SszJyCkrK8O2bdtw+vRpGBoa4uLFi9i+fTs6dOhAdXdHc3Nz+Pn5IScnBz169BAqyKe1k660tDS8vLywdOlS3Lt3Dx8+fED37t2p7OJeTU1NDSEhIbh+/brI94qFhQWhZGQ1bdoU06dPx/Tp0/Hw4UPExMRgy5Yt8PDwQEZGBul4Yqevr4+AgADcu3dP5Ptk9OjRhJL9GFRVVdGwIbutV01WVpZ0BLGobeJZUVERcnJy0KlTJ2zcuJFAMrLqWuCXnp6OrVu3olmzZpg/f76Yk/04WCNEQU2bNqWi+VRti0Dbtm2LsWPHwsTEpNbX1Fe1Pd8oLCxERkYG/P39ISUlhSlTpog5GTlXr16t87tlwoQJ1BXwdO/eHQBqbdDWrFkzas+rdnZ22LBhA1asWIEePXoINcURVcRPA3ZcqtTsWr9x40ZMmDABHh4eXIOciooKeHh4UPUsuWYRgouLC+bMmQM7OzuB1wQFBSE7O1vMychh7xNh7H0iWs3v4blz52Lt2rWYOHEit2306NHQ1NTEoUOHYGZmRiKi2LFjUjd5eXlERkYiLS0NmZmZKC4uRo8ePaCrq0s6mtj16NEDGRkZta41+NJU7PqM3bMWjR0XYadOncKaNWtgbGyMjIwMlJaWAgDev3+P7du3U1V8XVuj96ZNm6JTp07w8vKisoC0rqldlZWVcHV1xebNmxEWFibGVGTQdn/xW61Zs4b734qKCgBAw4YNYW5uDnt7e5LRiGIN8IXl5eVBWVkZAHDu3DlMmDABenp6UFVVpa5h6LdatGgRFBQUSMcQiw0bNmDKlClYtWoVFc+5vkbXrl1x7Ngxoe1r1qxBgwYNCCSSDCoqKti+fbvQdhprWRwdHaGgoIChQ4cK7auoqMDKlSupmnoNAFpaWvj999/RoUMHtG7dGi9fvuSejQHAy5cvqVmjw3ydJUuWYO3atcjNzQWfz0dycjIeP36M+Ph4kecaGsydO1fg7/Lycty+fRuXLl2icu1SSEiI0LbKykq4u7v/MM2reXxa75gS0K9fPxw9evSHeXOIg7u7O2xtbamc8lVTVlYWjI2NcePGDdJR/nNdu3ZFSkoKWrVqBUD4c5GXl4dhw4ZRd6H6LbS1tZGQkFDvzyWjRo2Cvb29yI5SwN8dl9l7hWH+HTRcp9Q2DV5OTg6dOnWChoaGmBP9GH777Tf4+Pjg5MmTpKOIxZ07d7BmzRoUFxfD29sbOjo6yM3NhaurK27cuAFHR0dqO/eJKq6uXoTD4/HYd/IX0HINB1Rdx9WGx+NR17mvLuXl5Th79ixVE5uq1dWwgZ1TmH+ChuvZ2qY+VF/P6unpsenOIpw8eRIhISEiH6zThs/no7Kykr1PvgIN55RvlZaWhl69elHTwE2UmJgY7Nu3r9b7C/VR7969ceLECaFO5dVevHgBQ0ND/Pnnn2JORs6hQ4dQUlJSa1OpvLw8REdHf9Nkp/qi5jV+zYYxtN83YMdFmI6ODvbv34/OnTsLbH/06BHMzc3xxx9/EEpGTv/+/REbGyvUzO/JkyeYMmUK0tLSyAQjiL1PhLH3iWh9+vRBQkKC0HF5/PgxTE1NqbpOqcaOyT9nbGyMHTt2cIUt9dG1a9dQXFwMfX19kfuLi4uRnp5ea7Oh+ozdsxaNHRdhpqamsLS0hKmpqcA9pNu3b8PGxgYpKSmkIzISLjMzE9bW1rh06RLpKIyE+PjxI549ewYA6NChAyua/H8vX77E/fv3WQN8AHp6eggKCoK2tjbGjRsHOzs7TJgwAY8ePcLUqVNx/fp10hHF4lvWmtDYIKZv3744duwYe7ZVQ3Z2Nng8Hjds5a+//sKxY8egoaGBGTNmEE5HTkZGBho2bAgtLS0AwK+//oojR45AQ0MDy5Yto+pZ4C+//IItW7Zg9+7d6NOnD7e9srISK1asQFpaGn755Rd06dKFYErxOn/+PBwdHeHo6Aigap3K4sWLoa6ujsePH2Pbtm0wNDTkmsgwDFB1vykkJIRreti9e3csXboUenp6pKNJlH379iE9Pb3Ohl00efToESwsLH6I38ZsRA5D1NGjRzF//nzqi6/v3bsHFRUV0jHEgsfj4cOHD5CRkeEWlnz48AHv378HAO5/mdrR0jOjZ8+eyMjIqLX4muaOyzUVFhbi1KlTePbsGebPn4/mzZsjIyMDioqKUFJSIh1PbMrKyhAYGIjTp09DQUEBM2fOxNSpU7n9rLEDA+CbO/nv2LEDM2fORLNmzf6jRD+Gzp07Izc3l3QMsZk2bRrMzMywdu1aboKKkpISdu7cicOHD8PPzw/JycnYuXMn4aTixwpmv099v255//49N63r7NmzhNP8WHr27Ek6AhGZmZmkI/xQMjMzYWZmxq5nKfetRVyJiYkYNWqU0HRF2vTo0QNZWVmkY4hVeXk5tm3bhrS0NAwaNAi2trYIDw9HcHAwysvLYWRkhPXr11P14Jz5fjY2NtQ0E6rNoEGD4OPjQzqGWMnLy+PZs2e1Fl8/e/aMmqm91b40SUZRUZHKwmug9unxtGPHRVhFRQUePXoksqi2srKSUCqyZGVlcf36daGF5NevX4eMjAyZUISx94kw9j4RrW3btjh06JDQgs/Dhw9zi6tpw47JP5eVlYXy8nLSMf5TX5rI26RJE4HC65ycHLRp04aKqXDsnrVo7LgIe/z4scjPkry8PAoLCwkk+nHQ0OTiazRu3BglJSWkYxBTUFCAR48eAahaj0L72mGg6j1RXQDH/E1FRYWaddVfMnbsWNjb20NNTQ1v377lGuncuXMHampqhNOJz9KlS7/qdbQ2iNHT08OtW7eofo7zudWrV2P69OkwNTXF69evMW/ePHTp0gXHjh3D69evqb2Xv27dOixYsABaWlp4/vw5Vq1ahTFjxuDkyZP4+PEjXFxcSEcUm7lz5+Ldu3dYsGAB9u7diy5dunATr69du0Zd4TUAjBgxAp6envDx8cGrV6/A5/Px888/AwCkpaUxc+ZMrF69mnBKRtIMGDAAkZGRdb6GrWEC9PX1ERAQwIqv/9/z589/mHuxrPiaIaq+FyBUq62guKioCBkZGfDz84Opqal4QxHC5/Mxbtw4gb9rFsNVF2Qztdu5cycVRbW2trb4+PFjrfvV1dWpLwLLzMzEvHnzIC8vjxcvXmD69Olo3rw5kpOTkZ2dDX9/f9IRxSYsLAwJCQmwsrJCYWEh/Pz88Ndff8HT05N7DS3fOcy/JywsDBMmTKC++Pr58+do06YN6RhiExISguHDh4vcN23aNOjq6sLV1VXMqcgxMzPD7t27oaCggLi4OMyfP591WWZEGjhwIC5duoRWrVrBwsICwcHB1J8/v8aDBw+oKqgdNGgQTp48iZYtW8LJyQkuLi7UFet8D3Y9y3yrdevWoU+fPlQ/uACqmnG1aNGCdAyxCg4ORkxMDIyNjXHq1Cnk5+fjwoUL8PT0RGVlJTZv3oxffvkFNjY2pKMyPxD2PVR1P19eXp50DLEaMGAA9u7diyFDhojcHxUVhf79+4s51Y+lvi8sX7ZsGfz8/CAnJ4eXL1/C0NCQNfcAOy5fMnnyZLi4uOD58+fo1asXgKqpMzt27MDkyZMJpyNj7ty5cHd3x+3btwWOSWxsLJYsWUI4HRnsfSKMvU9Ec3Z2xvLly3Hx4kX07t0bQNVxefr0KbZt20Y4HRnsmDD/JkNDw3rdiIvdsxaNHZe6KSoq4tmzZ2jXrp3A9rS0tHr7Wfm30NDk4mukpKRQOcG3uLgY69evR0JCAtdQSUpKCpMmTcLPP/9MzTqEbyn0Cw4O/g+TSC4+n4+TJ0/ijz/+QEFBgVADLhqPi5OTE1RVVZGdnQ0HBwdumMTr168xa9YswunEhzWFqdvw4cOxceNGPHz4EJqammjYULBMiMZp4Pfv3+d+F584cQJdunRBdHQ0Ll26BDc3N2qLr588eYJu3boBqDouAwcOREBAANLS0rBq1Sqqiq+BqnqFd+/ewcrKClFRUdiyZQuuXr2K3bt3Q1NTk3Q8IsaNGwcDAwNkZGQgKysLlZWVaN26NXr06MF+GzL/GFvDBJw8eRLNmzcnHUPsPi825/P5eP36Nc6fP//Ng/VIYcXXYmRiYsL94GHoMmDAgFoLink8HqZOnYoFCxaIORUZrMO/aA8ePMDevXtx8+ZN5OXlAai6Wd+3b1/Mnj0bGhoa3Gu/1Im4vqj5bxalUaNGAhNX0tLS0KtXL6oWMPn5+cHMzAxr1qxBv379uO3Dhw+Hvb09wWTid+zYMXh5eWHkyJEAqhbl2NjYwMnJiZtIxBo7MN+KLSyv6pDq7+9fazFyffSlf6uqquoXO7TVJw8fPsTHjx+hoKCAkJAQmJubU/PQk/k2TZo0wdu3b9GqVStcvXqVLZxgRCorK8OHDx/QsmVLxMfHw8HBgXQkifGlh3pFRUXsepb5Zux6tmqCxtatWzF48GDSUcQqMTGR+41sbm6O8ePHIyAgAIaGhgCqOlKHhoay4us6sHMu87mysjJERESgT58+pKOI1cKFCzFjxgzY2trC2toanTp1AlA1dTQ8PByXLl1CdHQ04ZSSrb4vLD9//jyKi4shJycHJycnDBs2DK1atSIdizh2XOrm6OgIRUVF7Nq1C69fvwYAtG7dGvPnz4eVlRXhdGQsWLAA7dq1Q1RUFI4ePQqgagKcj48Pdw1HG/Y+EcbeJ6INHz4cycnJOHDgAB4+fAgAGDVqFGbOnFlvm598CTsmzL+pvt9fYvesRWPHpW7Tp0+Ht7c3fHx8wOPxkJubixs3bmDDhg1UN0Rh/lbbMJHqQT0xMTHw8vIScyry/Pz8kJqaitDQUK6ZX1paGry8vODn5wcPDw/CCcWDtuaO/4S3tzcOHjyIwYMHQ1FRkd2vR9Va2fnz5wttt7S0FPh7wYIF8PLyomrIBvO36sm0ISEhQvtonQZeXl7OrSm/fPkyRo0aBaDqfkr1/SYa8fl8rrHFlStXMGLECACAsrIy3rx5QzAZOT///DPevXuHSZMmoUmTJti9eze6du1KOhZRUlJS6N27N9fAgGG+V32/x1STqampwDUsn89HXl4eCgoK4ObmRjAZGbdv3xb4u0GDBmjZsiXWrl2LKVOmEEr1bVjx9Xfi8/nIysqCsrIyGjZsiNLSUvz6668oLS2Fvr4+WrZsyb2WlpsDjLDaCo7l5OSgpqZGVVH+oEGDSEeQOBcuXMDSpUvRo0cPjB49mluAk5+fj5SUFJiZmeF///sfhg0bRjipZLOxsanXHZdFuXXrlsBk52pKSkrU3RjIzc1Fly5duL/V1NSwZ88eWFhYwMHBgT0M/AoDBgyAjIwM6RgMAQMHDhT5oKK4uBgVFRXQ1dWFra0tgWRkbNmyBcuWLRPq/lnt5cuXcHFxoaYAu1u3bnByckL//v3B5/MRERFRa+c5WruBMlV0dXVhYWGBzp07AwCWLl2KRo0aiXwtTQ2ZvtSZr6SkRExJJEPfvn2xZMkS9OzZE3w+H15eXrVef3ze8bC+O3fuHHR1daGoqChyf0VFhZgT/XhUVVVr/f5m6rfPH1pUKyoqQk5ODjp16oSNGzcSSEbOq1evuIfBampqaNSoEbS0tLj9vXr1wosXL0jF+yHQ9OCP+Vttv2mKiorw4MED8Hg87Nu3T8ypyOrevTuCgoLg7OyM06dPc9v5fD5atGiBLVu2oEePHgQTMqR16tQJmzdvxuDBg8Hn83HixIlapx6YmpqKNxxB7LjUrUGDBrCxsYGNjQ3ev38PACKPD21Ndw0NDb9YQJuYmIhRo0ZRMRmCvU9EY+8T0dq2bYuVK1fW+Rp3d3fY2toKrOGpz9gxYZivw+5Zi8aOS90WLFiAyspKWFpa4uPHj5g9ezakpaVhZWWFOXPmkI7HSIClS5eK3N60aVN06tQJXl5eMDIyEnMq8k6dOoWgoCCBZqnDhw+HjIwM7OzsqFlfTeN581sdPXoUwcHBVA2K+Lekpqbi06dPpGP8Z75lrYmFhcV/mEQyscngwjQ0NBAdHY0RI0bg8uXLsLOzA1D1LJXGyaPVevbsidDQUAwZMgSpqalwd3cHUNVMtrY1K/VVze9lBQUF8Pl8dOvWDXFxcQKvc3JyEnc0ifXu3TucO3eOymcbDPO1DAwMBP7m8Xho2bIlBg0aBHV1dUKpyNmzZw/pCN+NrUj8Do8ePYK1tTWys7PRvn17REREYMWKFXj8+DH4fD5kZWURHR2Njh07ko7KEPatBcf1+SFXZWUlwsPDcfbsWZSVlWHIkCFYtmwZZGVlSUcjJiAgADY2NlixYoXQvuXLl2Pbtm3w9/dnxddfQOOiWGlpaW7BSU1Pnjypl+ePuigqKuL58+do164dt01JSQlRUVGwsLBgP3y/ws6dO0lHYAhxdnYWuV1OTg6dOnWChoaGmBORFR8fj/Pnz8Pf3x+ampoC+6Kjo+Hv7w9tbW1C6cTP19cX27Ztw7lz58Dj8XDx4kVISUkJvY7H47Hi6y+o792YN27ciLi4ODx79gypqano0qUL1df41R48eAAjIyOBa5SaXr16hSdPnog3FEEbN27E7t278ezZM/B4PBQVFdXrh7/fonPnzhg7diymTZsmcv+dO3dw/vx58Yb6wSQmJpKOwBDy+UOLatXXs3p6eiKvX+ozeXl5FBYWchPNunfvLlCoUlpaWu+vTb5WdWf3z98jN27cIJSIIam2qTNt27bF2LFjYWJiQuVkmpEjR+LcuXO4ePEinj59Cj6fz51f2TU/4+HhAT8/P5w/fx48Hg9btmwR+R3D4/GoWojDjsvXq60oHaCz6e6XrFu3Dn369KGqqBZg75NvRev75EuOHj2K+fPnU/cMtS7smDAMu2ddG3ZcaldRUYHr16/jp59+wvz58/Hs2TMUFxdDXV2dquErTN1Y8ZtoJSUlIgu6WrVqRV3D6s8VFBTg0aNHAKqeGdJ+fSYnJ1fr83WGbrt37/6q1/F4PCqLr2v69OkTG8QDwN7eHsuWLUNERARMTU255tVnz56lepqvs7MzHBwc8Ouvv2LRokVQU1MDUNUopV+/foTTidfn01j79u2L8vJyge3subqg7OxsODk5Uf9sg2HqwtZS1z+s+Po7bNq0CVpaWggNDUVsbCwWLlyIjh074uDBg+Dz+bC1tUVISAh1k1WY71efH3KFhoYiODgYurq6kJGRQVRUFPLz86nu6PfkyRMYGxvXut/IyIgVRTIijRo1CiEhIdiyZQu37eXLl9i0aRPGjh1LLhgBOjo6OHbsGIYMGSKwvboAm8buwmVlZQgMDMTp06ehoKCAmTNnYurUqdz+vLw8DBs2DHfu3CGYkpEEX5rK+rkdO3Zg5syZaNas2X+UiKzExER4enpiypQpWLZsGWxsbJCTkwNnZ2fcunULjo6OmDFjBumYYtO5c2cEBgYCALp27Yrdu3ejVatWhFP9mOp7oxhZWVmYm5sDANLT02Fvb19vzxPfokuXLujduzdmzZolcv+dO3dw+PBhMaciR1FREfb29gCqrmX9/f3RokULwqkkQ8+ePYUe6tQkLS3NFVEyVTIzM2FmZsauZ5lvfmhBwxQ4dXV13L59m5t2HR0dLbD/3r173EN0WpSXl2Pbtm1IS0vDoEGDYGtri/DwcAQHB6O8vBxGRkZYv349NRMT/wkaFhZ86z1qGiZt3rhxA2/fvsXIkSMxZswYAEBcXBx8fHzw8eNHGBgY4Oeff67Xx4Cpm7a2Ng4dOgSg6r7BqVOn2H0DsOPyb6nv91L+CXZMhLFjIowdE9HYcRHGjgnDsHvWtWHHpXZSUlKwsrJCUlISmjVrRl0jc+a/YWxsjB07dtT750B9+/ZFUFAQ/P39uYLAkpISBAcHo2/fvmTDEVJcXIz169cjISEBlZWVAKrOM5MmTcLPP/+Mxo0bE05IxvLlyxESEgIfHx/W/JERcPbsWdIRJFpFRQXCwsIQHR2N/Px8nDp1Cu3bt8eWLVugqqpaayP4+mzw4MH4/fff8f79eygoKHDbp0+fTu05Fqi6Z33s2DGh7WvWrEGDBg0IJCKnPkxj/beJGgr3LfsZhlbf8tmoq+FsfWFqavrVa0zi4uL+4zTfjxVff4cbN25g165d0NLSgp2dHaKiouDp6YlGjRoBABYsWIDVq1cTTinZTExMWNdHEerzQ66EhAS4ublh5syZAIDLly9jwYIF8Pb2pu6CvZqqqiouXLiAzp07i9x/4cIFqKioiDkV8yNYu3YtbG1toauri0+fPmHOnDnIy8tD3759sXLlStLxxGrJkiVcB9DPKSkpYc+ePbh8+bKYU5EVFhaGhIQEWFlZobCwEH5+fvjrr7/g6enJvaY+f98w/52wsDBMmDCh3hZVysnJwd/fH2PHjoWbmxuSkpKQlZWF3r174+jRo1BVVSUdkRjWofvbPHz4EDExMXB0dAQA7Ny5E0pKSoRTiQe7Mf03bW1tPH78uNb9TZs2xYABA8SYSHKwB6OCPDw8UFFRUet+dXV1dsxEYNezzD9BwxQ4Dw8PNGxY+63/8vJyWFtbizERecHBwYiJiYGxsTFOnTqF/Px8XLhwAZ6enqisrMTmzZvxyy+/wMbGhnRUicXOucJomLQZEhKCQYMGYeTIkQCAu3fv4ueff4apqSnU1dURERGBNm3aYPny5YSTMpLgzJkz9bKp8Pdix4VhGIZhfhyenp6sYcpnaGjEVY3dfxWNHRdhXbp0QVZWVr2+H8CIV1ZWFsrLy0nH+M85OzvD2toa+vr63OTRzMxMSEtLY9euXYTTkeHn54fU1FSEhoaif//+AKoaPnp5ecHPzw8eHh6EE5IxYcIEJCYmYsiQIWjXrp3Q844foTiDYUgIDQ1FfHw8HBwc8PPPP3PbNTU18csvv1BZfA1UNbWoqKjAtWvXAFQNImnXrh3hVJIhPT0dDx8+BABoaGigR48ehBORV1BQAABU39MfMGBAnfcC+Hw+VfcKGOZrfemzA/z9+aFh0IiBgQHpCP8qVnz9HYqLi7kuOE2aNEHjxo3Rpk0bbr+ysjLy8vJIxSOGz+cjKysLysrKaNiwIUpLS/Hrr7+itLQU+vr6AhcjtN4coNnLly8xfPhw7m9dXV3weDy8evUKbdu2JZiMHFtbW9jb2+OPP/6Arq4uFBUVAVRNpb1y5QouXryIgIAAwikZSSQvL4/IyEhcu3YNd+/eRXFxMXr06AFdXV3S0cROVVW1zoJIJSUlTJgwQYyJyDt27Bi8vLy4xbGTJ0+GjY0NnJyc4OPjA4Cuh+X/xIABA7huu8zfaFlw37dvX2hqauLKlSto3LgxFi9eTHXhNQDk5ORAXl5eqHlSWVkZbt68iYEDBxJKJjmKi4tx/PhxxMbG4ubNm9DQ0OCKr2kpsH316hWuXLmC5s2bY8iQIQIT8IqLi7Fr165vnlD6I3N1da1zf4cOHagsVi8pKUF6ejqaN28uNBXi06dPOHHiBExNTcmEI4RNixT2pXNFUVERu579AlVV1ToLcGlFw/Vsp06d6txvbGwspiSSIzExkfuNbG5ujvHjxyMgIACGhoYAqs7DoaGhrPgaVZ+RyspKSElJCWy/ceMGoUSSi4bzSWZmJlasWMH9nZSUhF69esHLywsA0LZtW2zbto0VXzMAqp6Liro+q6ysRE5ODrVNZtlxYRiGYRjJcOXKFezevZtbWK6uro65c+cKPFun8ffyl9Dwuwdg96xrw46LaHZ2dtiwYQNWrFiBHj16CDV5pGGC1T/FmlzQTUtLC8nJyTh27Bg3YGPixIkwNjamdrrxqVOnEBQUhMGDB3Pbhg8fDhkZGdjZ2VG7vtrR0REZGRkwMTGBoqIiex7I1ConJwdnzpxBdnY2ysrKBPY5OTkRSkVOQkIC1q9fjyFDhsDNzY3brqWlVetgo/quuLgY69evR0JCAiorKwFUFWNPmjQJP//8M7XTr/Pz82FnZ4fU1FRuAE9hYSEGDx6MwMBA6gqPCwsLERgYiKSkJBQWFgIAmjVrBiMjI9jZ2dXbIUW1adq0KRYtWoQ+ffqI3P/06VOsW7dOzKkYSVVRUYHr169DS0vri5+V+r6GKSoqinQEiVJz3Z+LiwuMjY2ho6NDMNH3qb/vXDFo06YNXr58yT0Ud3BwELjYKCgo4IqzafHo0SNYW1sjOzsb7du3R0REBFasWIHHjx+Dz+dDVlYW0dHR6NixI+moDCEVFRVChWwNGzYU+uFLkwkTJnCTeSMjI/H69WsAQOvWrdG3b1/s2bMH/fr1I5xS8tF4ky07OxvKysoYMGAANQVd/0RpaSn27t2LiIgIpKSkkI4jNrm5uejSpQv3t5qaGvbs2QMLCws4ODjAwcGBYLofw86dO0lHYAhJTEzE+vXr0bVrVyQlJSEmJgZWVlaYNWsWVq9eTV1R/qtXr7BkyRKkp6ejQYMGmDhxItzc3Lgi7Hfv3sHCwoKKbmy1SUtLQ0xMDE6ePImSkhJYWlrC29sb6urqpKOJ1V9//YX58+ejsrIS5eXlUFJSQkhICPd9VFxcjJCQEKqKrxlhjx8/xvz58/Hy5UvweDz0798fmzdv5prZFRUVwcnJicoFWzXdv39fYBK2lJSUwLUdDc6dOyfQoOxzdU0KZ6okJiaSjsBICHZOqbqmrZ6moqamhkaNGkFLS4vb36tXL7x48YJUPCLKy8uxbds2pKWlYdCgQbC1tUV4eDiCg4NRXl4OIyMjrF+/njUIody7d+8EvouvXr0KfX197u9evXohOzubRLQfBg0Ly9+/fw8XFxecO3cOcnJymDFjBpYtW8Y1cSgoKMDo0aOpu2/AjgvDMAzDSI59+/bBx8cH48aNg4WFBQDgzz//xIIFC+Dk5ISffvqJcEKyqq/plZWVhfYlJSUJDCKpj9g9a9HYcandggULAACLFy8WWKtE0wSrr5WXl4fo6Gju2SBrckG37du3o1WrVpg+fbrA9piYGBQUFHCfLZqUlJSIfA7WqlUrlJSUEEgkGS5cuIDw8HC2HpKp05UrV7B48WK0b98ejx49QpcuXfDixQvw+Xx0796ddDwicnNz0aFDB6HtfD4f5eXlBBKR5+fnh9TUVISGhqJ///4AqtZ4eXl5wc/Pj9omF+vXr+cGjFSvbXvw4AEcHR3h5eWFzZs3E04oPm/fvsWMGTPw6tUrGBsbo3PnzgCAhw8fIi4uDleuXEF0dDRVNWHV59BBgwaJ3N+sWTNqGrUxXyYlJQUrKyskJSV9sfi6vq9h+vwz8+nTJ9y9exf5+flcAxBaFRQUwMbGBi1btoSRkRFMTEy49Ts/ClZ8/R2GDBmCx48fcz/wZs2aJbA/JSWFugv4TZs2QUtLC6GhoYiNjcXChQvRsWNHHDx4EHw+H7a2tggJCcHGjRtJR2UI4fP5WLt2rcCivdLSUri7uwt0kAoODiYRjxhtbW1oa2uTjvFDo/FCftSoUejfvz9MTEwwbtw4qn7cfa60tBTbtm1DSkoKpKWlYW1tDQMDA8TGxiIwMBBSUlKYO3cu6ZhipaioiOfPn6Ndu3bcNiUlJURFRcHCwoLK7o5lZWUIDAzE6dOnoaCggJkzZ2Lq1Knc/ry8PAwbNow9DKXc8uXLcenSJaxatQpz5swBAKxZswYGBgZwcnLChQsX4OfnR1VjlICAADRo0ACHDx9GUVERNm3aBAsLC+zatYv77qHxezg/Px9HjhxBbGws3r9/DyMjI0RFRWHmzJmYMmUKdYXXABAYGAgDAwN4e3ujuLgYmzZtwuzZsxEZGUndb+NqW7ZswbJly2rt2vjy5Uu4uLggMjJSzMnI2bRpE7p06YKYmBgUFRXBx8cH5ubm2LNnD9UT365duwZfX1/ExsYCAKZPn46SkhLu/Mrj8RARESEwiae+69y5M8aOHYtp06aJ3H/nzh2cP39evKEkXGZmJszMzNj1LMPOKSLIy8ujsLCQW0jevXt3gSlEpaWl1DX2Cw4ORkxMDIyNjXHq1Cnk5+fjwoUL8PT0RGVlJTZv3oxffvmFTQOnnKKiIrKysqCsrIzS0lLcvn0btra23P4PHz6gUaNGBBOSxaYnVtmyZQsyMzPh7++PoqIihIaG4vbt29i2bRv3LIjG+wbsuHw/2r6bmX+GvU8Yhvka27dvh5OTE2bPni2wXVtbG2FhYVQWX5eXlyM4OBh79uxBcXExAKBJkyaYPXs2li1bxl3niyrIrm/YPWvR2HGpHZtm9fXy8vJYY2aGc/DgQWzatEloe5cuXbBy5Uoqi6/79u2LoKAg+Pv7c0MASkpKEBwcjL59+5INR1Dbtm0F7t8zX2/RokXUrCENCAiAlZUVbG1t0a9fP2zbtg0tW7aEvb09hg0bRjoeERoaGrh27RpUVVUFtp88eRLdunUjlIqsU6dOISgoCIMHD+a2DR8+HDIyMrCzs6O2+PrixYuIjIwUWNumoaEBNzc3WFlZEUwmfiEhIZCWlsbp06eFGqLY2trCysoKISEhcHZ2JpRQ/IyNjetsAqOoqMiu7xkBXbp0QVZWFtq3b086isT47bff4OjoiDdv3gjto7FpW2hoKN69e4eTJ08iMTERkZGR6Ny5M4yNjTFx4kSBWhdJxYqvv4Onp2ed+ydMmEBdd8cbN25g165d0NLSgp2dHaKiouDp6cndlF+wYAFWr15NOCVDkqmpqdBDcBMTE0JpJE9RUZHA5Gt5eXnCicirXhxcXZz/4sULnD59GhoaGtDT0+Ned+PGDVIRiYmNjcWxY8cQEhKC9evXY9iwYTAxMcGoUaOom0q0detWHDx4ELq6urh+/TpWrFiByZMn4+bNm3BycsL48eO5iSK00NHRwbFjxzBkyBCB7dUF2NVFpTQJCwtDQkICrKysUFhYCD8/P/z1118C13RswSPz+vVrxMXFoWPHjgLbtbW1kZCQgE2bNmHOnDlIT08nE5CAy5cvIyQkBL169QIAREdHw9bWFnPnzsXu3bsB0LnIceTIkRg3bhxcXFwwdOhQNGjQgHQk4jIyMrBu3To0aNAAcnJycHd3h4qKCiwtLREeHk7lYpz4+HicP38e/v7+0NTUFNgXHR0Nf39/6pow3bhxA5GRkWjZsiVatmyJsLAwuLu746effkJUVJRAUy6a7N+/H5MmTRLYFhUVBRUVFfD5fOzZswcHDhygqlCyZ8+euH37dq37paWlqVj8+a3Y9SwDsHOKKOrq6rh9+zY37To6Olpg/71796CmpkYiGjGJiYnw8vLCyJEjYW5ujvHjxyMgIACGhoYAqs6zoaGhrPiacvr6+ggICIC9vT1+/fVXyMrKctMhAODu3bvUPkhn0xP/dubMGfj5+XEL2EaPHo2FCxdi8eLFCA0NBUDnfQN2XETj8/nIzs5Gq1atuIXldb2WEaSqqlprgzdasfeJMPY+Ec3ExARNmzYlHUOi0HRMioqKRBZgDB06VGQRGA3Wr1+P06dPw8HBgSvuunnzJoKDg/H27VuqihDYPWvR2HGpXW0T4GiUmZlZ5/5Hjx6JKQnzI3j9+jVat24ttL1ly5bceknaODs7w9raGvr6+tzkt8zMTEhLS2PXrl2E05Gzdu1abNy4ER4eHj9EIcZ/5cyZM9DX10ejRo1w5syZOl87evRoAMDChQvFEU0iPHz4kJvO27BhQ5SUlKBp06ZYsWIFlixZIjRQjwZLlizB2rVrkZubCz6fj+TkZDx+/Bjx8fHYvn076XhElJSUCBXUAkCrVq3qLC6t7yorK0U21m3YsCF101nPnDkDDw8Pke+T1q1bw8HBAe7u7lQVX0+fPr3O/az4mvmcnZ0dNmzYgBUrVqBHjx5o0qSJwH4am+p4eXlh/PjxWLp0qcjzC40UFBQwY8YMzJgxAzk5OUhMTERsbCyCgoLqXB8oKdgTl/8QjQtOiouLua5ZTZo0QePGjdGmTRtuv7KyMvLy8kjF+2HU54dcfn5+pCNIpMOHDyMyMhKPHz8GULVQgMfjoVOnTpg3b16tk75osGTJEowZMwbm5uYoLCzE9OnT0bBhQ7x58wZr166l8iZJte7du6N79+5Ys2YN/vjjDyQmJmLdunVwdXXFmDFj4OvrSzqi2Jw8eRIbNmzA6NGjce/ePZiYmKC8vBxHjx6lcgEbUPXZqe1BlpKSEvbs2YPLly+LORVZx44d4xaWA8DkyZNhY2MDJycn+Pj4AKBzwSMjaP/+/bUW0crKysLV1RXjxo0Tcyqy3r9/j2bNmnF/S0tLIzg4GCtWrICFhQU2btxIMB05KioqSEtLg4qKClRUVKicdC3Kp0+fBP5esGABpKSkMH/+fO5cS5PExER4enpiypQpWLZsGWxsbJCTkwNnZ2fcunULjo6OmDFjBumYYlVSUiKwAJjH48HDwwOenp6YPXs2AgICCKYjJz09HYsWLRLY1rZtW64r9aRJk6jr+O/h4YGKiopa96urq+Ps2bNiTETelx5gFRUVsetZBgA7p4ji4eFRZwFKeXk5rK2txZiIvFevXnEL+tTU1NCoUSOuOB0AevXqhRcvXpCK90Og4Zy7YsUKLF++HLNnz0aTJk2wYcMGgaaPsbGxAg0yacKmJ/6toKBAoNlWy5YtERkZCWtra9jY2MDLy4tgOnLYcRGNz+dj7NixSExMFGp++Dkam+5+SWJiIukIEofG98mtW7fw8OFDAFW/jaubZlaj7X1SWVkp8p5+ZWUlcnJyuHMxTYWkn7OwsICvr6/Q9DOajsmoUaNw+vRpod99Z86cwYgRI8iEIiwxMRGbN2/G8OHDuW1du3aFsrIyVq1aRdX7g92zFo0dl7q9e/cOMTEx3HeyhoYGJk+ejObNm5MNJmbVQ1hENcSp3k7D/RPm6ygrK+P69etC66rT0tIE1hjTREtLC8nJyTh27Bi3xmvixIkwNjaGrKws4XTkODg44OPHjxgzZgxkZWWFCgSvXr1KKJl4LV26FCkpKWjVqhWWLl1a6+tonJ4IVNUolJWVAagqkHz27Bm6dOkCACKnTNLAwMAAYWFhCAkJQePGjREUFITu3bsjLCwMQ4cOJR2PiL59+yIoKAj+/v5cI8iSkhIEBwdzTahopKOjA29vbwQEBEBJSQkAkJubC19fX6FhT/Xdq1evuHOHKJqamtQ2iakpJycHbdq0YcNpGJGq154sXrxY4Pdf9e9BGq9T8vLyMG/ePFZ4LUJZWRnS09Px119/4cWLF2jVqhXpSF+FFV9/p5KSEiQmJiItLQ2vX79GgwYN0L59exgYGFB38QEAbdq0wcuXL7kHWA4ODmjZsiW3v6CggCvOpg2fz0dWVhaUlZXRsGFDlJaW4tdff0VpaSn09fUFjlN9fojxNZ1upKSk0Lp1a+jq6mLUqFFiSEVWeHg4goODMWfOHOjp6XFfsnl5eUhJSYGPjw8KCwsxf/58wknJyMjIgJOTEwDg1KlTaNWqFeLj43Hq1CkEBQVRXXxdjcfjQUdHBzo6OjA3N4eLiwvi4+OpKr7Ozc1Fz549AVT92JWWloalpSXVD3FUVVWFFlHUpKSkhAkTJogxEXm5ubkCN0rU1NSwZ88eWFhYwMHBAQ4ODgTT/TgGDBjwxak0P7I3b9588cccbeeWdu3a4e7duwILYhs2bIitW7dixYoVQoU9tDh58iTS0tIQExODqVOnolOnTjAxMQFA33ukWpcuXXDjxg2uiKfa/PnzUVlZiVWrVhFKRo6cnBz8/f0xduxYuLm5ISkpCVlZWejduzeOHj1a53d1fdW5c2fcunVLqGHBunXrAFTdiKVRTk4O5OXlub83bNggcANWQUEBb9++JZCMnJqFXUyVc+fOQVdXt9ab83UVqzN/o2EKHDunCOvUqVOd+42NjcWURHLIy8ujsLAQysrKAKqa/NXsOl1aWkrtde3XomHSZsuWLbFv3z4UFRWhSZMmkJKSEti/detWoe7ltGDTE/+mrKyMR48eCSyelpOTQ0REBObPn0/tBAR2XERr0KAB1NTUqLsW+acyMzNhZmZG3eKkCxcuIDk5GQoKCpgyZYrAPYR3795h+fLliIqKIpiQjJycHKxatQrXr1/nmmUWFhaiX79+CAwMRNu2bQknFK/379/DxcUF586dg5ycHGbMmIFly5Zx1ysFBQUYPXo0VZ+f2qbhXbt2DefPn+feI9VT8eq7mucJdXV1hIWF4erVq9wC+z///BPXr1/HvHnzCCUkS1paWuQkyXbt2omcgFafsXvWorHjUrvU1FQsWrQI8vLy3DqVPXv2ICQkBGFhYRg4cCDhhOKjoKAABweHWtfJPnjwgNpnyd/C09Pzh1lw/j2mTZsGHx8flJeXQ0dHBwBw5coVbNy4EVZWVoTTkbF9+3a0atVKaMJkTEwMCgoKqGuiWo2m6aJ1yczMFPnfTJU+ffogLS0N6urqGD58ODZs2IB79+7h9OnT6NOnD+l4xAwYMACRkZF1viYxMRGjRo2i4t6+i4sL5s+fD319fW4tU2ZmJmRkZBAREUE4HTnr1q3D4sWLMXr0aO5eQU5ODrp06ULdEJYWLVogKyur1vtqWVlZ1NY+1WRoaIiEhAQqh5MyX0bjvfovGTduHP744w906NCBdBSJ8fvvvyMxMRHJycmorKzEmDFjsH37du63oaSr36vM/mNPnz7FvHnzUFJSAmlpaeTk5GD48OG4desWDhw4gDFjxiAgIKDeL+araciQIXj8+DEGDBgAAEJFkSkpKejevTuJaEQ9evQI1tbWyM7ORvv27REREYEVK1bg8ePH4PP5kJWVRXR09Bc7vNcHNRd+1qayshJPnjzB4cOHYWVlhRUrVoghGTn79u2Dj48PDA0NBbarq6tj8ODB6Nq1K/z9/aktvi4pKeEmwV+6dAljx45FgwYN0LdvX7x8+ZJwOsmQk5ODY8eOITExEffv30ffvn25B160qKioEHgILCUlRcXNoX+qtLQUe/fuRUREBFJSUkjHERtFRUU8f/5cYCGBkpISoqKiYGFhwTV6YOq2c+dO0hH+UxMnToSbmxvGjx8vtK+kpASbNm1CdHQ00tPTCaQjQ19fH4cOHRKa+F1dgL18+XLk5OQQSkdW//790b9/f7i6uuL48eM4cuQIKioq4O7uDmNjYxgYGAg0WarvTE1NcfXqVZibmwvts7GxAZ/PR3R0NIFk5PXt2xeampq4cuUKGjdujMWLF1NZeA0AY8aMwfHjx2Fqaiq0b926daisrKTyfdK0aVM8e/aMK4AbO3aswP6srCyBgjga3b9/X6C4WEpKqs4OxPVR586dMXbsWEybNk3k/jt37uD8+fPiDfUDomEKHDunfBk7p1Tde7x9+zY37frz79979+5BTU2NRDSJw+fzUVlZKVR4TNOkzdru69M20asmNj3xb3p6eoiNjRWYmghUfR+Fh4dTu4CaHZfarV69Gv7+/nB3d4empibpOBKPhmYfNR07dgyOjo4YNmwYHj9+jL1798LLy4trelhWVobU1FTCKclwcXFBeXk5kpKS0LlzZwBV6xCcnZ3h4uJC3aLhLVu2IDMzE/7+/igqKkJoaChu376Nbdu2cQ3daPv8LF26tNbpo+vXrwdA11S83bt3C/zdrFkzPHjwAA8ePOC2ycvLIzY2FkuWLBFzOvJ++ukn/O9//4Ovry/3mSktLUVoaChmz55NOJ14sXvWorHjUjtPT08YGhrC3d2du1dQUVHBTQY/duwY4YTi07NnT7x69arWZ15FRUXUfR9/jby8PERHR3NNuWhpDGltbY23b9/Cw8ODm1YrIyMDa2trLFy4kHA6Mg4ePCiyiV+XLl2wcuVKaouvzczMSEeQKGVlZbC2toaHhwcVa8y/lpOTEz58+AAAWL58OT58+ICkpCR07NgRa9euJZxOsq1btw59+vShYn2tpqYmkpOTcezYMTx69AhA1dpAY2NjyMrKEk5HjrKyMuLi4nD58mXuuKirq0NXV5dwMvHT09PDli1bsGvXLqEBAaWlpdi6davIRry0Ydf0TF0GDRpEOoLEWbduHVasWIG0tDRoamoK1ZRaWFgQSkbGsGHD8O7dOwwbNgyenp4YNWrUDzeUhcdnZ8J/zMbGBsrKyvDw8ACPx8OOHTuQmpqKnTt34smTJ7CysoKZmRmWL19OOqrEeP78OWRkZNCmTRvSUcRqyZIl4PP5sLOzQ2xsLC5duoSOHTti69at4PP5sLW1hby8PHXdgr7k3Llz8PDwqPcLh3v37o24uDihbrHVHjx4gClTpuDPP/8UczLJYGxsjGnTpmHMmDGYOHEiwsPD0a9fP6Snp2PhwoVUFY5+Ljo6GomJibh+/To6d+4MY2NjTJw4kcpCnq5du0JfX5+7EDt37hx0dHTQuHFjgdcFBweTiEdEaWkptm3bhpSUFEhLS8Pa2hoGBgaIjY1FYGAgpKSk8NNPP1F1o97FxQV8Ph8+Pj5C+3JzczFnzhw8f/6cmkUn1crKyhAYGIjTp09DQUEBM2fOxNSpU7n9eXl5GDZsGDXHZdeuXdi6dStGjx4NNzc3rnPhtWvX4OTkhAYNGsDHxwf9+/cnnFR8ysvLUVJSUmuBTnl5OXJzc6n8/hHl4cOHiImJQUJCAt69e4eMjAzSkSRWWloaevXq9cPdSPlWiYmJWL9+Pbp27Qo3NzfExMQgKioKs2bNwurVqyEjI0M6okTLyclBmzZt0KBBA9JR/lOLFi1CixYt4OvrK3L/2rVr8ebNG2zfvl3Myci5du0afH19ERsbCwDo168fSkpKuIc6PB4PERERVD0AdHJygqysLNzc3ETuf/jwIWxsbHD27FkxJ5NsNE4LZOcUYeycIuzx48do2LBhrR3Kjx07BikpKaGGkfVZeXk5tm3bhrS0NAwaNAi2trYIDw9HcHAwysvLYWRkhPXr19f761emdjU7t79//x67du2Ctra2yOmJNBXwvHv3Dq9evaq1icX79+9x+/Zt6hZfsONSu4EDB+Ljx49cU9XPFzpevXqVUDLx+9IE9KKiIly9epWqa1lTU1NMnjyZW3yUlJQEFxcXODs7Y9q0adTdr66pd+/eiI6OFmp2n56ejp9++om6Z8kjR46En58fBg8eDKBq0vXChQvRrFkzhIaGorCwkLr3irW1NaSkpODj4yMwPbNHjx5ISEiAhoYGwXSMJPj8e+fy5cuQlpYWmABXVlaGIUOGUPVc/VvRcs/6W9F0XHr37o34+HiuGUq1R48ewdTUFH/99RehZOJ3+vRpFBcXY9KkSSL3v3v3DmfPnmWFlJ+h8Z51TR8+fMDDhw8hKyuLjh07Un2vrVevXkhKShK6R/v8+XMYGhri1q1bhJKR9+zZM8TGxuL58+dwcXFBq1atcOHCBaioqFDXSBUAdHR0qBnwxfz3+vXrh6NHj7IJtgyDqt8xU6ZMgbS0NGbNmoXOnTuDz+fj0aNH2L9/P0pLSxEbG8s1PacVO28wX3Lt2jVER0cjKysLW7duhZKSEuLj49GuXTtusCtNDh8+DHd3d0hLS6NFixYC+3g8Hs6cOUMoGRmHDh3C+PHj0axZM9JR/jF6RjL/B1JTUxEfHw8ejwcAsLS0RFBQEN68eYOOHTvC2dkZPj4+rPi6Blq/cG/cuIFdu3ZBS0sLdnZ2iIqKgqenJzeldcGCBVi9ejXhlJKnf//+6NmzJ+kY/7levXphx44d8Pb2FupqUlFRgZ07d6JXr16E0pG3dOlS2Nvbw9fXF0OGDEG/fv0AACkpKejWrRvhdGSFhobCyMgIrq6u3ANRWpmamnLfxwC4CQg027p1Kw4ePAhdXV1cv34dK1aswOTJk3Hz5k04OTlh/PjxQhOb6rslS5Zwnfo+p6SkhD179uDy5ctiTkVeWFgYEhISYGVlhcLCQvj5+eGvv/6Cp6cn9xqa+jVZWVlBX18fjo6O3Dn22rVrOHDgAMzNzWFvb09d58uGDRvWORmxYcOGAoXX2traSEhIoPbaX11dHY6Ojli9ejUrfvsCGxubev9eWb58OS5duoRVq1Zhzpw5AIA1a9bAwMAATk5OuHDhAvz8/LhrXEaYoaFhvX+fAFX3lObNm4fmzZvD2tqaWyCbn5+PnTt34ujRo9RNsNq/f7/Qgq2oqCioqKiAz+djz549OHDgAFWFkh4eHgKTej+nrq7OvntqQdP1LMDOKaKwc4qwTp061bmflok7NQUHByMmJgbGxsY4deoU8vPzceHCBXh6eqKyshKbN2/GL7/8AhsbG9JRGULY9ETRFBQUuOZ1osjJyQkUGBsbG2PHjh31frESOy61c3Z2Jh1BYpw7dw66urpQVFQUub+u6//66unTpxg5ciT3t6GhIVq2bInFixejvLwcY8aMIZiOLGVlZZSXlwttr6yspK75PVBVbK2iosL93bJlS0RGRsLa2ho2Njbw8vIimI6M8PBw7N69G1OmTIGbm5vAZ4lhgKpr1ZrGjRsn8DcN1yH/BlruWX8rmo5L9+7d8ejRI5HF17St3fnStZmCggKVhdeZmZl17q9t3QotmjZtit69e5OOIRGUlZVx/fp1oXNnWloaldf41a5evQobGxtoa2sjNTUVK1euRKtWrXD37l3ExsYiKCiIdESxMzExQUxMDOzt7UlHkUgfPnwQehZY1zonpn77loK20aNH/4dJJEvN5rJfQtNE1rZt2yI6OhoeHh7YvHmzQONuXV1drFu3jv1WRlXz97qedzB0O3XqFNasWQNjY2NkZGSgtLQUQFUT4u3bt1NZfL1lyxYsX74cCxYsoKJJ3ZdMnz6ddITvxoqvv4O8vDw+fPjA/V1SUoLy8nKuoFZLSwuvX78mFY+YkpISJCYmIi0tDa9fv0aDBg3Qvn17GBgYYMiQIaTjEVFcXMxdcDRp0gSNGzcWuDmirKyMvLw8UvEkVrNmzajopvvzzz/D2toaQ4cOxcCBAwUWxKampqJRo0bYtWsX4ZTkjB8/Hv3798fr168FHlIMGTIEBgYGBJORd/78eYGCY5r5+fmRjiBxTp48iQ0bNmD06NG4d+8eTExMUF5ejqNHj1L7vlFVVa1zMq+SkhImTJggxkSS4dixY/Dy8uIW4UyePBk2NjZwcnLipoTT9p7R0NDAoUOHYG9vj5UrV0JWVhaRkZFUTiL6J2grbqoLDY2EvgcN75XXr18jLi5OqAN1dZOCTZs2Yc6cOUhPTycT8AdAw/sEqOpW7urqCl9fX+zevRtycnLg8XgoKiqClJQUnJ2dqbunkp6ejkWLFglsa9u2LXc9N2nSJCxYsIBENGJonv5Ql6+ZFkjb9Sw7pwhj55Qvu3//vkCBl5SUFHUTRBITE7nfx+bm5hg/fjwCAgK46d/S0tIIDQ1lxdcUY01O/h1ZWVkiiwdpR9NxobH4ojadO3fG2LFjMW3aNJH779y5g/Pnz4s3FGFNmzZFfn6+QPGBjo4Otm/fjoULFyInJ4dgOrIcHBywfv16rFu3jmvcfevWLXh7e8PR0ZFwOvFTVlbGo0ePBN4rcnJyiIiIwPz587/4W7G+srS0xODBg2Fvb49z587BycmJdCSJ4OvrK3I7j8eDjIwMOnTogNGjR6N58+biDSZmtR0H5tvQcs/6W9F0XCwsLODt7Y2nT5+iT58+AIA///wT+/btg729vUDhLW3F2NXKy8vx6dMnNG3alHQUIqoHSIj6XFRvp+2eNSPatGnT4OPjg/Lycujo6AAArly5go0bN8LKyopwOnICAgJgZ2eHefPmCTQx19HRwd69ewkmI6eiogIHDhzA5cuX0bNnTzRu3FhgP43X/c+fP8f69etx9epVfPr0idtefY69c+cOwXQMSUuXLv2q19H2Pvm8uWxteDweVcXXQNVwyfDwcLx79w5Pnz4FAHTo0AHNmzdHYWEhjh07RmXT6poWLlwIoKqY9ujRo4iJicGRI0cIp2IkRWhoKDw8PGBqaorjx49z27W1tREaGkowGTllZWUwNDRkhdf1CCu+/g5Dhw6Fn58fNw5+8+bN6NatG9ctKTs7myuipMXTp08xb948lJSUQFpaGjk5ORg+fDhu3bqFAwcOYMyYMQgICBCa7lvftWnTBi9fvuQ6Lzs4OKBly5bc/oKCAtYNhmJdu3bFyZMncfToUfz555/IysoCACgqKsLOzg7GxsbUd2Fr3bo1WrduLbCNdcCsWlBx/PhxPHnyBADQsWNHTJw4kcpJ6V9zA5HH43GFpDTIzc3liv40NTUhLS0NS0tL9gCnFqWlpdi7dy8iIiKQkpJCOo5Y5ebmCiyoV1NTw549e2BhYQEHBwc4ODgQTEdGWVkZtm3bhtOnT8PQ0BAXL17E9u3b0aFDB7Rt25Z0POYH8eDBA5iZmVF1o54Rtn///lpvosnKysLV1VVoughDr59++gkjR45EcnKywDX+uHHjoKysjJKSEsjKypINKUY5OTkC03g2bNggMA1OQUEBb9++JZBMcrBCySpsWqBo7JwiiJ1ThF27dg2+vr6IjY0FUNVtuKSkRKCje0REBFXTwF+9esUtilZTU0OjRo2gpaXF7e/VqxdevHhBKh7DMEy9ceHCBTRo0ADDhg0T2H7p0iVUVFRg+PDhhJKJX8+ePXH79u1a90tLS1M3WaV379747bff0LdvX4HtgwYNQlhYmFBDHZo4OTnh48ePmD59OqSkpABU/d6pbrBUc6r81atXScUUGz09PcTGxgqdM5o2bYrw8HCqi1W6deuG2NhY+Pj4wNTUlKqCyNrcvn0bt2/fRmVlJTp16gQAePz4MaSkpNC5c2fs378fGzZswP79+6GhoUE4rXjl5+fj8ePHAIBOnTpRt86NYf6JVatWAQA2btwocl/N4tr6/pzw7NmzePv2LSZPnsxtCw0Nxf/+9z9UVFRAR0cHgYGB1K2LVFBQgIODQ60NMB88eED1dS3zN2tra7x9+xYeHh4oKysDAMjIyMDa2porcqLRvXv3sGnTJqHtLVu2xJs3bwgkIu/evXvo3r07AHDXbtVoXQtYvZ7Nx8cHrVq1ovY4MMJqNsJh/saay36ZgoKCUG3Cy5cvuYm+NPv9998RGxuL06dPQ05ODmPGjCEdiZEgjx8/FjndWl5eHoWFhQQSkWdqaoqkpCT2u68eoasC9l/m4OCAJUuWwMjICDweD8rKygJTegsKCjB//nyCCcXPy8sLenp68PDwAI/Hw44dO5CamopDhw7hyZMnsLKyQmhoKJYvX046qlgNGTJE4Etl1qxZAvtTUlK4H8YMneTk5DBr1iyh9wZTu2fPnsHV1RVRUVGkoxDh7++PXbt2oUmTJlxH96tXryIqKgpWVlbUFUvGxcVBRUUF3bt3ZwsI/l9FRQUaNWrE/S0lJYUmTZoQTEReaWkptm3bhpSUFEhLS8Pa2hoGBgaIjY1FYGAgpKSkMHfuXNIxxU5RURHPnz9Hu3btuG1KSkqIioqChYUFdd1R79y5gzVr1qC4uBjh4eHQ0dFBbm4uXF1dMXHiRDg6OtY6iYZhGOZzb968+eJiNfYQkKlJRUUFlpaWAttKS0sRGRmJ8PBwqprENG3aFM+ePeMKDcaOHSuwPysri7pGZaxQUjQ2LbB27JzyN3ZOEbZ//35MmjRJYFtUVBRUVFTA5/OxZ88eHDhwgKpzSvUD4Or3Sffu3QXeF6WlpezajeGw6YkM889t2rQJ9vb2QtsrKysREBBAVfG1h4dHnc2C1NXVqVsYaWlpiRs3bojcN3jwYISGhiIhIUHMqSRDzeJqBli+fDlevXolcp+cnBx27dpVZ3OD+k5WVhaenp44c+YM/vjjD7Ro0YJ0JKKqr8t8fX25a/yioiK4uLigf//+mD59OlavXg1fX19EREQQTise79+/h4eHB5KSkrjvIikpKUyYMAFubm4CDcwYhhF05swZ0hEkRmRkJMaPH8/9ff36dQQFBcHW1hbq6uoIDAzE//73P+rWHPTs2ROvXr2CqqqqyP1FRUVsbRMDoOo+UvU69IcPH0JWVhYdO3aEtLQ06WhEycvL4/Xr19yayGp37tyBkpISoVRk7dmzh3QEiXP37l3Exsaic+fOpKMw9YCxsTF27NhBXRPEL9HW1kZCQoLQ+ZihQ25uLo4cOYIjR46gsLAQhYWFCAgIwIQJE9jzUkaAoqIinj17JrAGHQDS0tKoPX9UVlYiPDwcly5dgpaWltDwWtp+I9cHrPj6O7Rq1QoHDx7EkydPUFpais6dOwt8KGreWKJFamoq4uPjuS9US0tLBAUF4c2bN+jYsSOcnZ3h4+NDXfG1p6dnnfsnTJgAU1NT8YRhJNbr16/x559/Ii8vD0DVtOfevXsLTXxmqhQXFyM1NZV0DCLi4uKwd+9euLq6YsaMGVyBbVlZGQ4cOIBNmzahS5cuVJ1XzM3Ncfz4cWRlZWHy5MkwMTGhfmEjn8/H2rVruRvypaWlcHd3R+PGjQVeV7NxTH23detWHDx4ELq6urh+/TpWrFiByZMn4+bNm3BycsL48eO5aRE00dHRwbFjx4S6LlcXYM+ZM4dQMjKmTZsGMzMzrF27Fk2bNgVQdSx27tyJw4cPw8/PD8nJydi5cyfhpAxpZmZmde4vKSkRUxJGkk2cOBFubm4i7w+UlJRg06ZNiI6ORnp6OoF0jCRhTWKE9enTB/Hx8Rg8eLDI/XFxcejTp4+YU5HFCiVFY9MChbFzijB2ThGWnp4u1Gm5bdu23KLQSZMmYcGCBSSiEaOuro7bt29z066jo6MF9t+7dw9qamokojESiE1PZJh/7unTp1BXVxfa3rlzZzx79oxAInJoX1AvyqBBgzBo0KBa9+vo6EBHR0eMiSTHl+5H0kZBQaHWKZqFhYVo1qxZne8lWowePRqjR4+mdspMtYiICERGRgo0V5KXl8fy5cthZWWFuXPnYunSpVRNTHd1dcWdO3cQFhaGfv36AQBu3LgBb29vrFu3DoGBgYQTMozkqq2glkYPHjzgziEAcOrUKejq6mLx4sUAqib4ent7U7ewfObMmSguLq51v7Kycq1N3Rg6NW3aVGjSJs2MjIywadMmbN26FTweD5WVlUhLS8OGDRuoWg/J1K1nz57Iyclhxdf/gKqqqlARGO2ysrJQXl5OOobEYc1i6HTq1CnExMTg2rVrGDZsGBwdHaGvr49+/fpBU1OTFV4zQqZPnw5vb2/4+PiAx+MhNzcXN27cwIYNG7BkyRLS8Yi4e/cuunXrBqBqjUFN7DP0Y2JXTv+Cjh07ko4gMeTl5fHhwwfu75KSEpSXl3OFgVpaWnj9+jWpeBKL1o4eTJXi4mKsW7cOSUlJ4PF43EPid+/egc/nw8jICJ6enkIFk/XdlyZa5+bmiimJ5Nm3bx9WrVqF2bNnC2xv1KgRLCwsUFFRgb1791J1s9HNzQ1OTk5ITk5GbGwsNm/ejOHDh2Pq1KnQ09Oj8kLV1NRU4N9tYmJCMI1kOHnyJDZs2IDRo0fj3r17MDExQXl5OY4ePUrle6TakiVL8OjRI5H7lJSUsGfPHly+fFnMqcgJCQmpdbrOtGnToKurC1dXVzGn+rHQ8nl68OABjIyMhDr2VXv16hWePHki3lA/GBreKzY2NnB0dERycjLc3Ny4a/1r167ByckJDRo0wC+//EI4pWSj4X0CsCYxolhaWmLevHlo3rw5rK2tuSny+fn52LlzJ44ePUrNJKJqrFBSNDYtUBg7pwhj5xRhOTk5ApPMNmzYAEVFRe5vBQUFvH37lkAycjw8POpccFReXg5ra2sxJmIkGZueyDD/nLy8PJ4/fy50T+XZs2fUPQurqbKyEk+fPkV+fr7QwsaBAwcSSkUWOybC2DERtmPHDrRr1w6GhoYAgBUrViA5ORmKiorYuXMnunbtSjih+LFjIuz9+/fIz88XaopTUFCA9+/fAwCaNWuGsrIyEvGIOH/+PMLDwzFgwABu27Bhw+Dl5cV+93wBLfesvxVtxyU3NxdpaWkoKChAZWWlwD4LCwtCqcTvw4cPAoMR0tLSBBoSa2ho4NWrVwSSkTVmzJg69ysoKLDGOgxTh5UrV8LT0xMjRoxARUUFjIyMUFFRgYkTJ3LNHWjz6dMn7NmzB3/88YfI34NxcXGEkpHj7e0NNzc35ObmokuXLkL39mn83fO1EhMTSUdgGEaCrVy5EjY2NggMDBRoYscwtVmwYAEqKythaWmJjx8/Yvbs2ZCWloaVlRV1w7+q7dmzh3QE5l/Giq+/Q0ZGBpo1a8YVzsbHxyM6OhrZ2dlQUVHB7NmzYWRkRDileA0dOhR+fn5wd3eHtLQ0Nm/ejG7dunFfvNnZ2dzCNtqUlJQgMTERaWlpeP36NRo0aID27dvDwMBAaNIkQxdvb2/cunUL27dvh66uLrf4taKiAleuXMH69evh7e0NLy8vwknFy8fHB61bt+aaN3yOpgefn3vw4AFGjx5d634DAwNs3bpVjIkkg7S0NCZOnIiJEyfixYsXiIuL4xbhJyYmchNsaeHn50c6gsTJzc1Fz549AQCampqQlpaGpaUldQ+CP6eqqlpnd24lJSVMmDBBjInIqq3wupqqqioiIyPFlObHREvXyy5duqB3796YNWuWyP137tzB4cOHxZzqx0LDe8XKygr6+vpwdHSEkZERXF1dce3aNRw4cADm5uawt7eHrKws6ZgSjYb3CcCaxIiio6MDV1dX+Pr6Yvfu3ZCTkwOPx0NRURGkpKTg7OxM3f0UVigpGpsWKIydU4Sxc4qwpk2b4tmzZ9xk+LFjxwrsz8rKou6BevX04toYGxuLKQnzI2DTExnmnxs9ejR8fHwQEhKCDh06AKiahu3n54dRo0YRTkfGzZs3sXr1arx8+VLodzCPx8OdO3cIJSOHHRNh7JiIFh0djU2bNgEAUlJScPnyZezcuRMnTpyAv78/du3aRTih+LFjImzUqFFwdnbG2rVr0atXLwDArVu3sGHDBhgYGAAA/vrrL6qGbzRv3lzgPlM1OTk5NGvWjECiHwct96y/FU3H5ciRI1i3bh0aNWqEFi1aCOzj8XhUFV8rKSnh4cOHUFFRwYcPH5CZmSkw5frt27fsOVgN5eXl+PTpE3XrlxjmW0lLS8PLywtLlizB/fv38eHDB3Tv3p2qa7XPOTs7IyUlBePGjUPv3r2pfdZTU0FBAZ49eybwvcPj8cDn86n9jTxw4ECR7w0ejwdpaWmoqanBzMwMU6ZMIZCOYSQTGxQnbOrUqdi3bx/++OMPTJo0CYaGhtywEYYRhcfjYfHixZg/fz6ePXuG4uJiqKurs989TL3Ciq+/g5OTE9auXYv27dvj8OHD8PLywrRp0zBp0iQ8fvwYrq6u+PjxI6ZOnUo6qtg4ODhgyZIlMDIyAo/Hg7KyMoKDg7n9BQUFmD9/PsGEZDx9+hTz5s1DSUkJpKWlkZOTg+HDh+PWrVs4cOAAxowZg4CAgDqnajD1V3JyMrZv3w5tbW2B7VJSUtDT04OPjw8WLVpEXfG1iooK7O3tuY7cn7tz5w4mT54s5lSSoUGDBigtLa11f1lZGRo0aCDGRJKn+t/P5/PrnIBWn9W8sVgbHo8HHx8fMaSRDBUVFQINHaSkpNCkSROCiSRfaWkp9u7di4iICKSkpJCOQ0xxcTGSkpLw6dMnDB06lOoHOqI8fPgQMTExcHR0BADs3LkTSkpKhFP997S1tfH48eNa9zdt2lRgYgSN8vPzuWPUqVMnoUZcN27cIBFL7DQ0NHDo0CHY29tj5cqVkJWVRWRkJAYNGkQ6mkR4+vQpnj17hoEDB0JWVpZ7GFotKSkJbdq0IZhQPFiTGNF++uknjBw5EsnJyXjy5AkAoGPHjhg3bhyUlZVRUlJC1cItVij5de7fvy/wO1BKSgpdunQhmEj82DlFNHZOEdSnTx/Ex8dj8ODBIvfHxcWhT58+Yk4lWdj5hKkLm54oLD4+HoaGhkKNUUpLS5GUlARTU1MAgKenJ7WNmutC03FxcHCAtbU1JkyYwN1Dys3NRf/+/bn7S7Rxc3NDz549sWPHDrRu3Zr66zaAHRNR2DERLS8vj/udfO7cOUyYMAF6enpQVVXF9OnTCacjgx0TYZ6envD19cXKlSu5a3wpKSmYmZlxz1Q7d+4Mb29vkjHFavHixfDz84O/vz9at24NAHj9+jU2btyIJUuWEE5HhpOTE1xcXITurxUXF2P9+vXw9fUFQM89a1Gys7MBgDvH1ETTcdm6dSuWLl2KhQsXUr82Z/z48fDx8cHChQvx22+/oXXr1ujbty+3Pz09/YvN7uqjs2fP4u3btwLr2kJDQ/G///0PFRUV0NHRQWBgICtiYZgvUFFRgYqKCukYEuH8+fPYsWMH+vfvTzqKxHB2dkb37t2xefNmtGrViv1GBrB06VKEhoZCX18fvXv3BlDVZOrixYv46aefkJWVBXd3d1RUVFD725BhPrd79+4vvkbU75/6zNPTE87Ozjhx4gRiY2Ph4+MDPT098Pl8VFZWko7HSKCEhASMHTsWjRs3FnpuyjD1Bav0/A5Pnz6FmpoaAGD//v1wcXERuBjt1asXwsLCqCq+btWqFQ4ePIgnT56gtLQUnTt3FigoHj9+PMF05Hh5eUFPTw8eHh7g8XjYsWMHUlNTcejQITx58gRWVlYIDQ3F8uXLSUdlCKisrKx1ujMANGrUiMqL1Z49eyIjI6PW4uvqLnU06tGjB44dOwY7OzuR+xMSEtCjRw/xhpIApaWlSE5ORmxsLNLS0jBixAisW7cOw4YNo/KBV1xcHFRUVNC9e3dqPyuf4/P5WLt2LbcAtLS0FO7u7mjcuLHA62o2jqFBaWkptm3bhpSUFEhLS8Pa2hoGBgaIjY1FYGAgpKSkMHfuXNIxxebly5dYs2YNMjIy0LdvX3h7e2PevHl4+vQpAEBWVhY7d+7EwIEDCSclq7i4GMePH0dsbCxu3rwJDQ0NbnEsLQXHrq6ude7v0KED9uzZI6Y0kuX9+/fw8PBAUlKSwEK2CRMmwM3NTeQ0jfqsrKwM27Ztw+nTp2FoaIiLFy9i+/bt6NChA9q2bUs6HjFv3rzBypUr8fvvv4PH4yE5ORnt27eHs7MzFBQUsHbtWgD0PMRgTWJqp6KiAktLS4FtpaWliIyMRHh4OFUNYlihpGjXrl2Dr68vYmNjAQDTp09HSUkJ9zuIx+MhIiICurq6JGOKFTun1I6dU/5maWmJefPmoXnz5rC2tuYK/vLz87Fz504cPXoUERERhFOKFzufMN+CTU8U5uTkhGHDhgkVEH/48AFOTk5c8TWNU+SvXLmC3bt34+HDhwAAdXV1zJ07V+B8QtNxkZeXR3R0NFJSUpCZmQlZWVloaWlRfb/t6dOnCAoK4tYeMOyYiMKOiWjNmjVDdnY2lJWVcfHiRe75Kc0NmtkxEVRRUYHbt2/DwcEBTk5OeP78OQCgffv2AhN4unXrRioiEQcOHMDTp08xcuRI7h5sdnY2GjVqhIKCAhw8eJB7bVxcHKmYYhUfHw97e3uh4uuSkhIkJCRwxde03LOuVl5ejuDgYOzZswfFxcUAgCZNmmD27NlYtmwZdw+KpuNSUlICIyMjKtehfG7p0qXIzc2Ft7c3FBUVsXHjRkhJSXH7ExMTMXLkSIIJyYiMjBRYJ3v9+nUEBQXB1tYW6urqCAwMxP/+97+vGqrAMLSo/p79GjR+dpSUlNj0yM+8fPkSoaGh7DdyDWlpabCzs4O5ubnA9ur7cNu2bYOWlhb27NnDiq+Zr0JDU4OzZ8+SjiCRZGVlYWZmBjMzMzx58gRHjhxBeno6zM3NMWLECIwbN05oWABDL19fX7i7u2PUqFEwMTGBnp6ewO9ChqkPWPH1d5CVlcWbN2+gqqqK3NxcrktQtT59+iArK4tQOrJoWkzyNVJTUxEfH89dhFpaWiIoKAhv3rxBx44d4ezsDB8fH1Z8TanqAlFvb290795dYN/t27fh7u5O5Y1oW1tbfPz4sdb96urqOHPmjBgTSQ4rKyssXboUpaWlsLKygqKiIoCqTtS7du1CVFQUdcWj7u7uSEpKQtu2bTFlyhQEBASgZcuWpGMRZW5ujuPHjyMrKwuTJ0+GiYkJmjdvTjoWUaampgI3hExMTAimkRxbt27FwYMHoauri+vXr2PFihWYPHkybt68CScnJ4wfP56qH8IbNmxAWVkZPDw8cOLECcyfPx8dO3bEvn370KBBA7i7u2Pbtm2IiooiHZWItLQ0xMTE4OTJkygpKYGlpSW8vb2hrq5OOhojQVxdXXHnzh2EhYWhX79+AKqmXHt7e2PdunUIDAwknFB87ty5gzVr1qC4uBjh4eHQ0dFBbm4uXF1dMXHiRDg6OmLatGmkYxLh6+sLKSkpnD9/HhMmTOC2Gxoaws/Pjyu+pgVrEiOMNYgRxgolRdu/fz8mTZoksC0qKgoqKirg8/nYs2cPDhw4QFWxJDunCGPnFGE6OjpwdXWFr68vdu/eDTk5OfB4PBQVFUFKSgrOzs4YMmQI6Zhixc4nzLdg0xOF8fl8kYuxcnNzqWvCVdO+ffvg4+ODcePGwcLCAgDw559/YsGCBXBycsJPP/1EOCEZPB4Penp60NPTIx1FIvTu3Vug8TvDjoko7JiINnbsWNjb20NNTQ1v376Fvr4+gKr7crQeK3ZMBElJScHKygpJSUlo3749unbtSjqSRKhuGMRUNZTl8/ng8/n48OEDZGRkuH0VFRX47bffqF57sH79epw+fRoODg7cROObN28iODgYb9++hYeHB9mABEyZMgUnT57EggULSEchTlZWFv7+/rXup7VR9YMHD7hnpABw6tQp6OrqYvHixQAAGRkZeHt7U1lAyjC1uX379le9joZCQFEcHR2xadMmeHh4QFVVlXQciaCjo4PMzEwqf+PU5tKlS7C3txfaPmTIEGzYsAEAMHz4cAQEBIg7GvODYkOfgMLCQhw9ehSzZ88mHYWYjh07YtWqVbCzs8P58+cRExODFStW4M6dO6SjMRLi0qVLuHjxIhITE2FnZwdZWVmMHz8exsbG0NbWJh2PYf4VrPj6O+jr6+PAgQPw9vbGwIEDcfLkSYGb9CdOnECHDh0IJhS/jIwMNGvWDO3btwdQ1RU0Ojoa2dnZUFFRwezZs2FkZEQ4pfjJy8vjw4cP3N8lJSUoLy/nun9qaWnh9evXpOIxhK1btw6rV6/G5MmToaCgwD20KSgoQGFhIfT09LBu3TrCKcVPQ0Ojzv2NGjUSuJGUlpaGXr16cQuL67ORI0fCyckJGzZsQGRkJLdwrXpx7Jo1a6gr2I+OjoaKigrat2+P1NRUpKaminwdTQvL3dzc4OTkxE0D37x5M4YPH46pU6dCT0+PypvRfn5+pCNIpJMnT2LDhg0YPXo07t27BxMTE5SXl+Po0aNUvk+uXbuG0NBQ9O7dG/r6+tDR0YGPjw/X6GLJkiXUFWXk5+fjyJEjiI2Nxfv372FkZISoqCjMnDkTU6ZMobbwesuWLVi2bBkaNhT9s/rly5dwcXFBZGSkmJORd/78eYSHhwtMQR82bBi8vLxgbW1NMJn4TZs2DWZmZli7di3XiVpJSQk7d+7E4cOH4efnh+TkZOzcuZNwUvFLSUlBRESE0PTvjh074uXLl4RSkWNmZibwN2sSwxrEiMIKJUVLT0/HokWLBLa1bduWu2cwadIk6hZCsnOKMHZOEe2nn37CyJEjkZycjCdPngCo+i4eN24clJWVUVJSAllZWbIhxYidT5ivxaYnCqpueMjj8TB37lyB38kVFRXIysrCsGHDCCYka/v27XBychJanKWtrY2wsDBqi6+/Zho4TebMmYMNGzYgLy8PmpqaQvebaCwUZMdEGDsmojk5OUFVVRXZ2dlwcHDgvotfv36NWbNmEU5HBjsmwrp06YKsrCxuLRMDLFu2jHQEiTFgwADuenbcuHFC+3k8HtXDNBITE7m1BtW6du0KZWVlrFq1isri69WrV2PhwoW4ePGiyO9kmgpqBw4cKHJNgZycHDp16gQrKysMHTqUQDKyPnz4IDAcIS0tTWAStoaGBl69ekUgGcNILlqbNXytXr164dOnTzAwMICsrCy39rza1atXCSUjZ+TIkfD19cW9e/dEfh+PHj2aUDJyFBQUcO7cOVhaWgpsP3fuHBQUFAAAxcXFVE1Rz8nJEVqTUu3mzZtccyFPT0+u8TmNKioqcO/ePaioqHDvFQDYuXMnlJSUCCYj58qVK4iJicHp06fRuHFjqoqvk5KSYGhoKLS9QYMGGDVqFPT19bmmQgwDAA0bNsTIkSMxcuRIfPz4EadPn0ZiYiIsLCzQtm1b/Prrr6QjMsx3Y8XX38He3h7m5uaYPXs2evbsicjISFy9ehXq6up4/Pgxbt68iZCQENIxxcrJyQlr165F+/btcfjwYXh5eWHatGmYNGkSHj9+DFdXV3z8+BFTp04lHVWshg4dCj8/P7i7u0NaWhqbN29Gt27dICcnBwDIzs6m+qKddgoKCggPD8fDhw9x8+ZN5OXlAQAUFRXRt29faguavpWNjQ0SEhKoeWA6Z84cjBkzBidPnhS5OJY2n080ZqpIS0tj4sSJmDhxIl68eIG4uDh4eHigoqICiYmJVN1IA77uISePx4OPj48Y0kiO3Nxc9OzZEwCgqakJaWlpWFpaUvuZys/Ph4qKCgCgefPmaNy4MVd4DVR9PxcWFpKKR8TIkSMxbtw4uLi4YOjQoWjQoAHpSBIhPj4e58+fh7+/PzQ1NQX2RUdHw9/fn9rOfc2bNxc51UxOTg7NmjUjkIickJAQgQVJNU2bNg26urpwdXUVcyrJUFxcLLKY6+3bt1Q0VPqcr68v6QgShzWIEY0VSgrLyckR+N7ZsGGDwPWbgoIC3r59SyAZOeycIoydU2qnoqIitBCntLQUkZGRCA8PR0pKCplgBLDzCfO12PREQdVTE+/cuQM9PT2Be47VTVTHjh1LKh5xRUVFIovPhw4dik2bNhFIRB6bBi6suqDL2dmZ28bj8biJ8jROEWHHRBg7JqKVlZVh/vz5Qts/v8alCTsmwuzs7LBhwwasWLECPXr0QJMmTQT2V6/docnvv/8OHR0dkfuio6Mxc+ZMMSciJyoqCnw+H3PnzsW2bdsEig0aNWoEFRUVagsOgKo1B+3atRPa3q5dO6HCL1ps374dly5dQqdOnYT20XafqeZ1SU2FhYXIyMjAwoULERQUhFGjRok5GVlKSkp4+PAhVFRU8OHDB2RmZgqsV3n79i119/EZ5p/Kzs4GACrXQ9a0atUqvHr1CitXroSioiJ13zeiuLm5AYDIOg1afyMvWbIE7u7u+P3339G7d28AwK1bt/Dbb7/B3d0dAHD58mUMHDiQYErxsrKywv79+wWaogBVjVEWLlyIa9euAQCMjY0JpCPH29sbmpqamDZtGioqKjB79mzcuHEDjRs3RlhYGAYPHgwAAkM3aJCdnY3Y2FgcOXIE2dnZMDQ0RHBwMHUN8B0dHaGgoCCyiVJFRQVWrlxJ5TmW+TqNGzeGnp4eCgsL8fLlS64BL8P86Fjx9XdQUlJCfHw8duzYgXPnzoHP5+Ovv/5CTk4O+vXrhwMHDqBXr16kY4rV06dPoaamBgDYv38/XFxcMH36dG5/r169EBYWRl3xtYODA5YsWQIjIyPweDwoKysLTF8tKCgQ+fCLoYu6ujortP4OfD6fdASxa9u2LdUPyWtiE42/rLpYks/no6KignAaMuLi4qCiooLu3btTec6oTUVFhcCDcSkpKaFFJ7RhDykEqaioIC0tDSoqKlBRUWHXK/8vMTERnp6emDJlCpYtWwYbGxvk5OTA2dkZt27dgqOjI2bMmEE6JhGLFy+Gn58f/P390bp1awBVU1U2btyIJUuWEE4nXrUVXldTVVWlcjo6UPWQJj4+HnZ2dty2yspKhIeHcw9yGLqxBjG1Y4WSgpo2bYpnz55xC28+L+7KysqichE1I4idU4SVlpZi27ZtSElJgbS0NKytrWFgYIDY2FgEBgZCSkoKc+fOJR1TrNj5hPkWbHri36qnJqqqqsLQ0BAyMjKEE0mWUaNG4fTp07C2thbYfubMGYwYMYJMKMLYNHBhZ86cIR1B4rBjIowdE9GGDh2K8ePHY8qUKdQtCq4NOybCFixYAKDq3nXN34E0Ny+wtrbGnDlzsGrVKu45YUFBAZydnZGWlkZV8fWgQYMAVJ1nVVRUqL5XIMpPP/2E//3vf/D19eUap5aWliI0NJSq6W81RUZGwsfHB5MnTyYdhTgzM7M693fr1g07duygrvh6/Pjx8PHxwcKFC/Hbb7+hdevW3GRNAEhPTxdZvM8wTJXy8nIEBwdjz549KC4uBgA0adIEs2fPxrJly6hs/nHjxg0cPHiQ+iaQNWVmZpKOIHGmT58OdXV17Nu3D6dPnwYAdOrUCXv27OGGR1hZWZGMKHZ9+vSBlZUVoqKiuOc7qampWLRoEdfkjkanTp2CiYkJgKrJ6FlZWThx4gQSEhIQGBiI6OhowgnFp6ysDL/++itiYmJw7do1DBs2DGvWrMHq1auxePFiaGhokI4odvb29li2bBl2796NPn36cNsrKythZ2eHtLQ0/PLLLwQTMpKoeuL1sWPHcOXKFSgrK8PIyAhbt24lHY1h/hWs+Po7NWvWDPb29rC3tycdRSLIysrizZs3UFVVRW5uLtc5qVqfPn2QlZVFKB05rVq1wsGDB/HkyROUlpaic+fOaNjw74/f+PHjCaZjJEX1ZJXPJ9GWlZXh5s2bVHUbY77ekydP8McffyA/Px+VlZUC+6oXvTH0Ki0tRXJyMmJjY5GWloYRI0Zg3bp1GDZsGJWTa83NzXH8+HFkZWVh8uTJMDExEepqSCM+n4+1a9cKPCx3d3dH48aNBV5Xs3FMfbd161bu319WVobQ0FBu+tnHjx9JRiPi5MmTSEtLQ0xMDKZOnYpOnTpxN2BpXoAiJycHf39/jB07Fm5ubkhKSkJWVhZ69+6No0ePQlVVlXREsTI1NRV4Pzx58gQjR47kCleys7PRqFEjFBQUULVoa8uWLVi2bJnA77+aXr58CRcXFyoLsB0cHGBpaYn09HSUlZVh48aNePDgAd69e4cDBw6QjsdIANYgRhgrlBStT58+iI+Pr7VxQ1xcnMBDQYZO7JwibOvWrTh48CB0dXVx/fp1rFixApMnT8bNmzfh5OSE8ePHQ0pKinRMsWLnE+ZbsOmJwr606J4mUVFR3H+rq6sjLCwMV69e5Rbb//nnn7h+/TrmzZtHKCFZbBq4sBYtWlB/bfI5dkyEsWMi2saNG3HkyBFYWlpCVVUVU6ZMwaRJk6ieUsuOibCa381MlaioKDg6OuLy5csICAhAVlYWXFxc0KlTJ8THx5OOJzaZmZnQ1NREgwYNUFRUhLt379b6WpqKnT5fa3L58mXo6+tzxyAzMxNlZWXUTYCrJi0tzRUwMXUbMWIEQkNDSccQu6VLlyI3Nxfe3t5QVFTExo0bBe6zJSYmYuTIkQQTMoxkW79+PU6fPg0HBwfuXsrNmzcRHByMt2/fwsPDg2xAAjp37oySkhLSMSReYWEhmjVrRjoGUf3790f//v1Jx5AY3t7esLW1xeLFixEREYHr169j8eLFsLOzo/K5erU3b95wwzQuXLiA8ePHo1OnTpgyZQp1v5/19fXRuXNnmJiYYPPmzVBQUAAArF69mnAycubOnYt3795hwYIF2Lt3L7p06cJNvL527Rp++eUXdOnShXRMRoKsXLkS58+fh6ysLCZMmIAlS5agX79+pGMxzL+Kx2dj/5h/kYODA6SlpeHt7Y0VK1agU6dOAlOstm/fjsTERBw7doxcSIaRMK9evcKSJUuQkZEBHo+HiRMnws3NjSvCzsvLw7Bhw6jstvwt+vXrh6NHj1I1aeTQoUNwd3dHixYtoKioKFDwxOPxEBcXRzAdQ5q7uzuSkpLQtm1bTJkyBcbGxmjZsiXpWMTVLEi/ceMGhg8fjqlTp0JPT4/aItK1a9d+1b/d19dXDGnImzNnzle9bs+ePf9xEsn04cMHHD9+HEeOHOGawxgbG8PAwIDac0xeXh4cHBxw5coVNG7cGNu3b+emJNDkWxo00NQgZsSIEWjevDn8/f2hqakpsC86Ohr+/v7Q1tZGeHg4oYRkFRUVYe/evcjMzERxcTG6d++On376CW3atCEdjZEAXbt2hb6+Ptcg5ty5c9DR0aG6QczGjRsFCiXfvHnDFUouWrSIykJJAPj9998xb948WFpawtraGq1atQIA5OfnY+fOnYiKikJERAS1i0GZKuycImz06NFwdnbG6NGjce/ePZiYmMDMzAw+Pj7U/j5m5xPmW9QsvKB5euKgQYNw8uRJtGzZEgMHDqzz/HH16lUxJiPra6e68Xg8KifZrl69Gt26dROaBh4REYH09HQEBgYSSkZOv3792JTaz7BjIowdk7oVFBQgISEBR44cwaNHj6Cnp4cpU6Zg1KhRtTZGrO/YMfl27u7usLW1peZ5x4cPH+Dm5oZTp06Bz+fD1tYWNjY2VP0m7Nq1K1JSUtCqVSt07doVPB4PopZS0nSNDwBOTk5f/VpaniHXtH37drx+/Rqurq6ko0i8u3fvwsrKCikpKaSjMAzzA+nfvz82b96M4cOHC2y/cOECVq1ahbS0NELJyLl06RKCg4OxcuVKaGpqCk3/prER5I4dO9CuXTsYGhoCAGxtbZGcnIzWrVtj586d1DTOef/+Pff///v37+t8LY3vE6BqvejChQvx8eNH3L17F6tXr8bs2bNJxyJq5MiRWL9+PYYMGYLRo0fD3d0dI0aMwP379zFr1iykpqaSjig2gwYNgqamJkxMTGBoaMh9Tnr06IGEhAQqJ19XW79+PZKTkxEVFYUtW7bgjz/+wO7du6k5vzJfb/Xq1TAxMYGenh6Va5YYOrDia+ZflZubC3Nzc6ioqKBnz544cOAAevToAXV1dTx+/Bg3b95ESEiI0I/i+i4jIwPNmjXjikLj4+MRHR2N7OxsqKioYPbs2TAyMiKckiHF0dERjx8/xs8//4yioiJs2rQJPB4Pu3btgoKCAvLy8qCnp4fMzEzSUSUajcXXI0eOhLm5ORYsWEA6CiOBunbtChUVFXTr1q3OB+Q0LSz/3IsXLxAXF4f4+HhUVFQgMTGRa3zBMNUKCgoAgJqFNt/i4cOHiImJQUJCAt69e4eMjAzSkcQuMTER69evR9euXeHm5oaYmBhERUVh1qxZWL16NWRkZEhHZAh7//49PD09ceLECSxbtgw2NjbIycmBs7Mzbt26hTVr1mDGjBmkYzKMRPraBX40Le5jhZK127dvH3x9fVFRUQE5OTnweDwUFRVBSkoKa9eupf4BOsPOKaL07NkTZ86c4abf9e7dG4cPH4aWlhbhZGSx8wnztb5USExLU664uDgYGRlBWlr6i81A2WRsutWcmPL+/Xvs2rUL2traIqeBL1myhFBKcn799VccOXIEv/32G5tS+//YMRHGjsnX27NnD/z9/VFWVoYWLVpg5syZWLBggVDzJZqwY/J1tLW1kZCQQM2ag4yMDKxevRoVFRV49eoVDA0N8fPPP6NJkyako4nNixcvoKKiAh6PhxcvXtT5WlVVVTGlYiTd0qVL8fvvv6N58+bo0qWLUEMLmtdgfM7b2xuPHj1CREQE6ShiVVtzMjk5OXTq1AlWVlYYOnQogWQM82MYMmQI9u7dC3V1dYHtDx8+xE8//YTff/+dUDJyWCNIYaNGjcKmTZugra2NlJQU2NnZITAwECdOnEB2djZ27dpFOqJYdOvWDZcuXRJoJvQ52t4notbaf/jwAatXr8bw4cNhbm7Obae1iHTbtm345Zdf0Lp1a5SUlODUqVOQlpZGTEwMDh8+jIMHD5KOKDafPn3CqVOnEBMTgz///BP6+vowMTHBypUrER8fT3XxNQDY29sjOTkZTZo0YYXXDMNQjRVfM/+6wsJC7NixA+fOncPz589RWVmJNm3aoF+/frC0tESvXr1IRxQ7ExMTrF27Frq6ujh8+DC8vLwwbdo0rij98OHDcHFxwdSpU0lHZQgYNmwYQkJC0Lt3bwBVXbZsbW2Rk5OD3bt3o7y8nE2+/gq0PQgF6Pw3M1+PTTP+suzsbMTGxiIuLg5lZWU4ceIElcXXX1OEwOPx4OPjI4Y0kqGwsBCBgYFISkpCYWEhAKBZs2YwMjKCnZ0dmjVrRjihZCkvL8fZs2cxduxY0lHEavny5bh06RJWrVolMDH9+vXr3OfKz88P/fr1IxWRuFu3buHhw4cAAA0NDfTs2ZNwInJ+/fVXuLm5QVFREVlZWejduze8vLyoW6z1LQ2l2A17hhHGCiXr9vLlSyQnJ+PJkycAgI4dO2LcuHFQVlZGSUkJZGVlyQZkGAnTrVs3pKSkcI2maGxsWBt2PmH+TbRNT2SY2rBp4F+HTakVxo6JMHZMRMvLy0NcXBzi4uLw8uVLGBgYYOrUqcjJyUF4eDjatGlDzeL7auyYfDuafhft2LEDQUFBmDFjBtasWYOnT59izZo1eP/+PTZu3Ej1sw1GtPz8fDx+/BgA0KlTJ7Rq1YpwInK+9HydpjUYtf1bi4qKcPv2bTx58gR79+6l7hlhbc3JCgsLkZGRgaSkJAQFBX317ySGoU1wcDAeP34MX19fSEtLA6haU+vs7IyOHTti2bJlhBOKH2sEKax37944deoUlJWV4eXlhdLSUnh6euLx48eYPn06NZN7r169Cm1tbTRs2JC9T/5fdRF6zRKpmn9X/zdNBeminDx5Ejk5ORg/fjzatm0LoOoaRl5eHgYGBoTTkfHs2TPExsYiPj4eubm5MDIywuTJk6Gjo0PVNN+a1/jl5eU4dOgQBgwYAE1NTYHXfW3zc6Z+ioqKwowZMyAjIyPQfFcUCwsLMaVimP8OK75mGDHo06cPkpKSoKqqCjMzM5ibm2P69Onc/mPHjiEsLAzHjx8nmJIhpV+/foiLi0PHjh25beXl5VixYgWeP3+OjRs3wtTUlOofeV+Dpgeh1ZydndGrVy+BTmwMw9SttLQUycnJiI2NRVpaGkaMGIEpU6Zg2LBhaNCgAel4RFRPSe/evTvq+mkQEhIixlTkvH37FjNmzMCrV69gbGyMzp07A6jqoJuYmIi2bdsiOjoaCgoKhJNKjvLycrx69QoqKiqko4jVzJkz4efnJ3ANV62kpASbNm1CdHQ00tPTxR+OsJycHKxatQrXr1/nmhUUFhaiX79+CAwM5G7a0yQvLw8ODg64cuUKGjdujO3bt1PzYKsmUQ+5RKH9IRfD1IYVSn670tJS7Nu3D+Hh4UhJSSEdh2EkSteuXaGvr88tXjt37hx0dHSEJt+xaU1V2PmE+adoa6BZUVGB06dPCzTiGj16NNXFgLUVI/B4PMjIyKBDhw4YPXo0mjdvLt5gjMRjU2qFsWMijB0TIDk5GUeOHMGlS5egrq6OadOmwcTERKCJ6rNnz2BoaEjNvVp2TP45mu616OnpwdvbG8OHD+e2lZWVYfPmzdizZw+1741Hjx5h79693PWsuro6Zs+ezT0vpNH79+/h4eGBpKQkVFRUAACkpKQwYcIEuLm5QV5ennBChqSaDaprqp7wbG5uTsU59VtFRkbi1KlTiI6OJh2FYSTS0qVLceXKFUhLS3MNuzMzM1FWVoYhQ4YIvJam+9fXrl1DdHQ0nj9/jqCgICgpKSE+Ph7t2rXDgAEDSMcTOz09PQQFBUFbWxvjxo2DnZ0dJkyYgEePHmHq1Km4fv066YgMIS9evPjq19I2MIH5OpWVlbh48SJiY2Nx9uxZNG3aFH/88QfpWGJT2zV+TTwe74sFt0z9NmrUKMTGxqJFixZ1NpWiveEuU3/Q+6SbYcRIVlYWb968gaqqKnJzc7kJx9X69OmDrKwsQukY0tq1a4e7d+8KFO40bNgQW7duxYoVK7Bo0SJy4X4gN27cIB1BLGr+WFFTU8PWrVvx559/QlNTU2gBG+sUxDCC3N3dkZSUhLZt22LKlCkICAhgU4cAmJub4/jx48jKysLkyZNhYmJC9WLPkJAQSEtL4/Tp01BUVBTYZ2trCysrK4SEhMDZ2ZlQQsnz4MEDmJmZUVcouX///lqbNsjKysLV1RXjxo0TcyrJ4OLigvLyciQlJXELkh49egRnZ2e4uLggIiKCcELxSkxMxPr169G1a1ckJSUhJiYGVlZWmDVrFlavXg0ZGRnSEcWG3UxlmO/D5/Oxdu1agS7/7u7u1BdKlpaWYtu2bUhJSYG0tDSsra1hYGCA2NhYBAYGQkpKCnPnziUdk2EkjpmZmcDfJiYmhJJIDnY+Yf4LNPXAvn//PhYvXoy8vDx06tQJABAeHo4WLVogLCxMaCoCLW7f/j/27jyu5rT/H/jrVBIpSZSlpGgaS6PsIVtjZ8TY92QvREqJFu2ypttSMTJoyDo0lmnGfDFGE2YMyn1bkzVrkpQ6vz/6OTPHKcx9j3MdfV7Px+P7+DnX9fnjNdevuz7n87ne1/siLl68iJKSEsW6XLt2Ddra2rCyssLWrVsRGRmJrVu3olGjRoLTqldhYSGys7NhYWEh6QL9v3qzS23Pnj2VutT+/vvvkutSyzVRxTVR5uvri759+2Lr1q0q+zBeq127tqTeuXNN6H3s27dP5T1ppUqV4OPjg65duwpKJdahQ4cwZ84cNGvWDC1atAAA/P777+jfvz+WLVsm2Xc+/v7+yMjIwNq1axUd0c+ePYvQ0FAsWrQIy5cvF5xQnEePHuHq1asAACsrK0nuPdi8ebPoCB+lLl26YM2aNaJjEGksQ0NDlb+7derUEZRGMxw6dAje3t7o378/Ll68iMLCQgClh6SsW7dOksXXPXr0gJeXFxo0aIAnT57AyckJAJCRkYEGDRoITifO06dPkZycrHQ45qBBgyS1F5AF1WX7O4WyUt97rqWlhc6dO6Nz58549OgR9u7dKzqSWvEen97HDz/8UOa/iSoqdr4mUoN58+ZBV1cXoaGhmDVrFho2bIjZs2cr5tetW4f9+/fj22+/FReShFmyZAkyMzPLLEJ59eoVPDw8cPToUckVNL3LlStXMHnyZMkVcLztdKC/4klBRKped3j+9NNPIZPJyr1OasUqgHJH8LNnz6Jz58748ssv0bFjx7euVUXUrVs3BAUFoVOnTmXO/9///R8CAwP5wOAvMjMzJVl8/fDhQ9SsWfOt16Snp0vyJZednR2SkpLQpEkTpfHz589j1KhR+P333wUlUz8PDw8cP34cc+bMUToZ9MyZM/D19QUAREREKDYsSUVRUREWLVqE6dOns+MB0d/w+vfGu5TXXbGiWrJkCb755hs4OjrizJkzePz4MQYNGoTffvsNU6dORa9evaCtrS06JhF9BPj7hD4EKXVPHDZsGGrUqIHIyEhUr14dQOlmv/nz5+Px48eS7ej11Vdf4fTp0wgPD0e1atUAAM+ePcOCBQvQsmVLDB06FHPnzsXLly8lc1jZixcvsHjxYuzZswdA6QZic3NzLF68GKamppg8ebLYgAKwS60qrokqrknZXrx4IalO3++Da/Lfk9K9GwDk5ubi0KFDyMrKwsSJE2FkZIQLFy7AxMQEpqamouOpnbOzM/r3749Zs2Ypja9atQr79u3D999/LyiZWC1atEB8fLzK+6709HS4ubnht99+ExNMoPz8fCxevBh79+5FSUkJgNJu4F988QUWLlzI38H0TpcuXYKrqytOnDghOgoRfSQGDhyI8ePHY+DAgUr3rBcvXsSkSZMk+fukqKgIiYmJuHPnDgYNGqTYn/LVV19BX18fQ4YMEZxQ/X799VdMnToVBgYGaNasGQDgwoULyM3Nxdq1a9G6dWvBCdXv7t27MDAwgL6+vtJ4UVERfvvtN0mtCfeev7/+/ftj/fr1kj/447VHjx4BgCQPm6Lyve++JJlMhvnz53/gNEQfHo+QJlIDLy8vjBgxAqNHj0azZs2wceNGpKWlwdraGteuXcNvv/2G2NhY0TFJEE9PTxQUFJQ5p6Ojg5iYGNy7d0/NqTRfUVERbt++LTqG2rHYj+i/N3DgQMkVEr8vXV1d9OvXD/369cOtW7ewe/duBAUFobi4GPv371d5AFmR3b9/H40bNy533sbGBjk5OWpMJN6bHfHeVN59TEXXr18/BAQEoFevXipzBQUFiI6ORlJSkqQ2Or5Wp04dvHr1SmW8pKQEtWvXFpBInJycHOzevRuWlpZK4w4ODti7dy+io6MxZswYyf2cVKpUCYcPH8b06dNFRyH6qEitqPp9HTx4EJGRkejevTv+/e9/Y8CAAXj16hX27dvH+38i+lv4+4Tof5ORkYGdO3cqCq8BoHr16vD09MSXX34pMJlYCQkJ2Lhxo6LwGgAMDAzg4eEBV1dXjBs3DjNmzICrq6vAlOq1dOlSZGZmIjExEZMmTVKMt2/fHqtXr5Zk8TW71KrimqjimpQtLS0NWlpaKgeqHjt2DCUlJejcubOgZOJwTeh9ZGZmYsKECTAwMMCtW7cwdOhQGBkZ4fDhw7hz5w6ioqJER1S7nJwcDBw4UGV8wIABkjkkpyxGRkYwMDBQGa9WrZrSASBSEhERgV9//RVr1qxBy5YtAQCnT59GSEgIIiIiEBQUJDghabrk5GTY2tqKjkGk8R4+fIhr164BABo2bPjOw/ErsmvXrpV58L+BgQFyc3MFJBKvUqVKmDhxosr4+PHjlT5PnjwZISEhktirEhwcjD59+iAwMFBxkGxxcTGCgoIQHBwsqQZx9+/fx/Tp03HhwgXIZDLFHq/XeyCfPn2KsWPHSqrRCPeev7/s7Owy971JSW5uLpYvX46UlBTF3xlDQ0P07dsXs2fPlux3QfrTxYsX3+s6vmOnioLF10RqYGpqij179mD9+vX48ccfIZfLce7cOdy9exf29vbYtm0bmjdvLjomCaKjo6O06aas+Xr16qkxkWZ416by1ycpSdnq1asxceJElVNzCwoKEB8fD3d3d0HJiDRTRESE6AgfBS0tLQCAXC5HcXGx4DTqV6NGDWRnZ8PMzKzM+ezsbKVNxFJw+fJl9O3bF/Xr1y9z/v79+7h+/bp6Q2mASZMmwcfHB4cPH0ZAQIDi5yI9PR2+vr7Q0tLCpk2bBKcUY968eVi8eDEWLVqk+J7zxx9/IDQ0FD4+PoLTqdfWrVsVv1ffpKenB39/f/Ts2VPNqTSDs7MzUlNTVV5+EhH9Xffu3VOc3m5jYwNdXV2MHz+eL3GI6G/j7xOi/42lpSUePHigcqjdw4cP0aBBA0GpxMvLy8PDhw/RqFEjpfFHjx4hLy8PQOmmpaKiIhHxhEhNTcXy5cvRokULpfHGjRsjKytLTCjBjh8//s4OiXp6epJ678M1UcU1KVt0dDS8vLxUxuVyOZYuXSrJQmOuyX9vwIABkjmQODw8HC4uLvD29oa9vb1ivHPnzmX+/EhBmzZtkJ6ernLvevr06TKLnaRi2rRpiIiIQFRUFGrVqgWgtFB9yZIlkj1g9dChQ1i1ahXatm2rGOvcuTMqV66M2bNns/iayt3z9uzZM1y8eBHXr1/H119/reZURB+PvLw8BAUFISUlRbFvSVtbG71790ZAQECZh4JUdCYmJsjKylLZt3P69GmYm5sLSvVx+PXXX/Hy5UvRMdTixo0bWLlypaLwGij938748eOxZ88eccEEWLp0KbS0tLB9+3Y8e/YM0dHRGDt2LDZs2KDY3yWXywWn1HyvG0vw94y0PHnyBMOGDcP9+/fRv39/WFlZAQCuXLmC3bt34+TJk0hKSpLcHlpStnnzZtERiNSKxddEamJoaAgvLy/JvqSg8uXm5mL//v0YOXIkAGDu3LlKX/a1tLQQEhIiuVOCEhMT8emnn5b7cjM/P1/NiTRPbGwsRowYobLR4sWLF4iNjZXc5goi+u8VFhbi8OHD2LlzJ06fPo0uXbpg0aJF6NSpU7lFgxVVx44dsWLFCmzYsAG6urpKc4WFhVi5cqVKt4iKrnHjxrCzs1Pcq7wpIyMDO3bsUHMq8VxdXeHk5AQfHx/07dsX/v7+SE9Px7Zt2zBixAh4eXlBT09PdEwhfH198eLFCwwdOlTpNF1tbW34+fnBz89PcW1aWpqomGrx+PHjd57ALdVingYNGiA2NhZnzpxB06ZNVe5px44dKygZEX1siouLUalSJcVnbW1tVK1aVWAiIvpY8fcJ0d/3ungYKH23ERoaCnd3d0VR7W+//YbY2FhJvxvr1q0b/Pz8MH/+fKUDyiIjI+Hs7AwAOHfuHCwtLQWmVK9Hjx6V+V35xYsXkv2OzC61qrgmqrgmZbtx4wasra1Vxq2srCR7oAPX5E/Xr1/HqlWrEBwcrHIg/rNnzxAYGIjZs2crNpJLqWDy/PnzWLx4scq4qakpcnJyBCQSIzU1VfHvbt26ITo6GhcuXMBnn30GAPj9999x8OBBeHh4iIoo3LZt23Djxg107doVderUAQDcuXMHlSpVwqNHj/DNN98ort29e7eomGpVUFAAExMTlfGaNWuioKBAQCLSNOV1gatWrRocHR0RExPDIiait/D390dGRgbWrl2rOCTm7NmzCA0NxaJFi7B8+XLBCdVv6NChCA0NRVhYGGQyGe7du4ezZ88iMjJSsoehkKomTZrg6tWrikLJ165evQpbW1tBqcT4+eefERsbq3gem5SUhJkzZ2LcuHH46quvAEh3r87fIdUC9VatWqFy5cqiYwgTGxsLXV1dHDlyROV7z8yZM+Hq6orY2Fil/X9ERBUdi6+JiATbvn07MjIyFAVNP/zwAzp16qQoOj579iw2bdokuZc5FhYWGDduHL744osy5zMyMjBo0CA1p9Iscrm8zAcAmZmZPFGKiN5bYGAgUlJSYGZmhsGDB2Pp0qUwNjYWHUuYWbNmYfDgwejZsydGjhwJKysryOVyXL16FVu3bkVhYSGioqJEx1QrBwcHXLt2rdx5fX19yZ7436hRI2zfvh1eXl7w9PSEnp4eNm7ciDZt2oiOJhQfrv6pX79+CAgIQK9evVTmCgoKEB0djaSkJJw/f15AOrGSk5NhYGCA8+fPq/z3y2QyFl8T0XuTy+WYP3++4uCcwsJCBAYGqhzqsHr1ahHxiOgjwt8n9CFU9O6JrVq1UnpGLZfLMXv2bMXY681ZU6dORUZGhpCMogUHByM8PByenp5K3ZpcXFzg6+sLoLQYLjQ0VGRMtWrWrBmOHj2KMWPGKI3v2LFDpRu2VLBLrSquiSquSdkMDAxw8+ZNlQ5wWVlZ7+wUXlFxTf6UkJAAMzMzlcJroHSdzMzMEB8fL6mi69d0dXWVDtJ57fr165J6TzhjxgyVsa1bt2Lr1q1KY8HBwRgxYoS6YmmU1wcG0Z9atGiBVatWISoqSlGUUVBQgNWrV0v2fpaUsQsc0f/m6NGjiI+PV9qH0qlTJ4SEhMDNzU1gMnEmT56MkpISjB8/Hi9evMDo0aOhq6sLV1dXlecrJC2ZmZmKf48dOxahoaG4ceOG0mFCW7ZskdzhmHl5eUoNz3R1dbF69WrMmjULY8eOxZIlSwSmI00XFxcnOoJQqampCAoKKvPAqVq1amHevHkIDAzk/kAikhQWXxMRCXbo0CF4enoqjc2bN09xwuWRI0cQGxsrueLrZs2a4cKFC+UWX8tkMsmeqtW6dWvIZDLIZDL07NlTaXNbcXEx8vPzMXz4cIEJiehjkpSUhLp168Lc3By//vorfv311zKvk8rmcjMzMyQlJSEoKAjLli1T/K2RyWRwdHTEokWLFKe6S4W/v/9b5y0sLCT7ArmoqAgxMTE4cuQI+vTpg2PHjmHdunWwsLCAmZmZ6HjCuLi4iI6gMSZNmgQfHx8cPnwYAQEBigNy0tPT4evrCy0tLWzatElwSjF++OEH0RGIqIJ48+/OgAEDBCUhoo8df5/Q+2D3RGWJiYmiI2i04uJiXLx4EfPmzYOvry9u3rwJADA3N1cqyv/0009FRRTC09MTkyZNwuXLl1FcXIzExERcuXIFZ8+elewzJnapVcU1UcU1KVv37t0RFhaG2NhYWFhYAChdq4iICHTr1k1wOjG4Jn9KS0t766b63r17Y+7cuWpMpDm6deuG2NhYrFixQjF2+/ZtREdHo0ePHuKCqdlfi1WobO7u7qIjaJwFCxZg4sSJcHJyUnSRzMzMROXKlZGQkCA4HRHRx8/IyAgGBgYq49WqVVMqppQSmUyGadOmYeLEicjKykJ+fj6sra0r9KGP9H4GDhyospe6rO9Ac+fORZ8+fdQZTaj69evj0qVLsLS0VIzp6Ohg5cqVmDVrFqZOnSouHGmUa9eu4dmzZ7Czs1OMnTx5Ev/617/w4sULODs7S+7n5f79+2jcuHG58zY2NsjJyVFjIiIi8Vh8TUQk2M2bN9GwYUPF54YNG6JSpUqKz7a2trhx44aIaELNnz8fhYWF5c7b2tpK9kWYn58f5HI5/Pz84OHhofSwsVKlSqhXrx7s7e0FJiSij8nrh7D0J3Nzc8THx+Pp06eKv8EWFhYwMjISG4w0SkZGBry9vZGfn4/4+Hi0a9cO9+7dg7+/P/r16wcfHx8MGTJEdEwhdu3ahUGDBqmMv3r1CitXrpTUZjZXV1c4OTnBx8cHffv2hb+/P9LT07Ft2zaMGDECXl5e0NPTEx1Tozk4OGDv3r2K4hUiojeFh4eLjkBEFQR/n9D7YPdEZW3atBEdQaNpa2vD1dUVKSkpMDc3VxRmSF2rVq2wd+9erF+/HjY2Njhx4gSaNGmCpKQkfPLJJ6LjCcEutaq4Jqq4JmWbN28e3Nzc0Lt3b5iamgIA7t27h5YtW8LHx0dwOjG4Jn+6c+cOatasWe58jRo1cPfuXTUm0hzz58/HzJkz4ejoiJcvX2LMmDF48OABWrRoodI8gKTtl19+Qbt27cqcS0pKkmRjABsbGxw+fBjffvstrl69CgDo168f+vfvz3c+RET/gGnTpiEiIgJRUVGoVasWACAnJwdLlizB9OnTBacTS1dXF40aNRIdgzRIamqq6AgaycnJCdu3b0fPnj2Vxl8XYHt4eEj2uyApi46Oho2NjaL4+ubNm5g6dSpatWqFTz75BOvWrYOenh7Gjx8vNqga1ahRA9nZ2eU2nsnOzlY0HyEikgoWXxMRCfbixQs8e/ZM0UVz165dSvP5+fkoKSkREU0oY2NjaGtri46hkV534alfvz7s7e2VivWJiP6uiIgI0RE0VvXq1ZVONZSqFStWwN3dHTo6ZX99vH37NhYsWICNGzeqOZlYQ4YMgYuLC+bPn684TdjU1BRxcXHYsWMHIiIicPjwYcTFxQlOqn4hISE4evQoFi9erHjYevXqVXh5eeHJkyeSKr4GgEaNGmH79u3w8vKCp6cn9PT0sHHjRhYpvKe/ntBMRERERCQauye+W25uLg4ePIjbt2+jXr166NWrV5ndiqSicePGyM7O5oFSb7CwsEBISMhbr1m/fj2GDx8uia5W7FKrimuiimtSNgMDAyQlJeHEiRPIzMyEnp4ePvnkE7Ru3Vp0NGG4Jn8yMDBAVlYW6tWrV+Z8VlZWmYfqSIGBgQE2btyI06dPIzMzE/n5+WjatCkcHR1FR1O7u3fvQldXF8bGxgCgOED1zp07qFu3LkaNGiXpw+/d3NwwZswYzJkzR7E35dGjR/Dz88Pp06clWXwNAFWqVMHQoUNFxyAiqpC2bduGGzduoGvXroo9tXfu3EGlSpXw6NEjfPPNN4prd+/eLSomkUYo77vO20yePBkhISGoXbv2B0ikGTw9PVFQUFDmnI6ODmJiYnDv3j01p/r4SKGhz/nz5+Hm5qb4/O2338LS0hIJCQkAgE8++QRff/21pIqvO3bsiBUrVmDDhg3Q1dVVmissLMTKlSvRqVMnQemIiMRg8TURkWDm5ua4ePEibGxsypw/f/68ygnmUuDk5AQXFxcMHjxYqTO41OXl5SleADdp0gQvX77Ey5cvy7xWqi+KiYjon7Vnzx4cPXoUUVFRKvcrSUlJiIqKgoODg6B04sTGxqJz585lzg0ZMgSOjo7w9/dXcyrNsGfPHsybNw/9+/dHeHg4rl+/jiVLlqB79+4IDAwUHU/tioqKEBMTgyNHjqBPnz44duwY1q1bBwsLi3JPCSUiIiIiIs3E7omq3N3d0a9fP/Tq1Qv/+c9/MGbMGMhkMpibm+PWrVtYuXIlNm3aBGtra9FRhZg9ezYiIyMxa9YsNG3aFFWrVlWa53P88q1duxa9e/eWRPE1u9Sq4pqo4pqUTyaToWPHjujYsaPoKBqDa1KqVatW+Prrr9G+ffsy5xMTE9GyZUs1p9IsLVu2fOsa9O/fH+vXr1cUPlVEHh4emD59Orp27Yrvv/8eHh4e6NKlCxwcHHD9+nWMGTMGMTEx6Nq1q+ioQiQmJsLHxwc///wzli5diuzsbCxYsAANGzbEnj17RMcTYt26dahZsya+/PJLpfHk5GQ8evQIkydPFpSMiKhicHZ2Fh2BKpCpU6eyQ+sbfv3113L3HFcUOjo6b33uqqOjo1S47uDggL179/IAzTdIoVnC48ePlfZunTp1Sum7X9u2bREZGSkimjCzZs3C4MGD0bNnT4wcORJWVlaQy+W4evUqtm7disLCQkRFRYmOSUSkViy+JiISzNnZGStWrEDHjh1hYmKiNJeTk4OYmBh88cUXgtKJM3LkSOzZswcJCQmwt7fHl19+id69e6NKlSqiownVunVrHD9+HDVr1kSrVq3KPFlMLpdDJpMhIyNDQEIiIqpo9u/fj+DgYAwePBju7u6YNGkS7t69Cz8/P/zxxx/w8fHBsGHDRMdUu/IKr1+rV6+e5LqBv2ZhYYFt27YhLCwMbm5u0NbWRkREBPr16yc6mtplZGTA29sb+fn5iI+PR7t27XDv3j34+/ujX79+8PHxwZAhQ0THJCIiIiKi98TuiarS0tLg6ekJAIiKikKHDh0QHh4OXV1dFBUVITAwEGFhYYpOEVLzuvBi2rRpSs/z+Rz/3aSwue81dqlVxTVRxTUp38mTJ/HVV1/hypUrAABra2uMGzdOkh18X+OalJoyZQqGDRuGmTNnws3NTXHo+9WrVxEfH4/jx48jKSlJcErNlp2djVevXomO8UFdvnwZjRo1AgCsX78enp6eSsWzX3/9NVatWiXZ4msHBwfs2bMHAQEBcHFxgVwux8yZMzFp0iRJdMIryzfffIPo6GiV8caNG6v8/BAR0d/n7u4uOgJpqNTUVDg5OaFSpUpITU1967Xdu3cHUPqdgOhdpPQc8u+Ii4tTHABYUVWvXh05OTmoU6cOSkpKcP78eUyYMEExX1RUJLmfDzMzMyQlJSEoKAjLli1T/PfLZDI4Ojpi0aJFFfqANiKisrD4mohIMDc3Nxw+fBg9evTAF198AUtLSwDAtWvXsG/fPpiammLSpEliQwowY8YMzJgxA6dOncKuXbuwePFihIaGonfv3hgyZAg+++wz0RGF2LRpk+Ikvk2bNkn2ZRYREalPtWrVEBUVhR49eiAgIAApKSnIzs6GnZ0d9u3bV+6G84puxYoVcHd3h45O2V+rb9++jQULFki2APvo0aM4cOAAWrRogevXryM5ORmtW7eu8A/l3zRkyBC4uLhg/vz50NfXBwCYmpoiLi4OO3bsQEREBA4fPoy4uDjBSYmIiIiI6H2we6Kqly9folKlSgBKD6Bav349dHV1AQCVKlWCm5ubpA+dSkxMFB2BPhLsUquKa6KKa6Jqy5YtCAsLQ8+ePTF27FgAwO+//47JkyfD19cXo0aNEpxQ/bgmf2rSpAlWrVoFPz8/HDlyRDEul8tRo0YNrFixAk2bNhWYkDSBtrY2nj9/DqC02NzJyUlp3snJqcxCWym5fv06zp8/DzMzM9y/fx/Xrl3DixcvULVqVdHRhMjJyUGtWrVUxo2NjZGTkyMgERERkTTMmDEDJ06cQM2aNTFjxoxyr+OBh0RvFx4eXua4TCZD5cqVYWFhge7du6NVq1ZqTqZ+bdq0wb/+9S8EBATg4MGDKCkpQZs2bRTzly9fluTeSHNzc8THx+Pp06e4ceMGgNJmLEZGRsjNzcW3336L/v37C05JRKQ+LL4mIhKsWrVq2LZtG5YuXYoDBw4gNzcXAGBoaIh+/fphzpw5kuuU8Vdt27ZF27ZtsWjRIqSkpGDXrl0YNmwYrK2t8eWXXyqdMCUFbdq0wc2bN2Fubo62bduKjkNERBLSokUL2NjY4OTJk6hSpQqmTZsmyYeLr+3ZswdHjx5FVFQUbGxslOaSkpIQFRUFBwcHQenEWrRoEXbv3g1PT09MmDABDx48gJ+fHwYMGICAgAD06dNHdES1iY2NLbdL+pAhQ+Do6Ah/f381p/q48LAhIiIiItIk7J6o6pNPPsEvv/wCCwsL1KpVC7dv30aTJk0U87dv34aenp7AhGL9daPW2wQGBmLmzJkwNjb+wIlIU7FLrSquiSquiap169bB19cXo0ePVhp3cHDA2rVrJVVo/BrXRFnXrl3x448/4tixY7hx4wbkcjkaNmyIjh07Svoehf7UunVrHDhwALa2tvj000+RlpYGW1tbxfypU6ckd7DsX61fvx6rVq3CsGHD4O3tjRs3bsDb2xsDBgzAkiVLYG9vLzqi2tWpUwdnzpyBubm50vjp06dRu3ZtQamIiCoOW1vbt74jZlGtdGVmZpb5byL6ey5evIiLFy+ipKRE8Y7j2rVr0NbWhpWVFbZu3YrIyEhs3boVjRo1Epz2w/L09ISrqyu6du0KbW1tLFiwQOmQqb1796Jdu3YCE4pVvXp12NnZKY3dvn0b3t7eLL4mIkmRyeVyuegQRERUSi6X49GjRwBKT0RloUHZjh49Ch8fH+Tm5kryYZqtrS3q1q2Ltm3bol27dmjbti3MzMxExyIiogps//79WLx4MWxtbREQEIDk5GQkJiZi5MiRmDt3LipXriw6otrl5eUhODgY3333Hdzd3TFp0iTcvXsXfn5++OOPP+Dt7Y1hw4aJjilEv379EB0drbQ5CSjtuBIdHY2zZ88KSkYfI3t7e+zbt09lExMRERERkSg//vgj/Pz88OTJE8XY6+6JISEh6N69u7hwArx+Xu/j4wMAWL16NaZNmwZra2tcu3YNMTEx6NOnD7y9vQUn1WwODg7Yu3cvv/v8hZS+D/61S22LFi0AlHapPXTokOS61L7GNVHFNSmbvb099uzZgwYNGiiNX79+HS4uLpJ8Fsk1+dPZs2fx5MkTdO3aVTG2e/duxMTE4MWLF3B2dsbChQuhq6srMKVmk8Lf4ytXrmDkyJHo0qULGjRogLi4ODg7OyvuZ1NSUhAUFIRBgwaJjipEx44dERoaqnTQbFFREZYtW4bNmzfj/PnzAtOJERcXh/j4eHh7eysKMU6ePIklS5bA1dUVU6ZMEZyQiOjj9v333yt9fvXqFTIyMrB79254eHhgyJAhgpKRpigqKoKbmxuCgoJgaWkpOs5HRwr3+H+X1Nbkq6++wunTpxEeHq5oDvfs2TMsWLAALVu2xNChQzF37ly8fPkSCQkJgtN+eK9evcLly5dRo0YNlYO3MjMzYWpqiho1aghKp3kyMzPh4uIiyfoNIpIuFl8TEQn28OFD1KxZs9z5V69e4eLFiyonB0nNixcv8N1332HXrl04ffo0LCwsMHjwYEyePFl0NLU7deoU0tLSkJaWht9//x1FRUUwNzdXFGK3bdsWJiYmomMSEVEF4eHhgePHj2POnDkYM2aMYvzMmTPw9fUFAEREREjyZHug9MVfQEAATExMkJ2dDTs7O4SEhEi6K3hhYWG5m9WuXr0KKysrNSfSLPn5+UhJScHLly/RoUMHvgx8w5UrV5CcnKwo3EhPT4ednR03QBIRERGRRikoKGD3xL84dOgQwsLCcP/+ffz11bOuri6GDx8OHx8faGtrC0yo+aS2we99SGlNnJycMHnyZJUutVu2bMHatWtx7NgxQcnE4Zqo4pqUbe7cufj000/h5uamNJ6QkIDz589j+fLlgpKJwzX5k5ubG9q0aaPYU3Dp0iUMHjwYAwcOhLW1NRISEjBs2DB4eHgITqq5pPL3OCsrCytWrMDRo0eRn58PANDR0UGzZs3g5uYGZ2dnwQnFefToEYyNjcucS0tLQ5s2bdScSDy5XI7o6Ghs3rwZRUVFAIDKlSvDzc0N7u7ugtMREVVc3377LVJSUrBmzRrRUUgDtGvXDklJSdxv8V+Qyj3+3yG1gzE7deqEjRs3qnS1/s9//gNXV1ccO3YMFy5cgKurK06dOiUoJWkqFl8TkRTpiA5ARCR1HTt2xPHjxxUF2P3798f69etRp04dAMCTJ08wbNgwyd6knjlzBjt37sTBgwdRXFyMnj17YtasWWjdurXoaMK8LrAGgJcvX+LMmTOKYuzdu3fj1atXsLKywoEDBwQnJSKiiiAnJwe7d+9WeWHx+sFzdHQ0xowZI8mT7QGgRYsWsLGxwcmTJ1GlShVMmzZN0oXXQOnm+qysLOzcuRM3b97EggULULNmTfz000+oW7eu6Hhqdfv2bXh7e+PChQto0aIFQkNDMWHCBNy4cQMAoKenh7i4OEnf2wKlBekHDhzAzp078dtvv6FRo0aK4utWrVoJTkdERERE9Ke/dk/8/PPPAZR2TwwLC5N098SePXvC2dkZFy5cQHZ2NkpKSlCrVi00bdpU0TmD6H0UFBQoDjFo1aoVKleuLDiRejx79gydOnVSGe/QoQOio6MFJBKPa6KKa/KnxMRExb+tra2xdu1apKWlKXUEP3PmDCZMmCAoofpxTcqWmZmJWbNmKT6npKSgefPmCAkJAQCYmZkhJiaGxdcECwsLLFu2DHK5HA8fPkRJSQlq1KiBSpUqiY4mnLGxMXJzc3Ho0CFkZWVh4sSJMDIywoULF9CgQQPR8YSQyWSYN28epk+fjitXrkBPTw+WlpaS+x5IRKRuLVq0wKJFi0THIA0xYMAAJCcnw8vLS3SUj87UqVNRvXp10TE0itR6Webl5eHhw4cqxdePHj1CXl4eAMDQ0FBx0FBFVt7hSQYGBrC0tMSQIUPKPYyKiIikg8XXRESCvfmlLTs7G69evXrrNVIQFxeHXbt24fr162jWrBm8vb3Rt29fbtR6Q+XKldG+fXu0bNkSbdu2xf/93//hm2++wdWrV0VHIyKiCmLr1q3Q0tIqc05PTw/+/v7o2bOnmlNphv3792Px4sWwtbVFSkoKkpOT4erqipEjR2Lu3LmS2SD8prS0NEyaNAkODg749ddf4enpiZo1a+LSpUvYuXMnVq1aJTqi2kRGRqKoqAhBQUH47rvvMHHiRFhaWmLLli3Q0tJCYGAgYmJilDZHSsnp06eRnJyMgwcPoqCgAOPHj0doaCisra1FRyMiIiIiKlNsbCzatGmDrl27Aijtnrhw4UKl7om1a9eWZAGPtrY27OzsYGdnJzoKabiQkBD4+/urjOfn52PKlCnYvHkzgNL3RFLRrVs3HDlyRKVLbWpqKrp06SImlGBcE1Vckz999dVXSp8NDQ1x+fJlXL58WTFmYGCAnTt3Yvr06WpOJwbXpGxPnz6FiYmJ4nNaWhqcnJwUn5s3b447d+6IiPbRCA4OVjQSkAKZTKb0M0OlhxhMmDABBgYGuHXrFoYOHQojIyMcPnwYd+7cQVRUlOiIwujr6/P7DxGRmhQUFCAxMRG1a9cWHYU0RHFxMbZt24aff/4ZzZo1Q5UqVZTmfX19BSVTr9TU1Pe+tnv37gCAKVOmfKg4H624uDiYmpqKjqE23bp1g5+fH+bPn4/mzZsDAP744w9ERkbC2dkZAHDu3DlJdJY3MDAoczw3Nxfbt29HQkICvv76a9jY2Kg5mTjv2sN27949NSUhItIcLL4mIvoIyGQy0RHULiEhAQMGDMDKlSsl9aXlfRUWFuL333/HqVOncOrUKZw7dw5mZmZo3bo1Fi5ciDZt2oiOSEREFcTjx4/fubFGivcqHh4eOH78OObMmYMxY8YAALy9veHs7AxfX1/89NNPiIiIgL29veCk6rd06VLMnj0bEyZMUPrvb9euHb7++muBydQvPT0da9asgZ2dHZycnNCuXTuEhYUpNm9Nnz4d48aNE5xSvR4+fIhdu3Zh586dyMvLQ9++fZGYmIjhw4dj8ODBLLwmIiIiIo3G7ol/39OnT/Hjjz9i4MCBoqOQhjh69CgMDQ0xc+ZMxVh+fr5KQWlFxy61qrgmqrgmZfvhhx9ER9A4XJOymZiYIDs7G3Xq1EFhYSEuXryo9Pfn+fPnku5sfPLkSXz11Ve4cuUKgNLfM+PGjYOjo6Pimv79+4uKpzHu3LmDVatWITw8XHQUIcLDw+Hi4gJvb2+ldz6dO3eWbKfJ/Px8rF+/Hr/88ouiU/pf/Z0iKCIiUtW6dWulPShyuRzPnz+Hnp4elixZIjAZaZJ///vfaNKkCQDg2rVrSnNS2sM0Y8aM97pOJpMhIyPjA6fRPOXdw8tkMlSuXBkWFhbo3r07WrVqpeZkYgUHByM8PByenp4oLi4GUHq4qouLi+LgAisrK4SGhoqMqRZv+55XUlICf39/LFu2DGvXrlVjKrHePOCvLHXq1PnwQYiINAiLr4mISCMdO3ZM0i8632bs2LE4d+4c6tevj9atW2P48OFYunQpT3YkIqIPol+/fggICECvXr1U5goKChAdHY2kpCScP39eQDpxcnJysHv3bpVTPh0cHLB3715ER0djzJgxklsXoPQlV3R0tMq4sbExHj9+LCCROA8fPkTdunUBAEZGRqhSpYpS1wwTExPk5uaKiidE165d0bNnTyxYsAAdOnSAlpaW6EhERERERO+N3RP/vjt37sDX15fF16SwYcMGjBw5EoaGhhg/fjzy8vLg5uYGbW1tSXW7ZpdaVVwTVVyT91dYWIjs7GxYWFhAR4dboQCuCQA4OTlh6dKl8PLywvfffw89PT20bNlSMX/p0iWYm5sLTCjOli1bEBYWhp49e2Ls2LEASg90mDx5Mnx9fTFq1CjBCTXH06dPsWfPHskWX58/fx6LFy9WGTc1NUVOTo6AROL5+/sjLS0NX3zxBWrVqiWpAi8iInXw8/NT+iyTyWBsbIzPPvsM1atXF5SKNM3mzZtFR9AImZmZoiNotIsXL+LixYsoKSlBw4YNAZQW62tra8PKygpbt25FZGQktm7dikaNGglOqz76+voICQmBr68vbt68CQAwNzeHvr6+4ppPP/1UVDyNoaWlhbFjx0ru0FAe8EdEpEqaT9eJiDSITCbD8+fPUblyZcjlcsXnvLw8AFD8v1Jz/vx5PHnyBF27dlWM7dmzB6tWrcKLFy/g7OyMhQsXQldXV2BKMU6fPo1atWqhXbt2aNOmDVq3bo0aNWqIjkVERBXUpEmT4OPjg8OHDyMgIEDxMis9PR2+vr7Q0tLCpk2bBKdUv61bt5ZbNKqnpwd/f3/07NlTzak0g4GBAXJyclQ2rWVkZMDU1FRQKnG46UZZ3bp1cfr0adStWxd169Zlp2siIiIi+qiwe6Kqd73DkOo7jr9rwIABSpvbKjILCwvEx8dj3Lhx0NLSwoEDB6Crq4t169ahatWqouOpDTexqeKaqOKavNuLFy+wePFi7NmzBwBw6NAhmJubY/HixTA1NcXkyZPFBhSAa/KnWbNmwcPDA6NHj0bVqlURGRmptL9g586d6Nixo8CE4qxbtw6+vr4YPXq00riDgwPWrl0rqeLrd3Upfl2MIFW6urpl3tNfv34dxsbGAhKJ93//939Yt26d0mEORET0z3FxcREdgYgqiO7du8PIyAjh4eGoVq0aAODZs2dYsGABWrZsiaFDh2Lu3LkIDw9HQkKC4LTq9+DBA+Tk5KB169bQ09NT1DDQn6pUqYKCggLRMTRKbm4u9u3bp/I8gYioImPxNRGRYHK5XKkwRy6XKz1AkuqXmdWrV6Nt27aK4utLly5hwYIFcHFxgbW1NRISElC7dm14eHgITqp+v/76K9LT05GWloa4uDjMmTMHDRs2ROvWrdGmTRu0adNGsi+5iIjon+fq6gonJyf4+Pigb9++8Pf3R3p6OrZt24YRI0bAy8sLenp6omOq3ePHj1GzZs23XiPFezgA6Nu3L6Kjo7Fy5UrIZDKUlJTg9OnTiIyMlGSns5UrV6JKlSoAgKKiIqxZswYGBgYASjdCSs3Bgwdx+vRpJCcn48svv0TDhg0xYMAAANL93wwRERERfTzYPVFVq1at3novL9V3HNevX8eqVasQHBys2Nj32rNnzxAYGIjZs2crfl6CgoJExBTG1tYWa9euhaurK+zs7LBu3TpJPl96E7vUquKaqOKaKFu6dCkyMzORmJiISZMmKcbbt2+P1atXS6rQ+DWuyZ+MjY2xZcsWPHv2DFWrVoW2trbS/MqVKyV18MdfPXv2DJ06dVIZ79ChA6KjowUkEmfGjBmQyWSQy+XlXiPF+9nXunXrhtjYWKxYsUIxdvv2bURHR6NHjx7igglkaGgIIyMj0TGIiCqcR48e4cWLF6hXr55i7D//+Q82bNiA/Px8ODs7o3///gITkiZ5+fIlNm/ejFOnTuHhw4cq93K7d+8WlEy9EhMT3/vasWPHfsAkmikhIQEbN25Uej5rYGAADw8PuLq6Yty4cZgxYwZcXV0FplS/x48fY/bs2Th16hRkMhkOHz4Mc3Nz+Pn5oXr16pg/f77oiBrjxIkTsLS0FB1DI5w8eRLJyck4cuQIqlSpwuJrIpIUvokhIhLs73z5lZJLly5h9uzZis8pKSmws7NDSEgIAMDMzAwxMTGSLL6uWrUqnJyc4OTkBKC0c8jp06dx6tQpxMfHw8vLC5aWlti/f7/gpEREVFE0atQI27dvh5eXFzw9PaGnp4eNGzeiTZs2oqMJ069fPwQEBKBXr14qcwUFBYiOjkZSUhLOnz8vIJ1Ynp6eCA4ORpcuXVBcXIy+ffuiuLgY/fr1w7Rp00THU6vWrVvj2rVris/29vYqXTJatWql7ljCtWzZEi1btoS/vz8OHDiAXbt2obi4GIGBgejfvz+cnZ15mBARERERaSR2T1Slr6+PqVOn4rPPPitz/saNG1i0aJGaU4mXkJAAMzMzlcJroHSDn5mZGeLj4yVTdD1w4MAyi5Z0dXVx//59jBgxQjEmlc2xf8Uutaq4Jqq4JmVLTU3F8uXL0aJFC6Xxxo0bIysrS0wowbgmql4fhvkmKRdPduvWDUeOHIGbm5vSeGpqKrp06SImlCC1atVCQEAAnJ2dy5zPyMjAoEGD1JxKc8yfPx8zZ86Eo6MjXr58iTFjxuDBgwdo0aIFPD09RccTYtasWVi5ciUiIyMVh+8SEdH/LiQkBLVr11YU/T18+BCjRo1C7dq1YW5uDl9fXxQXF0vywHdS5efnhxMnTqBnz56ws7OT7GE5X3311XtdJ5PJJFl8nZeXh4cPH6JRo0ZK448ePUJeXh6A0oN1ioqKRMQTJjw8HDo6Ojh69Ch69+6tGO/Tpw8iIiIkVXydmppa5vizZ89w4cIFJCcnK+oWpOjOnTvYuXMndu3ahTt37qBPnz5YvXo12rdvLzoaEZFasfiaiEgwKRctvc3Tp09hYmKi+JyWlqYoNgaA5s2b486dOyKiaZyqVavCyMgIRkZGqF69OnR0dHDlyhXRsYiIqAIpKipCTEwMjhw5gj59+uDYsWNYt24dLCwsYGZmJjqeEJMmTYKPjw8OHz6MgIAAVK9eHQCQnp4OX19faGlpYdOmTYJTiqGrq4uQkBDMmDED//73v/H8+XM0adJEkieBbt68Wenzo0ePAICFxf+fvr4+hg4diqFDh+LKlStITk7GihUrEBQUhAsXLoiOR0RERESkgt0TVTVp0gRA+e86DA0N39pFsKJKS0vDkiVLyp3v3bs35s6dq8ZEYpVXzESl2KVWFddEFdekbI8ePULNmjVVxl+8eCHZzfdcEyrPXxsDWFtbY+3atUhLS1MU6v/+++84c+YMJkyYICihGE2bNsWFCxfKvV95V1fsis7AwAAbN27E6dOnkZmZifz8fDRt2hSOjo6iowmzceNGZGVlwdHREfXr14eOjvIWXCkeJkRE9E/47bffEBERofi8Z88eVK9eHXv27IGOjg4SEhKwdetWFl8TAODo0aNYv349WrZsKTqKUD/88IPoCBqtW7du8PPzw/z589G8eXMAwB9//IHIyEjF/f+5c+ckt5/pxIkTisND/8rS0hK3b98WlEqMGTNmlDmur6+Phg0bIiQkBH379lVzKrGKiorw/fffIzk5Genp6ejUqRO8vb0xd+5cTJs2TeUwAyIiKWDxNRGRYCUlJYiPj8cPP/yAoqIitG/fHu7u7tDT0xMdTSgTExNkZ2ejTp06KCwsxMWLFzFz5kzF/PPnz1GpUiWBCcUpKSnB+fPncerUKZw6dQpnzpzBixcvYGpqirZt22LRokVo27at6JhERFRBZGRkwNvbG/n5+YiPj0e7du1w7949+Pv7o1+/fvDx8cGQIUNEx1Q7V1dXODk5wcfHB3379oW/vz/S09Oxbds2jBgxAl5eXpK/n6tTpw7q1KlT7ryDgwP27t0Lc3NzNaZSv9zcXCxfvhwpKSnIzc0FUFp80LdvX8yePRuGhoaCE2oGa2tr+Pj4YO7cuXxBSEREREQaj90T/9S/f38UFBSUO29iYgJ3d3c1JtIMd+7cKbPw7bUaNWrg7t27akwklhR/Bv4OdqlVxTVRxTUpW7NmzXD06FGMGTNGaXzHjh0qayUVXBMqz5td8QwNDXH58mVcvnxZMWZgYICdO3di+vTpak4njpubG/Lz88udt7CwUCpcl6qWLVu+tbipf//+WL9+/VvfC1UUPFiIiOjDePDgAerVq6f4/Msvv+Dzzz9XHHLRrVs3rF+/XlQ80jCmpqbQ19cXHYM0XHBwMMLDw+Hp6Yni4mIAgLa2NlxcXODr6wsAsLKyQmhoqMiYapefn1/mnrYnT55AV1dXQCJxMjMzRUfQOE5OTrCyssKAAQOwbNkyRUMaKR0mS0T0JhZfExEJtmbNGqxevRqOjo6oXLkyEhMT8fDhQ4SHh4uOJpSTkxOWLl0KLy8vfP/999DT01N6kXPp0qUKX6hTnlatWuHFixcwMTFB27Zt4evri7Zt28LCwkJ0NCIiqoCGDBkCFxcXzJ8/X/HiwtTUFHFxcdixYwciIiJw+PBhxMXFCU6qfo0aNcL27dvh5eUFT09P6OnpYePGjeV2+yJlUugU8eTJEwwbNgz3799H//79YWVlBQC4cuUKdu/ejZMnTyIpKUnxoJpKNWvWTHQEIiIiIiJ6T0OHDn3rvFSLrw0MDJCVlaW0afivsrKyUK1aNTWn0gzdu3dHcnIyatSooTSem5sLFxcXpKamCkomDrvUquKaqOKalM3T0xOTJk3C5cuXUVxcjMTERFy5cgVnz57F5s2bRccTgmtC5eGhl2Vr1arVW+erVq2q9N7n7t27qF27NrS0tD50tI9KdnY2Xr16JTqGWkjx+w0RkTpUq1YNz549U3w+d+4cvvzyS8VnmUyGwsJCEdFIA/n4+CA6OhpBQUHlPn+Tort37yI1NRV37txBUVGR0tzrYmMp0dfXR0hICHx9fXHz5k0AgLm5uVLh/qeffioqnjCtWrXCnj17MHv2bMXY60ZybPzF73zFxcWQyWSQyWTQ1tYWHYeISCNI8y8CEZEG2bt3LwICApCQkIB//etfWLt2Lb799luUlJSIjibUrFmzoK2tjdGjR2P79u0ICQlROlFr586d6Nixo8CE4nh7eyMlJQXHjh1DdHQ0hgwZwsJrIiL6YGJjY7F48eIyT4wdMmQI9u3bJ5nNFG8qKirCypUrceTIEfTp0weVKlXCunXrJNW5it4uNjYWurq6OHLkCIKDgzF+/HiMHz8eixcvxuHDh6Gjo4PY2FjRMTXK5cuX0b17d9ExiIiIiIjoA+nfvz/u3LkjOsYH16pVK3z99dflzicmJr61c2BFduvWrTLfgRUWFuLevXsCEon3ukvtm6TcpZZrooprUrZWrVph7969KC4uho2NDU6cOAFjY2MkJSVJ9oA/rgnRh9WnTx/cunVLdAwiIqIK57PPPkNiYiJKSkpw8OBBPH/+HO3atVPMX79+HWZmZgITkiZp3rw5Xr58CWdnZ9jb26NNmzZK/ydFJ0+eRK9evZCUlISNGzfi1KlT2LVrF3bu3ImMjAzR8YR68OABcnJyYGlpCX19fUk0i3ibefPmYfv27XBzc0NRURGWLFmCfv36IT09HV5eXqLjCSf173zHjh3D0KFDsX//fnTo0AEeHh44cuSIpA9/JCJi52siIsFu376Nzp07Kz47OjpCJpPh/v37kn5YZGxsjC1btuDZs2eoWrWqyulJK1euRNWqVQWlE2v48OEqY/3798f69etRp04dAYmIiKgi++t9Slnq1auHjRs3qimN5sjIyIC3tzfy8/MRHx+Pdu3a4d69e/D390e/fv3g4+ODIUOGiI5JgqWmpiIoKAgmJiYqc7Vq1cK8efMQGBgIPz8/AemIiIiIiIjUTyod8aZMmYJhw4Zh5syZcHNzQ8OGDQEAV69eRXx8PI4fP46kpCTBKdXrrx2tjx07BgMDA8XnkpISnDx5UrKditilVhXXRBXXpHwWFhYICQl56zXr16/H8OHDYWhoqKZUYnFN6F3Cw8PLHJfJZKhcuTIsLCzQvXt3GBkZqTfYR0DqhRoE2NravrXwQOrFTURE/61Zs2Zh/PjxsLOzQ3FxMaZMmYLq1asr5g8cOIDWrVsLTEiaZM6cObh//z48PT1hYmLCokAAS5cuhaurK2bOnAl7e3vExMTA2NgYXl5e6NSpk+h4Qjx+/BizZ8/GqVOnIJPJcPjwYZibm8PPzw/Vq1fH/PnzRUcUwsbGBocOHcLXX38NfX195Ofn4/PPP8eoUaNQu3Zt0fGEk/p3vsqVK2PAgAEYMGAAsrKysHPnToSEhODVq1dYs2YNBg0ahHbt2rErNhFJCouviYgEKy4uRuXKlZXGdHR0UFRUJCiRZvnr5hsAOHXqFD777DO+5HuDVDasERGR+q1YsQLu7u7Q0Sn76+Pt27exYMECyRVgDxkyBC4uLpg/f76iK7ipqSni4uKwY8cORERE4PDhw4iLixOclES6f/8+GjduXO68jY0NcnJy1JhIPBcXl7fOFxQUqCkJERERERHRh9OkSROsWrUKfn5+OHLkiGJcLpejRo0aWLFiBZo2bSowofrNmDEDQGlR15sbG3V0dFCvXj3Jbnh83aV2/fr1ii61TZo0QVJSEj755BPR8YTgmqjimvxv1q5di969e7PQ+C+4JtJ28eJFXLx4ESUlJYpDYq5duwZtbW1YWVlh69atiIyMxNatW9GoUSPBaYk0y+rVq5U+v3r1ChkZGdi9ezc8PDwEpSIi+vjZ2toiJSUFZ86cQa1atfDZZ58pzfft2xfW1taC0pGmOXv2LL755hvY2tqKjqIxrly5gmXLlgEofdZWUFAAfX19zJo1C9OnT8fIkSMFJ1S/8PBw6Ojo4OjRo+jdu7divE+fPoiIiJDss0igdG/+tGnTRMcgDWdhYQFPT0/MmjULx44dw86dOzFlyhTo6+vj1KlTouMREakNi6+JiASTy+WYP38+dHV1FWOFhYUIDAxElSpVFGNvPryXqokTJ2Lv3r18kEZERKQme/bswdGjRxEVFQUbGxuluaSkJERFRcHBwUFQOnFiY2PL7Qo+ZMgQODo6wt/fX82pPi5SOHm4Ro0ayM7OhpmZWZnz2dnZSqd1S8Hly5fRt29f1K9fv8z5+/fv4/r16+oNRURERERE9AF07doVP/74I44dO4YbN25ALpejYcOG6NixI/T09ETHU7vMzEwAQLdu3ZCcnAxjY2PBiTQLu9Sq4pqo4pr896TetagsXBNpe93VOjw8HNWqVQMAPHv2DAsWLEDLli0xdOhQzJ07F+Hh4UhISBCclkizODs7q4z16tULjRo1QkpKCoYMGSIgFRFRxWBsbFzm71kA6NKli9Ln/v37Y/369ahTp44akpGmsbKy4sHub6hataqi6VetWrWQlZWlaBbw+PFjkdGEOXHiBBISElT27FhaWuL27duCUmmGp0+fIjk5GVeuXAEANGrUCIMGDWJjNABTp06V3F6ud9HS0kLnzp3RuXNnPHr0CHv37hUdiYhIrVh8TUQk2MCBA1UKTwYMGCAojeYoryPeq1ev4OHhoegWvnv3bnXG0litWrVS6aBORET0T9i/fz+Cg4MxePBguLu7Y9KkSbh79y78/Pzwxx9/wMfHB8OGDRMdU+3KK7x+rV69epLrBv53SWFzX8eOHbFixQps2LBB6bAloPTApZUrV6JTp06C0onRuHFj2NnZlXuqckZGBnbs2KHmVERERERERP+ss2fP4smTJ+jatSs+//xzAKXvM8LCwvDixQs4Oztj4cKFKt8VpeCHH34QHeGjxS61qrgmqrgmRPQ+EhISsHHjRkXhNVDa+czDwwOurq4YN24cZsyYAVdXV4EpiT4uLVq0wKJFi0THICKSjOzsbLx69Up0DBJk7ty5iIiIgKenJ2xsbFCpUiWl+b/e50rFZ599htOnT8Pa2hqdO3dGZGQk/v3vf+PIkSMqneSlIj8/v8xDMJ88eSLJ57Kv/frrr5g6dSoMDAzQrFkzAMDmzZsRGxuLtWvXonXr1oITijVlyhTRETTOXw88MTY2xoQJE0RHIiJSKxZfExEJFhERITqCRvr3v/+N9u3bo0WLFooxuVyOzMxMtG3bFjVr1hQXTgPFxcWJjkBERBVUtWrVEBUVhR49eiAgIAApKSnIzs6GnZ0d9u3bh3r16omOqDHy8/ORkpKCly9fokOHDrC0tBQdSaNcuXIFycnJ8PHxAVB6/2Jqaio41Yc1a9YsDB48GD179sTIkSNhZWUFuVyOq1evYuvWrSgsLERUVJTomGrl4OCAa9eulTuvr6+PVq1aqTERERERERHRPy82NhZt2rRB165dAQCXLl3CwoULMXDgQFhbWyMhIQG1a9eGh4eH4KRinDt3DqdOncKjR49QUlKiNOfr6ysoleaTwkF2fxfXRBXXhIjeR15eHh4+fIhGjRopjT969Ah5eXkAAENDQ0XnPPrTm80VqFRwcLCk9/EUFBQgMTERtWvXFh2FiIhIEtzc3AAA48aNU7o/k8vlkMlkyMjIEBVNGF9fXzx//hwA4OHhgefPnyMlJQWWlpaYP3++4HRitGrVCnv27MHs2bMVYyUlJYiPj0fbtm3FBRMsODgYffr0QWBgILS1tQEAxcXFCAoKQnBwML799lvBCdVPLpfj4MGD5T6zXr16taBkmoEHnhCR1LH4mohIMHd393deo62tjVq1asHR0RHdunVTQyrxEhMTMX/+fNjZ2cHd3R1aWloASk9rHzVqlMpLQCn59ddf3+s6qZ8+RkRE/6wWLVrAxsYGJ0+eRJUqVTBt2jRJF17fvn0b3t7euHDhAlq0aIHQ0FBMmDABN27cAADo6ekhLi5O8n+P8/PzceDAAezcuRO//fYbGjVqpCi+lkKBrZmZGZKSkhAUFIRly5YpNr/KZDI4Ojpi0aJFqFOnjuCU6uXv7//WeQsLC2zevFlNaYiIiIiIiD6MzMxMzJo1S/E5JSUFzZs3R0hICIDS74sxMTGSLL5eu3YtVqxYgYYNG8LExERpjsVMRERE6tGtWzf4+flh/vz5aN68OQDgjz/+QGRkJJydnQGUHpbCQ2ZVSfGQi5MnT+Krr77ClStXAADW1tYYN24cHB0dFdf0799fVDy1a926tUqR1/Pnz6Gnp4clS5YITEZERCQdiYmJoiNoHHNzc8W/q1atiuDgYIFpNMO8efMwfvx4nD9/HkVFRViyZAkuX76Mp0+fYtu2baLjCXPjxg2sXLlSUXgNlNYpjB8/Hnv27BEXTKDQ0FB88803aNu2LUxMTPicmoiIlLD4mohIMAMDg3deU1JSguvXr2PHjh1wdXVV2rBTUbVs2RK7du1CQEAAhg8fjujoaFhYWIiOpRHGjBmj+GJX3os9qZ7eR0REH8b+/fuxePFi2NraIiUlBcnJyXB1dcXIkSMxd+5cVK5cWXREtYuMjERRURGCgoLw3XffYeLEibC0tMSWLVugpaWFwMBAxMTESPaFz+nTp5GcnIyDBw+ioKAA48ePR2hoKKytrUVHUztzc3PEx8fj6dOniuJ8CwsLGBkZiQ1GREREREQkgFQ64j19+lSpsDgtLQ1OTk6Kz82bN8edO3dERBMuMTERYWFhGDRokOgoREREkhUcHIzw8HB4enqiuLgYQOlmexcXF/j6+gIArKysEBoaKjKmMK/v08o6PDUlJUVS3Y23bNmCsLAw9OzZE2PHjgUA/P7775g8eTJ8fX0xatQowQnVz8/PT+mzTCaDsbExPvvsM1SvXl1QKiIiImlp06YN0tPTkZSUhJs3b2LVqlUwNTXFnj17UL9+fdHxhHv+/LnK3uJq1aoJSiOOjY0NDh06hK+//hr6+vrIz8/H559/jlGjRknqnv5NTZo0wdWrV2FlZaU0fvXqVdja2gpKJda+ffuwevVqdO7cWXQUjdSqVStJ7g8lInqNxddERIKFh4e/97U//vgjgoKCJFF8DZQWpi9btgw7d+7EyJEj4eHhwdOkAFSvXh36+vpwcXHBF198gRo1aoiOREREFZiHhweOHz+OOXPmYMyYMQAAb29vODs7w9fXFz/99BMiIiJgb28vOKl6paenY82aNbCzs4OTkxPatWuHsLAwxcbq6dOnY9y4cYJTqtfDhw+xa9cu7Ny5E3l5eejbty8SExMxfPhwDB48WJKF139VvXp12NnZiY4h3IoVK+Du7g4dnbIfSd2+fRsLFizAxo0b1ZyMiIiIiIj+V+yI9ycTExNkZ2ejTp06KCwsxMWLFzFz5kzF/PPnz1GpUiWBCcXR0tKCg4OD6BhEJAEFBQXQ09MDwE2ir3FNCACKi4tx8eJFzJs3D76+vrh58yaA0oNE9fX1Fdd9+umnoiIK8erVK6xevRqbN29Gfn4+gNKOgaNHj4a7u7vi3q2sguyKbN26dfD19cXo0aOVxh0cHLB27VpJFl+7uLi813WBgYGYOXMmjI2NP3AiIiIi6Tl06BC8vb3Rv39/XLx4EYWFhQCAvLw8rFu3Dq1atRKcUP1u3ryJxYsXIy0tDS9fvlSMy+VySTdzMjAwwLRp00TH0Chjx45FaGgobty4gc8++wxA6QFLW7ZsgZeXFzIzMxXXSqUYu1q1ajy44S3i4uJERyAiEorF10REH5GWLVuiWbNmomOo3eDBg9GyZUt4eXnh1atXouMId+zYMXz//ffYuXMn4uPj0blzZwwePBhOTk4sTicion9cTk4Odu/eDUtLS6VxBwcH7N27F9HR0RgzZgzOnz8vJqAgDx8+RN26dQEARkZGqFKlilJHKxMTE+Tm5oqKJ0TXrl3Rs2dPLFiwAB06dICWlpboSKSB9uzZg6NHjyIqKgo2NjZKc0lJSYiKiuImfCIiIiKijxA74ilzcnLC0qVL4eXlhe+//x56enpo2bKlYv7SpUswNzcXmFCccePGYcuWLViwYIHoKERUAYSEhMDf319lPD8/H1OmTMHmzZsBSGuTKNeE3kVbWxuurq5ISUmBubm5ZDbTv8vixYtx5MgRzJs3Dy1atAAA/Pbbb1i9ejWePHmCoKAgsQEFefbsGTp16qQy3qFDB0RHRwtI9PHYt28fJk6cyOJrIiKiD2DNmjUICgrCwIEDceDAAcW4g4MD1qxZIzCZOPPmzQMAhIWFoWbNmtxL/P89ffoUycnJigNDGzVqhEGDBsHIyEhsMIHmzJkDAFiyZEmZczKZTHJF+x4eHoiNjUVYWJji0DqpunbtGp49e6bUYOTkyZP417/+hRcvXsDZ2RlTp04VmJCISP1YfE1E9BExNDTE6tWrRccQwtLSEtu3b8fz589RrVo10XGE0tXVRZ8+fdCnTx/cvn0bu3btwuLFi1FYWAgXFxd4eHiU20mQiIjo79q6dWu5RbR6enrw9/dHz5491ZxKM/BFhbK6devi9OnTqFu3LurWrSv5TtdUtv379yM4OBiDBw+Gu7s7Jk2ahLt378LPzw9//PEHfHx8MGzYMNExiYiIiIjob2JHPGWzZs2Ch4cHRo8ejapVqyIyMhK6urqK+Z07d6Jjx44CE4ozceJETJ48Gc7OzmjUqJHK+wypvgcrD7vUquKaqJLymhw9ehSGhoaYOXOmYiw/Px9ubm4CU4nFNaH30bhxY2RnZ0v2MJiy7N+/H8uWLUPnzp0VY7a2tqhTpw7mzJkj2eLrbt264ciRIyq/Q1JTU9GlSxcxoT4ScrlcdAQioo/K2LFjsXr1ahgaGr7X9cHBwahZs+YHTkWa6tq1a2V2tzYwMJBco4TXLl26hJ07d8LKykp0FI3x66+/YurUqTAwMFA0Ptu8eTNiY2Oxdu1atG7dWnBCMVJTU0VH0Di9e/fG/v370b59e9SvX1/lmfXu3bsFJVO/6Oho2NjYKIqvb968ialTp6JVq1b45JNPsG7dOujp6WH8+PFigxIRqRErs4iI6KOhpaUFAwMD0TE0St26deHu7o4vvvgCCxYswPr16zFhwgRJn8pGRET/rMePH7/zhZVUi5BXrlyJKlWqAACKioqwZs0axb3KixcvREYT4uDBgzh9+jSSk5Px5ZdfomHDhhgwYAAA6f6MkKpq1aohKioKPXr0QEBAAFJSUpCdnQ07Ozvs27cP9erVEx2RiIiIiIj+C+yIp8zY2BhbtmzBs2fPULVqVWhrayvNr1y5ElWrVhWUTqyQkBCcOnUKbdu2hZGREZ8ZgF1qy8I1UcU1KduGDRswcuRIGBoaYvz48cjLy4Obmxu0tbUltxavcU3ofcyePRuRkZGYNWsWmjZtqnJfIsUD8XV1dVG/fn2V8fr166NSpUoCEomTmJio+Le1tTXWrl2LtLQ0RUfw33//HWfOnMGECRMEJSQiooooLS0NRUVF7319//79P2Aa0nQmJibIyspSuX87ffq0ZA8YatasGe7evcvi678IDg5Gnz59EBgYqHg+W1xcjKCgIAQHB+Pbb78VnFAM7stR5ePjgwsXLmDAgAEwMTGR9DPr8+fPKx2+9e2338LS0hIJCQkAgE8++QRff/01i6+JSFJYfE1ERB+lzMxMuLi4ICMjQ3QUYQoLC3Ho0CHs3LkTv/32Gzp37ox169ax8JqIiP5R/fr1Q0BAAHr16qUyV1BQgOjoaCQlJeH8+fMC0onTunVrXLt2TfHZ3t4eN2/eVLqmrFN2K7qWLVuiZcuW8Pf3x4EDB7Br1y4UFxcjMDAQ/fv3h7OzM4yNjUXHJA3QokUL2NjY4OTJk6hSpQqmTZvGFzxERERERB8xdsQrW3kHykr5Of7u3bsRExMj6Z+LN7FLrSquiSquSdksLCwQHx+PcePGQUtLCwcOHICuri7WrVsn2UMuuCb0PiZPngwAmDZtmtKmcrlcDplMJsl9GKNGjcK//vUvhIeHQ1dXF0Dpnow1a9Zg9OjRgtOp11dffaX02dDQEJcvX8bly5cVYwYGBti5cyemT5+u5nREREREwNChQxEaGoqwsDDIZDLcu3cPZ8+eRWRkpGTvT0JDQxEQEIB79+6hcePGKp17bW1tBSUT58aNG1i5cqXSwReLjKUAAH0lSURBVJja2toYP3489uzZIy6YAKmpqXByckKlSpXe2fm6atWqsLKygqmpqZrSiffTTz8hPj5eknv93vT48WOYmZkpPp86dQpdu3ZVfG7bti0iIyNFRCMiEobF10RE9NGSy+WiIwhx7tw57Ny5EykpKahXrx4GDRqEFStWSHqzFhERfTiTJk2Cj48PDh8+jICAAFSvXh0AkJ6eDl9fX2hpaWHTpk2CU6rf604yrz169AgAWFj8/+nr62Po0KEYOnQorly5guTkZKxYsQJBQUG4cOGC6Hgk2P79+7F48WLY2toiJSUFycnJcHV1xciRIzF37lxUrlxZdEQiIiIiInoP7IhH/w0jIyPJdiAqD7vUquKaqOKalM/W1hZr166Fq6sr7OzssG7dOujp6YmOJRTXhN7lr/dxUubu7q70+eeff4aTk5OiMCUzMxNFRUVo3769iHjC/PDDD6IjEBGRRF2+fBk5OTlvvUaKBaSkavLkySgpKcH48ePx4sULjB49Grq6unB1dcWYMWNExxPi0aNHyMrKgq+vr2JMJpNJ+oClJk2a4OrVqyrdwK9evSq53yUzZszAiRMnULNmTcyYMeOd12tra2PevHmS6W5sZmaGatWqiY6hEapXr46cnBzUqVMHJSUlOH/+vNI7nqKiIsnWbxCRdMnk/M1HREQa6M2XXG969uwZ0tLSJPlAwNbWFnXr1sXAgQPRtGnTcq/r3r27GlMREVFFdvnyZfj4+ODevXvw9/dHeno6tm3bhhEjRsDLy0uym7Zyc3OxfPlypKSkIDc3F0Dp6f99+/bF7NmzYWhoKDihZnn16hV++OEH9OjRQ3QUEsjDwwPHjx/HnDlzlF56njlzRvESMCIiAvb29qIiEhERERHRe+rWrdt7XSeTyd7ZTYOkY+fOnTh27BjCw8NRpUoV0XE0RmZmJsaNG4cZM2awS+3/xzVRxTUpNXDgQKVOva/dvn0bxsbGSs+rd+/erc5ownBN6EMJDAzEzJkzK+zBs38tTHmX8PDwD5iEKiJ7e3vs27ePBw8REb0nW1tbRaHom6ReQErlKywsRFZWFvLz82FtbQ19fX3RkYTp06cPrK2t4ebmhpo1a6p8R6xXr56gZOKkpKRgyZIlGD16ND777DMApQeGbtmyBV5eXkpF2VIrxn6bwsJC7N+/H8uWLcPx48dFx1GLo0ePYvPmzQgKCkL9+vVFxxFq7ty5eP78OQICAnDw4EGsWrUKJ06cUDx/PHToEGJjY7Fv3z7BSYmI1IfF10REpJGaNm0KR0dHmJiYlDn/5MkTHD16VJIP097nSz4fNBIR0T+tuLgYXl5eOHjwIPT09LBu3Tq0adNGdCxhnjx5gmHDhuH+/fvo37+/4oH8lStXsH//fpiZmSEpKUnRKZxKi6/v37+PunXrio5CAg0fPhwRERGwtLRUmSsoKEB0dDSSkpJw/vx59YcjIiIiIiKiD27gwIHIysqCXC5H/fr1oaOjozQv5aLAs2fPskvtG7gmqrgmwOrVq9/72ncd+F1RcE3oQ3FwcMDevXtZPCph5RWdy2QyVK5cGRYWFujevTuMjIzUG0ygoqIiVKpUqcy5R48eKQ4rCAgIwKxZsyrs4QVERP80W1tb7Nix452/N6VYQEr0Plq0aIG9e/eiQYMGoqNojHfttebBDuXLy8vD9OnTER0djdq1a4uO88G1bt0aL168QHFxMfT09FTu99PS0gQlU7/s7Gy4uroiKysL2traWLBgAUaOHKmYnz59OurXrw8/Pz+BKYmI1IvF10REpJH69++PsWPHYsiQIWXOZ2RkYNCgQfzCS0REpAZFRUWIiYnBhg0b0LNnTxw7dgzNmzdHaGgozMzMRMcTIjQ0FL/88gs2btyoclhMTk4OXF1d0b59ez5o/IvMzEy4uLjw/k3iSkpKoKWl9dZrfv31V7Ru3VpNiYiIiIiIiEid3lUgKJWiQHapVcU1UcU1ISLRpNi59+HDh7h27RoAoGHDhqhZs6bgRGKNGTMGFy9eRElJCRo2bAgAuHbtGrS1tWFlZYVr165BJpNh69ataNSokeC06uHh4YFVq1ap/I1+8OABxo8fj/379wtKRkT0cbO1tcWJEyck/7eX6L81depUuLi4oGfPnqKjaIxbt26997U82EGVlA7jetdzNRcXFzUl0QyvXr3C5cuXUaNGDZiamirNZWZmwtTUFDVq1BCUjohI/XTefQkREZH6NWvWDBcvXix3XldXF3Xq1FFjIiIiImnKyMiAt7c38vPzER8fj3bt2uHevXvw9/dHv3794OPjU+5hKRVZamoqgoKCVAqvAaBWrVqYN28eAgMDWXxN9IbHjx+/84V5WZuKiYiIiIhIs7EjHr0vqRRXv4uzs7PoCBqHa6KKa/Ju3bt3R3JyssqGz9zcXLi4uCA1NVVQMnG4JkT/nby8PAQFBSElJQXFxcUAAG1tbfTu3RsBAQEwMDAQnFCM1/fw4eHhqFatGgDg2bNnWLBgAVq2bImhQ4di7ty5CA8PR0JCguC06nH79m0sWLAAYWFhirGcnByMHTsWjRs3FpiMiIiIpKxr164IDw/Hv//9b9jY2EBHR7lMqHv37oKSicOC6v+NlHp8Sq24+l10dHTK7Rz/ro7yREQVETtfExGRRiosLERxcTGqVKkiOorG+u6773DgwAFcv34dAGBpaYl+/fqhV69eYoMREVGF0qxZM7i4uGD+/PnQ19dXmtuxYwciIiLg4OCAuLg4QQnFaNasGb7//vtyO3/fvXsXn3/+Of744w81JxPnXQ+iCwoKcP36dXa+lrj27dsjICCgzHvWgoICREdHIykpCefPnxeQjoiIiIiI/lvsiEfv69y5c5DL5fjss8+Uxn///XdoaWmhefPmgpIR0ceovO54Dx48QJcuXST5jIlrQv8kKXW+nj17NjIyMuDv7w97e3sAwNmzZxEaGopPP/0Uy5cvF5xQjE6dOmHjxo0q9/D/+c9/4OrqimPHjuHChQtwdXXFqVOnBKVUr0ePHmHUqFFwcnKCr68v7t27h7Fjx8LW1hbLly+HlpaW6IhERB+lMWPGIDY2FoaGhqKjEH2U3lYQKZPJJLNXJzU1FU5OTqhUqdI7Dx+rWrUqrKysVDr7UikpfR/86aefoKWlhU6dOimNHz9+HMXFxejcubOgZOpX3uGpBgYGsLS0xJAhQ2BsbKzmVEREYrHzNRERaSRdXV3RETRWSUkJ5syZg4MHD8LS0hJWVlYASl9ueXp64tChQ1i2bBk7BhIR0T8iNja23AeIQ4YMgaOjI/z9/dWcSrwaNWogOzu73OLr7OxsVK9eXc2pxLp8+TL69u2L+vXrlzl///59xaExJF2TJk2Cj48PDh8+jICAAMX/TtLT0+Hr6wstLS1s2rRJcEoiIiIiIvq72BGP3ldwcDDc3NxUiq/v3buHuLg47NixQ1AycdilVhXXRBXXRNlf/3uPHTum1JG2pKQEJ0+elFyHK64J0f/m6NGjiI+PR6tWrRRjnTp1QkhICNzc3AQmEysvLw8PHz5UKb5+9OgR8vLyAACGhoYoKioSEU8IY2NjbNiwASNHjgRQ+rPTpEkTREdHs/CaiOh/sHr1auzduxcuLi6KZ0uvPXv2DHv27ClzjohKZWZmio6gEWbMmKE4kGzGjBnvvF5bWxvz5s3D+PHjP3w40ljR0dHw8vJSGS8pKcHSpUslVXz91+dJf5Wbm4vt27cjISEBX3/9NWxsbNScjIhIHBZfExGRRiouLkZCQgJ++OEHFBUVoX379nB3d4eenp7oaMIlJibi5MmTWLNmDbp27ao0l5qaCj8/P2zatIkPA4iI6B/xroeH9erVw8aNG9WURnN07NgRK1aswIYNG1QOjSksLMTKlStVTsOs6Bo3bgw7OzvFZpM3ZWRkSHIDNSlzdXWFk5MTfHx80LdvX/j7+yM9PR3btm3DiBEj4OXlxXt+IiIiIqKPUEJCAjZu3Ki0AdbAwAAeHh5wdXXFuHHjMGPGDLi6ugpMSZrgypUraNq0qcr4p59+isuXLwtIJN6tW7dQUlKiMl5YWIh79+4JSCQe10QV10TZ6w3UMpkM8+fPV5rT0dFBvXr1VMYrOq4J0f/GyMiozE3m1apVk3QHzm7dusHPzw/z589H8+bNAQB//PEHIiMj4ezsDAA4d+4cLC0tBaZUvzp16mDDhg0YNWoUHB0dsWTJEjZIICL6H23ZsgWZmZkYM2aMypyBgQHS09ORl5eHadOmCUhH9HHKzc2V3L3sX4vQ31WQXlhYiP3792PZsmXcby1xN27cgLW1tcq4lZUVsrKyBCQSJzw8vNy5kpIS+Pv7Y9myZVi7dq0aUxERicXiayIi0khr167F6tWr4ejoiMqVKyMxMREPHz586029VOzcuRPz5s1TKbwGSk+99/LyQmJiIh8GEBHRB5Ofn4+UlBS8fPkSHTp0kNyGCgCYNWsWBg8ejJ49e2LkyJGwsrKCXC7H1atXsXXrVhQWFiIqKkp0TLVycHDAtWvXyp3X19dX6hhB0tWoUSNs374dXl5e8PT0hJ6eHjZu3Ig2bdqIjkZERERERP8ldsSj96Wrq4sHDx7A3NxcaTwnJwc6OtLavsAutaq4Jqq4JmV7vYG6W7duSE5OhrGxseBE4nFN6EMYMGAA9PX1RcdQi2nTpiEiIgJRUVGoVasWgNL7kyVLlmD69OmC04kTHByM8PBweHp6ori4GEBpd0AXFxf4+voCKC1ICA0NFRnzg2vdunWZxdUvXrzAjz/+iLZt2yrG0tLS1BmNiKjCOHTo0FsPCxo+fDgiIyNZfE1UjvXr16N+/fro06cPAGDmzJk4fPgwatWqhbi4ONja2gpOqHl0dXXRo0cP7NmzB/fv30ft2rVFRyJBDAwMcPPmTdSvX19pPCsrC1WqVBGUSvNoaWlh7NixcHNzEx2FiEitZHK5XC46BBER0Zt69OgBV1dXDB8+HADw888/Y/LkyTh37hy0tLQEpxPLzs4OBw8eRN26dcucv3XrFnr37o1z586pORkREVVEt2/fhre3Ny5cuIAWLVogNDQUEyZMwI0bNwAAenp6iIuLQ+vWrQUnVb+bN28iKCgIJ06cwOuv1jKZDI6Ojli0aBEaNGggOCGRZioqKkJMTAw2bNiAnj174tixY2jevDlCQ0NhZmYmOh4REREREf0X5s6di99++63Mjnj29vZYsmQJDhw4gISEBOzatUtwWhJpzpw5yMnJwb/+9S9FEWlubi5mzJgBY2NjrFy5UnBC9Xm96VUmk+HNbRt/7VJb1mG8FRXXRBXXhIj+SdevX8eqVasQHByMatWqKc09e/YMgYGBmD17tsohKVIwcOBA3LhxA0VFRahTpw4A4M6dO6hUqZLKIcS7d+8WkFD9iouLcebMGdjY2EBHRwc3b94EAJibm0umKP+1v/P/5y4uLh8wCRFRxWVvb48DBw6Uuyfy9u3b6NevH86cOaPmZEQfh27duiE6OhoODg44ceIEZs+ejeXLl+O7777DnTt3sGHDBtERNZaDgwP27t0rye9Bb7Nu3TqMGDFCEt3TFy1ahLNnzyI2NhYWFhYASrthe3h4KPYzUakbN25g8ODBSE9PFx2FiEhtpHV0NBERfTRu376Nzp07Kz47OjpCJpPh/v37ki/I0NPTQ25ubrkPGvPy8lC5cmU1pyIioooqMjISRUVFCAoKwnfffYeJEyfC0tISW7ZsgZaWFgIDAxETE4PExETRUdXO3Nwc8fHxePr0qaIY3cLCAkZGRmKDEWmwjIwMeHt7Iz8/H/Hx8WjXrh3u3bsHf39/9OvXDz4+PhgyZIjomERERERE9DexIx69Lx8fH4waNQpdu3bFp59+CqC0W2vNmjURFRUlOJ16sUutKq6JKq7Ju507dw6nTp3Co0ePUFJSojT3+m+Q1HBNqDwJCQkwMzNTKbwGSjt9mZmZIT4+HkFBQQLSieXs7Cw6gsbR1taGq6srUlJSYG5uLuluiSyoJiL68LS1tXH//v1y90Tev39f8k17iN7mwYMHikOEfvzxR/Tu3RsdO3ZEvXr1MHToUMHpNJsUelmmpqa+97Xdu3cHAEyZMuVDxdE48+bNg5ubG3r37g1TU1MAwL1799CyZUv4+PgITqdZTpw4oXJAGRFRRcfiayIi0kjFxcUqBcQ6OjooKioSlEhztGjRAtu2bSv3heeWLVvQokUL9YYiIqIKKz09HWvWrIGdnR2cnJzQrl07hIWFwcTEBAAwffp0jBs3TnBKsapXrw47OzvRMYRbsWIF3N3doaNT9qOG27dvY8GCBdi4caOak5EmGTJkCFxcXDB//nxFZwxTU1PExcVhx44diIiIwOHDhxEXFyc4KRERERERva/i4mJcvHgR8+bNg6+vb7kd8V4X2pK0mZqaYt++ffj222+RmZkJPT09DB48GH379kWlSpVExxPihx9+EB1B43BNVHFNyrZ27VqsWLECDRs2VDyzfk0mkwlKJRbXhN4mLS0NS5YsKXe+d+/emDt3rhoTaQ53d3fRETRS48aNkZ2dzS6ARET0wX366af4/vvvy933eOTIET5bInoLQ0ND3LlzB3Xq1MGxY8cwe/ZsAKWFxa8PyyTpmjFjxntdJ5PJkJGR8YHTaB4DAwMkJSXhxIkTimfWn3zyCVq3bi06mtqVV6j/7NkzXLhwAcnJyQgJCVFzKiIisVh8TUREGkkul2P+/PnQ1dVVjBUWFiIwMBBVqlRRjK1evVpEPKGmTp2KsWPH4smTJ5g4cSKsrKwgl8tx5coVbNiwAT/88AM2bdokOiYREVUQDx8+VJwsbGRkhCpVqiht2DIxMUFubq6oeKRB9uzZg6NHjyIqKgo2NjZKc0lJSYiKioKDg4OgdKQpYmNj0blz5zLnhgwZAkdHR/j7+6s5FRERERER/S/YEY/+rqpVq2LYsGGiY2gUdqlVxTVRxTVRlZiYiLCwMAwaNEh0FI3BNaG3uXPnDmrWrFnufI0aNXD37l01JtIcv/zyC9q1a1fmXFJSEoYPH67mRJph9uzZiIyMxKxZs9C0aVNUrVpVab6sLuoVVVFREZYvX44jR46gevXqGD58OL788kvF/IMHD9CpUydJFqsQEf0TRo8ejTlz5sDMzAwjRoyAtrY2gNJD/7Zu3YpNmzYhOjpacEoizdWjRw94eXmhQYMGePLkCZycnAAAGRkZaNCggeB0JFpmZqboCBpPJpOhY8eO6Nixo+goQpVXqK+vr4+GDRsiJCQEffv2VXMqIiKxWHxNREQaycXFRWVswIABApJoHgcHByxfvhwLFy7E4cOHleYMDQ2xdOlStGzZUlA6IiKqiNgNg97H/v37ERwcjMGDB8Pd3R2TJk3C3bt34efnhz/++AM+Pj7cWE3lFl6/Vq9ePXZHJyIiIiL6CLEjHr1Ned0yytK9e/cPmEQzsUutKq6JKq5J2bS0tHjg4xu4JvQ2BgYGyMrKQr169cqcz8rKklQx7V+5ublhzJgxmDNnDipVqgQAePToEfz8/HD69GnJFl9PnjwZADBt2jSlvzdyuVxyXfHWrl2LvXv3wtXVFbm5uYiIiMC5c+cQHBysuEYulwtMSET0cevZsyfc3NwQEhKC5cuXK54x3bx5E/n5+Zg4cSJ69eolOCWR5vL19UW9evVw584dzJs3D/r6+gCAnJwcjBw5UnA6Is2TmJj43teOHTv2AybRLCzUJyJSJZPziQ8REdFH6cWLFzh+/DiuX78OAGjYsCE6dOig1BmciIjof2Vra4uhQ4cq/r5s2bIFAwYMgIGBAYDSv0c7duyQ1OYKervvv/8eAQEBMDExQXZ2Nuzs7BASElLuZi6SlhUrVsDd3R06OmWfB3j79m0sWLCABdhERERERB+Z//u//8OyZcvYEY/K9GY3dJlMplSY8tdCHik+Y3J0dISXlxe71P4F10QV16RscXFxuH//PhYsWCA6isbgmtDbzJo1C69evUJsbGyZ89OmTUOlSpWwatUqNScT78yZM/Dx8UHVqlWxdOlSZGdnY8GCBWjYsCEiIyMl+44jLS3trfNt2rRRUxLxevToAV9fX3Tt2hUAcOPGDUyaNAktW7ZEWFgYHj58yM7XRET/gHPnzuHbb7/FjRs3IJfLYWlpif79+8POzk50NKIKYfLkyQgJCUHt2rVFR9EY9vb22LdvX4U+WJSFxqq6deum9Pnx48d48eIFDA0NAQC5ubmoUqUKjI2N/9bhohXR3bt3Ubt2bWhpaYmOQkQkBIuviYjoo5KXl4dffvkFDRs2hLW1teg4REREFd6YMWPe67rNmzd/4CT0sXjw4AHmzZuHkydPokqVKli3bp2kNt/Q23Xp0gVGRkaIioqCjY2N0lxSUhKioqLg4OCA+Ph4QQmJiIiIiOi/8dfiWql3xKO3+/nnnxEdHQ1PT0/Y29sDAM6ePYsVK1Zgzpw56NChg+CE6texY0d8/fXXsLS0FB1FY3BNVHFNylZSUoLJkyfj+vXraNSokcqBf6tXrxaUTByuCb3NxYsXMWzYMHTt2hVubm5o2LAhAODq1auIj4/H0aNHkZSUhKZNmwpOKsbz588REBCAQ4cOQS6XY+bMmZg0aZLS/S2VLTAwEDNnzoSxsbHoKB/MZ599hgMHDqB+/fqKsXv37mHs2LFo3rw55s2bhy5duvC7DxHRPyA9PR3btm1DdnY2Vq1aBVNTU+zZswf169dHq1atRMcj+qhJodD471q3bh1GjBihKLqtiN4sNC6PTCaTZKHxt99+i61btyI0NBRWVlYASr8nL1y4EMOGDcOAAQMEJxTLwcEBe/fu5e8NIpKsstsMERERaYhZs2ahdevWGD16NAoKCjB48GDcunULcrkcy5YtQ8+ePUVHVLuTJ09i8eLF2L59u0q3kGfPnmH48OEICgrig0YiIvpHvFlU/ejRIwCo0Jsn6L+3f/9+LF68GLa2tkhJSUFycjJcXV0xcuRIzJ07F5UrVxYdkQTbv38/goODMXjwYLi7u2PSpEm4e/cu/Pz88Mcff8DHxwfDhg0THZOIiIiIiP6mv9M5g6QtLCwMgYGBSu8wOnXqhCpVqmDhwoX47rvvBKYTY9y4cdiyZQu71P4F10QV16RsISEhOHXqFNq2bQsjIyMWSIJrQm/XpEkTrFq1Cn5+fjhy5IhiXC6Xo0aNGlixYoVkC68B4Pr16zh//jzMzMxw//59XLt2DS9evEDVqlVFR9N4+/btw8SJEyv0+0MTExPcvHlTqfja1NQUiYmJGDt2LHx9fQWmIyKqOA4dOgRvb2/0798fFy9eRGFhIYDSpj3r1q3jnkgiequ/UzjcvXt3AMCUKVM+VByN8cMPP4iOoNFWrlyJVatWKQqvAcDKygq+vr6YOXOm5Iuv2e+ViKSOxddERKTR0tPTMW3aNADAkSNHIJfL8euvv2L37t1Ys2aNJIuvN23ahKFDh6oUXgOAgYEBhg0bho0bN/JBIxER/WNyc3OxfPlypKSkIDc3FwBgaGiIvn37Yvbs2RX65E96fx4eHjh+/DjmzJmj6Jju7e0NZ2dn+Pr64qeffkJERISiqxVJU7Vq1RAVFYUePXogICAAKSkpyM7Ohp2dHfbt24d69eqJjkhERERERP+FNm3avNd1UuiIR2+XlZVV5rOkatWq4datWwISiTdx4kRMnjwZzs7O7FL7/3FNVHFNyrZ7927ExMSgS5cuoqNoDK4JvUvXrl3x448/4tixY7hx4wbkcjkaNmyIjh07Qk9PT3Q8YdavX49Vq1Zh2LBh8Pb2xo0bN+Dt7Y0BAwZgyZIlfLfxDlLYjN+uXTt8++23aN++vdL46wLs1+/GiIjof7NmzRoEBQVh4MCBOHDggGLcwcEBa9asEZiMiD4GM2bMeK/rZDIZMjIyPnAa+ljk5OTg1atXKuMlJSV4+PChgERERKRJWHxNREQa7dmzZ6hevToA4NixY+jRoweqVKmCLl26YMmSJYLTiXHp0iXMmzev3PkOHTpgw4YNakxEREQV2ZMnTzBs2DDcv38f/fv3V5zweOXKFezevRsnT55EUlKS4u81SVdOTg52794NS0tLpXEHBwfs3bsX0dHRGDNmDM6fPy8mIGmUFi1awMbGBidPnkSVKlUwbdo0Fl4TEREREUmAFDri0ds1b94cERERiIqKgomJCQDgwYMHWLJkCezs7ASnE4NdalVxTVRxTcpmZGQEc3Nz0TE0CteE3ubs2bN48uQJunbtis8//xxAacF+WFgYXrx4AWdnZyxcuBC6urqCk6pfYmIiYmNj0blzZwCAjY0NduzYgWXLlvHdBgEApk+fjqtXr5Y5Z2pqis2bN+Pnn39Wcyoioorn2rVrZTadMTAwUDQLICIqT2ZmpugIH4W7d+8iNTUVd+7cQVFRkdKcr6+voFTitG/fHgEBAQgJCUHTpk0BAOfPn0dgYKDK4UtSNHXqVO4NJSJJY/E1ERFptDp16uDs2bOoXr06jh07hmXLlgEo7cApxRd+QOkmpDdPs/8rHR0dPHr0SI2JiIioIouNjYWuri6OHDmi2BD72syZM+Hq6orY2Fj4+fkJSkiaYuvWrdDS0ipzTk9PD/7+/ujZs6eaU5Em2r9/PxYvXgxbW1ukpKQgOTkZrq6uGDlyJObOnYvKlSuLjkhERERERB+IFDri0duFhYXB3d0dXbp0QZ06dQAAd+7cgaWlJWJjYwWnE4NdalVxTVRxTcrm7u6OmJgYhIeHo0qVKqLjaASuCb1NbGws2rRpg65duwIoPfh94cKFGDhwIKytrZGQkIDatWvDw8NDcFL127dvn8oBQZUqVYKPj49ivUja6tWr99ZDZE1NTeHi4qLGREREFZOJiQmysrJQv359pfHTp0/zkCEion/AyZMnMW3aNJibm+Pq1ato3Lgxbt26BblcjiZNmoiOJ0RYWBh8fHwwePBgxf78V69eoVOnTggJCRGcTrwpU6aIjkBEJBSLr4mISKONHTsW8+bNQ9WqVVG3bl20bdsWAPDrr7/CxsZGcDoxTE1N8Z///AcNGjQoc/7SpUuoVauWmlMREVFFlZqaiqCgIJXCawCoVasW5s2bh8DAQBZfEx4/foyaNWu+9Rp25CEPDw8cP34cc+bMwZgxYwAA3t7ecHZ2hq+vL3766SdERETA3t5ecFIiIiIiIiL6EBo0aIB9+/bhxIkTis6B1tbWcHR0lOxzA3apVcU1UcU1KdvmzZuRlZUFR0dH1K9fX+UA6927dwtKJg7XhN4mMzMTs2bNUnxOSUlB8+bNFZvJzczMEBMTI8nia2NjY+Tm5uLQoUPIysrCxIkTYWRkhAsXLpS7N4Ok6969ezh9+jQePXqEkpISpbmxY8cKSkVEVDEMHToUoaGhCAsLg0wmw71793D27FlERkZi+vTpouMRkYZLTEx872ulet+2dOlSuLq6YubMmbC3t0dMTAyMjY3h5eWFTp06iY4nhLGxMeLi4nD9+nVcuXIFAGBlZYWGDRsKTiaOXC7HwYMHcerUqTK/96xevVpQMiIi9WPxNRERabRRo0bBzs4Od+/ehaOjo6Kborm5OWbPni02nCCdO3fGypUr0alTJ5WugAUFBYiJieHJy0RE9I+5f/8+GjduXO68jY0NcnJy1JiINFW/fv0QEBCAXr16qcwVFBQgOjoaSUlJOH/+vIB0pClycnKwe/duWFpaKo07ODhg7969iI6OxpgxY/hzQkREREREVIHJZDJ07NgRHTt2LPea/v37Y/369Yru2BUZu9Sq4pqo4pqUzdnZWXQEjcM1obd5+vSp0mG7aWlpcHJyUnxu3rw57ty5IyKacJmZmZgwYQIMDAxw69YtDB06FEZGRjh8+DDu3LmDqKgo0RFJQ+zatQuLFi1CpUqVUKNGDaU5mUwm2SIeIqJ/yuTJk1FSUoLx48fjxYsXGD16NHR1deHq6qo43JuI/ntTp05F9erVRcf4YL766qv3uk7K921XrlzBsmXLAAA6OjooKCiAvr4+Zs2ahenTp2PkyJGCE6pfeHi4ylhaWhpkMhkqV64MCwsLdO/eHUZGRuoPJ0hoaCi++eYbtG3bFiYmJpI9OJWICGDxNRERfQSaN2+O5s2bAwCKi4vx73//G/b29hX6AcDbTJs2DYcPH0bPnj0xatQoxclaV69exdatW1FcXIypU6cKTklERBVFjRo1kJ2dDTMzszLns7OzJfs3mZRNmjQJPj4+OHz4MAICAhQ/F+np6fD19YWWlhY2bdokOCWJtnXrVsWBSm/S09ODv78/evbsqeZUREREREREpGmys7Px6tUr0THUgl1qVXFNVHFNyubu7i46gsbhmtDbmJiYIDs7G3Xq1EFhYSEuXryImTNnKuafP3+OSpUqCUwoTnh4OFxcXODt7Q17e3vFeOfOneHl5SUw2cdhwIAB0NfXFx1DLVauXIkZM2ZgypQp5b7vICKi/55MJsO0adMwceJEZGVlIT8/H9bW1pL5O0P0d6SmpsLJyQmVKlVCamrqW6/t3r07AGDKlCnqiCbMDz/8IDqCxqtatSqKiooAALVq1UJWVpaiMcvjx49FRhPm4sWLuHjxIkpKShR78q9duwZtbW1YWVlh69atiIyMxNatW9GoUSPBadVj3759WL16NTp37iw6ChGRcCy+JiIijRYaGgobGxsMGTIExcXFGD16NM6ePYsqVapg7dq1aNu2reiIamdiYoKkpCQEBgZi2bJlkMvlAP7sFLFo0SKl06qJiIj+Fx07dsSKFSuwYcMG6OrqKs0VFhZi5cqV6NSpk6B0pElcXV3h5OQEHx8f9O3bF/7+/khPT8e2bdswYsQIeHl5QU9PT3RMEuzx48eoWbPmW6/haalEREREREQkJexSq4prooprUrZz585BLpfjs88+Uxr//fffoaWlpTjgW0q4JvQ2Tk5OWLp0Kby8vPD9999DT08PLVu2VMxfunQJ5ubmAhOKc/78eSxevFhl3NTUFDk5OQISiXX9+nWsWrUKwcHBqFatmtLcs2fPEBgYiNmzZyt+XoKCgkTEFKKgoAB9+/Zl4TUR0Qemq6srmQI3ov/WjBkzcOLECdSsWRMzZswo9zqZTIaMjAw1JiNN9tlnn+H06dOwtrZG586dERkZiX//+984cuSIyrMEqXjd1To8PFzx/efZs2dYsGABWrZsiaFDh2Lu3LkIDw9HQkKC4LTqUa1aNdSvX190DCIijcDiayIi0miHDh3CgAEDAAA//vgjsrOz8d1332Hv3r1Yvnw5kpKSBCcUo169eoiLi8PTp09x48YNAECDBg3YeZSIiP5xs2bNwuDBg9GzZ0+MHDkSVlZWkMvluHr1KrZu3YrCwkJERUWJjkkaolGjRti+fTu8vLzg6ekJPT09bNy4EW3atBEdjTREv379EBAQgF69eqnMFRQUIDo6GklJSTh//ryAdERERERE9KFJqSMe0ftil1pVXBNVXJOyBQcHw83NTWVz8L179xAXF4cdO3YISiYO14TeZtasWfDw8MDo0aNRtWpVREZGKh28u3PnTnTs2FFgQnF0dXWRl5enMn79+nUYGxsLSCRWQkICzMzMVAqvAcDAwABmZmaIj4+XVNH1a4MHD8bBgwcxefJk0VGIiIhI4jIzM8v8N/3p7t27SE1NxZ07dxTdnl/z9fUVlEosX19fPH/+HADg4eGB58+fIyUlBZaWlpg/f77gdGIkJCRg48aNSt9/DAwM4OHhAVdXV4wbNw4zZsyAq6urwJTq5eHhgdjYWISFhbHZChFJHouviYhIoz1+/Bi1atUCAPz000/o1asXGjZsiMGDByMxMVFwOvGqV68OOzs70TGIiKgCMzMzQ1JSEoKCgrBs2TLI5XIApaeiOjo6YtGiRahTp47glKQpioqKEBMTgyNHjqBPnz44duwY1q1bBwsLC5iZmYmORxpg0qRJ8PHxweHDhxEQEKA4PCg9PR2+vr7Q0tLCpk2bBKckIiIiIqL3xY54RP87dqlVxTVRxTUp25UrV9C0aVOV8U8//RSXL18WkEg8rgm9jbGxMbZs2YJnz56hatWq0NbWVppfuXIlqlatKiidWN26dUNsbCxWrFihGLt9+zaio6PRo0cPccEESUtLw5IlS8qd7927N+bOnavGRJpj7ty5mDJlCo4dOwYbGxvo6ChvwZVqEQ8RERGJU1RUBDc3NwQFBcHS0lJ0HI1x8uRJTJs2Debm5rh69SoaN26MW7duQS6Xo0mTJqLjCfP6WT0AVK1aFcHBwQLTaIa8vDw8fPgQjRo1Uhp/9OiR4pAuQ0NDlQL+iqx3797Yv38/2rdvj/r166t879m9e7egZERE6sfiayIi0mgmJia4fPkyatWqhWPHjiEwMBBAaVe8N18ESsX7nmy/evXqD5yEiIikwtzcHPHx8Xj69Clu3LgBALCwsICRkZHYYKRRMjIy4O3tjfz8fMTHx6Ndu3a4d+8e/P390a9fP/j4+GDIkCGiY5Jgrq6ucHJygo+PD/r27Qt/f3+kp6dj27ZtGDFiBLy8vHhiKhERERHRR4Qd8Yj+d+xSq4prooprUjZdXV08ePBAaeMwAOTk5KhsCpUKrgm9DwMDgzLHpfzeZ/78+Zg5cyYcHR3x8uVLjBkzBg8ePECLFi3g6ekpOp7a3blzBzVr1ix3vkaNGrh7964aE2mOdevW4fjx42jYsKHKnEwmE5CIiIiIpK5SpUq4dOmS6BgaZ+nSpXB1dcXMmTNhb2+PmJgYGBsbw8vLC506dRIdTyM8f/5c0YjltbKe9Vd03bp1g5+fH+bPn6844PCPP/5AZGQknJ2dAZQejCilww18fHxw4cIFDBgwACYmJvyuQ0SSxqfqRESk0QYNGoTZs2ejVq1aig6bQOkp7lZWVoLTiVHei1AiIqIPrXr16rCzsxMdgzTUkCFD4OLigvnz50NfXx8AYGpqqtj8GRERgcOHDyMuLk5wUhKtUaNG2L59O7y8vODp6Qk9PT1s3LgRbdq0ER2NiIiIiIj+JnbEI/rfsUutKq6JKq5J2Tp06IBly5bhX//6l+Idam5uLpYvX654ryw1XBOi/46BgQE2btyI06dPIzMzE/n5+WjatKlk/3djYGCArKws1KtXr8z5rKwsSRZlAMDGjRsRFhaGQYMGiY5CREREpDBgwAAkJyfDy8tLdBSNceXKFSxbtgwAoKOjg4KCAujr62PWrFmYPn06Ro4cKTihGDdv3sTixYuRlpaGly9fKsblcjlkMhkyMjIEphMjODgY4eHh8PT0RHFxMQBAW1sbLi4u8PX1BQBYWVkhNDRUZEy1+umnnxAfH49WrVqJjkJEJByLr4mISKN5eHigcePGuHv3Lnr16gVdXV0ApV9qJk2aJDidGOHh4aIjEBEREamIjY1F586dy5wbMmQIHB0d4e/vr+ZUpImKiooQExODI0eOoE+fPjh27BjWrVsHCwsLmJmZiY5HRERERER/Azvi0YcSHBz81p+tioRdalVxTVRxTcrm4+ODUaNGoWvXrvj0008BAJmZmahZsyaioqIEpxODa0L0v2nZsiVatmxZ7nz//v2xfv161KlTR42p1K9Vq1b4+uuv0b59+zLnExMT37pOFZmuri4cHBxExyAiIiJSUlxcjG3btuHnn39Gs2bNUKVKFaX51wWkUlK1alUUFRUBAGrVqoWsrCw0btwYAPD48WOR0YSaN28eACAsLAw1a9ZkR2MA+vr6CAkJga+vL27evAkAMDc3VzQfAaB4xiIVZmZmkj1wi4joTTK5XC4XHYKIiOh9vHz5EpUrVxYdQ6PI5XI8fvwYMpkMNWrUEB2HiIiIiOitMjIy4O3tjfz8fISGhqJdu3a4d+8e/P39cfbsWfj4+GDIkCGiYxIRERER0Xvq0KEDoqOjyy3KOHnyJLy8vHDixAk1JyNNdvLkSXz11Ve4cuUKAMDa2hrjxo2TbGfJOXPmICcnR6VL7YwZM2BsbIyVK1cKTqh+XBNVXJPy5efn49tvv0VmZib09PTwySefoG/fvqhUqZLoaMJwTYg+HHt7e+zbt0/lMIyK5uLFixg2bBi6du0KNzc3NGzYEABw9epVxMfH4+jRo0hKSkLTpk0FJ1W/devWIScnhwcOExERkUYZM2ZMuXMymQyJiYlqTKMZpk+fji5dumDo0KGIjIxEamoqXFxccOTIERgaGuKrr74SHVEIe3t77Ny5E1ZWVqKjkAY7evQoNm/ejKCgINSvX190HCIioVh8TUREGq24uBhr165FUlISHj58iEOHDsHc3BwrVqxAvXr1JFuYkZOTgyVLluCHH37A8+fPAQDVqlWDs7Mz5s6dCxMTE8EJiYiISGpWrFgBd3f3cjvt3L59GwsWLMDGjRvVnIw0SbNmzeDi4oL58+crnRALADt27EBERAQcHBwQFxcnKCEREREREf0ds2bNwqtXrxAbG1vm/LRp01CpUiWsWrVKzclIU23ZsgVhYWHo2bMnWrRoAQD4/fffcejQIfj6+mLUqFFiAwpw7949jBo1Ck+ePFHpUrtx48YK31mzLFwTVVwTIiLNIJXiawD48ccf4efnhydPnijG5HI5atSogZCQEHTv3l1cOIFmzJiBX375BUZGRmjcuLHKe7HVq1cLSkZEREREf3Xz5k08f/4ctra2yM/PR0REBM6ePQtLS0vMnz8f9erVEx1RiDFjxmDatGmSPQiT3k/r1q3x4sULFBcXQ09PT+VAv7S0NEHJiIjUj8XXRESk0VavXo09e/Zg5syZWLhwIfbv3w9zc3OkpKRg06ZN+Oabb0RHVLu8vDx88cUXyM/PR//+/WFlZQW5XI4rV65g//79qF69Onbt2qVSzEJERET0IXXp0gVGRkaIioqCjY2N0lxSUhKioqLg4OCA+Ph4QQlJE/z000/o3LlzufO3bt2Cv78/i/SJiIiIiD4S7IhHf5eTkxMmT56M0aNHK41v2bIFa9euxbFjxwQlE4tdalVxTVRxTUqlpqa+97VSKQzkmhCpj5SKrwGgoKAAx44dw40bNyCXy9GwYUN07NgRenp6oqMJ4+vr+9b58PBwNSUhIiIiIvr7srKyEBAQgAEDBpR5mJCtra2gZKRJdu/e/dZ5FxcXNSUhIhKPxddERKTRPv/8cwQHB6N9+/ZKL7GuXLmC4cOH49dffxUdUe1iY2Oxd+9eJCUlwdjYWGnu4cOHGDFiBAYNGoSpU6cKSkhERERSlJeXh+DgYHz33Xdwd3fHpEmTcPfuXfj5+eGPP/6At7c3hg0bJjomERERERER/cPYEY/+Dnt7e+zZswcNGjRQGr9+/TpcXFxw9uxZQcmI6GPx5iZgmUyGv259kslkin9nZGSoLZdIXBMi9ZFK8fXZs2fx5MkTdO3aVTG2e/duxMTE4MWLF3B2dsbChQuhq6srMCURERERvfby5Uts3rwZp06dwsOHD/FmidC7CikruufPn6usSbVq1QSlEeu3337D3LlzcevWLcXY6+cIMpmMzw2IiIjeoPPuS4iIiMS5d+8eLCwsVMblcjlevXolIJF4P/30E6ZMmaJSeA0ANWvWxOTJk7Fjxw4WXxMREZFaVatWDVFRUejRowcCAgKQkpKC7Oxs2NnZYd++fahXr57oiKSh8vPzkZKSgpcvX6JDhw6wtLQUHYmIiIiIiP6Grl274scff2RHPHov3bp1w5EjR+Dm5qY0npqaii5duogJJQC71KrimqjimpQtMzNT8e+ff/4Z0dHR8PT0hL29PYDSgsEVK1Zgzpw5oiKqHdeEiP5psbGxaNOmjaL4+tKlS1i4cCEGDhwIa2trJCQkoHbt2vDw8BCcVP1u3ryJ4uJilXcZ169fh46ODurXry8mGBEREUman58fTpw4gZ49e8LOzk7pEC6punnzJhYvXoy0tDS8fPlSMS71ImM/Pz80adIEy5YtQ82aNfmzQmX66aefoKWlhU6dOimNHz9+HMXFxejcubOgZERE6sfiayIi0miNGjVCenq6SrHOwYMH8emnnwpKJdb169cVL8rLYm9vj6ioKDUmIiIiIvpTixYtYGNjg5MnT6JKlSqYNm0aC69J4fbt2/D29saFCxfQokULhIaGYsKECbhx4wYAQE9PD3FxcWjdurXgpERERERE9D7+2hHv888/B1DaRSUsLIwd8UghMTFR8W9ra2usXbsWaWlpaNGiBQDg999/x5kzZzBhwgRBCdVvxowZSp/ZpZZrUhauybuFhYUhMDAQrVq1Uox16tQJVapUwcKFC/Hdd98JTCcG14SI/gmZmZmYNWuW4nNKSgqaN2+OkJAQAICZmRliYmIkWXzt6+uLwYMHqxRf//7770hOTsbmzZvFBCMiIiJJO3r0KNavX4+WLVuKjqIx5s2bB6D0ezKLjP90+/ZtrFmzBg0aNBAdhTRYdHQ0vLy8VMZLSkqwdOlSFl8TkaSw+JqIiDTa9OnTMX/+fNy7dw9yuRyHDx/GtWvXsGfPHqxbt050PCHy8vJgaGhY7ryhoSHy8vLUmIiIiIio1P79+7F48WLY2toiJSUFycnJcHV1xciRIzF37lxUrlxZdEQSLDIyEkVFRQgKCsJ3332HiRMnwtLSElu2bIGWlhYCAwMRExOjtDGfiIiIiIg0Fzvi0fv46quvlD4bGhri8uXLuHz5smLMwMAAO3fuxPTp09WcTgx2qVXFNVHFNXm3rKysMt+bVqtWDbdu3RKQSDyuCdGHFRwcjJo1a4qO8cE9ffoUJiYmis9paWlwcnJSfG7evDnu3LkjIppwFy9eRGhoqMp4ixYtsHjxYgGJiIiIiABTU1Po6+uLjqFRLl26hJ07d8LKykp0FI3Srl07ZGZmsvia3urGjRuwtrZWGbeyskJWVpaARERE4rD4moiINJqzszPWrl2L2NhYVKlSBatWrUKTJk2wdu1adOjQQXQ8IeRyObS0tMqdf/PUeyIiIiJ18PDwwPHjxzFnzhyMGTMGAODt7Q1nZ2f4+vrip59+QkREhGJzKElTeno61qxZAzs7Ozg5OaFdu//X3p1HVV2u/R//bBFEBFJBxRQHUMMMj4p5kpRSLJv0UTvpr5NmkuGQgqamYCaYgpRZajyKipodjeqYY1qOlZpFDmmFUjmEdHAIQ8EJg/37w6d9oo1lg/veuN+vtVyL731/YX24Vins/b3u6zYlJSXZHuIaOnSo+vfvbzglAAAAgKvFRDxcjc2bN5uO4NSYUmuPmtijJuULDQ3V1KlT9fzzz9teX/r+++/1wgsvqGXLlobTmUFNgD9ux44dWrRokQ4ePChJCg4OVv/+/RUeHm67p1u3bqbiOZS/v79yc3NVt25dFRcXKysrSzExMbb9s2fPyt3d3WBCcywWi86ePWu3XlhYqJKSEgOJAAAApLFjx2ratGlKTExUvXr1TMdxCrfccouOHTtG8/UvdOrUScnJyfrqq6/UrFkzVa5ctqUsMjLSUDI4Ex8fHx09elT169cvs56Tk6OqVasaSgUAZtB8DQBwem3bttXChQtNx3AaVqtVXbt2lcViueI+AACAo508eVLLly9Xo0aNyqy3adNGK1eu1LRp09SvXz998cUXZgLCKeTn5+vGG2+UJFWvXl1Vq1YtMz3D399fZ86cMRUPAAAAwO/ERDzgz2NKrT1qYo+alC8pKUnDhg3TnXfeqbp160qS8vLy1KhRI6WmphpOZwY1Af6YJUuWKCkpSV27dtWjjz4qSdq7d6+io6MVFxenRx55xHBCx4qIiNCLL76o0aNHa+PGjfL09FRYWJhtPzs7W4GBgQYTmnPrrbcqLS1N06dPl5ubmySppKREc+fOLVMjAAAARwoNDdXFixfVpUsXeXp62h2Uk5mZaSiZOVOmTNHEiRN1/PhxNW3a1K7JOCQkxFAysyZOnChJ5b5GYLFYtH//fkdHghOKjIxUUlKSUlNT1aBBA0mXp2FPnTpVnTt3NpwOAByL5msAACqY5ORk0xEAAADsLF26VJUqVSp3z9PTU88884y6du3q4FRwRlc6RAgAAABAxcNEPPxeV3qPw2KxqEqVKmrQoIEiIyNVvXp1xwYziCm19qiJPWpSvoYNG2rVqlXavn27Dh06JOnypNrw8HCXfQ2KmgB/TFpamuLi4tS3b98y623atNGcOXNcrvk6NjZWw4cPV9++feXl5aWUlBR5eHjY9pctW6YOHToYTGjO6NGj9cgjj+iee+5R27ZtJUk7d+5UUVGRXn31VcPpAACAq3rqqad04sQJjRw5Uv7+/vz+J+nUqVPKyclRXFycbc1ischqtbp0k/GBAwdMR0AFMGbMGA0cOFD33nuv6tSpI0k6fvy4wsLCNHbsWMPpAMCxLFbGYwIAnMytt9561b/4u+JpbAAAAM4oPz9ffn5+v3rPzp07bQ+iwDWFhISod+/eqlq1qqTL00S6d+8uHx8fSdL58+f11ltvueybXAAAAEBFM3HiRGVnZ9sm4i1fvlxbt261NWasWrVKr776qpYtW2Y4KZxFv379lJWVpdLSUjVu3FiSdPjwYbm5uSkoKEiHDx+WxWLR0qVL1aRJE8NpHePbb7/VsGHDdPjw4XKn1DZs2NBwQsejJvaoyZ/TrVs3zZ0711Y7UBPgl1q3bq0VK1bY/X165MgR9ezZU3v27DGUzKzCwkJ5eXnZJjz/pKCgQF5eXmUasl3J8ePHtWTJEh04cECenp5q1qyZ+vbt61IHCAEAAOfyt7/9TW+88YbLTnMuz3333afg4GANHDhQfn5+ds+l16tXz1Ay53PmzBn5+vqajgEnY7VatX37dtvvPTfddJNuvfVW07EAwOFovgYAOJ3ly5df9b09e/a8hkkqjoSEBMXExKhmzZqmowAAABfVvn17TZw4Uffcc4/d3oULFzRt2jRlZGToiy++MJAOzqJfv35Xdd9rr712jZMAAAAA+CucOnVKw4cP165du2wT8e666y7bfv/+/dWqVSuNHDnSYEo4k0WLFmnXrl1KTk6Wt7e3pMtNPePHj1dYWJh69+6tUaNG6eLFi0pPTzec1nF+epCNKbX/RU3sUZM/rnXr1lq1apUCAwNNR3Ea1AQoa9SoUWrevLkGDhxYZj09PV1ffPGFXnrpJUPJAAAAgN/Ws2dPTZw4Ua1atTIdxWm0atVKK1eu5MC6X5g7d67q16+v++67T5IUExOj9evXq1atWpo3bx4N/AAA/ALN1wAAXAfatGmjlStX8uY4AAAwZsGCBZoxY4YiIyM1ceJE3XDDDZIuT7uOi4tTpUqVlJSUpLCwMMNJ4UxOnTolSRwiBAAAAFRwTMTD1erYsaMWLlxoN9X666+/VlRUlLZu3aovv/xSUVFR+uSTTwyldE5MqbVHTexRk/LRaGyPmgDS4sWLbR8XFRVpwYIFatOmja1hZe/evdq9e7cGDBigoUOHGkoJZ3DgwIGrvpdmFQAAYMK2bdv0yiuvaOTIkWrWrJnc3d3L7P90CKIrGTx4sHr27KmuXbuajuJUOnfurGnTpqlNmzbavn27RowYoZdeeknr1q1TXl6eFixYYDoiDPn578i/5dFHH72GSQDAuVQ2HQAAgF/z5ZdfqnLlyrrpppskSRs3btTbb7+tJk2aaNiwYTyw9X84SwUAAJgWFRWliIgIjR07Vvfff7+eeeYZ7dy5U6+//roefvhhjR49Wp6enqZjwgmcOXNGL730ktauXaszZ85Iknx9fXX//fdrxIgR8vX1NZwQAAAAwO/l4+NT7nr16tUdGwROr6ioSPn5+XbN16dOnVJRUZGky78jXrp0yUQ8p5abm6sff/zRdAynQk3sURMAuHqLFi0qc+3r66tvvvlG33zzjW3Nx8dHy5Yto/naxfXo0UMWi0VWq1UWi8W2/tOzOj9f279/v8PzAQAADBw4UJLUv39/u59XLBaLS/6M0qlTJyUnJ+urr75Ss2bNVLly2dapyMhIQ8nM+v77722H9m3ZskX33nuvOnTooHr16ql3796G08GkX/6O/MMPP+j8+fO257jOnDmjqlWrqmbNmjRfA3ApNF8DAJzas88+q+joaN100006evSoRo4cqbvvvlvvvvuuzp8/r/Hjx5uOCAAAgP/TpEkTvfnmmxo9erRGjhwpT09PLVy4UO3atTMdDU6ioKBAffr00YkTJ9StWzcFBQVJkg4ePKjly5drx44dysjIsE1OBwAAAABcXzp37qz4+HiNGzdOoaGhkqTPP/9cKSkp6tKliyRp3759atSokcGUAADAFWzevNl0BFQQmzZtsn28f/9+paSk6PHHH7dNSf/ss8+0cOFCjRkzxlBCAADg6n7PxFpXMXHiRElSamqq3Z6rNqRLlw+dysvLU926dbV161aNGDFC0uVG/ZKSErPhYNTPf0devXq1li5dqilTptie7Tp06JAmTJigPn36mIoIAEbQfA0AcGpHjhxR8+bNJUnr1q1Tu3bt9OKLL2rXrl166qmnaL7+P3v27DEdAQAAQJcuXdKsWbO0YcMG3Xfffdq6davS0tLUoEEDBQQEmI4HJ5CamioPDw9t2LBB/v7+ZfZiYmIUFRWl1NRUxcfHG0oIAAAAALiWJk2apOTkZI0cOdL2MJ+bm5t69uypuLg4SVJQUJCmTJliMiYAAABgU69ePdvHsbGxeuaZZ3THHXfY1kJCQlS3bl3NmDHDdqAQAACAI7Vr1047d+5URkaGjh49qpkzZ6pOnTpasWKF6tevbzqeEQcOHDAdwSndfffdGj16tBo2bKiCggJFRERIunzIUMOGDQ2ng7OYMWOGZs6caWu8li6/bh8XF6eYmBh1797dYDoAcCyarwEATs1qtaq0tFSStGPHDt15552SpLp16+qHH34wmMycH3/8UaWlpfLw8LCtff/998rIyNC5c+fUuXNntW3b1mBCAADgivbv36+nn35a586d0/z583Xbbbfp+PHjeuaZZ/TAAw9o7Nixeuihh0zHhGGbNm1SYmKiXeO1JNWqVUtjxoxRQkICzdcAAAAAcB0qKSlRVlaWxowZo7i4OB09elSSFBgYqGrVqtnu++lQXgAAAEdJTk4ud91isahKlSpq0KCBIiMjVb16dccGg9P56quvym1gql+/vr755hsDiQAAAKT33ntPTz/9tLp166asrCwVFxdLkoqKipSWlsYzxf/nzJkz8vX1NR3DqLi4ONWrV095eXkaM2aM7XXZkydP6p///KfhdHAWJ0+e1I8//mi3Xlpaqvz8fAOJAMCcSqYDAADwa2655RbNnj1bK1as0Keffmprvs7NzS23YcMVTJgwQZMnT7ZdFxUV6R//+IeWLFmibdu2qX///vrggw8MJgQAAK7ooYceUqtWrbRq1SrddtttkqQ6depo3rx5Gjt2rKZOnaonnnjCcEqYduLECTVt2vSK+82aNdPJkycdmAgAAAAA4Chubm6KiorSmTNnVK1aNYWEhCgkJKRM4zUAXAuTJk2Sn5+f6RhOhZoAZWVlZenf//633nzzTX366af69NNP9eabb+rf//63duzYoalTp+ruu++muRYKDg5WWlqaraFJkoqLi5WWlqbg4GCDyQAAgCubPXu2EhMTNXnyZFWu/N/5jG3atFFWVpbBZObMnTtXa9eutV3HxMSoXbt26tixo0tPxXZ3d9fjjz+uZ555RjfffLNt/bHHHiszVCM6OlonTpwwERFOoH379po4caK+/PJL29oXX3yhhIQEtW/f3mAyAHA8Jl8DAJxafHy8xowZo40bN2rw4MFq2LChpMuntLVu3dpwOjN2796tCRMm2K5XrlypkpISrV+/Xj4+PnrhhRc0f/583XHHHQZTAgAAV5OamnrFnz8eeughhYeH65lnnnFwKjibGjVqKDc3VwEBAeXu5+bm6oYbbnBwKgAAAACAozRt2lS5ubkKDAw0HQXAdWLHjh1atGiRDh48KOlyU1z//v0VHh5uu6dbt26m4hlBTYDf76ep1snJyfL29pYkFRYWavz48QoLC1Pv3r01atQoJScnKz093XBamJSYmKjBgwfrjjvu0E033SRJys7OlsVi0Zw5cwynAwAArurw4cPlTrf28fHRmTNnDCQyLyMjQ9OmTZMkbd++XTt27ND8+fO1bt06Pf/881qwYIHhhM7t008/1cWLF03HgCFJSUkaO3asHnzwQduBDj/++KM6duxYZoAcALgCmq8BAE4tJCREq1evtlt/+umnValSJQOJzDt+/LitCV26/OZ5165d5ePjI0nq2bOn3n77bVPxAACAi/qtg1/q1aunhQsXOigNnFWHDh308ssva8GCBfLw8CizV1xcrBkzZqhjx46G0gEAAAAArrURI0YoJSVFsbGxatGihby8vMrs/9TsBHtMqbVHTey5Wk2WLFmipKQkde3aVY8++qgkae/evYqOjlZcXJweeeQRwwkdj5oAf0x6eroWLlxY5mcRHx8fDR8+XFFRUerfv7+efPJJRUVFGUwJZ9CyZUtt3LhRq1ev1qFDhyRJ9913nx544AG7n20BAAAcxd/fXzk5Oapfv36Z9V27drnsIYjff/+96tatK0nasmWL7r33XnXo0EH16tVT7969DacDnFvNmjU1b948HTlyxHa4X1BQkBo3bmw4GQA4Hs3XAACnlpeXJ4vFYpuMt2/fPq1evVpNmjRRnz59DKczo0qVKmVOE/vss8/09NNPl9k/d+6ciWgAAABlnDt3TmvXrtXFixd1++23q1GjRqYjwbDY2Fg9+OCD6tq1q/75z38qKChIVqtVhw4d0tKlS1VcXKznn3/edEwAAAAAwDUSHR0tSRoyZIgsFott3Wq1ymKxaP/+/aaiGcWUWnvUxB41sZeWlqa4uDj17du3zHqbNm00Z84cl2w0pibAH1NUVKT8/Hw1adKkzPqpU6dUVFQkSfL19dWlS5dMxIOT8fLyctlnlgAAgHPq3bu3pkyZoqSkJFksFh0/flx79uxRSkqKhg4dajqeEb6+vsrLy1PdunW1detWjRgxQtLl1yFLSkrMhgOcXHJyst1aZmamLBaLqlSpogYNGigyMlLVq1d3fDgAcDCarwEATm3UqFHq3bu3evTooZMnT2rAgAFq2rSpVq9erZMnT2rYsGGmIzpcSEiIVq5cqVGjRmnnzp3Kz8/XbbfdZtvPyclR7dq1DSYEAACu6D//+Y+efvppffnll2rVqpWmTJmiAQMG6Ntvv5UkeXp6at68ebr11lsNJ4VJAQEBysjIUGJioqZPny6r1SpJslgsCg8P17PPPms7eRgAAAAAcP1ZvHix6QhOhym19qiJPWpSvsLCQnXs2NFu/fbbb9e0adMMJDKPmgB/TOfOnRUfH69x48YpNDRUkvT5558rJSVFXbp0kXR5WACHzGLTpk3lrv+8CcFVp0sCAABzoqOjVVpaqscee0znz59X37595eHhoaioKPXr1890PCPuvvtujR49Wg0bNlRBQYEiIiIkSfv371fDhg0NpwOcW1ZWlrKyslRaWmqbdn348GG5ubkpKChIS5cuVUpKipYuXWp3iBkAXG8s1p+ecgUAwAndeuuteuONNxQUFKTFixdr7dq1ysjI0LZt2zRx4sQrvqlxPcvMzNQTTzyhWrVq6eTJk7r//vuVlJRk209ISND58+eVkpJiMCUAAHA1sbGxOnbsmB555BGtW7dOR44cUYMGDTRlyhRVqlRJCQkJKigo4CFr2Jw+fdrWnN+gQQNOQwUAAAAA2CQkJCgmJkY1a9Y0HeWai4iIUHR0tN2U2iVLlmjOnDnaunWroWTmUBN71KR8o0aNUvPmzTVw4MAy6+np6friiy/00ksvGUpmDjUB/pizZ88qOTlZK1assE3Bc3NzU8+ePRUXFycvLy/t379fktS8eXOTUWFYSEiILBaLfvnY7U9rFotFYWFhSk1N1Q033GAoJQAAcFXFxcXKycnRuXPnFBwcrGrVqpmOZMylS5e0ePFi5eXlqVevXrr55pslSYsWLVK1atX00EMPGU7o3Fq3bq1Vq1ZxsJCLWrRokXbt2qXk5GR5e3tLunzg3/jx4xUWFqbevXtr1KhRunjxotLT0w2nBYBri+ZrAIBTa926tVavXq369etr8ODBatOmjaKjo/Wf//xH99xzj/bt22c6ohEHDx7Utm3bVKtWLd1zzz2qVKmSbe+NN95Qy5YtecMPAAA41O23367Zs2erZcuWKigo0G233abXX39drVu3liQdOHBA/fv31yeffGI4KQAAAAAAcHZt2rTRypUrXeLhvtatW2vFihV2E3eOHDminj17as+ePYaSmUNN7FGT//r54Y5FRUVasGCB2rRpo1atWkm6PBF89+7dGjBggIYOHWoopWNRE+DPKSkp0e7du9WsWTNVrlxZR48elSQFBga6dLMKyrdjxw699NJLGjlyZJkp6TNmzNCQIUPk7e2tiRMnqmXLlmUGKQAAAMA5RUdHa/Lkyapdu7bpKE6F5mvX1rFjRy1cuNBuqvXXX3+tqKgobd26VV9++aWioqJ4FhDAda+y6QAAAPyaJk2aKCMjQ3feeac++ugjjRgxQpJ04sQJl56MFxwcrODg4HL3+vTp4+A0AAAAUn5+vm688UZJUvXq1VW1alX5+/vb9v39/XXmzBlT8QAAAAAAQAXiSmfId+7cWRs2bLCbUrtp0ybdeeedZkIZRk3sUZP/WrRoUZlrX19fffPNN/rmm29saz4+Plq2bJnLNBpTE+DPcXNzU1RUlNauXavAwECFhISYjgQnNmXKFE2aNElt2rSxrbVv314eHh569tln9c477yg+Pl7x8fEGUwIAAOBqffrpp7p48aLpGE5n8ODBuuGGG0zHgCFFRUXKz8+3a74+deqUioqKJF1+/enSpUsm4gGAQ9F8DQBwaqNHj9awYcOUnp6uHj162N7k2rx5s1q2bGk4nRmffvrpVd136623XuMkAAAAZVksFtMRAAAAAAAAnN7Pp9QGBwdrzpw5yszMLHdKraugJvaoSfk2b95sOoLToSbAn9e0aVPl5uYy1Q2/KScnR97e3nbr3t7etqnpDRs21A8//ODoaAAAAEC5Nm3apIiICLm7u2vTpk2/em9kZKQkadCgQY6IBifVuXNnxcfHa9y4cQoNDZUkff7550pJSVGXLl0kSfv27VOjRo0MpgQAx7BYXenIaABAhVRSUqKioqIyJ2jl5uaqatWq8vPzM5jMjF87ZfmnhieLxaKsrCxHRQIAAFBISIh69+6tqlWrSpKWLFmi7t27y8fHR5J0/vx5vfXWW9q/f7/JmAAAAAAAoAJo3bq1Vq1add02QHXu3Pmq7rNYLL/5QOT1gprYoyYA4Dgffvihpk+frtjYWLVo0UJeXl5l9strtoVrevjhh1WtWjU9//zzqlmzpqTL09+efvppnT9/XkuWLNFHH32kxMREvffee4bTAgAA4Ldc769DSpef6dq+fbv8/Px+8xl0nuuCJJ09e1bJyclasWKFSkpKJElubm7q2bOn4uLi5OXlZftvpXnz5iajAsA1R/M1AKBCOHXqlA4dOiRJCgoKsr2B4YoKCwvLXT9//rwWL16s1157TYGBgVqzZo2DkwEAAFfWr1+/q7rvtddeu8ZJAAAAAABARecKDz0C+POSk5PLXbdYLKpSpYoaNGigyMhIVa9e3bHBDKImwB/z8waEnw69lySr1UoDAso4dOiQhg4dqtzcXNWtW1eSlJeXp8DAQP3v//6vGjdurI0bN6qoqEg9evQwGxYAAAC/idchgSs7e/asjh49KkkKDAxUtWrVDCcCAMej+RoA4NTOnTun5557TitXrlRpaamkyycn/c///I8mTJhgm6zoykpLS7Vs2TK98sorqlSpkoYNG6aePXuqUqVKpqMBAAAXdurUKUly6UNzAAAAAADAH8NDjwCuRr9+/ZSVlaXS0lI1btxYknT48GG5ubkpKChIhw8flsVi0dKlS9WkSRPDaR2DmgB/TGZm5q/ut2vXzkFJUBGUlpZq27ZtOnLkiCSpcePGuv3223lOBwAAoAJypdchL126pIEDByoxMVGNGjUyHQcAgAqhsukAAAD8mqlTp+rTTz/V7NmzFRYWJknatWuXJk+erKlTpyoxMdFwQrPWr1+v6dOn64cfflB0dLT69esnDw8P07EAAICLOnPmjF566SWtXbtWZ86ckST5+vrq/vvv14gRI+Tr62s4IQAAAAAAqAi6d+/uMlM0mFJrj5rYoybl++l7Tk5Olre3tySpsLBQ48ePV1hYmHr37q1Ro0YpOTlZ6enphtM6BjUB/pirba5OSEhQTEwMB8+6uEqVKikiIkIRERFXvKdbt26aO3eubTo2AAAAYJq7u7uys7NNxwAAoEJh8jUAwKn9/e9/18yZM/X3v/+9zPrHH3+sESNG6OOPPzaUzKzMzExNmzZNX331lR599FE98cQT8vHxMR0LAAC4sIKCAvXp00cnTpxQt27dFBQUJEk6ePCg1qxZo4CAAGVkZOiGG24wnBQAAAAAADjakSNHNHPmTE2aNMnWDPiTwsJCJSQkaMSIES4xYeaXmFJrj5rYoybl69ixoxYuXGj3PX/99deKiorS1q1b9eWXXyoqKkqffPKJoZSORU2Aa6tNmzZauXKlS/7Mgt/HlSYoAgAAVGRpaWl6+OGHXWagRFJSkjw8PDR69GjTUQAAqBCYfA0AcGoXLlyQv7+/3bqfn58uXLhgIJF5TzzxhHbs2KFevXopNTVVtWrVMh0JAABAqamp8vDw0IYNG+x+fouJiVFUVJRSU1MVHx9vKCEAAAAAADAlPT1dAQEBdo3XkuTj46OAgADNnz9fiYmJBtKZxZRae9TEHjUpX1FRkfLz8+0ajU+dOqWioiJJkq+vry5dumQinhHUBLi2mHMDAAAAOK9NmzYpIiJC7u7u2rRp06/eGxkZKUkaNGiQI6I5jZKSEr3++uv66KOPdMstt6hq1apl9uPi4gwlAwDAOdF8DQBwaq1atdLMmTP1/PPPq0qVKpIuN2S/8soratWqldlwhmzdulWVK1fWunXr9O67717xvszMTAemAgAArm7Tpk1KTEws9+CcWrVqacyYMUpISKD5GgAAAAAAF5SZmakXXnjhivv33nuvRo0a5cBEziM9PV0LFy4s05ju4+Oj4cOHKyoqSv3799eTTz6pqKgogykdi5rYoybl69y5s+Lj4zVu3DiFhoZKkj7//HOlpKSoS5cukqR9+/apUaNGBlM6FjUBAAAAALiqJ598Utu3b5efn5+efPLJK95nsVi0f/9+ByZzHl999ZVuvvlmSdLhw4fL7FksFhORAABwajRfAwCc2vjx4/X4448rIiJCISEhkqQDBw7Iw8NDCxYsMJzOjOTkZNMRAAAA7Jw4cUJNmza94n6zZs108uRJByYCAAAAAADOIi8vT35+flfcr1Gjho4dO+bARM6DKbX2qIk9alK+SZMmKTk5WSNHjlRJSYkkyc3NTT179rRNagoKCtKUKVNMxnQoagIAAAAAcFUHDhwo92P812uvvWY6AgAAFQrN1wAAp9asWTOtX79eq1ev1qFDhyRJDzzwgLp16yZPT0/D6czo2bOn6QgAAAB2atSoodzcXAUEBJS7n5ubqxtuuMHBqQAAAAAAgDPw8fFRTk6O6tWrV+5+Tk5OmYm+roQptfaoiT1qYq+kpERZWVkaM2aM4uLidPToUUlSYGCgqlWrZruvefPmpiI6HDUBAAAAAEC6dOmSBg4cqMTERJd6rQQAAPz1LFar1Wo6BAAAv9fRo0c1ceJEl5x+vW/fPrVo0UJubm7l7hcXF2vjxo267777HJwMAAC4sp8e5luwYIE8PDzK7BUXF+vxxx9X/fr1lZycbCghAAAAAAAwJTY2Vj/++KNSU1PL3R8yZIjc3d01c+ZMBycz7+zZs0pOTtaKFSvKnVLr5eWl/fv3S3KdhklqYo+alC80NFRr165VYGCg6ShOg5oA11br1q21atUq/h/Db+K/FQAAALNuu+02ZWRk0Hz9CxcvXtRrr72mTz75RPn5+fplO9ny5csNJQMAwDnRfA0AqJAOHDignj172h4icCXNmzfXtm3b5OfnJ0lq06aNVq5caXvD5vvvv1fHjh1dsjYAAMCcY8eO6cEHH5SHh4f++c9/KigoSFarVYcOHdLSpUtVXFysZcuWqW7duqajAgAAAAAAB8vKylKfPn3UqVMnDRw4UI0bN5YkHTp0SPPnz9f777+vjIwMtWjRwnBSxyopKdHu3bvVrFkzVa5c+YpTal0JNbFHTa6sV69eGjNmjNq3b286itOgJsC1NXHiRMXGxqpmzZqmo8DJrV69WpGRkfLy8jIdBQAAwCUlJSXJw8NDo0ePNh3FqYwaNUrbt29X165d5e/vL4vFUmZ/2LBhhpIBAOCcaL4GAFRIrtx8HRISou3bt9uar395Wu7333+vDh066MCBAyZjAgAAF3T06FElJiZq+/bttpNRLRaLwsPD9eyzz6phw4aGEwIAAAAAAFO2bNmi+Ph4FRQU2NasVqtq1KihyZMnKzIy0lw4g5hSa4+a2KMm5fvwww81ffp0xcbGqkWLFnYNbt7e3oaSmUNNgN/nyJEjmjlzpiZNmmT3/0dhYaESEhI0YsQI/v5FGTt27NCiRYt08OBBSVJwcLD69++v8PBww8kAAADwk+eee04rVqxQw4YNdcstt6hq1apl9uPi4gwlMyssLExz585VWFiY6SgAAFQIlU0HAAAAf71fnkQGAADgCIGBgZo/f75Onz6tb7/9VpLUoEEDVa9e3WwwAAAAAABgXKdOnbRlyxZt3bpV3377raxWqxo3bqwOHTrI09PTdDxjmjZtqtzcXJq6foaa2KMm5YuOjpYkDRkypMz7o1arVRaLxSUP8qYmwO+Tnp6ugICAcg8m8PHxUUBAgObPn6/ExEQD6eCMlixZoqSkJHXt2lWPPvqoJGnv3r2Kjo5WXFycHnnkEcMJAQAAIElfffWVbr75ZknS4cOHy+y58jPWderUUbVq1UzHAACgwqD5GgAAAAAA/KVuuOEGtWzZ0nQMAAAAAADgJPbs2aOCggJ16tRJd911lyRp+fLlSkpK0vnz59WlSxdNmDBBHh4ehpM63ogRI5SSksKU2p+hJvaoSfkWL15sOoLToSbA75OZmakXXnjhivv33nuvRo0a5cBEcHZpaWmKi4tT3759y6y3adNGc+bMofkaAADASbz22mumIzilsWPHatq0aUpMTFS9evVMxwEAwOnRfA0AcEo9evT41ZPFzp8/78A0zuebb77RyZMnbdeHDh3S2bNnJUk//PCDqVgAAAAAAAAAAAB2UlNT1a5dO3Xq1EmSlJ2drQkTJqhHjx4KDg5Wenq6ateureHDhxtO6nhMqbVHTexRk/K1a9fuqu5LSEhQTEyMataseY0TmUdNgN8nLy9Pfn5+V9yvUaOGjh075sBEcHaFhYXq2LGj3frtt9+uadOmGUgEAAAAXL3Q0FBdvHhRXbp0kaenp9zd3cvsZ2ZmGkoGAIBzovkaAOCUunTpYjqCU3vsscdktVpt14MGDZIkWSwW20MWAAAAAAAAAAAAzuDAgQOKjY21Xa9du1ahoaGaPHmyJCkgIECzZs1yyeZrptTaoyb2qMmfs2rVKj3++OM0Gv8MNQEu8/HxUU5OzhUnvuXk5Mjb29vBqeDMOnfurA0bNmjgwIFl1jdt2qQ777zTTCgAAADYuXjxol577TV98sknys/PL/PMtSQtX77cUDKznnrqKZ04cUIjR46Uv78/z5sDAPAbaL4GADilYcOGmY7gtDZt2mQ6AgAAAAAAAAAAwFU7ffq0/P39bdeZmZmKiIiwXYeGhiovL89ENOOYUmuPmtijJn/OLx+wBjUBftK2bVv961//Uvv27cvdX7x4scLCwhycCs7m54egBAcHa86cOcrMzFSrVq0kSXv37tXu3bs1YMAAQwkBAADwS/Hx8dq+fbu6du2qli1b0mT8f/bs2aM33nhDISEhpqMAAFAh0HwNAEAFc6UTlwEAAAAAAAAAAJyRv7+/cnNzVbduXRUXFysrK0sxMTG2/bNnz8rd3d1gQufHlFp71MQeNQGA32fQoEHq06ePYmJiNHDgQDVu3FiSdOjQIc2fP1/btm1TRkaG4ZQwbdGiRWWufX199c033+ibb76xrfn4+GjZsmUaOnSog9MBAACgPO+//77mzp3LYUq/EBQUpAsXLpiOAQBAhUHzNQDAKeXk5Gj27NlKTk6WJN155506d+6cbb9SpUpaunSpgoKCTEU05j//+c9V3XfjjTde4yQAAAAAAAAAAAC/LSIiQi+++KJGjx6tjRs3ytPTs8yDj9nZ2QoMDDSY0PkxpdYeNbFHTQDg97n55ps1c+ZMxcfHa8OGDbZ1q9WqGjVq6OWXX1aLFi0MJoQz2Lx5s+kIAAAA+J3q1KmjatWqmY7hdEaNGqWpU6dq5MiRatasmd2BmN7e3oaSAQDgnGi+BgA4pddee03+/v6269OnT+vJJ5+Un5+fJGnt2rVatGiRJk2aZCqiMZGRkbaPf3qAwmKxlFmzWCzav3+/w7MBAAAAAAAAAAD8UmxsrIYPH66+ffvKy8tLKSkp8vDwsO0vW7ZMHTp0MJgQAAC4qk6dOmnLli3aunWrvv32W1mtVjVu3FgdOnSQp6en6XgAAAAA/oCxY8dq2rRpSkxMVL169UzHcRoDBw6UJPXv359nzwEAuAo0XwMAnNLHH3+sKVOmlFnr2rWrbepBvXr19Mwzz5iIZpzFYlFAQIB69uypTp06qXJl/jkHAAAAAAAAAADOq2bNmlqyZIkKCwvl5eUlNze3MvszZsyQl5eXoXQAAMBV7dmzRwUFBerUqZPuuusuSdLy5cuVlJSk8+fPq0uXLpowYUKZQ2Pg2pKTk8tdt1gsqlKliho0aKDIyEhVr17dscEAAABQRmhoqC5evKguXbrI09PTbsJzZmamoWRmLV682HQEAAAqFLq1AABOKTc3V7Vr17ZdP/TQQ/L29rZd16tXT8eOHTMRzbgPPvhAy5cv19tvv62MjAx1795d//jHPxQcHGw6GgAAAAAAAAAAwBX5+PiUu05zCoBrqXv37qpWrZrpGE6FmgCXpaamql27durUqZMkKTs7WxMmTFCPHj0UHBys9PR01a5dW8OHDzecFM4iKytLWVlZKi0tVePGjSVJhw8flpubm4KCgrR06VKlpKRo6dKlatKkieG0AAAAruupp57SiRMnNHLkSPn7+5eZ8uzK2rVrp507dyojI0NHjx7VzJkzVadOHa1YsUL169c3HQ8AAKdTyXQAAADKU6lSJZ04ccJ2HR8frxo1atiu8/PzXXbic61atRQdHa13331XM2bM0OnTp/XQQw+pd+/eevPNN1VaWmo6IgAAAAAAAAAAAABcE0eOHNFTTz2loqIiu73CwkKNGjVKR48eta0lJiaqZs2ajozocNQE+GMOHDig9u3b267Xrl2r0NBQTZ48WQMGDND48eO1bt06gwnhbCIjIxUeHq6tW7fq7bff1ttvv60PP/xQ4eHhuv/++/Xhhx+qbdu2V5yQDQAAAMfYs2ePZsyYoejoaPXq1Us9e/Ys88dVvffee3r88cfl6emprKwsFRcXS5KKioqUlpZmOB0AAM6H5msAgFNq2rSpPvrooyvub926Vc2aNXNgIufUtm1bJSUlaf369fL09NTEiRN15swZ07EAAAAAAAAAAADwF2JKrT1qYs9VapKenq6AgAB5e3vb7fn4+CggIEDz5883kMwcagL8MadPn5a/v7/tOjMzUxEREbbr0NBQ5eXlmYgGJ5Wenq7Y2Ngyf9/6+Pho+PDhmj9/vqpWraonn3xSX3zxhcGUAAAACAoK0oULF0zHcDqzZ89WYmKiJk+eXGYIWps2bZSVlWUwGQAAzonmawCAU+rVq5fmzJmj999/325v8+bNmjdvnnr16uX4YE5m9+7dGj9+vLp27apz587p2Wefla+vr+lYAAAAAAAAAAAA+BVMqbVHTexRk/JlZmbqnnvuueL+vffeq48//tiBicyjJsAf4+/vr9zcXElScXGxsrKy1KpVK9v+2bNn5e7ubigdnFFRUZHy8/Pt1k+dOmX799rX11eXLl1ydDQAAAD8zKhRozR16lR98skn+uGHH1RUVFTmj6s6fPiw2rZta7fu4+PD8C8AAMpR+bdvAQDA8Xr37q2PP/5YgwcPVlBQkBo3bizp8i99hw8f1t13363evXsbTmnGiRMntGLFCr399ts6c+aMunXrptdff51J4AAAAAAAAAAAABXE1U6pTUxMNJDODGpij5qULy8vT35+flfcr1Gjho4dO+bAROZRE+CPiYiI0IsvvqjRo0dr48aN8vT0VFhYmG0/OztbgYGBBhPC2XTu3Fnx8fEaN26cQkNDJUmff/65UlJS1KVLF0nSvn371KhRI4MpAQAAMHDgQElS//79ZbFYbOtWq1UWi0X79+83Fc0of39/5eTkqH79+mXWd+3axe8+AACUg+ZrAIDTmj59uiIjI7VmzRodPnxYktSwYUM9+eSTuv/++w2nM6dTp06qU6eOevTooc6dO6ty5coqLS3VgQMHytwXEhJiKCEAAAAAAAAAAAB+TWZmpl544YUr7t97770aNWqUAxOZR03sUZPy+fj4KCcnR/Xq1St3Pycnp9yG9esZNQH+mNjYWA0fPlx9+/aVl5eXUlJS5OHhYdtftmyZOnToYDAhnM2kSZOUnJyskSNHqqSkRJLk5uamnj17Ki4uTpIUFBSkKVOmmIwJAADg8hYvXmw6glPq3bu3pkyZoqSkJFksFh0/flx79uxRSkqKhg4dajoeAABOx2K1Wq2mQwAAgKv386bqn05j++U/5658KhsAAAAAAAAAAICza9mypdatW3fFRsnvvvtO9913n/bu3evgZOZQE3vUpHyxsbH68ccflZqaWu7+kCFD5O7urpkzZzo4mTnUBPhzCgsL5eXlJTc3tzLrBQUF8vLyKtOQDddVUlKi3bt3q1mzZqpcubKOHj0qSQoMDFS1atUMpwMAAMAv7dy5UxkZGTp69KhmzpypOnXqaMWKFapfv77atm1rOp4RVqtVc+bM0dy5c3X+/HlJkoeHh6KiojRixAiz4QAAcEJMvgYAOKXS0lLNnz9fmzdv1qVLl9S+fXsNGzZMnp6epqMZt2nTJtMRAAAAAAAAAAAA8CcwpdYeNbFHTco3aNAg9enTRzExMRo4cKAaN24sSTp06JDmz5+vbdu2KSMjw3BKx6ImwJ/j4+NT7nr16tUdGwROzc3NTVFRUVq7dq0CAwPLDE8AAACAc3nvvff09NNPq1u3bsrKylJxcbEkqaioSGlpaS7bfG2xWDRkyBA9/vjjysnJ0blz5xQcHMxhQgAAXAHN1wAApzR79my98sorCg8PV5UqVbR48WLl5+crOTnZdDTjrvRwBQAAAAAAAAAAACqGtm3b6l//+pfat29f7v7ixYsVFhbm4FRmURN71KR8N998s2bOnKn4+Hht2LDBtm61WlWjRg29/PLLatGihcGEjkdNAMAxmjZtqtzcXAUGBpqOAgAAgF8xe/ZsJSYmqkePHnrnnXds623atNHs2bMNJnMOHh4eatKkiekYAAA4PYvVarWaDgEAwC/dfffdioqK0v/7f/9PkvTRRx8pOjpa+/btU6VKlQynM2vevHnq16+fbQr4rl27FBoaKg8PD0mXT2WbNm2aEhISDKYEAAAAAAAAAADAlWRlZalPnz7q1KlTuVNq33//fWVkZLhUsyQ1sUdNft2FCxe0detWffvtt7JarWrcuLE6dOhgex/VFVETALi2PvzwQ02fPl2xsbFq0aKFvLy8yux7e3sbSgYAAICf+9vf/qZ33nlH9evXV+vWrbVq1SoFBgbq6NGjuu+++/T555+bjggAACoAmq8BAE7plltu0YYNG1S3bl3bWmhoqDZs2KCAgACDycxr3ry5tm3bJj8/P0mXT2FbuXKl7VTd77//Xh07dtT+/ftNxgQAAAAAAAAAAMCv2LJli+Lj41VQUGBb+2lK7eTJkxUZGWkunCHUxB41sbdnzx4VFBSoU6dOtrXly5dr1qxZOn/+vLp06aIJEybYDq92BdQEABwjJCTE9rHFYrF9bLVaZbFYeFYHAADASURGRuq5555TeHh4mebrFStWaO7cuVq7dq3piAAAoAKobDoAAADlKSkpUZUqVcqsVa5cWZcuXTKUyHn88twUzlEBAAAAAAAAAACoeDp16qQtW7YwpfZnqIk9amIvNTVV7dq1szUaZ2dna8KECerRo4eCg4OVnp6u2rVra/jw4YaTOg41AQDHWLx4sekIAAAAuAq9e/fWlClTlJSUJIvFouPHj2vPnj1KSUnR0KFDTccDAAAVBM3XAACnZLVaNW7cuDInbxcXFyshIUFVq1a1rb3yyism4gEAAAAAAAAAAAB/2M+n1N51112SLk+pTUpKctkptdTEHjUp34EDBxQbG2u7Xrt2rUJDQzV58mRJUkBAgGbNmuVSjcbUBAAco127dld1X0JCgmJiYlSzZs1rnAgAAADliY6OVmlpqR577DGdP39effv2lYeHh6KiotSvXz/T8QAAQAVRyXQAAADK06NHD/n5+cnHx8f2p3v37qpdu3aZNQAAAAAAAAAAAKCiSU1N1ddff227/mlKbXh4uKKjo7VlyxalpaUZTOh41MQeNSnf6dOn5e/vb7vOzMxURESE7To0NFR5eXkmohlDTQDAuaxatUpnz541HQMAAMBlWSwWDRkyRJ988onWrFmjN998Uzt27NCIESNMRwMAABUIk68BAE5p6tSppiM4tbfeekteXl6SpJKSEr399tuqUaOGJPHmDQAAAAAAAAAAgJNjSq09amKPmpTP399fubm5qlu3roqLi5WVlaWYmBjb/tmzZ+Xu7m4woeNREwBwLlar1XQEAAAASPLw8FCTJk1MxwAAABUUzdcAAKc0bNiw37zHzc1NtWrVUnh4uDp37uyAVM7hxhtv1Jtvvmm79vf318qVK8vcU7duXUfHAgAAAAAAAAAAwFViSq09amKPmpQvIiJCL774okaPHq2NGzfK09NTYWFhtv3s7GwFBgYaTOh41AQAAAAAAAAAgL8WzdcAAKfk4+Pzm/eUlpbqyJEjeuuttxQVFVXm1Pfr2ebNm01HAAAAAAAAAAAAwJ/AlFp71MQeNSlfbGyshg8frr59+8rLy0spKSny8PCw7S9btkwdOnQwmNDxqAkAAAAAAAAAAH8tmq8BAE4pOTn5qu/dsmWLEhMTXab5GgAAAAAAAAAAABUbU2rtURN71KR8NWvW1JIlS1RYWCgvLy+5ubmV2Z8xY4a8vLwMpTODmgAAAAAAAAAA8Nei+RoAUOGFhYXplltuMR3DYRYvXnxV9z366KPXOAkAAAAAAAAAAAD+CKbU2qMm9qjJr/Px8Sl3vXr16o4N4kSoCQAAAAAAAAAAfw2L1Wq1mg4BAACuXufOnX/zHovFok2bNjkgDQAAAAAAAAAAAP6oK02pLSgokJeXV5lGW1dBTexREwAAKpaJEycqNjZWNWvWNB0FAAAAAAAAfxDN1wAAAAAAAAAAAAAAAAAAAEA5jhw5opkzZ2rSpEny9vYus1dYWKiEhASNGDFCgYGBhhICAAAAAADgr1bJdAAAAAAAAAAAAAAAAAAAAADAGaWnpysgIMCu8VqSfHx8FBAQoPnz5xtIBgAAAAAAgGuF5msAACqYPXv2aMuWLWXWVqxYoc6dO6t9+/aaMGGCiouLDaUDAAAAAAAAAAAAAAAArh+ZmZm65557rrh/77336uOPP3ZgIgAAAAAAAFxrNF8DAFDBpKam6uuvv7ZdZ2dna/z48QoPD1d0dLS2bNmitLQ0gwkBAAAAAAAAAAAAAACA60NeXp78/PyuuF+jRg0dO3bMgYkAAAAAAABwrdF8DQBABXPgwAG1b9/edr127Vq1bNlSkydP1oABAzR+/HitW7fOYEIAAAAAAAAAAAAAAADg+uDj46OcnJwr7ufk5Mjb29uBiQAAAAAAAHCt0XwNAEAFc/r0afn7+9uuMzMzFRERYbsODQ1VXl6eiWgAAAAAAAAAAAAAAADAdaVt27b617/+dcX9xYsXKywszIGJAAAAAAAAcK3RfA0AQAXj7++v3NxcSVJxcbGysrLUqlUr2/7Zs2fl7u5uKB0AAAAAAAAAAAAAAABw/Rg0aJA+/PBDxcTEaN++fSosLFRhYaH27t2r4cOHa9u2bRo0aJDpmAAAAAAAAPgLVTYdAAAA/D4RERF68cUXNXr0aG3cuFGenp5lTs/Nzs5WYGCgwYQAAAAAAAAAAAAAAADA9eHmm2/WzJkzFR8frw0bNtjWrVaratSooZdfflktWrQwmBAAAAAAAAB/NYvVarWaDgEAAK7eqVOnNHz4cO3atUteXl5KSUnRXXfdZdvv37+/WrVqpZEjRxpMCQAAAAAAAAAAAAAAAFw/Lly4oK1bt+rbb7+V1WpV48aN1aFDB3l6epqOBgAAAAAAgL8YzdcAAFRQhYWF8vLykpubW5n1goICeXl5ycPDw1AyAAAAAAAAAAAAAAAA4PqwZ88eFRQUqFOnTra15cuXa9asWTp//ry6dOmiCRMm8KwOAAAAAADAdaSS6QAAAOCP8fHxsTVer1mzRufOnZMkVa9enTdzAAAAAAAAAAAAAAAAgL9Aamqqvv76a9t1dna2JkyYoPDwcEVHR2vLli1KS0szmBAAAAAAAAB/NZqvAQC4Djz77LPKz883HQMAAAAAAAAAAAAAAAC4rhw4cEDt27e3Xa9du1ahoaGaPHmyBgwYoPHjx2vdunUGEwIAAAAAAOCvRvM1AADXAavVajoCAAAAAAAAAAAAAAAAcN05ffq0/P39bdeZmZmKiIiwXYeGhiovL89ENAAAAAAAAFwjNF8DAAAAAAAAAAAAAAAAAAAA5fD391dubq4kqbi4WFlZWWrVqpVt/+zZs3J3dzeUDgAAAAAAANcCzdcAAFwH5s2bpzp16tiuL1y4YDANAAAAAAAAAAAAAAAAcH2IiIjQiy++qJ07d2r69Ony9PRUWFiYbT87O1uBgYEGEwIAAAAAAOCvRvM1AADXgbZt28rDw0PFxcVasGCBIiMjTUcCAAAAAAAAAAAAAAAAKrzY2Fi5ubmpb9++evPNNzV58mR5eHjY9pctW6YOHToYTAgAAAAAAIC/msVqtVpNhwAAAFevuLhYs2bN0vbt2+Xh4aGBAweqS5cuWrZsmV566SW5ubnpkUceUXR0tOmoAAAAAAAAAAAAAAAAwHWhsLBQXl5ecnNzK7NeUFAgLy+vMg3ZAAAAAAAAqNhovgYAoIJ54YUX9MYbbyg8PFy7d+/WDz/8oF69eumzzz7T4MGDdc8999i9yQMAAAAAAAAAAAAAAAAAAAAAAAAA+G2VTQcAAAC/z7vvvquUlBRFRkbqq6++Uvfu3fXjjz9q1apVslgspuMBAAAAAAAAAAAAAAAAAAAAAAAAQIVVyXQAAADw+xw/fly33HKLJKlZs2by8PDQY489RuM1AAAAAAAAAAAAAAAAAAAAAAAAAPxJNF8DAFDBlJSUyN3d3Xbt5uYmLy8vg4kAAAAAAAAAAAAAAAAAAAAAAAAA4PpgsVqtVtMhAADA1QsJCVFERIQ8PDwkSVu2bNFtt92mqlWrlrnvlVdeMREPAAAAAAAAAAAAAAAAAAAAAAAAACqsyqYDAACA36dHjx6yWCy26+7duxtMAwAAAAAAAAAAAAAAAAAAAAAAAADXDyZfAwAAAAAAAAAAAAAAAAAAAAAAAAAAAICYfA0AQIUTFxf3m/dYLBYlJSU5IA0AAAAAAAAAAAAAAAAAAAAAAAAAXD9ovgYAoIJZvny5brzxRt18882yWq2m4wAAAAAAAAAAAAAAAAAAAAAAAADAdYPmawAAKpiHH35Y77zzjnJzc9WrVy91795d1atXNx0LAAAAAAAAAAAAAAAAAAAAAAAAACo8i5WRmQAAVDjFxcVav369li1bpj179uiOO+7QP/7xD3Xo0EEWi8V0PAAAAAAAAAAAAAAAAAAAAAAAAACokGi+BgCggvvuu++0fPlyrVixQiUlJVqzZo2qVatmOhYAAAAAAAAAAAAAAAAAAAAAAAAAVDiVTAcAAAB/TqVKl/85t1qtKikpMZwGAAAAAAAAAAAAAAAAAAAAAAAAACouJl8DAFABFRcXa/369Vq2bJl27dqlO++8Uw8++KA6duxoa8YGAAAAAAAAAAAAAAAAAAAAAAAAAPw+NF8DAFDBJCQkaO3atQoICNCDDz6obt26qWbNmqZjAQAAAAAAAAAAAAAAAAAAAAAAAECFR/M1AAAVTEhIiG688UY1b95cFovlive98sorDkwFAAAAAAAAAAAAAAAAAAAAAAAAABVfZdMBAADA79OjR49fbboGAAAAAAAAAAAAAAAAAAAAAAAAAPwxTL4GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEmVTAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGdA8zUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiOZrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBE8zUAAAAAAAAAAAAAAAAAAAAAAAAAAAAASKL5GgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAk0XwNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJJovgYAAAAAAAAAAAAAXKcuXLhgOgIAAAAAAAAAAAAAoIKh+RoAAAAAAAAAAAAAYMy4ceP0wAMP6IMPPtADDzyg0NBQ9erVS5999pntnhUrVujhhx9Wu3btdOutt6pfv37at29fma8za9YstW7dWvv27VOfPn0UGhqqJUuWSJKmTZumbt26qXXr1urYsaOeeuopnThxoszn9+vXT4MGDdKaNWt09913629/+5sGDx6s06dP67vvvtPjjz+u1q1b6/7779cnn3xyzesCAAAAAAAAAAAAADDDYrVaraZDAAAAAAAAAAAAAABc07hx47RlyxZVq1ZNw4cPl6+vr+bNm6evv/5a69evl5+fn1555RXVqlVLDRo0UHFxsd555x2tW7dOq1atUuPGjSVdbr5OS0tT3bp19dhjjyk4OFjVq1dXSEiI4uLidPvtt6t27do6deqUFi5cqIKCAr3zzjuqXLmypMvN10eOHFHdunUVHR2toqIiTZ48WeHh4fruu+/Uo0cPNW7cWGlpacrOzrZlBgAAAAAAAAAAAABcXyqbDgAAAAAAAAAAAAAAcG0FBQV6+eWX1b59e0lSu3btdMcdd2jRokUaNWqUhg0bZru3tLRUt99+u/bt26fly5frqaeesu1dunRJI0eO1H333Vfm6ycnJ9s+LikpUevWrRUREaGPP/5YHTp0sO0VFRVpzpw5qlmzpiQpOztbCxYsUEJCgh5++GFJUu3atdWtWzft2LFDXbp0+euLAQAAAAAAAAAAAAAwiuZrAAAAAAAAAAAAAIBRPj4+tsbrn67Dw8O1d+9eSdLBgwc1ffp07dmzR/n5+bb7jhw5Yve17rjjDru1Dz74QLNnz9bXX3+toqKiMp//8+brkJAQW+O1JDVq1EiSFB4ebrd27Nix3/dNAgAAAAAAAAAAAAAqBJqvAQAAAAAAAAAAAABG/bzh+Sd+fn46ePCgioqKFBUVpZo1a2rcuHG68cYbVaVKFT3zzDO6ePFimc+pWrWqqlWrVmZt3759Gjp0qCIjI/XEE0/Iz89PFotFvXv3tvt8X1/fMtfu7u6SLjeD/8TDw0OS7D4XAAAAAAAAAAAAAHB9oPkaAAAAAAAAAAAAAGDUqVOn7Nby8/NVq1YtffbZZzp27JjS0tIUEhJi2y8sLFRAQECZz7FYLHZfZ+PGjfL29tbLL7+sSpUqSZK+++67v/g7AAAAAAAAAAAAAABcLyqZDgAAAAAAAAAAAAAAcG2FhYXasWNHmeuPPvpIf/vb33ThwgVJ/51CLUm7d+++6gbqCxcuyN3dvUxj9urVq/+i5AAAAAAAAAAAAACA6w2TrwEAAAAAAAAAAAAARlWvXl3jx49XTEyMfHx8NG/ePFmtVvXv31+S5OXlpcTEREVHR+v48eOaNWuW6tSpc1Vf+/bbb9err76q5557TnfddZf27NmjlStXXstvBwAAAAAAAAAAAABQgTH5GgAAAAAAAAAAAABgVK1atfTss89q7ty5io2N1cWLF5Weni5/f3/5+/trxowZOnXqlIYOHapXX31ViYmJatiw4VV97TvuuEOjR4/Wpk2bNGTIEO3cuVNpaWnX+DsCAAAAAAAAAAAAAFRUFqvVajUdAgAAAAAAAAAAAADgmsaNG6cvvvhCa9asMR0FAAAAAAAAAAAAAAAmXwMAAAAAAAAAAAAAAAAAAAAAAAAAAACARPM1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAEiSLFar1Wo6BAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYxuRrAAAAAAAAAAAAAAAAAAAAAAAAAAAAABDN1wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgieZrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBE8zUAAAAAAAAAAAAAAAAAAAAAAAAAAAAASKL5GgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAk0XwNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJJovgYAAAAAAAAAAAAAAAAAAAAAAAAAAAAASTRfAwAAAAAAAAAAAAAAAAAAAAAAAAAAAIAk6f8DD0puzHMWpVAAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(50, 10))\n", + "df.plot.bar(ax=ax)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "38393d22-85a7-477d-9796-040aee2b624c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "speedups = (df['test_pydicom_read'] / df['test_dimble_read'])" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "f7785fc1-72aa-4463-8645-29f260d37f78", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Example File')" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(20, 8))\n", + "speedups.plot.bar(ax=ax)\n", + "ax.set_ylabel(\"Dimble Speedup Factor\")\n", + "ax.set_xlabel(\"Example File\")" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "02c55f5a-fd80-4685-91c3-7638fa98dd87", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "count 56.00\n", + "mean 31.08\n", + "std 64.01\n", + "min 4.02\n", + "25% 5.73\n", + "50% 8.26\n", + "75% 13.46\n", + "max 329.51\n", + "dtype: float64" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "speedups.describe().round(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "aadeebaa-1a89-4bcb-804f-13de8bc511cd", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "8.255566963388068" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "speedups.median()" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "baf7ef0a-5c70-4818-8013-946f001fc8ae", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "31.08230768490863" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "speedups.mean()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2d37893a-8a50-455f-8f56-9f4c23c5a1e7", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/test/pydicom_comparisons.py b/test/pydicom_comparisons.py new file mode 100644 index 0000000..1880153 --- /dev/null +++ b/test/pydicom_comparisons.py @@ -0,0 +1,139 @@ +import json +import tempfile +from pathlib import Path +import os + +import numpy as np +import pydicom +import SimpleITK as sitk +import gdcm +import pytest +import dimble + +PIXEL_ARRAY = "7FE00010" + + +# These files euther use DICOM features unsupported by dimble or are corrupt. +# Eventually these will be moved out of this list because either dimble will +# support them or we will have asserts that specific and helpful error messages +# are raised. +ignore_files = [ + "OT-PAL-8-face.dcm", + "emri_small_jpeg_2k_lossless_too_short.dcm", + "bad_sequence.dcm", + # problems with reconstruction + "SC_rgb_expb_32bit_2frame.dcm", + "SC_rgb_expb_32bit.dcm", + "US1_J2KI.dcm", + "SC_rgb_32bit.dcm", + "US1_J2KR.dcm", + "SC_rgb_32bit_2frame.dcm", + "explicit_VR-UN.dcm", + "SC_ybr_full_uncompressed.dcm", + "color3d_jpeg_baseline.dcm", +] +TESTFILES_DIR = Path(__file__).parent.parent / "pydicom-data" / "data" +assert TESTFILES_DIR.exists() + +dicom_files = list( + p + for p in TESTFILES_DIR.glob("*.dcm*") + if p.name not in ignore_files and "recon" not in p.name +) +if os.getenv("E2ESMALL", None): + dicom_files = dicom_files[:1] +assert len(dicom_files) > 0 +dicom_files_ids = [p.name.split("?")[0] for p in dicom_files] + +DIMBLE_FILES = {} + +def convert_to_dimble(dicom_file: Path): + dimble_file = Path("/tmp") / dicom_file.with_suffix(".dimble").name + if not dimble_file.exists(): + dimble.dicom_to_dimble(str(dicom_file), str(dimble_file)) + DIMBLE_FILES[dicom_file] = dimble_file + +for dicom_file in dicom_files: + convert_to_dimble(dicom_file) + +print("dimble_files", DIMBLE_FILES) + +def pydicom_to_numpy(dicom_file: Path): + ds = pydicom.dcmread(dicom_file) + pixel_array = ds.pixel_array + return pixel_array.sum() + +def sitk_to_numpy(dicom_file: Path): + ds = sitk.ReadImage(str(dicom_file)) + pixel_array = sitk.GetArrayFromImage(ds) + return pixel_array.sum() + +def _get_gdcm_to_numpy_typemap(): + """Returns the GDCM Pixel Format to numpy array type mapping.""" + _gdcm_np = {gdcm.PixelFormat.UINT8 :np.uint8, + gdcm.PixelFormat.INT8 :np.int8, + #gdcm.PixelFormat.UINT12 :numpy.uint12, + #gdcm.PixelFormat.INT12 :numpy.int12, + gdcm.PixelFormat.UINT16 :np.uint16, + gdcm.PixelFormat.INT16 :np.int16, + gdcm.PixelFormat.UINT32 :np.uint32, + gdcm.PixelFormat.INT32 :np.int32, + #gdcm.PixelFormat.FLOAT16:numpy.float16, + gdcm.PixelFormat.FLOAT32:np.float32, + gdcm.PixelFormat.FLOAT64:np.float64 } + return _gdcm_np + +def _get_numpy_array_type(gdcm_pixel_format): + """Returns a numpy array typecode given a GDCM Pixel Format.""" + return _get_gdcm_to_numpy_typemap()[gdcm_pixel_format] + + +def _gdcm_to_numpy(image): + """Converts a GDCM image to a numpy array. + """ + pf = image.GetPixelFormat() + + assert pf.GetScalarType() in _get_gdcm_to_numpy_typemap().keys(), \ + "Unsupported array type %s"%pf + + shape = image.GetDimension(0) * image.GetDimension(1), pf.GetSamplesPerPixel() + if image.GetNumberOfDimensions() == 3: + shape = shape[0] * image.GetDimension(2), shape[1] + + dtype = _get_numpy_array_type(pf.GetScalarType()) + gdcm_array = image.GetBuffer() + result = np.fromstring(gdcm_array, dtype=dtype) + result.shape = shape + return result + +def gdcm_to_numpy(dicom_file: Path): + reader = gdcm.ImageReader() + reader.SetFileName(str(dicom_file)) + reader.Read() + image = reader.GetImage() + gdcm_array = image.GetBuffer() + return gdcm_array + + +def dimble_to_numpy(dicom_file: Path): + dimble_file = DIMBLE_FILES[dicom_file] + ds = dimble.load_dimble(str(dimble_file), fields=[PIXEL_ARRAY]) + pixel_array = ds[PIXEL_ARRAY] + return pixel_array.sum() + + +@pytest.mark.parametrize("dicom_file", dicom_files, ids=dicom_files_ids) +def test_pydicom_read(dicom_file: Path, benchmark): + benchmark(pydicom_to_numpy, dicom_file) + +@pytest.mark.parametrize("dicom_file", dicom_files, ids=dicom_files_ids) +def test_sitk_read(dicom_file: Path, benchmark): + benchmark(sitk_to_numpy, dicom_file) + +@pytest.mark.parametrize("dicom_file", dicom_files, ids=dicom_files_ids) +def test_gdcm_read(dicom_file: Path, benchmark): + benchmark(gdcm_to_numpy, dicom_file) + +@pytest.mark.parametrize("dicom_file", dicom_files, ids=dicom_files_ids) +def test_dimble_read(dicom_file: Path, benchmark): + benchmark(dimble_to_numpy, dicom_file) \ No newline at end of file From 58198e514a07f166a4a26b4daced25e9f575030d Mon Sep 17 00:00:00 2001 From: strongchris Date: Thu, 18 May 2023 05:01:13 +0000 Subject: [PATCH 06/11] better conversion scripts --- dimble/__init__.py | 3 + dimble/dimble.py | 4 + scripts/dicom_to_dimble.py | 30 + scripts/dicom_vs_dimble.py | 33 +- .../load_times_variance_visualisation.ipynb | 535 ++++++++++++++++++ scripts/pyprocs.py | 15 + scripts/skm_tea_to_dimble.py | 24 - 7 files changed, 614 insertions(+), 30 deletions(-) create mode 100644 scripts/dicom_to_dimble.py create mode 100644 scripts/load_times_variance_visualisation.ipynb create mode 100644 scripts/pyprocs.py delete mode 100644 scripts/skm_tea_to_dimble.py diff --git a/dimble/__init__.py b/dimble/__init__.py index 2a0195b..d561b79 100644 --- a/dimble/__init__.py +++ b/dimble/__init__.py @@ -5,7 +5,9 @@ dimble_to_nifti, load_dimble, nifti_to_dimble, + rglob_dicom ) +rglob_dicom __all__ = [ "dicom_to_dimble", @@ -14,4 +16,5 @@ "nifti_to_dimble", "dimble_to_nifti", "_create_temp_dir", + "rglob_dicom" ] diff --git a/dimble/dimble.py b/dimble/dimble.py index 5459911..27a963c 100644 --- a/dimble/dimble.py +++ b/dimble/dimble.py @@ -133,3 +133,7 @@ def dimble_to_nifti(dimble_path: Path, output_path: Path) -> None: sitk.WriteImage(itk_image, output_path) finally: ir_path.unlink(missing_ok=True) + +def rglob_dicom(path: Path) -> list[Path]: + dicom_extensions = [".dcm", ".dicom", ".DCM", ".DICOM"] + return [p for p in path.rglob("*") if p.suffix in dicom_extensions] \ No newline at end of file diff --git a/scripts/dicom_to_dimble.py b/scripts/dicom_to_dimble.py new file mode 100644 index 0000000..5b537b2 --- /dev/null +++ b/scripts/dicom_to_dimble.py @@ -0,0 +1,30 @@ +from pathlib import Path +from multiprocessing import Pool + +import plac +from tqdm import tqdm + +import dimble + +def convert(dicom_dir: Path, dicom_files: list[Path], dimble_dir: Path): + for dicom_file in tqdm(dicom_files): + dimble_file = dimble_dir / dicom_file.relative_to( + dicom_dir + ).with_suffix(".dimble") + if dimble_file.exists(): + continue + dimble_file.parent.mkdir(parents=True, exist_ok=True) + dimble.dicom_to_dimble(dicom_file, dimble_file) + +@plac.annotations( + dicom_path=("Path to DICOM directory", "positional", None, Path), + dimble_path=("Path to DIMBLE directory", "positional", None, Path), +) +def main(dicom_path: Path, dimble_path: Path): + dicom_files = list(dicom_path.glob("**/*.dcm")) + list(dicom_path.glob("**/*.dicom")) + list(dicom_path.glob("**/*.DCM")) + # convert(dicom_path, dicom_files, dimble_path) + with Pool(16) as p: + p.starmap(convert, [(dicom_path, dicom_files[i::16], dimble_path) for i in range(16)]) + +if __name__ == "__main__": + plac.call(main) diff --git a/scripts/dicom_vs_dimble.py b/scripts/dicom_vs_dimble.py index 1c048e5..583cbaf 100644 --- a/scripts/dicom_vs_dimble.py +++ b/scripts/dicom_vs_dimble.py @@ -2,6 +2,7 @@ import time from pathlib import Path from typing import Optional +import json import numpy as np import plac @@ -12,20 +13,31 @@ import dimble -def dimble_loading(dimble_files, cuda=False, verbose=True): +def dimble_loading(dimble_files, cuda=False, verbose=True) -> list[int]: + times = [] for file in tqdm(dimble_files, desc="DIMBLE", disable=not verbose): + start_time = time.perf_counter() data = dimble.load_dimble(file, ["7FE00010"]) if cuda: data = data["7FE00010"].cuda() + end_time = time.perf_counter() + elapsed_time = end_time - start_time + times.append(elapsed_time) + return times -def dicom_loading(dicom_files, cuda=False, verbose=True): +def dicom_loading(dicom_files, cuda=False, verbose=True) -> list[int]: + times = [] for file in tqdm(dicom_files, desc="DICOM", disable=not verbose): + start_time = time.perf_counter() data = pydicom.dcmread(str(file)) data = torch.from_numpy(data.pixel_array.astype(np.int32)) if cuda: data = data.cuda() - + end_time = time.perf_counter() + elapsed_time = end_time - start_time + times.append(elapsed_time) + return times @plac.annotations( dicom_dir=("Path to DICOM directory", "positional", None, Path), @@ -36,7 +48,7 @@ def dicom_loading(dicom_files, cuda=False, verbose=True): def main(dicom_dir: Path, dimble_dir: Path, n: Optional[int], cuda: bool = False): if n is None: n = -1 - dicom_files = list(dicom_dir.rglob("*.dcm"))[:n] + dicom_files = dimble.rglob_dicom(dicom_dir)[:n] dimble_files = list(dimble_dir.rglob("*.dimble"))[:n] assert len(dimble_files) == len( dicom_files @@ -50,14 +62,14 @@ def main(dicom_dir: Path, dimble_dir: Path, n: Optional[int], cuda: bool = False # DICOM dicom_start = time.perf_counter() - dicom_loading(dicom_files, cuda=cuda) + dicom_times = dicom_loading(dicom_files, cuda=cuda) torch.cuda.synchronize() dicom_end = time.perf_counter() dicom_elapsed = dicom_end - dicom_start # DIMBLE dimble_start = time.perf_counter() - dimble_loading(dimble_files, cuda=cuda) + dimble_times = dimble_loading(dimble_files, cuda=cuda) torch.cuda.synchronize() dimble_end = time.perf_counter() dimble_elapsed = dimble_end - dimble_start @@ -72,6 +84,15 @@ def main(dicom_dir: Path, dimble_dir: Path, n: Optional[int], cuda: bool = False ) print(f"DIMBLE is {dicom_elapsed/dimble_elapsed:.2f}x faster than DICOM") + with open("/tmp/dicom_vs_dimble_timings.json", 'w') as f: + json.dump( + { + "dicom_times": dicom_times, + "dimble_times": dimble_times, + }, + f + ) + if __name__ == "__main__": plac.call(main) diff --git a/scripts/load_times_variance_visualisation.ipynb b/scripts/load_times_variance_visualisation.ipynb new file mode 100644 index 0000000..d44f47b --- /dev/null +++ b/scripts/load_times_variance_visualisation.ipynb @@ -0,0 +1,535 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "7f9e5224-6fb3-4fd4-a5a8-0a0f1281c59c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1918292/3053543668.py:8: MatplotlibDeprecationWarning: The seaborn styles shipped by Matplotlib are deprecated since 3.6, as they no longer correspond to the styles shipped by seaborn. However, they will remain available as 'seaborn-v0_8-\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dicom_timesdimble_times
010.8938720.215417
16.5025860.071315
2163.9320520.061256
3129.9169150.061937
4246.3435140.059573
.........
9958.2625660.061196
9968.7866760.061516
9974.1293780.061206
9983.9145840.060224
9994.7679470.060264
\n", + "

1000 rows × 2 columns

\n", + "" + ], + "text/plain": [ + " dicom_times dimble_times\n", + "0 10.893872 0.215417\n", + "1 6.502586 0.071315\n", + "2 163.932052 0.061256\n", + "3 129.916915 0.061937\n", + "4 246.343514 0.059573\n", + ".. ... ...\n", + "995 8.262566 0.061196\n", + "996 8.786676 0.061516\n", + "997 4.129378 0.061206\n", + "998 3.914584 0.060224\n", + "999 4.767947 0.060264\n", + "\n", + "[1000 rows x 2 columns]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "with open(\"/tmp/dicom_vs_dimble_timings.json\") as f:\n", + " timings = json.load(f)\n", + "\n", + "df = pd.DataFrame(timings) * 1000\n", + "\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1d9e81a4-a413-4eb3-8864-c590da5396f8", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsEAAAHTCAYAAADGR8V5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA7tklEQVR4nO3de1yUZd7H8e8MoBInkYOGaJaKWApitibhoqZ2UCvPpZUaaaap23pKHxRR81S6agctTxlp5dq2ZVrP03GfetTVCjVLzUOmZikgiiAhMPP84TIbCymOAzN4fd6vV6+c+77mvn8XPwa/3F5zj8Vut9sFAAAAGMTq7gIAAACAqkYIBgAAgHEIwQAAADAOIRgAAADGIQQDAADAOIRgAAAAGIcQDAAAAOMQggEAAGAcQjAAAACM4+3uAqqTjIyzVXYuq9WiOnX8dOpUnmw2PtTPE9Ejz0ePPBv98Xz0yPPRo7LCwgIqNI4rwR7KarXIYrHIarW4uxT8Dnrk+eiRZ6M/no8eeT565DxCMAAAAIxDCAYAAIBxCMEAAAAwDiEYAAAAxiEEAwAAwDiEYAAAABiHEAwAAADjEIIBAABgHEIwAAAAjEMIBgAAgHEIwQAAADAOIRgAAMAFnnhimBYtmi9J6tOnh9atW+vmii5fda3bGd7uLgAAAOC3HpnzSZWeb+VTnVx+zGXLXpWvr6/Lj+sqmzZt0OLF8/XBB5+V2u7pdbsSIRgAAMDFgoOD3V2CU6pr3c5w+3KI7du3a/jw4UpISFCzZs300Ucfldpvt9u1aNEiJSQkKCYmRoMHD9bhw4dLjTl9+rTGjh2r1q1bq02bNpo8ebLy8vJKjdm7d68GDBigli1bKjExUcuWLavsqQEAgKtUfn6+ZsyYqi5d2uvee+/Q66+/Vmr/fy4rOHv2rObNe1o9enRVp07xeuihfvq///vcsf+zzz7Wgw/2U8eO7dSnT49yj/fKK8sd5+zdu7u++OIfys7O1uOPP66OHW/ToEH3a+/e7y5Z+9dff6lZs1KVm5urhIQ2SkhooxUrXiq37oSENvr739/ShAl/0u2336aBA/to9+5dOnbsqJ54Ypg6d07Q8OGP6KefjpU6x+eff6ZHHhmoTp3i1bfvvVq58mUVFRVJupDtVqx4Sb16dVPHju107713auHCZyr0dXclt4fgc+fOqVmzZkpJSSl3/7Jly5SWlqZp06Zp3bp18vX1VVJSkgoKChxjxo0bpwMHDmjVqlVaunSpvvzyS02dOtWxPzc3V0lJSYqIiNDf/vY3TZgwQc8//7zefPPNSp8fAAC4+rzwwiLt2PG1Zs+erwULXlB6+lf6/vt95Y612WwaN260vvlmp6ZOna60tHUaPnyUrNYLMWzv3j2aOnWSOnfuqtWr39AjjwzT8uVLtGnThlLHWbfudbVsGauVK9eoXbsEzZgxVampU3TPPfdo9eq1ioiI1MyZKbLb7RetvWXLWI0ePVZ+fn56550P9M47H+iBBx763fGrV6/QHXd006pVa9WwYSOlpibrmWdm6aGHhmj58jTZ7XYtWDDPMX7nznTNnJmivn0fUFraOk2YMEnvv/+eXn11paQLgX/durUaP36yXn/9bc2e/axuuKFJhb7uruT25RCJiYlKTEwsd5/dbterr76qxx9/XJ07d5YkzZs3T/Hx8froo4/UrVs3HTx4UJ9//rnWr1+vli1bSpKSk5M1bNgwTZgwQXXr1tW7776rwsJCzZo1SzVq1FDTpk21Z88erVq1Sv3796+yuQIAgOrv3Llz2rjxHU2ZMkNt2vxBkpScPE09e95d7vgvv9ymPXu+1Wuv/VUNG14nSapfP9Kx/8031+jmm2/R4MGPSpIaNrxOhw8f0tq1abr77h6Oce3axeu++3pLkoYMeVR///t63XjjTbrrrruUnZ2ngQMHafjwITp1KkshIaG/W7+Pj4/8/f1lsVguOq7E3Xf30O23d5EkxzkGDUpS27btJEl9+96vWbOmO8avXLlMDz44WHfd1d0x10cfHa4XX1ysRx4ZphMnflGdOiG65Za28vb2Vr169XTjjS0uWYeruT0EX8yxY8eUkZGh+Ph4x7aAgADFxsYqPT1d3bp1U3p6ugIDAx0BWJLi4+NltVq1a9cudenSRTt27FCbNm1Uo0YNx5iEhAQtW7ZMZ86cUVBQUIXqsVotslotrpvgRXh5WUv9H56HHnk+euTZ6I/nM6VH3t6XN78TJ46rsLBQMTEtHc+tUydY113XSFbrv49ntVrk7W3VwYPfKzw8XDfccH25x/vxx8P64x8TS9XRqlWc1q17XRaLXV5eXpKkpk2jHGPCw8P+ta2ppAs9Cg+/EGhzck6rbt3wi86hJM+UN/eSuktERf32vKFltoWFher8+QIVFJyTn5+/Dh78Xrt373Rc+ZUuXA0vKChQUVGBunTpqr/+9Q3163evbr01XvHxtykh4Y/y9q7aWOrRITgjI0OSFBISUmp7SEiIMjMzJUmZmZmqU6dOqf3e3t4KCgpyPD8zM1ORkZGlxoSGhjr2VTQE16njJ4ulakJwiUff/3OVnq+qreu/xN0lXLHAQDPeRVud0SPPRn8839Xeo+Bgv8saX/L1CAq6ptRzvbysqlnTR8HBfvLyssrXt4aCg/0UHBwoq9X6u+fx9v732BJ+fjVlsVj+dSwveXlZFRBwTZljBAb6OWoKCrpGkhQQUOuSc/rt8X/rt3WXqF3b3/E4L+/COerUCXBsCwjwddQQGOin/Px8jRo1Sl27di1z3rp16+jaa0P1P//z39q8ebM2b96s+fPn6s031ygtLU0+Pj4XrduVPDoEe5pTp/Kq9Erw1f5DR5Kys/MuPchDlfQoJydfxcU2d5eDctAjz0Z/PJ8pPbrcv4sCAkLk7e2tzZu3OZYJ5OTk6IcfflBMTCtlZ+epuNim/Pzzys7OU0TEdfrll1+0c+d3juUQvxUZeZ3++c/tGjjw33Vs3vxPNWjQUDk5v0pSqeP91rlzBf86f77OnMl3/PlSczp/3qbi4uIy48o7T27ur47H5Z3j7NkLNZ4+fU7FxV6KiorWvn371afPgDLnLXm+JMXFtVVcXFt1795T/fv30pdf7lR0dPOL1l0RFf2lxqNDcFjYhUv9WVlZCg//92X9rKwsRUdHS7pwRffUqVOlnldUVKQzZ844nh8aGuq4clyi5HHJFeGKsNnsstkuvtgcl6eoqPr/UC0utl0V87ia0SPPRn8839Xeo8udW40atdS9+7167rmF8vcPVHBwsF5++UVZLFbZbP8+ns1mV1GRTTExcYqNjdNTT43TqFFPqn79Bvrxx8OyWCy69dZ49e8/UEOHPqzly19Wp05d9O2332j9+jc1duxTpWorOd5vleSS4mKb4xeVivQrPLyezp07p61bt6pJkyjVqlVLtWrVKvc8xcX/flzeOUq2FRVd2DZ48KOaMOFPCgurqw4dbpfVatWBA9/r0KGDGjZshDZt2iCbrVg33thCNWvW0qZNG1WzZk2FhdWt0u8zjw7BkZGRCgsL05YtW9S8+YXfDHJzc7Vz50498MADkqS4uDjl5ORo9+7datHiwqLqrVu3ymazKSYmRpLUqlUrLVy4UIWFhY7L7Js3b9b1119f4aUQAACgalTGh1e42ogRY5Sff04TJz6pa67x0/33D1Rubu7vjn/66Xl6/vmFmjbtv5Sf/6siIyM1fPgoSVKzZtGaPn22li9/Sa+8slwhIaFKShpe6k1xrtayZazuu6+3UlIm6cyZMxoyZKiSkh5zybHbtm2nefMW6pVXlmnNmtXy9vZWw4aN1KPHfZIkf/8AvfbaK3ruub/IZrPphhuaaO7cvygoqLZLzl9RFvul7qNRyfLy8nTkyBFJ0n333adJkyapbdu2CgoKUkREhF5++WUtW7ZMc+bMUWRkpBYtWqR9+/Zp06ZNqlmzpiTp0UcfVVZWllJTU1VYWKjJkyerRYsWmj//wkcXnj17Vnfeeaduu+02DR06VPv379fkyZM1adKky7o7REbGWdd/AX6Ht/eFtUP93ny8ys7pDi90mnfpQR6qpEfZ2XlX9RWS6oweeTb64/nokeejR2WFhQVUaJzbrwTv3r1bDz/8sOPx7NmzJUk9e/bUnDlzNHToUOXn52vq1KnKycnRzTffrOXLlzsCsCQ9++yzmjFjhgYNGiSr1aquXbsqOTnZsT8gIEArVqzQ9OnT1atXLwUHB2vEiBHcHg0AAMBQbr8SXJ1wJdj1uBKMykSPPBv98Xz0yPP9Xo/Gjh2tXbvSy33OQw8N0cMPP1JVJVa5anMlGAAAAK711FPJpT5d97cCAwOruBrPRAgGAAC4yoSFXfzDMiBd3R8BAwAAAJSDEAwAAADjEIIBAABgHEIwAAAAjEMIBgAAgHEIwQAAAC7wxBPDtGjRhU+r7dOnh9atW3tFx1ux4iUNHjzgomOmT0/RiBEjrug8l/LbeV1NuEUaAADwKCM/mVCl56uMD25atuxV+fr6uvy4lenrr7/U6NHD9f77nyog4N8fODFr1jPy9r76IuPVNyMAAAA3Cw4OdncJLhMYGOTuEioFIRgAAOAy5efn69lnZ+t///dTXXPNNbr//odK7e/Tp4f69XtA/fpdWM6QkNBG48ZN0ubNn+urr7arXr1rNWnSVNWuHaw5c2Zo797v1KRJlKZMma769SNLHevvf39Lr766UmfOnFZ8fHtNnJgsf3//cuuy2Wxas2a13n33bWVlZalBg4YaPDhJHTt2vuh8fv75uEaPHi5Juuuujv/6f3f9139N0xNPDFPTps00ZsxYx9y6d79XR48e0f/+76cKDAzSk0+O1003xWju3Bn66qvtioior0mTpio6+kbHOXbu3KGXXnpee/fuUe3atfXHP3bQY4894bhi/re//VXr1q3VyZMn5Ofnr9jYVpo50/VX6UuwJhgAAOAyvfDCIu3Y8bVmz56vBQteUHr6V/r++30Xfc7q1St0xx3dtGrVWjVs2Eipqcl65plZeuihIVq+PE12u10LFpQOfT/9dFSffvqR5s5doPnzn9P+/fs0f/6c3z1HWtoqffDBRo0bN0lpaW+qf/8BmjFjqtLTv7pobeHhdfX00xfOvXbtW3rnnQ80Zsy43x2/bt3ratkyVitXrlG7dgmaMWOqZs5MUdeud2vFitcUERGpmTNTZLfb/zWPYxo3bpQ6dOik1atfV2rqLO3atUN/+cuFc+7d+50WLXpWSUmPae3atzR//mLFxra+aM1XihAMAABwGc6dO6eNG9/RyJF/Ups2f1Djxk2UnDxNxcVFF33e3Xf30O23d1HDhtdp4MBB+vnn4+rS5U61bdtOjRpdr7597y8TVs+fP6/k5FQ1bdpMrVq11p/+NF4ff/w/ysrKLHP88+fPKy1tlSZNmqq2bdupfv1I3X13D3XtepfeeedvF63Ny8tLAQGBkqTg4DoKCQn93avNktSuXbzuu6+3GjRoqCFDHlVeXp6aN79RnTp1dszv8OEfdOpUlqQL4bxLlzvVr98ANWjQUC1bxmrMmPH64IONKigo0IkTv6hWrVq67bb2qlfvWkVFRatv3/svWvOVYjkEAADAZfjpp2MqLCzUjTe2cGwLDAxSw4bXXfR5jRs3dfy5Tp06/9rW5DfbQnT+fIHy8nLl53chgIaH11NYWLhjTIsWMbLZbDpy5EeFhISWOv6xY0f166+/6sknR5baXlhYqKZNm13mLC+u9FxCJEk33PDbuVyYX3Z2tkJCQnXgwH4dPLhfH374gWOM3W6XzWbTzz8f1y23tFW9eteqX7971bZtO7VtG68//rGjatWq5dK6f4sQDAAAUAV+e4cFi8VSZlsJm83u1PHz8/MlSfPmLSwVnCXJx8fHqWP+nkvNpWSb3W77V23ndO+9vdSnT9mru3Xr1pOPj49WrHhN6elfafv2rVq+fKlWrnxZy5a9WupOFS6dQ6UcFQAA4CpVv36kvL299d13u1WvXj1JUk5Ojo4ePaJWrW526blOnvxFmZkZCg0NkyR9++03slqt5V51vv7661WjRg2dOPGL4uIuv46SoGyzFV9Z0eWIiorWDz/8oMjIBr87xtvbW7fc0la33NJWQ4YM0513dtDXX29XYmInl9cjEYIBAAAuyzXXXKPu3e/Viy8uUlBQkIKDg/Xyyy/KYnH9W61q1KihmTNTNHLkn3TuXJ4WLnxGHTt2LrMU4kJdfrr//gf13HMLZLfbFRPTSrm5ufrmmx3y8/PXXXd1v+i56tW7VhaLRZs3f6Fbb71NNWvW1DXXXOOSeQwcOEiPPTZYCxbMVY8e96lWLV8dPnxI27f/U3/+80T93/99ruPHf1KrVnEKCAjUli3/J7vdrgYNLr7E5EoQggEAgEepjA+vcLURI8YoP/+cJk588l/hc6Byc3Ndfp769RsoMbGTxo8fo5ycHMXHJ2js2Kd+d/zQoY+rdu1gpaWt0vHjP8nfP0BRUdF6+OEhlzxXWFi4kpIe09Klz2nWrFTdeWc3/dd/TXPJPJo0aarnn39ZL7/8okaMGCrJroiISN1+exdJkr9/gP7xj0+0cuXLOn++QJGRDZWS8rRuuKGxS85fHou95N4VuKSMjLNVdi5vb6uCg/3U783Hq+yc7lAdftD9npIeZWfnqajI5u5yUA565Nnoj+ejR56PHpUVFlaxNcTcIg0AAADGYTkEAACAAZ55Zpb+53/eL3df1653afz4yVVckXsRggEAAAzw6KPD9cADD5W7z8/Pr4qrcT9CMAAAgAGCg+soOLiOu8vwGKwJBgAAgHEIwQAAADAOIRgAAADGIQQDAADAOIRgAAAAGIcQDAAAAOMQggEAAGAcQjAAAACMQwgGAACAcQjBAAAAMA4hGAAAAMYhBAMAAMA4hGAAAAAYhxAMAAAA4xCCAQAAYBxCMAAAAIxDCAYAAIBxCMEAAAAwDiEYAAAAxiEEAwAAwDiEYAAAABiHEAwAAADjEIIBAABgHEIwAAAAjEMIBgAAgHEIwQAAADAOIRgAAADGIQQDAADAOIRgAAAAGIcQDAAAAOMQggEAAGAcQjAAAACMQwgGAACAcQjBAAAAMA4hGAAAAMYhBAMAAMA4hGAAAAAYhxAMAAAA4xCCAQAAYBxCMAAAAIxDCAYAAIBxCMEAAAAwDiEYAAAAxiEEAwAAwDiEYAAAABiHEAwAAADjeHwILi4u1sKFC9WpUyfFxMSoc+fOeuGFF2S32x1j7Ha7Fi1apISEBMXExGjw4ME6fPhwqeOcPn1aY8eOVevWrdWmTRtNnjxZeXl5VTwbAAAAeAKPD8HLli3T66+/rqlTp2rTpk0aN26cli9frrS0tFJj0tLSNG3aNK1bt06+vr5KSkpSQUGBY8y4ceN04MABrVq1SkuXLtWXX36pqVOnumNKAAAAcDOPD8Hp6em6/fbb1aFDB0VGRurOO+9UQkKCdu3aJenCVeBXX31Vjz/+uDp37qzo6GjNmzdPJ0+e1EcffSRJOnjwoD7//HPNnDlTsbGxatOmjZKTk7Vx40adOHHCndMDAACAG3h8CI6Li9PWrVv1ww8/SJL27t2rr776Sn/84x8lSceOHVNGRobi4+MdzwkICFBsbKzS09MlXQjSgYGBatmypWNMfHy8rFarI0wDAADAHN7uLuBShg0bptzcXN11113y8vJScXGxnnzySd1zzz2SpIyMDElSSEhIqeeFhIQoMzNTkpSZmak6deqU2u/t7a2goCDH8yvCarXIarVcyXQqzMvL438/cQlv7+o7z5IemdKr6ogeeTb64/nokeejR87z+BD8/vvva8OGDZo/f76aNGmiPXv2aPbs2QoPD1fPnj2rtJY6dfxksVRNCDZFcLCfu0u4YoGBvu4uAZdAjzwb/fF89Mjz0aPL5/EheN68eRo2bJi6desmSWrWrJmOHz+ul156ST179lRYWJgkKSsrS+Hh4Y7nZWVlKTo6WpIUGhqqU6dOlTpuUVGRzpw543h+RZw6lVelV4JN+IbOzq6+d+go6VFOTr6Ki23uLgfloEeejf54Pnrk+ehRWRW9wObxIfjXX38tc/XVy8vLcYu0yMhIhYWFacuWLWrevLkkKTc3Vzt37tQDDzwg6cK64pycHO3evVstWrSQJG3dulU2m00xMTEVrsVms8tms196ICqsqKj6v2CLi21XxTyuZvTIs9Efz0ePPB89unweH4I7duyopUuXKiIiwrEcYtWqVerdu7ckyWKx6OGHH9aSJUt03XXXKTIyUosWLVJ4eLg6d+4sSWrcuLHat2+vKVOmKDU1VYWFhZoxY4a6deumunXrunN6AAAAcAOPD8HJyclatGiRUlNTHUse+vfvr5EjRzrGDB06VPn5+Zo6dapycnJ08803a/ny5apZs6ZjzLPPPqsZM2Zo0KBBslqt6tq1q5KTk90xJQAAALiZxf7bj17DRWVknK2yc3l7WxUc7Kd+bz5eZed0hxc6zXN3CU4r6VF2dh7/BOWh6JFnoz+ejx55PnpUVlhYQIXGcT8NAAAAGIcQDAAAAOMQggEAAGAcQjAAAACMQwgGAACAcQjBAAAAMA4hGAAAAMYhBAMAAMA4hGAAAAAYhxAMAAAA4xCCAQAAYBxCMAAAAIxDCAYAAIBxCMEAAAAwDiEYAAAAxiEEAwAAwDiEYAAAABiHEAwAAADjEIIBAABgHEIwAAAAjEMIBgAAgHEIwQAAADAOIRgAAADGIQQDAADAOIRgAAAAGIcQDAAAAOMQggEAAGAcQjAAAACMQwgGAACAcQjBAAAAMA4hGAAAAMYhBAMAAMA4hGAAAAAYhxAMAAAA4xCCAQAAYBxCMAAAAIxDCAYAAIBxCMEAAAAwDiEYAAAAxiEEAwAAwDiEYAAAABiHEAwAAADjEIIBAABgHEIwAAAAjEMIBgAAgHEIwQAAADAOIRgAAADGIQQDAADAOIRgAAAAGIcQDAAAAOMQggEAAGAcQjAAAACMQwgGAACAcQjBAAAAMA4hGAAAAMYhBAMAAMA4hGAAAAAYhxAMAAAA4xCCAQAAYBxCMAAAAIxDCAYAAIBxCMEAAAAwDiEYAAAAxiEEAwAAwDiEYAAAABiHEAwAAADjEIIBAABgHEIwAAAAjONUCH722Wd1+PBhF5cCAAAAVA2nQvA777yju+66SwMGDNDbb7+t/Px8V9cFAAAAVBqnQvA//vEPLVmyRKGhoZoyZYoSEhI0ZcoUpaenu7o+SdKJEyc0btw4tW3bVjExMerRo4e++eYbx3673a5FixYpISFBMTExGjx4cJkr1adPn9bYsWPVunVrtWnTRpMnT1ZeXl6l1AsAAADP5lQItlqt6tChgxYvXqzPP/9co0aN0q5duzRgwAB169ZNK1euVFZWlksKPHPmjB544AH5+Pho2bJl2rhxoyZOnKigoCDHmGXLliktLU3Tpk3TunXr5Ovrq6SkJBUUFDjGjBs3TgcOHNCqVau0dOlSffnll5o6dapLagQAAED1csVvjAsODtbgwYM1d+5ctWnTRgcPHtS8efOUmJioiRMn6tSpU1d0/GXLlqlevXqaPXu2YmJi1KBBAyUkJKhhw4aSLlwFfvXVV/X444+rc+fOio6O1rx583Ty5El99NFHkqSDBw/q888/18yZMxUbG6s2bdooOTlZGzdu1IkTJ670SwAAAIBqxvtKnnz27Flt2LBB69ev1549exQdHa2pU6eqS5cujiUTTz75pFavXu30OT755BMlJCRo9OjR2r59u+rWrasBAwaoX79+kqRjx44pIyND8fHxjucEBAQoNjZW6enp6tatm9LT0xUYGKiWLVs6xsTHx8tqtWrXrl3q0qVLhWqxWi2yWi1Oz+VyeHmZceMOb+/qO8+SHpnSq+qIHnk2+uP56JHno0fOcyoEb9myRevXr9fHH38sLy8vdevWTdOnT1eLFi0cY/r06aNrr71Ww4cPv6ICjx49qtdff11DhgzR8OHD9c0332jmzJny8fFRz549lZGRIUkKCQkp9byQkBBlZmZKkjIzM1WnTp1S+729vRUUFOR4fkXUqeMni6VqQrApgoP93F3CFQsM9HV3CbgEeuTZ6I/no0eejx5dPqdC8JAhQxQbG6vk5GR169ZNvr7lf+EbNWqk7t27X1GBdrtdLVq00J///GdJ0o033qj9+/frjTfeUM+ePa/o2Jfr1Km8Kr0SbMI3dHZ29X1zYkmPcnLyVVxsc3c5KAc98mz0x/PRI89Hj8qq6AU2p0Lwu+++q6ioqEuOq1+/vmbPnu3MKRzCwsLUuHHjUttuuOEG/fd//7djvyRlZWUpPDzcMSYrK0vR0dGSpNDQ0DJrk4uKinTmzBnH8yvCZrPLZrM7NQ+Ur6io+r9gi4ttV8U8rmb0yLPRH89HjzwfPbp8Ti0giYiI0MmTJ8vdd/LkSZfeeqx169b64YcfSm07fPiw6tevL0mKjIxUWFiYtmzZ4tifm5urnTt3Ki4uTpIUFxennJwc7d692zFm69atstlsiomJcVmtAAAAqB6cCsHJyclatGhRufuee+45l956bNCgQdq5c6eWLl2qH3/8URs2bNC6des0YMAASZLFYtHDDz+sJUuW6OOPP9a+ffs0YcIEhYeHq3PnzpKkxo0bq3379poyZYp27dqlr776SjNmzFC3bt1Ut25dl9UKAACA6sGpEPzll1+qQ4cO5e5LTEzUtm3brqSmUmJiYvT8889r48aN6t69u1588UVNnjxZ99xzj2PM0KFD9eCDD2rq1Knq06ePzp07p+XLl6tmzZqOMc8++6xuuOEGDRo0SMOGDVPr1q01ffp0l9UJAACA6sOpNcFnzpyRn1/5i459fX11+vTpK6mpjI4dO6pjx46/u99isWjMmDEaM2bM746pXbu25s+f79K6AAAAUD05dSW4QYMG2rx5c7n7tmzZ4livCwAAAHgip0Jw37599corr2jZsmWOuy6cOnVKy5cv1yuvvOL4IAsAAADAEzm1HGLw4ME6cuSIFixYoAULFsjLy0vFxcWSpPvvv1+PPPKIS4sEAAAAXMmpEGyxWJSSkqJBgwZpy5YtOnPmjGrXrq1bb71VjRo1cnGJAAAAgGs5FYJLNGrUiNALAACAasfpEFxcXKydO3fql19+0fnz58vsv++++66kLgAAAKDSOBWCv/32W40aNUo///yz7PayHyNssVgIwQAAAPBYToXgadOmyd/fX6tXr1aTJk3k4+Pj6roAAACASuNUCD5w4IAWLlyoP/zhD66uBwAAAKh0Tt0nuFGjRsrLy3N1LQAAAECVcCoET5o0SS+99JIOHjzo6noAAACASufUcogZM2YoIyNDPXr0UHh4uAICAkrtt1gsevfdd11SIAAAAOBqToXgm266SRaLxdW1AAAAAFXCqRA8Z84cV9cBAAAAVBmn1gT/lt1u14kTJ1RUVOSKegAAAIBK53QI/vzzz9WvXz+1bNlSHTp00L59+yRJU6ZMYT0wAAAAPJpTIfi9997TsGHDFBkZqZSUlFKfGtegQQP97W9/c1mBAAAAgKs5FYJffPFFDRo0SAsWLFCvXr1K7WvatKn279/vkuIAAACAyuBUCD569KgSExPL3efr66uzZ89eUVEAAABAZXIqBIeFhenQoUPl7tu3b58iIiKuqCgAAACgMjkVgrt3767nnntOW7ZscWyzWCz6/vvvtXz5ct1zzz0uKxAAAABwNafuE/zEE09o//79GjJkiGrXri1JGjp0qE6dOqUOHTpo2LBhrqwRAAAAcCmnQnCNGjW0ZMkSbd26VZs3b1Z2draCgoIUHx+v+Ph4V9cIAAAAuJRTIbjErbfeqltvvdVVtQAAAABVwqkQfPz48UuO4c1xAAAA8FROheBOnTrJYrFcdMyePXucKggAAACobE6F4Oeff77MtpycHH3xxRfasWOHxo0bd8WFAQAAAJXFqRDcuXPncrf36tVLs2fP1rZt23T33XdfUWEAAABAZXHqPsEXk5iYqE2bNrn6sAAAAIDLuDwEf/3116pRo4arDwsAAAC4jFPLIWbOnFlm2/nz53Xo0CF99dVXeuSRR664MAAAAKCyOBWCP/nkkzLbatasqXr16iklJUV9+/a94sIAAACAyuKyEAwAAABUFy5fEwwAAAB4OpfdJ/j3WCwWjRw50pnTAAAAAJXCqRC8evVqFRYW6tdff5V0YT1wQUGBJKlWrVry8fFxjCUEAwAAwNM4FYJXrlypP/3pTxoxYoTuuOMO+fv7Kzc3Vx988IGWLFmiv/zlL4qJiXF1rQAAAIBLOBWCZ8yYoaSkJPXu3duxzd/fX3369FFBQYGmT5+u9evXu6xIAAAAwJWcemPc3r17FRkZWe6+Bg0aaP/+/VdUFAAAAFCZnArB9evX1xtvvCG73V5qu91u19q1axUREeGS4gAAAIDK4NRyiLFjx2rMmDHq2rWrOnbsqJCQEGVlZenTTz/V8ePHtWjRIlfXCQAAALiMUyG4c+fOWr9+vV5++WV9/PHHysjIUFhYmGJiYrR48WI1b97c1XUCAAAALuNUCJak5s2b6y9/+YsrawEAAACqxBV/YtzPP/+sr7/+WufOnXNFPQAAAEClczoEv/nmm2rfvr06duyogQMH6ocffpAkjRw5UqtXr3ZZgQAAAICrORWCX3nlFc2YMUP33XefVq5cWeouEX/4wx/0wQcfuKxAAAAAwNWcWhP82muvacSIERoxYoSKi4tL7bv++usdV4UBAAAAT+TUleATJ04oLi6u3H0+Pj6sDwYAAIBHcyoER0RE6Jtvvil3386dO9WoUaMrqQkAAACoVE6F4H79+mnJkiX661//qtzcXElSUVGRPvvsM61YsUL9+/d3aZEAAACAKzm1JjgpKUk///yzpk6dqpSUFEnSAw88IEkaMGCABg4c6LoKAQAAABdz+sMykpOTNWjQIG3evFnZ2dkKCgpSu3btWAoBAAAAj3fZIbigoEDx8fF65pln1KlTJ5Y+AAAAoNq57DXBNWvWlK+vr7y8vCqjHgAAAKDSOfXGuPvuu0/r1693dS0AAABAlXBqTXBgYKB27NihHj16qH379goNDZXFYnHst1gsGjx4sKtqBAAAAFzKqRC8YMECSVJGRob2799fZj8hGAAAAJ6swiG4R48emj9/vqKiorR3715J0rvvvqvExEQFBQVVWoEAAACAq1V4TfD+/fv166+/Oh4XFxdr4sSJOnbsWKUUBgAAAFQWp94YV8Jut7uqDgAAAKDKXFEIBgAAAKqjKw7Bv70rBAAAAFAdXNbdIQYNGlQm9A4cOLDMNovFoq+++urKqwMAAAAqQYVD8BNPPFGZdQAAAABVhhAMAAAA4/DGOAAAABiHEAwAAADjEIIBAABgHEIwAAAAjEMIBgAAgHGqXQh++eWX1axZMz399NOObQUFBUpNTVXbtm0VFxenUaNGKTMzs9Tzjh8/rmHDhik2Nlbt2rXT3LlzVVRUVNXlAwAAwANUqxC8a9cuvfHGG2rWrFmp7bNmzdKnn36qhQsXKi0tTSdPnix1S7fi4mI99thjKiws1BtvvKE5c+bo7bff1uLFi6t6CgAAAPAA1SYE5+Xlafz48Zo5c6aCgoIc28+ePau33npLTz31lNq1a6cWLVpo1qxZSk9P144dOyRJX3zxhQ4cOKBnnnlGzZs3V2JiosaMGaM1a9bo/PnzbpoRAAAA3OWyPjbZnaZPn67ExETFx8dryZIlju27d+9WYWGh4uPjHdsaN26siIgI7dixQ61atdKOHTsUFRWl0NBQx5iEhARNmzZNBw4c0I033lihGqxWi6xWy6UHuoCXV7X5/eSKeHtX33mW9MiUXlVH9Miz0R/PR488Hz1yXrUIwRs3btR3332n9evXl9mXmZkpHx8fBQYGltoeEhKijIwMx5jfBmBJjsclYyqiTh0/WSxVE4JNERzs5+4SrlhgoK+7S8Al0CPPRn88Hz3yfPTo8nl8CP7555/19NNPa+XKlapZs6Zbazl1Kq9KrwSb8A2dnZ3n7hKcVtKjnJx8FRfb3F0OykGPPBv98Xz0yPPRo7IqeoHN40Pwt99+q6ysLPXq1cuxrbi4WNu3b9eaNWu0YsUKFRYWKicnp9TV4KysLIWFhUm6cNV3165dpY5bcveIkjEVYbPZZbPZr2Q6+A9FRdX/BVtcbLsq5nE1o0eejf54Pnrk+ejR5fP4EHzrrbdqw4YNpbZNmjRJN9xwg4YOHaprr71WPj4+2rJli+644w5J0qFDh3T8+HG1atVKktSqVSstXbpUWVlZCgkJkSRt3rxZ/v7+atKkSZXOBwAAAO7n8SHY399fUVFRpbZdc801ql27tmN77969NWfOHAUFBcnf318zZ85UXFycIwQnJCSoSZMmmjBhgsaPH6+MjAwtXLhQAwcOVI0aNap6SgAAAHAzjw/BFTF58mRZrVaNHj1a58+fV0JCglJSUhz7vby8tHTpUk2bNk39+/eXr6+vevbsqdGjR7uxagAAALiLxW63s8i1gjIyzlbZuby9rQoO9lO/Nx+vsnO6wwud5rm7BKeV9Cg7O491WB6KHnk2+uP56JHno0dlhYUFVGgcN5UDAACAcQjBAAAAMA4hGAAAAMYhBAMAAMA4hGAAAAAYhxAMAAAA4xCCAQAAYBxCMAAAAIxDCAYAAIBxCMEAAAAwDiEYAAAAxiEEAwAAwDiEYAAAABiHEAwAAADjEIIBAABgHEIwAAAAjEMIBgAAgHEIwQAAADAOIRgAAADGIQQDAADAOIRgAAAAGIcQDAAAAOMQggEAAGAcQjAAAACMQwgGAACAcQjBAAAAMA4hGAAAAMYhBAMAAMA4hGAAAAAYhxAMAAAA4xCCAQAAYBxCMAAAAIxDCAYAAIBxCMEAAAAwDiEYAAAAxiEEAwAAwDiEYAAAABiHEAwAAADjEIIBAABgHEIwAAAAjEMIBgAAgHEIwQAAADAOIRgAAADGIQQDAADAOIRgAAAAGIcQDAAAAOMQggEAAGAcQjAAAACMQwgGAACAcQjBAAAAMA4hGAAAAMYhBAMAAMA4hGAAAAAYhxAMAAAA4xCCAQAAYBxCMAAAAIxDCAYAAIBxCMEAAAAwDiEYAAAAxiEEAwAAwDiEYAAAABiHEAwAAADjEIIBAABgHEIwAAAAjEMIBgAAgHEIwQAAADAOIRgAAADGIQQDAADAOIRgAAAAGMfjQ/BLL72k3r17Ky4uTu3atdOIESN06NChUmMKCgqUmpqqtm3bKi4uTqNGjVJmZmapMcePH9ewYcMUGxurdu3aae7cuSoqKqrKqQAAAMBDeHwI3rZtmwYOHKh169Zp1apVKioqUlJSks6dO+cYM2vWLH366adauHCh0tLSdPLkST3xxBOO/cXFxXrsscdUWFioN954Q3PmzNHbb7+txYsXu2NKAAAAcDOPD8ErVqxQr1691LRpU0VHR2vOnDk6fvy4vv32W0nS2bNn9dZbb+mpp55Su3bt1KJFC82aNUvp6enasWOHJOmLL77QgQMH9Mwzz6h58+ZKTEzUmDFjtGbNGp0/f96NswMAAIA7eHwI/k9nz56VJAUFBUmSdu/ercLCQsXHxzvGNG7cWBEREY4QvGPHDkVFRSk0NNQxJiEhQbm5uTpw4EDVFQ8AAACP4O3uAi6HzWbTrFmz1Lp1a0VFRUmSMjMz5ePjo8DAwFJjQ0JClJGR4Rjz2wAsyfG4ZExFWK0WWa2WK5lChXl5VbvfT5zi7V1951nSI1N6VR3RI89GfzwfPfJ89Mh51SoEp6amav/+/Vq7dq1bzl+njp8slqoJwaYIDvZzdwlXLDDQ190l4BLokWejP56PHnk+enT5qk0Inj59uj777DO99tprqlevnmN7aGioCgsLlZOTU+pqcFZWlsLCwhxjdu3aVep4JXePKBlTEadO5VXplWATvqGzs/PcXYLTSnqUk5Ov4mKbu8tBOeiRZ6M/no8eeT56VFZFL7B5fAi22+2aMWOGPvzwQ6WlpalBgwal9rdo0UI+Pj7asmWL7rjjDknSoUOHdPz4cbVq1UqS1KpVKy1dulRZWVkKCQmRJG3evFn+/v5q0qRJhWux2eyy2eyumRgkSUVF1f8FW1xsuyrmcTWjR56N/ng+euT56NHl8/gQnJqaqvfee08vvvii/Pz8HGt4AwICVKtWLQUEBKh3796aM2eOgoKC5O/vr5kzZyouLs4RghMSEtSkSRNNmDBB48ePV0ZGhhYuXKiBAweqRo0abpwdAAAA3MHjQ/Drr78uSXrooYdKbZ89e7Z69eolSZo8ebKsVqtGjx6t8+fPKyEhQSkpKY6xXl5eWrp0qaZNm6b+/fvL19dXPXv21OjRo6tuIgAAAPAYHh+C9+3bd8kxNWvWVEpKSqng+5/q16+vZcuWubI0AAAAVFPcTwMAAADGIQQDAADAOIRgAAAAGIcQDAAAAOMQggEAAGAcQjAAAACMQwgGAACAcQjBAAAAMA4hGAAAAMYhBAMAAMA4hGAAAAAYhxAMAAAA4xCCAQAAYBxCMAAAAIxDCAYAAIBxCMEAAAAwDiEYAAAAxiEEAwAAwDiEYAAAABiHEAwAAADjEIIBAABgHG93FwAAQGV6ZM4n7i6hUq18qpO7SwCqJa4EAwAAwDiEYAAAABiHEAwAAADjEIIBAABgHEIwAAAAjEMIBgAAgHEIwQAAADAOIRgAAADGIQQDAADAOIRgAAAAGIcQDAAAAOMQggEAAGAcQjAAAACMQwgGAACAcQjBAAAAMA4hGAAAAMYhBAMAAMA4hGAAAAAYhxAMAAAA4xCCAQAAYBxCMAAAAIxDCAYAAIBxCMEAAAAwDiEYAAAAxvF2dwEA4MkemfOJu0uoVCuf6uTuEgDALbgSDAAAAOMQggEAAGAcQjAAAACMQwgGAACAcQjBAAAAMA53hwAAAB7rar9Di8RdWtyFEAwABjMhYABAeVgOAQAAAOMQggEAAGAcQjAAAACMQwgGAACAcXhjHAAA1RhvbgScw5VgAAAAGIcQDAAAAOMQggEAAGAcQjAAAACMQwgGAACAcQjBAAAAMA4hGAAAAMYhBAMAAMA4hGAAAAAYhxAMAAAA4/CxyQAAAG50tX/09cqnOrm7hHIZdyV4zZo16tSpk1q2bKm+fftq165d7i4JAAAAVcyoELxp0ybNnj1bI0eO1Ntvv63o6GglJSUpKyvL3aUBAACgChm1HGLVqlXq16+fevfuLUlKTU3VZ599prfeekvDhg1zc3VA9XS1/zMeAODqZEwIPn/+vL799ls99thjjm1Wq1Xx8fFKT0+v0DGsVousVktllViKl5cZF+m9vavvPEt6ZEqvAABwhqf+XW9MCM7OzlZxcbFCQkJKbQ8JCdGhQ4cqdIyQEP/KKO2i1vVfUuXnxOUJDPR1dwlutWH+ve4uAQCAy+aZ0RwAAACoRMaE4ODgYHl5eZV5E1xWVpZCQ0PdVBUAAADcwZgQXKNGDd10003asmWLY5vNZtOWLVsUFxfnxsoAAABQ1YxZEyxJQ4YM0cSJE9WiRQvFxMRo9erVys/PV69evdxdGgAAAKqQUSH47rvv1qlTp7R48WJlZGSoefPmWr58OcshAAAADGOx2+12dxcBAAAAVCVj1gQDAAAAJQjBAAAAMA4hGAAAAMYhBAMAAMA4hGAPtWbNGnXq1EktW7ZU3759tWvXLneXZKTnnntOzZo1K/XfnXfe6dhfUFCg1NRUtW3bVnFxcRo1apQyMzPdWPHVb/v27Ro+fLgSEhLUrFkzffTRR6X22+12LVq0SAkJCYqJidHgwYN1+PDhUmNOnz6tsWPHqnXr1mrTpo0mT56svLy8KpzF1e1SPXrqqafKvK6SkpJKjaFHleell15S7969FRcXp3bt2mnEiBE6dOhQqTEV+dl2/PhxDRs2TLGxsWrXrp3mzp2roqKiqpzKVasiPXrooYfKvI6mTp1aagw9ujhCsAfatGmTZs+erZEjR+rtt99WdHS0kpKSynzaHapG06ZN9cUXXzj+W7t2rWPfrFmz9Omnn2rhwoVKS0vTyZMn9cQTT7ix2qvfuXPn1KxZM6WkpJS7f9myZUpLS9O0adO0bt06+fr6KikpSQUFBY4x48aN04EDB7Rq1SotXbpUX375ZZm/POC8S/VIktq3b1/qdbVgwYJS++lR5dm2bZsGDhyodevWadWqVSoqKlJSUpLOnTvnGHOpn23FxcV67LHHVFhYqDfeeENz5szR22+/rcWLF7tjSledivRIkvr161fqdTRhwgTHPnpUAXZ4nD59+thTU1Mdj4uLi+0JCQn2l156yY1VmWnx4sX2e+65p9x9OTk59ptuusn+/vvvO7YdOHDAHhUVZU9PT6+iCs0WFRVl//DDDx2PbTab/bbbbrMvX77csS0nJ8feokUL+3vvvWe32//do127djnG/OMf/7A3a9bM/ssvv1Rd8Yb4zx7Z7Xb7xIkT7Y8//vjvPoceVa2srCx7VFSUfdu2bXa7vWI/2z777DN7dHS0PSMjwzFm7dq19tatW9sLCgqqtH4T/GeP7Ha7/cEHH7TPnDnzd59Djy6NK8Ee5vz58/r2228VHx/v2Ga1WhUfH6/09HQ3VmauH3/8UQkJCbr99ts1duxYHT9+XJK0e/duFRYWlupV48aNFRERoR07dripWrMdO3ZMGRkZpXoSEBCg2NhYx+snPT1dgYGBatmypWNMfHy8rFYry46q0LZt29SuXTvdcccdSklJUXZ2tmMfPapaZ8+elSQFBQVJqtjPth07digqKqrUh00lJCQoNzdXBw4cqLriDfGfPSqxYcMGtW3bVt27d9f8+fOVn5/v2EePLs2oT4yrDrKzs1VcXKyQkJBS20NCQsqsB0Lli4mJ0ezZs3X99dcrIyNDL7zwggYOHKgNGzYoMzNTPj4+CgwMLPWckJAQZWRkuKlis5V83ct7/ZSsZ8zMzFSdOnVK7ff29lZQUBB9qyLt27dXly5dFBkZqaNHj2rBggUaOnSo3nzzTXl5edGjKmSz2TRr1iy1bt1aUVFRklShn22ZmZllPm215DE9cq3yeiRJ3bt3V0REhMLDw7Vv3z49++yz+uGHH/T8889LokcVQQgGLiIxMdHx5+joaMXGxqpjx456//33VatWLTdWBlRf3bp1c/y55A09nTt3dlwdRtVJTU3V/v37S73XAZ7l93rUv39/x5+bNWumsLAwDR48WEeOHFHDhg2rusxqieUQHiY4OFheXl5l3gSXlZVV5jc6VL3AwEA1atRIR44cUWhoqAoLC5WTk1NqTFZWlsLCwtxUodlKvu4Xe/2Ehobq1KlTpfYXFRXpzJkz9M1NGjRooODgYP3444+S6FFVmT59uj777DOtXr1a9erVc2yvyM+20NDQMneLKHlMj1zn93pUntjYWEkq9TqiRxdHCPYwNWrU0E033aQtW7Y4ttlsNm3ZskVxcXFurAySlJeXp6NHjyosLEwtWrSQj49PqV4dOnRIx48fV6tWrdxXpMEiIyMVFhZWqie5ubnauXOn4/UTFxennJwc7d692zFm69atstlsiomJqfKaIf3yyy86ffq04y9melS57Ha7pk+frg8//FCrV69WgwYNSu2vyM+2Vq1a6fvvvy/1C+fmzZvl7++vJk2aVMk8rmaX6lF59uzZI+nfAZceXRrLITzQkCFDNHHiRLVo0UIxMTFavXq18vPz1atXL3eXZpy5c+eqY8eOioiI0MmTJ/Xcc8/JarWqe/fuCggIUO/evTVnzhwFBQXJ399fM2fOVFxcHCG4EuXl5enIkSOOx8eOHdOePXsUFBSkiIgIPfzww1qyZImuu+46RUZGatGiRQoPD1fnzp0lXXiDT/v27TVlyhSlpqaqsLBQM2bMULdu3VS3bl13TeuqcrEeBQUF6fnnn9cdd9yh0NBQHT16VM8884yuu+46tW/fXhI9qmypqal677339OKLL8rPz8+xPjQgIEC1atWq0M+2hIQENWnSRBMmTND48eOVkZGhhQsXauDAgapRo4YbZ3d1uFSPjhw5og0bNigxMVG1a9fWvn37NHv2bN1yyy2Kjo6WRI8qwmK32+3uLgJlvfbaa1qxYoUyMjLUvHlzJScnO/6pA1XnySef1Pbt23X69GnVqVNHN998s5588knHequCggLNmTNHGzdu1Pnz55WQkKCUlBT+qakS/fOf/9TDDz9cZnvPnj01Z84c2e12LV68WOvWrVNOTo5uvvlmpaSk6Prrr3eMPX36tGbMmKFPPvlEVqtVXbt2VXJysvz8/KpyKleti/Vo2rRpGjlypL777judPXtW4eHhuu222zRmzJhSS77oUeVp1qxZudtnz57tuNhSkZ9tP/30k6ZNm6Zt27bJ19dXPXv21NixY+XtzfW1K3WpHv38888aP3689u/fr3Pnzunaa69V586dNWLECPn7+zvG06OLIwQDAADAOKwJBgAAgHEIwQAAADAOIRgAAADGIQQDAADAOIRgAAAAGIcQDAAAAOMQggEAAGAcQjAAAACMQwgGAACAcQjBAAAAMA4hGAAAAMYhBAMAAMA4/w+JAQvBJhSXEwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df.plot.hist()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d4ed43a2-237d-416d-8b16-d431f42481d1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.kdeplot(df['dimble_times'])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "07db65b0-c6a3-4677-9fe3-13150b19890a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.kdeplot(df['dicom_times'])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2293ac4b-8678-43fa-99c8-a759c6b404ae", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dicom_timesdimble_times
count1000.001000.00
mean67.060.06
std84.120.01
min3.050.05
25%4.760.06
50%6.360.06
75%158.010.06
max269.320.22
\n", + "
" + ], + "text/plain": [ + " dicom_times dimble_times\n", + "count 1000.00 1000.00\n", + "mean 67.06 0.06\n", + "std 84.12 0.01\n", + "min 3.05 0.05\n", + "25% 4.76 0.06\n", + "50% 6.36 0.06\n", + "75% 158.01 0.06\n", + "max 269.32 0.22" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.describe().round(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d3a2df9b-fdc9-48e6-a5bd-a1f21216dedf", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "speedups = df.dicom_times / df.dimble_times\n", + "sns.kdeplot(speedups)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c421867a-12db-4d46-b4dc-35a11918f786", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "count 1000.00\n", + "mean 1098.76\n", + "std 1381.47\n", + "min 41.51\n", + "25% 78.10\n", + "50% 104.10\n", + "75% 2581.40\n", + "max 4709.77\n", + "dtype: float64" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "speedups.describe().round(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "4470cfeb-a376-41a7-a20f-63e27f33f9ce", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAq8AAAHTCAYAAAAJafG6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA3jUlEQVR4nO3de3xU9Z3/8fdckhBDJkIIJRHQFEuiBMLAupg0SlG2dL20YlpbpVoodSsVcfFSWvZXY5RC2lJFBV2Ld1pLWaHdesMtrdKHNbvSfQBCxEgXECEgSQCHxJDLzPn9gUwdw0xmwsyc+Sav5+PhI+ScT8585pMzyduTc844LMuyBAAAABjAaXcDAAAAQLQIrwAAADAG4RUAAADGILwCAADAGIRXAAAAGIPwCgAAAGMQXgEAAGAMwisAAACMQXgFAACAMdx2N5AsjY3H7G4hbpxOhwYPztLhw60KBHiDtE9jPuExm8iYT3jMJjLmEx6ziYz5hMrLy+6xhiOvBnI6HXI4HHI6HXa3kpKYT3jMJjLmEx6ziYz5hMdsImM+sSO8AgAAwBiEVwAAABiD8AoAAABjEF4BAABgDMIrAAAAjEF4BQAAgDEIrwAAADAG4RUAAADGsP0dti655BLt37+/2/LrrrtOVVVVam9vV01NjV566SV1dHSooqJCVVVVGjJkiA3dAgAAwE62h9fnnntOfr8/+PnOnTs1a9YsfelLX5IkLV68WBs3btSyZcuUnZ2te++9V3PnztXq1avtahkAAAA2sT28Dh48OOTzX/ziFxo5cqT+8R//UceOHdPatWu1dOlSlZWVSToRZi+77DJt2bJF48ePt6FjAAAA2MX28PpJHR0d+v3vf69Zs2bJ4XBo+/bt6uzsVHl5ebBm1KhRKigoiDm8Op19532DXS5nyEeEYj7hMZvImE94zCYy5hMes4mM+cQupcLrhg0bdOzYMU2fPl2S1NTUpLS0NHk8npC63NxcNTY2xrTtwYOz5HD0jfB6kseTaXcLKY35hMdsImM+4TGbyJhPeMwmMuYTvZQKr2vXrtXFF1+sz3zmM3Hf9uHDrX3qyKvHkymfr01+f8DudlIO8wmP2UTGfMJjNpExn/CYTWTMJ9SgQVk91qRMeN2/f7/eeOMNPfTQQ8FlQ4YMUWdnp3w+X8jR1+bmZuXl5cW0/UDAUiBgxa3fVOD3B9TVxY4eDvMJj9lExnzCYzaRMZ/wmE1kzCd6KXOCxbp165Sbm6svfOELwWUlJSVKS0tTbW1tcNmuXbvU0NDAxVoAAAD9UEoceQ0EAlq3bp2uuuoqud1/byk7O1uVlZWqqalRTk6OBg4cqEWLFsnr9RJeAQAA+qGUCK9vvPGGGhoaVFlZ2W3dwoUL5XQ6NW/evJA3KYB9Ojo6VFe3LaavGTNmrNLT0xPUEQAA6C9SIrxWVFSovr7+lOsyMjJUVVVFYE0hdXXbdP9T65WbXxhVffOB3Zo/U/J6Jya2MQAA0OelRHiFeXLzC5U/stjuNgAAQD+TMhdsAQAAAD0hvAIAAMAYhFcAAAAYg/AKAAAAYxBeAQAAYAzCKwAAAIxBeAUAAIAxCK8AAAAwBuEVAAAAxiC8AgAAwBiEVwAAABiD8AoAAABjEF4BAABgDMIrAAAAjEF4BQAAgDEIrwAAADAG4RUAAADGILwCAADAGIRXAAAAGIPwCgAAAGMQXgEAAGAMwisAAACMQXgFAACAMQivAAAAMAbhFQAAAMYgvAIAAMAYhFcAAAAYg/AKAAAAYxBeAQAAYAzCKwAAAIxBeAUAAIAxCK8AAAAwBuEVAAAAxiC8AgAAwBiEVwAAABiD8AoAAABjEF4BAABgDMIrAAAAjEF4BQAAgDEIrwAAADAG4RUAAADGILwCAADAGIRXAAAAGIPwCgAAAGMQXgEAAGAMwisAAACMkRLh9YMPPtAdd9yhSZMmady4cbryyiu1bdu24HrLsvTAAw+ooqJC48aN08yZM7Vnzx77GgYAAIAtbA+vH374oa699lqlpaVp5cqVevHFF7VgwQLl5OQEa1auXKlVq1bp7rvv1po1a5SZmanZs2ervb3dxs4BAACQbG67G1i5cqWGDRumJUuWBJeNGDEi+G/LsvTMM89ozpw5mjp1qiTppz/9qcrLy7VhwwZdfvnlSe8ZAAAA9rD9yOuf/vQnlZSUaN68eSorK9NVV12lNWvWBNfv27dPjY2NKi8vDy7Lzs5WaWmpNm/ebEfLAAAAsIntR17ff/99/frXv9asWbN00003adu2bVq0aJHS0tI0ffp0NTY2SpJyc3NDvi43N1dNTU1RP47T6ZDT6Yhr73ZxuZwhH+14fIckhyO6eTo+/hq3Ozn92j2fVMZsImM+4TGbyJhPeMwmMuYTO9vDq2VZKikp0W233SZJOv/887Vz506tXr1a06dPj9vjDB6cFXXYMoXHk2nb47rcLrndrqjqXW6XPJ5MDRqUleDOQtk1HxMwm8iYT3jMJjLmEx6ziYz5RM/28JqXl6dRo0aFLPvsZz+rV155JbhekpqbmzV06NBgTXNzs4qLi6N+nMOHW/vUkVePJ1M+X5v8/kDSH9/na5O/y6+uLn9U9f4uv3y+Nh050prgzk6wez6pjNlExnzCYzaRMZ/wmE1kzCdUNAe6bA+vEyZM0O7du0OW7dmzR2eddZYkafjw4crLy1Ntba3OO+88SVJLS4u2bt2qa6+9NurHCQQsBQJW/BpPAX5/QF1dyd/R/f6ALJ04ah4NS/b0atd8TMBsImM+4TGbyJhPeMwmMuYTPdtPsPjWt76lrVu36t///d/13nvv6fnnn9eaNWt03XXXSTpxXuUNN9ygRx55RH/84x9VX1+v73//+xo6dGjw7gMAAADoH2w/8jpu3DgtX75c9913n1asWKHhw4dr4cKF+vKXvxysufHGG9XW1qa77rpLPp9PEydO1GOPPaaMjAwbOwcAAECy2R5eJWnKlCmaMmVK2PUOh0O33nqrbr311iR2BQAAgFRj+2kDAAAAQLQIrwAAADAG4RUAAADGILwCAADAGIRXAAAAGIPwCgAAAGMQXgEAAGAMwisAAACMQXgFAACAMQivAAAAMAbhFQAAAMYgvAIAAMAYhFcAAAAYg/AKAAAAYxBeAQAAYAzCKwAAAIxBeAUAAIAxCK8AAAAwBuEVAAAAxiC8AgAAwBiEVwAAABiD8AoAAABjuO1uAEiWjo4O1dVti7p+zJixSk9PT2BHAAAgVoRX9Bt1ddt0/1PrlZtf2GNt84Hdmj9T8nonJr4xAAAQNcIr+pXc/ELljyy2uw0AANBLnPMKAAAAYxBeAQAAYAzCKwAAAIxBeAUAAIAxCK8AAAAwBuEVAAAAxiC8AgAAwBiEVwAAABiD8AoAAABjEF4BAABgDMIrAAAAjEF4BQAAgDEIrwAAADAG4RUAAADGILwCAADAGIRXAAAAGIPwCgAAAGMQXgEAAGAMwisAAACMQXgFAACAMQivAAAAMAbhFQAAAMYgvAIAAMAYtofXhx56SEVFRSH/felLXwqub29vV3V1tSZNmiSv16tbbrlFTU1NNnYMAAAAu7jtbkCSPve5z+nJJ58Mfu5yuYL/Xrx4sTZu3Khly5YpOztb9957r+bOnavVq1fb0SoAAABslBLh1eVyKS8vr9vyY8eOae3atVq6dKnKysoknQizl112mbZs2aLx48cnuVMAAADYKSXC63vvvaeKigplZGRo/Pjxuv3221VQUKDt27ers7NT5eXlwdpRo0apoKAg5vDqdDrkdDoS0H3yuVzOkI92PL5DksMR3TwdH3+N252cfsPNJ5a+k91zsti976Q65hMes4mM+YTHbCJjPrGzPbyOGzdOS5YsUWFhoRobG7VixQrNmDFDzz//vJqampSWliaPxxPyNbm5uWpsbIzpcQYPzoo6bJnC48m07XFdbpfcblfPxZJcbpc8nkwNGpSV4M5CfXo+sfRtV8/JYte+YwrmEx6ziYz5hMdsImM+0bM9vE6ePDn47+LiYpWWlmrKlCl6+eWXNWDAgLg9zuHDrX3qyKvHkymfr01+fyDpj+/ztcnf5VdXlz+qen+XXz5fm44caU1wZyeEm08sfSe752Sxe99JdcwnPGYTGfMJj9lExnxCRXPQyPbw+mkej0fnnHOO9u7dq/LycnV2dsrn84UcfW1ubj7lObKRBAKWAgEr3u3ayu8PqKsr+Tu63x+QJcmyopunJXt6/fRjxtK3XT0nS19+bvHAfMJjNpExn/CYTWTMJ3opd4JFa2ur3n//feXl5amkpERpaWmqra0Nrt+1a5caGhq4WAsAAKAfsv3I609+8hNNmTJFBQUFOnTokB566CE5nU5dccUVys7OVmVlpWpqapSTk6OBAwdq0aJF8nq9hFcAAIB+yPbwevDgQd122206evSoBg8erIkTJ2rNmjUaPHiwJGnhwoVyOp2aN2+eOjo6VFFRoaqqKpu7BgAAgB1sD6/3339/xPUZGRmqqqoisAIAACD1znkFAAAAwiG8AgAAwBiEVwAAABiD8AoAAABj2H7BFmC6jo4O1dVti7p+zJixSk9PT2BHAAD0XYRX4DTV1W3T/U+tV25+YY+1zQd2a/5MyeudmPjGAADogwivQBzk5hcqf2Sx3W0AANDncc4rAAAAjEF4BQAAgDEIrwAAADAG4RUAAADGILwCAADAGIRXAAAAGIPwCgAAAGMQXgEAAGAMwisAAACMQXgFAACAMQivAAAAMAbhFQAAAMYgvAIAAMAYhFcAAAAYw213A+j7/P4u1de/E3X9mDFjlZ6ensCOAACAqQivSLijjfu0bm+bztrj6LG2+cBuzZ8peb0TE98YAAAwDuEVSTFo6Ejljyy2uw0AAGA4znkFAACAMQivAAAAMAbhFQAAAMbgnFcYq6OjQ3V127otd7mc8ngy5fO1ye8PBJfX178jK9CtHAAAGITwCmPV1W3T/U+tV25+YchyhySX2yV/l1/WJ5bv2l6rYYWlSe0RAADEF+EVRsvNL+x2FwOHwyG326WuLr8s6+/xtfngniR3BwAA4o1zXgEAAGAMwisAAACMQXgFAACAMTjnFUgiv79L9fXvxPQ1Y8aMVXp6eoI6AgDALIRXIImONu7Tur1tOmuPI6r65gO7NX+m5PVOTGxjAAAYgvAKJNmgoSO73SEBAABEh3NeAQAAYAzCKwAAAIxBeAUAAIAxCK8AAAAwBuEVAAAAxiC8AgAAwBiEVwAAABiD8AoAAABjEF4BAABgDMIrAAAAjEF4BQAAgDFSKrz+4he/UFFRkX784x8Hl7W3t6u6ulqTJk2S1+vVLbfcoqamJhu7BAAAgF1SJry+9dZbWr16tYqKikKWL168WK+++qqWLVumVatW6dChQ5o7d65NXQIAAMBOKRFeW1tbdeedd2rRokXKyckJLj927JjWrl2rH/zgByorK1NJSYkWL16szZs3a8uWLfY1DAAAAFu47W5Aku655x5NnjxZ5eXleuSRR4LLt2/frs7OTpWXlweXjRo1SgUFBdqyZYvGjx8f9WM4nQ45nY54tm0bl8sZ8jEeOjo6tH37tqhqd+6slyxLDkf083Q4HFHVO3TiebndPT83l8spx8fb7raRjz86FLouqX2E23aUPcTaRzQSse/0JcwnPGYTGfMJj9lExnxiZ3t4ffHFF/X222/rueee67auqalJaWlp8ng8Ictzc3PV2NgY0+MMHpwVU9gygceTGbdtbdr0tu5/6hUNKSjssfZvb/238keNl9vtimrbLpdTTpczqnqX2yWPJ1ODBmX1WOvxZMrldoXdrtsVutyuPnrbQ6x9xCKe+05fxHzCYzaRMZ/wmE1kzCd6tobXAwcO6Mc//rGeeOIJZWRkJPSxDh9u7VNHXj2eTPl8bfL7A3HZps/XpkFDR2roWaN7rP1g3/8p4A+oq8sf1bb9/kDU9f4uv3y+Nh050hpVz/4uf/ftOk4E1y6/X7Js7ONU242hh1j7iEYi9p2+hPmEx2wiYz7hMZvImE+oaA7W9Cq8XnrppVqxYoWKi4u7rXv33Xc1Z84c/fGPf+xxO3V1dWpubtbVV18dXOb3+7Vp0yb96le/0uOPP67Ozk75fL6Qo6/Nzc3Ky8uLqedAwFIgYPVcaBC/P6Curvjs6H5/QJYky4puRpZlRV0bS72l6J9XuJ6DpwpY3dcls4+w245hdrH0EYtEbLMvYT7hMZvImE94zCYy5hO9XoXX/fv3q6Oj45Trjh8/roMHD0a1nQsvvFDPP/98yLIf/vCH+uxnP6sbb7xR+fn5SktLU21traZNmyZJ2rVrlxoaGmI63xUAAAB9Q9Thtb29XW1tbcEjRi0tLTp69Gi3mg0bNmjo0KFRbXPgwIEaPTr0z9RnnHGGzjzzzODyyspK1dTUKCcnRwMHDtSiRYvk9XoJrwAAAP1Q1OF15cqVWrFihaQTV0vPnj07bG0878O6cOFCOZ1OzZs3Tx0dHaqoqFBVVVXctg8AAABzRB1ep06dqrPOOkuWZWnhwoWaM2eORo4cGVKTlpamUaNG6bzzzut1Q6tWrQr5PCMjQ1VVVQRWAAAARB9ei4uLgxdoORwOTZ48WYMHD05YYwAAAMCn9eqCrenTp8e7DwAAAKBHvQqvx48f18MPP6xXXnlFBw8ePOWdB3bs2HHazQEAAACf1KvwWl1drRdeeEFXXHGFRo0apbS0tHj3BQAAAHTTq/D66quvasGCBfrmN78Z734AAACAsJy9+SKXy6Vzzjknzq0AAAAAkfUqvF577bX6z//8z3j3AgAAAETUq9MGBgwYoP/93//VN77xDZWVlcnj8YSsdzgcmjlzZjz6AwAAAIJ6FV6XLl0qSWpoaNCWLVu6rSe8AgAAIBF6FV7feeedePcBAAAA9KhX57wCAAAAdujVkddNmzb1WHPBBRf0ZtMAAABAWL0Kr9dff70cDocsywouczgcITW8wxYAAADirVfh9Xe/+123ZR9++KFef/11/dd//Zeqq6tPty8AAACgm16F1+Li4lMunzRpkgYMGKDf/OY3uvDCC0+rMQAAAODT4n7B1oQJE7Rx48Z4bxYAAACIf3jdsGGDzjzzzHhvFgAAAOjdaQM33XRTt2WdnZ3avXu3Dhw4oDvvvPO0GwMAAAA+rVfhtbW1tduyjIwMlZeXa9q0abroootOuzEAAADg03oVXletWhXvPgAAAIAenfY5r8ePH9ehQ4d0/PjxePQDAAAAhNWrI6+S9Oqrr2r58uXasWOHLMuSw+HQeeedp3nz5mny5Mnx7BEAAACQ1MvwumHDBt1yyy0qLS3VD37wAw0ZMkSNjY1av3695syZowcffFBTp06Nd69A0vj9Xaqvfyeq2vr6d2QFEtyQjTo6OlRXty2mrxkzZqzS09MT1BEAoD/rVXhdvny5Lr/8ci1dujRk+be+9S3dcccdWr58OeEVRjvauE/r9rbprD2OHmt3ba/VsMLSJHRlj7q6bbr/qfXKzS+Mqr75wG7Nnyl5vRMT2xgAoF/qVXjdtWuX7rjjjlOu+8pXvqKbb775tJoCUsGgoSOVP/LU7yb3Sc0H9yS+GZvl5hdGNQsAABKtVxds5eTkaPfu3adct3v3buXk5JxWUwAAAMCp9OrI62WXXab77rtPAwYM0LRp0+TxeHTs2DGtX79ey5Yt0zXXXBPvPgEAAIDehdfbb79dDQ0N+tGPfqS77rpLbrdbXV1dsixLX/ziF3XbbbfFu08AAACgd+E1PT1dDz30kOrr6/XXv/5VPp9POTk5mjhxooqKiuLdIwAAACAphnNe9+zZo6uvvlobN24MLisqKtKMGTM0Z84cXXfddTp48KCuvvpqvf/++wlpFgAAAP1b1OH1iSee0BlnnBHxDQgmT56srKwsPf7443FpDgAAAPikqMPrX/7yF1VWVvZYV1lZqddff/20mgIAAABOJerw+sEHH2jEiBE91g0fPlwffPDBaTUFAAAAnErU4TUrK0tHjhzpse7o0aM644wzTqspAAAA4FSiDq8lJSV66aWXeqx78cUXVVJSclpNAQAAAKcSdXi97rrr9PLLL2v58uXy+/3d1gcCAS1fvlzr16/XjBkz4tokAAAAIMVwn9dLL71U3/nOd7R8+XKtXr1aZWVlKigokCQdOHBAtbW1ampq0uzZs3XJJZckrGEAAAD0XzG9ScEdd9yhCy64QE888YReeeUVdXR0SJIyMjI0YcIELVq0KOKttAAAAIDTEfM7bE2ePFmTJ0+W3+/X0aNHJUlnnnmmXC5XvHsDAAAAQvTq7WElyeVyKTc3N569APL7u1Rf/05UtfX178gKJLghm8UyD0kaM2as0tPTe6zr6OjQ1q1bo9pmf5gzAMAcvQ6vQCIcbdyndXvbdNYeR4+1u7bXalhhaRK6sk8s82g+sFvzZ0pe78Qea7dv36b7n1qv3PzCHmv7w5wBAOYgvCLlDBo6Uvkji3usaz64J/HNpIBo5xGr3PxC5gwAME7Ut8oCAAAA7EZ4BQAAgDEIrwAAADAG4RUAAADGILwCAADAGIRXAAAAGMP28Prss8/qyiuv1IQJEzRhwgR9/etf18aNG4Pr29vbVV1drUmTJsnr9eqWW25RU1OTjR0DAADALraH12HDhumOO+7QunXrtHbtWl144YW6+eabtXPnTknS4sWL9eqrr2rZsmVatWqVDh06pLlz59rcNQAAAOxg+5sUXHLJJSGfz58/X7/+9a+1ZcsWDRs2TGvXrtXSpUtVVlYm6USYveyyy7RlyxaNHz/eho4BAABgF9vD6yf5/X6tX79eH330kbxer7Zv367Ozk6Vl5cHa0aNGqWCgoKYw6vT6ZDT2fNbbJrA5XKGfIzXNh2SHI7oZuRwOKKujbX+tGsdf//okKPn+kT1EYfaWOodOvF9dLvD7xcn9xmn05Gw73c0faSqRLy2+gpmExnzCY/ZRMZ8YpcS4bW+vl7f+MY31N7erjPOOEMrVqzQueeeqx07digtLU0ejyekPjc3V42NjTE9xuDBWTEFBhN4PJlx3ZbL7ZLb7eqx1uVyyulyRlUba308a90uV0z1qVYb87bdLnk8mRo0KKvH2oEDByTu+x1DH6kqnq+tvobZRMZ8wmM2kTGf6KVEeC0sLNTvfvc7HTt2TK+88ooWLFigX/7yl3F9jMOHW/vUkVePJ1M+X5v8/kBctunztcnf5VdXl7/HWr8/oIA/EFVtrPVxqXWcCK5dfr9k2djHadbGvO0uv3y+Nh050hq25uS+09JyPHHf7yj6SFWJeG31FcwmMuYTHrOJjPmEiubAR0qE1/T0dJ199tmSpJKSEm3btk3PPPOM/vmf/1mdnZ3y+XwhR1+bm5uVl5cX02MEApYCAavnQoP4/QF1dcVnR/f7A7IkWVZ0M7IsK+raWOtPtzZ4qoDV/fkks4941MZSbyn6fSIQsBL2/Y6lj1Rlev+JxGwiYz7hMZvImE/0UvIEi0AgoI6ODpWUlCgtLU21tbXBdbt27VJDQwMXawEAAPRDth95/fnPf66LL75Y+fn5am1t1QsvvKA333xTjz/+uLKzs1VZWamamhrl5ORo4MCBWrRokbxeL+EVAACgH7I9vDY3N2vBggU6dOiQsrOzVVRUpMcff1yf//znJUkLFy6U0+nUvHnz1NHRoYqKClVVVdncNQAAAOxge3hdvHhxxPUZGRmqqqoisAIAACA1z3kFAAAAToXwCgAAAGMQXgEAAGAMwisAAACMQXgFAACAMQivAAAAMAbhFQAAAMYgvAIAAMAYhFcAAAAYg/AKAAAAYxBeAQAAYAzCKwAAAIxBeAUAAIAxCK8AAAAwBuEVAAAAxiC8AgAAwBiEVwAAABiD8AoAAABjEF4BAABgDMIrAAAAjEF4BQAAgDEIrwAAADAG4RUAAADGILwCAADAGIRXAAAAGIPwCgAAAGMQXgEAAGAMwisAAACMQXgFAACAMQivAAAAMAbhFQAAAMYgvAIAAMAYhFcAAAAYg/AKAAAAYxBeAQAAYAzCKwAAAIxBeAUAAIAxCK8AAAAwBuEVAAAAxiC8AgAAwBiEVwAAABiD8AoAAABjEF4BAABgDMIrAAAAjEF4BQAAgDEIrwAAADAG4RUAAADGsD28Pvroo6qsrJTX61VZWZm+973vadeuXSE17e3tqq6u1qRJk+T1enXLLbeoqanJpo4BAABgF9vD65tvvqkZM2ZozZo1evLJJ9XV1aXZs2fro48+CtYsXrxYr776qpYtW6ZVq1bp0KFDmjt3ro1dAwAAwA5uuxt4/PHHQz6vqalRWVmZ6urqdMEFF+jYsWNau3atli5dqrKyMkknwuxll12mLVu2aPz48TZ0DQAAADvYHl4/7dixY5KknJwcSdL27dvV2dmp8vLyYM2oUaNUUFAQU3h1Oh1yOh1x79cOLpcz5GO8tumQ5HBENyOHwxF1baz1p13r+PtHhxw91yeqjzjUxlIf8Hdp5876iPuF0+nQwIED9O6770iWlZjnpxP7k9tt+x92YpaI11ZfwWwiYz7hMZvImE/sUiq8BgIBLV68WBMmTNDo0aMlSU1NTUpLS5PH4wmpzc3NVWNjY9TbHjw4K6bAYAKPJzOu23K5XXK7XT3WulxOOV3OqGpjrY9nrdvliqk+1WpjrfcdbtC619o0Ym/PtX97q1b5o8Ynpme3Sx5PpgYNyoqqPhXF87XV1zCbyJhPeMwmMuYTvZQKr9XV1dq5c6eeffbZuG/78OHWPnXk1ePJlM/XJr8/EJdt+nxt8nf51dXl77HW7w8o4A9EVRtrfVxqHSeCa5ffL1k29nGatb3Z9plDRmjoWaPDF308mw/2/1/ieu7yy+dr05EjrVHVp5JEvLb6CmYTGfMJj9lExnxCRXPgI2XC6z333KPXXntNv/zlLzVs2LDg8iFDhqizs1M+ny/k6Gtzc7Py8vKi3n4gYCkQsHouNIjfH1BXV3x2dL8/IEuSZUU3I8uyoq6Ntf50a4OnCljdn08y+4hHbby3/enZJOT5Kb77ph1M7z+RmE1kzCc8ZhMZ84me7SdYWJale+65R3/4wx/09NNPa8SIESHrS0pKlJaWptra2uCyXbt2qaGhgYu1AAAA+hnbj7xWV1frhRde0MMPP6ysrKzgeazZ2dkaMGCAsrOzVVlZqZqaGuXk5GjgwIFatGiRvF4v4RUAAKCfsT28/vrXv5YkXX/99SHLlyxZoquvvlqStHDhQjmdTs2bN08dHR2qqKhQVVVV0nsFAACAvWwPr/X19T3WZGRkqKqqisAKAADQz9l+zisAAAAQLcIrAAAAjEF4BQAAgDEIrwAAADAG4RUAAADGILwCAADAGIRXAAAAGIPwCgAAAGMQXgEAAGAMwisAAACMQXgFAACAMQivAAAAMAbhFQAAAMYgvAIAAMAYhFcAAAAYg/AKAAAAY7jtbgBA3+L3d6m+/p2o68eMGav09PQEdgQA6EsIrwDi6mjjPq3b26az9jh6rG0+sFvzZ0pe78TENwYA6BMIrwDibtDQkcofWWx3GwCAPohzXgEAAGAMwisAAACMQXgFAACAMQivAAAAMAbhFQAAAMYgvAIAAMAYhFcAAAAYg/AKAAAAYxBeAQAAYAzCKwAAAIxBeAUAAIAxCK8AAAAwBuEVAAAAxiC8AgAAwBhuuxsAAJN0dHSorm5b1PVjxoxVenp6AjsCgP6F8AoAMair26b7n1qv3PzCHmubD+zW/JmS1zsx8Y0BQD9BeAWAGOXmFyp/ZLHdbQBAv8Q5rwAAADAG4RUAAADGILwCAADAGIRXAAAAGIPwCgAAAGMQXgEAAGAMwisAAACMQXgFAACAMQivAAAAMAbhFQAAAMYgvAIAAMAYhFcAAAAYw/bwumnTJt10002qqKhQUVGRNmzYELLesiw98MADqqio0Lhx4zRz5kzt2bPHnmYBAABgK9vD60cffaSioiJVVVWdcv3KlSu1atUq3X333VqzZo0yMzM1e/Zstbe3J7lTAAAA2M1tdwOTJ0/W5MmTT7nOsiw988wzmjNnjqZOnSpJ+ulPf6ry8nJt2LBBl19+eTJbBQAAgM1sD6+R7Nu3T42NjSovLw8uy87OVmlpqTZv3hxTeHU6HXI6HYloM+lcLmfIx3ht0yHJ4YhuRg6HI+raWOtPu9bx948OOXquT1QfcaiN+7Y/OZsU6Dng79LOnfVR7cudnZ2SpLS0tKj7KCkZq/T09Kjro3ltxfJacXxc73bb/keu05aInzt9CfMJj9lExnxil9LhtbGxUZKUm5sbsjw3N1dNTU0xbWvw4KyYfvmawOPJjOu2XG6X3G5Xj7Uul1NOlzOq2ljr41nrdrliqk+12oT24UyNnn2HG7TutTaN2Ntz7d/e+osyBg7SiM+eH1UfTQ27VTUvUxdccEFU9Z8U6bUV02vF7ZLHk6lBg7Ji7iFVxfPnTl/EfMJjNpExn+ildHiNp8OHW/vUkVePJ1M+X5v8/kBctunztcnf5VdXl7/HWr8/oIA/EFVtrPVxqXWcCK5dfr9k2djHadYmZNsfz8YfSJ2ezxwyQkPPGt1j7Qf7/k9neIZGVStJ/i6/fL42HTnSGlW9FN1rK6bXSi96SFWJ+LnTlzCf8JhNZMwnVDT/s5/S4TUvL0+S1NzcrKFDhwaXNzc3q7i4OKZtBQKWAgGr50KD+P0BdXXFZ0f3+wOydOI842hYlhV1baz1p1sbPFXA6v58ktlHPGrjve1Pz8aEnntdq96/RiJ9XSyvldPpIVX1tecTb8wnPGYTGfOJXkqfYDF8+HDl5eWptrY2uKylpUVbt26V1+u1sTMAAADYwfYjr62trdq7d2/w83379mnHjh3KyclRQUGBbrjhBj3yyCM6++yzNXz4cD3wwAMaOnRo8O4DAAAA6D9sD6/bt2/XDTfcEPx8yZIlkqTp06erpqZGN954o9ra2nTXXXfJ5/Np4sSJeuyxx5SRkWFXywAAALCJ7eF10qRJqq+vD7ve4XDo1ltv1a233prErgAAAJCKUvqcVwAAAOCTCK8AAAAwBuEVAAAAxiC8AgAAwBi2X7AFAHbr6OhQXd22qN7ppr7+HVlR3kfc7+9Sff07MfUyZsxYpaenx/Q1ANCfEF4B9Ht1ddt0/1PrNSS/UC63S/4uv8K9f9au7bUaVlga1XaPNu7Tur1tOmtPdG9N3Xxgt+bPlLzeidE1DgD9EOEVACTl5hcq/+zz5Ha71NXlD/v2r80H98S03UFDRyp/ZGxvZw0ACI9zXgEAAGAMwisAAACMQXgFAACAMQivAAAAMAbhFQAAAMYgvAIAAMAYhFcAAAAYg/AKAAAAYxBeAQAAYAzCKwAAAIxBeAUAAIAxCK8AAAAwBuEVAAAAxiC8AgAAwBhuuxsAgETw+7tUX/9OVLX19e/ICiS4IQBAXBBeAfRJRxv3ad3eNp21x9Fj7a7ttRpWWJqErgAAp4vwCqDPGjR0pPJHFvdY13xwT+KbAQDEBee8AgAAwBiEVwAAABiD8AoAAABjcM5rH9bR0aG6um1R1XK1NWC/WO6QIEljxoxVenp6AjsCgNRDeO3D6uq26f6n1is3v7DHWq62BuwXyx0Smg/s1vyZktc7MfGNAUAKIbz2cbn5hVxtDRgk2jskAEB/xTmvAAAAMAbhFQAAAMYgvAIAAMAYnPMKAAaK5c4EnZ2dkqS0tLRe17pcTnk8mfL52uT3h96ahLseAEgmwisAGCiWOxPs2v6GMrIG6azC83pd65Dkcrvk7/LL+sRy7noAINkIrwBgqGjvTNB8cI8ys/NOq9bhcMjtdqmryy/LssJ8NQAkHue8AgAAwBiEVwAAABiD8AoAAABjcM6rYTo6OvTWW3Vhr/r9pPr6d2SFXw0Apy2Wux5I3Jkg1XR0dKiubltMX8P3EHYjvBqmrm6blj39ioYOH9Xtqt9P27W9VsMKS5PWG4D+J5a7HnBngtRTV7dN9z+1Xrn5hVHV8z1EKiC8Gih32DkqOPu8Hq/6bT64J3lNAei3or3rAVJTbn4h3z8YhXNeAQAAYAzCKwAAAIzBaQMJEMsJ8LG8baP08UVY3B8cAHotET+jT7597siR58rpjO5XayJ/VyTqoqreXKDndg+Iex+JEusFbLHMOdy2w731ciK+h33lAj3CawLEcgJ8LG/beKK+VvmfHX+aHQJA/5WIn9EOSUcO7dX8mdM0bpzXtj6kxF5U1ZsL9C644IK495EosXxPYp1zuG2f6q2XE/U97CsX6BFeEyTaE+BjedvGk/UAgNMT75/RDodDLrfL9j6Soa9foJfIC9hOte1kv/VyX7hAz5hzXn/1q1/pkksu0dixY/W1r31Nb731lt0tAQAAIMmMCK8vvfSSlixZoptvvlm//e1vVVxcrNmzZ6u5udnu1gAAAJBERoTXJ598Utdcc40qKyt17rnnqrq6WgMGDNDatWvtbg0AAABJlPLnvJ64Mq5O3/3ud4PLnE6nysvLtXnz5qi343Q65HT2fIJ5PLhcTh0+uEfRPNqHzQd0/PhxHczKimrbHzYf0PH242p4L1t+v1+R3mIrlm0nqtaWPhySy+XqNp9UmIfts/t4Nh8eNqjnJPZxYG/WKfedVO7ZpNfV4YN7tHPniZ+Rdtq5sz7+P6Md0pEP9urdd6N/T+6E9KHY5hxLD73tIy3NpYEDB6il5bgCgdS+XU4s84h1fw677VO8thL1Won1+3344B65XOfJ7U6tY50OKxlnB5+GDz74QBdffLFWr14tr/fvV3D+9Kc/1aZNm/Qf//EfNnYHAACAZEqtKA0AAABEkPLhddCgQXK5XN0uzmpubtaQIUNs6goAAAB2SPnwmp6erjFjxqi2tja4LBAIqLa2NuQ0AgAAAPR9KX/BliTNmjVLCxYsUElJicaNG6enn35abW1tuvrqq+1uDQAAAElkRHi97LLLdPjwYT344INqbGzUeeedp8cee4zTBgAAAPqZlL/bAAAAAHBSyp/zCgAAAJxEeAUAAIAxCK8AAAAwBuEVAAAAxiC8prCHHnpIRUVFIf996UtfCq5vb29XdXW1Jk2aJK/Xq1tuuUVNTU02dpw8l1xySbfZFBUVqbq6WpJ0/fXXd1t311132dx14mzatEk33XSTKioqVFRUpA0bNoSstyxLDzzwgCoqKjRu3DjNnDlTe/bsCak5evSobr/9dk2YMEH/8A//oIULF6q1tTWJzyIxIs2ms7NTP/vZz3TllVdq/Pjxqqio0Pe//3198MEHIds41f72i1/8ItlPJSF62nd+8IMfdHvus2fPDqnpj/uOpFP+DCoqKtJjjz0WrOmr+86jjz6qyspKeb1elZWV6Xvf+5527doVUhPN76iGhgb9y7/8i0pLS1VWVqaf/OQn6urqSuZTibueZnP06FHde++9mjZtmsaNG6cvfOELWrRokY4dOxaynVPtWy+++GKyn05KMuJWWf3Z5z73OT355JPBz10uV/Dfixcv1saNG7Vs2TJlZ2fr3nvv1dy5c7V69Wo7Wk2q5557Tn6/P/j5zp07NWvWrJBwf80112jevHnBzzMzM5PaYzJ99NFHKioqUmVlpebOndtt/cqVK7Vq1SrV1NRo+PDheuCBBzR79my99NJLysjIkCTdcccdamxs1JNPPqnOzk4tXLhQd911l37+858n++nEVaTZHD9+XG+//bbmzJmj4uJi+Xw+/fjHP9acOXO0bt26kNp58+bpmmuuCX6elZWVlP4Trad9R5IuuugiLVmyJPh5enp6yPr+uO9I0uuvvx7y+Z///Gf927/9m6ZNmxayvC/uO2+++aZmzJihsWPHyu/367777tPs2bP14osv6owzzpDU8+8ov9+v7373uxoyZIhWr16tQ4cOacGCBUpLS9Ntt91m59M7LT3N5tChQ8Hneu6552r//v26++67dejQIT344IMh21qyZIkuuuii4OcejyfZTyc1WUhZDz74oPXlL3/5lOt8Pp81ZswY6+WXXw4u+9vf/maNHj3a2rx5c5I6TB2LFi2ypk6dagUCAcuyLOub3/ymtWjRIpu7ssfo0aOtP/zhD8HPA4GA9fnPf9567LHHgst8Pp9VUlJivfDCC5Zl/X3feeutt4I1GzdutIqKiqyDBw8mr/kE+/RsTmXr1q3W6NGjrf379weXTZkyxXryyScT3J39TjWfBQsWWHPmzAn7New7fzdnzhzrhhtuCFnWX/ad5uZma/To0dabb75pWVZ0v6Nee+01q7i42GpsbAzWPPvss9aECROs9vb2pPafSJ+ezam89NJL1pgxY6zOzs7gsmj2uf6K0wZS3HvvvaeKigpdeumluv3229XQ0CBJ2r59uzo7O1VeXh6sHTVqlAoKCrRlyxaburVHR0eHfv/736uyslIOhyO4/Pnnn9ekSZN0xRVX6Oc//7na2tps7NI++/btU2NjY8i+kp2drdLSUm3evFmStHnzZnk8Ho0dOzZYU15eLqfTqbfeeivpPduppaVFDoej2xGOlStXatKkSbrqqqv02GOPGf+nzVi8+eabKisr07Rp01RVVaUjR44E17HvnNDU1KSNGzfqq1/9ard1/WHfOfkn75ycHEnR/Y7asmWLRo8eHfKGQxUVFWppadHf/va35DWfYJ+ezam0tLRo4MCBcrtD/yB+8rSLr371q3ruuedkcWt+SZw2kNLGjRunJUuWqLCwUI2NjVqxYoVmzJih559/Xk1NTUpLS+v2CzY3N1eNjY02dWyPDRs26NixY5o+fXpw2RVXXKGCggINHTpU9fX1Wrp0qXbv3q3ly5fb2Kk9Tu4Pubm5Ictzc3OD5581NTVp8ODBIevdbrdycnL61f7U3t6upUuX6vLLL9fAgQODy6+//nqdf/75ysnJ0ebNm3XfffepsbFRP/zhD23sNjkuuugi/dM//ZOGDx+u999/X/fdd59uvPFG/eY3v5HL5WLf+dhvf/tbZWVl6Ytf/GLI8v6w7wQCAS1evFgTJkzQ6NGjJSmq31FNTU3d3inz5Od9Zd851Ww+7fDhw3r44Yf19a9/PWT5vHnzdOGFFyozM1Ovv/66qqur9dFHH+mGG25IRuspjfCawiZPnhz8d3FxsUpLSzVlyhS9/PLLGjBggI2dpZa1a9fq4osv1mc+85ngsk/+ECgqKlJeXp5mzpypvXv3auTIkXa0iRTX2dmpW2+9VZZlBS/8O2nWrFnBfxcXFystLU1VVVW6/fbbu53/2ddcfvnlwX+fvGhk6tSpwaOxOGHt2rW68sorg+eQn9Qf9p3q6mrt3LlTzz77rN2tpJyeZtPS0qLvfve7GjVqVLfzqm+++ebgv88//3y1tbXp8ccfJ7yKuw0YxePx6JxzztHevXs1ZMgQdXZ2yufzhdQ0NzcrLy/Ppg6Tb//+/XrjjTdO+ae6TyotLZV04jSM/ubk/tDc3ByyvLm5OXiUY8iQITp8+HDI+q6uLn344Yf9Yn/q7OzUv/7rv6qhoUFPPPFEyFHXUyktLVVXV5f27duXpA5Tx4gRIzRo0KDga6m/7zuS9Ne//lW7d+/W1772tR5r+9q+c8899+i1117T008/rWHDhgWXR/M7asiQId3uPnDy876w74SbzUktLS36zne+o6ysLK1YsUJpaWkRt1daWqqDBw+qo6MjUS0bg/BqkNbWVr3//vvKy8tTSUmJ0tLSVFtbG1y/a9cuNTQ0aPz48fY1mWTr1q1Tbm6uvvCFL0Ss27Fjh6S+8QMxVsOHD1deXl7IvtLS0qKtW7fK6/VKkrxer3w+n7Zv3x6s+e///m8FAgGNGzcu6T0n08ng+t577+mpp57SoEGDevyaHTt2yOl0djsVoz84ePCgjh49Gnwt9ed956TnnntOY8aMUXFxcY+1fWXfsSxL99xzj/7whz/o6aef1ogRI0LWR/M7avz48Xr33XdD/sf6jTfe0MCBA3Xuuecm5XkkQk+zkU78DJ49e7bS0tL0yCOPdDtifyo7duxQTk5Onzlifzo4bSCF/eQnP9GUKVNUUFCgQ4cO6aGHHpLT6dQVV1yh7OxsVVZWqqamRjk5ORo4cKAWLVokr9fbb8JrIBDQunXrdNVVV4Wc5L537149//zzmjx5ss4880zV19dryZIluuCCC6L65WKi1tZW7d27N/j5vn37gj/oCgoKdMMNN+iRRx7R2WefHbxV1tChQzV16lRJJy6kuOiii/SjH/1I1dXV6uzs1L333qvLL7885HQME0WaTV5enubNm6e3335bjz76qPx+f/Bcu5O/JDZv3qytW7fqwgsvVFZWljZv3qwlS5boy1/+csQLMEwRaT45OTlavny5pk2bpiFDhuj999/Xz372M5199tnB2/f0132noKBA0okQsn79ei1YsKDb1/flfae6ulovvPCCHn74YWVlZQVfN9nZ2RowYEBUv6MqKip07rnn6vvf/77uvPNONTY2atmyZZoxY4bRAa2n2bS0tOjb3/622tra9LOf/UwtLS1qaWmRJA0ePFgul0t/+tOf1NzcrNLSUmVkZOgvf/mLHn30UX3729+286mlDIfFpWspa/78+dq0aZOOHj2qwYMHa+LEiZo/f37wnM329nbV1NToxRdfVEdHhyoqKlRVVdVvji6+/vrrmj17ttavX6/CwsLg8gMHDujOO+/Uzp079dFHHyk/P19Tp07V9773vR7/HGyq//mf/znleVDTp09XTU2NLMvSgw8+qDVr1sjn82nixImqqqoKmdvJG2f/6U9/ktPp1Be/+EX9v//3/4y/J2Wk2cydO1eXXnrpKb/umWee0aRJk1RXV6fq6mrt2rVLHR0dGj58uL7yla9o1qxZRv+CPSnSfO6++27dfPPNevvtt3Xs2DENHTpUn//853XrrbeGXGjTH/edmpoaSdJvfvMbLV68WK+//rqys7ND6vryvlNUVHTK5UuWLNHVV18tKbrfUSfvcfrmm28qMzNT06dP1+23397tqnuT9DSbcPuVJP3xj3/U8OHD9ec//1n33Xdf8PSckSNH6tprr9U111wjp5M/mhNeAQAAYAziOwAAAIxBeAUAAIAxCK8AAAAwBuEVAAAAxiC8AgAAwBiEVwAAABiD8AoAAABjEF4BAABgDMIrAAAAjEF4BQAAgDEIrwAAADAG4RUAAADG+P8nJKEwzKWxuAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.histplot(speedups[speedups < 500], bins=50)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "dcfb2b1f-3284-47af-9426-b5e91af3c623", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "104.1" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "speedups.median().round(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "34086f4a-b479-44aa-a23f-997aecf441e5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAC64AAAMWCAYAAABLXDovAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB2J0lEQVR4nOzde5jXdZ338dccQBEBAcFUPGI7WICCmkoYcgh1EYVKTU30DnNhS5B01QxYSa+lJWkjMXXRMFmz3G6yS8zDotatu7p3dpOHBDxBhgfk6CRynPndf7ROToCc5svA+HhclxfO53v4vb/MdPW5Lp98KSuVSqUAAAAAAAAAAAAAAEBByht7AAAAAAAAAAAAAAAAmjbhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAACbNXPmzFRVVWXRokWNPQo72Y033piqqqpG+eyFCxfmy1/+co455phUVVVl9uzZjTIHAAAAAAANR7gOAAAAAPARMmLEiBx11FF59913N3vO5Zdfnq5du2bFihU79Fn//d//naqqqrp/unbtml69euWCCy7ILbfckuXLl+/Q/f/6s772ta/l05/+dLp27ZoTTzwxI0aMyMMPP1x3zr//+7+nqqoqP//5zze6fs6cOenSpUv++Z//uW7tggsuqDd/9+7dM3jw4Nxxxx2pra3dqrnWrVuXH/3oRxkyZEh69uyZY489NoMGDcq4cePyyiuv7PiDN1FXX311XnzxxYwZMyaTJk1K165dN3vuj3/844waNSonn3xyqqqqcvXVV2/23Orq6owbNy4nnHBCjj766FxwwQX5/e9/v8lzH3nkkQwdOjTdunXLySefnO9///vZsGHDDt0TAAAAAOCjrLKxBwAAAAAAYOc544wz8thjj2X27NkZMmTIRsdXr16dRx99NL17907btm1z5plnZtCgQWnevPl2f+YFF1yQbt26pba2NsuXL8+cOXNy4403Zvr06fne976XE088cQeeKPn+97+fm266KYceemjOOeecHHDAAVm5cmV+/etf59JLL80NN9yQwYMH5wtf+EJ+/vOf55//+Z9z8sknp23btkmS9evXZ/z48dl///1z6aWX1rv3xz72sXz9619PkqxYsSKzZs3KxIkTs2LFiowZM2aLs40aNSr/5//8nwwaNChnnXVWNmzYkFdffTW/+tWv0qNHj3Tu3HmHnr0pWrNmTebMmZMRI0bkS1/60hbPv+2227Jq1ap069YtS5Ys2ex5tbW1ueSSSzJ//vwMHz48bdu2zY9//ONccMEFmTlzZg499NC6c3/961/nq1/9aj71qU9l3LhxefHFF3PzzTdn2bJlmTBhwnbdEwAAAADgo064DgAAAADwEdKvX7+0bNky99133ybD9UceeSTvvfdezjjjjCRJRUVFKioqdugzjz322Jx66qn11ubNm5cvf/nLGTVqVO6///507Nhxs9e/99572WuvvTZ57MEHH8xNN92UU045JZMnT06zZs3qjl188cV5/PHH696SXVZWlm9961sZMmRIJk2alIkTJyZJpk+fXhcm//XntGrVKmeeeWbd1+eee25OO+20zJgxI6NGjfrQ35tnn302jz32WMaMGZMRI0bUO1ZTU5Pq6urNXvtR9v6b+Fu3br1V58+YMSMHHHBAysrK0qNHj82e9+CDD2bOnDmZMmVK3c/jaaedllNOOSU33nhjJk+eXHfupEmTUlVVlR/+8IeprPzzf0pp2bJlbr311gwbNqzuDxxsyz0BAAAAAD7qyht7AAAAAAAAdp4999wzAwcOzFNPPZVly5ZtdHzWrFlp2bJl+vXrlySZOXNmqqqqsmjRorpz+vXrl7/7u7/L008/nS984Qvp1q1b+vfvn3vvvXer5+jSpUuuueaaVFdX56677qpbv/HGG1NVVZWXX345l19+eY477ricd955m73PlClTss8+++Sf/umf6kXr7zvppJPSt2/fuq+POOKIDB8+PDNnzsz//b//N3/84x9z0003ZeDAgXXP/GH22GOPdO3aNatWrdrk798H/fGPf0yS9OzZc6NjFRUVdW98T5LXX3891157bU455ZR07949xx9/fEaNGlXv9z35y/fj6aefzvXXX58TTjghxx57bMaPH59169aluro6V155ZY477rgcd9xxmTRpUkqlUt31ixYtSlVVVW6//fbccccd6du3b7p3754vfelLefHFF7f4/Enyi1/8Ip/73OfSvXv3fOpTn8qYMWPy5ptvbtW1L7zwQi6++OL07NkzPXr0yIUXXpjf/e53dcdvvPHGuu/X+/H4lr4vBx54YMrKyrb42Q899FD23XffDBw4sG6tXbt2Oe200/LII49k3bp1SZKXX345L7/8cs4+++y6aD1JzjvvvJRKpTz00EPbfE8AAAAAAITrAAAAAAAfOYMHD86GDRvywAMP1FtfuXJlnnjiiXz2s5/Nnnvu+aH3+MMf/pDRo0fn05/+dK6++uq0adMmV199dV566aWtnuOUU07JnnvumSeeeGKjY6NHj87q1aszZsyYnHXWWZu8fuHChXn11VfTv3//7L333lv9uSNHjsxBBx2U8ePH59prr01FRUXGjh271de//vrrKSsr2+IbwQ844IAkyX333Vf31vfNee655zJnzpwMGjQoY8eOzRe/+MU89dRTGTZsWFavXr3R+ddff30WLlyYSy+9NP369ctPf/rTTJkyJSNGjEhNTU3GjBmTY445Jrfffnt+8YtfbHT9vffemzvvvDPnnXdeLrnkkrz00ku58MILs3Tp0g+d8+abb85VV12VQw45JFdffXWGDRuWJ598Mueff/4W3yD/0ksv5fzzz8+8efNy8cUXZ+TIkVm0aFEuuOCCPPPMM0mSz372s/nGN76RJDn99NMzadKkXHPNNR963601d+7cfOITn0h5ef3/NNKtW7esXr06CxYsSPLnuP799Q/ab7/98rGPfSxz587d5nsCAAAAAJBUbvkUAAAAAACakhNOOCEdOnTIrFmz8qUvfalu/cEHH8z69eszePDgLd5jwYIFueuuu3LssccmSU477bT06dMnM2fOzFVXXbVVczRr1iyHHnpo3ZvJP6hLly6ZPHnyh17/yiuvJEn+5m/+Zqs+73177rlnrr322gwfPjwLFizINddck/3222+T59bU1GT58uVJ/hz2/+xnP8vzzz+fk08+eYtx/9FHH51PfepTueeee/Loo4/mhBNOSM+ePdO3b9+6qP19J598ck499dR6a3379s0555yThx56KEOGDKl3rH379pk2bVrKyspy/vnn57XXXsvtt9+ec845JxMmTEiSnHPOOenXr1/+9//+3xtd/9prr+Xhhx+ue+7PfOYzOeusszJt2rS6cPyvvf7667nxxhtz2WWXZcSIEXXrAwcOzNChQ/PjH/+43vpf+973vpf169fn7rvvzkEHHZQkGTJkSE499dR85zvfyb/927+lS5cu2XvvvTNx4sR84hOfyJlnnrn53+BttGTJkrqf1w/q2LFjkuTtt99OVVVVlixZkiTp0KHDRud26NAhb7/99jbfEwAAAAAAb1wHAAAAAPjIqaioyKBBgzJnzpwsWrSobn3WrFnZd999c+KJJ27xHkcccUS9YLddu3Y57LDDNhmhf5i99torq1at2mj9i1/84havfffdd5MkLVu23KbPTJI2bdrUvSW7d+/emz3v1VdfzYknnpgTTzwxp512Wm6//fb069cvEydO3OJnlJWV5fbbb89ll12W1q1bZ9asWfnWt76Vvn375rLLLqv3hvIPRvDr16/PihUrcvDBB6d169Z1bwD/oC984QspKyur+7p79+4plUr5whe+ULdWUVGRrl27bvJ7MmDAgHqxfvfu3XPUUUfl17/+9Waf5z/+4z9SW1ub0047LcuXL6/7Z999980hhxyS//7v/97stTU1NfnP//zPDBgwoC5aT/4ceJ9++un57W9/W/f9LMqaNWvSvHnzjdbfX1u7dm3deR9c/6A99tij7vi23BMAAAAAAG9cBwAAAAD4SBo8eHDuuOOOzJo1KyNGjMhbb72Vp59+OhdccEEqKiq2eP3++++/0VqbNm3yzjvvbNMc77333ibD806dOtX9+5o1a/KnP/2p3vEOHTpk7733TpJNhu8fpqamJuPHj0/Hjh3z3nvv5frrr8/06dM3ee6BBx6Y66+/PrW1tXnttddyyy23ZMWKFdljjz226rOaN2+ekSNHZuTIkXn77bfzm9/8JnfeeWceeOCBVFZW5oYbbqh7xltvvTUzZ87M4sWLUyqV6u7x18+eZKM3trdq1SrJxt+XVq1abfJ7csghh2y0duihh+aBBx7Y7LMsXLgwpVIpAwcO3OTxysrN/yeH5cuXZ/Xq1TnssMM2Ota5c+fU1tbmzTffzMc//vHN3mNH7bnnnlm3bt1G6++vvf89ff8PEWzq3LVr19b7QwZbe08AAAAAAITrAAAAAAAfSV27ds3hhx+e+++/PyNGjMisWbNSKpUyePDgrbp+a+L2LVm/fn0WLly4yVj5g8HvL3/5y3zjG9+od3z+/Pk5/PDDkyQvvvjiNn3unXfemRdeeCE33XRTFi9enG9961u57777Nvnse+21V3r16lX3dc+ePfO5z30u//Iv/5KxY8du0+d27NgxgwYNysCBA3P66afnwQcfzLe//e1UVlbmuuuuy8yZM3PhhRfm6KOPTqtWrVJWVpYxY8bUi9jf9/7b4rd2vSHU1tamrKws06ZN2+T3f6+99irssxtChw4dsmTJko3W33777SR//v68f16SLFmyZKM/CLBkyZJ07959m+8JAAAAAIBwHQAAAADgI2vw4MGZMmVK5s2bl1mzZuXQQw+tF+UW7aGHHsqaNWvSu3fvDz2vd+/em3wj+mGHHZbDDjssjzzySFatWrXJN7f/tTfffDPf//73079//wwYMCC1tbW599578+1vfzsnn3xy3ZvLN6dLly4544wz8pOf/CRf/vKXN3rz+dZo1qxZqqqqsnDhwqxYsSIdOnTIQw89lCFDhuTqq6+uO2/t2rWbfNt6Q/jDH/6w0drChQtz4IEHbvaagw8+OKVSKZ06ddrkm9M/TLt27dKiRYssWLBgo2OvvvpqysvLN/kW/4bUpUuX/Pa3v01tbW29wP/ZZ59NixYt6p7pyCOPTJI899xz9f73sHjx4rz11ls5++yzt/meAAAAAAAkxb16BQAAAACAXdr7bxj//ve/n7lz527129Ybwrx58/JP//RPadOmTc4///wPPbdjx47p1atXvX/eN2rUqKxcuTJjx47Nhg0bNrr2iSeeyGOPPVb39XXXXZckGTduXJI/v6F8woQJWbFiRb773e9u1ewXX3xxNmzYsMmY/oMWLlyYN954Y6P16urqzJkzJ23atEm7du2SbPoN9jNmzEhNTc1WzbStZs+encWLF9d9/eyzz+aZZ57JZz7zmc1eM3DgwFRUVGTq1KkbvQW+VCplxYoVm722oqIin/70p/PII49k0aJFdetLly7NrFmzcswxx2TvvffegSfaslNPPTVLly7Nww8/XLe2fPnyPPjgg+nbt2+aN2+eJPn4xz+eww8/PPfcc0+93/+77747ZWVlOfXUU7f5ngAAAAAAeOM6AAAAAMBH1kEHHZQePXrkkUceSZLCwvWnn346a9euTW1tbVauXJn/9//+Xx599NHsvffemTp1ajp06LDd9/7bv/3bzJ8/P7fcckteeOGFnH766TnggAOycuXKPP7443nyySczefLkJMl//Md/5JFHHsnVV19d7+3en/jEJ3LeeeflrrvuytChQ7f41vkjjjgiffr0yc9+9rP8/d//fdq2bbvJ8+bNm5crrrgiJ510Uo499ti0adMmixcvzr333pu3334711xzTV2wfvLJJ+cXv/hF9t577xxxxBH53e9+l//6r//KPvvss92/Nx/m4IMPzrnnnptzzz0369aty5133pl99tknF1988Ydec9lll2Xy5Ml5/fXXM2DAgLRs2TKLFi3K7Nmzc/bZZ2f48OGbvf6yyy7Lf/3Xf+W8887Leeedl4qKivz0pz/NunXr8g//8A/b/SyPPvpo5s2blyRZv3595s+fnx/84AdJkn79+qVLly5JklNOOSVHH310vvGNb+Tll19O27Ztc/fdd6empiaXXnppvXteeeWVGTlyZL785S9n0KBBefHFF3PXXXflrLPOSufOnevO25Z7AgAAAAB81AnXAQAAAAA+wgYPHpw5c+ake/fuOeSQQwr5jBkzZiRJmjVrllatWqVz58659NJLc/bZZ9e9cXxHjBkzJieccEJmzJiRu+++O++8805at26do446Kj/4wQ/Sv3//rFq1Ktdff32OPPLIDBs2bKN7XHbZZXnooYdy7bXX5t///d83+Qb0Dxo+fHh+9atf5d/+7d82Gygfd9xxGTVqVB5//PFMnz49K1asSMuWLXPkkUfmiiuuyCmnnFJ37je/+c2Ul5fnvvvuy9q1a9OzZ89Mnz79Q0PyHTFkyJCUl5fnRz/6UZYtW5bu3btn3Lhx6dix44ded8kll+TQQw/NHXfckZtuuilJ8rGPfSyf/vSn069fvw+99uMf/3juuuuuTJ48ObfeemtKpVK6d++e73znOznqqKO2+1kefvjh/PznP6/7+oUXXsgLL7xQN9v74XpFRUX+9V//NZMmTcqMGTOydu3adOvWLRMnTszhhx9e7559+/bN1KlTM3Xq1Fx33XVp165d/u7v/i5f/epX6523LfcEAAAAAPioKyv99d/nCQAAAAAANEmLFi1K//79c+WVV37o29EBAAAAAKChlTf2AAAAAAAAAAAAAAAANG3CdQAAAAAAAAAAAAAACiVcBwAAAAAAAAAAAACgUGWlUqnU2EMAAAAAAAAAAAAAANB0eeM6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIWqbOwBdiVLlvypsUdgG5SXl6Vdu5ZZvnxVamtLjT0OAMAOsbcBAJoSexsAoKmxvwEAmhJ7GwCgoXXo0GqrzvPGdXZb5eVlKSsrS3l5WWOPAgCww+xtAICmxN4GAGhq7G8AgKbE3gYAaCzCdQAAAAAAAAAAAAAACiVcBwAAAAAAAAAAAACgUMJ1AAAAAAAAAAAAAAAKJVwHAAAAAAAAAAAAAKBQwnUAAAAAAAAAAAAAAAolXAcAAAAAAAAAAAAAoFDCdQAAAAAAAAAAAAAACiVcBwAAAAAAAAAAAACgUMJ1AAAAAAAAAAAAAAAKJVwHAAAAAAAAAAAAAKBQwnUAAAAAAAAAAAAAAAolXAcAAAAAAAAAAAAAoFDCdQAAAAAAAAAAAAAACiVcBwAAAAAAAAAAAACgUMJ1AAAAAAAAAAAAAAAKJVwHAAAAAAAAAAAAAKBQwnUAAAAAAAAAAAAAAAolXAcAAAAAAAAAAAAAoFDCdQAAAAAAAAAAAAAACiVcBwAAAAAAAAAAAACgUMJ1AAAAAAAAAAAAAAAKJVwHAAAAAAAAAAAAAKBQwnUAAAAAAAAAAAAAAAolXAcAAAAAAAAAAAAAoFDCdQAAAAAAAAAAAAAACiVcBwAAAAAAAAAAAACgUMJ1AAAAAAAAAAAAAAAKJVwHAAAAAAAAAAAAAKBQwnUAAAAAAAAAAAAAAAolXAcAAAAAAAAAAAAAoFDCdQAAAAAAAAAAAAAAClXZ2APA7m7dunX5/e+f22j9k5/slubNmzfCRAAAAAAAAAAAAACwaxGuww76/e+fy7/c8WDa739Y3dqyNxdkzEVJjx7HNN5gAAAAAAAAAAAAALCLEK5DA2i//2HZ/+AujT0GAAAAAAAAAAAAAOySyht7AAAAAAAAAAAAAAAAmjbhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhWr0cP03v/lNRowYkd69e6eqqiqzZ8+uO7Z+/fp85zvfyeDBg3P00Uend+/eufLKK7N48eJ691i5cmUuv/zy9OzZM8cee2yuueaarFq1amc/CgAAAAAAAAAAAAAAm9Do4fp7772Xqqqq/OM//uNGx9asWZMXXnghI0eOzMyZMzN16tQsWLAgI0eOrHfeFVdckZdffjnTp0/PLbfckqeffjrjx4/fWY8AAAAAAAAAAAAAAMCHqGzsAfr06ZM+ffps8lirVq0yffr0emvjxo3LWWedlTfeeCMHHHBAXnnllTz++OP52c9+lm7duiVJxo4dm0suuSRXXnll9ttvv8KfAQAAAAAAAAAAAACAzWv0cH1bvfvuuykrK0vr1q2TJHPmzEnr1q3rovUk6dWrV8rLy/Pss8/ms5/97Fbfu7y8LOXlZQ0+M8WoqCiv92tjzlGWpKzsLz87Zf+zXlnZ6H+pAQCwm9hV9jYAAA3B3gYAaGrsbwCApsTeBgBoLLtVuL527drccMMNGTRoUPbee+8kydKlS9OuXbt651VWVqZNmzZZsmTJNt2/XbuW9eJjdg+tW7do9M+vqKxIZWVF3VpFZUVat26Rtm1bNuJkAMDuqLH3NgAADcneBgBoauxvAICmxN4GANjZdptwff369Rk9enRKpVImTJhQyGcsX77KG9d3IxUV5WndukWqq1enpqa20eaorl6dmg012bChpm6tZkNNqqtXZ8WKVY02FwCwe9lV9jYAAA3B3gYAaGrsbwCApsTeBgBoaFv7oufdIlxfv359Lrvssrzxxhv50Y9+VPe29STZd999s3z58nrnb9iwIe+88046dOiwTZ9TW1tKbW2pQWZm56mpqc2GDY23ia6pqU0pSan0l5+d0i4wFwCwe7KHAACaEnsbAKCpsb8BAJoSexsAYGcrb+wBtuT9aP0Pf/hD7rjjjrRt27be8R49eqS6ujrPP/983dpTTz2V2tradO/efWePCwAAAAAAAAAAAADAX2n0N66vWrUqr732Wt3XixYtyty5c9OmTZt06NAho0aNygsvvJBbb701NTU1WbJkSZKkTZs2ad68eTp37pyTTjop48aNy4QJE7J+/fpcd911GTRoUPbbb7/GeiwAAAAAAAAAAAAAAP5Ho4frzz//fIYNG1b39cSJE5MkQ4cOzde+9rU8+uijSZIzzzyz3nV33nlnjj/++CTJDTfckOuuuy4XXnhhysvLM3DgwIwdO3YnPQEAAAAAAAAAAAAAAB+m0cP1448/PvPnz9/s8Q879r599tknkydPbsixAAAAAAAAAAAAAABoIOWNPQAAAAAAAAAAAAAAAE2bcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQlU29gDwUbFu3br8/vfPbfLYJz/ZLc2bN9/JEwEAAAAAAAAAAADAziFch53k979/Lv9yx4Npv/9h9daXvbkgYy5KevQ4pnEGAwAAAAAAAAAAAICCCddhJ2q//2HZ/+AujT0GAAAAAAAAAAAAAOxU5Y09AAAAAAAAAAAAAAAATZtwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEI1erj+m9/8JiNGjEjv3r1TVVWV2bNn1zteKpUyZcqU9O7dO927d89FF12UhQsX1jtn5cqVufzyy9OzZ88ce+yxueaaa7Jq1aqd+BQAAAAAAAAAAAAAAGxOo4fr7733XqqqqvKP//iPmzw+bdq0zJgxI9dee23uueeetGjRIsOHD8/atWvrzrniiivy8ssvZ/r06bnlllvy9NNPZ/z48TvrEQAAAAAAAAAAAAAA+BCNHq736dMnY8aMyWc/+9mNjpVKpdx5550ZOXJkBgwYkC5dumTSpEl5++23697M/sorr+Txxx/P9ddfn6OOOirHHntsxo4dm/vvvz+LFy/e2Y8DAAAAAAAAAAAAAMBfqWzsAT7MokWLsmTJkvTq1aturVWrVjnqqKMyZ86cDBo0KHPmzEnr1q3TrVu3unN69eqV8vLyPPvss5sM4jenvLws5eVlDfoMFKeiorzer405R1mSsrK//OzU1mzISy/NrzfbSy/NT0qleuclSdn/3KOystH/HAkA0Ih2lb0NAEBDsLcBAJoa+xsAoCmxtwEAGssuHa4vWbIkSdK+fft66+3bt8/SpUuTJEuXLk27du3qHa+srEybNm3qrt9a7dq13CgqZtfXunWLRv/8isqKVFZW1K1VL38jM3+1Oge99pe1l599Kvt3PrreeUlSUVmR1q1bpG3bljttZgBg19XYexsAgIZkbwMANDX2NwBAU2JvAwDsbLt0uL6zLV++yhvXdyMVFeVp3bpFqqtXp6amttHmqK5enZoNNdmwoaZuraamNvvse1A6Hvg3dWuLF72S2praeuclSc2GmlRXr86KFat22swAwK5nV9nbAAA0BHsbAKCpsb8BAJoSexsAoKFt7cubd+lwvUOHDkmSZcuWpWPHjnXry5YtS5cuXZIk++67b5YvX17vug0bNuSdd96pu35r1daWUltb2sGp2dlqamqzYUPjbaJrampTSlIq1f/ZKZVKW7eWxn8GAGDXYV8AADQl9jYAQFNjfwMANCX2NgDAzlbe2AN8mE6dOqVDhw558skn69befffdPPPMM+nRo0eSpEePHqmurs7zzz9fd85TTz2V2tradO/efafPDAAAAAAAAAAAAABAfY3+xvVVq1bltddeq/t60aJFmTt3btq0aZMDDjggw4YNy80335xDDjkknTp1ypQpU9KxY8cMGDAgSdK5c+ecdNJJGTduXCZMmJD169fnuuuuy6BBg7Lffvs11mMBAAAAAAAAAAAAAPA/Gj1cf/755zNs2LC6rydOnJgkGTp0aL797W/nK1/5SlavXp3x48enuro6xxxzTG677bbsscceddfccMMNue6663LhhRemvLw8AwcOzNixY3f6swAAAAAAAAAAAAAAsLFGD9ePP/74zJ8/f7PHy8rKMnr06IwePXqz5+yzzz6ZPHlyEeMBAAAAAAAAAAAAALCDyht7AAAAAAAAAAAAAAAAmjbhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFqmzsAeCjrqZmQ+bPn7fR+ic/2S3NmzdvhIkAAAAAAAAAAAAAoGEJ16GRrVyyKDNfW50DF5bVrS17c0HGXJT06HFM4w0GAAAAAAAAAAAAAA1EuA67gLYdD87+B3dp7DEAAAAAAAAAAAAAoBDljT0AAAAAAAAAAAAAAABNm3AdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQgnXAQAAAAAAAAAAAAAolHAdAAAAAAAAAAAAAIBCCdcBAAAAAAAAAAAAACiUcB0AAAAAAAAAAAAAgEIJ1wEAAAAAAAAAAAAAKJRwHQAAAAAAAAAAAACAQu3y4XpNTU2+973vpV+/funevXsGDBiQm266KaVSqe6cUqmUKVOmpHfv3unevXsuuuiiLFy4sPGGBgAAAAAAAAAAAACgzi4frk+bNi133313xo8fn1/+8pe54oorctttt2XGjBn1zpkxY0auvfba3HPPPWnRokWGDx+etWvXNuLkAAAAAAAAAAAAAAAku0G4PmfOnPTv3z8nn3xyOnXqlFNPPTW9e/fOs88+m+TPb1u/8847M3LkyAwYMCBdunTJpEmT8vbbb2f27NmNPD0AAAAAAAAAAAAAALt8uN6jR4889dRTWbBgQZJk3rx5+e1vf5vPfOYzSZJFixZlyZIl6dWrV901rVq1ylFHHZU5c+Y0yswAAAAAAAAAAAAAAPxFZWMPsCWXXHJJ3n333Zx22mmpqKhITU1NxowZkzPOOCNJsmTJkiRJ+/bt613Xvn37LF26dJs+q7y8LOXlZQ0zOIWrqCiv92tjzlGWpKys/s9OWVnZVq1tar3sf+5bWbnL/9kSAKCB7Cp7GwCAhmBvAwA0NfY3AEBTYm8DADSWXT5cf+CBB3Lfffdl8uTJOeKIIzJ37txMnDgxHTt2zNChQxv0s9q1a7nJqJhdW+vWLRr98ysqK1JZWVG3VlFRnvKK8i2ubfbcyoq0bt0ibdu2LP4BAIBdSmPvbQAAGpK9DQDQ1NjfAABNib0NALCz7fLh+qRJk3LJJZdk0KBBSZKqqqq88cYbufXWWzN06NB06NAhSbJs2bJ07Nix7rply5alS5cu2/RZy5ev8sb13UhFRXlat26R6urVqampbbQ5qqtXp2ZDTTZsqKlbq6mpTW1N7RbXNnvuhppUV6/OihWrin8AAGCXsKvsbQAAGoK9DQDQ1NjfAABNib0NANDQtvZFzbt8uL5mzZqN3oJeUVGRUqmUJOnUqVM6dOiQJ598MkceeWSS5N13380zzzyTc889d5s+q7a2lNraUsMMzk5TU1ObDRsabxNdU1ObUlL3M/m+Uqm0VWubWi+l8Z8LAGgc9gAAQFNibwMANDX2NwBAU2JvAwDsbLt8uN63b9/ccsstOeCAA3LEEUdk7ty5mT59ej7/+c8nScrKyjJs2LDcfPPNOeSQQ9KpU6dMmTIlHTt2zIABAxp5egAAAAAAAAAAAAAAdvlwfezYsZkyZUomTJiQZcuWpWPHjjnnnHPy1a9+te6cr3zlK1m9enXGjx+f6urqHHPMMbntttuyxx57NOLkAAAAAAAAAAAAAAAku0G4vvfee+eb3/xmvvnNb272nLKysowePTqjR4/eiZMBAAAAAAAAAAAAALA1yht7AAAAAAAAAAAAAAAAmjbhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUCjhOgAAAAAAAAAAAAAAhRKuAwAAAAAAAAAAAABQKOE6AAAAAAAAAAAAAACFEq4DAAAAAAAAAAAAAFAo4ToAAAAAAAAAAAAAAIUSrgMAAAAAAAAAAAAAUKjtCtf79++fefPmbfLYiy++mP79++/QUAAAAAAAAAAAAAAANB3bFa6//vrrWbdu3SaPrVmzJm+99dYODQUAAAAAAAAAAAAAQNNRubUnrl27NqtXr06pVEqSvPvuu1m5cuVG58yePTsdO3Zs0CEBAAAAAAAAAAAAANh9bXW4Pm3atNx0001JkrKysgwfPnyz537ta1/b8ckAAAAAAAAAAAAAAGgStjpcHzBgQA488MCUSqVcc801GTlyZA4++OB65zRr1iydO3fOkUce2eCDAgAAAAAAAAAAAACwe9rqcL1Lly7p0qVLkj+/cb1Pnz5p165dYYMBAAAAAAAAAAAAANA0bHW4/kFDhw5t6DkAAAAAAAAAAAAAAGiititcX7NmTX7wgx/koYceyltvvZV169ZtdM7cuXN3eDgAAAAAAAAAAAAAAHZ/2xWuT5gwIbNmzcrpp5+ezp07p1mzZg09FwAAAAAAAAAAAAAATcR2heuPPfZYrrrqqnzpS19q6HkAAAAAAAAAAAAAAGhiyrfnooqKihx66KENPAoAAAAAAAAAAAAAAE3RdoXr5557bn7xi1809CwAAAAAAAAAAAAAADRBldtz0Z577pnf/va3+eIXv5gTTzwxrVu3rne8rKwsF110UUPMBwAAAAAAAAAAAADAbm67wvUbbrghSfLGG2/kd7/73UbHhesAAAAAAAAAAAAAALxvu8L1efPmNfQcAAAAAAAAAAAAAAA0UeWNPQAAAAAAAAAAAAAAAE3bdr1x/Te/+c0WzznuuOO259YAAAAAAAAAAAAAADQx2xWuX3DBBSkrK0upVKpbKysrq3fO3Llzd2wyAAAAAAAAAAAAAACahO0K1++9996N1t5555088cQTefjhhzNhwoQdnQs+0mpqNmT+/HkbrX/yk93SvHnzRpgIAAAAAAAAAAAAALbfdoXrXbp02eT68ccfnz333DM//elPc8IJJ+zQYPBRtnLJosx8bXUOXPiXv8lg2ZsLMuaipEePYxpvMAAAAAAAAAAAAADYDtsVrn+Ynj175vbbb2/o28JHTtuOB2f/gzf9h0QAAAAAAAAAAAAAYHdS3tA3nD17dvbZZ5+Gvi0AAAAAAAAAAAAAALup7Xrj+ogRIzZaW79+fRYsWJA333wz//AP/7DDgwEAAAAAAAAAAAAA0DRsV7i+atWqjdb22GOP9OrVK6ecckpOOumkHR4MAAAAAAAAAAAAAICmYbvC9RkzZjT0HAAAAAAAAAAAAAAANFHlO3qDNWvW5O23386aNWsaYh4AAAAAAAAAAAAAAJqY7XrjepI89thjmTp1aubOnZtSqZSysrIceeSRGTVqVPr06dOQMwIAAAAAAAAAAAAAsBvbrjeuz549O3//93+fZs2a5eqrr87kyZNz1VVXpXnz5hk5cmRmz57d0HMCAAAAAAAAAAAAALCb2q43rk+dOjWDBg3KDTfcUG/9wgsvzBVXXJGpU6dmwIABDTIgAAAAAAAAAAAAAAC7t+164/qrr76aIUOGbPLYmWeemVdffXVHZgIAAAAAAAAAAAAAoAnZrnC9TZs2WbBgwSaPLViwIG3atNmhoQAAAAAAAAAAAAAAaDoqt+eiv/3bv813v/vd7LnnnjnllFPSunXr/OlPf8qDDz6Y733vezn77LMbek4AAAAAAAAAAAAAAHZT2xWuX3755XnjjTcybty4jB8/PpWVldmwYUNKpVIGDhyYr3/96w09JwAAAAAAAAAAAAAAu6ntCtebN2+eG2+8MfPnz8/TTz+d6urqtGnTJsccc0yqqqoaekYAAAAAAAAAAAAAAHZj5Vt74sKFC/O5z30uv/71r+vWqqqqcv7552fkyJE577zz8tZbb+Vzn/tc/vjHPxYyLAAAAAAAAAAAAAAAu5+tDtd/+MMfZq+99kqfPn02e06fPn3SsmXL3H777Q0yHAAAAAAAAAAAAAAAu7+tDtf/8z//M5///Oe3eN7nP//5PPHEEzs0FAAAAAAAAAAAAAAATcdWh+uLFy/OQQcdtMXzOnXqlMWLF+/QUAAAAAAAAAAAAAAANB1bHa63bNkyK1as2OJ5K1euzF577bVDQwEAAAAAAAAAAAAA0HRsdbjetWvX/PKXv9zieffff3+6du26Q0MBAAAAAAAAAAAAANB0bHW4ft555+WBBx7I1KlTU1NTs9Hx2traTJ06NQ8++GDOP//8Bh0SAAAAAAAAAAAAAIDdV+XWnti/f/9cfPHFmTp1an7yk5/kxBNPzAEHHJAkefPNN/Pkk09m6dKlGT58ePr161fYwAAAAAAAAAAAAAAA7F62OlxPkiuuuCLHHXdcfvjDH+ahhx7KunXrkiR77LFHevbsmeuvvz59+vQpZFAAAAAAAAAAAAAAAHZP2xSuJ0mfPn3Sp0+f1NTUZOXKlUmSffbZJxUVFQ09GwAAAAAAAAAAAAAATcA2h+vvq6ioSPv27RtyFgAAAAAAAAAAAAAAmqDyxh4AAAAAAAAAAAAAAICmTbgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAAAAAAAAAAAQKGE6wAAAAAAAAAAAAAAFEq4DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAAAAAAAAAAAQKGE6wAAAAAAAAAAAAAAFEq4DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRqtwjXFy9enCuuuCLHH398unfvnsGDB+e5556rO14qlTJlypT07t073bt3z0UXXZSFCxc23sAAAAAAAAAAAAAAANTZ5cP1d955J+eee26aNWuWadOm5f77789VV12VNm3a1J0zbdq0zJgxI9dee23uueeetGjRIsOHD8/atWsbcXIAAAAAAAAAAAAAAJKksrEH2JJp06blYx/7WCZOnFi3dtBBB9X9e6lUyp133pmRI0dmwIABSZJJkyalV69emT17dgYNGrTTZwYAAAAAAAAAAAAA4C92+TeuP/roo+natWtGjRqVE088MUOGDMk999xTd3zRokVZsmRJevXqVbfWqlWrHHXUUZkzZ05jjAwAAAAAAAAAAAAAwAfs8m9c/+Mf/5i77747/+t//a+MGDEizz33XK6//vo0a9YsQ4cOzZIlS5Ik7du3r3dd+/bts3Tp0m36rPLyspSXlzXY7BSroqK83q+NOUdZkrKy+j87ZWVlW7W2teeW/c9nVVbu8n/eBADYDrvK3gYAoCHY2wAATY39DQDQlNjbAACNZZcP10ulUrp27Zqvf/3rSZJPfOITeemll/KTn/wkQ4cObdDPateu5SajYnZtrVu3aPTPr6isSGVlRd1aRUV5yivKt7i2LedWVFakdesWadu2ZYFPAwA0tsbe2wAANCR7GwCgqbG/AQCaEnsbAGBn2+XD9Q4dOqRz58711g4//PA89NBDdceTZNmyZenYsWPdOcuWLUuXLl226bOWL1/ljeu7kYqK8rRu3SLV1atTU1PbaHNUV69OzYaabNhQU7dWU1Ob2praLa5ty7k1G2pSXb06K1asKvBpAIDGsqvsbQAAGoK9DQDQ1NjfAABNib0NANDQtvalzLt8uN6zZ88sWLCg3trChQtz4IEHJkk6deqUDh065Mknn8yRRx6ZJHn33XfzzDPP5Nxzz92mz6qtLaW2ttQwg7PT1NTUZsOGxttE19TUppQ//+0AH1QqlbZqbWvPLaXxnxUAKJ7/vwcAmhJ7GwCgqbG/AQCaEnsbAGBnK2/sAbbkwgsvzDPPPJNbbrklf/jDH3LfffflnnvuyXnnnZckKSsry7Bhw3LzzTfnkUceyfz583PllVemY8eOGTBgQCNPDwAAAAAAAAAAAADALv/G9e7du2fq1Kn57ne/m5tuuimdOnXKNddckzPOOKPunK985StZvXp1xo8fn+rq6hxzzDG57bbbssceezTi5AAAAAAAAAAAAAAAJLtBuJ4kffv2Td++fTd7vKysLKNHj87o0aN34lQAAAAAAAAAAAAAAGyN8sYeAAAAAAAAAAAAAACApk24DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAAAAAAAAAAAQKGE6wAAAAAAAAAAAAAAFEq4DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAAAAAAAAAAAQKGE6wAAAAAAAAAAAAAAFEq4DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAAAAAAAAAAAQKGE6wAAAAAAAAAAAAAAFEq4DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAAAAAAAAAAAQKGE6wAAAAAAAAAAAAAAFEq4DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAAAAAAAAAAAQKGE6wAAAAAAAAAAAAAAFEq4DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAAAAAAAAAAAQKGE6wAAAAAAAAAAAAAAFEq4DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAAAAAAAAAAAQKGE6wAAAAAAAAAAAAAAFEq4DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAAAAAAAAAAAQKGE6wAAAAAAAAAAAAAAFEq4DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAAAAAAAAAAAQKGE6wAAAAAAAAAAAAAAFEq4DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAAAAAAAAAAAQKGE6wAAAAAAAAAAAAAAFEq4DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAAAAAAAAAAAQKGE6wAAAAAAAAAAAAAAFEq4DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAAAAAAAAAAAQKGE6wAAAAAAAAAAAAAAFEq4DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAAAAAAAAAAAQKGE6wAAAAAAAAAAAAAAFEq4DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAAAAAAAAAAAQKGE6wAAAAAAAAAAAAAAFEq4DgAAAAAAAAAAAABAoYTrAAAAAAAAAAAAAAAUSrgOAAAAAAAAAAAAAEChhOsAAAAAAAAAAAAAABRKuA4AAAD/v717j7KrrO/H/55JZiBAEsIESABjI5REQggDckkMpcslalH+ALR1iSg0BakiLQVRARuTCkTlkoIUESMgV1HAVqFUsYi2hIv9cklGMkYCC1OIJBNCAgRmMjO/P/wxdcgZciYn+5y5vF5rsXCe85y9P/tynv3sfd4cAQAAAAAAAIBCCa4DAAAAAAAAAAAAAFAowXUAAAAAAAAAAAAAAAo16ILr3/rWtzJlypRccMEFPW2vv/565s2bl8MOOyzNzc357Gc/mzVr1tSwSgAAAAAAAAAAAAAA3jCogutPPPFEbr311kyZMqVX+4UXXpj77rsvCxcuzA033JAXXnghp59+eo2qBAAAAAAAAAAAAADgjw2a4Porr7ySz33uc/nKV76SsWPH9rRv2LAht99+e77whS9k5syZ2X///XPhhRfm0UcfzWOPPVa7ggEAAAAAAAAAAAAASJKMrHUB5Zo/f36OPPLIzJo1K1dddVVP+9KlS9PR0ZFZs2b1tO29997ZY4898thjj+XAAw8sex319XWpr6/blmVToBEj6nv9u5Z11CWpq+t97tTV1ZXVVm7frs5NWb68dbPt3X//6WlsbKxwKwCAWhsocxsAgG3B3AYAGGrMbwCAocTcBgColUERXL/rrrvy61//Oj/4wQ82e23NmjVpaGjImDFjerU3NTVl9erV/VrPLrvsWDJUzMA2Zsyomq9/xMgRGTlyRE/biBH1qR9Rv8W2/vRdv/a53PHzjXnbs//Xtua5pzP3jFE55JBDitg0AKAGaj23AQDYlsxtAIChxvwGABhKzG0AgGob8MH1559/PhdccEG+853vZLvttit0XWvXvuIX1weRESPqM2bMqKxfvzGdnV01q2P9+o3p3NSZTZs6e9o6O7vS1dm1xbb+9O3s7MrO49+W3fbc9//aNnVm/fqNefHFV4rYNACgigbK3AYAYFswtwEAhhrzGwBgKDG3AQC2tXHjdiyr34APrre0tKStrS3HHXdcT1tnZ2ceeeSR3HTTTVm0aFE6Ojqyfv36Xr+63tbWll133bVf6+rq6k5XV/c2q53q6OzsyqZNtZtEd3Z2pTtJd3fvc6e7u7ustv70fXNbd2q//QDAtuXaDgAMJeY2AMBQY34DAAwl5jYAQLUN+OD64Ycfnh/96Ee92r74xS/mHe94R0455ZRMnDgxDQ0NWbx4cd7//vcnSVasWJHnnnsuBx54YA0qBgAAAAAAAAAAAADgjw344PpOO+2Ufffdt1fbDjvskJ133rmn/fjjj8+CBQsyduzY7LTTTvnKV76S5uZmwXUAAAAAAAAAAAAAgAFgwAfXy3Huueemvr4+Z5xxRtrb2zN79uzMnTu31mUBAAAAAAAAAAAAAJBBGly/4YYbev293XbbZe7cucLqAAAAAAAAAAAAAAADUH2tCwAAAAAAAAAAAAAAYGgTXAcAAAAAAAAAAAAAoFCC6wAAAAAAAAAAAAAAFEpwHQAAAAAAAAAAAACAQgmuAwAAAAAAAAAAAABQKMF1AAAAAAAAAAAAAAAKJbgOAAAAAAAAAAAAAEChBNcBAAAAAAAAAAAAACiU4DoAAAAAAAAAAAAAAIUSXAcAAAAAAAAAAAAAoFCC6wAAAAAAAAAAAAAAFEpwHQAAAAAAAAAAAACAQgmuAwAAAAAAAAAAAABQKMF1AAAAAAAAAAAAAAAKJbgOAAAAAAAAAAAAAEChBNcBAAAAAAAAAAAAACiU4DoAAAAAAAAAAAAAAIUSXAcAAAAAAAAAAAAAoFCC6wAAAAAAAAAAAAAAFEpwHQAAAAAAAAAAAACAQgmuAwAAAAAAAAAAAABQKMF1AAAAAAAAAAAAAAAKJbgOAAAAAAAAAAAAAEChBNcBAAAAAAAAAAAAACiU4DoAAAAAAAAAAAAAAIUSXAcAAAAAAAAAAAAAoFCC6wAAAAAAAAAAAAAAFEpwHQAAAAAAAAAAAACAQgmuAwAAAAAAAAAAAABQKMF1AAAAAAAAAAAAAAAKJbgOAAAAAAAAAAAAAEChBNcBAAAAAAAAAAAAACiU4DoAAAAAAAAAAAAAAIUSXAcAAAAAAAAAAAAAoFCC6wAAAAAAAAAAAAAAFEpwHQAAAAAAAAAAAACAQgmuAwAAAAAAAAAAAABQKMF1AAAAAAAAAAAAAAAKJbgOAAAAAAAAAAAAAEChBNcBAAAAAAAAAAAAACiU4DoAAAAAAAAAAAAAAIUSXAcAAAAAAAAAAAAAoFCC6wAAAAAAAAAAAAAAFEpwHQAAAAAAAAAAAACAQgmuAwAAAAAAAAAAAABQKMF1AAAAAAAAAAAAAAAKJbgOAAAAAAAAAAAAAEChBNcBAAAAAAAAAAAAACiU4DoAAAAAAAAAAAAAAIUSXAcAAAAAAAAAAAAAoFCC6wAAAAAAAAAAAAAAFEpwHQAAAAAAAAAAAACAQgmuAwAAAAAAAAAAAABQKMF1AAAAAAAAAAAAAAAKNbLWBcBg0d7enpaWJZu1t7YuS3dXDQoCAAAAAAAAAAAAgEFCcB3K1NKyJJddd0+aJk7u1b5i6eJMmDyjRlUBAAAAAAAAAAAAwMAnuA790DRxciZOmtqrrW3VM7UpBgAAAAAAAAAAAAAGifpaFwAAAAAAAAAAAAAAwNAmuA4AAAAAAAAAAAAAQKEE1wEAAAAAAAAAAAAAKJTgOgAAAAAAAAAAAAAAhRJcBwAAAAAAAAAAAACgUILrAAAAAAAAAAAAAAAUSnAdAAAAAAAAAAAAAIBCCa4DAAAAAAAAAAAAAFAowXUAAAAAAAAAAAAAAAoluA4AAAAAAAAAAAAAQKEE1wEAAAAAAAAAAAAAKJTgOgAAAAAAAAAAAAAAhRJcBwAAAAAAAAAAAACgUILrAAAAAAAAAAAAAAAUSnAdAAAAAAAAAAAAAIBCCa4DAAAAAAAAAAAAAFAowXUAAAAAAAAAAAAAAAoluA4AAAAAAAAAAAAAQKEE1wEAAAAAAAAAAAAAKJTgOgAAAAAAAAAAAAAAhRJcBwAAAAAAAAAAAACgUILrAAAAAAAAAAAAAAAUSnAdAAAAAAAAAAAAAIBCCa4DAAAAAAAAAAAAAFAowXUAAAAAAAAAAAAAAAoluA4AAAAAAAAAAAAAQKEE1wEAAAAAAAAAAAAAKJTgOgAAAAAAAAAAAAAAhRJcBwAAAAAAAAAAAACgUILrAAAAAAAAAAAAAAAUSnAdAAAAAAAAAAAAAIBCCa4DAAAAAAAAAAAAAFCokbUuANj22tvb09KyZLP2adOmp7GxsQYVAQAAAAAAAAAAADCcCa7DENTSsiSXXXdPmiZO7mlre/7pnHlS0tx8cO0KAwAAAAAAAAAAAGBYGvDB9auvvjo/+clPsmLFimy//fZpbm7O2WefnXe84x09fV5//fUsWLAgd999d9rb2zN79uzMnTs348ePr2HlUFtNEydn4qSptS4DAAAAAAAAAAAAAFJf6wK25OGHH84JJ5yQ2267Lddee202bdqUOXPm5NVXX+3pc+GFF+a+++7LwoULc8MNN+SFF17I6aefXsOqAQAAAAAAAAAAAAB4w4D/xfVFixb1+nvBggWZOXNmWlpacsghh2TDhg25/fbbc/HFF2fmzJlJ/hBkP/roo/PYY4/lwAMPrEHVAAAAAAAAAAAAAAC8YcAH199sw4YNSZKxY8cmSZYuXZqOjo7MmjWrp8/ee++dPfbYo9/B9fr6utTX123TeinOiBH1vf5djfXVJamr2/wcqaur26y93LZK3l/3/9c1cmTvfVCq1r76AgADQ7XnNgAARTK3AQCGGvMbAGAoMbcBAGplUAXXu7q6cuGFF+aggw7KvvvumyRZs2ZNGhoaMmbMmF59m5qasnr16n4tf5dddiwZKmZgGzNmVNXWM2LkiIwcOaJX+4gR9akfUd+rvdy2St8/YuSIjBkzKuPG7bjFWvvqCwAMLNWa2wAAVIO5DQAw1JjfAABDibkNAFBtgyq4Pm/evCxfvjw333xzIctfu/YVv7g+iIwYUZ8xY0Zl/fqN6ezsKnx969dvTOemzmza1NmrvbOzK12dXb3ay22r9P2dmzqzfv3GvPjiK1usta++AMDAUO25DQBAkcxtAIChxvwGABhKzG0AgG2t3B9VHjTB9fnz5+fnP/95brzxxkyYMKGnffz48eno6Mj69et7/ep6W1tbdt11136to6urO11d3dusZqqjs7MrmzYVP4nu7OxKd5Lu7s3Pke7u7s3ay22r5P3dKb39pWrtqy8AMLC4XgMAQ4m5DQAw1JjfAABDibkNAFBt9bUuYEu6u7szf/78/PSnP83111+ft73tbb1e33///dPQ0JDFixf3tK1YsSLPPfdcDjzwwCpXCwAAAAAAAAAAAADAmw34X1yfN29efvzjH+df/uVfsuOOO2b16tVJktGjR2f77bfP6NGjc/zxx2fBggUZO3Zsdtppp3zlK19Jc3Oz4DoAAAAAAAAAAAAAwAAw4IPrt9xyS5LkxBNP7NV+0UUX5bjjjkuSnHvuuamvr88ZZ5yR9vb2zJ49O3Pnzq16rQAAAAAAAAAAAAAAbG7AB9dbW1u32Ge77bbL3LlzhdUBAAAAAAAAAAAAAAag+loXAAAAAAAAAAAAAADA0Ca4DgAAAAAAAAAAAABAoQTXAQAAAAAAAAAAAAAo1MhaFwBsvc7OTWltXbZZe2vrsnR31aAgAAAAAAAAAAAAAChBcB0GsXWrV+aOZzdmz2fqerWvWLo4EybPqFFVAAAAAAAAAAAAANCb4DoMcuN2m5SJk6b2amtb9UxtigEAAAAAAAAAAACAEuprXQAAAAAAAAAAAAAAAEOb4DoAAAAAAAAAAAAAAIUSXAcAAAAAAAAAAAAAoFCC6wAAAAAAAAAAAAAAFEpwHQAAAAAAAAAAAACAQgmuAwAAAAAAAAAAAABQKMF1AAAAAAAAAAAAAAAKJbgOAAAAAAAAAAAAAEChBNcBAAAAAAAAAAAAACiU4DoAAAAAAAAAAAAAAIUSXAcAAAAAAAAAAAAAoFCC6wAAAAAAAAAAAAAAFEpwHQAAAAAAAAAAAACAQgmuAwAAAAAAAAAAAABQKMF1AAAAAAAAAAAAAAAKJbgOAAAAAAAAAAAAAEChBNcBAAAAAAAAAAAAACiU4DoAAAAAAAAAAAAAAIUSXAcAAAAAAAAAAAAAoFCC6wAAAAAAAAAAAAAAFEpwHQAAAAAAAAAAAACAQgmuAwAAAAAAAAAAAABQqJG1LgCojs7OTWltXbZZ+7Rp09PY2FiDigAAAAAAAAAAAAAYLgTXYZhYt3pl7nh2Y/Z8pq6nre35p3PmSUlz88G1KwwAAAAAAAAAAACAIU9wHYaRcbtNysRJU2tdBgAAAAAAAAAAAADDTH2tCwAAAAAAAAAAAAAAYGgTXAcAAAAAAAAAAAAAoFCC6wAAAAAAAAAAAAAAFEpwHQAAAAAAAAAAAACAQgmuAwAAAAAAAAAAAABQKMF1AAAAAAAAAAAAAAAKJbgOAAAAAAAAAAAAAEChBNcBAAAAAAAAAAAAACiU4DoAAAAAAAAAAAAAAIUSXAcAAAAAAAAAAAAAoFCC6wAAAAAAAAAAAAAAFEpwHQAAAAAAAAAAAACAQgmuAwAAAAAAAAAAAABQKMF1AAAAAAAAAAAAAAAKJbgOAAAAAAAAAAAAAEChBNcBAAAAAAAAAAAAACiU4DoAAAAAAAAAAAAAAIUSXAcAAAAAAAAAAAAAoFCC6wAAAAAAAAAAAAAAFEpwHQAAAAAAAAAAAACAQgmuAwAAAAAAAAAAAABQKMF1AAAAAAAAAAAAAAAKJbgOAAAAAAAAAAAAAEChBNcBAAAAAAAAAAAAACiU4DoAAAAAAAAAAAAAAIUSXAcAAAAAAAAAAAAAoFCC6wAAAAAAAAAAAAAAFEpwHQAAAAAAAAAAAACAQo2sdQEAAAAAAINBe3t7WlqWlHxt2rTpaWxsrHJFAFunr/FsOIxl1RzLh/N+BgAAAIBSBNcBAAAAAMrQ0rIkl113T5omTu7V3vb80znzpKS5+eDaFAbQT6XGs+EyllVzLB/O+xkAAAAAShFcBwAAAAAoU9PEyZk4aWqtywCo2HAez6q57cN5PwMAAADAm9XXugAAAAAAAAAAAAAAAIY2wXUAAAAAAAAAAAAAAAo1stYFALXT2bkpra3LSr42bdr0NDY2VrkiAAAAAADoW3t7e1palpR8zXPt2ujrmDgeg5PPGAAAAFAkwXUYxtatXpk7nt2YPZ+p69Xe9vzTOfOkpLn54NoUBgAAAAAAJbS0LMll192TpomTe7V7rl07pY6J4zF4+YwBAAAARRJch2Fu3G6TMnHS1FqXAQAAAAAAZWmaONlz7QHGMRlaHE8AAACgKPW1LgAAAAAAAAAAAAAAgKFNcB0AAAAAAAAAAAAAgEKNrHUBAAAAAAAMLe3t7WlpWbJZ+7Rp09PY2FiDioDBqNRY0tq6LN1dm/ft7NyU1tZlm7Ubd9gapc69ESPqc8QRh9eoIgAAAIChQXAdAAAAAIBtqqVlSS677p40TZzc09b2/NM586Skufng2hUGDCqlxpIVSxdnwuQZm/Vdt3pl7nh2Y/Z8pq6nzbjD1ip17q1d9UzGjBmVffbZr4aVAQAAAAxugusAAAAAAGxzTRMnZ+KkqbUuAxjk3jyWtK16ps++43abZNxhm3nzuVf3Fn0BAAAAKE99rQsAAAAAAAAAAAAAAGBoE1wHAAAAAAAAAAAAAKBQI2tdAAxE7e3taWlZ0quttXVZurtqVBAAAABAgUo9C3nDtGnT09jYWOWKAKi2zs5NaW1dtll7udeBvq4lriNb1p/rsP289ao53xmKx6nSMQIAAAAgEVyHklpaluSy6+5J08TJPW0rli7OhMkzalgVAAAAQDFKPQtJkrbnn86ZJyXNzQfXpjAAqmbd6pW549mN2fOZup62/lwHSl1LXEfK05/rsP289ao53xmKx6nSMQIAAAAgEVyHPjVNnJyJk6b2/N226pnaFQMAAABQsDc/CwFg+Bm326SKrgWuJVuvP/vOft561dx3Q/E4VTpGAAAAANTXugAAAAAAAAAAAAAAAIY2wXUAAAAAAAAAAAAAAAo1stYFAMNDe3t7WlqWbNY+bdr0NDY21qAiAAAAoEjt7e35f//vf9LZ2bXZa9v6eUB/njuU27dUv9bWZenefHPS2bkpra3Lylp/ufV3dHQkSRoaGrZqmeXqa38Usa5qGYrbxOBQxLlX6TL7en9f49mb9TW+lRqjyl3mQFVqW6s1Ftea5/fl6ezclF//+tdZv37jZvMb+wooQjXnFrW+5g2Wa9FgrzMZeLWy9QbL+QgA8GaC60BVtLQsyWXX3ZOmiZN72tqefzpnnpQ0Nx9cu8IAAACAQjz++OO55Dv/nl0m/Emv9iKeB/TnuUO5fUv1W7F0cSZMnrHZ+tetXpk7nt2YPZ+p2+L6y61/xdIHst2O47Ln5Hdu1TLLVWrdRa2rWobiNjE4FHHuVbrMvt7f13j2ZqXGtz+8f/MxqtxlDlSltrVaY3GteX5fnhdXr8x3f/x69pj0Wrr/qN2+AopSzblFra95g+VaNJjrTAZmrWy9wXI+AgC8meA6UDVNEydn4qSptS4DAAAAqJKmCX+SCVV6FtCf5w7l9n1zv7ZVz/TZd9xukyp67lFqXaNG71qVZylD8ZnNUNwmBocizr1Kl1nq/W81nr1ZqfGt1BjVn2UOVG/e1mqOxbVm3CzPLru/PRPf/s50d3dvuTPANlCtucVAuOYNlmuROhlIHGcAYDCqr3UBAAAAAAAAAAAAAAAMbYLrAAAAAAAAAAAAAAAUamStCwCGnvb29rS0LOnV1tq6LN1dNSoIAACghFL3Lm+YNm16Ghsbq1zR4NLX/hto+26w1MnQ09m5Ka2ty3q1dXR0JEkaGhp6tVfruUmlz2xKvb/W2zRYDPdrzmAZi/uqs9R5Xqqtr/O+P+PBQNsnRRiKn4e+tqnUOVHqfKh0zCy1zKT0/iz3WtDXMvtz7pdS7njQn2tOqfdXUxHHtFLl7r9Kj2elBuL1oT81DcT6h7NqXl8Gy7Gv5ne2lYzv/amr0utDrY9df+ovt6Yi7vP6s36g+obiPRUAw4vgOrDNtbQsyWXX3ZOmiZN72lYsXZwJk2fUsCoAAIDeSt27JEnb80/nzJOS5uaDa1PYIFFq/w3EfTdY6mToWbd6Ze54dmP2fKaup23F0gey3Y7jsufkd/bqW63nJpU+syn9/tpu02Ax3K85g2Us7us4lTrPS7eVPu/LHQ8G4j4pwlD8PPR97mx+TpQ+HyobM0sts6/9We61oNQy/9C3/HO/lHLHg/5cc2p97hRxTCtV7v6r9HgWUWetj2d/ahqI9Q9n1by+DJZjX83vbCsZ3/tTV6XXh1ofu3Lr709NRdznDcTzGfg/Q/GeCoDhRXAdKETTxMmZOGlqz99tq56pXTEAAAB9ePO9C/0zWPbfYKmToWfcbpM2ez4yavSum52P1XxuUukzm1Lvr/U2DRbDfSwaLNtfqs5S53lfbX0pdzwYLgbL+dAffZ07pZQ6Hyr15mW+lXKvBaWW2d9zv5z196fOgfq5KeKYVqqc/bctjmelBuJ40J+aBmL9w1k1j8dgOfbV/M52a8f3pH91VXp9qPWxK+L6tq3v84CBz+cWgMGsvtYFAAAAAAAAAAAAAAAwtAmuAwAAAAAAAAAAAABQKMF1AAAAAAAAAAAAAAAKNbLWBQADT2fnprS2LuvV1tHRkSRpaGh4y7YkaW1dlu6urVt3e3t7WlqWbNbe17qmTZuexsbGLb6/VF8AKFdf1xfXFoDaGk7z/1LbWu59Un+W2Z/3l1LqfrKvZVa6/nL3Sal71L7qLLX+as0D+nM/3J9jX8l+Srb+GcGIEfVZufLpdHd3b77QEvpzjld6nMvtW8nzjWrqz7lT622q9JlTpeNepYoYi4uoqT/rL3ebKh13+vMZLXf9g+ncGc76M74OlrG4mnUOln1SSn+uw0UodyxKqrefy70O9tVere9pitKfY1Lu+5Py5u997adS7y9lIJ7PlZ47SWX3D0Wcu5Uusz+f8aQ6937VfG5R6WeskvX0ta5Kx9fBch3sz7OQSpdZy/u8or7HL2KuXsR9Uqn3V/ospz/Xp2p9xvsyEO+HS6n0mpnU7tlgrQ33Z+3J0NvO/rBP2JLhNEZQHUMquH7TTTdl0aJFWb16daZOnZovfelLOeCAA2pdFgw661avzB3Pbsyez9T1tK1Y+kC223Fc9pz8zrds+0P74kyYPGOr1t3SsiSXXXdPmiZOftMyN19X2/NP58yTkubmg7f4/lJ9AaBcpa4vri0AtTec5v+ltrXc+6T+LLPSfVfqfrKvZVa6/nL3Sal71FJ19rX+as0D+nM/3J9jX8l+Srb+GUFdkqd//WB2/5Pyns2VW2d/6u/rOJfbt5LnG9XUv3OntttU+TOnysa9ShUxFhdRUzFjaaXjTn8+o+WtfzCdO8NZf8bXwTIWV7POwbJPSunPdbgI5Y5FfdVaRJ3lXgf7aq/W9zRF6c8xKff95c7f+9pP5V4LBub5XNm5U/n9w7Y/dytfZvmf8Wrd+1XzuUWln7FK1tPXuiodXwfLdbA/z0IqWWZS2/u8or7HL2KuXsR9UqXb1J9xr/zrW/U+DwPxfriUSq+ZtXw2WGvD/Vn7UNzO/rBP2JLhNEZQHUMmuH733Xfnoosuyrx58zJjxoxcf/31mTNnTu655540NTXVujwYdMbtNikTJ03t+btt1TMZNXrXLba90V6JpomTSy6z1LrKfT8AVMr1BWBgGk7j85u3tT/3SeUuc1t48/1kkesvZ5/0dY9azTrLVe79cH+PfSX7Kdm6ZwR1dXV5cfWzZdXXnzr7W3+p41xu30qfb1RTf86dWqv0mVOl416lihiLt3VNlb6/qHGnlL4+o+Wsf7CdO8NZf8bXwTIWV7POwbJPSunPdbgI5Y5FSfX2cznXwb7aq/k9TVH6c0zKeX9/1lPpdWAgns+VnDuVrquIc3dbLLMv5d7/FXHvV83nFpV+xrZ2PW+1rkrH18FyHezPM4ZKllnr+7wivscvaq6+re+T+tOv0nGv3HVV+/MwEO+HS6nkmlnuMoeq4bKdyfDa1nLZJ2yJc4Rtqb7WBWwr1157bf7yL/8yxx9/fPbZZ5/Mmzcv22+/fW6//fZalwYAAAAAAAAAAAAAMKwNieB6e3t7WlpaMmvWrJ62+vr6zJo1K48++mgNKwMAAAAAAAAAAAAAYGStC9gWXnzxxXR2dqapqalXe1NTU1asWFH2curr61JfX7ety6MgI0bU9/r3tl722lXP5I/Phpfans9rr72WVTvu2KtvqfZy2yp9/0CsqT991656JsuX9z6Gy5e3brbvt8X7S/UFgHKVur5s62tLfX1ddtpp+7z88mvp6ureJssEGOoqnf8PpvuHUrWWe5/Un2VW+v7+1FSt9ffnfrbc+8wizpH+3A9Xup+r8oygLlm3+rk0vPpqdthhh17LLHc/1/q5xVB8llLE56HW+7maz4cqGfeqWVO1xtIBN+70c5nV/DwV8RmvdL4zXMbSah3nWl8fBstntD+19ueaU7Vr1trn097+erbffvukeyveP0jOnUqPXV+qdf9Q63OnWvcKRVxz+rOuWp971Rp3ijgf32q5b9af9xdx7AbifKnW9/hFjGXV/DxUsk+K+h6/iLG0iOM8WO7H+7Od/fleqoj1F6GI63i1ng32RxHPGAbTs/JKDcRjWmv2CVvyVmPEiBHvzMiRzhP6p667u3vQp2J+//vf58/+7M9y6623prm5uaf9a1/7Wh555JF8//vfr2F1AAAAAAAAAAAAAADD25D4Tx3GjRuXESNGpK2trVd7W1tbxo8fX6OqAAAAAAAAAAAAAABIhkhwvbGxMdOmTcvixYt72rq6urJ48eJev8AOAAAAAAAAAAAAAED1jax1AdvKySefnM9//vPZf//9c8ABB+T666/Pxo0bc9xxx9W6NAAAAAAAAAAAAACAYW3IBNePPvrorF27NpdffnlWr16dd77znfn2t7+d8ePH17o0AAAAAAAAAAAAAIBhra67u7u71kUAAAAAAAAAAAAAADB01de6AAAAAAAAAAAAAAAAhjbBdQAAAAAAAAAAAAAACiW4DgAAAAAAAAAAAABAoQTXAQAAAAAAAAAAAAAolOA6g9JNN92U97znPZk+fXo+8pGP5Iknnqh1SQAAeeSRR3Laaadl9uzZmTJlSu69995er3d3d+ef//mfM3v27BxwwAE56aST8swzz/Tqs27dupx11lk56KCD8q53vSvnnntuXnnllV59li1blo997GOZPn16jjzyyFxzzTVFbxoAMAxdffXVOf7449Pc3JyZM2fm05/+dFasWNGrz+uvv5558+blsMMOS3Nzcz772c9mzZo1vfo899xzOfXUUzNjxozMnDkzX/3qV7Np06ZefR566KEce+yx2X///XPUUUfljjvuKHz7AIDh5eabb84xxxyTgw46KAcddFD+6q/+Kvfff3/P6+Y1AMBg9q1vfStTpkzJBRdc0NNmfgMADESC6ww6d999dy666KJ85jOfyZ133pmpU6dmzpw5aWtrq3VpAMAw9+qrr2bKlCmZO3duydevueaa3HDDDfnyl7+c2267LaNGjcqcOXPy+uuv9/Q5++yz89vf/jbXXnttvvnNb+ZXv/pV/vEf/7Hn9Zdffjlz5szJHnvskTvuuCPnnHNOvvGNb+R73/te4dsHAAwvDz/8cE444YTcdtttufbaa7Np06bMmTMnr776ak+fCy+8MPfdd18WLlyYG264IS+88EJOP/30ntc7OzvzqU99Kh0dHbn11luzYMGC3Hnnnbn88st7+vzud7/Lpz71qRx22GH513/913zyk5/M+eefn1/+8pdV3V4AYGibMGFCzj777Nxxxx25/fbbc/jhh+czn/lMli9fnsS8BgAYvJ544onceuutmTJlSq928xsAYCCq6+7u7q51EdAfH/nIRzJ9+vSeAFdXV1eOPPLInHjiiTn11FNrXB0AwB9MmTIlV155Zd773vcm+cOvrR9xxBE5+eSTM2fOnCTJhg0bMmvWrCxYsCAf/OAH89RTT+Xoo4/OD37wg0yfPj1J8otf/CKnnnpq7r///uy+++65+eabs3DhwvzXf/1XGhsbkyQXX3xx7r333txzzz212VgAYFhYu3ZtZs6cmRtvvDGHHHJINmzYkJkzZ+biiy/OBz7wgSTpmc9873vfy4EHHpj7778/p512Wn75y19m/PjxSZJbbrklF198cRYvXpzGxsZ8/etfz/33358f//jHPes688wzs379+ixatKgm2woADA+HHnpoPve5z+UDH/iAeQ0AMCi98sorOe644zJ37txcddVVmTp1as477zzPbQCAAcsvrjOotLe3p6WlJbNmzeppq6+vz6xZs/Loo4/WsDIAgLe2cuXKrF69utc8ZvTo0ZkxY0bPPObRRx/NmDFjekLrSTJr1qzU19fniSeeSJI89thjede73tUTWk+S2bNn5+mnn85LL71Upa0BAIajDRs2JEnGjh2bJFm6dGk6Ojp6zW/23nvv7LHHHnnssceS/GHusu+++/Z8+Zn8Ye7y8ssv57e//W1Pn5kzZ/Za1+zZs3uWAQCwrXV2duauu+7Kq6++mubmZvMaAGDQmj9/fo488she85jEcxsAYOAaWesCoD9efPHFdHZ2pqmpqVd7U1NTVqxYUaOqAAC2bPXq1UlSch6zZs2aJMmaNWuyyy679Hp95MiRGTt2bM/716xZk7322qtXnzceKK5Zs6YnSAYAsC11dXXlwgsvzEEHHZR99903yR/mHg0NDRkzZkyvvk1NTb3mLn/85Wfyf3OXLfV5+eWX89prr2X77bcvZJsAgOGntbU1H/3oR/P6669nhx12yJVXXpl99tknTz75pHkNADDo3HXXXfn1r3+dH/zgB5u95rkNADBQCa4DAAAAAG9p3rx5Wb58eW6++eZalwIAsNUmT56cH/7wh9mwYUP+4z/+I5///Odz44031rosAIB+e/7553PBBRfkO9/5TrbbbrtalwMAULb6WhcA/TFu3LiMGDEibW1tvdrb2to2+y88AQAGkl133TVJ3nIeM378+Kxdu7bX65s2bcpLL73U8/7x48f3/EL7G97423wIACjC/Pnz8/Of/zzXX399JkyY0NM+fvz4dHR0ZP369b36t7W1lTV32VKfnXbaya92AQDbVGNjY97+9rdn//33z1lnnZWpU6fmu9/9rnkNADDotLS0pK2tLccdd1z222+/7Lfffnn44Ydzww03ZL/99jO/AQAGLMF1BpXGxsZMmzYtixcv7mnr6urK4sWL09zcXMPKAADe2l577ZVdd9211zzm5ZdfzuOPP94zj2lubs769euzdOnSnj4PPvhgurq6csABByRJDjzwwPzqV79KR0dHT58HHnggkydPztixY6u0NQDAcNDd3Z358+fnpz/9aa6//vq87W1v6/X6/vvvn4aGhl7zmxUrVuS5557LgQcemOQPc5ff/OY3vf7jvQceeCA77bRT9tlnn54+Dz74YK9lP/DAAz3LAAAoSldXV9rb281rAIBB5/DDD8+PfvSj/PCHP+z5Z//9988xxxzT87/NbwCAgUhwnUHn5JNPzm233ZY777wzTz31VL785S9n48aNOe6442pdGgAwzL3yyit58skn8+STTyZJVq5cmSeffDLPPfdc6urq8olPfCJXXXVVfvazn6W1tTXnnHNOdtttt7z3ve9Nkuy999454ogj8qUvfSlPPPFE/ud//if/9E//lA9+8IPZfffdkyTHHHNMGhoact5552X58uW5++67893vfjcnn3xyzbYbABia5s2bl3/7t3/LJZdckh133DGrV6/O6tWr89prryVJRo8eneOPPz4LFizIgw8+mKVLl+bcc89Nc3Nzz5eXs2fPzj777JNzzjkny5Ytyy9/+cssXLgwJ5xwQhobG5MkH/3oR/O73/0uX/va1/LUU0/lpptuyr//+7/npJNOqtGWAwBD0SWXXJJHHnkkK1euTGtray655JI8/PDDOeaYY8xrAIBBZ6eddsq+++7b658ddtghO++8c/bdd1/zGwBgwKrr7u7urnUR0F833nhjFi1alNWrV+ed73xnzj///MyYMaPWZQEAw9xDDz2UT3ziE5u1H3vssVmwYEG6u7tz+eWX57bbbsv69etz8MEHZ+7cuZk8eXJP33Xr1uWf/umf8p//+Z+pr6/P+973vpx//vnZcccde/osW7Ys8+fPz5IlSzJu3Lh8/OMfz6mnnlqVbQQAho8pU6aUbL/ooot6fkDg9ddfz4IFC3LXXXelvb09s2fPzty5c3v+76ST5H//93/z5S9/OQ8//HBGjRqVY489NmeddVZGjhzZ0+ehhx7KRRddlN/+9reZMGFCPv3pT/uRAgBgmzr33HPz4IMP5oUXXsjo0aMzZcqUnHLKKXn3u9+dxLwGABj8TjzxxEydOjXnnXdeEvMbAGBgElwHAAAAAAAAAAAAAKBQ9bUuAAAAAAAAAAAAAACAoU1wHQAAAAAAAAAAAACAQgmuAwAAAAAAAAAAAABQKMF1AAAAAAAAAAAAAAAKJbgOAAAAAAAAAAAAAEChBNcBAAAAAAAAAAAAACiU4DoAAAAAAAAAAAAAAIUSXAcAAAAAAAAAAAAAoFCC6wAAAAAAMETce++9mTJlSlauXFnrUgAAAAAAoBfBdQAAAAAAAAAAAAAACiW4DgAAAAAAAAAAAABAoQTXAQAAAACgDMuXL88pp5ySww47LDNmzMj73//+XHPNNUmSL3zhC/nQhz6U+++/Px/60Icyffr0HHfccXnsscc2W84dd9yRY445JtOnT88RRxyRyy67LJ2dnb36rFq1KmeffXYOO+ywHHDAATnhhBOydOnSXn06OjpywQUX5NBDD83BBx+cc889N6+88kqvPg899FCmTJmSJUuW9Gr/9Kc/nRNPPLHn7yuuuCLNzc154okn8uEPfzjTp0/PX/zFX+S+++6rZJcBAAAAAEAPwXUAAAAAACjDaaedlvXr1+eCCy7I1VdfnTlz5mTjxo09r69evTrz5s3LnDlzsnDhwjQ2NmbOnDlpa2vr6XPttdfm/PPPz+zZs/PNb34zp5xySr773e/msssu6+nz0ksv5WMf+1iWLVuWL33pS7niiisyatSofPKTn+y1rEsvvTS33HJLz/q6urpyySWXbPX2dXR05Mwzz8yxxx6bb3zjG3n729+e008/Pa2trVu9TAAAAAAAeMPIWhcAAAAAAAAD3dq1a7Ny5cqcd955ec973pMkOfzww3v1WbduXRYuXJiZM2cmSQ499NAceeSRue6663LWWWfl5ZdfzuWXX56/+Zu/yT/8wz8kSd797nenoaEhCxYsyJw5czJu3Lhcf/31Wb9+fb7//e+nqakpSTJz5sy8//3vz6JFi3LOOedk3bp1ufnmm3PKKafkU5/6VJLkiCOOyMc//vH8/ve/36pt7OjoyN/+7d/mwx/+cJJk9uzZed/73perr746l1566VYtEwAAAAAA3uAX1wEAAAAAYAvGjRuXPffcM5deemnuvPPOrFq1arM+o0eP7gmtv/H3rFmz8vjjjydJHn300bz66qv5wAc+kE2bNvX8M2vWrLz22mtZvnx5kuS///u/c9hhh2Xs2LE9ferr63PIIYdkyZIlSZLf/OY3ee2113LUUUf1quF973tfRdv5x8sbMWJE3vve9/bUDwAAAAAAlfCL6wAAAAAAsAV1dXVZtGhRLrvsssyfPz+vvvpqpk2bli9+8Ys55JBDkiS77LLLZu9ramrKU089lSR58cUXkyTHHntsyXU8//zzPf0ee+yxTJs2bbM+kyZNSpKsXr26Z/l/bPz48VuzeUmShoaGjB07drP631gXAAAAAABUQnAdAAAAAADKMHny5Fx++eXp6OjIo48+mksvvTSnnXZafvGLXyRJ1q5du9l72trasuuuuyZJTyj8G9/4RiZMmLBZ37322qun3xFHHJG/+7u/26xPY2NjkvQss62tLbvvvnvP62vWrOnVf7vttkuSdHR09Gpfv3596urqerV1dHTkpZde6hVe/+P6AQAAAACgEvW1LgAAAAAAAAaThoaGHHrooTn11FPz8ssv54UXXkiSbNiwIYsXL+7pt2HDhjzwwAOZMWNGkqS5uTmjRo3KqlWrMn369M3+GTduXJJk1qxZeeqpp7L33ntv1mfKlClJkn333Tfbb799fvrTn/aq7Sc/+Umvv98IyL/xq+/JHwL2LS0tJbftj5fX2dmZe++9t6d+AAAAAACohF9cBwAAAACALVi2bFm++tWv5uijj87b3va2vPzyy7n66quz5557ZtKkSUmSnXfeOeedd17OOOOMjB49Otdcc026u7vzyU9+MkkyZsyYnHHGGfn617+eVatW5dBDD82IESPyu9/9Lj/72c9yxRVXZNSoUTnppJPyox/9KB//+MfziU98InvssUfWrl2bxx9/PLvvvntOOumk7LzzzvnoRz+aa665Jttvv33222+/3HXXXXn22Wd71T1hwoTMmDEjV155ZUaPHp2RI0fmmmuuyejRozfbxoaGhlx11VV5/fXXs9dee+WWW27JqlWrcuWVVxa/gwEAAAAAGPIE1wEAAAAAYAt23XXXjB8/PldffXV+//vfZ/To0XnXu96Vr3/96xkxYkRPn7PPPjtf+9rX8uyzz+ZP//RPs2jRoowfP75nOX/913+d3XffPddee21uvPHGjBw5MpMmTcqf//mfp6GhIUkybty4fO9738vChQtz8cUXZ926dWlqasqMGTNy1FFH9SzrrLPOSmdnZ7797W+nq6srRx11VM4666ycc845vWq/+OKLc/755+eLX/xixo8fn7//+7/PXXfdlQ0bNvTq19DQkEsvvTTz5s3Lb37zm+y11165/PLLM3Xq1KJ2KwAAAAAAw0hdd3d3d62LAAAAAACAwewLX/hCli5dmh//+Me1LmWrXHHFFfnOd76TRx99tNalAAAAAAAwRNXXugAAAAAAAAAAAAAAAIY2wXUAAAAAAAAAAAAAAApV193d3V3rIgAAAAAAAAAAAAAAGLr84joAAAAAAAAAAAAAAIUSXAcAAAAAAAAAAAAAoFCC6wAAAAAAAAAAAAAAFEpwHQAAAAAAAAAAAACAQgmuAwAAAAAAAAAAAABQKMF1AAAAAAAAAAAAAAAKJbgOAAAAAAAAAAAAAEChBNcBAAAAAAAAAAAAACiU4DoAAAAAAAAAAAAAAIX6/wCvcooGPahAcQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(30, 8))\n", + "sns.histplot(speedups, bins=500, ax=ax)\n", + "ax.set_xlabel('speedup')\n", + "ax.set_title(\"VinDr-CXR Sample of 1000\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3889c981-5684-4f1f-beca-4e99a36995ee", + "metadata": {}, + "outputs": [], + "source": [ + "speedups.plot.hist" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/scripts/pyprocs.py b/scripts/pyprocs.py new file mode 100644 index 0000000..78b7998 --- /dev/null +++ b/scripts/pyprocs.py @@ -0,0 +1,15 @@ +import multiprocessing +import time + +def func(xs): + time.sleep(1) + return [x*x for x in xs] + +def main(): + xs = list(range(100)) + with multiprocessing.Pool(16) as p: + ys = p.starmap(func, [(xs[i::16],) for i in range(16)]) + print(ys) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scripts/skm_tea_to_dimble.py b/scripts/skm_tea_to_dimble.py deleted file mode 100644 index 46c7e48..0000000 --- a/scripts/skm_tea_to_dimble.py +++ /dev/null @@ -1,24 +0,0 @@ -from pathlib import Path - -import plac -from tqdm import tqdm - -import dimble - - -@plac.annotations( - skm_tea_dicom_path=("Path to SKM-TEA DICOM directory", "positional", None, Path), - skm_tea_dimble_path=("Path to SKM-TEA DIMBLE directory", "positional", None, Path), -) -def main(skm_tea_dicom_path: Path, skm_tea_dimble_path: Path): - dicom_files = list(skm_tea_dicom_path.glob("**/*.dcm")) - for dicom_file in tqdm(dicom_files): - dimble_file = skm_tea_dimble_path / dicom_file.relative_to( - skm_tea_dicom_path - ).with_suffix(".dimble") - dimble_file.parent.mkdir(parents=True, exist_ok=True) - dimble.dicom_to_dimble(dicom_file, dimble_file) - - -if __name__ == "__main__": - plac.call(main) From eb7de0fa80258bf8b68e606b0b2ea6cf57eb1729 Mon Sep 17 00:00:00 2001 From: Chris Ayling <100549942+StrongChris@users.noreply.github.com> Date: Thu, 18 May 2023 15:51:19 +1000 Subject: [PATCH 07/11] Create .gitattributes --- .gitattributes | 1 + 1 file changed, 1 insertion(+) create mode 100644 .gitattributes diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..32edcfd --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +*.ipynb -linguist-detectable From fb548698271f8c3a17e106a5eda70236c2c3e6d9 Mon Sep 17 00:00:00 2001 From: strongchris Date: Thu, 25 May 2023 04:03:52 +0000 Subject: [PATCH 08/11] make conversion scripts nice, clean up code --- README.md | 2 +- dimble/__init__.py | 5 +- scripts/brats_to_dimble.py | 25 -------- scripts/dicom_to_dimble.py | 51 +++++++++++---- scripts/dicom_vs_dimble.py | 42 +++++++++---- scripts/pyprocs.py | 7 ++- scripts/to_dimble.py | 69 +++++++++++++++++++++ scripts/vs_dimble.py | 120 ++++++++++++++++++++++++++++++++++++ setup.py | 1 + test/pydicom_comparisons.py | 55 ++++++++++------- 10 files changed, 302 insertions(+), 75 deletions(-) delete mode 100644 scripts/brats_to_dimble.py create mode 100644 scripts/to_dimble.py create mode 100644 scripts/vs_dimble.py diff --git a/README.md b/README.md index 978a29c..338d1fc 100644 --- a/README.md +++ b/README.md @@ -51,7 +51,7 @@ dimble.dicom_to_dimble('xray.dicom', 'xray.dimble') dataset = dimble.load_dimble('xray.dimble', fields=["7FE00010"], device="cpu") # load a dimble file's pixel data sliced to a 224x224 chunk offset by 100 in each dimension -dataset = dimble.load_dimble('xray.dimble', fields=["7FE00010"], device="cpu", slices=[slice(100:100+224), slice(100:100+224)]) +dataset = dimble.load_dimble('xray.dimble', fields=["7FE00010"], device="cpu", slices=[slice(100,100+224), slice(100,100+224)]) # convert back to dicom dimble.dimble_to_dicom("xray.dimble", "xray.dicom") diff --git a/dimble/__init__.py b/dimble/__init__.py index d561b79..b7c8507 100644 --- a/dimble/__init__.py +++ b/dimble/__init__.py @@ -5,8 +5,9 @@ dimble_to_nifti, load_dimble, nifti_to_dimble, - rglob_dicom + rglob_dicom, ) + rglob_dicom __all__ = [ @@ -16,5 +17,5 @@ "nifti_to_dimble", "dimble_to_nifti", "_create_temp_dir", - "rglob_dicom" + "rglob_dicom", ] diff --git a/scripts/brats_to_dimble.py b/scripts/brats_to_dimble.py deleted file mode 100644 index 6557d78..0000000 --- a/scripts/brats_to_dimble.py +++ /dev/null @@ -1,25 +0,0 @@ -# ruff: noqa: E501 -from pathlib import Path - -import plac -from tqdm import tqdm - -import dimble - - -@plac.annotations( - brats_nifti_dir=("Path to BRATS NIFTI directory", "positional", None, Path), - brats_dimble_dir=("Path to BRATS DIMBLE directory", "positional", None, Path), -) -def main(brats_nifti_dir: Path, brats_dimble_dir: Path): - # traverse brats dir and convert all nifti files to dimble and save them with same structure in dimble dir - for nifti_file in tqdm(list(brats_nifti_dir.glob("**/*.nii.gz"))): - dimble_file = brats_dimble_dir / nifti_file.relative_to( - brats_nifti_dir - ).with_suffix(".dimble") - dimble_file.parent.mkdir(parents=True, exist_ok=True) - dimble.nifti_to_dimble(nifti_file, dimble_file) - - -if __name__ == "__main__": - plac.call(main) diff --git a/scripts/dicom_to_dimble.py b/scripts/dicom_to_dimble.py index 5b537b2..ad5b56b 100644 --- a/scripts/dicom_to_dimble.py +++ b/scripts/dicom_to_dimble.py @@ -1,30 +1,59 @@ -from pathlib import Path from multiprocessing import Pool +from pathlib import Path import plac from tqdm import tqdm import dimble -def convert(dicom_dir: Path, dicom_files: list[Path], dimble_dir: Path): + +def convert( + dicom_dir: Path, dicom_files: list[Path], dimble_dir: Path +) -> list[tuple[Path, Path]]: + errors = [] + mappings = [] for dicom_file in tqdm(dicom_files): - dimble_file = dimble_dir / dicom_file.relative_to( - dicom_dir - ).with_suffix(".dimble") - if dimble_file.exists(): - continue - dimble_file.parent.mkdir(parents=True, exist_ok=True) - dimble.dicom_to_dimble(dicom_file, dimble_file) + try: + dimble_file = dimble_dir / dicom_file.relative_to(dicom_dir).with_suffix( + ".dimble" + ) + if dimble_file.exists(): + mappings.append((dicom_file, dimble_file)) + continue + dimble_file.parent.mkdir(parents=True, exist_ok=True) + dimble.dicom_to_dimble(dicom_file, dimble_file) + mappings.append((dicom_file, dimble_file)) + except: + dimble_file.unlink(missing_ok=True) + errors.append(dicom_file) + print(f"Worker finished with {errors=}", flush=True) + return mappings + + +def flatten(l): + return [item for sublist in l for item in sublist] + @plac.annotations( dicom_path=("Path to DICOM directory", "positional", None, Path), dimble_path=("Path to DIMBLE directory", "positional", None, Path), ) def main(dicom_path: Path, dimble_path: Path): - dicom_files = list(dicom_path.glob("**/*.dcm")) + list(dicom_path.glob("**/*.dicom")) + list(dicom_path.glob("**/*.DCM")) + dicom_files = ( + list(dicom_path.glob("**/*.dcm")) + + list(dicom_path.glob("**/*.dicom")) + + list(dicom_path.glob("**/*.DCM")) + ) # convert(dicom_path, dicom_files, dimble_path) with Pool(16) as p: - p.starmap(convert, [(dicom_path, dicom_files[i::16], dimble_path) for i in range(16)]) + mappings = p.starmap( + convert, [(dicom_path, dicom_files[i::16], dimble_path) for i in range(16)] + ) + mappings = flatten(mappings) + with open(str(dicom_path).replace("/", "_") + ".csv", "w") as f: + for mapping in mappings: + f.write(str(mapping[0]) + ", " + str(mapping[1]) + "\n") + if __name__ == "__main__": plac.call(main) diff --git a/scripts/dicom_vs_dimble.py b/scripts/dicom_vs_dimble.py index 583cbaf..2ace7ad 100644 --- a/scripts/dicom_vs_dimble.py +++ b/scripts/dicom_vs_dimble.py @@ -1,10 +1,11 @@ # ruff: noqa: E501 +import json import time from pathlib import Path from typing import Optional -import json import numpy as np +import pandas as pd import plac import pydicom import torch @@ -13,7 +14,9 @@ import dimble -def dimble_loading(dimble_files, cuda=False, verbose=True) -> list[int]: +def dimble_loading( + dimble_files, cuda=False, verbose=True +) -> tuple[list[Path], list[int]]: times = [] for file in tqdm(dimble_files, desc="DIMBLE", disable=not verbose): start_time = time.perf_counter() @@ -26,7 +29,9 @@ def dimble_loading(dimble_files, cuda=False, verbose=True) -> list[int]: return times -def dicom_loading(dicom_files, cuda=False, verbose=True) -> list[int]: +def dicom_loading( + dicom_files, cuda=False, verbose=True +) -> tuple[list[Path], list[int]]: times = [] for file in tqdm(dicom_files, desc="DICOM", disable=not verbose): start_time = time.perf_counter() @@ -39,20 +44,31 @@ def dicom_loading(dicom_files, cuda=False, verbose=True) -> list[int]: times.append(elapsed_time) return times + +def prepare_paths(mappings_file: Path, n: int) -> tuple[list[Path], list[Path]]: + df = pd.read_csv(mappings_file, header=None).iloc[:n] + dicom_paths = df[0].apply(lambda p: Path(p.strip())).to_list() + dimble_paths = df[1].apply(lambda p: Path(p.strip())).to_list() + return dicom_paths, dimble_paths + + @plac.annotations( - dicom_dir=("Path to DICOM directory", "positional", None, Path), - dimble_dir=("Path to DIMBLE directory", "positional", None, Path), + # dicom_dir=("Path to DICOM directory", "positional", None, Path), + # dimble_dir=("Path to DIMBLE directory", "positional", None, Path), + mappings_file=("Path to mappings file", "positional", None, Path), n=("Number of files to load", "option", "n", int), cuda=("Use CUDA", "flag", "c", bool), ) -def main(dicom_dir: Path, dimble_dir: Path, n: Optional[int], cuda: bool = False): +def main(mappings_file: Path, n: Optional[int], cuda: bool = False): + # def main(dicom_dir: Path, dimble_dir: Path, n: Optional[int], cuda: bool = False): if n is None: n = -1 - dicom_files = dimble.rglob_dicom(dicom_dir)[:n] - dimble_files = list(dimble_dir.rglob("*.dimble"))[:n] - assert len(dimble_files) == len( - dicom_files - ), "Number of files in DICOM and DIMBLE directories must match" + dicom_files, dimble_files = prepare_paths(mappings_file, n) + # dicom_files = dimble.rglob_dicom(dicom_dir)[:n] + # dimble_files = list(dimble_dir.rglob("*.dimble"))[:n] + # assert len(dimble_files) == len( + # dicom_files + # ), "Number of files in DICOM and DIMBLE directories must match" print("Loading", len(dicom_files), "files") # warmup @@ -84,13 +100,13 @@ def main(dicom_dir: Path, dimble_dir: Path, n: Optional[int], cuda: bool = False ) print(f"DIMBLE is {dicom_elapsed/dimble_elapsed:.2f}x faster than DICOM") - with open("/tmp/dicom_vs_dimble_timings.json", 'w') as f: + with open("/tmp/dicom_vs_dimble_timings.json", "w") as f: json.dump( { "dicom_times": dicom_times, "dimble_times": dimble_times, }, - f + f, ) diff --git a/scripts/pyprocs.py b/scripts/pyprocs.py index 78b7998..b106cf2 100644 --- a/scripts/pyprocs.py +++ b/scripts/pyprocs.py @@ -1,9 +1,11 @@ import multiprocessing import time + def func(xs): time.sleep(1) - return [x*x for x in xs] + return [x * x for x in xs] + def main(): xs = list(range(100)) @@ -11,5 +13,6 @@ def main(): ys = p.starmap(func, [(xs[i::16],) for i in range(16)]) print(ys) + if __name__ == "__main__": - main() \ No newline at end of file + main() diff --git a/scripts/to_dimble.py b/scripts/to_dimble.py new file mode 100644 index 0000000..4bd93b4 --- /dev/null +++ b/scripts/to_dimble.py @@ -0,0 +1,69 @@ +from multiprocessing import Pool +from pathlib import Path + +import plac +from tqdm import tqdm + +import dimble + +converters = {"dicom": dimble.dicom_to_dimble, "nifti": dimble.nifti_to_dimble} + + +def convert( + input_dir: Path, input_files: list[Path], dimble_dir: Path +) -> list[tuple[Path, Path]]: + errors = [] + mappings = [] + for input_file in tqdm(input_files): + name = input_file.name + if name.endswith(".nii.gz"): + converter = converters["nifti"] + else: + converter = converters["dicom"] + try: + dimble_file = dimble_dir / input_file.relative_to(input_dir).with_suffix( + ".dimble" + ) + if dimble_file.exists(): + mappings.append((input_file, dimble_file)) + continue + dimble_file.parent.mkdir(parents=True, exist_ok=True) + converter(input_file, dimble_file) + mappings.append((input_file, dimble_file)) + except: + dimble_file.unlink(missing_ok=True) + errors.append(input_file) + print(f"Worker finished with {errors=}", flush=True) + return mappings + + +def get_input_files(input_path: Path, extensions: list[str]) -> list[Path]: + input_files = [] + for extension in extensions: + files = list(input_path.glob(f"**/*.{extension}")) + input_files.extend(files) + return input_files + + +def flatten(l): + return [item for sublist in l for item in sublist] + + +@plac.pos("input_path", "Path to DICOM or NiFTI directory", type=Path) +@plac.pos("dimble_path", "Path to DIMBLE directory", type=Path) +def main(input_path: Path, dimble_path: Path): + extensions = ["dcm", "dicom", "DCM", "nii.gz"] + input_files = get_input_files(input_path, extensions) + + with Pool(16) as p: + mappings = p.starmap( + convert, [(input_path, input_files[i::16], dimble_path) for i in range(16)] + ) + mappings = flatten(mappings) + with open(str(input_path).replace("/", "_") + ".csv", "w") as f: + for mapping in mappings: + f.write(str(mapping[0]) + ", " + str(mapping[1]) + "\n") + + +if __name__ == "__main__": + plac.call(main) diff --git a/scripts/vs_dimble.py b/scripts/vs_dimble.py new file mode 100644 index 0000000..69d85ba --- /dev/null +++ b/scripts/vs_dimble.py @@ -0,0 +1,120 @@ +# ruff: noqa: E501 +import json +import time +from pathlib import Path +from typing import Callable, Optional + +import numpy as np +import pandas as pd +import plac +import pydicom +import SimpleITK as sitk +import torch +from tqdm import tqdm + +import dimble + + +def dimble_loader(file: Path, task: str) -> torch.Tensor: + match task: + case "load": + return dimble.load_dimble(file, ["7FE00010"])["7FE00010"] + case "sum": + data = dimble.load_dimble(file, ["7FE00010"])["7FE00010"] + return data.sum() + case "rrc_sum": + return dimble.load_dimble( + file, ["7FE00010"], slices=[slice(0, 224), slice(0, 224)] + )["7FE00010"].sum() + raise ValueError + + +def dicom_loader(file: Path, task: str) -> torch.Tensor: + data = pydicom.dcmread(str(file)) + data = torch.from_numpy(data.pixel_array.astype(np.int32)) + + match task: + case "load": + return data + case "sum": + return data.sum() + case "rrc_sum": + return data[..., :224, :224].sum() + raise ValueError + + +def nifti_loader(file: Path, task) -> torch.Tensor: + data = sitk.ReadImage(str(file)) + data = sitk.GetArrayFromImage(data) + data = torch.from_numpy(data.astype(np.int32)) + + match task: + case "load": + return data + case "sum": + return data.sum() + case "rrc_sum": + return data[..., :224, :224].sum() + raise ValueError + + +loaders = {"dimble": dimble_loader, "dicom": dicom_loader, "nifti": nifti_loader} + + +def file_loading( + loader: Callable[[Path, str], torch.Tensor], + task: str, + files: list[Path], + cuda=False, + verbose=True, + desc=None, +) -> list[int]: + times = [] + for file in tqdm(files, desc=desc, disable=not verbose): + start_time = time.perf_counter() + data = loader(file, task) + if cuda: + data = data.cuda() + + end_time = time.perf_counter() + elapsed_time = end_time - start_time + times.append(elapsed_time) + return times + + +def prepare_paths(mappings_file: Path, n: int) -> tuple[list[Path], list[Path]]: + df = pd.read_csv(mappings_file, header=None).iloc[:n] + original_paths = df[0].apply(lambda p: Path(p.strip())).to_list() + dimble_paths = df[1].apply(lambda p: Path(p.strip())).to_list() + return original_paths, dimble_paths + + +@plac.pos("mode", "DICOM or NIfTI", choices=["dicom", "nifti"]) +@plac.pos("mappings_file", "Path to mappings file", type=Path) +@plac.opt("n", "Number of files to load", type=int) +@plac.flg("cuda", "Use CUDA") +def main(mode, mappings_file: Path, n: Optional[int], cuda: bool = False): + if n is None: + n = -1 + original_files, dimble_files = prepare_paths(mappings_file, n) + print("Loading", len(original_files), "files") + + original_loader = loaders[mode] + + tasks = ["load", "sum", "rrc_sum"] + + timings_dict: dict[str, list[float]] = {} + for name, loader, files in [ + ("original", original_loader, original_files), + ("dimble", dimble_loader, dimble_files), + ]: + for task in tasks: + timings = file_loading(loader, task, files, cuda=cuda, verbose=False) + timings_dict[f"{name}-{task}"] = timings + + with open(f"{mappings_file.stem}_timings.json", "w") as f: + json.dump(timings_dict, f, indent=2) + + +if __name__ == "__main__": + plac.call(main) diff --git a/setup.py b/setup.py index aece290..4ae14f1 100644 --- a/setup.py +++ b/setup.py @@ -16,6 +16,7 @@ "msgpack", "python-gdcm", "SimpleITK", + "pytest-benchmark", ], extras_require={"dev": ["black", "flake8", "isort", "pytest"]}, tests_require=["pytest"], diff --git a/test/pydicom_comparisons.py b/test/pydicom_comparisons.py index 1880153..8ea41b8 100644 --- a/test/pydicom_comparisons.py +++ b/test/pydicom_comparisons.py @@ -1,13 +1,14 @@ import json +import os import tempfile from pathlib import Path -import os +import gdcm import numpy as np import pydicom -import SimpleITK as sitk -import gdcm import pytest +import SimpleITK as sitk + import dimble PIXEL_ARRAY = "7FE00010" @@ -47,58 +48,66 @@ DIMBLE_FILES = {} + def convert_to_dimble(dicom_file: Path): dimble_file = Path("/tmp") / dicom_file.with_suffix(".dimble").name if not dimble_file.exists(): dimble.dicom_to_dimble(str(dicom_file), str(dimble_file)) DIMBLE_FILES[dicom_file] = dimble_file + for dicom_file in dicom_files: convert_to_dimble(dicom_file) print("dimble_files", DIMBLE_FILES) + def pydicom_to_numpy(dicom_file: Path): ds = pydicom.dcmread(dicom_file) pixel_array = ds.pixel_array return pixel_array.sum() + def sitk_to_numpy(dicom_file: Path): ds = sitk.ReadImage(str(dicom_file)) pixel_array = sitk.GetArrayFromImage(ds) return pixel_array.sum() + def _get_gdcm_to_numpy_typemap(): """Returns the GDCM Pixel Format to numpy array type mapping.""" - _gdcm_np = {gdcm.PixelFormat.UINT8 :np.uint8, - gdcm.PixelFormat.INT8 :np.int8, - #gdcm.PixelFormat.UINT12 :numpy.uint12, - #gdcm.PixelFormat.INT12 :numpy.int12, - gdcm.PixelFormat.UINT16 :np.uint16, - gdcm.PixelFormat.INT16 :np.int16, - gdcm.PixelFormat.UINT32 :np.uint32, - gdcm.PixelFormat.INT32 :np.int32, - #gdcm.PixelFormat.FLOAT16:numpy.float16, - gdcm.PixelFormat.FLOAT32:np.float32, - gdcm.PixelFormat.FLOAT64:np.float64 } + _gdcm_np = { + gdcm.PixelFormat.UINT8: np.uint8, + gdcm.PixelFormat.INT8: np.int8, + # gdcm.PixelFormat.UINT12 :numpy.uint12, + # gdcm.PixelFormat.INT12 :numpy.int12, + gdcm.PixelFormat.UINT16: np.uint16, + gdcm.PixelFormat.INT16: np.int16, + gdcm.PixelFormat.UINT32: np.uint32, + gdcm.PixelFormat.INT32: np.int32, + # gdcm.PixelFormat.FLOAT16:numpy.float16, + gdcm.PixelFormat.FLOAT32: np.float32, + gdcm.PixelFormat.FLOAT64: np.float64, + } return _gdcm_np + def _get_numpy_array_type(gdcm_pixel_format): """Returns a numpy array typecode given a GDCM Pixel Format.""" return _get_gdcm_to_numpy_typemap()[gdcm_pixel_format] def _gdcm_to_numpy(image): - """Converts a GDCM image to a numpy array. - """ + """Converts a GDCM image to a numpy array.""" pf = image.GetPixelFormat() - assert pf.GetScalarType() in _get_gdcm_to_numpy_typemap().keys(), \ - "Unsupported array type %s"%pf + assert pf.GetScalarType() in _get_gdcm_to_numpy_typemap().keys(), ( + "Unsupported array type %s" % pf + ) shape = image.GetDimension(0) * image.GetDimension(1), pf.GetSamplesPerPixel() if image.GetNumberOfDimensions() == 3: - shape = shape[0] * image.GetDimension(2), shape[1] + shape = shape[0] * image.GetDimension(2), shape[1] dtype = _get_numpy_array_type(pf.GetScalarType()) gdcm_array = image.GetBuffer() @@ -106,6 +115,7 @@ def _gdcm_to_numpy(image): result.shape = shape return result + def gdcm_to_numpy(dicom_file: Path): reader = gdcm.ImageReader() reader.SetFileName(str(dicom_file)) @@ -114,7 +124,7 @@ def gdcm_to_numpy(dicom_file: Path): gdcm_array = image.GetBuffer() return gdcm_array - + def dimble_to_numpy(dicom_file: Path): dimble_file = DIMBLE_FILES[dicom_file] ds = dimble.load_dimble(str(dimble_file), fields=[PIXEL_ARRAY]) @@ -126,14 +136,17 @@ def dimble_to_numpy(dicom_file: Path): def test_pydicom_read(dicom_file: Path, benchmark): benchmark(pydicom_to_numpy, dicom_file) + @pytest.mark.parametrize("dicom_file", dicom_files, ids=dicom_files_ids) def test_sitk_read(dicom_file: Path, benchmark): benchmark(sitk_to_numpy, dicom_file) + @pytest.mark.parametrize("dicom_file", dicom_files, ids=dicom_files_ids) def test_gdcm_read(dicom_file: Path, benchmark): benchmark(gdcm_to_numpy, dicom_file) + @pytest.mark.parametrize("dicom_file", dicom_files, ids=dicom_files_ids) def test_dimble_read(dicom_file: Path, benchmark): - benchmark(dimble_to_numpy, dicom_file) \ No newline at end of file + benchmark(dimble_to_numpy, dicom_file) From d62bb88f38b33ac4afaff7cb61448de427a68921 Mon Sep 17 00:00:00 2001 From: Jake Goulding Date: Thu, 25 May 2023 00:13:26 -0400 Subject: [PATCH 09/11] First round of feedback for idiomatic Rust review (#12) * Use `fs::read` instead of manual implementation * Remove unneeded `File::try_clone` Immutable references to `File` can also be written to. * Remove unneeded `Cursor` References to `&[u8]` implement the needed `Read` and `Write` traits. * Use iterator methods to prepare dimble fields * Remove unneeded variables and types * Avoid creating Strings for two ASCII characters * Decode directly to desired type instead of going through `Value` * Reduce code duplication for converting integers * Coalesce panic and print statements * Use Iterator methods to build a new vector * Remove unneeded variable * Avoid checking the type twice * Use `unwrap_or_else` instead of manual matching * Extract duplicated calls to `set_item` * Simplify header length and data parsing * Use the header length constant in more places Since we use it as a `usize` some places, and a `u64` others, I changed the base type to a `u8`, which is large enough to represent the 8 bytes needed. This allows us to losslessly convert to a those two larger types. * Merge import statements * Demonstrate one way to create Rust errors and integrate with Python While it's possible to create your error types by hand, I like to use my library [SNAFU][snafu] to help with some of the boilerplate. There are other popular libraries such as `thiserror` or `anyhow` as well. I demonstrate a few facets of the crate here: 1. Creating opaque errors that do not expose internal details. Here, `ir_to_dimble::Error` wraps `ir_to_dimble::InnerError` and hides details except for the causal chain and error text. This is good for public APIs where you should be mindful of semver concerns. 2. Localized errors that compose into larger ones. `ir_to_dimble::SerialiseFieldsError` only deals with the ways that `serialise_dimble_fields` can fail and helps you avoid repetition and keep the scope a little tighter. I also followed PyO3's example and implemented a conversion from the Rust error to a `PyErr`, going through the existing `DimbleError`. This is a very basic implementation; a better one would expose the causal chain as a Python exception chain and potentially even have a traceback including Rust code. [snafu]: https://docs.rs/snafu/ * Remove unneeded ownership * Remove unneeded explicit types * DRY up repeated unwraps * DRY up repeated code --- Cargo.toml | 1 + src/dicom_json.rs | 30 ++++- src/dimble_to_ir.rs | 142 +++++++++--------------- src/ir_to_dimble.rs | 262 ++++++++++++++++++++++++++++---------------- src/lib.rs | 126 ++++++++++----------- 5 files changed, 310 insertions(+), 251 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 8f7149a..d36dcf4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -18,4 +18,5 @@ rmpv = "1.0.0" safetensors = "0.3.0" serde = { version = "1.0.156", features = ["derive"] } serde_json = "1.0.94" +snafu = { version = "0.7.4", features = ["rust_1_61", "backtraces-impl-std"] } \ No newline at end of file diff --git a/src/dicom_json.rs b/src/dicom_json.rs index 253e902..93a2561 100644 --- a/src/dicom_json.rs +++ b/src/dicom_json.rs @@ -1,6 +1,8 @@ use serde::{Deserialize, Serialize}; use std::collections::HashMap; +use crate::ir_to_dimble::VR; + pub type DicomJsonData = HashMap; #[derive(Serialize, Deserialize, Debug, PartialEq)] @@ -24,8 +26,34 @@ pub struct DicomField { #[serde(rename = "Value")] #[serde(skip_serializing_if = "Option::is_none")] pub value: Option>, - pub vr: String, + #[serde(with = "vr_serialization")] + pub vr: VR, #[serde(rename = "InlineBinary")] #[serde(skip_serializing_if = "Option::is_none")] pub inline_binary: Option, } + +mod vr_serialization { + use serde::{ + de::Error as _, ser::Error as _, Deserialize, Deserializer, Serialize, Serializer, + }; + use std::borrow::Cow; + + use super::VR; + + pub fn serialize(value: &VR, serializer: S) -> Result + where + S: Serializer, + { + let value = std::str::from_utf8(value).map_err(S::Error::custom)?; + value.serialize(serializer) + } + + pub fn deserialize<'de, D>(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let value = >::deserialize(deserializer)?; + value.as_bytes().try_into().map_err(D::Error::custom) + } +} diff --git a/src/dimble_to_ir.rs b/src/dimble_to_ir.rs index 45b0fca..f1f329a 100644 --- a/src/dimble_to_ir.rs +++ b/src/dimble_to_ir.rs @@ -1,9 +1,8 @@ use crate::dicom_json::*; use crate::ir_to_dimble::{HeaderField, HeaderFieldMap}; use memmap2::MmapOptions; -use rmpv::{decode, Value}; +use rmpv::{decode, Integer, Value}; use std::fs; -use std::io::Cursor; fn headerfield_and_bytes_to_dicom_fields( tag: &str, @@ -11,142 +10,109 @@ fn headerfield_and_bytes_to_dicom_fields( dimble_buffer: &[u8], ) -> DicomField { match header_field { - HeaderField::Empty(vr) => { - let vr = String::from_utf8(vr.to_vec()).unwrap(); - DicomField { - value: None, - vr, - inline_binary: None, - } - } + HeaderField::Empty(vr) => DicomField { + value: None, + vr: *vr, + inline_binary: None, + }, HeaderField::SQ(sqs) => { let seq_fields = sqs .iter() - .map(|sq| { - let mut sq_data: DicomJsonData = DicomJsonData::new(); - for (tag, header_field) in sq.iter() { - let field: DicomField = - headerfield_and_bytes_to_dicom_fields(tag, header_field, dimble_buffer); - sq_data.insert(tag.to_string(), field); - } - DicomValue::SeqField(sq_data) - }) + .map(|sq| DicomValue::SeqField(headers_to_data(sq, dimble_buffer))) .collect::>(); DicomField { value: Some(seq_fields), - vr: "SQ".to_string(), + vr: *b"SQ", inline_binary: None, } } HeaderField::Deffered(field_pos, field_length, vr) => { - let vr = String::from_utf8(vr.to_vec()).expect("expected vr to be utf8"); // inline_binary VRs are OB and OW. TODO support the other inline binary VRs - let field_pos: usize = (*field_pos as usize) + 8; + let field_pos = (*field_pos as usize) + 8; let field_length = *field_length as usize; let field_bytes = &dimble_buffer[field_pos..field_pos + field_length]; - let dicom_field: DicomField = match vr.as_str() { - "OB" | "OW" => { - let inline_binary: String = match tag { + match vr { + b"OB" | b"OW" => { + let inline_binary = match tag { "7FE00010" => { // Pixel Data "TODO encode pixel data correctly".to_string() } - _ => { - let mut cursor = Cursor::new(field_bytes); - let v = decode::read_value(&mut cursor).unwrap(); - v.as_str().unwrap().to_string() - } + _ => rmp_serde::decode::from_slice(field_bytes).unwrap(), }; DicomField { value: None, - vr, + vr: *vr, inline_binary: Some(inline_binary), } } - "PN" => { - let mut cursor = Cursor::new(field_bytes); - let v = decode::read_value(&mut cursor).unwrap(); - let name = match v { - Value::String(s) => s.into_str().unwrap(), - _ => panic!("expected string"), - }; + b"PN" => { + let name = rmp_serde::decode::from_slice(field_bytes).unwrap(); let a = DicomValue::Alphabetic(Alphabetic { alphabetic: name }); DicomField { value: Some(vec![a]), - vr, + vr: *vr, inline_binary: None, } } _ => { - let mut cursor = Cursor::new(field_bytes); + let mut cursor = field_bytes; let v = decode::read_value(&mut cursor).unwrap(); - let value: Vec = match v { + let value: Vec<_> = match v { Value::String(s) => vec![DicomValue::String(s.into_str().unwrap())], - Value::Integer(i) => { - if i.is_i64() { - vec![DicomValue::Integer(i.as_i64().unwrap())] - } else { - vec![DicomValue::Integer(i.as_u64().unwrap() as i64)] - } - } + Value::Integer(i) => vec![integer_to_dicom_value(&i)], Value::F64(f) => vec![DicomValue::Float(f)], - Value::Array(a) => { - let mut values = Vec::new(); - for v in a { - match v { - Value::String(s) => { - values.push(DicomValue::String(s.into_str().unwrap())) - } - Value::Integer(i) => { - if i.is_i64() { - values.push(DicomValue::Integer(i.as_i64().unwrap())) - } else { - values.push(DicomValue::Integer( - i.as_u64().unwrap() as i64 - )) - } - } - Value::F64(f) => values.push(DicomValue::Float(f)), - _ => { - println!("unexpected value type: {:?}", v); - panic!("unexpected value type") - } - }; - } - values - } - _ => { - println!("unexpected value type: {:?}", v); - panic!("unexpected value type") - } + Value::Array(a) => a + .into_iter() + .map(|v| match v { + Value::String(s) => DicomValue::String(s.into_str().unwrap()), + Value::Integer(i) => integer_to_dicom_value(&i), + Value::F64(f) => DicomValue::Float(f), + _ => panic!("unexpected value type: {v:?}"), + }) + .collect(), + _ => panic!("unexpected value type: {v:?}"), }; DicomField { value: Some(value), - vr, + vr: *vr, inline_binary: None, } } - }; - dicom_field + } } } } +fn headers_to_data(sq: &HeaderFieldMap, dimble_buffer: &[u8]) -> DicomJsonData { + sq.iter() + .map(|(tag, header_field)| { + let tag = tag.to_string(); + let field = headerfield_and_bytes_to_dicom_fields(&tag, header_field, dimble_buffer); + (tag, field) + }) + .collect() +} + +fn integer_to_dicom_value(i: &Integer) -> DicomValue { + if let Some(v) = i.as_i64() { + DicomValue::Integer(v) + } else if let Some(v) = i.as_u64() { + DicomValue::Integer(v as i64) + } else { + panic!("Could not represent the integer as i64 or u64") + } +} + pub fn dimble_to_dicom_json(dimble_path: &str, json_path: &str) { let dimble_file = fs::File::open(dimble_path).unwrap(); let dimble_buffer = unsafe { MmapOptions::new().map(&dimble_file).expect("mmap failed") }; let (header, header_len) = deserialise_header(&dimble_buffer); - let mut json_dicom = DicomJsonData::new(); - - for (tag, header_field) in header.iter() { - let field: DicomField = - headerfield_and_bytes_to_dicom_fields(tag, header_field, &dimble_buffer[header_len..]); - json_dicom.insert(tag.to_string(), field); - } + let json_dicom = headers_to_data(&header, &dimble_buffer[header_len..]); let json_file = fs::File::create(json_path).unwrap(); serde_json::to_writer_pretty(json_file, &json_dicom).unwrap(); // TODO don't write pretty (this is for debugging) @@ -154,7 +120,7 @@ pub fn dimble_to_dicom_json(dimble_path: &str, json_path: &str) { fn deserialise_header(buffer: &[u8]) -> (HeaderFieldMap, usize) { let header_len = u64::from_le_bytes(buffer[0..8].try_into().unwrap()) as usize; - let header: HeaderFieldMap = + let header = rmp_serde::from_slice(&buffer[8..8 + header_len]).expect("failed to deserialise header"); (header, header_len) } diff --git a/src/ir_to_dimble.rs b/src/ir_to_dimble.rs index 944ae43..4c581a4 100644 --- a/src/ir_to_dimble.rs +++ b/src/ir_to_dimble.rs @@ -1,14 +1,15 @@ use rmp_serde::{to_vec, Serializer}; use serde::{Deserialize, Serialize}; -use std::collections::HashMap; -use std::fs; -use std::io::{BufReader, Write}; +use snafu::prelude::*; +use std::{ + collections::HashMap, + fs, + io::{prelude::*, BufReader, SeekFrom, Write}, +}; use crate::dicom_json::*; -use std::io::prelude::*; -use std::io::SeekFrom; -type VR = [u8; 2]; // TODO use newtype pattern? +pub(crate) type VR = [u8; 2]; // TODO use newtype pattern? #[derive(Debug, Serialize, Deserialize)] pub enum HeaderField { @@ -27,18 +28,15 @@ fn extend_and_make_field(data_bytes: &mut Vec, field_bytes: &[u8], vr: VR) - pub type HeaderFieldMap = HashMap; fn get_file_bytes(safetensors_path: &str) -> Vec { - let mut f = fs::File::open(safetensors_path).unwrap(); - let mut buffer = Vec::new(); - f.read_to_end(&mut buffer).unwrap(); - buffer + fs::read(safetensors_path).unwrap() } fn dicom_values_to_vec(tag: &str, dicom_values: &[DicomValue]) -> Option> { let field_bytes = match dicom_values { - [DicomValue::String(s)] => to_vec(&s).unwrap(), - [DicomValue::Integer(u)] => to_vec(&u).unwrap(), - [DicomValue::Float(u)] => to_vec(&u).unwrap(), - [DicomValue::Alphabetic(u)] => to_vec(&u.alphabetic).unwrap(), + [DicomValue::String(s)] => to_vec(&s), + [DicomValue::Integer(u)] => to_vec(&u), + [DicomValue::Float(u)] => to_vec(&u), + [DicomValue::Alphabetic(u)] => to_vec(&u.alphabetic), many => match many .first() .expect("This should definitely have a first element") @@ -51,8 +49,7 @@ fn dicom_values_to_vec(tag: &str, dicom_values: &[DicomValue]) -> Option _ => panic!("{tag} expected only strings"), }) .collect::>(), - ) - .unwrap(), + ), DicomValue::Integer(_) => to_vec( &many .iter() @@ -61,8 +58,7 @@ fn dicom_values_to_vec(tag: &str, dicom_values: &[DicomValue]) -> Option _ => panic!("{tag} expected only ints"), }) .collect::>(), - ) - .unwrap(), + ), DicomValue::Float(_) => to_vec( &many .iter() @@ -71,8 +67,7 @@ fn dicom_values_to_vec(tag: &str, dicom_values: &[DicomValue]) -> Option _ => panic!("{tag} expected only floats"), }) .collect::>(), - ) - .unwrap(), + ), DicomValue::SeqField(_) => { // TODO: handle sequences of sequences properly return None; @@ -80,6 +75,7 @@ fn dicom_values_to_vec(tag: &str, dicom_values: &[DicomValue]) -> Option other => panic!("{tag} unexpected value type {:?}", other), }, }; + let field_bytes = field_bytes.unwrap(); Some(field_bytes) } @@ -87,14 +83,16 @@ fn prepare_dimble_fields( dicom_fields: &DicomJsonData, data_bytes: &mut Vec, pixel_array_safetensors_path: Option<&str>, -) -> HeaderFieldMap { - let mut header_field_map: HeaderFieldMap = HeaderFieldMap::new(); - for (tag, dicom_field) in dicom_fields.iter() { - let header_field: HeaderField = - prepare_dimble_field(tag, dicom_field, data_bytes, pixel_array_safetensors_path); - header_field_map.insert(tag.to_owned(), header_field); - } - header_field_map +) -> InnerResult { + dicom_fields + .iter() + .map(|(tag, dicom_field)| { + Ok(( + tag.to_owned(), + prepare_dimble_field(tag, dicom_field, data_bytes, pixel_array_safetensors_path)?, + )) + }) + .collect() } fn prepare_dimble_field( @@ -102,7 +100,7 @@ fn prepare_dimble_field( dicom_field: &DicomField, data_bytes: &mut Vec, pixel_array_safetensors_path: Option<&str>, -) -> HeaderField { +) -> InnerResult { match dicom_field { DicomField { value: Some(value), @@ -110,23 +108,22 @@ fn prepare_dimble_field( inline_binary: None, } => { match value.as_slice() { - [] if vr == "SQ" => HeaderField::SQ(vec![]), + [] if vr == b"SQ" => Ok(HeaderField::SQ(vec![])), [] => panic!("empty value"), [DicomValue::SeqField(seq)] => { let sq_header_field_map = - prepare_dimble_fields(seq, data_bytes, pixel_array_safetensors_path); - HeaderField::SQ(vec![sq_header_field_map]) + prepare_dimble_fields(seq, data_bytes, pixel_array_safetensors_path)?; + Ok(HeaderField::SQ(vec![sq_header_field_map])) } dicom_values => { // call a function to handle this match dicom_values_to_vec(tag, dicom_values) { Some(field_bytes) => { - let vr = vr.as_bytes().try_into().unwrap(); - extend_and_make_field(data_bytes, &field_bytes, vr) + Ok(extend_and_make_field(data_bytes, &field_bytes, *vr)) } None => { // TODO this is kind of a hack for gracefully not handling sequences of sequences - HeaderField::Empty(vr.as_bytes().try_into().unwrap()) + Ok(HeaderField::Empty(*vr)) } } } @@ -136,7 +133,7 @@ fn prepare_dimble_field( value: None, vr, inline_binary: None, - } => HeaderField::Empty(vr.as_bytes().try_into().unwrap()), + } => Ok(HeaderField::Empty(*vr)), DicomField { value: None, vr, @@ -147,81 +144,163 @@ fn prepare_dimble_field( pixel_array_safetensors_path.expect("expected pixel_array_safetensors_path"), ); // data_bytes.extend(field_bytes); - let vr = vr.as_bytes().try_into().unwrap(); - extend_and_make_field(data_bytes, &field_bytes, vr) + Ok(extend_and_make_field(data_bytes, &field_bytes, *vr)) } _ => { let field_bytes = to_vec(&inline_binary).unwrap(); - let vr = vr.as_bytes().try_into().unwrap(); - extend_and_make_field(data_bytes, &field_bytes, vr) + Ok(extend_and_make_field(data_bytes, &field_bytes, *vr)) } }, DicomField { value: Some(_), vr: _vr, inline_binary: Some(_), - } => panic!("value and inline binary both present"), + } => ValueAndInlineBinaryBothPresentSnafu.fail(), } } fn prepare_dicom_fields_for_serialisation( dicom_json_data: DicomJsonData, pixel_array_safetensors_path: Option<&str>, -) -> (HeaderFieldMap, Vec) { - let mut data_bytes: Vec = Vec::new(); +) -> InnerResult<(HeaderFieldMap, Vec)> { + let mut data_bytes = Vec::new(); let header_fields = prepare_dimble_fields( &dicom_json_data, &mut data_bytes, pixel_array_safetensors_path, - ); + )?; + + Ok((header_fields, data_bytes)) +} + +pub(crate) const HEADER_LENGTH_LENGTH: u8 = std::mem::size_of::() as u8; + +fn serialise_dimble_fields( + header_fields: HeaderFieldMap, + data_bytes: &[u8], + dimble_path: &str, +) -> Result<(), SerialiseFieldsError> { + use serialise_fields_error::*; + + let mut file = + fs::File::create(dimble_path).context(CouldNotCreateFileSnafu { dimble_path })?; + file.seek(SeekFrom::Start(HEADER_LENGTH_LENGTH.into())) + .context(CouldNotSkipHeaderLengthSnafu)?; + // leave room for header length field - (header_fields, data_bytes) + let mut serialiser = Serializer::new(&file).with_struct_map(); + header_fields + .serialize(&mut serialiser) + .context(CouldNotSerializeHeadersSnafu)?; + + let end_of_headers = file + .stream_position() + .context(CouldNotQueryStreamPositionSnafu)?; + let header_len = end_of_headers - u64::from(HEADER_LENGTH_LENGTH); + file.seek(SeekFrom::Start(0)) + .context(CouldNotSeekToStartSnafu)?; + file.write_all(&header_len.to_le_bytes()) + .context(CouldNotWriteHeaderLengthSnafu)?; + file.seek(SeekFrom::Start(end_of_headers)) + .context(CouldNotSeekToEndOfHeadersSnafu)?; + + file.write_all(data_bytes).context(CouldNotWriteDataSnafu) } -fn serialise_dimble_fields(header_fields: HeaderFieldMap, data_bytes: Vec, dimble_path: &str) { - let mut file = fs::File::create(dimble_path).unwrap(); - let mut file_copy = file.try_clone().unwrap(); // copy this because rust complains about borrowing file twice - file.seek(SeekFrom::Start(8)).unwrap(); // move 8 bytes forward to make room for header length (u64) - let mut serialiser = Serializer::new(file).with_struct_map(); +#[derive(Debug, Snafu)] +#[snafu(module)] +#[allow(clippy::enum_variant_names)] +pub enum SerialiseFieldsError { + CouldNotCreateFile { + source: std::io::Error, + dimble_path: String, + }, + + CouldNotSkipHeaderLength { + source: std::io::Error, + }, + + CouldNotSerializeHeaders { + source: rmp_serde::encode::Error, + }, + + CouldNotQueryStreamPosition { + source: std::io::Error, + }, + + CouldNotSeekToStart { + source: std::io::Error, + }, + + CouldNotWriteHeaderLength { + source: std::io::Error, + }, - header_fields.serialize(&mut serialiser).unwrap(); - let header_len: u64 = file_copy.stream_position().unwrap() - 8; // (u64) TODO maybe make a less magical number - file_copy.seek(SeekFrom::Start(0)).unwrap(); - file_copy.write_all(&header_len.to_le_bytes()).unwrap(); - file_copy.seek(SeekFrom::Start(8 + header_len)).unwrap(); + CouldNotSeekToEndOfHeaders { + source: std::io::Error, + }, - let mut inner = serialiser.into_inner(); - inner.write_all(&data_bytes).unwrap(); + CouldNotWriteData { + source: std::io::Error, + }, } +#[derive(Debug, Snafu)] +pub enum InnerError { + #[snafu(display("Could not open the path {json_path}"))] + CouldNotOpen { + source: std::io::Error, + json_path: String, + }, + + #[snafu(display("Could not parse the DICOM JSON"))] + FailedToParseJson { source: serde_json::Error }, + + #[snafu(display("DICOM data contains both a value and inline binary"))] + ValueAndInlineBinaryBothPresent, + + #[snafu(display("Could not serialize the fields"))] + SerialiseFields { source: SerialiseFieldsError }, +} + +type InnerResult = std::result::Result; + +#[derive(Debug, Snafu)] +pub struct Error(InnerError); + +type Result = std::result::Result; + pub fn dicom_json_to_dimble( json_path: &str, pixel_array_safetensors_path: Option<&str>, dimble_path: &str, -) { - let json_reader = BufReader::new(fs::File::open(json_path).expect("json_path should exist")); - let json_dicom = deserialise_ir(json_reader); +) -> Result<()> { + let file = fs::File::open(json_path).context(CouldNotOpenSnafu { json_path })?; + let json_reader = BufReader::new(file); + let json_dicom = deserialise_ir(json_reader)?; let (header_fields, data_bytes) = - prepare_dicom_fields_for_serialisation(json_dicom, pixel_array_safetensors_path); + prepare_dicom_fields_for_serialisation(json_dicom, pixel_array_safetensors_path)?; + + serialise_dimble_fields(header_fields, &data_bytes, dimble_path) + .context(SerialiseFieldsSnafu)?; - serialise_dimble_fields(header_fields, data_bytes, dimble_path); + Ok(()) } -fn deserialise_ir(data: impl Read) -> DicomJsonData { - let dicom_json: HashMap = - serde_json::from_reader(data).expect("Failed to parse JSON"); - dicom_json +fn deserialise_ir(data: impl Read) -> InnerResult { + serde_json::from_reader(data).context(FailedToParseJsonSnafu) } #[cfg(test)] mod tests { use super::*; - use std::io::Cursor; + + type Result> = std::result::Result; #[test] - fn test_ir_deserialisation() { + fn test_ir_deserialisation() -> Result { let ir_data = r#" { "00080005": { @@ -252,78 +331,75 @@ mod tests { } "#; - let ir = deserialise_ir(ir_data.as_bytes()); + let ir = deserialise_ir(ir_data.as_bytes())?; { let field = ir.get("00080005").expect("expected 00080005 to exist"); - assert_eq!(field.vr, "CS"); - let value: Vec = field + assert_eq!(field.vr, *b"CS"); + let value: Vec<_> = field .value .iter() .map(|v| match v.as_slice() { - [DicomValue::String(s)] => s.to_owned(), + [DicomValue::String(s)] => s, _ => panic!("expected only strings"), }) .collect(); - assert_eq!(value, vec!["ISO_IR 100".to_owned()]) + assert_eq!(value, ["ISO_IR 100"]) } { let field = ir.get("00080008").expect("expected 00080008 to exist"); - assert_eq!(field.vr, "CS"); - let value: Vec = field + assert_eq!(field.vr, *b"CS"); + let value: Vec<_> = field .value .as_ref() .unwrap() .iter() .map(|v| match v { - DicomValue::String(s) => s.to_owned(), + DicomValue::String(s) => s, _ => panic!("expected only strings"), }) .collect(); - assert_eq!( - value, - vec![ - "ORIGINAL".to_owned(), - "PRIMARY".to_owned(), - "OTHER".to_owned() - ] - ) + assert_eq!(value, ["ORIGINAL", "PRIMARY", "OTHER"]); } { let field = ir.get("00080090").expect("expected 00080090 to exist"); - assert_eq!(field.vr, "PN"); + assert_eq!(field.vr, *b"PN"); assert_eq!(field.value, None); } { let field = ir.get("00100010").expect("expected 00100010 to exist"); - assert_eq!(field.vr, "PN"); - let value: Vec = field + assert_eq!(field.vr, *b"PN"); + let value: Vec<_> = field .value .as_ref() .unwrap() .iter() .map(|v| match v { - DicomValue::Alphabetic(a) => a.alphabetic.to_owned(), + DicomValue::Alphabetic(a) => &a.alphabetic, _ => panic!("expected only alphabetic"), }) .collect(); - assert_eq!(value, vec!["Doe^John".to_owned()]) + assert_eq!(value, ["Doe^John"]) } + + Ok(()) } #[test] - fn test_serialise_dimble_fields() { + fn test_serialise_dimble_fields() -> Result { let mut header_fields = HeaderFieldMap::new(); let vr = b"CS"; header_fields.insert("0008005".to_string(), HeaderField::Deffered(0, 1, *vr)); - let data_bytes = vec![0x42]; + let data_bytes = [0x42]; let dimble_path = "/tmp/test.dimble"; - serialise_dimble_fields(header_fields, data_bytes, dimble_path); + serialise_dimble_fields(header_fields, &data_bytes, dimble_path)?; let file_bytes = fs::read(dimble_path).unwrap(); assert_eq!(file_bytes.last().unwrap(), &0x42); let header_len = u64::from_le_bytes(file_bytes[0..8].try_into().unwrap()) as usize; - let mut cursor = Cursor::new(&file_bytes[8..8 + header_len]); + let mut cursor = &file_bytes[8..8 + header_len]; let _decoded = rmpv::decode::read_value(&mut cursor).unwrap(); + + Ok(()) } } diff --git a/src/lib.rs b/src/lib.rs index 86babfc..5a93bf0 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -17,7 +17,8 @@ use rmpv::Value; use serde::{Deserialize, Serialize}; use std::collections::HashMap; use std::fs::File; -use std::io::Cursor; + +use crate::ir_to_dimble::HEADER_LENGTH_LENGTH; static TORCH_MODULE: GILOnceCell> = GILOnceCell::new(); #[pyfunction] @@ -25,8 +26,9 @@ fn dicom_json_to_dimble( json_path: &str, dimble_path: &str, pixel_array_safetensors_path: Option<&str>, -) { - ir_to_dimble::dicom_json_to_dimble(json_path, pixel_array_safetensors_path, dimble_path); +) -> PyResult<()> { + ir_to_dimble::dicom_json_to_dimble(json_path, pixel_array_safetensors_path, dimble_path) + .map_err(Into::into) } #[pyfunction] @@ -218,8 +220,8 @@ fn value_to_py(py: Python, value: Value) -> PyObject { Value::String(s) => s.into_str().into_py(py), Value::F64(f) => f.into_py(py), Value::Integer(i) => { - if i.is_i64() { - i.as_i64().unwrap().into_py(py) + if let Some(v) = i.as_i64() { + v.into_py(py) } else { i.as_u64().unwrap().into_py(py) } @@ -237,7 +239,7 @@ fn value_to_py(py: Python, value: Value) -> PyObject { fn get_field(py: Python, buffer: &[u8], field_pos: usize, field_length: usize) -> Py { let field_bytes = &buffer[field_pos..field_pos + field_length]; - let mut cursor = Cursor::new(field_bytes); + let mut cursor = field_bytes; let field_value = read_value(&mut cursor).expect("should be valid messagepack"); // TODO better error handling value_to_py(py, field_value) } @@ -254,12 +256,9 @@ fn header_fields_and_buffer_to_pydict( slices: &Option>, ) -> PyResult { let dataset = PyDict::new(py); - let fields = match fields { - Some(fields) => fields, - None => header.keys().map(|k| k.as_str()).collect(), - }; + let fields = fields.unwrap_or_else(|| header.keys().map(|k| k.as_str()).collect()); for field in fields { - match header.get(field) { + let py_field = match header.get(field) { Some(HeaderField::Deffered(field_pos, field_length, _vr)) => { // return the field value @@ -268,29 +267,15 @@ fn header_fields_and_buffer_to_pydict( match field { "7FE00010" => { - let tensor = load_pixel_array( - filename, - field_pos, - field_length, - device, - slices.clone(), - )?; - dataset - .set_item("7FE00010", tensor) - .expect("inserting should work"); - } - _ => { - let py_field = get_field(py, dimble_buffer, field_pos, field_length); - dataset - .set_item(field, py_field) - .expect("inserting should work"); + load_pixel_array(filename, field_pos, field_length, device, slices.clone())? } + _ => get_field(py, dimble_buffer, field_pos, field_length), } } Some(HeaderField::SQ(sq)) => { // return all fields of the sequence (In the future we might support lazy loading of sequence items) let sq = sq.first().expect("sq should have at least one item"); - let sq_dict = header_fields_and_buffer_to_pydict( + header_fields_and_buffer_to_pydict( py, sq, header_len, @@ -300,47 +285,34 @@ fn header_fields_and_buffer_to_pydict( device, slices, ) - .unwrap(); - dataset - .set_item(field, sq_dict) - .expect("inserting should work"); - } - Some(HeaderField::Empty(_vr)) => { - // return None - dataset - .set_item(field, py.None()) - .expect("inserting should work"); - } - None => { - println!("field not found: {}", field); - println!("header: {:?}", header); - panic!("field not found: {}", field); + .unwrap() } - } + Some(HeaderField::Empty(_vr)) => py.None(), + None => panic!("field {field} not found for header {header:?}"), + }; + + dataset + .set_item(field, py_field) + .expect("inserting should work"); } Ok(dataset.into_py(py)) } fn deserialise_dimble_header(buffer: &[u8]) -> Result<(HeaderFieldMap, usize), DimbleError> { // TODO better error handling, this is a mess - let header_len = u64::from_le_bytes( - buffer[0..8] - .try_into() - .map_err(|e| { - DimbleError::new_err(format!( - "safetensors object should have 8 byte header len: {e:?}" - )) - }) - .expect("file should have 8 byte header"), - ) as usize; - let header: HeaderFieldMap = rmp_serde::from_slice(&buffer[8..8 + header_len]) - .map_err(|e| { - DimbleError::new_err(format!( - "safetensors object should have valid header: {e:?}" - )) - }) - .expect("file should have valid header"); + assert!( + buffer.len() >= usize::from(HEADER_LENGTH_LENGTH), + "file should have {HEADER_LENGTH_LENGTH} byte header, is only {}", + buffer.len(), + ); + // TODO: `split_array_ref` when stable + let (header_len, buffer) = buffer.split_at(HEADER_LENGTH_LENGTH.into()); + let header_len = u64::from_le_bytes(header_len.try_into().unwrap()) as usize; + + let header = &buffer[..header_len]; + let header = + rmp_serde::from_slice(header).expect("safetensors object should have valid header"); Ok((header, header_len)) } @@ -384,6 +356,12 @@ pyo3::create_exception!( "Custom Python Exception for Dimble errors." ); +impl From for PyErr { + fn from(value: ir_to_dimble::Error) -> Self { + DimbleError::new_err(snafu::Report::from_error(value).to_string()) + } +} + #[pymodule] fn dimble_rs(py: Python, m: &PyModule) -> PyResult<()> { m.add_wrapped(wrap_pyfunction!(dicom_json_to_dimble))?; @@ -399,6 +377,8 @@ mod tests { use super::*; use std::fs; + type Result> = std::result::Result; + #[test] fn test_load_pixel_array_safetensors() { let path = "testfiles/eye3.safetensors"; @@ -434,7 +414,7 @@ mod tests { } #[test] - fn test_integration_single_string() { + fn test_integration_single_string() -> Result { let dicom_json_text = r#" { "00080005": { @@ -451,7 +431,7 @@ mod tests { fs::write(ir_path, dicom_json_text).expect("should be able to write to file"); - dicom_json_to_dimble(ir_path, dimble_path, None); + dicom_json_to_dimble(ir_path, dimble_path, None)?; dimble_to_dicom_json(dimble_path, ir_recon_path); @@ -461,10 +441,12 @@ mod tests { serde_json::from_reader(recon_json_reader).expect("should be able to read json"); assert_eq!(recon_json["00080005"]["Value"][0], "ISO_IR 100"); assert_eq!(recon_json["00080005"]["vr"], "CS"); + + Ok(()) } #[test] - fn test_integration_string_array() { + fn test_integration_string_array() -> Result { let dicom_json_text = r#" { "00080008": { @@ -483,7 +465,7 @@ mod tests { fs::write(ir_path, dicom_json_text).expect("should be able to write to file"); - dicom_json_to_dimble(ir_path, dimble_path, None); + dicom_json_to_dimble(ir_path, dimble_path, None)?; dimble_to_dicom_json(dimble_path, ir_recon_path); @@ -495,10 +477,12 @@ mod tests { assert_eq!(recon_json["00080008"]["Value"][1], "PRIMARY"); assert_eq!(recon_json["00080008"]["Value"][2], "OTHER"); assert_eq!(recon_json["00080008"]["vr"], "CS"); + + Ok(()) } #[test] - fn test_integration_no_value() { + fn test_integration_no_value() -> Result { let dicom_json_text = r#" { "00080008": { @@ -512,7 +496,7 @@ mod tests { fs::write(ir_path, dicom_json_text).expect("should be able to write to file"); - dicom_json_to_dimble(ir_path, dimble_path, None); + dicom_json_to_dimble(ir_path, dimble_path, None)?; dimble_to_dicom_json(dimble_path, ir_recon_path); @@ -522,10 +506,12 @@ mod tests { serde_json::from_reader(recon_json_reader).expect("should be able to read json"); assert_eq!(recon_json["00080008"]["vr"], "PN"); assert_eq!(recon_json["00080008"]["Value"], Value::Null); + + Ok(()) } #[test] - fn test_integration_inline_binary() { + fn test_integration_inline_binary() -> Result { let dicom_json_text = r#" { "00080008": { @@ -540,7 +526,7 @@ mod tests { fs::write(ir_path, dicom_json_text).expect("should be able to write to file"); - dicom_json_to_dimble(ir_path, dimble_path, None); + dicom_json_to_dimble(ir_path, dimble_path, None)?; dimble_to_dicom_json(dimble_path, ir_recon_path); @@ -558,5 +544,7 @@ mod tests { .contains_key("Value"), "should not have Value field" ); + + Ok(()) } } From a27c17acd0f5049a3ecccc3b365fcaebb41c8036 Mon Sep 17 00:00:00 2001 From: strongchris Date: Fri, 26 May 2023 05:26:51 +0000 Subject: [PATCH 10/11] update dicom and nifti baseline discovery scripts --- Makefile | 7 ++- ...isons.py => dicom_baseline_comparisons.py} | 6 +- test/nifti_baseline_comparisons.py | 63 +++++++++++++++++++ 3 files changed, 71 insertions(+), 5 deletions(-) rename test/{pydicom_comparisons.py => dicom_baseline_comparisons.py} (98%) create mode 100644 test/nifti_baseline_comparisons.py diff --git a/Makefile b/Makefile index 830ce20..e496bd9 100644 --- a/Makefile +++ b/Makefile @@ -19,8 +19,11 @@ test: prep_test bench: prep_test pytest --benchmark-enable --benchmark-group-by=fullfunc -bench-pydicom-vs-sitk: - pytest test/pydicom_comparisons.py --benchmark-group-by=param -s --benchmark-save=pydicom_comparisons +bench-dicom-baselines: + pytest test/dicom_baseline_comparisons.py --benchmark-group-by=param -s --benchmark-save=dicom_baselines_comparisons + +bench-nifti-baselines: + pytest test/nifti_baseline_comparisons.py --benchmark-group-by=param -s --benchmark-save=nifti_baselines_comparisons fmt: cargo fmt diff --git a/test/pydicom_comparisons.py b/test/dicom_baseline_comparisons.py similarity index 98% rename from test/pydicom_comparisons.py rename to test/dicom_baseline_comparisons.py index 8ea41b8..5f4f112 100644 --- a/test/pydicom_comparisons.py +++ b/test/dicom_baseline_comparisons.py @@ -65,13 +65,13 @@ def convert_to_dimble(dicom_file: Path): def pydicom_to_numpy(dicom_file: Path): ds = pydicom.dcmread(dicom_file) pixel_array = ds.pixel_array - return pixel_array.sum() + return pixel_array def sitk_to_numpy(dicom_file: Path): ds = sitk.ReadImage(str(dicom_file)) pixel_array = sitk.GetArrayFromImage(ds) - return pixel_array.sum() + return pixel_array def _get_gdcm_to_numpy_typemap(): @@ -129,7 +129,7 @@ def dimble_to_numpy(dicom_file: Path): dimble_file = DIMBLE_FILES[dicom_file] ds = dimble.load_dimble(str(dimble_file), fields=[PIXEL_ARRAY]) pixel_array = ds[PIXEL_ARRAY] - return pixel_array.sum() + return pixel_array @pytest.mark.parametrize("dicom_file", dicom_files, ids=dicom_files_ids) diff --git a/test/nifti_baseline_comparisons.py b/test/nifti_baseline_comparisons.py new file mode 100644 index 0000000..30ece0a --- /dev/null +++ b/test/nifti_baseline_comparisons.py @@ -0,0 +1,63 @@ +import json +import os +import tempfile +from pathlib import Path + +import gdcm +import numpy as np +import pydicom +import pytest +import SimpleITK as sitk +import nibabel as nib + +import dimble + +PIXEL_ARRAY = "7FE00010" + +ignore_files = [ + 'visiblehuman.nii.gz' +] +TESTFILES_DIR = Path(__file__).parent.parent / "niivue-images" +assert TESTFILES_DIR.exists() + +nifti_files = list(p for p in TESTFILES_DIR.glob("*.nii*") if p.name not in ignore_files and "recon" not in p.name) + +if os.getenv("E2ESMALL", None): + nifti_files = nifti_files[:1] +assert len(nifti_files) > 0 +nifti_files_ids = [p.name.split("?")[0] for p in nifti_files] + +NIFTI_FILES = {} + +def convert_to_dimble(nifti_file: Path): + dimble_file = Path("/tmp") / nifti_file.with_suffix(".dimble").name + if not dimble_file.exists(): + dimble.nifti_to_dimble(str(nifti_file), str(dimble_file)) + NIFTI_FILES[nifti_file] = dimble_file + + +for nifti_file in nifti_files: + convert_to_dimble(nifti_file) + +print("nifti_file", NIFTI_FILES) + +def nibabel_to_numpy(nifti_file: Path): + return nib.load(str(nifti_file)).get_fdata() + +def dimble_to_numpy(dimble_file: Path): + return dimble.load_dimble(dimble_file, [PIXEL_ARRAY])[PIXEL_ARRAY] + +def sitk_to_numpy(nifti_file: Path): + return sitk.GetArrayFromImage(sitk.ReadImage(str(nifti_file))) + +@pytest.mark.parametrize("nifti_file", nifti_files, ids=nifti_files_ids) +def test_sitk_read(nifti_file: Path, benchmark): + benchmark(sitk_to_numpy, str(nifti_file)) + +@pytest.mark.parametrize("nifti_file", nifti_files, ids=nifti_files_ids) +def test_nibabel_read(nifti_file: Path, benchmark): + benchmark(nibabel_to_numpy, nifti_file) + +@pytest.mark.parametrize("nifti_file", nifti_files, ids=nifti_files_ids) +def test_dimble_read(nifti_file: Path, benchmark): + benchmark(dimble_to_numpy, NIFTI_FILES[nifti_file]) \ No newline at end of file From 17f8d5895d5537b0b82bf3d45f95f77716d7e5c5 Mon Sep 17 00:00:00 2001 From: "Cian Byrne BCST, MACS CT, MAICD" Date: Thu, 8 Jun 2023 03:50:56 +1000 Subject: [PATCH 11/11] changed format of README (#15) * changed format of README * fixed formatting readme --------- Co-authored-by: wallarug --- README.md | 20 ++++++++------------ 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index 338d1fc..c9ddf8d 100644 --- a/README.md +++ b/README.md @@ -2,27 +2,23 @@ Nimble Digital Imaging for Medicine -Near lossless and easy conversion from DICOM and back -- Done +## Pipeline -Support for fast and random access of metadata -- Done +### Completed -Extremely fast and zero-copy loading to CPU/GPU -- Done +- [x] Near lossless and easy conversion from DICOM and back +- [x] Support for fast and random access of metadata +- [x] Extremely fast and zero-copy loading to CPU/GPU +- [x] Safe: no codegen/exec based on the metadata +- [x] Support for ITK file formats [[ref](https://simpleitk.readthedocs.io/en/v1.2.4/Documentation/docs/source/IO.html#images)], including NIfTI +### WIP All relevant data types including uint16, f16, bf16, complex64 and complex128 - Currently supports f32, trivial to support other datatypes Bindings for Python and conversion to NumPy/CuPy/JAX/Torch tensors - Currently supports loading to Torch tensors (easily extensible) -Safe: no codegen/exec based on the metadata -- Done - -Support for ITK file formats [[ref](https://simpleitk.readthedocs.io/en/v1.2.4/Documentation/docs/source/IO.html#images)], including NIfTI -- Done - ## Installation