From b2c87902b2bc23049485135c2c81ceaead5aa512 Mon Sep 17 00:00:00 2001 From: Jacob-Jan Sloots <47000395+slootsjj@users.noreply.github.com> Date: Tue, 23 Dec 2025 14:46:04 +0100 Subject: [PATCH 1/5] Introduce DateSlider and DateRangeSlider --- widgets/+wt/+mixin/TickableDateSlider.m | 102 ++++ widgets/+wt/DateRangeSlider.m | 627 ++++++++++++++++++++++++ widgets/+wt/DateSlider.m | 371 ++++++++++++++ widgets/icons/down_grey_12.png | Bin 0 -> 120 bytes widgets/icons/up_grey_12.png | Bin 0 -> 123 bytes 5 files changed, 1100 insertions(+) create mode 100644 widgets/+wt/+mixin/TickableDateSlider.m create mode 100644 widgets/+wt/DateRangeSlider.m create mode 100644 widgets/+wt/DateSlider.m create mode 100644 widgets/icons/down_grey_12.png create mode 100644 widgets/icons/up_grey_12.png diff --git a/widgets/+wt/+mixin/TickableDateSlider.m b/widgets/+wt/+mixin/TickableDateSlider.m new file mode 100644 index 0000000..d46b108 --- /dev/null +++ b/widgets/+wt/+mixin/TickableDateSlider.m @@ -0,0 +1,102 @@ +classdef TickableDateSlider < handle + % Mixin to add date ticks to a slider component + + %% Abstract properties + properties (Abstract, Transient, NonCopyable, Hidden, SetAccess = protected) + + % Slider + Slider matlab.ui.control.internal.model.mixin.SliderComponent {mustBeScalarOrEmpty} + + end + + %% Protected methods + methods (Access = protected) + + function [majorTicks, minorTicks] = getSliderTicks(obj, orientation, options) + % Update the limits in date-picker and slider + + arguments + obj (1,1) + orientation (1,1) string {mustBeMember(orientation, ["horizontal" "vertical"])} = "horizontal"; + options.TickLength (1,1) double {mustBeInteger, mustBePositive} + end + + % How many days? + nDays = obj.Slider.Limits(2) + 1; + + % What space is needed for the labels? + % Depends on font size and font weight. + if obj.Slider.FontWeight == "bold" + elSize = 0.6; + else + elSize = 0.5; + end + fontSize = obj.Slider.FontSize; + + % What is the slider orientation? + if orientation == "horizontal" + + % Size of slider. Always in pixel units (cannot be changed) + sliderSpace = obj.Slider.Position(3); + + % Minimum space required for label + if isfield(options, 'TickLength') + tickLength = options.TickLength; + else + tickLength = 11; + end + minSpaceForTickLabel = elSize * fontSize * tickLength; + else + % Size of slider. Always in pixel units (cannot be changed) + sliderSpace = obj.Slider.Position(4); + + % Minimum space required for label + minSpaceForTickLabel = elSize * fontSize * 2; + end + + % How many major ticks fit in the available size? + maxMajorInterval = floor(sliderSpace / minSpaceForTickLabel) - 1; + maxMajorInterval = max(1, maxMajorInterval); + + % How large are the steps for the major ticks? + + % Is the interval size a prime number? + if isprime((nDays - 1)) + majorIntervalStep = max(1, round((nDays - 1) / maxMajorInterval)); + else + majorStepArray = (nDays - 1) ./ (maxMajorInterval:-1:1); + isIntegerStepSize = majorStepArray == floor(majorStepArray); + majorIntervalStep = majorStepArray(find(isIntegerStepSize, 1)); + end + + % At what tick location do the major tick labels need to go? + majorTicks = floor(0:majorIntervalStep:(nDays - 1)); + majorTicks(end + 1) = (nDays - 1); + + % How much space is left for the minor ticks? + minSpaceForMinorTick = 10; + nMajorInterval = ((nDays - 1) / majorIntervalStep); + maxMinorInterval = floor(sliderSpace / nMajorInterval / minSpaceForMinorTick); + + % Is there enough room for all steps that are left between the major + % ticks? + if maxMinorInterval < majorIntervalStep + + % What is the maximum number of minor ticks that can fit in the + % major tick interval? + minorStepArray = majorIntervalStep ./ (maxMinorInterval:-1:1); + isIntegerStepSize = minorStepArray == floor(minorStepArray); + minorIntervalStep = minorStepArray(find(isIntegerStepSize, 1)); + else + minorIntervalStep = 1; + end + + % How much room is available between the major ticks? + minorTickSteps = majorTicks(1):minorIntervalStep:majorTicks(2); + minorTicks = majorTicks + minorTickSteps(:); + minorTicks = unique(minorTicks(:)'); + end + + end + +end \ No newline at end of file diff --git a/widgets/+wt/DateRangeSlider.m b/widgets/+wt/DateRangeSlider.m new file mode 100644 index 0000000..553aad1 --- /dev/null +++ b/widgets/+wt/DateRangeSlider.m @@ -0,0 +1,627 @@ +classdef DateRangeSlider < wt.abstract.BaseWidget & ... + wt.mixin.TickableDateSlider & ... + wt.mixin.Enableable & ... + wt.mixin.FieldColorable & ... + wt.mixin.FontStyled & ... + wt.mixin.ButtonColorable + % A slider and date-picker combination + + %% Events + events (HasCallbackProperty, NotifyAccess = protected) + + % Triggered on value changed, has companion callback + ValueChanged + + % Triggered on value changing during slider motion, has companion callback + ValueChanging + + % Triggered on limits changed, has companion callback + LimitsChanged + + end %events + + %% Public properties + properties (AbortSet, Dependent, UsedInUpdate = false) + % These properties do not trigger the update method + + % Value of the slider and date-time selector + Value (1,2) datetime + + end + + properties (AbortSet) + + % Limits of the slider and spinner + Limits (1,2) datetime = datetime("01-Jan-2020") + days([0 3]); + + % Date format + DisplayFormat (1,1) string = 'dd-MMM-uuuu' + + % Orientation of the spinner and slider + Orientation (1,1) wt.enum.HorizontalVerticalState = wt.enum.HorizontalVerticalState.horizontal + + % Size of date-picker (width for horizontal, height for vertical + DatepickerSize = 120 + + end %properties + + properties (AbortSet, Dependent, UsedInUpdate = false) + + % Minimum gap in value range (days) + MinGap (1,1) double {mustBeNonnegative, mustBeInteger} = 1 + + end + + properties (AbortSet, Dependent) + + % Index of selected item + ValueIndex (1,2) double {mustBeInteger} + + end + + properties (AbortSet, UsedInUpdate = false) + % These properties do not trigger the update method + + % Define step size for buttons + Step (1,1) calendarDuration = calendarDuration(0,0,1) + + end + + %% Internal Properties + properties (Access = private) + + % Minimum gap + MinGap_I = 1; + + end + + properties (Transient, NonCopyable, Hidden, SetAccess = protected) + + % Slider + Slider = matlab.ui.control.RangeSlider.empty + + % Date picker on the left + DatepickerLeft matlab.ui.control.DatePicker + + % Date picker on the right + DatepickerRight matlab.ui.control.DatePicker + + % Button grid on the left + GridButtonLeft matlab.ui.container.GridLayout + ButtonsLeft (1,:) matlab.ui.control.Button + + % Button grid on the right + GridButtonRight matlab.ui.container.GridLayout + ButtonsRight (1,:) matlab.ui.control.Button + + end + + %% Accessors + methods + + % ValueIndex + function set.ValueIndex(obj, val) + + % Validate input + maxRange = days(obj.Limits(2) - obj.Limits(1)); + try + mustBeInRange(val, 0, maxRange) + mustBeIncreasing(val) + catch ME + throwAsCaller(ME) + end + + % Set value + obj.Value = obj.Limits(1) + days(val); + + end %function + function val = get.ValueIndex(obj) + val = days([obj.DatepickerLeft.Value obj.DatepickerRight.Value] - obj.Limits(1)); + end %function + + % Value + function set.Value(obj, val) + + % Validate input + valueIndex = days(val - obj.Limits(1)); + valueGap = days(diff(val)); + maxRange = days(obj.Limits(2) - obj.Limits(1)); + try + mustBeInRange(valueIndex, 0, maxRange) + mustBeGreaterThanOrEqual(valueGap, days(obj.MinGap)) + mustBeIncreasing(valueIndex) + catch ME + if strcmp(ME.identifier, 'MATLAB:validators:mustBeInRange') + msg = 'Value must be greater than or equal to %s, and less than or equal to %s.'; + Merr = MException(ME.identifier, ... + msg, ... + char(obj.Limits(1)), ... + char(obj.Limits(2))); + throwAsCaller(Merr); + elseif strcmp(ME.identifier, 'MATLAB:validators:mustBeGreaterThanOrEqual') + msg = 'Value gap must be greater than or equal to %d days.'; + Merr = MException(ME.identifier, ... + msg, ... + days(obj.MinGap)); + throwAsCaller(Merr); + else + throwAsCaller(ME) + end + end + + % Update datepicker components + updateControlLimitsAndValue(obj, val); + + % Update buttons + updateButtonEnable(obj); + + end %function + function val = get.Value(obj) + val = [obj.DatepickerLeft.Value obj.DatepickerRight.Value]; + end %function + + % Display format + function set.DisplayFormat(obj, val) + try + d = uidatepicker('Parent', []); + d.DisplayFormat = val; + obj.DisplayFormat = d.DisplayFormat; + catch ME + throwAsCaller(ME) + end + end %function + + % Limits + function set.Limits(obj, val) + startOfDay = dateshift(val, 'start', 'days'); + limitIndex = days(val - val(1)); + try + mustBeIncreasing(limitIndex) + catch ME + throwAsCaller(ME) + end + obj.Limits = startOfDay; + end %function + + % Gap + function set.MinGap(obj, val) + + % Parse input + if isduration(val) + val = days(val); + end + + % Validate input + maxGap = days(diff(obj.Limits)); + try + mustBeGreaterThanOrEqual(maxGap, val) + catch ME + if strcmp(ME.identifier, 'MATLAB:validators:mustBeGreaterThanOrEqual') + msg = 'Value must be smaller than or equal to %d days.'; + Merr = MException(ME.identifier, ... + msg, ... + maxGap); + throwAsCaller(Merr); + else + throwAsCaller(ME) + end + end + + % Set value + obj.MinGap_I = val; + end + + function val = get.MinGap(obj) + val = days(obj.MinGap_I); + end + + % Datepicker size + function set.DatepickerSize(obj, val) + try + g = uigridlayout("Parent", []); + cleanup = onCleanup(@() delete(g)); + g.ColumnWidth{1} = val; + catch ME + throwAsCaller(ME) + end + obj.DatepickerSize = val; + end %function + + end + + %% Protected methods + methods (Access = protected) + + function setup(obj) + + % Call superclass method + obj.setup@wt.abstract.BaseWidget() + + % Set default size + obj.Position = [20 100 530 40]; + + % Configure grid + obj.Grid.ColumnWidth = {'fit', obj.DatepickerSize, '1x', obj.DatepickerSize, 'fit'}; + obj.Grid.RowHeight = {'1x'}; + obj.Grid.ColumnSpacing = 5; + + % Buttons left + obj.GridButtonLeft = uigridlayout(obj.Grid); + obj.GridButtonLeft.RowHeight = {"1x", "1x"}; + obj.GridButtonLeft.ColumnWidth = "fit"; + obj.GridButtonLeft.ColumnSpacing = 0; + obj.GridButtonLeft.RowSpacing = 2; + obj.GridButtonLeft.Padding(:) = 0; + + obj.ButtonsLeft = [uibutton(obj.GridButtonLeft), uibutton(obj.GridButtonLeft)]; + obj.ButtonsLeft(1).ButtonPushedFcn = @(h,e)obj.onButtonPushed(e); + obj.ButtonsLeft(1).Tag = "leftUp"; + obj.ButtonsLeft(1).Icon = "up_grey_12.png"; + obj.ButtonsLeft(1).Text = ""; + obj.ButtonsLeft(2).ButtonPushedFcn = @(h,e)obj.onButtonPushed(e); + obj.ButtonsLeft(2).Tag = "leftDown"; + obj.ButtonsLeft(2).Icon = "down_grey_12.png"; + obj.ButtonsLeft(2).Text = ""; + + % Date picker left + obj.DatepickerLeft = uidatepicker(obj.Grid); + obj.DatepickerLeft.ValueChangedFcn = @(h,e)obj.onDatepickerChanged(e); + obj.DatepickerLeft.Value = datetime("02-Jan-2020"); + obj.DatepickerLeft.Limits = [obj.Limits(1) datetime("02-Jan-2020")]; + obj.DatepickerLeft.Editable = false; + obj.DatepickerLeft.Tag = "left"; + + % Slider + obj.Slider = uislider(obj.Grid, 'range'); + obj.Slider.ValueChangedFcn = @(h,e)obj.onSliderChanged(e); + obj.Slider.ValueChangingFcn = @(h,e)obj.onSliderChanging(e); + obj.Slider.Limits = [0 3]; + obj.Slider.Value = [1 2]; + + % Date picker right + obj.DatepickerRight = uidatepicker(obj.Grid); + obj.DatepickerRight.ValueChangedFcn = @(h,e)obj.onDatepickerChanged(e); + obj.DatepickerRight.Value = datetime("03-Jan-2020"); + obj.DatepickerRight.Limits = [datetime("03-Jan-2020") obj.Limits(2)]; + obj.DatepickerRight.Editable = false; + obj.DatepickerRight.Tag = "right"; + + % Buttons right + obj.GridButtonRight = uigridlayout(obj.Grid); + obj.GridButtonRight.RowHeight = {"1x", "1x"}; + obj.GridButtonRight.ColumnWidth = "fit"; + obj.GridButtonRight.ColumnSpacing = 0; + obj.GridButtonRight.RowSpacing = 2; + obj.GridButtonRight.Padding(:) = 0; + + obj.ButtonsRight = [uibutton(obj.GridButtonRight), uibutton(obj.GridButtonRight)]; + obj.ButtonsRight(1).ButtonPushedFcn = @(h,e)obj.onButtonPushed(e); + obj.ButtonsRight(1).Tag = "rightUp"; + obj.ButtonsRight(1).Icon = "Up_Grey_12.png"; + obj.ButtonsRight(1).Text = ""; + obj.ButtonsRight(2).ButtonPushedFcn = @(h,e)obj.onButtonPushed(e); + obj.ButtonsRight(2).Tag = "rightDown"; + obj.ButtonsRight(2).Icon = "Down_Grey_12.png"; + obj.ButtonsRight(2).Text = ""; + + % Update the internal component lists + obj.BackgroundColorableComponents = [obj.Grid, obj.GridButtonLeft, obj.GridButtonRight]; + obj.FontStyledComponents = [obj.DatepickerLeft, obj.Slider, obj.DatepickerRight]; + obj.EnableableComponents = [obj.DatepickerLeft, obj.Slider, obj.DatepickerRight, obj.ButtonsLeft, obj.ButtonsRight]; + obj.FieldColorableComponents = [obj.DatepickerLeft, obj.DatepickerRight]; + obj.ButtonColorableComponents = [obj.ButtonsLeft, obj.ButtonsRight]; + + % Update the slider ticks + tickLoc = 0:days(obj.Limits(2) - obj.Limits(1)); + dtArray = datetime("01-Jan-2020") + days(tickLoc); + obj.Slider.MajorTicks = tickLoc; + obj.Slider.MinorTicks = tickLoc; + obj.Slider.MajorTickLabels = categorical(dtArray(tickLoc + 1)); + + end %function + + + function update(obj) + % Set the value ranges + + % Set orientation in grid + if obj.Orientation == "vertical" + + % Grid + obj.Grid.ColumnWidth = {'fit', 'fit', '1x', 'fit', 'fit'}; + obj.Grid.RowHeight = {obj.DatepickerSize, '1x'}; + + % Left + obj.GridButtonLeft.Layout.Row = 1; + obj.GridButtonLeft.Layout.Column = 1; + obj.DatepickerLeft.Layout.Row = 1; + obj.DatepickerLeft.Layout.Column = 2; + + % Right + obj.GridButtonRight.Layout.Row = 1; + obj.GridButtonRight.Layout.Column = 5; + obj.DatepickerRight.Layout.Row = 1; + obj.DatepickerRight.Layout.Column = 4; + + % Slider + obj.Slider.Layout.Row = 2; + obj.Slider.Layout.Column = [1 5]; + + else + + % Grid + obj.Grid.ColumnWidth = {'fit', obj.DatepickerSize, '1x', obj.DatepickerSize, 'fit'}; + obj.Grid.RowHeight = {'1x'}; + + % Left + obj.GridButtonLeft.Layout.Row = 1; + obj.GridButtonLeft.Layout.Column = 1; + obj.DatepickerLeft.Layout.Row = 1; + obj.DatepickerLeft.Layout.Column = 2; + + % Right + obj.GridButtonRight.Layout.Row = 1; + obj.GridButtonRight.Layout.Column = 5; + obj.DatepickerRight.Layout.Row = 1; + obj.DatepickerRight.Layout.Column = 4; + + % Slider + obj.Slider.Layout.Row = 1; + obj.Slider.Layout.Column = 3; + end + + % Make sure values are a datetime number + if isnat(obj.DatepickerLeft.Value) + obj.DatepickerLeft.Value = obj.DatepickerLeft.Limits(1); + end + if isnat(obj.DatepickerRight.Value) + obj.DatepickerRight.Value = obj.DatepickerRight.Limits(2); + end + + % Gap is bounded by limits + obj.MinGap = boundValue(obj, days(obj.MinGap), 0, days(diff(obj.Limits))); + + % Update datepicker limits + updateControlLimitsAndValue(obj); + + % Update datepicker display formats + obj.DatepickerLeft.DisplayFormat = obj.DisplayFormat; + obj.DatepickerRight.DisplayFormat = obj.DisplayFormat; + + % Update ticks + updateSliderTicks(obj); + + % Update buttons + updateButtonEnable(obj); + + end %function + + + function onButtonPushed(obj, evt) + % Triggered on button pushed + + % What button was pushed? + oldDate = obj.Value; + newDate = obj.Value; + + switch evt.Source.Tag + case "leftUp" + newDate(1) = min(newDate(1) + obj.Step, newDate(2) - days(1)); + case "leftDown" + newDate(1) = max(newDate(1) - obj.Step, obj.Limits(1)); + case "rightUp" + newDate(2) = min(newDate(2) + obj.Step, obj.Limits(2)); + case "rightDown" + newDate(2) = max(newDate(2) - obj.Step, newDate(1) + days(1)); + end + + % Update the value + obj.Value = newDate; + + % Trigger event + evtOut = wt.eventdata.PropertyChangedData('Value', newDate, oldDate); + notify(obj, "ValueChanged", evtOut); + + end %function + + function onSliderChanged(obj,evt) + % Triggered on slider moved + + % What changed the date? + prevDate = obj.Limits(1) + round(evt.PreviousValue); + newDate = obj.Limits(1) + round(evt.Value); + + % Update datepicker limits + updateControlLimitsAndValue(obj, newDate); + + % Update button enable status + updateButtonEnable(obj) + + % Event data + evtOut = wt.eventdata.PropertyChangedData('Value', newDate, prevDate); + + % Trigger event "ValueChanged" + notify(obj, "ValueChanged", evtOut); + + end %function + + function onSliderChanging(obj,evt) + % Triggered on slider moving + + % What changed the date? + changedDate = obj.Limits(1) + round(evt.Value); + + % Update datepicker values + obj.DatepickerLeft.Value = changedDate(1); + obj.DatepickerRight.Value = changedDate(2); + + % Event data + evtOut = wt.eventdata.PropertyChangedData('Value', changedDate); + + % Trigger event "ValueChanging" + notify(obj, "ValueChanging", evtOut); + + end %function + + + function onDatepickerChanged(obj,evt) + % Triggered on button pushed + + % What changed? + prevValue = obj.Value; + newValue = obj.Value; + + switch evt.Source.Tag + case "left" + prevValue(1) = evt.PreviousValue; + case "right" + prevValue(2) = evt.PreviousValue; + end + + % Prepare event data + evtOut = wt.eventdata.PropertyChangedData('Value', newValue, prevValue); + + % Update the components with the new value + updateControlLimitsAndValue(obj, newValue) + + % Update the buttons + updateButtonEnable(obj) + + % Trigger event + notify(obj, "ValueChanged", evtOut); + + end %function + + + function updateButtonEnable(obj) + + % What are the buttons? + buttonsLeft = obj.ButtonsLeft; + buttonsRight = obj.ButtonsRight; + + if ~(numel(buttonsLeft) == 2 && numel(buttonsRight) == 2) + return + end + + % Can interval increase to lower bound? + if obj.Value(1) > obj.Limits(1) + buttonsLeft(2).Enable = true; + else + buttonsLeft(2).Enable = false; + end + + % Can interval further increase to upper bound? + if obj.Value(2) < obj.Limits(2) + buttonsRight(1).Enable = true; + else + buttonsRight(1).Enable = false; + end + + % Can interval further decrease to center? + if obj.Value(1) == obj.Value(2) - obj.MinGap + buttonsLeft(1).Enable = false; + buttonsRight(2).Enable = false; + else + buttonsLeft(1).Enable = true; + buttonsRight(2).Enable = true; + end + + end %function + + + function updateSliderTicks(obj) + % Update the limits in date-picker and slider + + % Get ticks + [majorTicks, minorTicks] = getSliderTicks( ... + obj, ... + obj.Orientation, ... + "TickLength", strlength(obj.DisplayFormat)); + + % Set slider limits and ticks + obj.Slider.MajorTicks = majorTicks; + obj.Slider.MinorTicks = minorTicks; + + minLimit = obj.Limits(1); + minLimit.Format = obj.DisplayFormat; + obj.Slider.MajorTickLabels = categorical(minLimit + days(majorTicks)); + end %function + + + function updateControlLimitsAndValue(obj, val) + % Update values in datepicker components + + % Current control value + currentVal = [obj.DatepickerLeft.Value obj.DatepickerRight.Value]; + + % Value provided? + if nargin < 2 + val = currentVal; + end + + % Bound current value by lower limit and upper limit. + if eq(currentVal(1), val(1)) + val(1) = boundValue(obj, val(1), obj.Limits(1), obj.Limits(2) - obj.MinGap); + val(2) = boundValue(obj, val(2), val(1) + obj.MinGap, obj.Limits(2)); + else + val(2) = boundValue(obj, val(2), obj.Limits(1) + obj.MinGap, obj.Limits(2)); + val(1) = boundValue(obj, val(1), obj.Limits(1), val(2) - obj.MinGap); + end + + % Update the limits and value + obj.DatepickerLeft.Limits = [obj.Limits(1) val(2) - obj.MinGap]; + obj.DatepickerLeft.Value = val(1); + + obj.DatepickerRight.Limits = [val(1) + obj.MinGap obj.Limits(2)]; + obj.DatepickerRight.Value = val(2); + + % Update the limits and value in the slider + obj.Slider.Limits = days([0, diff(obj.Limits)]); + obj.Slider.Value = days(val - obj.Limits(1)); + + end %function + + end %methods + + %% Private helper functions + methods (Access = private) + + function boundedVal = boundValue(~, val, lowerBound, upperBound) + boundedVal = min( ... + max(val, lowerBound), ... + upperBound); + end + + end + +end % classdef + +function mustBeIncreasing(A) +%MUSTBEINCREASING Validate that value array is increasing +% MUSTBEINCREASING(A) throws an error if array A is not increating. +% MATLAB calls sort to determine if A is increasing. +% +% Class support: +% All numeric classes +% MATLAB classes that define these methods: +% sort, isnumeric +% +% See also: MUSTBENUMERIC, MUSTBEREAL, MUSTBEVECTOR. + +try + mustBeNumeric(A) + mustBeReal(A) + mustBeVector(A) +catch ME + throwAsCaller(ME) +end + +[~, idx] = sort(A, 'ascend'); +if ~all(eq(idx, 1:numel(idx))) + ME = MException( ... + 'DateRageSlider:mustBeIncreasing', ... + 'Value must be increasing.'); + throwAsCaller(ME); +end + +end \ No newline at end of file diff --git a/widgets/+wt/DateSlider.m b/widgets/+wt/DateSlider.m new file mode 100644 index 0000000..d013da5 --- /dev/null +++ b/widgets/+wt/DateSlider.m @@ -0,0 +1,371 @@ +classdef DateSlider < wt.abstract.BaseWidget & ... + wt.mixin.TickableDateSlider & ... + wt.mixin.Enableable & ... + wt.mixin.FieldColorable & ... + wt.mixin.FontStyled & ... + wt.mixin.ButtonColorable + % A slider and date-picker combination + + %% Events + events (HasCallbackProperty, NotifyAccess = protected) + + % Triggered on value changed, has companion callback + ValueChanged + + % Triggered on value changing during slider motion, has companion callback + ValueChanging + + % Triggered on limits changed, has companion callback + LimitsChanged + + end %events + + %% Public dependent properties + properties (AbortSet, Dependent) + % These properties do not trigger the update method + + % Value of the slider and date-time selector + Value (1,1) datetime + + % Index of selected item + ValueIndex (1,1) double {mustBeInteger} + + % Date format + DisplayFormat (1,1) string + + end %properties + + properties (AbortSet, UsedInUpdate = false) + % These properties do not trigger the update method + + % Define step size for buttons + Step (1,1) calendarDuration = calendarDuration(0,0,1) + + end + + %% Public properties + properties (AbortSet) + % These properties trigger the update method + + % Limits of the slider and spinner + Limits (1,2) datetime = datetime("01-Jan-2020") + days([0 2]); + + % Orientation of the spinner and slider + Orientation (1,1) wt.enum.HorizontalVerticalState = wt.enum.HorizontalVerticalState.horizontal + + % Size of date-picker (width for horizontal, height for vertical + DatepickerSize = 120 + + end %properties + + + + %% Internal Properties + properties (Transient, NonCopyable, Hidden, SetAccess = protected) + + % Slider + Slider = matlab.ui.control.Slider.empty + + % Date picker + Datepicker matlab.ui.control.DatePicker + + % Selection buttons + GridButtons matlab.ui.container.GridLayout + Buttons (1,:) matlab.ui.control.Button + + end + + %% Accessors + methods + + % ValueIndex + function set.ValueIndex(obj, val) + maxRange = days(obj.Limits(2) - obj.Limits(1)); + try + mustBeInRange(val, 0, maxRange) + catch ME + throwAsCaller(ME) + end + dtArray = (obj.Limits(1):days(1):obj.Limits(2)) - obj.Limits(1); + obj.Value = dtArray(val); + end %function + function val = get.ValueIndex(obj) + val = obj.Slider.Value; + end %function + + % Value + function set.Value(obj, val) + try + obj.Datepicker.Value = val; + catch ME + throwAsCaller(ME); + end + obj.Slider.Value = days(val - obj.Limits(1)); + obj.Datepicker.Value = val; + end %function + function val = get.Value(obj) + val = obj.Datepicker.Value; + end %function + + % Display format + function set.DisplayFormat(obj, val) + try + obj.Datepicker.DisplayFormat = val; + catch ME + throwAsCaller(ME) + end + format = obj.Datepicker.DisplayFormat; + obj.Limits.Format = format; + end %function + function val = get.DisplayFormat(obj) + val = obj.Datepicker.DisplayFormat; + end %function + + % Limits + function set.Limits(obj, val) + startOfDay = dateshift(val, 'start', 'days'); + try + numVal = days(startOfDay - startOfDay(1)); + mustBeGreaterThan(numVal(2), numVal(1)) + catch ME + if strcmp(ME.identifier, 'MATLAB:validators:mustBeGreaterThanOrEqual') + msg = 'Error setting property ''Limits'' of class ''%s''. Value must be increasing.'; + Merr = MException(ME.identifier, msg, classname2link(class(obj))); + throwAsCaller(Merr); + else + rethrow(ME) + end + end + obj.Limits = startOfDay; + end %function + + % Datepicker size + function set.DatepickerSize(obj, val) + try + g = uigridlayout("Parent", []); + cleanup = onCleanup(@() delete(g)); + g.ColumnWidth{1} = val; + catch ME + throwAsCaller(ME) + end + obj.DatepickerSize = val; + end %function + + end + + %% Protected methods + methods (Access = protected) + + function setup(obj) + + % Call superclass method + obj.setup@wt.abstract.BaseWidget() + + % Set default size + obj.Position(3:4) = [400 40]; + + % Configure grid + obj.Grid.ColumnWidth = {'1x', obj.DatepickerSize, 'fit'}; + obj.Grid.ColumnSpacing = 5; + + % Slider + obj.Slider = uislider(obj.Grid); + obj.Slider.ValueChangedFcn = @(h,e)obj.onSliderChanged(e); + obj.Slider.ValueChangingFcn = @(h,e)obj.onSliderChanged(e); + obj.Slider.Limits = [0 2]; + obj.Slider.Value = 1; + + % Date picker + obj.Datepicker = uidatepicker(obj.Grid); + obj.Datepicker.ValueChangedFcn = @(h,e)obj.onDatepickerChanged(e); + obj.Datepicker.Value = obj.Limits(1) + days(1); + obj.Datepicker.Limits = obj.Limits; + obj.Datepicker.Editable = false; + + % Button grid + obj.GridButtons = uigridlayout(obj.Grid); + obj.GridButtons.RowHeight = {"1x", "1x"}; + obj.GridButtons.ColumnWidth = "fit"; + obj.GridButtons.ColumnSpacing = 0; + obj.GridButtons.RowSpacing = 2; + obj.GridButtons.Padding(:) = 0; + + obj.Buttons = [uibutton(obj.GridButtons) uibutton(obj.GridButtons)]; + obj.Buttons(1).ButtonPushedFcn = @(h,e)obj.onButtonPushed(e); + obj.Buttons(1).Tag = "up"; + obj.Buttons(1).Icon = "up_grey_12.png"; + obj.Buttons(1).Text = ""; + obj.Buttons(2).ButtonPushedFcn = @(h,e)obj.onButtonPushed(e); + obj.Buttons(2).Tag = "down"; + obj.Buttons(2).Icon = "down_grey_12.png"; + obj.Buttons(2).Text = ""; + + % Update the internal component lists + obj.BackgroundColorableComponents = obj.Grid; + obj.FontStyledComponents = [obj.Datepicker, obj.Slider]; + obj.EnableableComponents = [obj.Datepicker, obj.Slider, obj.Buttons]; + obj.FieldColorableComponents = [obj.Datepicker]; + obj.ButtonColorableComponents = [obj.Buttons]; + + end %function + + + function update(obj) + + % Set the value ranges + + % Set orientation in grid + if obj.Orientation == "vertical" + obj.Grid.ColumnWidth = {'1x', 'fit'}; + obj.Grid.RowHeight = {'1x', obj.DatepickerSize}; + obj.Datepicker.Layout.Row = 2; + obj.Datepicker.Layout.Column = 1; + obj.GridButtons.Layout.Row = 2; + obj.GridButtons.Layout.Column = 2; + obj.Slider.Orientation = "vertical"; + else + obj.Grid.ColumnWidth = {'1x', obj.DatepickerSize, 'fit'}; + obj.Grid.RowHeight = {'1x'}; + obj.Datepicker.Layout.Row = 1; + obj.Datepicker.Layout.Column = 2; + obj.GridButtons.Layout.Row = 1; + obj.GridButtons.Layout.Column = 3; + obj.Slider.Orientation = "horizontal"; + end + + % Set component range + obj.Slider.Limits = [0 days(obj.Limits(2) - obj.Limits(1))]; + obj.Datepicker.Limits = obj.Limits; + + % Update ticks + updateSliderTicks(obj) + + % Set value + if isnat(obj.Datepicker.Value) + obj.Datepicker.Value = obj.Limits(1); + end + obj.Slider.Value = days(obj.Datepicker.Value - obj.Limits(1)); + + % Update the buttons + updateButtonEnable(obj) + + end %function + + + function onButtonPushed(obj, evt) + % Triggered on button pushed + + % What button was pushed? + oldDate = obj.Value; + newDate = obj.Value; + switch evt.Source.Tag + case "up" + newDate = min(newDate + obj.Step, obj.Limits(2)); + case "down" + newDate = max(newDate - obj.Step, obj.Limits(1)); + + end + + % Update the state + obj.Datepicker.Value = newDate; + obj.Slider.Value = days(newDate - obj.Limits(1)); + + % Update button enable status + updateButtonEnable(obj) + + % Trigger event + evtOut = wt.eventdata.PropertyChangedData('Value', newDate, oldDate); + notify(obj, "ValueChanged", evtOut); + + end %function + + function onSliderChanged(obj,evt) + % Triggered on slider moved + + % What changed? + newValue = evt.Value; + oldValue = obj.Datepicker.Value; + + % Round value to whole days + newValue = round(newValue); + newValue = min(max(newValue,0), days(obj.Limits(2) - obj.Limits(1))); + + % Prepare event data + newDate = obj.Limits(1) + days(newValue); + evtOut = wt.eventdata.PropertyChangedData('Value', newDate, oldValue); + + % Update the state + obj.Datepicker.Value = newDate; + + % Skip for event ValueChanging for performance + if evt.EventName == "ValueChanged" + obj.Slider.Value = newValue; + + % Update button enable status + updateButtonEnable(obj) + end + + % Trigger event ("ValueChanged" or "ValueChanging") + notify(obj, evt.EventName, evtOut); + + end %function + + + function onDatepickerChanged(obj,e) + % Triggered on button pushed + + % What changed? + newValue = e.Value; + + % Prepare event data + evtOut = wt.eventdata.PropertyChangedData('Value', newValue, e.PreviousValue); + + % Update the state + obj.Slider.Value = days(newValue - obj.Limits(1)); + + % Update button enable status + updateButtonEnable(obj) + + % Trigger event + notify(obj, "ValueChanged", evtOut); + + end %function + + + function updateButtonEnable(obj) + + % What are the buttons? + + % Limits of interval reached? + if obj.Value <= obj.Limits(1) + obj.Buttons(1).Enable = true; + obj.Buttons(2).Enable = false; + elseif obj.Value >= obj.Limits(2) + obj.Buttons(1).Enable = false; + obj.Buttons(2).Enable = true; + else + obj.Buttons(1).Enable = true; + obj.Buttons(2).Enable = true; + end %if + + end %function + + function updateSliderTicks(obj) + % Update the limits in date-picker and slider + + % Get ticks + [majorTicks, minorTicks] = getSliderTicks( ... + obj, ... + obj.Orientation, ... + "TickLength", strlength(obj.DisplayFormat)); + + % Set slider limits and ticks + obj.Slider.MajorTicks = majorTicks; + obj.Slider.MinorTicks = minorTicks; + obj.Slider.MajorTickLabels = categorical(obj.Limits(1) + days(majorTicks)); + + end %function + + end %methods + +end % classdef \ No newline at end of file diff --git a/widgets/icons/down_grey_12.png b/widgets/icons/down_grey_12.png new file mode 100644 index 0000000000000000000000000000000000000000..68f2ad1200cd89add35b7c5553e2fd49f16f9d14 GIT binary patch literal 120 zcmeAS@N?(olHy`uVBq!ia0vp^JV4CG!2%>>pKk|Au$OrHy0X7yW8$-BFPPUA02I>k zba4#fn3>pKk|Au$OrHy0X7yW8$-BFPPUA02I>q zba4#fn3>zPQ;@-c=TM5;`DaTu&Yj+5t&()XP{6e0!7JY%R!bswOqZMECC~GK( Date: Tue, 23 Dec 2025 14:46:22 +0100 Subject: [PATCH 2/5] Add unit tests for DateSlider and DateRangeSlider --- test/+wt/+test/DateRangeSlider.m | 429 +++++++++++++++++++++++++++++++ test/+wt/+test/DateSlider.m | 308 ++++++++++++++++++++++ 2 files changed, 737 insertions(+) create mode 100644 test/+wt/+test/DateRangeSlider.m create mode 100644 test/+wt/+test/DateSlider.m diff --git a/test/+wt/+test/DateRangeSlider.m b/test/+wt/+test/DateRangeSlider.m new file mode 100644 index 0000000..8573c16 --- /dev/null +++ b/test/+wt/+test/DateRangeSlider.m @@ -0,0 +1,429 @@ +classdef DateRangeSlider < wt.test.BaseWidgetTest + % Implements a unit test for a widget or component + + + %% Test Method Setup + methods (TestMethodSetup) + + function setup(testCase) + + % Assure the correct MATLAB version is present + assumeMinimumRelease(testCase, "R2024b") + + % Call superclass method + testCase.setup@wt.test.BaseWidgetTest(); + + % Change figure size to accomodate for slider ticks + testCase.Figure.Position(3) = 800; + + % Setup widget + fcn = @()wt.DateRangeSlider(testCase.Grid); + testCase.Widget = verifyWarningFree(testCase,fcn); + + % Set callback + testCase.Widget.ValueChangedFcn = @(s,e)onCallbackTriggered(testCase,e); + testCase.Widget.LimitsChangedFcn = @(s,e)onCallbackTriggered(testCase,e); + + % Ensure it renders + drawnow + + end %function + + end %methods + + + %% Unit Tests + methods (Test) + + function testValueProperty(testCase) + + % Set the value + newValue = datetime("01-Jan-2020") + [days(0) days(2)]; + testCase.verifySetProperty("Value", newValue); + testCase.verifyControlValues(newValue); + + % Set the value + newValue = datetime("01-Jan-2020") + [days(1) days(3)]; + testCase.verifySetProperty("Value", newValue); + testCase.verifyControlValues(newValue); + + end %function + + + function testValueBoundaries(testCase) + + % Configure the control + expValue = datetime("yesterday") + [-days(20) -days(19)]; + newLimits = datetime("yesterday") + [-days(20) days(15)]; + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + testCase.verifyControlValues(expValue); + + % Set the value within limits + newValue = datetime("yesterday") + [days(10) days(15)]; + testCase.verifySetProperty("Value", newValue); + testCase.verifyControlValues(newValue); + + % Change the limits out of bounds + newLimits = datetime("yesterday") + [days(20) days(30)]; + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + testCase.verifyControlValues([newLimits(1) newLimits(1) + testCase.Widget.MinGap]); + + % Set an invalid value + expValue = [datetime("yesterday") + days(20) datetime("yesterday") + days(20) + testCase.Widget.MinGap]; + invldValue = [datetime("yesterday") + days(31) datetime("yesterday") + days(32)]; + testCase.verifySetPropertyError("Value", invldValue, 'MATLAB:validators:mustBeInRange'); + testCase.verifyControlValues(expValue); + + % Set an invalid value + expValue = [datetime("yesterday") + days(20) datetime("yesterday") + days(20) + testCase.Widget.MinGap]; + invldValue = [datetime("yesterday") + days(15) datetime("yesterday") + days(25)]; + testCase.verifySetPropertyError("Value", invldValue, 'MATLAB:validators:mustBeInRange'); + testCase.verifyControlValues(expValue); + + end %function + + function testDatepicker(testCase) + + % Configure the control + expValue = datetime("today") + [-days(20) -days(19)]; + newLimits = [datetime("today") datetime("today")] + [-days(20) days(15)]; + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + testCase.verifyControlValues(expValue); + + % Enable the datepicker to be able to type + testCase.Widget.DatepickerLeft.Editable = true; + testCase.Widget.DatepickerRight.Editable = true; + + % Pick a date using datepicker (right) + newValue = datetime("today") + [-days(20) days(15)]; + testCase.verifyTypeAction(testCase.Widget.DatepickerRight, newValue(2), "Value", newValue) + testCase.verifyControlValues(newValue); + testCase.verifyControlLimits(newLimits); + testCase.verifyButtonsEnabled([true false false true]) + testCase.verifyCallbackCount(1); + + newValue = datetime("today") + [-days(20) days(10)]; + testCase.verifyTypeAction(testCase.Widget.DatepickerRight, newValue(2), "Value", newValue) + testCase.verifyControlValues(newValue); + testCase.verifyControlLimits(newLimits); + testCase.verifyButtonsEnabled([true false true true]) + testCase.verifyCallbackCount(2); + + % Pick a date using datepicker (left) + newValue = datetime("today") + [days(9) days(10)]; + testCase.verifyTypeAction(testCase.Widget.DatepickerLeft, newValue(1), "Value", newValue) + testCase.verifyControlValues(newValue); + testCase.verifyControlLimits(newLimits); + testCase.verifyButtonsEnabled([false true true false]) + testCase.verifyCallbackCount(3); + + newValue = datetime("today") + [-days(10) days(10)]; + testCase.verifyTypeAction(testCase.Widget.DatepickerLeft, newValue(1), "Value", newValue) + testCase.verifyControlValues(newValue); + testCase.verifyControlLimits(newLimits); + testCase.verifyButtonsEnabled([true true true true]) + testCase.verifyCallbackCount(4); + + + % Pick an out-of-range date using datepicker + expValue = datetime("today") + [-days(10) days(10)]; + + invldValue = datetime("today") + days(10); + testCase.verifyTypeAction(testCase.Widget.DatepickerLeft, invldValue, "Value", expValue) + testCase.verifyControlValues(expValue); + testCase.verifyControlLimits(newLimits); + testCase.verifyButtonsEnabled([true true true true]) + testCase.verifyCallbackCount(4); + + invldValue = datetime("today") - days(10); + testCase.verifyTypeAction(testCase.Widget.DatepickerRight, invldValue, "Value", expValue) + testCase.verifyControlValues(expValue); + testCase.verifyControlLimits(newLimits); + testCase.verifyButtonsEnabled([true true true true]) + testCase.verifyCallbackCount(4); + + end + + function testDatepickerButtons(testCase) + + % Configure the control + newLimits = datetime("yesterday") + [days(0) days(10)]; + expValue = newLimits; + testCase.verifySetProperty("Limits", newLimits); + testCase.verifySetProperty("Value", expValue); + testCase.verifyControlLimits(newLimits); + testCase.verifyControlValues(expValue); + + % Verify buttons enabled state + testCase.verifyButtonsEnabled([true false false true]) + + % Push down is disabled + testCase.verifyButtonPushAction("left", "down", expValue) + testCase.verifyButtonPushAction("right", "up", expValue) + testCase.verifyCallbackCount(0); + + % Push the button up once + testCase.verifyButtonPushAction("left", "up", expValue + days([1 0])) + testCase.verifyButtonPushAction("right", "down", expValue + days([1 -1])) + testCase.verifyControlValues(expValue + days([1 -1])); + testCase.verifyControlLimits(newLimits); + testCase.verifyButtonsEnabled([true true true true]) + testCase.verifyCallbackCount(2); + + % Change step size and push down + testCase.Widget.Step = caldays(4); + testCase.verifyButtonPushAction("left", "down", expValue + days([0 -1])) + testCase.verifyButtonsEnabled([true false true true]) + testCase.verifyCallbackCount(3); + + % Push up + testCase.verifyButtonPushAction("left", "up", expValue + days([4 -1])) + testCase.verifyButtonPushAction("left", "up", expValue + days([8 -1])) + testCase.verifyCallbackCount(5); + + % Push up disabled at this point + testCase.verifyButtonsEnabled([false true true false]) + testCase.verifyButtonPushAction("left", "up", expValue + days([8 -1])) + testCase.verifyCallbackCount(5); + + % Push down + testCase.verifyButtonPushAction("left", "down", expValue + days([4 -1])) + testCase.verifyButtonPushAction("left", "down", expValue + days([0 -1])) + testCase.verifyButtonsEnabled([true false true true]) + testCase.verifyCallbackCount(7); + + % Push up + testCase.verifyButtonPushAction("right", "up", expValue + days([0 0])) + testCase.verifyButtonsEnabled([true false false true]) + testCase.verifyCallbackCount(8); + + % Push down + testCase.verifyButtonPushAction("right", "down", expValue + days([0 -4])) + testCase.verifyButtonPushAction("right", "down", expValue + days([0 -8])) + testCase.verifyButtonPushAction("right", "down", expValue + days([0 -9])) + testCase.verifyButtonsEnabled([false false true false]) + testCase.verifyControlValues(expValue + days([0 -9])); + testCase.verifyControlLimits(newLimits); + testCase.verifyCallbackCount(11); + + end + + function testTickLabels(testCase) + + % Change the limits + newLimits = datetime("today") + days([5 10]); + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + testCase.verifyControlValues(datetime("today") + days([5 6])); + + % Check tick labels + expLabels = string(datetime("today") + days(5:10)); + actualLabels = testCase.Widget.Slider.MajorTickLabels; + actualLabels = convertCharsToStrings(actualLabels(1:min(6, numel(actualLabels)))); + + % Allow some time for the component to catch up + drawnow; + pause(2) + + testCase.verifyEqual(actualLabels, expLabels) + + % Change the limits + newLimits = datetime("today") + days([0 10]); + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + testCase.verifyControlValues(datetime("today") + days([5 6])); + + % Check tick labels + expLabels = string(datetime("today") + days(0:2:10)); + actualLabels = testCase.Widget.Slider.MajorTickLabels; + actualLabels = convertCharsToStrings(actualLabels(1:min(6, numel(actualLabels)))); + testCase.verifyEqual(actualLabels, expLabels) + + % Change datepicker size so that slider barely fits + testCase.Widget.DatepickerSize = 220; + + % Allow some time for the component to catch up + drawnow + pause(2) + + % Change the limits + newLimits = datetime("today") + days([0 20]); + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + testCase.verifyControlValues(datetime("today") + days([5 6])); + + % Check widgets exist + expLabels = string(datetime("today") + days([0 10 20])); + actualLabels = testCase.Widget.Slider.MajorTickLabels; + actualLabels = convertCharsToStrings(actualLabels(1:min(3, numel(actualLabels)))); + testCase.verifyEqual(actualLabels, expLabels) + + end %function + + + function testMinGap(testCase) + + % Configure the control + newLimits = datetime("today") + days([50 100]); + newValue = datetime("today") + days([50 50]); + testCase.verifySetProperty("MinGap", 0, days(0)); + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + testCase.verifyControlValues(newValue) + + % Change the minimum gap + minGap = 10; + newValue = datetime("today") + days(50 + [0 minGap]); + testCase.verifySetProperty("MinGap", minGap, days(minGap)); + testCase.verifyControlValues(newValue) + testCase.verifyButtonsEnabled(["off" "off" "on" "off"]) + + % Change the value + newValue = datetime("today") + days(70 + [-1 minGap + 1]); + testCase.verifySetProperty("Value", newValue); + testCase.verifyControlValues(newValue) + testCase.verifyButtonsEnabled(["on" "on" "on" "on"]) + + newValue = datetime("today") + days(70 + [0 minGap]); + testCase.verifySetProperty("Value", newValue); + testCase.verifyControlValues(newValue) + testCase.verifyButtonsEnabled(["off" "on" "on" "off"]) + + % Increase gap + minGap = 20; + newValue = datetime("today") + days(70 + [0 minGap]); + testCase.verifySetProperty("MinGap", minGap, days(minGap)); + testCase.verifyControlValues(newValue) + + minGap = 30; + newValue = datetime("today") + days(70 + [0 minGap]); + testCase.verifySetProperty("MinGap", minGap, days(minGap)); + testCase.verifyControlValues(newValue) + testCase.verifyButtonsEnabled(["off" "on" "off" "off"]) + + % Increate gap even further + minGap = 40; + newValue = datetime("today") + days(60 + [0 minGap]); + testCase.verifySetProperty("MinGap", minGap, days(minGap)); + testCase.verifyControlValues(newValue) + + minGap = 50; + newValue = datetime("today") + days(50 + [0 minGap]); + testCase.verifySetProperty("MinGap", minGap, days(minGap)); + testCase.verifyControlValues(newValue) + testCase.verifyButtonsEnabled(["off" "off" "off" "off"]) + + % Check decreasing the limits + newLimits = datetime("today") + days(60 + [0 20]); + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits) + testCase.verifyEqual(testCase.Widget.MinGap, days(20)); + + % MinGap cannot exceed limits + testCase.verifyError(@() set(testCase.Widget, 'MinGap', 30), 'MATLAB:validators:mustBeGreaterThanOrEqual') + testCase.verifyError(@() set(testCase.Widget, 'MinGap', -1), 'MATLAB:validators:mustBeNonnegative') + testCase.verifyWarningFree(@() set(testCase.Widget, 'MinGap', 10)) + testCase.verifyButtonsEnabled(["off" "off" "off" "off"]) + + % No callbacks fired + testCase.verifyCallbackCount(0) + + end %function + + end %methods (Test) + + %% Helper methods + methods (Access = private) + + function verifyControlValues(testCase, dateValue, absTol) + % Verifies the control fields have the specified value + + arguments + testCase + dateValue (1,2) datetime + absTol (1,1) double = 0 + end + + drawnow + + numValue = days(dateValue - testCase.Widget.Limits(1)); + testCase.verifyEqual(testCase.Widget.Slider.Value, numValue, 'AbsTol', absTol); + testCase.verifyEqual(testCase.Widget.DatepickerLeft.Value, dateValue(1), 'AbsTol', absTol); + testCase.verifyEqual(testCase.Widget.DatepickerRight.Value, dateValue(2), 'AbsTol', absTol); + + end %function + + function verifyControlLimits(testCase, dateLimits, absTol) + % Verifies the control fields have the specified limit + + arguments + testCase + dateLimits (1,2) datetime + absTol (1,1) double = 0 + end + + drawnow + + % What is the minimum gap? + minGap = testCase.Widget.MinGap; + + % Verify slider limits + numLimits = [0 days(dateLimits(2) - dateLimits(1))]; + testCase.verifyEqual(testCase.Widget.Slider.Limits, numLimits, 'AbsTol', absTol); + + % Verify left datepicker + limitsLeft = [dateLimits(1) testCase.Widget.DatepickerRight.Value - minGap]; + testCase.verifyEqual(testCase.Widget.DatepickerLeft.Limits, limitsLeft, 'AbsTol', absTol); + + % Verify right datepicker + limitsRight = [testCase.Widget.DatepickerLeft.Value + minGap dateLimits(2)]; + testCase.verifyEqual(testCase.Widget.DatepickerRight.Limits, limitsRight, 'AbsTol', absTol); + + end %function + + function verifyButtonsEnabled(testCase, enabledStatus) + % Verifies the control buttons have the specified enable status + + arguments + testCase + enabledStatus (1,4) matlab.lang.OnOffSwitchState = [true true true true] + end + + testCase.verifyEqual([testCase.Widget.ButtonsLeft.Enable testCase.Widget.ButtonsRight.Enable], enabledStatus); + end %function + + function verifyButtonPushAction(testCase, side, direction, expValue) + + arguments + testCase + side (1,1) string {mustBeMember(side, ["right", "left"])} + direction (1,1) string {mustBeMember(direction, ["up", "down"])} + expValue (1,2) datetime + end + + if side == "right" + buttons = testCase.Widget.ButtonsRight; + else + buttons = testCase.Widget.ButtonsLeft; + end + + if direction == "up" + buttonIdx = 1; + else + buttonIdx = 2; + end + + % Type the new value into the control + testCase.press(buttons(buttonIdx)); + + % Verify new property value + testCase.verifyControlValues(expValue); + + end %function + + end %private methods + +end %classdef \ No newline at end of file diff --git a/test/+wt/+test/DateSlider.m b/test/+wt/+test/DateSlider.m new file mode 100644 index 0000000..94e5d02 --- /dev/null +++ b/test/+wt/+test/DateSlider.m @@ -0,0 +1,308 @@ +classdef DateSlider < wt.test.BaseWidgetTest + % Implements a unit test for a widget or component + + + %% Test Method Setup + methods (TestMethodSetup) + + function setup(testCase) + + % Call superclass method + testCase.setup@wt.test.BaseWidgetTest(); + + % Setup widget + fcn = @()wt.DateSlider(testCase.Grid); + testCase.Widget = verifyWarningFree(testCase,fcn); + + % Set callback + testCase.Widget.ValueChangedFcn = @(s,e)onCallbackTriggered(testCase,e); + testCase.Widget.LimitsChangedFcn = @(s,e)onCallbackTriggered(testCase,e); + + % Ensure it renders + drawnow + + end %function + + end %methods + + %% Unit Tests + methods (Test) + + function testValueProperty(testCase) + + % Set the value + newValue = datetime("01-Jan-2020"); + testCase.verifySetProperty("Value", newValue); + testCase.verifyControlValues(newValue); + + % Set the value + newValue = datetime("03-Jan-2020"); + testCase.verifySetProperty("Value", newValue); + testCase.verifyControlValues(newValue); + + end %function + + + function testValueBoundaries(testCase) + + % Configure the control + newLimits = datetime("today") + [-days(20) days(15)]; + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + testCase.verifyControlValues(newLimits(1)); + + % Set the value within limits + newValue = datetime("today") + days(15); + testCase.verifySetProperty("Value", newValue); + testCase.verifyControlValues(newValue); + + % Change the limits out of bounds + newLimits = datetime("today") + [days(20) days(30)]; + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + testCase.verifyControlValues(newLimits(1)); + + % Set an invalid value + expValue = datetime("today") + days(20); + invldValue = datetime("today") + days(31); + testCase.verifySetPropertyError("Value", invldValue, 'MATLAB:ui:DatePicker:valueNotValid'); + testCase.verifyControlValues(expValue); + + % Set an invalid value + expValue = datetime("today") + days(20); + invldValue = datetime("today") + days(15); + testCase.verifySetPropertyError("Value", invldValue, 'MATLAB:ui:DatePicker:valueNotValid'); + testCase.verifyControlValues(expValue); + + end %function + + function testDatepicker(testCase) + + % Configure the control + newLimits = datetime("today") + [-days(20) days(15)]; + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + testCase.verifyControlValues(newLimits(1)); + + % Enable the datepicker to be able to type + testCase.Widget.Datepicker.Editable = true; + + % Pick a date using datepicker + newValue = datetime("today") + days(15); + testCase.verifyTypeAction(testCase.Widget.Datepicker, newValue, "Value") + testCase.verifyEqual(testCase.Widget.Value, newValue) + testCase.verifyCallbackCount(1); + + newValue = datetime("today") + days(10); + testCase.verifyTypeAction(testCase.Widget.Datepicker, newValue, "Value") + testCase.verifyEqual(testCase.Widget.Value, newValue) + testCase.verifyCallbackCount(2); + + % Pick an out-of-range date using datepicker + invldValue = datetime("today") + days(20); + testCase.verifyTypeAction(testCase.Widget.Datepicker, invldValue, "Value", newValue) + testCase.verifyEqual(testCase.Widget.Value, newValue) + testCase.verifyCallbackCount(2); + + % Change date using value property + newValue = datetime("today") - days(20); + testCase.verifySetProperty("Value", newValue) + testCase.verifyEqual(testCase.Widget.Datepicker.Value, newValue) + testCase.verifyCallbackCount(2); + + end + + function testDatepickerButtons(testCase) + + % Configure the control + newLimits = datetime("today") + [days(0) days(10)]; + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + testCase.verifyControlValues(newLimits(1)); + + % Verify buttons enabled state + testCase.verifyButtonsEnabled([true false]) + + % Push down is disabled + testCase.verifyButtonPushAction("down", newLimits(1)) + testCase.verifyCallbackCount(0); + + % Push the button up once + testCase.verifyButtonPushAction("up", newLimits(1) + days(1)) + testCase.verifyButtonsEnabled([true true]) + testCase.verifyCallbackCount(1); + + % Change step size and push down + testCase.Widget.Step = caldays(4); + testCase.verifyButtonPushAction("down", newLimits(1)) + testCase.verifyButtonsEnabled([true false]) + testCase.verifyCallbackCount(2); + + % Push up + testCase.verifyButtonPushAction("up", newLimits(1) + days(4)) + testCase.verifyButtonPushAction("up", newLimits(1) + days(8)) + testCase.verifyButtonPushAction("up", newLimits(2)) + testCase.verifyCallbackCount(5); + + % Push up disabled at this point + testCase.verifyButtonsEnabled([false true]) + testCase.verifyButtonPushAction("up", newLimits(2)) + testCase.verifyCallbackCount(5); + + end + + function testTickLabels(testCase) + + % Change the limits + expValue = datetime("today") + days(5); + newLimits = datetime("today") + [days(5) days(10)]; + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + testCase.verifyControlValues(newLimits(1)); + + % Check tick labels + expLabels = string(datetime("today") + days(5:10)); + actualLabels = testCase.Widget.Slider.MajorTickLabels; + actualLabels = convertCharsToStrings(actualLabels(1:min(6, numel(actualLabels)))); + + testCase.verifyEqual(actualLabels, expLabels) + + % Change the limits + newLimits = datetime("today") + [days(0) days(10)]; + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + testCase.verifyControlValues(expValue); + + % Change datepicker size so that slider barely fits + testCase.Widget.DatepickerSize = 240; + + % Check widgets exist + expLabels = string(datetime("today") + days([0 5 10])); + actualLabels = testCase.Widget.Slider.MajorTickLabels; + actualLabels = convertCharsToStrings(actualLabels(1:min(3, numel(actualLabels)))); + + testCase.verifyEqual(actualLabels, expLabels) + + end %function + + + function testSlider(testCase) + + % Configure the control + newLimits = datetime("today") + [days(0) days(100)]; + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + + % Get the control + sliderControl = testCase.Widget.Slider; + + % Click the slider + newValue = 74; + expValue = datetime("today") + days(74); + testCase.choose(sliderControl,newValue); + testCase.verifyControlValues(expValue); + testCase.verifyEqual(testCase.Widget.Value, expValue); + + % Verify callback triggered + testCase.verifyEqual(testCase.CallbackCount, 1) + + + % Drag the slider + startValue = 0; + newValue = 32; + expValue = datetime("today") + 32; + testCase.drag(sliderControl,startValue,newValue); + testCase.verifyControlValues(expValue); + testCase.verifyEqual(testCase.Widget.Value, expValue); + + % Verify callback triggered + testCase.verifyEqual(testCase.CallbackCount, 2) + + % Drag the slider to a fraction (with rounding turned on) + startValue = 32; + newValue = 13.8; + expValue = datetime("today") + days(14); + testCase.drag(sliderControl,startValue,newValue); + testCase.verifyControlValues(expValue); + testCase.verifyEqual(testCase.Widget.Value, expValue); + + % Verify callback triggered + testCase.verifyEqual(testCase.CallbackCount, 3) + + end %function + + end %methods (Test) + + %% Helper methods + methods (Access = private) + + function verifyControlValues(testCase, dateValue, absTol) + % Verifies the control fields have the specified value + + arguments + testCase + dateValue (1,1) datetime + absTol (1,1) double = 0 + end + + drawnow + + numValue = days(dateValue - testCase.Widget.Limits(1)); + testCase.verifyEqual(testCase.Widget.Slider.Value, numValue, 'AbsTol', absTol); + testCase.verifyEqual(testCase.Widget.Datepicker.Value, dateValue, 'AbsTol', absTol); + + end %function + + function verifyControlLimits(testCase, dateLimits, absTol) + % Verifies the control fields have the specified limit + + arguments + testCase + dateLimits (1,2) datetime + absTol (1,1) double = 0 + end + + drawnow + + numLimits = [0 days(dateLimits(2) - dateLimits(1))]; + testCase.verifyEqual(testCase.Widget.Slider.Limits, numLimits, 'AbsTol', absTol); + testCase.verifyEqual(testCase.Widget.Datepicker.Limits, dateLimits, 'AbsTol', absTol); + + end %function + + function verifyButtonsEnabled(testCase, enabledStatus) + % Verifies the control buttons have the specified enable status + + arguments + testCase + enabledStatus (1,2) matlab.lang.OnOffSwitchState = [true true] + end + + testCase.verifyEqual([testCase.Widget.Buttons.Enable], enabledStatus); + end %function + + function verifyButtonPushAction(testCase, direction, expValue) + + arguments + testCase + direction (1,1) string {mustBeMember(direction, ["up", "down"])} + expValue (1,1) datetime + end + + if direction == "up" + buttonIdx = 1; + else + buttonIdx = 2; + end + + % Type the new value into the control + testCase.press(testCase.Widget.Buttons(buttonIdx)); + + % Verify new property value + testCase.verifyControlValues(expValue); + + end %function + + end %methods + +end %classdef \ No newline at end of file From 723a41171537fdb8e1d8e011961304eb3407427c Mon Sep 17 00:00:00 2001 From: Jacob-Jan Sloots <47000395+slootsjj@users.noreply.github.com> Date: Tue, 23 Dec 2025 14:46:42 +0100 Subject: [PATCH 3/5] Add DateSlider and DateRangeSlider to WidgetsList --- widgets/doc/WidgetsList.mlx | Bin 138292 -> 146778 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/widgets/doc/WidgetsList.mlx b/widgets/doc/WidgetsList.mlx index 8721f1086a732f32159f65cc83eb3de2985928b4..d377c68fdf251fd902fe81cf2ba4d5818ef12bec 100644 GIT binary patch delta 95723 zcmV($K;yr(xCq+%2(a)23S4t+X=M`t04sHq`U4(+wvzwde+7;+8O!q&NtW$2Nt?b? zoTTxL9eZrQ^xfq$HxLO)s7ZoHKvvvN{`cEmfFvl(wrp9gIn#C`^UGoZEU+K!0t@h` ze|}41b}4c#Rr)5_?(_mC(ojV*9lr_wb^hV`%iy0s|1^6Ysc@Qz)G(k=_3PQ2U}8-6 zy4%%%;Y1`{cT^@)csEjc!VTQ!Cc(DiUpg!zU1+nz(^B|po=el3yX)b7#V!lEfdj?`T0<41NksDVh3p$Pa_erUu85F zMkBGIB)LsEpRX37Imtb)i-_uln+T3ly1RIPldDYRu}m)*iSbZ{+>o?EP%$6AM#;4{ zJKeWaV^sP}E~EF~c#_4UGcifLxfOVIv@{Hf=Ic~uvrOTQ_-2+C?D<5nT5e0%snh+( z%y<>+Bz|>rm&*s08V!s>4e3>?bjCyBO5$kD&ok4h_}o(WveaxwZO@(c%`Oh1Ku1De`9ahR9d1|aH6!t$^`8%+r1vcfBn54`(f|v){h&Qwn%{2mQBmD zfdp*(Ydd%gGC}#L(Y}gR4vac4Sm!0Y0}dNyxlp#YeK&?>udvDv{A+!sh zx!fRWncV{F188j|*(vf7hHnV)0t zDl;EMkxTrJa&0Hncvw&|Bx?>L`juM^ z6MarAqhjco!DG~SnIc|=0FF?90gzP2QxSLAQ%4)HGS&z;;SfdbLyg}A9@t=NmAVSu zz@T$rM4~ITeyacrQm3{1fcAW>+}%et_1+yS%?9ZhbYHtCN0KMfU4IfY7_#z@VmV zgd%?RR)i6s)qQY8qzDa~fo_4l1UAkks&PmX)x-~N8xctZx-H^}@mQfHV-?()GGzK- z)%1e2k%T1Urw=>3>ojsmC^gXW8_Yu;kI+f;~tr>#i%=#B#BIh7hu4n&OcB&YK)fBj6{IPiK56^Dnz8gg4YJ1?QS#uX<%lGtv==P zXDMd4fo4I+kgyS`3848u_4=)fnm(`lz^1f@S9HnK5Ijxj!I?^bae9TI5Z+!&4Q%5p z7Rw7nD8q+jej#KMP64Wr4#5lSUP|m}Mx;3Hf$k@m{|qg-EYk(BB`TW69Mlin6lZft zOio+PJ>**Gp-4M3c_G1BmfTMHz+LwUpf`T@zW?lH@7b%JOAt+Ymz7UwbmWjj%FlzGEOFNa&5oqF~!#=8+xSSJUS>!gGrm@6M^@w@il+}Vh zweE&cDJTuc`*F?_000@1UgRTSO^p%rX&O$j%X3fhcp5Q(@YX|oE=}S8R73E+4UpwP zEkvt6`F9cniLgrfCXfjqi=g(}QbPyNfiUHXK zS3pWU9>kzUCGC)d4F)}UK>{8doQ^0->n$`$q5MWfov|D(NSuq9P()8;b`X_3@`GsG ziKbR*|NhT^A2nU~dWYuNS&X*JIxVPG9Re(-EoFUNqrs|r`LKBc)RiIhhloWe4QmjQ z+Gv|43__bQaFNjogAXP_N+T1&)bKZGr6)a6xeNbZtaIidDjUEztoXm$zxI3m zDGXdq>HAdHTNS{gcx)}mNl=9@oKK|oj6E8aaIk@Y8sJnKjzdR-^TWYg>m?0KFRAHj z^y<%0Bd;0fb;*16bQEe?=j)wo=)32v3d#mfTg_K;H6LuA+oPy8>N82VoQAS%fCvhJQ?nFj z)Q@<73TFLnIt|1OscAKfIr;`E_VvoHsN2^WK1jW>i-Eq8uT4|YWVKSKVxwFopbarf zT#Xp|DB5Z-&_xPTYgMg=(GU))sKgc%z_Vw9Yl&`W6t%(EPt+v<0J;6h4jADg4`qZU ziJ(>ywz8Y+@aA9ONeYDm7%Bn>o;n`vJKZ$)$AkrwZQ9-o!ipqPCOdN}1YgTqOSp(4+FJrY(^pV&1L4WRDbNtmR_Za6w|LIoj-3bv14F zIo(H_=a*=}Ua-^6II_?>0GT1qB)Le@NYFU-T-X_&?_n3-!NgEGxVnV_L9DF#0?e76 zIc^bxfkdb!8NqoBLTdqIcA7txuOBdn|RLtY+5Sc0kG%B86&#pfPAfbtD$_2)qP;zx3mi}+Eo)$0otxz%}M}*M9S!= zy)?4+eMW_#d_}A^fTxLd+G-i|h?~i;xG`tBRm{KEn%!MwsLmO)yL;;}W>4zk%L;T^ z(!AYiu6cWcvH3!O>$m)tC8vUj0ab%=ud3RLs8=z1DCQLcbO%V#i4(V`&n-Bv7BgIv~AHG7|eW($3etDm@$^(n>tM`x4-lTX1Ks@m7E$O9W5p!5fB`t+MQ$RzsEfR0ombFHp#LD!{AwpG+QCr8QDC2yqfcJ+hK9@5M}9DLD-xD%I<6|jvV`i z4t!W?kXpd-ffEic_RH>ob$)_{TJKyra!$&B(E&#^x&)+3+@@KHV~iM0W9y6vW9)zf zzuKOLg0O}=C5AEvfEMK5&>=nA?xMZIojw3MP~}{t;g!u4Bi?{^D9lX25ZR-lXZz_7 zH*4Ktb3Kv*r4lZf*Lc05YqP?Yrs2jLZ)DQtahb)2ncyUs3D2+C{xpXMK`c9?9h3Ec zX9d+~6&u25kE(dKzC)}Y@gR;Lez<#1`G@{G=9Cx0-!b6Fy{DIV@19<+uwWk19#fVt zmyqS6fRy#f^4@aXYwk3CePp<0EVY1N9>uy(vs89^xGX0y26vH^>k<>XXm$nv$_~=3OrO9d0b`qHMZ4IfYJJ-$H1Ls0}dbT za_L$>uZ?lnZKEX?02cA1FlHJHPX!q9Echh{BLpwrf|-PW2XQvx7%I3hxpzx(kRX{G zD9ib!Ugu?-^*TH7)28#R7m}Z0_%o8D@7QMcmwXm`)12uk+gN9rOw-#o**mmGK?^r$5@V6qRy{MXw$X~E7VG%$(vHR!ZR|da37L>N?+oLn>N`Q3{;8GzA z%+2}$)YZY{7kIuK?$_s&G+Kq}Sohy;vH^YK%IEGLeR?`sdrY99!Z_ zo$M3~{2}L|oe}(OoxwLOP@_?QusF$?5gAbQI(v)X7r?gt0w|gSO6Oc(AjD4Znlnd2 zW+|ICXFgZQ)$nMJ*#i-&Fn`?FXAmRssNfM8J4{1Ab0(3Vs3{;5APjKD6;r!Ajb=v) znu^n{F-=D1mC9#4r%7@8dPg-IE{jjj)TYJDb-!?;aBY;#Gi^9}wGr)qJ%aYOUlAD! z!p>^yUN&k{e4SBgrtB0xoXvHWB>-)n&$Tl>l1$}>;ml|86^&dJeaL${07$#~UDOC; zW!S0E)7TUz@}J>Z=(R@xme-2lbiOPDo-pHm(F1xLhJUy_7YyR=Qk9BpmkaZ7+gJ|L zNPL5=cAA5qO2xz5!o(bZL4(lJ7I;OJytCHV&~fgdeuNyb??XdqIi8rAof9;`8C}T? zAam>Kb|iWT!03X2sc0+RB}NH)%vW)-bom+O$)o=Nh=LvCNZ=;2b=I?>Ha z+3M=H!#4YD4%3P{RRJG`5I5Xkm)x=Jd@Kpi?E4l@&^pr2IeuP$4UMu-$EQbwL-zJx z=jX?t&H|4F+SToz3$Pa#Unv5A6=xNLt;M7okk2DUAPnxTf^!haA9Y=+VBTN8R{g40 zXXk_S_kN|2wJjowsZ2mCX636^fQydM!`ODYJK4VJFO#T0muP31L_1D8XTqN8ZiS#m z{xW;5_@yyy0}B0rLYA-G!lPf7`FG1SNHLE}b4>NlwzGV*>{QKibnx%@@7TxV(}Vv$ z{&WuAuFF2ZKRrL#9~=fAz1N)(i_7j51Y3)#=uCh*SzX<3tI4I;BZ%u~N4%gam$km` zf8ncbKfrY(t^c8~w*4xXE#&~_yH1Emd*C&N4VSE@`a1yysl%qkhCkv++fggr76wB0&V@9zJIghj6k;G zR_@s|%z|Qyj1B%sak9pZKcL`4F+z#!lxN@%f!h>@(_G(B5U&S08LZ2cyoXWdEF(E* zC+(~3${rNb@AZ4n;b)J&3{mb+Y2$Z77r9p5;^U+s-Ri@qKmR{aO9KQH000080000X z0QA(#NV-}90AUyclMxpefBfebOzUyf>7n{oJ;e?tEk~HJTHQQD#|N4b# z8K-gi-Q@4c|AHgz-{5~&@;CTD)Q10Cum901w=CKBzii*B`j>yoe%Jp5#?w{5p8frA zzv92w&1+w(zrlaKfBDyM{iB6{e4>?q7Z_f|Wl{JW{BK47`eCp%e=kAh|F!9}R|QYQ z>;Ic)YefJexeL3S{B|j1@3!sTXmA>cw9hBh{+<&yLIewOMPA#Rm&09}j9!iByNUN) z)^?|@+q!KW-z&Q*c1j2~EnT|@IoMbs>URp25X+EweOPn}5hiM-BCoiu{>mPVo4hpK zo>~jpO+s;Ke~-9dskj**i~pZ1lbz3S`88X*_@HQ1bqJo;lq1hQqPfM>Z2pq_>nkv& z>!r8W@Jv^D+Gn4P+ey%~nLhZ6!!8`c&z+^Rp4^vU1`Vl?mJ#n7-)QKJiQJp|>}fw~ zf(lx{_oWZ15v?oBp6e>9TEZwQpU(%H?Umud+I3bse+iQji?(vm53Bl_Jl9H1&u%}B zYlf~~N?EYOmgT^}t5BMXPmOy_;fx<)gb(sq>#@`%HxannV2;V$6qH7rG*VV^Pmbgh ztv>o)pdGXq*J6-r( zuXztee@ZPy^y4rLx@f&RxpL5U3Hr9g`@P0@RM7U(7|%71KAoP?i|~9R)aIX?Rqfux z?`U>E;~2kPgtb2`yonDypyFtnsl%U;Z~5#Ge{0{$TNlUJ^tD^)Nf_eHm%(#Uqq8r0 z{J?mC*w;)@)WNCjGe;#`{LuVxf|YqgKI`<)e`gc2h{n|KGRN_+FstXWyAu3nt4tIgdi`#xg9LI=_^8USXk~w^Y=1;y91yHLmi!Wk*2jh5SM+`BcS=Xdn4R zQ55aZa2%7#H|aMV_#nrtE6=*>%7LLKK3c}8QRan6362;R?p?u)X@^{k*B#_{Z&maf ze^^Qxx__Q@XfOWjTYEt)U4*M?{OK0+x_o+~^RW&h|XW^3*7nUc#cC96K&qJej3Mprswm{vEoTN0>`-z zD1Ryp>(%hE<2=IR!}i|Jk%r+Q{-7oF(Q5ei7YMb!{yo{k`Z69^vLEbPRSkAs+?gNA z?SDRohCzY&t%@?YYAxcbeaEg}y*AACW58*0#qtZ53IaA=PSUj2Qa@rNe@QRm&#QS-jEr+PG0GXvh8hBip`C#Oq%F6H{Wt!JRYYz*>ckxYKN|G$G^&M0@lkKIh zSP$GLpt+ETp`ho2 zm&b+ObbtmA24lA~rj-)Hwv^dmOoy@#BfbjxKsW8-c_8-E;(+0Yf0omqVT136vn_S; z?}LVqQa!$VZsP~QDJtn7P6@5C506lc5L`0Q(P$Bzz zSSqD)q0E#cU9dL}pEc`E;%eNmUu-muQ|SQDtnKS9l_YF3WW3VKgZ19yIR6lxz3Pk= zJ$IaBAM|%ZYbdpe@;CN}^>Cgj3ZKNVhjSm4s*Bt@LO-uhfBWD98Tioo(jE=JvYYea zxIsQ7lF;_+41DP_X>0b#yY=FK9eY~>cs*XosD_;G2rc;fO8|@Azv`F9z6^}(6%Nu> z94FkttcpR^HqwSvrnhZXTc2(p+L!3;1OPzJ2uiZjV2`9E#x6hQgL4e+2z5yGI`z?iaprbl`FnxkL!}Q`zC-&C7z-x~wWOfl z1$GVBH*7$CpYd<~5gT$f+#f>zCY&UXrguxHmbe{O(-7RQFO4vgZz?KuD^*hU?H_yw z=naC5d+GXN9YHwMA&jUOB4> z-V9Cx|4hF3(9iSJeQw z5Az=33ekHx8@rS}eaz%r&Cx$##u>{kTh{bVCrNHqsA25zKTmyjwy!0;cLK8LDc5LD z5G1I(*e2<9j&GpnHsUaczv-rs?jvYzm$a`Ze@}cASCYgv4fc2!3@)EJhm%9GL7h>Q zz!C~h%Q3DkNu%^}CQfra{nYFUGSwos1gS5ZlAR#+rEVWw+!5-kdaue+o`{2m`;cgk z)ene*7Bu0HLk@X_GyrL^7al)F4!s9Nc(C!C-Px*@`??H)Cz@0pNOUG|mgUN?kBf!W ze-XYKPI`?pr#(bBGrdq3FS-e?-s##KXbcdroL0!zxZ`F11D2sPTADgms&Js&!UgW2 zb2L$2wj?MTPvN#y_?N0paw*iiI$WL=4u@vld)M_< zK1`(_ZYo8Qm9b4P%V6&u(cqS<1%U$Jf1{(>ViGK#Xk$>+A%jnQ5w}Ybs@`f+{W+B4 zT%M4Um_z%xfTjyK6Y)bOpr^xy%d@#&JSSKZVZ2{jIV4mmE~TDwu2WsDr$;pLt>*aJ zDWJh>!;=$DdT~DtloFXHx8Bwt?FBGp5bkil*llSt>&cmMdt2iMR=5l>rIlhDe=aL* zM^Tqo;o($s>X0E44m$I6DX@N`F4t|&ha_639pfsQFQ<>})QzLz&zL1`3tLIXf+KR6 zz6_keFL&=0XGl?YU2t}Ox3?tenj|~A;LYKq`BDwjnX^?r_&|MG9<3FCudW8h#@RF- zrQ8AQ2SG|Je$f6jzZyo`xEvXle+ZU_ZATfvfJLyMJ!D~AZ1B(;ay;h-F zx~80ARP6HzH~Xm@+*{hz$`9`Td{VevVKu^(E6%US3$J9LHOTqpOcz$}JD%$S9@zNQ zyXr!Ef~-$UY8xFx2N4a(+AEbHMS*vinig2XRCf zEa-GY5XXDnC^YzWBAh|Ph}OuQAa*SEb`GG$)Z)5hz>c?a+2Tchxyscu-W-_UMC7HQ z^|GtI2EkB-nG^<7C$qc-QDy(ISCfmv3gj? zY7h0JDACMZ5z9@}_vNNjYr?UQu;y*vkIaTUX<_Y2f}`TmDq#32iw3#BNsl)e|ARX? zs}faSQ51>SiMY~f93neFlh`5cvwot=dgmxT1!ljdiF+cgn6Od#|1y%wVfRr=Yjfc5s%Al zAldi((~DcqHWk7?9#sT{{mCFhq%iYKu$>9+0|=tvM=hd+3o8$JcAi$slQ|R1W7oxX zdF94RRB1o3^}ygge;ZG*O~JvlG7u4e3lPFH(7?chg@4ZW2_FmfT@Mp1rud*3=(D6; z!mG>ISC;j1A&vT^2R;@lo|qi)Q&|rf+B`~=hLFrhqU#X^>;oD7`b5oEw>|?7$V9(k zx9ZTxl)x)X!)VIHc(?a^+n;^$7~gaz(JD(iFzjs&Zcc0}e@q8rqx>Dw+fr>aep09> zUfQ=)Mp)T*h?9-q{Cm|Ohe~&R5X68x1K3&ZM)grqy(OW?<134$GZ4FV>P@@<#9?!J>Y9rQJ>GjZ< zsuW2NNm?-fv&4$l{>tU z4)#oT7_9OwyJEB}VMv3Jh_GdrwmskpqM3H4e|W>pYT9qiKR(g#O zp&7@=H)UTPvG$x`1*$S+-P9UeKMaR9~9)tY+qdZTHRfFY?u`B^*nOT65{zo_fDR0}6rmkol=j>1ozBf6TIY ziIkvd14>ts7P$~LWYn@|xjqcF9}7ycU^c=~_eiDFsFJp>bz;p_(7(CmS(qceE7ub1 zRZ&EpFZdy}ZaGSkCB!6oPF>mNO$g=ef5#PN_Y(Fud8n#-GO>vy?Rp=^+E%vOAiFVBcf}GR+tUY~ey`iQJibj;Rf+-Z3iXKz!e~Y19Nc6bg zI+?HRu^lkJHH@XH3O%f9QDzTwOTZhmvGhGy}(SnPD}Wmgbp- z#ydbLWXc3e)&;?4w2C{@Ba>AM7+XryZY14GwvKo?VL7L2AF2eAe`IOIaOvYPPKGl- z*8NUn`CY^njaD5H+=KXjui;y<9qiob3ZEZuZ855GwmyKH!p|?W-_Z=_9%Ewm9t52* z=g0TAfcs~&e9d&{Cq|cmD^R;UMzYZ`??_KkYr>803&+_KHpXus)#07EBPw%+FM_F6 zb?3Sj-|hl74TAcAojbfM=SJ=(aYyYa1fu8g-0}#O zrXTQS+8dqO8fWQBU6h)71RtQU@ETTSnU1rZxq*NQ4H6J0lhwX}`SIgpUuIgl0M&~r z?qlOcL8yK99`ODfUAM-&{%Xv8a@(Z{OYafu{8CHE8P8d zZ@iHb#R;|a{fmb({Toa8xqvNz?_g#gjv4=EB8mt0hOEZ(i)LgQ^ubA3c)oI+aQQR~ zASct1LBN46e|M_?K3|HGtP2=-p=kJ|ea4)E?B$F*9jf!2OU@3a=Vv$aRI_8@>)JD-fIMZQ{>Q`S3KPX5vhe(xcvSm$G&I`T`7guP8mT zXdofWvKwMIxJ&>Tsvu$i{ERHn$MJr9ij50m)MV8%Q-FxqmB91ZG-s=C%qo~Y0$0lF zh`O|je|tchfByK3?Q7_k5xOpE$2ZM!7X<_99nGjJemhj`J)meq%RD4}x0-;nAdztO z>)kF7W}CNUc|Se{9$w#6$?LYnX3JNF=ff_G;u&zXe#$oG z<+=*4OX(x-;F@6=$gonq0!X#YmqkzC%>P#Q)d=RDY_O7x89*8k%ATI4rd#(V(+yuP zGPBA7)$S2S0d5{-Ydq*l!)m}Eu(TnWwERX_*DE+ivMjr`FlG ze}}xhrMW5S?#bCSmMnG(R0oIzW0p*{{x#p&=c?AQKM34u)0qvZW_2d(&;m1U^-KG# z%PfSp2s1#X?3{nw5A4(J!mdl#aE)KrN+oCfD{uE8@HC;Rd_9sZVh@yDzZZ(?gV|{6 zH@vjwDF7t@}5Wc~PdZg-b5P}9`sm%o&J_Cd6+QVQ`vd<_tP>^l#Nf2z^F z)B*F>ksbF{v$zjLt(>a==`vVk72~dCosEm*^;ZU5cLP#dTK)BU{mZ}n*IfHA!~UoK1P}*3%eHj+5r+znx9NLspBR8s=ece;}PY7b-Nn zy>@#W?U;Ov?X^vHCZKx$zD?1b+O2(j);lS98B^zNQ{V%f zz7#z{xK)wWF=hZi#>Aa_e~OY?z649Nz(w)$6wSIhscve<;BC#uqK~ea6;7rw)pm z^tuW8qxYfTA`*OT79D++dk-9;}<$SG`?l=(h3O%}hOvRQ9a6p&hn%-w5M zUh}+6&odI8)YfJ0R9MgY8Zuy;NYS*RGm~{q!!ZdzrZ7V;izm7Vw?Fn-0XoD*Ql(vo z7R#SQh#Ujdec9?0e}5LDn&-nK9@>~g7WUeC=S7cm16V6l0SfYdbDlUBgWe>o{93Qr z)>yS=DeYrd^BV#&n2J)r^_tiPs+hI>fo7PZ`WpOksN*5)O)+qU%8{1a8hoC2Lh*<13CZvz5d?!@DwD)Iy%o2P^8aF3!dalq{V#Bx(OUjOSM)C zv_gE};-?M!N@_3E*zsCP^Slj znj(7m{H>)nXZv#Evl2NWpz45)i41Jt8c<)tISTKG8-(&t0)hGbYtM7D2ePW3vu;@% zAc^4vCl<4vyI{4&lW?4l**bIT3gcb8Q}sdR^@+nDL z>lF*}WE69QMpf`sJ`u%_f?k3rp4C8NrRX>U)&omXc&z*+)dz!xmI$`V;cD&RsUz8q z26kreY;>TB5oe=o9ARv9t7G@8xdcEHN%N5ij>H8h>fcy446Zj|#Rk@7xhwytlN0u)GR`9i@I^>J)+%eG7Kmv6z%F&{vzXQ#LXZi!%JA874^ zkzvy4^Rseaqc#k(8mz%XAd{Qp|F3c8|A-sBmb_?_bIP^=|4EMEuym93DO20``y`4* z1j|nyGQn!Ph8$scEvc5f5O*7(-gISQxocSop7ZQl`~-zQ>+|v zj94x4`6}{nyg#j7YI$?;J2wjZghU|uv{e`y_)I~3vP#aiUCREooR;fJZiv>vPr4n? zhn|hQFhm$8c5|hherKAZpj@tldySaAlQddDwS~kF#t>ZH8b0S}hRqnNzoUi0)5NFp zf2l=ZW5a25-oh65Whr{g*#uk+8GMpz?f96;>nY?LMwOK+@a33U{z&b+YK!BN@vFni z+(N=JO_d3mPDEJg({rlS4*}c5{pNW&2!OKsoR#=h+Bq90BzvmYHhvl=0N7JbfiIxg zF`#T6A7e&1;#x4bmKPBV34H`sYrxOE(X}Zw#FGI+G{q4UB8m$Sk@ESae@g^9KF84a z7>pDz^@D<7H;XDD6|Y08#|3z+H~N7T<1kzLT%z01ZZe#~S0=U-JqL`AR5_Y$0MUA4 za5X*5{6$#eZ$AgMgof!`K8^&O|U;Ep*uZgiiuQ_Awbh4ZruhAFdHuvp3G zEjf*p!!-;oAl{9Be_gT0fhUCel*dp{0qVt*6HoH=J?Nj^V`Y~T?5ZRtt{if>WlBSo zJDUA=ri~Vn{JHv_9;@@E%E6l4SoB4sWvBMVsITa8v3C3u@+eY0u3@685vgpfKe1u2 zZ1savR94l|K#-*wJB#mZy!_m5sy((kq?cx<$J3aqf90T=TEMF)FPQ$-IWtabP-HxjZPk1T`XnydEX+AJ&)=#TLvTnxY@AgvlQF{q$o_!>-QN?*#FEi3l!$DQ$4}Ei<&g{cZx52_J#&U+yAjA;@sv!nIMn4b#L4p;$(ak-+(5 z`h50w11HvN^h>ffrm&U}1@#3_d5oJMp>KjJwU-3}e{AVhzf_~HaW<#Xw3gOBqny?JgXUNWzqf#`CFx;ouBnv=Wr{w4y((~iptXT9xn<8Utv zm=`BmXU{4BV~!KO8cs{s@@?_+42+hpmic?Ye@8BeXT&va_1WkuAdD4K+dd}0Q}9>b z>!wLr<~@1?lt^)z+Gm+}J=@yap78yq?2CoHjSx2y!{wo(u4>QC-aY*T(?$$`OZXL6 zp02eUd;HFss4h}ZZ5b--v!e3&ru?sA6hnwUW5hw#HQ4gPD{%xS+<)aq3w^=1_s#)B ze_lXT^N)&S0hUOY>0igwpGzN*XhS4w5OcLoat^lhc$klSJg*){=zYpI&gJbeX#B7N zg^(W;4n_(eB;=Pi1;Gc3e~Hn3uQhw!`2EQr_T+DDJjJ;%De}#OFdsw>6V6*{uwmQx zQgpEx-WXS9+>rBn1A6!v+qXShc78P&f1?NO{39s8+=`8~P3w!1{AtSjQ}2z_<(QL8 zw(C5g8ik-Epw^c7iV>h7Q(EouqXSYi-5(#vOSM24$(f zi_S{rPoy47;cJO6O-0*|*->DjZ5B?pf3g6Ldt%YFrtRTEy-B9BYHP^)=>f3zf1tsw z(MVZeA>ZquH@E+!<0QARdi-o}sw0%Bmjpj9 z>*i3PbWa0tDr_flNWaivijgl>e?IU}UM2QPAaxy0D9n3k%jB@Vpz$YNj`vUj9sU%} z8v&wpezJHqEEyI1bNv+u%cQsR#n|G_0y1&43WZ_0f0p!;=k$-^7b(mEe@`6qo$fL6 zWe`*2Ban?oGh0}aV7s87D^vqfW5eHdTsS1ZYkHbU2#^Ut?$+!(pvj1d8KfvcdRJdi zo|%!ytU15h?$JSwA{Zx~Uy0`QT+eC!&!y{z`5$QY_e6=8me6h?DEt!6L-g z1F*5WLS#+c52~ zlW^YCdxx@66J(#C4*hB8e{ei&qlA`=B=qerrmc#f^QToR@v^Kl0P$TAWv?KHfS`0_ zf$V%3%4H=#`;&xsUvDpfbMy;+u3Roh3DTdG`54E>D<6BDAKr9B&pW8LCBvzrGMy*G zXL58RJ4NmET-Eh7f2VyZ(MfXu(m948wS7y@{U`aFq}_>JC&)^H^lzJE>^lIw#6u>v zc%%;p7dWxaF}s>S3G$QyAD*#(YI3|NBVgJ_2H5^*A_Vt>o@vyL-=0CM1+D>;H5Y6- zIrLTKmuW{^9OVKhVD@a7EP^$RGn%Z$h4k-7}8}WHb z{)bLqY0C$?dXT8$IO?PQmUg~Dkm^t>jt_$x=$bhVf4>8pfXCknG$HOgY8yiQSO6Ma zkJh0;f3(a2^xL9+tA1_TvLOqotZNtvKTJI>s|Id*Ibj^WlR|wLkBite&?4a1x;8f# zWWL{kqXVS&oQ2(gCmdPpjL$XNJ!e;Vqi$EbM zFRVupf57pMF6ySNI_k2-y7!quFx)PN6}n+vtIgY2z8%n3zrz5(xLoqCgJXRqnZ|8f z=&Fr=l8YG?-0JU)HSjf6IA2D!8jnv4?g<>{uiQEyRVyVG!YdImWyjLro*4vTI1bY! zNy0devoOg}r47T(%7*jpf2wTt?^^0~p+>VHfAt2Rg!%!uF}b-m-^rV8E~jD&_tq44}9=x~!%7oWR;Jn=Hm>)iJ;AD9tfj7V|) zf6gXVc)C*6JdbnqCOdQ5FIi1}IoXGWI(OMwGxa+(y~cfhwv{XVJ3$EM={nPsH+U5B zGT|9WK3DMYn6#XtX+77xvKRnzS}(kc!;D#%>Zxc-)27tARY93N2nUxga@e=Xt2FC! z%Kp&NR7YNPCz$9|qOav820(fwKsEm~e~5HSCodt=sf$3PYp>-5gemyWcH3k-#)0NL zsZkUoubvfl^66noe(Q+2P*OA3{%McxKkO-h`#CUCGj9X+;X2^Y;Fkj7ydbpP2Pq_) z_MeiQ#1Q2FNpceXpG^{?|5-`GKV{pnKV{pnKjqNyKg|XHr(7TY$8_YM?vDTIfA097 za((!pa((z8`}wC_AO5FYAA$V8k=8?bgp?_s|IbV7aoa!AdYraZD*K1DUi;O0So(c% zx&JM#m$M7ea|sV~xO-g)BfPEly|#jwiGX`pTNa7VS;YEx*s7-hJ3z$02t-yZvp(Zk zuUGj%!u`QjmRgLc1vqtqynS8uMoV`Z%YS;mPW}+8B8o!NF0k`H*xQs$Q>))8PkD z_1|r#mpVXxuotzLEIG6BF2qM3x}GdOwXA+5fCVXAI3bM12)*CJu%Bh{GDG#g;eTxT z+4laW8crn+AKSLz zaPMPB^e({1oNpVu?(0GX>*Hq2Wk0go!N4e(CpnqKoKHn65LrU>5SA2Zl%4P1OL` z#JsE21h)L&1M&026&{jgnrE}d4WOYA#-{6YtVJSrDBEA@2N^yd6r^rw7=|9R15H%( zE7#)!+glTAtzolsTZd;srwuQS)5)K`e6;yG(qW zG@=$~4C}d_^aEUc&w`a1FROhlyIC=3p8UZ~-_N7CC)OW7^x%BHkbehH8;I%0Ss~;R zUNw!-+>85EbYB>4mp$!8M1A6pVR$zYb0AE1e(`LwpHD!t>%US|>R%};aDo3N->kpn zTj7+}U-GSnI2iyyB?tMMwSUD$sgwQI+nrtz{xiZN@&D+^4)#AA6|w)Ms7U-NSP_2; zR>Yq|5JCUH5ks&XLw_l}r2ZLY$?~6xnr8kvtC0GiQG}@q8msW4K>t(XOZt~3F#r0K zCTgkf|KTT1&RF!?j`{4A3F?c9`|p0zgdL-<$S;CDB$P|345NZlB6XxU87&X6~fOH&!rIPaf81A8MyO54f_&m}*sXO33xqs`}w(2RO4sgDeTl4$X zCig`@r^^th#lv!|xe0hsM=~;yYJbkKt_}=YRTV^#AE+n}xFGKv$JLF7(M|&c6JDzQ zj#mfyjqxSCUJ)2!$DRMby*gJ+Co#UAjCGA)gJg=L#(ax`sw{tFwjLDuR`%?kj{u{J z%2uyB?_TqJo`0vuV+ye6C!L@Av{v~Guh3~i*h9s9V@Pk6Yb$`f{a2;coKC{&`;@yX z-slnsXh=W4+md1X(omS?h60d%1-_A0)GZW2FtGI*DYh?&z_15HLv%q--%x!V2eEDE zrpk1jAE0%Ng)1=>(Q=;m<>^k(JOZs)UW-Af#n7gO?SI!aW$G+Xxd~#5@R;)7QxMkO zlFoeU?q6Hwzb)*%PrHe%SFBhJ2XTxC-v~)4{L&y-o;B^765-T)xetlq>I$$sw`#hp9aJ9?OZ9P;@Usw&ppkZ^EWv{;9LI$GZ{(SWuA8MZS zj($&+tbYMA%7&cyAoir6EjxXt;JA_Zxz_N+M;gmybq}ABBw5&RGXIU8HphEqn=0<_ z-yt!F;IPKR7BNP+0#V!K?-+tlGSD3W-OgViV8%d#0o~dKT)?~I?2f6DcMu$pm7WM{ z7=GH~10*8K)-hH3Do3inpNh#MInRM#bwQOSWPel-XC#E-OX5bkFb;TGXogW=tnjt$ z>m`r8OA014d1^Y!FWLR_jxBoL7iM9wgcNivEJT+a9SEQIxSoUS+>XIpukV@u6}*9* z&*Nl!iQJg#e*2=@$P3(3WF7+N3BSckx|Qd+X!ymnKDfOMsYsr!K)iFq&>`i=tF=Aq z2!G{mmz-0FvatJr_)ge7WnZ{S4gN=_V*fj|+(57ORH`Xj20_!-_k4$ML+6c&0@lgI z?_c)vc|oQ&#xJHm;yFyePoU+rJ~(@IWbxmYi7LIeC*U?Ea8!$6{NG~+Q>aZ9NqLfR zat{?N{J9RZ7p9)S!*=p))fpy?;T+ z@y<{xc!ylXYS{AkSPn8rCV)F7>K_+oTB->c#PuUK#wFm5W&{(9_yj5YFmt-R@qBKP7g z$VQcJZNa!nu#Jek0Do`dV&aeqxBab1hM~%g-hgjLGfD)t`t0wb6xaH< zb#j>eXDx>v({FW(R^x3-nihU5z{r8+i?8CEbtU@l{@3Nf9E;}-#w7^KJ9vPwk4BrYCf@ zI$owPSrEjGXtrR*=FV(s zsN=Xi<0_lwyW6<=4rY-KX4T@~oWl*FFox`aof{ih_((YCqvX9gmqYJeX(m-@Kq0K6N2|q$Ph5EFGeQY#jc4W?SGJa zQW!Nmggnsr0MR%?a({oj@JCLulGb-)X1xD*+TL^5ab-&yd?2DhQuM%J09w(A60K^)Glr9Ei#$8R>aB`kq;^yqA8`qhb^h}`oJ)nd`O>- zFU^e$R6)kkW|jbtQ8-p{1{#_`%26#%1+;|1aRifVg09r0n15CNka~%wKW*3DtxP3p zNc;Ze_TVXs+N;7hFt2pG3TzN4*KRJwUo% z0Om0&VTI6W0Apq3%qhX3Fxv3*nN1_%r8wkoz zEV@pKh3JYUNC%5jZN?7~*{01024`}d=q=xNCYqvpfjK+C#)0f5|9Mp)wz*a&iQTOz zT*9ZQICmSAQRve%p7Ponb*g&eM_3zc34SkATyw))s(+z8*KDH$oS~>)6|3^Wf{SQD zEOmU6G^|lF$IX{(uEW4}g)p=Hx-x!)m=bye^Okz%$!rexCr&TSBJ`<{VGD&rMqS`M zC%OLJdvLdYIuZ5;NX%(f5%8y|12h^C&>Z~u>oB!FiuWjFn~#GqRGw45P5KY-dO-fE zTDm$eE`RZMT(5RxG>gIdK`P?o?4H(lJcD>861UVRm?TqDzeg?0GaRL>@)asVsy$KJ zB)LY(QiW&=s{5UP>l$Z)JR-~P_(P&+r39DjTHgnh%fB)(#quqfNGOf46ECJt<8o75S?lSeC(0?>MJ{OeNuouyO3lbEF21<*TAUTx0 zra{|45HIlT3`79<&ZIuq25=ivfprQn61DHe-SoAfcSCS4jT4$s#zm*q9PW!XsLdBm ze7HX-;cFFz^jpDFf%O0VzRG_ zrhod0(jMiRNhSWXACP2&Jc)jWFK^m6zPh(}t?^?8094py{UU5t6}Rn@ds_ApPcHjE z77F2OZ8?+W;q+8o9^3{0r^W#C2lwaR^jMgw&kkl%Rk&8AS?$nA+h> zl)%CB7vX9RN@XCg2l#t6tdKSaIE>|p@PF^A_Fe$M`cm|VO7FhL8D!5B`krtO@F(;8 z)QDM)UrT#&VJAP|1KPcYJYtd4{yjNnd@EC0Skc>}=I@VV=VWUm?eJb?6THA6uAglr zPmpJ9K#Zsqo+#+?IiC6)F!_(ZTgdVc1TsKL8^!UHN=>z1A*DN&mwtRr0`szCK7Y)O zlUt(wvyEZyWhp08fk7AnaP2MKs^&}vc#?rg@_~UVGd}brI2c^EO8^6%smJPu;KX^B zK&EbD-Te$&^scFqEvt zxP~{{XxR8M)=DOVe0C>tdfOPOUwc-y$iMg*nV>Y>o`UI|8V@2!oYjaz(q z_818p%a zOCc)h?RtbajJo;4EeDoFkAWbP`n*C#y;P%jzAL=DMdOw_2#ePkW}k3Tjx@A>e`1^u z+q^E6Cce0NJ4y){)sCifxxCRR-ts(Hj~%w}Wah5qA7=`-U4sHRX^nRI_dcZE_7^z3VV_(wf@|-Q=2m%+T?Z5w+e4n$35P+@YSvW z?mmj($$5)R!AlkfyCr8BAO}xx_)=NZ~x_$Kq=zo#0&Ey z4G5XKAWi^OI4)_LWq&Y+qL0@9^*$IUi1Iaj`jYtmd#FG82_7Q>F`sFV_nMhCoR{kN z@|=a7VzSMj$>#e*kltR^&@2Gilp7dj!<`dg<_87l*C4NwNq{(tVUEhTtW@6+u6jMk<9Kj8oT_kXL*_}9AL zUtS~rcgvC3zkjM6`L~U#zt&p`?B7v&Oz20#L`d`>QH0_Dfj^k!KNy6<|0AWd9FRhW zj0pT+QhCJ9|5AD64?i=8zf>N_ptrmJ7OXA*X{L<%j4lEs#KA)M)Ujw-z-6J*Eb4() zDGz%LMHZk1+@NC!(nC?aCc#s*+Zm-YYv&0fg`}@3yMI5TGYnysU>UwI%aq_5{m1de zygMiA!9@#ewf+lAE_$Nr=q%qwg`OH#UCvm8+=gy$=+C8GxcfZ{FPc^%-QO=1i~FB^-_By#Q(>klg(|(V za-YYyE`N#pQvMofxxp(PnlH!Tp)KidVy$>~~x!lP45?R-foekTM zogXkJ8@_aKn?V%Tc0RaeKPmYaxS`TuPIG#q0bLyPeVo+!nJA$+Y7~Z->z9lkz$Cp} zjb>AXq1(|Aw!BQlxBzbOi%0w}OmF13>A~EP=6}{LQ6F@!8nasE#M!e6ZD*>*7A!4; z=!qMNl)BM6%Dp*tEhySv9c?d$8S@*+mu5)mlt5* zn);J?Koafdrwx}rY030UoH4mb>EoP^dFd!fQl#OKzJP2Z$ULsyA&l>$wO*5~ z0)Lpd=4&r(+EjBQQkXU~w4qTzcqe6ra#6{=v8{PG%7Cmt?toUh&zw2+Qt`e`C=3V= z(0Fs}JlI_qNbQstobMQSX`rJ8fm@iA_-U${GP*;gP+s0el}_2_CD5`Sl2$Nm@$POI29UHRTqy`99LPNU1*$-NG# z4qu0HUI^1a=pnFp?G0@g9ECq|)a+(po^3~D-yfz=;?FfJJLAl_wzY}}il#dg)1-r?A}K+yFUC^=rTyB|l8ApfawCWR!se_a!~FUP*%extK*&?^^beHE#pd z4P%hB3$jmV-69f8^&@J#_eJBA&VN6fHw9h#?u&_%dlqL+w9+HbdKkk{!0|hPp{!@o z@J}Ppip3Lp;CP(IRVKDN*2)-#_Yrs^oz$SoXXSQwjNd6O7#QltnNIiCXHjT=;#(>O z0K`EcILVCXaWF9Uh5-(gz|sXMY^~nKlyK{Tvze%N%jZ!ev8VHO2=^W027e-|Itc8O ze@yK@it?D>X^pX76$dc)`$A;No@Xt98JO3^hWXtk3^d#YNBM;1fZc^f1B}P}N@kN) zbHT>K#HP{b7HLjQ{<{2m+g8~jVYgNHwQ+){=Y~IhnQTOrRi+3d@7J2AXC8Si4zji9 zg3eyTlii=|Y!$k|Zwb2yPk-}#-Z7}95$}Ob!ZhDi2+#jrx}HE+pyz`!rrTn4@%-em z=gYQ11PC5_ab9`8J#LZQLkRxN8?3L*mmosML@*E*J%b!P)nU@aa(o}{{y1PxnwfS+ zyc$3EN_4~UM?iU(J4F8Fw+G~3cZFv@krrp zIDWc(mDL=^Mh<&5TYp1jKFVw%xus;ktv;ZTcZa%h(p&Yq58s-?76`tdKfa79WLJH-{O(ToSFq1uTmtt z2W1WJW0^+!*NEj?1*~B^J!_0T5KEq|s(C7a@!>+bk7N~}Sv2oQBp@D;7WS@>Gr^3Tdm1othHcvA7y`raT~&Qh;oSRKX_{#Z)=N;c zfj=F%=zlfK-DwgCcQUYXU!w-n>$n_6%xq*uxp^!7#QzbTf54EjO3V2syuDR?Hp96A z^bIy{ah*}<*LzaMdQ1T}!RvQ8ZQ%?RS&=&L%D|okc8|CB>!Uc0S_Rv~vi;35d&FI} zn0H(FD*?HlJ!uirB8+OwvyrA-pKu#y3G~amjen80Z5l@qk74O~8{JYZS3_GM$%3l% z_kjc?WT;|0qATFP87AE!;y^rbec~qmq6);xTNI$2U;#x|9Baht{|;NnIYt_n+=L2- z3U3qfM#?b#w(#?9SZrP+xsG_b$ zqJPr|U-e=aB$RKV8Lag~X_;ibsI!2x8U+A7hfive_aj1ukJ;-!`u0~z4YF7MwRjWMgE4!Cm_Ey4(eU*dw&e= zg^J#0llT4K701rSyH+$+#nMzu%bi;g0%nokf;hJ4+7{4IX50#PfT^_a`iO-e4A(mo zDaR8((mdy+VO#)@fOF%T@l$vk379tVpWQP*UNQC0Cjs25x?cl41p-ntuUIK*X!NDU zFpP?^h5G3FHB+BUZO%khz-SsEL4RThquOSh$m4m=wX(ciWc^{rLisXX-`s)cPlP|q z?>KM%boMAThvh1ITu1z3FHi@@00_FhL$hm--$JZB5g^*17W&$x?ei_c1o?yDF9UvN z;3+?Sh`@#;@kKq)C?t#4;)lJH%^%S|63fTf7uub6F6O`+yIO9{$Fpn0`+r%nuyYVg z!EM?m(?(6n)^libm~IeM8@OfqhEv*wkA3bxaI;XpWPDM>a(S189MHb3)e?TY_cxk7iX#eJ>K^zV1d{O)>c4Ep*KJt?b?=}l` zHIC!8zd^p4klWZymJU5x&wpDGYFZ4McJbLs`LKowB_$c{58)4lj@%5BGV31YVJeuq znLKN+9QaI6;{X_vo~6rH(A#B;n#Z>nz73rTl9OAA9TxEm8C^5;9+!lAU*E@_DiJb$ zC))EEqiI0M?~6v8#ZXOB-XUq1IMZET(F5td+leo_=i{>+#;6^mPJca-`(CTWD9O(s zjqAEB+amW+H^-7SF$pEJee);Q0^?k&NFpZita_qbJ*gUzgV@ zz($#HEq7O7>>;1>@$REf-Cp60WPO;G69`kcX<4~{4(3W^{@H+6Ugc|Hk7q+E-vQcC zMyIf|A2hSsqb$W1Z-3})cDx0Uw{gY2b3#M$yHt4VRx4A$r zlygihuGWGnuGi{mKgEPk330{GuOwM!lAoMMlqBm{b&ij-sFbxvKzFJI>kd`Uk0A1z ze_r~jSG!lCCcr1Z0S~q6`Oa1!u#GoM%E4n8&sIAOxjRdq?A`zy-ChFz7ok&1^s3XX z6+~Zuj3EnqQ-6YSbbCe=uk@H^rla$TiKZyL=C{N>yb*1?d3o(%`Mq9YY}gXkn`X9* z-N5j7hmmAX((<^1<7YY#mqp%!)q=S)+8YL@#~{`g1ZLFsx@hbcTcwJRWdsQ0It5F( zSusLkd)+`L=(9&%ZS`PN=SI~VGuI`UJVuMwoc-5qlYhF!`uA9vIlKfk$aq*k;$e8b zshOsz^`6J{eHhBUOYZE|;f)U~TsJTecksd2b$9l3!^a6OGm=e8CLi>J)!9fgBIGWD z$QMd}rPOC2fn%@d7kLIRsLfDs#@+`^sVc$jafH)Z{Jbai?ad2lyYQ%7cMNMYy7v?R z2u17n6o0=z#E#C7Pu-867&nFqsZ0BH^=DC45y75Grxs~*h%KdLUWM5x&(+q9Et7{P z$tq|CyeuJ7HJUl8S2OQF1t9n%@=>IFTt120m|$!laoJ| zaYUhQX!%OZumYjE&M~E(o4x@BBIf67;rQys!GDR|szl=()!@Q~LX8qd88^5&!;k+$ z8E^cWw6vE&WZJ^86^-4#`eDt~7O5)jcr!06Vl>Dl9ano1nbQdDu79}mQv@Ps&h>3# zA~?v2T=@$O+#8wYADD<}khK;o`pEwH zyMIcSnC6gOZ++xt%)S1ee7s|9a${CEs=f57YV@=6(LaU7luEk)P(L9BNt^H6*crTfC%7YBo{p6fHYfp2tgRAi~&$z30k z>jj|N{r+j}+qZ59=8Mw~-H^p=tSl`k=YQ*2hltX*Yk22m-4k8_w1m_x6Kr> z-=asbhTB_g>pyAbZUnbGzd2QzhUIhlHj504)qO@lmcvee^Xl7N&Y~l2sP#H+-r-LVT`U6xj^M)j9J9cnSjI!y?FE!hhWy-@&RrOQ(fNKx9P5 z?+Y{9?CdxlHiOSHi~aUEAfp!mle{=46OB_w#?0xSX{`5KX0~cekMoJ2q8#A;u!Gqn-)4 zn=7|BBcX*z1z#t`CoWHTnF=QGK}--?Rtnys^22#z{ymlWfc(=UCajAr0fqcs-(h}p zBR=*4hG})Qg=@8J6Rbs^d4Cm*_}gM9YTk90)%NIr)%?zC}sn=aIfw~hKAKeaN z@I`MQPOLK+gzM+a;2@vKDZe_B?XE#cW-o!C*|t2%a_pN;SXu?^3x5#LHNK6a7jN+q zEuT<8qQ*KftDNaL@R^?AnQEqq2C~vHeA^sQ;C~nW zSC9aqnx-&p$Jv73$@ra%jjF4Qp`1$njecn6uVMZsFk7$a%^`Egvio`ipKB+Vao2k1 zXJ6RVaRielBGB*d27g@_X4?p4HA;?u2A+970VcFZ&lcs^Yg5Qgm+61hNG6)^}pVv*Dt?EB7ssM6n|JWMe>WIPzb#8%O+2ibnkHvI*wju^UH849~K+cjmuf$A9gM{}(M8H&m+a{Y6XG zxq+~b;QhSI{AaJfD=AN!&W=Zt|E9_Mio0jA>hSE%X7GN}zzuxWl~(gr`_dbQACi^D z>{g7#_GcoQ+WTvJZK-w;GL&s^m<7YRWaS=}ClkF04Q^Wuyx3&2;6%DNTeb}Eu#hj; zcXFODJ>D+ZD1Y*>egX2pv?-KOdW8d&6G= zq~FK`HYRi=xs+4Ce)r^bohy?+hXwrcBAh2MnAWW$ihtT;esklS>vc|XoNKcQpI9!r zn)BPRupYh+R@2tHTntWYJbt_5|8%(XP&B2oZ8~9M%Oc{F02rTdus@+NrbRTqe<3JW zIvGEZRK824QTplZad0?57?$Y-A$9^8&Yyml+F80MNm{o}6htoGbT?((7KAbXkOD^w z?{vGwpMT3eJ8j-wxu7N7kSU63AHwdle9nrcs^+gdyMt?hWOIKeP$EWT0b-rDd;AGd z$WrlV8{EePY+oWblL_O$MCfH*PYOji%sfcB%M^ODlA! z^QCtWU^@idPxcx=Cep|n#c{B*NX;@m5Z>%?>3ZzKtlrT2Jwr=>J&@ZH#5 zOl;dnDV!Fmym;If0xFM&(eCKR69ZXE9c}RCFQ9UB3xM752-{R1(vP%f0C)^95B)}{ zXJ8ke+%iL%fNm?t`>ejl^L*U95EboLsedqpzY@%&KL&#Uo_Sw0;~bnoKl@OR06=l| z-F7a|nP{j#9h(-6x~(`*WO+q^6Fu%D3Pu#Eoh6x?plrn;Y^{dSy_a+h%LncaUxeie!VpHXRqgAj3=VKi!?HBPy1ND{*MCO53gs)_ zQUMeBR<0v9b9Pe3>rC3)jRZ{hQ?qc5$(C=wylX8XVDR`KzK1Sw{sIgJvVZ3qpYTRO zc#r%LGkzL2Z=UZuY-gqeflat|1n9HJ!dNFQAE2%*Mzc)=V=V8G%uu(dT2+pEa%J0h zMAKViI=>ek=>Vb==HZE4)_)se3Wfi9%AUVtxX|!hDA7HoYZ@bBJ{z~1Z{1az+P5oY zPKG@r_uF8nU5JWG|6CLo`ZyRnOO39K>357Jt#p-w%JxVI{DFM7Da)$}lTl&MCLUJ@ zEbJu3qk_*tcy0w(gLU8K_0d1>lb5lF4xq;Ch zY~qSJR)s&0SkfH#aRS<4kNxq{9hoh}W6tjmXnD1q)dX|)+yGL(bX~;J=dA~^LsjC> zB5LRsS*K}a;O$uEUw@-*gW3ERlThB?Ncmw5*0?$t>f^aT@^w!OI=#S}K5y=XuPS#i zAjXKx%O-w$*#3rF;+iA?%rGByI+x4_1QcY%ofG9kdgU?YgZbTIWGb=yq_O2RWj8PE z2I7Po33W)9vrrJHLlA4MqArhs0BHRUmUHDDlsfm$M-c~r;C}(XL!notv;-ySZyJK5 zw@f)B^|@&J^As*9pQz970t`WBWVrt{R~!m$X5+M$#a=Jz&#S^`{599yVy&y1%UBx! zlFSMa-FcSo*x|{+hmI8bUp%dC3;;;U9Fy2dz_48JQ~!MZqCXC2G4OhBn_jL))gHfh z98g1a%`ea1y?>@M(P#1aut{3Y77gd6MP|(`Cl?VLHa*FDkqBO-4NfCpIQ~$$MUjzfHAbb*;^N3 z4B<*N!Up&8R*>5^WXm#H?HRa-Z*xt`i7X zAtOr)iT?ofc{4F9GauJpeHu0n?&FIlw*C-#uudxN(UN0ftPf&Yg@kG@KMPpF7H>Yy8MMd|cCTv-;ECF9Xkm>>KiCBuJ5&@K+Gkc~v7Gcnes@cXV8}L93U1 zBC-J&1#W7D34fB_4SjyO_;$q?oXh(t*{U{6A8<<_a^Mt$n_naZ-$eT`9(Ag90LMO_ z?0*GA1U{*-NH+32Vq->7?EdbBa;>}KJIk4xd3kDa?yJK%=_Hck4V620v;x4mFdH&xGpE1un!T+0n_DcAELAPay(0}~?OT*`4ex)qq041c%^!>ifcPiwj88rC8 z2fg}xR`l;BA7ZYDdK7edQG`=E;evP`p-iJ)x)_!*ks4R7@GA0;G<(5)av}boA#@w&edGTT0aj4r9y~++hfx?+yAX zs{2#FJN6mFM=I(eS(0=gRs#szow$c!_VO24=ZprWr-2nUnryi=0yMX6FHNI6^#qVj zUlmACPNq+#{%#n!y{9=>+*=x95fEoW01Ya9)NZ#nbt|&(Ew&lo$KBBI9)Fhi^o?^0 z_NZU_=HDDud(FEJAj2NqEew<=v5`lz#@aD|vtiz)zBW&KYS!6<{K?(i?c_UvEpzidWUlx4s zo`EvH^@u4nKVpXd!S0++7TLYw=_^B9u|KnL^!OB}ENYtN!)_4{-hbzOhM!%0HLcW0 zTH_BE>3TmI#{uiQ&=jsBXg;js%@DWqXI_)r=iyTq3C}V7G(5Immn7UbJQJNFu44gr zFebn7GkYypGfi^eOJ&IStm=apue%H+?f5jDWYWr1@IH!5{anK9)3#6=Vivib(3@GF zwG=7oo&=o>nB9FAH-DSx9J;jah>~;LwXy&YC zrJ;lPI`4}LZTpuY!+{4i_jYLP-J$52#ita8bMC`AG8&JUOWsooc`L=mi4 z2vbha<>NP4Azap4!+swfo_96<>zqTu;s<-KWmw~RY+J!wxPMa_U+}iV+AJ#;4VGjd zD@EqKM@TFijrt<|6@}YtYSSNsmNYK4p1R7-Pob* zs=Ym?E(t{=Zx#bq8hpi2fUwMXsD2w3ww|n|c3F!N-@*kUo8*^7qr-e0VKU!R9qgLl zjIlu8>$?Ezw0|i-=y*VQ@P6LXa)2P$c>cE9PZim=s6K@tvv-yH%i0#(sTRVo4u>KB zam`yxod+OL>ti_(+K1okQ}^H8Fq~QMcMsK<(UTy<8Z{b;+sBwe&2L86i<{F}oUrVZ ziU#uoALGE_4G*VS%uT@|!Dc(iT>kj*mF>Fk`%nicuYYkCk^vO}alpir&%Nj7aCI-)N-=$fcPuGG39$S!gNHd&z%e%nqeX3Qu>9cDD~ zHk6B^5a}>20CeD-6s(IlvLg0i3Ot$kJsm%~%eIhihPpzIwXVCV_*OF?X#{M{#lSVs z;p`C2DSr`9fFDn~Fc^m0cKO3X~64GgChC**p7@_;z$O2Hu*2Sk`RmFadTvo^+mpu>s%fMx0@k*swMNldh z@9^sbf@NRsEGXt56dYoYa`RxgrYqlwixcxegnWAwL0{z0?Bvswtc%^VV(X;P%bVAn zg@4Sn&TZAc^7P6P!w6i!S6@L-7n;1fdsV<-+&&}& z)v*yzZ^C}*)aUL`V>Sz6?~2l$bHq}22=l$Xe@hphxj|o-ai4U#GDtQ)TkLU5U7>9x z3l${{^n|Fpkwuq4}FXnuYzA|&RAE*Mil*#c+j*`kWgV$@gju_SN+p%kH;4`DEJ@%!spzJj7eE z2bHeNw_S>wHcAgrOe8)C8ZycEu)PUi;moI0_J1~WFI_g;-}@P9Pp%OaTCd(OMrmFn z`{_lpa4Pnruw?P7%ykelHtl6pF@Ic^wq;9XD}{SnXQKlk)HU^4L~5n`Ave9!w{O4G z*U4Drrn0=Uvrn7kO8A_0fvD{Z32k>&wy)JmNhay4XFHZFrGAOmxBPkfjt5RBuFt{? zMls}qKn-43bFV$iDMH?27EjjAolqvh7#T)k1u8S{SOH{gg8!_qoRUk1`r`D!dQ#uN;|dbSs{yfOLi6c7PiDj79!;bV;OwTm zp<(KK2=eUSXEGAWn!fG>JAc1F&qbbnlKDT&EtP`42%1P9ac=}`DQ4XMc^_*^n@q?N z3f&YXrnRD@vWm;4W)@#2PnkY=YKn*#&Iq2?6L0;h*L&zIpZ#gG9Vg|!x0)Q^(ve!v zz9@8YR1>T~&=%D7%GBc>{4339?c`@kJ_@AMF54%oN`(dLRcbgoNq=B!&5{1Rqrb_U z4e@rqXwvz++iU0Q#1BBUBR3S30F9VHZxPh}O1Aq8ef5D!M{>KM=DdA+CV7|IN^|ye zfyzNvpziaKSTyOMYy@?`Nc<3<$=fQ2Hx76_6Hd$m$0znXs3EO5YtrQoF|yd7LAWB! z_bDfdMGzq1))3!+V}A(7=Qf@)TKaWuhRLcE)kcM`Xz--B94yRlT9 z2Wt|P%saO8(Yz0L6j~f zQ*4IYUO~+2dRS8-HNDY5_z%3FOf0@Cu7q;rlDB6|>9p&1{b>#hNNnhKz=q6yQX}W< zIDK9T>Ws4h54eREZ*KbOuEyqaQp^g1=g+SM9u7c7zJSQ?`)=@mPSZ2UDzY3Tl&v0b zYkl|ULAR@*@qaBKHE^2cHFFYi{!X-wW6y8u%e-qWMZ|$=73Is)%x6Q-@`09<>4((GQC3F$FL&atQq6O354^pHXvhj@{;Wbz!DIeyGLr60)J~8wH=QY)^Q#HYo?r7d0E_FoY~g0yuxmz9(31af zFwKMWMTFPvBcCDq`b}iDJbwtot2@9O{&BE_jGHi8PBs3}D*0kVqAAHAV%yADI|z87 zWdut1!hdjdH-|TP-u&EI=Y*2_KnqCIwp{$<=8}xMgx2-d<3L>+3oA0CYO5g}gwiry zI$9LR9WWs zf`=Oq$-$#V+1(|OLflM4k+g!-8qv~}rm0+=HGhQrG;*W$KCz*P;bLT|!CY_u7JWS_ zxh`X5!nxj(=zT5+>c_3UIupFvAC&qg8wsPBek5!m ze1F>h)0B1y7br0&G@20-c|42j$H@d*p$e>X;g8>KckxpA3c)z;j1bA43g)W9@rQBGvEy*V~VW_Qz)yw86TCt9uFATdG0oR!g820-9baf z;d@;twszMl?sG+AmkIq&-V2|USYT@IQ-6(n>F>z;k)6{Y&bWAG-oF@j{MthT5{nt_ zj+!Fev?cGMWZdLB=Gm*DKX7G^_DzQqe`3D@Y?F z%EgE88izW05GF&P0?As7QlO96zjai1!ZB#M&nWwVWE{(9`u#x2oib_wufOX6Ob~#3 z6JCSD_{t^>%sI@71e5qU-6>B-NPo!@6+2PvjM;r6QhdrwAnD%SD>#nh0AhK-u!aXG z$~OWzWQmIcou0h0Km1kM;Q)X1-HK8D0X;vWiRe3Wykos__KV}@XITJn^QY{y?+$l! z<(B9E5J_>jUtAxSMJrgl!095tM^7bCi^di1pM?eH!a~>O_`qBDf40fz?|&sy;-53M z{@*_O7X4S9eM|nWV~G5l2{idPZ9Vn3aw_$=z8~tZ?Mi?9bn0)PPW|oE>3@p_HHK3X zLJPvb&?5AISx_7BIEsI18ya8N)0XzTZY%v)i%|W^WZpqTtZWs60)VT?MDAnSp+r4Q zkzMS9lvKnc*f{FDGD_Mpmw#6qz#===rg#|auMP2N5W-^>eo==hOv+EU!3w^y8ZB?+ zX+61mGwo+6Wv+zue7cPpApV_&>!m7i^(>$mOaU(796~KVBC*{JYcJj@O(q{dpP>XN z!aa&3sObuDlVU+PlNSH6Q+`Z;gR-BfPY0pt7>wq(ht=M~?Qp}Xnw_F-J&k!%aVb!Dy$TCG}MjvEQ~h-Op2-KNdA1Un|7 z?LJN6DO1e)u&dbXeTM0Zc&Nz>?QU&qMtg! zP=HmP=D3BTx+R3q-Brwx_h@?Vr!UAlL$Uyd`MFP;JnX@>m+z2zzn%oV(|wq`#3N7h z7xG!xQ5f}mkhkFa6&V(!n4j8>>*>2<%CZ&#FDi5Mx;;pHvwvoTTzw(cEiWMQ1+8Ew z6%$kCiJpRRws_|-J^5c@H7yLIC@NMSH#+4E_R&j8k-M&(Sg0I2};2!9%shP>Sp zA2}x6b^ELNbAKwUF)$nFZ#3`UyYZe>CS!ls#C@Cc@6*U~fy@=Qy2S{#%43st{Tw?~ z$LKM?_8GnGH0B!Oa$8v)T;&1K`#=?J= z3lTcN$UhG{GhQ3DU57a7Whq=RZ0Lvjjr5lNzC^{og}-Fy5`4v1+Ffusr-Zs-UE)li zfpc^wZgCA{mTwTg*7!$oUm02e%~)0W>5%OPpv3EhZ);8n@mdUV%Gf}k<~cj`&$jwR zegg`1rhl=9bT*1I@a7wx(~i!MNHHSmzvf&GE}3Wfwk)n?svu=g??lNiVkg|Ytoo~nqfR^H zR&MkFLqNR0&3;t(J3@^iN<_YdWh67mW%5482=w>f9P&qa-!PdNB6Y+Re|PZX$8`#2 z=Z}+D-JcCU9?Wzk&6Da&z(1kf$<**SkAOdis(%apRi{+tV(+8S{gJ_=L zuZ|*#GU}u|Eh7-56?Ycz zTyjF);rILG#C`HjH{jW)5y#9OB(CQ`R3s1lfG18Bzb^Tr?)qnr1=FXI z9B_Z_p1Lh@pB8ds$}Qye<^2#}f%GNS{XWMBcIj(3*k6UlJTKn(9H%p#Rg|HMAMmyZ zx_sLfUQjxLATm=K^0iWVV&d2P7Q7_zgpl{?cEzp>FZ;1H0M3>we_O`gbKTsLyGd^K zz6OYEYbdo1f}d~w02o+;%R>cP49|0aLNA9!9_G?BHVJg6$@BXBH{zZR$R@6-AQ z`sHE_le-dc{)YG|zcuTwmCZ~yr@~OzNj{{X35Aybi@En&c2!%lML&oKynDn+IN_am z!-E6}@4o(Y#@;7x#Xajp+={A-xHHx?OLNR20X;KY>piozE5q;oou>E9Uuu!ZT*!X_ zQ0py~K~1}WSW{dkc=*l^F6s3aRpooPfvs)wL7eJUPtW6(ge?Z4osP2i)<_ZpEbuM* z3M#F>b-yVyIRgz*98@qUMbeS_>V`8_s5~?E@`znNC?Oj60yMvM$$IUZdwyX09vwea zSK5U<{vqb=5F;w~)35Cg#$9_BH^_g)OS7kGgCGE>o{l;PT->4M4aO)2af}!L*{{85 z;8V*wX%jxm{_1@q+I?XHH5D!T*fc&iGINOrZUjryI8Mp6=~V=WsFrlM{#g(99_BsI z6UJFMqrrL=_kj0#py8F;dbU>=EVOq!n{ zY}0R+>&)PZ=C|shL&%(fEV?rq_4>Nw2~XH;?LPL9#;%7JEppey_ayx+FT)LVp6`}O zdx)mYmhEuUxypWVgk{}U#T0*~D{jZ2PaQ??T%v1DdVXP3$0ArcjY<2yJD*g9Cy1aQ z-gz&NoQUf^debX9m&Zp?2EiUp-Pb(JTZnJQ^NJufwv9hOuab?Zi-I6FULy8Dp&Vog zIfNnhO_m$ovC!m`Nt`NNqMD?mHKl7e@%&7>VMylXu)l-p?JP~5H64F8AdV=@k2$jm zBDr&4GD_ml_VeN^Nbzq=c9dJuSq*Ujfr3tqPxg)w{t&!YkSv$ zv3gBKY+w9axcB;S48o7%mC6Shp7i!0)@h_hS@7G~SF4)$0>8SHW3w|@U{W@V zwvi;gOucXkKt07_m}GykK4`x8d=3Bw;N8cuRjK>zJAPzN*ZRxT=9fsODJm%uWsx&n zI#DeHe;=ZL{0fmA&%e)04HQm^y(WfTPKqQxSNa;EVN8W!We(O88MMEl^^TEwKO3O; zHLQS?C@=TR2|VwLm(9lztV*RmbIh*ql<7%C>7$9lxrAomvf6)sw6ZE6By0sBgr9vx z)}hZyt&pi#`mUNSW786MB{=fO;B|QJL%RpSC+vD57iFU1&@RXDd!NfZOpZdEpWjQ} zjB_(%c3xwH{MAm)zGAHC_mHpl)`?AtNjlJK%MhuB8}Vp-IaGPs%=jP*pxTfy1I7wk|Y{{3SxpJeyS zb6V7(4K&9@s9#T53`Zj=F;s=xFOuxz&}sIb;6GDkB7irnm z=Y0_*ZLNp+C4{f~7;)zVp2M+{qXY<(7tAH-(ctd2gv86dma9R{cyY$Lc^YqXo7tOC(I~oqd(P| zAzXCfc$5!NmIyKDcdDE9H6Cs)61sy*6>>W*Nc|M|l>dIlc$Qo;E_i~-6s`#6&wJ3; zZ9=nTehGg+>~0_ZN_N;TDILA(g6Pn&L;LtF0!m2^CMOOBZXaF zSERXuh=)=u6|4=}d?wFIZGtxIe$+RBwovipgY8u8b_`F(HG!B^a8;>^$upA{9?)7 zSkEkb0Rp|*!}HI9w^N+)H2`K=u}BZrnfA^XK22^_u+mNe|Aw1s81^sHl}XoIq|4o<0yK(#c=}RnBuy?5Cm;u?p`nfH*Q%o09(CY);+i{a$J8| z!smgsTU3(t`zOtF8Tzu#i-3N~mu(%Ks&cI|L++QaGeMvUKrcPwmzB%iOadDb#FFWk zal9Js;HI&O3({b6sym74H9ptKL6_46 zBGC;JKZ;&6ry;s4B z0i}eHpJci*`JrHoc<8aBqi>$zI8`a1uCvDiwUb?83A@NKPo0NRdW43uQ$xb2V;MbJ zWv;Got;ED17YF(3(=!tnZpzrYKU>gwt9$i!n*3N+e$IHM@s%{9xSqcb^XGrx-qGAM z?&76k3FdlThU_42j+o+)>V__Ug0jQg3!pr~&J_9swhm?;&a!9W2t6`|f26bSaLVnb z{(2V{xBI#si|22JY{GQgL+Em#TF54uz=69TM+=CC|00x_}H*+ z+N+sCE3s^tx@!182TP;7-m`xUzOIePXjWUE18~&zK)PE5UXmNWw&(xK@Abxr4uQ7= zQV&kN|BuL{{@2=B(f_;y;eVF}A@fh0t;|2ooHGBk*~_HYP^}ukp9`lbPj7mZ1Olwb?I7csWivSr+e8e>mR=k zvd_&G|M6Pf;nsFqBbKk;#c=+rOJshe z@+sqX` z&j9F+mKW2N2fBa%n!z;zMKo`=myx5_nfJ7nGc1&1O0mf6aa6I=R} zX4hK>3>8k|annu@YOR66}I<_uFvti8+H&CJ~w_-be>QTamBXTvl<-Q z^rYc_S{;At1;qXoH^;_%yzBNazS}a|ns1h1il!Es4g;?<6;!cOmo1n)?gxL%ZrxU0 z`_0)QIHDr&K4QFz>DD>D#ZaRD8ZcecWl*;891kHFPUGh-$poJ7L}AOC)^Yco3sZJp z=N96r@zs^qT_U{ye8gl6ip~4^iRGBj690|x58!`G>9h7I^ry3t-|}O)agPNZS@ZxG zYCN1UsK)J?ZaLj2^bLJHt|GHSlXgh5qu#e~WAW*WrA8BZ)oL{q))91x5g)kG9owe#NK}pa{GNZVYmwEt01YtDhL3vXAE( z`N0JD0iNfsE+KNZuBZw-6QX_~FAJ zd!LG&d$9MO_N+7gqUmX|tgZj{B6@$A{DG}3TD=}8$P&+K>MG>*59C!=(}x~ zSEDNSr{-WHd@B@`#;!|OM6_SM0gL{}Dn{@Yuu*Q~vjU0!Dz}SmvLb(6aF*f??^QjT zOJ@*?7VJdP)tBA(9N%x{NppvF;Tj*tG?t~VCBh^5R`^yru3U;TTOiYq$EnTirngSk^z4JE6l6TjBA(r0oV56@ zN=oRBmbla}^j9aIguQ={nTcm>+uaTv;jutH4qbiu;Ms5SN;h`TTsj{N;#bp-FOHE5)(r+mD~lJu7?Tyj9PO(;U`xa}w(!2!Jq(!ghb``9m^LcE@XmvrHMy@{&(5 zMU6AK*ZbZv_o*!Q=ijHF44kcw;vuk=P!NlPD}pw&gyHM)K$%w%lJ^S(1s?5q?}0hK zc0Y()RQf*7@y2{gu$eAO?du!tx}Y!L@G4?`Zqd}B>Cy>2J?bH5)W12Xo_v+unph3~ zEWkHRyL^9TE+1`UD3fGB+-Y{mQcB#`RWO@<4D=RP@6xe^Utht}e3Q@T_jXtuZtG<8M22z~@xLh>XId3`|4rp$5S^Ex$ z=Hj=a&{UOCQa8~*%0pJIU!C0|!u7#Il=UE%j>-x4@hhU9lwp`Sjs_Gb>l_2K7X-<7 zlGY#ZG3ZSw`AP6~g)|u0q2Qz_%XR=j=x}^b?tOrtw9m;(1u>-b)Z7R1TZQE)xYA&^9P|=p_t51S;UOyeGf(h*hJp0XLJ-OwlUaJE zR2fAP0ZmkBE7m?rD>~aR?5T#2eNq6kxgvk>BwszKt(z5#`lEolyDQ_C!T`@Sksc?N zh}5iF$2f3qgjie`Fwk|}|E1V3@l65qe<`YH!3la6aoOw*PNXJeORITS~_ z2G(1UnH$dpvA!$}H)HNGIAsb-MK?+?BQsrgf^5D@DmOr~?32@4*KQ|~1tR&g{w{x` zDa(>P7lM(qa#_Z@Lq0>Ie@{4D_gSsy!1derH4@+wf2{yAD9vhG;C=%p z4>pSIuZ`-y&>;6L@qj}kUM-DS!z5L|Gn3XI!0j3Z&BmF{*?^_?Zyf1vEY=O6LjhVR z{!o9>s&B+jxib>GG5BoN(F<(_>NWJ`2r@T}I{7p94k09p$4?_F=0j*@jBkIKZEc8} zIyChwSnoj9^^X#-{%P;r<*QuNL`?FEa>c|T~iAZCk4}%&`RECip z@ZXBuSZG7S2BMn!Q9{AxzR{-y!Tsdw>-YI)E*uUJlg6Nth24L&V>2vI^r5s0lt~MJ z$~N01bZ_^){5k*JCi=BstBprX^3%+IAHTW}%3 zjK2HfEo-X79(;fFJUxV2Kz*zWuPR8zDkA-wlsP?^BBabTQm8IVj}Y~3socKHbLr3- z+ACK8c|Cl{@FZAq7-(hgmf!GMN)gY@UUGkL=kfM+zG%uP{VfK8rCjNAv0P9Ofx7%4 zqB=f@{94XPa@2oaBmb0N`2$yjGtxCHwm*%y>QaVY-hi#-6xkXykk zbyG2u+nLyFOtALa_@m8&!Qr$&+CwlqnXAiL`B+(kB5V?HcIA1g_HUNaH;wlSx~i#@m8*|j>FI?u`?OG zV(#PaWCDNOsn7fOrHE9JzeDqL6vnNUh^`+1udD51O7oC7WetLHF%+FX_RfB)ocl3} zMmRzxe%1p(WXM6+k2nazhvllZ?+q+8c}6?}mVdX2a3cT%N$`9p2lzB>86hAvOyl!L zkH~Jk=YMJ+PS2F=)|^WJj@pIjN7TOR01S=a?TCLU+JP8$V+8slPi|NHXSF}odwlln z-zH%u&iloK^2UCi5lf`-@bND*@3d?~jgCNWX<3rS=FeNUT-3FP59%wL@`b{;lOKYE!%hL|Vh_j##Sk>JnZEPG7YN@}aliq@Uf|%e(Go^! z7Jql>2fR-spBvoK>1xgTuOWWg=GexC;=z#w9!?xt0gvCGdwH9f$(hqp%$vgczFj*! zv-e2YC>rEY@Ir#56sZn(-OqxqJGZI+{IY-EVMuG$X~YM~z$j!Y>-8_pvACrluQm=| z#9eS-#2MsCx*kLhS>8vp;r3^%p4?3pLck?%1;20m1;uk!eB=Sq8&O)aN)jC8qxb@T zhv^dL6+0r=f5(=~mcZ*eJjDDfDyKHjAxECE%kJD z6`G~&UHAe6;iImaAnCmYN!N}zMyu%~a`mJB!)?R={Ve0qpUMu(um0HKxB7ofdi8ka zN7+<{l&eptZi(jR>8qWu@>9Suk{^3Umx7BSjN@x z(p2wC*Ha%PUBM;w2=MrUy6snNzQjZiUo7<(-;zZ3(7UJQ(wg^lokAI64*j-T+J+7! z1X~ii`Ctyb%4={fVDZFTOjmz>zkDRgLeRg}P;@mF(}#RB9jI z*In&S5dL#Vrr1A@w_xah?aUPWPoJ4$|4nD6>_1%&`%lV1>_3g2u>XHFc7h`RBXcLB zfC>nY{P)P!y8C}PH03s{TwechXgbB{79G`}oYa4qJ3)OPD&@4;VspC);;`bYC(qTK$h{h# zrTvX-j&__APcAYx2W;#V zN#xyGx9HjhfoG(ixGG6DPf|4k^_}*8Kfd-40a&5hmFIsHP|OqioP-L>gy?57U!|}3 zV+iNd{u5iTlUCg=w$Eg4SI*a`<$vH;ZH;JnUH5~ROu!kvg=9J>35Q7}%Fn$i>DbjR z;Xs+Eh>Tf<#YCSy|~)&H8ccouDnNU@^ajt2&YCpFKHDF(xo&%#t6 z`vYs{7S4YZ%I%`w%%k?T8_CyyXZ-4Ki}@G18T?LU`%~%!Q@anG_~F>;{JVGGLz0jj zq@~q5(uHEQ7;qmrxq7WZF`z8T0Mv1k> zRy3>+4Gq-0fpA&a z1lLLS2}9(Y$xQgAUkXi9Z1F2$xRzmg(%T00=eH{XJhYi;X-o=N%(pBr{kQR72cNoK zAXo$UAH7;YCmM;>-@QfHj@RVDpMZZu|H)A`0+=Su7fsgR3(nb z*Wxp=mD|YbUMohF;Nge>M&dcQM?+AE(?qjR!H6RC%)Y8wBkMhr$H^cjCS>&YF1xBM zo?fKth7W~n#Qn{06f9RU3;6fAb?2+Rw97zbZ|r1u_5#RRz6;IJ{ezMk)@px;xBWO4 zTXZ!id0~kW)qb_*w-?<4uEZS+I$uF;g2!g~*#pR5+EJ)T-4k=AS4Jm<%&$5?HRw<6 z2z4e#RDt`!G6m7=0Pgi$=d)X47Tzqr+Kbe{;3s=Nx6J}T`ejS_59;|{9V>J*zCQCS z>N)F@h90&uvo0Gm!!a%1w61?KpBORZ0K)pTVhjICW-ZT)A;@*o?Jsr9JG)8XTH<;O zIX~>?$-ZH){~d3IS55B=mn-i6X}oMH3SIFJRa8xHs59pyE_q4T&#u3et*jtAR8J=Z zH)DhbUeYjFdrLX9c1S~Hxphd~F?t+XfYU7fSlG$3V3rAjFu=kc%GZDWEpGjYCbK19 z#Qflfe{0P2-R4?&xEWbRp1*gPhHAzt7$v_L@A&pISJh92?0HyM(*lA^y4>KpV-W^Z z6TE^v=DZKQHu!3FmZhi@XGns`O_bxC0K;*s?eEHp-5Gp%VPtVr!-h5|osA z`4k6?S(#%Q9^w|P_>JEzLO=^Y)9&a$ceBX|^@aDVKH5pMk&Uw^+zy~(^)*tU3 zaQ6I(o$&ffE*O7@;Q%gYpCILj;gt~1I1QPwBTVO~t&%ka)?_8B@3Uq(hqC+kWnR{` zGlI=#J-+TUMsFYWa~MLw{?a#R+e*3|o`j?2hPP*C(9yv61kZdqg{+8RiW!znaG~+1_T%xcYnksp$fBSRF!i zPPc#M+He4yi_+*egPjENZ+7ztrPCc=cd!34-Po`1H>Bv%&zrK;SWs1FilS&XN(8N7 zNcs^Ol)lbarP%A|ZodO{D-68x9&A|CWEbbqgM*j(b8q9hyP@hf+O*`)PFVM$DT~u6 zwFKR~KP~m+ycrXP_W(rw9eMxGz01kn#9A?`ryzxR2@}CB(&A<@w5AI z*MHz3|MxSEv6eee2}`;6%>3Oqcc1&3+BKmgE$LyRJ-4Yy~j^DTe( z>Wzb#EB@x14qRT&k(hB`UpwdreP+tMyASU9d01*=(N4;U$6^4wC z69Mhs*FfegnoL1TGo~z7n)l1aA1Hqi=MN3<#zlN0nUKBBhyOOj^XKuNeN7*7T`rYZ z1s{%Sswl$~S<-)~M$g1c zA_qauRlUbmCbmdDA*p?(kqzbvAZY-SXR?gcHr=MmD8-f{ZpWn(2mrdA(5*fN!z_)n z+Z=pu6FC&53;Q+!ygM)ny3rj$i#;>Jc$TfPZpZWiyi+&==CqL3gR1tUqY?ujo&6J_ z3&^f$X@x|q4FUL1PUtPs8oPhd9G}l?k{7;$C0AcsO&Gjk00floJ`>zHvV~Od{;=Ra z(5T-L0&x0QTCm%M`EE+p>g3j~eGb7x_qYdjfP13*#PfX{$U1&C+@`YD1~Uxl`VWmU zi~gtFO=p2HJ+{DT-lM9hmY&%prfd`xxJ?+H0GJ&vvgqJhN(+>3*0z7HD48Nl6vQ6) zesI4B>*Grpv1__g58=p^Y7o_!zm3u>r2mjCHoeA4hUVaXH`4~sCVC38LN^~$qn-tS zu78;wWT5a?)gfBO6~18I`due`$>g71am`qI&-(j}Tro9ZTt7d7w_nTsR9;hE!AsUY zn%om&4UvH8K2o^1`?!A_k2Za0iuU8kf=sXp3*-6ceVUIQJTvF6Pr?tZ&3iPl2eE*I zRSfbmw1ivvi#F^{6jt~{o}b&}dS5518?cnGD=fQWaEbTMyY0(7AZDrNu1gFfXP2Da z@O`f>^x~;y*)|4mvoUb*6QnUnrpLRL?%oo>YQ|Bkl( zjNXs)VD!lf9~Ps{;(HMD1+Er^)$tI7nWS_3k#r-M70?^~DZ=LY6)!yvX%5?WS4j`9 z<{w6=E2n4^WGNW8L}4B$b=-QPFL3Tb(3 ztST^vBn)r;gy4Uxx{1akS!<;iGoC#Oogey<%O>~b_}(g){d%2P?%^bYm+V@qsCF2U zsl}rErGFUOZwk@)*c(nHJn3OxsRvW~;la1;Y({b%#w4Kw#zp;g%{W0|Dk(c_tR<%y1kX+L_?le6} zK0Y4bwk?3Wu~7|^!`kkzVma}0g(7x2ODNI+>xvhdWs2T&->FYeQQAi&oLFMv9ezS_ zbKP2GarLu08v{dRg|4;k{B_^cgP0iz+ILV#M0Xzt0EqeR~_3vLxpT#)AhhxnCIgs(3JHgVl4T68Zn6nKOqYd0iO{aN%EbMl;(>hq$rsQ;`i(L#f8r%~1{Yu9={I)5NFXuiZ;#}uuvO~4)2;rh;}dtTw?b1OG2NZY>2E0^In@9b1xd?QZ)-C| z&D7s*cQwCR<-Sjt^u29-Iz;JQCtz9rRyBegrYHaw{455>QjeNAI^^TRDQy}wm9wtq zj9St23{(;I*O#FdA|sVdF=ksL4N!khSxXMqW+?5=M`frGu4J#z+6Gj&zo@*6`{9Ec zg*uolZ0S0{2+9uq;e@*%PuKWc$7mF)N-^u}1(shIwIEu%2;_@80`b-D^GOE9!$U7> zQyG9;mpAkZ&!X#%q*kwJq(eG|@!^xRV=^fG$gbl&P#lfD(Ik;|5!zAO3iwD@5MBKbmnFJ~VFHd|xbOW!U^#@1aQx_Zw3x@(Da>S!n8PMI z+Ut)nR)+5*&r|V@t+Ogf5IhC&)c{_dM));AIRaZP@*t7%!T50T#ki>9I*>e%EMCu? z-p{Np%Sf!v#aJ@Cw8l%$h2?+ES?-gT+_ws^XjG8($~&B^NP5ViyAYdsYn-CcJmX{j zDE!4K&F5K#x_i%Uan=5-J0w+3&fbN8)g9!nJC%|n3k7m9_37tZSIYkpvVrr0404)W zXr9|803rr1lD=r&_CvE-J!dqBvFuVD9&ar@K)mp;88Apy7j-n=sw{sD{^a(vvoBpV zo|%Ji?=Tl;@8M~)8xg#d)x7x44xg<8G!BU-!`9$f9Y1==Fun8V6qq6wn-(fj?N>WL znw5sV|7wb&$%sKfjv$CbtN3v{v84yn;8#2uBuOWp(~zQPi_vLf*=gPIrJ6AfG%3s&o|{* z)ZziPiVSe^OlDlfzjO3+OH#?PJDQ|KKe^tL$Wyg=4;$QZENFjnzT(;K)$f5vF7Q=2JH8Tw#*V}ye*3dm5n6%%LC~p?r@rliQ~S!p23U;ws1Gs+w5jm05<_v zf-PbC>V9(Zg;)opS&}7YTkRO^`Ek!}gGnmyQ|um+LX5*K>?`Z6+G6xS7W4t}8v(G@ zpWniQKkv)vu|R*A$BGV%hN1hh@re0REyeEpm1H%WtvL4G8(|BA?Fu&5otOe|;`8Hx zT-YShd3#{=LiMnRhx1LJHxHN#xOky;(IPfSHi04~Nk3ruH-3PMe?FyK_vGHT#=^5( zsVQd`*)ziL+1+iJfV{DuQx*t{SRKRqnf0TzT2Z+{DSLkhFjaNGmVxuGgJ1*!fTzx7 zAv)hF^L1S`4fu&i_|nkLuYsoDU%MBLsQXFJ0AWz=wnel$?{CP^Y36|Y4VLZ@%r`AQ zBvnds_41D!HawjwF3eZur8@aE^mWHW3NGM$z4sDqE8P2}8#Iq9W#ng+A^-)=xU1=J zh^|9$wJm=jnr~P&;)>I38MFzY&)XnSa~)1%7E}Wk9tz(nTUAqrHk3NR=+--#@eh+Z z&C82dXs%`bur>TPbx%ji?8hRD#ypzw2;wN|fUFt{YMA>s^<(xV zUiao_KVeLqL@oXzdVQqU4U~riZ~#-6ngC{qI?sRfx`gYW{Ggmf3ZW1LX30?a2Y{ic&tb^s8p{<9ck{wwmyG3(aZDjb#hr5ys_IU(d7x zVN+RUCSoRr`9cU)ek0Uet(^}wR;hRM!;Hh#UY|FDddvwcAI|RHoDycOcS7#>ea7mp zu7!V+l&#;#}?AYG3JreJ07{3qy^&uFhJ>*Bd+e^rKNZsM0d0B5* z_Teu>?%x<6x_n97-;@qr@a<2(|1$7cem;Lo9}n%SIUINAc|z96t!K{dq3z1&y_WNj zGy&+r)AvAP#~fLQw!f#X-%t9jYrd87dnVNK zS50HN@(y*Q3B=Upg%(`n)lU{`{+)kk1Agm&T~PGVPAhM#HBr(f6R7jYd}f zZo=yd$gEe+_VWzVN&EbEiv}-~w+~MIbfvRKbt=CWxj?ZMU1Lp8$@jP3c2s||6@Q7X zXTc6v8I8oAKI>tBZU7Vg^a5`wfMIu(^M3itB2Y?xe;ko~kj!n&bz^^Ng0=neylW1? zQxnNx;k5>58M~^x&a9gbPtS*QV^Acp=3OU>!V6i}bR^AzG0^1WCiA46waUNsCpjd( zq)7I?&wI^gf(vA%=jZ2OAfA7#Yb!@`*?x&O@?bIcse>SiOL%9ocEzB0Mi+R}zetD% zUs#7diBg>wUO&$7s_-rN7nlEL?bjc_{zZ_kN{_*r(dINZzg13`=dTo>4pAI^QCmE* zy}YLrrRGQGXqh?%?}A<$B%b&ugD<8vjT4HROssSqRjT5}#~UF?^mu>3u+<#CQ2BzQ z!(@&&^Sy`F-+B=bT2URId(qV3FRnl6YRnB3h^RJOB{ZC^RBHsL;;PRriFr4I-KOWd z6YKUvMb=;so88|I-qD=>H**`u<&+CR0FqdmjXZxiG?Ckrh=foNRxDZk(SM3x?o_{= zt??WHRtJdH$L%%W55j+A5%2A+7`qQi`TF-=1VAMY1vxhI{tUef)}gM!+uhG_F?St? z@CAOnZx5JzpBP_g2o?eNh!^ZgkQ!X^E_29l?LpF>HX1F4fWJ!wUsiTg-)G69Gh^e! z9skv3L9KN-*OEB!&B6mNTKKKZ|9mCB`O<1NTy@LK{b})&pp1W(9|E#&zj)fbHUR^m zeN)O%G6%%8uy%RzAMIooKJFg>>XTp$R*yRlzz5~Y@0s|>=}Pe{>t#5de}tfxtDm%2 zVul1{TtSKnFLYa?@VjpV)mgoWWc|F2J&1MKRMd&e4!Si+5;!L;K?2x0E1k7qbUg%s zoY^ecGw%iq6DxmSVut7V0RU=p6;UL={}+4jwFJ46WQlzcYz#m`KSCw6*7=suNN6p- zp1{4c>>Y0HF2}lu$kM1W`dB)v)zf#y= z!iCw=@b-K^7~o(^AXr_i@sV>Kzrt`P(9Lv!MV2{#0U>{iJ3jicj081A>X2I8{VYiA zT{di{5h+QZMoU*y;PT`9_nN3zmWu6sy+y5{CpR4tM4e+kP-Il+nRhPH$6YMAW>I}k29<1gLY%IoHbYX^qUJqeucvCoqSJMG=0+b6X$ z8%f2JDE)t&BZ2j&l=T)@m_d529@bvTySZqCd6{|myfL54g|0$9Qfh`MU0e29DkoN+ zZ};P$iXG8F*JICUH@pLKkOJZs zUvG~Td^sB>=Cszjj)Kx=`ffo}h~`&wYYHVIY&d`5zwf)TQq8i`I`#PCPfvXk3dx1+ zCW}!jQF%f%i8;vad~NJp>-`_*X3{B?~wtKxq#ieQqfIq%)jE`AdrwW=?~Y$}S9B>FEf zRZ8MUyj0qBqcMr^9ijm_XM0lfy~DTtSYX4iD^TO}^E2eMCGLY5|S-Odp= zPtbGln=Cy1jr|SO*L4qhPccDYjlqBPZmSvO%Z-zFL5&Go=TCm9qF+TgwZ*}7;KKd>$tnaq5$Ri1b7W)U&{Q+`d;(7cv-*162E_gEuR0i zNsAe7bKm*)J1hnB7x3O6{4|PYikOKC^Y@%!k`O~2+&mi2#)_I$V0xgm&wEc0(H8Zh z|5-5?w?5J zyiywCZ(lq_<`G&WA$JQ2Xnz~NO9nxc;P0cK%!dU*F?sw7FsO8K@DV5uxNkqS# z(SPdGvR{zE)SBkxTveTYesXX98`Go!n8iWa-%i4Z-vSOGxLjlHhxJD#DnE5pdn7w(PhEgbir{YYqRIimC%qmlTP0G z;SP15ZY><2C0W(OK@a8j{pAfim4UHTJ9>FZE8h_$Ltm&xJ?nq5+W}F@Q+B?!Q6T}6 z{F9s&WiDh)Q1@sO;rFRvPQW@yV!!13i{gw&)llrqswnO9N#S_JT;dj8mnhGYC+EFe zs@X0(x`G~QPbq5fEx$Pmf_mzE--R9fOO$5-RY0o0+rU={C=I2|8(*;?LWr5<`8yn~AR(9VvLlz2mKXp2SV75?6W+saj6M3wh{Y`jg z6?ZX;)O*hJ&U(^+UNa1=gY(I6k~1a!F4MLw-1tbdVDGE2vaiTq>$qyd(o8{%>usG< z^uIZG&1fXoO%#B{*z4O+7>po4-83zlW^YVI3v8lE#onvevr?1~*fwq9w9^42^HyX7 z1BGliE{wA0yze)59mUSgUs;0orC1bz8xTW_kv$d#cm9@t+YRq?LoP?$aApFUC%Hza zLd*1?b?uV~&8FDIr&>ACH zrB^m#p2buC+ssFz8mCD0hx8;)rP&cl2o>axnZw1TI!s1CTpw-!6o?k=7)nu z(H`UNZP$}>Abb)KPwtz*O5?svo(43~9Uzi3v%qyP47)oQdE?UYW}bDd;%MGUCg*+6 z-rV(nc9c5{&h!E=fyaCgOYZs?y%N^kt|b39|8e#|l7D-(g#?*3-4K;}{LI5x5;W zwUjI5SytU1fWm93TPV9{&i+XYR$oVK>qT;Z`wcRatt^y}Sl0Uy$C`C#6~y;@PISL# zgcW^(!9Ah4o1fkjiVvvby{11{WWj>Are?Qz@`(qo#RC#a&YWklyf&&k4A&;jb5@~h z8O=)Hzha2ClN9OzD||;1UJ|qVnX<*-Q}!{4`wq83{ClbdE6_I2(wag46@Tm4K8GH*t?~_}`G2%>NBVW9;9^7f${giDh`2XD~t{@V`#ckq!P%PGZoN zmev25oHXA!*JCuE(x@ko>G1!d=%~DZ6zp9jCGgfh8D7wk&r~s8^>y$eTj;ltFLWCi z+qvGOI&vD&KY}6g%M8v>#Y9b6N_zigRw=E0&RQm@q$(L?2yufzDN~z-ktK6O0GJ}* zpZAX>n3V=mFku}TDdsAbM5(LvU6#6xJ!Pm!s$9CG2t|W*ju0T}mG(PKQyqeTZGZ7A za;^*$MXH-i6Cw&Uka8OqevqKt$IZ1K^FrMLduiY>1(E$?G!9Ff^-1#{HvLh{LPItZ zhln6y^+vNdauyFV=R)XBYP-piAcY|L(!wcBncTG!nnP(&m}bY|AI7YX*Bg3&S9AE=;0>z;=@WLZt#L~h<01Fv-8^Asw!y2lYa1wE zy9`t7WOXbdeJ`pK7fcmq#+I9!-X7L9qGT!474~e>H*VBf7-<~4(#&Q_)S{iq6H%lPW?+J zE(UjZPj8Ndugjal37+)JvSLmd{rxY-J(Cc+u2NK$I_LlY?*Cig1!=Pk`??toPD%dh z;%Tc*Culc8cH~%Et3;#*B7yeVSD*UHp)z^PM_ZIzEg}*Gj7@`9l9ILM0Ai5K6v~e_c4F&%eVVhwHv@{f{-`=Eh*Yu5-U))c-CVx^D@G z`-It8_kd?-mA_8G8^!R3oQ0Hc;0$?-Jfn@RPQaTU-`ZP;X3?>KEqCxt7HcXQPDI%% zPZUOVS~Z4x)@|#4mbSUQa?53TioBH^UhqloRA7TdO^KWh&9>om8Xq5k^|#Z-eo!T| za|H=;DeVab(bI(|rZle|~SX(Hex>)tj}nkojGOOpi;GtW)t6!#2lzTcEr3oq5D=U6ZWX15>c ziiFPbc5OsUpHhgnMs6-x-AZ}d9l4@lQ!C+%xaW%cd0xKqkz7o2725+SHDJSKe89C^E zw)gCB=;8ra6JOa+$@F;hK9-3;y2Oa?Svz}M{Tl&OtoxCqN$&_!{lw&{9n&K5wt_jL z-yFXT@Aoe8$sN68TY86ebsi@DvlK^uNg4_g0Mdo&BepiI@2<}_{Mlzx54Z1;HcJuv z*|ma78hF-!3Y*|dOz^tF-q_WKhIt=!u@DR4g7@$&k$l@>jrY@7@f{a;u*0&*wa`_m zhPHFf>1FPOI+HnnoP;DvUhD9@f=|o(5+hKQy|((gqkD!H-enajp>36k%x>u#bS?2j z*$jJMN15mIj9JBY*sqHOC_>1;-!+5g=k;knZQ7B4fv~~kQfoh3XQ-4MC;dGdc%|q> zia5}$($;UeAz#T=#(q&0LMA^iGP_J7ezCq9M<8kY$?{KaGB?#>B<9>-u8|XE4v)f2 z`DX9y8z98FI(Z!c=Q(0z7f&saX~Z`aGBxsUA8&cIq**67fs7}khlPBAD-P#fkeoCs zR5G4_ZXD+b3Od;#2-y@Gu3c`=EK3dA`l_GK%)~8GJqz0;j(3^B#=&SXYn)6m9zyYx7C+Qn$Q83_I-U z+VJ^%bN0_#jRyM`i@-qfbD09~6z*S>)@@UNiCOY2Rk*t5F*Lu$iqr;7+j>y2G-dg_u*ur1$M-&arzqI20$V)&PyD~#hTj)_0o-2yS$o3j4*{^@UjT3?iJx~&W})LXO+#-!ZP`K>~+ z0TVkHOm#H>3x6xqi1lWA1E-}ogIF>H(y1+jKs*bE@%pb24f*F#)9XJ?+h6~GGTQ$7 zBNlo65sM&y#3Bg%Ux7N_9E{N{`>!G4e<_5}q3b6057ZG* z8vm+qLuWc;a{O<+M7tV(i&cFc@9{TvfYiHUMOdpg!bhdY^VI!A>X39-L2Y;y(no;;dojqwEr8gXZ-TUi#*FS z?aZA+1$T>^k6x+yBL`AwR#DNH7NKH7=zm#ZlK{5^8(Zi~`E)D~wOLV-ur`|~T-`NCmPq!psD zWGuRD>aWAf(jD68qa`1I{q3g)){!j1&;A|#p|vP&(LZ*ySk8jdcezlrZT(!1l_YD! zqL5)N>GpnY{dMiH>c)hftRcg^p`d_1i=}YdPS?z#LofJ|@%7)4bh|Z3C*2(k>L%l* zPal--yXr?}nW9%aM%T9}**k8ZPxbK|Nokm0;$OPBBmG-2%tpF*bNM3=4dYr6mP zf<-BgfQ0_F1$=TL<@a0ZD$rf)x|*@tWB?W1E@|XzB`f`ZYHD8-gbKzD5NMCC9 zMtJbmgtq2J68$EA!Rp0VO7O!s0JKBw`ObNpJTSdN*;E_|Rsn?lOEfpraY3BXcw{ zmXLEomIpMPxa+9{)Vp_pIdp$Mkc4sW+Ro%Fa@(1IAADhOVof@a#N#Uk2*wYpBHhPC zjFDmMY|$}06vc^#@`!X~;f`t~e+;IQ=M5*ET zmDjr3iEFmLv88(Ex<(GpNI>dv_6BJm(1#?v*Bc&u#Sg#0oR-eF1CNExhsr;nzGx^c zYY1e2;yOtH?9&X6cCyhR(LdPHwAjm2D-gaai~6QFB1tU*aGLS$mvh5n=J@?+hqC~P zY(uQ_!2l}=U?ceKDRY4YsOZ1jN37rG3t|)ot7B)`TVsf2^dY+MXA1DpmJX?;p*s6P zjpOJk0*@*9kgTOi*Nkti3!ckmK_gq{M-s3=BY=->k?hN00 zhrw-@eZf5`iyWPn;>r?PfM^Q(y3ob~%Z}{)AOPASZAc zjnHvijF_rB$mG6}Ptl4b{6Q)od!#(_f-in4vO4rqliFy1$J7Q0w%#%Eu{cINXNk)lvy^wgI6?%^>Y#PC&T4MuY^twxp1JAkkLl58|cMH-?v+v@U7 zz~5RJjr_@1c}ar(u}Z_MKJ)SY`2@IWXpDjQdxGH1;eM*B1xHHn99$_e{L_bj7t$Lq zrNehDRBw(EadhB)$Du~P*fy>a1|No=rlD$r`@D@xlWKaQ$TX^al;wnATY>TN2%=#L zDOdl3Kw|iWLk>B5@*4=!*LM4WkOwU^$Q?bfc1Y}2h|QhE6mH)*4J!Pe9p+1V-cudc z$d3Ksw9Dln)%Dg0dTFeoNb`Dsay;VdJanaEiloq+vGQTz?+NF2S2)^GW@1hc*g$frDwc?evd2ny7KA7C2BD9ZebJEq)yCCF$My$ew59#*p zkp=&I-)KDVc#k`>(pU;zu@b|vg49HB`evYFWuRAUL`Q|M-|+qATtP+{jn^c(_w8n) zwjr2uSI#q|FvWNkI(H6CF=&RkAue!hl;+X~=hFuEAW8L`9$3;z zpM-sFe_i?Zd;Q9a0n@fD)>U=YRkVhTSy@7T&!Uq^@qB*+1{b0l3@fvS|XnJ z8D3HBQ!-yvN#WU}e1^v%e(592OVWNL8-Lt5^jj@sTw~gsCes%Nge7)g%ekMWVlB;8 zvzN_lcA=%6{Yrk;kB|IziQR@30LR13lV&A(5xoK38FuzZlb5`QH?Lb6pjG0;z_sEV+X?_Th_s47mct*E>p1Zm9wIhvchJRvQr2b=}UlrT(AiBV?~wt^cA&cU&HP6 zeniKjLs+q~H*6M&WFJtQS_weZi)VO{AY78Czh-GuyF|CBfzzkZ8wbm-g;tK-Y!y?_ zN#BCtCFS2gI~T+RxZ>(3(+Zsbs-K4ITbtzrOp%#Ttv~a|Gj6c#3;dJ_!An}6 zZf?4nS^y(|aQAto`U%mPtnSAuMxxa)h(y~k1Ibo;(tK*AtS2S~BYO8|9KtRVM1&UZ z*{&{cFwh}p7IU9&KP#o3p%x>qoVdLZ)J5trn@Ia~3YuVKGgi`biWJ0FGGTtrM)7%yPam0C4c26Q_#*v3BAx>wL+ksc?n!+PRcX#4V<%kUC7*)ebKJ@{6XxsLi zjPB39ra=BQ!c&nP&B#LLT_8>(rL7^M|CFPDz`uk7f=Oruh0xEDoB+1z0PA0>-TfYw zn+SjOmG#!UjCt}M%WEW>*wdmi-^-e+5w1gKp-y0as8of~}+<*5OC!s^$0xpqN z+W<`k&5?l$m}K_cF|jbF0T7sKnf@$+I@*#GS_!P*cw$mC&JK6&>4 z!Bt7@KOJYVe^s3MpX^QlG0tFr-gCx({wpF1Mc@>|^Z&xVP%ioRh!SMy!u$^r<$mW? zIa)*iUv!HDc<12^$1pG$LH`ED8+#1j&em9mrn z=GUC9|L(Q!)rd6h4Jtt?(? zIh+CD1noEgzFHC3c%hom z_JZ4xfO`AGe%`kAw-GP^<{d0MQIn_x1$W=Kg&VQnV#ylXeI_nAngk}a|4g;>7|D3b z{XI)zPj+@xOQK_hPyT2KV~-^7Q=ZX>t?*2JUa6@w)o2PzyYCtjB#?Z6A@#h!PGwt| zBA=ICQ9}P)O0g^wk=+O7?pjpUe;^_%SOkV(3=V!(4@%y-9f(7UF}$jDmr005MHxL7 z6X;+NRVrHKX;b=jg;;~2X>WJ)Par%6hr*ukkJf1dbXOo!)fHdOolv4CdfT&$s9?OF zmH1Zi`z~R>wbrgNtg`QaXMA>rwk)Q!1e9jc!&p@dK(pT~SDOm@{<0XtQyq2uC2sHk z@;UXgXqJAUM4D}Z8;qa(3+DH-zCSN^;pH1lJgmW>ih2OQgLYY3$64GoM7w84@h)jq z(N2MHLNaDC|F3-WzjDJ9ymJU9cENp712}W{tn&y_lP>*JFV$s#Q+Jca?-Fb`c}H-! z_8)n^Uj!IHp3kFF4T=M;?yA2qRM&nj9s{%labzKG+nM7Q$MLS;p?I3ChgvN+O``VR zQwid_xUJJo?kT?%Y$iDM5}I?K|I|(a^BnBXPrTRU=g|n8K`?jSJl|fU?~HgdMpyQI z1T9PxL{Z8jT>*%HLHsu36z6K1lW5kbJ&8e!pIVeCo6wmR+64I9%7YH=W|tC2EUdmz zr3j-y;DtmK6(DLyJbDWGX2b|`;rKUy>TFh+CwFS-Rx7_y_}F%d1_1HR7r}f(s(qzL zoeVLkFqw7>CjB0*R0~67XXr<3&SI?KUG%v)p`;*`YfguMZ$y409IEY)9>t!4NUV3< zjfD1TM3;V4*zE`qQ)XYl0Ig5)yk21FTu?@W4)x11)X2Q+z^#i z3`yKmfF5YGmVtX9W`ycMuB$=r9&euO5Sp9za5LdGWIE%qgAkd9AwJ1XzwKemt6@2T zJl;$UG_l-&3}Gr$+&!?)JSQ*=xc|Jc2c5Q`>Z3zX0#G8o*Bfy?2LPTk`X!Z)v2Z3S zJyE09>DME?D;(1oF|d&P#&L#x7w-{p@^1Sc%ZE=7EXKBXwszg+sRx z%azB+Om+{YX7@WV^uAw5f{)(ZE5|rCWnldIKtN_14P-Rg8nX3#yhPzUJ%a49L+Mb?SiQpbHs|}Y(>Kb%7QI61tMRzj zYbLsX4!M2R2#Ey>#X5ZZKSLye+z3?|cm?eK%x4nMM6TQ+VJBNxMl+%8b|8FKiGsAl zfJdrO*pHj<$J7WZ`IyrBDFA#&SN(mjOho5|6%2zWD^dI1URV?%k|T&ZM74~jK(UnQ z@w)wiQXgGmAzFr5VljTR?8!-oFOY&Ruq+XOdAF%6dWpYBNmAB=kC4zD_Y{1*S`73` z<9az)twHKa=c%)*w-qeUd73cd)#j{YJgJ^Q#jdX?xtPY9$6U50bK6p-B#pemNET3gv@$~vt^9mSKf{5lHd~*FS|@OEp~=Wa+=gZx}FgeTw>SpWs<>p;1XQ&6!S# z;hqCV?h#1$qpRE!5d?zL5&n{aY(R+n82+O@GVx<0ltskLpU`jOzx2l;{G%K6Q!Mz7 zU8ZTK0P@wnE&;TQ5!_?70A8`eqJ|8A^LYI1Ba}02sIGG{FD1BcaCwE>q>ypxE}g&H z{_-^YrSIc{GZTkldtLD_8X~&T4!K5!nboH!U+I>vh@D$ z`Dw9PrL}i)`@PJJi_{;n)*tt_i}goAoys1z0Zi!T(}S09?InR(*s~k%pQv-rbvD{3M85kM4PPB zQa~V|xCa7ISFG_84jFHuOTm={HUb=#+c*Fw{K7S~T31Pt%a15w2of&}P2qb{L(14$h&kUIwg$ z!gU^PFNw;HStNKZ8d{Y2H3l1Xt9g?UV?jRiEAO%saJXZuGCeX)DMh)hA~xJLuIn}| zO-^<+Lf@u!hqe1-7u7%G=w^viB?ULS zU~XFFI;_280Bffaif@{SpLB6}@L1G7&daUoU44|zE zYcDxze>b$GPj1ZeCN!@cxQ?KvX4((M53ei&H0n5iKA7kXDHhq*bdNgkW@@2lC0h_` zauA1eWAdHMSFS1I^(*^W|AjvFw`5-+I>T_1ujhDdfgEp$s2|Sl;sN|AKL0~cjiDu` z6h2$Ur?$_31p7Ho(A;sMKi??E5hvp<5Dr>zI(y63Km~FglUvl27#f8>SCXJNq#w_f z;0&UFW$voyye-xj``%uOwvCCX_sPqTiM5f-d-L(;K0r6ult zQCyigU0OHoemJ^MM&GfDF_-CaJCQCP`Fw{7J1kt2)AH_HbM;&VzAmG2!lfd@`x!4E z+=^~t;lX;F!Ru34=DWV&RNDYmZ5Jh5KvSWAhy_PxRORO7ulYcmOyhpL^#h|csoG80 ztxaa$eMQ(Uw#nD|y0L@<1|C0__x(|fcef^mRq025fq7*i3)9I2%@4+TOJ8gJn8Lvy zv7$}w%|pb6a8103btK!Ho60I50hj<7xkCBsOI<99Mj8`R52#@k&3X3iLeT2`n`lRW zLt%-en`h4Lvwly*qtKo+h0@Sby5pK8jBgDd4>zBuOZ4-WVnQG3;Zr(%y~)9t@$jK> zY*8x%nrGhKf2y3dHss*(-B!$(oUIq<&4%&3Zq+qDk!2PY5Fk|{W^1#b32&0gz`+yt z^E0pxnXiWSOuv*l6T63+vj}yw?y!k}^Isz6YSWF4taVso@>^yA^p&}xifm(|wP%NVP9r8V$_nl!MclC;Fpu&sF)YBML+MGOx`11I`;0xv=5gTk zEOFHBn9_Q#55BzKa_Ox|cst@@&WV(c#_F39W}|q=MJ^qB#JyNvgc5G93msg49_AvV zJkNn*3d&r!;d)odpt$)1H!2@Yxse0EiGBg?(N!JT&F9l-@&xAQg#zLP@3~MT5Ka|e zw@bczWz_i(Z_G(y)4j{5FvQeP!%nYyfpVE*H(=fPGJKc*sj92^+6{`hm?&?5R|@@n z!e%2V%<1nNK$x(|=_ucDK@BW_mQIrv|0M4+OMt^p6nS9Mx4K`3i^TyFc2)aY!w#NX zRU`XI@y4*Ep#v&d8l7xzhVy)q6cuhPG}9s{m|6`s*bMGzUR3Q8KN0l;Za58u=5!U& z2N-L{M_!A;xJNKl^LwTply23TDg3Q%mM=86YS;-JbqM81R_ESe(!rILQz=-dVh|-9lCKv&Eh46K_fd?1B z1I^{uPv3$5mE-R;%@q5)_P3)IawQYqVZYx2v9gy9tLCuW-0Aiqz^Lu|JGhQY)r`dZ z31So;K1Mt~)L@suEq)1qu=A2Bw)!<#_-rE|xI??aKhI@7^+dF~k3JDWJMj*gxAgBS z0W=`gQe5=XT+H6eg)pnU$5&2yobewrDpPSQ0-u>8e>T76&#R?67?A)A6-IxLAA?7? zIB1JV+PYV@y}Rk7t$HS%%WiF(D{T3-V{pe(hf}F!Ds5vw0pD?d{m9B#DyK~)Kin;w z7NLdYYnLDvwkL)!IoDhmmax7bfUjTp={FkpXSK7Z%R)U;B?`dMhZDK3Jup!n3U~>% z4yfF{YMsmQ_A9FJW`Ts#dlWgup`K!L#;>9NsYr?quiHQBf^oU%p?%bYPissX0_xH? zsvYy?+J28uND@|m!2}dFa4j5?M~Lm~emn}mmvEai>~8R%!2h-nb8Y`~5e zAfhxAq{CJzwj+E=OoF!7>2iXSRxVRw)n<<0F6Zbze_A4fNRzQK{Epc;KzaSap}4!L z*bdTKfPt?!x$q_jb?UJse4PlCwcQL8pZWA!xVQR78b-r^x?F9PDR0*7guzeFP5$Ab zG~B_T0a%k(b%6MTw#ZgY2D+JW+bFFSn#RRhAu>F6yv!#UcYA-s_ahfIffgN~$G42o z^gL9~7^V}Ix0s{@e)}t0w$0ABfu)wv!IG53qn2$TG!68tq9&(X4b_%|n=u@g$t=fn2T`Q52(TkD7R~QMb9o|qG{Ks9n;>xshqAQwQGS{@cT$^& z69sJkG}qaWpc%{-_S2dRv7kMF8@-L25k&kU)+zgcePQuO*pGlk@C+?8xJ{G{%C^c` zt)9Y}{Kw`)W=kv+vEmm?d!8;yYeGtOzSN`vup|M6U(505gC4Y6Dw5`j7>&cTb^3Fb~p;XLD% zn4T$rwi_PttjMDyDCi`TuKNd$E5qbo*37k5RQu<44{wt`DSb-BLjjt2!spPWPA4^=54g+s-IHRDF^1)A{LcsffEU_va7JVJNVX!y`|BeZ$f124)bXgHK{j@EtImw z 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¥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

GIHB@UnBv`}%L}glhX_2;gCGh9 zAlUbA&Qdf)1qgEVJDksBWaWB12Y=*Yq8;J%haZW<_nl=47rxe6VtD|ZJn*V-UY!KU zH2@g|8ZGq3pz%$*VE%p4K}~nJ@jTLKJu_lI)3zuAuF@B6NzK9-FCk->kT&cO!P}t( zu5gfJ)yi13E%J&_!aE!3S*x8KTYsWsZbasy#k%>FzG6Q~TXebqst!uTlYcgM_AkE! zJ$|PYGibqYTZ}jT{76cJ{#Fc{N7dTJg-x9V4=hFBHze=^p0-H0oBMA zO&W#}7^QP|z86x;m!GgbnfFV3P`}}rV5Xv~Csw>t1xEja5{=v*&|q7VJOuJn|5MSP z1Tuc|aKe46N^QXwK**`Z1Q#Wr5&rZmi{ZcCzmbC?l7(@G;=a-d!+-N+vF&IrW&xDw z1_fNvOgTb*F!)o7{Nd1-AKi4(xPGoKM4TKAu#u-X7f%J!hTO+Sf3`T`EwdvqoO9zV zz2GxZ>DIOPhf<}vZl?NukL(_;KqF#>$Zh;9Gp+_i=Hjt=6~?EzRBm|0do%KDqQ6) zWYSpeiF_RQ!z=qn@7v>_AO4X%dA6-z{@Jbgl#z?zX#V%?o*2xVyitx-+vg{3>I-3HBY{zx=x(MRtCl2cJLpQ4fL4;qk=d_^v z@gEN&Vfm?tXn%ChpA18*o;~_E7>b3G-z0A^yx@gWb&m%&e5^9cb+vR71^Z~qx+6Xg z=3urydkLoD?|s}2vV#`_^wSFN1_kxFOUZ8tu7kDZ%|q+2U)J1;5LDr{@lBt%fyL*_ zpSaX3hnIhdOebz-g=_LqC^tqo!gxj+GPP>eiB@2)1b^i)Wds31Fd1>ZAM-RAvtUL7 zfX4X)Fe<>SK>YWOZApO;6T%}H)_Y)8j@jWE#hE|-^dh4;Xb~0dl@VXJ+dUjN2hbJ1 z_COM?vQ()Gu=)va+=}PN$uFmC(fw3N=8WP;ZbA|QGe50D$yiHoa(StHd;q&B7H>KE zN-6Qa-hbP+tvWb98gsJvVA-5~`%y7f*C#3OWm6hO%Dwd0%Vm9_bZfSvEBSm&k%Wi! z@1-5KtTrJ8JLCz94Q+NIE&6HeoPhle&q&&(H5cQoKUtGWDDfaE^E?BaC_gmKC$gc& z3$?G9YFmoBN}OXkLxzdFGT5dht(UIa8>y)&uzw4Nrmp)9`+ByY_VFH1zZbgKv4yia zqTw}+-?ytaC`q=5@UC`q@o5LDI)u|NBLoE({F2!IjgX^#cEDW5?Z}!_4cu3^o1kIXUo>*%1SdGXfal$i%#_i ze@Y6})z=H>fa;@j@r_EyJ@>T_Qbz+)C&RooVdr(hiwI|<3JWCJ5BhLK@h1ji?#}}z zJIb@WD0{Z=QH6jb#$@#LgBiGQRfA}$x!10rleg>|*>drPKs3=H@Wi^pHX zXy0`7Ih!f${QD+8(B1+dNKnrbydmvIP~BA#uS^VmMXNn7u^G0#`*`(}0qcLxvu}Ru ze(l@o!<}3_HP&?bOM%{%?zuEmexdj5O+=o}v%pI{a$FiY$KtFzqbH-YNS@kbTYsQ@ zZKj9{X!YaX4zlIP+AytKCdhHF17uV%Qo?s*)yu=uUOe08<0X^a{C0!5FJn&uoakfo zX9X*Gb}d2z{HU|kXbX6G{lnJKF znb4bhQ6J@ABvAqG)T>=zKs3V(I4NJqhrKVTfDVsKRtv6;^}9-B^Zw%U-+#3Iy5rZq zP|TKy(K}N@pT_#P3d!>M72L-{^P|rzgF!dd`B*`sHv&xv_{lmKpvnMuB25ZjWUFf@ z5Y#DGDhMo=xynQv%JRf`fS^$yPwjG6R6s0)>-pKk>L00yHz7(EL#qTnxQp!$iWJcU zey^xDU3u7_jYO_lvZTxAQGdgHqQLTgArvc8%(n!s-tO1CyB&-rTl;UOH=53H`vw6} zY{(|``60lBZ67pXeZ^Z}@#2o|hx^i}^rcOip>JSy+-vns(;?Fj?0ey!?X2ka9Fj8C z@4K)!l{iG`*s!M!y?xI^MFzJgp5Y=NKMWuX_zs`qFV8+PvJe2s-GAI8T3$yCRdfV3FNst<) zL>+y@2l2z~DfiBZQh#(yL)EO#J^b63OHI;?5sBSoT!iuo$rY2wktc2gRwyM81m%1x zdZ6pDNw5_Z9q`DH#9)RREPrF?w6NBkR22UPa)K-7iNjW+x0wufc+_jV1H$;$4AL^j6cJfLO0U^ z7D?i~1%xQ>h_quF32F$HAv3wVElA>C7Hni8DT-06W~=exiX;AOPt>g{*|KAIQEKQ( zOvlL8m8+fZox_(8pFQuj0SZ*j}R4+hU~5`Q@R!=fh%cG~+#vQO+JHWbSzOZtf;fwiZG^_J9_PP&~IeBFw73c&)4 zDtGaDW1`D}u2MNNYKACHUG`b5CRUnn^W&Ye71BV}U2Bfd4)kX~_sS!OwIsYZ@r_d{ zBS7AD^=IEDpI@n5AnEY+wn%==Stv1QUw^glDJW~Fc=Ov*Fk;pDQYaB( z!vX*GyBjNhSyo)9AHI0gQ<#K8icfx%#V`}8A|=|?7;cspriERbH)Qfje{VS3`vE)F7rJx#SMvEm6xsbJlLBKYLtYrce4}*(!GDB+S@#2R&6*Ee z-Y2rP$bY-G1sR_EO1~!-WM!mOz1KoVZY}%s*u@()L)XAfQb!JI!FG3UbPhBez!v2rusKj zN_%3~Q&YH$s17@;CR&DSab_yJ6#K(6JgT)8ynk?Zm^9>JAw9t!Y^>6d(e$k{E5b1f zU|J{z@7~ZZc@rSDDlf!nYl;#@`VW|@L}8=eFbT?UX?4DEE?5Q!6ypKFqy3yPU%Fc} zXr3?Y2r6@xUr^bU_8RCxQ$%^6<*WW?fILh}43)KulvqV}< z1b>(G$~N)woyiHn@}l8x5~7(9)_e(Ixe@Y4eBG=A!H?PYWCqzNPt(ljYy^M!-Am_v zfB+V67HRf4tT#VEb+`>VJb%0DwKX@^m1&!f_>;qOP!lcy9dbZV48^{&85|SPYe1e# zcm-(mZ4bW{;zEBw9wilIssh*V9C7mmt$zUHbm8GR@itIf*FE4}*#Lnx0kgZWhF>f< zPToICLeLt2@#EwMM*9Jm!##^9^~o zlGz|<>_n&AfnijB-4njI$VI+!w;re&R6msq@v?>W3I;qHX*LWtM$fUG-DXjMvVT1S zyoTymN&LxrZW~>^q+LRV-_8~<{v6U`y3^jjeA^wCg82)0?+<<&1tUX@RDt<>O)zPI zAvSItEoWinmy}_8pw#HSr-)z)TKQ|tgbNEjkiYY!*jJ$f8fQURI(pA0Du!VMHx&HV zugMih{zwP~Olj1HI3zjX-(gIi1AjW+{c4YT@ECU^`YP3#(cg!gG*KaoL)M6RtYD z9&PR&{o`BS^lVFAuxaXhxv)u>eGWDA zfC>`ne|X+So1G6)k<}u`Xs#fOFdgvPuI|+>M4dTz7;n|K~PtD@B3%R{wVTn8~F0U zmM9l9uRDMhey|hA+kYg-@VLO;{=&fke+v4D=%c$H=<-!>Fo8cuhUJf^yD#v8D#JwR zk)(JH;uTW1zSeu@Q(I>T@%zX-kFkbg=A1WF@oWtwuWNnoL9Em!LN{d$x#BO02Bg4qW;AYTdO>3BZM+3!*I=X6k`cuz2$DKYxdLWBkZY!j$8R;U&_x?wVB@*8d*X5=|!nS&GbEn2mCpC?>mL~$uh7i6}k2?}p_Z0*>ot>3R5^5Aoi zQ?DU7uHCm9RcpXM_sATsJOp=p;8tCF04%mPomzRYf2%Tv#b4v_;ukeh1F4@#_Z&JH z%oi%njdU>+qJK!_^LG=TS-~BQBDEjqy61ONUo#A>gB=w&$(hpMF430sx$%)|!fq_H zk|#@UXFE#D(o9JU>peTg@P83^&8Q^TPZWS8*eh-+3`USfGYpfa*&9>QA2wCRa{npU zvr|+I*fwp!w9`H#@n&cN1BGliE)4T0-ZxGhTeb?LsedZax@40Aa2;Z3A+*M_h}XQZHUl52R%v_!udePln-s{<(vqu>)>3fESz}sP{Z5r&5{?Iq%czg z()UHsH~5-V0jKZ>tui08a;r8d@?dP_eZye(5(|dT-9>Md{zz4}F{mP#O5ret$}$0=EfyN{Ldsjx&-=pv9R%=S5r8 zCer-J=ZmYBb0U70$vHQQ49Sia8;mt!{gk?t*cG3_+}Zv8Zo(Xr8z`(YlFHYh(5=-% zD~%J+bWPNce|5hxaRhEdPA%06xu*H;4u3%A)yyg7-8E+Kq(A2G8?v1nN?q*d23wmb zAF{055XYMLXYD8VH9Neo=|N3jpnoqY?&hcWg5rIue6Lvp3oKaD=G5*cPd@&@F?m2F z$(eIamRCn*hvBb5^PE{KYEH9a{Kto=J4vB7u)?<|;YA_;K1;UzYso$n;{JtuLVx@t zRf7G{7SGbEPXBR2?jI+#i~Ri^sR3DxRgcjyeQJ09W0^v zLL%@#Psow=|4K_@(3O^yf18#x-+u_#WmKM0sV9T!@cvcEQGUtTyG$$KtwuRs(vZj0 z30?obenfUqvyd-z8yL&J-lH;dD)4)BLXwx^pHa<(ZB>cdFJ@LT`+A(YOi)GD637t3 z27zL(v?(Kr#)beeMZTkVLlVqNgD9A?wuF>(or!|j*V-m6j72EmrMcr`iKx`86~&7uhb1zJeHCl!8>p!7@HYdz+Lx?T0s!a)Wi`^Bgn zmbL4X-92pDBa(#%Y$yyNLBh(7V{gnX9Av=-(3@0ugCju-L5ih=Gng{CYb8{hQlTKr zsk!h#E;Y=|LmW-hnzYOEaetgf07N+!T!9H6#{8SCH|VbCpxNLJt3P5C^slXTDi-4* z=VshIVdj?3D__UbQU2>J45mJlgvgC%CljSees%K#KzLowRSu`(MiK=wgJbGWn6cCigX-)QD$1}HjVYV-YJNNlS#Pk5Z(dww%?SHb{#T%$le~(Kt zq{^aRPam4OXr3cTVvmY@pt||`-VpAu{yAge0Ku`okeCW4vIQpbhA#{JB9fj2`xXaw zX=}YUD{;Yukq4pvQHM*w-PyC79pUTprf`BMy{f92Q$m~n$#c&|g#OkUs))V)|9|%X ztyo|m_M{d487H`HI2|Ce}O ze*d`q=imQZ?&@z{!QXm6mVd!s1^xq8BKh3w|5C);-3;E~yPx}1Je{#6yeSfb1zLMPB>P+m|_bW#E zZ~Uk87IFBOG8^k0@NBPAY?r)V4sXa_Na@Ddkh@4T+FHs4yy@|+zBOnTY|C^8*I==> zmf%#7%<4p8RHGGr_|BST-fijH+l+TyUS!ByF5m^9q+S6wNKoa_-q3s-PP_H+0a%-z zF870~n4K$0h=0py_frx-x^#t%=H-$Q>Bbc-n#W62q26c>}|>3USopAt_^EsUy3 zK4(Vqe;)gDtvGOSpZgNAFo@&8wV)!Flo_J9>pc9C`bTEA7qax+pxa-U%uhbk(6>c zzaP@&8Dc#LTu?;=&$eRg$HWA$8|;q#S64ANLKhP;5zc=P&u&WG4QsNW`ik$ku!B98 zhmMJ^ay@jtV@xk&CzP2i_~Rr*QFJ?-=Vg3a)_<1}f`a6Bb?l7J8JKvV*QAJcbuKWw zsj1MlBok#Z?0p}3p3gI3Wy@w`2k}vakecS2K_hxaUDRbg>3=quT)t{!X$+N-UA9Q=-l%$&3B+ z1~Kfgrfb9J_@?*KT8}#W7D``7@pGAc_x#-7Ce3?JrAEcGROx7{%h3Fm$YSR+UFX&v zS*rYHctmLNHi6i9a30p%jwGlEUfBr*IOq@tiPY?I8PuY`j2jV0)vtetTLX+4ynmwD zI?lX7NmL2%n~ER3kcJ#*X4Y$Kz_;dwWo5m(_}yJyHf`Ax%4M^+VN22Y)Lmc@MP44=t9!v1a1mtk>KH8rTz%LKIKdP)tB;Gkc@LS z%K@MJC9kZ15TP^meh}TH!B?1jVSkpbuQPmgW7F>Y;=^i`fA>=pPnCPwMXULzmeD{gmFYX;q@B1eq0(21|pVK~s+ZV;ngQ6~Z(Bhv?PurXU2O`(3 zAKSWo1- zf!(a1aswuIE}8mh|0niVq7n1W{B)ca-wa|(3`l2|1OmzY(e>AVhPcRotZpv+@22?h zKa1nT@ZVw)_;0ZY{I^&Hrv5Wf$D4yOnq~hvto@Ie2u=QjwL4oyYkyO}7J?mo%N~Aj zVE>9bd`jhC-+Q7ny*}AqoPR9gt^{$pDzD=`Hd7CXKS!tub5%$9sI_FC`o>Q>of$8w zqf!_MgJ4k#K>+GJYmv-JYf5#v5AFt*zkU{rbwEDPBJ9!-V??yd37ZzoI6z${$xs zsK5FVOSloom<8iYo_{LT|9}VrK6PQ==JcLljx7J?_$bV~FLDo2Tas@G1s>tgn_r2> zmo|eU-6sqx#-ywE8{4cT-mZNEbt5bNmjqLur$4*wJJ;6UyGzLd}-h zI2X)n>9!y zogMVQZO)6)&##W4gRO{rjUEt&%swht>J2 zTSIgj&-v2fS424`z*9nr3VMow=qQ6kv0W?|fq^4IzzZ>!%;;Y~Xz;ROOvuJ@xy_{f zEjZd&=Wp;kn17r?^}WjPl19c5uYYYL>iAI-N(xMYslz;nC6@|my!m6<7H~^bDu3lx zdld80RP_-$Fb{?=?(u$V0C(L>Gf)RRR(Uiim}7-+9QVlLBtl_DBr;zlH^F&zc+qbz z5b{;Z&Llth%l=BtsD>6E3clq*94&-{RRlM z%k?pl)qoxxd_AF^v5~}Y6JoG_@wMzX_y&MhfIXi%?zU$`*Kc*_V56W5LXG9=0f0({rc0GAm@2e01GUaK># zum#8s^s0^|sYq<{S`XNOtx|fbSk?f;39Kv0Q-6N7+LUwz(Y(}V*$y~c0UaezDPI8% z%_$9;!-+9J1^3AdpN3OsJvD%O|7>6moW=vvASoQno;+FVdLzOY1}E0EcS$_CGJs$_ zzb>pA z)PD$K%kL|%_Fp^svfmq9DrcdoF}8RAEH)aWwgOV2OuV z(a<+LEmn6@io9#uWLuxCv`Tp?{T0mHh)JN zx<7-r)?;v&=P|gaRav0ZQeJr~(sdQyYXG*z@2^bdYQ~ta<+pO@w_x zzYwM!!y5KO!69XKO_96ta1QauVczUBW_X2B!Ir}tfKCX4x?*DOR1DtUt{{=bo3I-2 zr4+8h5ju{G5i(^5nZnbHDO{11KYvI$vPQ}!FDMs&_r%N8(UmiaZ6xONgW%X$@%dfw z0Qby1Pv?^wm*^*xL69YsEF=qjTl-ku^jb2w35ci>2Ay^YHihDX2P zLVo&7?(rQ9l$&FO9PPXDIDC;9+r~A-;6vB4EKm$^pSMwNGgT{PiALo}UQP(MWEigw zKOB~Taeqn3AxkEy~LTq8D#^<(;)1bib*=AzW zb)OotdVcH&r(O;RDUQ2_&`V`?S)A9C;}J*Wp(_(IB!k|JSquw*FF5xF&RcBkzcD*V zq|cfl@aimY$MmE0tK;4Lq)(@I9%AqFgFme|cCI|SXADHDc#0x(BY*!EG+<~kOJdy? zEU5MH>ip;~vtNZIJw&vATHOtei-NV5A)cJ+T)smVuUq~S99js*^p@{F#Vt+O*Rt)p` zh)c-x9>dGBb&AG|swg~vMAGmiz%OlNc~RVNWaEt+hsO0XCVyW{ebZ$2!hoQ{?t9sH zTWZ!+9VLHRylRzd)?2T%xwe$6=O1+xT`BYY{UqM?5t7PE7_(R z&)YQJh4(5MCS12mdgn>ukMP}3HR&6^vh4rn>nA#_mxb;#OEW?K2W$8J{edw4A7hK; zznd-o({{OEf6D-0f4duv{Qb85-!e<&Kc$2pd-Hsffq&@#=XS19E!7-@dOm*)|H>h` zw}QiT$gIqz^o2xQpCoyAtc^XJq&Kj<5U0w_@MdqJ+ZHybwIR3IP z@KZ_zuV`tyx#?!8K8(P9^vbjoqA^L?k5vc-vt@_02AMQ^DdOC$YRP_vG*?#j0Q85l)Ur6%tAYd3 z@ARs%?Sl3D8;!;O)g`VsBfct6VW&Fe(xRF36~Fl!*34?i-mKe>WNLE|A$2S*g<(Wv zrhhi~hyrfs=C=1}QzJ@O-3|S7-va}8B8m2{eCD&WEoq)sLPo8! zQCq3)JeWw1_gtTe!zN2MELYJVkl<5jo5;ii(qb z<^k5wbzPi}PUBpYFGcO=sauZbWGV3ukffp9eWA}Us>Toh`jik%LL>MIyaFi*V4Du` z+hpoJ?qRhF09fIl2NU0TPDEPA+w#!Qg@b$|0or@m9!1a!&4qQugMS^fZ8TK!a(_Hk zgmU=BpgJ?HD?XLvr+ndvjGDWX8P}!^2twnFH!pBt^E`H)H=)@Sn~cKvZXPzc`oZKR zzuoNZ+6cV6pR?*9MG;hnZIjAGYz2ty!c43t-HhDNE{QKK;w8@ibc|;8pI*t_fAbzE zqC?RE4w2W}0E+oX^9##hXs%${n}1|6+&#f71_^odp8TSjy%=7*CqFM_rS)Im`(tKBANprCFl|F)Ax@i+?J**WvCG z-^xwphAU$y@6E3T`;|6z7{c@LruVzqzQ>Rf=B`9yMb$lRj$LREuLRnywEiYKFNMb` z^5<2()T(@C)o}WN?RVn<0O#$epzOrL)+R$)pQv+<9Uss11p+DHTJ*)(D6aP_!DQJl zgDDtN@+?|l495STw0+mI)`>$7H?mC4=(q3uzL`=*K z4@r>S)mfR1u1fsI?3nXvp?2q@y3a}ww&R$DV91)>g{*j=-+APDnLOm59BfdW!65_R zyOhPSS1?Rn_u^fNwdzT8k0q9}3QFClMsMmHYVX!-8b@s`#=GeAD}SliQ6)bJhPQD} z&M$3B7p9ACFS-o{X#fxVdE3@%BM}JBIz)K~O{@(x(*0gGVMa!a$E)x3sk9JS>{*Y! zvb65Q%I0kgcyEQ>h1@|cOK;P^OHF+Qzq|L|HjZD!_Rr)is5N~iIzvB_?zj3R1;xLI zc7mtV>E7JkcvE(xP4H;&|;cV!KkF-0qnyOJbcS~P_xeMVB(>g!?R3w zg?ccUq+rKlK^+2PYRO0fW64#QOEnBz&IZ2z3Hhh^rt$mvqkUQs)8(jKcKJ_tCycDg z-uXCrkh7njlZ96O_Fc^VYQ0?}MB`rf{Ol@Y+iYQr7{g(QxqoUlgr(Ip)0*<}tJ3H} zBnI~WE>R2qD`fQ3W;o`i5=pvwt~Z9@3D)njf7K^)k>%%20-__ZhJ7Gmhn=FZk241{ zLZd3)J{58J_fKj1pEB~8=-wn7x$wSd9+J9y+I>h#moFo%m-2FG@Rg%k4BQ$#c!Qq@wZKrw^{Ji%UH&LzPHB;oMmu#hS6SA;oVMbhT+V0vut~g z-}gwwV{oOvyZ412)<@`nc=?7M}KCqywdUl<6Zv|0td2yX7h@G%>batV2)) z^dg*XXt}S$Stx)Ka)7G(6VZWUm)lCKJ`st|P4BdKUYxz0bf{9@=DQl^!F&sRhcf)M`B%X1?O!TOC#&!4T6_4qMnz+yZq9{dw%jfR(^a1gM0>1Zvq$gp}G~g{y_NIyK z-4)Ni4MsN~&(s@ZCZ~TSR#zQ32Cmmp@ZFm38R0sYe(|(xh#Qygj@@_n4+84O?1Hm( zg?}LR1hCOqE<*o22$l7M--Hx1P-ex%D*u`6fJv8Z5Ippf@&jWs2i~!mxk^ueA0;yv zQlC9_Q{(oi_0|W`rEnC64=AT~scJSFir-M!nRH*GvJ*6vlVclhsDdH0Pv zaCxs%#%kWsdd+0lp#ZDKhm>QF$Up%8nST-mWu~to(9`4gdp%P`D)Ghs5O=C|6)Y8t zZioDPm&i*x9J;$2iu(cdengKCH5(JgI7LY4n6d}gN+oQLIngv3s+9B!ps*x8D4ry1 zAJbEYhNVJg#tYzqS|43*qk4+kQa=9D^e$gVE|`8?a8aPj?$B58l&ZVwq@sJF7=JT7 ze;Y$yEe?MQ^LoCoT7PIOlO^v}15vQt=V>w@fy~!L!VuKoWj%ZjrD=weMt32GW%)jM zKkus|$!|)6#Un$^V)5hpfO!XO)PyH5q6w-^-A%vJJ+N_%hxp9Rx-HMBG-Z1*h3tAr zvu$B2#<|$XHiewa6Q^ao86sCa#eZ|-BGLHnaeo`U7Fx0{=+ghpY8Y^8z0H5O(7ShB z7);hJYi1I10BgX^J|x;zOqtmdias96i2Nu|F(0UV2malrWD>?kEb>55LjT)De_EA4 zh|n;Z+f*3jF3YkK2>ltKE{61r72RXCAwjkMyndM0apUaWQ)k#P!{8%9j(-Wm$mKM$98*4e#lG>P=^57VdAM6@dIaJzT)t>N3NS1E z)5!A&DDi|+NxDCLt+|3l?A*IWJ>&5{z&L=LBsN)bXCy5a|Ew>F-#|09I)(ia0pLdZ z69lCRcm+3IjJ;O@a&feI;iS`a z;<$Sw?m$6->k(M3@0cVLw~slP^DNy6itsSG*g7&B@2*qf3UWy24oJIQ+{Ut^j%2}Uszt%ePq z&alI&EQ^7zmE^9!lCt2P52+sUnrZLhGb>P^DqQg8niEgP+v`*cBdhq~5!xJYM0par z)RM;1y*~grK*zt9aT+a3(zu|O)OO3`duzcRmBDZCuAdDKC0XXY7ribz4%XNMqkgw% zIasvl-P+yl4i$COCs2Q+oHz3Nr`x_QC) z6EuCX2TZd>iJHJ0ld~Y!M>~t&xQEQYQoTC5Pet(ww;WEJtKEM?etp70ExsZMAyM+R zias`dHEp~i@^uleDr-L0cbhM#reVM!NzWd-9VZ6Tg7w{bn;sy4#z`{GB}R8tLUDA) zl3>3a)^9Ef^gKoIW?abW(qfXmsm_iW7dH%U;8^Dw{i-w zsU@z%!3AwL#lU~V*e!kd)9GfD)~PgVZ3YUrGj#~#g%lV?ba2&*3t=ynyF=#J)EKy$ zu3b}a`vL4q8;D8-ROpdp1?-6R7Wn+y{_%SwUjPD>xDopxfj4Jr%qQT_H>WIYlD0ei{bMi z@P6?;whUe~f%8t6MEEkH+hC56N@rReNK%uUZ!8iAo7u51LqC^;hOiUD>Aa*IOx52P zO1T14i^;LR#=?7SjbDG_llktZ9``ZeEH6_36a(Lp^wdoIp?>`<4IrI9ju4mLLxKm6 zJ%L#l+*E(djkMr$Qi~7rcmqzpQ`yQld9?nNFW&ziVf`z(CydPq5@+i<9-F5`8!8#c z8$din+$QxEcIqr6vxOLLrI0vZArzhaI6(vQLVvz6oF`BAvpfjcelh7wu?N~y>WJEc zp2D%f|MCR|e}*LdxH6JH7=^z|Ba6CB`udAG8t{Lzdz-SrshVwz&`s8+;vG6)4fCuQ2-bmxOwjEPa&-Eb`*GnlrE9wIv9_EZpm|!e_DQPw8=eVe)!;Ywz zii=eJ&2=9KpZS@Ds`ux>a1~=O5V(Jz%V#mds^E>z21{ua@7n~G$9$Nw_M9dR8(o>; z%(^g0nvgvcYxF_T`Ood*-(H$^RuPRgsa&#m+2s4U7B<}Utd~co(A);Cn^5?#;(Kb^ zDm{0TCNDO~+UiOk)t7X*;NfS??**Z(pJz;vZG@hx%RFK3Bg(=2p|GK2SfSUoem3k#h_-IsA-d*(9qP(%4w42XAj`b;RUSq-O+4 za|+@_wF?4t8uG2_%7YLZYxavi7n5}lZzyN*o=j!}Rixz29I+RUdS^7%@8%J_rMLUd zzNcQwyT{5OFn4z=Y4GoTr5}GxN$8*QVXY=N%IWo()f9cp4BKD9ej2Dt+Pf7)IQbi5 zNgh$mf&(ZkQK9xX_~1QcVED|gj2-Hq8SzSzRCRu94}ez8)Kq-={SFdh=`0&w&VI4E z6TlE?)OX|MT}P?uX8fr{De#XkPTm-5a*OBYRSfNdY)P$g4K^`5Xo!DwST}snb6HO# zmh3JxCemvs;Z0>NQ(Xmwd8AfIi&0pM)!Uiqr{(9y$|;LdA*6yLk+$6XvQzM#tzS`n zYPt4C)Wdz1HC|(A3fLBTZ63&5_bj(pH--9Yr1H7!_O`j=mR&oJbR2!WON~n8ZR{uL zH?E_cf} z4w=SqqSv*17G^v=LB{OkQS6^`oeLk}iYC4|D5i}bLl0@Fr-+(~Yp5#?P4M9f@X-*> z%f${o)D9u3ae46Q%h>34%$94bZcK<{PQ^tGGYQ=vkFKi)1NML3tSR|oR-v0r_<2d* ztb-FEXA=fs&l$#`uvMBkS&`~jU3`CurlFor8$SKKLLKrUKzPN> ze1qfBpq@#&+6~|JrCvnF)=|DFqCYZ=J@sV+wfE*9G^H*g@|Ibf5q7b;J`#2`-Wq>4 zQRZVF;}|@hQ~CC}EgXJ7 zLN+O|jKY5s4q31m*Q#f^epKEPLPzk~Ew(Mxj-DLz`53ai#*|!VOHG*&N0ATzXTQJm z!3=sW=S?E>pCM!!R@*pZH)EUa`*%5U_kNp$Kky?^*{OIPzk_qKCQO1bmd96#9zVx? zN>J_P=kN*K3E@v#rvpt({fF22)Bw!;f8Wew;tb2$=rD^d`d*)j^sK4h1rngD% z8bCD=9v&8d#PHB%Uwi?`)EGro1PAN+vQld%;oQL)rJ;Tkb znaiYp4f5CN>kDFQZfsCi{)Sx7aEGuoo6x)8cKW=>FQ*O7%hxkqlahkw^THh8McsQJ zyO34NX0f3?1zVTJA;OL@D4nwyWp1F1-byyJUf9pTV4CvcAe$ zo*wa+x7fG&rd?Ypn^j{Tgc4iyr)_dJYCohwFa2KYnEhe$Pv{slJ2lvY%*A|f8p0hO z3zv;GoHxqO(HDPmgQ6bxyVCu)7@Y?`zvV9B#-0hRV_F>oPbq<7KH|$rDz1}N2P}UQ z+vfSEcyL{@SNv?x0<%DSSF6wH$SnTWrVYaxt0T~*S+L;sd9SNK642q;FIo9*@Xb&B zo$evq;Bx-&t?a=F7Z9c!P9jG6!tvvNGu53fK#!amaXjh8K z0he9qZMp4yJXwCYKRQ|{a-&aExLYd~L>j;7ERUy-$~Nc-sO(8D=#)%zSS&4^q4W~H z5$+W82Ubl9z!UCuXO!n;3tD$ND{yCHjm_ zJj_N52eT^DoAY2gf#@Dy{<+{_9Htaqh;an#_I-OyF#&&nXA=Hn`>}Zwn6~4<$xHlQ zYl5up7+!IwspmX=)aG`){%Y@i<8?)v0Ch@o7N&%=66BG=*7x`cJ;o>;Woc@gdr$R) zYL!ntitpFq@V4FcFYJFMoYS(#3uVRQYjE}k;1?>!MJWb9JXy)Gy~1fE+R;DHPrv-u z>4Y{!?wvG+p2#tWB5Ih4DZNVMH+(rx)Q(K^yeFkJcf|ley$psS_IaM9)i&EiLU&Ps z*dy(lt6ve0zj#$Zb%II!P^V~4+(#E_R28?)J>%DxisU# z=4^bK*5RmF6!|e&E#=@;@@t@a9cP2%Xk?HJhWgWaVy8?k^oG>FQcmjmeGS=J%K3Ek zLF07v>;{k}C}cgqbetM+f6*laA7chB-Zhm-B%o0R(svc&F1#o?3$p{ zExitu-rKGC!1RCp7??Z*%1~&Pe!RfXcMS9fA0UP+=orZ7bEF=<03~Msv41VHOkiAv zGYhi`sP0jJfDfd*0v5^rVyqrkzXboVz#?u0MG>8lJ?-%s2sNfWpcNVWt9e->?Lf0O zyyO}6Pi8Rcx7%(W<-9*RpQk=S=np#wEbqE&L~pAt)7O9MQsaeS5||vs<^LIaWga|9&hwv_<65Qe5*-nD4bsHAg03h+vH!n^*k=0b2R4> znbHU$x6gmpJvx^6->UoewTG_-&`adl(3Thi{+kY*ud^Q&(5wP`~tGhg>a~`(9+?Hs#I3UyX`b}AxzCVdn(AJ=F z^AvxRTVkToysIzO134j#+qaUH#OJDdY&H#^0D0ny10Kwa3}O{5pP(56FOxsN)gx;S z%v1R5zP~YZO&5c-zJQXAp>7>bb~b@{6H@U%Cw|-4K4d}!ORw~0xDQfkPHNK5`-XHE ztsrmU6m<9f3n>7ox=z6qX4CLfV~ZUkll6bD9KyZ?Elu>}XGqHvzGv&V+*K;W1Ij`` zk2+m-0hK0~eTdd4&+fEo=FYmnThkyElv-T=^v-qs-Cjn>cclIDdwXB>?j+a*pl;05 z;O_$kHnS`4laeJkslMS2sK1$4dWS74;?OIb_e0kSQ%XMki36| zk#?_&y9r=4MBRrD6b7(wtJnd5dP+q_Ru%30zmJPp4uTs@%b9OVKlP_~LH9i-rF=d- z?!t!r$=3X66aV4dMrw0`E5YoUk`qlnT-Bw46HCPOb3AY>KAws)Euxj zMYV(YazZzC_((AWGn%Ae2!R$+Y$|`__|qH9cra5&X5KdR(-qGQCpp3{&X%Zg88s$% zFgtaT&t-M)3rvn%y+DkGcxB0Wr2Ojq1d-`j2FdJlWi`sOobw|Utrxz%3_Uog?dD-$ z-S&CwqgOvX*j^04^r3zfp7w$Ry~;-J4M_cn5xxjw`ER|?J z^LQ{3n&LZhaPB_;;p0^c6Ggr~p5O7S7lkOv6ei_9|5lgxYb~!0sv~!FTSy45AeEnf!hBRHt-9N&=IJE^4o%sp=yY{ne^}6mV`=S1FjX!&#OprGn`x%{pzX zSYia?$|l)s`IQRzYzi+~onwDW-!Gx{&bQ&M?TAf4_!r*};zejH2D! zL;m1?eFhj_+u`NZ`tu5$05+!f+ji7BdyyfEYSPbiD~vKMt;;em#RDvgE0{k9)$|+5 z9=i@Cu`%e$H%9e~_!#YRzBBQz=?5eNwh4e#mg*;* zSz>7`H^pn?qpx7f(wg#!jSB9-+fuXGX3w~#Z;RKv;4huf7?YTX!TUc_0+>lG_CQ*9 z8(12GOi9y7c&6dapS}x<&wB{?_Wp$K3N$1*kh^0M__52P=mT-%u$24wt|2HrLI0M# zqg>hfm5{#60pWFtB0GQOg7_WYkg0{TByv4ItHlX2Olf*{{q!ETsP&cJ)e{y&z91A~ zA!F&Zs@YnJXNv=v-~rDh|I;k%_p_- zdl9Zo1D4ZkmR`}^I?5(3aw`*HPJ4|fSB1>OOG1xUDFib{V03?-2eo3=0bysI+5uu` zy0{+N#3R&SBou^O-dHpKT^xuwt2n^4tvaQIm*w-$n!?N9Ixa$;9VC`bjdJj7b3k})0T{-a{y?;E4PxchnP4{`a9 z36NuGB36G6nAFPTkeAgCfN~RwS=b*$cb)Hx`}7VS-ghDwXIzq3|B^t=jE{)CaH)a_ zWf20fU<27!2)SZVHl)IJA?RTCR3ccD`TJPZ<^ki67+po$1CwJeU@Z`|x1J7R%?#Ta zj*#PE3_9r7R z2Xb}6#0HSLt2@dh7RORI?(Ny}-zP>+RPqa9kYhOcT~jiw{Kl|6PihR2SEnh~S1?Uu z5QLxFMSIA9{@mN$L+eXOHc|4^uXKt{VX{+4^qFIY0tlF!bz)tN)$JN3-EVL0sCGHY zVmE)`@cw9TJ_XNGN}!eA@&^+N{>`1r({^T{bU0D(%KOlqR`CvFBu<=di~T@{!hK5) z%&7kuK=-f?Qf6ct{lCKETy643wGqkGrv~9C=(^{LORfYaN9R zM7pD#X5{rIhzwsQZgpX*;pqkyNe8?UP_ciT#r0q%2A6yU&LFG6H2LX{#{NR~2bJe- zMl*Mnv*g_Vh0kRqZd+~T0~ozp|8703;O+szfAA52qwhXFs$NB7coXj70NmBC@UhE= z{l`(2dSL-tU{9cVZmTGe8z?z{p`>KrB{XXCxmz5&dN>*Bba&v_EnbJWL3vN;EpC77 zL4Eh5TsEKK>ml>RYc7wI85>Ad+j{A3oqO2(VtC&r8WD8>d1Jh_et{XrU_C_n-R0~6 zJz|3}49r!2cT<`|qXOq^eOvu(Gw@Zg{jl;*x#ZeaXlFG1D2V}o@=VgLT*^1FWanr0 zLl>(saO@h&FWjJsV4|9_o;do>3yFVBUpR#+S>3pDOPH#yTXI^1oT%0d8T(}AW4GqO z7X*{xp*B*)H0LQx#AR5LfeGYb;1Bf+;XU%(UD71BuR7r`;|+%0e?8Gfa;PYUVH@pq z`Hk;S`^4UhMk*dBq6bvDY3U*nPoc-_oe-Z45ygbMl#us0%KkxxCqLVrip_r)>wWtu zld9ptu^Z|L!agtK9>nGmQ0e|W@PeG!K+`;Av46asv1%ULD4G}hox6hRbcEsNiF)Cz zrm++=KjOjH-8yGUVM4`Y-__z$Pp}-e^4unM5 zCbjUh(R+;mK5ih7bBC?NP2zv!?v1u@Am>Ffy2ZPd6@0UbZ3R8E1;)XrQa7~}7m<0Y zRP8#lO+9}cfEI%E*A5?jmHncuTT^=Wc?1{?(I#QlweW;BuUaT2ei^A)S}!p!8Ca)$ zE@5A+Ht5i&38^C?05vZidlco*Y~>yZR!<3%t+Tp1Qp)wS|B#)qAD@3yXgF5ukr7ad zq^AU|zk~~Qb6QaK#=AI<~dqm(?9mbaat;iW=x~f zK!i~C3DtMMxLN>{5BXRNSR+N@~7DSvs z!v5VV-s^d|j#W`#uAhH{$QYL8XtSGxYk`s}REAC^}bb zzF@3%>WuDjQboKU9$CTg{%H>CsRyT6uF%LX$)*gBwotl##%#gpe|ta1!+q@s^~(Xc zhs4T^!Z6~#6RIa6P5J>cT^SNcISWKeFjx`@IAm85lCwY)gi?Q{;$YTzq*VCDr4I8t zQ*`8ZkMBL+Cew*5llIg7+Axiuy}}!4^(3BwYyYVCb>>SgVi}ny{P@B$D}dfbcof^= zb&~+{8ymIFv8R=dnUx)g&0*h<<;oH(Nqu$?Vg@)EyT%jI*;b@2qj@|74h2#Smi9E- zl5BNlA>53naI1gn!{mYrHO0=QlNbR8@zq`@{0>j@9pb^_yGMm(Gwpql$ANte@e1UL zSjVy4z4sxbZcuQU|Ddy0c(!-{Z+|*4kVwmZ5-K-7^-3$3%(kavY38CoUN*I~q@XJU z&@(H*r?`we_9W3aNPiG>Y_fyPK_`mv>zCfH3Q#Oa2%eApf*V=MBXC5G7 zhx#+iyH=Q2pfV$fi&$Cq!yDQU_129A5lG581ByU@%>gy2j6c{%rvIC6CLg#b;2u^V z&EYQE?^#ThH$o7!j!>2@`>*pyglpetvZJ&365S7KK$+DsKMq;GpB-JRg#_C8c4nX4 zfrcvkiFSV#j)(ExhNCxzxw7^T-ukQOQKl=^%glOEo76jBo|*q(XRo1I4bL%e^0n0*7CZ59Ol%J)mDnnKaPm`!uM z$D9h77+uXI1@(Sclt2)ixx)i3z(-{48m~Wt*5c{i20YfHg~o}IBp|62>SR{r^4_k7 z&~!z!?XEJ0B?3MnpTkJZz4MU?skRAZ-Muq_4UJ8u@1Nv6l2osBoua55eIN&qL6GX8 zCcA%wXgg&ZXyKtcr!N6Rq({T$V}6$yCd}XQu1a2%2jH|ybXyu$l>Da1~ki90rBM{gs4$G>30nhh|lqTM0omB4z zxspB>GTELQ&qjPS(b@ESHhumokc(Zh%K&=!^8!2r{GtXqhp{>5@MOT>@~!Tg&MAM2 zE1Ik@=EG8FOJZGdQ~PNy;j^=#bNrLDSc>K*B<)==u64X@bg47PX~KXhy#d*aQHRW= z(s*GE@jJb~b5hZSO2Jz1rZLZ?3$f;{2Vvri-~_*q#6~6ln`X`_dR@Xre`X!*g${wLfy&NR+O)c zwNB65imEeO5>1JAD1$%aksAeOeWGKRYnSK#)(v54d3-Nj~70jO_Qd-+u{5)edmDz1OZ{RrZW zBqQH1g|C#ie8u~Fb^C-O29QMMZyA4J`au!~vvVKc?;k%aNJRi4#RF^VFI29}@N36X z)u$$2#VGDZ`j3qmdOOXJ$g|BK*oa~Ag5r@a9I7W$yUXiahmv<_X45%vXno({em}c{ zUsd^g>;V^~L~xO9sIj3YZ=rv~3IIcdOyI=-TkTR+>bU-R3ua@@PN!6@?IYhRNU(~j zoA$4-=VWsYHku78%a!{Is022pf~}_Zq|{;kGFd0J^CIF9&MDSLRtzf4-Rebd3A*rh z&VA)fj7s}D%MWw&!K0khvf*K$RAo9I{nRhxeg+na1(g3o*D z5v8+IP1SX0%Ca16uepQatPhKb52IT@0$ncmKO|Zptr$@LHuKRz0FiQsw1+te94lt6 zTQNDpznBAl$tZ_L$to5^7->ofI5b(r!RYwaTY#|c6^!lnXJ1#^P_je8#WEwTtfLL; zuk6SE`c#3Ar_u!fgH3;l|9w2%V5LdQ!9!sRb=6kBDCMxT81BiMIX(;)o(v9tlZ}T@_L5c?B7`86bgl%FC zq*?Wh%(r+O9mu<9I2Jn#sbOoritCFs6|A!^Zg(yr0K+((I8%Qi-~!V zn(|icuT2mz;;)bXwdnQl-JXfRHuEF?dNqRl>!bfI&HNDRMLZCa{x2z;{bK*21wRuO zew_cMnIG!%8FYc)@JjRVjTk<(EW$O%!faM?hub`#9Y%jm9-HXpMHhf51bbVvfoG_E zs&Vp=G}FS7%i;bW$@tvU<24#bpqlT4PNId2aFKXl&(Fsk8t;l+d=Y|Em8MMzz2I&1 z$8d~Vh^bIp%|?;9ncjc6K$EHEOpn2p~jp0?eSLc{;Uu z|IfXT949m%y7x9NzP?s8T9Hc683bD;zMyOAZmZh>@dL)|%Li{8WKBX%(;yE7mW;eo z6%5|K{U+(&tEl+WU5Smq*E6S?#Ce1w2`Jn()$D&)<*tx|S1^eBCG10pr~!i%_NAi+ zpjrpsY;3@D;q9z^0=$2@!wKV**>ht}H_)f3Jbmr``hIOf zvP*wQ?>J68HEW@^j=@}kYHm7CudsUdQ$!{N#4{o@mpLU)PJ9p3K36g)0i}Y*sO8RB zvL3;G3&i)4mplNmgF)z`IlE*g&lR$clvl$_&#GujBaAG~DkrQ1vG$4KbK5LwUZ~|Z zJmbs)5-UZc1#5vA-~?7S*p+^)CoH2VdbxiHopw%A1ue{mIoU*s={p=)`wHYU~cn#h}zTxW^KGX*&7(Jz-Y& z_H$k`wte?a9PxDf^~UGre?wmW>ee!b{4YAM$4ixcAmJ#WZ{G46B0&F9{ASN;Nqv9M zI~Cts=?)D@#^$LMtCAWj=`@7wl!mzfn&B6)c;qrZ42~63K)40zn zmwXuZGv0;O@5JibV~y4+_Iv5{UTmN#zhjQ1yY#1fJX;_;d-%2I1+8gZ^IrVv6;2+q zMfWi!=PT5OR>afT4r)MF0NBWT?r(qTWwE41S?rEBv_$(HpvGRx3@*3N3a7HpX$}aI zWH8Bu$8BUGgO;qjvous_o1N#A9nD4;kqYF;arT0FDo+FUTd zLRSjiEN=U{YbMS8A=>B9O*4{$lE`byQU&y^KsCL>buObim!QR_)pDLm@*jV{1DQE| z)#1lGDknE$Pc)yi{axQrzT&bCPrKZ|?qehJUCUJ5H|f7G;q!5RmgAYYLi~Kxo2}=D zQ4FJ?eZB%2ccegwfQay$_*u@RpTs{#<)4_`y%~i;9Y+5Lgvbp00Eo-Wx%dxY0Y8My zGHh=1_8(xmVOn5zW|!HX$r*pi0T1Z^3$_{DhxgYpkA_YKS8peI@WOzWa%kB}C(v#a zz`L<#)|f&(_Rn=qdyjoZ`sgV_{W-!JjcD~G74SC(g0&pgd4nyE`?{p>TOW-r4bPj# zqL*2dj91S@pHS;nJ!aNa`&hL?ev^X4<{{P%as5s=c_`rb9?7$bBW8cMW+VhJLtB?` zgTE_&bL_NC>H)Pi@5aoBb6>xCxKHH(z5iPfZ~87B6DQE-0f{}h14gx31wZ8^c-yi`AOOfj@?dquNOku_U$uQJC4iQK>n{9Zqn~v zBcQEg6-@;}$+Xb@MP`5lrLn)NqCN*mBTPIzpEdDicy*%6G+M?9UB$fcCN8LH0)cF=C6~Z|ASnz`KGg;ZIZ@{Uf5~Ku)VvkeLF{p57PW({CPu zG%0Ge7{mEgqm#giA`mOJn3ZozKdxI7`S}O`N`9grw(cga?ZLiheXP4zl0nHY?sEkU zelN4Xt(E^H4>)Bu|FihOzfFMF|9I)2#m9hUCVqVMZjXPUyy)FbvkW1AtnviT)XxX<1aW_#GYZgqXD~>G0d?t$NTm=AVcp}x&L!ovf~)@cg$v14s<7gqp{FGV zkWEWz3pZWSGalBi#PZ^E!8`F9A75ufely>z<^1WE__9CsltbiGwq=HyN5vK1;Bus*27$q>Es^ zR1#R>UC#`=Q8~%_x8X%exnp{-yKh$pU(Dv^JK^hD~mZH9&;!?-FN&h0sidB zkurawEk4J21i4%$e47Bc^tNwDbAC+VkzZNN8}n!03xUPT3}DJ&dRd_QOv^M%{Di@bX8tO~U|rDf?kp$f#fcxA^>j$tyiq zN4*hHnU(Jl#@!q!X3xg^kdcVP)(eA0rL=!r69XK;3&->3fyw&(J)!4X*@?p7uJeqH zjz)(mY(w!n1TzqX!?;rP3qx;B-;Pw-ZNR0e&7v(9e3BviwbWjbRq(^tr~zC9yVJt? zIE8oV<}u%Ayd5mvG8zWpyD3Dw98R||d=F8MQ@9p*6=9usIOJ7FE7+gh(l?})%SJ;5Oo+ioC?8^}r ztvng|KCXA?3UmKqzKVnEV~!1I3eT>RjCdje*g;j z0vu@bLB3qTa8cJ{_E4TYUd8;aR&+umK#?D}!)bZMTRon*&6LHtXUmh|iawQgECzW_ zbjjB0@YJ1V1fgLvoyM~vAH#n*jC^WyHq*>e3kZ0o)HlVY;Rt}ux&SWzy&nG?jvMyP ziz-(V{h8RYo6gDDPo7wAYZO4Y2Xe*Nf7N7`fJ+XRDWNzl(a*~=KYTU=-V+M_9DMN~ zJa>6RMc}u?!H%6BlaQp-NKCHa6cglw6(>;ER8W<(3=BqlCGz zYhkMlSX)Y{1A_erzmiTlkq%Jif8({@(v6IpG=P)R?NDpXi@|v?SCX@gdh= z^9&PFcJdQi8kr7>_sM+Ae)G5%o8ND0nxo#~Mxp$Dgdr?UN@l-5XjJTYgn~9zF&L2qi5lM0)aYFlitY-n!+P4!z~#82Y27K^(K&Y`9NHd(Qei zd6elB!(~&u-V}>R*rP@%GRdG?G&ylFfk>hXxY#tV0XlF!smaNz{8Xl;xsRcM14GFE zse;QVTXP--A{DZs7U-F|gkSeKg*M;u?`i6Us9hujlc6hag;jmS8VWD>GD%Ah2;s>+ z#`gPw;1PdA-W>m{@+yDw=KUZ6(Bfr7!*kUo)z^M$+T99j*59Y|V->H8PKO)gxxGb@ zpjm(o*Fp01Kloj%srKTtdsoZ{(CTvToyB<-u)3QU!|acSY7*jQ)EGC!F3`y>d2cBF zGJ(5P6v%OVdo;v44Q8%TMZK-z6u!Q-e8-_FT6BL53_4!>0q}1x?ry zr31G{12Ao=supsMACxl8-}J-Y+be*idO%=E#2}&2Zk@~>G&$<)u#FA4d~16j0FktK zm3kklA0ReSP1p4}IF*QtgE|u{h5wZ@ z3EsroKp-_h0s$pLvk;(}pQP&}yJjq9x}<+sb3XkB=r%n@?H-eNEv|S|8&%>;(ogCm zp>=)ker9(UsT7ERZ*jat40im3&`9G(;$2W^r_cKB4V5M3Kgn-_7a*ADgUVwxdhm(m z)!9oPiT9nLS7j>ih5>b#OT3)*%|$G?yl_j^CU^%MZ( z$yeAXmFBp(%f`=7NF2&Ud(S&=V|)_*cy6Qe4K~*T3t6a$^4?kIe=o44v+qYcnfTM% z+R^q;uY;Erz_{Is5vpW&jj3B>9GZXhO^x$D6))cy`{EbfyEl{~QyA_#4&Yi05&u3~ zo5M93xx1G*kyiP-h71huj4k&07{6zj&;b>LOMV&Xs~ddU#@Dj^AclWP+-Fp~6n%0( zQ$*@B51L~0<@gmY)cSe7pIZvGx#~GI`O`l-A|+H731C^sk+kOo-To;sq*8zIAexLL zUBPPg-+o99@8Be0UkY-076Rrz@Hi>8V5a=Qacac#w%F}W=Jod~`udvGloz)hn5&>5vNIUdgM{y@B>!16xs1yggI>Uk&O>Q&QBhR8)C|4lKb{S}fY zaw%H0sQmQm^}cK2_kDlZ*F@n8iTlX@AZ@qn`q@x4RB4&~(gm=_74pnJ2EE~H7juDV zf;FnmvZl=v@vQ_E&&NAx;%-(XRFzR)M79Z<_EWgu)}P;31F8A$IkH3NgY*LedR>e? zl29jf!k2Jjdy3_9Z%S^;eK-09h66+8>-R`m2+D&ccT5Jig0O$)FCbe@TNUpDs7wZV zUF6m_&=}z7N^i3+w_&d3LAnU*v~0M{ezmkg344}$@69Aw^Rb?Zj=CQ@LxNz+Sqit%Px_Z$LLx;Rh8zwR2R*<{Y{(^oF$TC}nc|gd^FP zDkr~Q{`9_9kL=QcWxN>pfLlEJ)gN(bEwUd@0F48!ToZ9i}V!pHEINx4-Uqh5W>K zt-K{q!W>OZg?Uyg_-uYMc^U{#nXS{VeuNrk>h@Rf$wVSb@uO6 zo5^}C7oZJV_1*hBE9^N`Zj{Q=9iv|age%;^U}pQ?8cq|ZvTdy7u+KGzSvckN)BsF7C>K$r&;t7^FY zw6Z?Sk;cq}A1Qm!*F3h?MXx6*9NC6i<@>x~kI>t907%#{iIE!qch~SQysWZ*yzI&+ zkGj&IhmsKwoXawR>s~DV2fI@IJ)VO8kLf<_|5*27|1RCf{|cW+*uQEy z_HTcB68mdQ4-7&7U+6xB7g(C*{ykj~|50ze{-^HSM!-`4d)@aGIFfmM!0T%K-vmy) z(d>yA#RKL`je}G{kh)6iHEw8KsPc%(^`!Z9BBHxgB?%w*2H&=sRlA4VmYI2tDmc5* zVZny{N>eYajP1iEZTuZQY^Y&ZD?}CwO*(%?jH-^AJhjt=sp?dok~%8C=o)Ao?0nTE zxWZj#@DqkQ$D~Q}Tkb7ELNO{b(;IhvOyq1%*&&wZD$!K6iY9nLvmwrH#J!UKC(rjS zukp-)hC6t|vKv;Rel;o)+t0MCv=YThA-EsKZ`{8;j|nO51kSPSC4v^o&7;Dd4%!RO-vE=&EhagFGce^1kpr(qGSCK>xywSz5~?y zU$VlxEm+WF_yFN6adAbZ07mZjmKY6{A@1l=%!Bt<^&n@Wgj{zWg2xt97xN0x-}1pu z$}W;COuo2&21*=QCYD?okR;uxGdX|2wRwL4!q7ja`5|1$>gvQ}>_YY@(==M*Fb#y# znTncUbzUsEmzHc*WE0txJQiKmJ*h{X#}{6r>PW_Ah!d z^eW+^hD5`ycgCp3zTNN7hpIDz?kqt?kYT@oj|=kXfwL|2ebl*zzH7>u?zn%F?#!JT z;G&$urW#d(waVKNwf8qkS;#HZQr3RS<~mHeaY zY_+PLa>BkyhUL;8;f|NyYOa4W4xQV&yDZyZ>s_0eWS|mgQWT?euv{18#`@>dKkwHM z$}Yo%W?ug3fjRc{&a5oj{50lwrX&b(5O#5NAqX@IN^QYjQb8x4JK%fdx9zIY<<>N$FIojp=$CO9?{K|jdO?#F{1SY%= z^K0*dEULfhLos6+IjJOH6={U4vV`?Mc0^&=Q=s7q))UuxSkhg*e3xVFVxeB$%yW_! zmya)PoMx+?f~LF1{QfQyHFiwj-EF@X_Wc4l8UwvJhx!7jp5$Vm`iO4v52(3~=+ljx z*=Nj9l6_6Ak^%0JOss!Y)v^ml3~C8+tit?Pito4knBoITHv}dt3_i0>W>9r%+3llG zZ&?YyFcjr*n6!|$gEeK@^~Xa+mrfnIyhg+IrXzXOzNfNh-YqQ`lS{%2gncxy}xOuQCxOvpsobY9vt;z>Y;O$jf@Oyve#&N9)|1O=X=1=*3 zZUyqQ5Q$Rep?hC$K-TOxyO!P*?82Xx*1kI6<7B|8k)wcwPg+DA_(uV1s;Te1Vir93uuIO? z`C~lO+efUj!MuNj;75n~TSL7+wRzC|J}OUvd=XqtFCTvVkPP^H#SAr}1u!(JDTQ8p zvL#K^*iGLKBMJ)e^D$+cfoSLryK5iX96N&sWNp~#X`?I{`V_5TDAb*TotJai6Wj0( zf;O5-26@$drs!3rREvaaOYbhS)^zid2$gF%-l_QKkH~)<`FMu6y#umfP zg`DYxOx*bqlEOUXyXN%Le;1+R1nH?B&<^aYi3aV?t$BUI{f)B>Y>9ys_QD(*mO8`6 zRVkTu;kM&D$2^Zz%I5e|4SU`nO+xOQj<3)JlQ7Ux@q8LZ{$3Um(@EC9=eZfjMe2)77UH-bzeyCm`nN1{-E4Vl%ihC-@Q)M9s*tXOwLR5!5y&<1oU2^wpPadAO z_RFUf&<$@E)NLY57+VVY#Z_uqzx6k0LO-n6kEaj5@hq7i<{1J|5&AVuLk01B5BxK>ZqU16zhhZZ_ z{7M;X20=wGXG<;4O?uFtmCd|MebO_omDD$<9X$FIOgI1EdoF6EZ52iOTA1MzS`r~w zM!tV`qXHb@6w0U%IW}MJ_s+)aW1Zj6xleok#Zm+oQT#1T--qJS?j(*}}~ z@1FfKnhLn;Zt&w<=i(u{0{yI}xcnm^x6=g|KvU0 z^?JU5J$M9b6C;xbf?X0QNv`fE4itZVp55|!55Rq;#+rARsS39YojNFuXb~Z0wKC{tD*vjbtL>Uh_aw0ki3PGF$Tn{zwCdy?1Fgk zE974xtV9s)Xx`Ou{6r4N+dC29k`R)phVs3GF^q?NBnYI|eEGXD*+V{Q=`cNQ&W&z1 zg8MojNAysVh*ICjn7tt7X#F%Fp!4whQju`J;4e3N`+R;3rJUbd!{NY4 zud?nO@uNl`B})B@jAxU*$mc_-K0jo65gXs^OPB9T1jnhF0>``$8qlW&O{l#=Uk25wSJ6hV6-l&gVFl&vf*`EjpgDX6pGPfq+6Y63A9nA5O>0DO zr{_lrGu`7;p;>$H`2`*6z?IoG5z#LfdX&X}+Er?i^fa?)z{8dCFjrDW<^iD zsM-Jdxy9_Q6JYC1vD+2jK^}J*Q#hk?8)4g^;ut*zSnYoo-3G()M=kP6+tD*0eBwzMWKRTxYyS zgkiHxzJ66n>_7sO@Q%|ke7Ch3u6&0#KM2@nkZ}?!J8H~u{+Fq~DysRKMtF|9jO+Gj zE?ouCEfWMkgmayLllk*{8z%%a^jN~cT^GK>zZfyyz}=M&KAyT1dc6DmqaDf(_zSjm z+TR@qy8vbmNNWz4G$ds>%ew<9{Om@q*)T7ia^y59?}M%0Ne*=uGm$m z7W_iL^(zzM_t@^ZS(2xN0zga?>;NE69426z5ZmYDJBHPNpG%El!;%DX9=tYD|lTS{N)GcE|Bomg=GCCWS84;+F~+BhvOTgjqV}ifRvI0n$S)}{$jxp z`Z)zKyIyI3YRc;hm(vOXCqz6S&Ity0A3Qzkp^_|sT!qsVr^)w=*`*^vDL|}YHa)P{ zN9(e;@M|eU@mhETo-4g;E0vJQITQ-O@hyH#?n{8Reg^-Hp6dY{E_7jD%%`DE zQyL{>O}|OFr_%zbR1coeX#dRseYX7-7v@yJrdW(^COk_%wbgZu#~0csf+i>1TO12< zOz1Jurj11)a$JTfQL%}D?9vH5=^a1b)^7oRPts<~a9JE*tw8}Rd1nx)1iTC0Fh?!H z2b9TwjN}h*u~eyfx?%y-I1caeU9m`%5myVt93EmCnw9vQ@`uiDLex%OSNtNSXc3s6 z{5E=|KWifyr)MVF`H*e7E)riwzAQb*i&cIp0iEmsXb8=Gd2ReIu)}=z63$TKWTAb( zC`&SyMX3#)`%*asw|s@AIFk6?8fP0EKoTNmDu9D{))tT2Lq)R^NuS2Z7|#8yPG^O@PcHE+_5D_ zi^5t<_<`O;Xz+|?XNESua!^_y#rog`wHx=>w3x4aOi-L2fddw2oE{vY99Q52ura8A zagvGPGE>>Dbq3-+Q9?|fcnp_-bNEVqCl#c8b41gTL+wQIRiexjp0f0$CC)+74G|Wn z;Wn<}OLbJ1>37Lmtxl}FAfx4|JBAu_NX-5-L`j;?uw@yY4JAMPuQZ5FetJ>><}wm3 zYrS%~5E06SAx6t_#%^r2-0pl)JYh3`n6`#C!4^ucziAHDE>$#PAdz>Z?#{O1cmeBg zv^HKLXg`h}WvZv-h#Ql}pEtrf7ya4yeDsjiq8O-nz266Qy#5rvv4Rc(T$X^G8SAOT zu8@6Y@(1BT5SY#<^?e6nZZYb`(RhjDV&Gs*Xx`@#7fxd)(M!)>_Lw3AOLjniSMRlx z<4P5PI8oT2@Zlr`GKfArj}tz$)(^%eH`C)xe@0uXKPinEepH03Q-c?qIvh0}&9`Gh~(U^39xCapXOW(ba zqv0oqha)e)Tk$cr$lql)+N$M=H9dtwY z>qHWBS>?M}Mj;jv%uK>s? za0f#?B+2zkJpbX*EJWS?w5Xzc0VfGGYOntQ2t15{OC8U|wH0|=^}RnA=zi)nVzr0s)z8!ZyncX<{sRQfr2>*u%o4FfDpqW8sacC!n$<4e_DUx64yGuLozH-qrNcn{IJ|YBScTjP za94Jjp#bK=P;T8X-9=PU&BNo-rQU$PcUj*dLxtSD>y{DEWkBX79sqA(eKOn1;uVG% zzyV;|3Ai&hiY(>V2-u^)VkDI7&|TUrJO+hfBw#t~CW+ORCCy(;(qxw6;ZvEW@;}fqOsCxHq9$l^-()g)DZg&D-RYrUy{VwTUJdRBJ z1(GgsJArAZDQY=zeOiz~>#WbAA^r-nKz|gOKc6{&?(w@L8u3HyNF^w?U;d7W;j)+< zm~xY&yOINy2?)Ijv9f;cF$Kkqx^}VQ0ka_u|7*ne9`~*PUkmo4-=5lS!9f5x@sY3R z-u+tB3a{62Nngh|0H&>2hZKIH%>=EFqYig)QeB`R?RbaE(0c(m?SFCzge* z?77c>4b6d1lF?j@Fd?RfxDi)gG7DSHoe%puVVgYY_8DK$?#;M02y}9Gz(@WN`W)sa z(LG*^m0+N>oYExx!1F8Lwn8mB7aq$mmRN36-}$k#;dTx4Zk*+C%1X6|L9KD|K=2W=yiictY3^#z7jUm5uO z=Uuy(y|Pxf4G(*sSfb0#U1X+;RGuAscx#kGF`-UQfWIbfXA~<=q*GPU@ zCtocZp3bxb7?~}~fhr$n>dNDCe5?rFBG&{!2QwY^~nqZX7hWjQkX&$MgcUk z(N4#EaroiL=bEk?cD??wXF*VqHsA8`1oLVtk17QCGQXaGJ;01%Z;3(=4S<9JSgqdo1)%5NpZXj|6JY?{ zStmxbb2|2hDDc*aV|%{VlhoS#4DjA@SZT0iyBps=UP9kK1BsBsvL;LI$sz`B`c9Gn zU!VE*@{MqM9q=>+uJP;%K%!^1pNyd>1d{9UJIqn|_xgwbKc3e%Yz3bj5DD^sAdq;B zsWPBSzqWLs=!E6{Kw;=tefL0(sYK%a ze&gDbobv7uJ5fsOKv$D}HoBVdH*(%{z9^nsiWm zG-eX9o+B0b5=7-$zE9$ zPtA$bpA;V60Ex7<}=2|U;3@j$eF7T}%`r`&a zPhAF)CmX??zLxFe6i}xh21p3b6&y@1HQ7D*%z(?08Liht=agW7XMf6Dv^YC}nRQkB zT>Py0ROaMIqg9utcb9%tOG|c($Q7})lpSAX_@08Bpp)15#AWvDH@U>M46L$5Oh`^v z6Uj^w*s3!dOntP63nep&L{o*B9k-}IB;i%PDa1o zn#VN-rzQG5>1e@!5SjtG>o;g}8S~hHof}y|3_*_=g?5b^klMHX9`9`zBov?Qwkt5O zl@FV20dZvN<&MAahr%-t8d4?O;drm(ZoeuSnqKuYQW~N;oTjhUhYt{epGt5+VHGKY zkZF+ifJ(~5%Q*Mp42Xr6iy}qJG}*su+qkbWB7tbI+QPwq-16IgOOfq7xBV6EuZg6? zA13*n=#p+9*t)&oO)d9_cyPQxO6ZZIjAlIc7Fl0uh(Y)nx({8Ej4BsCRK+nOxIbT< z-$sO)OFD+kf*<-2;)Oa?E0*H`x}!1mO+h(nB&SS8UaF_Tam33T1x9$<_KCq=2FQCl z$SCV3WG;h$#kkANRU9qGNd{VeQEiaQJl!FDFR!3#8Bf?5fr~WP{gp*arzz$Uumt1k z>U3@V=bV!x(%HUnyTP{vE>*D357!f#ijx_Nh!SPHW_6p+;}>`z?Ad+#>PZ%%!S6k? zcoU*y{Ob4DayB9CsCXT2yXawwaZ!ytrN+;d`u53x+VJ}`V7B-X;EXgUo!d!g$MPEH zvZn#2MRYH=p7IZKWo((PK}=%FBf>PQfLroIGd3nSYRKY7Mr~P&UbJjqrlti9y#IIs zl39rT+5`F}uaF|xL}4+pVwLkZBypXZ9SscM!w<>UYIXnM5JW&I(7ZAd{BZQ7NfR(3 zBIX5uK~mJR4eWRxpej>r_G7_uteTzyhbS3;aj%X!t}Y)R9QS0w;fehz{l0Inij`V_ z!e11hC(7>Y)RUBV3&EY-7%A0P0ha|}9YKQA6+#__>%&J^IA^jm&l?AUjOP>@btJ{m z0?%F07<|#wQOUxm-=i%?mE)c9nrHb(YjRJ2m^dBKJ4PVl&q+B$x0( z=j#JkJ8y1VnP27@4rUNtMrY;&C1u>yrouT%3pT~jza<%B=-;pRZ-J>mR{SsPq5ao?SO0o% z*kA7r`|G`7#Q%%XR*7L`kzj;>OK9tS=iu_hKSEnYadlqwUqV~e41UAfkGoTH|7%L) zdu5(Xky9$GdM68%+e__)AFT7=w2>t2sOYE)`OIY=z9sduTT}Qf$T)&uQE#&A){lwx z7*jC(K(x=_ocwNQu5BzCy^zL#myfQ~b)V7+Qj`WAu!Y|yMF&ubo$_Ly_W7^}hJ=ZO zTtrR$9guH6F1T#lmZ38HZ9y6M8_IAd-Xa`T7|2Bc55NC3GWL|bgyRg}6#%WXGUb^Q z5;w`*%_2Ru3+|UIk8dSAw6wdAsAQOK?Bdn)&u1KbuNM5D_luGONT&3E120dK8y#XF z+*FbCgjQ0X76CpJyx)xClUW^{#P`vw2;rZfbEb4K>sS9M*8lbQXYuo(nf|c(>&}7L zdgSZYdIv^mcJD31FFo8_#MPvTnP5pf;d$U^&s!~TEBbvN@!-?(QYHD^nf3E6GvziB zBqSuc#wvy6^9|}bP%s34Po#Qj?^8sh;d#{GspPsjW|Vvn$*hS5LQ>g(|I zbA`l?DU~_FY+XY@BVz=!vHl3w-otQJP=C0(;g3#LM?fD%Fk-xaa_#>2*{s16HNr>F zrXia2Pe9%t^4E83*^!917|~^fCTu#fmbNHZH`uf*#X!}3o;DT}R zT+*bP{NdmqiQ4YW7iJd^L%D0|r^cOAL2f~Zn9kIXf&s?*K06*fY7|sAw-6xCpa`hZ zL=h1O=(iph3{Pc$6>{FBmKPYyHYiGcH#_oeA6=wfU2A-i#oRyNIr~~&tQy-BALzG1 zWuyL!`2Zip`a`Mk|Sw~px$0@gF@OoFpOv6_e_n6mA%8b;so#@Hb>Lu#2A z#Z_m6p-gUwyId-fvNe%EM%-f|bPUbTX=fbMUriR`77}iMgLatL_`(9$;~QPa#Ah;x zT59=I4aTd`3~lz14Ob8m-0je9P|c#O^d-DRgEiQa++Ol=`dJ!gpXQ;X2)*3!%7CmC z`aBHm_i1~a$$grw>@;=CplMnv``X&^&T#KVMXmhnF|T*J+g=p1;&s5D9Z$(ZYDQn} z@vRXb>J9dPV+hZ1v1J+V@32jvZdBIqC)Ao=+h?K25r+#Bc62S=@N~t9?Dc222N38S zr>&+&UiIL3o1|z!!Tx|!H;qdzZ&cbnC=#)I*3@_it9 z7x_|c6h-l!n=i0_6k6H4ty(brf%OW&n`yR`$pYZnF4N7crHT`@YXRdiX=p+dOn z4iCz_K!}3^-)WSFAvPa%^^^wJu?0TuWR>=)#&yv*&c5 z-Q@x}nfITq_A@2^OIB`m&MN>uVF*5l(gP3Sm3I6XzK|D60J`_>+})Er8C@NJgw2yo zZB(!+GZmxI&@C0TR|CCd86_eGC7+?@hq)|!NJ_F06Dx^QPj`#fLy2w9_{V(_@iM(0 zR1H7tv_LoUOpFc?rZnZ2N5u=oM)+L>B*hUW@wRjf$Z=GVwL&VeAsl3H!Kb?eC>dLHmsfk7j!?T zC81xW$q)dvyEno-5D11|KVI43>`|gn6bT`jo-^Zr7y{GfXtjo{_d+XF^AZgA;c_wi zp&eSG*SoFcH&n(aEoc7Yh4=ZZ2yfO|alXqv6U#>)j8LQnjPr2A1P;bhN3I4cu>Ci; z4kkX_r5^9JmLy5qa9QAg5SVqIJwuKq__}6tdQFy987WIguqdCKt6lOjMu#sxQq;XQ znlTWBoc^r5AN_*H-!n!Wo$Rp!aGl;BgQj~n^SbYC2f@v}MUC^AbT|*$Vw>ziMe8K$ z@NgmHR}Txno#jq@cRq*x6sIW<$t7K;LAAJE%&JPH_BSQFkB2dT0A0Pcxw-If#WbRy z(YRRkT(v^QcN>@?CLV*ozRmd&0j%ICxxNd8mCqaUFJyzCiDxx#|57#gZi|7k$!nY~ z%evdrjseMRj}yXQ3)UD8SRw#2d0CP;A+!vvqV9lV2QXyn?G`p3f1&aLXt~i(Kdy&~{iee|OYcC^|`^M1}A(H(m zI-TeF?339JtcTb5J6#wq*MB^o3yr1CnYFk%ve(JH8?tvJ)qTGMe_Jvz+EbA@zyAKA zlmuj7D?RL6^iJy^k)LD+ms$2>IEXX(r{}}DV0pZ(cD6)+>IgZ+Lka$$VM}<|-hQl| z=4Fq4B*&Ab#xPY<>kd=bhA#2D?jPOYYtkYZ+~UthI(uF}!*B7a^UUC8PZ)R-@$yP}($6F*x?S#Hkv#Ac;@y3L9UoYw78&0cUE0L^?xp8u&Ui$U z=6~KeCr+V%yIimM`ZHf5@biD_SW?hk*58vlgRhLI+bUEx5N6fXXF0OW+dA@`#ZmHt zVKD#XE6LIr?z7o$asJKHt0UjBT*}MDEJ@Nd7|AuaF&PTW2NjGgKa@a)mRcn(K4kenGZ@Vbk(xu!r2PV97w_^{`I`F3R!= z-X1DRLM8-}myrD4@i#8!yb(uf%xdPSHs9%`xh_$?J*TM98EAyugc6)SXlm}(2CvgGC3GT@>^Cx3|5)L?!LC~dHDm+uG z)lnjBuJS?|7%17rn&&?SVMjPgqj0D_f4l&9JojPqKo*~btv5;W#cUFb#F%8>TI&8B z|A~CMn6*v6XOPC>05m(-HH9RlocY$HP7r!z z>pWMMW&S+$GMT#OlpQaRzrst<~7E$sDXF7a{KlKI?45dm(;mUU*=FZhnC#At56RnubPSQYq3Y(}sE zX_k!DW~^hBC1)t6AaoYF8n7-`=wmN`Cn0tY5E^PiGxTJz_*|izno2jg*cD{nbA>?= zDjLa0UIW?V1LSZR3C$Yd}-dG)uprai+@l$D3nN|Hy0zg1JNcxUhDh`U7-Lu{(5s&eW1d93?+;VY4EWmxC$6otXMSntzk{81mw7pTg42Bz^2XFyMiJ$g0I1g^CpCQQ?D zplhQ6UzXSuNatmH5f+x?Wm#<7`Y=}yD1MidDlTLaMvB2?bDOO{M!E&p9X#tl2Z`e} zd@qi-Xb-$oHS-5i8AN#K1#T7up>yq0A?RdF~7zhVzN{TDSx(=?JiYPbffPq?t70i! zhEY|r?z$1Vr*@Y|@7{ACzez~6juEuIiL{Doe}EoK@6LCdXY3KrSnHmD$0iFlT$=DJ70l2CA#Lg&F?A~?He~`*8v)p54im^kTKI#W6)%qZ5r3mC+4riPw zGCzEcP|uj(cdR$S*8vb%iuyqcvF{X)LSKuoOeAn^e};3zUh%1Gd)=+LN<~Qzf7XJ) zy+ju%8ym*Vi)*%WVqc$s!Xr2z@CG3ukRSBnIQ790+Fe68vLU}k-*;v}I0( z#>OL&(39kg9f7uVpk20D#Vu&{VFpuGH7*AWc_N(Kw|;%Oug@J7-?$Z6#e&oGOk>TY z2E$Cro`%g6Jy;PCpv_z-Xj1jkr=M#Wn({7W$@iXv>v4)+O_d~nm69)Y&kkT^r9G9W z$MxPM^U`86`FYo{##b<`$@gW*ujQAi{7I-Hx zkJCQ#Nj^KO`y}WJ!!*l1_z6igu-20a4V+kOx;q^2u5c2E3sBq^x^ZR;w3aevW`TcG z2|!7@;o5-5cDqo2BXAZ)&N?f6ONHLkmt^QkhIzg+Y$9?Si!q=br=H|~)#c*W9Y@4K z8o9;fI7ksz3R@`LS-q$+$1`+(Z0osn-^a=BiP8|__O`yuuM$)W&`If#d{>ff4#uKH z#Y54k55srskkD+w85ha;#E;wcy1E;pM-&*sslC{UQN@{mT`BA{X9BqUAK=Zk+k>&~ z-Ze+GLq_fc>>9Y3&F1JldMlCJXWsLG^$#0?s6be7RmIhsN7QP=fmz}juIM;k<800& zy3DDP{J9GCQ8m>}Y9Kl{)5p%RR|U{H_T>Cj2~YJ0i2)idxKlvO(s3+& zC5xS9;X6b$FZLH)xT8bL0cGQ>^L}*a-NFd?FK8IarS3W_c%eJZlm_xrf28v6&y0SJ zpLNYME;6CQx$CK}CtKk8J0#0D1=KGYmpk~iAp#bE-jSN@2A42&UKd2iU!;JNp44rA zM~Y{>DC}mBDlffe9B+;B`WTDBgIS~}6<61unbwTpfx0W0H6%P}j!bU`Y&55~ zHJVI+7O0OJU~Y0pzEWgUmiMDvbQY$q4*7W8cue2s=a~EP5OTsJG~q&W7n1uoUI~@Y zplE&#zphI;4$^oS$+Ai3${*)6(p%sP^~IoDd5IihWvbO!RVE99-V}Fn@2>@g%j)5= z*S;PE@t>-D(uEE@Dggq2A@*;q0>r+7{goe7x^frca?jOVpVJEoquO5Y)NnE-W-9~V&NBAxpNQx zbyYp6jea-dQ$;;>qgz9#D<-_Mzgjoyu4AxGcxfG9GEcq)g1#3BpQrXl#uC7%+h+8C z*j1JQ{I9R_Qq!oP72|U!)}IaqJ6_57MI!Us{5;`aauPRdNMg;NMx-9mrJY11e zG|wj{y{d8ptntEI5crg$sv&ZmI|R;ud(COz*O9VBkb>rs`ArBW!52(@eNUQ4>iadd zAW&ucq3jut9?|q;*r@I$!B-A?>C_d#64~`|4}_DVo0v`YU4t06HZwM z0+)i4@M_7(JZnjk^XiXbOBEU^rq)zwqq{@eY!EUhl}9Mn+M8KFgeoWmQtP( z3NO6Cu>m!zFPIHC+4@HOmI;A>B=xaJvNT<_42E$VBW&0vuld83}6Fj zDXY;sZZLeU$7O1j5wJo4Cc3Nk3v?Y#QL0I#NGRVXebceUuUg^}lH9^VT-&oN1Syo@ z3~to+j2rn1FXuL8(>a=(d`RHXq@m4e3JiSgMPJ60sNQ>QIT8HHrXT%(euB?>lp=bj z%zpTBtcZK!pwBapVs+>owBfa#z(fE)}_~v;A1O0oZ~4v`!er5 z#HK=04zXRy$<;Dd3_|2(s z?=lkjcDrO3{o)lCpXKm>Zvq^`-;70WQBYbStUwY|1*h=-z!5(kKx92~vt6cS_=;Z+m)J;YCE-M*A{~`~od2h@d zE~R|q7ETf)TI!i~3hXGp((91)Oxg#PX&rM8?t7>owzUTfAz{RSCg1LFvAwMZakwg) zXGxNz(~%XZ*MSgibywoS?x~g=J-y*{A`6;pTu;!3LF~+BqwA2~bu5w`4G}?7eo){$ z%aBTy;B5x4EG?KZO~K^+_{QTY`iXaFqmnXx{sy?&T8KSiAuw;f6QKI1-Xf-zG+eX3 z+nHV%x4e#f2X5hiyUyo4YD zvuv8DRI!57`#NbQ3s36Ce>kqVnQ&WrOjWLTNtXKCWS!=Jq#Q3Ixa%_ZB8o*ZSor0V zj{iopImtO#2A-vD5Hf3f$GhELVi_v1*364ka6~LB0;eXeP0i8 zc@Q7#DfTMoNapxWpV^t6423SdvzKS3d_c_Ugid{wb1{i_C;+bZ(CarD-#>AQ=b0w* z!Ecg?mq>empt;eN0yBevgL{PX(E&c#PkaMrq2Tr;FNMHO`7i+Kk2ILm(-EC7krNm_ zH`{~gRZA2mi^Za+Qqh;Roc8`KxclgzkDfJMlm&iYM4v)NS5onES^=f!VHx>Nz-Ry! z4ituxDS9HaxDtSJDSN*}OUpR0zfUY8ydTS}ji>E@Am2@^6}c>Z->EN!{b*14-Mu%g zU_IfZr55u!CN$J#(*4++WIshcIA2R3edN2>-U+H1hjUsSG;bNdd=*kD>(=lTbVG-Z zwkQVS8BPW!U*-Lp(H$;n!pleiCgnI7qU%*N(cvZ~U-2%u zILUK=c;5~C_O3x35;o##glL+NEPQFYSHwwJNSMJBo3HUX_Bl&IX-eFt8@%S)=%O^l zCJXJafHH`we4RRmO~P7f(>Cl6kv%mgGZ)V5bw3z0=@v#cHC~EMGP%^@d0_S0lwe5$Mi8oUbxMlMF;L2f@m#&yoXJ&Wb+X$uW;^YgY3>RSZ=(PwL{l< z%oM)3<8yzgz_nfe>_OHK%*B`IF;V+wyRHS$=GaId{E0g7Kw32bFz+qtPSj7 zKAUO(;%Bx3K1M?fi1}+urVAdp(#^h~pSEc(DP8^AjSKA_w|6G)L?ue!18S@6YR*p) z86{N*h#wcsPyP6o<)fQ~lbhi46A19cFz}UzRh#JBdYlrv+DLtW2{cZEY2O`t=A!uL zb5n+gKN!z04Y$u7V4%%L*JAO1b}~P!qJ$5LxF`o){>{l9^P4cjFvkbU<>3m*azPNW~*-Kn+y*`p5Ygy#*v+~@j zN>%yJh^4f;r_q?x-b_6{_ zwjndW?= z04cO`+)f7z@g;{V)H{Z!HPml4y#%tN%9R&KExg$^>0zB))Xz_QW3ckheHabrrjx$& z`!+Ert%IMHexF73vBdg+slT14Xn17mu|2ioFu;SP#O55G{Vm_0&POgN)Y(%q> z&8xhsJ-pRE$lz)r80uoCWSTnz|Jl?hxXHVYCP%FS8gbPjvih5UgY?ql&3B`)%T80O z_vUI_dBO(ptt5HB3B=iEka#rV4!OB9LkDTG@M3eoOXgZ3&ouuQzjs%D!>f_gz5YcF zz(NQ@^d4mEg>;eKIsE>as_i}{54hwtj>olUPNrT?mJvG! zkCuF|Tu|)X@>Y4tdKLE^(1cnkXTe06E$&1-2)@NCNGKjBd5!>4n!Bg$@jro+o zr>t6GXzw>#I*s=J&di1;#scrT!L}>gAoLQxJ)FuOFV#quGE;UUv&Ld9x|@f{0Lxg{ zx$F0HEHn%X0;{QS_tmB05``JAq-k*|m$8rIYQ2j*ew8y{>!*ubApCU?KtT^Om@_zE z$d_ASsahw0Za3Sh4zRbOIQ6PCS6qkh~9+r-0aU2qV`pBRE|3V9!ustj=uUG@)uz=G&L=4~_o99+^GkR>U*CGB4A zh765oP8iq)&zj%BaqrS+=6CvjyM65*9wVb6pl2JNUuuo?4c((863K^M^Mf0U-ze6^#S!e;)MA>kRv}QejJTU&AaGq0CU09iTy*_)^H4LSe<+&u1 zK=2BC03xk)O1gFJ%^smep~{PvK)kg3#Api7=uqNQw{IGkkl`D2>ek;BN*6IvGboN_ zpB8XmKVxi>Ue*WEllioLf*W_Q+h6t0t>ukm(MRbHMT<=)UephZl~fDNWc3lO+{;XV z-COhw(O!8nhgIIhuLdzL3vZUgz#RS^-O~H^^62Q9fJL}gvPshz4`g}dzTl8h21RN$ zL2HTg^IAI{3I^J`!#FrH+)gp7BtCpUjQus5z(g7pStzEZp z@Y)}sOJJk9q#mDlI*e7SAFjkTIHlHq5ZHTZF*=?1YyEYk$}Z8?G#*p>nr{>7o2qA= zm>)v~mjOVFujYx8&XC)EV8!^(7jynjFl zQ(Y}Kop2C4{v%kDz)zC#lAhX7d2$su&i$^2uG$7sqlR4f{;Jn*?CUt2o6a#OTS_^{ zaX#zR;>)!Fc`bmqsup^o5mtH6Za*)+c{6R8s<UaV`Ee zsRZSn@%%x}$CN2dNf6VR)7ZwpuH*O57CDIF-Sq8s=m=h^ ztR}BThO2ahg=KBdce@_T*O^TgTHQ;mthF0%YO+Q)VOkM(bjD+bhO`8BV-yE?XCuQ` zKYAzmEdc#uC>}Pp`@8sDXIME-d-0K0l}CwYfI3Epmy6|{_c1^nzo)~02k#w^-<3H5 zdYMW%MVi**bNFT;grndpmLC@jSJP%7v8#{dvF1!iTvO3>yzl@b>r1K&@@sOoSZGne z?491<#~lUnMeURS%zl%+oGqy7Ir%A$VM-Z?-x>E}sU3Spnj4=Uq`;_t1{$j6h z{doItN@ObaXh(twl1fW|9Nl^FIea0qo$b{q5S^4h%S-BfpY&oW!jS*k%gQRKOi%ZC z6`QGFI!kIH2P64h0^sMdckvPv_;GuML-Tz`2&dMHN4XDg@J(f}Isq$TQDbr#Y)fVSZh`?JwZd5uJzibDr>Zm7j0_sQgb}jdk~bJ>~4qjP$MpIY0i2|KM8ZVFo*TCYh;PA*~%o#q?G(TQ~$HmA604CU~vlDHU=s4{RB z3(H#bSbhh8pDcoTZYnqGfJYy-La>`=I>BH~jd+FYXM%+CReQ`sm)IG;V);?Un zm(G&sJYQQ>I<=4?VfHb5<4gYhk||CcPcjk;22$iY96MSgonCtr({Ngtib6AL+>XMp z-xZkEE<)aI(E+5?zkfwzOL(QCvWeL@cRii2Wg$&}>+FlQ`&h!dUfBov$ko529W;ed?(BKS!d@)u!7k)jF2T zVbWhW0KV3q(vK-YCaPp!SW*N*ZU!lJ?>cFJLO}(*KZswKKu!X)sbxEEVd%=|NE8=k zBfx2?$LY?<7tw6Kd5j32uigv;Pw1-@owjLzjM!~Ga9pCPBJd!^R|*l0FLuqHg8ER)jT#e&zfkbTq^gx{u)*O!k8fipG~~j&~IP(5k}Lc zvvFZwIHmEmNZ2`jPLg{vYdMW7EPhKWYWf0ZDKRz8+;wVof9|?X?d^t(GkEtep&A%} zh7zbE*(KnOox77gPCtmGJicg`?hSzQi)pZLbubp1#1g=7hfV6QLa~J7h66I}6RhnE zZV$@FDlbG42u7A}jl^W)RWLcNC#^*0Hqw9-Q)mG2eRQ@ROC8lic*MuJTosu=03HCI z@p7dUWm)#pll0@cLC2`+s9$Tv(wSU;l9i-Ig2A7p^{yqztn{fW-}Iv@tlN4@7U-oo zKoV;@XVLY17kkc|$wM>UGKe?(Z^?_~ei#NY1hcSJH5TEnojM+L%e{!42vWVl)oo-N zx;LUWbu@Ngl9Zq*BF^{F+ikxu_HKr!&U21*OS55peF9oT+>@;*U~P&?96zyt%cW}- zv|7+NQzw;0F5j(Vzx5PsrC(Ll0Nr`vJ7$==Yx06)jNY(e^$fdQAaa-DBL32^STzjJ z*A}@B!GSM_W1jsuQeNF(HOeu#J$vBZAz1bf^Q!g|#To!?FqrBzlf~4;d=O2QVH4nj z$uBT|<@r;i=jQBb^+;w2%CED3jmMewbo1?XYncJRSF!v_!5##gns()@?{phXSZdBP zUMQlDJOwLRm15rsBF#9nQlFbC(|J58pKH&}G}q$O^IoJ)@wa%+zBYWjc8-`atv?Q0 z-z;B&M!8?M*5;Bk2J!0YgJBOmz>?>A9A5Inaf(rCbRV!~Mc38$yt9aZz~rbe{TN#k z3TuPx@&ptZ@x;Yi*Eg8s=u*oh?KYwOcK)?5NM7sq*ZG8EGj1edt)Bh(jt67jVdYC6 zN&DbmA8A!C`J78CruAiOpRqv0Uu+NJ#=a58b>d^P*@80#8g`=*&1!`E2pL?o?R_2R z!F()Ts>q8@eY*||#K(PqlX99uY1U8{Y4qVW!o|<~#eCRUtES0vIKQomo3)pK!_MhC zyCNe$1NDTqV`R$v(N*063~A~*B^KA&AH~fW^2W7nqfiI5qSj!aO4vT+OF}m~tL-W9 zL2QPT37|oc9P|`2T^xK?-dGRsbu`YFRZLzd^>>oW&85pzMcx{J%74D%Ho6B6zHHwf zY#gQ#bXUc4(Ia*<+WZ##(#FsoFosWG^N}cS3T-oX5m+u{@n_4wzK_l}_K=^ZO3h4C zf9`CWC;G9f@|A9qm%DN=@oLJ4F@jbBPHoeoOdMhq?tvQYwP#NR*xJPLSJ14z-LnzS zT^EI=N9vDkOe4sDcPWh5oy+XcCn``<{FLGmG*}YW!HtI}Tyw`71^soHw<{^?bhcTV zrg5YV{?Y9;;x0YXEqf9dzYW`)R*AN833rhD5awZN-h}eX?rZ3$1yX8 zxOA}DE{CmYCarp`S}-cWX}-9Zl=>)Sm?lB7PC^U}usL*p15W6cH*>^aJ`JDu9M;ND z2bs2Q?}%|bBiEyF?^;*BFh8f3%ec~ofJ65J)*mO(47 zlALB^hUa?nod(E?XSFr?l?pJ`|eno2$;;clBaGv%P@B^oEt9ahqAl2`rL$J z7-W~NDN?2P6cnQrXkfmEahbK0%~$xXS*P<0HRS|Mz3B`0T zy5diaH2ZEeDU~-(ZQ1$Ti@zmx2(z@DSyCf4kdeahlHN;%545-Xx%6*k1o?$Ei*cX7jh&r>8z9kC-eS^USAm_k*ZOs3p+@cX^Cojg^VNo8GkR1@2`PJ+^; zgdRfgLxA)oK%s#W$+5gORTNTGDs2Qd~=AEWU4%)YELo=qf&6BE;w;E>; z?zDC*tGZeWn}r|5?JEj~g@7AwE=~kv*pgp%n=1{j0x~Q2fUdkB1L+-Ate=9JiMe>6 zJs(7=?5=G}QOHEIPcX5swgn)Jv?vN%B|NlyG3Fs~D_ixZb-^ZgM#p3-dELF|NcUAy zd0U0;4}w3iOxxC|#k_aD-uEZ;;%dKM-r#yts)u%f-{y{dy}Z_Mz1@qFo2d!GT4xct z=kh&xfC&=(XZpp&Qn)C$ig;F z1R?iaz}SmmJxzRt9QF)xkxik{EGq)?^?>)8ZrtG|PR4!ow`rO`fF*0vR_gIp(|SM} zayT{u#dry2q;x4wSxUXAC-3*Oq*-P|&Gmqm!>Zq3(#aXluAZ@e2-2JNTjSC=i}xq} zV*|IbF%FfXjf+?M4;3XyRqZxLKVM)CRkOTVms^7bO9{aY()+ZRcTK)wO2eX1%AHkS zR4H=Dl1OVP**|P+#HU^Tqa5(;ZVEJHO`B=0w*;ZTCtg!TNV5~kuMenAavid$ zTx_D;iZPy2TasgN5-8YyHXutabr-rLzqUg8+=>Y9Ho80r9?7j-vcB=tXXCtOs6mtp zX2IY4{!Zea)vr8_eBQGN%?N=k1C}ZZdPy-WBAcl3rl_1)%QjSuZknN8_}Fg_J#A%%(vh*3)uVbLr?bvjX);6w^X?R5hIC4{s0LlJc{&<; z7^bW01f_)(0~gGd>Gs048J7S~f)TxOQ*gtxc?=imI3STP0L5Y|=<%z4)N*O>lVT** zRx6-@PKAd{P#B26F4g#f;Bn9!uM11#+$?uizTY8V*|0EkfxEz5>6RcJMy1lj;&s3O z;E*!q^M0-%-lmu(gTxo1)u^Wp(j3VaJ(#w|j2&^SFD-I3akCJO85|&!&5DN6PHBDp zWz}2%WK4hE?bxN6yST2ZB1}CQ1TDjIZ5H09h6X2?$Xr!MI)>*4OzU?9`h1oYC^swZ z-;<2nAo$zKnypPHjQakthg6OEQU#Ef?;u|l+TW>|2*g8yJ8rhu`v+*TdEz)6pvomf~d%cz=%UvpE&42jHd(AQ-3Y znY3)ekP!LR%`~U}l)Lt7J#-$qR=VS(=V~HSn1erNd-cuGH@X6%y13s9qA22UT6RY( z+e5DWa8p8`1@Fl3@=d8HU-?_(bbGy;jj&6X$w7-1NJ`ex9CN8(d+rWA3=bAovwmWg z03(e=OQs~7F2%Hnc791JI3uE+xJ|u&)Iv0sJpC^rdK&7y{m2mdTXHBP`Q;a3libHP z%^JzB0X@Stf+PTjSMf2x@c0#kUbfl1pAwuQb7aBg8%|1l2G>$zg2rbzi{7B8X-IUq z@B%l88LRUeZQN$g{wa#0z^?QhinQ1QlJ@wEJLBIqm0%lBK@b(rXRG^Bz4% zZ{1{`L=Ocf$0=ODr~Y+~;tpTmmHjEUbGlRx)lIT*#K(agf8Dd;9tq`ROMRUZ>j91? zAwrE!*D^@DtO-fW<=Sgz>NUwjcfs{N>SFw@V|z^CI=mbdN3G z?zX}A{4*W$G*rih8mT-tVDm5`+NRvkl#MHqZ51XHd#bDk;R?yT*F|*L79zj~5lSTr zp=}n3T&JtCQz+kum90`nP9Z}g>1MMtM&&_zLzkmw0a#*Gw5G3$e6yCpBK zBD?+DbGpF``V$_d??+^^TO!#DAv*6gVa?BJna=i$*r~@Gj764We2G0gU#5Q||xe;_Gt-mJ|N%0pO)* z%kOj-7yz*nMJ=^r`?qzhJD&$34ytcQ?($N%SkvLXtFT)Z$c6JbW8@pwGx>Yxaq6W? z7FXO~Hr{8HE}mPf6sm9v6(rI?MAB+kiq+kw&hW6;=4wH1Rh9oN877s>@Ulc*(; z_LegKz8h;iA1p3LWANvcjGv(;+sSHz-Cfx}M1z;KutB&%%4@yZ*Mr^4uKiC~1}(gs zM$h$3YMH37QD6JK`CgOy#?Q#mh;0s&m|N}qU6LPc;|NT1n#NUmd3$slnXqQpnpE*_ z2!|LjK+$-*nP6RP)_`4kkh56nZ6;u`m)^CmlyXm5$gErw9X;-Roju=8ps||jNuK6i z(U$1vy~Q3MMiELO=+`s3LRo4w+&S)v5ib%lju$|w!J#JU#g^x`On;EdS+{CqpSXTr z?-1KedHj@Ct!bHl>xnztu?L-ls$pzN5&=vD05kU3SG%>8g`tVBXz3RMN7*QVhih_b zhm#L!TFU8~X&$~ykJ@ORg6H2fc+&*S=K0X?$}P@vrQWMe7}axm4)I~%$EA;Wqi!zx z!wBE!^1eWETw6s`a68F#!t%<3Zdv1yrZZj-YF%M$HW9Dgy0azt3fB`TGO;A~LV(5y z*f!YSjC{8FM(uN`6D&L|w)BB{vtJc+$jj0$dvNZIVs-iWN$nMu9=82;IvaWSf=rxu z9@ZdCj#*|(wAm#*pM-h(QZRu!gbLP%&%MLA@w+DOQ>E(MBhzR%HNDWE{3C61CH{p` z^rpPmc6i*pjZw4wZBu@y9q#wtAD3Z?^J>9p0S2)ioz7U!v zzs^(gWhOUvqTLF0do04lQUs+C{LVWlJUb)Dg-)oLt_-!hi?v@;F`fW#;#&c@NK$T3 zgshvsP^WQ{3kzrFQJQ-x6xX?eez(4d;YfXhKAI7BMP!X@qpiWJHCAyp$G^Vce@QL= z%XRgoz5U7ljU8;( zxvTCjK-Q%fOT@sHUiS^WGeqy!%`-pvn1ZnY>xeWA@_g8lI7q3VjC}?aH`MRTb=VZ- zd|6$ctIcQCb`pokeXTAN|8c>uis2n_*wn+Mc)Wq2(0IUAZ4M=Jre3oZeR4@}KJYLK ze@qjfX3DuHQX=u*p+S8i2X^a>JD|G*a+USf%mB_iIwxr|%uYS6xWov1-!|Q?k4jHs zewLeL%(nX~XV)i2qed85Sl*q|PkQ^(L-IQ6hvp2!17?<j#rHMEx57RRIitA1 zVS+{xt}`ZWh_TmRF()UC-1V0CEa^-Bfnqfo;zCwbOF!NeJjSg`hj5=%QjKqmhuKn2 zcA(&k_2`C7aM-Fu_~9~2 zoK)d#j<5w`%rshW$u^s)1#kUMCNfI5(-E0a_Q&Rtv_->6y^233gPe&tG;vD)%OsrK za9k11@Z&0}gS~z}>v?3F)Y;HWw|nXAA8@@}InLW{a3O=q_4?$;wPlZSK=bds2WKLc zfP*1&&?fG*5i3Y;mFu`iI#IqSKL8K>O>S9SJsI?#AOWN;cXi^)E`H5>U*R)h<5AOg zkH#Tc{v%%T&?Mj&6$^2ull+)|2w4l(Ah|}Z@61+rJc?T3bEMcX@>D<9WOk!6@PGBsB!;6_0}=N*)P zAkMz+Fq+CALv~V*<@Lnqi|kPe5t~lxE4Iu6OUO)?FUZrhlY>(86MMMZF@R2DHqu+> z265Vnh!=$XFQx#JAS0ux4l5hoH2wHC0a<%H9Wc39?Lw*C(n7TZx~Cq`nJ0~cTVI46bJ?A1Bv*$ zWoZy%fe~_k8%a}2K8hfr=|*wkMIVvz)r+&q)kw*8VtoOKjGUU6o|8CYgo=;?n3f*J zK!<>jPy12fcAxkFSmfci*aOV>v!u8SEktG5`x93h22yj#ZjUd=3etJ+?D4($SSDn1 zJZgfRD-d=wLW9hye{nL8LNV!xvw_rfvQM`?Dob}XXdTya!ad;lX;5|P^kJam^S(F@ zk(0Z!W-YhLvm0B>Fh;R3LdL0hwadg>(f8!rJqt|?x#uJd-;EvY9jzkC-t~^Y;MLAE zFn1;f?2Sth1>j2x)6_4`uNjdJSGT2#&~|ThwU{>vggbt(a~N9a$N^Vw44^9ZUuoqz zJm2tphxMO*A0Je5&FsPTLO^lDO*dIPFAm!V*0h4xMU+?#reqxT zT6SkHYCfBcSde0fW|*(5PdMJHk(9aBvdez`sjz-Q`)(`{d?Tgv<0qXEQw1l>r;Oi{ zBXyuF>JfyLp{z7MOI_gNT|Xz zN}O)E`OTkg7+BBo!dbaDg6k0vdcE*#^pzvRp9`aPL#7m~HE{|aky4lwvi2|swbsiZa1 zVco<)3|4Jx@y$G!3g)1uy5juPqXfRnry@+$6L31uE>{j+iZCkvpeRtCJEY~MmcGg~ zB3Z8z$fPklmr#ILXtgFZy1|~P7;BvW!EK_Ul{DZcz9;J=wyQnf+fkfASsYkd5${}m zz58?CoJr_L&*(|}%tUe52;Wv!-mrj+`EuKOJqIEaV-__|VZM9rk4WqbRR|nguL${0 zLkL#6k2_VVfPJn6kpWtnBQHXugL4;(7^5916QL@Xxrh=x(Po?ij?DK%LRd_Cy1nq< zT3cDV3h{F(-E}vY9GQoq#^X(xab?E(91)x77`hKh&`Cpt>$q-C8@$z@)^a@XtNXoL zW7)m~CcTX})zr}qpR0lcQOXCQoS=Bc)TC<{3QY7cnX*y~jN1F0a(=yKH$UWk4W^%( zs)+)$z2aWNnV6Z#BUXJrjon~zD%1jVZeV$vLuhTi{hi%t^toK6-F^rY`ItmwtPh4r z(qdDUA;>@DurfsPbbQhefuB8<2m)adDi8?)N!ov2GNG_NZHXBK!g+x}EPrwS(EL;& z{Nn#fi$Hf+v#5YUeG6a^)Bn)^8V}g9ttt?XKhu3tfe6D@Ou!(|+b$SKX^f{M`nHS| z8gu9Gv;?-naIDm22rZm2_u*V?m!}6CD+FtE3BoP;-zoj$@~;)~FBc3O1p8V6 z!b|zLiqrZMrtoF|>n0pKqzIw^f5HB@@J=Tc|5q>+$KQUfN)Se@wi*OV=>j{=67*j^ C`756Q From 0cefe38f4d005b396676b102ec736874de22a7e4 Mon Sep 17 00:00:00 2001 From: Jacob-Jan Sloots <47000395+slootsjj@users.noreply.github.com> Date: Tue, 23 Dec 2025 21:24:10 +0100 Subject: [PATCH 4/5] Extended test coverage and fixed bugs. - Fixed bugs for ValueIndex - Removed event LimitsChanged as it was not triggered. --- test/+wt/+test/DateRangeSlider.m | 109 ++++++++++++++- test/+wt/+test/DateSlider.m | 168 +++++++++++++++++++----- widgets/+wt/+mixin/TickableDateSlider.m | 6 +- widgets/+wt/DateRangeSlider.m | 27 ++-- widgets/+wt/DateSlider.m | 36 +++-- 5 files changed, 272 insertions(+), 74 deletions(-) diff --git a/test/+wt/+test/DateRangeSlider.m b/test/+wt/+test/DateRangeSlider.m index 8573c16..5a2ee65 100644 --- a/test/+wt/+test/DateRangeSlider.m +++ b/test/+wt/+test/DateRangeSlider.m @@ -22,7 +22,6 @@ function setup(testCase) % Set callback testCase.Widget.ValueChangedFcn = @(s,e)onCallbackTriggered(testCase,e); - testCase.Widget.LimitsChangedFcn = @(s,e)onCallbackTriggered(testCase,e); % Ensure it renders drawnow @@ -333,6 +332,110 @@ function testMinGap(testCase) end %function + function testValueIndexMappingAndBounds(testCase) + newLimits = datetime("today") + [days(0) days(10)]; + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + + % Set by indices (0-based offsets from lower limit) + testCase.verifySetProperty("ValueIndex", [1 11]); + testCase.verifyControlValues([newLimits(1) newLimits(2)]); + + % Mid-range indices + testCase.verifySetProperty("ValueIndex", [2 7]); + testCase.verifyControlValues([newLimits(1)+days(1) newLimits(1)+days(6)]); + + % Non-increasing should error (identifier currently has a typo in the class) + testCase.verifySetPropertyError("ValueIndex", [5 4], 'DateRageSlider:mustBeIncreasing'); + + % Out-of-bounds should error + testCase.verifySetPropertyError("ValueIndex", [-1 3], 'MATLAB:validators:mustBeInRange'); + testCase.verifySetPropertyError("ValueIndex", [0 11], 'MATLAB:validators:mustBeInRange'); + end %function + + function testOrientationVerticalLayout(testCase) + % Switch to vertical and verify positions/size wiring + testCase.verifySetProperty("Orientation", wt.enum.HorizontalVerticalState.vertical); + % Force a distinctive size to assert against + testCase.verifySetProperty("DatepickerSize", 180); + + % Let layout settle + drawnow; + + % Grid is 2 rows; first row equals DatepickerSize + testCase.verifyEqual(testCase.Widget.Grid.RowHeight{1}, 180); + + % Left side positions + testCase.verifyEqual(testCase.Widget.GridButtonLeft.Layout.Row, 1); + testCase.verifyEqual(testCase.Widget.GridButtonLeft.Layout.Column, 1); + testCase.verifyEqual(testCase.Widget.DatepickerLeft.Layout.Row, 1); + testCase.verifyEqual(testCase.Widget.DatepickerLeft.Layout.Column, 2); + + % Right side positions + testCase.verifyEqual(testCase.Widget.GridButtonRight.Layout.Row, 1); + testCase.verifyEqual(testCase.Widget.GridButtonRight.Layout.Column, 5); + testCase.verifyEqual(testCase.Widget.DatepickerRight.Layout.Row, 1); + testCase.verifyEqual(testCase.Widget.DatepickerRight.Layout.Column, 4); + + % Slider spans the second row + testCase.verifyEqual(testCase.Widget.Slider.Layout.Row, 2); + testCase.verifyEqual(testCase.Widget.Slider.Layout.Column, [1 5]); + end %function + + function testDisplayFormatPropagation(testCase) + fmt = "yyyy-MM-dd"; + testCase.verifySetProperty("DisplayFormat", fmt); + drawnow; + + % Datepickers should reflect the same format + testCase.verifyEquality(testCase.Widget.DatepickerLeft.DisplayFormat, fmt); + testCase.verifyEquality(testCase.Widget.DatepickerRight.DisplayFormat, fmt); + + % Tick labels non-empty (format checked indirectly) + labels = testCase.Widget.Slider.MajorTickLabels; + testCase.verifyTrue(~isempty(labels)); + end %function + + % function testValueChangingEventOnDrag(testCase) + % + % % Add this callback only for this test + % testCase.Widget.ValueChangingFcn = @(s,e)onCallbackTriggered(testCase,e); + % + % % NOTE: "drag" gesture does not support objects of class "matlab.ui.control.RangeSlider". + % end %function + + function testStepWithCalendarMonthsAndMinGap(testCase) + base = datetime(2020,1,1); + newLimits = base + [days(0) calmonths(3)]; % Jan 1 .. Apr 1 + testCase.verifySetProperty("Limits", newLimits); + + % Start mid-range + startVal = [base + calmonths(1), base + calmonths(2)]; % Feb 1 .. Mar 1 + testCase.verifySetProperty("Value", startVal); + + % Use month step + testCase.Widget.Step = calmonths(1); + testCase.verifyButtonsEnabled(["on" "on" "on" "on"]); + + % Increase MinGap; inward moves should be prevented or error via Value validation + testCase.verifySetProperty("MinGap", 20, days(20)); + + % Left "up" (narrows gap) — with current code this likely errors due to hardcoded days(1) + testCase.verifyError(@() testCase.press(testCase.Widget.ButtonsLeft(1)), ... + 'MATLAB:validators:mustBeGreaterThanOrEqual'); + + % Right "down" (narrows gap) — same expectation + testCase.verifyError(@() testCase.press(testCase.Widget.ButtonsRight(2)), ... + 'MATLAB:validators:mustBeGreaterThanOrEqual'); + end %function + + function testLimitsNormalizationToStartOfDay(testCase) + d1 = dateshift(datetime("today"), 'start', 'day') + hours(9); + d2 = d1 + days(5) + hours(17); + + testCase.verifySetProperty("Limits", [d1 d2], [d1 d2] - timeofday([d1 d2])); + end + end %methods (Test) %% Helper methods @@ -349,7 +452,7 @@ function verifyControlValues(testCase, dateValue, absTol) drawnow - numValue = days(dateValue - testCase.Widget.Limits(1)); + numValue = days(dateValue - testCase.Widget.Limits(1)) + 1; testCase.verifyEqual(testCase.Widget.Slider.Value, numValue, 'AbsTol', absTol); testCase.verifyEqual(testCase.Widget.DatepickerLeft.Value, dateValue(1), 'AbsTol', absTol); testCase.verifyEqual(testCase.Widget.DatepickerRight.Value, dateValue(2), 'AbsTol', absTol); @@ -371,7 +474,7 @@ function verifyControlLimits(testCase, dateLimits, absTol) minGap = testCase.Widget.MinGap; % Verify slider limits - numLimits = [0 days(dateLimits(2) - dateLimits(1))]; + numLimits = [0 days(dateLimits(2) - dateLimits(1))] + 1; testCase.verifyEqual(testCase.Widget.Slider.Limits, numLimits, 'AbsTol', absTol); % Verify left datepicker diff --git a/test/+wt/+test/DateSlider.m b/test/+wt/+test/DateSlider.m index 94e5d02..ef59d3f 100644 --- a/test/+wt/+test/DateSlider.m +++ b/test/+wt/+test/DateSlider.m @@ -16,7 +16,6 @@ function setup(testCase) % Set callback testCase.Widget.ValueChangedFcn = @(s,e)onCallbackTriggered(testCase,e); - testCase.Widget.LimitsChangedFcn = @(s,e)onCallbackTriggered(testCase,e); % Ensure it renders drawnow @@ -28,52 +27,62 @@ function setup(testCase) %% Unit Tests methods (Test) - function testValueProperty(testCase) + function testValuePropertyAndBoundaries(testCase) % Set the value newValue = datetime("01-Jan-2020"); testCase.verifySetProperty("Value", newValue); - testCase.verifyControlValues(newValue); + testCase.verifyControlValue(newValue); % Set the value newValue = datetime("03-Jan-2020"); testCase.verifySetProperty("Value", newValue); - testCase.verifyControlValues(newValue); - - end %function - - - function testValueBoundaries(testCase) + testCase.verifyControlValue(newValue); % Configure the control newLimits = datetime("today") + [-days(20) days(15)]; testCase.verifySetProperty("Limits", newLimits); testCase.verifyControlLimits(newLimits); - testCase.verifyControlValues(newLimits(1)); + testCase.verifyControlValue(newLimits(1)); % Set the value within limits newValue = datetime("today") + days(15); testCase.verifySetProperty("Value", newValue); - testCase.verifyControlValues(newValue); + testCase.verifyControlValue(newValue); % Change the limits out of bounds newLimits = datetime("today") + [days(20) days(30)]; testCase.verifySetProperty("Limits", newLimits); testCase.verifyControlLimits(newLimits); - testCase.verifyControlValues(newLimits(1)); + testCase.verifyControlValue(newLimits(1)); % Set an invalid value expValue = datetime("today") + days(20); invldValue = datetime("today") + days(31); testCase.verifySetPropertyError("Value", invldValue, 'MATLAB:ui:DatePicker:valueNotValid'); - testCase.verifyControlValues(expValue); + testCase.verifyControlValue(expValue); % Set an invalid value expValue = datetime("today") + days(20); invldValue = datetime("today") + days(15); testCase.verifySetPropertyError("Value", invldValue, 'MATLAB:ui:DatePicker:valueNotValid'); - testCase.verifyControlValues(expValue); + testCase.verifyControlValue(expValue); + % Configure a simple range + newLimits = datetime("today") + [days(0) days(10)]; + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + + % Expect index 1 -> min date, index 11 -> max date + testCase.verifySetProperty("ValueIndex", 1); + testCase.verifyControlValue(newLimits(1)); + testCase.verifySetProperty("ValueIndex", 11); + testCase.verifyControlValue(newLimits(2)); + + % Out-of-bounds should error + testCase.verifySetPropertyError("ValueIndex", -1, 'MATLAB:validators:mustBeInRange'); + testCase.verifySetPropertyError("ValueIndex", 12, 'MATLAB:validators:mustBeInRange'); + end %function function testDatepicker(testCase) @@ -82,7 +91,7 @@ function testDatepicker(testCase) newLimits = datetime("today") + [-days(20) days(15)]; testCase.verifySetProperty("Limits", newLimits); testCase.verifyControlLimits(newLimits); - testCase.verifyControlValues(newLimits(1)); + testCase.verifyControlValue(newLimits(1)); % Enable the datepicker to be able to type testCase.Widget.Datepicker.Editable = true; @@ -118,7 +127,7 @@ function testDatepickerButtons(testCase) newLimits = datetime("today") + [days(0) days(10)]; testCase.verifySetProperty("Limits", newLimits); testCase.verifyControlLimits(newLimits); - testCase.verifyControlValues(newLimits(1)); + testCase.verifyControlValue(newLimits(1)); % Verify buttons enabled state testCase.verifyButtonsEnabled([true false]) @@ -150,6 +159,62 @@ function testDatepickerButtons(testCase) testCase.verifyCallbackCount(5); end + + function testValueChangingEventOnDrag(testCase) + % Attach ValueChanging callback to count intermediate events + + % Add ValueChanging callback function only for this test + testCase.Widget.ValueChangingFcn = @(s,e)onCallbackTriggered(testCase,e); + + % Configure range + newLimits = datetime("today") + [days(0) days(50)]; + testCase.verifySetProperty("Limits", newLimits); + + % Drag the slider; ValueChanging should fire at least once + sliderControl = testCase.Widget.Slider; + startValue = 5; newValue = 25; + testCase.drag(sliderControl, startValue, newValue); + + % We don't assert exact count (depends on platform), just > 1 + testCase.verifyTrue(testCase.CallbackCount > 1); + end %function + + function testStepWithCalendarMonths(testCase) + % Configure range across months + base = datetime(2020,1,1); + newLimits = base + [days(0) calmonths(2)]; % Jan 1 .. Mar 1 (approx) + testCase.verifySetProperty("Limits", newLimits); + testCase.verifyControlLimits(newLimits); + testCase.verifySetProperty("Value", newLimits(1)); + testCase.verifyControlValue(newLimits(1)); + + % Set step to one calendar month, start at min + testCase.verifySetProperty("Step", calmonths(1)); + + % Push 'up' twice: Jan->Feb->Mar (clamped at max) + testCase.verifyButtonPushAction("up", base + calmonths(1)); + testCase.verifyButtonPushAction("up", newLimits(2)); + + % Push 'down' twice: back to Feb->Jan + testCase.verifyButtonPushAction("down", base + calmonths(1)); + testCase.verifyButtonPushAction("down", newLimits(1)); + end %function + + function testButtonsEnabledMidRange(testCase) + % In mid-range both buttons must be enabled + newLimits = datetime("today") + [days(0) days(10)]; + testCase.verifySetProperty("Limits", newLimits); + mid = newLimits(1) + days(5); + testCase.verifySetProperty("Value", mid); + testCase.verifyButtonsEnabled([true true]); + end %function + + function testLimitsNormalizationToStartOfDay(testCase) + % Provide limits with non-midnight time components + d1 = dateshift(datetime("today"), 'start', 'day') + hours(10); + d2 = d1 + days(3) + hours(12); + testCase.verifySetProperty("Limits", [d1 d2], [d1 d2 ] - timeofday([d1 d2])); + end %function function testTickLabels(testCase) @@ -158,7 +223,7 @@ function testTickLabels(testCase) newLimits = datetime("today") + [days(5) days(10)]; testCase.verifySetProperty("Limits", newLimits); testCase.verifyControlLimits(newLimits); - testCase.verifyControlValues(newLimits(1)); + testCase.verifyControlValue(newLimits(1)); % Check tick labels expLabels = string(datetime("today") + days(5:10)); @@ -171,7 +236,7 @@ function testTickLabels(testCase) newLimits = datetime("today") + [days(0) days(10)]; testCase.verifySetProperty("Limits", newLimits); testCase.verifyControlLimits(newLimits); - testCase.verifyControlValues(expValue); + testCase.verifyControlValue(expValue); % Change datepicker size so that slider barely fits testCase.Widget.DatepickerSize = 240; @@ -183,8 +248,7 @@ function testTickLabels(testCase) testCase.verifyEqual(actualLabels, expLabels) - end %function - + end %function function testSlider(testCase) @@ -197,22 +261,21 @@ function testSlider(testCase) sliderControl = testCase.Widget.Slider; % Click the slider - newValue = 74; - expValue = datetime("today") + days(74); + newValue = 75; + expValue = datetime("today") + days(newValue - 1); testCase.choose(sliderControl,newValue); - testCase.verifyControlValues(expValue); + testCase.verifyControlValue(expValue); testCase.verifyEqual(testCase.Widget.Value, expValue); % Verify callback triggered - testCase.verifyEqual(testCase.CallbackCount, 1) - + testCase.verifyEqual(testCase.CallbackCount, 1) % Drag the slider - startValue = 0; + startValue = 1; newValue = 32; - expValue = datetime("today") + 32; + expValue = datetime("today") + days(newValue - 1); testCase.drag(sliderControl,startValue,newValue); - testCase.verifyControlValues(expValue); + testCase.verifyControlValue(expValue); testCase.verifyEqual(testCase.Widget.Value, expValue); % Verify callback triggered @@ -221,9 +284,9 @@ function testSlider(testCase) % Drag the slider to a fraction (with rounding turned on) startValue = 32; newValue = 13.8; - expValue = datetime("today") + days(14); + expValue = datetime("today") + days(round(newValue - 1)); testCase.drag(sliderControl,startValue,newValue); - testCase.verifyControlValues(expValue); + testCase.verifyControlValue(expValue); testCase.verifyEqual(testCase.Widget.Value, expValue); % Verify callback triggered @@ -231,12 +294,49 @@ function testSlider(testCase) end %function + function testOrientationVerticalLayout(testCase) + % Switch to vertical orientation + testCase.verifySetProperty("Orientation", wt.enum.HorizontalVerticalState.vertical); + + % Slider orientation must change + testCase.verifyEquality(testCase.Widget.Slider.Orientation, "vertical"); + + % Layout positions should match update() vertical branch + drawnow + testCase.verifyEqual(testCase.Widget.Datepicker.Layout.Row, 2); + testCase.verifyEqual(testCase.Widget.Datepicker.Layout.Column, 1); + testCase.verifyEqual(testCase.Widget.GridButtons.Layout.Row, 2); + testCase.verifyEqual(testCase.Widget.GridButtons.Layout.Column, 2); + + % DatepickerSize affects height in vertical orientation + testCase.verifySetProperty("DatepickerSize", 180); + drawnow + % Grid.RowHeight should include DatepickerSize as second row + testCase.verifyEqual(testCase.Widget.Grid.RowHeight{2}, 180); + end %function + + function testDisplayFormatPropagationAndTicks(testCase) + % Change the display format + fmt = "uuuu-MM-dd"; + testCase.Widget.DisplayFormat = fmt; + drawnow + + % Verify propagation to datepicker and limits + testCase.verifyEquality(testCase.Widget.Datepicker.DisplayFormat, fmt); + testCase.verifyEquality(testCase.Widget.Limits.Format, fmt); + + % Ticks/labels should be updated (non-empty categorical labels) + drawnow + labels = testCase.Widget.Slider.MajorTickLabels; + testCase.verifyTrue(~isempty(labels)); + end %function + end %methods (Test) %% Helper methods methods (Access = private) - function verifyControlValues(testCase, dateValue, absTol) + function verifyControlValue(testCase, dateValue, absTol) % Verifies the control fields have the specified value arguments @@ -247,7 +347,7 @@ function verifyControlValues(testCase, dateValue, absTol) drawnow - numValue = days(dateValue - testCase.Widget.Limits(1)); + numValue = days(dateValue - testCase.Widget.Limits(1)) + 1; testCase.verifyEqual(testCase.Widget.Slider.Value, numValue, 'AbsTol', absTol); testCase.verifyEqual(testCase.Widget.Datepicker.Value, dateValue, 'AbsTol', absTol); @@ -264,7 +364,7 @@ function verifyControlLimits(testCase, dateLimits, absTol) drawnow - numLimits = [0 days(dateLimits(2) - dateLimits(1))]; + numLimits = [0 days(dateLimits(2) - dateLimits(1))] + 1; testCase.verifyEqual(testCase.Widget.Slider.Limits, numLimits, 'AbsTol', absTol); testCase.verifyEqual(testCase.Widget.Datepicker.Limits, dateLimits, 'AbsTol', absTol); @@ -299,7 +399,7 @@ function verifyButtonPushAction(testCase, direction, expValue) testCase.press(testCase.Widget.Buttons(buttonIdx)); % Verify new property value - testCase.verifyControlValues(expValue); + testCase.verifyControlValue(expValue); end %function diff --git a/widgets/+wt/+mixin/TickableDateSlider.m b/widgets/+wt/+mixin/TickableDateSlider.m index d46b108..b0a1861 100644 --- a/widgets/+wt/+mixin/TickableDateSlider.m +++ b/widgets/+wt/+mixin/TickableDateSlider.m @@ -22,7 +22,7 @@ end % How many days? - nDays = obj.Slider.Limits(2) + 1; + nDays = obj.Slider.Limits(2); % What space is needed for the labels? % Depends on font size and font weight. @@ -70,8 +70,8 @@ end % At what tick location do the major tick labels need to go? - majorTicks = floor(0:majorIntervalStep:(nDays - 1)); - majorTicks(end + 1) = (nDays - 1); + majorTicks = floor(1:majorIntervalStep:nDays); + majorTicks(end + 1) = nDays; % How much space is left for the minor ticks? minSpaceForMinorTick = 10; diff --git a/widgets/+wt/DateRangeSlider.m b/widgets/+wt/DateRangeSlider.m index 553aad1..3d2c51c 100644 --- a/widgets/+wt/DateRangeSlider.m +++ b/widgets/+wt/DateRangeSlider.m @@ -15,9 +15,6 @@ % Triggered on value changing during slider motion, has companion callback ValueChanging - % Triggered on limits changed, has companion callback - LimitsChanged - end %events %% Public properties @@ -103,31 +100,31 @@ function set.ValueIndex(obj, val) % Validate input - maxRange = days(obj.Limits(2) - obj.Limits(1)); + maxRange = days(obj.Limits(2) - obj.Limits(1)) + 1; try - mustBeInRange(val, 0, maxRange) + mustBeInRange(val, 1, maxRange) mustBeIncreasing(val) catch ME throwAsCaller(ME) end % Set value - obj.Value = obj.Limits(1) + days(val); + obj.Value = obj.Limits(1) + days(val - 1); end %function function val = get.ValueIndex(obj) - val = days([obj.DatepickerLeft.Value obj.DatepickerRight.Value] - obj.Limits(1)); + val = days([obj.DatepickerLeft.Value obj.DatepickerRight.Value] - obj.Limits(1)) + 1; end %function % Value function set.Value(obj, val) % Validate input - valueIndex = days(val - obj.Limits(1)); + valueIndex = days(val - obj.Limits(1) + 1); valueGap = days(diff(val)); - maxRange = days(obj.Limits(2) - obj.Limits(1)); + maxRange = days(obj.Limits(2) - obj.Limits(1)) + 1; try - mustBeInRange(valueIndex, 0, maxRange) + mustBeInRange(valueIndex, 1, maxRange) mustBeGreaterThanOrEqual(valueGap, days(obj.MinGap)) mustBeIncreasing(valueIndex) catch ME @@ -297,11 +294,11 @@ function setup(obj) obj.ButtonsRight = [uibutton(obj.GridButtonRight), uibutton(obj.GridButtonRight)]; obj.ButtonsRight(1).ButtonPushedFcn = @(h,e)obj.onButtonPushed(e); obj.ButtonsRight(1).Tag = "rightUp"; - obj.ButtonsRight(1).Icon = "Up_Grey_12.png"; + obj.ButtonsRight(1).Icon = "up_grey_12.png"; obj.ButtonsRight(1).Text = ""; obj.ButtonsRight(2).ButtonPushedFcn = @(h,e)obj.onButtonPushed(e); obj.ButtonsRight(2).Tag = "rightDown"; - obj.ButtonsRight(2).Icon = "Down_Grey_12.png"; + obj.ButtonsRight(2).Icon = "down_grey_12.png"; obj.ButtonsRight(2).Text = ""; % Update the internal component lists @@ -544,7 +541,7 @@ function updateSliderTicks(obj) minLimit = obj.Limits(1); minLimit.Format = obj.DisplayFormat; - obj.Slider.MajorTickLabels = categorical(minLimit + days(majorTicks)); + obj.Slider.MajorTickLabels = categorical(minLimit + days(majorTicks - 1)); end %function @@ -576,8 +573,8 @@ function updateControlLimitsAndValue(obj, val) obj.DatepickerRight.Value = val(2); % Update the limits and value in the slider - obj.Slider.Limits = days([0, diff(obj.Limits)]); - obj.Slider.Value = days(val - obj.Limits(1)); + obj.Slider.Limits = days([0, diff(obj.Limits)]) + 1; + obj.Slider.Value = days(val - obj.Limits(1)) + 1; end %function diff --git a/widgets/+wt/DateSlider.m b/widgets/+wt/DateSlider.m index d013da5..50e9651 100644 --- a/widgets/+wt/DateSlider.m +++ b/widgets/+wt/DateSlider.m @@ -15,9 +15,6 @@ % Triggered on value changing during slider motion, has companion callback ValueChanging - % Triggered on limits changed, has companion callback - LimitsChanged - end %events %% Public dependent properties @@ -80,14 +77,13 @@ % ValueIndex function set.ValueIndex(obj, val) - maxRange = days(obj.Limits(2) - obj.Limits(1)); + maxRange = days(obj.Limits(2) - obj.Limits(1)) + 1; try - mustBeInRange(val, 0, maxRange) + mustBeInRange(val, 1, maxRange) catch ME throwAsCaller(ME) end - dtArray = (obj.Limits(1):days(1):obj.Limits(2)) - obj.Limits(1); - obj.Value = dtArray(val); + obj.Value = obj.Limits(1) + days(val - 1); end %function function val = get.ValueIndex(obj) val = obj.Slider.Value; @@ -100,7 +96,7 @@ catch ME throwAsCaller(ME); end - obj.Slider.Value = days(val - obj.Limits(1)); + obj.Slider.Value = days(val - obj.Limits(1)) + 1; obj.Datepicker.Value = val; end %function function val = get.Value(obj) @@ -114,8 +110,6 @@ catch ME throwAsCaller(ME) end - format = obj.Datepicker.DisplayFormat; - obj.Limits.Format = format; end %function function val = get.DisplayFormat(obj) val = obj.Datepicker.DisplayFormat; @@ -138,6 +132,10 @@ end obj.Limits = startOfDay; end %function + function val = get.Limits(obj) + val = obj.Limits; + val.Format = obj.Datepicker.DisplayFormat; + end %function % Datepicker size function set.DatepickerSize(obj, val) @@ -172,8 +170,8 @@ function setup(obj) obj.Slider = uislider(obj.Grid); obj.Slider.ValueChangedFcn = @(h,e)obj.onSliderChanged(e); obj.Slider.ValueChangingFcn = @(h,e)obj.onSliderChanged(e); - obj.Slider.Limits = [0 2]; - obj.Slider.Value = 1; + obj.Slider.Limits = [1 3]; + obj.Slider.Value = 2; % Date picker obj.Datepicker = uidatepicker(obj.Grid); @@ -234,7 +232,7 @@ function update(obj) end % Set component range - obj.Slider.Limits = [0 days(obj.Limits(2) - obj.Limits(1))]; + obj.Slider.Limits = [0 days(obj.Limits(2) - obj.Limits(1))] + 1; obj.Datepicker.Limits = obj.Limits; % Update ticks @@ -244,7 +242,7 @@ function update(obj) if isnat(obj.Datepicker.Value) obj.Datepicker.Value = obj.Limits(1); end - obj.Slider.Value = days(obj.Datepicker.Value - obj.Limits(1)); + obj.Slider.Value = days(obj.Datepicker.Value - obj.Limits(1)) + 1; % Update the buttons updateButtonEnable(obj) @@ -268,7 +266,7 @@ function onButtonPushed(obj, evt) % Update the state obj.Datepicker.Value = newDate; - obj.Slider.Value = days(newDate - obj.Limits(1)); + obj.Slider.Value = days(newDate - obj.Limits(1)) + 1; % Update button enable status updateButtonEnable(obj) @@ -288,10 +286,10 @@ function onSliderChanged(obj,evt) % Round value to whole days newValue = round(newValue); - newValue = min(max(newValue,0), days(obj.Limits(2) - obj.Limits(1))); + newValue = min(max(newValue,1), days(obj.Limits(2) - obj.Limits(1)) + 1); % Prepare event data - newDate = obj.Limits(1) + days(newValue); + newDate = obj.Limits(1) + days(newValue - 1); evtOut = wt.eventdata.PropertyChangedData('Value', newDate, oldValue); % Update the state @@ -321,7 +319,7 @@ function onDatepickerChanged(obj,e) evtOut = wt.eventdata.PropertyChangedData('Value', newValue, e.PreviousValue); % Update the state - obj.Slider.Value = days(newValue - obj.Limits(1)); + obj.Slider.Value = days(newValue - obj.Limits(1)) + 1; % Update button enable status updateButtonEnable(obj) @@ -362,7 +360,7 @@ function updateSliderTicks(obj) % Set slider limits and ticks obj.Slider.MajorTicks = majorTicks; obj.Slider.MinorTicks = minorTicks; - obj.Slider.MajorTickLabels = categorical(obj.Limits(1) + days(majorTicks)); + obj.Slider.MajorTickLabels = categorical(obj.Limits(1) + days(majorTicks - 1)); end %function From d16e5a4c5f84cdcf8386fbae94286cdb14d2d884 Mon Sep 17 00:00:00 2001 From: Jacob-Jan Sloots <47000395+slootsjj@users.noreply.github.com> Date: Tue, 23 Dec 2025 21:44:22 +0100 Subject: [PATCH 5/5] Add wait time for component to catch up --- test/+wt/+test/DateRangeSlider.m | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/test/+wt/+test/DateRangeSlider.m b/test/+wt/+test/DateRangeSlider.m index 5a2ee65..bca2cac 100644 --- a/test/+wt/+test/DateRangeSlider.m +++ b/test/+wt/+test/DateRangeSlider.m @@ -218,15 +218,15 @@ function testTickLabels(testCase) testCase.verifyControlLimits(newLimits); testCase.verifyControlValues(datetime("today") + days([5 6])); + % Allow some time for the component to catch up + drawnow; + pause(2) + % Check tick labels expLabels = string(datetime("today") + days(5:10)); actualLabels = testCase.Widget.Slider.MajorTickLabels; actualLabels = convertCharsToStrings(actualLabels(1:min(6, numel(actualLabels)))); - % Allow some time for the component to catch up - drawnow; - pause(2) - testCase.verifyEqual(actualLabels, expLabels) % Change the limits @@ -235,6 +235,10 @@ function testTickLabels(testCase) testCase.verifyControlLimits(newLimits); testCase.verifyControlValues(datetime("today") + days([5 6])); + % Allow some time for the component to catch up + drawnow + pause(2) + % Check tick labels expLabels = string(datetime("today") + days(0:2:10)); actualLabels = testCase.Widget.Slider.MajorTickLabels; @@ -254,6 +258,10 @@ function testTickLabels(testCase) testCase.verifyControlLimits(newLimits); testCase.verifyControlValues(datetime("today") + days([5 6])); + % Allow some time for the component to catch up + drawnow + pause(2) + % Check widgets exist expLabels = string(datetime("today") + days([0 10 20])); actualLabels = testCase.Widget.Slider.MajorTickLabels;