From cea4652db582a4ccffc3678cdfc5afe3d25519f8 Mon Sep 17 00:00:00 2001 From: Yashvi-Sharma Date: Wed, 8 Apr 2026 14:37:26 -0700 Subject: [PATCH 1/3] Added detconfig for new DEIMOS (science), and notebook for testing it. Minor fixes in slice handling. Updated example configs. --- eregion/configs/config.py | 8 + eregion/configs/detectors/basic_ccd.yaml | 51 ++-- eregion/configs/detectors/deimos_sci.yaml | 284 ++++++++++++++++++++ eregion/configs/pipeline_flows/example.yaml | 12 +- eregion/datamodels/image.py | 41 ++- eregion/tasks/imagegen.py | 6 + eregion/utils/image_utils.py | 37 ++- playground/deimos_sci_testing.ipynb | 274 +++++++++++++++++++ 8 files changed, 650 insertions(+), 63 deletions(-) create mode 100644 eregion/configs/detectors/deimos_sci.yaml create mode 100644 playground/deimos_sci_testing.ipynb diff --git a/eregion/configs/config.py b/eregion/configs/config.py index 47cbe2d..ba9a036 100644 --- a/eregion/configs/config.py +++ b/eregion/configs/config.py @@ -16,6 +16,14 @@ def slice_constructor(loader, node): start, stop, step = values case _: raise ValueError("Invalid number of arguments for slice.") + + if step is None: + if start > stop: + step = -1 + else: + step = 1 + if stop == -1: + stop = None return slice(start, stop, step) yaml.add_constructor('!slice', slice_constructor) diff --git a/eregion/configs/detectors/basic_ccd.yaml b/eregion/configs/detectors/basic_ccd.yaml index ae91744..a3b6e4e 100644 --- a/eregion/configs/detectors/basic_ccd.yaml +++ b/eregion/configs/detectors/basic_ccd.yaml @@ -1,19 +1,22 @@ -## Config file for creating instances of an image class (here DetImage) for a basic CCD detector -## The DetImage instance contains the outputs from a "single" detector. -## The "image" can be stored in one FITS file with one extension that has all the detectors/outputs, -## OR in multiple FITS extensions, one per detector/output, OR in multiple FITS files, one per detector/output. -## The config structure should describe how to load one FITS file. +## Config file for creating instances of DetImage image class for a basic CCD detector +## The DetImage instance is designed to contain the outputs of a SINGLE detector (not mosaic). +## The flexibility provided by YAML allows instantiating image(s) from one FITS file with one extension that has all the detectors/outputs, +## OR from multiple FITS extensions, one per detector/output, OR from multiple FITS files, one per detector/output. +## The config structure should describe what's contained per FITS file. + +## The following example describes a single CCD detector with two outputs (channels) that are read out from the same FITS extension. +## The data for each output is defined by a slice of the FITS extension (ext_slice), and the location of that data in the full DetImage data array is also defined by a slice (data_slice). --- description: Basic single CCD detector, one channel detector_type: CCD # (specify the type of detector, e.g., CCD, CMOS, H2RG, etc.) -detector_output_class: CCDOutput +detector_output_class: CCDOutput # (use the correct class here for the detector output type) -# List of class objects, each containing a list of outputs. +# List of Output class objects, each containing a list of outputs. # An output is described by the FITS file it is in, the extension in that file, and the slices that define its data. objects: - name: 'det_1' class: DetImage - filename_format: '*.fits*' # Use wildcard to indicate the filename + filename_format: '*.fits*' # Use wildcard to pattern match filename if needed properties: x_size: 2048 y_size: 4096 @@ -22,27 +25,27 @@ objects: outputs: - id: 'chan_1' ext_id: 1 # FITS extension ID - ext_slice: [!slice [0, 4096], !slice [0, 1024]] # Slice of the ext_id that has the data for this output - data_slice: [!slice [0, 4096], !slice [0, 1024]] # Slice of the full DetImage data array where this output's data will go - serial_prescan: !slice [0, 0] - serial_overscan: !slice [1024, 1024] - parallel_prescan: !slice [0, 0] - parallel_overscan: !slice [4096, 4096] + ext_slice: [!slice [0, 4096], !slice [0, 1024]] # Slice of the ext_id that has the data for this output (left half) + data_slice: [!slice [0, 4096], !slice [0, 1024]] # Slice of the full DetImage data array where this output's data will go (left half) + serial_prescan: !slice [0, 20] # 20 prescan columns w.r.t. the data_slice + serial_overscan: !slice [1004, 1024] # 20 overscan columns w.r.t. the data_slice + parallel_prescan: !slice [0, 20] # 20 prescan rows w.r.t. the data_slice + parallel_overscan: !slice [4076, 4096] # 20 overscan rows w.r.t. the data_slice parallel_axis: 'y' # First axis in the data array (rows) represent parallel readout direction - readout_pixel: [0, 0] # Readout starts at (0,0) + readout_pixel: [0, 0] # Readout of this amplifier (top left) gain: 1.0 # electrons/ADU read_noise: 5.0 # electrons bias_level: 1000 # ADU - id: 'chan_2' - ext_id: 1 # FITS extension ID - ext_slice: [!slice [0, 4096], !slice [1024, 2048]] # Slice of the ext_id that has the data for this output - data_slice: [!slice [0, 4096], !slice [1024, 2048]] # Slice of the full DetImage data array where this output's data will go - serial_prescan: !slice [0, 0] - serial_overscan: !slice [1024, 1024] - parallel_prescan: !slice [0, 0] - parallel_overscan: !slice [4096, 4096] - parallel_axis: 'y' # First axis in the data array (rows) represent parallel readout direction - readout_pixel: [0, 2047] # Readout starts at (0,2047) + ext_id: 1 + ext_slice: [!slice [0, 4096], !slice [1024, 2048]] #(right half) + data_slice: [!slice [0, 4096], !slice [1024, 2048]] #(right half) + serial_prescan: !slice [2048, 2027] # 20 prescan columns w.r.t. the data_slice (on the right since readout is from the right) + serial_overscan: !slice [1044, 1023] # 20 overscan columns w.r.t. the data_slice + parallel_prescan: !slice [0, 20] # 20 prescan rows w.r.t. the data_slice + parallel_overscan: !slice [4076, 4096] # 20 overscan rows w.r.t. the data_slice + parallel_axis: 'y' + readout_pixel: [0, 2047] # Readout of this amplifier (top right) gain: 1.0 # electrons/ADU read_noise: 5.0 # electrons bias_level: 1000 # ADU diff --git a/eregion/configs/detectors/deimos_sci.yaml b/eregion/configs/detectors/deimos_sci.yaml new file mode 100644 index 0000000..d6a21ad --- /dev/null +++ b/eregion/configs/detectors/deimos_sci.yaml @@ -0,0 +1,284 @@ +## DEIMOS science CCD config +## FITS with 1 extension, full focal plane image with 8 detectors -> 8 DetImage instances to be created +## Each DetImage instance has two outputs (two channels per detector). +--- +description: DEIMOS CCD detector array, 8 detectors with two channel readout each +detector_type: CCD +detector_output_class: CCDOutput + +objects: + - name: 'det_1' + class: DetImage + filename_format: '*.fits*' + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'E1' + ext_id: 0 + ext_slice: [!slice [8249, 4124], !slice [0, 1094]] + data_slice: [!slice [0, 4125], !slice [0, 1094]] + serial_prescan: !slice [0, 50] + serial_overscan: !slice [1074, 1094] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 0] + - id: 'F1' + ext_id: 0 + ext_slice: [!slice [8249, 4124], !slice [1094, 2188]] + data_slice: [!slice [0, 4125], !slice [1094, 2188]] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 2187] + focal_plane_position: + x_cen: -46.08 # mm + y_cen: 30.72 # mm + angle: 0.0 # degrees + + - name: 'det_2' + class: DetImage + filename_format: '*.fits*' # Use wildcard to indicate the filename + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'E2' + ext_id: 0 + ext_slice: [!slice [8249, 4124], !slice [2188, 3282]] + data_slice: [!slice [0, 4125], !slice [0, 1094]] + serial_prescan: !slice [0, 50] + serial_overscan: !slice [1074, 1094] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 0] + - id: 'F2' + ext_id: 0 + ext_slice: [!slice [8249, 4124], !slice [3282, 4376]] + data_slice: [!slice [0, 4125], !slice [1094, 2188]] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 2187] + focal_plane_position: + x_cen: -15.36 # mm + y_cen: 30.72 # mm + angle: 0.0 # degrees + + - name: 'det_3' + class: DetImage + filename_format: '*.fits*' # Use wildcard to indicate the filename + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'E3' + ext_id: 0 + ext_slice: [!slice [8249, 4124], !slice [4376, 5470]] + data_slice: [!slice [0, 4125], !slice [0, 1094]] + serial_prescan: !slice [0, 50] + serial_overscan: !slice [1074, 1094] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 0] + - id: 'F3' + ext_id: 0 + ext_slice: [!slice [8249, 4124], !slice [5470, 6564]] + data_slice: [!slice [0, 4125], !slice [1094, 2188]] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 2187] + focal_plane_position: + x_cen: 15.36 # mm + y_cen: 30.72 # mm + angle: 0.0 # degrees + + - name: 'det_4' + class: DetImage + filename_format: '*.fits*' # Use wildcard to indicate the filename + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'E4' + ext_id: 0 + ext_slice: [!slice [8249, 4124], !slice [6564, 7658]] + data_slice: [!slice [0, 4125], !slice [0, 1094]] + serial_prescan: !slice [0, 50] + serial_overscan: !slice [1074, 1094] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 0] + - id: 'F4' + ext_id: 0 + ext_slice: [!slice [8249, 4124], !slice [7658, 8752]] + data_slice: [!slice [0, 4125], !slice [1094, 2188]] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 2187] + focal_plane_position: + x_cen: 46.08 # mm + y_cen: 30.72 # mm + angle: 0.0 # degrees + + - name: 'det_5' + class: DetImage + filename_format: '*.fits*' # Use wildcard to indicate the filename + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'E5' + ext_id: 0 + ext_slice: [!slice [4124, -1], !slice [7658, 8752]] + data_slice: [!slice [0, 4125], !slice [1094, 2188]] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [4124, 4123] + parallel_overscan: !slice [19, -1] + parallel_axis: 'y' + readout_pixel: [4124, 2187] + - id: 'F5' + ext_id: 0 + ext_slice: [!slice [4124, -1], !slice [6564, 7658]] + data_slice: [!slice [0, 4125], !slice [0, 1094]] + serial_prescan: !slice [0, 50] + serial_overscan: !slice [1074, 1094] + parallel_prescan: !slice [4124, 4123] + parallel_overscan: !slice [19, -1] + parallel_axis: 'y' + readout_pixel: [4124, 0] + focal_plane_position: + x_cen: 46.08 # mm + y_cen: -30.72 # mm + angle: 0.0 # degrees + + - name: 'det_6' + class: DetImage + filename_format: '*.fits*' # Use wildcard to indicate the filename + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'E6' + ext_id: 0 + ext_slice: [!slice [4124, -1], !slice [5470, 6564]] + data_slice: [!slice [0, 4125], !slice [1094, 2188]] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [4124, 4123] + parallel_overscan: !slice [19, -1] + parallel_axis: 'y' + readout_pixel: [4124, 2187] + - id: 'F6' + ext_id: 0 + ext_slice: [!slice [4124, -1], !slice [4376, 5470]] + data_slice: [!slice [0, 4125], !slice [0, 1094]] + serial_prescan: !slice [0, 50] + serial_overscan: !slice [1074, 1094] + parallel_prescan: !slice [4124, 4123] + parallel_overscan: !slice [19, -1] + parallel_axis: 'y' + readout_pixel: [4124, 0] + focal_plane_position: + x_cen: 15.36 # mm + y_cen: -30.72 # mm + angle: 0.0 # degrees + + - name: 'det_7' + class: DetImage + filename_format: '*.fits*' # Use wildcard to indicate the filename + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'E7' + ext_id: 0 + ext_slice: [!slice [4124, -1], !slice [3282, 4376]] + data_slice: [!slice [0, 4125], !slice [1094, 2188]] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [4124, 4123] + parallel_overscan: !slice [19, -1] + parallel_axis: 'y' + readout_pixel: [4124, 2187] + - id: 'F7' + ext_id: 0 + ext_slice: [!slice [4124, -1], !slice [2188, 3282]] + data_slice: [!slice [0, 4125], !slice [0, 1094]] + serial_prescan: !slice [0, 50] + serial_overscan: !slice [1074, 1094] + parallel_prescan: !slice [4124, 4123] + parallel_overscan: !slice [19, -1] + parallel_axis: 'y' + readout_pixel: [4124, 0] + focal_plane_position: + x_cen: -15.36 # mm + y_cen: -30.72 # mm + angle: 0.0 # degrees + + - name: 'det_8' + class: DetImage + filename_format: '*.fits*' # Use wildcard to indicate the filename + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'E8' + ext_id: 0 + ext_slice: [!slice [4124, -1], !slice [1094, 2188]] + data_slice: [!slice [0, 4125], !slice [1094, 2188]] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [4124, 4123] + parallel_overscan: !slice [19, -1] + parallel_axis: 'y' + readout_pixel: [4124, 2187] + - id: 'F8' + ext_id: 0 + ext_slice: [!slice [4124, -1], !slice [0, 1094]] + data_slice: [!slice [0, 4125], !slice [0, 1094]] + serial_prescan: !slice [0, 50] + serial_overscan: !slice [1074, 1094] + parallel_prescan: !slice [4124, 4123] + parallel_overscan: !slice [19, -1] + parallel_axis: 'y' + readout_pixel: [4124, 0] + focal_plane_position: + x_cen: -46.08 # mm + y_cen: -30.72 # mm + angle: 0.0 # degrees + + + + diff --git a/eregion/configs/pipeline_flows/example.yaml b/eregion/configs/pipeline_flows/example.yaml index 8dc630c..f9dd1eb 100644 --- a/eregion/configs/pipeline_flows/example.yaml +++ b/eregion/configs/pipeline_flows/example.yaml @@ -10,20 +10,21 @@ pipelines: nodes: # List of tasks (nodes) in the pipeline flow - name: TASK_1 # Name of the task node, required task: package.module.class # Path to the Class of the task to run, must be a subclass of `Task` defined in tasks.task - init: # Initialization parameters (for Task.__init__) inputs: # Specify any args needed from outputs of other tasks in this config - arg_1: pipe_name.node_name.data.key # Output of tasks are wrapped in TaskResult objects by the engine, and the data produced by the task is in the TaskResult.data dict; specify the path to the data you want to use as input for this task + arg_1: pipe_name.node_name.data.key # Output of tasks are wrapped in TaskResult objects by the engine, and the data + # produced by the task is in the TaskResult.data dict; specify the path to the + # data you want to use as input for this task # etc. params: # Specify any additional kwargs (which are not task outputs) needed; refer to the task documentation for required and optional params and kwargs param_1: value param_2: value # etc. - - run: # Run-time (Task.run() or Task.lazy_run()) inputs and parameters, as above, use `inputs` to specify data coming from outputs of other tasks, and `params` for any additional parameters + run: # Run-time (Task.run() or Task.lazy_run()) inputs and parameters, as above, use `inputs` to specify data coming from + # outputs of other tasks, and `params` for any additional parameters inputs: arg_1: pipe_name.node_name.data.key - # etc. + # etc. params: param_1: value param_2: value @@ -43,7 +44,6 @@ pipelines: params: param_1: value # etc. - depends_on: [TASK_1] # should be specified if this task depends on the output of another task; ensures correct execution order in the pipeline flow - name: PIPE_2 diff --git a/eregion/datamodels/image.py b/eregion/datamodels/image.py index 0e3c5b9..b105d9d 100644 --- a/eregion/datamodels/image.py +++ b/eregion/datamodels/image.py @@ -123,14 +123,12 @@ def set_data_in_parent(self, new_data: xr.DataArray | np.ndarray): # Convert new_data to numpy array if it's an xarray DataArray, to ensure compatibility with parent data array. new_data_np = ensure_numpy(new_data) # Assign new data to the appropriate slice in the parent DetImage - self.parent.data.values[self.output_slice] = new_data_np + self.parent.data[self.output_slice] = new_data_np def show(self, ax=None, save=None, **imshow_kwargs): if ax is None: _, ax = plt.subplots(1,1, figsize=(6, 6), tight_layout=True) - image = self.data - im = ax.imshow(image, **imshow_kwargs) - ax.figure.colorbar(im, ax=ax) + im = xr.plot.imshow(self.data, ax=ax, **imshow_kwargs) if save is not None: ax.figure.savefig(save) return ax @@ -161,42 +159,40 @@ def serial_axis(self) -> str: def get_prescan(self, kind: str) -> xr.DataArray: slc = self.serial_prescan if kind == "serial" else self.parallel_prescan axis = self.serial_axis if kind == "serial" else self.parallel_axis - return self.data.isel(**{axis: slc}) + return slice_data(self.data, {axis: slc}) def get_overscan(self, kind: str) -> xr.DataArray: slc = self.serial_overscan if kind == "serial" else self.parallel_overscan axis = self.serial_axis if kind == "serial" else self.parallel_axis - return self.data.isel(**{axis: slc}) + return self.data.sel(**{axis: slc}) def show(self, ax=None, shade_regions=False, save=None, **imshow_kwargs): - if ax is None: - _, ax = plt.subplots(1,1, figsize=(6, 6), tight_layout=True) - image = self.data - im = ax.imshow(image.values, **imshow_kwargs) + ax = super().show(ax=ax, save=None, **imshow_kwargs) if shade_regions: ## Shade the prescan and overscan regions - spandict = {0: ax.axvspan, 1: ax.axhspan} - def _bounds(s: slice, n: int) -> tuple[int, int]: - s0 = 0 if s.start is None else (n + s.start if s.start < 0 else s.start) - s1 = n if s.stop is None else (n + s.stop if s.stop < 0 else s.stop) + s0 = s.start if s.start is not None else (0 if s.step > 0 else n) + s1 = (s.stop-1 if s.step>0 else s.stop+1) if s.stop is not None else (n if s.step>0 else 0) return s0, s1 + spandict = {0: ax.axvspan, 1: ax.axhspan} regions = [ - (self.serial_prescan, self.parallel_axis, "gold", "Serial Prescan"), - (self.serial_overscan, self.parallel_axis, "red", "Serial Overscan"), - (self.parallel_prescan, self.serial_axis, "cyan", "Parallel Prescan"), - (self.parallel_overscan, self.serial_axis, "blue", "Parallel Overscan"), + (self.serial_prescan, self.parallel_axis, "gold", "S Prescan"), + (self.serial_overscan, self.parallel_axis, "red", "S Overscan"), + (self.parallel_prescan, self.serial_axis, "cyan", "P Prescan"), + (self.parallel_overscan, self.serial_axis, "blue", "P Overscan"), ] - shape = image.shape + shape = self.data.shape for s, axis, color, label in regions: axis_idx = 0 if axis=='y' else 1 a, b = _bounds(s, shape[axis_idx]) spandict[axis_idx](a, b, color=color, alpha=0.3, label=label) - ax.legend(loc=(0.01, 1.01), fontsize=8) + ax.scatter(self.readout_pixel[1], + self.readout_pixel[0], + marker='x', color='red', s=100) + ax.legend(loc=(0.55, 1.05), fontsize=7) - ax.figure.colorbar(im, ax=ax) if save is not None: ax.figure.savefig(save) return ax @@ -293,8 +289,7 @@ def show(self, ax=None, save=None, **imshow_kwargs): raise ValueError("DetImage has no data to show.") if ax is None: _, ax = plt.subplots(1, 1, figsize=(6, 6), tight_layout=True) - im = ax.imshow(self.data.values, **imshow_kwargs) - ax.figure.colorbar(im, ax=ax) + im = xr.plot.imshow(self.data, ax=ax, **imshow_kwargs) if save is not None: ax.figure.savefig(save) return ax diff --git a/eregion/tasks/imagegen.py b/eregion/tasks/imagegen.py index 91a0a01..03a3163 100644 --- a/eregion/tasks/imagegen.py +++ b/eregion/tasks/imagegen.py @@ -174,6 +174,12 @@ def _build_single_image_object(self, image_data_size[1] = max(image_data_size[1], output_obj.output_slice[1].stop) image.add_output(output_obj) + # verify that calculated image size is consistent with set size in obj properties (if given) + if 'properties' in obj and 'x_size' in obj['properties'] and 'y_size' in obj['properties']: + if image_data_size != [obj['properties']['y_size'], obj['properties']['x_size']]: + self.logger.error(f"Calculated image size {image_data_size} does not match specified size in config" + f" {obj['properties']['y_size'], obj['properties']['x_size']} for {obj['name']}") + # Assemble full image data from outputs image_data = np.zeros(image_data_size) for output_id in image.outputs: diff --git a/eregion/utils/image_utils.py b/eregion/utils/image_utils.py index 3b9dd1c..c1c9ab5 100644 --- a/eregion/utils/image_utils.py +++ b/eregion/utils/image_utils.py @@ -69,18 +69,35 @@ def ensure_numpy(data: xr.DataArray | np.ndarray) -> np.ndarray: case _: raise TypeError("data must be an xarray.DataArray, or numpy.ndarray") -def slice_data(data: xr.DataArray, slicer: tuple[slice, ...]) -> xr.DataArray: +def slice_data(data: xr.DataArray, slicer: tuple[slice, ...] | dict[str:slice]) -> xr.DataArray: """ Slice a 2D or 3D DataArray using ('y','x','t) positional slices. """ - if not isinstance(slicer, tuple) or not all(isinstance(s, slice) for s in slicer): - raise ValueError("slicer must be a tuple of slice objects.") - - match (data.ndim, data.dims): - case (2, ("y", "x")): - return data.isel(y=slicer[0], x=slicer[1]) - case (3, ("y", "x", "t")): - return data.isel(y=slicer[0], x=slicer[1], t=slicer[2]) + match slicer: + case tuple(): + if not all(isinstance(s, slice) for s in slicer): + raise ValueError("All elements of slicer tuple must be slices.") + match (data.ndim, data.dims): + case (2, ("y", "x")): + slicer = {"y": slicer[0], "x": slicer[1]} + case (3, ("y", "x", "t")): + slicer = {"y": slicer[0], "x": slicer[1], "t": slicer[2]} + case _: + raise ValueError("DataArray must be 2D with dims ('y','x') or 3D with dims ('y','x','t').") + case dict(): + if not all(isinstance(s, slice) for s in slicer.values()): + raise ValueError("All values of slicer dict must be slices.") case _: - raise ValueError("DataArray must be 2D with dims ('y','x') or 3D with dims ('y','x','t').") + raise ValueError("slicer must be a tuple of slices or a dict of {dim: slice}.") + + # hack to not include last element of slices but still use .sel() which includes the stop index + for k, sl in slicer.items(): + if sl.step > 0: + slicer[k] = slice(sl.start, sl.stop - 1, sl.step) + else: + slicer[k] = slice(sl.start, sl.stop + 1, sl.step) + + return data.sel(**slicer) + + diff --git a/playground/deimos_sci_testing.ipynb b/playground/deimos_sci_testing.ipynb new file mode 100644 index 0000000..f2c8054 --- /dev/null +++ b/playground/deimos_sci_testing.ipynb @@ -0,0 +1,274 @@ +{ + "cells": [ + { + "cell_type": "code", + "id": "initial_id", + "metadata": { + "collapsed": true, + "ExecuteTime": { + "end_time": "2026-04-08T21:31:11.283907Z", + "start_time": "2026-04-08T21:31:08.647428Z" + } + }, + "source": [ + "from eregion.tasks.imagegen import ImageCreator\n", + "from matplotlib import pyplot as plt\n", + "\n", + "creator = ImageCreator(detector_config='../eregion/configs/detectors/deimos_sci.yaml')\n", + "res = creator.run(input_source='../data/deimos/warmdark_allchans.fits')" + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-04-08 14:31:09,409 - DetectorConfig - INFO - Config loaded from file '../eregion/configs/detectors/deimos_sci.yaml'\n", + "2026-04-08 14:31:09,409 - image_creator - INFO - Item ../data/deimos/warmdark_allchans.fits is a regular path string\n", + "2026-04-08 14:31:09,410 - utils.io_utils - INFO - Found FITS file ../data/deimos/warmdark_allchans.fits.\n", + "2026-04-08 14:31:09,410 - image_creator - INFO - Processing file ../data/deimos/warmdark_allchans.fits\n" + ] + } + ], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-04-08T21:31:11.292975Z", + "start_time": "2026-04-08T21:31:11.288767Z" + } + }, + "cell_type": "code", + "source": "res", + "id": "6c032d1480e88d8f", + "outputs": [ + { + "data": { + "text/plain": [ + "{'unknown': [,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ,\n", + " ]}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 2 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-04-08T21:31:11.773821Z", + "start_time": "2026-04-08T21:31:11.299758Z" + } + }, + "cell_type": "code", + "source": [ + "# top left detector in DS9\n", + "det1 = res['unknown'][0]\n", + "det1.show(cmap='Greys_r', origin='upper')" + ], + "id": "52ed79d9718d2942", + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + } + ], + "execution_count": 3 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-04-08T21:31:12.078939Z", + "start_time": "2026-04-08T21:31:11.778477Z" + } + }, + "cell_type": "code", + "source": [ + "fig, axs = plt.subplots(1, 1, figsize=(4, 8))\n", + "det1.outputs['E1'].show(ax=axs, shade_regions=True, cmap='Greys_r', origin='upper')\n", + "axs.set_title('E1')" + ], + "id": "8092f5c8015e4fad", + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'E1')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZoAAAMECAYAAACG9eN5AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAA/59JREFUeJzsvQm4JUWVLRxVQBVjMQoFMoiizIOAMqg0KDKINLS0z1YEVIaHH/gL2MCjm0aEVmwUkVYGfTJoA8rQAorIIAiIgAyCMghPFAWUQVso5qKg7v9FSl7j7lp7iMyMPOfU3eu757vnZMacEXvvtSJPniljY2NjweFwOByOQphaqmCHw+FwONzROBwOh6M4nNE4HA6Hoyjc0TgcDoejKNzROBwOh6Mo3NE4HA6Hoyjc0TgcDoejKNzROBwOh6MoFixbvMMxufDKK6+EOXPmDLoZ8y0WWmihsMACCwy6GY5MuKNxODrCs88+Gx555JHgD9sohylTpoSVV145LL744gVrcXSNKf4IGoejGybz61//Oiy66KLhNa95TWUQHd0iOvA//elP4fnnnw9vfOMbndmMEJzROBwdIMpl0RBGJ7PIIov4mBZCHN/f/e531Xi7hDY68JsBHI4O4UymLHx8RxPOaByOUpj7QghjL3VT1pRpIUyVmdIxxxwTzjvvvDB16tQwffr0cMEFF4TVV199Qpqtt946PPbYY9X5uM9xxhlnhDXXXLObNjocDNzROBylnMyzl4TwypPdlLfA0iEsvgvrbG688cbw4x//ONx5553VnVnxpoTFFlsMpr3wwgvDeuutF77+9a+HQw89NHzve9+b2PS5cytn5XB0BZ9NDkcJRCYTncyURUKYunS7VywjliWwo8hSlltuucrJRMQ7s5ZeemmxiVtttVV44IEHqvfLLrtsOPDAA8P6668f/t//+3/hP/7jP8Jb3vKWsMEGG4QvfvGLVZo//vGP4W1ve1vYcMMNq+O//OUvq+ORFcXP8fg///M/V8dOO+20Kn889qEPfWj8lu/IqA4//PCw6aabVs7unnvu6WjAHcMMdzQOR0lMWTiEqYu1e8UyFLz73e8O9913X1hnnXXCJz/5yXDbbbepeSKTiY4l4i9/+UvYcccdw1133RUeeuihihHdcsst4Y477giXXXZZuPvuu8O3v/3tylH84he/CD//+c/DGmusUaU/8cQTw/XXX18d/5d/+ZeqvP/1v/5XuPXWW6tjM2fODOeff/54vdEZxvYdcsgh4Utf+lKr4XWMBlw6czjmAyyxxBKVU4jy2dVXX105nmjc43+Kf/zHfwwLL7xwtX/zla98pToW75TbaaedqvdXXnll+MEPfhB+8pOfVJ+feeaZiuVEhrLnnnuGBRdcsCojOqlY3wc+8IGw1FJLVWmXWWaZ6n90MP/2b/8WZs2aVb3SO/H+4R/+ofq/ySabhHPOOaeH0XEMGu5oHI75BNEBRMcSX1FGu+SSS6CjqfdoUsTv/6R7NJ/+9KfDXnvtNU/en/70p+HSSy8NH/zgB8PnPvc5ti1777135azWXnvt8NWvfrW6JblGvBEhIt6eHL9/5Jj/4dKZw1ESYy+GMPe5dq9YhoL7778//OY3v/lrlWNjldS16qqrNmrydtttF77xjW9UX4yMiE4ispLf//73lQz2v//3/w577LFHtUfzzne+s7rTLZ6vJbiI5557LqywwgrhpZdeqiQ3x+SGMxqHowTi7cjxTrFqE/+F9uXFsmKZwuNv4mb+008/PS5LfeITn2hU1Q477BDuvffesPnmm1fsJspi//3f/x2uvfba8IUvfKHaY4nHogOJjifuCcWbBCKjik7q+OOPD0cffXS14b/88suHN7/5zY277Zg/4I+gcTg6wIsvvhgefPDBat8j7n8M4ns0k3acHUMPZzQORylUjsGdg8PhezQOh8PhKAp3NA6Hw+EoCnc0DofD4SgKdzQOh8PhKAp3NA6Hw+EoCr/rzOEohRdeCOGljm5vnjYtPiem9c8EzJ49u3rG2OWXX179tkt8rMwpp5yiPoDT4WgDdzQORyknc8klITzZ0c8EREewyy6ss7H+TMD/+T//J7z88svVz05Hh/TZz342fOxjHwsXXXRRq+bFR8n4L146OLh05nCUQGQy0clExxCdRJtXLCOW9VK7nwmIj4X51re+VT32v/69mSOOOKJ6AGb8uYD4cMxrrrlmPH18vEx8UGfM95GPfKRiP/GJA1dddVV1Pn77Pz4Pbcsttwz/3//3/1WOLj5oM/40QHwqQER0avHJAfF4/CmB+inO++23X1XWuuuuO/4zBBGxD/GnBmL6d73rXVXdjtGHOxqHoyTit9cjs2jzWribnwmIz0KLzz+LT3quER1OdAzxkTPvf//7K7kt4oknnqh+fyY+Piaynve+973VY/+vuOKK6tE28XlqEdFBxUfTnHzyydUj/+MrOq74BOmI+ONq8fln8Vh8Nlr9kM/Pf/7z4fbbb6+Ox8fbPPzww9Xx//mf/6kegRN/fuC1r31t+O53v9vRhXAMEu5oHI756GcCTjrppOqR/NGg18zDive85z2VI4kyWJTS3ve+943/bEDc/9loo43CtttuW7GMxx9/vDq3yy67hGlx/yiE6nlnUZr7z//8z/EHcv7oRz+qHsJZM6iaZcXnpEUntvHGG1cPBI1OMiL+vHSsIyIynvSpz47Rhe/ROByT5GcC3vCGN1Q/ahYfwBkNekR8aGZkFZEJxZ8KiPJY/BGz+FMC8eGYdZrvf//7YbXVVpunzvTnBaKTiT+eFn9GID6QM+4bIfz2t7+tGNBNN90Ullxyyeq3beJNCulPCET4zwjMP3BG43CUxIsvxs2Rdq9YRgc/ExBvDvjwhz8cDjvssMp5RMSfbI57J/HXMiOifHbqqadWNxPUT12OT2SOLKVGvOEAIdYfZbh//dd/rRxXfPhlZCdRPqvre/LJJ6sfUouObsaMGVU9kfU45m+4o3E4SiDKSVEminefxY38Nq9YRizrVYkKIbKU6ETi5nr8UbNo2NHPBETHEh3RG9/4xorhRDZzxhlnTJDP4k8317+CGVH/UmZ0SNGBpJv3KeJPOsf6Y7qVVlopbLHFFtWmf/xJgfomgehU4v/4g2hrrbVW9QNpb3/721sPt2O44T8T4HCUenx9z9+jmQzwnwkYTfgejcNRCtExuHNwOFw6czgcDkdZ+B6Nw+FwOIrCHY3D4XA4isIdjcPhcDiKwm8GcDgK4YX4yLOOyoo3Nvs9Z45RhTsah6OQk7kkfkGxo/Lig1t2UZxNfDJA/A5NfJBl/J7KN7/5zQnf3I943eteV31RMmLmzJnVQzbjf4ejJFw6czgK4KVXncwirzqJNq9FXi1LY0fxi5HxW/vxqQDx+WOnnXYaTBcfDRMfcBmfsPy5z31uwrn6G/wOR5dwR+NwFET86uZiLV/6s5vnxTve8Y7qycoSttpqqypNfHBl/Ob+P/3TP1Xf/I8PzfzUpz5VPfcsfov/nHPOqdLHJyrHh2DGh2vGV3zCc0R8unP9MwDx6QARn/70p6v8kWEdfPDBExhV/HmBmD+ef/TRRxv0zjFqcEfjcMxniNLZD3/4w8r4S4gPyqzT/OpXvwr/8i//Uj1FOTqWFVdcsfpZgJtvvrl6uGZ8fH98ZtnHP/7xijXFB2JGBhUfVxN/wyb+LEFkSfH3aSLiTxXE/NE5xQd5/vSnPx2vN/5WTiwjPoDzG9/4RuHRcAwD3NE4HPMJnnrqqYopREksPmk5PkcMIf5QWUwXH24Zf/gs4k1velPFSOqfBYgOIKaJzyuLzzmLT1yO70844YTqt2QiE4nyXHx22Uc/+tHxpy4vs8wy1f/4ezRvfetbK0YUnUz8vZsa9XPU/GcAJg/8ZgCHYz5BvUejIe7R1D8TUDuo9KaBuE/zta99Lfzd3/3dhHxR6orOIzKh+PMD9Y+koeeRHXTQQRXLicwo/mJm/TMAEbVT8p8BmDxwRuNwFER8wP9zLV/6jwR0i/izAKecckr1A2gR8eaC+D6ymvjE57jnEtNElhJ/BuDMM88cdyTx1zSjo5kyZUpYdtllKzZ08cUX99wDx7DBGY3DUQDTXr1j7MlXb3Vui1gW/yMB3WLfffetnkQdf48mspvISuKez3nnnRfOPvvssNBCC1XSXJTA4m/cxJ9kjjcJxONRRov7M3GvJt5YEH8uIP4ImmNyw38mwOEo9Ph6/8Jm9/CfCRhNOKNxOAohfv/Fv83vcPgejcPhcDgKw28GcDgcDkdRuKNxOBwOR1G4o3E4HA5HUfjNAA5HIbzwQggvdfQ7AdOmhbCIcmeB5enNTz75ZDjggAPCLbfcEsbGxsIOO+wQvvSlL41/idLhKAG/vdnhKHDbbXQyl1wSDXs3w7v00iHssovsbJZbbrnw5z//uXq/++67V494OeSQQyakid99iY+o+dd//dfqOzLx2WXRGdUPw2yK+IXO+E3/0vDbm0cTLp05HAUQmUx0MtExRCfR5hXLiGXlsCP09Ob4+Re/+MX4882mTp0avvjFL1a/SROf2LzZZptV3/6vEZ9/Fh3Xn/70p/C+972vclDxeWd33HFHdf4jH/lI5ajiY2ni88++853vVEwqPt9sl+gVQ6iep7bHHntUz1GLx3/yk59Ux9/73vdWjjAysPrp0PEp0jFN/LJnLOcDH/hAxbocow+XzhyOgojf3VwsPuu/JSJDyn16c5TFUsRHxkRDHh1MjSWWWCKsuuqq4Te/+U14//vfXz2/7PDDD6++7R+//R9ZUmRH0TnFZ539+te/Dh/+8IfDz372syp/fKpzfB8fOROfBP29730vvPGNb6wePRNx7LHHVuX/13/9V8WgouOJiM4tPoAzOrhY7j/+4z+OP0X629/+duVottlmm3DDDTdUTtMx2nBH43DMZ09vrn9rhnt6M4foaKLBj47mwgsvrD5HxCc033PPPRP2eWrE9NHJRLztbW8L++23X+WYascR80bnExEd3JJLLlm9j1JdfTz+jEB8xUfYrLnmmtWjayLiI3Aiy3FHM/pwR+NwTJKnN0eWEKWzyCxqVhMZRjTy8WGZ8bll8XiUz+KDMGuZKyI+iTnebECR3mxw6qmnVr9fE5/uHGW2+Fs0CD/+8Y+rnw6ITCjuZ8W08aGc0dGkNyX4053nH/gejcMxSRAlrShvxR8yi4gO57DDDqv2UKKTiYgs5sgjj6x+nCzKZhFRwopOpEZ0Vgj1b9bEX9yMv1UTZbX4dOc6b6wvSmpPP/109WTn6GSiY+TKc8w/cEfjcBTEiy+G8Nxz7V6xjK4QH+kfDfsaa6xRvSLiRn6N6GjiHkktm0V85StfCddee221vxNZ0bnnngvLjr87Ex1ZfMW726Kz+rd/+7fxn4qOT3iOLCfuHUUmFSWy6JTiTQGO+Rt+e7PDMZ/c3jwZ4Lc3jyZ8j8bhKIDoEKJj6PMLmw7HsMIdjcNRCNExuHNwOHyPxuFwOByF4TcDOBwdwr/JXhY+vqMJl84cjg4QvwMSv7gYH9fymte8ZvxLjI5unUwc3zi2cbwdowO/68zh6AjPPvtseOSRRzzqLojoZOJt04svvnjJahwdwx2Nw9Eh4lOM58yZ42NaCJHJ9PGUaEe3cEfjcDgcjqLwmwEcDofDURTuaBwOh8NRFO5oHA6Hw1EU7mgcDofDURTuaBwOh8NRFO5oHA6Hw1EU7mgcDofDURTuaByTEmeddVb1LXPuFX+SOOK8884LH/7wh6tfp4zHt95660E33eEYOfizzhyTGsccc0z1Y2UU9a9Pxp8hvv3228Nb3vKW6qeJHQ5HPtzROCY1dtxxx7Dpppuy5//rv/4rvPa1rw1Tp04N6623Xq9tczjmF7ijcTgErLLKKj4+DkdLuKNxTGrMmjUr/PnPf55wLO7FLLvssgNrk8Mxv8EdjWNSY9ttt53n2PTp08OLL744kPY4HPMj3NE4JjVOPvnk8KY3vWnCMX8MvcPRLfz2Zsekxlvf+taK1aSvbbbZZtDNcswnuP7668POO+8cVlpppUqSvfjii7PLOP/888NGG20UFl100bDaaquFL3zhC2HU4I7G4XA4CuG5554LG264YcWcm+CHP/xh2H333cP+++8f7r777nDKKaeEE088MXz1q18NowR3NA6Hw1Hw9vl///d/D//wD/8Az8+ePTv88z//c3UL/WKLLRY222yzcO211064vX7XXXetHM3rX//6sNNOO4Ujjjgi/Md//MdI/WS4OxqHw+EYEA488MBw0003he985zvhl7/8ZXj/+98fdthhh/DrX/963BEtvPDCE/Isssgi4ZFHHgm///3vw6jAbwZwTGpEaeK+++6b5/iWW25ZRZBRY4+viD/96U+VFBIj1IitttqqejkcTfDQQw+FM888s/of93AiIru5/PLLq+Of+9znwvbbbx8OPvjg8JGPfKTaO3zggQfCCSecUKV99NFHw+te97qRGHx3NI5JjaOOOgoejws9OpprrrkmfOYzn5lw7t/+7d+q/5/+9Kfd0Tga46677gqvvPLKPHc9RhZTf49r3333Db/5zW/Ce9/73jBnzpwwY8aM8MlPfjIcffTR1dMqRgVTxkZJ6HM4HI4RxZQpU8JFF11U7bnUD2yNG/333HPPPLfUL7744mHmzJnjn6NDeuyxx8JrXvOacPXVV4f3vOc94Yknnqg+jwKc0TgcDscA8OY3v7lyINFhvOMd7xDTRkcUbxiI+Pa3vx222GKLkXEyEe5oHA6HoxCeffbZal+lxoMPPhjuvPPOsMwyy1SSWWQ0e+65Z7XvEh1P3AeMjGWDDTao7jCLj0e68MILq5+niE+riJLuBRdcEK677rqRumYunTkcDkchxFuVtwFfAN5rr72q30SK+y7x5pJvfetb4Q9/+ENYbrnlwuabb17tC66//vqVo4lf+Iz7OXGXIzKZz372s9Vt0KOESeVo4pem4rdqo9YZv0T1la98pfpmuMPhcDjKYXRuW2iJuPF2yCGHVHcK/fznP68cTbx1MOqjDofD4SiHScNoItWMv5JYP7ph7ty51W+NfOITnwj/5//8n0E3z+FwOOZbTIqbAV566aXq53jjoxtqxHvQ4wMU47dyKeJ97PFVIzqlv/zlL9W97fEWRYfDMf8gxtrPPPNM9aXJpt9NiRv10c4MAtOmTZvn6QEI8WfJ4+t3v/td9XndddetvkcWH5ODEPeQPvrRj3byExqTwtHEDbV4G+EKK6ww4Xj8jL4Vftxxx83zJT2HwzF/4+GHHw4rr7xydr5oeFdfffVq73cQmDlzZnU3m+ZsYt8+//nPhze+8Y2Vc/3mN78Zdtlll3DHHXdUTgchfkH0/vvvH//cNNCeFI4mF5H5xP2c9FcYV1111fBwHPgQwuOLTgmfe9ti4S+L4ujnuOOODgsu8HJ4eeH3hikLzKguDlUoLRcs5kHp6mNI9Uzrou/TctGxOj06rrWpC0htT+ulbUVjmx7Lab+lv7ljENPGV2TGTUCvN+ozTW9NS/NNX3jhMPvFF9kx5trCzbU6rbWsND2C5Zya5tlnw7Gbbhpmj42FGJsvMDYWLnrmmbDEEkuEJohMJjqZ6KiiYe4TTz/9dLUFENugOZp491qKePdaZDg333wz62jiOKZfHG2KSeFo4i2D8QtPjz/++ITj8TMaxEgP44virK1D2PeWEN74/Fg47ifPhiM3nhL+vPC8E/q1SywWFpr6bHh50cUnOBrO2CMjSt9z4AyJZJxpOmtdTWExdsg5SONC20/ToDxtHUYu0vKjJBM/o3Hoc+yl+RA/R2P14rRpWUEMTZOCS29dC/S45tRQmQhLPPNMePnVshZ4NQBoew2ik+nb0aQOx2LDakSFJ34fJz67L94yLX0PKP4GTgySNt544+r5a5xTCpP9rrOoYW6yySbVF6FqxIGLn6VBpvjdciEcu1kIjy0cwswXQ/j3n4+F5V4Eiy1MCQHYVWpoNJahTfy6PJRHY1B1lC21BRnGJveO5ETU9f+0Dem59DNNJ0XIqD0as2kLznCm5+l10NqVU3daJ7q+aRvoOdQ2yWmgNtd9p/MsbZvlWljOWzG/3vu0yiqrhCWXXHL8FeV/hPh9nPh4m+iE4k8PxEfirLPOOjDtmmuuGc4444xwySWXhLPPPruymfFhs/HJ0bmYFIwmIkph8UtSm266afXdmS9/+cuVN6ebXRr+ssiUcOTGf3UytbOJn1NmMxa9zBR9cqOFa5Ww6ny0nPQcMsKSQaB5UdpcyShnYdN2IgdRH6d9TtusRb4WB66NvZQ+RRNn1tYYSvIU53i4+WGZo5z0xc012s7c+caltc6f+REPE9mOYzPRecQnE8TtgPjEgWgT41MGkLOJQXgaiEcns/baa4evfe1r4dhjj81q36RxNB/4wAeqxzvEuyyinhp/GjU+jpveIGBBdCqas0HgFhJa6FqUi2QMFD1bjIMkU2Xr30zkrCFNSx0GPcfl5RxtW+PSV7SdlocMslY/veb0PS0LjbkmmdFyaT5uDtB5nc5XzvlIjgfNRynwQue7BlIASmPs1fqssl1Ud9ZYY43qfVR5br311nDSSSdVzkPDQgstVD0mJ32kjhWTQjpLf2Qo/lhQvHX5Zz/7WavHOPzV2UwZl9GOuWMsTHsFy1VWQ9TEMFsjdWQs0MLTIkutjqbgIml03hItSw5JS28xSCUNiib9aW1JrxUywpL0lWOMpWAEBTK0XMmB0WNpfu26cPODa/dkxty5cyd8lUNC3NeJ0tuKK66YXc+kYTQlUDOb6GQuWnVKeGmBVC97ddIn6bkFgoy4leZrxpWWpzkojbXkwiqfIUPElUffoyiZptU+5/bXem04liWVK40FxwDQPKDMkOaXGIAmZ6H6rP2jdaHztP/SfOXyU8zP0pn1btr4nZl4B2383tC5555bPYvtiiuuqM7Hh3vGJ0TX+zvHHHNM9dy1yICeeuqp6vFdMVDfZ599Qi7c0XTgbA56a5joZAik6Fyb/BbJKi3XIpVw0hhqX1u0ifyRAZOMmsVx5BibriS3nGtnla4swQvnsDRnlraZc9zIwHP95GQ5bh5yzpljY1x9aEwmM5544onKmcRf5ow3DMQnREcn8+53v7s6H3/pM/3C6pNPPln98Frcalh66aUrqe3GG29kbx6Q4I6mA1AnU911Bua0pF2jBYb+I2gRK0qHFmOphZgbyVNIhjL9LBl0Gt137Uw5x81F6E3Kp5KUxcnQzzQ/V45lnLh5lrZZAuc00LXi2si1aRDQZL0SyKnv9NNPF89HdpPixBNPrF5dYFLt0fSF6q4zRtpJ/4+nb2H4OBlDy5OzSKlG3gac47QYEjqOtDx0niuLS2c9T42+1B4L2rSlydyxXs/UgdfvUR6OXeZIoekxVJ4l6OLyOwYLdzQFUDEa5S4gi3afs7chpbcuUmT80+hSy29to2YI0LhZGA8XYUvjIpWnyYt9RtTSfNECF8nxIgdNzyFHar0W1uOon2k/LGwByX1SGx39wR1ND0gXLGe0czVli+xFF6cUkaJ8uVG5BZwhkJiA5pgsEa70WTJ2bY5L6XL7k+MsrfOGyqyWOZSWQctCc1tisJJDSKUzqR/cfo00z7ue0w4d7mgKSmfIwFuYSy6TST9bnJcm5XF5OVjSWuRDri0Wg2Wpg9aV034JTSLkNnVqLJZKnRJzSyUxrcwm11ByUpJj49gVLVOa41Zm6ygPvxmgINJFgowhPW+h/bQ8qV7JSKD2cZKRBM5JSQ4jrSc3f5fjYymLgzVvTFffyaO1KVcylMpA+TjDnssIuTYj2StlJpZyaH2c1IrKa3M9u4BFLegao+I8ndH0sEejaevU6XCwRv1pek6KQuVxcoXEwqwylyXa5cqmMoslAqf9zqlXO5YDq6PIaZOlDORw6LjR8ZTakL64oIUGK7ReVIdmnLl1oTmUtizd0S3c0fQILuJqo91zUhJa5DSS1/YcJOcnyTFcORZoUS9iYTlRv9SunGvThgnltlM6ZzG4nJwqnctpS5omnVeUYXHOX2oDHfM0GJIYGxfUOQYDdzSlAOY1igTrzyiKN1VjSEcXPydx0DKbsoC6HmQIOONO+43kRq5MjenlSCpdlEHBjb2WXrq2moNtEiS0mWccM+HmFSfx0SBJOi45JeRE3dkMDu5oCkB7enMbxiDWS3RxFP1JEoZUt8Z+UFuoYbBIatw+QlpfUwZDj+XIK33KLl0EGakj4gw2cuZc2dTZp07T6oSpw6UslaZDxyQ2TvsjMR5Hv/CbAQru0XCRuMXAaYtXiu65/zQNbWPati4WpeQ0OEOfOh7EVnIchDSGbRhKLvqsi5MV0RxsIpVJQYM2h61OzdIOrh6rFFgCHKsriVFhac5oCt7ejBYzJ1XlRl/cokUOxGJgqJZeGhYGJTnSnAi6abvaokuDaon6pbwaK5ScfvpeMuja2HHjwTkH5KS0/BZjPyrGeX6CO5oCSH9hk058LkoXyxPOc8aCSmQ0ss2Jbi2QpDipLxKzSR0Kx7xomTlGxMqMNDnPWr71OlqgzR3puKVdGvvQ2KKUF9WrMVxL+fWx3HY5ysMdTSlMwdGfJAkhcBEaivyoE0GLjtPnOUeB+gC7a9TZOafLpUXtQnsEqN7cCJvLZ3VIGtqUgxgJGk+uHqkcC7i09DqlDohrBwp0kLxH60nbwa2LHGnP0R/c0RSWziYcF2QrjplYjCFaXOlip4tU09JRPU3lBsnw5/STOlBUh9WwSfVp56R6NDRlRiiPVerS2pEaeZpGMvyoTDq30uuiSZ5trm36ngvuHIOF3wxQ8GYAU1pBysiVtKg81lTWoAZBa4elPq3dKJ+2D0CjZ9r/HMkxd5wt4MrNMeBSPjRv6Jhw45gLxH7pXEIyLdc2qT3cNdTmAwdNwusKXABQEqPiRJ3R9ABNypBkCSu4hYlkBhr1pdEoigSbRPgW/ZwaRK2O1AB1yVAsLLMJOAPXtFwtYrewv/S85LTS/JagQwo0uPyonShg4PpJ+6cFFtb57Oge7mh6eKgmciSczp7zlGWaBx2zHLcYeQkWw8MxkvqcFq1KUg41ItSYcWVK/ZVknqbowhlqxrZpeyRJS2J8GuOw5OOuH3WsiE2l77n/aX7HYOCOpjAsbEByQtY6OEmCW/BI1qjbQ41zF4xGM1hpHq5+6gCoEUrTaJq/1JdBGCTJATaV2qTy0HtqmNEYasdz2A6at4jJoLbR9LQNg7qODgx3NIX3aCRJoUprfIilBGrEOSNLDbVV8kLQHJtkGGg+jsFxTgM5ReTIuKjXOr5d69/SeGuMgsvHfZbagMaVk7iQVImkLzT/NEeFgIIH2kZOQqRtdwwP/GaAHqSz6piyKastnhSShKTVa4n4LIuUc46SEeN0d9QfVAbXTu4cMo6p4UT9tMhJuWgynlpebvw5p8Hll+rlxt/KdFAbuIBICsiQZEbL4dgvLackcoKYrtB3fU3hjKaHu844XTk1eMjxmOoCESBnGGh6jW1JbZBYmMWR0LxS9Joep8Yjx4Ckhq2N8c8FxzBRHSiStyBlH3W5nENA/7kypb5wzgc5BVROE8Nf9zN3vTjDGSzc0RRkNNqi5iI+lFYy5PV/xBxSA8TVjxwDdx61XeojLVMyftxYoPx1PhRJa23MdeIccsrJkeu4ay21TQsa6GcUfKB20HmE2kDPI3lLuzYc6nT0x+OoI8251qPCAuYnuKPpAemC1SZ+jpzFGWtOikrr4uqU8lqgGTzOueX2mTNyFnQtiVmYocZSpPP0nFVOS/Oi/1oggZxZmocySjqnNEbDvUfn5s6dO48z4xy4tp6c3fQP36Pp6QubKOq2Ohhk+CXpipap6d+0fmkhttG6OUmMayNKg5gRalPTdjbJZw0OLIYXyYXcOek8krak8ZcYEuc00uAJMWfKcLj6uHbTsuj155xuV0w0F1wgWRKjws6c0fTwCJp6QSAjkv6HZTFGlJZPz7WN5LiI0+qQrGVzSMcsPSZJb1ROsdZpcfhdQCsbOU2N+UnMgEsryY+ovVxAIjk1VA/XZwRtHDTGhPJpdTrKwR1ND79Hg6IdJAGl/3MMM5fHwmRQemtUb42mNGZF0yIjojmYNC9Xbo5E1yWs/UdsI9dAW9siORhUvuSkaHrOQaBzSCrTmAr3X+vHqET/8yPc0ZTAFD2yK2n0JKklrYPWpR1v0x7JKFDDghwdGrdUtqHnaJq6jCZOW0PXZVqMYxdGM8fxc22TmEaaN10LmozGtQM5JtoPKcCKNxQ4mxkM3NGUAJnnXNSXyyBQmeg4MrwWI1tSSrIwNs2IpW1Cxsay92CRr1Cd1jxt0cQpaRG+JKfW563ybco4uLGysJH0vcawtfJpmVI/ndUMBn4zQKk9GsVepIaRRoHSwo/n6ls9KdK8kr6uGZamcgNXLucAuMiU2wegfeTO0/YgI4baSY935UBo2615OOdJy+VkRvReYigpKCvhWCE3tpzUyY2xNvbWscsZ464xCEc2NiJyoDOaUns0yQ+fWSaFRe+uP1M5KC0/XbiWSDXnuAYU6Wp1U0OWntMiWqsh1o5rEX9btJHjuLal80CSJevjkvPm5CzJYUjHuDZbmIs0DhKLQmWNihGeDHBHUxDWCExKm7NY0CJvUm4bg4ucoMWQSE6ZkwPTz22MSp+6fY4TTvNo+xL0GOfwcwyx5PDTNklOinMk1uubptHa3iSocvQDdzQFwck79D2SgqxA+nn6HpWLjlvlslwpjUIyfsg4cuNEz6H2a8Y4Pde1IeL6mRN8pPksaTmJlGPAWp2SrCbJZ+lxzuFpLIy2AbVHcsClZFBHM7ij6fF7NBPSMAs1JyrTZDVaBxd50vIlAyO1TzunLXaODXEMSds30PYHLO3m+qIhN+JuCo2xagZaYiUofXpOkt6kdmkMBx1HARPXNy69Y3BwR1MYnIRADbxF0uCcVRq5plEkNSiavq0ZQoujkM7lMiUaEXPMEEXuue3POWc1Xk2NnHQtJCZgZa0onaU82r56vDnHzrWfCxi0MUjrlepAfUZ9cvQHdzQ9/B4NWojU+WgLQjOEmiORos+SSA2LhU3QdiInzLE2Wp5kyHJZgSW91jc09hJ7zG2zxPiQgdaCIO16WRyUNHaWepAMKI0Bx3JR+x39wW9vLoUxmb5bpBwLy5hQpfEOJKp90/S59Wplp+WiNqPPnNRnSdcElBXS+rh2pHkt4AIKyTAixmaN7FG5iBlwBlyap2lZ3JzlZDc0BhKoc7Sw676dSt9B3CgxNGc0pTBF3iOhxqNp1M2lpVG/JMdZjIGlHcggSqwNHdO0dSki1vT6pqyLays6nivdcXJWWh5yKtRJSHMN1U3z5/abymZaHyX2w0luiMlydVja7Bgc3NH0/Hs0SL7oerFIWrnGonLKbuKIuGMcw6IGyuo8NImlCTQnwhnT3DK1AIVLK8mJFsfNnUcBktZX1Bau7RKbQu8dowd3ND1CkpWs0TJa4JKckubhDBEqq7TR1uQV2taUpVkkuaYG39o/1Ia2rBQZVq5vVqeG2tXEgNMARXMgKCDg2JvUF4tj5fom9cXRL9zRFAS3KKhRy5GqNMlC2x+hejo6T9E0spSYiCTlWRxJfdyixVuMmJUpSe1sC6tDRw7XEqikeWk9Gtvk+oscEHJISPpK54LGbNH85AIuDc6O+offDNDTzwRMOE8WmEUnp+UhjZ6LGNM6kMNBZbdZjGjfABk0Lh23x6DJP5Y9gPSY5IBy9gHajpdUbnqMzhV0Xbny6PxA5XD5uGNcPo1p0HoRg+UCKdQPVMcgYGG1XWNU2JkzmoJAEkF9HC2yHGjMJf1MI0gUSVqi4ybtkyA5DslJc8bRKqVoshNn6Ln2W2UfznCjfNrYaFIfnVucQ+LK0cZSGkNJFk3PS1Ka1HcLpL46+oc7mh5uBqAGvQtDLskYaLFqkaJUhxYto3ySAbQAOUhrGktkaTE6iEFy56X8EvOxGj9NVkPGnWO5lj40daxpnzmHIjlbjbWidnDjkTPXHWXhjqYU4i8FMBvz9TEpYrbScLqg6nycVCIZHC3y7NJgawaOY3q0b6idGmPJaXsX6bU+dwHKXHIhXQ/EDNBc6poJS46Jm8tS353RDA7uaEoBrDlO8qCLGRkmizzDGVpOaqIRYSlDiNqoRa50PCwGJCcaTttihUVuk461MXSWtlqcjFVyTY9x0itNi6TY9JjFiXDzGfUPzWtpTjujGRz8ZoDCj6CZ55xhYxoxIAsTofKctGhp/V1JetY20uPoMy0jbXN6TGs/J1216TMqS0MO20j7lLK4pvUgFkDrsLYXjbtV/tJYsmUuonI0h4PSdA2rCtElRoWlOaMpCG6y0/P0ODrPpeOiTokRSA6oi4nLRfLIIHGfOY0fRcqSAZEYTBujk5O3DXNCDoNjrhqzo/kkw0+vGdcmNG846dI6Dihd/auyqGzkLEfFAE8WuKPp6WcC6s+WKFwyGJpB5YxHuhAlSaeLiC9nkdOImDMWyPAhSSV336Avg5Q7Jsg5I8ZqZYCUFVG2LDEgiwzFtUdyUhpLQ8ESkue4+U7LculscHBHUxBSBC3JYpq8wJVJI1VtAVODUxqSYeSYWv0eGVtkeHMi25y+t3FIVtmLCzpQf7SyJNZav9cCDOrQuXagNqL2IZlNajc6ns5xSz7UP2c7/cMdTcE9Gk1ioOey6mCiN0lOQgwAocuFaNXkURpJZuPK0Mrkyk/rQe9r6aYJLIGDtc1aHRSSA0CsB+WXZDEkrWkBFPpM56Y0f7WyNDiz6R9+M0DPPxPQxSTnpCIpctYiXJq3LdORmAVqP5ISOenR0laarsn+QKkoWIvILXWhMjiWoo2bNEY5DJFzltL4ozlL203Lo+msKM3eJcZeCqPCzpzR9PgzATWQk5CidQqL5IHScXo5XYCavKG1mbZVkmy4dNz5nIXVhyyWWz5njLowgMgx07Jzx946h6T3VodNZbomEpsEZzKDgzuaHp4MYLk1U9Om2bqUx/5rDkyTN7S6ubyUqdD3Uj6k+SNnpbEVLcJsI1U1gbRHobWFHrcyInSNJCartZ9joFz7NTbEpaflauxtfmMA8xvc0ZRCMp/TRYkWlpVBsFUByQnJJOn5ul1cm7h6tHZwbbNIWJxUwo2ZVh7XP67cYQA3BlYDSfNqfcwx2Ol1RM4/bafmiNJ5aWX2KG2u4xjGaz4Z4I6m1M0Ar0pnFsksV5+3Shxa1MvVlWuYLfo5F5nWxzi5j2s/Pc+Vy9XdZzRsdeSoPmnMNVnVcu1pIKC1x8JQkFOhsliaXoLULi3Q4Nro6B9+M8AAIlQaFbZZbJyjomXSRd/lAiyxmJF0JkmRFvlQYkklo2EL86rTcXmloEE7z9WJnI3WZsQkaX5tn0U7z6Xn5jQHrp2loEm1JTAqjtQZTcE9GuvC5iK8NhE0J8HQeiSmkVMfhZU9cEY2lb0sRrouo4vxKwnOmUjj1USyzHFAKB1iJlpQw0lb0nkNVhaO8uU6Jkc5uKPp4fbm6qPhWVzccWlxaec47ZyLQq1ts7QhR1LjnBUywuh42jfuc277tfRNHFnO93E4Q5ljMFEZaTmaE+eCIcS0UPCC5DNOQqbH6JqxBBHSfHIMDu5oCu/RaItAM6Y0/XgdGZIDOm5diBYJJidvTkQq1SfteyBDZynTilyDzzECLT3Xfus1sTpZi6TEORdaTpoWtQkd48pE11jKk8sEHf3BHU1PX9hEGngElYektBOKN7AcZJi0SLBpHTVoBGp1aih6RYbG4iy4sWvLEDkJqA3ayI6WsqkjQUGMZLQ1KSz9n5YlzWFJttUkXW0OOJMZTgy1ozn66KPn0erXWmut8fMvvvhiOOCAA8Kyyy4bFl988bDbbruFxx9/fEIZDz30UNhpp53CoosuGpZffvlw6KGHhpdffrn8Hg2xH2iBS3o3fZ8TYSPJwxKxSm2R0qfQmBnqHzV2SO7hykBSGjJc9Dh3zMLQmho0jtHSunOYKBpPyjzQ2GrjIjlAbq5aAwGaR2oL11/k8Ghb+3Y6dC729RoFDP1dZ+uuu2740Y9+NP55wQX/1uSDDz44/OAHPwgXXHBBWHLJJcOBBx4Y3ve+94Wf/vSn1flXXnmlcjIzZ84MN954Y3j00UfDnnvuGRZaaKHwuc99rqx0NsbLDl1QfKp1c9o3TZuml8ouAWRUuGia6x9iPmm+9BhnpDRnLo2PVf7iymvCEul57pi1XZKzksqWJDEugOLKk5ytNP7onCTLaXkd/WDoHU10LNFRUMyaNSucfvrp4dxzzw3vfOc7q2NnnnlmWHvttcPNN98cNt9883DllVeGe++9t3JUK6ywQthoo43CscceGw4//PCKLU2bNq0XRkMNZnqMi9LQ5zS95qxoGokx9Amrk+WibC6KQ2PcFBZWw7WtabmWNlmYCm0jkh8t7dLmKk2DytfYmua8aBpujGmatG53LMOBoZbOIn7961+HlVZaKbz+9a8Pu+++eyWFRdx+++1hzpw5Ydtttx1PG2W1VVddNdx0003V5/h//fXXr5xMje233z48/fTT4Z577mHrnD17dpUmfeVCi5qRFs0tJM1YSIZCkp04tKXjFnlHYgxcm3KNalvkjIMlbZtxRfODvqcOSJp39VzgnDfHVFA9aZ60zPQzGocceS79j9qBykN5HYPBUDuazTbbLJx11lnh8ssvD6eeemp48MEHwzve8Y7wzDPPhMcee6xiJEsttdSEPNGpxHMR8X/qZOrz9TkOxx13XCXF1a9VVlklu+1o4aKFSd9rDioti4s40Tm6ODkjJdWL2oH6K7EWxDykvlj6y0lsbdG1YWorV+Y4M6vEp0X+1FFojIHKm1obOClUckKcA+Pa1cVcsCBdY32+RgFDLZ3tuOOO4+832GCDyvGsttpq4fzzzw+LLLJIsXqPOOKIcMghh4x/joymqbOZohhcSf7gFisyxsjYalo2Yj25/aPlamVRx0D7Kjlj2l8uD8qXthmVgc63AW1ffUxK3wbSuFM2hNJK/ZbGFrGKnH5a0nOyGz1Gy3MGMzwYakZDEdnLm970pvDAAw9U+zYvvfRSeOqppyakiXed1Xs68T+9C63+jPZ9akyfPj3MmDFjwqvJD59phl4sIyMvxwJovjQKkmS0XKNHHajEyiRjmMuGkHzCOY8cR5hz3FJOruGzsFqpbah/lNkiNsmVQdNw84gLPGhbLXNZYkxaOe5ghg8j5WieffbZ8Jvf/CasuOKKYZNNNqnuHrv66qvHz99///3VHs4WW2xRfY7/77rrrvDEE0+Mp7nqqqsqx7HOOuv01m4UuUdoiz1Nx0X5kmGmZdC8Un2WYxyshhVFt5rR04xkDkOx1MW1NQe5hi+3Xk1C4Qy/5hCk8lLnQuvnggOu7Wl52lhZJbGugijHJJDO/vmf/znsvPPOlVz2xz/+MXz6058OCyywQPjgBz9Y7Z3svffelcS1zDLLVM7jE5/4ROVc4h1nEdttt13lUPbYY49w/PHHV/syRx55ZPXdm8haiiKZz7nSFDWOKJJPQaN5JLtp9XOyHdcGS1moTiRtcGwEyVwo4uUYGieTSeyHG5M24K6bBWn/JOkL5UnrltplTWeZe7TNqP11evrewoS19vZ1TR3zkaN55JFHKqfyP//zP+E1r3lNePvb317duhzfR5x44onVs6PiFzXjnWLxjrJTTjllPH90Spdeemn4+Mc/XjmgxRZbLOy1117hmGOO6f0Lm5zUU6VX7p5Jy6DlpWUgQ4zSNlnAFtA+SvVzbeVkH2Q8U/mmiUGVjqG8XcMqK9JztM/UAXHsVyo7xzhL1zMneJACEpTW4qi7mMdNoTHLEhgVhjbUjuY73/mOeH7hhRcOJ598cvXiENnQZZddFvpE/YXNarILd8JIERxKQ8+hMtExTnqq06YGu83iRM5NYkYcqCxDy6T9QAaXawO6BrkRcK4R44wlNwY0HTKyHLOQ8mj10PKRI6AOjmsXd/05R25pB2qXJShzDB4jtUczKkCMpjrOGA9uoUmLiIsGkeORyqLloTItbaLgjAAy+k3qR+OHyuEcRU5faJu0fnF5m4yr5izSsi1OLK3LKsXRPBx7SdNagqQ0L+fULGvAAo5BO/rBUDOaUQW660ySerjoPMeop/XlOjTaBmSIJvRvypQwd+7cSrbU5B4pikfsBOXlIlg0vui8hT1K7bfKT2k7NFjGBaVrUj4nu6H60vxaeuuckZiN5Fg4hkrbZb0+nGPsCi6d8XBG0wOQrJNzPndCo8VqjVjpMUk64tgUxzq4emj7kJHjDJ40FtYxtbIGy3ntuuRG1VIQYW0T58S587TNNA1n+K1lSHVbHE9at8RYHcMDdzQ9QTN2KHJtUhYy7LkyQ1NQo5MyAs05ce8RU6DvufI54yy1wXLcmi5HDm1TD0pn6VM6dhTcmHEGvonBTwMIS760XxKT6WOuO/LgjqaHn3JGUbfGbMTyDZEcMvpS+lJI+44iaa7NnJFODZ1FAkKQIuXcslDZ6H2bMuu8TdgMOmdxEpyERa+RFBBofaDXUHKQqF7OGTqjGT64oym4R6MtIMlIpouySbSIZApJMmmySJto3lZNHeWjn626uzZ+mqFt0862yBljznkiyak+nhMESW2SAggENN+os+LapjGZHIbZJdI29/myIj4vMj7Kq37aSfzKxw9/+EMxT/wJlviw4niHb3xAcdM7eN3RFGQ00sKn0aCkY2sSjFVvn9BG5vsWuU4DtU8qC+n6VOZDQLJYOn4py6Ht4z5LfeoSudenaQBgkZxQPdK4aWxPqxMZQ83Jp9fSuh4QLA50MmHllVcOn//856sn3992223Vz6vssssu7JPs4294xe8xxi/G33HHHWHXXXetXnfffXd23e5oegK3aFJIi5ZLS6UHlI47bzEEbYxibjkW58dF49peg5VJlTRG3P4GhTRuVrbBlcWNkcYYaV7aF1oGZfP0s4WBautBKgON82SX1Hbeeefwnve8J7zxjW+snhn52c9+tvpl4vgleISTTjop7LDDDtWvEsff+Yq/5bXxxhuHr371q9l1u6MZMKToTltw6FxqgDUHVf/PYUFa+60SFmUkWr2U9aG60H6BxBRLIcfA5baLuwbcWKIxqT+jceL6kB7nnJ0U9CAGyp2jfUr7SQMN2mdtrEtf/0HJZk+T38+KT0qREH99OH4h/rnnnht/NiRF/D2v9Pe+IuLTV+rf+8qBO5pSePXJANyiSCNCySFQSAsYHUPnOVaA6siRfVBZ3HktLWoPyqtF+Gk++r4r5DJC1J627eLyc+NMmYq1D2jsUXAjlck5FtQ+xFxp+9F7jd3Pb1hllVUm/IZW/E0thPiQ4chi4rMe999//3DRRRexDxjmfs9L+i0vDv6FzVI3A0zBslC6gOhip+e4qC6NHJHjStPW5ya0TymbHjP3W9mTsZZB2QtXjuRstHZ1BY45ovqlOZD2O9cYojxI2rLmTY9rTop+lsYDzTtJTqTrgLIdS+CTEyiNMh5++OEJP2fCPTR4zTXXDHfeeWeYNWtWuPDCC6tnP1533XXFn2bvjqYHoAiWGhsuKuMMLGdcpM+5TsZyXjOMmpRBHSZyoKhPkoOV8uf0zYLc8tNrioKCJs4GpeWcDBpnydmgY9wcpmUhB6QxUM4Jo/bnBhhtrvOwY4bxd7PirxKvscYa1fv4Uyu33nprtRfzta99bZ603O95Sb/lxcGls57uOquBFg19P6Es4TiK9lOpQZLGaN2WRcsZBEt7pXLT/1w7uehUkl6sRqW08aF9TNsqGdM29VmchxTt0/mEyuAcCgfLXKEBBEor9Y+bD/Ozk2mD+Cgpbj8n7t2kv/dV/54Xt6cjwRlNT0ByQXpckxvQMW0x0UUrSU+SrEfTS44LGQGpDxoQ60nr4fqDxsXSxxKQ6uLGtG192hjmsCbNkaRsRWKiKLiRrqkme0nHLOy+a3BSY0nk1Bd/on7HHXcMq666anjmmWfCueeeG6699tpwxRVXVOf33HPP8NrXvnZ8f+eTn/xk+Lu/+7twwgknhJ122qm6eSDeFv31r389u53uaAp+YTMFWoBIPrNMHMlhpMfowpfkJGmBaxId51Sog+OcBgLXHkk64QwiMj59Rrcc+0PpujZUiAmi66UFFhoro9KYJN2l6aT6ufZIaVFQ4fgr4i8NR2fy6KOPVjcMxC9vRifz7ne/uzoff504Pii3xpZbblk5o/hjkf/yL/9S3RZ98cUXh/XWWy/kwh1NQemsmuzGxcSxE87wSNIVdVpNolhUtjUP52CkvlgYkFanJf0gDFB6TbinXiMHrclf0vWR5lyO46ZOBjkdyzmuDjpG0vEcNirWEyYnozn99NPF85HdULz//e+vXm3hezQFIRkEbiGi8xwk6Qwtxhz9XGuDxWlaDQMXDVMDl5ZJnRcn6dBzg45yNRnRyvq0PmlGPYdR0vZwjFprM6pbKittR52PY0pWiXLQ13+ywhlNQdDoiVsknK7cBpyRRixHqzfXaaE0WoRO60DRPSrbMmY5kfAgYB0nlD5nTOn5tCw0vpQZS/Vp1wvVi8rn2sQxM4lxoXpLYtgZzSDhjKYgkAOhi1YzpLkRLYryJXaQRoqW8nPB9R3VxY0N6hsnD1raorXD0pccWKQuqR057LF+nzPWOW1GAQGd55bARWo7DX7onJbmJmr3qBjj+RnuaHq4GUAz2pycYgWSlWi56X/JwTWpn8sv6fZNI/26HO6cdCxtG3fcwiRyDRdilBo4Y47OW+rQgh4rOJmOlic5utSZWOUwOpckVkXbOYwsdrLBHU1BcA6Avs+VdCS5i2raFjmhhKRE60f1pONC3yPHS/uTGqG6fNQ3qY0UOVJcLqzjrMlJGmOxOgMrOHZBz1G2bL0mKB8qX+oflxbBGU7/cEdT+Aub0uS3RrpooUvaOso3TxuV54VJ+XIgSXKoLUjGQ1G4JOHQvFybS0W6Fnaa6wDReUk2kowxdeyWOqV+SIwDBRpWmU9qg0Wekxybo1/4zQClH6rJPHpDm/x0AdN0VHZABhoZgS4kMXSMYwe07VbnpkW/XNSPGFybPjdhe5YoXCqTjhMXkEj9l1gDkh0tzpga7xwDzrVVArqOOazQ0q4ugcakjzpHAc5oenioJucoxDIyIk1kzDUNvMvFl8PGkKGyOGJO+tFkSaksS78GEf1yzkS7dpwhlsqwGPu0/PoYvWYp07Y4Vq5eK1unzB6lcQwP3NEUBGIfNZD001V9lvJoJFtqgeZKZ8ggaQ5JM5o5bAKV2xZN6peg7T1IjA45CEubqGFHDp9zDHQd0Pza+HBs2cIcHcMBl85K7dG8Kp1NMSwmTVOv00yog5GkaNmI1aRprJFtF5CktBqcTMRF61Lf6/Kk6FmSLLtCiaDCUmfOcQ5UqtSYNjff6jx0vkkMy8K+BiGRcXDpjIczmoLSGWUy3ESUNHJt8krau8QE0nRdyGLouBa1cmyEMyzIOWt9lKJjNO45kmXXyDWUUnoqUXIMBLFtCZZ0abm5abnrYa3bpbPhhDuagqARoGTwm0RjnKFFrIAek6JOa7ssUTNnzKijoPk5h8A56vRcjnNscj2aGjOLPNU2KtecvEU6Q+c1ic0aKHHXW+pL+lkra9CsxoHhjqbg7c3S5Kcshy5oy+JDi06TInKkoab7N6hOa/u1+iXJD8lrUrSeY/S4/uWcawNJWpJYojb3kGPiGBCqk9aNggwaEElzQmNCmlTmjGY44Xs0BZ8MQNkMMoKchMTtSWgLPVfjlqJoKV/TfRjNEHCGBo2llJ7mS+tGBpgbh9Qxt5Vu2uTnmGmT8ukca3M9pbRpfagcej79rF0P7jwtp0/kSJBdYVQcqzOaHhgNAidh0DRaGTR/rsaN5LY24AxNXbZkHKTjKRuTHKi1/dw4oUAApe8KVikvJ40kS6Lj3DVBhpNj0RxjsV4vS1CE+mk55hg83NEUBF1skkFFEba0yNECpmnTRU+jRkkWa7NYNakGlS8Z9FR+0RwWApWJctlZE1gcJ21ffT5XMuVgkb40aRQxDeokOHmMcybpy9oXrm85QYtjsHDprCfprP6vOZ3xMgx7D+h9mlZydFL9XS5WJJ1pBjdtA+eEJIkQlcONofV6SOCujXTNpHI452+V75rKaqi+ury0DK0d3Din7ZPayrUbqQDc9UOBW2kn5NIZD2c0JTAleQSNsIGtRXXWqA8ZU6qNIymkhMzAOT1uDLjFj6JejvkhA0TLQHXlyDRdMRgNVgMu9UtyCIgZUkaSlkllMFo3ZShSv9F10gIP2j7UHq7/tG7H4OCMpgTiPJ+at3dgicqkvOl/CsRy0vJR3Vq0b4kQLfIcYl0cu6H1cm3syoF0FQW3ja7TMbFKnXRcUKBB0+W2iaurbhMKrDSmqrFwaa7StmnMqms4o+HhjKaHmwFQ1BdBI8uuGQYn4UgODUWLlghRcnLpe+TociJgTh6zMLVcOakro5QT8XP5LeklZyHJixrS8UUyGk2jQQokKONCAQlqH9duSzpHebijKbVHI0hnbYyAtng4B8BFW/S8xiis7aqPSXIPkvQ0WQbVaW3vIA2Ppa7cQANF7HQcOedKx05Lx/WHc6CSQ8hheCgIQu11DDfc0ZRiNK8+gqb6zBj4JlGmtsA49oG0blp3juad21bJAaK20vdWdqi1Q5M3Shgwi5TX1OlxDJGrk2MkqD2c80f5qZPTWCW3NnIdHoe+r7FDhjuaHn7KmYs6TWVl7O0gw0wNBtXAcxdkE7kpZUtaPppWkv1QucipcNKMFW2Zj+V6d2H8aN+5fYv6cw7Lkq4rPW8NKiztyAl60iCkhFN3NIffDNATaISZykZUYkqBIncu6kPSlyRXWRecJolI7c09J/Wvfo/azxlES1+ps6bHLCxSkkWnTp3aaC/E4tS5YECTLXNZDU1P5xqtk/YFQWOlmqSG6hwkcoPILjAq7MwZTcGbASTJxiKntJHOqFyW1osWsKSp57StyWJHDoNGy1T6Q4xMkgVpO7n6pWOW9qNzWkRP20UNPNc+jW1IbdUcmtWApfMYMVHEJinr4JiXNkdR/pTVOIYHzmh6Asdk0mP0vVSWxFTqcrg2SJEjMl5WB8IZLUukzvUp10l04TD7hNZHyzhwYyJJi+iaaMyVY3iUxdD3Ut3cGHDrwToPBwFnNDyc0RR+MkAawVnkHm4xo3z0M2UAKC8qgxqdrow36ktO9EwlGNTeOn9XDGRQkTCK/LX2SIxNY3U0LQo+0vxoDqPPTViklIeOg0VO5Op0DA7uaAqDSgScQdeiIYuUQh1byaiPc3boGMekLFEzclIW6UtqVx9ow6ysbebGQZPykPPmnLnk5DVnaHEmWlu5dBbHw+Vx9A+Xznp8erMU8VmMMAcqndH/FpmlreOxGHvJuLWVDGk5aI+gST9y2VKaz3KMOycZb+6c5JzR/LIEL7R8bQ5L14MDx6ikNqG6tLJLS2ounfFwRtPD7c2c0bHKASgv+izJYen5lP10iS5ZkjUqlxx00wjW2g5rPcjwlkRqWJF8q0mRFNy8suRHbUFpcliqVm/u9XOUhzuansAZRBrxWWQIaz2cg5HQRl5AeXMdGuc0uXNc3dZ9DgTrPoOWHuXryhnnMEit3RJDQgxFykPTSccsTBe1h2ubtV+O/uGOprB0Zo2+pWOasUJ5JINEF2vXETxNa9XwNR3e4jw4Z9cEdFxKyou5yGFRTdmVJl2h8rT6aVokcUqsVAqkLO13DAbuaApDM/gSm2liTLUy0B5G1xE8l56yOKkualA4h0gj21LynbTvkWv020TabSQlBGtAYtlPyRl7KutxbaPX3rL/RNPlnHOUgd8MUPChminSRaFFcdKxXA2d+0xZlsa4coyX1D7aBq5dqA2onZZ25eyLWA15Xa4lDx3vJuPYxHlIZaVlSoxbCoJQn9B8sswzTqKjbeY+a+gyGJHq6NuJjY2I03RGUwpTdOOIorOu9nzoubTOJhF20wmNjBoqUzJkqC2aYUqPlTQsTcZASkPf07oscpdklDmnj+qzsF7aJoltc/IoupZp2nTuUtkXldWlfOroBs5oCj+CZqqBMaBFphkUypAouIXLsQVJPmuySDnJw8I+0vYg5kXTcu1va1w0FpHDOHPaojEfyVlZ2IzFAXPOiRtnC1vj5iy9xm3qGKRDcUbDwxlN4dubLREsWsjagqEMBkkXUv3pOWnxWh8IyZWdtomTCyUnhyJwKeK3HtfOWc53CRSdt2FLbVhP2gaO7aA5o7Fleu01ppTmp46oT1buaA93NKUA5jSKxumi5dgJXVy5C8uq26MyrGxEawcnF1oMpNYOOjYoatd0/y5gYaFaOmuQgYw9Yq6oHUiKQvVYma6FAXHMTpqnFtlRa2uaxp3NYOCOpgTifH91znMLi4vmpcjSIhloTKLJYrOyLJRHyof6zhk+2gepbM7oNImCu0AOA7Pk51iGVK4k22rOHc0dbk7Q/RWuXKkvlnNN4Xs1g4E7mhJI1gfSotPjFr08R0Kb0IyGLMaa35rXGsmnRgo5E+psrf3lZCnknNtCcgJNy7D2y8oGEfuTHLOlT1YZEs17S1DC5dfa5RgO+M0APT3rzLKY1HIN0oNWB1dGX9GfFs1ye05pm6jRzGVcFhaZA+uYog1t6ZgFyAlzeygoKLFIUmk/aR5roJT2M4VVTqP5NZacM8+7gqY6lMCoOFZnNAVAFwOKJjWjgiYtWmTcnge3LyId6wpdszNtL8ES3ZZgGrTdOfnR3GjSLm6eSHMup62S8bQ6Rs2Rob6jAELab5PGwDF4OKMpgVfnd7XImYWSRmgo2msTjaHomJPwJjS7gyiw6R4QZ9CoodSkFTSGTfYRuHY2gSTx5Y4Xl57b3+qC2aK8Ulto+Ra5lPZDGzOO4VjrLQFnNDyc0RSUzjhZo/6vORaLAaJlcEwApZXKagoteuVkK86wpE5Ii361yJ2TeazsToqoLZCucRNWZDnO1W2V6lKjntsmS3ouEOLakZbBpRuEwXfIcEdT6ns0U+Y1hJaInHNEKC19r0FLWy/QLo0K53BpnTQtVwZ1PE3K0I5zny11SOCYSAlI0hxtE5prdGyplEXfU2eU4zhzxsDCVizO0dEvXDorCEsEzDGb3MWHov7UuaX/6TGuPskAWdpDo0vLXgHHZGh7tHZ1IQPSNrXJzxk/zRHUsIwdKtdSZtpG1GatfGnucOVybaHXWyufQ5fX3wqXzng4oykIyk6kBdbFoqALmzPM6FiX0TY1nqmR1fYX0GfaF9retOxcKUrrg1RWV/KZ5XxTI6YZde2acLKvpS9aoJKWh8rUpODcfjsGB3c0Pd3eTBdIG9071/BZo2ZL3U1ADYlljwRFwbQc6gysEbgFFgaRa8wshrKLSFyL9NFctJSnOUEa4HBMhKZJ01LHxjl8bS/GZbPhwkAdzfXXXx923nnnsNJKK1UT5+KLL55nshx11FFhxRVXDIssskjYdtttw69//esJaf7yl7+E3XffPcyYMSMstdRSYe+99w7PPvvshDS//OUvwzve8Y6w8MILh1VWWSUcf/zxvf6UM7eIaqD3iIHU7y2SF30vyTfztN9g6JpGllIEzZWP+pxrYJoa7660/hwH0oVUx5XFMQaO+WgskjqJ9JwEmgcFIlLggPpjOe6YhI7mueeeCxtuuGE4+eST4fnoEP7zP/8znHbaaeFnP/tZWGyxxcL2228fXnzxxfE00cncc8894aqrrgqXXnpp5bz222+/8fNPP/102G677cJqq60Wbr/99vCFL3whHH300eHrX/962c4l64yL5iVZw2o4pKgPfdY0cq4eLr0lQkf5kPOU2iTls+wXSJ/7gNXwdW0g0djmXGuJASFWyeXNkdukdqR1aszNMTwY6M0AO+64Y/XiJsqXv/zlcOSRR4ZddtmlOvatb30rrLDCChXz+ad/+qfwq1/9Klx++eXh1ltvDZtuummV5itf+Up4z3veE774xS9WTOmcc84JL730UjjjjDPCtGnTwrrrrhvuvPPO8KUvfWmCQ+pcOiNrQFoUaE9FrSNjTwUZbE6esrTXWieNcOl/rS+UjVFYJTdrm61oKm/RPnN94sbJOs5cWzWpyTp2HLPhnI7U7yaMkTJcDjTAK+18LNJo1xgVhzq0ezQPPvhgeOyxxyq5rMaSSy4ZNttss3DTTTdVn+P/KJfVTiYipo+Pto8MqE6z1VZbVU6mRmRF999/f3jyySdh3bNnz66YUPpqI51J0CJCtS6woGn0L+netJ6uFgtqC5INaV84psRFx5wTpXVLbbQep/XkwurINRZgNeLWMbEEQda+ILkrl8Vz85NzqlygIs0nR78YWkcTnUxEZDAp4uf6XPy//PLLTzi/4IILhmWWWWZCGlRGWgfFcccdVzm1+hX3dZqAGlm6MGi0mf7XFi5iJhamkLYLfW4qbUjpLc6LjhE1FNo+AIqy6TmrjDNs+r5V+kORPu0rml8Su+IYEufUuOvNBT20Tdp8LzlXu0Da/z5eo4KhdTSDxBFHHBFmzZo1/nr44YfzCxmT2Yp1sxZNJjrJuEUvLUqp7CYRrpRGYxbc+bqf6XkuIrY4T60dJaDVlSvtcWMgGW56LD1nYZeoHk2my2VCUh+4NFI50nFH/xhaRzNz5szq/+OPPz7hePxcn4v/n3jiiQnnX3755epOtDQNKiOtg2L69OnVXWzpKxtTeMdAo/X6GCxmypQwd+5c1fikRllzQtLxLqJEKQLXjEuOcZDKssKavmn0qDFM67GIpjIQGldrGdwcTa8ZDQhyykTnpLI4J2fBKDGA+Q1D62hWX331yhFcffXV48fiXknce9liiy2qz/H/U089Vd1NVuOaa66pDHPcy6nTxDvR5syZM54m3qG25pprhqWXXrpcBwxzmi5WdN66sCzygiXilNqZmw/Vz8lWXHRM5Zi0D0iCsUpAuf1pEx3nskDJyEqyHyqDzp8cmZUbb1QvYuKcTEfL4tgo1z5rsGNlPo753NHE77vEO8Diq74BIL5/6KGHqklx0EEHhX//938P3/ve98Jdd90V9txzz+pOsl133bVKv/baa4cddtgh7LvvvuGWW24JP/3pT8OBBx5Y3ZEW00V86EMfqm4EiN+vibdBn3feeeGkk04KhxxySLF+0bvOUgajTf4mRp3q3txnFJFqkCQUa9tQWVz9nEGRnKhFnuqC/XSVlysvZ6wlJsQ5Fi6fRXpqwoBRQICumXbNc+psks4xn9/efNttt4Vtttlm/HNt/Pfaa69w1llnhcMOO6z6rk28DTkyl7e//e3V7czxi5c14u3L0bm8613vqu4222233arv3tSIm/lXXnllOOCAA8Imm2wSlltuuepLoKVubY7gFlPOPkJOXZboMEWOzJEji6SyR44kRNualkHL46JkizOxjI0VJYxYV84r1wlZrq90TdEcRNeFzg/NcWkMnJME2wZHTSEx51IYFTlwoI5m6623FgcqTpZjjjmmenGId5ide+65Yj0bbLBB+MlPfhJ6Q+zSq09vntJSelKrEvZj6KK2yi60nNwoG/XXIgFKMg0yikhuo+2V2o7SW/YHtOO5+xWSxMTlSdtvKTPnfA2OiXDjzM0biUVZ2onScn1wFjOc8Kc3FwSNrLiossvFwRkFi6G3litB0v65NkhGQ4qic6UcjVVy+aUI3FJG2l7OOWrH2p5HrEMLUqQycuasxJykdkiOPbcNfcAZzQjeDDDyGJP3KOrPdZouKHBaPqfRS9E6bRct2wIre+McMFdWOkaojxLT4dojGVbOWfYFbq5wn9Njdd5UfkwDDus+CCqnPkfLpWVZ2UYOe07bw2HQ182B4Y6m4M0AnKGMoIs3TZf+l4CcBzIqqK4mkXQuOAkN1YWMmcW4WowVZ2SlsjXH2iSazhlfLfiQmB4dY4kVWMaWMkjLPEZp0XWQGDC6jml7tH4MG+OZzHDprADqR9BQCUBajDQqt8g11KAg2QExAbbdjOTTBJIBsebjpB4knaG2onRN5D+EJk5ZKjf3XDo/cse56TXl6pPYqYUd50q6w+pMXDrj4YymFMiTASSpLGdRjhefoXdbZKo2chnXvrqMtA1amZozppE16iPXfkt/BmEs6no1RoacJnfOwoYsDooz6prkxtWlMXapD+jac33Tjjn6hTOagtIZp29zTANF7RaDkZZHjY/GSlBE2pbZcP2wRLJ0bFJHwjlJqQ5Ln2n9TftdGpLEZBknVJaWlquT5uPmHOcYLX2V2q9dP84Bl4QzGh7OaAogfXqzxCCkKDRnkSHNmmMQ3GdOM9fagkDzc1GsFFFr0TkydNaInvZZS1cSqA5L2xFo8JJj+KRrw80rxKg4B0HnlXatuHGxMpZhChAczmiKolp0TJRMnQPnPKwsh5bLRflc/SUXKe1Dbj7E0mpYDJuFvZSAhRFxRlLqr6UMNEYcC7K0gZYrnaN958ahLVNOj3Pp+4QzGh7OaEpJZwqNt8pZ3ILSFheV4yRmQ7XvtB1dIKcPWjQvyY0o/SAjW3otmrALK8tF9dbv0bhpjl8KdLj2cPObsiCp3xqz4urjynMMB9zR9AAkY0jRT65xTI0HWqjIGFvqbmqkrRGmZAjSvkiMrwlT6hu5bdPkzS7qS6VbjhGmZXGsiZ63yKN1PhoEWQIDS4CRlu8YDvjNAAVAf2EzR4OWjHSOFp1r3JBE1RRIitMWPyeTaek0ViSlQ+X2AU7GqkFlM248pXK5OpCkZZHjUNm0TFS2RdbkZD6aX5J76bgNAi6d8XBGU1A6q8Hp2BQ5MgCKDjWZRGpDTlSZA03aommoMaFRM42AEVOUInUOfTIijnVa26S1lXNc1vx1Gdz1kZhmWn7TMbUGBhYm5hgOuKPpmdFQp9MVxad1SGWi820WZs6CR5EsHQMuMk0dKTd2wyyXSPsXucbfCknSsgQ2KADhWEb62TIH0Xv0mWtf06DN0T/c0fTIaCzGlJ7XgBwXzW+JlnPYlOU8x5qoYeWMDOcIOcnJ2gYLOAfXtlyUP+c6a8aVGyNk1JG0xtUnOXbUTqlflKVqfUFtQv1CfehyTjjawR1Nj2grKeTs2VCD0ibyl/ZVcpAaGGr86NhIxshiOFH7rBISSqc57raQxliSH7n8nGOkLNI6J1E7qMRJ92xQuVwggeZtCquj066TZSwd3cNvBigonVULA503bGhbZAdJyqB7GfW5NA2X3got6rTkRVIa11/6niuPk3ZynW1XsiZtY845ZKgtkbp0rblyaX5prCm7QGXRMiRmrdWFnBiXVkMpWc3C1LrGqDhNZzQFYTFsORq9JJFpCzY9hwxBV4svR5LLzScxIoszyWWUXRsk67WR2A0XsXP5JMciSXhUqqNjj5yWNr6U+Wj9pXkpg+L6yvXJMTg4oymFMTm65KJu7hiKDq06N2IvtA2lgNqAQPuKpBiuH6iMtCxNluHS02i6KZDEJBl0jbXRz8gBWRwLxzxQ2zmZTXJuyMlzLBsdQwGENJZcO/qCMxoezmh6+D0aaeHR49wxa7RGy0XSBTXaXUd+qO0WqUZrCzKskhyTnpfK5eQdK9vUovKc6D3XqaH0yEFSZmIJWqgTrI+l/7V5nLaHaz86htgSZVWoDRKrmuwM57jjjgtvectbwhJLLBGWX375sOuuu4b7779fzHPWWWeNj3X9WnjhhbPrdkfT0+/RpP8pujD2WuSZ1kXzcQ6Qa6sGqZ+cgZIcBu0T1wfJ+VgcQQ6ocbM4Msv1yG2LxTFLbMJSHyc/aoyiTsc5Q6n9XJu1a4vWAUpXAqkz7PNlxXXXXRcOOOCAcPPNN4errroqzJkzJ2y33XbhueeeE/PNmDEjPProo+Ov3//+9yEXLp2VwphNI5eMrBQFSgaKGmZNIkmPa2wkd7FKETqVxui5um3UWHHyCWJJpYwLNb4WOa6NBNc0L8dqKCNA0hpqf/qZnpdYkSa9SeuDpqVtzF0/kxWXX375PGwlMpvbb789bLXVVmy+OI4zZ85sVbczmlJ4dY4j42jKbozA6ULkFh1iBMiIc8Y8F6lh5RgT9547psklJdFmL6ALg2dhTCg9Z/zrcyggSdNxMmsaUaOgSQtOLCyappGcn2VM5mc8/fTTE16zZ89W88yaNav6v8wyy4jpnn322bDaaquFVVZZJeyyyy7hnnvuyW6fO5oevrCZGm8axTehwLRsaaEiR5QyAC4ybcNiuHZJhgHl15ym5lgtzp07JzHGXOTmlWQilFZyJm0YKgo+uPmjMS7J8WntoHVx9eUGLl2jCxlsrKF0Fp3AkksuOf6K+zES5s6dGw466KDwtre9Lay33npsujXXXDOcccYZ4ZJLLglnn312lW/LLbcMjzzySNbYuHRWEJWxAzIAkgNQtJYDi5wmlS1JFG2hRdcWY58aO01moX3l+tNUXrHmk9icls+aHo2LJJ1a+2J1QEhyo/VJAYE2L3OAmJW1T6OOhx9+uNpLqTF9+nQxfdyrufvuu8MNN9wgpttiiy2qV43oZNZee+3wta99LRx77LHm9rmj6eFZZ5bFxRl6zrDW+dPPyKhRBsW1iebn6m9rELjyNCdEx0yLXtP8TeSVNlIZTddF0KCxM8pGufSIpUjXX3L2yLlxQRSqR0qr9RGVXSKoaMviS2Ps1fqik0kdjYQDDzwwXHrppeH6668PK6+8clZ9Cy20UHjzm98cHnjggax8Lp318MNnTZgDpcbofF0GTStF/6gcbYFy7ZdglX1QHbRu5Hg1VkjTo3K7QI7xkgwskjBzjVh6LTmHg8rV+iHNYyqfWfJYjlscap3X4kTmZzZjRRyn6GQuuuiicM0114TVV1895OKVV14Jd911V1hxxRWz8jmj6UE6485pkZwlskNRnpTXwmq6Zi1pH6VIOsfA5rQ3py+WiBq1I6dMxBJQ4GABJ5lx6XKCkDod6k9aBscuaN/peRTEpE5LWhPSXO+DvYwiDjjggHDuuedW+y3xuzSPPfZYdTzu6SyyyCLV+z333DO89rWvHd/jOeaYY8Lmm28e1lhjjfDUU0+FL3zhC9Xtzfvss09W3e5oeoDFiVicDCeJIPnAstg45yTlR3k0xoCMG3IyqHxaj2QgrQbG4pQ4NtUGOU5Jcxgofa7DoQEAYlXc3EUMOs2XpqXv6TxD/U/Po3ZIDG1QTmaQ0pkFp556avV/6623nnD8zDPPDB/5yEeq9w899FCYOvVvQteTTz4Z9t1338opLb300mGTTTYJN954Y1hnnXVCDtzR9Awu6otoSv85g4Dq6MIY0zrawBphW8aN638T49OlsUrbF+/asQQAqAxNYkSfqeOS5EhUnxRIcNeDptXmueTMtTnP1eVotlavvfbaCZ9PPPHE6tUW7mgKABm+0ouAk2bQeS5Nei5XetPaRqM9asgkZ4sMkWU8NQeE0IQJcnVT557j5Dnj3kRSs5StzQ+NUVqDJak9GtOUnJpljEuvwWFnNIOE3wxQAuDaawuVyhhWpIaaM+bIkFsjxxygsrn3kiRC+0Hfc1E6fa+1E+WRxiHHmFqcvTVvEwaqtdXi3Olc1SRNre11mWk6zvija2uRNTVn5RgMnNH0BKQ9c4u1abSc5uXkDdoWrnxLP+hnzfAjB6FJZrQ9SPKRpBcLrHm6NlTWCBvNlSZpKKzsELFlLa+1TI5t0j5wAdQwOQ9nNDyc0fSAdOFwBoCT2xC0KBNJUqi8Loxyk2hbMlwSUF8sDEQzul2MSxM0qUdiSjljqM1HmkebS+h6cGmsSBkQLRs5I8fwwh1Nqe/RjOFoXpIJKDjDYZGoOMZkZRFSuyxt5MrhjJvVYFBDaUlvYYiofV0ZsRKOSzPo0tyhDFgbSzRvuc9WGVKqK+2HVaJL4c5n+OCOpgCqxQDWGLcILXIIOs7tzaTlInmJ1i/2Q0GuUdacpCUvdQaSo85x7LSOElKZBU33gCTJkqbLGXPE+DhmRK9vm4AGzVmpXzSfO5zhgTuaApA2Kzmg85yh5NJwzksytm3lDan9VnBOUtoQTj9rdSNDaYniu4K0Xyal1yD13TL3NNmR2wfhmLqFZWrXNGf+of63ZVSOMvCbAQb0rDP6n0urAS16+n5C24hToulLyjzWaFSTRWh5aCzT99I+lrX9XUTHObKlVm+Xc4eTxri9K4nF0nZxTFpiHeg6cvOTjgF1Wn06G+ueV5cYFdbmjKbgs86kPRrqbLhFi2CRwTiZgTP2XS9ILtLU6pSMmFWj58qmdfS1mJvKlBIjrY9bZSdaZk4ZSJ6lLMYioXJOgq4LKViidUlsyBnN8MAdzQDASTk5+ZvIRRRokeYaLi4tx7RoGyUjyjllrv05xrXP6FVzGGmanHNt9j+sSB0BkjOR8+ecF82bOilULspP20Pb6hhOuHRWCmO6ZNOG5nPMRJOM0jTWtrRhABoD4eQkqU9a+2m+knIggkUWbVqnhTlI56nMZHVWaVokVVn7ieZt6nDodUZtRfPTcj1Kw6UzHs5oSu3RTNGj/DbRphTNaRq6lFaKFHPaS2UXqf3UwCA5BRkZrc+DinBp+yRZLAc5fePakDIISYpsInGm15orl5PJ6s9SvTkB2jDMA8ff4IymMKjezMkouYsBRXuSQ0AGAEWm6JzWRo2RoHRWBiPVTRlLl5Ft6Sg4ZyxzmKAlv8QOpLq4suo06Wd6PqdMKT2atznz5dU3oQSc0fBwRlMYVB6w6PQWQ6MtYEn6QkZKck4apHRNJTiubbTf1sibO8+lz3UylutK32tptfIlJ6PtdVjKkt4jw845OU4uQ+c1h9Z2LpaSUh0ynNGUwJTEoL96iIvgUTSuRejISSADjAwEt6jb6O5tIEXgmkPU+ozSWNEk4ragTXukMjmn05Y5obpR8MQ5aMt5dJwDx2rQ+0GgjRw+P8MZTQFYZaSmETgXNVI5RDPQ6HzXCyU1JJL8peXXnCDnbHMhOdlBSGmWepEMJjkHtEdiZcj0MyoLzTVpzuUwsVxVoA1Td3QHdzQ9AC1mjpHUi06L8qV60s80YrSwmBJas1Se5hCp06Rt5IyK1UBLxzTmaEHW/gHImxP15wQqaAyl+rWxbyI7SsEHrUOTvZAq0HfA4MBw6awHoIgzN4JFMgVNLxlC7lxapqVtTY1tnZcD7R9n4OhnGsXntM9ihLpgSV2MWY7UhSAFEDmyH5LN0vNpmdJYavKXNB/bjGedvwRKBGgaRoWdOaMp+AgaLbqyRoA5kWw92bkoEEXokuRCj+UucM6YawacM7B13lTCsUa8fSLHeDcpL5fdSHMtR7qU2kPnHndNLZItcqxaIGENCoZljkwmOKMphVd/JmCKoKFb9yw0o4XKpXUih6LJaV0AOTHUH46pISdnZXRa5Ns2MpZYBhpTydDmlm9xZGhOWAw6Ld/inHJkM8t8465ljpTZt0NxRsPDGU3BZ51RoIWSvrcavlx5B0lMOcjV3FF7OEMktV2LwtH+QI6Da2uIrOPY1Ai3ba/FoXFzrr6OkiyJmHNbY5sGP4Mw3I4ycEdTClPy7oyii1oC50i4iJGWrRmsposbGQekvafHaaSaGhpqvDjDQ/vI1ZsrN3WFHAchGX6uPEmiTRltbttQgECZMCdt0nJyQduN+qbldyc1PHDprOAeTS2dIQdSgvJTuYzuc9CFazFqTepH0JgLdVKSZEaNDufAm/SjhNyS2xZOJkLvUfnWecaVR/Na5Fw015o4d0nGo2WWmMNt4NIZD2c0BSHtF9BJWSr6kgwWWoyaXi/llcBJgygqlsq3Gi4u6s+RsdqijaOz7v1I0hYqR2I3VqCgJb2OyCGgMqT2pYEHN0e0sh3DA3c0BUGNOl1cbRa8JiVoUT7aH6LtbCKHcFIZlw9Fgcg5WvZcUBvQOUmGa2OkpCi/aRnSeSRTWvJ3sYfClUvZhlaOdq0oM+fmr6WNjsHBHU0PNwNwElYbQ0dlshpoMXKLmkaMaRk5jAs5UVQ/yse1y9JvLa3UXq5dnASVUy5FX4bQEvFz+x7cNdACBSmwyGEbEpND18TiVB3DA9+j6QnI6HZtcKyGjktDo8ecKBkZNM0ZWPZjUN80eckKjfVRCSh3rwXV1xYc4+SO0etqYRnaeysLpXnTdCjoksZZClrQfOCcXEm205YtNsGoOFtnNAVvBsiVnuhi0yZRE4NLZTIp4s0tm9bDtVczFohlaXq+tQ2oTnqMM1hdGaku5TntGBpzxGpy2onmDJfOMg/oeHPXhc5Lbu5q9Tr6hzuagtKZZLA1Ay8ZUFSmJgNp5yyLMMdASobMEpFb2mKV9rj62xpSSx1S+W2kuaZt5NiPhSlQNoPOU3bCMR3us/WY1l93KsMFl856uL05R7pqCs7pcAsUGQtJushtG91Dkhiaxu64NJLsVZ/vsi85kNiStneF8tB25DpWyUlpspR1v4Y7hpyO5Ixou6n8x/Vj0HDpjIczmoKwRPWpVJRbLq2Dk8JoneicdpzT5S2QpDoOiN1JUpqlL4M2VBbnkOMEuLKtaS3OR0uXXhdLW5Hz564L+o/ksVHZp5jMcEbTEyy6scXhcFIEMgwoauT2P6zRdY48ZImArWkR45IcB0o/qAhYi9zTc5ys2MaYcv2WWCzHBjVnIo0xleCQA+PK11gX6kPfcEbDwxlNCQhz3bJgJFj3FVA+Ggly5baNEGkdFqPEOT7JOHOLnP7v2/hIhp1La5EVc6Q2ybEiNmFxEHU6yfnVx7nziOVb5ov1mLOc4YQ7mgKQ9OYcI9S2Ts7o9BUVaqyJyof0HNdmxOrSPkqSZR/g2JlkGFNY5oiWho4pOm5hz1wdksPhggR0/TnmpIEbt0FfeweGS2c93AxQHRMWlOSYYPlMFJwubClq1T63BSdtWaU2qr9LsiMn7wyToclhIl2mq0GNPYr6kcxK06TpuDKl4AIxozR/eky7hm2ub6k9HZfOhpTRXH/99WHnnXcOK620UjVxLr744gnnP/KRj4xPvvq1ww47TEjzl7/8Jey+++5hxowZYamllgp77713ePbZZyek+eUvfxne8Y53hIUXXjisssoq4fjjj++lf5IsIu0vWKDtT1jPaZFg00Up6fFc26x1UidE8wybEcot0yKxaYbYOh7a+CPHgZwK5yQQg5LmGBcE5QRpHAYlpToG7Giee+65sOGGG4aTTz6ZTRMdy6OPPjr++va3vz3hfHQy99xzT7jqqqvCpZdeWjmv/fbbb/z8008/Hbbbbruw2mqrhdtvvz184QtfCEcffXT4+te/XvZ7NGO2yJseR1G9BmnfBdVNpTSOeTRlBihS5aRDqY9aXlqn5tBzmUCfaOLgrA6ZIkde0urQHD1yQDlyodTW3PmZBqwlQPen+nqNAgYqne24447VS8L06dPDzJkz4blf/epX4fLLLw+33npr2HTTTatjX/nKV8J73vOe8MUvfrFiSuecc0546aWXwhlnnBGmTZsW1l133XDnnXeGL33pSxMcUueYkr9fkere0oLQ5AzqRGiZmgHPMUSSRIb+W/vElZ22K3XUFqOTY1ib7h3klC2BpkEsVSqjCyeC6pdYASeroTS54JhOo3JGxDjPTxj6mwGuvfbasPzyy4c111wzfPzjHw//8z//M37upptuquSy2slEbLvttmHq1KnhZz/72XiarbbaqnIyNbbffvtw//33hyeffBLWOXv27IoJpa82j6CRjC/M3yBKszADWj7HaprIEVLbrA5LahPXD5qPRnm5UqAkI1rL0GDJr42rxgq4cbCyCW2s0/JpwGK57lxwYr1elCk5hhtD7WiibPatb30rXH311eE//uM/wnXXXVcxoFdeeaU6/9hjj1VOKMWCCy4YlllmmepcnWaFFVaYkKb+XKehOO6448KSSy45/or7Om2QLtquImRObkOftegYRcvouLVNkvOTnADXvzof1w9aJjWEXLnDaqC0OVJCZuPagOYUvQbpeEtyjiaP0bzcdUXnmvazS7h0NqJ3nf3TP/3T+Pv1118/bLDBBuENb3hDxXLe9a53Fav3iCOOCIcccsj458ho2jgbiwzTVKpBBkBiL6gOuoCbOkVkBFBkzKXjytDy0bFDTolrC+pDGwlOYpcWyUxqv1YG54ypZFofl/qC5gEnK1qlMulaobyobdrc7FLqdEwSRkPx+te/Piy33HLhgQceqD7HvZsnnnhiQpqXX365uhOt3teJ/x9//PEJaerP3N5P3BeKd7GlrybQInp6zLpIOJkpJ7LjWAxnfJtAi4alPNJ5i7zVFJ3sAXSAXCdDz3NOwsr8LG1AjAOlR2ktcwIFCk0l3j7gjGY+cTSPPPJItUez4oorVp+32GKL8NRTT1V3k9W45pprwty5c8Nmm202nibeiTZnzpzxNPEOtbjns/TSS/fSbsQW0uPWSBeVWeen73Ojcs2ANQEn6UnlI0PJsT2OnXQR7ZaMjCWDnL6nxjtHCpTepwab20/hHEeTNkjXLsfJpG3SmOewOaHJjoE6mvh9l3gHWHxFPPjgg9X7hx56qDp36KGHhptvvjn87ne/q/Zpdtlll7DGGmtUm/kRa6+9drWPs++++4Zbbrkl/PSnPw0HHnhgJbnFO84iPvShD1U3AsTv18TboM8777xw0kknTZDGSt3ezDEPTnYwl08WcPpZi1AtC7zEIuUMV3qepksjbqmfktwmoet+Wp1TDtPNZaaoHZxj48aNq5+TXDmHQq+jJAciWJ2KY/gxUEdz2223hTe/+c3VKyIa//j+qKOOCgsssED1Rcu///u/D29605sqR7HJJpuEn/zkJ5W0VSPevrzWWmtVezbxtua3v/3tE74jEzfzr7zyysqJxfyf+tSnqvKL3tocMWVeA4gWXg6bsRoolMZaB3IIbeWK1DFoUbLWVk5mbNLGro2XhbG1KcdaHg0opP0WydlwTLOJdMmxUq5PyGFRJoZYD1eeYxLfDLD11luLi+qKK65Qy4h3mJ177rlimngTQXRQg/yFzS6cjWXxcJo4J0FIZWtyFepfl3sP1GBKxoWyH679g0K8GzKVbym4qF9jA1xZNL9khC2sCbUDtVUqgyuXvrf0y/LZMTwY6rvORh3SvkFT+Sxnj0fSzrUIM81vlaByjCFqY3qMyjHSvgbHcqzOsw/Em1SayqHpf/peKktjBPR8+lmaT9Z5TY/lSJuonXSeDZtjKSU7S+i7vklxM8CogpuAVI5Ij0ll0XSSnEQjTiR7dLVALEaMHpcMCle25mBQOSnb0fYmrGjD4krDEhxw4yCxYc0BNt0X45g4F3A0CdIcg4MzmlI3AyRAC2ZCesVg0miQW1xIi0dl0IhQa58FMV98IgNyWpqeLhk2VA9Xv1XntzC1JlJOV5CMca5zs8ifkqNu2keNxdCyOUfCXSvEdK1MvRTi3a7x1XedowBnND3s0Ugad/1fMn6aLCYtRiqX0IVocQpiX4GzQm1A7eOYT8o+uLTIwKSftfZa+8W1r2+geZMD5Nhz5DipXiSdanO7CZvmAhJ6zNnO8MEdTSkkawdFZ20jLku0b2EsmhHg6pLaQcvT0tI0XP2So9aMUG47pDylo2Vt7CwOR2K26XtN1rXOM8scyR33HEaLMGx7OJMZLp2VAjPHNVpP2Y9kRKUFb5GgNNnBIjFp/aBtkJiPdJ62BzlM69gOygC13dOxSqjoHCdfcuPGybscpOuaI2chSVebhzQ4GeT17Zvtjo3IHpUzmlJgrj+VDCQWUqebUCzIRyN+i6zQlXQmQWpr+l6Sweh5lAZJbWn5bSSnQSx2TaLKLYMbf6sciPJIjqgN60DzUmM2Eht3DAec0ZSCYtPaGj0tgkzfI4PbxT5GV6DtpG1AUTHKUx+v8yOnWqJvOfs+XLtTNDGSFrbDSagWpiDtl2nMKIfV0GDJ6gxRfo61l4IzGh7OaHoCNQIW3doqoaC9HykK7Uoes4IzUukxTmqT2sqd4/YerNJN16DXxCJDWc5x0iRltdycSNsjOSbKwi194eqy9J8rh/aPkwK5OgYlqTmc0RR91lk18dPjzL4LF2nRyIwaX27RI42bM8oSW9AgReZc9C7JIBqjkcaLHuOid0ufOGjlaCzTKktK44DmDcfqtGNau9NzaM6g/JxMmabJMfjcnNQk1kE4FWc0PJzR9Ai0oDXDxkWO2kJL01hksiaL1MLGUiMr1ZFTJ41aOSNukYa0fqDypGtiyZdjBOs5wPVNq5MeQ3MEpZecNHUa9Bpb60Dlc2OTO4YlmKmjOdzR9IwcqarJYrI6FqmMNouUMyZWo6zlobIYF/2j8jjEL5pa0iHGaEFO35GhtpQpHZccKuewNOeM5hFXT65jlT5r6ZvU6SgPvxmgFKbYosOm8k69sDk5gUoOqB5JsmsKyflJDCvHOXIRtQSpn8hZWRhjl6AOND2G0qHznJyqsZ86bwqLBGY5nrbBMqZ0/HPkspw1VAKx/r6/qT82IszNGU0PoIshfW+NYLVy68+aFGExOqitOe1oUg43Rulnycg1rZfL14XByqmfc3ZSOuRkrGyLKwe1QZKr0vmL6ra0iZNDJSc7iP0QR3M4o+nhETRa5C1FfAhalMulkxZ9mwheW/DIaHFl0HGgkXl6XmODHDvRxjnnWkiQ9hssEp2lfDoGlNFY+4LGSGuTRXazjDuXXmpP10y8CwzC+Y2NiLN1RtPDQzWtskPThcLtXdBFqxm4tmi6R1LnRYYyPc8ZT61eFC236Utb5F4DK2OT9itymGB9DrGV9H1umbkGmjI2jf2PitGdjHBH0xMkdmFlBNJ5SVPn6kFyTRtobEXLy+03pMYOSSuWvYG0nEFBM+zcMc6pUsObprHUVY+51XhzDtsijUnlc8wFHUfXfFiur4OHS2c9wBJ950ZqnKHlHJplb6jLzVRNY9fSo/bSdNYx5SS0PpA7DinQeGh7K9Lx9LzmqNEc0aRYizSmneOuFWovN48HBZfOeDij6Rlc9NUF7efkhVyjYa1LgsW4So5Cio41mY07Zulfm+ugtSO3vRq4OZSz18IZalpGOu7ouuUwI1qu5VohppMzX11WGyyc0RS8GUBaEKlRaBORURmElmmNqHPbYFm4aZTLMStL+ZpB1ZhZjhO1OqPcyB31n+ZFsqDWDq0uxBhSx6GxAknaoudRfTQw4FgQx2Bpu2m/rNe2D9bjjIaHM5qCkHTkJnq2NX0aOeewiCbQyqGGQXK6HBAT0Ix2Thtz0aQ8zXl0HXHTOUANM2fktTIlmVKb02kabj1wjk2aQ85Whh/OaHoAF+m1MWKcBMdFxhJDyAEyBJwBQlEqJ+/Q42gfgRpFzmhpbR4UrIwGnWtjUC2MgWOBtG7umqK8nNOQ0nJBApoXbdWAruGMhoczmh6AFitdJLlGhJPMJIPcxcKwSkacjk/rbspKaP+QodYckNaHPiFJim2uU844SunqY9xxxDa5OUrL51g57XdOwOAsZ7jgjqaH79FwhgJFiRagaJGL/rnI0qLNS59pe7T8lj5x0TOSfTi2llNfm/Y2ydtFO63gJNOmzJbusdC5I7EudG3ROdReVIe1vRTufAYHl85KIcOmaDJGnYYaVk0+4yJNlMdSv5Tecg7Vz0XyKJKV+ona2LTNubAawCbSWVft5MrWZDlO7qLHakj7KJzxR+w+DSbQOa6t0rUozVrjc876ftbZ3J7rawpnNKXuOot/TMQn6ddp2hTofFvtPi27aaSLwBl8JJ1x9SG2RuUU5ExR30YBXbMdiUFY8lvTIHmL1pteJ9Qeaf5x9UuyHK3fMXg4oymIaoExUpeUxxqNW+WRVPJAZWvG2pLGEh1zDEtjLFobpIh30HsvVliuAQVntNE5midH7tOuAyflUtBgi77n2tqEpQziunMSeUmMikN1RjNkE1HaN0nT0M/aPhByMlYWg8qWImXUNmRIqcFB0qAk2SDDmiNjDcMCtjhnKzjWS49zLy4AyBkLlJ72kWP6tA80LUo/6gZ4ssAdTUFwUZ1Fd86RgygjoAuZLv6mRrkJU8hhXzQ9x9DqY1SGlMpC7ZLGuOuIOGcPRMuXw4xpeiRB0vSIcaTzSxtXbi5b+qjNMevczVlPjvJw6aww0H6KxdlocgEnXXDGVpItrLJe3HhEka9lDNJ2cDIM5xC5fPQ9N559yCvSWCBnT5EjXWpMw3LOIrMhYy3NWW0ecXPROo8kRqyhDynNpTMezmh6hGT82iyEptEaJ69o6dvUi+QxSxuQA0JyG9fW0uAcJPoswSoV5Totjh3mGGtah+T86zRSANVElpOksybOytEP3NEUhrQQ0+PIAEtyCycrIOfRt9GldabtsLRFcsaUhSHG2NQhWPJb0FXQQK9hG2aG5oJlbtJ06WeNGaE2W8ffIm1qwVpT2bEpqCzZ18uK4447LrzlLW8JSyyxRFh++eXDrrvuGu6//3413wUXXBDWWmutsPDCC4f1118/XHbZZSEX7mh6AFqIdKJQgykZFhQpanXVqA2D5shygCJWzbBxeZHhog4F9V1yqlaDmpYvtbktrM4WzRcE2j9JMuTGTgtqOGdC69HGS5OHpfnPMViuTmn9TEZcd9114YADDgg333xzuOqqq8KcOXPCdtttF5577jk2z4033hg++MEPhr333jvccccdlXOKr7vvvjurbt+j6eHJAFIk3mTSc7o20t+Rtm8xttZ2SJKOJq2k6dvKHlajmpunzVjQMrrqq1Q/MsC5Y4DK5RgqmoN1mi7kYbpuUNnaPlHTazq/fWHz8ssvn/D5rLPOqpjN7bffHrbaaiuY56STTgo77LBDOPTQQ6vPxx57bOWkvvrVr4bTTjvNXLczmh7RZvFZInjOsOZq8dQg5jIfzhFK0ooU3dZ5ucjZKiFIUg1XpxWWtFJfc2CRTbW09LN2rVD9XKBjrZfmkZBTnuXY/Iann356wmv27NlqnlmzZlX/l1lmGTbNTTfdFLbddtsJx7bffvvqeA7c0RT8PZo2coXlGFc2ymeVEZDB0haqZLg03RzJZCgt56BzonYkR7WJ9q3QWF9uvU0Nc05ayh7QfOUChdz9A6tzp2VOBgdixSqrrBKWXHLJ8Vfcj9GY0EEHHRTe9ra3hfXWW49N99hjj4UVVlhhwrH4OR7PgUtnpaSzMfxkABSZt5UYqLGVZDOuHU3r5sAZJ9puqySDznPMSaoDyZd9wRpAWB2J5LS5vqXXxSIn0TmDxg4xHElCk9gpzSdJZKjdOcy9a+Q4165Q1/fwww+HGTNmjB+fPn26mC/u1cR9lhtuuCH0AXc0pZDMdS4KK7EgODmDRvUSW+lisWpOg55Dzpfq8jSPxWHkOtNBGiorLHsjXD8Qo5P6zDkkLVCxOnNpbqB6tLnLtXt+x4wZMyY4GgkHHnhguPTSS8P1118fVl55ZTHtzJkzw+OPPz7hWPwcj+fApbMeoEVilujdUjY9zpUryVldLFBL5Mmdo1IaF32nRozmQe3QYJHghgUcA9BkyTo9HT+aRqovrUeK4LmyrUxKOy/121JuCaSSYZ8vK2La6GQuuuiicM0114TVV19dzbPFFluEq6++esKxeDNAPJ4DdzSlMCYv+HSSSM7EInGlEhJ9T8vn6rJEiRo0CYUrX3MQXNRNy+TkJKsUhdrSJaxji/qPrjcHq8NFTtzalhwnhaRLVKbUF8mhlVYJ5hcccMAB4eyzzw7nnntu9V2auM8SXy+88MJ4mj333DMcccQR458/+clPVnernXDCCeG+++4LRx99dLjtttsqh5UDdzSlkMz31BBqERr6LBlnzoml77lzFoZjQarfN3WU1BFyUlqOUUPyTU5+mr5p9C3VbXG8kvNs4hhRnzTpLP2fHtccNBpPS59p2pxAqM3YzM849dRTqzvNtt5667DiiiuOv84777zxNA899FB49NFHxz9vueWWlWP6+te/HjbccMNw4YUXhosvvli8gQDB92h6uOuMW7T0eFNIjkRjCLl7GKgc1H5qlLQ2U0fC9YMauvS9pd050Tu6TlJeq7HVxoZjZl3AEmggcPOVOiBUH8c4UV6O+UqMWGprn8iVsrpArnSm4dprr53n2Pvf//7q1QbOaAqiqVTSdDKhqM/q0NpGxk3Kszo5zhil761sQUMOg+Hyceek6B85tLaSkEWmkq6B1icaOFmup+bMkfTLtVNDW6bu6A7OaHoCJw81YTPUgHARpWQIrBKEZBikSNYCOh70GErDHe8K6Np0XQeqD/VbY6oatLmF5lFal5W1cOVooOWjc9wxtH4s83UyM5pBwhlNwUfQWLRitDCsEa8EFBlSw6UZB8tit0DT8i26PZXXJDmqDZBhyilXMmaahCgd0+rJYapUftRkR8Q4UBp6ndMXB8mJobyIoaH30jFH/3BG0wM044MWi7Y/gFgAjfIklpDTpq6ZnNYWTvJJz1k0ezQeWr80aUeDFCSga2PJn1MPLd/qgCU2QBkxxzJRnznGwQVAqD/amHF96HIezw/POhsknNEUBEf1aRqNwVjr4WSftA0W9pBbtzWKp6wkdYSSM6JlUcahSSPa+RzG2cRwaVF5W9A5JEX9XNss/UrnD51zqN70PHKAlnopM7cyL/R5VGSm+RHuaArfdYYWJAJarFZNXErDOZAcYyS1xyL1Wc5x8h6XpomEp5WbnrP0tW29XBskIAPNSWGSrJQzz9I6kVOzOgtLPzmn3ETGRO1wDAYunRX+mQBOGrNIOVIEzkWSmhOS2I8Gi8SVthHlt0g6FuZBDSDqC+eYLGMuOUNLOWm9WrDRRJrTghbNEWtBB8dE07yS3GZtm9Su3LxWlGI2XNBVEqPC0pzRFGQ0VBqyMhHpswZkNJB8ZmU61roklkANk9RHKq1RWS3tE+oDjXwl49TVItUcZi57tDpCaYzRuFnbjRgSvXac88p1FJpTpNIb7W8TOLPpH85oCgIZUCkaRNDYCTLCqB4a9dP2oTbnIEeaQZ+RAePabJVrtP4MyuBYxkPLS8dDcjBckENZsRbkSI7CwnbQ8SbBlwVdsZ8m9TrmhTOaHoEWaRMpgRqUtCxtgXNOpuQC0aQjDsgIcsaO1jVMyG1TEymNvk8/N2V0aE5JjozrQ5o+R9Kj6aS+WspxDA7uaAoCLcj0v5aP03w1lpPmRVErxx5Q+U0cEBex5jCR+j2SySQpqm3bm8CyV5NThrXdbfZ2NDmPu1bpNaH5uD6gwCg9bpHkaLnuSEYLLp0VhLR46vNo4VhkH1QHp9mnSNNRaUozHlZYjT11QlJZErNLz3P9yGl7rrSTU3buOa6PKA+SGlF5FkiyLHdeqodrEy2HOpWmc3EQ0hkXGJbEqEh1zmgK33XWtZw0T12MXMJFrFYD0DWoEaFt1JxyKuNI5UrlNOlnlwwpx8hzbUFjZumzloZzApKDt/Ynh4VI7Jeb6wjOeIYLzmgKIi6EqcregrZ5ygGxESRXIEciRYpdSBNcW7oqg/bLymZyGGKTc1ZJtCvnxo0HYqmUiWiOHdUvOUBULneMvufYE0rHjZHWtj7gTwbg4YymICS5gH5u4mQ4BiNFqJphyW0LAtXdpbKbRMVcHto/jt1ZDH6uY2zKdiwyn5UJdMWStfZZ9nfSc9Z9FwpJBkzngXXsRkVmmh/hjKYAutgb0NLSujjGxBkFxIas7MrSVqTlW+SsOr1krCR2qGn61nG2pskxXhy7TP8jWA215GwQa0jfc6xXGy+JjaC2akD15bAVqb2lmQ0X4JXEqDhPZzQF0CSSpgs+R2bhFheK/ml6S1RI82tprVEk5whoGuRELNKJZFhHbZGj/iPDxh2n5+v3Un1ae2jbuhwPS1kckxoV4zuZ4I6mJ0jyQvpZiwq1vYfU0KRORdPaLVq8BZrjkpxFfT41qtSJUKfTRnIqbZBQ/yzt4srKdfKWurUonGOkTaVZrg50PbU1w5XTtdNztIdLZz0hRxLg8qf/qQHgtHQrc+HySeVL7UzLpbIcV7ck9aXt4PaAclFaSqFGs4uI25o3lSCbOCdLfdKczp3vNL1lnrUJMkrApTMezmgKPussZ7LnLhqkvyNZhPuf05Y2i5ZzMpS1SFKPtb05UmXTutqgjVRlAQo+uLFP/0vjrzHoND8KfFA62h6ahvvsTGV04YymIKoFh44pshAqh4KLkLkoGqXvM+pDEh5lKKitUntpfuu5QTKcpg4VyZ+aUebqoc5HM+CSrMWVR+uT5j2qy/JZu+7SOJSAM5ohZTTHHXdceMtb3hKWWGKJsPzyy4ddd9013H///RPSvPjii+GAAw4Iyy67bFh88cXDbrvtFh5//PEJaR566KGw0047hUUXXbQq59BDDw0vv/zyhDTXXntt2HjjjcP06dPDGmusEc4666xe+shJXPW5+nj6mYPVMEj10T0QmsfSjlygKBs5nrpuThrTxgkZmLZR8KC1fiko0dJLMmVOH9Prx+3TSNez/q8FDKgt6LMknab1DUI+cwyho7nuuusqJ3LzzTeHq666KsyZMydst9124bnnnhtPc/DBB4fvf//74YILLqjS//GPfwzve9/7xs+/8sorlZN56aWXwo033hi++c1vVk7kqKOOGk/z4IMPVmm22WabcOedd4aDDjoo7LPPPuGKK64o07Ep2Gg21cLrsjijQxczWtzIQHAOqWvjyjkMiW2lRo2OneRMpHQScgxzTl/blqExO25sUJmcMecgORVq7K0OnRtnq3QnrSNNlnNMUuns8ssvn/A5OojISG6//faw1VZbhVmzZoXTTz89nHvuueGd73xnlebMM88Ma6+9duWcNt9883DllVeGe++9N/zoRz8KK6ywQthoo43CscceGw4//PBw9NFHh2nTpoXTTjstrL766uGEE06oyoj5b7jhhnDiiSeG7bffvvuOxXmerAXJ4CFJAaWP3zrmZANkpOl/i1aPyu4SGoPRZA9JZuMMvNQX6pS7AGdEc8q3MAwuiJCcVFOHh66JxTEg2ayN1MUFRCjQculsuDBUNwNExxKxzDLLVP+jw4ksZ9tttx1Ps9Zaa4VVV1013HTTTdXn+H/99devnEyN6DyefvrpcM8994ynScuo09RlUMyePbvKn76ykaxDqxGUaL8mudGFLC1YyViUcjIcJKmkjn7TVwpqdLQ0FKX6mcscmoCTqrhxSM+h9nJBUMpeaN31e649EtPi2JIEC1u1SGfOeCaxo4kRe5S03va2t4X11luvOvbYY49VjGSppZaakDY6lXiuTpM6mfp8fU5KEx3ICy+8APeOllxyyfHXKquskt8hwGg0Q4neI6CFj9iLJte1kXly8tK2cUxFKiuVH1HUKsmTpSUVaR8B9aUptABESkfTp9eCc0BWFsXlpRIbCpa4fNJxq0TXd4BRP+us79coYGgcTdyrufvuu8N3vvOdQTclHHHEERW7ql8PP/xwq/KQBEEXt3URcovOIpl0aWglNqS1X4qQLcg14JqE1haa07WMu5WBIsZnKSPNY3VY9Dwnu3ISLq0nh02h9LTOQbBVxwg7mgMPPDBceuml4cc//nFYeeWVx4/PnDmz2uR/6qmnJqSPd53Fc3Uaehda/VlLM2PGjLDIIovM0554Z1o8l76ykMxxi6QlRYcW5qDJalb9G9UvtRWVyRmTtC2IwaB6UNlNo9phMDxSm6W2or2IFMjQc3MqZTDaGHJMRHIeOUGSVoZ2/XPnqmOSOpo4EaKTueiii8I111xTbdin2GSTTcJCCy0Urr766vFj8fbneDvzFltsUX2O/++6667wxBNPjKeJd7BF57DOOuuMp0nLqNPUZZToV/pe0sbr/8gx0LJypLPUoOSwpdzzyEhwhiRXwuIcpNVZDYNzscLCgLjxyxkHKmVp1ySdW21kVe64xDTp2kmdnCST5ra3K6Tt7fM1Cpg6aLns7LPPru4qi9+liXsp8VXvm8T9kb333jsccsghFduJNwd89KMfrRxEvOMsIt4OHR3KHnvsEX7xi19UtywfeeSRVdmRmUTsv//+4be//W047LDDwn333RdOOeWUcP7551e3Thd7MsBYc904Jyq0SiBSJNhWVpLYWhOJBr2n/eUYTw76WqRt92py50aaTgsEtLYhaYx7r10PlE5iLZxEpq2jUQowJgsGenvzqaeeWv3feuutJxyPtzB/5CMfqd7HW5CnTp1afVEz3g0W7xaLjqLGAgssUMluH//4xysHtNhii4W99torHHPMMeNpIlP6wQ9+UDmWk046qZLnvvGNb5S5tbnGlL89GQDtEXBRei4oE+IYEK03rU9yTrn7RRL7aCrdpWWg97Rv1rZr7enKYFnKQvIWuqYW5yjJpRJzkWRd634IYh+oXjovNGdqnUfWNpfAIBjG2IgwmoE6GssgLbzwwuHkk0+uXhxWW221cNlll4nlRGd2xx13hEEAGeJcSYsDLQ9FsFw+LW0Xjo/KM5rBovm5diDH06VhGYaouKkRyZEmqYRGwQUOXJBinW9UNkbl0eOWfmlS3DBc18mIbOkssoXrr7++TGvmE4wR3QwtopwI15qOLmRO8kDpulqAnGSj5dEcC3ecM0RWw9QHLGMiRf9aeu48qpcek+qiadK89Jw0x7hyUX7UVtRvq2O0nusCOfsqY75HIyPe7hu//PjGN74xfO5znwt/+MMfil68+QWShIEWaY7sg+QHVHaaT5JjNCMigZNIcvMgZoMMn8VgWuvtOj2Xz3KduoBm8KV9nPq/du2RzMc5ufozDbhyHIAUjAxLYOHogNFcfPHFlXOJeyLnnXdeeN3rXhd23HHHcOGFF1bf4nf87WcCrIu+ycLjoncpP03DyRW0XW0lPoujQsaO1q8xmty2lU5v7SstWxtvTSqU5gO6FlIaTVqj8ih1MG1ZhMTSrTKxY0TvOnvNa15T3QkW7/L62c9+Vj0NOd71tdJKK1Ub7r/+9a+7b+kIIieSRwu564gbySbWPNbj3DnJWSAgFoOiZUsfULl9oMs9L3SMk5ksLIReD03qSoMTTpLjWAZ1aPSapU5TY9yatEbr7hP+ZIBCtzc/+uij1fdR4ive/fWe97yn+k5LvN043i02WUH3aCyGRzLOEizRJpcHGQ0puqVlc0CRpiSZcPtEqUHVIm6uXtR3Sx+6ABfloza1aQtiFOk5rl0oXe511cZTmmOSQ0RM1TJGOY7IMcR3nUV57Hvf+151C3J8cvIGG2xQPaPsQx/60Pg36OMXMD/2sY8V+57KsEMy7vX7JjKMZDQkuQwZgz4MrmRMuH0hzahY9hzqdGlZTR15G2j1a2OBytOYr/Vaov0ulCYnAKBt1YD6Q6U4Wh6aU22l3a6Qy667wKjsS2U7mhVXXLGiiB/84AfDLbfcUj2WnyL+7gt9EOakwtjE79GgKEszPhQWmSBlDqkBocaEtqFtRG1pU046brzoMWQAqUFq4tQpYv70Zxq6vnYofRsplRtLrk2pLKnV1YQxaOOFHAV3bem8trah1Bx3FHI0URJ7//vfX32/hUN0MvHHxia1dDaGZQxLpK2dS8tK36M8VgbQlTGksDIoLsJGzgI5VeRQujKEbaPmrg2iloYLOrQy0X/Ud4lRcHnS/6jeNC+qH5WRs3bcyYyYo4mb/g7DXWfgyQCcAUALw+pk6vzpe85YcAa+SaROI1sLa6H9ktgKbbfFwEl9k/KUdBy54PY50nOSvMTlRwzXwg40w47mjuQApHZJ9eTM10HJZy6dDfnTmyfLzQCcQeCirxyppP4vMYdUJstd4NL5HDkFRazos0X6yY1SmzjRNuWUNGASK5TGpon0hfKhOizXjM7RHGkzN9BwDA8G+gia+f17NBpLschBGoOhedNyJWPQZJHmSGUIWj9QGzmDIrEzKrfkGiULC2qCXDmLy0/fp+fTNiPWqTFpC2vlZEvuuiHnZh3jnGs4aOfjjIaHM5oeoEV6muzAySGSQ6Fp03qQAegKVsMlRehc++gYcY4bHR8GjR5JVrn5pWuXGjpprK1yk8Q20NyjbNlSjqVtXNqcvI7BwhlNKcT7AcbGwtSGDwOk7zlDzJ2j/y17KF0sVIt8Y907QG1DkbAl6m3CUrqOkBGj01gK16Y2Y8sFKDlGXjqeO2ZccCWtgSb19IFhCGiGEc5oSu3RTJnXGEoLIzWW2j6FpFXnSFfIsVn2AnKB+o6kPim/VKZUThtD2Lchs461dA2pjEWhBSYcqHNK52l6DM0ji/NEToSuBU4KduM+/HBH0+MejWbk6/fa4kdGmov4UR56jpYtfbaC1iWxFCmqRv1BEhQnJXGQjHGfhqtNXeiaUoOf1oHmo8aQ0ByyBE60ndK5nDlGHV5ufsdg4NJZYeksXQJooUuygXUDlJYvMR5rBJuDtnsgEiPjpB5NZtPYklVmy+2HxKCkvjWBNObIQWjzzVIXHVuJRaJy6dzmAgTLuGhS3yAYad/samxEpDpnNAWlM47RaJGk5gw0YyZFeSUWQ9PyOIaVRszS/gJlf/S81ram55rm6YotcuWWNKwcA+fmEzcHEQOn5Unn0v+O0YEzmlLSWXIzgLS5aY3cNBmIgjoyi0TSdSRvTctJfNb2cs6oPtcEJYx2kzGSxgPtY2j1crKjFvjQ8UVjT5kKcqzoPAoQ2oJzXiXhjIaHM5rCjEaSdixRt8UhWVgRcnIlwUWzXL3cWFCjliLdk0D1asalL2klx8HQ9JxB5srlrjc3H6jEmCMn0rycVIbe585HdF1zx9UxOLijKQikR6OFbpG5uEVaf0aLPmdPoI1R1nR2zTBokpIkzdDXIGA1kk0kUXRcuxYSa7TOJ+mcxcEgxpO2JTf6l5yqNb1jcHDprPBdZ5KUkKap39NzKJ3mQFAUTP9LUbIUvZaCJO9wbdPGtolkwl0LqVytDiRjSkDGmcpkmqwolU3TSUxJG3MkYUpOp8l40HZbMIigw6UzHs5oenrWGRelWxaZNoE545EekyJMqR1tHIy1j5xx0lhKE7lHamdar1ROU6PXxvhxzkDru3StJRmOzh9OYtOkPKleKchCrIdj+I7hhzOanoCkipx9GukcJ4MgZ8MxG84YdhEZ0jYiRmCR+ThDK8lA1vZJyDFq1r5I+XKcPicpcWPMzQlUBvpMxxpJpLRsy/zlWCInG2os3HqsSzij4eGMpqB0hhZJulDaOBkuL40EkUzGLUKtLU2hMQYtL2fk0FjSOvuOfJEEmJtPQw5TQ+NgZTJ1Wjr+9THu2tA6LVIhantOX5vW4+gHzmgKg4uqtEgw/ayVicqoj9EFa4kwu4YWraMoOT2esi9q3FAUXEqusoK7vjl7EVJaLTDhWEcOc2nKDqQx464bx3a18UesnB6zlNMVnNHwcEbTEzhJhZMGJNB8qfwgLSrJ4JSCJm1xTIQrg3MsJdC0fI4lWB18jkOixyxRPQ1EJANpMfZce2gaVB5XPmKpVjmPa1vf7NbxN7ijKXgzAHIAEpvJgcUwUYNC/3e98CQJxHKeptEiW0mmsvTNuueRnivl3DSJy+KQubQco0TyKiqLM9hoLknMB0ltkjOR5DhUvmUcHIOBS2c9gC50tE+iLRjJkHL7LpKURBd/F1JDG0kHOT/NgdLyUX3c2KA83DGuD1bkSkxpGvReS0/Hk84DznHkOnNpbFF7pHYjZyTNXzRvad/7dixz586tXn3XOQpwRlPwZgArNINiiV5R1GoxVLnGNhecbKGxOqq913mshr4paywhr1gcYxfnLGlz24LSWmWyOi0y/Jzzk9qJAhWuL85ehgvOaAqiWlyM0dMWSk4dCChatbCgedrf0ulI+0Jc27hyaNslWBiaxAK7jIjb7BHksigkZeWOnQS038L9t5SB2p/+R2uHYzO0jr6dTQk5WkPf9TWFM5rC0KSH9MUhd8FQ2SRdqFyEidrcZKFao2h6nmMvaVvpOFkNuCRJWvIMwmCh9/Vnab5wQQ06z+17aOCCJjSvkMNDbFWrCx2zOCzHcMAdTeEnA3ASUFZ5xvTUONLoto2cliNZSWVSp2cpz2K4OMZk3fdp0icJXJtz83LHLNeuqQO2zCkuHccQpbKtbeYYQ67c7OgfLp0V/JmAkhuU1NBydUnsJre++Iqbj036wO0fSc4XGVckqeREtlrbuTq0tOhcl7A6S2kvTEtrrV86nys9SnOYpssJgAbBaFw64+GMphSSHz6jTiaXMWjGMjXemiPh6kEySo7R0trMHZMMRbpw0/9036eJNNa0D2lbujBmTZyA1l/KQqj0iAwix1S48iUnzzkKLj0nq3FpaNq+nL2jOZzR9PRQzXnSGCNydJ4uZEk6kow7ij672puQ2mNxYMgQSg6xS6ZI2zF16tQJ9TVhgxysETkytBZYnbI0V7i5Rq+JxNq5c02uWxPJtQ84o+HhjKbw7c1NtGsLqDRGy+QiVi1abAJr3zSDl+Nc2iJHCmpbbxN2klNGXQ4aJzr/OAnVcs1SNknToHq4ttDjTSQ8zagPQjpz8HBGU5jRWLRrzZjR81T+oMaASnba8bR9abubGkFNnkP9o2m49iAm2GQfReubhTFqdaB0TY/RttD/VimMSmn1Ma4NGpvh0msOjGsrvb7StR42Z+KMhoczmh6+sJkagyaLQ5OaLLIHkum4qL2k7GB1EnTRSs6Rk9Ok8jk0MfxdGD8rK0TX3lIvxwrrcUaOCjkzKUjKkQg5dsONZdeKgKNfuKMpiDa6fm7ZnLGgoKwARb5d7kFo6TkDh9LTNkvt7ssQWdicxUhq5dAx45yt1A5UjlU6o9eFMhBOupP6zLUJoYl82aXU6mgHl856hMRCJEYiySB1Oq4MdBw5mzbQJBok8VgYCse0LGOX2/6uxkIqn46B5PBR37mym9SdAo2pVBaqG13rumxr+zQg6dTqwPqAS2c83NGUwpg9ipOgae1pWZpUxhmApjKTBBTdSlEv6qeUNkdC1FDaIFkCAGqgkcGmx3Lq1lgGbWMOM0PtyhnTtI/aWHUSVLQqwdEE7mhK3QyQzGYUhVmMotWoaJGvZgS6MNYImpyC6s9hbyV0+5L7Uxb2wX3WHDc6xkmnaZlcekmqQ0wG5UP949h0zjyXnM4gWY4zGh6+R1MQ2gJuWzZa5GgRIqlGKq+ttm2JojnJSNubsIyfdb9CarsF1nIthr/JHNGcjCa3Wa+1ZNhz2t2lA+DmTN9ymcMGdzQF7zrj9Gx6rlEd5K6gVINHxjxNo+nkXcgTqL3pOfQftQHtY3CRbJq+D+PTtFxpXnDHtGsjMZmm+ztpOjq/0s85ZXHlWx1eE8fcNnBytIdLZz08GcAil6Fz6Fvp3CJDWj5Niz5zx7oCNVBcNC1JMlaZEf1H5ZWGJidpzgUFBBrbtMqnXH6pTtQn2q+c8UaONudaS+lQm/u87n07tbERcaLOaHr8Hk0KC8OxGBY6uWn0yeVDbdCQK7VIddC9FvqZi5hLSFtdQjJsUnuaSIJWSSvNmxPopGVZr6mVPdHrreWRZEJ6XOvPZMb1118fdt5557DSSitV43PxxReL6a+99toJa7J+PfbYY1n1OqPpAShqszIdqbwatAzEGizyE6qHGpgmBpHmR22leak0SNOm57h2DcLoSNJkmzKkdJoRlgIEqV3atbKUZWHanBOkjIkrK7dfk5nRPPfcc2HDDTcMH/vYx8L73vc+c777778/zJgxY/zz8ssvn1WvO5oeoMlXbRZF7oLVjLMku3XRPmQcUR8QS+OcC3KwNB9qVx9GwVqPxYjnOiApP3qvMSNtHmnXRnJEUh20jU0DB2c5Iey4447VKxfRsSy11FKhKVw6K7hHoxkGzvCm0HRuGkVxRtfqRNo6F2RguEiP64PWptSg0WPIsHXtUHLKk8Y8t5xcpGNE54g0T2i9SKaVHInmsLi2SHm6uK6lWU461/t8RTz99NMTXrNnzw5dYqONNgorrrhiePe73x1++tOfZud3R9PDFzaRsaWG0aJTo+Opbso2RdC6OalHqlsCdQJW9iZF7Gl7LEYJRdlcmVJdTQ0W51Ck6N0Ki1xkNf6ojfQYx2hoHsv8rdcAdYCa80jTSO2ZzFhllVXCkksuOf467rjjOik3OpfTTjst/Pd//3f1ivVsvfXW4ec//3lWOS6dlcKUv30LmToczTHUaS0LicoVSGaS5AZN9mgiMSGZQ3JoVsktx2lpaTS0MWJt2UdXZXMswloGclKSQ0HzjJPSpDQcaBqXwv6Ghx9+eMIeyvTp00MXWHPNNatXjS233DL85je/CSeeeGL4r//6L3M57mh6grRIcoxoeo5jJ5xMZVmYbeSdtB7uMzqO0iBmhMaQnmtrfDRm2LZsiUlxY4KCAak8LviQypPkSTTfaBBiCWa0saFpqYPiAo5hQWxb/KnzvuuMiE4mdTQl8da3vjXccMMNWXlcOuvpC5uSY8hlDVSGq8ugL5peqqerxUsNE+d0kIxI2yMZOVqnVEcThoFQ2sBRBpoep32RnDN9j8qzyno5gQm6VhZ5jWsH135LeY5yuPPOOytJLQfOaErdDJCsC42xdBGl0WiVK1uTPrqAhdGkQPUiw0cdpiSdIblmUOAYKILVKUrMiL6X5p6VZXFzSJOztEBBu1aIhXF1ccf6AgoA+6gzB88++2x44IEHxj8/+OCDleNYZpllwqqrrhqOOOKI8Ic//CF861vfqs5/+ctfDquvvnpYd911w4svvhi+8Y1vhGuuuSZceeWVWfW6oynFaMAeTYpcqYeTpKSytai3K2jGiraXk3tQOmS40uiXG4c+tHxrudL1yJUfc9mv5sSlspATkIxpjvPn8iAWK5XJQcs7WXHbbbeFbbbZZvzzIYccUv3fa6+9wllnnRUeffTR8NBDD42ff+mll8KnPvWpyvksuuiiYYMNNgg/+tGPJpRhgTuagrc3a5FsG2ejSQ2onlKwMBaOoXCfqbNJ03AOtE6D6s/pizV9H0ZMkr0sebVyc+YfJ6/V56R5xwU8VOrT2DeSBrn+OeZFvGNMmkPR2aQ47LDDqldbuKPpGXThWRe7xmY4xyNF+mn9JcHtCWgRco1hMvyWNkgG2YI2jsUiLTWBhVFJEhsKLKQ6csoeljkwCtLZoOA3A/T0rDPN4KfQNj41I506M5TGwoJKwBKBSgtHcqKaRKSVZ2mjBZIsaIFWv+V6SfONnrOyUW18UZ1S+WnAkbIZrm0oQJPKtfTN0R+c0fQAzvhI0Z9WhoURaHq5lKYpLBEvkr8kaY2TWdK0XFu0tvaBHFlUkpvSY9o5SWJC7FjaK0F5uesnSWG0vyg9qg9da63cQTgZZzQ8nNH08DMBE84ZIjEtLdos5fY8pDJyIlsrrOVoMkp6Djkd2jf0GR3vqv1dQ2KdErixQ4afO27dC0Esks5B2gYrq0QOIqe8tnKloyyc0fQIKQqXFjsFinpz9lpK7ctI+xPUYNHImIuQUTpanyYV5fYhp48Sg2uKEo6RuzaaM6DXR5Ms6XWW2k2DCE1itkiv2rGScEbDwxlND5AkhDbQoj8qN6XHSwDJceniQ3tGXB+0MZP2DlDZTZ2BxjQs5ebW3VbyQ0xVkkql/RVNeqPXlAYTVlaOytY+50qLjsHBHU2pmwHG2kU8mrTELXZu8SE2odXbBazMAu1P0D5y57i2o2i4K6OvGdCmsDAkTSayypKaUUZjZgkS0mPa3OXqlD5zDjBN79LZcMGls8LgNO2cfJzkkaajEhMFlT9KLlBJAkP1omgbSVQaJBkHpZGi/Ny6aJmWtNb8Wju4OpFBluaSpa66DEnu5OYZN+8sLDtHrizJ2iW4dDakjCY+yvotb3lLWGKJJaof1tl1112rX3KjXzCqI6P6tf/++09IE7/JutNOO1XfXI3lHHrooeHll1+e5ydJN9544+qppmusscY8X0zq/GaAKbJ00RVzkMrlDPgwgO7dcEZLytsFe7BKb23QhZzTNDiwOETJcFP5FUlk9bk0rUWKayJttumzY5I6muuuuy4ccMAB4eabbw5XXXVVmDNnTthuu+2qnxtNse+++1aPRqhfxx9//Pi5V155pXIy8VEJN954Y/jmN79ZOZGjjjpqwvN8Ypr42IT4XJ+DDjoo7LPPPuGKK67o5Xs0NVJ5K13cuYYI7b/QY1U7mAUtyWx9AhkwSRZChi49V6p9gywPXUNNQqTpqXSaviRWl2P8LcyIm585deSg7/lN11Zfr1HAQKWzyy+/fMLn6CAiI7n99tvDVlttNX48MpWZM2fCMuLD3e69997q+TsrrLBC9Utwxx57bDj88MPD0UcfHaZNm1b9cE98MNwJJ5xQ5Vl77bWrx1zH31TYfvvti/WvWuDgOJULNElLMiacwaVGRNK1ubJKAG0SS3IWF3lbZK9hi2xzjILluksBCpIh0ZzQ2pDWh8rj6tTmptRelB/Ni2G7vo4RuRlg1qxZ1f/4JNEU55xzTlhuueXCeuutVz1d9Pnnnx8/d9NNN4X111+/cjI1ovOIP2d6zz33jKfZdtttJ5QZ08TjCPFnUOlPozaFRaeWjnPyF2JDSL7golbJ2HcNJHcgI4KYFypLM6zDhiZSn8ZyLdIiTYMcRn0clccFJxbJy9JXqZyc9ZBbhmMS3wwQfzAoSlpve9vbKodS40Mf+lBYbbXVwkorrRR++ctfVkwl7uN897vfrc4/9thjE5xMRP05npPSRAfywgsvhEUWWWSevaPPfOYzzTvz6vzWmEqEJgVZ9nS4Bcvp6Fx9pRamZpjoOHGOUYrIu2ZraT2W6F8rq4QMp80JSxqtDq1+WofmAOhctIyNNB8s6Iv9DELKGnPpLA9xr+buu++e55fb9ttvv/H3kbnEH9x517veVf2c6Bve8IZQApE11Y/PjogOKf5WthlxriU/E2CJxLloE+XjjC5a/NRgorpgFwyPBMk1wGnbkPOxyC2c420joVlkoNLQxhI5Vi4NGk+NIUljlDJlVA5lRpJDQKwbpeP6JbFDi6TnmMSM5sADDwyXXnppuP7668PKK68spt1ss82q//HHe6KjiXs3t9xyy4Q0jz/+ePW/3teJ/+tjaZr406eUzUTEO9O6+M3tXA0bIUcm4pwNfW+p1yLxWQwwJ91x6TSpEB3TnKI21sNgiDjDjc5bysgdZ2kMpfItLFm6DrmMRprjtA1sfaEMnNEM6R5NvDDRyVx00UXVr7bFDXsN8a6xiPqnRLfYYotw1113hSeeeGI8TbyDLTqRddZZZzzN1VdfPaGcmCYeHyQ0ycGalwM11oMyqNpeAMfa0rx1+3P60EQ60iJ/VEffBkuSYjUWamEhaT76nrIRiwO3SnBSGq79XBs4BzgMQcVkxNRBy2Vnn312OPfcc6vv0sS9lPiK+yYRUR6Ld5DFu9B+97vfhe9973thzz33rO5Ii7/0FhFvh44OZY899gi/+MUvqluWjzzyyKrsmpXE79389re/rX7A57777gunnHJKOP/888PBBx9ctH+cPNS14eeifW3fog9YojzOKNR507Gz7guk5yzsjB7L0f+bnMuF1i6J3Unyq1Sm1UDT65MLzlHksHnalr6lT8cQO5pTTz21utMsfikzMpT6dd5551Xn463J8bbl6EzWWmut6idFd9ttt/D9739/vIwFFligkt3i/8hQPvzhD1fO6JhjjhlPE5nSD37wg4rFbLjhhtVtzvG3r0ve2qwZMgpkCCyRJle2ZaG1YVQcpMhTyiNp/1x5SBbR0KfRaTqm0jWXjDmS3Lh06ThKzK5Oi+pH+yZN+oz6JDEV6fMgGUsaGPX5GgUMdI9GG6S4AR+/1Kkh3pV22WWXiWmiM7vjjjvCsIDqzjlGg9t/QVo2qjc1Hkg/p3kt0gYnOVmkKMkRavIXbYdUh8UQan0tBWkMrcjNJ/WVzj9p/wV9tlyLtC7qtNAcROVapDfH4DEUNwPMr79HUy0Ao26cYySoJIcWm+Y8UBto2Sid1h6EtC05/aR9kCQz1D+LPITq7BoWplE6MkVOwSrHcQ6EM/BaGsmBcAGBFBjlBEUlMQiGMTYijGaovrA5vz+9mUPu4tAkI0tUKeXPXahWR2Sthxpmi6zCGTxNaukDOdcjZz8pPY7GQ2NJmgRDy7D0TZO7JPYq9TNtj9QWZzbDCWc0pUDWg0V6sspTXF7EdGjdTeUxKV2OtGWRDKXyUPs1mRDlz0GufKc5VKk863HNGXN157aHpucYZX0OSW4WNmSdl5IEOmgnE790Hl991zkKcEbTA1DE2MbQoPe5kTo1AFaJqa0EpclI0p5A/V8y5JK01hRNZU3uWJO2SEyBO5eOlWSYpWuRloHmCx1vaU6h9lDWlEpkqN2DdiaOZnBHU3CPxhI1prpznc4CznCkL2qcqdHQDHFOFG/JK+3/aCwJRcbI4UpMaRCg0bdlTK3jyZ2TAgc0F3JlOZSGzmPUPo6JICYuBRoSJJluVPYz5ke4dFb4ZwIsDEFbANpeQxoFcjIcMgiag7MaZ0120RY/JzchA0Tbn55DfR10BGzZw+Dy5M6XJhKf1i46ltRBSVIWVwZ9bxkTxI60Ods3G0JsuzTGRsR5OqMpyGg4Y6gZVZpGMpjcAkSMxWIU2oIudEnmsvYvZWg5hqpJP4d54aZjIDFGi1QrOX+UjjoVK+PgmBMNfCzsg5NFHcMPZzQF7zqrFmZyPF2onLOxSEnUgVFILIG2oyQ0OQulTWHR/FGepm0tNSbWiF1jKpp8hPY6tDTW9qV50dyUrg0NeKRgRGuTJvcNEs5oeDijKYUpNm27RpcyjyQfpMe4qLZNVK85UMlQcM6VGiqanouyc1DScGlSmJbGej1yrptF0tQcldYOek3azHGJTTmGH+5oekSO45GQKyHkSktdLmQq5WmOD7EuSZYZdaOTs6fSVblWZiiNP+dMaFs5SYzOYc3hcpKrYzTg0lkPkOQGbt+h/jx16tRG0a4ms5QGJ4lIRou+rz+j6HuUItu27URjmcM2JHmVayOSw3L6kebRyuKYq8b6S6oCTeDSGQ9nND1A0q2pk7EYlDSfdDxHauhygSLHgBYhMhrIAHGyCarDAsvGc5do6/Qpe9CCCzpOkkHW9vNo+5EMitqRs++StldKy0mrw7xv4/grnNH0BMpguOgsXfTSwtGMlsSS0OeuokHOaGmRNnUqEhvSDCOtQ5J2pLxdAV3bJrBc89QZtAkwOMZUn7MwIFQe5yy0PJLj0phQX3BGw8MZTQm8Os+1xSFF+k0WC11w3KJL6+x6UUoOxWrgqaGU2JC2uNsa90HDen04FqlBYsza3glihk0ZuLZ3gz7n1OMYLJzRFEC1WJK7ziwatLZngyJGTgKiEosWbUrHNeQYcsTqctNbGR8to22aLvJJ+yoW1pdbtnQudeYWKY6WQ69JG/aErili/LnXvW+244yGhzOagk8GQIyG+5welxhOyoTQubpeznFpRsXcR0Wn18BFrmjvwKLfIxmOS4v6orGinONc26R2l2JdnHG1OHrEKNL/1rZz6ThGn9ZhOc7l71sidfBwR1P4yQD1f7qgNJlBkr3SsjlJSdLQuzBq1jLogrcaJZSWcyA5TCdX2rG0uU/kGE+NaeSyBFS2xoqatDGHnQ1yT8Zhh0tnhRnNlBZGooZVUkGLjmMFfUEzBDkSGueAS/dpWPZ5UDtQoMFJppKR5qRc1AZ0HsnEErPMHc8mAcIgMAzzZBjhjKbw05s5A9/U6aBjyBBTeS1NWxKco6PnJcdBy6FlSHtT6LjUHgldyVpdMkmtHo0JW/b66Lk0r8TM6XWQGJV2jrarzzns6B7OaAoyGmr462NaRImiSw3Wsri8ado2coQWcXP1StF4fY7m1fZsco73ES1LTo7OEW5MLGVpMlbb68zNMy29Ze5zbaVlDSMkObwURsXpOqPp6fdoNDmBLromeyCcobJuxvchr3FGkx6jn1F7aaSdoq2T6RLWQEF7r5XZZp9EOsexy5Q50zmErjNiQ7RMrm1cf0fF0E52uKMpgCZSCZIdNGeB6qBRIyf/lDS4ksOyOgBNgtP6LbVLS2dpc5O0gzKKaNyoxCrJbfSYxqYo2+SkObROcvdihpnhOP4Gl85KIX6VRrk1VDO6WjSXpqHHubosC7Nt5I/kQiSBWKJbSVahZeUyMmu6JgFDW+Sw2pyyEKu2sAnqOOh/Oh85eU6SyLjzKWNC7ePQN4N16YyHM5oSiGvm1fltNew10GLSomRkZNHilRyW1IYmkByHtT7UbilC5tpgPV4aOeOaG9nT85xRzpFXtfYhB4+YedqGXKetOYumcqGjXzijKYhqEYANUxr1WRaSFImiyJGLKClK78ugqJfWr8kxKJrOqTctg763IMdAWvvTtDzNsEpyV5qGY5M0H1euVQLVztNy0zpR2qbstQ84o+HhjKYgJCahORgKbkGidGnZlojSopF3AWTsUb80Y2gZi7T/bY1RE+msyTjmsDItrVUek5yDZOy59qD+a2NhvUYWJ+4YTjijKXjXWbUojAY+oqlBpIvbsn9D67WwKy5fXXaOTCIZQupU0rIt+zfW831Dc0LW8UKfc41vOp4WJ8QFBhzLzGGQEkPhrv0wXdcazmh4OKMpCCnySz9zkWOTstNXPfElI8UtDovRkhY+ty9DDRAnyyDZC+n/VuPadbphg8Rk0WdJoqLpUCBjZUxpPq5+KQ2aL1K5Wr2WfI7u4Y6mJzTZF8hJS+UmTpJChoU71rVzRcyF0+2ldKkDtew/pe+lMeLa3zW0OlC7rftSnLTEMREpCrcGRVIe7Rh3DbX2W5wM19ZhZEPzO1w66+lZZ5JR44ytpJ0jeYweR2lQlNglupIDqSSTGkTOMFENXzMy0rh0iZz9h7otabvoMS4fzWOpSxqr9DyaV1L7UblaEMKdQ+3UWJTElErBpTMezmgKgmMJlslvNXppVCpFh5xcpslmbRcqV5ZFAkHOUpIMtXQSSka5uTJkV2VLc0FjFFw5Wnppv4Vrs8bE03YM+z6NA8MZzZDs01gjahq1a7IBiiq5xYwMRFtGwh3PidClcxorbNOHrqH13Zo//VxD2uNA/63MF80lylzoewTpWlgDChq0DMt1reGMhoczmsLQ2EN9PIfBSGVJxiOtK13QbRasFrVyxh+VwRlDKb3UDtq3kszCAuQkOSZm3bdATJZjINRxSOPHOXWOsVhZUe5cp/k4iTEdj/QzV66jX7ij6QGaMbcYFak8q27N1SUd16DVZ4nyqOHgovOcvQiU3soYNeQaKskZc33XHDLXJo71pA4pdVBSn9C8tQQOOeWhdtb/OUeWOkrKzizOb9iY0GSAS2c9PL1ZkjW4z1YdnJZPjZFWj3bcUj8Hi+OjbbWksfSppDHpWk5smleSQbWyrNDqRPMQMUmOWdP3kjNF7bIGBn04F5fOeDijKXjXGYKkh3cZIad1pec4Y2dd2FJa6ig5mcVSdmqsuCiX1iWV2xa5ElzTdnBRObquTQ0o2uvQrimXhrYFtRexKOpkLIwuPa6pBJb56ugPzmhKYWzen3KOkKI4tUjGUVCjTsundTdhNLmSkmYwULlcdE4NETeGOawwF30ZLssYSOlRWitTlOaF9TpKgZSFeXLXM4fB5KTrEs5oeDijKSWdTZlXT6aaclOtX9PJ0/KpoWoS5Wt5ciP29D3S2JGh5JhMWv+wR65dMiwNVilRahN15Ny8Q4EP9zmHefYphzrKwhlNQaRRGZIWcqIzzvBK+zU0r6STN+0bKhfp+HQcqJRnMVqcYyllgLrS9nNlUknetDALK7PTAh4kb6Hrnl7LpvM7bZPU3ibl9wVnNDyc0QxBBCtNUMm40IWH9GtNO0fvtQhV65umr1vZCtLutXNdIkfStJzX9hWk8qxGjBsTznGh9zSf5qgQW+egzSVtfHKkxD4ZpEOGO5qCNwMg496VtIHksbocaeFybepqD0JiIByQMeP2ZyxjScsoDQtDaZK2STtyWJ5mlDWWieZaU5aZs/8kQWI87ngGB5fOSiFZIyj6ovo3tzCmTp0qyijUmKP/SO5AdWqfLdINYitaFKr1i2NbmuTSxGh3JSdyZWrMlY6ZVjatxwqr87cwYC0/dT5IctUkMesxa/tKwKUzHs5oCt8MkMMkJCOdA0mKSuvRDHOTiFBa4Llym+Y0c6Wztu3vonxLXnR9kNNvcw2ojCddeyrPUpmWK7/+T68TqltyPrRs63uKYdvTmUxwRlMQlXEgx2h0x0kNOfsDaHGm0SRa/BQoomwS3Vv2BppCYzDW/Cja7prddAFLUMIZaQo0H9Lj2l4M5wAsY9nFGEvz0sqMSl9PZzQ8nNEUBJrUUhTehfShSWYW6Upqf1tIxkiT8dL/lnItewxN2poL69g3aQN1Ppqxowa7/my9LrReyliaOH8LO7HOS8npOqMZHNzR9PRkAE4OSd9bZSdNrqBldq3vp8iNYpHRT6Pq9LhmaKxOM1eC7JKFtUVTKUhyslbWSaUyzuEgWZZrLzrflQMYNAN18HDprAfpjFtcVoNm2SvJMTpI7mi6QDVmZTVyVMJBbZSYCSetaBF7n8ZKuubafMhxEGi8LGVbpElt3khyFcdSc9iKJg/mpO8aLp3xcEZTEHQxok1Ri7PJjbDRAquNrbaou4rm07pQnVYDQOU/i5ym6fToPcrbFdB159JIZeQ4S1qX1C9uvqRladKldi1ouvqcJJ1p4yTJz8PESh3OaHoBt+i5YyksziiNMpFT4yLVNpG/1h6ubvReOicZRs0oSW3T8pSMhK3MRTPCFlmM5kUOxcp2OMctzRuaR2JJ9DzKq11zSyBTygk5o+HhjKbgzwRIEWx6XjqmySNpGupcUBRrMaDSQrTsGeREqPXx1EDQctBnS4SfuzdTGrljL42d5DhQmZzD19qFnBtiTJokSvNzdXBtRuebXts+5TTHX+F7NKVuBiBrABlHKSKTojkUAVLd3OIsJMPP9s1olNB7xERQ2lRSof1DebX2SvsEqA+lDFEbp2dltSifxRlpZadtkJgWymMZe62NNHiyzPG+HYozGh7OaEphCh9dNmUMSH+m5Un6vFW+6BLcvooEtCdA5UErq0nz1u+1tF1DknPaSn7a3ojGMilDQfXSOYXqounq97nXR+t/E7mU5nP0D3c0PYMuSk6K4CK6tBwKTS/XDEDXRpaTVaR6kYzGGbm0fE2GbNO3tuOSG1hw11a6zpJDzxl/WqdUF+dwUHu0/mhA89Yi43KfHf3CpbNSAGtAYhIWbV1C6ryogaeyWpPym0KLlKU01Mgh4ySxBVqOtb3IyXcBazmaAeWYrSUPVx8X2KA5xc0hTt6s2yB9RvWiwApJxMPiRFw64+GMphSm6JNQMwDWiLD+zDEIK7Pgym4KJFdZJBAucqWSmVUGyzFEJY2WVLa1L9y11crRjtPrQeemxCqR0+dYKeqD1M6mbMyS19EfnNH0BEt02HXZloiVK69L0Og4bTNqK81r7ccwRbcRVodYp7WURcfMwhhpes05oWuUUx4tl7bdIn8htsKxnWG57s5oeDij6eH25vp9Ew3bYqhoPdLiRe9LgzMOUvs4uS/9LEk1fUWzFpZCnYKFvWgskIN27TmJtgmkuckx1hxjjK67Zd4Mk/Nx/BXuaAqizURPjYtF86bnkHRhZQ5dwLL4JXlFk1AskTmXt0tYyqZGXupnfZ5jEpbyUZ70GiCpSytbOmaZn5bAgSuLliGNSRO5dDLh+uuvDzvvvHNYaaWVqjG6+OKL1TzXXntt2HjjjcP06dPDGmusEc4666zset3RFH6oZqkJz2n1mozUJipu076ctMiQWKUSaV9oGGGRzHIceXre6iQsxj3Ni5yWBk0Kk9qHzg3jNa3Ho+9XDp577rmw4YYbhpNPPtmU/sEHHww77bRT2GabbcKdd94ZDjrooLDPPvuEK664Iqte36MpLJ2NzZ1b/UomF7VxBtRK/TntG9Un6eRdLlzJUWjyEbd3o+XR0gwSlvHVmIuF2dD6uLGWjLvF8WlSqPUaoHJQGlrHMF7jUcGOO+5Yvaw47bTTwuqrrx5OOOGE6vPaa68dbrjhhnDiiSeG7bff3lyOO5qCjKZaEMDAckyDGkxuEVJjzBmOVGpAQOe7cDocQ8kxaJL8IxmfUdXmc5iNtleB5DGunPoYkpxo4CO1VZqvkoOgDrENE0ft7hslZVoJTz/99ITPUeaKr7a46aabwrbbbjvhWHQwkdnkwKWzgowmwjLhc/Vmab8CRfcpzZZYjbW9uZD0ea4dyMghp0mP5TizEpDGrytZj+tXjoxlaQNNY3EAnBOy7KtobZGCJpp2UAZ/UFhllVXCkksuOf467rjjOin3scceCyussMKEY/FzdGwvvPCCuRxnNIUhGdmUUaCFgdhKDXpckt2ow9GMoUXSsKIuKydiT9ustVOr25q2K0hMA6WxXFvumLV+SzmWOZGmQ0xSK4cr0wo6N61zuS802TNpi7q+hx9+OMyYMWP8eBdspku4oymIaqK/+j7XeFsWUVN9HoEaEou8x0HbZ5EYWf2Zk8Qk59ymzSUhtUGSCLVjqKy0Pk5uy3EOUr0aU+XSSsctY2Wpc9DXvG/MmDFjgqPpCjNnzgyPP/74hGPxc6xrkUUWGQ3p7NRTTw0bbLDB+CBtscUW4Yc//OH4+RdffDEccMABYdlllw2LL7542G233ebp9EMPPVTdFbHooouG5ZdfPhx66KHh5Zdf7vz2vDY/5YyYhCXybPsjY2nd3Dlre3LahPYB6DluT0AzusiASm0bJoOj7V+0bSsXUdPjnMPR2p1KsFId6X+LLGxlAcMQNEw2bLHFFuHqq6+ecOyqq66qjudgoI5m5ZVXDp///OfD7bffHm677bbwzne+M+yyyy7hnnvuqc4ffPDB4fvf/3644IILwnXXXRf++Mc/hve9733j+V955ZXKybz00kvhxhtvDN/85jcrJ3LUUUd1fntekz0aS8RlkbPM9RKnojm2NnsF1miSczoc4+HKQhJcE2M1CFjGNkd2sZaXs78iOQQuONAYCg2AuCDCOvdyArVBYO7cuQN55eDZZ5+t7GB81fYxvo8Be8QRRxwR9txzz/H0+++/f/jtb38bDjvssHDfffeFU045JZx//vmVbR4Z6Sx+cSjFZz/72Yrl3HzzzZUTOv3008O5555bOaCIM888s7q9Lp7ffPPNw5VXXhnuvffe8KMf/ajaoNpoo43CscceGw4//PBw9NFHh2nTpnV2e14b6Sw1kpxxz3U2SJ7iykN7FZpk0VS6S/Om7bLs0XDtrMvgInBOs8/tUyn0US83xlrdnKTL5aP1ICmTXnfOMaHryc1Peozbq3HWIyMG9DHornHIIYdU//faa68qSH/00UfHnU5EtJ0/+MEPKsdy0kknVXb5G9/4RrbtHJo9mshOInOJXyiKtCyynDlz5ky4tW6ttdYKq666anXLXXQ08f/6668/4a6IOAAf//jHK1b05je/udHtebNnz65e3K2DTaQztECrtEaNm6JJ9Jvj5DgD1AaWqFljXpbPHAYtu2j7ak32cGgQg4w8t5clzT3kBFKnQtOhvG2AHAfnXGh7uMCjNHJYaVfIrW/rrbcW86BthZjnjjvuCG0w8Nub77rrrmr/Je6fRJp20UUXhXXWWae6rS4ykqWWWmpC+uhU4jnp1rv6XNPb8+KtgemtgvHWwWyMzSvt0AVhkQK0haztTVj1couBzwHnVDmHRtNxLI3WIe0HlXLeudAMe868QFE+l7Y+ZpHNLPOPtgsFB4iJonql6ybBwrKbBm+Ochi4o1lzzTUrjfBnP/tZxUQihYty2CARdcpZs2aNv+Ktg02/RzPhODH6FsPGGQ/uPSrXImFZF2WuMdacKXLA1BhJxpST05qglGGSGAlKq52vgRx3fRyxj7QMzpmjtnAOhmMWHJOyOj1r3zUn7BgeDFw6i6wl3gkWsckmm4Rbb7210gI/8IEPVJv8Tz311ARWE+86i7fcRcT/t9xyy4Ty6rvS0jS5t+e1/VZtJZ1N+dseDdKQkYEVy2T2PCSJABkJdJwDJ6l1bWQ59oOiZiuDmwxGR5PitOusORvNcdA09Wdr3RZwstgwYhSks0nLaCjiXRRxfyQ6nYUWWmjCrXX3339/tVFV31oX/0fp7Yknnphw6110IlF+6/L2vGxGQ6SzGugYFzlaWQx9r8kasM3C/lFbpH3WHAXS5mleNF4o3TAvzCZja8mjMbxciVSaP21kSzQ/pfZL19wx/Fhw0BJVfMBb3OB/5plnqjvM4nde4q3HcW9k7733ru6KWGaZZSrn8YlPfKJyEPFGgIjtttuucih77LFHOP7446v9mCOPPLL67k3NSOK+z1e/+tXq9ryPfexj4Zprrqluz4t3UpQCZTQ1NBbSZjFpbAVJHBPa3OEC5qJfS9+sMkoOg8thjiWMmSYX5Y6fJi/RNJrkZGWLqAw05mheSwEEOi/VKWGQzsgZzZA6mshE4j3b8Za66Fjilzejk3n3u99dnY+3IMcnH8cvakaWE+8Wi/dx11hggQXCpZdeWu3tRAe02GKLVXs8xxxzTOe352WDWRNcVKhtGNMyLDKGtTytjbmwsgbaD+SAqQyU43w0p2Mpo0sj1oZNUSkxN29dv0XG5YCuAedAUP3pe875c2VYGbcznuHEQB1N/J6MhIUXXrj63QTptxNWW221cNlll4nldHF7XrZ0Vj24Wb57qC174TR2zcD2EfVZnIMmD3KRb2pwm2j9TdE2ys4JEFAZVkisRmLTnOHm2pw6LouDtsxBzWG5fDaaGPjNAPMj6u/RpNKZFKlRI5r+1xZ6+l5iNJJ0lmO0c6Jf2hZal2RstHKtRr4kmtYvSVtpmiZ1WPZoLCwXpdMCHJqPtkk7Zj2eG2RIbesSLp2N0M0A8wPoI2i4CZg6Ek464xYuZ3BLG98m0lPaJ2q0ENND5UjGOJctDQqoz5xR1oyWRWLi8knMEbVDa4OVYXJ9shjotPymzsJltcHBGU0PQNF3ziYqlxctUCnapMe6ML6aRKPVw7E3a7+4ceT2EgaB1HlaDCqSDFE6ri4LI6RjKbFcKZCxMFQLrFIel56iKetpA2c0PJzRlJLOxmzfP6DvLWkkI0oNLV1wqaGp0yGmobUtrQ+1W2ofym9ZpCiapVE1HSdrBJxjkJo66ByHQc9b5K6c/PSao+tOnTsaz/RzE7ZL25mmbRMotGE+ju7hjKYUXr0ZgLIPSRKjiGniXXfUENAFKEWZqK60TTRNF4tT2x/IcU6cceb6Q9tg7U+O89AibY6BSmxDY4A0QNAMc9P2S2k5+crKaqRzdB7mzFkrkxpvZygDZzQ8nNH0AM6Ic4ZFkipQ2bQeCs6ZSI7IWn9ajgWcA0BjgMaH6yMXkfeNLthOk3ZLkqPULinAQDIbZUGcE03P57Q/bTcaE2l+07oRnOUMBu5oCkIy2Jz8kJ6TjKUkIXH5UmYlGbZcKU/rG2eorMbDUm8Tx9LUKZRGTnBhLY+TyTSWRcuhzJw6MgvD6GrcrWtDO+4oD5fOSoF5BE3OzQD1cVh8g5sLaljak6blmAUHxEBQlInkIOqYpH5apEfJ8Fnzc7DKVRqrsOTX8nKyUlo/fS/Ji8gZ0TqQhIXagurm+sex7LRdWppBwaUzHs5oCn5hs4k80kRnR4YMGRSpbG5RdxF9cu2yyDWonbn7E02NkcURWZAzhjnBRpoeyVzpMS5I4JwgdSZcwJGWqTk0KYDg+kXr0NJYzjn6hzOanqBp5DU0ViFBkjEscoY1AtXawEkzSIqR+iG1UYrGUdlNIuGuImZkrFGaVJZC6RDrswQv6Jqk/y1sVpJDadu4/nPHNHbMjR+qb5AsxxkND3c0PTwZABkPzVCm4CJI7j1yXFYj23ahcvKY1Lb0sySxSe3TZEPNmSN0ZbAsY2qRJSVmYA1GJKdvkVqRw7FKmZa6uDlSH7dex2GT1SY7XDor+DMBUiRKF00uNGmByibUICGjVQpc9Cq1kRqU9JjkiNL6uAhTMupdSIUc2pRNx6AuD41T/R7Va2UcHNOix7WxpqDlSI4l/W9lQLlOz9EPnNEU/JmAksYLyVOa3o4+SxFj121F7dMcAQJnqKwyocaqUPourmGbcjT5kZMrJamtrWNIx9p6DVCwha4hx8SbSKB9/pZWfPVd5yjAGU1BoOgqjRCpMWhSdgoUeabH6bE+wcli9TntGGdouf2C+n/OuGqSVVfowjhKzhIxw1wmk6ZBc0e6Htayuf0frh3WtLR8x+DhjKZHoOjPsmC4SFjTuTm2gCQYer5raG2K4CJhTW6xtNvSr9LRMXcNcwwiGkfJQUpyI2UmWpuRBGedLxIDl8ppcryuo2+2Y5UPu8SoOFNnNAWf3pxCiig1tiHtQaT/uYhe0sAt7ZSgRaDS+/QYlXeQIeLK0IyK5OT6hCYdWsdeunYao0DORXIWHGPRHBNl7Vo5XLmc7CddT62Njv7hjGZA4LTu+rOWF71Hea17L02jv5xIOFeaQkbKElVzDGmY9HyE3L2pnPxtHG3OvER7K7QcVLbV2WnXM0da6xq+R8PDGU3h25tr0IVEF34Xi0KS1zj201XdVliNA2Jj9Djd56JpUH2D2G/pKg1lCVzenOtpYSiIaVr3TCR5l5appUfMVyvbMRxwR9MTuogopePIoHKGKT2ffqb5EHL6gAygJI1Y2s8ZWatD0SQ2Kzhj1pYZSsZaM9rpZ9q+pvtD1LinjgmV3YRpWfaIKPOxMKBRYbKTAS6dlcCr85ouDkmnliSEXAdF9yTS6B9JGxZtn7bZ2g5UFzJMlKFwfZIkGUmOpOVY+8altxr9XEiGWjPYKA3HFtNjnKNIr4007qi89L90fWj+nH5Z8qO8pSDN31IYFdbmjKYExnT5Kp2UTWUsLWqnDkTTyEshdXLWPqcSGdXoOadjkZByjVKX0XCuk2vCYKX0EguzBBqaYafnOcfNtRGdR22s02lsyDE8cEZTCmTu00iQGh3NCKH8XPlis5R9IakdlvPWuul7GulykT0nv2n1WtssMaA2fa/L5vpguX6aRJXWgdqeHrP0y8IUOZaS5kdlWs5zfbCUI/WrFGJ9fX+BcmxEnKwzmlKY0t1k4fR1+h/JIJQ9pXlgszuUznJA22dhYzSvxvCkOjlQg9ak/02DAq4d0jnLnkv9P2dvBQU6aK5xLJQrVwN1aDmMtE8n45DhjqZHcFEYtyil/QpqXOkxbmFq0k2O8bEgl0lwzhG1I5VqEEPsqm203lx0YfC0sdDOobHR9jmoo0dziZbBBUUau0DMCzkNbW64cxlOuHRWCoo9sujZFqdgkXVy5CYUwUtRoqaRa5JfThk5TGzUDI7FYKO0WpnWejlJLwWVyXLmY+pskDxWp6Hlo2uP2JgkufUFLTgqAZfOHNnGntOju5h0nBHJle2QZMLVh96jNMiRSUaHlqlJZ6hPw7ZArU4mTWuRBnOCAA1p27gxtwQFKL80R7S1kxOkOQYDZzSlMOVVx2GIyqhubt2TqN+j/Ok5VKbVIMzTLWN65Ixo1KwZOskYcc6pbR9KRMK031ZGgoDyagFGU2eczp10DtHrSetq0idrGjoHhsmhOKPh4Xs0BZ91hhwLZzwtWjn9nMN+UEQoRcJcvlxoTpMaDs6IpWm0Mmn6nHNdGi4uCrfKU5YyUfnSudw5Q4OYtDxOArOwHC44yHGIw+RkHDKc0RR8BM34Z0bXTrVxiYVwCxcd5yJn6f087e8gSqVtzT2PDJtkhLn+WJ1cCViMO2UNXLoSThW1ATkWjs3QvnHOw8IgUf1cH/pmpFb4s854OKMphTFePpIkIy7CsyxezqHV5VjK6HrvgusPTcMxvPSYJttY5LdBQDKQXPuayoD1ONDxkMaKM87SfLJctxJjrjGyHMbm6A/uaApLZ2hfgUbrFgkHRffpZ3SM1on+a/Vq0BiRxYDSfSXaTmqM0XhphqdklJuzZ2J1FpzcZJ0XVIaU5pt0vXL7I7Fhrhyrc0LsnivLZbXhgktnhaUzy56CJmXRNJxDQfJSaZkh1zAhI2fdRKXOSJPSBmVsLPUi55qeo+WlMmt6TJJWUT2W/RNahoUV03NWBp32RUpjdSCDdDDWedwlRoW5OaMpxWjAfNf0bc7wSJEcMkD0HC0TMavSkhl3nIuuUZ+khSwZQA1t+241bpwcqOXhJNj6v6Wv6TVHLAkxScSUucCpqSxrYSlpeaNiWB0T4YymJ6BoNF20XLRa57WUX+eVImGUxtru3P5KzAWxL9oPlNYiD6J6NUaZ27ecPEgGTMuS8nFyK0rD5WvTfjQv6XGuPAvj1JgQmrvD6mz8ZgAezmh6ACdxpOcptIhXk8SsaVH69PPUqROniHWRa86MjgmK3DmpzBJRW8+hdmloKs9Y2ViaXgs22jA2yxySxpkGMW3mt6W+Oh26/pZ6h9VBTQa4oym1R5PMaW7vhMoUklRilWFSA84Z6/SV5ufqQXWJ/Vd+C4f2wSIpobxpuV0ZkRIav4VxaXlLwCpFctcpZeOSpMcxIkubUJ1W5AQjjrJw6azgHk212Lg0wqPWURqxPuHx+ageVK4kg3BRJa2Ha5sGFBHntLGpvNcF2jo5SSqUykcyInd9OcbRlulRdsEFJJrsKbFfaV42kexKQnLcpTAqLM0ZTUFIkkhuBKxJaDQPWrCcJp7bPo6Z5EahWtSM+ofq4YxNH2jqSLlyOEkptz2UtaL2pOmk8pAz4Zy9JSjh2kzfc22WjnHlOgYLZzQFgRiNhTHkGE4axVqZBTIgudKEFdQ4IZmFgouAufLRGPYZ2Wpjnzp6KX9T42hhC7Q9NK3ULq5cyrxy51Muq7IwWS7YKg1nNDyc0fTwCBqrwcyqQ4gy0xdXryRRdIU2fUVGRdLupeN9RLaobRLTk/LnBB5W1txU2uQkvPp6cBJq7rXPYYbcZ1pOGznX0S2c0ZRAnP9jcmTFRYXzFGVgKYgl0Pw0orZKH21gNR4WqQ7tP6C+oLR9R7ZNImrpGlInhIwpl19ji00cAr0ObR06VxYn0UpsNUdu7hp+ezMPZzQFUC2IZC6n0Ti38HP2c5CxQUwmR8MuEYFK+TQnKxle2mZOZuMM4ChEtDnzQTpOy0JMRKoPMWOJvVllX8l5SseaOolRuObzM9zRFJTOqAPQFqJlI1RalGjvA+nmTYDqzAEdB073R21FbIxKadr+R5u2l4TmDJu2FcmnXHnS3oLmpDnHI6Whx6zXzXqui/SObuHSWeGHaiKpYTwdkHYkyYCelxavRVZA5VokiVxI7UrrpRKf1G+apm+JrI3TpuWgMUKyoGSQOdYgMSNL8GORn7j8KA2qt0n7m6QrDclhl8KoMDVnNKUwlj8RrcaSGlctWkTv63TovdQ+CzRtXQI3Rpyz4hyTVFYXaGLYNMMusRvad8QOaR7uXJ2/yVxsI0fmOI60rvQ4faF0juGDM5pS0tmrX9icKhhIy2JpG+2hsqS8UplWo00dCxetp+m5NBIb0hxlF5Ih1z+J/dF06ef0P0pft5uOibWMNH/93tof7Vh6nAtu6LhYxp5jrlL/hhF+MwAPZzSl8OpdZ0ge6yK60+SlnD2LrkAjdmQUNSObvpfGT0Ma9WrSU5fMBKXjPnPnLM5EAscIc9plkWeluYfSc+1r4wylz6gMx2DgjqannwlAdB8ZUckQcwZbMnyckaZldbEILRF7EyYltZEzNnW/c+TB3DHQDDo9lmsIrQ7W0kfJ2WvjagkUqEPh5D7URmlcJLYjOUzrtXH0A5fOevjCZnXMyGgsUS9a1On/Oo1UvuTo2ixITS7LMebImWqyXNu2t03PSUs0Hycf0vOc5MjJa02iess8oU4DzROrw7PMcc5JWcpI293l3NbQVcCWg1Fhac5oCt511vYpyE2MRW1sUwaVGi1kNLgyu2pb2kZNdpKiX0lGzGlHHwYn57OlHM5oWuRRLaiRDGQajGhOzeLkrGwG1Sf1hStD+uzoD85oCjMaa2SXu4CQoUHRJsd20nScvt4GWpSNImSpn6htTduqMY5SsNYrjYWWrk7LfUYMxSK3aXXQfJRpauWk8zRH7uTqHgSc0fBwRlOY0dSTj0ZokiRhrkfYs0EMijNAFkNQaiGm40OPS5/psUFFrzl7KNb2arKnlK+uh7LYGpyDkVgyCla4Mul/q8OR+ii1MSe/Y3BwRtPDHg0XySIGwhkTa3RJ911yZJpcCcoCbm+BS8vVjQyWtF+Q5teMT5so2MpQqNFFshgKPlB6rX40VijAaWr4EevgggXk0Now0WFnNPEW577rHAU4oynIaJCEwEW32p6C9Lk+JjEcLb12nJbbZJ8h/YyMkiTpoL7RY7QuS9SO2tI34s9lIwaqXUMKTn5K83NOTAsyJOZNrweqg6vHOu85NkzTDfpaOjDc0RRkNFbZIDcqscpM0kKlRpjKHVwbNeYlHePGgNYtSTZcn6W9hjRN6QiwyXVGfbEEFzltQQ5ck04pY+Tmc1oOYjuo/ZwDkqQ+mh8xW8dwwqWzwns0dLFaqT1dSBJb4QwVNQxa9Ci1K6fNXFtz8lkcmebEpcje2qZcaBKndTxoPmvZiLlwdUvjja6JlE6Tx7jrS6U8KTDR5DptfZWW1TQ1oARGxbk6oynFaMZwdKZFkeNlMAtXikzr95wjkqQoi8RkgWa8LPkoaDSdtjkdY02myYE1ryVd2zRNnLVl7FMGyTkU5ETSF5qn6XWxtB2xWPTeEsC0DZYcZeCMphTAnLZEgxyog6HOR5PpOEkDpe9qQVodC+oHx3IsEl6XfdCQ4wSs5VikM4kBck6liz0NC7vKcfJIzrWwmyZtL414I0DfbZrb880HTeGMpvDPBFiiLy2ap5+5CH6edhj2h7T6uwbnBC1tkfqoHRskujA+EmuN4OSn9Dwtz8qA6Hzj5FgrW0d905wK6oOEYZsDkx3uaApLZ9VnRRaQgAwKlRrQAtcMMHJWOe2S0MTQcJFt2ibab47J9RlV5rDRNrDKgkiukvZ8kNNCebWxbiOLchKbJNPlSM+OwcOls1KYYpekLIsG7Ulozig9x33W2qgZIpSGk3mo5EfbQ42ahq4di7VeOr5t94NQ+RyQtMjtsdC2pXPHyrZpWpSPC3xQWShNk3VhlSP7dDjWPakuMSrMzRnNACdBrmSEIntrlKrJaFxbrHsQFqT9SBclXaDS/gM6RstrCqtRKrWnZYGFlaJ03NzJcThpWZLUxh3rQhLLgbOa4YEzmp4eqomQIwVMKJ9hAVw5FrbARa1dLNYcQ4KidE62oTJil23uGxJzpH1H6SzMU3JWkhPQ2obKRWWi65W2XZp3iAVxLHlQ8JsBhpTRnHrqqWGDDTYIM2bMqF5bbLFF+OEPfzh+fuuttx6fmPVr//33n1DGQw89FHbaaaew6KKLhuWXXz4ceuih4eWXX56Q5tprrw0bb7xxmD59elhjjTXCWWedVbRfFkpf/5eiUg3c4kvbYJGXOPaQI181SSfJM5rRRc6IlqlJjMME6x4Hl44z8siw0/NSuVw5nJQr7blozkxKJzGoYXAyjiFmNCuvvHL4/Oc/H974xjdWE+eb3/xm2GWXXcIdd9wR1l133SrNvvvuG4455pjxPNGh1HjllVcqJzNz5sxw4403hkcffTTsueeeYaGFFgqf+9znqjQPPvhglSY6qHPOOSdcffXVYZ999gkrrrhi2H777ct0bGzePRopIk+PtYlU52mGcEdRGglapCqtjrStknSXs8fDMTHL+Fn2CoZV+296zZHjlcq0BBVoDlFnYhlnjXHTtFwZ6fUetsDB92iG1NHsvPPOEz5/9rOfrVjOzTffPO5oomOJjgThyiuvDPfee2/40Y9+FFZYYYWw0UYbhWOPPTYcfvjh4eijjw7Tpk0Lp512Wlh99dXDCSecUOVZe+21ww033BBOPPHEco4mmXhTmUfdI0Ns0b1RGSiKRBEnp8/T922AZBAO2r6MJhE2bXNbRzHoCFoaK3rMIi9JAYKFedA6OCevsTEp6MphSI7hw9DcDBDZyXe+853w3HPPVRJajchClltuubDeeuuFI444Ijz//PPj52666aaw/vrrV06mRnQeTz/9dLjnnnvG02y77bYT6opp4nEOs2fPrspIX22+R1NDWnxcpKctOsmR9C0vUMOG6kfGhLYfGSvKwGj/cveBtHNtJE0OuXso3PzhnIyFFdLz2h6N1g/koLqaa9LcdowWBn4zwF133VU5lhdffDEsvvji4aKLLgrrrLNOde5DH/pQWG211cJKK60UfvnLX1ZM5f777w/f/e53q/OPPfbYBCcTUX+O56Q00Xm88MILYZFFFpmnTccdd1z4zGc+0/p7NJbo2SLTiHUZvm+CyrTKFU3A1Yn+c5o+kkg0x5z2Q4viNWiSZtMyJZaqjYk0rtay689cvWm5yLhb2IcFnAzGyaG5kmYTB9oWLp0NsaNZc801w5133hlmzZoVLrzwwrDXXnuF6667rnI2++2333i6yFzivsq73vWu8Jvf/Ca84Q1vKNamyJwOOeSQ8c/RKa2yyip5jIbMb22h5ESGXJTKsYSUaXDlduV4rDIM5wiR5EP7LMlzFmeE+kj726XjtYBzGEie4vJLwQUy5pqchtJyebm5p7WVtjenPWm/qFN09jNcGLijifso8U6wiE022STceuut4aSTTgpf+9rX5km72WabVf8feOCBytHEvZtbbrllQprHH3+8+l/v68T/9bE0TbzLDbGZiHh3Wny1wlgzfdmyQDjjXJ/j2AA9T8vsYqFyDpMaQk2v5/qZHpeidEsbpTxc1N81qPGm42eRBy0Sm1Y3V1ZajiQnchIXmm+0Xm58kcNCgcywOBW/vXkE9mjSixX3SBAi84mIzCYiSm5RenviiSfG01x11VWVE6nlt5gm3mmWIqZJ94GKIJn7UmSnpbGeR+VZHVzX0bsk+ViMn0WPT41Ubttz07d1MhqTbVNH6qDSF1dP2h5r3chRWJ2bxelLbAwFJxIzbzuekwEnn3xyeN3rXhcWXnjhKninwXqK+FWQdE3GV8w3Uo4mSlTXX399+N3vflc5jPg5fudl9913r+SxeAfZ7bffXp3/3ve+V926vNVWW1XfvYnYbrvtKoeyxx57hF/84hfhiiuuCEceeWQ44IADxhlJvK35t7/9bTjssMPCfffdF0455ZRw/vnnh4MPPrh4/5DhR8yDpkXGIn1KK4oa0XEaMdL6Lfp+l9DkO9quOp2ku1uYkeV4Vw5KMn5N0nMO1cpatLIlR42uF02LrpcFtDyNnQwLaxl1nHfeedW2wKc//enw85//PGy44YbVzVFpsE4RA/f41ZH69fvf/360HE3sXHQecZ8m7r1E2Sw6i3e/+92VpBZvW47OZK211gqf+tSnwm677Ra+//3vj+dfYIEFwqWXXlr9jwzlwx/+cFVe+r2beGvzD37wg4rFxEGNtzl/4xvfKH5rM5XOkFyDorT6vSTlcMaYi+bSuqnhKulgkJGSIk7NgVBnLfWhhMGyRMtSWzSmgdrIyYSSw5D6mHPNJdaCgpsmYys5GCTBSawtzTMIx4SYZR+vHHzpS1+qvpv40Y9+tArS49c/4ldIzjjjDDZPHMu4BVG/6M1VQ79Hc/rpp7Pn4uZ7vClAQ7wr7bLLLhPTxCcMxC+B9oXqrjNhniMmgeQrTdLi8qcGgb6nZebWKYEaMWokOQYlOQuUB/VDAmKPU6dObexkm0hvmmPPcQCSDNaE6XDXBY0bCmrQfKPlSww8DcQ0NL3m8zueJl/BQPvML730UqUQReWoRlwH8esf0tc9nn322crORlUlPmElfhm+/p7jyO7RzE/goivN+NfnpLI0J5Wm0dKhepqgiaFM28VJRvRYroNA41+SybWF5nRpWuocpOuMAgFaD3qftkFjExxosMDls7A87foN4hpHQzyIVx2YL7nkkuOv+BUNij//+c/V9xXR1z3qr4NQRLUpsp1LLrkknH322VV9W265ZXjkkUfCSN11Nj+jWvD0M7OHQsEtPkkeQ3k1RzboqE9iNxZZRXLWw4IcA5x+pv8teSxt0ZxNLrRrwLEuqY1cHWkfLIx/suDhhx+u9lJqtL5r9lXELYn0xqnoZOLTVeJdwXEP3Qp3NAWBjCH6nKZtWo8kS9V10nqGYSFaDJ1kUCRHqvWvL+fEOYv0fE5QYalDyoMCHCk9MvK0LPpeqpeWyeXlmG+aZ1gCpkFjxqsPJpYQn7AS97PR1z24x3xRxOdIvvnNb66+YpIDl84Ko9ah6TGqU7cpn9PJu3RmuW3KrVNjaEgu0YypZnRzxqNN5I9kT+6cpV2SjMYdk6Q0q9RWf+bmrDZGlrlIgzH6Ss/V5eTKaqVQ1933y4p4g1X8rmL6dY8ohcXP1q97ROkt3iFcf8XECmc0hX+PRov+cqQfTWbioj2roSgNxK4szoP2zbq4upDUuhgviW1wx6wMCO1bSePKOR5N9kJlc9dEm9MSA6VBEvrfRC7ri70OOw455JDq6SubbrppeOtb3xq+/OUvV8+XjHehRcS7dl/72teO7/HEO3g333zz6kv1Tz31VPjCF75Q3d4cn4CfA3c0BVFNbkUW4GQMq5TAlUmNFaqHbXOGDIVkO6uBpG2j+SS2hs5z7WuDLo2T5DzoNUPprEwGjTOaE5pDS8vKYcfSXMsx+Fxg1SSA6Esi7ZtNjWXW94EPfCD86U9/CkcddVR1A0B84v3ll18+foNA/H2veCdajSeffLK6HTqmXXrppStGFH+Spf5CvBXuaErd3qxEjV0aR0mrRoZLk9u48i1OSqu3TociYM7haFG4Fjl3Hc2WiI4txh855hxDYwlmpDzpMXpdteAkl0mhOWEJMrgAyxnN33DggQdWL4T4hfkU8edU4qst3NH0wGjQ8aYLn60HOBj0vmtmoLEXTjJCZVOHh4wV6pdmTLp2Ck0CgRqWcdbYjHSeOmskmXFyGwIKQrh8UsCSBh5o7tEyJAYttZk7P2FehTLwZ53x8JsBCkJaLG2cjCarISOjRcylpAVLxG2RbtLPktQmfW6KtuXQsbek1Y5bI/l6rkljJs0n6uAsTobrB1dXk/HV5lVuYOQoC3c0BW8GsBjQJkxGYjCcHi8Zga4WX04Uqhk4zVAhx1oKbcvPlagsxtjqnNF40sCDfpbqo9cgZSlpORwzk9qV1ttXEOHoBy6d9QS0X9BULuNkkvpc+h89dgVp7Dn1ctAkH4uMhvIipylF9Oi/BO6adKXr5zIZNDb0eknjR+VHeg71kXMwNJ+292GVbLl5qrUT1TlMcMaE4YymIKyRKZUk6uNaWSgSRWXWhlnS0FEbUH25QPp72ibuHKqPYzOScZOMMjKuHPuyog8DyBlaJJmiPtBxlMrjggepbdLnLtaK5mgdwwdnNAWgRdtcOq0M9J5jNVI0yNXd5Z6GZKDS9iFJj5P/kERD+0fTSf2y9jfHuFn6zbVBYylWuRDVw6WnrFEqh2M1dfnos2WMKePNWRe5qMpvVYJcdt8OcGxEHK4zmgKQpA9ukeZOGKqTcwabk50sjKkpJAMfz9V356TMi5NkaFSeGrD0hZwv19c2fWqTl5sX9PpLbEVKk6aVnACC1bhrzoi79lZWyeWjTqvpfB1WyW1+hzuagt+joYskXSxI2rIYJpom/awt5jRdToTcFFoUnZNHy0uZj6WsviBJcBangmBlNFwQkqbLYWtcQJDj+GhbpfrdMcwfcOms4F1naIEjo8Od4yQ4DpzhQFEoPY6kNcQmaFtyGAMn+XFlcFKaJotxEowlstfa37Xhy3GGHBOVxpBjIOi/VCdyJpb8aRskliUxIEsdqF00f2m4dMbDGU1BRjPhmPLrmpZFxC1Ma6Rsajvzi4mcvGNZwJxD4+QuqU/cHgFXj1ZmLlMoDcp8ad1cG1LjysmzXD7tPL1mKOCg7eTKsraNjgO99lKb+2Drjjw4o+kJUpTFRWtWbZ2TjLjFrEX7XL1a1Gs5ThmTpW1NolwUbbfdqygJZEhTcKyFM6gWVpcb6XNsCJUt1Ynab2Us1ms5iOvojIaHM5qCsO5DcBGYFh1yZaG8aYSI2Ig1KrX0R2ojMhRS5ErbZZXrumR5fUCSOlGanPJSIAefY7A55qnJb7RttL/W4AL1wzH8cEZTEJxkhCJtLl/9WZN0LCyliQzTBST2gt6neSRGhNpcYh+lK6OG2FxuG5rkTfPlSF00v+U4vT40jcTsLcGBxI4Gjfpnlef3OpvAGU1BpMaVLqacxd42kq0Xp8QGrBFmLizGHzkcZFAszpmLwFG7rJDkqpz8XNu1+jhHTdOk/+kxjiEi55O2gzo3TupC7BTVpzkTC1Nt6vSdAQ0O7mgKIse45hg+umAlRsTtnXDnaL4mDsfaNi0v1xarwS6Fpk5YY6U5dWh7HZbyJEZJ81Bnw8m9qD1cndIxS5rcAGDYGNBkgktnPYCL4lKjkONspIgXRXzI8EuRJ8ccuDZapD3UdikfMnKW/QAL+nZQVnmK+2wxshzrodeRXn9OjtOutcSc03rRvLLs50jBhcReS0inVnDjUhKjwtKc0RT+KWfOyOZq5TkRLydjcBKVVpd23OI8rAtCk4ikfQFrHVz+LmBhZE3KsNaRprFIstz10oKA1FFxLEqqUzrPtd/iRJy1DCec0ZR+MoDy5ThrBGaJeGkdnC6fW3cOkNNBexQSC6P5JBlGMnAWo2Y1kFY0dVoWVsiNA8dI6nMoDWI4Erg5Rp0NzUPnPGIs1n2Xrq5TKRbgjIaHM5pSGOMXqWQAmoArMyf6s0hYbduHDB0yRMhIWmQcaSxzmJuUp6v+S3W1YYRa+XRMNWYsyVMW9iFJbJIMJ/WBvs+Fs57+4Y6mFJJ1x+nVuZJKnc+aPl3sWj5NFmuyOC0Gk2MtnGNBho9jbDnSZB8RNNenJnVJQQI3TihtfU4z3FZHorForlyrnNnFfByVfY35CS6d9QTEMkobP8QOqERVH+szus+JYCV2JrWbM0ht5UKrUUbjLMEqm0npLQzBGnjQejjHhcrX0kksSXI8bR1/U6duhUtnPJzR9ABtAuZKAtxeBdrnQO+5YzltQPkskCQsFKVTA2NlgpLc1gaIPXQBqZwm0hJ3rgkjsDoZS7uaSLTOREYfzmhKYEoem0ERHcqvfaYMRYs6qQG3RHy0HnYIGjzVGe3bpNF3V+ysS1jlQWm/giunKbjxQWNjcTxo3Lk5h+qQ2AnNx83jpte1z/ngjIaHM5oSiOuS2A1qaNJJaTXYKD0yYDSP1TlYztfla8hxSFxejj3Q/kuSUUk93mrAciUbLV0TmZObe1Zpjo6xNOe0tnMMm/YNBWOo/Vp9jsHDGU2p79FMmSjfIClIk6+aaP20rpx8KK3GprR2aOm5c1yEbHlPy6Dvu0LuOLTZf+lqXFGdXPu0+cMxEQs4Nm0px8q4+4YzGh7OaAr/Hk3KKDhZrMnC4BYmdWSIEdH3aXldM4Imkac1ktXKRmWWZDhaO9owLssckRwvmiOWeUnbzpWbMh50vbqSWdOyUB5nMMMJdzQ9gO41dM1CkLSmRYi5CzJnUece59IgiUfbq8ltcx+Op8k1tZapHWt7TjpPHUtE6pzo/grHmmhwxIE6tVLBkaN7uHRWENViYIy9xEJyIEWc0h4Ht9+h1UP7h9BEv9ciX865SA4117F1gdzo3Iqm8qVWTnqck2/TOqlslytf0rRNpc3cudoH/GcCeDijKQi0F4MMapOFIW2Mcsfq/9Q4tJXvuHOSdIfScuWj81zkXMMi2XQBC0PqQjrLyWMdS20OUuaAGGVuW5rONdpex2jBGU3hh2pKNwBwaSyg5XD7EamxkDaAm2yiWuQY5ARQH6xGmOsDcqDp/66BxlRLizB16tRO9y/q+iztsUhRaI5wjIY6IE3iouVqaDtfSwMFeH3UOQpwRlP6oZrg1lAU6VsWDYokU0OLjDBa8MjJdAmLfJeekyQVqY2S7NI3k2mKUu3kxiOHVUlOHaW1OHqr3KrBMn9HxQhPBrij6QEo+kOfUR6UXnIatAy04LuUM1B7LWxGKwcZOWS0JDmuBLooV2MOKbrYi0nLz6kbMWOtDO16o/PUaaQvrV+W9jsGD5fOCkJiLhLjqPNK4HRyapQ5iQdFqBbnJfVVa6NkEDhjRscHscMukMsqm4C2vety0ZjRcZXmIAKaNxykucfNbRRESNdhmJ2HS2c8nNH0PPGogdQkhrb6NmdI6MLucgHnRueSM+TO57ZXM+RWua8J2uwtWIwuYpNcfnrdLfOnqWGl5UvzgtvzoX2T+uoYXjij6eFmAMmIcixCYySorDQfOofOIzR1elydHPuytAM5m9xy0rJy+o9YVsoSmoBrO9c3aeykz5bx0SRYyjY0BqwxFQRaprQOcsuW+l0Czmh4OKMp/GQAaqgsenjThUENMy1bi061sq3QWFp9Loetof/SmEll5Ywnan8JA4eumzVvDYv8VBtDrT5UryVYovXnlC/1p/6sXXfL+A2z/Da/whlNYUbDReCcbm6NuLlFTiNj9J/WqdXbVKaysjCpXk42o2NG+yP1z9KfNqyFg8TINJbGjQFtc30uPYbkMku9lMFxcypNT9vDtQWVicqg0II2jrnSdpSAMxoezmgKMhqrjGWN/tDC4qJTbrFp8kpb58C116LTU8eBGBBNQ8uXouycfnXpZOj1acJaNeegyVtpPmqkpWti/ZxeMyovclIb6o9lDVjluKbnHd3DHU1PsMhW1mjOEgFyhtYiazXpA9derR31e2Rs0ryakaaMLi27qQNvipy86HpY5wE9hhw0lyY9JrEsKVhBjFLqj2WeS/PZGjSUYiyO5nDprCCqxZe8h+cb/LATkt04Q0yjSMmopP+bQpOFtMhVahtytKiPkmyS04+m4OqX5C6NaXL15IwjOsexDK4tnLPg2JIFuf3V1sugGItLZzyc0RTco5GiQSnab7uxKUW2XTmUXA3dwuikcUmN2DAaGMv5tqwxh4VydaYMJp0n0pjSOdPFOHNzWJvzWlrEgh2DhzOansFJC8ggWBY0jSKRbMSxJrpoS+xLaJKHReqizsfaTpRWy28pXxrHtuCMJzWcEjuijAWxWQv7yLkudRp0jqZrwkZQWRIDs0ptXSLW1/cTnMdGxJk6oykILppE0WbJaJwzSLn5ugAXlVMDgiJpTlJrU3/u+ab1timLk13TMjh5DkmlaeBhaR8ntdX/tfksSZnUgWrvNVaF5g0qz9Ev3NEUgBRF0yiSOh+ujKbSDGUzkm5vOZYLLgLVjE/6n6bL0fTTMps63LawROBcvlz21nQeaTIUldpouqZjaZVCu2Aog2A5jr/CpbMSiHN5ij7BtT0aDpKMkcoiSNfmFnVX0pkk6UhpLXmo/If6J7XLcqwEmoxtjuTIMQqOCVn2WqSyLIEL12dtLLh529X4lnQ2g3BiYyPiOJ3R9HQzAIrckNTQZOJw8gYXLUpSB4pYc8BF1DQaRnsO0nhJEs2oLLacdkrOWQtcJKdqYdNpPSi/RY5r4li5ulNIcpqUlqvL0Q+c0RSAJZKjkSXanJWiwjQfqhtF/mmakotQi7bTNKiNnNOkrK3LNpcE7UPTMrQgAO13pcfT95LD4spDZXISKL22FvlQu46S3IrK7HteOKPh4YymBF5du5ocpBlLSbvmDK9l0aJF2OUiQf2i/ymzSQ2Z5EibRMzI0PaJNs6FK0OTn7jPnLOwzL/0WuW0T0onIWf9oD45hgfOaApCi8CaSg3UcCJ2QN8jg15iMdI+cYxG6hc3LsgR1Z+thncQBki67hIkidDijK3tarrHwbFyrkwpcJKkwBRovlvq4NrUJUYpiOkbzmhK7dEYrn9q+LUJIxlLxGa4hStp8jlOIccJahGtZhzS99weDyp7WBZhF+3i8nCs2GLktfmC0kosCAUIpdhkE4fhLGdwcEdT8KGanGZepcl8VAeSx6S0aT3pf7HdBZlObuSOHF89Zumrz/Z2ZSi7NpIWo845JG3fB40xujbano3Uh6bjOiyBhEOHS2elMAVvAnPyT64jQIYjlcc4o8NJH6UkBqTdS9o6bRuVY9JyaN42bZb6LEk1FqB9Ka4OqX2oPchRoPbStE2dHddGSTKzyF3anERt1vpQWipD9fWNsRFxts5oeviFzRqcg6jyCMbXejyV4STDItXLGfYmQKzNUiaVEy0GUtPrc6RJirbjkLsfQ6GxCS4dKj9n/Op8Uv3SnKbHuP0kutcjwXot+nYyDhnOaAr/wmYEWkg5DEY6L8kliD3R6DLHWGn1U6A9GtROWpYlQk/L1+q39KUPcONtkUI59kLT0fSa5GZ1wJJT4VgxPUfbQ+eulaFYWNkgrrczGh7OaAreDIAMLTKmTaMvGvFzCx8ZqSZMg6s/p41NmAWKqnPzoPa2ZRpWdMEQrZIXZYNaG1AgQOtFBh6NLZ1flrai91w76v+Wsh3DBXc0hfdoJMaRo5cj4ypF+NSw1+k5J5SWYd0ryAGtO/0sSVz0HO2TZc9AalNuu3NAgwpr5C+1xcJ+NCdL54hUFjeOHCuVziNwgZgl7fyyfzEZ4NJZKemMzHHr3gfHbqihkBY6kk6kcq1yhOU8bR+KhCWjhWQ97r3FkOREzSWca5t603IQs+DSSefS/5TpSjIXHXeUtolUaZ1/Tcawb9YTfyKg7zrHRsSZDg2j+fznP19dpIMOOmj82IsvvhgOOOCAsOyyy4bFF1887LbbbuHxxx+fkO+hhx4KO+20U1h00UXD8ssvHw499NDw8ssvT0hz7bXXho033jhMnz49rLHGGuGss84q36EpWDOni1GK4NHntDxLhErrTNNY5KUm4FgcrZuOhcS2KAOysJpScmDTMpsyRYkVN0lnmWPoPCeXSfNZuzacMxt1w+oYQkdz6623hq997Wthgw02mHD84IMPDt///vfDBRdcEK677rrwxz/+Mbzvfe8bP//KK69UTuall14KN954Y/jmN79ZOZGjjjpqPM2DDz5Ypdlmm23CnXfeWTmyffbZJ1xxxRVlOzU27902nDGV7jqzMBykjXP50jrR+a4iMqsxo07YylY46Y2mKek4rKDtbDvuXVwjjSFpAQ43vzRpFqXjmFDuOFsdbSmkc7jP1yhg4I7m2WefDbvvvnv4v//3/4all156/PisWbPC6aefHr70pS+Fd77znWGTTTYJZ555ZuVQbr755irNlVdeGe69995w9tlnh4022ijsuOOO4dhjjw0nn3xy5XwiTjvttLD66quHE044Iay99trhwAMPDP/4j/8YTjzxxLI3AyTrDS1oSYpI09TnJaDFSZkCPV5qkmptzjEo0nGrU9KctCV9kzRSfTnX01Jebhto0CMFAdwx6Toilk6dlAW5DrkLmdQxnzqaKI1FxrHttttOOH777beHOXPmTDi+1lprhVVXXTXcdNNN1ef4f/311w8rrLDCeJrtt98+PP300+Gee+4ZT0PLjmnqMhBmz55dlZG+2qBptIYcUG0gOM0dlUHLkdK3BZJE0uNcOotR4aRButfAtYkr15KnDSQDi85xY6iVz31G9VAJkyuXnqeBi5UNIekYpZecck5w5IxmuDDQmwG+853vhJ///OeVdEbx2GOPhWnTpoWlllpqwvHoVOK5Ok3qZOrz9TkpTXQeL7zwQlhkkUXmqfu4444Ln/nMZzp5BM0UYDwkWasGJ2vQRY+Op3VJDkaSLNo6IdpfSz9pWnqMY25aewcd3abjbmE3uZE/HQtNEkNjrsmsluNoDtGyNQnVch259nLz2TGJGc3DDz8cPvnJT4ZzzjknLLzwwmGYcMQRR1TSXf2KbW3zw2eaUWyyl8A5i/SF8qRRoRaZ9gXOMFK2hqLrNF2TejWmVQKSkdbYmQQUbNDPTcZPc/SoTmTwNSeDIM1jqS2O4cLAHE2Uxp544onqbrAFF1ywesUN///8z/+s3kfWEfdZnnrqqQn54l1nM2fOrN7H//QutPqzlmbGjBmQzUTEu9Pi+fTVBmixaXKOVT/nnAWSSFAbJIPQ1PmhdqLPyNBp8iLHfrS6uPZaZKe20GTE9JhlzDVHlf6XjLBWZ+rw6vec/CWxKFpfW2dJP1vmXR+gY9TXaxQwMEfzrne9K9x1113VnWD1a9NNN61uDKjfL7TQQuHqq68ez3P//fdXtzNvscUW1ef4P5YRHVaNq666qnIM66yzzniatIw6TV1GH4+gkdiENlm0iRTv3U/rqPNwhoe2yVqPBciJSO9TI4acG8f8OPbTdX+6QlvWaBlLri46VpzT0xhFOr4S62rKLlH7pCBAk9kcw4WB7dEsscQSYb311ptwbLHFFqu+M1Mf33vvvcMhhxwSlllmmcp5fOITn6gcxOabb16d32677SqHsscee4Tjjz++2o858sgjqxsMIiuJ2H///cNXv/rVcNhhh4WPfexj4Zprrgnnn39++MEPftBbX5H+LMkFOaCyUvpZ0t/pcc0R5babi0xzjBByRJT95Moug4BVKuUcKScTUQeda+Q15io5dtQv2g5tT4Wrh8unlcMx9L4wKBY1Chj4XWcS4i3I733ve6svam611VaVDPbd7353/PwCCywQLr300up/dEAf/vCHw5577hmOOeaY8TTx1uboVCKL2XDDDavbnL/xjW9Ud571BS4C7yLa5crkjARnNKz1t13AmiGgEbTEUtL+ofFtMqZdsA6tTEmqstZFJS1NCuUcmDVwkBgyx6ApW9JkYK7daRraX9RGx/BhytiouMQBIt6htuSSS4a9/zGE55+fEp5/UZ7Q3/rmaWHBqc+EVxb7XyFMXRJG3l0yGiSTSBq9JKV01RZrGimPxF4s/UxhZUEW5OanrLMtNIZhGV8kocVj8cac+EQOdC59zzEQVLYGdC2tzKVRmlmzwj+/9rXhybGx8PyUKWGhuXPDha9+d6/JfmxtH6LU37ezGxsbq74G0rTtfcGfdVYQ1WRX9OYciYGrI0e7T1kCioTbgNsXSI9x0b0m40jym9XAdSWr5F6vJrIWqhNF8tpxWjdNbzXYdPy5cnIdhBSAce9zGFifcOlsRKWzUf+ZAOmb7JKDaCP5cFGtVH7XixLVLTkDzklS56g5UHqsDXOzXIOm48YFHTntsc4VTkrjjtH6LMbdOg7IKUpMr816cAwXnNGUQrL2LFEkitikiBPp7tZI06KZNzHMWlvrdPS4RTpL60nPSY6rjQPtWlLUWB0nE0oMDzlxyzyzBgAaW24jX+WUyTGeYYM/vZmHM5qC0BZNk/z1cS5arxcilciooZeixCYLWXJaNJ21fM45aTJUF3shJaJorc3SMY31WevmGCOFdJ00BsJ9Rsdy5iVXpmP44Y6mANJH0JT4noclL7dwuWg/1wgicIaFk0lyxwBJjqi8HGeW05emsOwhWdhB+h4FG9JnKSCxImVanKxlnUcSi20Ll9qGDy6dFUQafWtyWFeGDUWVnFRjrT+XgXDHrPseyEBy5Vj2d6T29hEhW68Jlxc5Fo5RSH1CjojLwx1rC+qopPWhXZ/Sa2kUHNzYiOxfOaPpATSqtyBXEqH11OckJ5MygVyHkAPqDKi0lx635EvP1W1v0ua+DVKTNlrZnzQGlr06if2g+jkpThtTCxOy7Btx5x3DCWc0pTA2bwSXE2Vr0SnKI20EI8mJMzRdLGBuHwXVwxkf1D8rE5Oi+j4NFJWbpP0NTe7U8nF91BgU58DpPNSYj+R06NyU2qc5GKmvg4QzGh7uaDIw+6UZ4aU5U8Kcl+WJ/dTTC4aFpk4L8RelpywQFw6K0rgy0uO2mwH+Ck0WoQ4GyUw2ycmGtH2cLBTrm7feiazrb2ljm6lTrfPa29vt3oteb21Y/9oXnphIjKXus3RujB3bv7aVHsdjGH8v8IUXqqOgj+n4T6x73gAmV8b82zXGQNd+Yj3ztpfB01PC7LEZ4aX4ZcdYbojPC2z3m1MOGe5oMvCbh/8xzHlpWnhpjpzuwkvWCAuE2WHu9EXDlKlxiOPER1aiPl4vDC5NfY6mz0XaDtQmWlduvW3a1hy18bSkof/T8xGpcZYwr+HW6o8qdb7EZ22PXLfty6Ix3UILhTBnzgLZN4FwbKsuR0ojyXBI6qV56XmOEY2nf3Hh8OuxfwrPhxBeGgthgRB/jfeMMJn2TPqGO5qcwZr6Qpiy0HMxjhPTLTVjdlhgyoth7vS5YcoCY4xBT4/97QnM86ZBjqjZZE6ZAyojjWzHxuaC43zZab7BSRmpQ5TGKG0fGl/qkGla6lAtDnbuAB2zdb6Mhfgs2tmzLem1AIkeb5JGm+/ceSX983PD9PBUeLn6avW8rMjRPdzRGFAb55dfmROmTpkbFlBuoXjx+Vlh6tRXwty5z4QpC7ycnEELU2I7E1rRekFoka22jzRMejjvVCxMTfpP8yDkXwt57AfDBBFefnlamDMnRvjzMV58Prz8qmgWudsrr94T5WykHPyhmgY88sgjYZVVVil4GRwOx6ARf0l35ZVXzs4XH0IanxJf/3x835g5c2Z48MEHh+6XilO4ozE+WiL+6Fr87Zs4GYf5KalNEZ9AG53p/Nq/CO/j6KPENYxM5plnngkrrbRSmDq12Tc+orOJvwg8CEybNm2onUyES2cGxMn32te+tnrfxU87DzPm9/5FeB9HH11fw/iY/zaIhn7Yjf0g4V/YdDgcDkdRuKNxOBwOR1G4ozFi+vTp4dOf/nT1f37E/N6/CO/j6GMyXMP5EX4zgMPhcDiKwhmNw+FwOIrCHY3D4XA4isIdjcPhcDiKwh2Nw+FwOIrCHY0BJ598cnjd615XfSFrs802C7fccksYBRx33HHhLW95S1hiiSXC8ssvH3bdddfqCQcptt5663l+jGz//fefkOahhx4KO+20U1h00UWrcg499NDwcvwNhCHA0UcfPU/711prrQnf2D7ggAPCsssuGxZffPGw2267hccff3xk+hcR5x7tY3zFfo3iNbz++uvDzjvvXH0TP7b14osvnueb+kcddVRYccUVwyKLLBK23Xbb8Otf/3pCmr/85S9h9913r760udRSS4W99947PPvssxPS/PKXvwzveMc7qnUbnyZw/PHH99I/B8CYQ8R3vvOdsWnTpo2dccYZY/fcc8/YvvvuO7bUUkuNPf7440M/cttvv/3YmWeeOXb33XeP3XnnnWPvec97xlZdddWxZ599djzN3/3d31V9evTRR8dfs2bNGj//8ssvj6233npj22677dgdd9wxdtlll40tt9xyY0ccccTYMODTn/702Lrrrjuh/X/605/Gz++///5jq6yyytjVV189dtttt41tvvnmY1tuueXI9C/iiSeemNC/q666qnqs949//OORvIax/n/9138d++53v1v146KLLppw/vOf//zYkksuOXbxxReP/eIXvxj7+7//+7HVV1997IUXXhhPs8MOO4xtuOGGYzfffPPYT37yk7E11lhj7IMf/OD4+dj/FVZYYWz33Xev5v+3v/3tsUUWWWTsa1/7Wq99dfwV7mgUvPWtbx074IADxj+/8sorYyuttNLYcccdNzZqiAYrLuzrrrtu/Fg0Up/85CdFozB16tSxxx57bPzYqaeeOjZjxoyx2bNnjw2Do4kGB+Gpp54aW2ihhcYuuOCC8WO/+tWvqjG46aabRqJ/CPF6veENbxibO3fuyF9D6mhin2bOnDn2hS98YcJ1nD59euUsIu69994q36233jqe5oc//OHYlClTxv7whz9Un0855ZSxpZdeekL/Dj/88LE111yzp545Urh0JiA+JO/222+vqHv63LP4+aabbgqjhlmzZlX/l1lmmQnHzznnnLDccsuF9dZbLxxxxBHh+efjT0L9FbGf66+/flhhhRXGj22//fbVww3vueeeMAyIskqUYV7/+tdXckqUiSLitZszZ86E6xdltVVXXXX8+o1C/+icPPvss8PHPvaxCT/ZMOrXsEZ8CnF8CnJ6zeJzyKJknV6zKJdtuumm42li+rg2f/azn42n2WqrraoHTqZ9jtLxk08+2WufHP5QTRF//vOfwyuvvDJhgUbEz/fdd9/IPYH6oIMOCm9729sqY1TjQx/6UFhttdUqQx017cMPP7xajN/97ner83HRo/7X5waNaIDOOuussOaaa4ZHH300fOYzn6l0+bvvvrtqXzQ00SjR9tdtH/b+UcT9jKeeeip85CMfmW+uYYq6Pai96TWL+0wpFlxwwSqAStPER/fTMupzSy+9dNF+OCbCn948SRA3jqPxveGGGyYc32+//cbfx6g3bsC+613vCr/5zW/CG97whjDs2HHHHcffb7DBBpXjiUb3/PPPrzaS5zecfvrpVZ+jU5lfrqFj/odLZwKiFLHAAgvMc5dS/Bx/bGhUcOCBB4ZLL700/PjHP1Z/2Cka6ogHHnig+h/7ifpfnxs2RPbypje9qWp/bF+UmiID4K7fKPXv97//ffjRj34U9tlnn/n2GtbtkdZc/P/EE09MOB/voIt3oo3idZ0McEcjIMoum2yySbj66qsnSFDx8xZbbBGGHXGvNTqZiy66KFxzzTXzSAkId955Z/U/RsURsZ933XXXhIV91VVXVbeVxh+CGzbEW1xjJB/bH6/dQgstNOH6RUkp7uHU12+U+nfmmWdWklG8TXl+vYZxjkZHkF6zuJcU917SaxaDh7gHVyPO77g2aycb08TbqOMeXdrnKLG6bDYATLg1wAFvb453vJx11lnV3S777bdfdXtzegfPsOLjH/94dZvotddeO+HW1+eff746/8ADD4wdc8wx1W2/Dz744Ngll1wy9vrXv35sq622mufW2O222666Rfryyy8fe81rXjM0t/9+6lOfqvoX2//Tn/60uoU33rob77Crb2+Ot3Rf8/+3d/+u50VxHMdPFiVRNpltBhallMFkwmSSrHaj1Shl8AdYjVKWT4qUTGw2P8oik0Ex3G/vd5+Prs/X8P36dvp81fNRtzCoc657Xl33fc75+NB2plIpPd6lfe5qR2mHVE65veM5PJ/PWmYthwxBrVZLX2+323t5s1xj0pbVauXk8/mn5c2JRMKZz+fOdDp1otHoQ3mzVKpJeXO5XNbyZrmOfT4f5c0/hKD5A51ORy9ymU8j5c5Su/8O5CJ+dsjcGrHb7XRACoVCGqYyF6Ferz/MwRCbzcbJ5XI6D0EGcRncb7eb8z8olUpOOBzWcxOJRPS9DL5fZHCq1Wpa6ioDTbFY1LB9l/Z9GY1Geu7W6/XD5+94DmX+z7PfZaVSuZc4NxoNDQppUzab/a3dp9NJg8Xv92uZdrVa1QBzkzk46XRav0N+GxJg+BlsEwAAsIpnNAAAqwgaAIBVBA0AwCqCBgBgFUEDALCKoAEAWEXQAACsImgAAFYRNAAAqwgaAIBVBA3w6Xg86srBzWbz3iez2UxX8XavJgzg77DWGeAyHA5NoVDQgJEl5ePxuMnn86bVatFPwIsIGuDJbqSywZjsSS/7uCwWC+P1eukn4EUEDfDN5XIxsVjM7Pd73VxLtkcG8Dqe0QDfyA6dh8NBd2zcbDb0D/CPuKMBXK7Xq0kmk/psRp7RtNtt/ftMtlAG8BqCBnCp1+um3++b5XJp/H6/yWQyJhgMmsFgQD8BL+KvM+DTeDzWO5her2cCgYDxeDz6ejKZmG63Sz8BL+KOBgBgFXc0AACrCBoAgFUEDQDAKoIGAGAVQQMAsIqgAQBYRdAAAKwiaAAAVhE0AACrCBoAgFUEDQDAKoIGAGBs+gWVZCJvljGoqgAAAABJRU5ErkJggg==" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + } + ], + "execution_count": 4 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-04-08T21:32:28.201182Z", + "start_time": "2026-04-08T21:32:27.676254Z" + } + }, + "cell_type": "code", + "source": [ + "# bottom right detector in DS9\n", + "fig, axs = plt.subplots(1, 2, figsize=(8, 8))\n", + "det5 = res['unknown'][4]\n", + "det5.outputs['F5'].show(ax=axs[0], shade_regions=True, cmap='Greys_r', origin='upper')\n", + "det5.outputs['E5'].show(ax=axs[1], shade_regions=True, cmap='Greys_r', origin='upper')\n", + "axs[0].set_title('F5')\n", + "axs[1].set_title('E5')" + ], + "id": "3096a92e35d0ae44", + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'E5')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + } + ], + "execution_count": 6 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-04-08T21:31:12.327805Z", + "start_time": "2026-04-08T21:31:12.326587Z" + } + }, + "cell_type": "code", + "source": "", + "id": "f6973e94283ebd5e", + "outputs": [], + "execution_count": null + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-04-08T21:31:21.911029Z", + "start_time": "2026-04-08T21:31:21.908151Z" + } + }, + "cell_type": "code", + "source": "", + "id": "5c7dc4334bbd05a6", + "outputs": [], + "execution_count": null + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-04-08T21:31:23.845431Z", + "start_time": "2026-04-08T21:31:23.842565Z" + } + }, + "cell_type": "code", + "source": "", + "id": "7a62a8fd7ee97283", + "outputs": [], + "execution_count": null + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-04-08T21:31:24.039064Z", + "start_time": "2026-04-08T21:31:24.036967Z" + } + }, + "cell_type": "code", + "source": "", + "id": "d423c205b41d456c", + "outputs": [], + "execution_count": null + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "2edc8ff0e9d2b559" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 9ba8ae0c389a87d9891c9c09782793d51b7a8da3 Mon Sep 17 00:00:00 2001 From: Yashvi-Sharma Date: Mon, 1 Jun 2026 16:06:22 -0700 Subject: [PATCH 2/3] Cleaned up configs, added new config for DEIMOS, cleaned up imports, added rotate and flip support in FocalPlaneImage, --- eregion/configs/__init__.py | 1 + eregion/configs/config.py | 2 +- eregion/configs/detectors/basic_ccd.yaml | 4 +- eregion/configs/detectors/deimos.yaml | 31 +- eregion/configs/detectors/deimos_sci.yaml | 376 ++++++++++-------- eregion/configs/detectors/deimos_sci_raw.yaml | 298 ++++++++++++++ .../configs/detectors/deimos_singledet.yaml | 20 +- .../pipeline_flows/masterbias_example.yaml | 2 + eregion/core/image_operations.py | 25 +- eregion/datamodels/__init__.py | 1 + eregion/datamodels/image.py | 158 ++++---- eregion/pipeline/engine.py | 7 +- eregion/tasks/__init__.py | 6 + eregion/tasks/calibration.py | 7 +- eregion/tasks/custom.py | 12 + eregion/tasks/imagegen.py | 25 +- eregion/tasks/preprocessing.py | 10 +- eregion/tasks/task.py | 3 +- eregion/utils/__init__.py | 3 + eregion/utils/image_utils.py | 2 +- playground/Example_pipeline_flows.ipynb | 286 +++++++------ playground/deimos_sci_testing.ipynb | 315 +++++++++++---- 22 files changed, 1100 insertions(+), 494 deletions(-) create mode 100644 eregion/configs/detectors/deimos_sci_raw.yaml diff --git a/eregion/configs/__init__.py b/eregion/configs/__init__.py index e69de29..d085c3a 100644 --- a/eregion/configs/__init__.py +++ b/eregion/configs/__init__.py @@ -0,0 +1 @@ +from .config import * \ No newline at end of file diff --git a/eregion/configs/config.py b/eregion/configs/config.py index ba9a036..84a835d 100644 --- a/eregion/configs/config.py +++ b/eregion/configs/config.py @@ -1,6 +1,6 @@ from abc import ABC, abstractmethod import yaml -from utils.misc_utils import configure_logger +from utils import configure_logger # A yaml constructor for slice objects def slice_constructor(loader, node): diff --git a/eregion/configs/detectors/basic_ccd.yaml b/eregion/configs/detectors/basic_ccd.yaml index a3b6e4e..7441de9 100644 --- a/eregion/configs/detectors/basic_ccd.yaml +++ b/eregion/configs/detectors/basic_ccd.yaml @@ -32,7 +32,7 @@ objects: parallel_prescan: !slice [0, 20] # 20 prescan rows w.r.t. the data_slice parallel_overscan: !slice [4076, 4096] # 20 overscan rows w.r.t. the data_slice parallel_axis: 'y' # First axis in the data array (rows) represent parallel readout direction - readout_pixel: [0, 0] # Readout of this amplifier (top left) + readout_pixel: [0, 0] # Readout of this amplifier (assumed to be away from this corner in both directions) gain: 1.0 # electrons/ADU read_noise: 5.0 # electrons bias_level: 1000 # ADU @@ -45,7 +45,7 @@ objects: parallel_prescan: !slice [0, 20] # 20 prescan rows w.r.t. the data_slice parallel_overscan: !slice [4076, 4096] # 20 overscan rows w.r.t. the data_slice parallel_axis: 'y' - readout_pixel: [0, 2047] # Readout of this amplifier (top right) + readout_pixel: [0, 2047] # Readout of this amplifier (assumed to be away from this corner in both directions) gain: 1.0 # electrons/ADU read_noise: 5.0 # electrons bias_level: 1000 # ADU diff --git a/eregion/configs/detectors/deimos.yaml b/eregion/configs/detectors/deimos.yaml index aa657f7..a8044cf 100644 --- a/eregion/configs/detectors/deimos.yaml +++ b/eregion/configs/detectors/deimos.yaml @@ -1,6 +1,6 @@ -## Example detector definition file for the DEIMOS instrument CCD array -## A single FITS file contains 8 extensions, one per detector, so 8 DetImage instances are created from this file. -## Each DetImage instance has two outputs (two channels per detector). +## Example detector definition file for the OLD DEIMOS full array. +## A single FITS file contains (at least) 8 extensions, one per detector (both outputs in same extension). +## 8 DetImage instances are defined below. --- description: DEIMOS CCD detector array, 8 detectors with two channel readout each detector_type: CCD # (specify the type of detector, e.g., CCD, CMOS, H2RG, etc.) @@ -46,6 +46,8 @@ objects: x_cen: -46.08 # mm y_cen: 30.72 # mm angle: 0.0 # degrees + flip_x: false # flip to place in focal plane assuming 0,0 is bottom left and +y is up, +x is right + flip_y: true - name: 'det_2' class: DetImage @@ -86,6 +88,8 @@ objects: x_cen: -15.36 # mm y_cen: 30.72 # mm angle: 0.0 # degrees + flip_x: false + flip_y: true - name: 'det_3' class: DetImage @@ -126,6 +130,8 @@ objects: x_cen: 15.36 # mm y_cen: 30.72 # mm angle: 0.0 # degrees + flip_x: false + flip_y: true - name: 'det_4' class: DetImage @@ -166,6 +172,8 @@ objects: x_cen: 46.08 # mm y_cen: 30.72 # mm angle: 0.0 # degrees + flip_x: false + flip_y: true - name: 'det_5' class: DetImage @@ -203,9 +211,11 @@ objects: read_noise: 5.0 # electrons bias_level: 1000 # ADU focal_plane_position: - x_cen: 46.08 # mm + x_cen: -46.08 # mm y_cen: -30.72 # mm angle: 0.0 # degrees + flip_x: true + flip_y: false - name: 'det_6' class: DetImage @@ -243,9 +253,11 @@ objects: read_noise: 5.0 # electrons bias_level: 1000 # ADU focal_plane_position: - x_cen: 15.36 # mm + x_cen: -15.36 # mm y_cen: -30.72 # mm angle: 0.0 # degrees + flip_x: true + flip_y: false - name: 'det_7' class: DetImage @@ -283,9 +295,11 @@ objects: read_noise: 5.0 # electrons bias_level: 1000 # ADU focal_plane_position: - x_cen: -15.36 # mm + x_cen: 15.36 # mm y_cen: -30.72 # mm angle: 0.0 # degrees + flip_x: true + flip_y: false - name: 'det_8' class: DetImage @@ -323,10 +337,11 @@ objects: read_noise: 5.0 # electrons bias_level: 1000 # ADU focal_plane_position: - x_cen: -46.08 # mm + x_cen: 46.08 # mm y_cen: -30.72 # mm angle: 0.0 # degrees - + flip_x: true + flip_y: false diff --git a/eregion/configs/detectors/deimos_sci.yaml b/eregion/configs/detectors/deimos_sci.yaml index d6a21ad..7c66f5e 100644 --- a/eregion/configs/detectors/deimos_sci.yaml +++ b/eregion/configs/detectors/deimos_sci.yaml @@ -1,6 +1,6 @@ -## DEIMOS science CCD config -## FITS with 1 extension, full focal plane image with 8 detectors -> 8 DetImage instances to be created -## Each DetImage instance has two outputs (two channels per detector). +## NEW DEIMOS Science detectors full array config. +## 8 fits files for full array, one per detector, each with 2 extensions for the two channels of that detector. +## Complete config to load all 8 detectors correctly from 8 separate files defined below. --- description: DEIMOS CCD detector array, 8 detectors with two channel readout each detector_type: CCD @@ -9,275 +9,339 @@ detector_output_class: CCDOutput objects: - name: 'det_1' class: DetImage - filename_format: '*.fits*' + filename_format: '*SCI_1_*' # Use wildcard to indicate the filename properties: x_size: 2188 - y_size: 4125 + y_size: 4124 saturation_level: 65535 # ADU pixel_size: 0.015 # mm outputs: - - id: 'E1' - ext_id: 0 - ext_slice: [!slice [8249, 4124], !slice [0, 1094]] - data_slice: [!slice [0, 4125], !slice [0, 1094]] + - id: 'E' + ext_id: 1 + ext_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the full DetImage data array where this output's data will go serial_prescan: !slice [0, 50] serial_overscan: !slice [1074, 1094] - parallel_prescan: !slice [0, 1] - parallel_overscan: !slice [4105, 4125] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4104, 4124] parallel_axis: 'y' readout_pixel: [0, 0] - - id: 'F1' - ext_id: 0 - ext_slice: [!slice [8249, 4124], !slice [1094, 2188]] - data_slice: [!slice [0, 4125], !slice [1094, 2188]] + gain: 1.0 # electrons/ADU + read_noise: # electrons + bias_level: # ADU + - id: 'F' + ext_id: 4 # FITS extension ID + ext_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4124], !slice [1094, 2188]] # Slice of the full DetImage data array where this output's data will go serial_prescan: !slice [2187, 2137] serial_overscan: !slice [1113, 1093] - parallel_prescan: !slice [0, 1] - parallel_overscan: !slice [4105, 4125] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4104, 4124] parallel_axis: 'y' readout_pixel: [0, 2187] + gain: 1.0 # electrons/ADU + read_noise: # electrons + bias_level: # ADU focal_plane_position: - x_cen: -46.08 # mm - y_cen: 30.72 # mm - angle: 0.0 # degrees + x_cen: 49.275 # mm + y_cen: 30.945 # mm + angle: 180.0 # degrees (assuming origin is bottom left and angle is CCW positive) + flip_x: false + flip_y: false - name: 'det_2' class: DetImage - filename_format: '*.fits*' # Use wildcard to indicate the filename + filename_format: '*SCI_2_*' # Use wildcard to indicate the filename properties: x_size: 2188 - y_size: 4125 + y_size: 4124 saturation_level: 65535 # ADU pixel_size: 0.015 # mm outputs: - - id: 'E2' - ext_id: 0 - ext_slice: [!slice [8249, 4124], !slice [2188, 3282]] - data_slice: [!slice [0, 4125], !slice [0, 1094]] + - id: 'E' + ext_id: 1 + ext_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the full DetImage data array where this output's data will go serial_prescan: !slice [0, 50] serial_overscan: !slice [1074, 1094] - parallel_prescan: !slice [0, 1] - parallel_overscan: !slice [4105, 4125] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4104, 4124] parallel_axis: 'y' readout_pixel: [0, 0] - - id: 'F2' - ext_id: 0 - ext_slice: [!slice [8249, 4124], !slice [3282, 4376]] - data_slice: [!slice [0, 4125], !slice [1094, 2188]] + gain: 1.0 # electrons/ADU + read_noise: # electrons + bias_level: # ADU + - id: 'F' + ext_id: 4 # FITS extension ID + ext_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4124], !slice [1094, 2188]] # Slice of the full DetImage data array where this output's data will go serial_prescan: !slice [2187, 2137] serial_overscan: !slice [1113, 1093] - parallel_prescan: !slice [0, 1] - parallel_overscan: !slice [4105, 4125] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4104, 4124] parallel_axis: 'y' readout_pixel: [0, 2187] + gain: 1.0 # electrons/ADU + read_noise: # electrons + bias_level: # ADU focal_plane_position: - x_cen: -15.36 # mm - y_cen: 30.72 # mm - angle: 0.0 # degrees + x_cen: 16.425 # mm + y_cen: 30.945 # mm + angle: 180.0 # degrees (assuming origin is bottom left and angle is CCW positive) + flip_x: false + flip_y: false - name: 'det_3' class: DetImage - filename_format: '*.fits*' # Use wildcard to indicate the filename + filename_format: '*SCI_3_*' # Use wildcard to indicate the filename properties: x_size: 2188 - y_size: 4125 + y_size: 4124 saturation_level: 65535 # ADU pixel_size: 0.015 # mm outputs: - - id: 'E3' - ext_id: 0 - ext_slice: [!slice [8249, 4124], !slice [4376, 5470]] - data_slice: [!slice [0, 4125], !slice [0, 1094]] + - id: 'E' + ext_id: 1 + ext_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the full DetImage data array where this output's data will go serial_prescan: !slice [0, 50] serial_overscan: !slice [1074, 1094] - parallel_prescan: !slice [0, 1] - parallel_overscan: !slice [4105, 4125] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4104, 4124] parallel_axis: 'y' readout_pixel: [0, 0] - - id: 'F3' - ext_id: 0 - ext_slice: [!slice [8249, 4124], !slice [5470, 6564]] - data_slice: [!slice [0, 4125], !slice [1094, 2188]] + gain: 1.0 # electrons/ADU + read_noise: # electrons + bias_level: # ADU + - id: 'F' + ext_id: 4 # FITS extension ID + ext_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4124], !slice [1094, 2188]] # Slice of the full DetImage data array where this output's data will go serial_prescan: !slice [2187, 2137] serial_overscan: !slice [1113, 1093] - parallel_prescan: !slice [0, 1] - parallel_overscan: !slice [4105, 4125] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4104, 4124] parallel_axis: 'y' readout_pixel: [0, 2187] + gain: 1.0 # electrons/ADU + read_noise: # electrons + bias_level: # ADU focal_plane_position: - x_cen: 15.36 # mm - y_cen: 30.72 # mm - angle: 0.0 # degrees + x_cen: -16.425 # mm + y_cen: 30.945 # mm + angle: 180.0 # degrees (assuming origin is bottom left and angle is CCW positive) + flip_x: false + flip_y: false - name: 'det_4' class: DetImage - filename_format: '*.fits*' # Use wildcard to indicate the filename + filename_format: '*SCI_4_*' # Use wildcard to indicate the filename properties: x_size: 2188 - y_size: 4125 + y_size: 4124 saturation_level: 65535 # ADU pixel_size: 0.015 # mm outputs: - - id: 'E4' - ext_id: 0 - ext_slice: [!slice [8249, 4124], !slice [6564, 7658]] - data_slice: [!slice [0, 4125], !slice [0, 1094]] + - id: 'E' + ext_id: 1 + ext_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the full DetImage data array where this output's data will go serial_prescan: !slice [0, 50] serial_overscan: !slice [1074, 1094] - parallel_prescan: !slice [0, 1] - parallel_overscan: !slice [4105, 4125] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4104, 4124] parallel_axis: 'y' readout_pixel: [0, 0] - - id: 'F4' - ext_id: 0 - ext_slice: [!slice [8249, 4124], !slice [7658, 8752]] - data_slice: [!slice [0, 4125], !slice [1094, 2188]] + gain: 1.0 # electrons/ADU + read_noise: # electrons + bias_level: # ADU + - id: 'F' + ext_id: 4 # FITS extension ID + ext_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4124], !slice [1094, 2188]] # Slice of the full DetImage data array where this output's data will go serial_prescan: !slice [2187, 2137] serial_overscan: !slice [1113, 1093] - parallel_prescan: !slice [0, 1] - parallel_overscan: !slice [4105, 4125] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4104, 4124] parallel_axis: 'y' readout_pixel: [0, 2187] + gain: 1.0 # electrons/ADU + read_noise: # electrons + bias_level: # ADU focal_plane_position: - x_cen: 46.08 # mm - y_cen: 30.72 # mm - angle: 0.0 # degrees + x_cen: -49.275 # mm + y_cen: 30.945 # mm + angle: 180.0 # degrees (assuming origin is bottom left and angle is CCW positive) + flip_x: false + flip_y: false - name: 'det_5' class: DetImage - filename_format: '*.fits*' # Use wildcard to indicate the filename + filename_format: '*SCI_5_*' # Use wildcard to indicate the filename properties: x_size: 2188 - y_size: 4125 + y_size: 4124 saturation_level: 65535 # ADU pixel_size: 0.015 # mm outputs: - - id: 'E5' - ext_id: 0 - ext_slice: [!slice [4124, -1], !slice [7658, 8752]] - data_slice: [!slice [0, 4125], !slice [1094, 2188]] - serial_prescan: !slice [2187, 2137] - serial_overscan: !slice [1113, 1093] - parallel_prescan: !slice [4124, 4123] - parallel_overscan: !slice [19, -1] - parallel_axis: 'y' - readout_pixel: [4124, 2187] - - id: 'F5' - ext_id: 0 - ext_slice: [!slice [4124, -1], !slice [6564, 7658]] - data_slice: [!slice [0, 4125], !slice [0, 1094]] + - id: 'E' + ext_id: 1 + ext_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the full DetImage data array where this output's data will go serial_prescan: !slice [0, 50] serial_overscan: !slice [1074, 1094] - parallel_prescan: !slice [4124, 4123] - parallel_overscan: !slice [19, -1] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4104, 4124] parallel_axis: 'y' - readout_pixel: [4124, 0] + readout_pixel: [0, 0] + gain: 1.0 # electrons/ADU + read_noise: # electrons + bias_level: # ADU + - id: 'F' + ext_id: 4 # FITS extension ID + ext_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4124], !slice [1094, 2188]] # Slice of the full DetImage data array where this output's data will go + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4104, 4124] + parallel_axis: 'y' + readout_pixel: [0, 2187] + gain: 1.0 # electrons/ADU + read_noise: # electrons + bias_level: # ADU focal_plane_position: - x_cen: 46.08 # mm - y_cen: -30.72 # mm - angle: 0.0 # degrees + x_cen: -49.275 # mm + y_cen: -30.945 # mm + angle: 0.0 # degrees (assuming origin is bottom left and angle is CCW positive) + flip_x: false + flip_y: false - name: 'det_6' class: DetImage - filename_format: '*.fits*' # Use wildcard to indicate the filename + filename_format: '*SCI_6_*' # Use wildcard to indicate the filename properties: x_size: 2188 - y_size: 4125 + y_size: 4124 saturation_level: 65535 # ADU pixel_size: 0.015 # mm outputs: - - id: 'E6' - ext_id: 0 - ext_slice: [!slice [4124, -1], !slice [5470, 6564]] - data_slice: [!slice [0, 4125], !slice [1094, 2188]] - serial_prescan: !slice [2187, 2137] - serial_overscan: !slice [1113, 1093] - parallel_prescan: !slice [4124, 4123] - parallel_overscan: !slice [19, -1] - parallel_axis: 'y' - readout_pixel: [4124, 2187] - - id: 'F6' - ext_id: 0 - ext_slice: [!slice [4124, -1], !slice [4376, 5470]] - data_slice: [!slice [0, 4125], !slice [0, 1094]] + - id: 'E' + ext_id: 1 + ext_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the full DetImage data array where this output's data will go serial_prescan: !slice [0, 50] serial_overscan: !slice [1074, 1094] - parallel_prescan: !slice [4124, 4123] - parallel_overscan: !slice [19, -1] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4104, 4124] parallel_axis: 'y' - readout_pixel: [4124, 0] + readout_pixel: [0, 0] + gain: 1.0 # electrons/ADU + read_noise: # electrons + bias_level: # ADU + - id: 'F' + ext_id: 4 # FITS extension ID + ext_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4124], !slice [1094, 2188]] # Slice of the full DetImage data array where this output's data will go + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4104, 4124] + parallel_axis: 'y' + readout_pixel: [0, 2187] + gain: 1.0 # electrons/ADU + read_noise: # electrons + bias_level: # ADU focal_plane_position: - x_cen: 15.36 # mm - y_cen: -30.72 # mm + x_cen: -16.425 # mm + y_cen: -30.945 # mm angle: 0.0 # degrees + flip_x: false + flip_y: false - name: 'det_7' class: DetImage - filename_format: '*.fits*' # Use wildcard to indicate the filename + filename_format: '*SCI_7_*' # Use wildcard to indicate the filename properties: x_size: 2188 - y_size: 4125 + y_size: 4124 saturation_level: 65535 # ADU pixel_size: 0.015 # mm outputs: - - id: 'E7' - ext_id: 0 - ext_slice: [!slice [4124, -1], !slice [3282, 4376]] - data_slice: [!slice [0, 4125], !slice [1094, 2188]] - serial_prescan: !slice [2187, 2137] - serial_overscan: !slice [1113, 1093] - parallel_prescan: !slice [4124, 4123] - parallel_overscan: !slice [19, -1] - parallel_axis: 'y' - readout_pixel: [4124, 2187] - - id: 'F7' - ext_id: 0 - ext_slice: [!slice [4124, -1], !slice [2188, 3282]] - data_slice: [!slice [0, 4125], !slice [0, 1094]] + - id: 'E' + ext_id: 1 + ext_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the full DetImage data array where this output's data will go serial_prescan: !slice [0, 50] serial_overscan: !slice [1074, 1094] - parallel_prescan: !slice [4124, 4123] - parallel_overscan: !slice [19, -1] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4104, 4124] + parallel_axis: 'y' + readout_pixel: [0, 0] + gain: 1.0 # electrons/ADU + read_noise: # electrons + bias_level: # ADU + - id: 'F' + ext_id: 4 # FITS extension ID + ext_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4124], !slice [1094, 2188]] # Slice of the full DetImage data array where this output's data will go + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4104, 4124] parallel_axis: 'y' - readout_pixel: [4124, 0] + readout_pixel: [0, 2187] + gain: 1.0 # electrons/ADU + read_noise: # electrons + bias_level: # ADU focal_plane_position: - x_cen: -15.36 # mm - y_cen: -30.72 # mm + x_cen: 16.425 # mm + y_cen: -30.945 # mm angle: 0.0 # degrees + flip_x: false + flip_y: false - name: 'det_8' class: DetImage - filename_format: '*.fits*' # Use wildcard to indicate the filename + filename_format: '*SCI_8_*' # Use wildcard to indicate the filename properties: x_size: 2188 - y_size: 4125 + y_size: 4124 saturation_level: 65535 # ADU pixel_size: 0.015 # mm outputs: - - id: 'E8' - ext_id: 0 - ext_slice: [!slice [4124, -1], !slice [1094, 2188]] - data_slice: [!slice [0, 4125], !slice [1094, 2188]] - serial_prescan: !slice [2187, 2137] - serial_overscan: !slice [1113, 1093] - parallel_prescan: !slice [4124, 4123] - parallel_overscan: !slice [19, -1] - parallel_axis: 'y' - readout_pixel: [4124, 2187] - - id: 'F8' - ext_id: 0 - ext_slice: [!slice [4124, -1], !slice [0, 1094]] - data_slice: [!slice [0, 4125], !slice [0, 1094]] + - id: 'E' + ext_id: 1 + ext_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the full DetImage data array where this output's data will go serial_prescan: !slice [0, 50] serial_overscan: !slice [1074, 1094] - parallel_prescan: !slice [4124, 4123] - parallel_overscan: !slice [19, -1] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4104, 4124] parallel_axis: 'y' - readout_pixel: [4124, 0] + readout_pixel: [0, 0] + gain: 1.0 # electrons/ADU + read_noise: # electrons + bias_level: # ADU + - id: 'F' + ext_id: 4 # FITS extension ID + ext_slice: [!slice [0, 4124], !slice [0, 1094]] # Slice of the ext_id that has the data for this output + data_slice: [!slice [0, 4124], !slice [1094, 2188]] # Slice of the full DetImage data array where this output's data will go + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 0] + parallel_overscan: !slice [4104, 4124] + parallel_axis: 'y' + readout_pixel: [0, 2187] + gain: 1.0 # electrons/ADU + read_noise: # electrons + bias_level: # ADU focal_plane_position: - x_cen: -46.08 # mm - y_cen: -30.72 # mm + x_cen: 49.275 # mm + y_cen: -30.945 # mm angle: 0.0 # degrees + flip_x: false + flip_y: false diff --git a/eregion/configs/detectors/deimos_sci_raw.yaml b/eregion/configs/detectors/deimos_sci_raw.yaml new file mode 100644 index 0000000..321530e --- /dev/null +++ b/eregion/configs/detectors/deimos_sci_raw.yaml @@ -0,0 +1,298 @@ +## NEW DEIMOS science CCD config, first pass version +## FITS with 1 extension containing full focal plane image with 8 detectors -> 8 DetImage instances to be created +--- +description: DEIMOS CCD detector array, 8 detectors with two channel readout each +detector_type: CCD +detector_output_class: CCDOutput + +objects: + - name: 'det_1' + class: DetImage + filename_format: '*.fits*' + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'E1' + ext_id: 0 + ext_slice: [!slice [8249, 4124], !slice [0, 1094]] + data_slice: [!slice [0, 4125], !slice [0, 1094]] + serial_prescan: !slice [0, 50] + serial_overscan: !slice [1074, 1094] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 0] + - id: 'F1' + ext_id: 0 + ext_slice: [!slice [8249, 4124], !slice [1094, 2188]] + data_slice: [!slice [0, 4125], !slice [1094, 2188]] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 2187] + focal_plane_position: + x_cen: -49.23 # mm + y_cen: 30.9375 # mm + angle: 0.0 # degrees + flip_x: false + flip_y: true + + - name: 'det_2' + class: DetImage + filename_format: '*.fits*' # Use wildcard to indicate the filename + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'E2' + ext_id: 0 + ext_slice: [!slice [8249, 4124], !slice [2188, 3282]] + data_slice: [!slice [0, 4125], !slice [0, 1094]] + serial_prescan: !slice [0, 50] + serial_overscan: !slice [1074, 1094] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 0] + - id: 'F2' + ext_id: 0 + ext_slice: [!slice [8249, 4124], !slice [3282, 4376]] + data_slice: [!slice [0, 4125], !slice [1094, 2188]] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 2187] + focal_plane_position: + x_cen: -16.41 # mm + y_cen: 30.9375 # mm + angle: 0.0 # degrees + flip_x: false + flip_y: true + + - name: 'det_3' + class: DetImage + filename_format: '*.fits*' # Use wildcard to indicate the filename + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'E3' + ext_id: 0 + ext_slice: [!slice [8249, 4124], !slice [4376, 5470]] + data_slice: [!slice [0, 4125], !slice [0, 1094]] + serial_prescan: !slice [0, 50] + serial_overscan: !slice [1074, 1094] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 0] + - id: 'F3' + ext_id: 0 + ext_slice: [!slice [8249, 4124], !slice [5470, 6564]] + data_slice: [!slice [0, 4125], !slice [1094, 2188]] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 2187] + focal_plane_position: + x_cen: 16.41 # mm + y_cen: 30.9375 # mm + angle: 0.0 # degrees + flip_x: false + flip_y: true + + - name: 'det_4' + class: DetImage + filename_format: '*.fits*' # Use wildcard to indicate the filename + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'E4' + ext_id: 0 + ext_slice: [!slice [8249, 4124], !slice [6564, 7658]] + data_slice: [!slice [0, 4125], !slice [0, 1094]] + serial_prescan: !slice [0, 50] + serial_overscan: !slice [1074, 1094] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 0] + - id: 'F4' + ext_id: 0 + ext_slice: [!slice [8249, 4124], !slice [7658, 8752]] + data_slice: [!slice [0, 4125], !slice [1094, 2188]] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 2187] + focal_plane_position: + x_cen: 49.23 # mm + y_cen: 30.9375 # mm + angle: 0.0 # degrees + flip_x: false + flip_y: true + + - name: 'det_5' + class: DetImage + filename_format: '*.fits*' # Use wildcard to indicate the filename + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'E5' + ext_id: 0 + ext_slice: [!slice [0, 4125], !slice [8751, 7657]] + data_slice: [!slice [0, 4125], !slice [0, 1094]] + serial_prescan: !slice [0, 50] + serial_overscan: !slice [1074, 1094] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 0] + - id: 'F5' + ext_id: 0 + ext_slice: [!slice [0, 4125], !slice [7657, 6563]] + data_slice: [!slice [0, 4125], !slice [1094, 2188]] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 2187] + focal_plane_position: + x_cen: 49.23 # mm + y_cen: -30.9375 # mm + angle: 0.0 # degrees + flip_x: true + flip_y: false + + - name: 'det_6' + class: DetImage + filename_format: '*.fits*' # Use wildcard to indicate the filename + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'E6' + ext_id: 0 + ext_slice: [!slice [0, 4125], !slice [6563, 5469]] + data_slice: [!slice [0, 4125], !slice [0, 1094]] + serial_prescan: !slice [0, 50] + serial_overscan: !slice [1074, 1094] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 0] + - id: 'F6' + ext_id: 0 + ext_slice: [!slice [0, 4125], !slice [5469, 4375]] + data_slice: [!slice [0, 4125], !slice [1094, 2188]] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 2187] + focal_plane_position: + x_cen: 16.41 # mm + y_cen: -30.9375 # mm + angle: 0.0 # degrees + flip_x: true + flip_y: false + + - name: 'det_7' + class: DetImage + filename_format: '*.fits*' # Use wildcard to indicate the filename + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'E7' + ext_id: 0 + ext_slice: [!slice [0, 4125], !slice [4375, 3281]] + data_slice: [!slice [0, 4125], !slice [0, 1094]] + serial_prescan: !slice [0, 50] + serial_overscan: !slice [1074, 1094] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 0] + - id: 'F7' + ext_id: 0 + ext_slice: [!slice [0, 4125], !slice [3281, 2187]] + data_slice: [!slice [0, 4125], !slice [1094, 2188]] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 2187] + focal_plane_position: + x_cen: -16.41 # mm + y_cen: -30.9375 # mm + angle: 0.0 # degrees + flip_x: true + flip_y: false + + - name: 'det_8' + class: DetImage + filename_format: '*.fits*' # Use wildcard to indicate the filename + properties: + x_size: 2188 + y_size: 4125 + saturation_level: 65535 # ADU + pixel_size: 0.015 # mm + outputs: + - id: 'E8' + ext_id: 0 + ext_slice: [!slice [0, 4125], !slice [2187, 1093]] + data_slice: [!slice [0, 4125], !slice [0, 1094]] + serial_prescan: !slice [0, 50] + serial_overscan: !slice [1074, 1094] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 0] + - id: 'F8' + ext_id: 0 + ext_slice: [!slice [0, 4125], !slice [1093, -1]] + data_slice: [!slice [0, 4125], !slice [1094, 2188]] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 1] + parallel_overscan: !slice [4105, 4125] + parallel_axis: 'y' + readout_pixel: [0, 2187] + focal_plane_position: + x_cen: -49.23 # mm + y_cen: -30.9375 # mm + angle: 0.0 # degrees + flip_x: true + flip_y: false + + + diff --git a/eregion/configs/detectors/deimos_singledet.yaml b/eregion/configs/detectors/deimos_singledet.yaml index 8903d4d..4d2b8ea 100644 --- a/eregion/configs/detectors/deimos_singledet.yaml +++ b/eregion/configs/detectors/deimos_singledet.yaml @@ -1,6 +1,6 @@ -## Example detector definition file for the DEIMOS instrument CCD array -## A single FITS file contains 8 extensions, one per detector, so 8 DetImage instances are created from this file. -## Each DetImage instance has two outputs (two channels per detector). +## Example detector definition file for DEIMOS single detector. +## A single FITS file contains data for one detector, with the 2 outputs in 2 separate extensions. +## One DetImage instance is defined below. --- description: DEIMOS CCD detector single detector_type: CCD # (specify the type of detector, e.g., CCD, CMOS, H2RG, etc.) @@ -22,7 +22,7 @@ objects: data_slice: [!slice [0, 4125], !slice [0, 1094]] # Slice of the full DetImage data array where this output's data will go serial_prescan: !slice [0, 50] serial_overscan: !slice [1074, 1094] - parallel_prescan: !slice [0, 50] + parallel_prescan: !slice [0, 1] parallel_overscan: !slice [4105, 4125] parallel_axis: 'y' # First axis in the data array (rows) represent parallel readout direction readout_pixel: [0, 0] # top left pixel @@ -33,18 +33,18 @@ objects: ext_id: 2 # FITS extension ID ext_slice: [!slice [0, 4125], !slice [0, 1094]] # Slice of the ext_id that has the data for this output data_slice: [!slice [0, 4125], !slice [1094, 2188]] # Slice of the full DetImage data array where this output's data will go - serial_prescan: !slice [1094, 1044] - serial_overscan: !slice [20, 0] - parallel_prescan: !slice [0, 50] + serial_prescan: !slice [2187, 2137] + serial_overscan: !slice [1113, 1093] + parallel_prescan: !slice [0, 1] parallel_overscan: !slice [4105, 4125] parallel_axis: 'y' # First axis in the data array (rows) represent parallel readout direction - readout_pixel: [0, 1094] # top right pixel + readout_pixel: [0, 2187] # top right pixel gain: 1.0 # electrons/ADU read_noise: 5.0 # electrons bias_level: 1000 # ADU focal_plane_position: - x_cen: -46.08 # mm - y_cen: 30.72 # mm + x_cen: 0 # mm + y_cen: 0 # mm angle: 0.0 # degrees diff --git a/eregion/configs/pipeline_flows/masterbias_example.yaml b/eregion/configs/pipeline_flows/masterbias_example.yaml index 1ab6fc0..ebc8107 100644 --- a/eregion/configs/pipeline_flows/masterbias_example.yaml +++ b/eregion/configs/pipeline_flows/masterbias_example.yaml @@ -15,6 +15,7 @@ pipelines: params: input_source: "/Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/*_bias_*.fits" identifier_func: tasks.custom.guess_image_type_from_filename_DEIMOS + fitsloader_func: tasks.custom.load_image_fits_DEIMOS - name: master_bias task: tasks.calibration.MasterBias @@ -39,6 +40,7 @@ pipelines: params: input_source: "/Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/*flat_0.000*.fits" identifier_func: tasks.custom.guess_image_type_from_filename_DEIMOS + fitsloader_func: tasks.custom.load_image_fits_DEIMOS - name: bias_subtraction task: tasks.preprocessing.BiasSubtraction diff --git a/eregion/core/image_operations.py b/eregion/core/image_operations.py index c859bd3..98eda8b 100644 --- a/eregion/core/image_operations.py +++ b/eregion/core/image_operations.py @@ -90,4 +90,27 @@ def sigma_clip_image(image: np.ndarray | np.ma.MaskedArray, sigma: float, axis: The sigma-clipped image. """ masked = sigma_clip(image, sigma=sigma, axis=axis, **kwargs) - return masked \ No newline at end of file + return masked + +def flip_and_rotate(image: np.ndarray, angle: float, flip_x: bool=False, flip_y: bool=False) -> np.ndarray: + """ + Flip and rotate an image. Rotation angle is assumed to be in degrees and positive for counter-clockwise direction, + and has to be a multiple of 90. + :param image: 2D numpy array + :param angle: in degrees + :param flip_x: True to flip left-right + :param flip_y: True to flip up-down + :return: flipped and rotated image + """ + if image.ndim != 2: + raise ValueError('Input image is not a 2D array.') + if flip_y: + image = np.flipud(image) + if flip_x: + image = np.fliplr(image) + if angle % 90 != 0: + raise ValueError('Angle must be a multiple of 90 degrees.') + else: + k = (angle // 90) % 4 + image = np.rot90(image, int(k)) + return image \ No newline at end of file diff --git a/eregion/datamodels/__init__.py b/eregion/datamodels/__init__.py index e69de29..bdcb698 100644 --- a/eregion/datamodels/__init__.py +++ b/eregion/datamodels/__init__.py @@ -0,0 +1 @@ +from .image import * \ No newline at end of file diff --git a/eregion/datamodels/image.py b/eregion/datamodels/image.py index b105d9d..0e9d4c6 100644 --- a/eregion/datamodels/image.py +++ b/eregion/datamodels/image.py @@ -9,12 +9,11 @@ import matplotlib.pyplot as plt from astropy.io import fits -from utils.image_utils import ensure_dataarray, slice_data, ensure_numpy -from utils.misc_utils import configure_logger +from utils import ensure_dataarray, slice_data, ensure_numpy, configure_logger +from core.image_operations import flip_and_rotate logger = configure_logger(__name__) - class DetectorProperties(BaseModel): """ Physical and sampling properties for a detector tile. @@ -128,7 +127,7 @@ def set_data_in_parent(self, new_data: xr.DataArray | np.ndarray): def show(self, ax=None, save=None, **imshow_kwargs): if ax is None: _, ax = plt.subplots(1,1, figsize=(6, 6), tight_layout=True) - im = xr.plot.imshow(self.data, ax=ax, **imshow_kwargs) + im = self.data.plot.imshow(ax=ax, **imshow_kwargs) if save is not None: ax.figure.savefig(save) return ax @@ -247,6 +246,7 @@ def __init__( self.meta = {} # Merge any additional kwargs into meta self.meta.update(kwargs) + self.id = self.meta.name # Outputs @@ -289,7 +289,7 @@ def show(self, ax=None, save=None, **imshow_kwargs): raise ValueError("DetImage has no data to show.") if ax is None: _, ax = plt.subplots(1, 1, figsize=(6, 6), tight_layout=True) - im = xr.plot.imshow(self.data, ax=ax, **imshow_kwargs) + im = self.data.plot.imshow(ax=ax, **imshow_kwargs) if save is not None: ax.figure.savefig(save) return ax @@ -300,9 +300,9 @@ class FocalPlaneImage: :param num_detectors: int Number of detector tiles expected. :param dim: tuple[int, int] - Dimensions of the focal plane image (height, width) in pixels. + Dimensions of the focal plane image (height, width) in mm. :param fp_center: Optional[Tuple[float, float]] - Pixels coordinates (y, x) corresponding to the focal plane center with respect to the image array origin (top-left). + Coordinates (y, x) in mm corresponding to the focal plane center with respect to the image array origin (top-left). Default is dim/2 i.e. (ydim/2, xdim/2). :param det_images: Optional[List[DetImage]] List of DetImage objects to place on the focal plane. @@ -311,64 +311,81 @@ class FocalPlaneImage: def __init__( self, num_detectors: int, - dim: tuple[int, int], - fp_center: Optional[tuple[float, float]] = None, + dim: Optional[tuple[int, int]] = None, det_images: Optional[list[DetImage]] = None, **kwargs, ): self.meta: dict = {} if kwargs: self.meta.update(kwargs) - self.num_detectors = int(num_detectors) - self.dim = tuple(dim) - self.fp_cen_pix = fp_center if fp_center is not None else (dim[0] / 2, dim[1] / 2) - self.det_images: list[DetImage] = [] - if det_images: - for di in det_images: - self.add_DetImage(di) - if self.det_images: - self.construct_focal_plane_image() + self.num_detectors = int(num_detectors) + self.dim_mm = tuple(dim) if dim is not None else None + self.pixel_size = None + self.data: xr.DataArray | None = None # To hold det image data in one array + self.table: pd.DataFrame | None = None # To keep track of det_image data position within focal-plane data array + + self.det_images: dict[str, DetImage] = {} + if det_images is not None: + self.update(det_images) + + def update(self, det_images: list[DetImage]) -> None: + self.add_det_images(det_images) + self.construct_focal_plane_image() + + def add_det_images(self, det_images): + det_images = det_images if len(det_images) > 0 else [det_images] + for det_image in det_images: + if len(self.det_images) == self.num_detectors: + logger.error( + f"Number of DetImages added have reached number of detectors present in this focal-plane.") + break + self.validate_det_image(det_image) + det_image.focal_plane = self + self.det_images[det_image.id] = det_image def validate_det_image(self, det_image: DetImage) -> None: """ Accepts either validated DetImageMeta or legacy dict with required keys. """ - if isinstance(det_image.meta, DetImageMeta): - return - if not isinstance(det_image.meta, dict): + import datamodels + if not (isinstance(det_image.meta, datamodels.DetImageMeta) or isinstance(det_image.meta, dict)): raise ValueError("DetImage.meta must be DetImageMeta or dict.") required = {"properties", "focal_plane_position"} if not required.issubset(det_image.meta.keys()): raise ValueError("DetImage.meta missing required keys for focal-plane placement.") # attempt to coerce for consistent downstream access - det_image.meta = DetImageMeta.model_validate(det_image.meta) + det_image.meta = datamodels.DetImageMeta.model_validate(det_image.meta) + + # check pixel size is same for all det images + pixsize = det_image.meta.properties.pixel_size + if self.pixel_size is None: + self.pixel_size = pixsize + elif pixsize != self.pixel_size: + raise ValueError("All DetImage objects must have the same pixel_size for focal-plane assembly.") def construct_focal_plane_image(self): - if not self.det_images: + if len(self.det_images) == 0: raise ValueError("No DetImage objects to assemble.") - # Cast all to validated meta - for di in self.det_images: - self.validate_det_image(di) - - pixsize = self.det_images[0].meta.properties.pixel_size # type: ignore[union-attr] frames = [] - for det_image in self.det_images: + for det_id, det_image in self.det_images.items(): props = det_image.meta.properties # type: ignore[union-attr] pos = det_image.meta.focal_plane_position # type: ignore[union-attr] xhalf, yhalf = props.x_size / 2, props.y_size / 2 frames.append( { - "det_id": getattr(det_image.meta, "name", None) or "unknown", # type: ignore[arg-type] - "x_min": pos.x_cen / pixsize - xhalf, - "x_max": pos.x_cen / pixsize + xhalf, - "y_min": pos.y_cen / pixsize - yhalf, - "y_max": pos.y_cen / pixsize + yhalf, + "det_id": det_id, # type: ignore[arg-type] + "x_min": int(pos.x_cen / self.pixel_size - xhalf), + "x_max": int(pos.x_cen / self.pixel_size - xhalf) + props.x_size, + "y_min": int(pos.y_cen / self.pixel_size - yhalf), + "y_max": int(pos.y_cen / self.pixel_size - yhalf) + props.y_size, + "angle": pos.angle if hasattr(pos, "angle") else None, + "flip_x": pos.flip_x if hasattr(pos, "flip_x") else None, + "flip_y": pos.flip_y if hasattr(pos, "flip_y") else None, } ) - - frames_df = pd.DataFrame(frames, index=range(len(self.det_images))) + frames_df = pd.DataFrame(frames) # Verify that there are no overlapping detectors, i.e. area covered inside corners should not overlap for i in range(len(frames_df)): @@ -381,63 +398,56 @@ def construct_focal_plane_image(self): raise ValueError(f"Detectors {a['det_id']} and {b['det_id']} overlap in focal plane.") # Verify the size of the focal plane image - fp_ymin = int(frames_df["y_min"].min()) - fp_ymax = int(frames_df["y_max"].max()) - fp_xmin = int(frames_df["x_min"].min()) - fp_xmax = int(frames_df["x_max"].max()) - calc_dim = (fp_ymax - fp_ymin, fp_xmax - fp_xmin) - if calc_dim != self.dim: - logger.warning("Provided dim %s != computed dim %s.", self.dim, calc_dim) - - # Calculate the positions to place each det_image in the focal plane array - # Flip y-axis and shift origin (specified by self.fp_cen_pix) to top-left corner - frames_df["y_min_fp"] = (self.fp_cen_pix[0] - frames_df["y_max"]).astype(int) - frames_df["y_max_fp"] = (self.fp_cen_pix[0] - frames_df["y_min"]).astype(int) - frames_df["x_min_fp"] = (frames_df["x_min"] + self.fp_cen_pix[1]).astype(int) - frames_df["x_max_fp"] = (frames_df["x_max"] + self.fp_cen_pix[1]).astype(int) + calc_dim = np.array([frames_df["y_max"].max() - frames_df["y_min"].min(), + frames_df["x_max"].max() - frames_df["x_min"].min()]) + if self.dim_mm is not None: + dim_pix = np.array(self.dim_mm) / self.pixel_size + if any(calc_dim > dim_pix): + logger.warning("Provided dim %s < computed dim %s.", dim_pix, calc_dim) + else: + dim_pix = calc_dim.astype(int) # Initialize DataArray - self.data: xr.DataArray = xr.DataArray( - np.zeros(self.dim, dtype=float), + self.data = xr.DataArray( + np.zeros(dim_pix, dtype=float), dims=("y", "x"), - coords={"y": np.arange(self.dim[0]), "x": np.arange(self.dim[1])}, + coords={"y": np.arange(frames_df["y_min"].min(), frames_df["y_max"].max(), 1), + "x": np.arange(frames_df["x_min"].min(), frames_df["x_max"].max(), 1)} ) # Place tiles - for i, det_image in enumerate(self.det_images): - if det_image.data is None: + for i in range(len(frames_df)): + row = frames_df.iloc[i] + di = self.det_images[row["det_id"]] + if di.data is None: raise ValueError(f"DetImage at index {i} has no data.") - yslc = slice(int(frames_df.loc[i, "y_min_fp"]), int(frames_df.loc[i, "y_max_fp"])) - xslc = slice(int(frames_df.loc[i, "x_min_fp"]), int(frames_df.loc[i, "x_max_fp"])) - self.data[yslc, xslc] = det_image.data.values + else: + imdata = flip_and_rotate(di.data.values, angle=row['angle'], flip_x=row['flip_x'], + flip_y=row['flip_y']) - self.frames_df = frames_df + slc = {'y':slice(row['y_min'], row['y_max']-1), 'x':slice(row['x_min'], row['x_max']-1)} + self.data.loc[slc] = imdata - def add_DetImage(self, det_image: DetImage): - if len(self.det_images) >= self.num_detectors: - raise ValueError(f"Number of det_images ({len(self.det_images)}) reached limit ({self.num_detectors}).") - self.validate_det_image(det_image) - det_image.focal_plane = self - self.det_images.append(det_image) + self.table = frames_df - def show(self, ax=None, save=None, **imshow_kwargs): + def show(self, ax=None, save=None, show_det_id=False, **imshow_kwargs): if ax is None: _, ax = plt.subplots(1,1, figsize=(8, 8), tight_layout=True) - im = ax.imshow(self.data.values, **imshow_kwargs) + im = self.data.plot.imshow(ax=ax, **imshow_kwargs) # Draw detector boundaries - if hasattr(self, "frames_df"): - for _, row in self.frames_df.iterrows(): + if hasattr(self, "table"): + for _, row in self.table.iterrows(): rect = plt.Rectangle( - (row["x_min_fp"], row["y_min_fp"]), - row["x_max_fp"] - row["x_min_fp"], - row["y_max_fp"] - row["y_min_fp"], + (row["x_min"], row["y_min"]), + row["x_max"] - row["x_min"], + row["y_max"] - row["y_min"], linewidth=1, edgecolor="r", facecolor="none", ) ax.add_patch(rect) - ax.text(row["x_min_fp"] + 150, row["y_min_fp"] + 150, str(row["det_id"]), color="white", fontsize=8) - ax.figure.colorbar(im, ax=ax) + if show_det_id: + ax.text(row["x_min"] + 150, row["y_min"] + 150, str(row["det_id"]), color="white", fontsize=8) if save is not None: ax.figure.savefig(save) return ax diff --git a/eregion/pipeline/engine.py b/eregion/pipeline/engine.py index 29e576c..3d2d0c3 100644 --- a/eregion/pipeline/engine.py +++ b/eregion/pipeline/engine.py @@ -2,10 +2,9 @@ from copy import deepcopy import graphlib -from tasks.task import TaskResult -from configs.config import PipelineConfig -from utils.misc_utils import configure_logger -from utils.misc_utils import load_class +from tasks import TaskResult +from configs import PipelineConfig +from utils import configure_logger, load_class from prefect import task, flow from prefect.futures import wait diff --git a/eregion/tasks/__init__.py b/eregion/tasks/__init__.py index e69de29..0c6c257 100644 --- a/eregion/tasks/__init__.py +++ b/eregion/tasks/__init__.py @@ -0,0 +1,6 @@ +from .task import * +from .custom import * +from .imagegen import * +from .calibration import * +from .preprocessing import * +from .analysis import * diff --git a/eregion/tasks/calibration.py b/eregion/tasks/calibration.py index b1a3b2b..003749f 100644 --- a/eregion/tasks/calibration.py +++ b/eregion/tasks/calibration.py @@ -1,9 +1,8 @@ import numpy as np -from tasks.task import Task -from datamodels.image import DetImage -from utils.image_utils import ensure_dataarray -from utils.misc_utils import load_class +from tasks import Task +from datamodels import DetImage +from utils import ensure_dataarray, load_class # Task to generate master bias diff --git a/eregion/tasks/custom.py b/eregion/tasks/custom.py index 725a94d..be33bd1 100644 --- a/eregion/tasks/custom.py +++ b/eregion/tasks/custom.py @@ -1,5 +1,10 @@ ### File for custom input functions/tasks defined by the user. ### import os +import numpy as np +from typing import Any +from astropy.io import fits + +from utils import load_image_fits def guess_image_type_from_filename_DEIMOS(filename: str) -> str: """ @@ -20,3 +25,10 @@ def guess_image_type_from_filename_DEIMOS(filename: str) -> str: return 'science' else: return 'unknown' + +def load_image_fits_DEIMOS(filename: str) -> tuple[list[Any], list[fits.Header]]: + input_data_array, input_headers = load_image_fits(filename) + for i, hdr in enumerate(input_headers): + if "TAPOFFS" in hdr: + input_data_array[i] = (input_data_array[i].astype(np.int64) >> 12) - hdr["TAPOFFS"] + return input_data_array, input_headers \ No newline at end of file diff --git a/eregion/tasks/imagegen.py b/eregion/tasks/imagegen.py index 03a3163..1c232d0 100644 --- a/eregion/tasks/imagegen.py +++ b/eregion/tasks/imagegen.py @@ -1,15 +1,13 @@ import os import glob2 import time -import importlib -from typing import Iterator, Generator, Callable, Iterable +import numpy as np +from typing import Iterator, Generator, Callable, Iterable, Optional, Any from joblib import Parallel, delayed -from datamodels.image import * -from utils.image_utils import ensure_dataarray -from configs.config import DetectorConfig -from tasks.task import LazyTask -from utils.io_utils import load_image_fits, parse_list_of_files, guess_image_type_from_header +from configs import DetectorConfig +from tasks import LazyTask +from utils import load_image_fits, parse_list_of_files, guess_image_type_from_header, load_class, ensure_dataarray ## Classes to handle image generation from configuration files @@ -44,8 +42,7 @@ def set_identifier(self, func: str | Callable[..., str]) -> None: """ if not callable(func): try: - module, cls = func.rsplit('.', 1) - func = getattr(importlib.import_module(module), cls) + func = load_class(func) except Exception as e: raise ValueError(f"Error loading identifier function '{func}': {e}") self._identifier_task = func @@ -59,8 +56,7 @@ def set_fitsloader(self, func: str | Callable[..., str]) -> None: """ if not callable(func): try: - module, cls = func.rsplit('.', 1) - func = getattr(importlib.import_module(module), cls) + func = load_class(func) except Exception as e: raise ValueError(f"Error loading FITS loader function '{func}': {e}") self._fitsloader_task = func @@ -160,8 +156,11 @@ def _build_single_image_object(self, outputs = obj.pop('outputs') self.logger.info("Building object %s with %s %s outputs and type %s from file %s", obj['class'], len(outputs), output_class, image_type, filename or 'array input') - ImageClass = globals()[obj.pop('class')] - OutputClass = globals()[output_class] + imclass = obj.pop('class') + imclass = "datamodels."+imclass if "datamodels" not in imclass else imclass + ImageClass = load_class(imclass) + outclass = "datamodels."+output_class if "datamodels" not in output_class else output_class + OutputClass = load_class(outclass) # instantiate image object image = ImageClass(image_type=image_type, **obj, filename=filename or 'none') diff --git a/eregion/tasks/preprocessing.py b/eregion/tasks/preprocessing.py index 7d66795..89eed3d 100644 --- a/eregion/tasks/preprocessing.py +++ b/eregion/tasks/preprocessing.py @@ -3,15 +3,13 @@ from typing import Optional, Iterable, Iterator, Any import numpy as np import xarray as xr +from joblib import Parallel, delayed -from tasks.task import LazyTask -from datamodels.image import DetImage, Output -from utils.image_utils import ensure_dataarray, ensure_numpy -from utils.misc_utils import load_class +from tasks import LazyTask +from datamodels import DetImage, Output +from utils import ensure_dataarray, ensure_numpy, load_class from core.image_operations import subtract_from_image, sigma_clip_image -from joblib import Parallel, delayed - ########### BasePreprocessingTask ########### class BasePreprocessingTask(LazyTask): """ diff --git a/eregion/tasks/task.py b/eregion/tasks/task.py index 3af6d9e..5563038 100644 --- a/eregion/tasks/task.py +++ b/eregion/tasks/task.py @@ -8,8 +8,7 @@ from astropy.time import Time import inspect -from utils.io_utils import configure_logger -from utils.misc_utils import load_class +from utils import configure_logger, load_class # Base abstract class for tasks, should have a call method for direct execution and a run method for pipeline workflows class Task(ABC): diff --git a/eregion/utils/__init__.py b/eregion/utils/__init__.py index e69de29..d66c827 100644 --- a/eregion/utils/__init__.py +++ b/eregion/utils/__init__.py @@ -0,0 +1,3 @@ +from .image_utils import * +from .io_utils import * +from .misc_utils import * \ No newline at end of file diff --git a/eregion/utils/image_utils.py b/eregion/utils/image_utils.py index c1c9ab5..5501bbe 100644 --- a/eregion/utils/image_utils.py +++ b/eregion/utils/image_utils.py @@ -69,7 +69,7 @@ def ensure_numpy(data: xr.DataArray | np.ndarray) -> np.ndarray: case _: raise TypeError("data must be an xarray.DataArray, or numpy.ndarray") -def slice_data(data: xr.DataArray, slicer: tuple[slice, ...] | dict[str:slice]) -> xr.DataArray: +def slice_data(data: xr.DataArray, slicer: tuple[slice, ...] | dict[str, slice]) -> xr.DataArray: """ Slice a 2D or 3D DataArray using ('y','x','t) positional slices. """ diff --git a/playground/Example_pipeline_flows.ipynb b/playground/Example_pipeline_flows.ipynb index 562270e..aa7217f 100644 --- a/playground/Example_pipeline_flows.ipynb +++ b/playground/Example_pipeline_flows.ipynb @@ -6,8 +6,8 @@ "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2026-03-11T00:40:57.497533Z", - "start_time": "2026-03-11T00:40:55.959788Z" + "end_time": "2026-05-27T00:49:09.737739Z", + "start_time": "2026-05-27T00:49:08.400947Z" } }, "source": "from pipeline.engine import PipelineEngine", @@ -17,8 +17,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-03-11T00:40:57.895771Z", - "start_time": "2026-03-11T00:40:57.507592Z" + "end_time": "2026-05-27T00:49:11.211991Z", + "start_time": "2026-05-27T00:49:11.166829Z" } }, "cell_type": "code", @@ -29,11 +29,23 @@ "name": "stderr", "output_type": "stream", "text": [ - "2026-03-10 17:40:57,510 - PipelineConfig - INFO - Config loaded from file '../eregion/configs/pipeline_flows/masterbias_example.yaml'\n", - "2026-03-10 17:40:57,511 - pipeline.engine - INFO - Number of pipelines defined: 2\n", - "2026-03-10 17:40:57,893 - pipeline.engine - INFO - Pipeline order: [('calib_flow',), ('preproc_flow',)]\n", - "2026-03-10 17:40:57,894 - pipeline.engine - INFO - Pipeline calib_flow order: [('calib_flow.image_creator',), ('calib_flow.master_bias',)]\n", - "2026-03-10 17:40:57,894 - pipeline.engine - INFO - Pipeline preproc_flow order: [('preproc_flow.image_creator', 'calib_flow.master_bias'), ('preproc_flow.bias_subtraction',), ('preproc_flow.overscan_subtraction',), ('preproc_flow.badpixel_masking',)]\n" + "2026-05-26 17:49:11,177 - PipelineConfig - INFO - Config loaded from file '../eregion/configs/pipeline_flows/masterbias_example.yaml'\n", + "2026-05-26 17:49:11,177 - pipeline.engine - INFO - Number of pipelines defined: 2\n", + "2026-05-26 17:49:11,178 - pipeline.engine - INFO - Pipeline order: [('calib_flow',), ('preproc_flow',)]\n", + "2026-05-26 17:49:11,178 - pipeline.engine - INFO - Pipeline calib_flow order: [('calib_flow.image_creator',), ('calib_flow.master_bias',)]\n", + "2026-05-26 17:49:11,179 - pipeline.engine - INFO - Pipeline preproc_flow order: [('preproc_flow.image_creator', 'calib_flow.master_bias'), ('preproc_flow.bias_subtraction',), ('preproc_flow.overscan_subtraction',), ('preproc_flow.badpixel_masking',)]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tasks.imagegen ImageCreator\n", + "tasks.calibration MasterBias\n", + "tasks.imagegen ImageCreator\n", + "tasks.preprocessing BiasSubtraction\n", + "tasks.preprocessing ScanSubtraction\n", + "tasks.preprocessing SigmaClipMasking\n" ] } ], @@ -42,8 +54,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-03-11T00:41:23.004102Z", - "start_time": "2026-03-11T00:40:57.906266Z" + "end_time": "2026-05-27T00:49:33.516303Z", + "start_time": "2026-05-27T00:49:12.063781Z" } }, "cell_type": "code", @@ -53,180 +65,199 @@ { "data": { "text/plain": [ - "17:40:58.639 | \u001B[36mINFO\u001B[0m | prefect - Starting temporary server on \u001B[94mhttp://127.0.0.1:8485\u001B[0m\n", + "17:49:12.825 | \u001B[36mINFO\u001B[0m | prefect - Starting temporary server on \u001B[94mhttp://127.0.0.1:8657\u001B[0m\n", "See \u001B[94mhttps://docs.prefect.io/v3/concepts/server#how-to-guides\u001B[0m for more information on running a dedicated Prefect server.\n" ], "text/html": [ - "
17:40:58.639 | INFO    | prefect - Starting temporary server on http://127.0.0.1:8485\n",
+       "
17:49:12.825 | INFO    | prefect - Starting temporary server on http://127.0.0.1:8657\n",
        "See https://docs.prefect.io/v3/concepts/server#how-to-guides for more information on running a dedicated Prefect server.\n",
        "
\n"
       ]
      },
      "metadata": {},
-     "output_type": "display_data",
-     "jetTransient": {
-      "display_id": null
-     }
+     "output_type": "display_data"
     },
     {
      "data": {
       "text/plain": [
-       "17:41:00.506 | \u001B[36mINFO\u001B[0m    | Flow run\u001B[35m 'unbiased-ara'\u001B[0m - Beginning flow run\u001B[35m 'unbiased-ara'\u001B[0m for flow\u001B[1;35m 'calib_flow'\u001B[0m\n"
+       "17:49:14.683 | \u001B[36mINFO\u001B[0m    | Flow run\u001B[35m 'jolly-barracuda'\u001B[0m - Beginning flow run\u001B[35m 'jolly-barracuda'\u001B[0m for flow\u001B[1;35m 'calib_flow'\u001B[0m\n"
       ],
       "text/html": [
-       "
17:41:00.506 | INFO    | Flow run 'unbiased-ara' - Beginning flow run 'unbiased-ara' for flow 'calib_flow'\n",
+       "
17:49:14.683 | INFO    | Flow run 'jolly-barracuda' - Beginning flow run 'jolly-barracuda' for flow 'calib_flow'\n",
        "
\n"
       ]
      },
      "metadata": {},
-     "output_type": "display_data",
-     "jetTransient": {
-      "display_id": null
-     }
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2026-05-26 17:49:14,712 - DetectorConfig - INFO - Config loaded from file '/Users/yashvi/Desktop/Detector Characterization Tools/eregion/eregion/configs/detectors/deimos_singledet.yaml'\n",
+      "2026-05-26 17:49:14,712 - calib_flow.image_creator - INFO - Item /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/*_bias_*.fits is a glob pattern\n",
+      "2026-05-26 17:49:14,714 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_2_2025-08-12T101455.893.fits.\n",
+      "2026-05-26 17:49:14,715 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_5_2025-08-12T101626.632.fits.\n",
+      "2026-05-26 17:49:14,716 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_4_2025-08-12T101556.386.fits.\n",
+      "2026-05-26 17:49:14,716 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_3_2025-08-12T101526.139.fits.\n",
+      "2026-05-26 17:49:14,717 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_9_2025-08-12T101827.618.fits.\n",
+      "2026-05-26 17:49:14,718 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_0_2025-08-12T101355.400.fits.\n",
+      "2026-05-26 17:49:14,719 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_6_2025-08-12T101656.879.fits.\n",
+      "2026-05-26 17:49:14,721 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_1_2025-08-12T101425.647.fits.\n",
+      "2026-05-26 17:49:14,722 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_7_2025-08-12T101727.125.fits.\n",
+      "2026-05-26 17:49:14,722 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_8_2025-08-12T101757.371.fits.\n",
+      "2026-05-26 17:49:14,722 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_0_2025-08-12T101355.400.fits\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tasks.custom guess_image_type_from_filename_DEIMOS\n",
+      "tasks.custom load_image_fits_DEIMOS\n"
+     ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "2026-03-10 17:41:00,538 - DetectorConfig - INFO - Config loaded from file '/Users/yashvi/Desktop/Detector Characterization Tools/eregion/eregion/configs/detectors/deimos_singledet.yaml'\n",
-      "2026-03-10 17:41:00,539 - calib_flow.image_creator - INFO - Item /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/*_bias_*.fits is a glob pattern\n",
-      "2026-03-10 17:41:00,540 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_2_2025-08-12T101455.893.fits.\n",
-      "2026-03-10 17:41:00,541 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_5_2025-08-12T101626.632.fits.\n",
-      "2026-03-10 17:41:00,541 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_4_2025-08-12T101556.386.fits.\n",
-      "2026-03-10 17:41:00,542 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_3_2025-08-12T101526.139.fits.\n",
-      "2026-03-10 17:41:00,543 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_9_2025-08-12T101827.618.fits.\n",
-      "2026-03-10 17:41:00,543 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_0_2025-08-12T101355.400.fits.\n",
-      "2026-03-10 17:41:00,543 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_6_2025-08-12T101656.879.fits.\n",
-      "2026-03-10 17:41:00,544 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_1_2025-08-12T101425.647.fits.\n",
-      "2026-03-10 17:41:00,544 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_7_2025-08-12T101727.125.fits.\n",
-      "2026-03-10 17:41:00,544 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_8_2025-08-12T101757.371.fits.\n",
-      "2026-03-10 17:41:00,545 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_0_2025-08-12T101355.400.fits\n",
-      "2026-03-10 17:41:01,522 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_1_2025-08-12T101425.647.fits\n",
-      "2026-03-10 17:41:02,369 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_2_2025-08-12T101455.893.fits\n",
-      "2026-03-10 17:41:03,217 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_3_2025-08-12T101526.139.fits\n",
-      "2026-03-10 17:41:04,074 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_4_2025-08-12T101556.386.fits\n",
-      "2026-03-10 17:41:04,486 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_5_2025-08-12T101626.632.fits\n",
-      "2026-03-10 17:41:04,914 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_6_2025-08-12T101656.879.fits\n",
-      "2026-03-10 17:41:05,352 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_7_2025-08-12T101727.125.fits\n",
-      "2026-03-10 17:41:05,798 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_8_2025-08-12T101757.371.fits\n",
-      "2026-03-10 17:41:06,672 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_9_2025-08-12T101827.618.fits\n"
+      "2026-05-26 17:49:15,815 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_1_2025-08-12T101425.647.fits\n",
+      "2026-05-26 17:49:16,743 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_2_2025-08-12T101455.893.fits\n",
+      "2026-05-26 17:49:17,674 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_3_2025-08-12T101526.139.fits\n",
+      "2026-05-26 17:49:18,078 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_4_2025-08-12T101556.386.fits\n",
+      "2026-05-26 17:49:18,515 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_5_2025-08-12T101626.632.fits\n",
+      "2026-05-26 17:49:19,440 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_6_2025-08-12T101656.879.fits\n",
+      "2026-05-26 17:49:20,365 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_7_2025-08-12T101727.125.fits\n",
+      "2026-05-26 17:49:20,777 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_8_2025-08-12T101757.371.fits\n",
+      "2026-05-26 17:49:21,214 - calib_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_bias_9_2025-08-12T101827.618.fits\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "17:41:07.067 | \u001B[36mINFO\u001B[0m    | Task run 'calib_flow.image_creator-9fe' - Finished in state \u001B[32mCompleted\u001B[0m()\n"
+       "17:49:21.663 | \u001B[36mINFO\u001B[0m    | Task run 'calib_flow.image_creator-fd5' - Finished in state \u001B[32mCompleted\u001B[0m()\n"
       ],
       "text/html": [
-       "
17:41:07.067 | INFO    | Task run 'calib_flow.image_creator-9fe' - Finished in state Completed()\n",
+       "
17:49:21.663 | INFO    | Task run 'calib_flow.image_creator-fd5' - Finished in state Completed()\n",
        "
\n"
       ]
      },
      "metadata": {},
-     "output_type": "display_data",
-     "jetTransient": {
-      "display_id": null
-     }
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "core.image_operations median_combine\n"
+     ]
     },
     {
      "data": {
       "text/plain": [
-       "17:41:09.365 | \u001B[36mINFO\u001B[0m    | Task run 'calib_flow.master_bias-17d' - Finished in state \u001B[32mCompleted\u001B[0m()\n"
+       "17:49:23.969 | \u001B[36mINFO\u001B[0m    | Task run 'calib_flow.master_bias-d7a' - Finished in state \u001B[32mCompleted\u001B[0m()\n"
       ],
       "text/html": [
-       "
17:41:09.365 | INFO    | Task run 'calib_flow.master_bias-17d' - Finished in state Completed()\n",
+       "
17:49:23.969 | INFO    | Task run 'calib_flow.master_bias-d7a' - Finished in state Completed()\n",
        "
\n"
       ]
      },
      "metadata": {},
-     "output_type": "display_data",
-     "jetTransient": {
-      "display_id": null
-     }
+     "output_type": "display_data"
     },
     {
      "data": {
       "text/plain": [
-       "17:41:09.382 | \u001B[36mINFO\u001B[0m    | Flow run\u001B[35m 'unbiased-ara'\u001B[0m - Finished in state \u001B[32mCompleted\u001B[0m()\n"
+       "17:49:23.982 | \u001B[36mINFO\u001B[0m    | Flow run\u001B[35m 'jolly-barracuda'\u001B[0m - Finished in state \u001B[32mCompleted\u001B[0m()\n"
       ],
       "text/html": [
-       "
17:41:09.382 | INFO    | Flow run 'unbiased-ara' - Finished in state Completed()\n",
+       "
17:49:23.982 | INFO    | Flow run 'jolly-barracuda' - Finished in state Completed()\n",
        "
\n"
       ]
      },
      "metadata": {},
-     "output_type": "display_data",
-     "jetTransient": {
-      "display_id": null
-     }
+     "output_type": "display_data"
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "2026-03-10 17:41:09,384 - pipeline.engine - INFO - Pipeline 'calib_flow' complete\n"
+      "2026-05-26 17:49:23,983 - pipeline.engine - INFO - Pipeline 'calib_flow' complete\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "17:41:09.427 | \u001B[36mINFO\u001B[0m    | Flow run\u001B[35m 'awesome-eel'\u001B[0m - Beginning flow run\u001B[35m 'awesome-eel'\u001B[0m for flow\u001B[1;35m 'preproc_flow'\u001B[0m\n"
+       "17:49:24.022 | \u001B[36mINFO\u001B[0m    | Flow run\u001B[35m 'voracious-mongrel'\u001B[0m - Beginning flow run\u001B[35m 'voracious-mongrel'\u001B[0m for flow\u001B[1;35m 'preproc_flow'\u001B[0m\n"
       ],
       "text/html": [
-       "
17:41:09.427 | INFO    | Flow run 'awesome-eel' - Beginning flow run 'awesome-eel' for flow 'preproc_flow'\n",
+       "
17:49:24.022 | INFO    | Flow run 'voracious-mongrel' - Beginning flow run 'voracious-mongrel' for flow 'preproc_flow'\n",
        "
\n"
       ]
      },
      "metadata": {},
-     "output_type": "display_data",
-     "jetTransient": {
-      "display_id": null
-     }
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2026-05-26 17:49:24,041 - DetectorConfig - INFO - Config loaded from file '/Users/yashvi/Desktop/Detector Characterization Tools/eregion/eregion/configs/detectors/deimos_singledet.yaml'\n",
+      "2026-05-26 17:49:24,041 - DetectorConfig - INFO - Config loaded from file '/Users/yashvi/Desktop/Detector Characterization Tools/eregion/eregion/configs/detectors/deimos_singledet.yaml'\n",
+      "2026-05-26 17:49:24,042 - preproc_flow.image_creator - INFO - Item /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/*flat_0.000*.fits is a glob pattern\n",
+      "2026-05-26 17:49:24,044 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_flat_0.000_0_2025-08-12T102203.192.fits.\n",
+      "2026-05-26 17:49:24,045 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_flat_0.000_1_2025-08-12T102233.989.fits.\n",
+      "2026-05-26 17:49:24,046 - preproc_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_flat_0.000_0_2025-08-12T102203.192.fits\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tasks.custom guess_image_type_from_filename_DEIMOS\n",
+      "tasks.custom load_image_fits_DEIMOS\n"
+     ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "2026-03-10 17:41:09,450 - DetectorConfig - INFO - Config loaded from file '/Users/yashvi/Desktop/Detector Characterization Tools/eregion/eregion/configs/detectors/deimos_singledet.yaml'\n",
-      "2026-03-10 17:41:09,450 - DetectorConfig - INFO - Config loaded from file '/Users/yashvi/Desktop/Detector Characterization Tools/eregion/eregion/configs/detectors/deimos_singledet.yaml'\n",
-      "2026-03-10 17:41:09,451 - preproc_flow.image_creator - INFO - Item /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/*flat_0.000*.fits is a glob pattern\n",
-      "2026-03-10 17:41:09,452 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_flat_0.000_0_2025-08-12T102203.192.fits.\n",
-      "2026-03-10 17:41:09,454 - utils.io_utils - INFO - Found FITS file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_flat_0.000_1_2025-08-12T102233.989.fits.\n",
-      "2026-03-10 17:41:09,454 - preproc_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_flat_0.000_0_2025-08-12T102203.192.fits\n",
-      "2026-03-10 17:41:10,302 - preproc_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_flat_0.000_1_2025-08-12T102233.989.fits\n"
+      "2026-05-26 17:49:24,466 - preproc_flow.image_creator - INFO - Processing file /Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/DTU_DT-SCI_2_flat_0.000_1_2025-08-12T102233.989.fits\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "17:41:10.711 | \u001B[36mINFO\u001B[0m    | Task run 'preproc_flow.image_creator-532' - Finished in state \u001B[32mCompleted\u001B[0m()\n"
+       "17:49:24.889 | \u001B[36mINFO\u001B[0m    | Task run 'preproc_flow.image_creator-4bb' - Finished in state \u001B[32mCompleted\u001B[0m()\n"
       ],
       "text/html": [
-       "
17:41:10.711 | INFO    | Task run 'preproc_flow.image_creator-532' - Finished in state Completed()\n",
+       "
17:49:24.889 | INFO    | Task run 'preproc_flow.image_creator-4bb' - Finished in state Completed()\n",
        "
\n"
       ]
      },
      "metadata": {},
-     "output_type": "display_data",
-     "jetTransient": {
-      "display_id": null
-     }
+     "output_type": "display_data"
     },
     {
      "data": {
       "text/plain": [
-       "17:41:13.745 | \u001B[36mINFO\u001B[0m    | Task run 'preproc_flow.bias_subtraction-d2a' - Finished in state \u001B[32mCompleted\u001B[0m()\n"
+       "17:49:28.006 | \u001B[36mINFO\u001B[0m    | Task run 'preproc_flow.bias_subtraction-103' - Finished in state \u001B[32mCompleted\u001B[0m()\n"
       ],
       "text/html": [
-       "
17:41:13.745 | INFO    | Task run 'preproc_flow.bias_subtraction-d2a' - Finished in state Completed()\n",
+       "
17:49:28.006 | INFO    | Task run 'preproc_flow.bias_subtraction-103' - Finished in state Completed()\n",
        "
\n"
       ]
      },
      "metadata": {},
-     "output_type": "display_data",
-     "jetTransient": {
-      "display_id": null
-     }
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "core.image_operations median_by_axis\n",
+      "core.image_operations median_by_axis\n"
+     ]
     },
     {
      "name": "stderr",
@@ -235,7 +266,21 @@
       "/Users/yashvi/Desktop/Detector Characterization Tools/eregion/.venv/lib/python3.13/site-packages/numpy/_core/fromnumeric.py:3860: RuntimeWarning: Mean of empty slice.\n",
       "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
       "/Users/yashvi/Desktop/Detector Characterization Tools/eregion/.venv/lib/python3.13/site-packages/numpy/_core/_methods.py:136: RuntimeWarning: invalid value encountered in divide\n",
-      "  ret = um.true_divide(\n",
+      "  ret = um.true_divide(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "core.image_operations median_by_axis\n",
+      "core.image_operations median_by_axis\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
       "/Users/yashvi/Desktop/Detector Characterization Tools/eregion/.venv/lib/python3.13/site-packages/numpy/_core/fromnumeric.py:3860: RuntimeWarning: Mean of empty slice.\n",
       "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
       "/Users/yashvi/Desktop/Detector Characterization Tools/eregion/.venv/lib/python3.13/site-packages/numpy/_core/_methods.py:136: RuntimeWarning: invalid value encountered in divide\n",
@@ -245,95 +290,76 @@
     {
      "data": {
       "text/plain": [
-       "17:41:16.396 | \u001B[36mINFO\u001B[0m    | Task run 'preproc_flow.overscan_subtraction-3d0' - Finished in state \u001B[32mCompleted\u001B[0m()\n"
+       "17:49:28.826 | \u001B[36mINFO\u001B[0m    | Task run 'preproc_flow.overscan_subtraction-e23' - Finished in state \u001B[32mCompleted\u001B[0m()\n"
       ],
       "text/html": [
-       "
17:41:16.396 | INFO    | Task run 'preproc_flow.overscan_subtraction-3d0' - Finished in state Completed()\n",
+       "
17:49:28.826 | INFO    | Task run 'preproc_flow.overscan_subtraction-e23' - Finished in state Completed()\n",
        "
\n"
       ]
      },
      "metadata": {},
-     "output_type": "display_data",
-     "jetTransient": {
-      "display_id": null
-     }
+     "output_type": "display_data"
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
       "WARNING: Input data contains invalid values (NaNs or infs), which were automatically clipped. [astropy.stats.sigma_clipping]\n",
-      "2026-03-10 17:41:18,317 - datamodels.image - WARNING - Output with id chan_1 already exists, overwrite is set to True.\n",
-      "2026-03-10 17:41:18,317 - datamodels.image - WARNING - Output with id chan_2 already exists, overwrite is set to True.\n",
+      "2026-05-26 17:49:30,698 - datamodels.image - WARNING - Output with id chan_1 already exists, overwrite is set to True.\n",
+      "2026-05-26 17:49:30,698 - datamodels.image - WARNING - Output with id chan_2 already exists, overwrite is set to True.\n",
       "WARNING: Input data contains invalid values (NaNs or infs), which were automatically clipped. [astropy.stats.sigma_clipping]\n",
-      "2026-03-10 17:41:21,860 - datamodels.image - WARNING - Output with id chan_1 already exists, overwrite is set to True.\n",
-      "2026-03-10 17:41:21,860 - datamodels.image - WARNING - Output with id chan_2 already exists, overwrite is set to True.\n"
+      "2026-05-26 17:49:33,293 - datamodels.image - WARNING - Output with id chan_1 already exists, overwrite is set to True.\n",
+      "2026-05-26 17:49:33,293 - datamodels.image - WARNING - Output with id chan_2 already exists, overwrite is set to True.\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "17:41:22.968 | \u001B[36mINFO\u001B[0m    | Task run 'preproc_flow.badpixel_masking-59b' - Finished in state \u001B[32mCompleted\u001B[0m()\n"
+       "17:49:33.467 | \u001B[36mINFO\u001B[0m    | Task run 'preproc_flow.badpixel_masking-44b' - Finished in state \u001B[32mCompleted\u001B[0m()\n"
       ],
       "text/html": [
-       "
17:41:22.968 | INFO    | Task run 'preproc_flow.badpixel_masking-59b' - Finished in state Completed()\n",
+       "
17:49:33.467 | INFO    | Task run 'preproc_flow.badpixel_masking-44b' - Finished in state Completed()\n",
        "
\n"
       ]
      },
      "metadata": {},
-     "output_type": "display_data",
-     "jetTransient": {
-      "display_id": null
-     }
+     "output_type": "display_data"
     },
     {
      "data": {
       "text/plain": [
-       "17:41:22.998 | \u001B[36mINFO\u001B[0m    | Flow run\u001B[35m 'awesome-eel'\u001B[0m - Finished in state \u001B[32mCompleted\u001B[0m()\n"
+       "17:49:33.481 | \u001B[36mINFO\u001B[0m    | Flow run\u001B[35m 'voracious-mongrel'\u001B[0m - Finished in state \u001B[32mCompleted\u001B[0m()\n"
       ],
       "text/html": [
-       "
17:41:22.998 | INFO    | Flow run 'awesome-eel' - Finished in state Completed()\n",
+       "
17:49:33.481 | INFO    | Flow run 'voracious-mongrel' - Finished in state Completed()\n",
        "
\n"
       ]
      },
      "metadata": {},
-     "output_type": "display_data",
-     "jetTransient": {
-      "display_id": null
-     }
+     "output_type": "display_data"
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "2026-03-10 17:41:23,000 - pipeline.engine - INFO - Pipeline 'preproc_flow' complete\n"
+      "2026-05-26 17:49:33,482 - pipeline.engine - INFO - Pipeline 'preproc_flow' complete\n"
      ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "{'calib_flow.image_creator': TaskResult(task_name='calib_flow.image_creator', data={'bias': [, , , , , , , , , ]}, params={'init': {'detector_config': '/Users/yashvi/Desktop/Detector Characterization Tools/eregion/eregion/configs/detectors/deimos_singledet.yaml'}, 'run': {'input_source': '/Users/yashvi/Desktop/Detector Characterization Tools/DTU_dettest/DTU_singledet_acceptance/PTC/SCI/20250812-101350/*_bias_*.fits', 'identifier_func': 'tasks.custom.guess_image_type_from_filename_DEIMOS'}}, upstream=[], timestamp=