[PATCH v4 0/5] v4l: extended crop/compose api

[PATCH v4 0/5] v4l: extended crop/compose api

[Tomasz Stanislawski]

Hello Everyone,

This is the fourth version of extended crop/compose RFC.  The patch-set
introduces new ioctls to V4L2 APIi for configuration of selection rectangles
like crop and compose areas. Please refer to discussion below for more details
about api development.

http://thread.gmane.org/gmane.linux.drivers.video-input-infrastructure/32152

Changelog:

v3:
- added target for padded buffer
- reduced number of constraint flags to SIZE_LE and SIZE_GE
- removed try flag
- added documentation for selection ioctls
- added documentation for new model of cropping, composing and scaling
- support of selection api for s5p-tv
- fixed returning ioctl's structures on failure

v2:
- reduced number of hints and its semantics to be more practical and less
  restrictive
- combined EXTCROP and COMPOSE ioctls into VIDIOC_{S/G}_SELECTION
- introduced crop and compose targets
- introduced try flag that prevents passing configuration to a hardware
- added usage examples

Tomasz Stanislawski (5):
  [media] v4l: add support for selection api
  [media] v4l: add documentation for selection API
  [media] v4l: simulate old crop API using extended crop/compose API
  [media] v4l: fix copying ioctl results on failure
  [media] v4l: s5p-tv: mixer: add support for selection API

 Documentation/DocBook/media/constraints.png.b64    |  134 +
 Documentation/DocBook/media/selection.png.b64      | 2937 ++++++++++++++++++++
 Documentation/DocBook/media/v4l/common.xml         |    4 +-
 Documentation/DocBook/media/v4l/selection-api.xml  |  278 ++
 Documentation/DocBook/media/v4l/v4l2.xml           |    1 +
 .../DocBook/media/v4l/vidioc-g-selection.xml       |  283 ++
 drivers/media/video/s5p-tv/mixer.h                 |   14 +-
 drivers/media/video/s5p-tv/mixer_grp_layer.c       |  157 +-
 drivers/media/video/s5p-tv/mixer_video.c           |  329 ++-
 drivers/media/video/s5p-tv/mixer_vp_layer.c        |  108 +-
 drivers/media/video/v4l2-compat-ioctl32.c          |    2 +
 drivers/media/video/v4l2-ioctl.c                   |  116 +-
 include/linux/videodev2.h                          |   27 +
 include/media/v4l2-ioctl.h                         |    4 +
 14 files changed, 4186 insertions(+), 208 deletions(-)
 create mode 100644 Documentation/DocBook/media/constraints.png.b64
 create mode 100644 Documentation/DocBook/media/selection.png.b64
 create mode 100644 Documentation/DocBook/media/v4l/selection-api.xml
 create mode 100644 Documentation/DocBook/media/v4l/vidioc-g-selection.xml

-- 
1.7.6

[PATCH 1/5] [media] v4l: add support for selection api

[Tomasz Stanislawski]

This patch introduces new api for a precise control of cropping and composing
features for video devices. The new ioctls are VIDIOC_S_SELECTION and
VIDIOC_G_SELECTION.

Signed-off-by: Tomasz Stanislawski <t.stanislaws@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
---
 drivers/media/video/v4l2-compat-ioctl32.c |    2 ++
 drivers/media/video/v4l2-ioctl.c          |   28 ++++++++++++++++++++++++++++
 include/linux/videodev2.h                 |   27 +++++++++++++++++++++++++++
 include/media/v4l2-ioctl.h                |    4 ++++
 4 files changed, 61 insertions(+), 0 deletions(-)

diff --git a/drivers/media/video/v4l2-compat-ioctl32.c b/drivers/media/video/v4l2-compat-ioctl32.c
index 61979b7..f3b9d15 100644
--- a/drivers/media/video/v4l2-compat-ioctl32.c
+++ b/drivers/media/video/v4l2-compat-ioctl32.c
@@ -927,6 +927,8 @@ long v4l2_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
 	case VIDIOC_CROPCAP:
 	case VIDIOC_G_CROP:
 	case VIDIOC_S_CROP:
+	case VIDIOC_G_SELECTION:
+	case VIDIOC_S_SELECTION:
 	case VIDIOC_G_JPEGCOMP:
 	case VIDIOC_S_JPEGCOMP:
 	case VIDIOC_QUERYSTD:
diff --git a/drivers/media/video/v4l2-ioctl.c b/drivers/media/video/v4l2-ioctl.c
index 002ce13..6e02b45 100644
--- a/drivers/media/video/v4l2-ioctl.c
+++ b/drivers/media/video/v4l2-ioctl.c
@@ -225,6 +225,8 @@ static const char *v4l2_ioctls[] = {
 	[_IOC_NR(VIDIOC_CROPCAP)]          = "VIDIOC_CROPCAP",
 	[_IOC_NR(VIDIOC_G_CROP)]           = "VIDIOC_G_CROP",
 	[_IOC_NR(VIDIOC_S_CROP)]           = "VIDIOC_S_CROP",
+	[_IOC_NR(VIDIOC_G_SELECTION)]      = "VIDIOC_G_SELECTION",
+	[_IOC_NR(VIDIOC_S_SELECTION)]      = "VIDIOC_S_SELECTION",
 	[_IOC_NR(VIDIOC_G_JPEGCOMP)]       = "VIDIOC_G_JPEGCOMP",
 	[_IOC_NR(VIDIOC_S_JPEGCOMP)]       = "VIDIOC_S_JPEGCOMP",
 	[_IOC_NR(VIDIOC_QUERYSTD)]         = "VIDIOC_QUERYSTD",
@@ -1714,6 +1716,32 @@ static long __video_do_ioctl(struct file *file,
 		ret = ops->vidioc_s_crop(file, fh, p);
 		break;
 	}
+	case VIDIOC_G_SELECTION:
+	{
+		struct v4l2_selection *p = arg;
+
+		if (!ops->vidioc_g_selection)
+			break;
+
+		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
+
+		ret = ops->vidioc_g_selection(file, fh, p);
+		if (!ret)
+			dbgrect(vfd, "", &p->r);
+		break;
+	}
+	case VIDIOC_S_SELECTION:
+	{
+		struct v4l2_selection *p = arg;
+
+		if (!ops->vidioc_s_selection)
+			break;
+		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
+		dbgrect(vfd, "", &p->r);
+
+		ret = ops->vidioc_s_selection(file, fh, p);
+		break;
+	}
 	case VIDIOC_CROPCAP:
 	{
 		struct v4l2_cropcap *p = arg;
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index fca24cc..fad4fb3 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -738,6 +738,29 @@ struct v4l2_crop {
 	struct v4l2_rect        c;
 };
 
+/* Hints for adjustments of selection rectangle */
+#define V4L2_SEL_SIZE_GE	0x00000001
+#define V4L2_SEL_SIZE_LE	0x00000002
+
+enum v4l2_sel_target {
+	V4L2_SEL_CROP_ACTIVE  = 0,
+	V4L2_SEL_CROP_DEFAULT = 1,
+	V4L2_SEL_CROP_BOUNDS  = 2,
+	V4L2_SEL_COMPOSE_ACTIVE  = 256 + 0,
+	V4L2_SEL_COMPOSE_DEFAULT = 256 + 1,
+	V4L2_SEL_COMPOSE_BOUNDS  = 256 + 2,
+	V4L2_SEL_COMPOSE_PADDED  = 256 + 3,
+};
+
+struct v4l2_selection {
+	enum v4l2_buf_type      type;
+	enum v4l2_sel_target	target;
+	__u32                   flags;
+	struct v4l2_rect        r;
+	__u32                   reserved[9];
+};
+
+
 /*
  *      A N A L O G   V I D E O   S T A N D A R D
  */
@@ -2182,6 +2205,10 @@ struct v4l2_dbg_chip_ident {
 #define	VIDIOC_SUBSCRIBE_EVENT	 _IOW('V', 90, struct v4l2_event_subscription)
 #define	VIDIOC_UNSUBSCRIBE_EVENT _IOW('V', 91, struct v4l2_event_subscription)
 
+/* Experimental crop/compose API */
+#define VIDIOC_G_SELECTION	_IOWR('V', 92, struct v4l2_selection)
+#define VIDIOC_S_SELECTION	_IOWR('V', 93, struct v4l2_selection)
+
 /* Reminder: when adding new ioctls please add support for them to
    drivers/media/video/v4l2-compat-ioctl32.c as well! */
 
diff --git a/include/media/v4l2-ioctl.h b/include/media/v4l2-ioctl.h
index dd9f1e7..2c0396b 100644
--- a/include/media/v4l2-ioctl.h
+++ b/include/media/v4l2-ioctl.h
@@ -194,6 +194,10 @@ struct v4l2_ioctl_ops {
 					struct v4l2_crop *a);
 	int (*vidioc_s_crop)           (struct file *file, void *fh,
 					struct v4l2_crop *a);
+	int (*vidioc_g_selection)      (struct file *file, void *fh,
+					struct v4l2_selection *a);
+	int (*vidioc_s_selection)      (struct file *file, void *fh,
+					struct v4l2_selection *a);
 	/* Compression ioctls */
 	int (*vidioc_g_jpegcomp)       (struct file *file, void *fh,
 					struct v4l2_jpegcompression *a);
-- 
1.7.6

Re: [PATCH 1/5] [media] v4l: add support for selection api

[Laurent Pinchart]

Hi Tomasz,

Thanks for the patch.

On Friday 26 August 2011 15:06:03 Tomasz Stanislawski wrote:
> This patch introduces new api for a precise control of cropping and
> composing features for video devices. The new ioctls are
> VIDIOC_S_SELECTION and VIDIOC_G_SELECTION.
> 
> Signed-off-by: Tomasz Stanislawski <t.stanislaws@samsung.com>
> Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
> ---
>  drivers/media/video/v4l2-compat-ioctl32.c |    2 ++
>  drivers/media/video/v4l2-ioctl.c          |   28
> ++++++++++++++++++++++++++++ include/linux/videodev2.h                 |  
> 27 +++++++++++++++++++++++++++ include/media/v4l2-ioctl.h                |
>    4 ++++
>  4 files changed, 61 insertions(+), 0 deletions(-)

[snip]

> diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
> index fca24cc..fad4fb3 100644
> --- a/include/linux/videodev2.h
> +++ b/include/linux/videodev2.h
> @@ -738,6 +738,29 @@ struct v4l2_crop {
>  	struct v4l2_rect        c;
>  };
> 
> +/* Hints for adjustments of selection rectangle */
> +#define V4L2_SEL_SIZE_GE	0x00000001
> +#define V4L2_SEL_SIZE_LE	0x00000002
> +
> +enum v4l2_sel_target {
> +	V4L2_SEL_CROP_ACTIVE  = 0,
> +	V4L2_SEL_CROP_DEFAULT = 1,
> +	V4L2_SEL_CROP_BOUNDS  = 2,
> +	V4L2_SEL_COMPOSE_ACTIVE  = 256 + 0,
> +	V4L2_SEL_COMPOSE_DEFAULT = 256 + 1,
> +	V4L2_SEL_COMPOSE_BOUNDS  = 256 + 2,
> +	V4L2_SEL_COMPOSE_PADDED  = 256 + 3,
> +};
> +
> +struct v4l2_selection {
> +	enum v4l2_buf_type      type;
> +	enum v4l2_sel_target	target;

You should avoid using enums in public APIs, as their size will depend on the 
ABI version on some platforms.

> +	__u32                   flags;
> +	struct v4l2_rect        r;
> +	__u32                   reserved[9];
> +};
> +
> +
>  /*
>   *      A N A L O G   V I D E O   S T A N D A R D
>   */

-- 
Regards,

Laurent Pinchart

Re: [PATCH 1/5] [media] v4l: add support for selection api

[Laurent Pinchart]

Hi Tomasz,

On Friday 26 August 2011 15:06:03 Tomasz Stanislawski wrote:
> This patch introduces new api for a precise control of cropping and
> composing features for video devices. The new ioctls are
> VIDIOC_S_SELECTION and VIDIOC_G_SELECTION.
> 
> Signed-off-by: Tomasz Stanislawski <t.stanislaws@samsung.com>
> Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
> ---
>  drivers/media/video/v4l2-compat-ioctl32.c |    2 ++
>  drivers/media/video/v4l2-ioctl.c          |   28
> ++++++++++++++++++++++++++++ include/linux/videodev2.h                 |  
> 27 +++++++++++++++++++++++++++ include/media/v4l2-ioctl.h                |
>    4 ++++
>  4 files changed, 61 insertions(+), 0 deletions(-)
> 

[snip]

> diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
> index fca24cc..fad4fb3 100644
> --- a/include/linux/videodev2.h
> +++ b/include/linux/videodev2.h
> @@ -738,6 +738,29 @@ struct v4l2_crop {
>  	struct v4l2_rect        c;
>  };
> 
> +/* Hints for adjustments of selection rectangle */
> +#define V4L2_SEL_SIZE_GE	0x00000001
> +#define V4L2_SEL_SIZE_LE	0x00000002
> +
> +enum v4l2_sel_target {
> +	V4L2_SEL_CROP_ACTIVE  = 0,
> +	V4L2_SEL_CROP_DEFAULT = 1,
> +	V4L2_SEL_CROP_BOUNDS  = 2,
> +	V4L2_SEL_COMPOSE_ACTIVE  = 256 + 0,
> +	V4L2_SEL_COMPOSE_DEFAULT = 256 + 1,
> +	V4L2_SEL_COMPOSE_BOUNDS  = 256 + 2,
> +	V4L2_SEL_COMPOSE_PADDED  = 256 + 3,
> +};
> +
> +struct v4l2_selection {
> +	enum v4l2_buf_type      type;
> +	enum v4l2_sel_target	target;
> +	__u32                   flags;
> +	struct v4l2_rect        r;

Maybe rect instead of r ? Lines such as

	p->c = s.r;

in patch 3/5 look a bit cryptic.

> +	__u32                   reserved[9];
> +};
> +
> +
>  /*
>   *      A N A L O G   V I D E O   S T A N D A R D
>   */

[snip]

> diff --git a/include/media/v4l2-ioctl.h b/include/media/v4l2-ioctl.h
> index dd9f1e7..2c0396b 100644
> --- a/include/media/v4l2-ioctl.h
> +++ b/include/media/v4l2-ioctl.h
> @@ -194,6 +194,10 @@ struct v4l2_ioctl_ops {
>  					struct v4l2_crop *a);
>  	int (*vidioc_s_crop)           (struct file *file, void *fh,
>  					struct v4l2_crop *a);
> +	int (*vidioc_g_selection)      (struct file *file, void *fh,
> +					struct v4l2_selection *a);
> +	int (*vidioc_s_selection)      (struct file *file, void *fh,
> +					struct v4l2_selection *a);

Why 'a' ? Don't blindly copy past mistakes :-) 'sel' would be a more 
descriptive parameter name.

>  	/* Compression ioctls */
>  	int (*vidioc_g_jpegcomp)       (struct file *file, void *fh,
>  					struct v4l2_jpegcompression *a);

-- 
Regards,

Laurent Pinchart

Re: [PATCH 1/5] [media] v4l: add support for selection api

[Tomasz Stanislawski]

On 08/26/2011 05:01 PM, Laurent Pinchart wrote:
> Hi Tomasz,
>
> On Friday 26 August 2011 15:06:03 Tomasz Stanislawski wrote:
>> This patch introduces new api for a precise control of cropping and
>> composing features for video devices. The new ioctls are
>> VIDIOC_S_SELECTION and VIDIOC_G_SELECTION.
>>
>> Signed-off-by: Tomasz Stanislawski<t.stanislaws@samsung.com>
>> Signed-off-by: Kyungmin Park<kyungmin.park@samsung.com>
>> ---
>>   drivers/media/video/v4l2-compat-ioctl32.c |    2 ++
>>   drivers/media/video/v4l2-ioctl.c          |   28
>> ++++++++++++++++++++++++++++ include/linux/videodev2.h                 |
>> 27 +++++++++++++++++++++++++++ include/media/v4l2-ioctl.h                |
>>     4 ++++
>>   4 files changed, 61 insertions(+), 0 deletions(-)
>>
> [snip]
>
>> diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
>> index fca24cc..fad4fb3 100644
>> --- a/include/linux/videodev2.h
>> +++ b/include/linux/videodev2.h
>> @@ -738,6 +738,29 @@ struct v4l2_crop {
>>   	struct v4l2_rect        c;
>>   };
>>
>> +/* Hints for adjustments of selection rectangle */
>> +#define V4L2_SEL_SIZE_GE	0x00000001
>> +#define V4L2_SEL_SIZE_LE	0x00000002
>> +
>> +enum v4l2_sel_target {
>> +	V4L2_SEL_CROP_ACTIVE  = 0,
>> +	V4L2_SEL_CROP_DEFAULT = 1,
>> +	V4L2_SEL_CROP_BOUNDS  = 2,
>> +	V4L2_SEL_COMPOSE_ACTIVE  = 256 + 0,
>> +	V4L2_SEL_COMPOSE_DEFAULT = 256 + 1,
>> +	V4L2_SEL_COMPOSE_BOUNDS  = 256 + 2,
>> +	V4L2_SEL_COMPOSE_PADDED  = 256 + 3,
>> +};
>> +
>> +struct v4l2_selection {
>> +	enum v4l2_buf_type      type;
>> +	enum v4l2_sel_target	target;
>> +	__u32                   flags;
>> +	struct v4l2_rect        r;
> Maybe rect instead of r ? Lines such as
>
> 	p->c = s.r;
>
> in patch 3/5 look a bit cryptic.
Notice that struct v4l2_crop contains field c of struct v4l2_rect type.
I wanted to keep this name as short as possible because it is obvious 
that selection is a rectangle,
so its coordinates should be accessed in "the shortest" possible way :)
>> +	__u32                   reserved[9];
>> +};
>> +
>> +
>>   /*
>>    *      A N A L O G   V I D E O   S T A N D A R D
>>    */
> [snip]
>
>> diff --git a/include/media/v4l2-ioctl.h b/include/media/v4l2-ioctl.h
>> index dd9f1e7..2c0396b 100644
>> --- a/include/media/v4l2-ioctl.h
>> +++ b/include/media/v4l2-ioctl.h
>> @@ -194,6 +194,10 @@ struct v4l2_ioctl_ops {
>>   					struct v4l2_crop *a);
>>   	int (*vidioc_s_crop)           (struct file *file, void *fh,
>>   					struct v4l2_crop *a);
>> +	int (*vidioc_g_selection)      (struct file *file, void *fh,
>> +					struct v4l2_selection *a);
>> +	int (*vidioc_s_selection)      (struct file *file, void *fh,
>> +					struct v4l2_selection *a);
> Why 'a' ? Don't blindly copy past mistakes :-) 'sel' would be a more
> descriptive parameter name.
Maybe just 's' is good enough. It keeps naming used by other ops.
>>   	/* Compression ioctls */
>>   	int (*vidioc_g_jpegcomp)       (struct file *file, void *fh,
>>   					struct v4l2_jpegcompression *a);

Re: [PATCH 1/5] [media] v4l: add support for selection api

[Sakari Ailus]

Hi Thomaas,

Thanks for the patch.

On Fri, Aug 26, 2011 at 03:06:03PM +0200, Tomasz Stanislawski wrote:
> This patch introduces new api for a precise control of cropping and composing
> features for video devices. The new ioctls are VIDIOC_S_SELECTION and
> VIDIOC_G_SELECTION.
> 
> Signed-off-by: Tomasz Stanislawski <t.stanislaws@samsung.com>
> Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
> ---
>  drivers/media/video/v4l2-compat-ioctl32.c |    2 ++
>  drivers/media/video/v4l2-ioctl.c          |   28 ++++++++++++++++++++++++++++
>  include/linux/videodev2.h                 |   27 +++++++++++++++++++++++++++
>  include/media/v4l2-ioctl.h                |    4 ++++
>  4 files changed, 61 insertions(+), 0 deletions(-)
> 
> diff --git a/drivers/media/video/v4l2-compat-ioctl32.c b/drivers/media/video/v4l2-compat-ioctl32.c
> index 61979b7..f3b9d15 100644
> --- a/drivers/media/video/v4l2-compat-ioctl32.c
> +++ b/drivers/media/video/v4l2-compat-ioctl32.c
> @@ -927,6 +927,8 @@ long v4l2_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
>  	case VIDIOC_CROPCAP:
>  	case VIDIOC_G_CROP:
>  	case VIDIOC_S_CROP:
> +	case VIDIOC_G_SELECTION:
> +	case VIDIOC_S_SELECTION:
>  	case VIDIOC_G_JPEGCOMP:
>  	case VIDIOC_S_JPEGCOMP:
>  	case VIDIOC_QUERYSTD:
> diff --git a/drivers/media/video/v4l2-ioctl.c b/drivers/media/video/v4l2-ioctl.c
> index 002ce13..6e02b45 100644
> --- a/drivers/media/video/v4l2-ioctl.c
> +++ b/drivers/media/video/v4l2-ioctl.c
> @@ -225,6 +225,8 @@ static const char *v4l2_ioctls[] = {
>  	[_IOC_NR(VIDIOC_CROPCAP)]          = "VIDIOC_CROPCAP",
>  	[_IOC_NR(VIDIOC_G_CROP)]           = "VIDIOC_G_CROP",
>  	[_IOC_NR(VIDIOC_S_CROP)]           = "VIDIOC_S_CROP",
> +	[_IOC_NR(VIDIOC_G_SELECTION)]      = "VIDIOC_G_SELECTION",
> +	[_IOC_NR(VIDIOC_S_SELECTION)]      = "VIDIOC_S_SELECTION",
>  	[_IOC_NR(VIDIOC_G_JPEGCOMP)]       = "VIDIOC_G_JPEGCOMP",
>  	[_IOC_NR(VIDIOC_S_JPEGCOMP)]       = "VIDIOC_S_JPEGCOMP",
>  	[_IOC_NR(VIDIOC_QUERYSTD)]         = "VIDIOC_QUERYSTD",
> @@ -1714,6 +1716,32 @@ static long __video_do_ioctl(struct file *file,
>  		ret = ops->vidioc_s_crop(file, fh, p);
>  		break;
>  	}
> +	case VIDIOC_G_SELECTION:
> +	{
> +		struct v4l2_selection *p = arg;
> +
> +		if (!ops->vidioc_g_selection)
> +			break;
> +
> +		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
> +
> +		ret = ops->vidioc_g_selection(file, fh, p);
> +		if (!ret)
> +			dbgrect(vfd, "", &p->r);
> +		break;
> +	}
> +	case VIDIOC_S_SELECTION:
> +	{
> +		struct v4l2_selection *p = arg;
> +
> +		if (!ops->vidioc_s_selection)
> +			break;
> +		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
> +		dbgrect(vfd, "", &p->r);
> +
> +		ret = ops->vidioc_s_selection(file, fh, p);
> +		break;
> +	}
>  	case VIDIOC_CROPCAP:
>  	{
>  		struct v4l2_cropcap *p = arg;
> diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
> index fca24cc..fad4fb3 100644
> --- a/include/linux/videodev2.h
> +++ b/include/linux/videodev2.h
> @@ -738,6 +738,29 @@ struct v4l2_crop {
>  	struct v4l2_rect        c;
>  };
>  
> +/* Hints for adjustments of selection rectangle */
> +#define V4L2_SEL_SIZE_GE	0x00000001
> +#define V4L2_SEL_SIZE_LE	0x00000002
> +
> +enum v4l2_sel_target {
> +	V4L2_SEL_CROP_ACTIVE  = 0,
> +	V4L2_SEL_CROP_DEFAULT = 1,
> +	V4L2_SEL_CROP_BOUNDS  = 2,
> +	V4L2_SEL_COMPOSE_ACTIVE  = 256 + 0,
> +	V4L2_SEL_COMPOSE_DEFAULT = 256 + 1,
> +	V4L2_SEL_COMPOSE_BOUNDS  = 256 + 2,
> +	V4L2_SEL_COMPOSE_PADDED  = 256 + 3,

What about defining V4L2_SEL_COMPOSE_BASE, for exmaple, and using that
instead of plain 256?

Also, as you change rhe enum to __u32 as Laurent suggested already, the enum
no longer needs a name. Whether it should have nde is another question. I
don't see a reason to have one.

> +};
> +
> +struct v4l2_selection {
> +	enum v4l2_buf_type      type;
> +	enum v4l2_sel_target	target;
> +	__u32                   flags;
> +	struct v4l2_rect        r;
> +	__u32                   reserved[9];
> +};
> +
> +
>  /*
>   *      A N A L O G   V I D E O   S T A N D A R D
>   */
> @@ -2182,6 +2205,10 @@ struct v4l2_dbg_chip_ident {
>  #define	VIDIOC_SUBSCRIBE_EVENT	 _IOW('V', 90, struct v4l2_event_subscription)
>  #define	VIDIOC_UNSUBSCRIBE_EVENT _IOW('V', 91, struct v4l2_event_subscription)
>  
> +/* Experimental crop/compose API */
> +#define VIDIOC_G_SELECTION	_IOWR('V', 92, struct v4l2_selection)
> +#define VIDIOC_S_SELECTION	_IOWR('V', 93, struct v4l2_selection)
> +
>  /* Reminder: when adding new ioctls please add support for them to
>     drivers/media/video/v4l2-compat-ioctl32.c as well! */
>  
> diff --git a/include/media/v4l2-ioctl.h b/include/media/v4l2-ioctl.h
> index dd9f1e7..2c0396b 100644
> --- a/include/media/v4l2-ioctl.h
> +++ b/include/media/v4l2-ioctl.h
> @@ -194,6 +194,10 @@ struct v4l2_ioctl_ops {
>  					struct v4l2_crop *a);
>  	int (*vidioc_s_crop)           (struct file *file, void *fh,
>  					struct v4l2_crop *a);
> +	int (*vidioc_g_selection)      (struct file *file, void *fh,
> +					struct v4l2_selection *a);
> +	int (*vidioc_s_selection)      (struct file *file, void *fh,
> +					struct v4l2_selection *a);
>  	/* Compression ioctls */
>  	int (*vidioc_g_jpegcomp)       (struct file *file, void *fh,
>  					struct v4l2_jpegcompression *a);
> -- 
> 1.7.6
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-media" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

-- 
Sakari Ailus
sakari.ailus@iki.fi

[PATCH 2/5] [media] v4l: add documentation for selection API

[Tomasz Stanislawski]

This patch adds a documentation for VIDIOC_{G/S}_SELECTION ioctl. Moreover, the
patch adds the description of modeling of composing, cropping and scaling
features in V4L2. Finally, some examples are presented.

Signed-off-by: Tomasz Stanislawski <t.stanislaws@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
---
 Documentation/DocBook/media/constraints.png.b64    |  134 +
 Documentation/DocBook/media/selection.png.b64      | 2937 ++++++++++++++++++++
 Documentation/DocBook/media/v4l/common.xml         |    4 +-
 Documentation/DocBook/media/v4l/selection-api.xml  |  278 ++
 Documentation/DocBook/media/v4l/v4l2.xml           |    1 +
 .../DocBook/media/v4l/vidioc-g-selection.xml       |  283 ++
 6 files changed, 3636 insertions(+), 1 deletions(-)
 create mode 100644 Documentation/DocBook/media/constraints.png.b64
 create mode 100644 Documentation/DocBook/media/selection.png.b64
 create mode 100644 Documentation/DocBook/media/v4l/selection-api.xml
 create mode 100644 Documentation/DocBook/media/v4l/vidioc-g-selection.xml

diff --git a/Documentation/DocBook/media/constraints.png.b64 b/Documentation/DocBook/media/constraints.png.b64
new file mode 100644
index 0000000..1e5a136
--- /dev/null
+++ b/Documentation/DocBook/media/constraints.png.b64
@@ -0,0 +1,134 @@
+iVBORw0KGgoAAAANSUhEUgAAAlQAAAFYCAIAAAAa0PWYAAAAA3NCSVQICAjb4U/gAAAACXBIWXMA
+AA7EAAAOxAGVKw4bAAAdZElEQVR4nO3de5xN5eLH8e+aGYwZl3GdIeSeCJ0R5eQgxEmJdJSSOlFS
+VHQ9Jd3popJcSklXqTmVlERKpH6V7lGddMFxpCkZzIzL3Nbvj7mbPXv2Ze3Za+/n837tP1h77ed5
+1pq113c/az1rLcu2bQEAYJKYcDcAAIDqRvgBAIxD+AEAjEP4AQCMQ/gBAIxD+AEAjEP4AQCMQ/gB
+AIxD+AEAjEP4AQCME+fTXJYV4mYAAOCnIG7PSc8PAGAcwg8AYBzfDnuW4BEQAIDwcuJMHD0/AIBx
+CD8AgHEIPwCAcQg/AIBxCD8AgHEIPwCAcfy81AGoTkcMaOZKGwAOoecHt6p4KQ+32QPgEMIPrlRZ
+zpF/AJxA+MF9vCcc+QcgaIQfXMaXbCP/AASH8IOb+J5q5B+AIBB+cA1/84z8AxAowg8AYBzCD+4Q
+WDeOzh+AgBB+cIFgMoz8A+A/wg/hFnx6kX8A/ET4AQCMQ/ghrOi0AQgHwg9hxb2qAYQD4YeIQlgC
+cALhh3CrmGfeE87f+QGgAp7nBxcoTC/L8jXG/J0fAMqj5wfX8DfJSD4AgSL8AADGIfwAAMYh/AAA
+xiH8AADGIfwAAMYh/AAAxiH8AADGIfwAAMYh/AAAxiH8AADGIfwAAMYh/AAAxiH8AADGIfzgSjyx
+AUAoEX4AAOMQfnArntgOIGR4kjtcjCe2AwgNen5wPZIPgNMIPwCAcQg/AIBxCD8AgHHMHfBiWVa4
+mwAAAbI5Fx4cQ3t+JB+AiMZOLEiGhh8AwGSEHwDAOIQfAMA4hB8AwDjmjvYsi3FTANyPQS4OoucH
+ADAO4QcAMA7hBwAwDuEHADAO4QcAMA7hBwAwDuEHADAO4Qe349ImAI7jIne4V0nsFf6DWxEAcAo9
+P7hUxQ4fXUAATiH8AADGIfwQSej8AXAE4QcAMA7hBwAwDuEHADAO4QcAMA7hBwAwDuEHADAO4QcA
+MA7hBwAwDuEHADAO4QcAMA7hBwAwDuEHADAO4QcAMA7hB7fw94kNPOEBQMB4kjvCz98ntvOEdwBB
+oueHMPP3ie084R1A8Ag/uBF5BiCkCD9EA8ISgF8IP0QDTvsB8AvhBwAwDuGHMAu+00a3D4C/CD+E
+XzDpRfIBCADhB1cILMNIPgCBIfwAAMYh/OAW/nbj6PYBCBjhBxfxPc9IPgDBIPzgLr6kGskHIEiE
+H1zHe7aRfACCR/jBjSpLOJIPgCMIP7hUxZwj+QA4hef5wb1IOwAhQs8PAGAcwg8AYBzCDwBgHMIP
+AGAcwg8AYBzCDwBgHMIPAGAcrvNzKcsKdwvgGlzvCDiOnh8AwDiEHwDAOBz2dDsOeRmLQ99A6NDz
+AwAYh/ADABiH8AMAGIfwAwAYh/ADABiH8AMAGIfwAwAYh/ADABiH8AMAGIfwAwAYh/ADABiH8AMA
+GIfwAwAYh/ADABiH8AMAGIfwAwAYh/ADABiH8AMAGIfwAwAYh/ADABiH8AMAGIfwAwAYh/ADABiH
+8AMAGIfwAwAYh/ADABiH8AMAGIfwAwAYh/ADABiH8AMAGIfwAwAYh/ADABiH8AMAGIfwAwAYh/AD
+ABiH8AMAGIfwAwAYh/ADABiH8AMAGIfwAwAYh/ADABiH8AMAGIfwAwAYp1rCz7KqoxY3MW+JASCS
+xIW2+JIQKPyHbYe2Ohcwb4kBIPKEsudXsfsT7R0i85YYACJSyMKPvX4x1gQAuE0Iws+yvO3vozcK
+vC909C43AEQep8Ovyn189J4Eq3LJyD+4FhsnwiN8W56jA174AlXFsqI4/RGRGKKF8Aj3ludcz8+X
+5Iv2L5Yvy8cvBLgHQ7QQHi7Y8hzq+fnY7upcPIeCNhRNpv8HNyDn4C7Vu2d0oufnzu9Q0INMQjpK
+xZ3rDIYwdVAa3MEdgwODDj+Xf1ECbV41LJbL1xyilcGD0uAO7hgcyL09AYPwkwuRIfRbqgHh5/9K
+ZAeBqMSgNLiFCwYHhvjenm7g/7fZtsk/RBsXDkqDR479/oiCv2Uoh8AY0PMDjBcFu0FzODDmI5ru
+KRWyBQk6/Fx+lCTQ5lXDYrl8zSFqRM1u0CiB/9Wi7+8dmiVy4rCnj0cJI21nH3B7o3FlAEBUceiw
+pwvOXroEyQfAEYHsMs3YzTrCuXN+5B/JB8A5gewr2L/4zNEBL6z3qrCGAMANnB7t6Y5L98OCG2fA
+ndjwIlHgf7Xo+3uHZolCcJ1fYUMri4Lo+8MU8zLuJ3oXGpEhSgeloRKR8ocM60YZsuv8ImXthx5r
+Am7ASXm4S7h/joXyIveK7Y72HDBviRFJyD+4RbiTTyG/vZl5+37zlhiRhFv3ITKEfk/K7c0Asxg8
+KA3u4I7BgYQfYBzb9rZ74egFQsv7xldd2x/hBxiKkIO7VO8WSfgB5mKIFsLDBVueAc/zA1A50g7h
+Ee4tj54fAMA4hB8AwDiEHwDAOIQfAMA4hB8AwDiEHwDAOIQfAMA4hB8AwDiEHwDAOIQfAMA4hB8A
+wDiEHwDAOIQfAMA4hB8AwDiEHwDAOIQfAMA4hB8AwDiEHwDAOIQfAMA4hB8AwDiEHwDAOIQfAMA4
+hB8AwDiEHwDAOIRfZCrQ8wNk1dWKPRXeSdeptVR3pPbYZabm67mhsizVHq79xdO2zZVl6ZZNHorf
+vlrXj1anFFmWajdV30v0/i4fWmXrx9d13olqUluWpcQm6nm6ZqxUXpnqjnwl6O3MKhoTTHWFBeZt
+VfeKVRe/Fu2sunmV8dLswAoEUD3iwt0ABCRGf5+s2mdr/loN/Ue5nzC/vqm1OTp/khpapRPTX9PU
+NarpY+F5WnGTHvpT543WhGN06DstmKd+a7XuC/VL8va5HUvUc6zsnpo6Sx2TlP6zPlyhxcs1ZWjp
+dnbmvRrdqvQjVry61/axWYFUVyi2qR5M0x955SbmbNU107Sns/7SoHSig80LUYEAHEH4RapGA3RG
+PS2br/SRalaSfnl6bYEKkjXxpNI5C/7U9ZPU6S7Vv1NrfSk6VsOe0dguqldc7IU91fEi3bFG746S
+VdmncvXiPdrXRp+tU4+EomlTb1PuoXIbWdehOq+rzwvphW/VFbISNWhUuSl2lqb31p7amvda6ced
+bF7ICgTgCA57RiorSVeMVN56rdhZOjH3Fy38XC3HKDWxeJKt9dOUlqKF433u+Vlq1bU0+SQln6TW
+0q9blOvlU7n6abeUohbx5SbXiK88L4MRTHX5WjFZMzZr7FJN7BCKxgFwO8IvgvWaqOa2Hn1VJcfz
+trygzdLFF6vk0Frmxxq/WFMWqUu850J8sXujfpQ69/Aan/E6JVX6SJfM0Mbtyq9krkP7lZFR+tqb
+JbuSOavgW3Ue/fyERj+jzjdp/pmKDVHzQlYgAEcQfhEsobvGttaXj+vnHEnSIT3ztHScxhxTPMcB
+3TdOOeN1U4/Aa8lP1w3XKK+Tbunrdb4Ynf24ruqpFbfqxNaKS1KfczX3bR0qP9eDfdSwYemrwWD9
+EVga+FZdRZkbNfxy2QO0/HbVrdBJdKx5ISsQgCM45xfJ4nXReN03XUt+0J1ddeArPb9dJ8xT2xpF
+729+WPfv1qt3qX6gRx7tTN0zXM9na856pSZUMXONlprziW78Uive1Pr3tSpNV6Vp8TS9f1dpzIxe
+qPFtSz8S10gNAm2bL9UdIf93TR6ub1O0/AW199SNdbB5ISoQgCMIv8jW4TwdP11PP6ObH9CnC7Ur
+RjNGFP1R87bp8jvVZ7ZOilVGhpSlHFt2jvbuVVwdJfjwl7ez9OAwTf9Ct2/Qlcf61iBLzVM1IVUT
+pLx0/au/HpyhpZdpQsui99v11iAHB4BUVV05OXr8fD37m27+WMOSPZfncPNCUCAAR3DYM7LFtdYV
+vbVjib7YqUeXqdYgnd6s6K2cXdpyWO9doSaFx9xaaeUhHV6loxvogveqLtk+oHkjdf0G3fC2pp8Y
+yKCVuGRNmihJn+/w/8OOV2frkzt0xbsauEC3BbQ4AKIJPb8IF6thk1VjjO6ZpbX7dNpkNSn+PRPf
+Rcve1YGC4jkPaPpIbeyhZTPVLrWqYg9q4ShdtUZXrtLM/r79RMrXlh91dCfVKplSoG8/lqTjmvu3
+TD7xs7r0NzR8plIu1AsTfB71CiB6EX4RL3mwhiRoxRwpSZP6lvZpYurprwPKzJep+TVVM0X9B6pe
+mcmbVmrp5tL/xiZpyCC9d4kuX6m2Y9Vzj9KWFr2V2EGnn3Dk8MhSh/VAf72UrAuG6biOqntYX76p
+OcvVaJTOblFpdYpTz6Fqn+j53dgkDRmi+h6z17fqCuVu0wWjlV5T156sd9PKvxej9gPUs4lPzauM
+x2YHUyCAkLN9IRW9okUgK6F6+bHKC+xV59qS3fRSO9PLbPvtEbXt+DPtfcUTtj5SWkvpq4399T77
+5jYe3mpwoZ3lpfw8+7Pn7YnD7HZN7RjZqmE362SPu9/+OdtrdbIf/sVrYw4FVd20b2zbtve/bSd4
+qrrwdcG6qptXGS/NDqzAsqLua4dguX/HVU2c+G5YdoUV6oFV3J3wZeZIYFnlTvr4tBKqV9StcviN
+bQBHcP+Oq5o48d1gwAsAwDiEHwDAOIQf/HB4s46t5MFAt2+u+uMur861bQDgOM75Sa48dO7OVW7n
+6L/bdbhikyw1PloNnb6GoJqrc1sb3LkNIIzcv+OqJk58Nwg/yZXbUNStcviNbQBHcP+Oq5ow4AUA
+gAAQfgAA43CHF7ezuA0lADiNnh8AwDiEHwDAOBz2dCljh3EBQDWg5wcAMA7hBwAwDuEHADAO4QcA
+MA7hBwAwDuEHADAOlzrAXY64ow2XfAAIBXp+cJGK93Lj7m4AQoHwg1tUlnPkHwDHEX5wBe8JR/4B
+cBbhh/DzJdvIPwAOIvwQZr6nGvkHwCmEH8LJ3zwj/wA4gvADABiH8EPYBNaNo/MHIHiEH8IjmAwj
+/wAEifBDGASfXuQfgGAQfgAA4xB+qG502gCEHeGH6sa9qgGEHeEHtyMsATiO8EMYVMwz7wnn7/wA
+4B3P80N4FKaXZfkaY/7ODwBe0PNDOPmbZCQfAEcQfgAA4xB+AADjEH4AIlFBxqcLJw/v06V5gmXV
+adG179nXPLMps+xh8bxtc4+3SiU0bf/XsbPW7Dh8xAztbtl0uMyn7ANbXp4+ZnCvTs0SLSumbrMO
+qaeOu3fZt3vzPX2kuIqkUa/vLigpIueHe461rB6P7cgv21577+rRSZZlJU/4ILvcgnhsBkKO8AMQ
+aezMLx4a1qnXxAXfNRww8f7FT84Y3yfhs9n/7Nbl3Me/P1h+1kYjZ7+0bNkrLz01c2z77c/fMPiU
+6Z9kVXbm2M76eu7ZnY4ZdffqrA5/v+yuhYsXTP/nwHYHV9808rh+j/ycV3l79r1847xvvWeXvWfd
+/Df2Sfr9349+tM+vpUVIMNoTQGSx92+44cxrVx4YPPfrVyd1TbQkadyV11x832l/u/myEe1P+Gpm
+au2SmesfO3D4iK61JJ1z3qn1ux1322OzN9764oA6nos9/aplewfN/vyVq1LrlXQM7Ie3rZzz1OFa
+lbYnpV9q5voHbl5++fJzkivrThSkr5676kCLSx/46yvXLZ///p6Bwxpyp6PwoucHIKIUpL9xx5M7
+9Zfb515WlHySFFO/15T517bTlrl3r83w3LWrdfTJx9dV5k8/ZeR7eLfgtzduX7TT6jXj0Ullkk+S
+Fd/69BvvGNmi0p5Co8F33nx89op/PfTlwcpmyd/5xrz3cludN/GiSSMaZ781750/CiqbFdWE8AMQ
+UbK+efWTXHW/eGTbGuXfqN159LltlPXh8iMPfRYp2Ld9e6biGjZJjPXwbvamVzfmqtuYM1vX8PCu
+VzU7XDrrosZb5/zr3zs9xaqUt+2VBR/Zrc87v3PjHuPOanr43Xkrd3meE9WG8AMQSQoyd+zIVvzR
+HRpV6IrVTOncTNr9U3qZ028FOdlZWVn79/xv86r7L73uEzU6Z0rfJE/F7t+xI1vxrTqWFmvnHcwq
+cTDXyzWmMUn9br3tpNx3pt23McvD2zk/vrjwK7U5//xj45X4l4vPTsnfMP+1HV7OIaIaEH4Aoti2
+Wb0b161bv1HLrqfd9FaDi5/98InTGnnZ7ZU5EVeQvuSUuiVOWrDNW1rVaHvR/ROa/e/RG5ZsrzDb
+oe+fXfQftbtg9DG1JCV0v+gfzfXZY2m/5Aa+VAge4QcgksTUbdkyUYe2//hnhZTJ+e27XVLj9sll
+Bqckj3ny7XXvvfPm0ofGd437JW3R6z8f8lxsvcJit5QUG9PotIUb1q1bt+bpfzb3oV11e990Vz/r
+g9vu/mB/+fN5B75e9Ow2HT1iSNMDGRkZGRmHWw4fmqzNTyz5gWsbwonwAxBR6nQ9q1ecvn562dYj
+uk6Hvn8pbasS/3rmsaWDPZXYumfffv0HDh099bGVz4yIe/+GMQ984/GUYGLXs3rFadOS17cVF1uj
+afc+/fr169urrYexoRXFtRp9/+RW6U9ev/jnnDKTMz9d+OKv0vYH+6Q0LHTUqYvSpZ+eempzpQNk
+EHqEH4CIEpMy7NZxzfTF7Vcv+ja75EScnfn5I5Mf/EntJ90yoIHHqwjiWpy74LGhCZvunrJ0h4fR
+JjEpZ942vnnBxmmXL/hyf2BjMRN7XHfPkPjP7rpj7Z6SZu39YP4ru3XMNUtXrym16rlJbbRjyRNf
+ZHsrDiHFdX4AIotVv9+s5fdtO+3GK7qnrr5i7KmpRxVs/+ytpxa8tf2os+a/dluPhMo+GNtsxL3X
+HdPtzun3fjRqfp+6RxZbr+8DK2bvOmPqlNS2L50/dsgJnds2jtm/64cPXlm8RfXOSI63pCpurB7b
+/Kx7p7b/y8z3s6QWkmT/uXb+iv2xfWZPHTW4RZkxpnntr50zf3LaYx/ff/LAwubu3bTypaWbSwea
+xiZ1GzKkS326J6Fj+0IqekWLQFYCQq9kQyv7AjzJ+/Pj+Zef0btTSryU0LxLnxFXL/5qX36ZGXK3
+PtJdajvtm0NlJub/sXxUfcX0nv9LrucZCrK+T7t59MAeHZrGS1bdZh17DLrw7le/25/vqczC/3aZ
+9WNOaQXpLw+vI0mpj/43L//X506JU/xp//69bMNs27bzf33ulBqqM3LFnoLCQipoc/PXh474EDuu
+Yk7sHSzbl4fEWMVHEaLliTKWVe64iE8rAaFneTpcxR8HKMSOq4gTkUSnGi7CE9sBVA/O+cFdeGI7
+gGpAzw9uRPIBCCnCDwBgHMIPAGAcwg8AYBwGvEgVBhADAKIbPT8AgHEIPwCAcQg/AIBxDA0/c28L
+BCAqsBMLkrkDXth0AMBYhvb8AAAmI/zgSlx8AiCUzD3sCZcqib3Cf3B0GkAI0PODm1Ts8NEFBBAC
+hB8AwDiEH1yDTh6A6kL4AQCMQ/gBAIxD+AEAjEP4AQCMQ/gBAIxD+AEAjEP4AQCMQ/gBAIxD+AEA
+jEP4AQCMQ/gBAIxD+AEAjEP4AQCMQ/ghrPx9kgNPfgDgBMIPYWJZRUlW8g9n5wcKdmlADdUdqT32
+kW+lL1UtSyNXqOw7+f/T0DqyLA1fXTwpT3OPl9VOmw5XKP2QVs/T6L8pJVGWpaYddckj2pVTdavs
+bL1+t05sq9qWrFg1aavTx2vlzjLVWUe+Es5SpvfGBFNdcYFb53iouujVUzvzq2peFe3Qlpc1ZrA6
+NZNlqW4zpZ6qe5dpb74PCx4ScaEqGPDC3ye2e5zfrrBHA8qKSdHkITr7La3drX80KfNGvt6cr5wG
+mtRXVpmJr03RGp/7A3npuulK/dlPo6/XMY313euad7XW/qwvHlaSl405T0vGaOxy9bxQs25VUq5+
+3qQVr2j5OA09qniehrp3tlrVKP1QfGvV9rVd/ldXrOnpSmuqvPITty7RtDfVeYgaxKroPf+bZ2dp
+3oW6apka9dYFl+mao7V3iz7doJtGaulD+nxqcRA5uOA+sH0hFb0AR5RsUcG8gCplrLTrye7/rJ1f
+ZmLuL3YP2cmX2VllJu5+005OsO9ZYNeWfeaqklntR7rbamt/c+jIkguy7W9+KlNsnv3MYFuxdtof
+3tqTs8XuLLvNjXZ2ubLsg7lVVFf1u45XZ9uZn9jHya59ir3lcIANKKxu/eW2ZA+abe/LLzd96wr7
+1lfsXP9LdmInwGFPVDsOWqLaJPXRyEZav0A780sn/vKyPpfGXKrE4in2Xk2boJRpGt/W15KtBHVt
+V+bEUaxOGiDla8tub5/K/UO7pZQuii9XluJDcxAumOryf9fk4dqcrKVL1aFm4G0o+E23L5LVS49O
+Ur2yiWOp9em6Y2S4jj8Sfqh2HK5E9amriefJ/livbi+ekqMXnpDa6+LjiqfY+vhOLU7QoqsVH/Av
+swJtXCUlqkczb3PFt1VqvD66TjNe1vbKTmfla3+GMsq8snIDbJRP1XmUoyfG6JnfdNNynZkcVPOy
+N2ljrrqNUesa3mYLoOTgEH4Aolr38WotPZ6mwsEoh77V0z/quEt1TK2iGQ58qXFzNf5x9UistJAq
+pb+ua9ap0xT1re9ttpgUPb5EPbN16yi1rqek9jr3Wr393/IzbVefZmrYsPQ1OE2B/WL0qbqKbG28
+U5e/owELdPuJOvL3gJ/N279D2VKrjqU9PDtPWVnFr4NlPuvcgvuAAS8IB9sO9uAn3Uf4KL6zxnfS
+9EX6Yaq61tJXT2q7NO8cFfVDDunhcdp9ju7qW2Ev77PMTzX8HGUP0PpblFDVzC1H6pOh+nKN3nxH
+769V2kNKm6NpH+qukphpqoVPq22ZflKjroG3rerqKvj9DQ2foZQL9cIEeTjeGVDzys6QvkTN/ln8
+n2765XO1CaLkQBF+CJNg8o/kgx9q6rzLNH2qntmsBzpq4YuK6aMRLYve3Pa07tyi2UsUu08ZUlam
+bCknU3v3qU59n3aQWV9pWH99cbw2LNOx8VXPL8mKV+owpQ6TpPQ16j9YM67WZR+qqFF11HuAutby
+VoJfqqiuvJyfdP5o/dZFH89TcqynOfxsXr2WSpS2b1He34vWZ6PTtGGd8nP19EV6OoiSg8NhT4RP
+YBlG8sFfrc9Wb0tLntTO/9OyPzXoSjUr3q3v+lKHD+qK44qOs7X6hw5Jq0apQXO958NJsgPfamRf
+bWint1fpxHqBtC35FE3sJm3VDn+u3guY9+rsTN0xQu9KC17TiXWdqTGxq3rFadMSbSs+gVejqfr0
+U7++alvHmSoCQvgBiHaxR2nyKfrtRc26V/sSNXlQ6Z6vy7V6d43WFL+Wz1Ss1Gum3lmlE6o6gnnw
+B43qozXNtfJd9W/oU0vyM/Sf9HJTCvbq4x1SMzUPYkSlM9Xl641JmvmtLnxRE9o71oaYFN02XgUb
+dfkC7S9wrNigcdgTYeXvwU+6fQhEjAZfqYSzNGedks5X3zJBVa+jBnQs/W9mgWpKKaka+DdJxZd1
+79XKl7S5zLmopG4a1FiX9NXKvRp7q/a8o6XFFXUYqBMaV9qQw9+r/8lKHqFhvdWxlQ7/T28+oeUZ
+GvWYWsRVWl1cEw0dWHxhhqfGDOniuSPjU3XFti3W6OdUs6dOzlLa0vLrL1EDTleTShpQ1LzKvsiW
++j6g2bs0dYravqSxQ9S5rWL264cPtHiL6p2heEtFw1r8LTk41XZFIVAprmpHqBVk2OfWtyX70g3e
+Ztu/2tNF7hU2xTY32/u+ttt42kovXO+t/Lw99vN32cN62U0TbcmuUd/u1M++f6WdXeCtOnWzf8n1
+1pjKLg33qbriS8vfPqvyb1+SvS6zquZV8Qewv0+zRw+0OzS1JbtuM7vHIPvuV+39+T4seAVO7BMs
+25ef0iW/zfndjRCpsv/HtgegkBORxDk/uIP3jZjkA+Aowg+uUVnCkXwAnEb4wU0q5hzJh4iz+fZK
+Hgx0rDaH4HqGaq7OtW3wE+f8AMBROXu0fbeH+3JZtXR0K9V0euxiNVfnhjY4EUmEHwAgojDgBQCA
+APh5kTtPYgMARD56fgAA4xB+AADj+HbYk3EuAIAoQs8PAGAcwg8AYBzCDwBgHMIPAGAcwg8AYBzC
+DwBgHMIPAGAcwg8AYJz/B+WGU9Ys4xMjAAAAAElFTkSuQmCC
diff --git a/Documentation/DocBook/media/selection.png.b64 b/Documentation/DocBook/media/selection.png.b64
new file mode 100644
index 0000000..b426e2c
--- /dev/null
+++ b/Documentation/DocBook/media/selection.png.b64
@@ -0,0 +1,2937 @@
+iVBORw0KGgoAAAANSUhEUgAABIsAAAHpCAIAAACN6SvPAAAAA3NCSVQICAjb4U/gAAAACXBIWXMA
+AA7EAAAOxAGVKw4bAAAgAElEQVR4nOydeZwcRdnHn+rpuY+9Zs/sZjcnCTmAEBIICQQJpwqIoALK
+pRxyqAiivojKJYKKyn0qtyDKGW6EcMl9BxNyb3az9zkzO2d31/tHTdfWdPf0zG42YZM8X/jkMzvT
+/dTR1VXPr57qakIpBQRBEARBEARBEGQcIH3ZGUAQBEEQBEEQBEGyoEJDEARBEARBEAQZL6BCQxAE
+QRAEQRAEGS+gQkMQBEEQBEEQBBkvoEJDEARBEARBEAQZL6BCQxAEQRAEQRAEGS+gQkMQBEEQBEEQ
+BBkvoEJDEARBEARBEAQZL6BCQxAEQRAE2ZmJvnisn+TiClY2zVl89FlXPfxhdybvieqWuw+Qh0+a
+csmnKfbD0OunVpCCuI58JlLQ1Naj9H5w78XfWDijvsxFCCHuUGXDzEVfP+2ia//xYb9mVQnVZ70V
+t6iZmrNejVBudNMNe2a/rzj19SE7IwBq13M/msHtzLrgxW51rAqH7JqgQkMQBEEQBNnFyMR6mle+
++eTtv/rO3lW7nXTnyhi1OEhpfeqW1wWtseG+e1YmRpfeGJoyGG65/7ip80/5w+PvfrFlIAMAkI72
+tK5+a/ndf/r5xfdvGIkM7Lzj4rs35Jer+VC7X7hw6RE3fMH+mvGj51b88ZBKx4jNIIgAKjRkm7DT
+TtcVN1GXRYt98dQfzjl64ZQKLyGEEDlQs/vS71x8++tthpzkmZMDdcud++j53/2aNRnjwQL+mhmL
+v/2Lu9/vs562U/o+fvjKM762YHKFVyKEOIK1U/c8+JTLHni7LUlNeTDT8NMPxmQgRRAEQb5kPBOm
+TZ9UExC/2vjgGQu/cdta0yCZaX7s1ndzvml58K6P4wAAUmDSnrvvlmX65IrhQ0KN0/XvZ8ybWuIo
+aGqroL3LzznziYHsX6XT5i856MAFsydVekZn7d3LL18xYKVV86L2vPSzgw7/6yr2127nPfPqdYeh
+PEO2Hoog24DIC9/w2TS7SSfe8VlUszgvs+mWBTlHNvz0/TillNLYa6eUF27PziOeHixoatRkNt93
+dGmelOsvyLWu9r91zaF5czz1lHvXxIcrQKiuqjP/O8S/V1rvmK+fMvP3X6QL1y2Ze+m7xppNbvzX
+eXu48pww8aIPE4XNGkuHIAiC7EBYjTKZ3o/vv2BJGe/o5SW3N2dyzkqtvnr37I/ehlD2U/i0FVGj
+eXXLXfvoZmb8bnXKnIGiTY2U+Nvn1DBrjkU3rRtOWYu3vPOv6//8RHPathIsxr49rmUFyGy8fo/s
+V+WnvBazNBLpfunC2UQ/c9o5yzuUrS0QglBKKcUYGrLN2Vmm60YyUZded/vxB//8hT7972Djnvst
+mFnDZdK6e04+6Pxnu01Rt5FSufdByw4+cMEMLgXpp1de+GS3MP+ndj75w8XH3fhJWv/CVTlt78X7
+7zW1ystOoBaThZ4J03YTmT23wYd9BYIgyM6EXL7HSdc9++L/7Zb9W3n9D3//Ii0ckFrz4F3/Yx8b
+zrz+yv2YEul57La3Bkea1hiaMqDG+7NLPJzBEs9w7Ip46xd88/yfHDXRWbQpR6kDAOCT3/36hd5i
+hme19+VfHnzon1ayUXTKWU++9tevVmP0DBkjvmyJiOyc7IzTdcVP1Kmdj3zdr+fPNf/i59pZObWh
+1XefNJFXQMMF75jn8EYUQ+MHJz67cqZ+YO25b/N4l9b/4qmVPMGyZb99YQvPpRbf+MKfz/n+Df9L
+2uYBQRAE2dHJ38NrPY98hauKBXe1qvyXxIc/a9SHq5++H918+77ZvwLfeKo3d61GoUF5BKZGirL5
+zsU8/476BUd9/+Lf3/HYfzcMmoNZhWJoe1922f4yG3AvX5ksHEMTmHzG420ZU4IIMnpwXhzZbuzo
+03VFT9Rpnc/9Zbm+7dOcy++/4rAa1ucT324n33z36bpkarnnpvdio85ODp7GBTN1TegOuPUlF7Tn
+hd8/0J39o+aMfz3y60Pq+HQi8TYd8pOb7jxvpnts8oAgCILscBD/1Pn1+h89G3r5c+LxT/72QDP7
+WH/cibMCdYedln10IPbsLa/0jORZrTE0ZcLRcOLNv1ucFU1q67tP3nXtL874xqLJJf5Jyy78xyrL
+/U/yIE888Zpz6gEAVl17yfKuole5yPvf/NJNR9fKI8s4gtiCCg3Zvvjn/fRKPl239pl3hIV+yf/d
+e8869rHh+O8tO+a0heyPgadueb1vZB34GJoaxjv14Dks58nnv9vYtPDoH/z8mjsff2tjxLg3R3zV
+M5/qiex51nemio+AkdDCM4/PhuKg7+1XN6dha6GZaOt/77rupawmbDjm2On6wsuhz5/8QB9tZ/zo
+wsWlxMqAia77T5g/W2Desbeu2/p8IgiCIDsMsQ/v/Gcb+1h/3Im7e8Ax4XBdVyVfvPnFzuKX6Y+h
+KSu8cy5+ef2K68/96tycZ79Tm/5z3YlzD7thbfHDFwksuPiqZW4AiD3xi79+WuwGWcqbv/35PzaO
+2asDEAQAFRqy3dlxp+uKnaijya7WaPazt3FquWFRurtmd12hQV9z38i39RXoun2Rn0iuUMP+FzwX
+AQCoPvK6xy/fR1+BQZOdzfpzc+4pe9Tk2y3ERLx51ecCH33cEt+qOU4EQRBkfEKH1r3fqv8RnlyR
+XWcReee2f3exj/XHnTTLCwCOuiNOzS68z6y45dn2Yl/4NYam8uGsOfD8G5d/0pPq/uLNJ+644qxl
+DdkflP9e9cf3R/AEumPC8df8ZDIAwLo//+LRtgL5KgtnveiuR07Z/7R/NONUJjJ2oEJDxgk7wnTd
+2E3UZbHapWP0OPe55MG/nz8vWFygDEEQBNnlGfrwul+9rAuRaUcurJQAAOjAm7c+0Z/9tvUv+/gI
+IYQ4m855P/ud9sYtT7YqxSQwhqYKQlzh6YuO+sGvbn3uzdv0h7i7Vm4cyUpH8O55we+/7geAxH9+
+c+v/bA+t+uZ9/7liv+yDAu3/OHHxGY+0bNWsK4IMgwoN2c7s4NN1RUzUEU9VfTD7baJ5nfEFZamO
+/3Xon8ubyp0AAMTh1hewp4dSwwKSpmJc9clu2SS9yPRvnHHWKUftzQRj5r2rDp5/wesRPhYRT/XE
+Ej3Z9R+3F6sgTTuFbLhqLj6shiAIslOh9H/64IVHHPK77IuWQV7ys9N2cwEA0L4VtzwTtTkVAN67
+7dHmIuTIGJqyJvHeL5YuPVl8uyeAFt3weWf2c2hinW9E85ZS9VFX/WwGAIA6UGA+VypZ8H/PvvLb
+BVlHpvXeby05+7G2sVGbyK4OKjRk+7KTTNfZTtT5Zh4xVx8PPr794ZxHuGjk3Tv+pSu08v0OnOgC
+AJBL6nQlNbBhc4yPCemOVfqxpLQmaNrEt3Lpz/5y691PvP3R3w7LrmxsufH7V3/AV3T4Zx09X5d+
+q2+47s1BXKuIIAiya9N17/F77jalLiQ5y/c46brX9fHSt+z6u06eKAMAaN0v3fx8diBxzfjK174u
+cPh8fbT65I5/ri847zeGpvJA1cHVr9732+/uN8ErBet223vxAfvNqa9cen0L+9k577Bp3hGadM86
+99rjSwofBwAglex36XMvXzIvO9Q2/+3YJec+1YEiDdlqUKEh240dfbqu6Ik6qfrwn3xV31nx00u/
+e+lz7Sw5Gl99zzmn3JUN8EHDyefuw14T55584Fx9d4+3rrnpnUENACC14ZFrHtIPnnLQ7FC+aUB5
+4vdu/+uB2Um8tX+6+J+tWQ1Mwof+/KRw9qiOO4477vIXtvBRkMbXP/ens0+//n/4eDOCIMiuQ3LL
+2jUb2qPijN2kE25/+7Gzp7HFEmrHcze/nB0qGn/84NNPPSmw/NE/7Jsdi1bd9eAXBcaPMTSVH8LH
+xlj7mg/ffP3tle26QvIc9Nc7T6wf8SvKpPBhV/xybtFHly2+/MWXfrFH1qPecPtRB/zk2a6tfbQO
+2eX5knb5R3ZyxBeGeCZMmz651vh0lG/ZzWvYi7io2vnQIfomFvnn2GDm71bp71jJ++qVkZsqnqG3
+zq7WDQRqp8/bf8m+s4XddZ1L/97CX7+SWnvTweKsna9+9oL5u1WJL86sO215Fz9eG3jplPDwb+7a
+GXvOaRJm8Mj8v6zVX2Rm/VqbyGtn8txN/uVHCd2y0v7YybVixcsVk/fcb+HcSRWsnhou/CBhdcly
+3li9214nP941/JIcBEEQZIfC4i1eDl95w+77ffX7lz3wbqc4IirNt+lvK4Npv11pHCzVtvsO0ke+
+iRd9yAaQPIPyaEyNGC3R9sFTt156+hELZjZWhdgw6whN3PPwM699ekNcfNlaofehLby7nQ90Wv8L
+J1fwurJ+H1rOEwFqz0sXzh52dGb86Pku8xvZEKRoUKEh2wTrVzpyJp1w+6dRvd9UttxzgD7D1fgz
+Qx+tbL5dn2ODKZd+qmu6PAptFKaKZ+itH/JNGE14Drp5Xc7go/a99ftDyvMdPvl793yRM3BQteel
+C2bniWlXfP22NcPZzTM8pNf8aS/9hOCxT3QLbx1d99DZs/O9qIWPivaXbJ+7tqBCQxAEQRAE2Q7g
+KkdkeyFO161+8Iw5gaxaUrcsv+W17HKAaaedMsuTe9aEr527NKsu1t9z7/+SdkmMoSkLfAuv+zDv
+RN3/nj57Ss5m9lLZvj9/btOqJ645++v7NJWyn4i3arcl37rw1hUt/7vn5OnenKiiVHHwn95Z8/Qf
+zzpi3sRQVmV6qmYc8J1f3vPuF4+dOa3gTh3OKSf/5tjsDiXRR39z93q+kNMz5du3fNT+/oOXnX7E
+3o2lbgAA4q+avMdB3/vNff/97xV7eqwNIgiCIAiCIF8ChI7tft8IgiAIgiAIgiDIaMEYGoIgCIIg
+CIIgyHgBFRqCIAiCIAiCIMh4ARUagiAIgiAIgiDIeAEVGoIgCIIgCIIgyHgBFRqCIAiCIAiCIMh4
+ARUagiAIgiAIgiDIeAEVGoIgCIIgCIIgyHgBFRqCIAiCIAiCIMh4Qf6yM4AgCIIgyCghhHzZWUAQ
+BEFGA6U0308jUGg4DCAIgiDbAptRCrEBx2UEQZCdkmIVGg4DCIIgCDIOoZQCjtEIgiA7DgW77JGt
+clyxYsVoc4IgCIIgRpYuXfplZ2HHB+UZgiDIzgU+h4YgCIIgOzyv4hQqgiDIuOfA4uYlcS9HBEEQ
+BEEQBEGQ8QIqNARBEARBEARBkPECKjQEQRAEQRAEQZDxAio0BEEQBEEQBEGQ8QIqNARBkB0ITVHG
+z6vDxlVmEARBEGQnAfdyRBAE2VbQZPMLN//x7v983p4pnbLw2PMuPGGvUtr68BmnPLrvbfedNdUF
+AEBj7/z2O5elf/HQ7xaHiNL7/gN/vuXJ99b3kvBuB373gvOPnhEgyub7T/v+y8suOnDNw09+sNl/
+ws1XTHj2ujue/aQzCa6yyfufetn/Hd3gBFB63//HX2976v21XXFP5ezDf/Tb85eEWh+/7rp//ffz
+1ojmr5196OkXnrWs0UOAGTzkl4esf/Df726I+Hc/6se/PntJVe54kG62OXc4M3f+7aTgx+Y85zsd
+QRAEQZBCoEJDEATZNtDou386/+oP9zzvsjvm+5qX/+XqCy923Xvzt2qWHNl0x79eaj5t6jQXAI2t
+fPp9ba9L9ggSSK66/fxfvbvXub+6Za9wev2zN15z8R8q7v3tkgAAZDbc/9Cev73q/surtNanLz5j
+RdX5f7hvYTUZbF29Oi4TAJr4/NZzLnq25qQLr71kejDZ+tkqoBRoWq09+NyrfzKxlHa9/9C1117i
+a7rrjGluAIDMhoceiV1+9YO/CbY/dek5v79+jzlXLCkVFZTtuXpmIJ1cc/uZFnkutTkdQRAEQRA7
+UKEhCIJsE2jfm/e9rC696mffnB8kMOXsS9rePfWf/1539I+nLT5y0m3/fKn59GnTXDS2cvkHMO9X
+cwKEDrx153J67PU//vpUFwDUn/6zTa+f9e+Po4sXAwD4Fp192qI6L4F0prOPVhw0b2ZDlQxVVfXT
+AABo/5t3PBFZdOltPziglABAfeMMAACY9s1TprHcTJjwo/Pf+s7Nr205ddpkAgAQOuCsk+ZXugAa
+D/nWvNuvfmdLekmpKKDcNufyzNDUe3dZ5nlpyPp05zaudARBEATZ8UGFhiAIsk1Id6/pgIYjpwVY
+ZEqunjsrePf6tgSdUbX/kZNvfeil5u9Pm5r6bPlHMP/XcwIEMl2rWuLtH/zg0AcFIw2b+1UgAI7K
+3eq8BADA1XDI0TMfvfF733l58eJF+y89eOketW6S7lrdqk08dWYodx0hjX7+6E03Pfza6q64BgAA
+Pu+AAuAEADk8pSoryBz+ck+8I6ZCsecOZyZ/noOJvKcjCIIgCGIHKjQEQZDtjKNy0ZGTb37whU2n
+V3cv/4js89tZAQJANVWTpv/0oVuPqsrdw0nZDCDJHmdWfbknfecv/97/o9dfe/Ot12/5yZ33fOPP
+t/1od6tkaOz9P//y1pYjfn3DFfMayvzqx5cdd0lGy27tQYiDp0IIAKW06HOHM5MvzzT2Xv7TEQRB
+EASxA/dyRBAE2Sa4KqfXkNb318WYMFE6P/08Vjq1zksAHJWLvja1f8Xzn7y7/CPHgq/NCgAAuKp3
+r3dsevWjXq2gacnfsPfhJ/3osptvu2C3jv88uyHlqppRL7W8tSoiiiCl69PVianHfXvxlAq/S1J6
+v9g4VNj0yM7Nl+etSRpBEARBdnFQoSEIgmwTSPn+3ztIevkPf3rsww3Nq16+7ap7Wqd+69ipbgAA
+Kbzwq9MGnvnrLe86F351dz87vmzRWceGP7ju0pue+2hDa+v6z974943XPbopbTCbWvvwjfc8/8Ga
+1q6ulpVvvd8h1UwLy6R00RlHBd+85jd3vrKyeUvz6reffvztbiibVOtofe3tTUMaja9/6qZ/bIKi
+N1OUizs3X56LPB1BEARBEDO4yhFBEGTbQIILLrzhlzf/4e+Xfv/6dOnkhaf86aJv1mc7XSm88Gu7
+/enalYFDvzrTp5/gnXnmTX8pu+HWv//q0c4hyV89fcGRp4UcBquSxxt7797L7t8SyUj+ur2OuOS3
+x0yQAeRZP7zp2uB1t9544QO9KU/17CPO21cqO+Ciiz6+7MYzjrqlvK5xwfFnf2XVTUa9lzfvxZ5r
+neeiT0cQBEEQxAgxPHuQ9zhCAGDFihXbNjsIgiDIrsTSpUvB9BQcUiRsaGZ19yoO0AiCIOOeA5cu
+BcguK7EZ+3CVI4IgCIIgCIIgyHgBFRqCIAiCIAiCIMh4ARUagiAIgiAIgiDIeAEVGoIgCIIgCIIg
+yHgBFRqCIAiCIAiCIMh4AXfbRxAEQRAEQXY4qMPxykT/0+WOtX5HhGo1cWXvruRJbek6VT9AlpdP
+8j1fKq/1SSSlTI9mvropfugQ5e9nVD3eMxf61wNM3tB/e4vKvWIqu36zb+g1BwQ6Bx9ZnfEKRzI8
+GXVab+KMjcm5wotECiYHAEmv+5Em7zNljnYnkTStekjZqzd1+uZUmBqT4Cz+rPfKvsL73cbKQ9+e
+4xrKJG94JzZHNf6ap66Uz+aWXx3KZ1L77gf9pymeMxf6E5v779moRapD35ohL1rZf3mvlvOOSyL9
+Z075FaH01e9EFji2qhRIFlRoCIIgCIIgyI5FMuC9crb/DTed05k8vkOtAGlDUP7vpNCLJZHHV6Z9
+APGg9/I5/red6qItybNbVM3jfKfGe/V891trBn/ZrrpzrW2odW/ZEm/U2F9ksMzzrvFllAAAoZ6h
+CzpVWZLaQ+4HJgR+FJLu+DA+TQUoLjnV7b5yXvANohzWGj8lrikueUOJ87Ua55GtqbCuqUK98XO7
+VME/pzWxYoSN9HGdawgAnO4nQkNz+nNOsamrWzdGL3VlS91c57+3RPvGmvhslhlKpyRFqUDL+5IL
+tOA7dc7BvlSpkILmcj5WBsHO5B4ZAMfWlALRQYWGIAiCIAiC7EBQh/O22f435Mw5H0aPjw7Hc87e
+6FxeTh0AVHbdOsv/tpT58fuRY7JRrNSxrakH55TcMT00IdZ/RnTYWl1XOlnlft6XOJOpCELeq3PR
+SGpm0N2Sm24gnl7cozoBoCs5Ty37wUTvQ8HEpQO0yOTaq3xvyNqJHw6eGWVyJQWtcD4hmiBeAkOp
+r3SpzpFWiMv5aDlUtsdnV/reqHNG+9PB4upqwoAyOfsF+bTcf2+JNrcndVBm2LIos0gmfUwvfSvs
+edeZPjQ9nOnOsHclaEe1Z3wA6laUAhkGFZol1NH8ysR7ni5fvdbfFqGhmvi0vbu+fVLbPnUqUT2P
+nrnweh69dWfqpvYdddrGb85P5bRDKq9ePum+50tXr/X1ktSk6dH5X9102qFDPiGwnmPHk6mf1vuN
+MzYePTdtd00MZxEtVDs0Y8/ew45pWzo947A8hud08WePXdnns/zV0/PHRz+f7wMAoLHyK7495+Wh
+zNdueOciMUoeL/vNsXNfn73yqT/2+oe/dXx0+X4XvBL93fJPFvn1pBOb/3bPxslOACB9z+95bP7o
+ee13P7j3BzG8fxEEQRAEKR7SX+F7yg3T18eOjeYst5NTmWPaAYD0VXifccO0DUNfFxYZEiVz3Nr4
+03v7Hp3o+s7nwxrGFU8uTYReqJFPWZdxA2gu12MldMHqtLKbUaGJTBhQvBPdrV6iDcBAUcmRQa8E
+oDalcgtDqVW4bmR0V3g/Itq325OLiOeVKu/7rsxBWQVVsK5GBJ3TlgpVeh6vIMvaaXYzCyK/WitD
+KvG1KEbJxg5UaCZoMvDYlbOvf8NdNqfzkOM7miqge0Pw0/9OuvjFkmsfX7mAxalDPedd0Fkjk1hn
+6OWH6m+9KDRwywdnzVSzbwiPBx+5fM7NbzsnLNpy1NktlZpn9Ts1j1w9/9W31vzhl+2NYmA9a0eK
+toeef2DCDT8KDdzx4fenmVYPGwj1nHdBZ7Usxbo9rc2hN55puuKZhid/8OnVJ0WGFWCo96xzu6qE
+6+uqiQ2nnPsrcSen6r9FP6777xAAOFc8EfrhnH5BjI0CGthz42WXuhQAAMg01/3p3pLKb6z5vh49
+D0xJYgNEEARBEGRkbKiUFVAP61HzuBFkQ1hWQDmiWzEc4I6nv5L03V/i2uxIz+LulqYd0qH+o97z
+xcbMXBU6Kz2r1fQfBum/bPMQ9TgSQMvTVCo6udqBjKvWdct0r3tzap+o6rNSNKokRWVNnL32KrSA
+t0Qcr9XJNJlYNqTVd6TLatyPlZMDO7IKqlBdjQxfNHVw2vNYnbuzI1FLAQAUn2u5HyY0pyZpW1cK
+RAQrywB1rLxt9vVvyPPO+fDK46M+IRb8/vLyMj7JEYjPW9wz2QkA3QfPV04/tenJR0Kn/LrfCwBU
+/uzWWTe/Le3z4/evOGbIQwAAjjy29cgH55x/x/RfTYjdeUZ0WCkN2+n6yjz1tB9MfPSh4ImXDnjt
+Mzl8FgDA6aeXPPCLPf5256ybZr130V5KNsuBoYVf6ZqcLz6V71fqevfR8mRl+zmzK29+o+6TaP+i
+oMXZxeOqHjiwOvs5+Wn5zfeWVMzt+cpBGWJ7FoIgCIIgSB6I1OUmoKkNSr4DoMtNQNPqzQdoWlMa
+IOToy/FEaF13Yuok/xMhMndQerlWLuke2l218FU0IiUcWkYi7SWem6bIoKQPj1IgpLjkaHl37NJQ
+6KoJvt9U+ABo3WB6cXfquPZ0laBtOutLjq0XTSi/emtgWRpsULzuJwNQuznVqIEzljwg7Xmizt3V
+maihRdTVSFGVr3aqjzV4XvEmT4xTALKx2t0KylldiuhVjqIUSA6o0HKh/RV3P+WG6et/eqwgzwBA
+Ts1nsWBTfMtZHZnqg5ZWT1QDrwS0v+LuZ9wwbcOPv56VZwAARJlx3NpvPb33A49O/Og7n+9rJXvc
+EwameyeuaPXGtAHvSN6C4CgZPOHnza+c2vTc/eVn7NlVOoJTjWjdFY99RKq/3X7YIvLAK1WPve/a
+76A0qikEQRAEQXZmHMn00ZHATXXO3oz8tE/7yhcZL7jMh3U0lBzVkP1MkukzvoguSQMU7yhRbcm6
+gSdbnO+XOz8olT8sd/+zxP2vmsRNHw/N1P3Lsq7YLzo0YXsObXLG2pgOaa52bwb1ZPbcl6oe3q09
+McH9ijdxQrzojI0A2tSRmtjgW14lHb9JdTrkZ6odEB06KJFz0MhLgeSCCi2XxIbKzxWYclhPbdE1
+Q4fcHXFwhDJMViU2hP+nwJQjuo0W3PGDv5J84P6SNzY79p1lsY5Ri3o6EuAqT/tG/pI654SeAyY0
+3bOmfHOqq5TNYahSPCpHhfkM2at4eZZyf3V4VJ+TApCO1+o+p8kTlw2V1HcsKat55rHy3gM7wvjS
+PARBEARBxgtUq0pRCDpaZFhgGRqiUJWiEJRazQdI0iYXQEYtN6wwpHS/tsxfp3sf0RxtydQRMetX
+Bpd1RS9p11wUypNKTUpftjfC5FypzKL2zKJ2ACK9P7nkonrv9VWJm9qzcTRvMjOvfyR7bDjk5TUO
+SCYWZCAqEwCo6k2XTfAsr5KP26Q4C9bVyJETqaNivhtrPBs3D9UH3f9xwZyNqarc+hxxKRADqNBy
+IIkudxK06galwEObGkkmHImMFOsMvnjrlFWQWXb8YAAAgMS73EnQaurNFrTypjRAaIsYWNftRNtL
+nrlpympQDjg8WmCJoyVyelIYoM09mAFg90Nn/Xm58eVZv3rrxmV6QCz316az3r3zhISseF9+MgC1
+m5c1auCMHXFAevkTdW90dR5Tg09+IgiCIAgybpjcrchh5/Nhx9Gtlo9X0Uk9iiPsfC7sOCr3gLTP
+/YoHPD3pica5clrel5wHwYeqoGFTqkmzVmjepLLHgFl4jCI5dp6215bklHp/R9CRaddG55PHg+6X
+XQDgPW+/HAeyv8a9cbMyXStYVyOHqge0KTdNdz8dTCyuc0e0zLF9FGfzxxhUaKOjo+EcHuaG5BH/
+99lPFsmsQ0wAACAASURBVIzq2SrRDkkuPuOLny5Jj66RG1VUWdeFv+ioE+LLoclCDnN+pf6GlAMg
+3Vy9fDPUndzV4AQAderh3eEnJjzxivdrJ8SxmSAIgiAIMk6gZb3xr6dKHmsKPDYYPU7YolBxu5aX
+a0e0K+W98SPTJU81+Z/ujx6l769IHfK/p3q2gHrC5oz5eROSSX+3Ja0GtcM6jRt+FMxPkclFfQ4l
+qZYNP3VGYn65C6BqaJTyDIB8VuceBPVbq4YWCssI+8KBq+rcy4Pxnw4Wriu3lV17KnsTe9Hgyw2+
+5jLi6UvMT+Nc/liDrncO1FuV8kCws0VWF9iG0cq6Lr6kvU5y9K0P339rzStPVxx/YHyyGwCoryrl
+gWBHq9mC1LfJBZCZIEa6y7ouvqR9gov6ypN1NSn/qC+H4trYDRBMlfB5HW9y1rz+vDuFWPzqWL+8
+pgOS316QSUblJABU9S4sm/D08qqW4zZNcgJI1O0ELeVQqLjimqTjEsiqjA+rIQiCIAiyfSBq5syV
+se7ZgZvmlb3emVwQVcrBsTHofLPK2dMXObQdiJL54cqhjjn+P+9d+l5ban5M0zzyO9WedzzakrXR
+U633hadzNkX+OLr8FJUc2Vxfcm4VXdyZnjWkVKukO+BaPsEVzaR+2qM69J0OYn73y1U5wa7SaHpe
+glo6WtTperyCSIPx47vTlUKZ1ETiX3X+V2qdZw+mfYXqajTlTWeO7YNfVXg+BrqszULujqgUiAWo
+0HLxTu6eJYc/eD7cfnRrvU3leJMz9hiY7ASY1zenTD71yslXPtx/y8kxN4B3Us9MR/ij58LtR+Va
+SPtefsUDnp79xUg3t7N1ZFrDr7WBvHfvRDeAVvh4C+LBJ192AcDD5+33sPh9f82zGzefM10DOTWp
+AmDAO6BCyfDzbHJ7D4GKoQpcaowgCIIgyHbDG0te8Z7ycqP36TL3P6u8EaDV8cw+GyIntad9AADg
+iyaueU95ssn7Ypnn5gmSlFamRZI//zx+eEzbFjqhiOToxPb496nrv2Wee+pIEsCfVqd2Dp23OblA
+eENapMJ3dUWO5Snr+25vtXxnGukr97wr0X22pMO5ktORSh034L8q7PlUTu+rFK6rkaPt2Zb2V7iG
+MqmjIxZydySlQKxAhZYLKes95eupDx5r+vNjg1ccJ2znqLg/WF5eekT7FGON0cqvrL3wpfLL75vy
+n8M/PbKKkvLeU45Mf/RU0w1P9192lL6dI3Ws+ffUh7fAhBM2z9u6/evNaJGSh65t3ATpr32vv2S0
+nU7ss7rXBqHhW6t+vHB4MaTWF77uqroXlwdP/+mgR07PmZuGJ6tf3Njyg2lZFZjZUvXkOgguG6zG
+hoQgCIIgyPaEqMrBG6IH5z9AymSOWZs5Jv8BjmTirlcT1r8p6atf7ynqyKKTC0aT34smvzeKzFhD
+KzoH/9Np+Yt2yCc9hwhfFKwrADp3de+K1cXmKtAXefpVCysjLwViBTrWBog658yV53fPvuGmeSe9
+3nnogmhjOfRsDH76ZtX7PX1/ONSs0ACk9OIzWxpOb/zbg6GlPxn0EWWPH648q2PObX/e+4z32g6d
+Hwtrni/eqX78HU94ydqrTo2OYrmvkZjvwzfCbbIU6/G0NgffeCa8Ka3u8YOV5+yhDAu0mP+dl6s2
+Crl1lEb3nZfwWBqkzo8erxiSBs89vnt+bpT82/+q+8srtf87e3CeT939lPWLXpp5/3l7dX+nY88G
+Nbml5IWHaza4Bn52Rn9AVIbGpGlgSv+CprF6EQeCIAiCIAiC7MSgQjNBvLFvXvHe/Jcb73667PV/
+Vj0cgVB1fNo+G/54UvvePov3oQGAa9KWHy6d8H9PTn7h2x8fU0uJL3rCNe/t+WTTvS+WPXbzhD4p
+3TQtctzPPz/98JhvTALrkfCNl4UBAEAL1Q7NOHjT977RtnR6Jid0HKm4zRRf/sftrbVW9mhf+aPv
+Sq59tiwyRcmXHDdw41Xhxz+V99pXkSq6Lr8v88itjc89PemFHoe7PDF5waZrftiysDr3LFPStd/9
+4N4fxEZbWgRBEARBEATZdSCUFrX9CiEEAFasWLFts4MgCILsSixduhQAihyJEANsaGZ19yoO0Aiy
+kyLJd+9derfVE2MTmwfu2qTgXgA7EgcuXQr6nns2Yx/G0BAEQRAEQRBknKKp3/ysf5lkXoZFnZlR
+b9OPjG/wuiIIgiAIgiBjw4Hhpfzzqz0rvrR87EzQYFId633mkPENKrRxh7Tx7r1PyxPL/vtdmyZh
+LBtBEARBkB0AVGsIMjpQoY07tIZvfnb/MsniF2emBq8XgiAIgiA7HgXV2oFLD9xumUGQInl1hdU7
+BbY96PGPP+Rgsh5j2QiCIAiC7Hhw9SVKMgP8JwysIYglqNAQBEEQBEGQMUZUX/nUGvsedRqCGECF
+hiAIgiAIgowZNtGzYlk5Ju+PRXZURiTaxfWxY7Uo8Utfc7tLKzT2RgIEQRCkGPCNWwiCcMZAhiHI
+VrMt5Nl4YJdWaAiCIAiCIIg920iM4eJGZCvZWeUZoEJDEARBEATZxRlbDWa9VWNuEkXKMzLb9A0h
+AEAp5X+yz2VlZaeddtoFF1wQDoc1TRMPkCQJADRNY/+uW7du+fLlLS0tS5cuXbZsWSAQ4Adz2Dcs
+LZ4E+8zs8F/Fz+I3ogXxdP6rqqoAIEkSs58vD7wIkiTxwwxZ4seLdggh4k+W1WvOIbcvlsWQK8Mx
+BuNi3szpsoIQQvr7+5cvX37bbbd98skn6XQ6e/zKfNm0YNvJsy99iSOgQmNoqiq2IfaZNUF+Y4tY
+tkjxJxBaMOTeseYj82HOkuXpBjtij5DPmiUF81MwkzamzHdvkbkqxrhlQobKN3ea+UyJWRIvtKFi
+i6wuQwFtclWkEZuWULzBMcFyODHnYUTtHITathkeLC0XbEv2132kWI6OlpmxbHuQvxspJnvFtHOb
+LOW7H/PhkHGkQJCdge0gw4pMd9tFz4rxK4iA+fTixwhxIBhR9rbbYF1M9kZUhFG4bZZG8onS4tm5
+5RmgQuNYKis+G8Hkfr5TbMjX+Ax3tY3ks7FZpDcmfpOvN7GZKSk+P9yU/VnFqEeDhCvorNtbMxsX
+RZe9hVFo3SJzNaIOuhj5YdmoRmrHhlFr+JEKUfurY5mZgqdY3r9FDuSGhAxpWUo1mxlEm5lFy3ya
+KaZ+bCyLTcVgik0MswnOUSSBIMg4YcwXJW6NoBpd6Cwf+TpJs59gP6Mq/ro182WjEGk8UbNEsc/q
+iMasgnGCfFkqmBAPYBS0aTDOhhiDPBuRg8fZ6eUZoEIzwFsMi4+LvpQ5klaMNdYceaO37C/yTbGb
+rYmn2EzDWN5gZkezyNhLkaEJMT/mzs5+gl8Mm1j+OqLKN/RKBcWnpVQ2dBzciLhwoiCG2igmVzaF
+svycL45UZMEN6sJGMxRsITYNckQKzdAYbAZjGyOGb/IN25CnMu1rmGOYgi0oic0q2nzW6BRawWuU
+Dz5eGnI40tEXQZDtzLjSYDaMrTxj8Ckkg+NhHm0ZomsH+jjONYOqqnxk570fT8LsFYiDlGgWTF2x
+mL188s/wq03fy1MpEsuxxnKgN7hDoo4yWBBHQB66MFS4QX1ZpqVpGqv8kRaKsSvIM0CFJsIElaIo
+iUQilUqxBsR/FdtiMdbExifeh6ztFu/9iLcEFOGKFTOdIzrl4ok2R+azIzpzoqtq6ePae9XmugKh
+gyvoVRuyxDvZUSs0UQZzO2JvYqNnzPUgdmr5qiLfJTDUp7l/NB+Wz++36Zrz6WqbvJmzZKkMi7lx
+iFVUx0aZ52tj5hFRvHcsW1c+I2LDNlxH8fiRKjRDGfNpaXtr+QZ7+2/EFMXK4ddOlmWfz+dyuVjv
+ly9vCIJsB7bF5hzbc2eObaHN+HBs7saJ8LAZU1yikGOwno1JMtD9NEVRFEWhwvyUOEyLfT6Yhlpu
+1tKBAaHbN2SVD5eG4QbyjJViKkVWVEF30Wwfckdzs00wzVObH40zjMLin5DrRLFqt0zLhu0jz15d
+8eqXrtZQoQ3DGko0Gm1ubu7r61NV1eFwSJIk3upgG/ISbzDuYrLma5hiyecH58sYN6XmPjJnmSUb
+g6IpQ58yUlhP53A4DKWz7Fwsb3XLgoiTWzYuuCW8pzM/UGsWcjbWxGtEcp8wNlsoprDi4jEqRFbz
+WchXNA4bolhjKMaOjbPOTBmCxvnOss+YaEq0kK9VWBrhpsS6ormC2d6OWZ2yG4erjoJN1JB/ngFD
+SxBHIBvLlmXkdSXOBBU/lIrZdjgcBp/DnH/LwvL7hRXK4XCUlpY2NDSUlZURYSIJRRqCbCO23W71
+422PxK3PD++IHA6Hx+NxOp3mHjgQCMiynMlk0um0pmmsx1YUJZVKsW/Ykaqq9vX1DQ0NJZPJSCTS
+3d2dSCRA6DxlWfZ6vU6nk6Vo77BpmpbJZJLJpKIolgeIcB/M5XJ5PB5ZlsUi2JSdJZHJZMwjteXx
+DofD5XI5nU42QBg6c4MFSqmqqoqipNNprprMNvnBLLdOp1O8EPxX8U/DwJ1KpZLJJHc+I5FINBpl
+KdqXiLPd5NkYWh41qNAAcufvBwYG1q9f39bWlkqlJEmSZdn+fsjX4pnHU1lZWVJSEolE+vv72U41
+5uh8PndK/Mnr9VZUVDidzp6enlgsJloAk3Np6Vfxg1mufD5fNBodGBjIZDLitIf5REsjAKCqqt/v
+r62tBQCWKypMWeWzYFlphBC3211aWhoIBAYHB3t7e+3rPN9PvO8rKSkpKSmJx+P9/f2sgEUWCgSH
+nlLqdrvLysr8fn80Gu3t7VVVtXhvVTySqf3q6mqfz9fX1xeJRMz9Y0FrvK6cTmc4HPb5fF1dXZFI
+BASHe0QuPqXU6XSWlpb6fL5IJBKJRGwKaKnxRD/e5/NVVFRQSnt7e+PxuOEUQxuzKR0AyLJcUlIS
+CARisVh/fz8baLlaE7W3vTUAcDgc5eXl5eXl/f393d3doM8CGA4zlFHMDG9U/B7s7e2NxWJ8sDfU
+qj3sGKfTWVFREQgEIpFIX18fG9cNd26Rstbn81VXV0uSZGgM3IK5H+C3g2ifUur1eqdOnTphwgSw
+7QQQBBkRuE/9GGaVEOJyudgAYZiHBQCv1+tyuVKpVDweZ5NflNJkMjkwMMCUAOhDQHt7e19f3+Dg
+YGdn56ZNm3w+H59lYw5JZWWl3+83d5Vml48tvOrr60skEuaxw3KMcDgcwWCwrKzM4/HwwdGyZ+bf
+xOPxvr4+Vq5ixhqXyxUKhUKhkMvl4ntFWtYns5/JZGKxWCQSSSaTbIdJm4OZs+fz+UpLS/1+v8Ph
+MB/GP/PSqarKnOFMJsOuztDQUE9PTyqVKlKh7VLyDFChiTC/PJPJsJutu7s7mUyC7rLzGJr9bAo/
+RlXVQCBQV1fX0NCwZs2alpaWwcFBKOSqGiwzr9ThcNTV1TU1NQWDwY0bN37xxReKoohR+OLdREpp
+aWlpXV1dTU1NMplsa2tjcqhIv1w0nslkGhoaZs2aJcvyxo0bN27cmMlk7PNguG/ZB+Z/h8Phqqqq
+CRMmRKPRTZs2JZPJYmrJEo/HM3PmzIqKinQ6vWXLlt7eXpu1jmaosMLB7/dXVVXV1tYy3Z5IJHhP
+VMwV5H2iqqqhUKi2tra0tLSlpWX9+vV8Y1kwLaLjX4pZAuFal5WV1dXVhcPhdevWrV69mrWQgpnh
+n3lMmFIaDAYDgYDf7+/s7NywYQNr8OZT7CuK0dDQ0NjYSCldu3Zta2ur2MWbRx2DHf6BNcVQKDR3
+7txgMNjZ2blu3bpUKiXLMg832VgTp1oYPp8vEAhUVVX19fWtW7cunU6zurIZq8RciVJ2woQJDQ0N
+oVCotbWV5Qr0ToPmeVRSbAP8xtc0LRQKhcPh6urqaDQq9gw2t5s5k+zXurq63Xff3eVyrV27ds2a
+NWwugE2aUiG4LdoUE6LCrEpVVdXkyZP5tLH9vAaCIBzUYJZsi/xz+VRZWSl25mxEczqdXq83Fovx
+jlfTtFgs1tLS0tHRwVwUptD6+vra2tr6+/ubm5udTqfb7eY9HhuDVFUNh8OWw434JaVUUZTBwcFN
+mzb19fUVuQpRluXq6urGxsZQKAS5Q7xlkVnQb9OmTQMDA5YLqURYJ+/z+Wpra+vq6rj4tD8lnU53
+d3dv2bJlcHAwn0IT7bOp8Pr6+srKSkMYzVwWluFMJtPW1tbS0sL1czKZ5H/apMjY1eQZoELjiBPP
+hJBMJhONRqPRKHdoCk5pG0in08FgMJPJBINBWZZ7enp6enqY52Sefc+XGT5XEQgEWGQ/lUr19PRk
+Mhm2vJCOJGzFpkkURWHag1La39/f2dlpcNogj04wkEwmA4GA1+uVZTkSibS3t/OVcqyvLCY/PDkm
+ogKBACGku7tb7GHzVY5lVimlHo+nqanJ7XZrmtbd3d3Z2el0Og0OtOh/G3Qje26Ync5qye/3ZzKZ
+rq6ueDwuy3KRLUHU2KzaJUkKBoOU0p6enkQiITY5EDz4fGXkcSRCCBuH4vF4e3s7IURUaPZyiGfe
+4XCwVQ0OhyMQCKiqymNf+RCrmvfRvF2VlpZ6PB5FUWKxWHd3Nwtd2leO+Cezw5bqsZlO3kSHhoYK
+xs1Aj06zoYVVSCaTCYVCTNM6nc7u7u5IJOLz+RwOh6IofA1MvpuR3xeqqno8Hha3DIVCiqJ0dHSk
+Uik2qHOpZs4hL5c4k8KfkfB6vaqq9vf39/T0sCPZTzaPvBoMaprGHhvzer2Dg4MdHR3sAL4222bI
+5x/43er1epna5wtveBUhyC4OarBxAlNoNTU1kyZN4j2V2I+xNS/pdJp9z8TY6tWr169fz+fcKaVD
+Q0Pt7e3xeFxV1cHBQTays45RkqTKykqv1ytOyFLT6iRRoXV1da1ataq1tZXPU9vjdrsnT57sdrv5
+Aj+zGyaiqmpra+tnn33W0dHB11zkM84cqmAwOH36dIfDEQqFbGJonGQyuXnz5lWrVnV2dhYsBfM6
+wuEwG3A9Hg9YuYv8GybAksnkhg0bVq5cOTg4yDwZRVHa2trYmhT7FHdBeQao0MzwuWfmLBreJFj8
+pDK/mfk9z+d7DHe4WRoZXGGqb2HCFqFxX5DknyYX88C/5B0WV0REeJDM8g4xO3k8z0R4UxzNDdAb
+NlnhqRuKzI9nq0lZltizf6KzS23XkomF5bniq8+ZLrJUjLxiRR+UpcXUCwCwXIHgGXMKtgReJ/yZ
+MU3TZFlmg4rN00eWdc58bpYrFullPbtZGOS7ZOwDa4RMn4gXXVGUTCajqmox6ppfSlZ74j2iqipf
+yF7QAi++2KiI/ug2y4z47CUR1kuYbbLKofq8KfuXVTszyNs/O5ibyjd08XgUs8BMMVnLbfKWbHii
+TCypZYZ5Q+XNld9BlnbMlQ96rF4MLbLb2bKexW/Etif2DAWjlAiys7LrPBK2o+NyudhCEq7QxEfr
+2dzl8OuPKR0YGGhra1u3bh1ffk8pTafTTMil0+lIJCIuSpIkaWhoaPr06eXl5bynzafQAIBNtLW0
+tLBlGsUUwePxuFyuxsZGt9ttGA3NBzMl09vb29zcvHnzZiaf7PtnSZLKysqCwWBtbS0R5lJtTkkk
+Et3d3c3NzS0tLQVLwdykSCRSWVlZVlaWb0LWUFfxeLyrq2vDhg29vb2avpdjJBLhq0PzsWvKM0CF
+xhEdfe5Gs9tSnNIuXqFBrsslOo78bjHf8Ab73I1jE9tEeITGoJEsy2JGnFznwozqIRrLe9igjsQS
+ic4lixTxujKrUIMQMiQhepxce3BTNiUiubE40cUkenApXyhAVBfi96K3LRrnZ+XLjCVc1IG+2ptF
+KvLpKMtWwf1vnm0xG+ZmY/Mnh7UrnhyTo8UoNEO5mDRidmRZdrlcLJ/F3yzMCLteDN7sxUyKxbHU
+QlzgMWvsRmZtj31m7Z8Q4nQ6tdw9acxJgN6wibCZJzPFhJCiKMw+CI1NRGxCBvscELQuyzMvTsF6
+E/sBYppBMFeR4V421B61nTxCkB0d1GA7AayTZAvFXS6X6GCwPtnpdKZSKba0gfVgbFlHS0sLe4af
+wabYNE0bGhrq6+sT+zo24kSj0UQioQnbG5qHbPaNqqrRaLSzs7OlpaXIR6q8Xm84HI5Go2xZjWjc
+st9WVXVgYKC9vb25ubkYEchEZl1dXSwWc7lclqMb5HodiUSiv7+/ra1t8+bNrPbsYRPZbJGL/ZH8
+GrFH6VpbW/nSLeYR2VfaLivPABWaJdxBNzy/NFJ/heaiCTv4GdzxfKeLzihXL9yZE9UaPwVynXvR
+oCh4ePzE4JFb5odngAhr5Lg1MUBhX0VmO2DyYnlvZaNALM3yInM5xJxpS1feXCfir2J3z5UVyX0c
+MV+WLCUu1x4gCImCLUG8jlruJhlcihgin2IvL1oWq5cQ4na7VVVlcSQehLGsT3tYuZjmZJk0D2MF
+rRnqlocKDQ2AX1bIf9XE4w3tipddvKn594bc8vZDct+ZQfTpCXGZvlRombH5ooh9gjhrY74vLKvL
+bFycapFl2WZLMfPwzCtWy92EE+UZsiOCyxF3YnjPL8uy2+0WFRrrPPmDJOLxmqaxvUNELWGYzBK7
+O4fDkUgkmK/Fl2ZQYToPcn0tdlgqlWKbQxZTEEppKpViS0XM02HmMZQlkUwmh4aGilRofr+frWcR
+NwAzu4scto4mmUzG4/FiSiFJEotVMl/CcrzggwvR196zjR6GhoZ46vkWcDF2ZXkGqNAsMbRgw/1T
+pONi8zCJ5XxJPplEcmEhBb7NuuXUjn0+ufgxxGFGBDPOujDu+/IVVqJ/bMiGWKXiN/wUnj1zt1Vk
+xsw7JRh6pWJsEj1mZXDo8x1vuMqGq0lMr8UUj7Esqbm/5h0ZP57FhcyL4izrHKziJJrwmk77AhoM
+8otF9IWp/KrZ9LY2BnkUSJzIMFy1Yq6dKK74+MeFKItFi8OGjRF+x4nTqDyHPKZdUMzQPJMXouYU
+0x3RtRDvNbDqbYpha85FkO0MarBdHHFSL5/KYojjCFMgRdoXhZl5XYnlNBmllL9Xzd4+Ed5JQ0xL
+eGx6fk14dZt9EuxZa96xFz+yszBAkUkU3LNEhNcSjzRAoRVSu7g8A1RoHJI7e20zn2HT3C3nvyWr
+jQQtjdgILVGh2YRx7D11sVMwuOk2Uk30/yDXaTaUyGy8mH7B3L0WdHltMCRtMztl37OIk3CGGhBP
+J8KMmn2exSgH9/XN+TEoEw7fGMZcUaJ0IVaxJsOl4RqDKStDpVkW1hKeFjcijmTFX0TxMCqEucyD
+ro1BIqzxAyH+ZiiR+QYRq86QEBVCl+aaES9cPg0GtjUplpGHH21WmZqbinjv8AyM6J0QlvYR5MsF
+NRhiJt9EEu+ZzWMQjMqdsOyBDQOEYcy1P9ds3zw9ly8tyB3F7E80ZMMw6pnNWma4+CTshypeRYYL
+J55YpMDbNeUZoEITEe9kg3MGRbQkw12a7w4x+PT2nj13/gwN2ux0mo1YZthwbxis5buTDfCKEjsO
+TdiAxOZc0T53pg23sdmZLmhTPMW8cqxgfsCqtzI8pGdwnQ0pgtVskKiLGOLCOUPexHHFbMeynRhU
+n9iJ8+T4hjdcTYk1nK9+DGLAUEVikzNfLEPmi7l2Zu1RZFMEoboMeTAIJ/ZBXLIIedo8v+MM1S7+
+SYUnHolpUY25gIZqEa+1eBMRqyWX+UotlsJQb8Qqum62Zj9yI8i2Ax8JQ0YBzcXwk+hfGb7cmj5N
+7K7Ff4tUF/lsFtnVbz0jMj7SQhVTt+I4NYpK22XlGaBCY1Cr0AT/qaCjI9qB3Ns4X0LmZmr+0t4/
+E4XWiO5Ag0e7lT1X8aqMp87PFb/km3aQ3ChQ8WYtF9dZuqoFYTJGlI7UFCSxbBXimk++6o/F9KGQ
+O26ZCugVJcY5ReXJJAdbuWdY0kmFPTwYhsWxVFiRaL6I+cYPw2fxeo26LYkCg5oYkSledrNxEMSS
+fYYt1ZRZaImX0magMrR5Qw7F627wAPJlKV/fkq+d21+XbeocILssqMGQ7QCxWjbCMPfYxZPPpqXz
+NuokDPbN46xhwBoFhtHE8IHbNzi9IzIOeQYRYopAiEUuMpVdWZ4BKrR82Phbxbj7+e4HbsFk0HiM
++WDDr8U3cfEU8ba0LKN4PxdjX3QuRyqELHNo+GD+yZC6pRF7j7lgHngl8OfZWELiU8jik1fsRCaW
++NJB0GUP3zVe0zeRZ6bML7+2rECu0NhLIZnYYxvu89xS/TlAvliOrYpk73pmZxlaIJeRlkLIrGFs
+BINYdSOqakvECzdWBg2fi7x3DGOYpU0ChEJh7WRMkRSYeizoE9icZbh5i6nDUXQmCAK4HBH5MrBX
+LObebNQKqhgvwjCFV7xxEEZ8m3PNP420u+ZOQsHDirdpMD7SU4o8cheXZ4AKzYat8Q5H1iMQAKAA
+lH0S/2V3MQCTcOwYlsCoc0jYPWWVya0KgPDPW19vo+4pDHEJ/r19cpbH8GgY76Yt9wAUH6hluoi9
+5pLvAeX1en0+nyRJgUDA7/c7nc5wOLzPPvvU1dUFAgGeDW7QXIFiVx6LxTZu3EgIYe8Kr66unjx5
+ciaTicViiURCfB8De9iXvdELAJick2WZyTy+PJIh/lmwK7cZkLZyns8mrWIOzodYpUWOVVbJEeHe
+IRY3i6kyACgFwlo0pQSAUFABAAi7oMwoJUAJYX8SACl7m1MhBZpjPSf/lGWF54cSQsVqK+aGMkj3
+ghWC7FKgBkPGGyMaAsa8T7OZuRtDtn6+22ANCtXbti5RwQxsU3ZEeQao0OwxO3Nj38KY9CI5LhcI
+HhmlYqIW3uFIskQoHX4Ix/ib6Tt+2JfrtxVfwHxHjuKqkVyo/tYOFkbjfTQhxOVy+Xw+t9vtcDh8
+Pl84HA6FQvy9W6WlpeFw2O12y7JcXV0dCAT22WcfSml5ebnb7S4yVMJ1VCqV6u7uzmQyVVVVHo9n
+JeHKqAAAIABJREFU4cKFM2fOzGQyvb29XV1d/PVcsViso6MjFovx/XMBgD2QxkJwPC4nPg5nv+lt
+Pgxd/9g2FfuJ0jFMKF8SlObMm+g6CsQblABld49VhiiABBQAJAra8HdAdAkH+h1NAahugYDJGjFr
+QN2Y2FeMpFzWoEjb1UANhuw0WHZf9jG3bZfuiMi3/qKYw2woJnS2ffp8cYnHdmYHlWeACq147Fde
+jSj4k+OXg+7jAQGS428xw/pRo9EYphxSweY2p2DwqmB8vxhTY4U4gcT3BeE5lCTJ6XQ6nU62OlGW
+ZZ/PFwqFWIisoqKivLzc4XB4PJ7KyspgMMgeDFNV1ev1hkIhFlVzOp2SJPl8PofDwWJZ9ivoxPww
+feX3+8vKylh+NE3zer0AoGlaIpGIRCKUUva+40gk0tHRkUwmKaU9PT1dXV3pdDqRSHR3d8fjcdA7
+ZR4nhDxjWPHVzsNxo6v8Itl6rT6KFPVC8X9z7lGS873hPs1Rd7mzLMP3tdX9zg8c/mRbs4azUGIh
+OeAjYcjOhLiyznKKsHjXwmz5S5mi4upFXDKz9fKMIXoyBgtiKttn0nNbJ2Fmx5VngApNpJjFXcVM
+PxfTCoeP1NitQyghlBJKKAW2NopKOXPqEgB7ukkD0NijL4TN3RuWXOdP0/S/iMaCdXrXULAEhRld
+/zg6UwUD9DbhKbNSYmKDvYeRPVpWVVW1++67AwCLhsmyXFZWVlNTU1JS4nK5/H6/1+tlpkKhEJNn
+oC+V5PbNm8gLFW7dS4pSStxJhW0cwp55o5S6XC4WuCOEqKpaWVlZX1/PzhoaGhoYGFBVdWhoqK2t
+rb+/n+1cwl6vCQA+n89cSzxXYsAwX2UWU7djgv3oa5PDYmzankLZfWd577BFiEQCmp1rodkvzRMr
+2UNFwUaASDwup8fZCBCSGxJjB2gGg5SI+pAfSQxfikUTS2pzgYyzBuYjkC+dzwkA0JUAADAbYNso
+MdRgyLjCfub3S1xHN1K2w5wmT6hgtaA8G5+gQjPCbxtLuVWkBuNOpME3AqvHSICS7AMp+oQ75R4h
+JUAlqgFQ/igL1UADQkk28gbULMrYykmrwumPqQw/g8R/0m9kca4/p9QFiyyqkWImsWwmbwxxJPsK
+Fwti7vXYN+Y5Np5DcaUfC08x8eNwOEpLS71ebyAQmDp1allZmdvt9vl8bCWh3+8PBoMsLMZ0EVsi
+6HK5mLpjRoi+gyJ/aRjbw4O/ZrqgPOM1YFCSRHg0jhtnj5PJsuzxeFg2SkpK6urqKKWZTGa33XZL
+JpOapiWTyXQ6HY1Go9FoRUWF2+0OBoPBYJDqb3bm1Wh+UZ45xGd+ZbbhgGIag8FsMYLQ8hTDhTZ8
+Nh/Gv7dtY1lhxm4f/tgYYWsbKXufta6qzGZ0yUb0tZKEatmn0QgBIlFC2JYjVtMt2U6BUDZ3o+cX
+2H+QndPRpR2lRM8MW9I83Pgt9ZhlwQvOdyDbj8+3uVuDGgzZgcguP2BD9pivGCjY6WVXpo/lXUkI
+73KBly9fuUbXK9Pcp2VAqLatrD9LnWnhlH4ZA8qOLs8AFZoZ0ZvkjvXWty3RT8r5mjuLNLvBmwYq
+BQ2IBpqWlWsUNOaIEQACGlX5kysgePDAbgxhbznhlmTdigZE08/TxJtUPJEaZvmt6gd0/cDFA9H3
+l7epAdECNeRcwHy8jQMtKmqzPjSYFcNZYh7YT7IsMz3m9XqDwWA4HK6urm5qagoEAsFgsKqqiu20
+wUJkrLziBhtML1H91XBi/om+a6IoZgoqT0OFiwYNVc2LQ/T9J9m6Sh58o5SyXUzY6YqisGfSEomE
+JEmZTGbmzJmaprW1tUWj0aGhoaGhoWQymUql2IniZeL7W/LCsjCjoXkXefnE65jvgpo1VTEGueom
++lN2hstNc3WvjR02uhGSnSUhxEFAIiABlShQAhK/E4EMl4RNuRAClOhzMewvVqLsmOkAIvF0mNhj
+8TjImgM+WhOeBFCgVBteYKmxORc20UP1IZ4pdlHYiyUV25WlBrZUdMjYgxoMQUaNMGFm9SMBQkbb
+hW3/mM+X1NnyKiJkbMWnge05muwE8gxQoZkhubv2ie+l5QcUbwqEGA53mIa/B2AT85SCRthqJ0qA
+SkCBahJQIIQyt425huxZNaqpmuoAB/NCDbs75J/iYRnRKFUJASKxkB1lagKIlv2SUt0VpKyH4qYM
+Egus7jeDS5cveCK6jFR/jbKmIx5jqU/yVbjhYrENFUW/HATnXnzFNlupGA6HGxoaamtrg8FgKBSq
+qqoKhUIej4ctJvR4PJAbKhRrXrysXCblq4Ti+ylR3lgW3KBVxHYL+usBzMmxUouhtt133726urqn
+pycSiQwMDHR3d7e2trKH2diqSC5HuepjspD9yavaUA8FSwdCMyB6PJC/HLyYi25pzTxlwNas0tyg
+X76K5S1Ev9oOQiQmzwAkQhwAEiEyAaJpKgWQJHFhIWVTHvqs5XDfQag+tcKC2EA1SjWNahqVACRC
+qMbFHRhv4qzFrHmqD+ZUAiJJFCiTbKxJEn1WtsjOitc85DZXlGdjwzbSYLOE2SgAQCWG7BIw74QK
+U9E5P7FvKOXfZ70Zy8BOIcjwZBkVktMT5/2+/qxx0Xc64WpIowAUNL3D12fihSN5wbL/FlEOIvw7
+/Fe2WoR64R/0hVXF5t8InxcUvuK+KPN0t6P+3DnkGaBCM8NnlJkXyx/+4a8DBisdYumPGuIJ3LMX
+/EIKABowf0ujIBGgJPvEi0YIBSoRIhEiAUgEJBZOA0KpplEi2ceszJ1F1mdlqygppRp79gw0SiEn
+/9S+o+HlYpXD3w/GfXSxWixryVxjXJvlO70gOdI3N1rCy071J7jYW57Z5h+lpaUNDQ0TJ06sqamp
+qakpLy93uVzsYTOiv39MdOXFuIQhdVEegJWDW7y8F08pph7MVZ1PI/F6FkMlPp/P7/c3NDRkMplE
+IhGLxdrb27ds2dLR0dHR0dHb25vJZCKRCKs6rsqYzGPyjMXlRlFAyKORqB6NFKWgzSnm77kFw2fz
+kQZrvOXocaThZY0EJE0lAESSZK6phJZG2YLDHCWlUT4zSYQxPTsrQSkQIhFJAk1j88FUH/EB+LOo
+bAN+okvA7AGsc5KAbdnP+gpCJEJA1RQAcDikUahcsR54Y0bs2HZxsFkokhEkBzosWPTFCbkrxPVO
+L/s1mw4b3jS3mCSGn/jgy88Jya4rz34pLFfKisCRkn3qBLJbEPCOne0PPGycENOyx8IlyfXnRJ3H
+CySUV/h/hEUQuz6rs+n2Hj52GnkGqNA4ouvGfFA+425WZQaPWQ+GGb/UdA1ECOH/QlY/6Hdj1v2T
++MSQxGQYaBK7UyW2Fz9lsxyqqgEFiUhUIzR7M0sAPMiWXQvJTBuKSLIPq2RXVemutuSQQE/CDlE7
+ca3CBA//1RxyNFgwfE+Ed3Ox4AnRAzLiwjmD2w1W7qaokURfnKsyZtnhcASDQa/XW1ZWVlFRUVlZ
+OWHChMbGxnA4zIQZO4yvG+QBVVF9meUZ/yyunyxGReT7ZmswpG6p8div7KVtoNceq3NJkkKhUGVl
+5YwZMwYHBzs7O7ds2dLd3b1u3bpYLBaPx+PxOHsRHKsu9oFtI2kZ++I5yRcX5R8MIopnnrccy/oX
+C85aEXuajgf9xNbFjuSbbfK1qZZ2cicOCKWgAQVCiSRRVdMoBUkiBFRVAdAcksRHb95kKdUANA1A
+4lOsJLuikQCw4By7kwilBCQglL0SA3K2dmVzKxQIaERf7ggEqAQa0VQKTmaVLX9UJYlkp3RHgmFq
+A8a6We7YoAZDkHFEEXfNcK8+mluM6nvtmu58XUMJ023ZoFj21+KS00NmlHuD9tkZKbqMLaLnyun2
+R5bI8HqOccHOJM8AFZoINcG9WLZvBPf2zBESSimfymH/E2lYMEDO4t6c6Lz+YH+2H5Bodjs4StjT
+YBoQCQiloKqaCgQkIjmITCVVZaE3ScpOuOsLqLKvyGV6TUwVmCMIVCVAs9vHsXIwb850k2VfrJvP
+Y6b6Mj9KKY+fmAWYoboMTjmvZyZszHEYs8ywlse5psTIp6IoLpeL6K+TLi8vb2pqYuEytjN+MBj0
++XzcPi+FOYAgZsZYW6bvi/duRYWQT9kW7D0NxxiaqNksqy4xDEv1FYxOpxMA2MJOn89XU1MzZcqU
+wcHBqVOndnd3d3V1bdmypaurKxaL8QZgTlFMtPjMG+8p3SYX2IY8G9ISBR47jK/zpMLSR3Mq5ori
++eHaDIBS0CioRNKIpFJNpZRS0AghRFYpaBrJ3ooUAEACKgMBImlAVJY1iRIAiVJmj6qgUpqhkKaQ
+ppRQKhMiUUIpzbClLwRkAIlQKXtf0+xuQfp4LhEqgQqaommUqpqqUUUmkqpR0IjDwZSfKoTEiVBE
+XT9aSTLeNgwCe+dnWy5HRBBkLOHKJs+vwlEjUxGGBZTZrbOzYSfeRQy7TOKXwr+5+cibFMthdtcT
+XfPxpRMA2Xl8FryzsGanCGn2gKybORxWI6b3vNhH0UQtmjchvjuC8KWeOzaOZo2R3CoaM3YyeQao
+0AzwWWS2aiuTyXBhlu948c+s6CFACFGU7Dw+e9IrnU4nkklCCFAtuwcbYfck1YCqRAIqOyjRKJVA
+0UChRNMkAKCapgGBpJJKawqllKpaOpXSFJVSogEhmkNYJ808L/2mBMjRXcxN1SiloCqqklEoBU1T
+U6mEplGJPYTGby8q6ZP+lLtxortGCFFVlbtumqal02lee2LEQ6xVc9VxX1DR64tFNliIxqaqDYjR
+MxbMAeFJM5/PV15ezlRZXV1dQ0NDaWmp3+93uVygr9VkF1p05bkRsSA23uqIMmxvxJCKvSnLX83y
+ksOlDv8ThMvBBAwLLgEA25GytLQ0FApVVFQkEomBgYHW1tbW1tb29va2tra+vr5UKpVOp1OpFLuC
+mUyGXc3hGQohaRtxy6V+MplkDUBRlHQ6nclk+F0JVttL8vKyXU942Zk45xu3sJd3s8+KotgLD7El
+qCqLxakSAQKaqqXTmbiqaJLkUDSVZlTJQQihAOrwohvqyI6CRAVQKNWIRiUqUXBQQhRF0zSVaqqi
+phU1mVGTDk3WKKGqRokKRCXssQS2/oXdhpoKoFAALTt7y2JmDj3UTylVNU1RVUlVNRVAUVmWeMfF
+tR27BIQQ0PcXyV59dtXsG/kOD2owBNmRIWzGm+oz0Fn/P696GJZPxd+jRD+cLTfUFzjpGor/z3NE
+dX9ppIXJUV08GGd1KD9Qd/CKDtQZ4n2m6qCsWASGh5cRlSHPOkY6LM6yQwwLBbB9yce+w9z55Bmg
+QjPDHBSv11tSUiLLMg/IWLrOBsS7JqMoIRackYjT5fIHAsl0WnY4JCm7CzbRewEVqEocFBwOSmRK
+iKZqRNGIqhIA4lBVICB7An7Z5ZSdLn8gFAgENUVxO10AoGlCQxfD2cMKjR8gaRQIkNLSUrfL43DI
+fr8/GArGhqKEEIk4+P2vRwAkAhLrC81+tqZpLpertLTU5XJJklRSUlJSUsKccstAk43wYBLI6/Wy
+90F7PB72ai9x1Zz4wdIsFQKegUDA7/c7HA63211eXh4MBpuamiZOnMieNGMRM7bVIZMf3A77bEhr
++4QRLCNghmKOwma+7w3J8VWdYNougu8Iwu4Fj8dTUlJSWVk5bdq0np6edevWbdiwobOzs7+/3+fz
+sYMDgUBJSQmXQGIwyqzQiB6MZcEuJhKCwSB775zL5QoEAkR/2s0Q7zJXEbusVN9/UlGUQCDg8XjY
+G8bZ+xJYQNVsxBBJY22eLYZMpdIejycYDLicskOS/B5vabBEyaiy7FI1oqia7CCSBJSqfEssAIlQ
+BwUKRAGisglQB5UkkDSAQCDkcfllh+zxOIMhr6L6iSoT6gbNAUQDogDRCBCgDgKsTVJCVEo1CkBZ
+1BwIACFUCoT8Lo9Tlh3BULCsvBSog1Ig2f0hqe4ADPsTlFL2+BoLmrIqZfdgMBhkcxaGy7SDCTbU
+YAiy80J0WUMo23sJIDsVTYaVApdURHfKBHVjgzAGZ1c6AE8s+zP7RLJvSsrOyHHhY07ARksR3WXL
+iSkJIlAIahGq/29UgtT4hblMrGKoEOATcquHCcnw+zxHqGWB+7N69fBBXx89iF6jhNegbmBU3o2R
+nVKeASo0A8xZdDqdkydPbmxs5HP2PMAChfwVmg2QU1XV3F7PpEmTfIFAbUP9gsX7RWJRSSKyU2aC
+T2+nRAGiEkKpREByUAKaqoGqEranvoNqlGikorS8srY25PXPnj2vLFAOiupxO1kQTMgNuzf4DUF4
+6BrYV5RIDtnldk9saCotKWuc2JhKJSLRAVl2OSSnqmlAKZHYdIvERBpbacnn2kFQC6qqVlVVlZeX
+U0rnzp1bXV3NH/fKpmda5Gb56gLuHdbX14dCoaampiVLlmQyGcMCPNGmOTjDY3HMO29sbCwpKZk4
+cSIAuN3uSZMmVVRUMGedSwVN03p7e9lbm80K3EYv7WQYqpF752KFUEorKir4S7HZXpfhcLiqqmrK
+lCltbW09PT0sSgkAe+65Z319PTUtk+NRKcs8cP3GxP+kSZPC4fCMGTM8Hk8mkyH6xiTmDWlE+HXk
+LU2W5UmTJvn9/sbGxgMPPFBRFHGbzYLxIofDoapqJqO43e7KyorKyrDH7Zk+dYbPFdRUkCQn1ZyU
+EkkCtle+YEsi7I1lRAWJ7R1CCSWggapSl9czaeLUkpKypskNirRXMhknIIPmItRJJKD/z9679ViS
+XWdi31o7ziVP3iqrsq5d3VWtrupWk2ySoiVSokiKtCBBwHgkPQmCAf8BQR7pycaIEmyMJMMDP8pP
+824YBgRCM7bHEqAHEiBEDS2Jbg4vYpPN7mZ3170qMysrL+ec2Gv5Ye29Y0ecS57KrupqdsViM+uc
+OBE7duyIHXt961sXjEElACgTXFhiSTQWQIM5rAggbvPk6ZOn1grnPvGJj507dxbqAFcUHUQXR1Uf
+XgdhcCjSaJpzaKq6vr5+/vx5A8ON2ffBmgBtSFgrrTytYrp+FdYbN0546VR/LW/i8YLRtMItqd24
+fBgyI4QqLDNamHEVCS7xxD4TIKzZzlGgrNpNI+6qeMH4GZn5PtXkfSh2qwkv63chh4UUz6aVX+ej
+kw8rPEOL0BqSspA/88wzZ8+e7fV6kwrrpEpXgxwxIbZXUWD1xFpvefncpYtLZ9cPR0Ov0ukWrnBE
+YBUCBFwSCZEQkbJTUhWBeIIQA0RKzlNHixU36JbFlcufvHLh405RmFNirmImmwvidMwmpQIEYiaP
+crDS6/TJnefVteWyHLmiw9xXEYXnWD4X6qAOIJDXzNExcQvmCLe2tqaqL7/88osvvhh6Ueed5vM/
+qVlmXl5eXlpaevbZZzc2NqYSGjn2y7ckF7jEvFkA1YkTJ55//vler9fv91M+wET0HRwc/M3f/M23
+vvUtTJRHa4QqLXgt868xNTJ/HGYBmGOcd04Lk0RW3odGSKE5jn7pS1/61V/91V6vl0Z+aWnJpsmV
+K1cODg6smpxhueTxaI0kdT+vcIAMs2nM5mI0pojYHVxbW7tw4UKKdsvx+fzLTP333g8Gg8Fg8Mwz
+zySEaftM3uVJMf9bBQrnukUxWBowFT97ZeXKs6+QFFAn6mzxJwZbzcKwGrItdkqaIjohgKiIikN3
+1RXd8cXnzp98poAbOy7Ed1QKYoDNoVGCszEpIETmTCJhcVOCEGvR7wxWe8vk+aMf/dkrV64ydwiF
+c4Wq3UdRtWQwuWuoRWlqo7gFEZnjQAOhPQFpMVgrrbQyIUaKhXeqqSrVT0GMutH8EKXGzguIBiYo
+OIqHMibVjxUqSX9rPF0oZzT/ajSWWMrOG/MWRFgVm6Gal1St4exim2fIOLSwoaK96rAzJTOYQ/o1
+vmcdojgQGlXgpkdlLNYZ+jMLZT7sq//xwbO85SclLUKrJOl/ZVneuXNnf3+fYtqJWSkKckUT1WQl
+JXgVdNyF557d7Lntcv/6/r390WEJ0RHIBedgVlWQJ/ZEVg/NCQAVgmcICgI54W7Z6Yw6bu++2+t2
+hv2u9rvqHHh+fYmqQ7DJDYWKHvaW/Ob5oud1a2fr5q139w/2QQ7UE/HAmFnIODRDaKQCmYoszBvN
+qoTdvHnz/v37DV6r1pnZqrAp08vLy8bAbG1tvfvuuyn0KMcSGgURS2vM3WLukSdOnDh58mTyvUzA
+zNCCtZZcGYfD4de//vWvfOUrKWlnK5Ni47+8vLy2tvaFL3yh1+ulkdfoWLiysrKyspLujtFcOzs7
+29vbBwcHKZgzTRb7iojcUvr+BKs6nc7p06fLstze3r579+5oNEIGy9N8bHQ1f2BSRkdmPn/+fL/f
+39nZefvtt62wG2VVBKfe+vQqsEZKKTtFsba8fv7MxUF/fW8b9++NZKSsJApiQL3CI2XgMQOHFApW
+M7OoAmQ5Uz10zCPpPKCVHVq9I/27KPbgFL4QLZSJuFSMFRraIwLEltoYLG5GnY5Df+DXuh2iUefa
+9Xfu3bvvuEco1FwhFcQK+AmjLFlG/pjtP+DklZWVoijW1tbMtxOYZ1N47/Irm18Mt+A7AB4dKmsx
+WCutfMgksjMaUAHpPE0+1/9rQKoOpY4+J2VW7vgh/VejkJpv2KwT2mw1fAgV0ZTJQJnmh07pTJSF
+32/V27uWkTJ+zofClpeplzLvBHlvZGJwGxhMcRw3yvny4YZnaBFakqSTOefKsnzjjTfu3LlzeHhI
+WfK3WfpKtd20VlUhDKXsrgx+6Vc+//GNlbe2bvzT6//5weigZC1J4KJVRxUgBXuGmluhqKljnkjI
+kXDHu96o191fcjtLxc5yZ3+lO17p+B5bkdusF2gQ4dULigAoqWA49ltrp/wnfv7ZM8/03nzjrf/3
+H79x+85tRQfUUQhRSVSa5Z8ChwYlyZKHVzBpNBo9//zzJ0+edM79wz/8w+uvv55n9muMzxwIZDr3
++fPnP/OZz/R6vTfeeONrX/va3t5eUt8RUVxqxDRv09QBWIbG5557zhBjv9+nmFjfApNSxbY8yMoY
+G2N75j8brfT7/U6nY/xkXoqg8RdxVIlof3/fKqpdv359NBoZNLI9DQAYVCOi8XhsNF2AQ2W5trb2
+6U9/+vLlyz/60Y++/e1v7+7uov4UzTEEpNnqnBuPx/1+/5d+6ZdOnDjx+uuv/+3f/u1wOLQTaZYN
+xWTSFoDAs8nYj3vd3uXnXvjMp3qb673Xv3/z9e/f8sNBByviuyCGesAb9UyISE07oEBJKwQhslM9
+jUbuftm7W5y43d28yes3pbcldCjK0IIKpzRWWKYcVjCIQN7mcFjmlOEd+a7T/snVs/0XOvKg95++
++Y3XfvDjTrFE1FHPIiCiSYSWWEZOmYFUbQpcuHDhc5/73OnTp5eWlvJhOTZOSxjsEUuLwVpp5WmT
+Sv2PKCLQaRP6BqAVpVO5dhsoQkbyzBQN6hkhhE4BACmBoAJYEihrkJEM4BMugo0q19n2gP4s3wnn
+zk6oMWqKzDtTU52VRYRip+OHvMkqx0p+xBxsVgG5+ofYr+wCwy0y99D8HJTGSDUbj9ry8jCv9g89
+PEOL0CbFlPv79+9fu3Yt4QSK6eBnSYBwyczDdODHndWlF3d39v14a7h37cG9ndGD0umYvDqA7RUA
+AgMkBEBIxamaV7Mn8ihYi+64GAwH/b21zhbc3W5nVzqH6PjCSQfgzJvZ4lyyeVKf58qikJFiXI4P
+98SP9cH93WvvXLt+8ya4C+ooCdOIqAz+A+rIKD2SxrQ1u/v+/n632zX3tps3b77xxhsNmnFSsZvq
+IJrc3vb29ow2+clPfmIEpu3DsdI0YjIPy/hn2fM3NzfPnj37/PPPX7169eLFi5avIvnXJSSAqGvm
+Hpgte7a4UKzerjEpfw6Z8vvunDt16lS3211dXV1ZWSnL8t13393a2trf37e7lt8gEwNLFvTlvd/Y
+2NjZ2Tk8PNzZ2bFj0ykSLJ/zLFmDNpGXl5e3t7et3Pa77757cHBgJzI0mF9do6n0lwiiZbfTW+6t
+Hx6Myj527o5vvTvEqM9CflQQOsRqNpdqJVMCGHCG2ARKpGyfXTnqln5p35Xb/eK242syvlnynqiC
+CnJOMZaA0JxaHBolHx1TGhhlQb5fyBJxeVjuyMHyjRvX3nrrzW5nQOhAi+DWSD566YTVV2MIQEyF
+BiKyYVdVY8Lt2hcBZi0Ga6WVVt5PCcFSRAqSCegwRR7evmTIzxARgwyRZRnqQ2nZBEtCdx72FAjw
+TGuABQpIzWGSKDnLh3ixhzkJOMTLVBg3IbGEqRSAwikYcIsPGdnSSTkfEH+poc7q0h4Vh/Y0wDO0
+CK0hue+W2dqTQj8/iIiIoGDTehjKVJAvHDOpwAuLFDoWGRUydl5YiYNhnVUJlp1DWFVUARVSIfIs
+LEKQsWi3Q+h0yfVBy8Aa6SppL0xyDRWoAdJoO9JoKUJKcOS9UBc0KugBpCue1TNzx3EHXIAKhQ+Q
+j4SISIiUqW60sUEw6iONj4mpzklTzyOCGltQb9CaypPdp9QsyLwZrZ3EhnW73TNnzrz00ksvvPCC
+RUOtra3ZUakMcSqonRI2Joeu1LEWoS0o+aAhPvM5vZw0e0Nf6+vry8vLZ86cuXTp0ttvv/3aa6/9
++Mc/vn379uHhoYGBVGMw+T1qTB1pWT2tCnYjki0/12QPc7FuJEAIwBpMD22exnOyqcSzOccFcafo
+OHZMzMSknQ6vsNtQWQOWmHr2aCokecWQEtBRtamtHNUJAin6pCXRLrs+Oiwd77tDKfaFvCgzFQqv
+8FCocWjWHIUUIQSCMrhgryyMYqzkibXTKbrdjmNHysROrWYicVqSKbuPAAEhkWO62ATC86Hg7zsA
++E74+iv44nGenmnytTtftQ9f/OIXZ92IVlpppZUggVHSCNKSrp84s7o3oL32NN+UI595QhGnk4QF
+AAAgAElEQVSnce4nqZmvZdim8RyKbGt2rtT17BpsNwVpCFaJCM0yyGn4WbMjNF5ozQtxzoUEeKZg
+hQNlY2SOVQ2bJBBMipYlbrrU4XBcVeKY2CWbogBjEKVeKi4mF6aqufoVHEVuBnl/4NnXvvq1J47W
+WoRWkwQGqJ69INdEG95QjQaCgUOFxDuVAupICwYThHxZyLjwQsIEViIiqFB0rFaCpQxRgid4IiJl
+1XHpx847FjARnENH0GV0SYkRky9afyjOktCbNBkIYKKuaMdph1GQEsE57jAXAkdwasQIV9NPwxU1
+Z01ScJOOmw9LQ5XPj2psmWqnn0TFjWJ0zrm1tbUrV6688sorV65cMbrGdPqGljlJjEzixlYWlzSq
+kzdu0uPRnhCj0c6fP3/p0qW33nrrhz/84Xe+853bt2+nKZYDPMNU+cYEz2wCNn6a7APFALPEtTba
+T+XyUprWqdx4Oip5ZhJCtkZAmYhQiBSQLtOAqAsBVGLQtwCerAK15cpnVXhzdAQcK7OuCJYUTqCC
+cUlDXwyVvYJZfZx4UPUgb5ZTIQneJMqAqqDgUr2nAuzIA0QhiT4RmNl7BSk5omQT1WqhByASZsT/
+9W//7+zS/x2uvYdHpC4Jg7XSSiutHF80+0QWsqECEUjEBLN4nxwaPTR5E+FQUoGMT7MgX4naETWg
+hmadmXu+0KWYazG/Aok/2eWCQTwlI+UsRJPpqNHMR7Wf6kunuVao7ZkpjzO7bf9m/a9RiHnj5mMa
+vDVyb5Bjy/sGzx5hy8eWFqE1ZRIY5DBslsU9/IvoaQglURZ1oEKJQ/Y0qIoldKtPIR9tGiQpTVGc
+BwIVUg/1UAZATMQAQ9K7A1XWoGo2xPSLkcEO1RaJxCtEzX9a44/W/6pX6diAz8J0bQxFQ1FOrNQs
+/NPYnsY5lbpKLeTKetqNmTc2Ns6dO3f16tWPfexjly9fXllZsaaS01oOzxINklpugdmxJce3JlMH
+s/FU2Ifl5eXnnntuc3Pz0qVLZ86cefXVV69du3ZwcGDeqp1OJ7FeDaSX5mDuV5mAU+pA6lhOwzb6
+k/KLUL2ywqyLanpyEtkUppBmg7yAhAkO6lQVwvacBmNr8HIMUQoUlkAISJUpFDpjm+y11diuOM7I
+bJUGoEh+zDGMNXQb8QTWV1BwTtYw///Dn/+Hh7rdC0qLwVpppZX3UwKcoPAXgVjSaI0OnzPuxmok
+PyxHHytjB0Kpge7svAGkJRKp9vOcK7C/lIBNBSMzjk4TD0dkbJuBmwriKOr/ToE+VP2ncVACwTXl
+kpG8L4+Q2G0NVsu4KEUdUqPvhkqmolL9vyk9OPIePVXwDC1CmyMUEzkmwHDUEaoI+bUJYBArOSUW
+oDTrBENBAnLkNOQQIAAkQf+KoWPmyhQxFETNR8p4MDbfZW7O0gV6B1BM4AawiopIrNokxCBQcIuq
+pX9tziVTghOy0phQcarKm4/nVC0/35g+JzdFjU6nvV5vc3PzlVdeeemlly5dunTq1CnLZ5DzJOnv
+HCA9B0C2MkdmMZD5gOfb81BAY67W1tZWVlY2NjaeeeaZV1999Qc/+MG9e/eGw2F+FgNFKed+I2dj
+8ldMXco/pCdHY+qLNH+RJfpPz+qR2fYzqwGRuWeIWo14IsdgBZOyKhhMTGkCU1iQWMNqmiwyFCrz
+gEmZwAwGHKmDMEiE4oKvqQf2bzQUx/D1iPtIVcUrEf3P//W/W+Q+PqyUL42ZmWMG1K999auP4yyt
+tNJKK4tIpY4ssIxHiDMfF0yegyLsyItKhyYVopAAzNKbOJ1lsWtQM76bche6KgDEYGcWYUcAWRSz
+EitZ8qiMxpp/ylQhel5NywBGgwqVYNwRIxUWJChTsB+G9T+uUIbPUkSaWThJicAL3oeGPG3wDC1C
+myO5k9UiOr2qJN2MoipGWQaBRPGaWSairJhjJCtZQeDc6KNk/ozOFDtWdhTTEmLySU+MVh2N2LQj
+ZnYgqBoTEBiB0LmA0OwNQtVRiWbLtPBcNc813cXxT06zYAIDpHihXq938uTJCxcuvPjiix/72MfO
+nTu3tLSUHCzz3H35qVNTU93YWpB2PJkDvyd30wmnU0sisrq6eurUqdOnT7/22ms3btzY3t62jJo5
+P9bA7YhgPufN5tzESYK30cn5D0D+QBpCCxcEte6oKOAILkygyurIEZJBwdDc+cOWP44gLWYLk8CU
+qURyLNHoQDIGK+MvLr41rbNfx97/9l5e5L/5r/+lXemzzz77G7/xG1/4whfW1tYwDXW30korrTwJ
+Sa4DSTQDXBGG1YK38kSCuYJSV5nS18AsBdIqZiKhBNIicyWIcETj6znFxS0EAilxT2oeUhRcHdQ8
+JjTj6yiYy4MmGRTImgdWTSbPHHJRmtU/UI51n8QwmObqVeHR+Rkv0zJsN4KDGkuxE2GMcihWacVH
+YNnp530K4RlahDZVGrpdQ89DVBanHao1Q4oCagiIRSBij3Jg5TnZNqJBJTUfoZOogsg4M2dZRTS+
+MCga6qPdIn852JSM/tnmfQl4IhAxcURgxCFjiYLMLGRRLtFLgGL36tc6qbQlL7UjC902cB1lGQJt
+h5Sy31pbXV29ePHiRz/60StXrly8eHFlZSWvZ5Uc2Gr3YMLJbZYnW6t9Li6Ts6DxK7LRbuycatDZ
+jVhaWrp8+fKJEyeee+65H/7wh//8z//8zjvvPHjwAFnp8ETPNs4+lYnN+5B/zim4/Kbnj9+RVxRa
+UAKYg4+xcVlMykQ2nZAS0CC6G4NIK+MqbO4hLrGsYdoTiOEUTtX/xXM/mdWf9yi/9eXfAhBtyqoq
+KRx8kgVtgOFWWmmllScoDUSS11am+u+Nw7J0HVmsVFSZmq3H7ZpZ1yVodVxjqwLU8aYnhfy4D/e+
+jCCNgi1e438IUKfyyKAMAiZ/QY0xcEdCqZTIxIoNJEot9ZnU1rbqNHMwJlXNRiujSkUiZkdqNehq
+qmyOMxfAspU8nfAMLUI7Uub7Qc0Qsx+wgAUkldeSATR7mo0cRoboYtLFkEsW2duFLRGqgu35ZiUy
+zymmYBGJMw1TjB9KTSfs+rsksuqZQwBCdMysV1+mgifdbpZKN8mwJT07PzYFF5mXWqfTOXXq1NWr
+Vz/xiU985CMfOXnyJIDxeHyk4jhLy2w1zvcicybCpP3iyKacc6dPnzZq9OzZs6+++urrr7++s7Nj
+ZBoRdbtdETFnxcmHrXGWyUdxssPHexIinKsmafrFph/C+keWfzmcOVLmleHVvEhAf/Jn/QVP/bDy
+r//33/vO//da1w1IC1FRlApVdoEVBxJsnKabPPRNbKWVVlp5f4Rqn2P0WQyjT7G5NTxm/0yaaBM8
+qzcaVSiq7Oz2Ng8QKF8CiMDmSKEAV/kJ51NDta5pvBI1Q515MoYdKNuV4ipivhwJ2RAlda9+yfUh
+i5HOweSuU+BXBnoRoptztDjRZO0iw54EiVzDhPk+rojGChwjT8hTC8/QIrRcFlRKjvCPiv839yXP
+ZOkZEalwRNwT3wdcnwc2XZXMSzE4SnHCZaYQUh2ExfqJsyTZMuo2pCk7sFqFezRroD0qjS2HZAlK
+5bSY5Y0wmuWTn/zkxz/+8QsXLlgRalXtdDqLFxCfVOtbeayyCETPybFOp3P+/Pm1tbWLFy9+97vf
+/e53v/vWW29tb2+nJyFl4Z96lsnTHe9Gz6bEw+/Zf2HBVpAKMyjEIKgk7hrAl/+se4xuHCl/8Paz
+wUBDDlrA97rl6oW1n/mlF/+F3FuD/sewzgZTKxAmPKflNm5NC/ARM6iVVlpp5YlLgk0abV2wxEiT
+0AuIek74q4nEWXRxoISIGi1mTBSpQiVmJakvUNPanHluVRVRjqqdtc9qZ5DUn3hJ6To0KZuxB9NO
+QVCIklizqTIm6tnqIsyytXZGU412q39U1ZtTxgRCDkZ/NW8UaLzEh5CnGZ6hRWi5PFo9XpEXVaRU
+bV4zlhpA1J9Q9yXUhpHEGoleyJUxJ6XnySSfd7Mkf5nlE9JsU1ZjTeOMRj42j0R7y8OEKGZCt8aN
+Xbl48eKnP/3pK1eubGxsOOfyZI+NWsN5mzha2564nlYWk/d+3xPWsojBsixHo5E5sl65cuXkyZPn
+zp371re+9YMf/MBI1JRNETMY2oe6iVN3DhbWakWfco2ENDOr1Fv/43/32cVPvbj8q7cvgaIJJst8
+rKQePp7dglZTEq3cdJs+6bxlO5Mjw/lSu6200korT0oaPgyIqWvNbBa3NY7JVIJpVFM4NrNmmUeh
+HUqEmDEkR0FK6aVs1cmqbPNTaLSIoBrXEWkxopCasiK9onslCdhcMjJ4hpCXkpDrOVqjD9O1k1Y0
+XaLU7MyKOHaIFjtj5iSi3mnLZXVtmfNFaCFn3ih9Ns4uAr98oI/wpTR5yuEZWoR2pDysXqhVqCVR
+nMtUe47r+8dnOv1A6U98gwSruEZHREqhq7XXE5pPfD4F4tzIvMSqs6eEcSRZRflJU0vesr07pudj
+mONglpwbKSbTywkxZn7xxRdPnz69ubl59uzZwWBQFEWeFTCddGrj+a9T3eEaMjVKrZWpksPpYxye
+H5WDbfvKzJac89y5cy+//PI777yztrZmuRxxFDicQ6hOeu7RhGE0TUmqDLUA8Fd//u+nne3PALzy
+60dd7Wz50z8ZCo3G/Tt++Q1s/nNx7gc4+eNycL3s7YxpCJZQUyOs/aFneY+VwFXIddwIoKo0aiad
+eFk15Cnxp0qTaNyaxpZWWmmllSct1RuJkkdeQwPKlZ0qTX3mWRfNWajtOIHZKi5L47s0f9FqVPKC
+o1MWxJLDswaGqV9D4OhS2oyQGgCiRBGhWZWA4NGkyqocawxEZ0VqnLMh1Fg7JHa9rjaSqqqAbId5
+zlhZuwYKmSms4WGUbIEKFWOCv4mmRTblXpHa+C8gTyc8Q4vQHqnY7M5nJsUoz/i45qYEZDOFMkWx
+AnTpe805WAMOrPacmFOmsybbf2MihMa1Rp5Fwi4WGCG1hI8TSmI6Qqe/G2aRFZMbU1KQxJNYSv3L
+ly/nhcJTRFlCdLPU8Va/fB9kvovpfCGioihyWJ6DtJWVlV6vt7GxcfnyZRE5ODiQKI1kMDkIp3rd
+vLyfky61+bPx7/+n//MYl7CI/Pkfj4RUwaoMJUCAklhMc0hRFCmAG7aMxaU+q5FD+adkvzVnEbIX
+QSXxhcBCogqxFRzQCrlpMqbOM6m00korrXygJL6hQrmRpP8omlo+KSVTNBHlIIYykFZfLapNph4R
+LE5FAG9vXw3hJ/ZiD/uYqmQv72A41/wNW6lnxl5F7iplywgoK9rjlKJFPq1fYlofqScVSz418zKq
+Magqp1Fm84/WuYx9Cyolcn0w9HpCaQwfakA0LLsB6SZAW9Fy6eIBgkpKXpyva3Vpbnhq4RlahJYk
+KfdpYuRay6JKTGKqkHKmZfl37LfZVoOpXJUd1HDfbVBjtQM09QLZ8980nNRaoCwA1eZp/Lny72q8
+0OxtkltoMnKsvmet55M8jHNuMBicOHHCFPQUcpYfAsB7n5e3SttnnejI7a08lDyqYUwPSUrwmG8s
+imJlZWVpaUlEbty40e12+/3+gwcPGo/WHCtADiD/4//y/wAA/g+M8eKn8N986pFcAQD8D//27+Xg
+DJfrjL5TR+osjb7ZPeNKWFvhVBVNWJtmV7ge1Vj0QuOaN9X6Un3REBWH7DVjCWCVzBOmZlmmZCRN
++cOmyyIUdCuttNLK+yCSfVYAav4CrCGMv/aWQ1J+QgGkCNKIkgW9SS8FsBdTj6hViA05rhWlEml0
+QDAMxUFjUtUQizaJmOKWSWItAiczmhExkYbMwwJKL+dQ/VMICl+SJJBmMXCA06rl3B2kArF57sc0
+NLlEjS9346oi32rXUbuQKtw5lR3IoFfNfEihCx7qoT4VkFtEnmZ4hhahzZKE06Z+nQHYMp9BjYcE
+fRGWQr/m72dNzekDLO1rer7f2xXF02UWFTS6kBTG+sk06mlpc2WgQjYak05lqb6w/WRkSF5TuNfr
+nTp16tlnn33ppZcuXrzY6/Um3eEag7+gTHImk19bOYY0/EgTw7n44fYhjz/MyS5Dbsy8vLx88eLF
+O3fuMPP29vZoNJp6T2e4I75X+a0/+k178JgcwP1e98oLV/7Lz//6mfUr//mb9wj70RAzLRQ0v167
+WExdHicL22hOdOUtE5Et4ESxvqKNhsTZESh7ilahZF3WvPFk7MmHMZUlmOrU3YK0Vlpp5UkKpXdZ
+KCtrQf4eQAryVwDEERhEzsr4Kg6ehES5ekNpR/vPThHPAFIhUfKWEwTwIemimgWMlaFeLa9HZidr
+xLLUvtc1pMqlAqRKoiRG0hlLlzLZg0hUPItwcF2q8JNSyGWg+XJCpIyqyDUHQiua5+wkIXZOFVae
+1+rHKBOYYn6ErNeJaMiwaAqZtmC8wAJo+MFU4MACmEOZZ3iGxOxVUyi0fIiecniGFqHNkqQ7zi9X
+3SSIwtZ8EyngfcyEEUjhh0AKj1w7igalzNphepsGF8wJCBeOyz5UVEaDcpylr5vybR5riUZzzp05
+c+bnfu7nXnrppQsXLmxsbJgLXNo5b6FBoDUkbZ8k3xr7zNJEW5kvObI6xuhNwviU/SXfnuLTRGRl
+ZeXFF18cDAZf/u0/fmSXkclv/tG/pKxgTl5JUyQEiDMzgURVNBhdsksCUB081SYYTTTVpFJo5Xcz
+yY9pDC/TuH+DeNPg55hZSILmoiIiYixZmqDNfsWmtG5myj0Ijh64VlpppZX3U8LbMobkgxTsDQ0R
+soIipNFRUGPEborbJaqAR2YyaxBE0ZhFKhAhERZVFVKgBIlFwSkYrCoQFZAjYrDGhG5Rp4oNxiUm
+vsjDCVWhQiokVjFJ2QsEJMmMJkpiCI3Ji3hWCTgwXDCFNInWoqQcCKTEcKzMQiTM6hCiwQxcgoIr
+qF2qKtSpc+pYHCuTOoabzD0SuTUhABCGkihKZSGnCb9J1CoFaR0jWAYUp+JUCtUijrVOrJyPSTP7
+aYRnaBHapOSxMcb5NLmvGVAk+BIHVSzFviQvXYXCe+9JXBj1ZLyZoxVVkZ3v9bpq/6QOBKUsvUWC
+DV+RWGytd8CuJ5WZnoRnU8GSfU5Hee9XVlaeeeaZV1555VOf+tQzzzzT6/XyQ3KvtnRs2p47yDVO
+tKDk3W5lEUm3eDK/y4LSmERpWhHR0o8HUw/ZBK6eOX6f/6v//l+srKx86Utf+uIXv/jNb37zr/7q
+rw4PDy2Dv3OOSSUUMWsUPQtij5yIaPRtseuwP5Sx0RTqYCzoulF5PVM8NOYpiVZFStHqAJpsWuZf
+nH5XUTFijYgVHqLI5m/Cv2HsgydM+MEgcSK623nRSiutfHAkvl8JYGVWZk8kzMIsBDAnDo0SQlNh
+kDKByBNJLJXcoLg0sm3ha4Q+wuRJPal3ZmcTkI8xaURKYCdWBYwB0ZJKT6U4UZeQR2wbYXWJGboB
+qLB49qUrpRBVK5orKiLR6EYgVZZAkpGhQkNmTtkFr0TWkHUSqLwKicCsrhDnfNGRTle6qqKq2apV
+Q2gAHDnvpSOdjnQ6Wnj4ODyVkCWXjAsdg5yQ89QR11WXdaBymUz6HKCkPIZ2RTuqnViY7f1BaD+l
+8AwtQkvSwBWWqSI5YjWip6ZqMAqtak5Dg80dIjHAhoQk+CRx7bg5Qovs9BCioqIxeiUQ0GSfQ2RK
+MD6Fq8imWFASo27N6TMmBmSSRssB7XA4HAwGH//4x1M+fauBllBZ2jnnVRa8wEksfQyZelEfYlnw
+em0uHI9p6b++dMzOHSW//eXfQkZ6G3q3stcWNmDsa3rAUv8NltixUKhKBcIiEPXeqxKT4/DAhzLu
+EcwlcIU5K8usH+YcRvkP2txp8hAiYnYIzLNCxVZtUdXgmYNgxgRifZrKDpJ7I+cvupZqbqWVVj4A
+4ixWBMRgJ+w8O+8cF4Vl84iaChEsFlhV4YiYSAglwRNFD8lapWc7KhjG2MLLoEzqUDJKp95KigWE
+VlJMVcKkKlAHTyTejzAc01idoFDVvPWEVbJTAVL4cTEuO6X0vfeliAcrmXZm5cvUkTgFKSmT41g2
+lgEI9bQItkE4SwSVRXYRgVhdVztd6fR8t689KLz4hNCQgGPspYOD137Z7fluV7tZBZrMKQmAMZNQ
+wBO0K64jrqdFXxxsjBmoqasEhcBuB0TRU+2q9gBnOSrrt7mFZw1pEVpTNIZImWKXbz/62KhMEZBm
+lKqk4k5FUQiXFGw20/MG5Fz7w/e+/qf5UzAu2YYYQ2oeAJAQamYvAas+TxGV1VtSMk09uYAmFZ+q
+q66UvGSbF5HRaLS2tvYLv/ALv/Zrv3bx4sV+v58SNsbGNW9zUvI9672qzpijiDla5qx7+vRgM5NF
+rjfp7ikDfmNgez/qP6bubT+zxcyHh4dvvvnm3/3d3/393//9/v6+2VCcc0Tjsiydc51OJ2IqRay6
+hvjg2Rx0zhVFUZal9x5wxqeJSEV1x4sFYE0VriByUBVvBpboD5mGoFrnKP83ik75dJTEyWq9WegQ
+m4sa6o4mx59ke66Mp6boUHaluf9wY/7i6ZsOrbTSygdK3NIyKASSuaJL/X5ZFCN2KAohKEgyxipm
+pKeCnVFqY1dor8eDJefFIr9iDvhguAouDCzECigVrP3uoZN9Lsc8VniFB40JZdCMFEwFKakSU+kh
+h91hueR1OejUMYO3dT/pIpnNfUnHS+PD7uF+Z99z6aUkNpQllguExbEUZi13cIUUgHbY9albEC1p
+1wUwxAqHgNA0ZuAn5mJVlwfjXvew6B50AFiqtcqrv55ugJj9Qdkf9VZkeQ0rQ+oEy2W8jLi2JRuf
+MHQF/aVx0RtR18V8xSQhPNAuEwSEGAF2zo/GS15WRFdBpflBJp4xjtCjlZ9qeIYWoSVJ6mbyprOK
+uqbS5WbmXF+pezkCFhVKgJIXX5bei7BzRdER0x2dqsKLOHYgy5wKIgl1/ezIzHPJ8qpSbWrXJPN3
+bv4e+2nufDF7TlaDI9TRNuogxL4EOoEVCNUz0lVy5m1IaQxy98XcUSqNTz5uq6urm5ubL7/88mc/
++9nnn3/eSlGnuKOkWOeXkLs4JqfTaZc5/W4iArZ8/waEa2VBcc7Nckd8j3L4wkH+NTGoIjIejy2j
+VafTef755weDARG99tprd+7c2dvbSzYUESnLMocZZVmWZWkmAOs8Mw+Hw3SKsiytLktVJSY+EWaj
+sYdToRIpucI5x/lsS4+QoooIrxZBqr5QTHmfbJchpiKiMUWjyewjxaUu0F/hfaCARPAVaHuzt4j3
+WpagkGAyBLgbt2bZkEO9Hc2ng/e+LMtGdh/7qeZV3EorrbTyPkp3bYPIwsmYOwWtrI573UPntCjM
+d1HyV5sCKqQqRaEi5P2428VguVg/0ev0rOgXVM0PHBFzRA7NE4Q6DquDg0J2+bCkoaCEITTykYAj
+JsdgKKuSR3nYH+q60AbRMGpYSfGxbARRjQvAcAnlyniv9+B+cV8iQmMmQ2hC5KRgKUiIFF1fqHZU
+fY87q8Vyj4sVLBXK4eWvTmExYYAtRcSO3UlaXykHnQfO9ZhBLMTMiQHItUpbN8sDXjrorcvqKVof
+8Sj6XySEplk5TQDiWDd0eTAuuvu+qyPoCFwSeZBPDiIKo9CgABOVhwfL43IddEDkYyknO3ulbYLq
+yTuPLz/t8AwtQpsUgwqdTmd5eRlAzhRhQt1HDgby6H3AOe4tL3V7XSKQAzEsnIWdU6jEuhdBX6tK
+IMUXQAR7avEkCq7ZPIx25zwZXJQpxu9g6o/pQAKuI2Ji51hBYDuvWLkNIoJ5PWsq11j5HAJMhE6n
+UxQdU6MNx1pCfEStLmfPvPfLy8tXr1795Cc/efXq1TNnzozHY0NcRm5ojGtKjmf5OBubkbeZX92k
+JGe2qXAuncuIl7Is8x2ecs+u8lU/bfMO8G/w5r85drOHLxzkHoaIMyv8PGH+SPAgUTrMbCWtP//5
+z58/f/7b3/72j3/84+FwmErnGUJLLK4RZYPBoNPpAHDOrays2E0vigJAWZZxtgVLqi1DFM8eOClV
+gPvdbq/XI+LkwmIrPCPWFxXNfe8tiiDyYPYDA6GGjtUiBTiWtjF9QQFiCxLLePC4lNpj6RVMyS0n
+5hZjcLfb6Q96jC4pq3aIFaQiII5hrypAJ3FzVNWmDy+9wWBg4aCNGvGNYnSttNJKK++nnLv6s8QO
+BDCjcCdOnXIbp4a9vnS6IMsjCF8ZrBWiBPVFId6DRZZXl85fOPUzO+PxmO1dK6lkWk4qKdgzCToY
+nF5+0PO3/FbJB0IjwBMsDk2D34Qyg0mtPbnfv6+n0X+u78YuKlwBP2la16j6XvQ7elp3ujtOnKoX
++IiXVKBi16mOAKfU993BeFDKeLkzODPYXNGl1fFyoWQ+m6SsIDFaMCwU5NituxOrB0u4LeXwkMCi
+wsxJuSFQotFsLGRULu12TsuG7x6OXSniI4rVsHDBp2RyROKcnKG13s54fO3uYU9Uh0RjcAl4igWc
+VGFu9pbUZTQe9XYfbCpQFOaKA0SHe8TIaCVg+N6fmQ8BPEOL0CbF4Nlzzz13/vx5M53P0dpr2zUY
+Cuxz6T33upeee5YL9r4kgDhm+TGLSszEoblLMACkrKUhbKTuNhUJ4aD6BS2OCbMBS2q18uUiNnxS
+dLvd4CAVUtYRlAkM8sFVOKiI0WsqIDQqisIICiLqdrtLS0uWDz15TCUlz/BVv9/f3Nzc2NgYj8fX
+r18vy9J063wYZ8GqdBc2NjZOnjzZyBTS2Nn81g4PD/f39wGsrKxYjbXGnsx89uzZq1ev5hAxu8bQ
+2twx/amUH3zltcfR7PDK4SKY2Wix+/fv7+7upp/mNJsjurRxc3Pzueees4dqdXU1sdy5t62drtfr
+Xbp0aWVl5dlnn/3FX/xFm9EGObz3CXrY+hDmUrS0MLFafkTijitObWxsbp7swMWp3o0xIdoAACAA
+SURBVOx2nKz2JfybhwfEHzRlFEqZv6J5B7GNtHPNBpNiRENEgTktC9ZW1z760Y9sbJwreAliRhMC
+iSiIXOyNqgpSbVTlZHYxR9D19fWzZ88aoMWMydhKK6208j7L5f/i08wODDALoz9Y6p09Nxosj51D
+LP4cg5qCYxARxq4QX5JA1nn98s88U/TsrYdADmn1f7NfkxB7dl5cKd3D3aWyHN8s3QOhEcgTzIUP
+pnapgIhIWVVJaa+3pxdo0FkWEaohNITA/6TXqaqCu8wX6F733sF4L5jnQhy0CkOJWArnHYk6oZXR
+8vpwfezHa/3V5dXeBp1YPRwUnsCeAYYDyHNCgfZ/Hrjltb2BXhsd3N21UpiWmtiGNADCZAUEytL3
+toqzeqrfK0TFi/l2pgVKAMszSUTsWJ0br5B27h7s6TtDd6B6ABqBxiArQ8dQVqhoMtxDVYp726eB
+pU4XbCAxOEEiuo8RHgFC+3DAM7QILUlOjlkW+BMnTuSJHI8GaZrsC+YyJL7gtXOn4QrvRZAl1bDA
+r6CPUZxU1QQDAiwzQmuKDkuY0A8zSdohNfeLzowAiJkcs2Oz2sf/LLernaNKoJT4cBBZ3gVWFeMi
+bMSMQ0O0uJvGbKya935ra+v+/fuq+uabbybeLN85DqHm6C6Job5ut/u5z33u85//fHKPnHr7zOHt
+5s2b3/ve94jolVdeuXTpEqLvpd1T771z7pd/+ZfPnj0rUSbP+1OK0P7ot778mFreu/ygMR3mzw6T
+Bsra399/9dVX/+mf/ml/f19j2GdqROtBiYk4De52Md5sb29vPB5/5CMfefnllweDASLh1jiEmU+d
+OtXr9c6ePfvKK6+gloZUnOOqe8Rxpc5E1HshsGMe9Psb6xsHO84e0uDvb7Cs4dMf/mqcQXEckI+D
+nQ1xAdSQGloqYyIqgJegmbVMQHUDAFpeXn7hhZ85e+bZwi1BWETZKHCAQkSappNGrSHrmKqIFEWR
+v/QalHUrrbTSyhORU1dfIsdEALMnFJ2CTp467A3ABJAyokOdBgO5KgHMTtkTANftnXtmozfgCJJi
+shDLEEWAgqHkQaVzpS8O9uT2g/72fd0qsRMRWl5nOYXpmxcFj3qj8enSLRXO9JeoPwHm5heRUPRj
+IsfliXK7s7WrrCTB+zHGpAiI1TkwSAvwga56r4W65WKp113b7GyujVe6xOCSVFgJYOFKswRA4I72
+1vYHfEvEjazTMdeASQyiTrBIdGmvs+k3VlxfoV589HIMpbQ1DDAzkSvEucOuPuhtD8cHO553FfvA
+EDwCqdUTN4SmKsxkY0yE3t7eacWqcxbIreaNkiyUdYvk8eRDA8/QIrRJMfX91q1bN2/eNB+q+SXR
+MoRm303nUi/SWVm61KETg3POOTXXxrrGk2laDQWv2ha1qhrFg+YhmutbVePB/TnS+Kl1S87txfty
+PB6HgDOSUOsiRJ0IqJzKoTE7gMbjUVmO7XLG4/HBwUFZlnaBhrvKKNvb29euXdvf3//Rj36Up3NY
+RPlLAICILIzts5/97MxbEMeiLMvbt2+/+uqrzHz+/PlLly419jF99Od//uc/8YlP5PkJJ7v0wQRp
+V0cvPqaWf9gNDFvCS4aLBoPB8vJyUUfFk4fPGsZ0CDOPx+PXXnvtr//6r2/dupWwcd7C5OEJgTNz
+URTm1lgUxZ07d+7evbu5udnv9zWmJTS3W5vIS0tLL7zwQr/fv3nz5ve///3RaJTMCgCMQzMPixQs
+YGyz8X0EKksvXgdLS+fOnu26ZfbrydCR1uDUzdwgEpfn6Cw5Y8ATSJtozdrX+tbK7hkugZgIDx48
+ePOtt25ev0foQh1ZsR5o3Q9aNauuFhKeZTBsfX291+ttbm6m0heLwO9WWmmllccqq5efBxsWIiEi
+YvR6B0UBhGDemmk7mNlCqAgB1EGxWayublBI5FhLuh2cmgjKpWJEbizF/dFweGf/5p7e8W5beAgS
+Si7rVK0ZbNwU2PdleGpM67aikEGlUAgs8nRJ17MAllF3tF1sVU6Z5l0V8wUwMbEj1ULdiEYsxSpW
+loqlDbd6hk+v0XqfHdFYMWYBgSREIXMYDiInRXe/WxwCWoYRoszVyvIgxM9ExEDfd075dY8VQIUk
+UI0qEapBwWbBd1oW2CMvev+O6F2Pe6B9xSHRmFgBhjqALaZGgrVSwdQX2VQtmdMyKvE2PRL5MMEz
+tAhtUozh+clPfnLt2rXd3V0LXMmt8pijgAIGfyDqRQYbq7rc++i5kyGFK5SYmDlUYYqH5DnbsgBO
+RYw20ZhPtnmq6kuuhWEOv0YgJkv6puJ9WfrxeOxTrJu9bdQHiwqNg/sXBYQWx8ER0Wg0HA6Hpg17
+74fDYYpDMy9EERkOh7dv37558+b29vZ4PLY+NAirORAo6Y6JDDk8PJy1Z2rHjhoOh1tbW0VR2Hlz
+z7ek66+vrzfcLPMG43g+MYT2mNJyHPzM/pxfL07bmMatYWKYPx2mig343t7ejRs3rl27VuW7nyv5
+KYxGs6fuxo0b3/ve986fP7+5udntdg2V2T5G4a6vrzPz5ubmT37yk69//ev7+/sGPxBNiAmHhHw5
+cTYabi+cE6+j4Xh5efCzL760tnTy5PJKRS1HLWBmt+NfjdaWfLs5doCDOwwHV5t0yXaSiPoiT9cA
+cgZ6H9x/8L3vfvd73/sRpIA6xx1VFfFc0LS3QbhykTAR7LZeuHBhbW0tEc7p5n4wjRSttNLKUyK0
+fiKE3wZthErikjgWDKpUoFDnKyhcQMQBMii4n4qNAckArjHin5WoVBqBh1p4HXb3/Wi33JNiV9wQ
+qB2LSD7ZRiYSqC8Cdxde6OGPQiXzsqiKswjJiIcIDg2KzK1BLZJEGdCCHDte5v0l6q/QYBnLq7q2
+JmtLWhCNVUYkAiURIDgxkgE8Vme5FU2/CxdcLUJZNkciWwMcOh1x5m1heRNi8IuHKpQBp2CCMsYF
+RNEZj2Q8PlDsgfZAh6CSSEGG0CjgXyJVkLlZMnW8WHZHCtmhNcb6NIycDy0fMniGFqFNimmih4eH
+u7u7e3t7iNphQh0Lef4oSu9Lh9FoZB5EIYt9iAOhpNXZ1Elp+ivtK+YL0Fka1rGEkuYXYGAwIlWn
+UI0gzworacJl6XciTRyFiHS7Xct7nsCP+RCq6s7Ozo0bN+7du2f0GjJ4hgX08txvDWYWiinUG9b9
+RlMU62Jbx/IdcoQ2lSLQLJvIIp18L7L85srjaHbv8oN5P8vDJUpKN9pSbqZkMHhIbEYxhweiW10O
+mOdLDr+NIzUadmdnZ39/f3d39/79+6dPn+50Ot77oiisq4bWDg4OAIzH493d3dFolFI+iog5YFB0
+tzDKCgDFB7XjCoCHw5Evywe7u+PxOK11WsWdzbDXJK/ndBW2PfMZrsbG/mbaQ9pjypqVKQsqYnP0
+8PBgb2+XtCOemTo2s9khy32cNxnuQs6Urq6ujsfjlBck/dRyaK200soTlHJpKRWRVaOJNCEw2LuK
+NDdVx+wTkTci10n+Tcmzz5qrXIyoVHLi2Lu90tFwb3yAQ+keiDsEBAqSiL+SvoaYVQDQTuxA/qJX
+ABLrUdp2ih4TFHUtK7GWjOv2xwLsULDrjrtDHnryBRV97Q38YNkPBtohGnkp4D0pCSUmjJAVixLv
+VTS2W6UWtjzi0X0kYDSmwkZJ1Qr52kh6FQ8F4AAHdUrCeujkEHDDkdBopBiCD4mGAaGBQ4ZJayRz
+gWHHpJaSjgikGnLxpzuiUxTeheTDB8/QIrRcav6HWZhNIzDjiEYQ7OHkTQcNrbBjjFH60ntirgpy
+xOeyZhZPKpgm6ztVb4RjXh2AaDjXiAspsGqkRGAJaqdyDJoTgU86aD4mqiFDo+l2pm1TFACHh4d3
+7959++23t7a2TCduIJ/UFGLHpnY7QeIjCbf0q4G61KVZR5mn3CQ8azBF71E9fSI82KNNvTdriKb+
+emRT0Ww2JWNnY89ZPxlC05jmcTweb21tWVMnT57s9/uIj00OwonIQiXzZpl5avftWPHee+8ciqLo
+FB0mjgR1mBKJIpvSQlrEJx04EoOGkDNEM4usZg0ebQdKlJ/CixfxnaLnqFAzqYKAycyc1Y1LrLLB
+UY3ZNfMY0VZaaaWVJyu+KALFpIbQ6sjK3maaqUi52TnpToTA6qTjzEidlCOGUimOfUFeqHRaFl5c
+KW6sEEgVJ5XCeCl/nROFskV1mo7i7unEGtZNqgziVP1U9VCIQQodu7HnsZKwoiNF1xcdX3ThGJ3S
+Q8UHF4ugtxAAp8zKKlAhlZDvPl/7QrqqYEY0CaouFFnpT1VhqI25UwNppKSe1QEsAhEVeFIP8kQ+
+uKTEM+Y6GDtxahZz4wlYVVUiDZGOfHj5UMIztAhtUhI50BD79Wh9lALmAUhUVJRgpQhDHnCvohrh
+kWl6uSaagURNTk9U+z2z0jzstUW7TswRaXR29BFICmeVi4hBViky5hkPQ5RUOiNYxuNx8i4jov39
+/Rs3brz77rs7OzsJxU3v0WIW+kklcqqkO9W4cVT3gcx3aLSQl+5dUB4TBsNRMOz9Ea1XIU/lxXPu
+BQvMi0Rb5TTaMfjJhL1Ta6o6Go22trasfsOFCxcMiTVSdJpBoSzLTieUiEAgxlM3KMxeTcuJS0Xd
+iUly88axpVrXYz7i+pzP9mocNNlQ6BszC1REvHgnUjBIWQNCk2ktWUnDyr90qlXCbtD8KNxWWmml
+lcctZVRIEPPfUqWxAEDERqiy4SZ9Jm2wty7V1C2inFZiIVaCZ/KOxEFEvPOevUKIrEQSqaXOCG/u
+lAI4rB4BoUVdiaq/GYdFiF5MqMWlVBuCoyMrkaLkUiyLvcKJ63hXiOuAWRyJlW6q1NZQ5FqJlSFQ
+gXoOr/NsSBVZ5hNz8SJmDQt9WAQDXItgDk5RAA6s0IKVwegIzA8SoepBogMFcSg0XhWT1dolNQ7N
+9LKgQwS0fIwV9sMKz9AitFySrmlZ4JOx30KtFrIo2wwkCCCkybtXgzZJzhUll2kmxxdMNGWYa3B4
+sSiregApyU+wtUTjUNIrKdHsqQJgMvTEbiHuaj3iQIareQOgAm+2GwA1Fj7G3OSGEMs3YPPXEJpp
+cqYQD4fDW7du5fAMR1EiC96dqXvmuLG6ykzdzHL3VQxbAxnO7+SHG4MdKWlMkrKe7vjD6u45RbkI
+HTr/p8TFGR4bj8dE1Ol0Tp06ZTAsh+gpa2juN+t9WX8MgLicEoiYISqipEqEwrmisPeArdEQq2dY
+VZlPK3AKRyDASp9V0REKNRfiWHxDhURILA4thlCAMzotFbQOi59NeAomHALAxOyInApG3jt2XlN0
+gx0ZPgW1ApxB09rAprFKPKeItGxaK6208qREKMKskP0v4bNKh6pbs6naXCGkSsdJ39Mb0KCNECnB
+Mlto2KJKKiqWM9JOqqQSe1EtIAmhIXtzh1c1kC9qYa/QGBLtFq3vasBRiYSFqqQdBLDCCRmZxUIi
+nJJAUrS9Q+NnBYShSlMRWlphgi7HbGSkIqZhpFgB3I7g4HelBKtDJ8RIhTXV9FMCKFKGGrmAgNCE
+iGN6FkPUyZcs4NKHptAeHzzLW35S0iK0piSFPrOyA4sBCbMC5EaagAqIELPPK2XJxMNhKd41bg3W
+ICRgoRptR7C3Bhwhe5QzZa6udDV20mTVCRSaRn3PwtMkeHTbzCSWaA7KUU1SfRu58gEcHh7euXPH
+4JnGSNAjx22+5CxNgwrLJWcAqB7zNkmBNrg1InpMMOzwhYM5v37wuYk0kgmSJQ3+eK3laPm9i2ZO
+FGVZbm1tWa7IM2fODAYDSyWangE7b7oWZi7LEWrPUrJ1ANFLI9gnsslDwXk+zqTAiWfZQChYUgji
+EAy/lTeMiqqqhFrXAiiJQlQFWRXpMNeTphHXfQI4NwurClSULHcjiFVIQ6ofobBwa9WkHQPhjAhF
+nCy5qSLNkUdyp1pppZVWjicBm0UsEm3TkXexr7BXnaaPYbNlqYjtVCCtQlYVt5Xat0JHSjAwJlCC
+RKSXOCvUsVXFqCEZ3YMJL15FMoCD6likWhGVrf0YqUVmDAx5AVjAAlaw2gcWqOXcDu99Ux09gQkK
+kqjWZfm+a30Ol0RExNEozxr9L+0nW9JCokhbEtisiaxhPUr5UXK3kIDs4qWyKkm8Wk0acxXLV3Vu
+MflwwzO0CC2XWepjsrunr9OPz44yj+DkDB39HoOCFQ0qlc6GfAZXM6dRmykz1GNmZ2hW6WqbRDbx
+wkVm7Ud7VFRKAVCk35vQKArnflAicnBwcPfu3evXrxt7hojrpg/XcWVOg1NR3JPFYB8OqWwKdZ/G
+xW/uHET9HiXvg4E0VTXSO6fLNJN0IFEtDo0isV0tThSWLgJUQk4sROWg6kPMla8U5x/FzRNSWUjy
+kTTT5JSU+zalkVa0KS0mj2nzHHFW9UeZg6XWtIQ4x2uzO2ebG3ck/6mVVlpp5UmJmPMgVT4BAAL9
+lOswkY2hGJVGdaYtl5ToKfxOkTQDJLpBCVkeRg0Wt1i+SLM1Ip65+pB5YOZuGeEnrR3R7Ixq7AlU
+hDjkq6xgI4daY2DAgUoFgzSwWwjZRxQgsrwmiU+r5YOrDHzVJRCIBNkCFHrNSVNVMmoxpTAwcz6H
+4nAwqyVly6NqbRG0agKKzGao+XiQPIxS8aGHZ2gR2iyZ1E5yOqiBBJBtrb8yosIXmTQKj3TM/JHl
+1omTelGVKDDq+UuiekFQw1pke2gITk2nDEArOzQRZiAk16rQv/CyUagKEWIOnqBoWmL9W7du7ezs
+WETQgheyoMyat/lt6r++FD4Av/EsfuNf2be/wA/f06mfBgw2X3LjRT7gx9bgH5Pqr6rD4XB7e9t8
+btfX15eWlpJ5JXfLjFtq3VDUpgLSbEyGlnxzXTNIVpVZhsAq3CF+oWzyhvlf2XTylXK2ZB1Jpc/Y
+zKUEmLt/DZily6wuMk3hOWitlVZaaeVJiaKCKbMlvtMomr+jHtTcK7aZHxLPEjJ7GDYTsqRLohCQ
+anAcrFnxgGxT8hysnB+00l0opmCb6FYekRI8BaEKNld6heUAB1kdaETySokVAq6AIewCzFWLwtfw
+/s8phCkjmSL8zIEqMpYScj3CCDmDj0phoYExa9VQKIJCmdTFfKk0s2CNPdSwParAshiJ9jTAM7QI
+bZZMjdBYUJJWhzhpNMTrJ6PNUa+arLGGqb5SHdPbJ26KneRcYYw/h2pPRIgxZckKspAulunookqq
+paXLQ1SLzbnxwYMHKZv545Av//Yf450/fhwttzDsSJn1pHxwtHnryXg8vnfvnvd+NBoNBgNz3stN
+BkRk9oWJjtcWzsysOXmBhDifFpFkMQzGyHzaVifL1rmHMdUEc03zEKr+Ug4H6x1bLCywlVZaaeVJ
+SUx0j+jXA6Bp0VZUQfzJchXgV/qY81vRUBaNz6RkLoEI8AwiEAm1m5VIJJzCSjBnBvb66zy4+yU7
+PlWKGwU3yCkQqQJpZN7tqiRCxo9FpydEnKbmJA9WK6QpCqKQxTlgHg41bIOa1wjxmoLQMns/KUm4
+RDYfx1iuM9QEIBi7Z7jV4uYCzcgxowsCQqtItEhi5PcxGT/DJprStaa8P/Dsa1/92hNHay1CmyeT
+kRjzldHwxGWaX1DwquOjagfU58vREiPCcITy1sRm+dfE8BmZN+1owoTmGuw51eljmpCicN77+/fv
+X79+/fr16/fv35+fuXER0e/M+fH2sZtFHYPlPZxzTz842ON9lsk7OJ03Pu4QPQ7311zG4/H29nZZ
+loPBYG9vz3vfcHlFiPEEqkuYmOa5NlDfodqgtR9SHEC27FfcNGJuEJuMVdPRL3KqaXOa1HtFwXgT
+HUbM9lKNMKWZr1NbaKWVVlr54EpAAPFFG3IkTV157G0702I1waEZYov6jVRMWgJp5uIogGhgeEgT
+QmucW1GdOPxVWOlnAx8pVgxpG7JVwq7LIocN95DmnQp/je+i6N1IAFs6xrC4hAgxTpfJBvPqNNrU
+sVNjCokZEEQfz2jVTwXfCGCL8NOQTiWFxVgYXYp+pphJqw6ms5sQmEYKSu5RCsX7Bs8eYcvHlhah
+VTLp1oiaStfcrambZjaKmkcTkM/mhhKWEcLTJJ9TlKxCcy0hE5dVvbSmW+a1lm9fGweHiVmRd+YY
+SXDOici1a9e+//3vf+c739ne3j6GZ+NcPPbQkjDYwcHBN7/5za985Su9Xu93fud3Pv3pT2seJvuI
+YMaHWD74dNlUyWfreDze2dm5fv36G2+8cfPmzTxBq/c+Bk+WWdYTzW2tQDSmxHnbvPKGFaNya6ks
+GRRTMsczIAQVaDa1am0db3hnwsjm7Yonq5mia/t/oO9vK6208hSKJgWlhq8mXsLZexUGcSbeZ8lK
+XRnOYC/KEAaiMQzM4lHqOXhNXYpEWVOhyhO+ZSn2c7avxhAlRSQP+Tf4RQhkmsZTa0wCHJkpVStT
+RtHNMKT0oFRcrQKL0+3x04ViXhD7rAQi5VDFrQLJIb0HIdWnC0WwA7qMu8UlsQq1q58rGz0zbM41
+3T5V8AwtQnufJHDUD2u3rkp1xODLOOU0VDMKLB8sp2LzrZNNBtPKUqr+YMOPf3XxCZziVYqiuHdv
+66tf/eqrr7765ptvjkajh7y648if/9Wf/f7v/36v15vsVeum1YpJIui89/fu3fvHf/zHU6dOmbtj
+ytSK9wWNRL6s4s5MgsexMdkUi66hCh6zg4+J11pppZVWPkQSKovU7GSzzdpR9SGauVfdzl0P6I/a
+Vnhpk6bs3JJSz099OTcyHDcz6Da7MP1nSugHIbEGISImiUjNehPcHhM5GLqu1Zas0QTcZkk1bAlR
+UjBSEmf6p8HVGPUMDjU307gYlxZShtS5sik9qOzmE1sm5WmDZ2gRWi5TVfxJNW4y0+OUjfGvPelK
+YW5FZr3+5Eb2PmeGbUrBmHZImnwBW6lBNAodiN5aANL2ZGlJpp3gSxXbCLvE/mbgrgHiMrtTsOeo
+c6yKt99+++7dO9evXz88PJw/jIsLfWzmT6dPn/6DP5j+05Ennb/Dgn1u5JlY8KcFW364WMcFTne8
+Lk32JJ8CC3qHTsr7Boryc1mE5A9/+ENVvXjx4mg0Sgkeje+tlw2om/OyjxQ/VCirWvuTY0mY32GN
+UmitOCrZ7A41CEMKZElpPMJaGN4DtU40v85wAyHCrMWtNV200korP91SAZGKAsu3Z6gpGbKPMnI1
+D8kji7NPEVvUnJ2mNp5jwnwRaVBt0z5Ob61mSw/rS+X1GHeKteBqHFetjzrRi+ldp3hWih0nAldk
+XNihvipG98vJ68jX16Rr5iNX72cdONflKYRnaBHaVMmzck8CsIaWWUvebb/bbhkSE4IwBFAVEo0p
+vi2GlAjKAQqpgLPn2BMJk2eUhDGoBAuxgMS6GANQUuYi64JExixFvKQZQOQKeBdSBYl4EVUCOwUR
+lYoyBLhK8mAGqrT7IcUCQKNRub29/e6779y5c+fg4CANwsM6Os7BY/OOIppI/HBM5PBQMpnMMP/p
+yGMxu29zDp+KBhcBXYu32cBgjcHMv+bpTBcEfk+E20wRpKq6u7v72muv7e7unj17dmVlJe8VkUNz
+dicDhRqQIyImJyAJRaJVoaIKQJScEBNbcuboyhErVFcEGgMMCtZGhQfGSmNQCfLEAFmSSSUILE9q
+cq5UkDVt76HoqU8VMadxcU6F6K37ABAzNdsmVI3WByp9sKFIz3nr9NhKK618IKSGiDIANttEOb2R
+iS3mU2jByeZZiBB4FdOKZC3ldFuztbD3RHjarJfoUQtjqhgQeLyYqz6AtNp5KLroTxZs0cnPU8+c
+FNfMKk8TQ8yTl2Q3I8fNDQA29USzvk7t29MJz9AitFxyvSTHXao6p0RvTX/NnzatYlCUoExKib+y
+wxRQIYpgKCqGcabYd4YWBGYlFpAHSVCh1RFR0N2qw+31IDXHxWimIKJQIslghrHRYGgh6pkE7GGm
+/zACKZMCee+txpT3XsTv7u5ev37t9u3bCZ69P4p4Q4PMN+aSXDFzvNH4sIgCOvWiHooOmjo483Ha
+Ir16rCi08XXx4ZrVCB6eJHyP0kCSBwcHN27cAOCcW15etg92ZdMNLhGuhDkJFfUCb2grGFSYARUv
+ymASqIcCKBL8IfJmNFEUSoRgfBHAKwngBSWpD8Mb7KBKcMnwaNjOukMpIIE0+iurisQ3CdmLRLxn
+MAc9IrJ4NbtqssZOeaflxik85KPeSiuttPJYJKpF5n2YaVkz8c9sl4Kpe9Yhn0Z0FLW1yBSFXqjq
+TGCRJ+pt/DTZocmfpi2SZosLwCykD4HEjfUjzTqfPAw179mcQYg/U7ramjKb+VIC1YJU6+ARhOBc
+ND1Xnlp4hhahTUrDfjypDR+hH8f3SC2yi8irKpSdE/YqElSvylM5MkIk5jelUGgBVdICVusoOkgR
+HFAo2NLda/UyCopXxp3F7oBMLxSMBWNyQszEICaoUziQ10BV12eRzVQmg2d2+cPh8N69e1tbW4eH
+hynn/nxpoKnjJgi5DfwJ3vmTI/frA7/+DH79v7Vv/+t7rIfWyqOV54E//V386e9O//V4tOossdgz
+7/3+/v6dO3cGg0Gv1+t0OnmtiEn8rCL2gdmCsEUxVvVVukRmZSsMLaIKLQnC5EjT4m5lZMzWKdFd
+P670BHLBTKuBYXcgb4oIEVWJlQ181VSSxJJFzBYIPREJtW/EzDicR65TOjxriibfZjkUN6baOfeI
+7kYrrbTSyjFEG9gsBIrNhjaU7TOp0gBIVdMAjYDGgoIpg2cU3t8Rj5hqJ0jYKMcpNC1/yGQH818j
+hRfe68leZ/2mOiGmaqdOFazjf9UBU9BhAzsls+OcjqVLSOtHyqWZ8lxVo6sNL0cKIzpxsZOnnFA4
+J7Dd0wzP0CK0SRGRlDLe2LMcqj0EFRAdogBiYiKYZxQTl+o1hW2GioYpFJaCv+FOBwAAIABJREFU
+vUhJlAmO4KAkHiqAOqgDClgsjQo3rT2kKMzIn7y1k2qm0NJ7JSGGQgReFSIgR865EGiKFCxHiWAw
+Ag1AWZaj0Wh7e/vevXsPxZ49EVe3VlpBhsH29/dv3brV6/XW19ctteP8oyz3o4gPgaAcklQpsdik
+gLqCSVVEOExbCFgVSqxKDIIa66XKpARzRQxACg4oCB1GV9AlVUiZ7LRIKK0mYaqH1c9YYon1cqBm
+eJGY/kerg6YbMHN4Nhlw+FjZ2lZaaaWVRYQsrNc+N96J05gbCk5CzXamgqSMbdMMnoWUGxT1quTz
+hwBQorVudjcaF9H4UHUvvNDD/6PbulK1c/Rvz+BZ4tAyWzxilHJCavnfZkd1Yku+8uQDU2+lYhzz
+vzmAXmzN0Km3I//2lMMztAitIaaRJLLIPjdC0SZNzvmxiEZoJjsy2BmYmQAvoozIfFW2j5ghCOaA
+GCq2A0QMYShDmdQxCtJChTxKJqFCJdTMQLTQk2IcMqXm7wFRgYIEjsixcgp0kVB5w9oJV4SYa5VB
+nojVl2VZGvPw4MGDW7dubW1tjUajY6TXb6WV91nSxDTutygKZj558mRRFFbMevKQ3EVWVYmZqFB1
+AgYTmIRE2asTgScRYlGoqAQwRgSoaMwFQqIkyoi5VEXUe1+yKCsTuoQuaRfqSQGeNqd0yqJHke3S
+WiUJCJSIHDkls3o2GcK0Z9pi2VOaV529CY879q200kor71VMA5ssqzVdousANSFAZYC2rxnQiJsU
+REjYjBDKjmVnjbxWDoxqTTfLGtVQTrXBdDSO7Beiz0SEPBqz54d3eMjrmHNoEk6q8XVOkcKbCslq
+2GwiWg5ohLZVV5VQqpVhg/1Ps5PlrF/zVBXOrfVjqoPmLHk64RlahJYLZZK+qhnImS1wBVHFybWW
+qXZoe9aZGKrj8diXwswEVRWeYpcOphOtZkTwkiKoeSOKeu+HigPiPhRqylOMcdPKvOK1+bxTzBsi
+KIZKY4UndsQAK7MolSIls5KKWc4T/acK50JmDu/9wcHBnTt37t69e3h4OEdvmx7bM3XPCZe2hj9k
+TmCePn36D//wD3/v936v3+8bz5kOieWtREScc4eHh9/4xjf+8i//stfr/e7v/u5nPvOZpIvTROqL
+dLsbJ5Xo6pYfku882UijhbTFew8gJRKc9KzLR4mj5H2e1XJqqhEntsjdycON8sc+/ylde+79S/8/
+e++6JMlxnQl+3/GIzLr2rbqBbjQAkYAgDsVZkViN1tZmabKZnUfZX/sC+zgyvYjMVrPaXclohJai
+RImkSIIk0AD6UlVd98wIP2d/HHcPz8is6moAJEAgDxpZefHwW3i4n+9cFx38lnu40nTQdVYi8sEH
+H/z1X//1X/3VX3344YdDH5YMX5cftCuoYInLyvtPs9ns2bNnk8lkOp1ub2/7aqnHuDwJIoEUNVGl
+qalGwxxhznYOOe91FqFNY4G02EMi0JrRGCGdIZIGChCMAhosKs8V55C5SHSZjEW40oshkIyMSU5Z
+BKTOFwyncTqO6UtfJB/yhuTknkydKZkPSQWWVHKZfMlhccGX5XqdW7CmNa1pTb8jclDEegtb1AHV
+3zNbRaL6acX2l3bJYvi3UM0CB5XA4RhmLffR36wGG0VgxoXSBUAWo0wr+LAqm2JxpFTdlyfRrdsb
+9etaG/kKRLdYV46JtzAH1VmFyjbzkhav7Mh48r628AxrhFZTbbOnmZyBQ8WvX2baV/O7AGLfd33f
+xR6gMKcUXJE1uhLW5HVryIEBVAkDNOpc9CSCPWIM5yLbZsFMARPSaMPesdizHI3IAFObRx5FmStu
+KTZABc0QARo0xh7sk/OMeeYPI6kxqmrbtsfHx48ePXr8+PHVqc+W8er1ObwaZiyz+CMYUEquALxA
+yVCMSktQ6wf8Vo6AzRW9KgrDEUhbaQlWOllizHixGgksA6p6jGW91d1Y7hgqRHQFjFxGXAXWlrbq
+S5YhaHHceuF01d0roe3LtJePI+i7clyjzl/RUP1m5bNZnuLz8/NPPvkkhPDw4cONjY0yb8u4vZpY
+NXdFELXQm5wrD3uwbXqi1dhHKgiEAJvAJgYxiWBH9DA1SmSIEIMR0ezIuE8eQU7BM7ULoCOVpjA1
+0xfYiGTBr5cSEQnS00gRCUIJEmDS971CUcVkNcvJV9NHIinP06TVq2itPVvTmtb0JaHB66xEDKk2
+p2XMBgDF0yP9kN2jFgsn0TiyEdHgAZzbXYBPLI2MjC0XmK4VO3gCeMnVf+ACrcpza4v9W4SjA0iz
+jJGq35cbLCd+/jPayrmibDWOxDPWaE2K7m55yKuGu4yJy8TYMh+8GvN+veEZ1gitUM2dhBBu3759
+cXFxcXHhXP5lrOTqqtRo1vV9u7N548aN0ITQNBRRU3dFc6F63i/oieEBZEtFIK/trLTWyRR7r0zu
+7G5snXAym7UUkcYsRWVcFCzJ4mZRUJopoGh2bjU395rJBu++svftb3/73r3nMRI04zk4I4U2oU0c
+tomg73vXnv34xz8+ODiYzWYi0rbtSi0KlmCGq4+uoJrjL+qj+qaUOl2NGWOMMdbZh/0jAGf9RWQ2
+m8UYvcBsNjs/P0eFkbxMwW8rFT51edfXlVZW4p/L4JAPp8CDEUM8mgr/1Sft+hakRQ1ST/6o2tH7
+op0bodblmpHvo5mFEPwWlGkcIaLR0EqFvgZ8UCSLfexKsOeT5gq3EV6ty5RGRzhzVLIUKwjTo4bs
+7+/fvn377t27N2/erGFzubAoPLuuEwnTSXvnzu50UyabeuMO77wq89O+kXkDmnYWZzAVNLAONocI
+qGAURCIa0DP0EAOICJ2bKDfBm7GbzDqeAmeUubB3yYgf4mWs+bTMT/mipNdVa23b3rt797XXXqO1
+ARNhY2YKNVFjnpDFCz0MZL253bt3b2dnx1egj71M7/JtWtOa1rSm3yf9rrYhWsYezBhsjMLGPNVn
+pRfJHCsAU6PMukgGdhyZJl6ne1wa0aoO2dLH1XWXY4nXbd1x8YvLfs3hGdYIbZlijCTffPPNt99+
+G5nlvY5EuWZPqdbHyGnz4O23mklb5X32db4g3qm09DkvWskj7yZQiNs74Y/vvvonO6/vzNpmxsaD
+haiXpFQM23IXa0GSQdno3Ve3N3bwzeYbt+/cOT/vo4ICwwzSEUJriNYNpUhzePbTn/704OAAwPn5
++bL3Ts3nlek6Ozv78MMPj4+Pr563mjNu2/bu3bt7e3tN06Di9Z1f3N7enk6n+/v70+nUGW7LgSX3
+9/eLZk9E5vP5z3/+8w8//DCE8N577x0fH6Ni5UlOJpP79+/fvn17pdZlpL0xs77vT09Pnz59enJy
+UsOPETgZVdU0ze3bt/f29jY3N2tUc0Wjqnp4eFjSGLxQLuBoc2tra29v7+bNm03TXC1QKCjl4uJi
+f3//+fPn8/n86sKl223b+nCm0+mIax/p+mr8dnJy8vHHH5+enjqICiHs7++///77s9nssnbbtt3b
+27t9+/bGxgYqiDhqq15vZvbs2bMnT55cx/7WzE5PT/f397/97W9///vfn06ny7NaJAJd1zVNCEG2
+t7fuP9jb3Z6+8c29ze2dONsU3RC0DroAJQKsITzoDkgjI02NiJQIMX/Cda64aZMb59PwOO5/NLdO
+5oY50BtgCFbxBZbEMEhWzGSOE2su0PEQjndu3vre9773+mvfoE3EGmFDEYNGRKvkniX4D0lVU12Q
+F+zs7Lz22mt1oMvlm7umNa1pTV8g2SXvx7Ri01oQfdWFssvusFdmXR3z+yIpQx3jvuzVtT5vqVdJ
+RF7/VHi+/I2x+n55hJmDLP9QAFFqsmLzViClusclDELu3eLV/seqXxY7tTj4HF9u+IFjCWM9CV7O
+gN/3ofKHCM+wRmg11aztrVu39vb22rb1b64QJNeMY7rcjIaosSO2b93SEEwtx+8WMNYPM8xKkA8g
+WHLDjMLo1tFqVOsmE9zd29rbnVx8fHB49hy9ac6rSIBVGsFBZL48QCPQhKbdvv1aq9PZbH5ycnx2
+3mmENFTrDL2QMBFpAFE1wpyb39zc/O53v/unf/qn8/ncdUojVFZPo/tQffzxx3/zN39zdHR0/Vsw
+mUzefvvtv/iLv3CmucAzD5gOYHd39/333y+BDczs5OTkRz/60Y9+9KOTk5PSE1U9Ojp6/PgxyY8/
+/vjGjRs1NCJ5+/btv/zLv/zWt75VbmI9kJUI7dGjR++99977779/tZFnTZubm9/+9rf//M///M6d
+OyNFzWXLqeu6n/70pz/4wQ+ePXvm6qAX4tsQwiuvvPLuu+9+61vfmkwmVyO0QgcHB//0T//0r//6
+r0dHRy8sDCCE0DTNd77znXfffffOnTuXjaJ8U3RZH3zwwd/93d99+OGHRcM5n88dul+mJ5xMJm+9
+9da7775769Ytq4wkR62Ue+rj/eEPf3h8fOz60suodK/rusPDw7Ozs1dfffX+/ftd19X42bIu3W99
+CI0Eto3cuHFjOp3cvLMpobG+pTVUCyTZmql3iiktNUATF7KQJuihMDZGi8G40e7uzaadPnv/2VNh
+r1F70oTZG7s6sMuBLO4nmpwAzKAKjWYAt7a2Hrz22o3dvYYbtACjUJRQ9FZnrM5nJFM4ogXb7LZt
+b9y4UXTLuZgBS+f9mta0pjV9sXSJ6udlKW+wC24muYGiVauLD1mSXqqVAtJWXphQy+i3RevEGnox
+v9a9pZUrrjk7CT1WlZTLxx0ckJ0BHi0zdbyaqS8l/YHCM6wR2jI5U/LkyZNnz56Vby5DI6g0DOVa
+F8XEGG3SvMF3bm89qK7N1tBLKmwABpqbQlEJMMnPzUyFaBqenBz+5Mc//OVPftbNekIKoABQLJTr
+AEYL40oIrb2xe/v7/M9vyoNf/vJX//ijf3z27FAVFKj1yRLbjAweF4Hg+fnpZDJ55513Hj582LZt
+13UF6ixTQbNmtrGx4TqQa047gBDCvXv3vvWtb21vb9cKNEdofd+7BqZWnhweHv785z//h3/4h/39
+/VFPXB364YcfjhKOi8j9+/ffeuutV155pe97Zhu50bjq2x1jfPTo0Y9//OMf//jHV2tpatrZ2VHV
+hw8f1o5YoyGPJqHrul/96lc/+MEPPvjgg2saOrZt+8Ybb9y8eXNvb28ymYwqHA2nzMCTJ0/+7d/+
+7e///u/39/ev05Dr0FT1/v37tsokcrkhn8+PPvrovffe+9nPfuYYm9lw9DLzV19Cd+/efeedd+7d
+u+dTt2zlWL93xO4q0yuGUN/lGOPp6elHH330y1/+0tWwANwytlaYM/kfsmma27dvgtzejh8+evTb
+33zczxBkImYwBaNZ5CCBJWDIMVONVGE0Qtmisdi3U7z5zr1bN5vJxgSkJ7c30ijJHWLBabxUWWed
+8SKpk2dnZ7/+9a8ff/RMMBFriGCAwZRaXDd8K0nMCFkyVpeRug721q1bbdvW86aqK5Jbr2lNa1rT
+74WM2a6oVlkV0LOSuOrDgsfVCgxT6dCQhWUo6rVRSdTXj3Rpq/oxKJo4KppATtFbAW6+uCChK4Wr
+kbGuI9tWDG4vttBmHkKJ9IHUnmEluFpkTocU2Om3dP3iPA7gdaGXi1XZ5dwDVk3hZ6M/XHiGNUJb
+phBCjPFXv/rVRx99dHFxUeBZXaaI8MsrFlVwNPR9N9nd+c8bzfaDO2TCZGY5PCAKBzZ6NgxmBvce
+IUBCTAUqNJldzD/+5PEvfvnL+XweQkPAcyEt6Kgv2bOooAVouHVr7zt/9s79+e3D589/8+vfPn78
+zAzRIkVFPPsTSfY9YFDVp08e7+7uvvnmm0Vz1bZtHWlwmRxQLUviX0hFd+Hqi8I7kkPK7FKnM9PO
+lM/n84uLi+s0gWwGWVos46q7UZq2KumCqhavthcSSbfGLOq+0a8rEZqPses6zwZ+nYZijEUFtGwK
+WFdeRoeMYF+2oZWwahkH1pPmF85ms77vS/lrroeCvkYYu67B10bxS7y6Qqvc8Gaz2SeffPKzn/1s
+f3//F7/4hc9GQWjF9c7MYtTpdPrNb35jY2N66/b8Jz/5lx/+8EcXZ13bbAig2ptFMhq10ocb2AuM
+gAJKiSY0aSyIYnd30yb/4/b91wnxJIdki8E0vzzRL5qlfMHh4eF77733bz/5d9FG0ARpVS2aIlTh
+QWzBYYHJGRbITnpvvPHG5ubma6+95gFU6hlb05rWtKYviiozgEvN95wuOQBWYRC3VFh1gVVvFgLv
+L7ZmLzhtLq12Zd/ysbHwZoBnlUwS48H4N0n+z8VqrwaN+XPFQGaYt3RlyUc3fh3X+GU6Mf6g4RnW
+CK1Q4e2cRbu4uDg4ODg7O2MVWwJVvIGalnVoMHRdt3F+dnpy0ve9qoUgFKqaydgC10ZvaEYzKEwI
+ApJyT5hIkKadTKZTx0YGI0SGh7KIZ1bsHDTCaGoyiaFFO2kn7SSEtmlag0E9eIaoOofKSRtUcXR0
+dHR0JCJN0zhw8vG66mklQ+yailHoy6upQItlmOEf3X/JgV+ZbWfK68gin45qXVm9DOpuXBHZ4uqa
+6wVzGdRHXkIjEPWyxGxfWle1Enle8c11WrliHupp9J7UNorlhl7dRA0PVkZnqUUkqJZNLSV5Yf2+
+jM2saZqu6/b39z0KTt3/or+dTCZ7e7f7vteoR0fPnz55fH42D6ElqdqRCkbAQVpRcvU0CBABpRgD
+NYQojYnqjfnswtElEMgWbAG1pJFb1edlca+lV1Pru+754eGTx48FE6oEmZhZNDUxg9a5r6vDeAC0
+fqc2NzdPT09HkpeXXfNrWtOa1vT50rB/1V9dAq4GKdcIN4wuMYxxBgAWS4WsPWONfbhg1LDcq5U9
+qlVWVUNDF8pBlsXrgx6PQ5dKfaXlorxiRmiofkJVVd3l6rryw1jHdflgBhUAs70Y65/rSgbguTz0
+Sxv4HPHdHzo8wxqhLVNh9dq29eS2NU9ZO2msJLp5koejmE6bJtkLCT0DNX0NLuwjwPApVa6O0wAT
+QZAQGJJ2zQxCA2M0EWEQDPvJ0IsV4yLMokIhvTQKMTIQojGW5Gp935OuPUDbNPN59+zZ06dPn+7u
+7noIClcp1BjgMju6EdZ6qckfXVgjpcJ/14jupZooddbpzkadX1Y31Y2+VCvI7G/ROl62fkrsk1E3
+rt+oj2WEV5dbLAqu61deOuZ6qqtR0LKGuQz/+gMpyNwuMQ29JgRdprpA27YbGxt37959+PDhfD5n
+RQBcHOB6Wtcb58stNDKZBgASoCr56St5YPxzW04vUiANNQgpaqGV0FAIkqBYkp+QtvqEstHf/JG+
+ks2CsJ207aQN1poKjIQQgqZIbQBdFjenqXONd9M0vuNxMRHFGqStaU1r+sLpElD2aWkJp1QNVSFD
+hm2SV11zLbrq2hFmKl+MNn+m/nGxJCtNGkaqsCW6TLc2/IZkwLXQuqMuP9eLwccIKH556CsAz7BG
+aCOquU9XBLHK6VQXuw4j6NFBhEJKH3tVk1Yio6oKBza63guM5kmoDUoaqIwqNFJJg2mM876fqWkI
+A8tI2hX22LkVoyAIJKDr57PZTNWapm2aEC2CopbE/6pqxtlsvr9/8Pjx47OzM2RDtZJ5uSjTlke9
+8v01qXCEIzO2usJljvz6MONT9KoghOXWr0kjLDHq/8peXVMXtNzVus6VPanR5vWnrtZWXb9wjXaK
+4OOlmru6jGXz0U8xV6UGVZ1MJnt7e48fPz4/P+/7vsTZ90U+0gFmna2adSINJcA0xo6iEnywfkSK
+GkvaaVKAhp60mqbaq0YHV2qqUPNka2MQdSX5chKKiMFTqakRQgGoq0TGWHqm6tnAqiXqP32pjt41
+rWlNX3daVqkt0YsOBdZwxOrvM1eW5FvMmqwVDV+jVwv6LMvt+v8GDDEEQMIG28vE1XH4V/V33Fit
+Q8Pq+agvXrDYvPyyAcvZwiylueHAuq5o5XPUhr0sfTXgGdYIbUSFTVlWDb08F2iqznIlYYaIRFOP
+cE0WSJVWf2oqqXkVUCNgPShAD4tABE3RGT2kh+Yoa4bF8CBZiFIT876j6rEam5YSTKGuqaDzkQBA
+ipk9f/78o48ePT98XvKPFY3ip2OIr0MrZ768/x01+july7p9zUX1skMu4R+vwEI1cPqd0nJDLzuc
+GrGXj3U9nwJt1uQSh+l0eufOnT/6oz+az+cHBwdWBfcvN4ikSBAJnt/OrI/WC6lqHiOEJEGap4gm
+IQIXw5j7YiuNpl4IULXeEA0RVGM09ibK9ERfd2oM6Vg2g1qyfTazIA2SpfGLD8oCof1J/4xCljWt
+aU1r+kOgQYRVDPK+ID2Qjd+krg2id2YM5iEMirVG6fNiEJXrDOOKo6GAwpX9tEs+flnoKwPPsEZo
+y2RLblS1+LzWD1xt6EUyRy4wt5USEbPeYCKSA7GtfDLVtcig0XqgESIICDWoMVIgYmYR0OpBKq92
+2TNjgBpUo8F9qyxqhJkIosElNyIkJcbu6OjoYP/Ak2UVs8bLDdWSU0w1A2N3u+uQFXY8C5m8WzWj
+7BMKzzjFKqvHC3Hjil+XwKzj5cz+4vPbsMkCJzDUfXl/PwVvPOjQBkPHcvAs9QMvd5NqdLSk3hxp
+APOB96lMQ+t6rvjsaMS78Okwp1UZ1Tc3N+/fv7+/v392djabzby5AvxEiiLdN4eopoQaott7CIUE
+lGkBg26LXM4wA0x7NxR13XgKIOLiGEYwGpSgh2G8Vu/B+pAlSAr40hNew901JFvTmtb05aMFW76V
+zlULZCvejXVOA+uQTQed7VhuJO3kS3vj9VVWKDXYwNt4tYnlqNBiucDcACN9J2NFWcFRo9bHzNho
+tkrwxcyFjMJUDrzXKiqobAGeLdZgS3Velz778fNVgmdYI7QRXYfJGxmt1WRZ9euZYeuSBN1yN31p
+tuhgmXwuhRZhBihEkmDe6CGzBQozCBiyWrl6EtNjZVi5laRvFKYwwEwtmvWG6J6eNA9sJO6ZdnJ8
+cnBwcHFxXnYRptgJHjGlzklYbLZHLONlPbmaPFRCDrdQeP1clVU7CwhPRqDw2Corw+deRkyREowp
+ku+wSRb4xIX66ENduSde2ghpIgZENXcsHLYu2hBMr+Dr6r6i0pG+YCSlluL3lKaJw5oopIC6jd21
+xpBoEZVZbsUWy3gBJCRaPx8vB5/ydDAfnWkihvufsE3WIRUd8fWXQNbLufCFm5ub9+8/ODk5e/L0
+mcZYzjk1lUEykC0ejSkWYoLznlFmLHocDrFy0/3+lrD5ntga6Sl37duIqRjWC5jiDFlxBCCY77bZ
+CnGGVd25ZGo+nUntmta0pjX9vugljvaXoYGDcqGmLvg8L5YcnWgvQZd0vhzzK2WRtnBuu5UUnc8y
+WwzbOD5cLZ9G5WNV9eg8GF3KxfNqZY+Xebwvy9nxFYNnWCO0lVRYlsK1lEDe9etqnmZx2WeWzTUX
+RlBcxM76uckoCCaAQRVUBpebJGgHBWEQQ2MWTFUyL5i54pFkZUSW2ToQARCYGaJHD0gpAEAAsdeT
+k5PHnzw5ev5cNRY2cuBkqyDdqWYrcY+s8qu94tG9erc1OvAaCmdu2X+uJERmVkLVDTP/ou3CykxA
+RtkJ3AacVhI/JvTGchtLlxYGsiSEsuo9TGGKaFlExyyu86IZ+ljCnNXsVtawpe8rh5TAiSCjo/I9
+uXgGmKMOu+ru+OtqfWm17C/bxjmgjyQ6SPaziz0eNbowZaiuHVbUAjxLEkYz4VhoOGoLi2tyIM/X
+YGZRlSHs3bt3cnpxft4dHR35MEB1dF2fRnkGhCAoiz0vnU/L0QgzMZQYrqLUIg0g4GIRevyfDKqH
+0RQ1JXIYIWbJqgmNrDBdBon+dNuwPaTOrQ4tXdopQqWRjvT3YBC7pjWtaU1X0qIEtVCRjJVT7uXw
+whCQkNUxzxLB0WssR8AVe+ESTlpsJH9lBjKleKt5j7zpXlYHs9lIFpAy54hbkJRmjqQ+puszuz5F
+FqSaHB0YuUDukC2eKFcAudzBS379HdFXD55hjdBqWlB5rWJKRl+u0qElqLCSPUTiyzIHzHEZf/gy
+L+vRepLZcdkeDJLU3YnVr+DC1YyUAQgwwhpYYxbSP5VkMEXAMJvNnj3bf/LkiWf9Gng1z6pbWUIP
+D31GGRXacJyxEivisueagKSQKBRLXLfvEEOoykVWNJkl1GBwqe5VNzIHZckBM4ed1+C9sOxQ5I0Z
+Y572Ua0L7PTKYXkOYvUOMyua0q1EnraM2alIWYYHdd1itPRLmklIUuvTgICrP6sYwa6JgSASkUsw
+LKt4sQrs5nuaM06m3uWpZ4YRHMA6aSZqtGxRP0bcWJrAFGEYJXRO6nfuW3oQUBCN64Br9ePyVJGo
+PLKdhBBAzB3EyO2tnVdeefXw4Pnp6VnXdSwYKls6Ly1pv6Esk13aZbkNqcTo3GUdfTUp0iB5Vi2v
+5XxA1if5Ql5slhJDXavvXe6u13z5gq0FT2tstqY1relLQldvRp9lq3KmK4ti6y8t78aJT1iCMZ+u
+tYWzarxZFy6hlPbGPZ5U2fbrCharyLLMgW24Xq+uGNcC/1X/LeD1iz0qvpLwDGuE9uWgsrZt/I2V
+CEKjkljky67ThpjvNtbAGliANYDjNAUiKX3fHx8fHRzsn5yc1LmJEzuZzPQqNc8Aw6T0qainLkdo
+K7tHAcQQDGKQLF3ybSMOigWjcUEiZOQQzHIFY3oVLwozRgJJX2QApcAIo49bXJ8KCDGocbDqtuXp
+Yt4cCYhZgOstS1GaWQ4kUWOn9HFBGFiLwi6fTT88YkZoRSqWOfYKiQlMgACVytpuVYVliBz6XYCx
+QZLyxgUL6ry95NPD58pz8BHKKzDB8rKGEUqoJHtXlzoWzErzHNAQ+DqjG7levdy4NIUpawVAkQCo
+CG/sbt+7u3dyfHR4eNB1vQQUicniPxvGPh7Bi8d4WZGMeF/imjWtaU0OU9r6AAAgAElEQVRr+mpT
+RlDILEb9U0I71WZ5lXpnJbNV5FvVFm85TseC9DefIoMfwQqyKz8OwrTVLASLMH90kbMmlLECIR0b
+o4CKC8LsBT6CFYDLc4ssj75sNAuMApEYvcXZWerxcjUvoE8nEvyqwjOsEdp16HMTJL+AfaypYIAS
+M6M8sTWPuCiYr2JpLNeffOAGWEcmjjflyVXV8/PTJ08e7+8fdF3nRp4JaaXUhAZFAkMctCjFti73
+oTz4Mn5mOWwYidKlCQACUikJh4moIAJLMFqChBt6OS6QPFKrLl1F5galJjApuh1HZGmXMqPQwKon
+WUllZRBSiZ1sKAYMRqdCE7FAC0HHG6Cle5H/YjAuL8DJUJ08FfM+vsf0EIHEoG3xk6wYatTGeO70
+lB2PX0BjBFIQZKwBsc8aIbWsjQZACYXpyCWqbnbksAYIjKZZouCSAkliRNezQjzaht+rbPGbPLFW
+3nmzelX4q5IKqFn0PNVAP91oHrx2d96ddd3586NDNUe24TK9+ufqvfX51HUFkrcRb7OmNa1pTX9o
+VHM/rL78dJWwPsgWlVdJivvCXEYvpgrg5DM/0UL60oE3s+QbT5hbFTlD4o4m2RzdvVQWbal+p3QZ
+9vwCdWi/O3hW1/xF0RqhXUWjqOXjcIIrqWZCmT35R78t8dcFgKRNwQsYICSEFNaSjkpkUaIajjq5
+UHsagjI1EIEI9CIqjMJo7AGLGg+fHz59+uz8/EyX8jL5VCht6TkMQxEYqAnmmJmN4eICk1zGnlhr
+mitNhCqMSW9ltYPdwmQNiJW5FlS1v0BjI2ZUo2qTB1S0dGYq1Ax1aCUWhSOCqvHcRr07+c1z3aLQ
+IMZgbJWqxUjPABgRActxOx2gkaAa1KAkJIV1ecFwHAkLEIxNZOP25WWpDZA8k0IFArSGFmgAWXQ5
+G8FAy0AuRb8BqWnmU4wZEA5XDRbH8UGoRCwNXLKLXzY8y1aYlpAelQADKJaOJgUMGk170+jhFC/x
+FVjSFtIo1jQG9vB4+LAQ5MbNrVfv3z46fnZ28Xw260SEDNkoFnkPKOeq5fgoS0KWq9ZgEs3a8G+5
+f5dOilUi1UVRrH8unnKXoNVRfWbDMD5HgdSa1rSmNX0eNIJhI3h2JUgrV4wpV5IwGqste4nrqISb
+l+CsS1r38m52ZKVQCk5WfQNngLwzRWxrHrdbRIOYJHmxpPDFRlOqEoBUQfn9wtEpXsvN69OjcJUv
+vedb5oSKGegLJgIYppFXlnsZNPzVhmdYI7Tr05UaqpUXDM9FZscSN7bKYd+fkuztAuaYAUmbklrP
+Oq1RQytrXEE0QzR0+V/PoNJo7NRMz85O9vefnp+f1vDMo39oUl8gCXQkP/XJ3lEW2hhSqy3znEWT
+k78vbdGMUGqkRsSImBzyPFJepaJyNFeNyAyqUMO1sj/laghQIDEhTCv7M6EEhgqlNK5LQyr4qW60
+HB8u2/K46iYJa6TAHQYAHojFsvWeOZxrIGJSg9OsfRthp4X3BlE0hkaHg6OCsHX/GNXE0BgaG4xR
+l+dtUUDm4WpMaZFUQ16fdSSPLNUrESYMVAgopRej3by4lhVK80VRukI1Y7EUxVTyEwKoimlAbGBq
+JjCoe/ddd48nQDJI6GOEGgQ0Feruzva9u7cPD5518xkRaCHFTmRJoFH6/6JAiKuXZGELBo90//wy
+x5OlkDol3E0SVhSZheYvr+5MGsiqBgYUuKY1rWlNX1p62T2K1VFdy1iHEjYcvdUVL0uGylllwT0/
+Mz+WYsdJjsxLI0QpJgIJGhptgjViAoPRTJIjs4pq8qmQxAa6/eWSJUn+bJ9tL6+w8KeYic+bvvLw
+DGuEdjXVpk0vhdAqXJawWfbdopliQblUxBh+jT9CZsmIrlYOEaU/dQ0culf3fEWv3AosKUJSUiZP
+9zSb9c+fP3/+/HmMUQQ57VmOacmU+AkUSNaj0dwerR5IGThFSTVTklXUkILl5tVVGZaWy6UEt0hT
+UWmC8jDdRZUGsRS1XjLjvKwEwgIEBhnJCEaK28tVtyFNCwgILbeuOaZ/AchX8eQpMi4U1lN7RhV1
+uZaZ5g3bjFqEXR6UT1REg2gIxmAsNoMG08tlganRvG9LiUvBbFK6eJEYRCjlQHCJXQF6l1SeXi0K
+LQBqmpJBIEeUKifaIBwkCDERBDGJl0xaxhaVXIBDpBSaQ2iKJRMPMxdgmJkGqGhshEowup6Lize8
+bnIk2hBVcZRHkNIwiSPixsb27Vv3buzun5zMY++zmESYLr9clKquGJWLLxKWzN2tnnKrYrdkUUS+
+bOUtWE0Zog0CUlM1FYZ0x2ALk27DPbhiKyuYcx2Cf01rWtOXh+rDIu2bQH5fxLi0ZTuKpd3OWCS/
+wyHpDMTCmVGsYvJvRVi8vIHWh3S97TK5fCe45kCM2XfeByUIovmwAMQYtBGTNoa2b5s4EWsARmrP
+XiVGMWWMJCMCktFSoKTQZFfu3KWfC9xn1eEFMDZgyoU6sg3mVU286Iflu3JdCPl1gGdYI7SaVoKc
+mlkZ2TeutgsaEERRnWUd2FIgAOTPJfyalWe4pL4ASYibHtdpABYaXfyY95gKlRRLqoSUyGDKGL0m
+6br+6Oj44mIWNXt5kYCY++HQw92ZpOB6JfS3YkG/lfhBKfIgAKBQPBIkEfKWmhCaVMIdFw8RJqb+
+hijjqvT2yfwQmmfWoOXL0o9cuOzhKZ4EzEzE/ymZ8gkg5EC7ljMI0xDNogFCKt3wkNnmEZdScWuz
+pNzroT2VpiiuxwlAuaF52rHFKBbElEqaCMSgDhkJpLwIeYWNQKg3KNAAjRpJEckzpmMQTKAVBJqY
+CnKkyPx/cceu68+vBo00FUSmtASSu5IRGiWN3YykiIjb0MMB59LRkXpWz6mQwShqVHWTyhyt37Kv
+nsLgWFFVlZRABhFmmQKydcnSrWLWwrl8IQCtWTD18JMWo6ohhGZ39/a9ew+Oj2dHR8eqboHqtVEo
+zBFlmNO418KcxdtShpy/t/yf1ZP3ErTAjmSmRcTHDroTpS1iMyzAs/rQrdOK1Hta+d7MAta0pjWt
+6ctEyzKmEgXxhfgsc0cAshWLszWFzahPDq4GZKv6lN/Ue69hrNUyZFFmMq0xEQ2NBslxiUMMTWzE
+ZNKHST9t4kTQgOzQd9L10lkwDdGdJ8w8IhlJBBUkpZylU211Ry/jYxZPqxVXDjNXhrwSw106N5+Z
+fj/w7G//z7/9wtHaGqGtIMtUg6Ly03XUaEWnkGTb9KjcChQ+riA2ZPvBktUpySUyqMo7TmKZtGYG
+yXHW4HFHBoVC6n+MMBWzhmhMHQ3Z6enZ0dFpNzdYW8WWINA7j9+2IgJDb1bx8AmxcvjoPRZk2JTC
+FQpgWQtR7wuSdwIDSAaCBo2auN4EmYpeBMP2kdQjYmZDcq9FYJEkSY4NDTBzuzt6AI8krlIgDODH
+DLTAYPBuuMORQHWwRvRBsWoqwZwCoMrkpOgsaqoxCoNIgGNAMChJKCNoZoO1G5CGZCmXcZ7aBEQX
+b3iJcZgkar2JARYd2ptD2bGNoVGMqhZTnTb4oRVQU4nZCIgfJUKY9aodjIbgswcgO5o5R08zU1UR
+CCVHxsfSKVW3WT9TBDwGJNSGhARw3z0jQAFNe2NUMlpMvppNIyI5k/Vl5L8yz7I/UACppoDFpHeU
+6cbm3r17z/YPTk5PFK47VeYUGNncMd22JV1TksikxxiWgu1kvfDCae+Gz5YB1GW7yyLnUNT7rhG3
+YauBo8ecH2DJJWGE74ZuDkOopVEOsy+fzzWtaU1r+j1SBRDc2KYSwy7jh6vJhoBd44uGTZrlf1v8
+wquo06bUx2b6bgEiDUVZMW8GGoM2TWyCJSv9JjaO0FpHaH0TrDFKJ3He9LNmHmgxRDUEWFQVQ2Ni
+AASizKLThX6PRrcMOi9hJWv8lWe8mpv6gy1+HCpmuviz0+8Nnn2ONX9qWiO0MdXgx9+M7BuXLX8K
+Q7MoV8jlyy82MOA2wLPR08vBSKvoiMwMaqZRLcZIMASxqAMHyFo6jpJU2krFeWcpWn1nTwGo2tnZ
+2f6zw9OTCzMRaWAeVp5ZUdD7AM2iWkwgx7uZjQZT5ZY0EwThGaZSNl4DlCBSXL56ArUauEdY9HRb
+no6sQIrh7ljhPSHiMVQs7wDV1pF2yhq5OeDzHcZMoIII9KUgcjIxM/GNV0C6ibfDTffWzZH967Y4
+dDaH2rekChOKpEkRKMx1PkZRIcxEVBRAr2YSNVgMGkWVGpEwXHJILPBs6SiBAMIUyYK+WpJRLIre
+KQ3TdY5Rocq4wkQhI8zcjsMzURjJpglBoBZBKcaNWRpnRrOsYzW3EqWAkZJihSwvehv9BQA1U7Mc
+Zz8FKTEg+nFK196ZKkxJFfEcCZ3rHK8SWCDfHy/j5qxJ8BE1CikhGEwpBLa3t+/cvfPs4Nnx8akh
+euDH/DRRJIDQwe1uhcqK6anQvEQ8skniKPwBwaD/varnw/Iuzn9kUueRamZqqupemxqjGSgco/nB
+aTDf6UotLyIOxmpNWoGCa1rTmtb0JaHFw/dLTqv3dtIzmBqMQaXpw6RvGw3OpTlCo0kTm3Y+DV0j
+1kA4D3E+iedxJtH60EHZiDaxpbLVAINEEGGRTXjB4fIHRF8reIY1Qlum2kCrfCy/qq4QzzuLswDt
+XLNj6jWoqplRnGFLMvVlAQYX/yTvFSD5QAGwwUNs2TCpqsZWPZCOoOiIAYyGXoL1cf5s/+mTJ09n
+8xkpQrhpn8O4ZMeoCV4KIMHMomqlKmJh64lkrQfrY1AVkBQzNaqhByIX+xXrrcOoJmQgG0XICYiH
+8UlCP65uUNLhXwA8EMUQ06OSZWXlDYvdlwevjRIU0hs7gyo8iqJ3h1FJIAQxNVNTczfcwd8t1Z0G
+PwjhfEIq1akQhMIMIhJENKoH1QTN2MPgroCe/EuEPboL6TvRKDCYqRIEG8ujgCksI50kiAs0IURS
+7oGkYaRVkCgtFV9Hlo05pHRyWdMyWp/JGtP9sNR1nh5qMaMdd1kuFQkFaqrUmSAGaEwCywWEUCpf
+bCgCUahDQm3190qXAKgjtYmBSqU0qhYhEaIIfjeWBYe28AekiAShmJpGUwWFFHFlt5k2YXp3796z
+ZwfHJ2fzvjOaL5I89wKaRluwPa4mzeBOh2q+9NK2kAQZOTWCDVaQWAJ5Y7LqScvYKd9ix+7MHpwi
+YkS0bMbrK9TvfmpECwATEVWt1WXXNBZY05rWtKYvhCojggV6Ge/ZS6GLDQVG5V+Wyv68eAA5G5hk
+dwwxNF3TXDRtHzxGSNDQxEYgIYbmvAnzNmBigTPpz5pZ0zRgjDKnSMu+YRtiaNl4OprkEmO1Pxqx
+4DK2LOh94Si+ePq6wTOsEVpNVhGy/BgZgJUC16sKLpbX6DoiTTWoWgqwwFXaECR2PylpnMsWkiJB
+pBG61R1Vs3MZMmJZqCHtAdlSaUgjnMIcsAc7SgTj6dnx06dPTs5ODL2IGGIK8c7M6Hs2KO3FekVH
+M5jmcCF5e2RO4AgTMoBALzoTKFJID2SVyKKmO+WhomcmM4bI0FPmBjVjEPdryopIE+8TjKCSwqAS
+IIFsKIGaOd+ML5FHDdB55aSJEFPGjn0follUAohgB4AIJhAKJMReFdaGBiIWojF6Rq4cBz+HBMlm
+ghwmxHutSu2k76WHmZLWqDIqPd2zElAT1zAqAWEfY9+oBjOBqEhqBlVEFGUZl5EmwVqJIXTSxLYN
+E43RV1bW69JqOA8DMImTSZw0fdtoG7SVVaeUe92Z6xXp3nuwWeTcJtqkFVUFqyznUAHtriOaaD/R
+fpp+XQBxC4s+U0s0aq1pC5241aGBUGatGiFmoLQWplHNTGENAXAKTo2THHx0JdVQsCUm5ERkIkKJ
+mrCTJwiEEXZj9979V8+fPnt+cnYUo+ZHCA7qJLA8fVl0svhQJ8NlQ1mVLnTAsJ9Um44NbugjVeNo
+jkrdRjNEVdWoqoPSzqi+2hdwqtXVFFGUi5BciuSvQ5trkLamNa3py0qfz/bEbJ7wu6MkOCu7usHc
+AgQgxEIT23beNGdNcxFClGASojTWEEINch7CvG0xQZALzk+ac23M0EXOAmQiGy03ApopJwI2Gho3
+21kwvPiD16F9DeEZ1gitUI3BzCyEMJ1Ou64jGUJw3gWrWJbBxLHo0EACbd9Od3c2NqaSUwyaWkRE
+QBJUpxhBgxQna168kvKtqWrf913fBcjGdLq1td1TYB5GYhwjJGO8LG4nEmdv9ExbGxttjPO+uwhB
++zg7OHx6dPzcLJJICRBLaHQDgQA0vIj9AWyTmEO1CRShWvR8vkkp43Ec6Dq6EGPsdN9wSvaAuj7f
+PVcXJDlswRLwXbRt56GZNU2zsRFZovxb0VNlCz51l6Mo4UJwIYziUd0rXV42hswJzRSBFDpKjK2c
+B7tobCYwqFGBDuwIA0TVCBE21poZTazv4gmPz+S0n/bJPtQS3qnTgdQAEYZuOj+bnl1sXfQ3u77v
++tgxpQ1TpRqNJqINNDgz3bCRXpqmEWGjaGOzYU2OUBEsxVmpkz8TYKPtTr+1Pd+60e1uNptRY4xR
+KAtxKIYlRhATTC5m5zfmu7v9zgwXllyKF4BNwpgJ6yrQNMatebPTb9zSTdOejJSsChouIgDn+EMI
+jfCG2m4fd9WmKYdBrdMpDQ20a9hVvam8I82d0GivhHmGB5oaCAYDIkPfs7OgoTWZnHdR5xva78C6
+nMagWmYr3pqhhe1a3KHttpNpDOi6XhUiQlACSRPRBw82nh/Hjz7+tYRNNTGwadvpdAqimTQZchWZ
+Tt0SqUaYMmrSbjKoiMbNja1J21Zad0BIvwmrOo1SbhCLugG0AiZCa2Rjc2NzczNgGjhtQtP3XbTe
+hDosA+bZzmr+7GrrwGw6ndbmAOXXpX6saU1rWtMXQ7WVwiUFrr9llWj6XPx2LPZebDKdqNdtxkX8
+hT1MNdGDIQZIA2n6IOeiB9ofq83FoxSnHVjDvGsoYXu6wylOcc54cBJb1U4xC5CpbbS6ObHplm6K
+YcIwEQn0nKFD5BMO/b9O368uwMwg1BYgS7rM+l68rNJukb6e8AxrhDYit/PZ2Nh466233nrrrYLQ
+SoGR8c/IYSO9T9F1LGxN33jn7XbS0HkiUiSYmKqKxyFHAjfAyPrPeSkPe5/QEgW379z67rvf+8b9
+19F1KNJuYhGkOUJLqg9PzpyDW6hqt7k5/eM/fuuVu7dmF/feevPWb95vz08ns3nIsMZSgEUDDAE6
+kfj6w25765Od7QD0hp40CQIqPAh/Vo84CIvqmaVkc/fp/dfmF7NpZ01nobM2YqLSmhD4lfd15+E3
+k8pNxIJMt7a7W7cO20k3mTCIpVAeyVQr86dK2KRpNUaqXmxu2Z27k4ev79y87fgN5XXYe5myjEgk
+FI3Iq7cPNvWRHPXtRbQOjEBP9snsAKBR2AgEJmoWQ394+6h/PcqRyEySXq5kUy5KqkF/ZzBgG2ev
+nj7e+cSmqm0ftadAQjJVjAG00MSWUQgT5UY3mZxPqPH2ZBfTe7vzzR3dasyRJ2HBQKPmsJzJ5rBp
+Jg/xcO/oxvRRmG40sCZqrBetnwRFiqaqILf3p/dP996yN+6EHYOpqQ3jcZFb9ACSBM0ixTaCvNbd
+vHmA7fbc9AJwNawj8BIOy40Ek/QgNOHO8enrEeeUTnKUmfTgFKNAVj6KeEuaXWlePZ9vP97fiAL1
+BDCWbW1hFAUjmrlNTDbOZfuUPNNJd77X2BsNdhT9ktFmOYSL8MEErdlrs9ndp/ubbdOAoevUlCKN
+pbwSUTHv4629O9+6s/fmm2/cvn//Gzvb0z/9zv+ws3Oj7ztmKF49/nW74grnCFUxo5ASNATttzab
+t955MJ025iFihFLqsBXiXDLlM0+xRJPGTU3VVAHs7e39xX/6Tw/uvgltJ81WE4JqVPQqlc46TXm2
+jbUBgzlau3nz5uuvv962ba1GexmToTWtaU1r+j1RRglf3goX664o5/d02X6wpokBp+iezrunGi6k
+iaFXd193l3lyT3b3bs42Lh7rs7PZLMxoOld2wTi16SRub+jWTdttIducRrSW0ghZlhlfX412mex0
+iT4b6Lo+fW3hGdYIrSbnRWKMJB8+fPjw4cOtrS2SMXpQv0Ex4zSCarVVdGLy2yC7m8cSs8ZFRaiE
+uSqg1HNpfwgEDyHoUvMbN3bv/Ic/ad5+ZyJBuxhjRIoIVFfmmrkc9w/MUcUNUNU+BLtxY7Ix6Ztv
+7P63//bOW293J6fPVOcICncVEwPMfbMCNOhs98b0zTe7GzeeGJJCjCJgdDekSgNIDy6i1oCTN9/c
+enj/O4fH1smtw/nu49Pt4273grsdWuD/8Iv+y//2v0sIIBgcPNm9V1+9ePW1WRA34nP+Mha7TZip
+kQih0djT0GzfeuV//v67D94QMJAZngE5KkZCagJjJGNoVEN3bs+f3bUfnP9LJ89VZj6WkoWLZo5/
+haSJmQnk/Oa5vou737hnHhwCyZfQtU+ppaylUNfETgIe2M83f/ars18YFIS/Jj2egBZCbIPCTKd9
+c3N+89bRrV77t+/80WT+9t753s75ZhNhEgUWEAiJ4haWAu+EkZRt7tz+9ebp4bMzHvj9EJF6XUnZ
+n/O3seveeHZvsvG9btoBiLE3RAwqIUWaRxGKCJpGBae39sPx//2T+eTC7MQwA+dgl0ctHlpTLYoI
+hRo1BJnN52+dz25tbYFCERQnzbxi4DOJQ+/Y93d2m6a59cEH+3/738+mG2YGNbGU8tuACFGyZzuT
+7efY/e3F1qNue7bxyvuf6Hz+jYk8cD+2/FBYkjuk0Q+SlBDk8GD3v/9fj3/8z12M0UzMLU3ZpICI
+7FVnEvo7e+1//I9vvHL3nTu3XplO9e1vhjffeLNpfNKW/LVSU2IQmktZtKcpSUijIhonE924gWP7
+JLpp5WU7wHhDcK1XwcICMGrs+tnOne3vfvd7f/J2FJs2MoUZqNH6aCn/AVD8OpE099mhsvieicjO
+zk7btn3fN836aFjTmtb0ZaJFRifJoj+32otT+WCIOG5+JIW7Jo0dWui+8IW/CSahDzxF96SLH3Vy
+xtCLuCuJACYQYBO7r9/QTRx3J7PzGS8MNlf2jbG16VS3t2y3t34ztLdlR2VDsyeGS/H5cnCqTMQL
+LxksdYqFxlJVn4m+zvAMa4RWqPL1R4zx6dOnZ2dnk8kEQNd1IuK2jiNXtMtMgGhQVUyaV775xuTe
+TSkCdtetMDn0exX+g//uXyUFCYQQETDHlL84Pzv66MnFwUmIon1UR1Ec6d/ETRwpJe5ccCUEaKr9
+1pRvvnn79u3Y97+998rRvfsbIewKT8C5IZIeXz51QECLLdA37QdNI5m3S0mp6IHLncf2YAhpz2lN
+m1fv4PVXw4VuHnPvo9mDfz+48/j83jEfzLld+vrgL/+ruzuRVNIMITSHTVMmCtVzn5x+COREHwQE
+lK2bD15/S5gyRQ8X5FoMHnqwM8wZOm2OD+e/enT4L8/nv4jtvoZzUAGTFEXDTUMTDBOjwYSiE+t2
+IjQIkKKslxPCdMEYs6jRiKNwdBpOkl7PbdFzPBMjaBQECAmdcHJnfudef3+HW/c3Xrk7ufPq/MEu
+dzeahuzM5hKNlnSjKVynAYQwhFloHgV82JlmwFCHgCd1QGgkKWRLe9Dv3cMtR/IaHGyruTItXRvM
+hEZhbDAL8rR//kn39Lcz/YQ8Ai8MM0pPAgiwgOxmljK9wYxsQ3ir795sJ5adEGNqyOjGr4vP0J8J
+oDE8fdIeHqjbaiblj9vJ+j2RyI2LcPtI7n54svvTi9sHzeTUdubzb/rTIDnQSdakWj6oIJW2+/QU
+//4zETlWjQaaBTIQDSkiZugVF02Y3bjRXZzq3u079/Zu7e7Yo0cfP3n2KDR+KyBBNKoLDoaxmKg1
+YhQxA3rESArYmLCPk6k9+KNbkzu9Py/FqXS0m9QfLSO0/BCkZeaY8/Ts9IP3Hx88ORdMBe6VpwoP
+6diUClKskrR2pexmPiMbGxuvv/76dDqdTqfI0qi1leOa1rSmrzhxydZxDNA+qylBbQ6ICp4RFAtN
+DPFc50/n8w8veELpycGbQTAVvW87WzfONy+O5scHZwecK6wz9gHS6mSKnW27MOpNbs3CPDK637br
+0Phyvb9ecS5/Gp1Xn8PB8TWHZ1gjtJU0m81+85vfPHnyZDabiWRr4Ms5lWVDIBr6vp/sbP3Ff/n+
+f9j9HgBXyCTLIhmv5yHLMasIIpYUckxRtfn8+eGP/vEff/WTn8eLThAq4YVVLYNQirHw6BY8DKGa
+Rp3dvTP9X//rdze3bsb+t8CvNzcOpxtHk+aMMndfLLAnjSZAIEy1U+tTb3KkkcxSamYVswOWERBD
+AxUqNzYnG7wBTA+7vSDozpoL257h5jDVd+6ABXsl1KHFerPoJBd2TysBHl1nxgm4hZitv1AL1ooB
+OA3sTWYqM210Ftuj/mL//Llu7ms4M0YYmGJw5NHltGfJxnDozliY565l+TZYUrD5jBnNhiASyMEb
+Bq2OB0gnJv2EPTea7U2ZbnH3drx1t7t7Y767hVbY9TpH7N1XLK0I7xcZQnAvR419Sg23mKHL8xcU
+O0zHaOKBO+FayRJr1CPdR5jBAtB4sjjKPMxPJJz1fTg/v+jiMeU5eEHOwZgUMhYsKZOBHDmTwhAa
+EVrWSTqYV83xTpjUdqW3r8y78kylfHAGMU/jSaOoiEqYsdOwOWnULpp+tnU237rgTcUkiVoGm47F
+3M3MN4D+kOp8niL7qxIMhJABoAiDWLRzCeexO/zZTx8/ePD+N75x99VX5J//+V/+8f/7+y6eh0AS
+oWkAj9uYb7KbsVjrgW0U1iPFh50gUOPOdvs//S9/9q0/fxhK7EQMhs6rj8ccXiTfUC/pcbtk/9n+
+//v//P3P/+23DTcEIQSJ2ikU5BDcMpkMF9zF8iA5VHv11Ve//8uLM1cAACAASURBVP3vv/LKK1tb
+WyPwtqY1rWlNXyri4vtPC6E4+lvRiip56YermxhOoMyeMMc/EzGRGGwGHFs8VB5DO9IZCgJgv9lj
+hja0bORMz4+65+yjoQMiKY1NJug72IZNzu28Z6/MWW+W9I55WMvxC4C02yf+sxJ3v2BqWb35rED2
+Evp6wjOsEVpNzATg5OTkk08+OTk5EZHy5UqXjBEHk9hgs77rN27snJ6cwqCq7uBCRvXU78kG0TO/
+l3gM5iBteIwtcfVCCqWf9c+eHnz4waN4MQ/SpHDezBoZb18UUBlUcwQE6Xnt1c7ms+b4ZC+EOJ0c
+G5437ZNGDoOcgz2kM87JjjSxAGsAkB2tLyNN4QVT4DktmwjhoRbFTAwN2IA0mUIA2zE960I3E53R
+ZtV0zUJI4x/CLCKHiU9bBXMAhQQFE+xE2hmkbCR1YuvyVdkYzQhlb4HasCO7Fn3U2HYxzBURGQMQ
+NPOMz0knNmSoy6moKv9Y78eAIG28FS+ocoD6i5Q7OSjFxAIu2nMNM6APyo1+sjWbbPTtJkJQ9irR
+oodyyS5LdK1UCEIKopkGj+9uiyvVBhO3rOGj575yNl1Vs2oXBtUcC9FjkzQQgsJ+JkEaAxSNKix6
+LFAiZoVwhu3VbRKBqDmANDAjNE2YLKO0ur/TPqKgZLcFUaOH4QSVohJUjOzn2jeAaEvbCNgSbEab
+KIawovVJkxdP8uVKYNrDbXhWDBAWss5WzDNxW4MYes6Oj48fPz55fnR+81ZzcPjsw0e/nc3O27Zx
+LzIU5WkyLXaU3DjAVFikawzZMojqjd2N46NvmoI5oV8x+4Qwa4krBsCTrrOMy+FvSW7PbtY/efzs
+ww8etbJJIARG7dQMIQWYAQAoEUE1gyfOQMZmKR0IeXZ2hryMi4sa1rSmNa3pa0Uv3PZeTnI1Ai8p
+TAhcZKoUFZsrzgxHZkewjrCBuVJVm1MQTDCzi9N4TOsNvSHCQkDbIiq4w80LXPTSm7mzumXhNGzc
+gd8V/S6a+ZrCMxJma4Q2UHEkCxU5m+JxFwofc9m1lfwcpuY1CJmskrI7GcxMFsBE4Z+TIRyMYJGu
+kxDXu5EhhLaZMBgJTSnWssLNqxAguSEVzVyK9GowQQzSkc/bdntj8yTG4yYch+YEODNEs949i0gz
+NIIWRrATxtLBFO2BlhNFJ1SZ0I0FUIBGGYBgtIiLiItos4guUiMtYniIYwp8UKpLk+mDyR+Tki0x
+riy2j8yAtkxjdWuKYi+rAoyMpNGUUIoKVRBFI0yhRhV61Mta1zC6R1llOKg7LOvd0h5omVvPPaho
+0UDWSE1puwKUSlX2hp6mNG0imohG0cJChGko011UeWnSPTOcAhqole409XABGZblKioUANSk8Eqo
+wq0vAJjjbQ9jgQCTQEZDm+piXrCD2SaQDByRMSkBMQVpKeYIAY8/UhY9i9LUqYlayz1omhwxjQA9
+7GY01wsbg8EIFVJAMZNY8tWV8WdtbL4JCz8SSfNqbm6brEJEVXoz08bYgpM+bpye4fSk72PDEJq2
+Ve2apiFF4XadkgJ1MlkXG8RDUIrnQhPCIKDANZjlfmR9VV5hZfEsqsYH6WuO1+/qQDPzVGYhSNM2
+jakKDUEEUAnwhIF5rEntjKYG0jFGM2uapmkad0u72mpgTWta05p+f3QJ189L3n+GKl9MCx5XvH41
+g6qJC2eSECIq2gtnxAVwQfQue9NkwDMhIwEqrWc/txnQWQqIJUTswIDJOS7m7JTRhXdwriyLjksH
+KpH2aFwDZ3OZXO7Fk/x5Q7SvKTxDugdrhHYp1XY+xRaovK6+JP8Zlr6z7EIQUSMEIiEt4mstdmdr
+CxvpxoqmpgIREUVh7rIrm5EIMGHKeJ2zkcHASHQSOpEjyiZlP/BQwnPwWHXuBYAOiGbG5PNCeHAT
+ZOXAguNQDo9hlnGBAgKqUdxATjFTdIouoo+IkYiUHLcPMcVYzDytD9uVEaxnYdgK86TkEhUOyhaX
+1b1AQXA0Iqc9tp4aqb1opEb26qElqKDH7KenPBs45KHSzMPntrJqpqCOwc1p+Y6WjCgGt0U3mkUF
+PYg+3WoUAjSwBnCY2xh18Knj0ERWfYl6fuusAxwBw8UZSWsBoFtMCpCighhSqgVn48WDy6ecLWSA
+mJqoNj74nMBL8mmAtExz7zL+Q8JgJaLkoMwDUnro0rUmLbM0QNLE8r02RgfDYCCDBwA1F0aQJkQg
+w8LgM+IZLQugNFOmKygIqDuywXzcjaA125jP5wcH88ePT197fQpOm3YS40XKE1FUYXnFVVa5NoD4
+hW4xL9wMjl90rLFCxGkBJFFF9thME0wKY4ygFiFPanFpzxltZYPlbZZVxRhRhRJZ05rWtKY1vSRV
+B0B+O4A0oxipZE90wByYC/qALIMDiJ7UdLL3iD3nig7oXbAIaAc2mM4w69mpuEfBiHnhQizHPxDh
+29cXnmVaI7QVNLDYWZBcJ3KtRctjtJb5pPph9A9Ro8bIiYiYahxKXf6oJA0SEg6CwdRi38fYJ0cb
+M0vx0KtNwGM/qoeqd/7PDApEUoNE4izG/dgTeBbCc8PzGM8Che7OVAREprAIc3tJIUxR2OisMXQ/
+IXP23DJgU1BJmrj/W09GiHouswjTasxKMU+x6wL+mgtdnNmkJGRyrs0TVPQO+c8iQiMFKWkblYyA
+EUqL1B6xRx8RlaqMzBH61fWD4nEqF++vZR1Z4Y8Tj6zZTagg6vTWhggQGUU7KIDrV8zMHNIaUAJ1
+OF4TICjEKMqgUKPvu6Sk3FkG1z8KJXWNFIjRslvUVYsrGSIaQaGZQh3fCyDuOOkRexUAQmBQxqii
+CkSBetBMwiQpkfJ6gxa4UtsTFjyS7lmGJVlvnChoUdh6IQvZJsSbiyoUmjAwBDbChmiQzPYaJtVf
+tXLSiFkLMvIbKxA/WwNGMwXE87R7d0Vi38/297tHH51+4+Bm30/UGqNIQ09ULRLg4e99IWvufPaA
+K8njDbCcCmLoXnIOtCV0bcNfB9/DrGYpAUVEjAlqq5kkKYJlsYfleiz55JWZrywCPIUd8v5WVn4R
+VK1pTWta0xdGlaDRBUj542dEG4XPGhiuTLVgtohjs5C1nBxc6NvlNLAmXGg1m947SOuByCxYFmcf
+qHQZpdGU2iMCPbJjhgLUvkPXw1MdWd1gYjcSf5VPgnGfAAzCwlXzU9VUrl0x8YvZYVfSF3SY/CHC
+M6wR2koqDmnOnbAiLHLty34ayQBPQHrI9ZQwNoQmNI0iRo3/P3vv2izJcVwJnuORVffefuBJkRAo
+caiRZmy12tXaftix/fk7f2DWZDtmI9sdPW0kUiRBEmj0fVWGn/3g4ZGRWVW3G2CTAMFyA25XZWVG
+RkRGuvvxV4Qe3E34OMNmOP7JcCZJpBUrkjzADjm+8UTbE7r71JSuI6gSh2J38+Gz+eDE58Ar4LaU
+OtmOLAIdoX8rXRwRntVUxCH0b1F82YMoWwkD9b2PSWfo/ZDguWHxAHHJVvePzF22By1+OW/xAQy5
+atsZG3mD8mFkACpbGUAzGeUQ5QEzTK1oAhyD4+wEfmZHgQ1woGHKVQbc0A3P84bDHaAwlXhz0Dw2
+z2JVgAS1bQNUHbUg6mpG5ppoUW2/T6V6gRlm1PkTckuJVeL5RoRmQF+nzEBrbsGMlTVEimEharvG
+WwxG26kMQ9AE+xNI/+1q8HkkbQtrwWCLP425qAI8CSGXIEAmmixrFhtRAqc5ymKgHO474OTNM+rH
+p+UADSpKR7S7Q89evfryn/7x1z/+sw8OhyvypvoXfphjx7xz0xzLT+0FzbXdiciaLclbwue9ekWG
+s7OnvfZJtB/6ihkheK2OtvWa1gJ1GH0CtwGkkYycWyQqiyOnh3ahC13oQt8cfcXy8W8kYZAa7Q7t
+Bw5HjsT8W3VBI+cdDqaprOU8EBWskWJhiwxt5mkCDKXFUQEPyOWmCofmg+YZs/dSYqd1l68Ej8YR
+/n4b6X5P4RkuCO0kedIGmwGLe+QMjQ4TZBUBIBLDyFpdRVF7ZGV8ae/pujH2f/N9I0KZazb6Ds9G
+NJGFRprVJCLLvAIzdDA+vHzBF8/nqbw23BIHM4BUjejEUPQK200t9hHDUrwASGCgDHYGuj/EAQca
+dwHYKnsnxHzqNW9aYqj0Os9+ee6HE+StjoK1AYRziFmW0tILsWTUZp7Pedsc1wPpz291sjb/5gBP
+U5tBKgpihFPRhZqbRns/a3myCYHzPu3QWxnzkOPGqMQTJAphhixqGdU1A6Llao3xh5dvVe/j1LM5
+aavj9vcVbLGjmYqS/Gy/hoeuvaHdwaNYq7DcqXNshesPx5PTXiTlHXIoFqU4Z0xWbu7u7v/u737+
+8n1/8d6rQ712XBceQni6K6NT1a0ZWCKCW+5X3J35FmfBl3xBov6HR+FVbTvYJ0wrv1h0NZ5E27rO
+nUbX7NA20DEB3bJS4od11lkAs3M5txe60IUu9I3Qmh+ljS+/9JN4+vztxY2dthM5XNHjDLbXdGNr
+Km+r4MENW113a3uS4AJBEyGawaixUR0PIcz6dQgzyvSSEe+FFKT1OIpmROfR7B03P/a4z+s23gRP
+Tux2tF/p9N8CFPz9hWe4ILST1PWS0YGGNIBvohyPHWuh7eVV7WSvLneWBDstsq+XU+v4CkPjiLei
+6cE0Mv5GET+0ynEJg9C82G1XMgguRUFwQWAtdtjtH7/3R9ff//7Ns5ta7F54TOO+i97yhCL/TEpX
+e+dBjREwB9mzYpJfNTZhis2Li6sQxWCMfCEZN3wi3C+ZucNW1TFR37HhKQHwkNS6Nkstp0X0ZVNL
+o+M00EmHtdrjhAAXkbUC0fjaEtW6ug03UGy4W560QQfJ33I4wbWVtWMCJLUp6Y6zClbSYQ5UoLQN
+1zrSbcq/IG/L4CT8HeHaVooluu5ezcXq5iiWHrYmi2iwsAvEeDKhL0ffswaf9N1tpmzp5Rq/sX/q
+4nDI1mJUMHVU9yqvGQIMh7zlEG5vMUjf08g7V1NvCWmIgGDuRdzjsP/pv332f/+XX/3gjw9Xz8zK
+s1IOxCN8jtdtKfpJQfSMZjn2ibXhZChiOxae0IgVldhjIUeGc0aAMYUnQZgtSZRymm0mmKfWysYO
+dYFnF7rQhb61dM6C+ja/njodCNHzFH/lWoB+nVv0z8n4FaXLooYvM88jpf1ySYIkxVbUxFIRq7WD
+XjUhc9tSHUngtR3C2/X59CiP9jF9opFvUo78XsMzXBDaORqjfZ74tUc5LqBue26vcxclFMJSvlIY
+lzPbMWzW9JGettTS6PGEq7u3VzZUvSodgJmchdvd/vGTT97/+ONpt39F3kuzVNOl5yCgCvasqsjO
+Yqp+2XresOG3xf4UhewAlKKdq8gnoCDShmQBJG3oMAXQKeutLRxlM5vxszL7azVxC6JedwwJKWPa
+Y09qIFmYCRKiUMeANeMhMUOqE1f1pJ7NwziNBIYBriatz2Kq35LB2Pitx8bWTkaph0BoFWOiW5+X
+BikXk9x29S2SQMtsLF0blh/BMuwhFquKDTzSo5CJNZzbI/EWmMkGaZYo2L66OXR3rAiyWs7DfK6A
+QdoSPfZKgMUy9TiGtutLlnUZwyUTzg0TNQ5/LTSYTzQmubuos/gqzL0A0/0df/bz12VXf/DHVzu7
+nmcvHMyZq8KimyexCKpcVB2d5ZPd+MaOlYHtWsqvic/amIMtkG33vGGwax6ysLjOxzbZtpcMtAtd
+6ELfAiIG42hnpjqJOfTEt5NnjiiC6982V58GaScMXkcNrY11bJIUkVqGlkjcYje1uQvGFkaAJ7g3
+fbJFZkTklmhtHyKdM+qdmbWvyPDV9Y9hxEdq2/mbvlXPvjb9vsMzXBDahkYr8ia+8VhZ6fkb/YQs
+2yaMxvE4eVBcmXdoVd+aeka01B9uTe6rlzyU9ihmELUc6vCitLLapCFS4VCrP1iZiTvhi5cfPP7J
+j3bvffAI+0K8J2skibGgJU2N+vzADtoYFrzSjzT+0AId28tqQqEbo5KsrKiZdijaoqWHospBycTK
+n3GETqmo67fxCbQJXx3vlzNqnEQH++wHFGMq4sbuEcqOmXjkMOs86NjB0J48e3xEMGH2zdL6DpXp
+LQndP5hpn11SBvXsvfQC9tkWwk42qO0dFnE5tOFyo22wr6XhpDHqPVqMJ2NC+JFhy1JlQ1v9poqq
+J9nqGnzF6asiIe0uayi2XNG3mZAAp0EqXCqLtOUWE4W+TUNzM54U2euh918XOM1lNqK12pceQKBI
+k7Svun582L9+fXh8KGWaoQcUK3Rv23QzL4+nZm1iVy80ufimu9ut3Sq3R9TSu1PSf8DW6s/ixNAS
+OB6xkxO04WYXutCFLvTtp7VU+U2oi4MjbPUOaKNKSGyFtgBVwkljsz8r5D9s4PLB5JUfUlfKo8x0
+kth2hmhB/2lw5LuYJG7k91rf+tbRdwCe4YLQjqmjsk1uxnjCWzSTCri4uJ94/KKkbp26bmjEcfQU
+e1ArzxAVGmD5MgsZ4oimDFsanZycabP0WMrjH396/cmndnV9K7wWHklnvMmqQxqWmKo1tlxqeCnX
+kHVQKmNfqUXlt1Y5BcByk6G5ZF6jsWgzeCEV/WOWrCeUWfRCFoiBtsjsBJLMI0zNnmfa6fp7opJT
+3Gk0InWNn+MvQ1sdMo4KeULtDjwa5yXIUdXmaq+TE8TVIzkxkv4xRtw3MlvOWGos9mlvwLaNq22G
+Nra0WS0LBtrM0FPU1x3Hhxu39sEs0GtqZC5mx9vn7sj0j2G4Rf9t7H53TRflzt3CHng2+/Pb29e3
+r3l1dVX217QHweUyrBY2CMAGp5qGlx3tRc646WA2LXD19AwpBWT+x/6SrHhILs+3pad9ZRfAdqEL
+Xegbp8boV1yKRxkFJy98mhajZvu2gWcrS3tqCttGTxwapOIgtNfnqVmFmx6wpIysQjnyvk2va6W3
+PH9xRKeiqDKsi8CcoCgdluNsqi0wRIettKelg62Sc5OqS865xosGmTROx2l6m8jIbof9zei7Ac9w
+QWgjnVRHThbZP3v5emlpvd5PX4UOxoZAybfVi9YKcPoZBElVaJ9pAKv7480Nf/Sjjz/4YDL7XLgX
+D8kiKGQN/GNNe/nG1R0H839XNJE/CO6AZ032hctwqPmK9CotavZCJ15THn1Y9eqorCba3Ca/Wlih
+GssPzNb+I9DzzEY8tu5q/3W82cjW8y7H/V8Y9sIdE8h3ftzhubr3bb02YuOv5L/tsS+RclgWAjKP
+LFvaItl8Eius1zl1wv4w0bFve7zKPlyu4HiPEfkE0HvyBVoJrv42CM1p2h4VkMVA0JL3hqXT7rte
+IxvZgVNfu0NrdXmCqJK/GTQJ19Czx4fD/V2F78z2UhEwWZRX0alVwZzMU+PfdvDUOzCGgG4l4xk6
+9aa8Pdq6ALMLXehC3x7yltsLJONLlvoGTvW0st+rGa+N512hGvSWBbC9PW9cDJ0dBeZ+Qg2Zpc05
+C2FbH94oSmJjpUWVCs0gFAZPnaJdylRjhkrNWkQzs4L/gk2PylCPJydkHKeld2ttTmRO6FNzvlL8
+cPrc3zi0/jsDz3BBaCM9kXL29ehtrhzfeC0L921gWtf/Nlqd0DaEzqp4lPRIPnz00bMffvrh9fW9
+dEfO0twKrYtdIc7WhvQ2jbdLG060v+oIl/mTHO6Uo6rlVqnHW49ejMz46XaZZBGnEA5PfMKqnyNo
+PD6zx8MBofY76NaLHgWjXKpfYHgc23sdd63Fp8VJK9mhxBoje1KOlq1uLowrXJfl7zc6dsAz67fM
+bnJlFVuelq36HEBpWdJLRCa2540DC19Z244tfJGrs7RMVX+Q2wl6kuuOb16rUZFuzi4i+upkw2kd
+KHZP3XHY5FaCbDp19PqMr8D4Uxzfwa+EZ/Ph7v7uvtbJsJvdjGYFxswJaDPaNYqcoKcmYDUZ207q
+GFpvRnG+jRM/nntER+cdL6cLXehCF/omSHyDEPkNaCUmNubXdB/pK7Dws7TRTxYlpYXELH3ZKIYe
+e6V2pnzK5heIT1Ls3ttlkY8i5K1UyyPqASZnpuCkbP1603WBZyu6ILQVjaVBxhz6r4PTekobgIz6
+O7pf/3NyRR/VRz3V5X6/PNDMK1nQMQoaztfX/u9+9NH3vrcv5Vfkg1kvgmcAs8JH10qj5vimSxt9
+91gJzi5QQhVsKeHA9p+v2zxdWn/T5Jvf2ZMmnqW1dJ9Fsf1WgWOJDbXU1GOz36dvdXyXtcarsbxI
+r7LeQRrg7DCuBZ17VvzvUYNpYYvilr0okwAy9ihbAMmC9c6g2qekC5d/tyCtRzW0ShwBlk6ZzY6m
+48jYdvLew53O/bKt/LkgtB4F2vqVf0+spqOrR7KjDnYM2I/nA1aR76XriuvXX97d3fPZ8z25Jw/S
+o1C5FOZo2YgpdLVqf1XzZXk6cWNpeGirXp18jscjwqlz3kyXoiAXutCFvs20MnziaRTQ4cTIw4ff
+Tlyf8lP96vadUSR4+XnQfDQ0NYKg1R3UhH+TpoxGscjT1vLKn3UCznV4ps0Z2YuWqyaMeWyhdoUs
+3e5vyae+9nxnPo3r2P7wjcBs1JWG4b0z0fMdg2e4ILSn6TgV7ViPOanZCOy6l0NyJ0DSpagqwG73
+P17Q7HtcbOuGN6WZi0aXjIFoleTYEEmWuYNEHYC7F8/9k0+unj8/mN0ZD8zNlGOYMMuykBzueVLj
+f+JrZ2EZHtfYStyqq/dcXUGso+zeTG+tTVr+00tVsnMHLYxho6C/4fDTXRs4ddwuH+ZS0KNr/PEv
+BWY1JxAoNKNZoMnEHiPsy7DGdr/kj9uKEAP66ix+s5p7JztCGwFDz0vucMjRQkSzgZQUHAZ2clK+
+Ki0rf12Gct1Uh5HsxVZ6tc3htJOri+sP4wO29U/LTEsF2Ltf3d3Z7Wu8//7N1fVLmksHqUICrG2v
+3edQ3tJCh3W+CFsk+O7+1213Rj0AC04TIEa8S1YFjVxFASKNaJvFMddfhKvmknmKrW0MVeOMXOhC
+F7rQN06/hUDsRflpitNJzDF8Yf9z/Nu23UHjWFtSTSoOC8visQku29C2BteJuwhwwtnUiW4c5iDJ
+3nraTmgUy53wdENci86vSl8TsH334BkuCO0kuXut1X0Mx8NYkHpT4HGzf9p4CVM/6kYPSW1DWJzT
++9n08F7/ruGolQEpWlXflrnzC5pUhRo18cxIzVN5/P739j/4frm5vp94D81Z+z88bQ5IreZP10e1
+fhePvQ0bSv2vcaGs4Z9DbdsfL5sPI5v1FSfcoFIk5Bzuc+LLMTZJANqj8kg4mbvFYQW+Y5cR+kk/
+FHCWWeXdenbdejsuNU9kbGA3NJ7x5moYvj9ZSiaxPRDvZUIChmxgkBaI0nu5/GwtGBJZfaSnEGvA
+9h2nK0fSviQ8Q67DJgKW4++Inm6Kqy61Ga2BFJt3Dy36sr0xyyjWDTwtm8bVvr1Ei8OV4M7sutb9
+6y8P93e7/f4ZeceIKJYgS6YqWmxKJrW8g74CuJgKjobbYH2cHtve9F7gxCKUtmszTDXuLoC9xubm
+ytixYniMx5/P7TVyoQtd6EK/W+rW6R46zkV2DXTMIM98Hg9qEDLt3xC1nUu3mPWlgZa9zFQ2hl8H
+cbocGbFX3jGqSDtMMrWdSVcnnqQuprQ9HCJKhIwOekeQbaI2UaI8Jce387cooKdnspmPuQyJHEJH
+lupzywUnglVH2XNm2G+g7yQ8wwWhPU3ubmahybv7mf2pt8Cs2y7inTGamcnlXm1vpaEzDcpxW99H
+BVnzZW92eGRP1F+MhoZWdzYRjtmoQiuAwZ9d4Y9/8Pzjj8t+f0s+QrHLWcmXSLlzktI9o6OXmetX
+jcs92zdvkIFAC8Yz0po9BwbQZJt6Ksnm2rdV6ssQOz0CU+AsBzs2Z7XkWyGVVXY4aBZBhFk3pKn9
+a1z5Rhr6u7qglx0Zwssb2kHDr0DEnreeBn6ihOoUCguy8tJQsDBa6Iy/+yc7Tht9M+pj6T7N7NwA
+pk8PSx1rKrG3GlLRajdNNvn01sa5LW3jGEcbxwDAY4R9rwmnnAGskbVemr/yVDmNbU3FAYOtHlv+
+3bjRkNgwnt0EXd2+nu9uy7Pn+wmdSQBKHxpn5F4JFCQ5nAJQOtBSA0HNucqmBzQLQuLosVdIWN02
+vskD7cnLhSlMIbUxjOUpLxC9vd+trNDyt3/o1qj4fCkccqELXegbp7W1SUeHvyppzd574tag4giI
+kPWtgevJxsYja21n1BdCOBWgOEoX4U+O5szv3eKX+hx6GjsWGLmgqbcxWW5w1Aqe9QlaJ++MDR4h
+yKGhdy5OvqvwDBeEtqG+B9oIzEop/YRzOWmLioNEKE3/apteLLUPSHfPN6rhjWXVrhd5WiaWs6PV
+NFSQLVqx9wOKfbzMBLnPhbOV+uyG3/vo6sVzZ3kQ6gImGiZILTHrqx+xozSKbN/ajisT2mXNj+ad
+awX32t9kHqum0zZGDHaoFQs58hycY3rHFG6LXi6DS+hCeFwc7rQ1n5F6xXYdTcTJTmRQxACZDWhl
+WMBU+BNckkK6GIm+l7fT3IoKHEabpqmUYmaorexKghBlRHuLYxhL4g8fFltV71bz5GwncDu3fXkI
+y2pQj3Ecn9EGQWwfxRP3OXvihsb3YtxZIh5kjKt3KZvRWpadlKdxzgg2+7A2QkR9JgR3lxt3dvX4
+cHd/q3qwYgVmyzLvDtKGkIgG00MByJ3kNx6qmHcmelpZJ052RssfwVro82JgNjMfwPw4laRO7k/d
+wZi7P73jyIUudKEL/c6IaetssntQFk6wp6c41rGk2UgPpcLBVEvG/zYIa3W3E+6foyPZRBfhMKGo
+FSgeG9TRhWfUjwWe5S9MPatXgw5sthnLk5rT6gQBniFSJ3TDnnrf/u1PZm21Tvm6ZOof06qlt6Pf
+HjwbW/6m6ILQFuo602LXDjU6S4b00842wa6X9QbdUSU3h0VyoAAAIABJREFUAwF3yfzk+hveuK4O
+pgZeCNJbl8zMKqrSGh4ehUH/c5kbWefZq0+7g/HhxQu8/z6urg7kHK8wUcGKFiS1IJHGNpbkn2MF
+cTvk4bLlKPs4hNSoHb2m/9nRd1h0wn0Qh0/EG55ssynGzI2D0ZJolRygR2ovCv362Z7yC23U+fwi
+opqcUHcZthPaYwuBQkNhJiM5aTJzK5pM2B+mq8P13q+LJgm1uJdqJpnPVisJL0ARYJLRCNAJX2vh
+S56Yln2wl54fD2hExGjz0JD6cFAtgk/rzRK2WOYEbbjxqYSmTSNHAqpjpuXE7X0X2T0Kv1NjPBYZ
+49d+5qrg6GAGoUT4RNv5zLu7+vig3c6gCaK7CIdq7GsIl7NZNSizJReh4WXkFjbpnW4uaJZebiYk
+OPoO2mohkMqm2uF0sZsUS84d3lLQIvwTbXvvdh8cuUKT8DSLu9CFLnSh3y3lBl+rLW84oIF22vqi
+E0e1+TTK8ziyUs9aVu8292ELl1a0afgcwjv66W0ow1pWzRAwsMSus2ETF6m2K4+QOTUtGfptb9h1
+wJ6OLqRaR4CrrJilK29u9i1PfCv6bsMzXBBa0LGduNZaaw1gFl6vnpa2Sl8ao/IIKIs7oDjkcqm2
+bKSAeGEHMkuXS1yJ7YfUxvIucLlcAdAcmr0WUKiSgxWqACQLNAkXqlCrYYbfmt1++PHVBx+W/f5A
+zEIVZ/JA+Gjk4JLy0lNflvjDMxPXz+L46g2hxh2lOeDqTvgjDVAYrs5JZqqycaQ7+k514lTXInhc
+GQIHqfkMgQyWZmfBLewwkn+Gu3D1zwajZbcdviQWeztLNLBQUosIVym+39WpwAC5ubntDvuiQsf1
+4/7F/XtXh+cTrp18zfvb6fZmuiqUT7VCPOwm3xtkwsRph2KVEEx9zlfOwAS34cs8ZxTQ+nR09s3A
+A8u34M7Lxgibed9+Hc74+uyYy//iMsOW5Rx7RlcTSw2GHu2SsBrp8fEnOqjhLyOCUfJai2QPdw+H
+h4oXBTI5JcHn1kFlEqFLEOUi3Z0iKVqHQp6mGKXHiwYg8FWDneHv7QyhcZI26mZFatzJJQujkmc6
+IyMTMwSrt3hmdZ1nKVfbPXvdgYYLWrvQhS70TZMJGkr7LkLoFDU+OYbIb37vGIc9KIR5uGkAzICb
+JlIyzOdYExgNe0tUwnLCUwZ9dO0Ei6X1zAU9521rVA05Y4HQwJQn7Opc9tAW4bnqw1G3NPYklTdA
+KBo1Vy5njL3skzTKzt7xnixzXui+rb7wnYdnuCC0oNFFFhrP1dXVixcvAJRSSimj4nJeZVEP7jPw
+UHe759dltyNhZhaFHtriF4crts0JWO9e0R0RZrbf7a72+1Kx390AxVXJ8IY5VaAi7ECBs/sBfjcZ
+Pvzo6kc/+vDjP7qadnfAvXQQK+G9/uuT9Pba9RvP1FPcamglo/GGMgfxE/kV9UWmuecs13vya6MB
+9pwL+Yonu80WJmikBNUqcfJydbi6PlztaimiiFJtV3fFC8j94+7m9sV0u59w7Tt+uXt49fzByitW
+n8sBwrTfT3XPyuJ2pd217/Y+FdJartPirmJfNTxmoW9DXwFSnZGV6h6fr0kD9w+WzrGO/ptR+tus
+7bfvSokGG+ZyVhm5PxweDoe63z3fXz+Qj8YdZcAuQlFFMLCZXEQFIBTYRDx79ny33wPsW9eETkAC
+lgVcnnhoGkBdgFSzm5vrZ8+e0XdTMaAK1eFOghMwAUZU8IC2459FsddlkOTNzY2ZjTlpEe/9jqbx
+Qhe60IW+Di0K0TtzwRyrXVpKGa/M5xw+8Oz1edJbydpsaWDzo174huvWZ4Vgij1C23+ZiNZ0n0RK
+y9XnbacblKj1f3ZuBtbi9slhvCPJ/IcAz3BBaMd0OBwA/Omf/umf/MmfPD4+kuwIbXPmGPcY9dOa
+qUWkUL1Oz6/+7M9+vNvtAPQ3JrnAYoA5T4NGSoJ48fL5X/7Pf/nRs5d69Kns5XRVWI3qCYTBd8Ak
+QJzNHuGfF/7ko48/+w//sX74wZfTdE/eA49gjaKGI6b4xonrzyff4q9YkGIVrLn+4V1TJPC05xsR
+AIJDM+AiOWG6Plzf3F7vX+13t6UcrMiK2+TFUEDaYZru9lcPz5/tXs57/LK8KtdXv8aXPh8q7o28
+0vW+Xtu829Xdi3r9Xn32XNdXXuBWEBtwAwsT18Bk3xVW+SZpY5D7LdBo8rRlN/XV8onZ3YF71/7x
+sUzl6sc//sEP/5S7/ReFDwCoCYgQWjPGFnsepUJJTijw+frGfvjDT6f9pFahs3l7oQ6+3tTTxcgj
+yd9/+fKv/pe/+vDlJ6gTSWIOy6mbCQWYSAOcnCNgUk7A3NW9ZwA++uijTz75xMxqrQHMvrpN5EIX
+utCF3jlFzauOH06b/rrIE3qlseOAnU3itoartSSUd19UStQjPrg50H1Lxzir205XB/vmJ/2/U6c9
+QQ2tduBloPUsNHXJMtamWypMnR7EgjH73/jPmSD2nPer6RnbWWmtrsTIeZFystLjMf1u4Nl//r/+
+8zeO1i4IrdGYu7/f77///e9/+umn+/3+uJDjaFTWZt0x3wGHy+sOu/ef302tcH9PJFvC/BpmO+MN
+T2eahDrXWut777/38V//9f/6F//TJKNKrRAc5mTEUho1SRNA16GUO+gXU/nnm2f/uNv9g5VfGG+J
+B+Nsrazc4l767ajwTMj6FS/LUkTZym+ulze7UZvoTQWFhdR1368Ka7TySCZ3dxYwXIGT768fr8ov
+7f4f725/Otstp7kUN3OjUSSqHXj4ix//hx//8M//9V/+9Z8e/umnr37BO0iPzkMR9trv/dmVP3/h
+z7/HDz7l90phmffkREEwb0YA59ivN4xjNBA+cU5Y/DSsFm7wcpYkzLfjHQHDU6uny7ZNZc/49pvU
+lVzfOdsc3pQ4WIC961q6ub5+7y/+/K/+0//5ycv3Hoz3JKLyvmLLdjAQmijRzMyc8+M97fHZB+Vh
+98s+QjWHZ/tX582pMfkEWg1/CcAHH3zwv/31X//lX5RduYFcPsMckJNqPjQClZgbkBfJKdgagEBl
+JN9///3dbrcp7SipnOzKhS50oQv9LogbRUADg+ZwcEtnfW5btaehshawwf61f96ce9So0lt10qa1
+wEEtkKq57fzNKtKR22z4kgXbsqUU03lhz/LYNHTuniNgXOFHIiL32+A34z92rv2WDMO/M3j2Dlv+
+2nRBaI26UhI19D777LMvvvhCUhR1rLUiLcrni5uFpYSkUXSv5Wb3gz//0/3HL6MCeJQ+l0SLTK9W
++TQ9x0fWDGu10s1aBv/t7d3n//KzL376mVUYJncKAmdhbggNE7UjbfYH6HPjTz/44Gc/+nevPvr4
+V6W8Nj7QDmapwat59kaY+A6JbUOnDlhykGv+svmXWBl5fuNesf8ZC+ThhFM0WTbPcOCn79INc93r
+6WZultUsJ99dHfb4nF/897vb//c1P4c9Mkp9pPSx+WXd/WD/ox/+2S/e/9U/fP5Pt5/d2izgIMxG
+7ny3w7MbvPeh3v9R+eT6enqv3FxZsRbXECUAUZYBD3NwihsPK5mZ1oQzp+YUKROYMkUtQdJvDKKf
+omPjRRYgHfqNrcXkK1Gfo5NyZymWJQgwYCffPz5OP/3Jq//6//zz/ur1Bx/e0b4kZqOBcGiuzXUV
+O9YLkUVK1cP+Cj/8s4+ffxI1GOFyKJLT6HSco9wSL6eklQcB8OWXr/7+H376q5/d7XgNCKxCVSA0
+FGCCCCZCE8hiVmr1YHFm5u43Nzc//vGPnz9/vtvtjiskXehCF7rQN0RHqVNHZsi1pW6Q46eo7ySz
+NJP1sAbvGcAFti323dVt+k9ZhGzs14pbr+4fslMt7iby4/mkIO120mNfVYBDsQlEV25b2n4DBXjT
+cHo3n5KVbJKul09uN8pEN7Kn8g8q29i/JcFv60E7fbtlop6kPyh4hgtC6zSir3me//mf//lnP/vZ
+69evzWy323VjM1Z67YYaQgNIsfp89d6z/x3/6d+//MuofY+1HR7dZbzsdBU3wIptkB5wQvjy1av/
+9t/+9u/+69/Otw+T7Wk7wYFZmCEPHxpZCLoOxK/N/senn35epuuX79nN9b2VebATMSFL4jOtE0TR
++3t2yF/HWfF2yOeseear3Ofr/UwMCvmWFT5BfYcx9rmNekogCCtepnnHW9hn0L+6fgV/tGWXSgKw
++eOKe9vt9nXyX9Vfff74S1NVFHeBFUwF1zf44ha3N9r9qf1gnma3wOlCbmSwwtrBoiO0YVXVZrXi
+nqxO+tScxTh/W3FwZ5reSmKchaBPtd3/HB9uTa/sGF3gxTy7G7irdffZL778m//y/7368u/fe/9z
+K18ABzPQ6PLqKGAJqENVAGBxoh6ev9z/H/zr//jRp8ObpTUCe1PHs3ekkfbrX3/+N3/zN//9b//H
+hCszGt0xC1BGOQIEnDyEpCYtohzdfZomAO7+ySefPHv27Ic//GEppZex/WrTeqELXehC75644tlv
+qRDozLka/mbjGjUgcoh1bNV489wnthE93/eOlphjaTeQQO/bAD2ZiNZlxZFpOfYFdUcY5lxwR/Xc
+67Vv+ZrXngOCqe+1IA7hqEOMPWMz+nONcLsmsZrZk/T15MofGjzDBaGN1LWleZ5fvXr185///Isv
+vsA6rPHcJUGt3JpI8VAPN+8///MvvohjXl1C2wTrXGuD+7gniEny6u4O4fA4/+qXv/zJT37y+Pp+
+V66iUghYgYBeZiqxTzQ4T+XVtPu3997/0v2DYlfkozRTvtg7TuEubb9xo/2OWvFXpDNX6I1nfPuJ
+K9FBQIwdTqJaRDyaUgsewFviFfDKcJgIth2YCcD43EotAGfWBz7c4UtgBqqg1p4e7lAnlNd8/Vge
+vVTFXioKhmnNrTKYAzoc/z2jJ0HjkUny5BVfzQ36lAtxewdWoGAyXh8ep1/84tXVs8OrL39l9ivg
+wQpIOFyy3C3dZc1QOol0f+/h5vXrL7Wqd/81HxEBI+e5/vKzX/7kX38y8cpIsLoOIFAmR4EmgL1S
+SLNvwsIR2RFaKeX29nZTNuniRrvQhS70zdPisBmcNCOtFYk0rp4qld9Pzl8y8hCD1OhobZMvtr4j
+36QScXs6mqQm5Wz7nxgQW688TacNxgISkrngYvztVfIRSEoS2laYSrcb1403eNanZnC1rZFYs843
+i/DaKXesLY5/U7JkZUccXXOO/gDhGS4I7STVWud5jshGSfM8RyzQufO7R6JvGUFHrXOdZwLFzKP2
+teXuah7RTTz2QjVs1vmQAMHIYqWY+cEPj7NXh+S1Sl4l0DME2dUChQswTzbvJr14sX/v/avdlQMP
+UZQ/jR0Rp5YmlbMviVpho5P2myMdeDA0LaHPfWiZvDsyLSaw7darPg1HDO8E2DjrPdHwf7//WiFe
++EtjR0sy8mA1W3ubTt5rmIgYTp/XNgfeQhCNFXwgH8AD5WWwi8WyMYMBdPOZ8yMeDZUADF68RklI
+v7vHwwGH2PCqFdhl+u/YNugm6lYGjd3d2rrWT3Uw9y3Tt5r3AY6ecGmdmp7fgDT+q6EvrYPbUej4
+UvQLtl3hcnx4gsOZ+Wl5UAQkSgbt3Xf3d7i/w7NnViYAcjmHcJNmiYxdyeSzYIh97LOtVuV1I+f6
+dI9Bj9lDLX1xeXUHIm63Cl6dQI191HyuYlgBoilve2z44qEMRufusb9IMDp37xzvgtAudKELfaM0
+xtoZBuVprCCyovFYZ6JsaGzUI5SWaDbFJSrXwyBK1oLpT29juxKFC+s+FkFqJjoxK7SFn87aNmUy
+IreuPDWYo+1/VuRQhTurWAV3KnBadGZIBogUbvcTqEl9DEPAyEbdi0kywaE0Pufw2giHxxGK47iL
+AJemzvsLT83AHyY8wwWhHVMvMD3uh9Z/OmlRzu2DoMQzJD3hUFvxZnQT3dfL9M39AYqVXSkk3TXP
+1R2kRRF/ykABFapUZWy81hCOk/XFi93zFzsrXwqPhTKaO9ScNqHyRircaYtGvtnaqujHppX2ArcX
+dAvP8vtx3ZAN59HyYq8n6giZvRW1faKCD1rnQmuu3vEwRWw6vumuFu6DpaKURqYW+nv77pwFiLtq
+EMtEWoR2Q0BubTzEL4TSHAx3hlsWuFWDeZ6x8gRozsk5yRC7jzMK/tOBspITx8+qHzxeg0KLiRjm
+4ivEs/qmJu9AX4UlH52zXlFt7/E+hvx8blD9RienZQPj+5mbnltibTeQKPJS5+nxUOaDoOvJbmhO
+HiJXTzR4bFITthB59UE2WYNlYPuoHooSPWBurUcgHPNyyGJ7u+Y1jY1qQBqNZrSoJcuJpdDqYzWy
+AIa2618JkckCY5HQihi5AyilBOt7i51FLnShC13od0Ws7d+0XDeEpgZBsJEuiw0vymwvpW/7z0qx
+nVbh2O6ZjHgVwSSTSzK4t92JVvfI2w53Ds1rlCkhCtBPbXGCwdARdtuWE7EdxHYOzv8Y6oHDnS46
+mNtsZkLakk0joAHO0SKZHT/L79Ocrdjch33e+i6s3p0LK+3qZN5eGrGPFM7tFwB/wPAMF4R2kqI6
+iKSI/EFisI2+ckp96Uo7WykDydPPXGt1cytRHYA69TauFE0CHSCOmyb1TZdpiG1wkaHBCtsGi4mo
+0Hy13+92JL1vO9gZTWZ89vsd16QPPXUAlQPAOUPj+7go1XnLUCx9cAxEnfGFpRFDF082fNTF833Z
+WLYwgIfs3sLKe4+WZ9CH/cbY8yVoW1mWD1GSJbar9oOhGicrMJNBcKJ2RJGCJphpWL8iQj2eGN3l
+DZmxwAqt0IqsiFOzAbiaFj50KmuBHk/N8PdoKMOHhd+yW8/6rzl3Orp0uc9bIjttPi+pXx2IpU9z
++d5Qypg1uMogXI9lfO7n+rAxF2w+dxwdZX8YRR2Ja/iBmI1XxCNQFeJcnqKqvcFxsVpZVy1yuUuq
+nOeuQ4yVZLR0g4s+kTVb5F69liKDSVKtgMemZ2RFppILQLjwaMCyS3Wwu55we/GbXehCF/q2EGvy
+P1LJnU4kXm+Ze8r+IzNcq9y9mB4JWGplUbbeXJa21zV4aTXeQvokK+/W3NyAermfD9LI2La8JGBG
+GGxhtm+0iD3JlXtCWu67HRFVSkBkOSVdRVma0yLc8lZs9c+GygXr3a6zXYesaSwimsE/1d6uAYYw
+XDCZlgSalaK2mYI/ZHiGC0I7pghxDKMy0rq8MS1jDc96TWoBQF2cbmDb650mqNbKKbY2dgBrLxGA
+1VruBoawAkkwWjGaGWnAVKvcq0BJMOXbhNDqqx92OOz3ePni6uZqV2hmJjk0N3gIYLj96Z2NI3o5
+QUIHT+e4yICyDJA1B1ZXp110Z/W0hwGIynVctZAGrTN3Wc3VU9QhmScGxEpTb1uIdWvTkv36NB9s
+HRgUfq6v4HBCbcXvJciJavDSGJ18FThBEKpSlapHHDnZjF2S18ZiCxT7WxXSIIYUEQzex2kJ7pe+
+CBgjJVrfE1UuYmOZXW1g87C7OvMIhnOAo6lbLABPTyWwguze3o2GzVYxo0EO8zaJ1h8umwjB8Kw3
+f3H0GevjT+A3YNER6ICBDjOWeebt/Xw48Pp6J0zuJlSYC7EbddQOYlyIccOXlsTNfGRrc0YbaWSC
+nupYvI80gjW8bbHltZm7H6pTkiG3+RDR/Y6U5HI0CxA94yTHbUVwwWkXutCFvg3EGSBUtJQ3w8Aw
+19n9bMatJqACjqXBcTGHhUhZq2smIKMc2XxGCssrE9a0RtELYS9tLrdcCdOeGc7cgChgJg2iOrrz
+NDOelkKnNK/NqWzuxOU2IkKVGDDt+Qa0FOfiOFEAYkPs9biAFkLZ/utTPN6Ga2UZi5Rdnsk5FeIP
+HJ7hgtCOycxKKVHNrFfbN7M3B/z0l6MtQ2/QCiKtlDJNZTa53NUiEdH14IXVxIeucUZTufOTGugx
+s6w7kjePv5HtooPql+L9zY19+NHzZ8+vzFjMvDlmxiuw3G97bOkegoNo+xP665X+7uyOE/Rh492o
+IOmQo2qoJ962HwE4wofkJm8knWNmSw97rHRjklKf7mCanrU6fBluY6djY+zttRPU7zAWyVUrgNc2
+UVmwdiveNISnDT0XWrl8d81SbevmtElNoAvuqhW1QrVv4oI5apNEzlvLPF53fOnywKwHudX/dovX
+cTWnJkZyVtWlytGZy8oGn4D2q18ioXkQFD02nwmh6GSgSobM6PaMRa5sINkGOA4dPNOnzfnMasUI
+zxQoFLKA0+y4vX18eKjPXxQCgguVzY0W021taQkgHV7l3TtKdXmKdbrFegTjJ42/0Mxis7UWaC0H
+WUpp9t+j4By2PQByeOk9G+O636J07YUudKEL/S7II14coBgblC0xgc2KvAYBZz7Etwg8aHU6MiqJ
+jQdzzW2H26TsTPvlYLPc4KRTQxhEJkKKptk0BuSphJynpyJ5WhIHUyy23asRyA82qB1DR44ldldl
+xqnoqSJd3cwta5sIbQXKRqCqdRPHYzlrKT1Ff5jwDBeENtJJXaT7x45PPonZWkhx+68ZM7xlQ9Ej
+R7MHJsVZvgCGfDtWLavpygzzDgCvnimnQsM8YemhmVmRZjfe3VzXly+m3eS1Phrd7HgTsOXOJ1+Y
+c7xG/W3WgmUGtNRsKhAgi6jreIc7gN3cnUMjrfn1vYcpWbDRwFC2oxm+aXVYkEQ5JcuCtwmr0B31
+wcI4gA71cvqtlaG7SrAXM0Jm4iwJ0DG5dlWTN4A26OFbIaLO7BaItMx7ODQdqEQ1VrNqrGw2uYha
+i577KvJ+C3kHO1lMLTt2X896i9UfSnMME4KMsItSVEgccvRguFyy7cGJX5CraoDDbDcIbBZmD0QE
+fyBbdm/Taulw+KcZEYZ1ekKon6QjM0AhIXkV4Cqw6nQ3ydwlk00CKmiwyEpt+anKoExGNXskF+jq
+QVtmw5xthwL0OM+lTGf3zXlLZ4PWOwSshrLOHF+Q2Nvk3F7oQhe60O+YFFEL7XPKpSZ9lrPQ5Q4T
+XWH1a1OiCDamm4GSEGjiYirHkmWONK6N/VmBxLz1EK23iK6lVaAzbzVxDkX1JtKX4MdTTPe8hyAE
+ZQib0uAZLdPbmtxM23BcwIzk2OREsBuwuSg/ImyN6FqQZFqmz6iUQ4b9YHFdnzMI6CdE8B8sPMMF
+oXVawpCGIxs1ZaOvbEvtp41iwWZcPPK5Ob3QD64uP1qfwT5WtX0SygAuL+3NVK+eo6j5QQAqk5MP
+n3zy3scfX5NfCg+uRxtjydZ36/znaVV1PH/Uv9caf0anRVWkXrCop+GOk5z9Znvn+8s6Vok/Z285
+q+UPWn347TMHbzFTMQGYLfl9Kwf/qNwnx3nqiQW/ae4sIQMZhALshH3FzrPZAUMca9BMzHT8Sw+T
+iOl1WGQ1s5W3siyyQsCaJy1F0Jlnq+GEfsTHUpyNrTf8MD73vnk1eunNAQCNeVNn5qt9GlETNiWA
+BYs4/nwQ4XJy9pvIY3fmPDhy+z66voT8aJ2MdFI8Hp3T/IEEiliq28Mj7h50OBiZxTagochLb8Tj
+SfXtSVtdHy3PbdmscOxUE3gZpLj8bsuiXMoo99Q1a+bPAeb1LNbVkI442wWeXehCF/qWUFgJ1SK2
+GUJ8xZ84ckilFE0+NyCssKBm/m5UnIoQn5bHL/RSuxSslWBMTu5YonBoEe3OjHJaQODKKtgjAAFA
+jgpAMIOgKqdUB0Pd289KG1vCMzMW40RO6NVHYFxGB+9G8uzfKM0BRjHwRdFsk9lOt9b/yI5WC19s
+WQZdM9Fa8I9DGvWrDoHXilbPX0v6Q4ZnuCC0kd6hRtLtMg1Vrb4ti/GJ+53+KZXgnp8SarKIGvqi
+5KpmIp18/PTTDz788Ar4OfkozMqM1eEOI6Y6VbtEyzu8/WX8tIm2DH7TApcLZJQRRpnJzEu/tDij
+gEFUZeq+o8XyEq9yGM6WLp+ZwSFyK39VspKY/ko4CfbwbBkZDqgxC40b/p+jSjTcF8vAjLiwnvGa
+hpZiLiKFd/X71rzEVj6icapFuaZYYDvYDlZkkUZHN1MpKmrepLjMMikr7Y5Ax1NbCi9xApiOZqPL
+ngwePel4GNoxgl5W+BKS0by751b7pltjMEZzCw9BLK0vIc9aPSw1M+QKC43CctPXc5EkT7yO2pwT
+QzJOwL7W3eNjeXjAPGO3u4LuoRlwqeRECOqYtwnsFiQD5oro+KppF4GjWqeZFoAT/eLR6LpL05mW
+gpzZbC982efe7XfKDC90oQtd6DchZhqFKKenHiSlFgRgiSrHkBq+yKyMnm/B5i0vN9IvWglkLlYw
+LQLUoEhMwxCVwNRDOiZcGySRXdrIDqnpEQnqiAjb9wSDbwnSmJpQR2glVKxW6CRg6Gj0XkQFx0Y6
+BiPQ6ky2fo4diR8cQKtsCR/MnQ3ELm0t9zSxB4auHykWvWSD0jr9gcMzXBDaO6Pj/Mr82j4M6zMX
+8RBXpvxlNHCMS3oFSRoPSYjWuIkEh1NVkuNx2uvle/v9lYQH4gDUhFKj8tX4jrb3a905r8KNZxGL
+ErgcVPvL5kBroK2YFoRmSu10nKuBqyyZbFh/O83F+jz2BpVowRVljtJTESCkq7ObGdCJ6egArDee
++vpp7tz0bF/kxhhf1vu6xXT9RuvDbVeEAk7iJBanEXQUscAyka6b8roVbWz1eLo67+z4oWZLU5oP
+h8nlqr/JWLmcMMQRjsjvCeIGsy7VohjizGGELMF2f4CJbwKb1RQYJ2+oow9fgc5cY1KR78Vr+c18
+ePTqtr8JhEZCiw+tCTO2tz7emK4I5Bepo+jFwoBcc/2g+mM9O7XdjrBZRsssvGkaNkE1F7h2oQtd
+6JsioghI02EEY8slaKyE2AVZ/h3NqHFFHG2+M0He85iP9K3QlGJDozA0E2EHZAZChYBvOSwr++wo
+dlMn5NhyXkJaFHtSs/u9gdUeqwo0mMEKClUkSnIraY1HAAAgAElEQVTASSfX2PHphrWgONKzuhhS
+7PYxCg7UsPir1UYgQW9uNEXkjsMJlMCKS1OLKXEUyU9qKe+Gfh/hGS4I7Rz18vpP2JKfSKYf38Ku
+I63jokcVDG+zLpsXSYtN3KHc59Zy68NgXALmly931zcGzESUkxBQmh1psWlo09NV996WNp2XEBsm
+RqWUpRYfowYsx4KtJfXXjHFMZrbpQWe+rarkWQSQCvD6FxHO2Mkxgr7phAzV6OQQRYcF42yH2JKy
+VviqgxNqCYZo1UmagcqFCsxRO2LMDlumjsODyFygNTxD44wAnKgmp6LGSVelLYM02nllI3tOP9LG
+f9VaFtBFTo39HLytsMiuW2JRuYJio21igcZD97fzucHeJztnOYLoWFvlQBHMUSw2FXXCl63ummRd
+BOVgZ+grrK//t6R192JTgxB+MvAKuJln1ergvpXbpGeYK8/dzVuuZns6Pa6/2TY27EHNW97lPbEs
+v5XQX8a8Vl3WY2iTk3m2nfrBC13oQhf6NpC5eS83FsyOkIczbTDwkWve14yK6mKyV0LyxnttyTtP
+/MD0JsmAQhRDcTGznb0x3qYOZJlIILOyRyWmy0pmp6PDYXJcMNHWmvoVqEczRvnJ1sVqqqbYmdUR
+gKuZ43NmmsBM5SxCi7rgiXBShxxLmehW1lKYHRV0R9RGi2QEIy0BtDVZtg7c7O67tAc3HW4Y+Tkb
+629Ev6fwDBeENtKmgP7JfYHOarmdlvPz5URLwGcLREvfF/D0WjyOLxzC2EL116DMGzEBMBXCzeof
+/dHLFy/2rb4fCzB185JWDocBG+RdFqPPk6psRuidQJ7NdkNn96UlwFqPyNpru4Ba9t+UPgANbWMF
+etdQjugaL5YqGyaYmLNHinSLOvgUvW3Rxg5mdI5LbIsV9tvkU1Cy+BYd4aQccgerisuoArehy9up
+6xytiYtxTbZtrOcZB8dBODjnikPlTBWBDsngQlUrI9NdT0dAln1ARA/E1ziIYNwK6SKj9/L9fWEr
+i9xkzO2Qjqaj262Gun5o61NHwdVEbK/oGLGW4UssyvKYebrAwXN18iluYj03a/vk+7hC+vHdGC+g
+C6BNwNXj4/1hVuwYJ4iUYzZOrcTWKveSfWf0hGQB8BtcxpCPsP67xBwvknQF49jQdD7f9UBGoL4g
+2Atd6EIX+jaTuQE1IEarQCFC3jjgYoJLVBSSInld/1dhanTLrIcmXKBWJSMMkIYeRG9UoabEZt4M
+a01wukfttiZw2nYqPSgz7hrp6N2yBhibR64x4fzRnvAHnKReC6RjQhFeUN2raTYVuVBjYxXE6Bdt
+ZXUvRvq0e+Alh0iXWtYD4AY4W/SHYw7FSW1SiNhTioaoLJKFJDWgMlucCw1qY5H1o0R+x1Lp9xee
+4YLQ3obe4rXpgW9SQ2Ct8F/oRBzsOoO5ZVRbNxprZqrmb30dD9UQOeavIF88MzfO5MP3v//RBx/c
+EJ8DJHbQDByS0QxZMY3HLQiNY1coqS5fl96y/bzk4LYeq7GqIhhVstBfaKqxK9q8pAJx7oPp4W3h
+OSGiwLmwfmUJDCUWBefCoQnAbK2F9lwmj1hGtyIWoUjFK8NEpJoVRBamzsyDGqqW9OlaP7rmtev2
+sSh1W4DYcc2giBEvJqNGhLahJYLtJIR36YD5gHnmwW2urG7V6VIVGH5LbwEYcDBGt24oISQ6jlpk
+1ai4K7PnBEAUaUZVioIaB896gULPqRo2tR64s0AcJXcPw14DUbTeNIfOAB3TtNCaoVgqp5nTrMkx
+dXimpWrI8KRO3Xn99WTW5QhmdPxgJKvO+4f54fHgquCBnMFZfpBDmJAxmYCQ2YhDYHH/ON59Bbw2
+7zhy0tuv6O6v8Smvoehb0CX37EIXutC3kEoNxtmqLkd1JYMjonICs7GHiwODrpUMXJA8oiJjs5Hw
+eAmAjIDkauLOQYomMxk1UYWgwyhPN1XP7aC6MbhFXHEDOIKvW/OtUTCyROQKQcjgjC5s9oN+mnom
+XBfmDoXrbIZm82IuQKoe1T0kyHue2RJoEv02EKhyhKCXezjQNKOlpreKwwIqHHSZHKhkJQGTGcKH
+1uKkwvKboHVdpySF+pLo0yfs3Yqh32t4hgtCO0nnKum/JUVonzLfJIw1JNp2RS4zayiLrQYC+31b
+rQyihzpjWdfkuHf26MKS2r5egmb4g/PuxUu7vlHVLXUoNFVEJUPLEL+m5UU3fCkjcN6gMc6Jlm4M
+8xbDdRm9EFMEEQho21Wjzjg4H5eptgcIvdijIbcQaMxLo1LfsZr613XEJDOOW15dilQspqlpgrnM
+RcJ2jqn65HJ3mge26W2mWaqVVAw4u9h/juYCcks/EkGgACWqRJJmhqJdYSGwOEGfptWY+/eexOzh
+TBMr6MZKVCCcSTJGCc2QIO7KSIsBroRQG6x4Wbe0RzGCQpEmgeiTQzhVIaAq9+JmcuP003l7BEfD
+9HGtLBgie7Kc5u3YyMwTojij2Ev8ZxXlwN0Bu5n7ijAHqL0Ii6VjM7EreDrScGj9YYw7ZYhwkTAU
+Ygcd6syH+/nhYa51LubAI1mbLA8DBztUDmG3uMnyFVv+nKLuO28dUsyw5C5kjdDQGTKSlkc1UYYY
+oBEBntn9LFBfMJwLXehCF/qmyBwkXPIItHMA3jYPkrNXzW4iFsCYUdDUAjX7OZmxjgCqEh5JVZE2
+AhcnZ3ErKlKhT4RTSot07F2mtrdpr6HV4MYaYTSB2nemjoiekvyZlKEaqqV+80ar4ooy81yCKmpl
+reaVfrBqpTohVcHlpDtlyz2IrgGQlAGSm4OM6XBVyIEZmU9BgoyqJgLFIhdm4+wGmrHQHGJLkjC2
+wsVqUNhGhIZB6K+l3jsEaL/v8AwXhLahnobR89CwfeNSpc0/i317IHdfNj9CKL6LD5upwqq/jf2N
+yZhIxYvfskjZXAp9wyLJyqSoQ7G0VyGf9Sg+7Mts5Z58TbtluRfuZTMlGATRW1l+9xyS1m9Phg+e
+GPkyV6gVNEyl/9RVbsTmG9HDABLgDM5u88xDb7PyALZij0bWnM/EsxwhTff1LHfavN0SKIuCkRF/
+ENY2VdICQLHV/Y9muj+GVNY0CW9af3zJSLz5dfIJbkFUWMOymjoQgJEC4YbAUTNIWB33ftyQ9ASG
+I8GCQkwRemEoE6ci24FtP2VRCg9e65vFSDL8cFm/bDo+gPRvLnOMmIsFaylqRc2okrfAyKHVXtQp
+oHZbOsMwWuNbg1neanWmd6hfrPW0icVlak0sFeWAMsMqSg0JyKVUSosslmO1dPvL3Ip5bXuSZ5NG
+0t1BGC0TDsIA2081YA9U4Jq4mcq+TJr213P93Hw2M3hEjZASw0jqdMVLbplXLZrFMI30HqQ7cJr+
+/FsmQwplh7tXj3wMwd3FqIxqYEurP7nSSLSIF3L8G2jN3ROw61J2/0IXutA3Szu5JHd5+Le6SuAB
+2UJTshbwnuEEJxFacDszM1CUyQkUwb22wl4EiMm5c9vNk6y4FZeluSssgE0ISpVNsaPnZqQrS27G
+pmd4fcbXhIijT7WUw87myepMt6xJ/GaE1iWEIMEd7vRq9WDzI+bDVE1zJYDqclkk3ydCG9U4gjSz
+CslNJI2MgiOhUkK1DZkheS18gixw4WCcCwUzMysFooefkwhnZYtyUszTYAFEQ4ori+nXTsc7ou8A
+PMMFoZ0kd3f3/hmAWcKrMxpPI2aqKJvSxdQw57m6+3Q1CbO7WzMrKH9vmKHnC7G7WwLouMslaa7V
+pVKmUkr16g2gCY2zuLmD825fXfeyu7I7CPcVr82EzCVtNZGUbmi22Gl210e+/YKWfe6Vf9iaoFkw
+SSslFLvmyIlNQgAa07etiBuQaeMwIYsEdy80QpLTaGby7vxJf0HrT0aY5wNRi9G0plCaWwSHZ+EM
+AmQR5XCXV1cVYKZWcsIkS7eEgr80Jd/yyUhwNWcPh1wmdn/GggSg6q1svRW5vLpL2rFUTsYS5XBP
+FnFc5nmY65gGAiwNEe8mXk12bbYnJ6JEbKc1fGUSM6Kgh3w2QRFDMBZJUki7Zdmp7TyW+nsr1lTT
+d6XYh6YBMRjkMWym74a0sJ51H21aJcK/05/oasACgBZMa7RSTA6Xw5t7KApqhcHECI/NC8xImlDk
+BW6ac2ttEm3zvzbSHurZxQIyKGaY7OxZc32q5UUjEyXDrzs+tkh720l74gY+kz6VZ+SNtzfJsgax
+5D6mTfdPautuMdPgzMLIK6PvzZATrMbjE1ufaXQ51YzDy/VDs1tTb7f+dCZw9PlCF7rQhX73tFOV
+K6UqvelNdJcU2pRZiu1UX7KqxQLVMhiDNDV30uxuRHGr1U0OtY2d986rWh7nIttVzg555GtQUOzZ
+E+pGJWHFALo38xpHTk54Rq+zqUbWMjkoQFMt+/mqHCavbnVIuD4lA1ZRKFCHZ6IL7lZnzo92OPBw
+mA6UzAmE7hhuPy7YNc3+QERmsVkgibR0Rklnl2aope2DRZwEwmSTqvNhshkmGM2sTAz1uTpDjje5
+pozyWFkcjxEa3xFC+27AM1wQ2knqZUJKKaGorfNkjkzvueiVrpc8RaHtFSuTlQBEZgy1Fukcb8pf
+r3iojgEa/EBWCDHQLHxNcs/6DkBPmEJEfqHSsL/a0+z+8FjKvNuhSlHwh5BRVZ6RgFZYaAEylD0Y
+h7uKlVoCvszMild/rLOpqeZGOjCLDjqsKstVuGEmKwutlCVuasLe1RzxFSxmNLjXWmcjrSxKdM4n
+0BJy2QFj87ThANAmk7yqSk7XtARrs4HHxgMiN2xn2kk7p7UStVHHY0HW4Q71xtcaAMfChNvjA2lR
+ug8ttjqr+IoBOcwJcwXKWTxzZ9fg0QIzAyeUHa4K9nCbZ1VDNc6FBka5puYDXoXlnWi6rR7SzBxy
+9xYoLm+LNiAd0WIn8GB4BKpHcjAKYd52X1E8ekclUGwSI+dMmw60lTSG2Q0T2BGaw7wGBikSKRdo
+igqOdLHKnHROYCnEHvUa8zUeHA+PUoUJhWHnkwCaGUVXzzPk8mExJUaaQ19t7jXgXltlzd4Slaty
+DAtQg0l2e3e4v/NpR9hktou9ewxo9RxJ9nXTM9Eac8n1tTjONs+Ox1+SRTDMwlasTMVkcCkXLZKB
+5Mo8g0mbFchrrUjwdnGdXehCF/o2kN2/DkQRLn0rUzGrtR4OB0lG0mhLCBAyUQJ5pP3ElI6kld1U
+dsXqrFpN0FwByeCl2nQ/PRz2d9o/mB/MzByQimCRa531RWQGK0Zjda9z7VElnXeKco5GN6IV0pDo
+gKY6XT3sr+drcxa3SEB5wiq2DoZp0tohN2lH3HDe11u/t8K97wopuGfyCRaEFnn2SlWuxKSZWbES
+Gtpcq7sDidAiB48m7EQjD1YO1eb76nNIGAugF1UwbbfblVLmw1znOVU2YsRfmba3Gs+7QGjfGXiG
+C0I7SWbW071wrKl05UzLohp+Y9O55J5hQqEdEvRaHUubGTG9arbVPk8zzJBV0i6T4NVbxYbmSMoI
+aVbxEZhldnXzokwviGdWXoiUDsQOIihKcA9fv8TZW0snVM8o1jp0Mz9Koiohc5i7ihWa1Ui3ZQEn
+YILvqSvyCnXPui++3/uO2vWGpkOprDQZ5QhXeHGfIZEmT9d3848rvVdjQGX74C6SpXmHsvJJw13G
+iB9rceNGN3ihJtMemonqitIXDaKE40bwlirIDreRDpiBMowhIxwZ1eDhhFxwwTxK97LQygk30nnq
+Hi0DjRZmMDfUCYdJD6WWqTqN7o4qeStK32uOsPvQ2oozM0xF1avHzMDNBc99AVpB4UCcAiqq41FW
+3VSNM00y2mRWBUBugYhkgmZESDsAWQvRb+vbW7GQcdG3Z0cSaLGv1XZxRAC8kpEOWKDJwQrOoKNU
+TE4QvsPjFe5ucFdxJVCcoop9R4CZiKdxaS/FLUe3Un5vZhJYMYQvl+lljVxSoCb+McHJCvjDw4N7
+jXo0coRxVgFym1DsT6FjJY69OS+Yl1+4OZirPfCV0QmL0BVB6q/QOLLjkR9xOQ2pGheodqELXeib
+pC9/DZop4FG5vrne73Z3d3f17r4jtNT01X1oxww1mS5B2tXV1bOrMh8e7+4xV9QaCIKlory2x4fp
+le8eUHdmZgJcBSggiEI5XEbsdtP+aifDw/3j48MjI3tki9A8xW84kyyUMEeFtPPddb16Nt8UcVKh
+PwXQuidqPATA4TK3K9rzqV7764dbf6x721nWD5MgW8RO5HQQHoqfWYlJK6Xsdrur3R7k/cPDYZ6p
+SEg7UGFZNmhyFNhc7N5xuC/1EAorzSxgK8s0Pbt+ZsXu7+4PcrW6Cd17hw4SN4hziOT4mvRdgme4
+ILSR+osRCG1Myei/shXKbupPuzJXnVIHGnNJlICLiPKl3s+nUnMGVnoUU50C1WozeMtHMzbvRrtj
+L2XYivWAFXDJpt1L8j3yAzO4T+ABaEFQkrtqIYECwd3DACUccQchssNaz+KkhJeZmKNaK2GG4oGT
+OAkTvFBX1AvomfzacLPDzZXvC3edw+xmTAUORXoOnEK9iqSfQw2GCaPBOOi17Pr1ssej3AWA1UmZ
+FbNSvdZazVAor7XKp+IwzrJ9tX0tu7pD3btmRyQOBiRpe4AgQrHhwf27p+MEZifafmiNMxcgKs9G
+HpSbGx4nHCZ6oaalBv4TOvlmcaZ+7agz5kfOh2l+2M3380w/zCbKhdmltlflJie4IxSiWKlmFdVN
+sdIFd68t3LylBXtIsYhsEJw7t4IH8cGLVMCpFKdZJAcAgJXGbJvzaZUZ3GapvS9MuwLywDLSx2mS
+y4oJgqMlZfqC0KrBrcxmlRJnw+OE+wl3BTeFEVhBtFBLRKFhM6aHcfGHj4CNTexx9f514dV83t7c
+1HShprt8AgU+Vn+4f3gtTCy11llw+Y4sGbbCFu2I6qrutWaqKjOyRG2JYbMqssPKVsK11w8HU6nz
+PB8Oh7K7mthS6NkTMpqlJzlF1H9ehzJ2PKaBRtZ3oQtd6ELfCP36H/+eLXub+/3Ve5988vLli1c/
++9nnn30WxtyWZp7JEOugp6XGV9PizKapvP/++/vvfayH+9uf/fzh9tarR4p6ZZ3LF6/nf3v4/PP5
+cOe7R7dDg31yhMnQHe4wu3pv/+HHHzr0889+UT+vtKYuIqNtRMV/6AI/dDjCVRHxgHu+/+zlfH3z
+L+U6i8edYLmbYK4+IBGCy7R7vn/5g5el7H790y8+r9rVyWSCq8XZrzg+lAJZKGg+tMnKi/+fvXf9
+keQ67gUj4mRmvau6q/oxPd2c93CGmiEpUrbuijb33mvo6sO14QvvBwOGF17AhvcCCxi7f8V+2D/i
+rr8IsAXL9sqybMG2RNmSTVgSbUocDkdDzpDz7Onpd3c9M0/EfohzTmVVV/e8KNEWK0hMV1dnnjzn
+ZOY58Yv4RURcnWvNkaGd9f29vT0X/SdZMKGDxAwIYg20BXf63E6l7wq+WiuQAUA5jpPmbLFQ6K6v
+bw361nLg5kMw0uo0jQ3o2RDazxk8gylCO0yiKCoWi/1+n4jMMMgKiCggriCqYekroCoUCUSGyuWy
+iYyrtOiy24OAkEu150rQBlKac4vhsF3VqVhYS58RYpJESSGCTBKTAICVzFdDFEBhJMQScDVOCGTG
+ZrMifYCYoUDGEqCwaCpVm2WswxFArWXh8mOMKWSSZzkGi7q4n6rnMbNl8d1FAoxFDDCgJIAzVhqc
+VoiLCUcFIBIG70Ur8wBAA7UY0Vl7ImOYxdoMNQJQQYRXXrWLQ21/RM90t4OIKRYWm9k0BkMsaWoZ
+GAyI5cxKmmI9jblXEC5ZsgzM4vPjoxW2pJFVzBoKfCjRHAA0zRNKbrkhQEIgXZoRxVhT6BYLnRL0
+xAwIM42Syvk3RmWUbs7KZLNoEcRSlGE2iPpt092P2oVigdFGmUEAAcu6DI8wzn2WThGlMRARM0OM
+LqcoBGxwkHROomAbLRlGAz2gPhiWCDBCEmMiAGFrreXwprhchTkDGYZh+ecnPFvuMc8NdysifQZE
+BFySDgAxwkaALKCQMKAl6CD3MU2pn2EnhY7FRMiCICGQ0VBsNgC6ezOHOu2+hoOnF4an2mMY90Kq
+dcYYg5FWNBNx5eBZgH3oWAxIBH3APks7TipJQUxGAAWBIoIRYACDQITWEJJAarNCsWAiI+o8IwJU
+y6l3VsuwRI4GXYuHZAgGNVwTGNAAotKKkaBQLJQrlRhLBmNmFhBAipB9AmcchciY3+8VjCVJIiJZ
+luXR2ugdm8pUpjKVn7WsXX3XITSkWq1+olKqFeP+/btrH9wAAGNc1iWPYjgfhxLqnID/SURJoVBc
+Xi4U43R/f/fGjZ2tLbaMDqFxZtp9+3C/s57KHiRdxoEgiGQAxkU6MIu1kTHx8dm5mbmMeWNts7/a
+Jx/APOSOoPAQoQm47NfKqWdhtszSsI0z9ahqbiQlHOU5PIbohg9CUqwVmivNJC3cefCwM2jHNiJA
+BBFkCax6CJQN8eZIJGMAQJgjMAvxfHNxzsRme3/v/vZ9tixgga3P0mwEIgYEsMRdwM3U7ma2CzBA
+SAWsSAYIrSian5+LarVOv7e2tTWw2TDhQe5m6M47Pp4nGXxefv7gGUwR2kHRSIylpaXZ2dler6cq
+WvgeQ5784RlOE3XITYBYPQu22KisnHjORMTC4AM6nSboCm+AqzotAD6Tq/uEQIG9TIAGAaFUKp4+
+fSoWsl1OTAEJWKxgqAnCjBlCF3inXOwaaNy/y2SqZFjAIFpVMlUtR4BCsRDHUZqmgzQFBvVBOe7k
+UEYQWs79IYgGAZltUoiqlYpl2253bcYCBGBEiNiSmJTK+1DYGHBnp5v1dzJ4aKUDz/n2HnyESEbL
+PgpWisVavdZv7+/s7iJrhg+lmDtmOXiIFronuTfcWf0RhahUrSSlpNNup92eWEZrDalvyYLZjexO
+cSMtd4BjY00kwCKRSKS6K4LGJIshLBTjpJAwSLfbG/QGaq5TL0RAh4wsIe7JL3qeyZABS8xJVWot
+2xLhTX64laFYPmIlypMDHTBFQAQrNsMMipDMF00z3k73e3v9YpREGKEABz5DLmjPBd/5EDBDBhGZ
+mQijKC7ESaFQYOZ2p5tZiy7HbqaFXwQRJBaJGNmYvon2+tDvQiYCgEZLfwtYIRNXSpVyhYi6nU6/
+1xP2rIYQr6eqvsAkhDYCAe6XCvV6A0B2d3atzZAAAUVcWhfxNlFG7KB9KP1t2tunqAPUp76FSIRN
+FFFkEKFYLlbKpcEg3d3by/qZutXIvafeheZ3Dh82PeyKIQFAICwUC7Va1RjT6XY67Y61mU/7TIAx
+ikG0SNuVqj13/tipMyeB96y1SEVEw2JZLKJ1yTcRrLXFWmFl5TkTGwZG9OkhAUAAQ13PEUNqSAxL
+AGoxdSYVza1Va1RffPnyTH1BshgtMTMDA7ErHKrPVPA3O2s05xEaADSbzYWFBQVvTs/I/XUqU5nK
+VD4RWb16RREakbFz83RiudKoDh7cX79+zVrrTY1h95Ox1XOEqYRARKVyuWUwWZjD7e3tmzfW7q9a
+togkCEzC2E9lp5tuWNzHqM+UKi1D8xsjoDCL5TiOMMLWqTkr/MHDD3of9VAACUe3EREaoW14w6n6
+tZiY0sW0cbperVXLcXliRc6jRT0DTFKoFWaPN3GfNmFrfbBuLBEMN5IA0MJp4Ok1ZAkAhSUSgyY6
+PQdRyWzd3rud3c/S1LGKhFUTFTECCGDR9AB2rd1hbgv0ECyAFbZAyADnms3C4kJ3be2BSMdm4NKT
+jyGwfDy/k7ESMY8pP5fwDKYITWWMzFMoFM6fP7+wsJAkieor4QCkkTfIOSdgqMqgoEdfAglFM6V9
+kyllUn1ODGw0+T6gCBgAAWRExlCsHkgALUYCJMoYJo2caszOvPrqq6985iXDEWGECOI0afAGJAtg
+CXrpYOuH3/+7N779FkKbTB8gE7TMmQCQQUKq16vnz59ZWJi7c+feT67f6+z3cUiOytk5MDCvvJ7t
+CWq6KjJnJ0+tvPrKmcFg8KMfXVl9sJZlAmgAiDgjQMZCT+5vpbXNfmXfVvtQtxLD/+Em8Mr/96eB
+vRDFyeVLly58/hff/eiDq//wvTRNozgiTdjqnPTqZ8jrrbnFFwBEkIiIqrXqpUuX5laOf3D9/WtX
+rva7XQBAIrWQWeqmsrnbvT+wG1ToWOoJMoARrSuNhCA2s8K2kCQLZ06eff5su9N998q7e6t7E4xk
+AILsVmGHjnJ2MmZhJjaFerJyaam11Nyvbz+Q+wMfyHRQDiEzCINGa6VRlU6/cvrciedv/MvNW/c/
+MinFEiGAK1wmB9iqIm59BCEyZIgti3CxWDy9dOrSpUv77c7Vf7myvv4QEUWsCwsGBFRuIQkwUUrR
+bpZtpOm2yB5gH4EFMrYZGlqanb30mc+Uq9X7779/48bN3qAnMCTOje6VOLYi69/9EwF3W63Tr7/e
+7/d/9N3vPlhbRW+6AyAR0mzLhggo6UFnh+Ge7W1LpyM7GZRZAEEIIxZMkvj8+Rcuv/j8vXv33vyn
+t7vdHURCTWMa+iQjNNDwu+7xSOpJxXp96fKLL9br9Q8+2L7+/s3e3j6zFi0lRAIxBGhMb2Z29hc/
+f/E//IfnI8PMVoTIKKTUsuVqcxG2GSWY1LGDa8AZQqZ5MjWMEUGLDQR3ngOO7DmQLIKupKqIxs4L
+zzZnPv/5z3/2MiInwEZYPXHsUvboxEso8qDOOfa42bnUjDG1Wq1SqajzMDAhpwhtKlOZyicoq1ev
+KAudKKKVFfzs5fJiK324uvH+T/r9njdxBYojHERoOWwgSFSrN07NNOJzZ2F7a+vDG6s3P7LWAmrd
+GQDILPYy6IgZEFkmdmszgHL4Nbw3iWKpY4vnWAQfUu/DHlt2CkvewBpKs+U0KddBERQc2H6dq4v1
+xUpSfjq6gogIQaFWnD3ebG90NnH79uAuWpXa46AAACAASURBVOV+CoyYHiX8A17ZQ78BRhKVTMW2
+BKq0Xdy9Y+8NBn0RreYirk6AWqPBIvYBu8IdkT5ACo4QxmCBhG1rtrCy0v3J9VWR/Sz1+uTI9dF3
+IW+0fQqE9vMKz2CK0PISwuKzLHv48OHu7q4xzuEwAuEIx05xf3IaOpIAATJbTGjhzEpxoa5EMAAO
+Ia2aoR0BtIYWADK6ADUSQIZIwLCmXFDSHlqATrezf2+jvb4DGYAYABjSodx7KCAQGczSztf/8u0f
+fP+tLEs1fkZQWFgAyIBBWl5e+K//9fLFiyvf/+fVb37z3sb6Hoy8NkMJ69zY98Hv8Uu/vLC4+Fx7
+v/PXf/3mO+98NBhYnzhcSAABMzGpUMqRxUQgEcCgj7/9Z3/i43+oXK2eMbzy6uX3731089t/s729
+peFDrhdHL77g7USIZMzx48uXquVWo/bO1Xff/cZf7u/sOtDk2rNMAws9MSlpFWsK6Q/R1cliQYFC
+oXAuPX/pwos7dvfdK1e3r2xbax3LLGeXGzonYKRroMgIBBiSpejY2fmXL758s/HBj+TtYQzjgYgg
+OEQUt2VgqRqdevnMmYvnfvjBv/6w/a9pP4vAIMBoybBcV0S/JPEF9zQoq2SLVE9efuUX7Wbv6rvv
+/6TzE2CXGAb9cqwV9AAEMAXsoXRF+gIpgPXOVAbEM8IXL5xvPHdiu93+8fsf7PS7wWyXnwzIETgP
+W5RvzzQqr70G7faNf3nrvX5f2PoAOq0V4UCFYGSh15f9thQ6UhxAwbLRXJQ8QEApFmsnTpz4z/9x
+/up7Gz/611tbm/cD9z5nTRy/WyMzzgggxkSlCr/44i+uPLc4SN/94MaNLNsItwkRASMWZM729+cf
+rN68cQPZZtYygEWjRdXcA4IAwMBs4wItnWqW59mgoKTCGZAgkBaOH5scv5UzkLAwihAaDUlFRCJC
+hE57/9bNta2HXQNlkFg0ZyxagQG4ONKA0NCXessklFQHEJFKpbKyslIqlaIoAl9oZAizpzKVqUzl
+k5De5gZo6iYTZfUqDXpJlkK3M9jd7nU7OVvpZCVhuEG70F8qCEunHWep6fezvb3+zlaWWYCgITBT
+yjgAsqgEDvJ5nhzTSVAgiwn3qDgoCwq1jd1mm2UH3ESgzfqu5L4UAAEE5BmbZEk5KscUPzLL80Rx
+xsXYRJWY96UN7R3eAYa8D20Sm9DvxR6hxRzvU2dQypKybUedbd7tcc+rBADoJkJthogpwABlIJCK
+lrT27TYQBoWCrZS7cbwLsuvV4xG7cUBoMpyhA3vwo+WnB8/yLX9SMkVoE2QwGNy8efPevXudTkcp
+jorTRIQM5YmzI8jNgS5EQQLI0rRYK772xf94qfFKDJqGVF9wcSX/AvhwMfzI/t2OwCcGFEBEdpwq
+2d7efvv73//gx9cGvQxRERoobTI4TgxGiNTu7P3zD957sNph9sFxIpqvD1GMMYWCabdn08Gx/f3G
++kNae5j6KJgxRHbEK4MAaIzZ3S5n/YV+d29zI3lwn/v9zB/gFzP3n+OR5yLtoLt2X1deBIz79ai9
+W7GDpNu22+v99fXcspbnXoa06R4BjYoxlJULSa9dSftmfy/b2uhtbYGfcXerSASsY5qieDdeKL2s
+nDeISnG0Gdc6M9zBaCOxq5ylB5fgYRKOcQmTJ2DJFtqFOtVLWCIZ1hvIL1qqLg+L700SBmCDphph
+Hffj/TVeG3Afh8FceTOd+xg6JxCImSggVahsFva6jcF+2n1oNu/xA2vZk+EcvvYuIIsCCNYxGXw2
+fQ88pGZwr1xq16ubhWQVZMsVSx7fj0Z+HiIbSdJv1PuReRhHd5llyAa1+X1Wr28hzaCXQtt64yeo
+gRMFuF2INhu1bq3cNrSGvApIKAEEjUFhmfyoC4BEkWmVy3v1aruQbCGsAmyMHCFGhFj44cOdb337
+r65ea+kjYYwPWwRNrUkohIDMXKkVX/tPn71cWzaICIxiUdQBP3ThjdJdPHJD8KmKQASEBYkios2N
+je9997s/uXqLpEJYAJezxwKlqAXiBQAMuEBsRWjWFQcHRw9eWlp6/fXXW61WuVwGj9DUSnX0LZvK
+VKYylZ+epO191RPEGO51TDqIOcN+j7tt227ntoUhnyms5weVBCLMkgjTXpylJh1Ir5t12lmaQdAQ
+HAFhTEMQgKE1EQUkYepikhYAgTpG9oQzHlcPDrNw+90GAaUtURYlmEQQTWCYeDPZ0cYyQQCDmCDH
+tovdtuyzsFcMcjrGUAvA0LtQUjuBpE29QZKlhaxDvT1od7iLoUqqkC+PywCMolVSM4Vnwb6PAG3E
+fhwNCknHmD2AvVzYxdisPDkiG5Gfb3gGU4Q2JvoCWGv39vY2Njba7bYamBWniXrK/EuSd6CJCLIS
+bREBSTAd9Er9cr/TM4zIYAANGQAr4jL5MQIFeqLvgCacYwRLgBpUJUKsTmwSK/u7exvrD9OeRS2w
+5gziKN6LR0gAePPDm6sPHmbWVabWMu+GUMRZ9IUNQoJYQEhASNjHKznuE/oRBhtMzlsYYAeAoBKi
+IkSDQMwgzAF/aMlDf7KmIuH8EiSSOTYgoIhFYeVOiljm1B84Vuh4iNCGP/NuNDEATMCqEWtUr7+c
+b4HDaovePQPD1TdkbYjR2CiysbExZRGkBCnmrT/htvlf/dIXps1PFVoiawxHJCZUahlzoD2OqCOI
+EZnEUpZCP4We+gfRe1Tzq/hBV1H4NcYkNTY1NqVsgIM+DCxYD/nVPgCiAXlujXblBMRHXepYDeIg
+itI4SiPTI+oh9iatu485zgGhjaPM0ICo528J+n+H9xkEIWNAhkxg4Meu3RYUAYmBuyh9hD5BD6QD
+YsQ78WR8154Az3RbQTCEXcIOQhthH6UNsA8gOkWuWDogkvT7vVsffSDSLhaLAhwbHKSZAERRAmCA
+SbOCMEvK5W6v76IZfa5HARYA1CL0/lkVcFmGwH+rmyWyOntJrFhrbTrY2dle39gw0AOOCWPLDEYA
++oADPVsZvOof9exF98Cr+alQKPT7/Txmm2KzqUxlKp+4CGe6/zACsEXHhWBhy5zp7jsaQD9ixh0q
+CbqoCoJYFHaLL7OwFbEAnkoOPuQ5bD+U29MBnEWcNIWWEQS0JBlAOrxKfq8a/grjuoGAoEViMmIw
+Z7o9KI9YjcXxJJjEgs0kZeCQhEtg/OSDRmXdHDO0ljgjztCmkKaQAmi3SEMERKmMwOhzUkNuYhCA
+EDLCzJA1JiVMAQajMwGTfn0K+bmHZzBFaGMSaD9aq1rtx0FZEZ/RMZf+TX/TYxySQCCDwMYYzfJt
+GTImC2AFDRoyQMgWvf8LxCePJ402IcgALGAmQAgmg5jIEBEzMZFAbCKIQZQN7LsQ1gXNqJimg8ym
+LC7JqYdVJKB+kWFGdY8reDgHoN8Ajtjx/cecicgHh7ks6IDqYHGQLI8NRtqZoAmL+4HAarEBGUYM
+OT/NJCfVgd6FO+KMR1obbNx8w8PWcMLpI00BERkCQtVt2Z9DIwFwbhz51kZxEgIYJPI+/QB4Dx/S
+gRFBcK7o0Ihdca4h2Aj3Ln99GZ90F20oKEIiBIzCwBbYOiQWKoWLtq+fAzYVGMJ0tzsigTFCxAgW
+JBt9BuDIWzcmgiiETKDp//MILb99KWgUQHZ2TgIggCx0GyQTsALsA8wsg/XxgZOvDIfMJEiGkCFm
+IClACpD51yS0JoQgEKVpjxC1yqeAMQbDOiEoouXJUMDokAjA6P/iqtJJHjyGdyfcDFf1ENQMRAYj
+FNIqAPri+7SnloweK7lQQPe2e+jFAGY4eL/KhWVNjVNTmcpUpvJJC3tLrqOqOx6EsAzJP3mz6UTL
+ZPgT+thsXxkmKCHhcjK6l0rOAhvwFSMykSI0JnAVP70cgdAgt6yDa0cZFk/HcvTtoSAIMqO1kHmE
+9gR2W4NsiS0xI1u0FmwGGQLySK9ZwOoulcetQ4QGYImYyBJmiJnulweu9YzyaYBnMEVoByUkb8zr
+K8PkDQccaABeBRZXMEvfZhVCMogxGQMGMqaYENE6DdnnbCMQAFJyFoJFYAcqMAKMGUAwImOASHKp
+zIPtYsw4IuiKZivA0dwmIgBgw1rmlVb1Nfhfc28N+hEheK8DjP1VB+7jw9C7VhAQXHJZALW+5Nci
+1+DkF9bZtGj4yo8ucuJ/jC82YXFwCyiKLnWCrAo6jxwQTsScpj2pRyhIgobJCJHgyEQcwJkjjYyB
+VNHsnUFZPmqBEi+H/RlcykoQREayQDksPTHOduSKfrKQ0drc/4KWwULOhwZuHwtYlAMazIU+q2kT
+LaJFVN4De+JnXh5z5/HV6NRMhzZH0uCAh9y/7gENyBhBa0kLAAhaUUMHZoKuTkuI2jysV6PPh/gf
+VsAyWE3HCmD9AehrpbHo7GiOUwQS5Mwqb9V5iAVBGIREE2AiC6AIgUQCRgAEbR6euUvk3m4SIPbw
+DAyCISCCiNB4RYMBhAiyzAqKD5jUcYYblnfbDlGZs7WMxp45dsDUkzaVqUzlExYHz7QikddYvHIz
+POrwnSZ/nFNsHKg7aMQc2lshWLhGNwf3N7dUqj43RHTjGoUc2jG3J6Gv9fLU4hwEgspwGWLOoB6N
+XnZsyAF9KQJ2xllxlnMKESuSA6+jyM19QEBBFCJw5WV97MjHJz8bePadN77ziaO1KUIbkXxc2Ugy
+AAD3zUj28OFTr5Zx8eWfnNqvGhQZRC0ORuSqIGtSbQ/RArhBAHA2f0uoYMsYBCtirREwgMqSEmHR
+EvEY3hy3Arj2tB6S4hQWRG9/CkchCVAuhcGo5hoWPYc0DkI08ItWyIQegRgBLQGmBDBtfTSPkcBY
+hE14tZ3/TMuHOGfOhHwOoL6sA8uOP1jBIiMLWAtsYZj+cbQn+U8hUYhrU8dMJPo/EqMJVi4YNjay
+PB3OV0QP9sZh3thEeGB2kGCW16oBrIDVYmsO1A4nNzeIMcg9OmoBUTtZhplVz6djL4KnMeiJnkHp
+Sf4C+YcFwWUiRUZiJCY/ygN7khxqHRyB3DyEtJrYRAuiuci3sFFKfu6D3VSLbruuqV9X8xlaQIaD
+9yefhflQsc5qKJoXkUNHxmZYxOo9RDBoENiy2+kFJSwjomld/W8GJAaJUYxPh6XoG73Jx0Woe4RP
+IebQxakCKncRHfU0A40PDz7P8XSaMvL+HgBgynjMEwSOmJqpTGUqU/mZydDmiWGPGwdejyluYcMD
+e+WjTKgHmiGnDUgO8hzRkZyiFo4fhp4/03I73JjzACy/V+GBv+oXwegJXmkTl2I/5P9Qe/YI9nPb
+UI5TA26DRIcVEXi4JY909KnlZwbPPsaWn1qmCG0oI2k/AMCXrNXkDfqrU0+DDF8wAhIOiUNRhJAN
+pYgaqs8IiMaFREVGkFifYZ86wwiAiEFXa1jXD6OhMyySMmRMYlz53VwwmNNlA5ERQX0s6koDzd+I
+yMPXVPQVFPZp1SFkZJ0kY9ajkSlzL6kGoXk4hq5fMIIqDk5a/it/mjpOBAMDwen5MsnPNaEtXV5A
+fYhsfd2qR8tYwg7VlcW3pU0HeD4KFrT/k0bluoQ+YboDTzmQhogjWvIYSJvkSXOmRGWrolsPD5rD
+Dpc8xlQjl2KzsdOHsMd/mPTkK/r0NxtJ0xcefJrkQAuHiwAgatkDDI8rADhP1MiButeEGR25LOYO
+OfRKj9cjkSNa8VdDBFA3FAojUkRa2Nq9j5oph72XUs2UBBwTF5ELhjPAlESpj6jcFwHWsZEgaWFE
+IdCS9yLAwiIgBiUCIERgsQgZ0cEQ1/DcesjmEByE522M1w1TeDaVqUzl35AM1R4c+QZzB+R25rwl
+eVTQW/ZwuEMc0FZkFLwd2NECa0g3Up+VerSDoeWD+ov/FUes1qOxEvnDJ2loQyXB6xYeGvne5SYF
+cv3LfzkcuTP7MgMz+iq+EKKlxYOxoRY0mhUgNzGuD7rPHRjL04K0TxU8gylCy0tQStDlsB5/hFSb
+Dn7tvOTJQKqLpwSIoJkKMiTEiIRgYBHBkBF1oAGQgBGJRIwAMTCAIYgYLZMAE2CUQWIpBmPQuEuj
+pwX7aCtVXF2CnmFZYPG52lD852BH8ZYjjYwRxQlPPGUCziHgf3eZg3JVyx6/UXRFnzmUEBg99xEt
+TVjuEPkIuuDRjSk2A7FiWSwDMzi/JLjlbWRRmrjchOcJfIidDWgv3Incgzd+OiIRudDHsf6JKKnu
+UGh9+KDRUzsIiYAIDSEF54xfuPM0j8Nb9nXa9UFCAZf4bzI0f1wJtShy9BOd99GdePg5xHeP9VND
+ytE7mviJnoWw+T3SoaR3wzhwCojEIqxlu8ETUsEXp0Eh9ypqGENiuBzbAaEI9dGZaxCQQQjRgggA
+oRABiRhBQjEEhGJAtMoaibg8jeSYjW5CSJ2fGPSDoSEAYNx7FsBkiEA7xEYwlalMZSqfiIjfBg5a
+RZ9M7XeuIb+lP9leFTQMx/E4ihpz+OlDbDiWivnQ846KgBhShLTJXE62PP7LX/hgd4Qd0VGjKXxo
+tNs/xu2U4m3r4wgNPbkRn3Rmj5JPGzyDKUJ7UjnaqBwi6y1BBgAoA5ABgABGTElGJROZVFhQ0++j
+AIpEIBFzxGAcvQytITGUASGCybCUUaFAsRhCZCAGYED0OQGcr16GuleILQkpKMHH/eeD65g5hJ0c
+nhVg/OXKBbagNivCaZpmWQaARIbIKEIb025HG3StBCAsTp+WQLLyZZrUua7a5YTJ9/r7EDaH5JZh
+gISjozuS7y3eEAUgSCLIVqzllMUCARo353lnjuOgHxR0My4iirXSLLPWAoAxJr/O5l21AGCtZWYt
+jT3m2kVEAkJAtsKWNdYRwMHSAIsRA8bF8FftEiHpiktgQAiEhAEBCUmQIbBmc4BoZN5x/AtC4sym
+g0GWpsHtPEYVhqPfHYRcIk33ZOqkGcG8X9Ed4p6HIXb1mzOGe0dkAIhZtEvGEDOO9ujRom4lAGBm
+vSljo/PFUvX5M9YCszALai16ZzAhNSSi7yiKOs8NcmJsJeEGWswkATMQFIfQwGoEHQAAGGT1ipMA
+IhoURBsjl1CKBAljhGBE9B0HEfCvjwssdA/pEKQdOgsHGbZTmcpUpvJJS9AcxGn+OSYRAExACpMX
+Ob9XSC7YatjIpGtOFhwy+QBGLNUjJx653oYgtMfll4xvo/nwBwHWUIUcLsLRKZrQv7Hvgw/NsxkF
+HEUnGINHouxc68NRumxWgsP/J/KfnhS2fQrhGUwRmsph0fBHaypjgWoeH+j6gfpcG8GYsZRRNTVZ
+GpUzyjJhAkGX351EIhDDGImQ5vMAZGPEGIuAApRB0VI5ocQSAgkSAwkSkubsd76D4EkWFkFstVov
+vPAC4oh2q581TeXi4mKz2axWq0tLS88//3yr1QrHwIgqzIfxu4gcIWp5eaVQKIjIqVMnu91ummaa
+YelwhCYAV/WXF154IVhoKpXK4uJisVicmZk5ffrU3FwL0UEU51kfVdBD4wGUKgpCxOPHjy8sLNRq
+taWlpfPnz+/v7wet2rVwiPMqRMeqXh5H0XMnnqvNVBntydMnUttPsyyHCsE5SdgnhTqAANS+JiJz
+c3MzMzOlUml5efkzn/lMv98PBweduF6vLy4uVqvVhYWFc+fO7ezsKEqBEB0ESIjLK8uzM7PlYnnl
++MoLFy4O0hREo8gCyNG86kYnbcTjh0M0WywWjx9bLpcqjfrMyZOnmAXYqvPQewlH9xkMc4eaY0IA
+WBgBnnvuxHyrVa/Vji8df/755/f29hQbPw4e8sP/sf56/PjxUqkkIidOnEjTVASDFxE93NWJPpBM
+E8jfUEGoVCrHjx8vFku1Wu3UqdOVSnUizBu5WQdCTxWhnThxotls6uP0/PPP7+zs+OMBkdQXhUgC
+UCqVkrgkTIhoIrJ2wCLkHuDAxRRAICAjhYhrUdaMBwapZqgLJmMQARJNbYwpgBVEUKeZskcEEEnr
+LRiOTTZLUiGIEGJHnHTLj4ex3oYDHrxNvAWHvK1TouNUpjKVfyPiwx9APMliaG49uLAdZolVhrln
+yUguUv2IK482AACeP6Qxw+TJGoeeevgVMIRtHQLTxmyUh6/JQzfXgXzA/t/8qQd8bIJKB/HwzDnI
+tFmfbs2TtcbC30ODIeWw4rSRSz7CPHiofDrhGUwR2hHySGrTQXE+LQQAIKGEqcKmYaO9Ps22Kd4n
+KyDIzvmLCICGJRJL4PwaDGCJLCEbEEBiIJaYoZZgISUA0iTbglaTz2LuPdSPVgQBPve5z506dSqK
+IkUsqujre65KZ7lcXllZabVa9Xp9ZWUlVH6bPKb87/61VCIosxw7tnTmzBlrrTHml3/5l63VUJzD
+EJq+5/+X/vLf//v/LgLGEDMjwJmzZ+fm5i5duvSbv/mbIhJF0dAD4DmDExVrHV0AM9Vq9fz5861W
+CxFV0c8jNK+GT7izgsLAABjFkXpyVpZXzp472+124yTa3NzIz4AOTvOeI0/274VDi8XixYsXl5eX
+v/jFL+p0oS+DHlyaSZKcOHFifn7+85//fLPZHAwGwWOT55rX6/UXXnhhrtX60pe+dOHCBc97sIAc
+QpwQIxBSUHOAk6mYFojM/Nzcc8+dWFw8Fploe2dLbQshQ+dwkCOC2jIRWWYNepyZmTlz5ky1Wi0U
+is9feL7f7z+Rr0pEAP5P/fzrv/7rKysrvV7vN37jf9nd3RUZsu/c3ZcRF+GYMDMgGGNMFC0vLy8v
+LxcKxSiKFRKHHe5xuqfXjaKo2WyePHmyWq2Wy2VF1zmyiUNoItDv91dXV2/fvt3pdMRl3FRPaVhJ
+FPRqOYkIbAn6Nd6fyTpxBqlgCsSsLEchAQbMQFM+gtEJ0NlAZUuyWJABNblfFWGRSDG5pnL1ho9w
+74Z9yM35hM9jMkVoU5nKVP4tSQAg7kPOnfMECMCt4BLq5zy+qLlyNEw9t7Q+qchBNWviYYcY0Uab
+cU6sp2cXom/qELR4yOexFtwnDPzNZ5BPLTyDKUJ7TMFc9PxhB4AzxYg+lxFD0VI5o8oA6x2Y3eHC
+LpNlEhEBFmEQQDIixmUvFEGxBjPilIAJUCBiRAYiqRexOKAs0nghglAWKR8/5lPAAcDy8vKrr74a
+RZFy57IsU+8ZACh9rlQqVavVYrFYrVbr9fpgMPC0qFFjkWt//FUMzisRqNcb8/PzWZbFcdzvp55d
+yGMqvveGjdirPve5z6kSjABZljUajXK5fPz4cSKKoshTATHE4B7oHgbYqZgniiIRieO42WwWCoVT
+p041m00FQrnTPCvioKbuy/kSkYAgYr1WazRmbMMWk6Tb7bixgC9m4E4inJwrRDNCkjHGGNNoNBqN
+xunTp2dmZnQ2AkITEWaOoqhSqVSr1TiOa7ValmU6HMfVVPxp2URxa65VrVbPnD0722zpsyfAqAhN
+0GWmAHI5ogTy5i43Y4iAUCqV5uZazFwoRN1uFwnz+4X3Ck563oHChkFESZI0Go0kSeIkmV+Yz7Js
+ws2aMD259ry88MILMzMzvV7vwoXnrWVCBajDp8ghtDwx0jUf3lBUYkatVms2m0lS8PUzCEf3i8OQ
+SQDG1lp9WRqNRhzHcRzPz8+Hx0lEAIxWOgOANE2vXLmyurqqN9RaNoYQjIiIMAIBuuQ8IgASSVZI
+98u99Vp7J7YWRUvUQwwQgZCgCGYALFrqTYxyQVnY5XWWDDDtwSz3Ksh9cGFpI3ZRxPFv8mM8bOyP
+iWCnMpWpTOVnKcG+BDmPFQ7B2WOtWsMjhYfuKf/XRzWBk7GYt4DJBGg0IUx9DOgMdTivneR5DWNr
+9ZFWMxn9//AL4+jf0XXUzQXKgT4ODxv5LCN/d2qaVxsQaaSvYz16DOz2aYZnMEVojy+HUezGJCQl
+BEAjGFmMB1BqS22XC9tSYkyYIGNmsICMYARJSPPpCSIbzJAyQksCgoYBRSSGeh2KPewWyRHqBJXR
+NlxaXFSaY1K9++67a2tr5CVNU4UxigqISGmQCwsLt27dunr16t7e3iGvvUzU1YLbh4jOnz//yiuv
+djqdt99++8GDB1lmmYd1JMPBOYQGr/1v7k9//ud/Lp54GRlz6dKlUrn8wY0bb/7TP6Vp6mfbZ7Bw
+qeCHLzbCcBUTH25HRPV6/fLly8eOHbt+/frV9672uj2AkeXgsFVYhusNIkKSFE6fPq1ukx//+Eer
+q6sszmukRRPAswpwwiLs7o4itHq9/rnPfW5lZeWtt966cuWKRqPlXUPMXKlULl68eP78+du3b7/9
+9tuBnBmCshDRWmk0Gp///OeXlpZ+8IMfXLt2zYNhR63VLgWsgugNamGA4vBnEienz5x68aXL+/v7
+P/zhDx8+fDh+l91Se3Bs6P1aGjsnc3NzL7740uzszE+uX79+/Xq324XcmyIeMk5mcSAQ0Rf+V/fb
+d7/73ddff73T6fzDP/zD+sN1jZoDf27OHiEjJEzvKFZUn2Ucx/ELL7zw0ksv3b9//80339Qn3OHr
+cIOORGhKmmXmVqv14osvzszMvP/++x988IGOznXK76na9ObW5n57z0TEVjK2zt3lKhOyAAlYAAsC
+KAbTIndq6U4z2xCbJYQxUgQSk8QCBCioflFNEAIGQAQykgxQAFmwD9SGSgX6VSALYnJJm4dIdZjm
+MvzzGDJ1nU1lKlP5NycYioo+rY/INwTw1G6voQrCamzH8WTKj9sJzxCSkOr58Zo5jEwEklNhjhaB
+g7uxRkAgoM8cNnbCwSYmtuu2Gr87Pr18yuEZTBFaXo42Gz8OKUiRhPqYGUGrIwFLlEKpC8UuVNmU
+LFJKwqAlpEQLNIsgijo/LKD1mXAUCaQJlnuQDKQfA/nU6Cg57Uu50OCd4AI//OEP79+/HzoWMoLo
+r0S0srLya7/2a5/5zGfefPPNv/7rv97Y2Dh8+Id9jwBCRK+//j83GjM7Oztf+9rX3nnnymCQHum0
+FwD4fzxC+x//4/8FByOgUqn8t//27BAORgAAIABJREFU62fPnXvnx+/88R//8dbWduiRjDYwceUI
+CwoRHT9+vNfrffazn/3Hf/zHv/j6X+zt7R2GDo4QRCwWil947QvFpLCzs/Pnf/rnV69eTbNURmtT
+P7IRnfalpaVCoUBE3/rWt77xjW8o6S4coxim2Wz+6q/+6szMzA9+8IOvfOUrm5ubnk0XjAIEACdO
+nGw0GiLyt3/7t9/+9rcHg76bgGGnJjuvZLgvIQBUKpVfev2XKtXS2sO1P/uzP/vJ9Z+w5dFFVUbO
+G8o4NDp37hyLPPfcc9/61re+853vbG9vDw99BDcDEACJ/m+P0L7xjW+cPXu20+n81V/91TvvvCPO
+EnHYZjDSEHrWuzDUatX/8l++1Gw2r1279qd/+qd37tw5YO47SgJyRsRTp05lWXbq1KnvfOc7b7zx
+Rn504OO7EJHINBr1EydO1mo1QEZXHIBd3kYQACvoAtORDXICaQX7LerFlNUIiwYilJggAjAAwgGh
+AYlEAgKQCQwQWTBj7IrZMYMCZUUb7w4L2QxTmQLASAh6UGvyBQomyhP4P6cylalM5Wcn3kEUEMAT
+g6P8kqjAZuRvj27Po0TxJ/uCogdPPkRX1H+9yVAmJdN+CpqD8149OQMCfRSJzw+OwcA3UQt7hPiJ
+IY+nn1E+nfAMpgjtCPFegnFy3aFIBl0uR//SuoLCAEiCCRPaqJRSKQOjySY02h8FQGioRiH7QoEs
+ggiM1EGIMyAGZCFBIy7SKFc4DQMfWtlr/X4/6PcHe0pE1WpVw2l6vd7W1taRCO0oQcS9vT1Nc7e3
+t7++vp6m6eO/kRsbm74d6A/S/f12ltn+YLC9vbu+vqF/evxuofd+lCuVXr9n2fYG/d3d3c2trScb
+lTcmFYvFTrudZXYwSHd3dzc2NgZp+qRNqR+sUCi02+3BYLC3t7exsZFHaO6KiIjY7XattZ1OZ3Nz
+c2NjY1KqfWw0Gv1+z7LtdDubWxv9Xs+PXuUx9xfo9bt7e7uWbZZlu3u7m5ubNrOj2vhhlIjxnm9u
+bna73TRN2+325ubm1pNPeJB2u83MWZbt7e1tbm6y5ScwTwabJECWpZ1OO8vSbrejT/goK/JxxRjT
+bDb7/b6Obmtra3Nzc+KVoyhKkliE1UGK5Mwmfp9lcIUogJnEEljCLKGsbGwFshmCEgoRE2GMWtcQ
+2OeARAHN/mIZUoBUMGNMRNhYQjEIoSAP+HJ5eMBQMmKinWRCBfDrHnjP51PM2FSmMpWpfIwyXIcQ
+HX0ixwDUpWxoxzywsOVSe2kb7sOQ4hi+8k0cJm7ZDB44FNYlXVjhoq67ecQ3OU8jut7r1UP64oOc
+xnzlp0Cwn0h9zNNMXAoTkBDTEYgeOeaV5E7WYRGKm2EP1cLIEXLIb3htPPgFCgtby9bmR3QwROXg
+rPiWRo781MIzmCK0w+RoKuNE0fcf3RshjENLDwIaIJLIWDSZGAsgICyITD5Tust6gygAVvO+MSBA
+StJ374YASOSLuDOFYFkAEGEf8IoAPmZp2LdRiwv6gm8TV4QnksDQA5c6/2ksWr4lBNTkFgSHpK9/
+ZBv6v4kMGVchCg8tJHBUV0D9DIRkjIlMFEdRHD8dKSKgLL0FGhx48DC9F8YYXYU1dOpgr8BtVxIZ
+KiQx5VbQx++S6NQQEZEhQ1pqDwK6gQNGuEc0rpxADbd7RrU+rOYOJzzZ4yQBTBJhFBnd3TTr5FN3
+KY5jvWtKxz3MfklEhUIBEZmt8u/1nhKiiCbIco5nT4ZGAmMkibgsXCEpuXBUjIz3x4uzzoYTDYLR
+FEKAlilBzkI9bz8HIiA+UHDczZibphGMNmaEeqTncypTmcpUfjYSRZEuWoaIyG16qJtzZJSGfxhC
+CzvIsCQPQmSigHxCSZXcKYeCNEfYQQQEExEZUkRBhCYyDKzG+dwZh2fSR7eXuwQBXgGIohG1XGPy
+tbe6aUdRpInZ8qa0yESG3D5OZExknDI2TPPtPWNheMMaPG5mIhMRGaU46oUiE7lR67UCQWNkGCNf
+qHIZPBzGmDiOD3oLjkRoQzv4pxmewRShqeSflZwePBTIudQOi8uSoB3KSHl59EGXCEigChsAMAOr
+Yzz3DjutCf1qggBAAIgMwCAuDQSzCAfvs4jk3rmxoK8RnJmPCwo9fzrX2djpOZg3+YqP2U7IVvJ0
+vdITh5Xf6NA+hLt8CFXAfRnYoYfd9ycVchvMIxTfI2YvjPGwYtaPKb5xZB76TGDctvZkDT71jTui
+zSc6fiwucYzc+9SCw+p8h1BWfKUHZlaMKsLGmFAXUERctmIMFlxftUB3anHxpQDDxQOBggkGHA2G
+wHnQETRUYBh45tJHugtIcOYPZwfytellqLtITvLjmrrRpjKVqXziMj8/px+IqNlslkrlJEmq1Uqz
+2SyXy/onl5riEDSkvO5gG6036vV6vVgsViqV2dnZubm5/GY6htCG2oI3makWF0fRzMxMsVwQlsZM
+Y35+Ls1S3xWn0KFgoDqNbx8eoc3MzBSLxUKhMDMzs7CwoFkDwqURsVwu1+v1QqFQLpdnZ2eVaIM+
+F4Bep1Ip1+v1QlIoFUvN2dmF+QVrrUdouuAjoiad0v0Rcnx4VAdDEiczjdlioVRIivV6o9Waq5Yr
+DuMN038Mu+/NoUNtV/OrtZqtaqVSLBTqtfrc3FySJHkdY2xWxwQRAe7q5085PIMpQpso4WHSVPXo
+7QGP1hfFM4kkl9IH3fsgzEgxIYJYF3g2kWokAe+BWv4zEAJhBCF0FXg9aVh8kSVVvIJm73hWOWw5
+9m6MybNMF3qP3LM0km/t2UFjHjc+Y8fys/eMHXv8zhxxZDCkQW6kTycfy6DyMp4z82nl40V6z/54
+j1lqjjg4VLUGb2dldYA5D7suCgLAAgzgI7uH/nbdzr2yEVaUgJkFMOT6CgZdvZS3KxOhZesakJEV
+xh+D4oMpJ05OfqQfL+SeylSmMpUnleXlZSVuE9HCwny1Wi0UCo1G49ixxTRNc9yAoV50sJGwjItI
+tVptNpuVSqVer4+BIhiamQ8sjwhaLlUVHkM0Nz9XqVQs27n51vHlpWG5VA96EEIkMsCYcRxcxxcW
+FiqVSqlUmpubW15eDjnSwqZTKpWazWapVKrVaouLi+CTtAXlBAHLpVKr1SqXyrVqbXFhsd/rM7OA
+ALImLQBBRANi3EhGzbB6oTiO51rz5XK5VCq3mq3jx48P+j1H4MpRWrwTw/8IWxwAg4DA4uJivVYr
+lUqzs7NLS0v1ev3xrcl5hPYxyr9HeAZThHZQ8vq9gjTNuB0Kah2usuDQouCffwQAdrWnQubrYcb5
+YJo54Jf3aplYLZ+EYkMNaBr1DqEzi+f1KjXkK057nCE/wQT91CRvN3q6FsLSfJhP4Cnaz6PcjwXs
+HX3AEUeGDuRNBs+OZp/ldJjkc4bD98gn6tJTTHj+3PDvM6L0sYEc1pT4ZJv6q0u/OeQ6AiGKi0PT
+KVIHugAwCAPy0MCDw58A6lkPWMzDLJDAaRbPchQRFkYW3b8JkEWvNO4Zc215wDYRhX5cNpepTGUq
+U3kW+YVf+AURIHIep8Vji/V6/eTJk91ul5kRfVEZOGr3GRrOAIrF4tmzZ+fn540xly9fXlpaemyE
+xgJAhnT1PHHixPzCvGV74eKFSrXsQFFYXxHIVeKZ4EMLMcqzs7OLi4utVuv555/X2kiQW4RFJEmS
+U6dONRqNLMsuX768srIiueqverEkSc6dO9tsteI4vnTp0sLCAjMLsIuWGUFoqjIOBxr0T2NocWFx
+fn6hWCyeP38+SeIsS/MlUnP7kD9PwBcFRdHNDqDZbK4srzSbzTNnzli23W73CfWBf36Sgx8t/07h
+GUwR2kQJim+IOXmkOdkrPQDBSj60dGtgCABo/SskUht2sI9P0oTUB6fKGREQhZTpLq0+i/fOjVQY
+U0mSJIoifdWPVpc/Lh09jxYex9vw05CJmuhh3Xic7oWBPB2f8GMBKmNffrx6cx7QPnUjec3+4+ph
+Hvg9Xd8+xsfP1/c7Cp7pX6MoGpkNtZ1K8K3n90UPsNx3gsCedyIBerkLjBlwRq4s6rkMt3BofJVh
+/IDvZV4LGf72U10fpjKVqUzlWeSll14CcIpTsVicn5+v1WorKyuhnlDgBwzN3jltJG9y0n+jKFpa
+Wmo2m0mS9Hq9/f39kbPQucHG+4HAwABAxgACM8/PzbVaTct89uzZmdkGjCyYGvWFJDTkQuQkFLGp
+VCpzc3MzMzNnzpwplUq614QdR5nzCwsLtVrNGHPx4sVOpxOcgb4tiKJocXFxdna2VCxeuHBBMacA
+A1hAACABRDCgBXX9aP3ZvkdItVqt1WoVCoUzp8/UalVm6zXO/BjGZkb59sTimPa1Wm1paalWq508
+eTIpJIPBYHRmDovyy3fmY5N/v/AMpggtL0FPDQpWULYC6/dI7XPEFSYC1lrLFggEgFnIP+Hk4srA
+k5Aw34TTtYZ+OHBsSA0VFRBmEEZjvEI8PgoAKJVKcRwPBoNH4pNn9DB8LC2Edo7408jrjfl5PnSA
+B10BT9HPZ0EdBxHj0VgoXOXoYz5GAJwHQo958MHrjkH0g06nw06Z2Fo44CnmfOxaYyaDZ5HwGExs
+KnypBRUAwBhjNZOVi0AAEJfkR/dt5/gKMM3rFo4d7VI4uotP2rYwmIEQgYX1cmrDJCJmEWbA+PEH
+qHyBMGkf4+xNZSpTmcpTy/Lysmj2LJEoimrVarFYbDab4OhCBJ5gMPH0vD/KERSNmZ2dLZfLiLi4
+uKjVa4bH648JjYloABeRcsgbjUalUhGRhYWFUrHgwoGV06R9EkR1o401pLofouaXqtVqpVKp1WqF
+Dof+KELTqDljzLFjx3q9Xj4u2o0LqTEzo8fMLyxUKlUAEGBA67ccRCQQ0rKZYxulKBufsFQs1eu1
+JEnm5ufiJGJhdBqowFhKquH5CDBMfoaISsjUqDlAyLLsk7L0/buGZzBFaCpjTw8RFYtFtVjkdbIj
+zPmIiIQCACwADIayzJaSUhLHCOQMGEhECF4FGvqZRw3kQ8+ax2fMjCIIGJuoVqnM1hudbICJ0VLF
+mkAx/0rrGnTv3j2NKJ3YZx3XEfFjTwoDJiKiZ2wqf/rj/Do2AzAaGTWGCg6iviMu+tSSHzt6ebpG
+Qjsh3chh4POJVsOJXXocrJi/XOjYY14R/IQf/U4d8f1jjvGRqPhxBH0B66OPiaJofn5ed1kXJKAh
+oygiDChoUBCEpVquFpKCurlykdb6v+RKmgEAyNDZHqw2Q28cIhISGlOpVGYadRMTkhCRtSwsRLFA
+2Msl3y4BBtODrhLValVDunW61Ij77Mk5pzKVqUzlWaRQKICuRT63oTGmUCiUSiWfmWmI0PLsABjd
+2cUn2TLGJEmiiRO18RGaTOArjW1PuvPosouIiIWkEJERhGKhkJVKmoAXAIRzusThPjTtSaFQ0HTB
+cRwXi0WYhNC0tyISpkKGObRJRxxFMZExRpKkYK0Ox7MctdguKpTypNCcD80hNMRCsRDHcRxHhUJS
+KBZ8NwI802kcH4vbsryaqyMyxsRJXCgUNFnliH51+L3+GLebf+/wDKYILS/6Vmga0+PHj8/Pz2sE
+Wt5rMeZOyWv/OYQmaJAZEpOcPHEyiWN1doNrx5N6NdQfw9oRAi+Dz1mGdncAAilXKhcuXCiWSl3b
+Z+O6ROQo2Hl80uv1Hj58uLa2NhaKFpRjlUcqx2E11F+ttVmWHaT8aWtxHOuKaa1VnU9yoVOqwvoM
+hL2JVwyn6OKrt0O5mnnRXiGiJmbQU+I4Rh96l1fiVbEO67IeE7CB5k8PHQ7HiM+2oq1pHvmQbz20
+oxHGgQ2rejnmUs3mZ1JEsix7zODAvBy8Tcq709VQuxSODHPOzFEUhcQV+W7oMfm8/5oSN2+MQMT8
+uUqa1TGGByAMMKShdyl6oyh0RusHhDnJ5zUeHVca2gyj02aPwFdhkuWAnzP3sAERxXF88KLhlulh
+cogPUMf1SLBXrVZffvnlixcvpmkaJhYFWKwIIwkaAgSbcjEuHV9aiU0i0vXqAB4w1kwaLqgC4pI4
+CrpEYbV64/Kly7OzDRMBkiAhCGgo3ChCgzBJWkIxPCrM3Gq1lpaW9P19TLA9lalMZSo/bbl69Sro
+LoOo/CAAuL+6evfOHb8gYwAJDqGFhW40wa8u5kmSLC0tMfP+/v6HH364u7vLzPnldzJCg1y6eQRj
+ooWFBUMGAG59dGv94cNwaWEP0QRBYJIPDcAjtFqtFscxM9++ffvu3bthMwqLcxzHx44di6Ko0+nc
+uHFjb28vbFviA9IIzeKxY0kS93q9D27c2NnZARHRLCUOoalepEAMIYTNDKPLgIyZnZ2JIkqS+KNb
+t9YePHBJp4YmwhxPf0R0olDV5VqtxiIzjca9e/fu3r2r1V/HENrkrJsISPTF4xP+8qTycwDPYIrQ
+Jkocx2fOnJmfn9fqRuEdUDkI8cP7D6r3IGseABKcKTWSlIABAZgts9GH0yMzcl5x8HnXnEboPWmY
+u4SVerV2+fLlM+fPpsiCashxf9YfAKBRs1tbW2+++aYxRpXFg5rlYDC4fft2FEWrq6tjEGioXCJW
+q9WzZ88eP34cANI0vXfv3s2bNzudTl5H11Pm5+dfffXV2dnZ3d3dGzdurK2tBYVeD5ibmzt37lyt
+VhMRgL/U04M6qHr5zs7O9vb20tLSF77whU6n0+/37969e/v27U6nk5//RqNx8eLFWq12+/btW7du
+9ft9/aZcLt+7d+/OnTtpmu7s7Fhrl5eXl5aWdnZ2tAOnTp0ql8t37ty5d+9ev98vFAovv/xytVr9
+8MMPb926labp/Pz8yZMnS6XSgwcPbt26pWgqiqJGozEzM6OAp9VqXbhwIUmSO3fu3Lx5czAYtFqt
+UqnU7/dnZmb29/cLhUKn0xkMBmoSU1hSq9XW19ffeeedBw8eHBbVFjBAHtrlRb8fDAa3bt1KksRa
+22w2EbFYLKZpGkVRr9fTD8Visd1ur6ysbG5uqtVNb7pmVdrd3VUrV6VSabfb7XZbSfD9fl+3Cm1T
+x6LY9fjx4/fu3cuyrFaraeCv3twkSTqdzsLCAiLqtU6cONFoNPTETqdTq9U6nY72sN/vt1otrf6s
+LNycF/eadrJare7s7Og8h0gD8MgtPMxElKYpMxcKhbzbR3EmM5dKpVKppKHkc3NzAXjrX6MoUsCc
+JEm/39/e3tbC6wAjZhf90Ov1Pvroo3a7/fDhwyMA9szMzCuvvPLaa68pHBIRREJAERawAEwRsUCW
+WmLTqLZsp8DssVO43rCMhu6mjBByhwB4p7tzw4PCP5mdnX3l1VdeuHQhTtQ3xroHM2uNwXDikDuJ
+uaqvwTI1MzOj8zlmlprCtalMZSqflLzzzhUAZ06dnZlptlpJoXD37t333nvP59XILZyjGML7tdQi
+DuqFK5VKg8GgVCptb29ff//6w4cP2U5AaIeIW67jOG7vtxv1BgLcvHHz9q3bVqznQLBuI6Lw7KAD
+DYYIbX5+fmFhQURu3rx5/fr1sA2FFbhQKGRZ1mw2t7a2rl+/vrGxAZ6XDm7fwCiKe/1+q9Xa29u7
+fv36w4drrN4CDPgrwNYJCE2zopgoOn58qTFTKxQKH35488MPP9TEkrnJFO9wm6gGa5Zpac3NVapV
+QLh9+/Z7773X7XYBHhehERH856Nm/3Hk5wOewRShjYnqJdbanZ2dLMsCcsh7nPJ+BhmlaSEgAIuw
+AFiWUlzCBZmNqghASD5uBF2KbRk60wUkb2Vx6bMJreM9q7KG/W7vwe7mxu62BbYoAII0ZDw5TzQS
+kdnb29vb2wPQiBTOK1v6YXNz84033njzzTf39/f39/fDEPIFuxBxfn7+N37jN770pS8lSbK/v//N
+b37zy1/+8q1bt/KTZq1NkuTy5cvnzp3r9/s3b978wz/8w7//+7/PskwdNdbaQqHw0ksv/c7v/M65
+c+eIKCA01Y9Ve07T9P3337927drrr7/+8ssvM/ODBw/+5m/+5i/+4i9u374demiMOX369O/93u+d
+Pn36G9/4xle+8pX19fUzZ8787u/+7vLy8re+9a2vfvWrW1tbH3744WuvvfaFL3zhzp07H374oYhc
+vHjxt3/7t5eWlr7+9a9/7Wtfe/DgQavV+v3f//1Tp0599atf/aM/+qN2u3358uXf+q3fWlpa+ru/
++7s/+ZM/WVtbU6zSaDRWVlY0ivfixYt/8Ad/UK/Xv/71r3/5y1/e2to6e/bsiRMntre3n3/++Zs3
+b87Ozt65c2d7e7vRaCwuLopIpVLZ29u7du3a9773vRs3buRXvQlWOn+b8p5AyCHn7e3tN9544913
+3zXGnDlzZnZ2ttls7u3tFQqFjY2NbrerjPbV1dUvfelL77zzzuzsrD7GGxsb586dy7Ls2rVrrVZL
+Nfv19fXV1dVTp05dvnx5d3e3Wq1mWWaMWVxc/Oijj2ZnZ3u93mAw+JVf+ZXvfve7u7u7p0+fXltb
+Y2YF/81m8969e61Wi5nfe++9arX6+uuv7+3tzc3NdTqd1dXVlZWVtbW1VqvV7XbX19dfffXV7e3t
+7e3tarW6t7eXJAkiZlkWENrJkyc/+uijer3+0ksvLSwsxHGs9S6jKBoMBgFZFQqFvb29NE2bzWYI
+RLbWVqtV9awqd39zcxMRL126pC41xSFpmipy7nQ6jUZjfX39xz/+8c2bN3UjCZ63MP9ra2vf/OY3
+oyja29vLGwvCHdSzsizb3NxUYO+y5jMCEIIIpgIWCQWNTTnGRBZN2cyHm62XQgGf7zXPe0S3bKjL
+nZ3n3TN4UUB63f7a2tr29oaJEELAqyAL5SIEdKVQsosjRoeVjZmLxSIilstlZdrk17qpTGUqU/mk
+5F/+5S0RICJDdOzYsVOnTlWr1Y8+/Ojtt9/u9zXYXvmNXgRGlq6QXtHzE6vVqqo3a2tr7155987d
+O3YUoU0UGQV+SZL0e/2V5WUQuHb12nvX3stsljel5X5MkMDOWF5ePnfunIhcv379rbfeCrkcw/Jb
+LpeNMSdPnlxdXb1y5cr9+/d18c/pCVgsFono9OnT6+vrV69evX37ljcET+zBcHo8bkMEiONkb2/3
++PFjxXLx+vXr71x5p9/v+81IRy1y2JDETS4IHF8+vnRsKYqjGzduvP322+OJWA7fWRAAn5m+8XMD
+z2CK0CZKt9v94IMP7t69u7+/H94iGPWVQQ6hjZwsImKtiLXSarS++Pqv/E+XX3WRow72AIy9NDLy
+NotHbprPlYiMwTiKTWQebmy88b3v/OuVd/p2gBFpmh2UkVZEUDXR999/P89Sw1E2drfb7fV6kOPL
+jQ0CYGjgOXv2bLVa3d/ff/fdd9UhExQ7FbW+z8/P67nlcllXENWnNc/KzMzMiRMnXnjhBSKCGyNz
+Zq1V3sKDBw/u37+vwTxpmlYqlfn5eVXiwygQsVQqnThx4sKFC2+99Zaq78Vi8dixY6dPnz558mS5
+XH7w4IHmO2q1Wq1WSxl61Wr15MmTzz33XKvV0hsax/GJEyfOnDmzuLiovpdGo3H69Onnnnvuvffe
+K5VKClaVvakOVcUkFy5cqFQqi4uLytkrlUr1eh0Rm83m5uZms9lcX1/Xs9THVavVEPHhw4f37t1T
+B9GTP5XDW9PpdO7fv2+t1UojzWZzbm5OfWK9Xk8hzezsbLvdXlxcXF1dVfgEAGmazs3NAcD9+/cb
+jQYiViqVwWDQ6XRKpZKmHq5UKiF5VKfTaTab+/v7/X5/eXn52LFjxphWq6XeUXVhzc/PdzodBYHq
+/1RYNTc3p89Ys9ns9Xr6q4gsLS3pDW00GlEUKS223W6HAaob9v9n783DLUmu+sBzIvPu29tqe1Vd
+1VJv6lJ3q1sr2jcEM4MBA8NgAx6DBwwYMMsHY4ZBXj5/nrEHDbaGRTIjbMxiELbMIJAMqJHRjhq1
+1It6rypVda1dy9vf3TIzzvxxMk5GRua9776lXm35+2q5N29kZERkLOd3zokT3PHEAMu2sl6vx5bD
+IAiazSZTNeZ+/IrDMOx0OryRmjsqE6q5ublarcbmR6VUr9djElIul+fm5vr9PusI2CFThol4SHa7
+XbbF2euiDe6Wly5d+sQnPvH444/3+31kLQshEAISqgggAoWEHmicak2//U3vetUr3hg7hQCOOmg1
+8/athwICb5BDfOnihYcffvjpp58EjFCB53tEFIUE6JG1fcA+opSi2D1Y3FMPHjz41re+dXp6mttq
+p877LlCgQIHt4Nix48DbDZQaDoeLi0vdbvfixYsnTnyt2+1xGkemcuUyAIDYyxsR2+32/v37V1ZX
+lpaWXjz94omvfS0Ko8nm4BiIWC6V263WyvIKEZ05c+b4seNBGBAlMd42zIERhuHy8nK1Wj179uyx
+Y8dcsxVis9mcn59fX19fXFw8derU6dOnZReJ5FSv1/fvP7C2tra0tPTiiy+eOHE8iiJIlSXtvW9d
+NQwNy+VypVpeWl6qh/Vz58+dOHGi1+0ZRaGdieORbxFXRCIaBsMrC1empqfOnz9/4sSJlZWVJOnY
+uGvbZ2g3Ez2DgqExhGuh2dgzHA5XV1fX1tbYsG7v3sm9Pb4eE5ZIEwyD0CM1GPbRV4BASJ5SrLlG
+ZwwnnR9jPbcMPBW7OEVRFAZBVKL+YNDtrvfDAXgKID58w5A+IgJWNQ0Gg+FwyNur0NoWJWVkhzGZ
+I2zOIHY2TG/rym7mkTyVgVwXX2oRZ9myARmZjxPwg+JznJSy97/Z6SVDSQaGZBIRb7cV9igOaSKJ
+ir8cXxQzqWTr8FW+kTeh2SzRbkawApPIPjRueTCmFZ5PpZzZ6k8CseVKOWUTGn8AKzIKmfPWpeVl
+bxhzznK5zKE+tdbs7IdmAxhvrpMK8r/2Fj7uVMrstw7DMAiCcrnMWfHj+FfOhK2p3DhMtzhbcSJ1
+NqfZmxilVGBt5uYbmZJJpbQDkEtlAAAgAElEQVTWg8GArK1l/Ggw5kejIkkNBwAYDAb9fp9zyxIw
+vleKlPu+pE2WlpZqtVoURWEYIAKCB6QQNSpNGGoiQs8Dv+rXoigCxVOHMVmPeO+xIzPYehwii6wR
+kNa61+2ura0qBYQaFfI+CKXKuQwNAEjHkZFl2LbbbdlBZw/8gqQVKFDgGoJpGCJ4ntfr94MgiCI9
+DIJery9ODc687MxZCUNDQMRSuTwcDrXWoY6Gw2Gv18tudx8D3gcclaPhcBhpTZoGg0G3290CQwOA
+Xq8XBEEYhnEmGYbGEikvr71er9vtZiLAISIOhwOOHz4YDjhNXhtIFZKrYkMLo7A/6IdRpLXmZun1
+emyYyOaQm7NdI8kk63gysk0AXG69Gdxk9AwKhuaALCsTGOHMcXniBFnagBg7DkE89kCThP9A3q6K
+slWfzB60JK9Ej24dVGTuBtAWJUBURATK3vkfJ7Q2s8XSle21JeI7pI+ldxpBkskHFl6doBTSFGiF
+hdRay+EEMkdoE8jbeZYUTD7YbT5KGgZDRWybBhMVoS5i9rQ5pNVQCYWzKYFkmCuLSx9waJvTXHbf
+EDaiDbI1mhw2r+AmlVgpAmlz4czi9SdfhZix15/wOikkGfdd+ZqrpJC7ZHmTWDLyE1i80X5r0lsc
+AiBvkD+wjRQMDRYODKa3oAVhYjJSIDNU7Xudd5T70m1SjRmXVIHnec1mk43GdomAEEEBUqzOJK3B
+HD2PZphiouukjPY33QPi/zGeFfgvKQQC0Jp40xnFe9uUtkKK8SNElSQRfOQtS0zkwnpWoECB6wdC
+WjxPB0EYGQVfEATDNJ/ZEGylCYIg0hGvRmEUMUHaZD6IiGEU8cIfRtEwCILNFgYRAIbDIS+arOvM
+ZhIEAS/icZWHw+x26CAoh2FIFOslgyAnzcZQGIYBkSYCedamMwFgeibvaLPNsjXcfPQMCoaWC7G3
+SJBQkU3HiGiW1KUIOLI+mI1hzBY0oA8AWsehYcV6LMZ3AATUvLdVkyZAIoq0Bq3jVMR5ogYCTajQ
+lu3ABH+UKtgExhZAhZDk1sKWp23xVOUZoB251jExSaONIifyRDF9MP9hmidU07lFspVH25EJbWuV
+bYcRDuPIoDbxsCV++7XKZzD+n9kqOKYe4aVcsNwwmJuCzYHZ5sPBS4T7SV/N8hP7HXEOYJEZ+y6h
+PTbnVFZcRHkQU0RltmvKQ8kcrmVzYPsplI6+k60jEQkBxrQ7sXxgq6BcYRsvIkqRpI5oGckdOmfT
+v9zyONqNLMiYJfnIGmNgRERFmoCQgJA0ACHyvlKKdKR1lLjiJH7OME79ahKj4WfmIhIAadJaK0Ll
+KSLpZpY7ChFvIzAemMnLtec3Z9CNqnWBAgUK7D5Ep5U+lGQT9wMAKkSlrAjbWy8MKqVw5HI2Hs66
+NmYZkvzHlJbd5T2FntpijVAU7kYY3WI+6UV2F3BT0jMoGJrAkUiyfcumZ7mcAcDEY1QEyDMA9/NY
+LlXxjSkZHa38UxkCcPwQSYaIiskeodYRmQFE8dZNMorzJJC6CF5g8QcYK25CRpS3ycwo5brNZ6Sh
+bM4gdzlUzSaENqkjY+rJLeGYSUpEc9uO55hBAFzeRZZpJdsOdjKw+oZ9xaFwuRUfVeZNgdLeknbT
+OY92ikfGvOb2tAyps3MGy54pdIssAg/mpVPapGnnaWeurbg12ZJLaXXGwCvXpZBOs9vUIlt3h41k
+S5hbErky5ie5UqlU+DyxZLAYv2VDlLgwrH3JPtDOLf86/xjPC2iM7WbDqlIes6+U6SwFrjiXP+U3
+KwtqtlXHFKVAgQIFdhnxBLX9TLYxtyWHnmzPFdxeAzbMhNI+LHIXxbJfahHcCmLln/h1bAu7tnbc
+rPQM7IPACzDQ6OPByKDjdRs2LLmYKO7jSBp0qIkAUWmtSZPyjIEtdTMA2ZIiiYbHU8rzlMJYCw5s
+heP4kHmlGMOFsp/HV0caRIROR27DNORibobj5w5bdB6fT+69jv1H7rVJZnYyzV7EtGnOkfjtK5CZ
+ENEc4QVmMhX7kpRtwsYfVU2hQ3Z52F4q1232gmljkbSV1ML2hbCtZzansstgWyM5se0dly2APNQu
+rRQ1O7KkYcUCaSfIGj/F+xFN2FVb3WinlA+YcY+EvEEx4ZtybrcaQZvXEitqrW5nPyb1MWVOyz4r
+VT4AIHaZpDg4LPHbdXx6s+B77J5Pecw/SVygQIECNz42xYgmzGpHqMgkzGrCBNucsckcxLLtfHZj
+4bh69MzO+VqhsKEBWJoJW54TqVpZZ9o6wr09RIkkXGN8jZURqFD5yvc8RNSRJgKFfE5RcoKHWOs5
+Hqz9iFihwXIzMP9C1sxHWht1Bwu1AIDsRkVEvFGKHYK33DJZ0uXQAxHsxPbl3C5DnW1ZmDZOCh9w
+nsuboxxnQkGuMC0PsssG1sSn07uhnJnaNjCixclt5z37cXYYEkoboBzBl4wf3YQ8f0M4jea0hrAv
+m7BR2rbpsCOb49l1dJo0O/urdOQV231RvmZb226obINQmmxLle1S5RbMbhxJzKZUJnvOK5aKb2FV
+cwiM9BmVHG6BWmtNGkEZYzjx3/RjKMkm76oFtFIyOQPigzhMw3AqYqMaEWmNKmf4cOmFoSb35ykd
+ct9dgQIFClwr7BSzGpPVJIvCzs6NzsQ7JtmWf90QO1idgp7tCAqGlg/pXo75BTLioHOj+Egb3yZA
+AGWiLSpUCoGiCIz/EwJwLAGk+GxZpi8EGoGMjySQjrMCINI6vlN5gACRBg7pHZ9cH88aHK9Pgt1t
+pzVktsrlYGMmBZvBitXCZmhZpsQYJdY7RbLlyFwh3k4jMnSWKTnMBKwtZKMqZfuD2ZmI11y2nDa1
+GFWvySf9rBhtF8x5ll0AzNuC5TSanb+8DvkqkCZyspIc5EFKKdlYaDOBbGvYF+3P/C/Hh7TrIu9L
+LtpMTN64vauNU/IVx7dzy/B9v1QqmZ2rWmtQylfoEQEqJCB2LjQVB1AmyCISgQYidFiaaY+Emxn7
+WjyxKNBxDpC0OCKRVoiASAoQPEvjw/drAqIoIuXFAYeSW1NaGP68axsJChQoUGBybJ8DbJPP7GxJ
+JinMhPRsm+XZKXJ1tbV7Nz09g8LL0cbWRogtyMYevElIRnE8MnpvBIQk+nXM5kwQbN7AL7a3eDOK
+JTNDbDETQcrkQtbR18bHamZmpl6vi9Q4eSNk6QpsNGhH3WVjsxYk+9ETjvMNC+l8yP11a5hwht1Z
+bKjhk8/Z4m3YpLldfbNFGnPLlptrFMvNrdF4fYrNS7fz+jzPa7VafICeUorIih2aLlTqIUgycO1h
+TtmC5BWNTJQh51czP6BCJTslmLKhmYTGKynch+96xy5QoECBLHaWPOwgf7iqVGTDR18T8WM8rnZ5
+bgV6BgVDmxzjxwAad8PNbrA0yTPScOYi2hTN4m7yzUw5sW2h0WiUSqVcJ70CBQTX28x+I8L3/Uaj
+wXE1wdq5R2T7LG9mYkBw5pNNviSU/xKdj1wxqqANtSrxLUUPKVCgwHWGm2leGk8XJ1SU21ltmTHu
+LNW8Su9od+jZ9RB0pGBoCTa0SGzc78VqFn8x2LyYRZCEarPzSYUfImM4S+4iMLs8EZEPmKa8+D/j
+Hp2u4+6bvHd2jrCd4raWwzVcCa6hZq7A5OBA/2R2JyY6EZsb5WMTGh0CZz6gzO/mUwqm87MlX9yl
+06kmLEOBAgUK3DQY5XmxqVlxN+fP3GeJyHc9OChO7p2xNdw69AwKhubA8XrK3SezQQ6ZDwxM73Vy
+fxyXU8zEzH6RiRzqWEas1+uVSuV6sIBfKxEwyzY3VZKdarcJjRU2rhO52d67tcvYbPWvVSdHc3y5
+fE3mjYQOpWCs35bqBgGsUT4Cch8AJuob61Qgp7ePyiF9aTLf4AIFChS4mbDNFVa2Ve/ySn09CAbj
+ISvgjhf1lqJnUDC0STBeRrE01bm3pnTo2R0mlAhdGH8VVbkIeKIFNz5KadW77b+EIiD6vt9qtarV
+6nZkLHuAjd/HtYPYQT3QdrLN3Xeb2yAb5rC1524TV8ld4fp8+9eQSCCi7/u+7/NBC2gflweUNXQ7
+sHjWBPa0eHKId7NivI/V+DpLXrlKmRF525NG/jOve4GgQIECBXYfuz83Xv+z8dVbi281egZFLEdG
+1jq8Y+w/0YuzwGZigiSGaVaHS/AD+d0un8krDv+WCGLstiRb1BARMD6F1vM8DhNC5vwrtCLXXQ3s
+4Mi8StPQDma7WcfRCXvU9Way4GLb9My+cr2V9ppAbGi+7wMAnxJhppTYn9C9Qz5SQuEQc61eSVIO
+Cktpi3r6f8nVdmw2xRB9j1Vy+UAZX2gyQTKvvQm+QIECBXZaxtgReWCnMhlTnlxl8RbS7DJ2tiS3
+ID2DgqExRhlGslLLqLus20E2ohmdeKzdxviam2EscRFiciwaxm5PBECAmAQxl0OtEVHHNjk7YHZc
+AokpL9px+bz9YbOFHG5QGU/8XXfz9klMc7bRw37FWyrmxs8CADInm0FmvOzsc3eql+4aeBMaezna
+pybyaIz/yMFl8cyAAMh2d94nJuYzo86R7BNelSQgAiREZ7+ra+R0GZc8OSkb2Iqb7Hu8gd5CgQIF
+bilsODvJyrXZX2/QeW9Db4ir8cRRbSXC8+SK6TEpb016BgVDy0WupCJmqPG0DURiIqJIUxSR1mIb
+U4ixMQ0sD1OS/xJ/xfgoNDAbzyw7GfHAAIBIp9whLeGZj0GrVCq1Wo0jOk6+/Sn3yg1KsXIhdZxk
+ih8z622ohHPIhgjuzl329LRha9tM+2qrAB1thZQw9/OmsKHiYwt5bvnGLYNr4XlerVYrl8s8S7gH
+soO4JlKisIndFDH2ghQXadeOlkwNZE6lRwKJQ2KOvOcz7hARiDQRIILWYB93BsBnehARGE0Q2p0t
+288d82mBAgUKXFfY8mzvTHQ7VJytY0fI1Q7O1dspjIgEO1WeW5aeQcHQciEjNooi2xi18Z2xOAYI
+oBBVfAERgUBrrT2vpDzSQUBIKY+j+CYAFtK4FJpAIRBqHYGOEEChAkRUiJ5C0KA1Fw3S4QZYUgzD
+0Pf9er1uTtHdGYF+C9jOQN19PwRbYIW8wm+BlpA5scTObRTr42Og5VfP84Rg2znYOqptttL4HOxf
+d6QX2cUeRas222echt21ro6I5XKZQ/I4R7Enn2PvZETFp9ArPsAQE+YGYLgWxOecITg1IJKQIMh3
+ExvhEAC1jhVBWmvPi81i5mBFY7yPo4vkq2Ag3bvsDwVJK1CgwPUGNO7luesI2vuBrdXTWYtzbxGf
+gqwhKFfN6mhyc9dlhxPaKUXfup1ly1kBHXnDXsGVUtmC8RVH1s0VfR32NaYpGOaMUBqVHqymNj8l
+CW5legYFQxPYPZjNZbzvH/LER0a2q7FCPGZLzKVAIYJSSnlepHVIUcXITLHPEsVJ7YzBUqmzNMY9
+neLS6SAM0FO+5yMSGUMa685ZC4+IURRprcvlMscw4Elny7NAIajtCHL5nvzE/nKIGIZh7o5Bvj27
+fsDoXrqDRS3ggNtfKeX7/qgD2dlEptgr0YwjjijCM4R9I2mizBkbxrkR0Tqyg+J9reIeSVprIFCe
+MiKLBgTAnFhQPFE4rNte0aMoyq7xBQoUKHA9QOgEh2jSWrNa007DIhwAyJGwSsncmHINEJKgDGwl
+qXA2yUSuoDWl24SEnxuGIR++4nhVOMpW+TC5o9OYZpHM+aE2+5KnsDTotIA0qZRWWkPSIKI4ichX
++41IXWRRk1a10+TqBNN1D/m/W5yeQcHQspB+zH2RuxqPtImEFQICQoUAFOkw0pHWURSFCOApTwea
+SClEHZM5hJQ4JqyNhb/YI1Kh8pSHAEy6lPJ8zycFRFqTNna7ONIAmfPQiMj3/WazWa1W19fXr5UB
+7dbBli119gSqlCqXy6VSSSZ6nkwdLVR25t1sAQrsCNhMzafD22uPo3zlN0YEEWlfgVKeUp4xfIuZ
+K94eRrEFzcw2sWukec/mJXNirbUmjUp5nud5yveUEUEUAQJpAGVMc5ZZLzbTj/RFYVUr3lAbAgsU
+KHBTwl4ltdbD4ZCIOp3O/v37e71er9dbXV3t9/v2Elkul2dmZkql0srKytraGhHV6/VOp6O1Xltb
+YzVoFEWVSqVer/u+T0TVarXdbpfL5dXVVRaZyuXy9PQ0ACwvL/d6Pc/zms1mrVYLgmBtbU1UpaVS
+iX0olFKNRqPT6RDR8vLy+vo6IvKJR0J1mE8iIkeWYrVsr9dbWloaDAZj5tsx0zX/GgQBt4PnedVq
+VahUFEXsDuZ5XhAEzWZzMBiIaxWXJAxDrm+lUiEi9sBqNpsO1wrDkEUR5sa9Xs+RkJVSWutaraaU
+Gg6H3GIsSzPvZZIMAFEUsWaTJRwhe4gIsODU7takZ1AwtCykkzEd4n7saDvsxDnDhkgTac3BPxAQ
+NVEYRV5s4CKFvAslx+MocXEEUhJwBEEp5IFCmog0ACEqzYMZEWJxUEpCoijyfb9SqdhhDKAQ5XcL
+uRZLd59SOsAmK9Js31qxb0hWYrHxPC+rCxz19XrAzdTx5NVUKhUeYpkwIRCrTHjgx5FXiXiTKY9l
+rc3GMxm8aL6BGd9pJxN+Okgg/3gGAoAo0qgQIO5CFtFL4hMRybMAIKXQ1VoHQeCoVwsUKFDg2gIt
+h5Eoivr9PgDMzs4eOXKk1+stLi5GUTQYDOxbKpXK/Px8vV4/c+ZMv9/XWrfb7UOHDkVRdO7cuSAI
+giAIw7BarbZaLd6r32g0Dhw40Gg0JEGj0Th8+DDr64MgKJfLc3NzMzMz3W733Llz3W4XAJRSlUqF
+GZHnea1W67bbbuN1nMlSs9lkFscFC8NwMBgoparVKgB4nlepVJhDdrvd3CXSNo5B3srO7dPv9xcX
+F7vdLpOrUqnEjRaGIZOlSqXS7/f37t27srJSLpfB6H8rlcpgMIiiqFwuV6tV5sClUmlqaqpcLjOn
+EibJbVWpVMrl8tLSEksjQRDws0ql0nA45Cpz4qmpKY4rHgRBFEWlUonpYhAEvG4GQcDczxKwUwzt
+lqVnUDA0B+xECAD1ep17p8jKY24BHjOIBASagCJNFIS6XWtVK1UFqFApy9BBxPxslLQqG1KI8wUN
+URjpSPteudVstVvtsh6qkg9ABJpTYmxKiwU1IuJhUK1Wl5eX19bWeApIO/sW2GGI9dK5bvefLPUC
+SKnHWB3FZjQAEF2XeAv4vs8pbYZ2/VjSxmsBr3nxdgRMj4moVqvNzMxMTU01Gg35iT8QEaIHGhAj
+UBFgpIG3jsryCbFji9smlP5guTGny0DIm9sQUTXqjampac9DRIo1PagQlHhHmqxIa4pN9EaHyut0
+q9ViBSpacWgKtlagQIFrCyEJiBgEwdLSUhRFd955Z6VS6Xa7J0+eZDMaL50AgIjtdvv++++fmZlR
+Si0sLERRdODAgQcffHA4HGqtz549u76+PhgMZmZmDhw4wGaxqamp++67b25u7stf/vLS0lIYhtPT
+0w899BDTv5WVlUaj8fKXv/yOO+64fPlyr9cbDAa8EDSbzVarxYa4ffv2veY1r2H6t7CwUC6X9+zZ
+4/t+rVYT2ra6uloqldrtNtv6SqXSpUuXzp8/v7i4uOXVU2u9tLR06tQpIqpUKnNzc/V6nSfzfr/f
+7/f5gNyVlZW77777woUL9XodTEi5dru9uro6GAwqlcr09HQURUEQ1Gq1Q4cOdbvdcrnMtop6vb68
+vFytVtkQ12q1zpw5wxSOOTAiVqvVbrc7OzuLiIuLi5VK5dChQ+vr67VardfrMStjA1232221WuVy
+udvtMk8T6wjAcanXrUzPoGBoWbBB9siRI4cPH5b9GI6PmZ3eYmhxIGzSkSYdhrrqV48cvq3kl8QA
+p4ypi9DE9ZDMyEjqou3mxwEAkQ4jHYbt5szRo/c2p1oBaix5sWwfW2ASvXgUaTDakSAI9u3bx54A
+Mn8V2Cy2LKc63YbVbKVSiZ3imGuxbwNPrFEUraysBEEwMzPDPhKseeKAgZIV91LbALITtdx5jNL5
+3biwa1Qulw8fPvzmN7/5rrvuqlQqkHZAJTL0CSKCEFQEiJo80qpRaRw+fLhcriB2xdgmvoexIS2h
+aek5QcxihnsRYLvVvv+BB/bu24NI8cxCgOilD8E2TtRx2RJtAiuJp6amDhw4wJpXMOTt5mDUBQoU
+uHHheZ4IY4PB4MqVK2EYvuIVr3jZy162trbWbDZPnz599uxZSa+UmpqaevWrXz0/P7+4uPjss88G
+QTA/P/+6172u3+9fvHjx/Pnza2trg8Fgdnb20KFD9Xp9fX19ZmbmVa961eHDhxcWFp577rlerzc7
+O/v6178+DMNTp06dPHmy1Wrdc889r3vd6/jrpUuXuGzNZrPdbvPMOT8//8Y3vrHf7587d+65556r
+Vqv79u2rVCqtVos9CVdWVng137Nnj1KKH/3SSy9dunTp8uXLWzixVjwgFhcXjx071mw2OYj39PQ0
+C4GsoK9UKjMzM1euXDl69GilUmm32wDAhse5ubkrV64wj2KnxLW1tXq93mq1ut1urVZj29fU1NRL
+L73UaDQGg8H09PTs7GypVKpWq0y3mOy1Wq2lpaVWq4WIV65cqVQqbOdst9srKyv9fr/RaAyHw3K5
+vLKyMjs7W6/Xl5aWPM8bDoesg+Z8GLc4PYOCoQlEFmFP2fn5+b1794odwxZTRombTNKASFOkNUWh
+9kDtac2WIz/SWmtSAIgKcOQINPTMBNY27k+ISnlKKdVsNO+88879h+a1D1ohKkAE0iZit2FoWies
+IAiCUqn01FNPvfjiiwDA3sA70WAFUsilIiKvc+/yPI+9CFqt1szMDHvAe553+fJldnsolUqDweDk
+yZPr6+tHjx4tlUrsSMDapn379vG7W11dvXDhQm4/LKTq3QEb28vl8sGDB1/72tfef//9rEB1jKIA
+zNC0hiFghMoj8HQIPpY6jVnqVxBV4n5o7FpmZyl/pHhbWszkzJH2aH5nhXGnc/Teoy9/+e0xiSPN
+O7R1yu5mG/diZ0i5wrsCpqenWc6wfXELFChQ4DpBGIarq6thGM7OziqllpeXT58+LduuBGy8mp+f
+73Q6TPDq9frc3NxwOGTjFas+xcuRnf327Nmzf//+VqvF9jrmV+zuyAv01NTU/v37u91uvV6XvQZs
+B+PPrVZrfn5+fX2dPf14SxizHXYFZG/JcrncbDY9z2s0GlEULS0tLS4u2lvpxgPT8TYAIIoidvjk
+ACpcL2ZovGGnVCo1m81erzc9Pd1ut3mz3GAwYN1cEAQAUK/Xa7UaEbFXZKvV4vLz7VNTU/1+v9ls
+drvdqamp2dnZdrvNDM3zPOaf7XY7iiJurm63y9v2SqVSp9MBgFKpVK/XgyCoVqtE1Ol0uPqlUok9
+Qj3Pc7xVdwo3Ij2DgqHlgu3FwmTGRHRMScnxhn4i0pooinRZlSvz5WptCoAdEVHMYtY2k3hLiVjg
+AIhQx56LGGu8ORrkIBheWby8sLI8xCgEDUioMD74FkQpjmC2nPHEtLKyIlFPbho3s13GJI023s+Q
+XyI7rHc6nfn5+WazOTMz4/v+8ePH19bWeLduEARnz54dDAZ33313v99vt9vnzp1bXFzcs2fPy1/+
+clYvXbhw4cqVK6JQsLGjld4BOEW6CYxpju8fu7KcOXOGB5ddQU6oQAFGBAGgRqUAvCiEil/F/X6j
+VAbmSZqI+LBEtp8l4bPE59lsG7M+g3njBMPB4OKli4uLC+xtrbVGVMrztI6sQxbjUhkmmeozRMSr
+qe3f6NSoQIECBa4V2NcuiqK1tbUgCDqdTq1WY+c93pAiKdk/ZWpqam5ujtkCALDhiPkDmoDJEimE
+HQ47nc7MzIy4qzC14O1qzHxYu7qwsCDHq0hISX5uo9GYnZ1lVSy7X/HnWq3GGxbW1taY7HHhG43G
++vr6cDhcW1vjCChbbpx+v7+2tsahSmq1Wr1eZzmQDVzMtSqVSqPR4OhWLBbyBjwuQ7Va5f1pnJ79
+JJlNlUqlRqPB9xIRc85Go8HslIg48kq9Xu/1erVajb0rp6amms0mp2eCyu1Qr9d5u1qj0ej1etz+
+3IxXY8W5QekZFAzNBuu/eQo4efLkwsICu5nZQXiy234gFa7NhAAAGg6DZqXxjje9o3P0IUTDtEiL
+UEVWRABr37/EB4D4VFsTYlsjLSwtPvrlL79w/FhfB5FHwyhEIA+ViqmZuZOSIimlFhcXV1ZW4Cba
+BbT72FS7ZacYRxTmyYgDQLH+yY7hyxMZH5PACXgN4EUITQyoMY+zL14TCXsMY7wJJH6ZE4hocXHx
+0Ucffe6557LJzOEXiKgBQ8AIAEkrINVpTr3x9W95xR2teMyyC3TsmpjycITESxGdazyfABKgXlhY
++uIXH3nhhecxjupPJCqhdHsLQ4u/GZ6vlLrttts8z5ubm2OPTUdHW6BAgQLXCmR2zJJ1HpLnebyA
+ZveeoAl8b2vYeQGVKLW2uk3EPyc6vBObHk34eLkr+5XLY98ikOJBRobMHhgwecuA2ftgx1R0gvFK
+AZzSSrBorjvfIhHL+F7+ajcUZgKV2ZvkZVmR6FlOQAc7Fpr9CuR97SBuXHoGBUMT2F0HAJaXl8+c
+ObO+vp61O9ldiswuDu5q8TYzJAAYDoNGtbm8shxRxD2UT62G5AzZGGTMaIAp2YxUYmUjAA3QD4Yv
+Xbp06tSpvg60DyFqIvI0xHG1kQgBKdW/2ZpfLpdrtVq32y1cHK8VYoJuwI4HAvkJrK4lE6V9Y2L7
+sLrldUjSnJLY69ONDml5jme1srKyvLwsB8UINEBsGscIMQKMgIAipdDvT/dWV5ejKEyckznaI8Re
+imnTvMPN0PoMRAREw2B4+dKl06dPI7KLI2gdISKo9FST6TBk3GJ5EeWK3DRvqkCBAjcN7DUxlrgM
+m8qFve7wvXKXZGh/yHucdMsAACAASURBVC5S2cnQFgVTqvkRalmHhIC1fDhL+ZYV6JbGLXG5ciou
+lEkSOxvehHHZjQxpucW+ki0/mG32cpyAfaPNim2yZz8C0gey7QhuaHoGBUPLwu7NkDcgacRWHyLS
+7IeEvKEEfT7wHgCAXZhiMQj1RDRJHsD8TZMG9FGx66MOQuK3ZxvfCI1zlYnPBgAcepV3ZBYMbTfh
+kCjKaLPsr9lZnq8406Kd+dUtfYHRICJ262eHGVlyUi+F9TVxrEYZpkREmrQmTQk9c3LfTEk0adbM
+AGhNSvHSS7xGRyPoVrYv2aJPNkGBAgUKXCvYVMqmPROml+uYMZ2NYll2SrJUpVmx0L7F/pxL7bIX
+bX6yZThiqs4cfu3IHnZdnJraP9lXIE3JxpfHbq5shs6Drt6ic6PTMygYmgMRiIXxo+XR5IxtBhEl
+Z/9xDggIHGJfIcZ8jdiVyPMVGe2FiQoQ28lMlqaTsj6dn6gUep5iI7RCNtYhEYfTRlRgaCAQKnas
+isP9oRWjolQq8W7OQvzaTTizv63fGoXs9Jp9ZcV7vIZARHboL5fLZLxuwFaUmhGNiMDxgZAdGBUA
+aCDN20fR7EAFIo7wyvmnHzfmNSOCMjtQ48caZRAqVNo5DjsRFGzRBEYIEAUKFChwzeEQBttktOFd
+9kKZZWV2+lz6lM1KPo96KBpHylxV/qhK7chqnuVFTuZSR5sTShpx5LGr6dTaziq3zGQRTtv4BlYz
+2s8dn9uWcRPQMwAoAnYlcAakM2akn4koxhCbLBplOBp2xTEA2BIPzN8gPnKaTJx92ZXmlsXdmGbC
+YwORJgJQyM9FE6GE3SdTIGPu47A8jUbjKm3ELDAGo+YdWS3sBNmZOnc12n1uZsv0kyTGNDHYLKQd
+JKvrp99ySZihsWeIrcRJ0sWMKfZrTkxlctQ0Jied8YAf8UAyM0qmJGb8a62jSJNm7RIiKq21jjQa
+QcF+HfYMlnqM5ZRi37X7na1AgQIFbNjCfZZvZFeHLCuwpTUY4ZaS5SGQmQCz65Hz2Zlac0tOGZ+F
+7U+zZO2GyGVWYx6Rmzi7Co+qMn+wheRsGzp+krlNvVO4OegZFAxtFLjfoHHYpbTjbO6AtCF660QC
+Q0CltNaR1hALbACWDS3JMOdzPOCAw+gjaK0JuEhkzkgCe4+KPfIRsVwut1otiQ+7U610o2BUlXOv
+Z2f2MTls+MQxE1DuhCi3586JQrxHpdkdjC/nNjFmrb0ewPXluFgcsWqj4iX1IeFi8gsiAWkgE9zH
+9D2ILxlLW+wNSZCaINKCA7FtHcDdlp2F3dmk79ncLKv4LFCgQIFrCGfFTElceXB0TI7WKUs/JPOs
+l6CdJ6TXd7t4znOdkjuJ7a9jnjgJ0ArvsaGHYZY9Shnk19xbcnmX3Z6yVR5GiDe5BSPLKLojuGno
+GRQMbRScQQt5wWdcVgZCkawL8ciJHSBZpFJKAZojjdyeiZZmPAaJkQ2BvRxtMY8yHM+ev/iz53l8
+iCE7ZN6CJG07yM5rY5I5sGerUTNjNv2orxM+9GpASpJdFCesy/jEozA+vT3LbypbyFs1J7+xVCq1
+220OymwrDpNWShoq2w6IiKDErIYmOTjTgfA2Dq3P/7tTAxgbXfwUJAI0bjabrVpSvmKKKFCgwPWN
+rU3gaDTvdiY2v5IPk0+DdjEc/pZL2DZb5gnLYK+GzlNsvmQXaVRhstQu+9Vha/LBIWmQbmTnxg1L
+sincTPQMCobmIId0mYu5XcodwDFbSlwUrQNmkaM1qljRHdMzig1qaP7EzorJs6x/5ZNkAFk+l66O
+OBZzvBA+o6OQwHYcY3iCUHrIqPHsBE5650ruK7sm9AxG1GL8jYxRM/6GyK7E9uK3NZa12VvkRkSs
+1WqdTqdcLo9yfrYqnjeCk7/smswWsuw4plQOZCaHOHMCoGS64JnGnj2YA6L9R9hgzuuzS+583lpb
+FShQoMD24TABR9Yfs+zmXse0LYg2CtQximg5D3KSbahblHu3v45TGjBihc0+KLf1nExGFT77CjZ8
+nHN9zIet4SajZ1AwNBv28BvV1RwJJpOHeCpR/MXOJrF6GcGLsiawxAwnFxDAbFszA9t2o0SIT07L
+m5HQqIuUUs1ms9Vq8fkBsIuC164RiQ2xhSpfvcJvqjDOMiDYLNXZPsYMkzGJR1V2kq44po7O7RM2
+qZ3hFroEHzPKLo5OnvINgADNHxvCrQABUXNSRNmTli4nJDOJzBQ4auYwRjQcszS6HzIlTzIbO9EV
+KFCgwHWBTU372VuEY4xaR3J1o87ykV2Xs3rV7FfYxjKURfZZdvEo7cXjkEP7Q25DjaFtznXHQ34U
+CZTMpSTbXGtuPnoGBUPLxRhNwASisGFfaJwaCexQ22AOO5J/c3geJj9h7NoEYLatIHG4SFRkAj6a
+G7NZCUNjxX+73a5UKioTP2B3sPuPy05JExbDeekTUqANc85OWOPVck55srP57lg5Rs2wk9w4vrJb
+Lvk2q5xdXyd/xRxnv1wuozmQJ+924VAkvEpMXezjSICUxHLMt4OTFTAIQDPxI/6QelZcuEmqYD+t
+IGAFChS4gTD5XD3qRmfRtDPMMq4N2ZoDzPh02IKHzUZyf9omnNU2m+0kejenQexiZ59iizScUmSV
+7NKffXFjGOymcFPSMygY2hjsjF3CSGdpxHYxTIhX3r044j8E+euI6giJtEZEfPoZxy9CRN/32+12
+vV6X4wG2WbnJcQ3NaPaUdFXl0U3lvKnEo1rvmsjWGy6Qo0qVy5Ylz9z0k/PPTb3ZLfdGHkT1er3Z
+bPq+H4bhiHM2pSQk3xO9TGpAj7B9x4/LL74x0MXfjConSxHH1APGPrfgbAUKFLheMEqPOUbXPPkk
+bzMQWxM6Ztl1bhmvwcxyFYcH7oKabAynyr0yXl7KaorHPDTbtltW+I7CzUrPoGBo4zFKGB01X7jS
+Fso/eTADIZXaTZE3PFI/IxqGJ8931BW2YqNarTYajRFa/wLjsB2xPptJ0fg3KJRSPIj4JLQoiijt
+noEyEbC9nDCOCpQoVZJxbY/wfC2NdTU7HWRuIetf9n0mTHa4gvm8cd/DNDZMX6BAgQK7DNxMSCSH
+gEF6FUbL9pW7Oo+66Fx3OJvzeVQtxieYELbg5xRsfM5ZegZ5vHHDDB2N6qjGGV/+zeLq0TM752uF
+gqG5GEP07TRZgHFpyrst5yja+DlWcrLYF1l/IPaO2mD4EpGdR+7kxRaAUqmUlOwmEr/G1CX7Nrdc
+8Qll1uyU5ywPowo2IXZkNp8w/53tJFso+c7yhC3nppRiV2F2cfR9HzInJcaTgTUQbVZmD2o0lrBx
+drQsSP7JXo6fL96VhLGfJB/H6MxVW2iBAgUKFLi2yFq9Jr+RPzg3TmI4crBlsnG1V3yn/FzO7MXs
+XfZ1RFks8sUAJ4esoSxbEhjbLE4BJsTNTc+gYGjjsanukk5stpIlvk0mVfy/XMhkk2F5TsABc05S
+OkmmJDLX2F+ZofFWtEmUT5NMVXaabYrRznQwZq7MThBbUKSN0nXZj9hQ7zUKk8/RlLereAzsMm82
+zRit2CikrUNJOcdo0XLzT+kyJniu86YmKfDkmWdz27DxlVL1ev3gwYPz8/OlUmk4HHIAHswJJkng
+jnwEQDanyeWYm/HYpiSdA8TElBYnpNSP1i8mI+TdqaPawX0p8tm5nl2kCxQoUGCXsZ0paFMrde5C
+nGtNGk/PcjMZs2Lu1Bw7av3dkNDaBZ5cirMV0NkKZlnfKMK2NbnxpqdnAOBf6wJcd7B7lSOMbixD
+pwVvcToUYYkHyAZjkX82khzGnknmt6Q88UUiQuvZ0ufdXIkAwPM8NgIMBoN+v8+7aLYw1zg5byjG
+bWoEZhNnr+Q+bsNiTH6XI61myzCKe4wq+eTkUxJn88yuJZJsQkJolyeXkcLoVrLLLG2yIXeyC0l5
+J6XA6O7htPyoF7FZIjG+P9uQ3WWs3di7d+8rX/nKTqdz5cqVbrfred6IAwYR4lGJRKiJxAE5zdlS
+4R6F1RFJIv5fp7wXKd7AmsoPwZoBCAEirREB0QdQGapGybQRPzFpWDmfo0CBAgWuZ+ys/mibhGFM
+tjub4YaYsE02q67dQi2unnbvVqBnUNjQGLmCL6RHLGODGQEB5Ggj0YwjJGYx/kyaXRaNu9H4wgFA
+nBQxPuFIeQoBSG88AIhIwhgQkdZ6amrqnnvuOXjwIPs6bsgWRul+7EeISJebj8MKtsbl7OujWMEO
+ztdj2kSeMuHjRMOEeX6njpZLnsu+czZyeYVdhmzXdWqRpTpOx7Z7+KgGt+su+Y9prkleXBZOQ2U/
+Ux7sB2V/cr5KPjC63yqlPM/zfd/zvEajcddddz300EP79u1Da5N6bnX4eSYYEJGZABI7FxHGw9+o
+cmKzV2INY+WMsZrJIyTUK0AcH0Req7ZcLlmxg5D8iS9CeubJEm+AnRxKBQoUKHC1MeF8teVpbZdZ
+1u7gOqnUZkns7tCz6yHoSGFDy4EttjpSLGzQp1FMX6LV5glBa41aK+V7CiDUYCUYDQJEVndrzkUp
+lsc8pULQmjRyeXLscim5P75EBADtdvvAgQOe512+fJmD0WXls5yijJbYbAqRm8YRncdWGaTYkyh4
+bIaQIyVv1aw3eSE3TJPlQmPE+jGZY14QWzvz3HtzJ75sYrScznMJlTyXCYBdhTGDIltB0RSAiX84
+qnh2kK4sBc22p92HHeqYrayTftR7JKIoijzPQ0TP82ZnZx944IGjR48+88wz7N/I1ZFwjnY+GNvE
+KI4UoowlnCQB28BQASpjRTPWMxJ7mtmDGqt+FEGUmM4JgEzcfQSAKGK7GU9cCpG0xesSG1zKSxLt
+uEGbXSkLFChQoMBNhlGy3PWAW4eeQWFDy8LWuLMQxo5MIpvCCKc71pPzX7JU84igVCwGMR3CWLkd
+67ZlHGQyja8ScoaauVoURZHWgOB5nlJqPMuzhxlLY1pr3k4zMzPD0iduZBucXKE+hsVB2moxBmiO
+mRIx3bnFFtPtK+NLnuUbWU4iuU1SSOe5du2yPAdHWF2cHHKzzSVgm5pA7V6d++uYK7kkJ0uucvmS
+c4vc5aTJcnhhWcIM5S6bg9lEC6zX6lTHLlguLcxtFh77zNN839+zZ8+RI0empqbATA5gThq0+6H9
+JIDEfh6PeoUo5BNQESij1klsZ25YIdNVjNMzALIBHYCANOtvjA5HKQ8JSOtIW0TPWOIoDjgURxBJ
+as3OjQ7lHkO/CxQoUOCmwXVLSHJxVUt7PU/4txQ9g8KGNgaI6ByOnhUH3XuMPxIREGmmUkSkiZRC
+9DwKKIoiL3Y5gtxRJiputIU2ItAEmgAAlUICckNmG639CHBpWaCcnp6enZ09d+7cwsLCysqKE3x/
+FCMa01CTD+lJssqKvM7t2XfhfB5DAMYUOJddOGUeRUJycxtVgCw9c9rfKWS2BZx8ZD+hwHGStG/P
+paxO/k4fGPU6Rl20myj7UuTXXJqaTSw8wWmZUbQz99VQBuN1LmBoGCcul8uzs7N79+6tVqsAwNfD
+MAQA1uDILakc+DQMUmwL1zGVMkSJuRsbzhCR0D6ImvU3RLFhnoA0EHMsw9LYtRhJm7OsEQkoiggV
+InoAzpRgTy2Su9vgNknLpbsFChQocNNg/IJY4PrBrUbPoGBouWDRTWsdhiHzNLBYQVZETuRXI00R
+QBSGpFm9TVprHWkfERVABKgUEGkgtEgaIiRn0Ep28h1ReR4iktZhGA7DIXhGcoX0TaP5FVsDwjCc
+mpo6cODAqVOnnnnmmZWVFT7TKdsOdn3H8I0NYUvwNDamhf0Ioqjv/fOf+97//HPf1oMQAAHq8DP/
+hv7trwKAXj30P+y7PPzpb4Sf/kYAAPA//zB9+Aq8N/1c6jf/yS/++Cd/8e8NQQOU/vhTanhe/ZJV
+KVrb//Xzi8P3fju899s5nz/8BM4v4U/lsiOnhACLF770EiwDTJ/54X96h52ey+8/8MwH/uFfwtoA
+IgBEqFf/yW9P/9bDS0/82nmAJ/Nr7j33Mx/8Vvibv/tzh+iD0bd85cyVj/3qx6Fb+un3vQecl/uy
+S5/818egfccPvnfG/+b3f3BPlGn3yoe++h1WaVM9IV2RVJosd+K3ZlufHEo5hudkm9FmAtm+ZJfH
+KWf2lmxix0RGGb9NARp3SjAWzmyBgyBAxFKpVCqVqtVqqVTixgnDkCcHALBdha1nEREheIgeECGG
+hJFmNkYURZGh0GbbGMTTgdUcPJ0kV/hm+QERYwaoICJibZKOtKbI8z2KDY8EqAA0GPZHROw6wRoe
+dtcUPu/opJwPBQoUKHCdYEfmJUfHt4U8J5FnCmwftyA9g4KhZcFDtFQq1et1sARWx53Jhn1RGW13
+GEbNerNcKiGgwiQiHCIgOR5G2RzT/8XCsfI9r95otFotNfTQN2I0uYYztPYsQVou11o3Go1mszk7
+O3vbbbft2bPn/PnzQRA40jZae/Acz7RRLSCSrp3GST/q9mxjEl06vvaa+3sXoF/5/fP1LzzZhXl4
+/+vhfT8I71D6Xz6CsRVg/1u+70OP98urv//t+uvX/t0pdS9hx5R2OHjgx99Gq9Ct/9rT+rFz9Ov/
+o3r7wscAH338yPe6zb3/jf/zrz9Bzd5vf3P4nvX3H6vdAemYGbmucbr1V7ACAABLL85NqeVVuycM
+D/2jr/7RK0NYLcH0PFSmITwP64v/7NvPvR7b3/PJ+u2zbb/k15rrP3f4HPjNX/hca6BUpKN26d5+
+YOg2Aejp7/hv5Y+8fvhN71j/2GNJ+wDo2e9cAYCP/OHhQDrKvnv/tz/tRjoq+aV6o7624N1VSpET
+ixiQ9BDbVJJlRPLWxEXTZjL211Gc1u48RMT5iNNvNr1QBUi73mmtZVeY8yJsdiFgvQPnw26KTr1s
+spflinbdPc9rNpudToePQatWq/V6PQgC3/dzSabJQTNDI60BQlARegqUIu3V6/VSic9SM++CCIA2
+GhtgQsIm6hsuoe97jWaj3W6jIgKtFIZhSETKKxOhzdBMRqjANUfX63VElDO45SyB8YUqUKBAgZsG
+hUJqDCYR4a4Gbk16BgVDsyGyned5hw4dOnjwoN0dx4zbDEPTmiCKdK1ce9ntt5f9EifitAQslAFi
+Kkdiscvp/ARkYioAUaPeOHrvva2ZziAakjISNliil2WgGFXBer1+6NCh6enpV7ziFffdd9/Zs2eH
+wyH7a0F6BPJzgyDodrtRFA0GAz4DyslWa93v99fX11lg7ff7lI6wAsZS0e/3e71eqVSqSHNZe5NY
+fA/DsNtdo/K33nfxwnr1Hb/80Xf+1v/7+8eOHdNa/yroA/+A/sYZDwCCCAC83/nzd3/m18+eOzd8
+y8dv/+z7nz2y8ktR6R8DACKVv/GJH/C7a9V3/Z//4VUf+JXf1Fpf/Iu3/cAvnPsbtUd/7E2/99GW
+f8HzlFKBBgDvt//rOz/1wTPLy8vf9eWjH/7ZL9y58q+g/LO8zY9lViaxEl19OByWSh684otA8KFH
+4Qde03/ba1ZOnFXG3Br57/rSH70yhMaen/21v7m8BJ1O5+LFi6dOHQ/e+cTrvtZ85ol964cPN5vN
+6YOn4e+eg/Lco791ZOh5w+Hw5S+/rV63X6Ua/OXt8Prn3/22k3/2xKsDQgDwfb/ciP7q3QSD+ie+
+0FA1xXz1N/7jm556+OJwOGw0Gvv37z9//vzRb8vnP86OOCFaNs0Gi1wxofJ9v1QqcWxDebm+75fL
+Zf6pXC5zglKp5Ps+/ySxELXW8qvkw5+FPnHt+FcAkAbnz77v894wfjXc3/gKByblQvJ13kLGjE7K
+w1SN81dKcYHL5TKTrlKpZA8cqeP09PR999334IMP7tu3r9ls3nPPPdVqlemitGdm0DHj8hEUUUQU
+oafRQwAviqBWrh85fLvvlWKTVdpwlo/4bVmGdfaQJALA6anphx58aN++vag0kQaMHV9RlQxDIwAZ
+uQoAFCqw6CUittvtQ4cOSStBmr8VKFCgQAHBjsyNm81kjE5wwtu3fK+N3VwXbll6BgVDy4KISqXS
+4cOH9+zZU6lUbFE1C/s6kyVEBNAaQEfkoz/bnC5HrEQ3HoyWBAh2qGxzyf5KEItipIm0rtdrd9xx
+54Ejh0iRVonw5GxJc6RM54pSqt1u12q1w4cPHz169PHHH7906VIURWCMbLbiPAzD48ePP/LII4gY
+huGzzz67vr7uPGtpaemrX/2q1pqlurNnzy4tLZEVT08pxSf8njhxAgB833/7XHx7o9GoVqvsZ6W1
+rtVqCwsLjz/5J+Ern/5OqPzRib93/uSXSqVSs9nkDNd/B/4A8a67wrPrBHUKli8rpRqNBvRav4zw
+47Sg108DQLVe/vO/vQjr/v/33N9+6dxfVatVrfVgEJz/yt/53bc89j3R2R/77iOP/lKrXC4vDgg8
+0sP+9PR0qVTyBvv/vQffH172cbnVas3MzPi+f/ny5cFgEEXRzMzMYDDwPO/06dO1+smfu60HYfX3
+Plj5gQ8tf8PXPfEH//XVfMRcqC997LvWYF39X//29UuLpLUOggAAKpXG4E9f+al+v9VqMvEIAnZN
+9Kq1GrMdnn9LCgDAq7VqtdpM736Yeh6Wzs7Pw9nzvlKq0+nc9p4e9ABm7++XptvNpu8hAKpyfXp6
+OgiCWq1WqVTa7fZwOCyXy0KDm82mUiqKomazyRyjUqkQEX8tl8u1Wo1ZENu7+NUwv1pZWSmVSlNT
+U/V6fXZ2lvuD53ntdnvPnj3NZrNer8/Pz3c6nVar5Xleq9WqVCr79+9vNpt79+7tdDpBEERRVC6X
+m81mFEX1ep31BVxC6VFTU1PD4ZCLGsfCAdBaM49iixZX0PO8KIra7TYbuFiJ0G632Xzk+z73KABo
+t9tcizAMlVKDwYBJ5nA45J+CIDh06JDoKchymNRaz8zMvPa1r33ooYf279/v+/6dd9558OBByOyR
+yyx+hKAQFBEBRoARIBCoMKSSKk81ZqL1MpEVFsTsEUNElK/WzAAS2NH8D/GCja1W+957X3Hk9ts8
+HzVpAEJEQCTyzAQhRDD2chQbmlTZ9/1Op8NdAtKBNwsUKFDg+sHVmJe2lqd916ZyuDmUX1e7Frcy
+PYOCoeUiiqKVlZXhcBhFkW0Cyu2LDgVSiACkSUcaGpV6aV6Vax2F6CmMTWeQCu/G1jRWjcd7UTKI
+PZuIhoPBpYXLFxcuDSnAklKoSNyeNpoZRB1eqVQOHTpERKurq1EU8e4alp6zjl4rKyuf+cxnXnjh
+BTYiXbx4kdmX3Rpnz5792Mc+9rnPfY4vDgaDEydOMGEjE6+8Xq+vra199rOffeyxx4jo7T8aP2Ju
+bg5M3AUOMvniiy/+0V88+pt3AZTmP/vhT546f7FUKu3du5essA1hGD5+OYLD1Dv3Qrlc3rNnT6i7
+P14GGMCLjz2tlJq9y4cuQHnv5//L51588Wyr1ULE1dXVT3/6S83e3Pe8+6Vv+b7oyH/cTyXvxDLB
+DEW99TvuuCMIgnJt8P0KAPyFs0vz8/Ptdrterx87dqxUKmmt77zzTq11tVp99NFHS7f93jvmAObu
+rTTbMPUpWHz+ZQdffWZh1fO8sHwMugDlAycuzGilwzDs9XpMZlqtFht22LgUhhoAgErtqakAY/sY
+ANR8AIDy9N7p1War1fqZh+fe99rL737D0n95+IjnefW6P/sNiwDq33/szYcO16pVX3kAQLW9dPv9
+neFwWCqVPE9Xp2fXu91Wq8WFR8S9e/fyS5mZmWHqUi6XtdZ79+71PE/4D79HJnK+77O77/nz57mp
+5+bm2B2OexRTLESsVCqNRsP3/UqlEkVRrVYLgqDVatVqNX4cP4jL0+l0ODoi27iGw6H0ukOHDjEf
+YwJmHfCFPDbZHMe/sj6lVqsxdwrD0CEYhgkHTKKiKGKOKo8rl8t33333gw8+2Ov1bJMRt5hSqtfr
+Xbx4ERGXlpbW19crlcrly5cvXrxoZzLK9wNBAZ9erTRBSPxJY8WvHTmALX9vrAwRkoaxId0NA5SM
+SX5cMlGgUgqh3++dO3d+YfGy56GGiItEAESeyVYbkhY/T2zvMur5RfMLQitm5oiiFChQoMANjCyh
+mpxibXNinMQ5a2efuOPYhfLc4vQMCoYmkHHC8t/x48fPnz+/urrKEqQYl9ivKfd2IlKIChWh1kRR
+GE21pt795nd93f2vQd/TmlBrRA8VAvvCQbz3HwAseSkDI1Ah4uLy8l//9SNffvLxXtAr1yrKU1pr
+0httX7EKqbXudDrvfOc777jjjuPHjx8/frzb7bKNRegoi+ls1FpeXn788ce/+tWvsjzqRH3kr1eu
+XFlaWrKNjSxV2650pVKp2+0+99xzQRAMh0MwDK3dbrOoLY52ly9fPlc/AQRQ7T325ceHSnmeNzU1
+RdZGKa3Ds2sEQBS82DngV/cFt/+tY9AH6Ex/7tGv+X6pc5iAACr0+Fee6Gpdr9eVUt1u96mnnlLr
+Gt4NMNQznc5KMLjYJZgh5V+Zv6MJnfO//IOfgksA7Zedv7g2MzMzOztLROfPnwcA3/cPHDjA1T95
+8vkP/dCzcBF/48MPHrmj8qMfe+JX37T4TW+78iv/qVyv13VjEQigMo/lmtKaTTdsgGJLhXQY9PjV
++Y1WKwRgsw9iVPMRgPzWbKdTRURY/yZQ/+H+2S88vOdVMNCq8vxPTGnAe5d6h/fuRYAw8ACA/tY9
+vwL3WO+7/Kb3fXS+3W6z6yn7HDLxaLfbaI5j1lq3223u+aVSiV+02NCYNhPRpUuXGo0Gu/k1m01O
+w650jUaD38vMzAx/EF/QTqdTq9WIKAgC7mZs1+JGYIsWmFiUDGbjPO7kupA05mZ2B1NKTU1N7d+/
+3944Gg8di25Jpew+LBbjrOuIXDlz5szHP/7xp59++tKlS81mc3p6+rHHHnvkkUeY9XFRnccJED0g
+BOJtYEEEGpVPPGZKVgAAIABJREFU5LXrnbe98e0P3NNG5VjNJwPb1mOzGoKCy1cuffozn37uuWc8
+DwHJ8z0ACMMIlQ+g0vvQUgzNbof5+fm3vvWt+/btq9frzsF3BQoUKHBdoTDvXxOMcdG6eovFrUnP
+oGBoDkQi6Xa7i4uLtkefEyDBuUvkOXZOIoThMBz2grX19Yi0jqKItCf5G0saZKSz9J6UOKx2vN0E
+URN1u93VleX1oO/1vVjW1HY+zpyVjCAOTsJGicFgAADD4XA4HNbr9Vartb6+zmWTOJZkRWtgBsVX
+2PFMAjAIJbPHKku9LH+zLM7mDpaPOV65QH4CQw6rZRZ5fd/3tWGP6XOBFW+9+tHvfeZHJerH1J5v
+/jsHhx7Ty1gYVUopywnNEsQ1+/hxo33fW/7T970FAAAuAbQO/fwH3zgMyeYA0ggMVT8HlzV4+596
+wddawzMPwJs/9eDtTzYrBwfaiyTQh9klxXXkTX3D4ZDbUPH54wDskxZ3EyLfT2nXtNZ+dP/7e95P
+VJ7fu69/4aRPhz4BGp5Y/+9UBJq01iHL6n+28t8/u5xsJ4P+fQDAIQfZjDYcDtEK1wEA7H6JVigU
+Tilx5LVhmGEY8g4loVVizhLak+57wNu6uL7SdFweMqF3uG3twSV5SpewqYIz9MgKfyKJIb3dzi6Y
+ZCsFtp9uRy7hivd6veeee+6pp566dOnS3NwcD5nl5eXFxUV5NNsexUNSgAhIiohPmY4IIgINykPy
+KYB+vx/357ivQOLzPNaAZrKOE2rSFOkwCFdWVhYWFj0fNYXsw6mJAPhoDy2HcyAan0cAgOS4OURs
+NBpMO/nlQvoggQIFChQoMAk25CrOqrT7Bdg+smrNq4Rblp5BwdCyEN+erP5YBP3cGzGJjE28DUQp
+pXwFgKSJeQJpDZQ+JTw+xQjiMCEsZwKKREXmyaQj0goBPOUppZhCxY8eWyH7i2eAiBw7od1u79u3
+b21tbXV11Y6b57QJGBOc43UGli3FlpIlH3Y8E/7mtKqIy/LZ8zxYrQNegeFas6IWQxTzXeoWAAD4
+z1++7aOnqDS3+htfvwzLC1/3wOGPfkEholquAQIMu60yDkPfNpuoIz0AgHI5sAJq/tHJ133+vI+D
+6f6Z+e6CIhO3kyvLTolkxR7Eo18BDTB7Z6+yhBUENQNTAItnj97R/8oLDdWdAgToXy550I9I6CsY
+K1kc+iV5N0msFLumXIYoiqLIw+eOwgNPvv2upz9y9i664wJA9fPPHLBzBsArZ98avVhWSmlxCFSx
+ObRSqbAjK3s5MjUS3mg/S7q3tBhT03K5zBFThMDYI4XSgRmZhoklltkOs0Hue1EU2fEVs53NUc6N
+6jBExBvnlBVx1O6cTg5oOe/ZvNTOFo1jcxAEx44de/zxx7vdLjtPchtKBB0w7qCiPrBLCsQKFhRr
+F3dbzUVSGBOtmGsRICAZj2dhbLkgMHchEZr8lFLol7xIk6aI8wNUmZsRzAmL0iZgxqb0zKSLFo6O
+BQoUKJCBIwhdb5ClcGdLmFWSQt5KvVO4lekZFAxNYIt0IpuyBOx4MeV2d+t24N1kIt+jQvQ8NDtO
+tCaUeCG87YRV54iUnDodC2pGTuOJQAFBGEUxY/E8iAdGyupmWKIJHmnRPqYkEoCBjE2s0+nMzs5y
+wMZs1WQE2nYMaaJcPYoIwdKMcmaUM184bpNsl8DFDtRPw/rKG+8N/uRx385QmpoZ5NlH9z73BU9r
+/YZPn/riL1z633/shS89dvfptchfmoL6GVhf/rp7wz95wrec3IL5b+oCwMd+v93XuqwxIgLASy+8
+cvHpUlw20sI6RFq1ewVA94PfvABLAFc++4HvNzVZBAD997/7zI/807th/TDUHoHumTtvD586UZKK
+s3DPjrKG07rthijyuZlcGZffA+UnDwV/TlOXfxIBqm9YX4wtU77v61jI1rKLzGkudjK036YEVRdr
+kvAx5vBcQmF0YRgOh0OJiGjfaLeV02dsT1e78wAAGzDFDGvDJv/2xaR9rN6lDKQ6qZa0Ink4mdjJ
+5EY2lvJrunjx4hNPPHH69GneRihBU6Q/cGuPOIcDFQ9hZKbEA5yID51GQMwEbh0NSUjJBZ4uEFAx
+DSOgKAp9jZ6nEi0KyRZXOzPpdoSYkFKyTvG2qzZpKQsUKFDg1kN2krwajGX8VJwVrraMDQsv64Ut
+OVyNKt/i9AyMKaIAQLqHidhny3kTd0EUbTRCqiujUnYcNgAg+6NI5pDE3efj09iVkWU9eYzWmhJj
+l9nQwuwQEThKAfM9lH/dcQUAlUplenqao+fBRhPBJHqj3IYSO1vWrIFmT1TsPheU3/KbVQD93p8/
+cWSWrIB+w863H3v3m8NkHhIqeOzwez7rw2Dlp/6XnqcURdW3/04VgP7xe08dnJKEUfUdxz8yT+A3
+fvNPamgbPYxdSOx1IrizqMp2Ei6qbj8DSwD+3L/48ht+Qf48dhQ8gMWvtKuaoqkf/csZgPAf/k+f
+bHcS6oIYlN/yF3e+sm8xkLgajpuobcaK/9eH/s2FGtCFn/yGTwLBJ7/2Ng9dDzTExMzIJRfWIZK3
+8zqEsZBlBLN/AjMWyPLYdMh2Ylo0+av0OVqcDxu7pP9I2Zz+MGqUOcPTzkTqaFff6aLZXueU09EU
+BEFw5cqV06dPr6ys2OZBaShpFudx9jpJkrHRu/CFpFS5VQUZuAAT8DhEUIjmZAIiYvdRQ0pjMpjY
+60bn4x5KDunXWqBAgQI3PSaU9HaQFE0C2kV3hklaIFc1f3WKswO4EekZFDY0B5TntZXwKyu4dv79
+KIecxTwJAIDYic3I3wgKlU6ZT0ikNgQA0CRsDU1QAOQokaCUQuWRjg+7NbQMxPjmFMgqWsIzHZrE
+sdGnp6f5vDIYMdJs+TWv3u6v8sGZyOzbbenWamdv8LG7v+O+Zz5y79If/N9f/vCFxlNnyjjX/WdH
+u7AGH//4kU+aCBuQ3K6Wf+8IvOP421574q6Z+19YxP4fv+K7Hnjyw3cs/OEvr3zoePu5y/SL71mF
+hRC80nt/7Z5Ta+IticAn2KWnP7sWNgMhivzXfRUAvnjsrS9+Zg5MbyEKfmLP8+8/uPSmV69//HPN
+6IvfBN/yEbhw6he//zdheu+/frTxU6+/At0FWKNPfOXrjmWMOWBYh81YuEEMCVF4/M0w+zBc6QNO
+P3ViTmHsL0dEmghAf/c7/vgDT1u0jab7z74D+rHk7Twu2+xSDLZriY+i0CqhQ1JU4bF2p7JzthvT
+5m+RmIKNN51TMOcWoZF2mW1+aO9qg/QIpbTRzHmWfV2YZBiGly9fPn78+IULFwaDgd0a9u12VBVw
+wORIwrYSGJIEbNpKigfpk6rJNoTbuY0DD36llLD9uLny047IJG9c514vUKBAgQJZyDo4ftp0lrZR
+IqUsLvLvmJS7Nl07K7sjQmwWuXLIzuIGpWdQMLQxEPHUGT8bqDGMHUu6MECKhMTClFjLEDQQQnxg
+muFpZBvXkECx1Ka5EzODMxvarF6NrkeT/TXl9uaM50qlMjs7u76+HgSBxHKYuKk2mBQmVMaL2K2U
+Aqid+cVXve11L376H135rvkV2MuNVv3nH3/Zn32kkpy9a7+X7vS7/rT8yXf3fvz7V37yl9qElVP/
+x6vf+e7j/+2Hln7gZQtwBGDNg9nZb/u7h88vl1hGTqYEq2VspgHpCRQRQS392mv70K3+2edmweIn
+iKXB5++G73z6W9/53J997jUR1X7o579b3fOFD3znC7B09qduB7iEUO+8/ytvffYzTYAUJTBFyG9z
+aTRcefOv4MM/RnCJ3hV15fA9K5OXPv8js/at/r9rvW2175qCs+RQHmT3Dbs1xP7pUBTIdCS51+bn
+8n7t9LIfb0xnI3I7bfYnJ9vcR49qUrI0MvaNg8Hg1KlTzz777OXLlzkOp8wD8lDhhEJQncdR/E+q
+0GgdbMY/6+QgNImvmPwHQIhkdDgmockjyZ1ioh5PIhhPNSh7XGWasHpctrWzttYCBQoUuM6xy1qk
+ZFHexalSFl80ynrnCmTU39tplkmEug2TbeFZO/4qb1x6BgVDc5BVQuRqOEap5CFWWrPpjMmY2X2C
+gIgK2ZRFwr+YbznGL3GR0vKVROIjFstQIouYIsSbTlAyTn0Y3+9LpVKr1ep0Oqurq3z0WW5rbAe5
+DE3c1RwiRESI3vBLL/u673yZXRiMxVV15X2vf2OcTPL31n/3wTf8brLDB9HrPnznGx5O2XC01hKg
+DtFb/+3v+gedjtYaIJJywpiZV8/+0L/8+3bK5JaX3vYjv/K2+F0DAHj0/Ft++F+8xWEgqTPLe/f/
+8P9zf3xLUkhf/+n/+q/a7XK5bGwu/KAZ/Yn3v5+TpRq25P3V+96feV+mIm4NRtmR5Fd+EbYxagyd
+y37d8AOR7fm58QrnPCg3hzEZjuJ4YNYwJ7J/EASLi4snT548d+7cYDAQ9jW+qNlfyZjB461gsvk0
+rgPEv5qkykwc6T5iMgMxxMnGVe7oZsrBOEis88qRn4zprDLaHHs5LxhagQIFbhRcEyP/jk+SzjJn
+63AdNegYhWbu5+sZV3utuaHpGRQMzUZW4pRRMUYZP3YkGBHNCFVGSZ5NJzY19/5YkKOEtkkikdas
+p1GKAKSFsFTOaYsHIlYqlU6ns7Cw0Ov12H1rFwb5KF1UVigf9TX7U65An72SzZbS4S7sBLnCa27h
+c4tnF2N8dZwqZLnNhjNa9t7N2pTGFM9OtlnGMubXbAOOaVIa7bXopB/F1uxMKO3ACQDr6+tnzpw5
+efLk8vIyZILZ5D43W+bERk6AaMY+AXMlezgTpOcDNP/aLoqY5AbJL4aiWXvVMP2rMfOCxRDdBhk1
+zAueVqBAgQK7gA2XS3bWyHraj8rnaszeN9yKcKPTMygihTB2kIqIvDVJjrZhxfrjCmzmjww+sGgf
+pO8k4w1lF4QAyB5cWX05u5y1Wq2ZmZlGo+FsDSpwzbEdjwWbh+94kbbpSnFtwW0iEWIAIAzDS5cu
+Pfvssy+++GK/30dEx8ImNxqOl0OyAMC2Zds/s4rGYp/WPTF/4/fEf2OaZf3JU/BsAzfuuytQoECB
+mxVZJabtaT9Kk5vFLTvD3wT0DAob2nhsZUsGASBR1nI1YvsHgcWknAAC5hIlN6LxZ4pdntK520NR
+dPRxDexxapsHRTZFxHq9vm/fvjAMgyDgkCHXOXaEcuTbYe796Ae+/nxecvXrf/F9X3mmvIUHbVja
+ySfTLVd8p0harj1wR7A7ijq0No8xQ4tPedb6zJkzzzzzzJUrV8SmStZJgJZqA8wgTBwWE0O38V4W
+JKM8PVAJLd9kSE8CbBLDMZzMCfVIxMGFMsa8nK8m2Zhel1R2ZAEKFChQoMDOw9IDAppovWidKAPG
+xWN8PrcgSbs56BkUDC0XjufPJkTGFFEiLZYPIiRCAhTGR0CW4KXMUWgUS36gACi5rjR4BApAKVBI
+SoHHynREJNSQmM6MoIhkXBxTAp+ImI4LnwSTaDabMzMzS0tLw+EwGwl9x5HLgTd86C4I8frY238y
+WM2zJJaGL+7SqLlunQo2S89yR9MWh1gehG5tVqVCJuAHkzREPHny5F//9V+fOXOGz4Uz5URUCj0F
+CgiJUIOKQGlCQtk+BhooMVVTrF5BY2cz/slxnFbUxtWRbWWggLSOJwU3Kj5a/4LME2R8HtNbT5EP
+w84ZRGjpaSjmZ86O01twLS9QoECBXcbk/vnOZ4Gz12CUee0WxE1Dz6BgaLnIbjLJ7oSBsVs44huN
+jxJK7BAOH0girXF2sUjGV8koxq2Y3BKQzWQLCOjF7oucADWAlsEKAJDZUgSGEY0aw+zK1Ww25+bm
+BoPB+vr6diS2DdvHxqYetEGzj959tGHiRGUVdPrHOmOKMEExt4urZ6e6hsh9d5NfHJXndlxA2Ywc
+RdFLL730yCOPPP/883w2N8hRb4l3iUR2VfLH3Q5qMna/JuYo2+E43jmqZJ5xK2Lb6HgjGpmNZ5mO
+YS5QOjRl8jA7P1N9MA2YnegKFChQoMAuIEu3spE/HOHNucUJOGznvDtV2CyuhkLwZqJnUDC0MZDe
+k+1GItaMzQBjKSqJnI8kHIBy5KtMCVK6cwkNxwEATBg3ismdiQeZqOtdbyoQ0mZvH8puOWs0Gvv3
+7+/3+0EQsCVto4JuHX/1G1+8eplPhs9d6wIUuAaQwSuG4pWVlSeeeOLJJ59cWVmxF0jkowiJSBNo
+Nk57CB4CKFRsl8pRCgAYP0I7kIe9Ic3yX4bYGLbxrEDGXp5Nl/7JkK6ciufcmomDct0u6gUKFChw
+w4EyYRiz06zDuOzrcq+4O9nhi5me5QY0doTV621i31mSdpPRMygYWi4s4cx1BBoFd8MGS1wJt4rd
+H3kni0IE3qymEt8nkdKMOS2O0p9saSMN6CGCFa6fEgNd7G1lPzi1o4UgdQC3UzX7YA3P89iMtr6+
+vri4uGWGlhX7bkqjUIGdRVZxaCO73jhaQ/un7O2UjgMpHTIMw5deeunpp59+6aWX2N3R2p+pzLDi
+9ArBA1JIoNAnioi9G5Uxf5nejaQBxACG8p/xZBZrWBzfh4hw3GoVj/rYEJ/SwHCAyISVyYjOWPeS
+QI9jHgN5LV+gQIECBa4eZC3jjSdkDqjkX22GZi9kwtCyhrXrGTu+xNx89AwKhuYg6y6VazXO3mVS
+W56LQEakQ1QqTiUCFli7SxIml7C05Kthd7Fgh0RApDUgokJzn5QEEmLG9C7txCeltUVbm7PJ7NBq
+taan/3/23vRJriu7E/udc19m7VUAqgA0SQBcms1mryQl9iJZIcn6JM8iaWzZIUcoRh457D9hPJYl
+uWdGli2H/4CJsT0ex3ywPNMhjWbkb/2hO8IeDsVeuDYpLgBIguCCpVBVqCUz3z3HH8699918+TIr
+q1AAQeD9gixkvuVu796X53e2e3xnZ8d7P6VX52SkWlrhr8X0yGdLTs8a12m6Jf8N21d96L3f2Nh4
+6623Ll26tLe3l98efyar10JYxQIRcZolVkxLOrOXUzJ9x0WeTFwItiy7LNrbx7QxJQuxt0fwdqRQ
+DeLytA3A02gMDVGoILlbhz+jF9cY7Gfl975FixYtPhXcyhsyvWDtBe6cM1OYbUhtikJzuR8MBt77
+brfb7XbtlL2fLcdV/iGX5Y6mh0eE2kAdYfPuSXqGlqE1IveASlsq58drtqAhxXxyWMr3OCMSUYg4
+VxSi6kuzaNUzsaUi8kCVqDcnhkJtb2UlryoODIIIguSGoF2vgt+ycqLyvmJliImALFlCTTKbnZ09
+ceLE7u6u+TpW5Uzl4TkJRPSt3/0mEY26OH77v/xW/tUS6JlZL7Vtcsn51wnOWlZOp9M5d+7c0tKS
+vQ1reqk7/3ZLrTp27NixY8fsZZ0m4R1AmgbWErPDWBvKslxcXDx79uzS0tLhRibdlbqTNsWeQAMa
+3+kaYW3Lj9TqwshqHb14Z2fnrbfeeumll27cuGHzza6pUmZp8CGmkHlRHVMJFfFEYAhhON+i+T5C
+wh2kCC6SsbsQQJC9ITj8pk4wbtmkjFqWZFlXlaG0H5S8qgkkIkbv1Ex1ZKQRDLO5VQUnFWxtkMe3
+pkWLFi1aHA3sJVwURVEU5rLovTcaZgyt3++XZTk7OzszMyMig8FARIqi6Ha7NetZTeH+6fZrFEeu
+8rtX6RlahlZDPr/ts8nHacbnZKZh6mvUTBMAZUQLVRQiiYgd+7IkpdENaRtbBACqRAqCV1+WfZAU
+BbyUXpAEW6s2+j6m7WlrFrRKVYNhOZWIkq3M2umcW1paWl1dvXnzpvc+93U83LKvSeGNJUwIS/v5
+/+rn9hUZR8/uaz+pXfCpv9FslFLIr3U5J2lH3rxxD6VmvMqn/eHaUHsEiX7T8G5j+6oARrUJyRWk
+xslHv9ZusVG9evXqiy++eOHChV6vB8A5l1wcbeZ3XOHYBRqmAkhRwHsoynCkziNNpyLRVKYgD3io
+qjKBmGBPmAls6UdAZp2rckPG7lb2r6Gt0KJRTY1Cqoj33rOrbo+6HYCMDprySCmY4YZ+1G3J52+G
+NP3a3RFbtGjR4vbBXr+dTmdubm52drbT6XQ6ncFgsLe3JyKzs7MAtre3+/3+ysrKysoKgJ2dHSNs
+i4uL9qLu9XqNMSl3IUk7Qtw+epaX/GmhZWhDSHQlsRT7XLMyNd4YyZgCAiXx4s0sYzpyZmKSUkRo
+yHY2Zu0Mu3AFuVW8Lwd98QMmESfqJQpwyYdJo+cS1zy8TCATH/akt66ZAEojcXcmls3NzR0/ftze
+Czs7O0VR5HLwHV72/+5/fa7x+Ld+95vT3F5rbU1YTwdzynrkmp5pmqfDQFQK6Hh74FFVPeH4KLfB
+sHB/0BprNK/2efLs0mxzCGTscXIzcsqRM7rd3d0333zztdde297erkVaG4dE8i20ulhB4v1gUO5R
+yrVPXK+doGq12AkPeFEVL+yY2RhalkVEk35nv8FMjpLBjZmYSTg+DiKKAWmZTySEoKSkYJtRUZuT
+FAFpcPLhmmaznRYtWrRoMRm1H4jaD5b5N3Y6nfn5+eXlZTOU7e3tbW1tiUin0wGwubm5t7d34sSJ
+9fV1Zr5x40av11tZWTl+/Lg5udy4cWNnZ+dOd+xTxb1Nz9AytBpyQ4GxF/OvM516kgtHpZZKpiQY
+HSJzLvKSAsmIWBVehERqWxwFXqWVvKvIHaeC9xMrmFmAvh8oaRLVYikaI1ZUtIwms1iNOhHyXhUq
+KmJ78HrvvSergFljThMRBQkzz87Onjx5cmdnx9Qzia8eSG7LhelcCvzm3/tGzgwB/NX/8cL0xRqe
+/2d/Ne6U+UzWyAAyvkGZc1dODO4kNzPUjEIYNlvl9rQ70IaEvLrcstd48WQkVpYXgoMYLRvtZjSM
+vNmNLTSvyHSq3++/887bL7744rVr10S8EZKy9MwhfaPNDlHvpYR5CRLYqWBQlnvOFcQx274lAaFK
+aWLHrXNMBGKIKIGgDCaFlF4GXr2HesAjptGnpHMB4ruBtPKKTKcEECIiMCkVRccVLFIi2sgQC6vs
++gQJRr3queR/za8Gw2v2zi+HFi1atLhPoDGczGxoKysrCwsLc3Nztt1R8qAxXfmxY8dWVlY6nY6I
+7OzsrKysrK2tiUi/3+/1eru7u6lM3PWe6rf4y3LP0zO0DC1HblFZW1ubmZnZ2dkZzWFam1VpAVDw
+RPSmvvaqK3NLD3zucx3XERGvCiix5XGMd6halgAFoMmViJBcpEIEjEJKlP2lpdnPP3rG8+5u2ZOQ
+m7Eyn1nyAB4WqHI1jRdW0MrKiRPHlx3jxInjTzzxxMm1k4BaXJwogRggVUm5C3Z3d1dWVl555ZWr
+V6+WZTmqWW/kq8gE5cQuRo0ndkGyYj37Oz877rn8+F/8ZOyTG4MJPpPf/HvfsHei+Xznsv6nRdIM
+yVaWUzWMmXu3FTXuNPoEKbrLTl+a3ZKinJ1zjT8hjbNraKENtyEfnBqrzKuuDSwzl2X/xo0b3W7x
+xBOPA8TsrEjn2HsPaFGwQrz4bmfm7ENnFxcWut3ioQdPfeVLj+/u7hBxATazGjGIxNaRogMwUBpF
+o0oJoKLC6o4trK4dO1aQ01LhA/kiEgITRvL/xJEABHAgo39CFqMqKoLZucVHHn50MNgtpQ9SZue4
+Q8TDKhyAYJoZKAichsLG5/Tp08ePH89XKzK1VIsWLVq0OARGNbA11Gxoy8vLS0tL3W631+sll/vt
+7e3BYLC6unrs2LHZ2dl+v09ExtC893t7exsbGzdu3Ehl3oXcbPTX+dC4H+gZWoaWIzE059wTTzxx
++vRpkyAxLKaMm1hqumuRGMdPM27m1PLqrBbpruBZBFIoRd9FkzTD7QAgIXIkuCwJqYff0/7miaW5
+/+AbX/za0w+VHGxdZO5UVc5GqqUIycmaKCsV7LrHjp+amVvqdh9/8HMP+FJAquoV8ArARQKmgDJR
+WZYXL1783ve+9+qrr+7u7uZrLDdHpDGsmTIAFEWxtra2trZmJde4B8a/SnKh/Lf+8ROquru7e+3a
+tY2NjXT7K3/6avPjnIgJxrr/9Du/uW/DbiuKohgMBru7u2a/zdnFHUCNxiR47xcWFrz3s7Oz6SlP
+zxvTOkLcgmxhYeH06dNzc3N6KAfOdItzrtvtWhqr2qmcs+VMz+B9CeDcubMrK8vOOTMgWz4tZi7L
+UtU7RyBRAZObm5k7fny54/zM17/4+CNrqgIRBhw7sXQg5EEeIMCpOqKBVWjGsap24Y5bPLZ4xu8y
+SmJ0WTu2p1qMRYvRY6PDGDoWnCIRfR1PnDjxrW9/6ytf/SIX4UXCVDBz7jWZRsCUsgROPs/Gyrrd
+7urq6szMjMZcz40qlRYtWrRokTD9G7LxpzwXhyxZiMWhFUVhMoC9pUNQdKdjP3kWNmwXW1qRfRWm
+n6Le+Wh/RO4MPfvB93/wqbO1lqFVyK09/X7fNq5NGQUmW1eILO01EH0dVXW2mFvuLsx3Fig6PmJ0
+gyK72pLuE2KGNwEZPyICCnjZ29r85KLOXdMFX3RK7iTRU4KWPHhJkqUaiE6SmRsl4EBwM+LnWOdZ
+O/3e9sbmjX7PEwCUYjY0cGR7wainUCJ64IEHFhYWTp06NT8/j+gtlhhaMqzlQ5Q+O+fm5ubm5uZG
+bSb5YDau4Zp55NKlS9/73vfOnz9flqUdP/Ufnsyvzwu58v2rTc95H/yr73y38fhX/rMvH6K0Q4CZ
+Z2Zmut1u/sLNzUF3phkYMVt1Op2FhQXziZ+AxgUyyvfOnTv327/926dPn56+PWka1HzwbGqN1l6r
+NE1IVd3c3Hz//fc3N2/YhHTOwbYopJC5Q0RUPSAgKbggsF/oLy92uk4Y2442GAPnAPEkBGKogErY
+HmhwAKsOgnVa457Wlk4RjmT3xnW58cnGtWtFOeiqhg3WUjhacIwOPQpKnJx7xq4zsxBRWQ5ubm3d
+2LhRdBn4gstzAAAgAElEQVQwF1DYW0dHXjjhhQYWH15utpxnZmYWFhZytUsyLE//jFq0aNGixeFA
+Mee+0bPctcccT+ys0bN0MWV5nvKixkkLd/KVnutGj6Qld4yeHWHJh0bL0CokIVhE3nvvvY2NDXPq
+tTWA8eFnUfoybiVmx/JeVhaWf/6Zby08+kQ2CyeL18buLHOjAo6UHIF8f29z4+OLn1zZKsvZ3X7R
+kw7ApOpVlWL4ShamQmnia1anKivNupnVR7/47MqJc++/99FLL7+1vr5NqqSlAkIsRBr3vw176RLK
+stze3j527NjTTz/92GOPzczM5LKyKXgsIWwjAUuhR5P90JKtI1+0OUMTkTfeeOO5557b2tqytHuY
+KJF3ni7yl1R+Zf8ng4kPogGv/cufjju18M35g5Y2irydNJz9PNcO3GGDRs1cljv9poPTuy7YU7Y5
+8+Uvf/l3f/d319bWEK1qtYvHqUJGv1Lmedt4V7Ld2QAOBoNLly4999xzn3zyUaZZICLGkCZFRUpV
+XzB3XPHgA6fpmSdPrc18dPn1S++9Rn57tkMovQw8iABRKkHmkeIUDJSqantnELGtRFUCd0ArfvDA
+9vqZGx+d6e99ToU4j1uruSbGsQurOa5yayIRK3TjxsbLL79y/sJbRAJSEIllCuHmx0FEpGT7vKVN
+HdbW1r7xjW+cOnXqoAbSFi1atGhxCOhEIJOp0qt49Lcyv/Iu93q4xZ+V+4qeoWVoozAydv369YsX
+L25vb1ucEqIQOUFqVBAUpGLWq7L0x5eOfeHMY/7sY0gMRGkcRxspmCzG3wFOS927ubO+WQ42+7Mb
+g2JXClFHqqIqCCJg2AA3SYS2ELQS7UikGMhMd+HBB86cm184dmP9yrvvXvj44xsMYpQiKsweJAoG
+GJaLJBRHRHt7ex988MGZM2ceeOABI2kGM2eZIqcx2Wu1rxSAEYF+VMoffb8YXSnLcnl5uSgK771V
+emjQV0PtdTPLYVwmsf1XYxMoWUWHw4Q38t2Axubty9DS562tLQCdToeIkqv9uComl7/v+Gj0FLXo
+6g8++OC11157/fWfrq9fN7uu957IRW5GkY5CpPRl35HOznQIe1/4wtqx5bkb6xc+vvwyy+ZcBzTw
+UgoTg0QwAHsCFIUqQb2GJhv3Y1WokHLhcazsb+1t0d7mih+csv3JzI4+rgNGyKo1hKrPzOj19j78
+8MO33z4v6gFxBStURMclhjSGpgpz6jYnmZ2dnSeffLKmKZg8sC1atGjR4taRyJWJmo1sbfTiQ7Oy
+O6/tzas+3I33Gz1Dy9AaoaqWGMcSY8SUh1WKszEzjGA+ggQFBmXZ6/W8eCUWURHP0QHS/JZM6WHl
+ZeYvBL13FMVYtQOdYRHtib9ZyBZ0Z6CleCFVxK1vA58jVQtOUw6bnykFaU6Ztcs6T1hh6oEGZdnb
+6+3u7e0W5AqIVymJfLShscKpAhC2NI+6t7f3/PPPq2q3233ooYfM+5liugga9gJNSp3ai2D0RdMw
+jiMmo2RWOkL9UDPZHk+oDkfeJty1L3m7O4lZQmPzpm9zztgP+squ1TKl4Q5Av9+/fPny888/b/kb
++/1+Ubh4gY/+xsneqyIDkUHB2ikgOgAGIPJ+A7LO2JB+nwdCSs4VgBJ6UPM6dqKs6tXInjIrA06V
+RCDqoKqDYzrYg5iPsVqGfNLGPexTPxFeFxyM5BWhIy3LshyYgkVEVaT04sm8r2vFUKozDL4xtL29
+vcFgkEZsnONAixYtWrS4FeS/Spio5ZxsdLrLLWZHiPuQnqFlaAk1C09yM9O4GVoKv8l1zMNlGLex
++A8AUMn13I6dg4dlZ1SKenHAQr3CTZY6xAQ1JSZRiIMUJAV5oZK4BPcFPVJvXpUUkrwpkSLthwZW
+sYakHXCdkCp1HQUixo4Kx4VzrCBF4RyILUUJqzqFUxUVZep0Or1eT1WvXLnyyiuvnDp1amZmZnV1
+tdvt2mjUhLmaUmf0DTLK4hofR15IomdHpdc/sM7pTpG3WzG7fbYwaj7dF/mUGDdtRo8QkXNuMBhc
+v379jTfeePnlly9fviwiztUyAOUMDbaUmJ0rmF0HIFVRKQmDbsd3tUR/h6CMgrUECWEA9UQgOCFW
+9iEYDI7gCE7BTPDEqn2lsmCUpB5e4VWFURBc1OJkXcgGLDk3xu/QkJ3RohTA7AAwkyoxE7OrjUj6
+vVcBNMSg6/C+BTW9bGtJa9GiRYvbhHEv2PQ71MjZxmlI70nCdn/SM7QMbRQcka+KmqSSn8o+m3Qj
+0QFJJUTsq+WHU9XImpoThkQBMSdaxui0YOowCaughPZJeswxR4iZ0cSi1yhZ44LbI+IGTSQQD5Qi
+A5WSLNrNxDSFqpC6GNoCjZ8sKCYp2lX12rVrP/7xj5n5qaeeWl1dRcadxo/McCfH5NyrjXbtSHKE
+uwvlxaMlb7didrv7Mc4QeojH2qiAHDXkGrz36+vrr7766osvvnjlyhUAReG8L+0aZttkotIXhHKC
+gy55IVXHptNgR6JQzyqOuCAWhXghFlIBE6BMovBKZtIWQAiewMoMdQovECYhCFCChJhIHcBAg59w
+bI9AoaIIOxcqhvUgIkLMYj0JYXXDqV0jRMS2Uqst2OjeGfafSJkeD/poWrRo0aLFvmh8A0+Je5WP
+1XDf0jO0DK0RSZFc26i6McjKUMmFCpAmrzx2DGJiEhF4jxDrAo0GtGp9KeJ3SxMSDQWqBHKEgnWg
+JfkeU8+50raetQVKsHQh4WP0f4oGATWyRpY4gAnESqyqXmRAKJld3H0N4S6FAETK7Aa+LHu9brc7
+GAxUdXd398KFC51OZ2VlZW5ubmFhYUiinSK7wzRna/S4URb/TGAcp7rzPpOfLsaxKR3xg52+qFE0
+lmPLttfrXbx48aWXXrpw4cLe3l6iZJWqhMh0K8EAHmLIoGZJ9sxAwYVDh7UjAxIlp10Hctwhr6QC
+cSAlJYVDWMO2Q5oHPIHIAjzRYZQMX0AcqSNSYgZDICoKJaqHq+ZDZt8pLFP7HJwfFbYxG4f9F2NX
+YiGUbHAkkGimTg8ixT/UdLctQ2vRokWLI0ftBbvv+3aaH8rPnIw0GfczPUPL0EaRm4Mad2udZCYK
+fMlolsasikHucUwODl5ERGHhZrm/EqVP4e4YrUaqEIUXFnFQBRzBQ70YjwrL2iqEatSaZ2Wqhm1x
+Tf4jY1/KDI4xMMG9y+RDAgBRtQgzjYn1rart7e2LFy+urq4uLy8/8sgjtkFWNgAN2JfF1S4edTpN
+j+beeAHdbz6To48+sYLpt70+aHWI9GwwGLz//vs//vGP33nnnZs3b9q6jmnlcy9CMsITDX3e9s8I
+eg0Aqgw4OFImZWYn3nvxTMzBZM3QxJs4KkbE2mR1OaiosgqpZwhbhv6wQm3j+dSe/AMRhUA0kG3e
+QUCoRGHJQ4J+x8z3ZPmCoqnd+hpM67GenDnngkLuStoytBYtWrQ4ckwjL427clTpeXeKRrfy83Gf
+0zO0DC0hCSWJAzQ6OqLJpDMkxIS7NfNXJJhamlllWEsfhSVrQrKjxdJBwfXKNjaqWJUENbdyteuZ
+piiV1JTwfyXomTq/8qK0hI+iaraCSNSCvKhqmnjk+yGaafHatWsvvfTS7Ozs0tLSQw89VHNd0xi8
+VxTFqOFRp44lS2V67z+7ZrSD4q7ymTyogetAqM2EfZ1da8dHGUWyfhvxS1f2+/3z58+/+uqrGxsb
+afsvjXl64pJN1qhsscfVRER2oW1pxo5ISMkrSgr0R0AC8kpQlEARIr2y/kEd4KBMsKVk3oYa1SkC
+sGX8j12t1CzBTBb9kFOR+T8I2R5NBUNDZxDeBRrJWtqSI5HV9B5r6VmLFi1afOqYTNImX3/HMI3O
+/RbdMe5PeoaWoeWgDMhcsJLYt38RUU0+WnZwQvIKKBOn7Z+ijruiZwga82CEE5ADeWWCI3UkBYSF
+IEzEhLBzmuYZShDV+OFYqsOy81sG/tBUDTIosYJEkw0AUKUgj3ItXT4A7/2lS5eWl5efeuqps2fP
+YtgFNI1b46BNs0pzwkyZi+ltJQx3P+4q8nYI1J5dvtxuvbS82GSXS5NnY2Pj+vXrZVlaen0RITJS
+FspKDcpLtl8VTVSJbFV5sAClZT8VqCo5VoS9KsxHOGb7kRgICkfKKk6NpClnrsiolj8Fp+VxvbYG
+S3rZRD1MYmVqlrXRJI6ULgRAHD0pJ9ulW4bWokWLFjXcuhwy4cWbhJ9aXTV/yPR5VKd2J9/bt1sk
+u2/pGVqG1oiaMc2QRLfDypQarWc13XYytYXLUMWhDXk1wRIzKkNZwXFvXCtqyE4VyZ+dioWryaxR
+YR8j3pDEQfN9rNqmuUCXD4VZF/f29nZ2dsqyVNV+v4/M6pgk7+TDNurkNm4M83fN6Pjfynun8d7J
+bgZ3EuPcGKZ8/d22gLd67fy1SSNzhC/rAz2v0cvM2Nvv9yX66Nq2GVR5L9eKqohYMD1TFSaq6RAD
+MXtqJErCFHUl8XaFZuvQVh9DHYHjuk6/pSECNFZFRIl21bvV0NGhAautr8jz0vGMDGqm/hjnP9zS
+sxYtWrQYh9vqYIImFtcof9aOfFrv7ckq18O16n6mZ2gZ2jjkprNahEbtQ46Jy7V+x3CGNcWQyKjV
+P0qqw/rwYBUjoehDle6NYmS8N96QyWgU4ttoWIVPGnKMUGxcdceoZJj4kqpub29vbm7Ozs4uLi7a
+vtU1G1ptDA+BRrbWeNkhSj50q+4MbrGF/LWxp+SVw/y6jLtrlLlNwzBvcWLUyk/zxJwYt7a2Ll++
+TETHjx+vrdzE9zWkKomF2RoY5W9UrQ6jYqppVeWql4ropb+2yrhaa5baUTnQvHg3EWyj+QkDltn2
+qv5HRUr1c77/iCbXzknjf/evjhYtWrT4FHHrzoe1s0dinbvFEvZFbqyr/UwcqPbJF9/n9AwtQxvF
+NHaeW8O4GZm8HEO+NlPLi2V2C2RKlUVJEOVADVayKjhlWECj4b/ZB4tVMaMcnJJmEmYwA4QskE30
+LJd319fXz58/v7y8/Oijjy4vL1vQWkhUMCkJRK3cUYJ6CLXQp+gAOe1Uycj30D0NOdFHe0P1EyM0
+IjtEY66KmEjexp4af0uDhSc05PA+k02GpBGXj/xrIh47OzsXLlx49dVXT548ubi4mLxka2qXQOqm
+oTRA9D9mNTs2GBC2+DWNUWIEDvqOoZZqSucBkAoQPZ2JbA0CrnpmRzSRGxZSixYtWrQ4UhxaOzzq
+XnSLxRrucDDIgfx9GnG7G/xZpGdoGdpdhiGKokQK20060DOQKAnMqFYRrmQKS5LmsOQf/sb/lOI2
+1hycr7KzI45fqHKR5MdV0163W1tbb7/9tlnPHnvsMbOkpTg7Eb8fVdt3NO738LM7j6Mlb2M8LV8F
+nt3B9kELq33n5Asc4b3f3Ny8ePHiCy+8cP78+aeffjoZl5LP7eTfxeYqKfcedqpOUbAKAaRcpUAN
+17DCVz7DcTWEz2G3NEkXA0bSELyL92PXt4h2LbVo0aLFHcO+8RT7xnGMc268G6Sj3GHqoPfegcZ/
+RukZWoY2inHzrKa5TxJe0/RKGRGrP2ltKeLeY4RoKAu+Uzk/o+g2FT0UFZa7w0gaZ3umVXnnYuJt
+YFQZX8WehM+seehMaHKy7FSXh/YP91TjHtYAvJdr165//PFHu7u729s3v/CFx9fW1pgdVJnZh+Ry
+pBBo2h1As/4mGVYxJDoSwsYAIDMbaiST45b0HXhNNb4/Nf/Y2IjpNWGayktuplUN1cmU96GhDeHA
+qPFz6kZMAH91qKxq0h6cuQGYv7Aw7tTe53eQjWe0Qw1PEnPBtf0soOyciFy7fu31119/+aWX33jj
+jX6/b7Fnzjnn3GAwAGC5HCmtq1QNxbG25avB69EqMb3I0GaF+baD9o3iEgqeydEwbq6/iDRP0smh
+vpBS3GIe9bWgDIt2G1rgo6tm2AXS6qjmU/Pv/93wG9+iRYsW9xVqrCx9mF6BeDc4ou/LLcfhyN07
+G/HZpWdoGVqOPCgzhc4nPpYLMbUPjVOTEh9C5mAYA8VCskUyplap3lO2bCJlNblMh9NvJyqlgEaB
+rRbGhlyyjTcSIMQmOprcFgmQkqpaWTHozIxnLlZUf4+oKnNIa05E/X7/8uXLW1ubm5vru7s3n376
+qRPHT1hicSiDTIT2RDaelKU2oUxMTbImKYjNNMKw/OaAg5BKAeWM2tV6vT8yuRnjBNamK/PmTrzj
+gI2pdaDm6xmZQjWB8rooRENVRxSRIzTQsYrM6bgT9SPjh2c0q8RR7/A2+8584/Gdx25CRaFKynBQ
+SKmqEBWArq+vv/jiiz984YcXL17c2NiYm5vLoyKH9CxVQo5sGSHrPMUcqaYyoThBCURC5Fk9QRhE
+RrlSdkS7XSmYuwPpYgAxzaot63R9nPkUUpGMzCVnKyHez4ADIYa02fFQQnwbpKmq+ZTQeGjUq3aU
+pyV1lWt8Ei1atGjR4qhxhLHZtxvTN3VCEpHDFTgNPtP0DC1DG0WaRjoxZXyOoVwFsYiYryPJRkFT
+ryap2b7RJhKG1AKUS+zRzymnWVV6bYUCkm5LbdCKDA7N8iR+Ui6kpdwEGrZuGrozOEPKaB/TKKlW
+ZweDcn19/c03B2XZJ8IzTz+zsnyi5wfOdRwXIl5BTERhTzbKOqhZwzlJlmJHyDwqiakQIfFO1VVe
+mohJ1athGXmeTU8sf1zjoRO/1k6NPZtSTGgyYGaUqKGO3AaSuGuwpXIwv8SSo7nGaIAMl1Qx/zhi
+EzoyNN80Fd7U1Yn9laELbUF81T7nbcBTTz3zz/63//1n5p4aU85YzJ9fHHfq/aVLP3np5eeee/7C
++fO7uzvee1MiGDezvKNEZMeZWaHEjNisRFo0bpVGRKI2tqDob8xExESiEE/wDBd1K0PzKpaJFCwa
+7WuU5x2xYRZRqnL/Zw9juKSw6u2BKikkqDii13EwVldvlepJhCbE/bFJQ/LVpGdJSIPQGtZatGhx
+r2Kc3+D0+NTfkLceAHZUONDvxZ0x/X3W6RlahmYYtTLXkmEcrLDwIam0SVS8FwIIrOpFm/JvAFGc
+q/ZDGlJ9a17uPishmWKSt6TxPhGhzIxAZIp8TVJZVkawFqCJ+UTiSsysKkTU6RTel9s722+9/c6g
+FKB4+umnFxdXQOKlBBFRx6hcFIMZsD2ZJO4cUIXixKWuMUcdBbMH5ZJn6mvqcSOjyO1So5ftZ0Ub
++zUd1WAVHMmhiSBKD59IxKe5vSON0mSA0VBLRdvN7y0SQDCQiflDvSYaqji/IGWJIapohh3kWin5
+Xc2DgQnmlnqHiXn74R47Gh3bufMz48sZi7NbZ84+hl97rHb4X8Hjefzz0WQh4KiOiUQ6rLZgPwcA
+IoaqqIplbyQGWbb+2JcwAUPK1VRIbayrS2lYm5hpF3jsLE6Impio2qi2O6zqIgSLYpOiJvUuo6M6
+ktExUb60hUaLFi1a3MOYXuSrRXwcSe3Jb2tCG0YPNtZ+176xRxX9t6+ue4CeoWVoOZI2Io8xS3rl
+g2qUNYu0Som5NdSiqpVDVTCcUdC2p+wBGS3TJIJlZrShlg+1bajqiqxVXYtLJcT2qAx5RaFOM8aN
+EhHiyAgRMzOB9nb7b791Hijg3DPPPLO4sKjqmbvMHC1JtldvylwnIAaUiGHNsW21zSlMvDFSIkek
+zpVEJZGAlOBVJY7hKPeYvPiD1a7W5zGGpjSGOnouXtBIuilFNgGqEE11TrBCjVagcZtx66hZfcQe
+bqw95bFIHntDffFZcckjdph8xfjAdK/CEzi1VYcKHCFu4QlQMmw29gEImyWrlsSeuAQQUmhkXd/5
+/FZgpBAoqxbQAiCQLFyYGz9wY/E7z/4Xv/Ns86lf//1fT4QpdCI8MFUokRBIBaLRGBbsZVkMZzY9
+4gIbMwWpWs15h9MjSYyxGovapaNTlskRO2O6qkQQFSIbbmlcBhQZpjYlUEnXpL8tWrRoce/hSN5v
+00iG9/aLdJoR2PeaIxyie4OeoWVoo6hpMtLnxumVx6EZ26Fg/zEfJiImQB1zp3CqqpbYkFgqqTcg
+SWghGiwl7xgiaSFRQbiDGgS5kTmuuUY/sE3TkauoRqcpMxLwqMCZSeDZ+iEiVXgv2eAos7OrSq/n
+L1z0qgPff+qpr584vkrsVZWUCQzi4GJJAMAh1CxsIUBQVhWAQaqi3hT5BO0DnrjHJGaY2o/o7PvK
+OBrVV1bUqGlO0/NK1CpzVp0WliqFwSFju7EwziflMLEcIaxNrR06osiSUAxdIyMXN5WW8imyzaVQ
+JIbtOwSWEAipBA/tAz0zMzcWrCqkAByBiQRgJdp5dFu0VPWOC4B7vd6HH330yiuv/OhHP/yf/+7/
+sl9rG/AXf/QXjcd//fd+TUUEUrBpH1iVQr78jJBHJkbVIq5OTPeUbYFO8fOU8aekxQnqHuKoOoGI
+inlvquRpISlaBcOdyUpmqVPSbMq3yrgb/GdatGjR4vYh10Z9hqjUXfJyPlwzDuuktj/uGXqGlqGN
+wrx6bEevEKyi6r2HeThlWeMb5mUloSkIRVE4YlVVERVjXsTMRJrr0c3KRamE/HhwZDLqRJGkAcHX
+rZLqploiVDWbiMT7wWAg0IKdejG+GOPmIkHM9PoYNtalCJZut2NZQ9SkRSVi3uv3337n7dL3HOOp
+r3/9+IljFtJDVDAxO6tMojun0c0QhKak5lgG8QWpY+dIVErv+4xewULK0CLS130pRPPwZJxmmhfE
+kA2Nh0oML/YRC4d9FePbydKXHAdlyqcGELQgCnNAoR4CUmIheBXNqUH0n83TTcQ8hVlWkTqZqA7m
+32qkIc21WkcJSJTbzEvVrBwyJDmGswyJFDx5PaNkqO3gHO+p1We7SoMgCqfKDCZ0yZGIlKW/eu3G
+y6+8+ty/f+7ypXd/4w/+I8fsSy1Lq0eXlpZ+5Vd+5Zd+6Zee9F/af6CH8Rd//G8ajio+/yX80ze/
+bCl9hkyI9Xk07v2glRtvfvhA0DCdVFW8ikAk2ifJMSAiaNwow2ok0hie1+jaLSLG3HDXyAEtWrRo
+ceQ4Enp2374kj7zjt1jgvUTP0DK0UTCzJeZOK9Y5h2F3oFFEIZ0AMZrjLEZLBApi8iIMYe6QZ9Ey
+8rJ0/2iJpoJXsrz4lZ6+8eppEEJWLM1BclYkgJmV2AHMJETKJvwph/QhdVVHFOy4KCy0TNLQMRWi
+UIioloPy0vsf/Lv/9/8b9Hd/9me+trq2TCRgJQI5TzSAlpaQj9RBC4IDOUBNmS+iRGDHACCenTrt
+Qa9BtxyXjqqMGWOC+oY7n/6M4CgUOGYxrWhcNGGpkhADCC5xhaCIq64cQy5H28NAoeqgDLK8FAIq
+iXokPcAjhkyZLYZAqpwx0FED39QYGrFkl2sax8hXImnRaD5K00chRNp1IUqq60rCFtMGaakhU43p
+DkKLiYjIMXGskVULoo5iRspCPYvq+o31H/7ohb964YXLH3642x+QKgNF0ekURel9WZZFUdia/T9/
++M///M//fDAYzM7OJlqihD/7h392iHH5r3/9p+NO/el3D1HegVEpDCLpJyJmx8RFxxF3BuVAIhO2
+W4jipWF8OXfnTpY0M6AlV4KhkLkWLVq0aHEbcN9yvCPEPUbP0DK0Gsxcpqqrq6tFUezs7ABIbA3j
+VSxB4BMTuUUBL7o8v7y6ttYpCuNEZiBK3kSVr1uzk2IyKejwNYeWlggKcuScA5Fzxerq2uc///nj
+KzukxBB1EMvub1FhCo5mGU0djD6NZVmKqO1PzUxnz57p9/viwVyokpfSAmCISb1++MGl9UdPrq4y
+ub7qrkdPdI+wQzRgImgH0gGKKmgrGAPMYoRyMHC2hxV6rvv+8dWbDz5Ie71CKzvknRAha6/PynM0
+sL9oc8yso0S27TgxMSujL9gZcK8sSuHcg3UElMWEGe93gLP94Eg9tM866LLOFzI741k8VGzHhCix
+03AymqZ6GsYsdeqwPxYVKxstQQEmOIYqvPenPleC3xWAWQg+34CBM74pAEgFHoCiozIHXQLNES+U
+veKTK5euXvuw03UPP/wIbMMIL6riisJm6dLS0qlTp7rd7tra2pe//OW9vb2iKJJ5nBz//X/x90Ot
+dQ9C/ZO/+yeHGILf+k0Ag5Gue8D/6Xdn4nfC2Ic/gkwVUTUx0mXLxjo3P//wuXP9QR9QdgRSL94G
+HCMMDUELIikUzZjY6dOnl5eXJ6uiWrRo0eLew6dCkHKt952v/R7DvUfP0DI0Q748zL3n8ccfX1lZ
+oQzpylo4Vq2QsLct4AUzRffM2oMzxYz3HmaL80GMxjj5LKi3M5NPLTMfDRnfGgqJh5IhIh1WqIha
+Q+fn57/4xdMnVh/d3VYIGCKs3jaAivkfWZESACb/xjxOb2Vl5eTJU4A8++yzTz75pdBzJdPoh926
+MJiZxcrSQm9vnWiLi5vAFrktok3mngOgTNph2N5rXskilciy6ouq+BLsfE8GZf/YsY1v/1x3dfVM
+Waac+1RPvZCezoRvjUOWrkwmsOFT+ddh/z9B8AqNw2dslwhwAkdu1vnu3if9a299svnuNd3sd4QL
+Zc53Mq880mznYsBSgbD9a36AwoQ+y14HndMLp770wPLZFZkpBX1BqfAggJjN+KpabZxcH6JokZ30
+uzA6YsO6BMoPJzWCxEM0fBfZZHRMgPb6uw8+tLK4dKFfXmcSglr2FwBQrh6A0UWy3c9IpCN+DrpK
+egx6rN+bX1rkn33mq1/9yleZO2Zwk1JKPwiRVqqdTufUqVNLS0uPP/54oh8hqSMTcq9dJJtUUEd8
+/8qvEquqF+8Lx4sLc6dPzcng8is/+su/8ZV/OmHgxuG3frMHABgA7wPvA9+343/0D98LTYgDTA12
+4WHjZUoepKKKEydWf+7b3/7Sl55UUhBEfepSljPSLL1EChWNF1QMbW5u7uTJkzMzM9773HGgRYsW
+LbtMOIYAACAASURBVO4NTOkRcFsdB8a9V/Pjh3v33sob+0AZLO823JP0DC1Da0TSH5v1bLKrTxWa
+laKRbGszCjH7KtVGSaoKhcW2gcwlMt5ZxXchJFoI8mISzdToGUIakeFmxA8x2ToRVSFnkVOF3XPt
+qhQNY/Y9JlKGxHCiYIpJ4W8j+h4R8d6bKxoRO8cARAUqab8nBVSdH/Q/vPzBpfc/KTo3T6z6+cW9
+2fkd564R3fQoLUs5ERFE4Yk9ALX0fXCqUPGlkop49YuL/tvfxlNPn1Qtgq1o3EtjNLxs8gso5815
+R4cYckNtQZa2XB5wUNsVvGQtHQFUeOqAF91gaeOd3l+7/gebm+J1pnQzvigk5Les7KT2MDI3NiUI
+CSAKD4iy9lh35nTpzNJXf/7hMz97mhf3hLYVe6CBEik5hRMFqTebaJpME3te9ZLqJ5pUCvlgDlHZ
+4RCr6jgTCmZHpICU5V5nxi0uvV56RgjnEmIFCGGrdhDAHOOtyCkKL91ysDjoX9/enNu80d3bXWJe
+Jl4s0PFSKkqwBTnajoNktjIJlu1qAtsCZ8eiYXOLkD8n9s0eh3MEiECdg3NMKU0m9J/8+RMdf6Uj
+Ox3xDiCwsiqLkv+t/2T8SI/B7//358ad+sd/WCLMh9yUFv8jC20Ni13FtjkDE5MjIhLxtg4jI4/v
+Ma7eACF70IhwYKfu5l/lFi1atLgzbKr2Jhz3Yjxyt/C73Mn8FpuX1P23gnuVnqFlaDXY6hoMBh98
+8MHNmzcHgwGG7WaN03GUoYHIe5nvzn/r6W98/dEnHTsAXrxqyOaXJUfP/w77M1YVWERT9n3U/mG1
+Vw5N40SrkG5ye+fmOxc+fPnld69f3WElIhFSMUuNGReQMt5X4nhO+cqyPHPmzNzcHDP/5Cc/ee+9
+d1UlyHwCRhAMFUoYANvAjbm5/plz7sw599DZzrETO85tKO0wlyql6ICoZPbkPKAQhjqggAIkCgEJ
+A90OPjfPqg5wCG6YkrIQjmOtYw/kRxu8+6rHOnRw2JIEhe3kJnAKBxBDWAasA4YQnPCs0sD13Ma2
+35rfKWmXSeYU8546kmT+ahbFhoRJoiAlBYlRroFih/QmycqMnFvFI2c8r+wpb4O3hXeVVFAIOVGF
+KqswBME8lYn41NCbBoo6/v2rcbpHepabd5r8K9URugSnEMCrepAQX0nKB9tPzOw8BEbcl0BBig7R
+nMqsyMLN7c33Lrx/6d3eJx/yza0l544RL/Y9ld4y4xOzs0yEqijLcmFh4Zlnnul2uxcuXHjhhRd2
+d3fNOmRdk8x0WakiQKoI3Aaq8ASdm5158IFTX//ao8eXB1T1SwlKw/PqT/8MQX2gHvBgU7rwf/4f
+5xseTIs/+EdjX9F/+J0PrBuAXr9+/Yc//OGFCxcEqiTOETHbxhXZGybawxGSr9ReEWtraz/zMz+z
+vLw8MzOT1DotSWvRosVdi+kzfEzJJXIvodFTB23eLbbkoLdMWWCtI6O+YFNi38GvnarpAY9kPG8f
+PctL/rTQMrQ6zMB19erVixcvbm1tWWpHIjJ7US08Y3SGBQsIUX9QLs8vPfLQufLhLxCbdQDERCa5
+mVljmGallA4EkhglMj2SxDwBImJGvHJQXrly5c033/zwg3VHzrGWUnq27Z9CBBhjyN2y1vF+v7+7
+u/vss88CePvtd376058SRXlOlNVIhYBAEKbSUb/b7X14qXf5fffFLy9//ZmVlWME9opdph5oT7EH
+6hF5Zi9Eqo5gwWZiUW02YtHIlHZqjk2aMCwToE3fph/4cAMDTlHYmJGK0wFrny16imYVxx0NZsTN
+9bcW93qdHSwMMFeWhdRJYWD5VXaPxJGVGJ6wx+h677p+0e/O6Y0ZUnbXxV1X3lK3J6SenIAtbyOr
+EARDnAwAVTuW1f046ySXUptGMWbs85dw/NfcZ4s4QT1IiBDYdWL+oUIiy40iDDiljsgchMR3trf2
+3vnrj3/4/McffeA3N+b3dldAi6C5gZCoCkomJnKWQ16Bfr+/srLy4IMPPv7441euXHn11Ve3traM
+flh2VjOjxdozf0CQJS8xi5+Kn5ub2dt77OGHT6wsdCt727hfpqZl+H99twslghftlHqy3/tC7+bX
+dre+Nuh/8b/9g19oLmci/tF3Hsq/PvELwC8AwG/83m8Qw4uICjMhJYWN64WJbcSTDc1G4OzZs488
+8ojGBLa469W3LVq0aGEYfVk1iWcH29g2j+w4dMMmWNsmXzB65ZTXHzkmMLpx10xuZEvPpkTL0IaQ
+5BIRKcsyiHHMaT5ZHpF0/dBMJaiCI0MTES9hjy9fllBwcEcKQSbjyBSZzcTasx8FqS0VGuPNltz1
+NKRCCTeKSDI/iahYtE9kaME5Knup5Rb8six7vZ6F7dmw2NvMyJNAFR7wUGIwaccrD7Rz7SN/c2Pr
+5ubO/Fzx2OMzy8sLnUJdAccqOvClV+2hIwwVtbwSIV8JEakJ9KQKtfTuZnWK4zY6kpO+Nh41I+bB
+3xwMsIIleDmKQ8k0YHgPVSqhXZJdLjudgZ/rSXeP50p04Ak+MJS8Odn8QphQxGqTgh0BEO9lVgeF
+7pI6wgbRDeKbQJ8AxE3niECwJBwEdVWhGePSqspgV2kcnnEbEuRmt4Tm8TNvQrXt/sRImBmrmKgK
+mjNDGBxEIF1QFzoLPz/oLdzcmn3nrZs/+vcfvfPXe3s7y94vln5GqVCz+pKqkhAK54hgS88Wsq1i
+s/oCsHSFwTDOlD5riNkLPDE6SQqxispgUJaDgXqpXD8phQveKv6H77zr5Rgwy3BxW/cQz/f7421o
+4/Cv//hfjzv1t//B3ySQmCdqCJmtGJopoYqiQNwSLfl4H7prLVq0aHHkOJwz4b7E4BC04cj50oR+
+HYjLHbSno4MzTXV5jQclwI31Tv9Y73l6hpah1UAxY6GZy/Kc+xzo1VhoDMoPNxjPMSFUlQkWlmbn
+MJTzb0xjkhPZMFMjkGbBJQ235e5yWQMV6tjZJtpQELFzrnCOhABxjokhMSSHNWyPHRISDi+hfGUS
+UVF0iqIYDEpAiZnIAT6mSWeoU3FQ2yS76O1037+w/lzng/Xry08+ufLgA6uFbgtvgVAwAdvweyAf
+o+2Uic3dMmxmoJLZzswgo9W3cQ8HNYtHMJs0pB1MyV5ilZNQMSpSOLNaOYAwYJWQM4Rh4j8RHFAI
+dYW6YkFWVGfVMXzP9qdjmwVx9BnSEeqwFgoHYpBlFVEStuSZStmTJyaK2+2Vzc2n1NF8fBRpC7cq
+Qm7sAIwoKsddxInTRVOhpT8hJgJYxAX1BjnxXfXzooulLO3uzF35CBfeufH6T9cvvqO9m6fVHyea
+d0UhWpQKBbEjKlEOSlJix6pCtiGhc4iBZ2YdSokcrWmmf7ElGbkrxVUv3guDnCs6ncI5Zw1F0Bck
+10HEITqan2rNCvqjPyzDK8A8XRXiARCo/M4fzR+05H/7P/0/4079rf/mb9YWdZvOsUWLFp8h5C7Z
+d9jQlBvEDkF18hJqn2toLH/KeydgQguPyt6FJl59aPXf/UDP0DI0Q21+J3nODESIE0ubUoaMm7sW
+BCIAOy66HeecRonXNpNFjNRK4liIQAKgzRM3t7QEkjbal9jcMcrv0F5iqEhZeu/FmehnOd5Mv24Z
+9oPU2WzRZmbbbEpVvS8Hg1JVi6JgdgpRsAVlEZhQKDuI9ssBo5gtlgelf+ONDz765Oonn5z49jfP
+njuzODfnOt0uu65XeBmwSyOjCkFIkSgggUo0MEQTTt1ddAxGlUbUcDAaQfctrnabQs0gxnEjYwJU
+GcJKakFqHuzZiW0Ax5YmJE/nGGV+VeFI/DjYXJViWguzcwo55Y5yR7kQKkCuQAmkFOpCBAv6auhQ
+9SsWP42kZkyGXNTMlCMDPe1QkQ+XUhyw2AiCijhVJiqIHFAACyrL4o/t7i5duHDzR3916aevXL+5
+NVvwqUG56P0s3AzIma0XrMoKR4wOuwKA7Qpv+84j+2FQ1RSHVrWr0qzELqoSUVE4MvdJwNLhEAVS
+Xw0IhbGbagbui9ygOvTEqApSDblN8Iff+cB3Lp8+J7/4N87p7JXvfvf/fvmVl4tu58//+DA7vP3l
+nxh5+ye4XD/ln2ym9y1atGhxl+MQZOk2VT0O6eepUerLtWZ5mY1UbbTqvOTGimqfa1a4xivzSmuO
+oNPbNm/lQdwZevaD7//gU2drLUNrQLLV2i6umFIFAlOra/pqJgr1IqUvvS+I2DkSDXYbml62HV/n
+kHWtnuZhCIFuVWIr4gokYiIxSTPaBmKWhFp92dpLG7s5Zzn6zL5g1IoVKiCAoQWjYLCSV+bCFX0t
+VTteVj6+suFf3ZTy0uaXjj366PyJtXknpdAMu1lCj+ApujEqq5IoPEEyN7pgWEppV8bbMcYMdBi9
+3D6ZO6BWlHk/WL7OIv5HkCKkxIBXQEiFRUnUzIFOUSoLhhPG5K+/EGVHVfssZI09SABPKEk9W+JD
+UfKA1yDEi6pldFSuZiOP74YGQhaIRzJIBie+Ru5BtX/3GyUlxdBWcdHB0p6ZsopT7YK6hEK1C1nq
+9xevXXNvv7P+0osfvv3mxtbGLPMJ0XkUc67T9SAlVSLxXsmLCki4KEQlOSczhx+Y3LOx0+mUZWlL
+gMGVBTObPVZCUUSHWpB47305pptKuAWHR619CyoaZPmHqiujvkTVmC1FdUzqov6d/+7vePEx1DCm
+bgUA/MUf/+UhGujeKPBq+PxL+OV0/AdXv3+I0lq0aNHiTuJW/AbH3XIkvt81t4X0d99WjdLOCWzt
+oGYra5X9RE5mgOMqnYanpZ4e9BHcMXp2hCUfGi1DqyNXBiCLx0jR80mvkGspsklmJEcJcMwmQDER
+oKIioqLJVSrm048sKxMR7aO5XlVbGqW4qyTADe3QNcInqrMEMUmTnGNOrlzMHMLTxAK7jGVSxVSy
+Xo1+SO+FELFDDqrqFWxtZksoGHJ7Q8kBjgclic4WnVPQ+fX1jZdfXl+/duP6+uqXv7p28nPL3VmA
+VGSbaUDm0xhKCtFESRS2fzls7WT9HWITIyazeB+F4aJ0U97RcHEwWYz4OQ6PS7JsZDYhoNruG6ok
+REoQVjhVJzFtRrQnDTcr9myYHImJ50piO6PBjLQogYHSQKlvVFCHEqiQgmP5YxIJUjZO9TdqaJFo
+vYWEwFuyNmqsMW92MPlEWxkUIGKKlkNz8TRlCNCFzomfVeqqzPj+8c2N7us/vf6jH11597293Z0l
+uBXBouqsUgGoRylWQiCoYglAUyus3FxrSDG+1DgwEYbpWfX4LD2QqoqEfKQCDY0ntrBDRGqL8Fc1
+qjTiQo5bF6p91myVDwewpkdm245X4x2IbPQ0pqg1CboJVU7+uGTqJFUv5l5LCiVwmuEE/Prv/Vqo
+U8SC7ULvVf/N//hvm2fIePzS2i+PO9WStxYtWtxuTOPQVDMKHa7k2wrKMM3FE74acgl2SgfLCeWM
+Q06ukgx8OJfI6bt/X9EztAzNMOoQWLPt7huSEW1POSeqHA5D+m54AZu3nqZFBJjxQmFpRcx8oqRg
+MU9GCwcLchYLWCwnPpIBwirTalsqqovTsKAl2+GMoSABKzGg0FIt3gmKtKaVgtEm3DVx8WjgdGpZ
+9klVKebHAxTwUDWaUaoXZuisKAMzIp3rW9h796Z2ypWT80urJ4qZZZYCWBfaYS6BgcoA3hsrCPta
+K1sKjSzNY2xKoA/ZI8jPpuMh5KgSd9MOwOne5E0w2t9wRX0OKOBJNcSGqULBngpmqLCW0MJ8NLVq
+VxqlqtisO0GmD7vTUZg1BJDCCVg8yYCkhFNlEnXJ7kKQsHV4KFzGP76sW1GUR+BgtQs0zam6SqFW
+RH6CIvtR2K5oUFLxFJQDpEpeHLRDmFNdHvTnd/fmVD6315+7uk6XP9ne2p0lmifMq84Qd7yQauUE
+m+XrMLWFZ4uAlKHfDwq2JojYYlfVKpgsLpPAsMyhMb4WWKBKtsN1oEa28Z1CFaI22gCgtjApJGLV
+bHd5JRIAwVVVCWqpUm1LCQvAs7Q9HsQ2w81d1iJYrd7wIxhyYDpokRg5Ecg2CFTJOsXxMVLFC1VG
+LX5/+x/8rTNnzvzqr/7qL/7iL66srKTj/HrdKXQatOStRYsWtxUHIjZoIjOJVIxenDsTNpY2mYdM
+aFLuK1jzRZxQcm5hm4x9CdLoiB20L41HckNFTX5urKXWjJaeNaJlaM0YtT5jZA7Vvwb5VCPRgSnO
+EZaiUEjerVFeTSRBbS/qyK4IlrDQWBOxEHmQ2Aq1cs1YYh9zXhYU90nQNkGaKGjTwxIiJbPyxB23
+UocpNtuHKiY6b+UjQ0wqokrEgMRGGOFDmeR2D4AKkBM4wBHUS3lz112/sbS1fVLkzN7u9XKwMzdD
+c7MLxHvAjuiODvZAnhxDSURJC8sFyBCgjEaHaDiwLmhMTBG4axwNECmxkVNoNE8FF1VE2hyGtoGe
+RWh1YXwySiRKwbykMFMakZBCSD3gpapPElGj0YLHDHNiXGGbb1ESieYsJ9YjktzsmgqZ8Bzzuocm
+tcbt1/PWjBQ3dAdINDtGyVxmVzLUqVcR4/1M6kidaiEy77A86K1cuUqffKKzc/OueNBL2S9vljJw
+rgt0okercTu2pjGJgiAcJn3iuYHdVj+0qkoEouC3TIShbQeGByJqUDgyIgpmMwWBybJ3hsSlloYy
+8qRcMxCHgqoWJRMcxVw8FrFpxi4xmyUjVwlF6qgEMCBxlwICQnbYZKmrNDPhSNTLAGnq1Z9o/iiH
+JR5VlS/ZtgSBp/3g+99PF0+gYRMwepeaC+VrhK8cWPnaokWL+xC5Z8QEkjYlf5tA1cZVfaArJxO2
+6dlX442HaJjhQPauCVem9o9e09i12lOrdWRcRfchPUPL0HJMOd3HHVcgGo4yH69wTsnSsUfvNxOU
+glsUaxQsAcDS8xnpEFJhEoKl6hMKOcmFRMm8hNNdCC5uyiHB30j7iOwaCo0xGdMEu8inNPs7PbIx
+yYhL+J43haBBvA52IXRF51kddJVxDnL2g0vbH17aevBBd+7s2sJCD7wBckxOsQvtB2YCR3AmIIOY
+IJFMGSMkVQ3ZNSz/Y24hrCTonL3UXgpEtmXAxGEYEoZR4zKUTgTimFdRK3U4S0edW8WLqlO2LVwq
+VUFE5hKbb0AwNOxTIyQaCcqF9Ll2zehdqf1CYR0wwKQM5cBPSBUQDyiICyKIdMR3VWdA8yJLOzcX
+Pro8eOONGx99jEcefeShMyeIbgILwJ5qQShg+UBsH3MjSsFUyIFPa0VsxqxTouHkncHYVb+sUlyk
+iFELSqvM2eEvDT0xs3pp7YFbJbbySJTTzgI2R2POVIr1BkWLtURNjxB24QgkHORBMSyTtJoZcfkN
+z7aRGT7djJj8kz/BGnY48obXxlTXMrcWLVoM43DEZrSEcTicw95B650+qu2gFicdRu3ggRu9X9tq
+BrRR5tkoYE9joMP9Ss/QMrQcU87amkvk0F0jH5Nxx7LNBYYWrFNGtyAUuRNAattEEQVp0GdhRWZt
+s9iuxq2rCObMmHOkSAgpFEscRTaCMtSFEKUhM1z2eSocwL075MqIXALO0YLjecYa4UFfnvng/Xde
+eH797EPdnZvdh87MLB8/NjfXBRcqUEFRKJNAiYdZYaATqgBHamZ+ZfGtYc3MmhzvTmMb/4SPB9gG
+6pbedhRakyUFGT51e34kbhGjjaLqrz0Ls97YLtUMhcLb7CVmEIk6lXmRee8XSlm+fp3fu7D3xus3
+3n5rczBYXl1dEn+CdIMwTxCoUzgoEwqFC3oAe9yELLdn9jSn7cjkixXVehnagI+GToZJE9OtpD2t
+kT1gK8Cs5Zpv7qfR4EpDLY/aEjLLmCoJKQAJOw1aalOUjS6sGrVFh0M+LIeQgY6YvI1jbmjJW4sW
+9x1GbS8H+LFu8sRrLH/K4zXiNNmmd4jmTXAOPARna/w8rq5avaO3TNnTyTTMCplQ9X1Lz9AytEZM
+IxNPuEYrKb/6D4kjRSahgCVol5i/m2NIf6BsCtbwl4ZSQESLkRWbSrd2pXg25MfNvJDkyOBcZcEu
+khpY7c1FQzeP8NJ9BieIro3XM4UEemb0cAyGONUV6Kr4k3u7qx9+NHft6saVa73Hv7D4+BOLDz60
+tLRohhkupCTtWxwPWX6I+CSMpIUgviBJB7NEGoPYKUVlH6PMcFjHWHtpzUl9hFsdCFof7Fj7wUqZ
+dHLCs2ueyUObtNXvVa1mYBq4KsYPFPdc17BfdghDFAXgSOF8Sd53SVfKweLmZveTT/Sdt2+89deb
+ly+VW1sLi0sPAJ8TOSG4Spgl9AGGWnSWS1k6srnKVC0Dmhx0N0TTUzBo4xBkfI9CIp3s6si8qtVM
+YaADGwsrMT1ds6txYFbmpQoBhEhVFCCQizPT7sqtuBr7JYBAjZ5J9oLJm35LvOW2KgVGydsv//Iv
+A9HX8aBoyVuLFvcf7BctmYMmxG4dOncFmn43b8VkN4pGM9eEelOPJrRq9Owt2s2m4aujNHLKQnI0
+tvB+pmdoGVoN+YKfxMGmonCRp1FQqUehvhKoNGnhwzcAEtKvwRIjWlPACqfE4T+2dATptkqHD8i4
+tOpa0Ylcm09QJktYOXx1wIH1TBqjvsbcSpGFwvaZEgGhIMyA5hSLQsdLWdu6UW5tb3185ealy7NP
+fPHYk08urq6eKjo75WBTdce5AdEghs1xFdtlI105iKVUEJpJrRajVWvcUb52p0JM7Td9xVNcecQi
+qY6l2UhZaXS4Yaopn4YCpdm6QABY4bw6lYJo1qNb+oXdneWPLpfvvHX1wvn+pff7N9aLweCYYFl0
+TbECWiTMWf59qOUtRFJTEGotyFvRYEmbyFFBqciRU7GkzFGESCIp1GQEo+BZaw6NYdYN61IAEITg
+SC0TjxB5IolaAluOzpo73BAKrcl0oMmgTjoyANVdo0dDP2Kvq6O3yQFmWkwgVBNo2AS05K1Fi3sX
+dT3pFNcf6OWWm4kOSjkmVzTakvzI9OapfS+YvsuNV+ZNqjUvKjcbSNohSOy4dt7n9AwtQ5uMAxmO
+hmCZ32IyNiH1BBeSV9R13oRMNa9BU56ZfSRkCQGFqB51pAVgiSEkhlkBQCUjNnYnSZxBctNoy8pD
+V9LN05mP7NJctaN1qX0YghDlBSIiEBeOwQLxqp5IuStYEir75dwnn6zfuHHz/fe233938ckvHn/4
+keUTJ2aLYotpj3hXZVepJHP3ggeEKmewjKSZGB0bSw1ya7MBbQLGqbIOgEpun/YtnPH6TxOxes6+
+pc8EyuIjY8yWms8jOqqzorOQ5Z3tmatX8f67/TdeW3/7za2NjYX+3pLokmJBaVZ4Hm4WrgsuAAe4
+YaNuDKmc3MDhHznVibNyQn8VCEGNQZ9hJm/blY4Asdg20spyR9HIWM/MSTYqFobGKqwSEsBqpJrE
+safDK1GZop0u5BoJCfwJCMlwqBqXRnecrE/Do3F3etJWuGPkrWVuLVp8drAvA5l89tBOiRS3Gkpf
+J1w5rkn5h2QYmLI9B3pj5xc3fq4dzFV14yoaN3S5rW8ahplKmPwo7096hpahTUA+ddKRybdEsUw1
+xPRbCSqAMMSxeLWjiHFkIf1ASJ6fKgIs4T2LkHhSyxEiRCAHctCCxLLhUzAPJVKigHJT21iS1QyI
+XFDFUuEBgAAps3ZDTxvXTxoiImJmSvapsWstWSWc3ei1T8xceCo8WOEKT8XAzxc8x7rQ29u++vHO
+ztbO+bcuP3xu5lvfOn3u4bWFhR4Vm+S6XOwReqCB1aqw8bXd11DJqRk9s6NUScRVV7InMKbVk5F8
+N7O6hj6ZjS86YYabokBd9xM4CBVrZB/JwDRlUcl4HG8PfJeS/SZOXhBX3p0WsUdph2VVKDip2FjD
+vV2hJaLjRMsbG903//rGKy9eee8i1q93dzZPqRwTnfPSLdUpYSBawnv1qgJVkWz7MKo9pMrTz+xJ
+tTWbm8RTIWOUhUNPL2kNg18yxcpUBLbjmDJIUUhgcAKoqVI4jLzG/0OBZLF5ymwmt5hASEKGk6C5
+CG6VkY4GCxmx7SwQB952ZitIo1dkoHoc3woUiJvGZJqqtYkwqgetnUqfD5Nx/87gaMlba3Zr0eKe
+QONrLQl1o7xiMsvKzzbeO+EtOkpmGkWp2tt4QnsmGA/rUsR+AWYaNrOdynsiXZN3Z9zgTDme09DR
++5aeoWVoOWoqjdoymErLElwbFYCECCk1CclEVRFVCTFgErMcqEd02IvGLFUELygIqZngSlIPLSEe
+MadcnOSRkSgAgqNqr7TUMLPSMUIWEpNqRW1nNgqOf5n1KxkrEOTPDGlR1dZ2JdSOH62o8KeYKlBV
+vcCDSttTAASlotQC3rF2HOa8Dna2Nne3rt+8sdPf/fixz88//OjcAw8tLx9bUtn2ugHaJeo5tjyV
+AlUlpaoKEDim3NdEUJO1MZI5TR3ORmA6pM2qk+9iRnOUhpzTNEjQFBlPODpVNU3tMjqvKsPPXA/c
+i8bqYMkMCUQq5pdKQQUQ/OTCFmAx5aANIwtIhUkLogIoVOcGg2M72/NXPvFvvfnJKy9fu3C+P+id
+LAfHpVxgXlI4JRAryIf4LYJARLyqR2QpxKwigZGGaa6JocEoirU++y1hZlMfMDNRonz2If1CjEav
+GbclUajNHBUVH4daIzMmVbVd6Tkm/Yj+hyphRdjm9Y6UVAuCozCOQvCU7bUtYQ+M3IZm7xSbWBRr
+jE9Xne0IqNXLJ7dia5wgo3NBo1ZiiIwh/myn0bvbLWzjMI5TtT6TLVp8pjBqmRGRMiJ/WeXX2zXJ
+MGVH7OJ0TU3S896bVJNIiH1F9jKsXZCOMLN9sEIA2I9OXtEEIpd+pGpKxtqVedU1nsPMzrlUSCWP
+Zb+AExjR9MfTg0hl2o7BNgjOuVRjQn4k3VJrWGp/Xtf9TM/+f/beLdaSJLsOWzsiH+d1n1W3UfXx
+wwAAIABJREFU6lZVd1d3D2fIme4ZDkYkZ0hBnIYlQzb91I8N+UeQ9WGIkGDAIAx/GP6hDQP2l2ib
+XzZtg9aXABF+QLIBW5ghaZIyOaMhOUM2OcN+1vvWrbqv887Y2x87M06czHPOvVVdXXVvVyx03zon
+T+bOiMiIyL1i79gbkaE1EXbihYNhGYIlCKVDsIBhMgwLY5kwZWJr1DABsijJkZBYAYFYDQ6Amy3D
+s2iaXRERjeFWkBRERenlWK72V+xM714u/fv1eBBIiIzAQOPdGxY40QjoIsKUJFIu11fVINIg5j5+
+SG1WQjBQw+YqG6NsFFQ7aPxPNKMzVfZmAoTL7TzOCWu+7jJtVGKQGSHncHiU/vCH0/39wZ27ky+9
+vf3G5zbXNtZs1oU5NuZEcGzNhGQKcWW6t1KrNWXaK9HADJVlA0a1ZJmzYD0BsaGykVU5BqjMsVW1
+uDY9e7dVqnJIBwmtGmtgjULMjCnKCbz3bFUK8pvv5gxNZ6mBPzv87K/0ZTFl8jFtpyo/OQGGDCvf
+FRG4ci+WJEIZkAtSSA7psssnk9b+o+TDD/vv/un+X/xw+HAvGw0uQS6L9ARZgVQMAIYUgDMQa0xi
+rNEM6CRk1EJUpXrTrk1BaxGM9c4nmu8O0+k0NICLCLMDrLV6Gqw1lfXM171ifmVqPyqpDwEkhsQQ
+jLApXMKSChKW8rFr7A9TkjYjMFzyJSYSCJMxYkkskAlSZaQgBpyIY3EEJyJCTqTM661PVzQkqehI
+Y4jmK3AwUxhHxhBZbQbPU6lMt0Gzzu6fZ1BHVIPXayFBr1q6ZnzhEX0mIyIuFEIdTP8656bTaZIk
+IUMzxni2A6DG35Q7LaRkXiwz6znhkZCS6a3DS2rrWf6EkMD4KbRpg/KF8VyleWZ4WvhGC8+vMTRt
+AZqH3qLZvKFqF7Z5+Df86j+EHMzXQsugH5psjRrkzcNf6MvwktMzRIYWwo8E31/DNY/mOo0iVO1L
+h6TSS6nMKYzCEYtRixOMGMvspLSlASDDKEPkmypfmkAYRA4CKlOhCViIxSiTYd2/UtqAQkVfpFo1
+n6ne5VkGlmAhBLIiVmCIUoFhIVMa4YKl+Uq/lLrwudUdZk6ShOaXmgLFRPN3z6aYKsKElKyodM4i
+ZohYSMpsxSkfEAGzsGMGEagtbI6Ox+Px8Oh4tL+/d+tW8ebnN6/srrd7eavVSbO2yIAwNDQ1piBy
+gqKsjoiwT/1WtkZpUYR4/7wmXzpDp5k1TdDeFRktn/DMXlexZvLpwJtLZRV/nVn05s+Q0NBHVDW4
+Zxnl3at5PPj/lKpUc2+l03s93lTurzyj8WBjiCGF6KtIWYmwGOYU3CVad0XbTVtu2js+wO3b/R+9
+t/fhhye3bw2PDzskVww2C24LMiFTwBnN7c2FiH7WJQkWUQuW7m4T9Qes+tLM6iVSvpWFmRlJYkRm
+q57h6y1c7CQy1XgPH4R/NZYNYcgYaORFNsKW2TInLJbZiljS8Pllu1QGbCmbi8CmHDYWrCPYiWGp
+sqaVnV8YDBSMMchAEsBWdN+BnGgaQDICNSpOQWOYEUwCqoae7xRELH47a41y+xabven914WT22eN
+oa1A9JmMiDh/SNMUgBIw1TeOj4/39vY6nc7h4eHx8bHqIXoaAGutiBweHu7v749GI9X+i6I4ODgA
+MJlMlCqMRqOjo6PhcEhE1lrn3PHx8cHBwXg8ttaqtH6/75wjolarlabpdDo9OTkZjUbW2jzPrbXj
+8bjf7zNzq9XS18rx8XG/3xeRPM+zLNMiKZHT+yZJoiX0Nr0kSVSa1k6pox4PuZO+47Iss9a2Wq3p
+dJqmqW+Wdrvd6/U6nU6r1cqyLEkSJYp5njvnVH6WZcwcEidU7E5LpTQpTVM9TQvgTVv+QgDOuTRN
+9UaeCed53mq1tOLdbldLIiJZlrVaraIo8jw3xuhXvTbP8yRJ/FV5nn8aXegi0jNEhtaEHzbhEkWo
+Ri+0PpcItGqj+rmIOBZmWBJLhaAggW6vUUIgxjJYQLrsDoPS5OX1eBYNliCWJDGSgtOS/Klrmegq
+uy+CV6y9eg2ARKyYRCRRC5UxlpAACZACUJ4SKGRSGQUXRj6cY6oSuDJriy0z0DePqZZNmnRYUkgK
+ZyBkiIiYUADOiWNhQ6mxmZPWcJJPD4eHR8f3HxzculW89kbr+o1852p3YzNrt9eybER2zDxkGgIT
+ImdISM07oDK/AELmU2OzNV9BX+HlD31m8JqFiwwegTdv0XwzSnheTZhnXLM/1T3KA57u1our4St9
+mQxmLrTLit+smj7aMnOeeF5dlYbLX40IpowkSYCERVgISIU74HU33egfZ0ePzMMHfOfjwXvvP751
+u3/ct5PRFmTT2G1BB5Qp5SAqBEwkZNgCRCzsWDQGzBxP0IG5sNjMUlraQM4xBR4UftlFX2Z+NcGT
+t6YFVRcdmMUYkxiTiCEWOJGCIWRJxYKEEpM6YWVEQsQlgxYmCIkjsOaAENIda0JSSBlxn0FlfBsI
+yAkVQmOQJXEiSRmnlAqQ5mS3gBUAUH/gAjQVMItDFamVjCECMwsrAbTzz37BQmzYwuH49T+9RAxt
+BSJ5i4h4QVBOonNykiQAjo6O7t271263T05ODg8PlS2ocq/KCTPv7+/neT4YDJRyTKfT/f19AOPx
+2DO0x48fn5ycKGtiZiV14/E4SRIlVycnJ/rSabfbWZZNJpOjo6PBYGCtbbfbSZIMh0OliO12W98s
+h4eHw+EQQLvd9nzDkzHlJ2ma6jTrGVq73S6KIk3TJkPTF5mIWGu1NdI0bbVazrksy5QvpWna6XTW
+19c7nY7eN0kS55xyOaWLSoecc964F1KvNE2TJFGepsXzX/VMPU3pLiqGpmK9IbHVanU6HS3e2tqa
+lsQYk+d5p9MRkTRN9Vdla/pZ+arSM634s8UFpWeIDM3DKyJ+eOuqgPZFLDIfLRCif3QxnUWUtxg4
+8ATOJRgJkxBIWETKnWSiATIgIsROi6A50GCEhI2ZGFuYpDCZo9yh5aRwbB25MtK3bpOpwk+YcsuZ
+gioFnRimkHQixjAYRNbCUMGsa/nOOS1BVVe1OjEFsSJq8KZ87wagXxeeHdox5lGakcSh3N3DIs6J
+K6gyljBDhIwxlpSmpjBdce29h8PDo/Gt28dXd5Mbr7Rfvdm+dq2ztd3t9KZJMgD1QSOiiaGppQmR
+IwjYCCygLnmMisyUzLqMh1dZEglzRV5B0maMSLzdscpyx7KUnkl4hyaP0v7hkzEjpGYzOxJmYWc0
+W3fZrwzKFF6BabBWo6okS56L0jOpNrmhCrVBEAuxzAYEQwRkrkids4Jc0GLXmQy7jx7aWx+OPv7g
+5PZHo8f7cnBI4+llUEc4A3UKlxdcejAKMYSZC1EfSYErmLnkvJ5f6YvE9zEJTYlVXRxEvT51lici
+dVkJLWmhy0rg0OKbQpTDV/4wStWERcq4HmQd2alYQZpQ7kSmkuruNBjye0cBEAr1gOQqnSGBCFaQ
+FGQcoYAUcI4mTENnLMiAHNMUpIm5i8ogXfZVgTWUlAn/yAFMKFidnwki7JwzYqAUtNwdKMEjDj/P
+JjS/JuUHMhreLBGrEDe8RUR8mmi3234a1xfB/fv333333VarNRwO7969O51OW60WgvlKRG7dujUc
+Dg8ODpRmDAaDDz/8EMDJyYmang4ODj7++OP9/X1jjHKG27dvKwdTExAz379/XznS9vZ2t9vV2x0e
+HqZpurm5mef58fGxcqGtrS2dTu/evTuZTERka2tLLVcI9CWlUsrcVM/Uu+u1yvr0JyU2+iZSIUmS
+GGM6nU6WZRsbGypKjVRJkmxubioT63a7So3U+re+vp5lmZqtnHNFUajxCtVOOTWgKV/SltEG9wYu
+XwD9VfnbZDJptVq9Xk8tafqAut3u1taWEtqdnZ1Op9Ptdoui6Ha7eqEy4VarlSRJt9vNskwZo94o
+TVOvcj8rXFx6hsjQQoQLyWre1e5iqk2Qp9AzggiMiCkpUpFmmU0TStMiNeOEOLfDhFiIYDXaABEg
+bDVUR7nJpgwUYARGEiHjjBQ2c0m7yHsuG3MqLsmZpkwiGonRiBBXDE0Mz2xo6lfn/3PGQjKb9cSk
+TARrTGLTLBUyRK7y0/M2B1dGxqeZX1lIwHTM6wj3g7/G0ELeW2tklEUsf02zNEnIGs4z08ptMTbW
+WkFKpCTBCcFoSAYIWbGUQ6au6D9+fDwcjfYeHt25N3j9tbVXXutdv9HZutTL85ExfeETMQNYazCB
+FIA2cbmni0jKcHdQG6a2F1UUKKxKFUC9NDCWLYvKHVHrRuX30iwnlS9lEBi9pPGrcwr723rSMLOt
+lczOn1CZuEzg7Coyo2KhBa4qJ+bV7kUWFWWsUJ/aMtyFsUQGrI/MiCSQxFIiLmXXIukZWu8PsoMD
+enCveO+Hhx+8f7S/Vwz7WTHtFi5PknWYFhkikwkZuMKJMwYwsJICCQG6qJHYVmJzQ6k1SZbl7VbH
++4cUhQOEDIVepSEqIidKwPz41UGtbwjfUcPtBFUzh1xabUpw4kyamCyXJHe2VdjuxPZgiiTrFoVz
+TELEBFDlklyaIAtta6kIM8rsZQm4C+TIDRWFoYHYQ3ITglolAQ3SWNowq8xpIIgxlGo4EqEJ7BDJ
+xGSWLJO1WZanWZpYKwQ4l6UJBM6BQEEFAUg4GPWzLmH65VtvaQwdbCKeGM9lw5t8H/T20wiLiLgo
+6Ha7QLlapzPS3bt3lWlMp9NHjx5Np1PlNv4VJiIffvjh/v7+wcGBzmyDweD9998HcHx8rKrdwcHB
+Rx99dHBwQETqNKhfDw8P1fKjDE3fHZcvX86yrN/v37lzZzgcZlm2vb3darUODw+n0ykzX7p0SUt7
+584dXSK8dOmSmqEwW/KTNE273a66UIYMTU12Sia1CspbPK/Tv9baXq+nRVKeoxdqxZUQqrtgmqZF
+UehbT9mXto8ar5QpeROZl6/nKEPTg/4FqmYuz9DG47EaytI09RS61WppuykFVY6nF+pp+q5Rm6E2
+snfc8MrkM+w5F5qeITK0EDp+dGhdu3ZtfX19Op36DopFBrRQ1/EMzRJgqGBpp+2r169lnXZvZ3vn
+x16T42FWSAIiY5zuWClDPLCBhgxRPQ9WYISMZAxx5JwZF+akSA4lPULWl2TM5DTRl6ZVEnDFO6pM
+1ADgQyqSd6krTGp7O73NqzZr71y98qW3v7h7OARslczJbzwV0VjngMYhqCnxRDSZTLSVAHzhC1/o
+drveXoFK+avxsdpnlIo+jKHLl7evXNlutez1a5f/0le/3D8ZEiUsBmTJkBgnpDkLAC7YTWwi1hCh
+IJ4QjUEnZI6GQ3f4ONvY6K2vt5CPWPZFWsTHjGNQnwCIE3BlpBRLIihAGm2RS3NTaVQrC1g+38D/
+bfYr+d9mnK0ycVFw8tznwFVxAWoq2IKTAkOI93Kci5lR6vReYEDVQpIWPIOZ7Jm3nwDOx1qBUZOM
+rWYMBoEkZdci0xLOjKyBN5m3i3G3f+iOHo2K6fbmBq31sjTZcJxNxgTqGJs5xxo0niHGkBAzixFr
+jC1d9QTdbu/6tVfWuhu7uzfefuvLo9HQU6myj6k74yItN1wRcM61Wq0bN260Wq2rV69+5StfUccM
+78Y8b/X11kovgYw1zOykyNvZ7u5Ob+tK0sk3r/7YtckokcN2IjQtxBFZI4aEoLtDmYggBq5k7FKm
+RyyjyggKTtltTse7k+GuTLfE9YQzkBgrhQhAIsaHei1T2AsBZGAgRgChhKlFSW97x/Q2ErHdL3zh
+82luyRIZYmayRliYSx/XajAK0ayJwlUnEdnZ2dnZ2THGKIP1g3f1ylTE0+CZkjf5PvA2AHzz8jsr
+Tvv2w289qeSIiPOAPM/DVV0ROTg4GI1Gat4ZjUbK1pRs+Plqf3//+PjYW8xGo9G9e/eIaDQa6ZGT
+kxMR0X1oymf29vaOj48Hg4FyIWZ+/Pixil1bWzPGjMfjg4MDdUdcX1/P87zf76vFbG1tTe/76NEj
+LcPm5qbymZBb6p4rlanvIO+IWIuoodvG9ELPo9S7UpmMMpxw950yKOVdporVoezIOysyc5Zlfm0u
+tM75r3pfvUSFh/vQ9I5qt+x0OhsbG+HD2tzc1A87OzufXpc4Cy46PUNkaCF0UOm6+5tvvrm1teUj
+CviRv0xZIVKfORiBgYghJxCha5d325sda69mrYwHIxoXFkSJZUtqj1GzixHRJGpshAhWxAoBKQsx
+SSETNhOTT00+dmbgMBGq6ARV5pKZl2PpLyfzdIIgBHZkOG1313ayZP2VV9c7vWujiQCWwKjC+QDq
+o+kAJyCaJUlDOFydc51O5/LlywC++tWvfv7zn39yFykCVEs2nXa+vb3eyrIb1651//Jfdk6AhJE4
+VtcwFhQAJ5qzwE1BYg0ZgjALTwhjMiODYZoOe70iSwR8fDLMhiOTp61Ou5slfWsHIkOQI2EyDCmY
+C2MIcAIWDbxeBfAIu0RVC5q5jGk7BS5joWGt8m8k+HR31dapyn+SykMrLWledL3JZlQclaTQCiTl
+eXN9VWpCqkOzuEm+e2tcDCldG7X+VmCNdFgsa2x3tK3Z5kl3PEyGQ+oPEjfNe50rrdbNS5ud3Nrr
+uy2gDZOCEhZiZ4gyATGzOmMKxBij+boMUkNWWJiZQGmabG9vd9qdNLVXrlzy3onhExEJEpyV5Ydu
+ew5d+6y1ly5d6vV6N2/e9G4wHt7lXR9nNbrLX9XF0bET4ixP25321tZ6Ozf0it3eukruyGJKTJYs
+DHFlk+WSEcFIAQBsfFgaSGklBIwxPZGtyWizmGxCuiKGSIwVIfZDuuSKpXMraRfVJyIQRsfYtU6P
+Ni+1HbK3v/z2a6+/lmQ2SaxjLpwTiCGrqREqxYXDFpBq84BCeWyaps45fWGf6jgQ8ezxbH0mA6zg
+b5G8RZxnqGnIb6BShlbbT6WkAoH/9qNHjwAws/Kx8Xis28OUY4hIv9/XkB5KeJxze3t7akTSE0Tk
+8ePHevna2ppzbjKZ6MJ9kiQbGxsiMhgMAFhr19bW/CV6l42NDQpiSHqOpMRS4RmaCkHwjlOWJZWH
+IQAlWn67XdhEWotOp4OZIwmrBc8Yo5Y6bQo1cOkypRZGld5wv5lnaGpqk8q5VEuuoqbT6cbGRrvd
+fj594EnxGaBniAwtBFXRckTk6OhoNBr5oe5HzgqGJoAq+CTsIFNmY7N2q7u+vrF/fHDrzoeT4z5N
+HUBiSUxlnCEDwIqQsICdYWPY6mYpJicEUAHXXe++9uaNVnfr7p339vZ1hWahkj/bdVTbpqOa/VTY
+5IObNze3Ns3B4fDu3b2T4RgwttTEQ/c6hzIUv/GNE9rHiqLY2tpSy/7e3p6uG/nJJTwfdfOjd1Aj
+EWLHxti1ta61NrXp0eHJndu3nWMWI0gYpgph76AR/wDNNFAKF3ZcEJxBQVIYM0nT4e61zvbOpfc+
+vPvun+1lSf+N13uv3Lh06dJO3poID4B+QmORIWNirDXGsXMshSlNMyJzhqWqyPW9ZLVWF3VJMxU3
+87H4SYPQg0LvxBlxnj2vhlR/85klryQf5LV3UPV0pbLXlI6yC6WSLy983oOyDDOzCQBSOqobxQxR
+CklYWsw5kIHyougORpv7e+bO7ZOPPtq7d3+yvfW5r331ytbmzt07x48fjR2XlwpYAIKBd6Gk8tFD
+w9kDBDJknGNXFAR0u+00Ncbw44OHt2/dKVxhbRKOPqVPUn9IHuVKga4vWms15Ne9e/eKoqB5tw1F
+RbhLL0dPYADDXAgXWZ5tbl1qpx2ZpHfv9h/vHYD77MYQMsaqKVh9Q31+aNJ8GEKk9jWhkrOzy/P8
++vWdre3t/nh099FfjEfCjlkKY9hY41dcAqapxlIxZQBIA12UNW59s5v33oShvQd7Dx89TDJrE1u4
+onCOiAwlED8YITLLBTRfdwDo9Xp+F4FvSpl39o14YVjC3IhIvv9JZUfyFnGe4d9NfjryczgCfcOf
+rB/8W8BrI/78mvwwJpx61PtrZT6nc/NetbX70Fzmj6icUH0Ky6OfvWeHL3x4SXivWk19y/iAIv6g
+Kq6+/FSFrAxrF7o++br4VTwEL8rwdnMbws8fPhv0DJGhefh+pn36/fffv3v37mAwUAOxEhLMj20/
+bBqimEUmRdFudyyZzY319z/64Ld/57cO9x8lMGTIqUMdVaEpNGqesIAZTCSa4YiFudwjRa+89mq+
+2Vvj3h/+4IM//v4fFYVTQ7PXqBUNWkH+IEFYuOCit75p39lK7ebHH9/7znf+xf0HD1lg7SxGfmXf
+kTJQpCzgWsw8Go3efPPNK1euGGO+973v/ehHP/LzSzi8wzEsc2aP0kYBAZHZubLz0/JTrTz/8KNb
+v/Vb/+9oNCL1RSRTcVH1IKuCXCr/KSOlMAlDHMEZmrTa8pWv/NhbX/mxvb21P/nB5OR4/8/+5PCV
+G93Pf37r2rXO+kbWW1trt0eCE5tMmYfCY2MKY8ZEzFKIePpczYCQKiNzlWa6JBglQSqtZEIkRGJ0
+N2Gpkwsw24Hkt6MxhdwIfnOaHvQp0MrmL7cv1XljGa1dP5fZHUqCoTetaCEAcqU7ZklwQSDoJjyf
+LkZZLxmBEQEzAQlRSkiBHGg7155OczfN+0P7cN/d+Xj/g/f7d24PHuwNR6P8iz/RHY0u379P3/nu
+Bx98cL8oEphECFWQxrKZUDFMEX2yRlhESluWsDC7tbXez/7sN954/eYPf/TD7373e/2TvrW2zAim
+maErW9f8uFObMhOByDC7oih6vd43vvGNjY2Njz766Dd/8zeHw2E1cCT0Xq4Y2qxzVv2WXFGwKzqd
+zs2br1tKNjc3/uQHP/zD7/2BQWFIisKxlBG3WKoHXjI0KVlu6WpIRCBDwry21vv6N3pp+8r7H3/w
++7//vYODIwhADIgpt33OesOcU2uZcN6A9JUvN27c2Nhez/P8+3/ygz//8z8TiM+lWA7AmesyAjsh
+EGQQ0RbY3d3Nsmx3d1cXdCMuCujtso+sZlOrfSCf9KrI3CKeJ7wPhWcXISHx7k5oLBCH1C7UT0I6
+5E/25+uvfmk+DItPgfeBZyl+pzQq3uhF1XShkM6pz6H/Kdw47SNaeTlhQAQKgqaEMlVgmJBNqp07
+IUPzUSUlcKPQe9W++rYNLWlSmf7C888PPjP0DJGhNaFdcDAYPHr06OTkRGcBVAPGjz1Fk7D5f6fT
+abfXG/ZPmIv+8Pjeg7t7D/aMjhm9C1Ur45WAOZECgVOFyhiT9zqD0Tgbdx4/Orl7+9HUFVmWl1NS
+qY9XCzZLVzQEIo750sSMhs4VdHIyvH//wd1792le152VoDrgj4eTy2Aw6Ha76tK9v79/9+5dP/HV
+WmY1pOQFGI2HTvhkOLx7/0G/3zfWitfEZ0UK7VCAkMAKE0TIMJEjTLvd9PAY06LHvD4Zrx0dHA6O
+J/fvPvrg/aOdnfz69e7rr29cvpLlrbW1dWrlI5tO0mQifCQ0Et0bZZnALI5FUG4hKqOnqJGl5JYg
+wCpPYsDOGLLmxSYQiRHdnTgzwyn/IgbIcyzPtAgzQ8nssVEZq9NnVvOtIOWeOkswBkylsU40iruW
+sLozgxgAQ5jL/M7QABdkRDS4hhVKIMYxCaeEXLgFtFna0yI7PDSPH/PDvfH9u/17d/v37g32H/Jo
+lBdFj6gznfYK6U4n9v7+4Nbdh4UDyAAgwyiLZUKnyrB36RsQgDXWsTvpnxwcHo2nRX8wfLi/751G
+yleg9kGqd7Hwzarvnslksra2dnx8LCKDweDWrVvj8bjdbuuqob54musIYW8nIuecK4pup9NbWxuP
+BkXROjg4+PjWXRG2ltgx4F/kOo7KYJrVI6xIMgggQySQ9cH06GQ8LuS4f7L38O7Dh/uV2Tbs2/DD
+SPxz12cOVOIly9NJMbGpefjo4a07t5Vp++mlqYJ4pcGPZV93Y4z6/KB6nXsFKOIzgBWc6inIWzS7
+RTw3hKvh4dQU0ht/goenTyGDqtmLwtXkps1K5dhKFTHzuVv8BzOfpMTPmd4cV6NqtRv50oZlXnh+
+WK8mI5VFKblrE3gYzs1vOQ4JbcjQaq9FCaBV9mU4P/gs0TNEhlaDXw4JB164AWZFd6wNNiIyROWq
+ComxRqMOCNgaK36pHaVFQLU6PSJK0Fj0cs0OhtIkYqxJHAMabKG8nzcrYMV4EYExVl3hjKniBdGs
+8PMTXNNAMYNnrbWrwjlxaTnmUU2dgRxS57oZSRFvfJNy+171i4EYHz5RIKAElAlykdy5lkhPsCVc
+DPqD8XCwd//k1keDjz8c7FzNt7bs9uV053KyfWmztyZELZuOiMZipuACZsIyJU1jAmesaswGkCpn
+WvmUANJ8dKWZrAruyPrUiCCmMmcC1SY1IcOVE6TMPTSqMmuXNQQIMAIu+wlBDARqmbKChJGwpEQF
+iTOlrY0BlrKoRpPpVbyRQUwGzNoDDZlEQIUTwBLlwqmwZsnrMHemk2QwoIPDYn9/eOfu+OGee3Bv
+uL83HgwxmaTFNDNmLUk7rkimRS6Sixhmy1LVrKwcz5sM53qW710iolnFqtQ3c53Iv0g0sKQal+cE
+zXtuUJBY03dI/1732XXCNZfa2wgVLeSyMEymPJKkaTGdFoUTQZom8LNEtdYhZW8BYWaShiYxhLAQ
+y2yakNItc6Y9+HEwG+BhwYhEygUjAUMYBIGwcJqkUoVhDBun+a5FoBN4VcNfpUfCneIRn2Es41TP
+1uy24kYREU8ETycWqhz+s6cutfmt9tmbhvzJHhRkdg6tRuG06ePp+7v7+2oJw/KEM2pY5tATssnW
+mqQurJRvjdBlsXaafg2DYynzlMrwEMqvvRpqje/ve94Y2meMniEyNI9an/aWYt+Jm2fWuj4Wde5y
+MKuVyBqN31jRMFU0Z2WQSoet7lguynvFVJUzMga6WKLprURWpyQO4Y31tSUQX/JwgkDkfJNUAAAg
+AElEQVQwZwGL9Vc/g6hkH1boLAiVYD/RcCMTXdA28H8r904DKYOSixgRJjIsiUjKkou0WdqOu9YY
+ojWR8WQ83H84PjqY3vp42Olyd83tXm1df2X92vXO+ub6+vp6lk+SZJTmBcmEeWSMCBzziLiwhqwB
+xAkckQMcANG9RqAywh68X5sSNqqC9Os56vNYWpMkNJX5f0vqPvte+VAalV3anJTEahAKTc0giYgV
+IUCECoBBruphBLFKL6WMZIFCjVw2LS+kDMhFWsz5dGKdS0bDdHCSHB+7u3dObt853HswfrjHw0Gr
+308no7axbSBlMUBOyFhI0CXqAgWX+R5KEiule2otN1e9W+rT92zKvxs8s6pxjFqH9Ec8K2u+pZIk
+KYoi9AChahm15toRDm2NcKW+h5Vbq7d2eeolvnPOF3H2j5SUskwx5yvASrZEiCDMpXFWn693ING6
+VFNKbQpyXF83bTZR7d0fNmyojoRlr00FES8hnq3ZbfVVkbxFLMPCyb9JWmoI5zQKrGe1GbIpPLy8
+RkJqOh4wR2xChTB0QAhn0fB4rUjLShJioY9S+NJEuJoZJP8ML/G630K62BQeXh46OkrDrewF4rNH
+zxAZWhNhN10YzazZrWtKD4K1Bz9uHTsBG6M6nJ7m1bdwPFT3oplrE5O32ohjZhGGgB35sdEc1IvU
+KqncqcOC1VS3hU0Rfg0Hqg9xqYtMqvs+xYj1xfBxZheeUzmCkW61KcmQ2qSgYScMUAhSlhSUC+XM
+uXOtAqklQ1IYckRuPBm5g8nR0QD3T+7c7v/oR6Mru61Ll5NLO/mlnfTy5U5vzbbbkuZMriAzBcbM
+I+GpmMIaRzQFTQVTiKv08wRIBRA4JqUlUnJx3TrEVUo0/a/cmVVa27xpqeRvVJqcgCrqiManF2g8
+Geh+No3nB0coDAqICFsRI8RghlUyQEJGM7wJ6RYlS7CObcFsTV5wWjhDlBvTnU7S8TidTJLDw+nh
+wXjvweHeg8nBQXH/Xv/oiMejbDxeg2yAe6A2c+KEWQojxiSWiQSZINPViMCSxBT0I5ox7bkn618A
+2ou0P/jOEL5vTiUMvi953hUGEQ5pifbVhauAflCU1NGUvEmdTR1zUTCzWKvxvlAlJV8wEv2kIOVT
+MyCQMbBWiJyIYwbBGEPGsMa6rAzKoV6wsHh+ipF5ULXfYHVbeVFNRSQcxZGkRTTx3MhbZG4RaKyh
+1z7XqFdtiRmLnA8pME/Vrgr1t5ARhfoSKiJESwxNVIW2Dy9ZRghrVEeWkM+awha+GX2xw1+9P39Y
+Zi+t9j4N7xVWyr9Pa03tX684B/hM0jNEhrYCMp+zdeEIXHGtpxxltzaemAGoyAbqnl9SSSaUOrjG
+bSNjYNR3jZWVMDM9OR2qETONdNes2rILEUwxtXmN5l0FQqxeGQol62zisyh65RZ1zV68PYbAgPER
+GgRWxIhYZsNihBKyGUwmYkC5K5MvdxjOYAwZnBwfnZyMHj6aJulhtyeXd/Kdq521dXPpUuvKlbVu
+N19fb/V6CWTAciQyBAqiscEYGBFNCQUAIAUSgFkfGjRbHZGQEWM4BafECcRSxbYJxgiIWL3W5lsE
+prTXzHwiK+Oq3k8IjkRIHPGUZCo8BQpAmIyAhaaAK01tZRptA1hQAknZZUWRQXJDXYdMxE6nyeHh
+9P69/uPH/cMj3n84ePx48Gh/fHQo43EyGMCYdUM9yBq7LqEL5CIQYqGpg3OFdu/KBbUsLJfcIXxy
+S0aM7041lt5c/FuNkJX5ZUL/V22zfqt3rU/WlhiDgql3qLCGABKon6NzYkwiug+7fC/OLz2GfZXK
+NRd9ltXGtDKACOvvuutxeZU9iUUwpojIUMljTZVFx58fvlNrohYOydr6iMyvRkVEnAVxw1vEp4Qa
+9aopITUG1bxWqhW62vFlCt5qAlO7b62Qzbk3pE+e9jzFBNvkb/5ezYrU5NcasPZrkxAurHtYhSct
+/KeBzyo9Q2RoTTQ7bhhs9Ow9MhwzGgJwNn1UzotLL9YhoFvEvJVIfzFGjSJCsItcv1bDR0BCMAE9
+kYSyGPNLMt56tkwpXDgRNHVivyCkqU6Cc2pmRl/gisl6/zGdKsmQsYYSIvXuK9O9CUOELVlhGGQi
+IKTGcDGdTCbHw+Ho4GD6wYf9LC+6XdnaaO1c2fjqV7/4uTevsxxPJg8TO8jSIk0La8dEoyQZAxOR
+AqKbu1jICqZC5V45hrGcicuJc0gmSMRYR5iSFEaswHjbS1UZT9hpdqzqKgIxxCQFMc+SKhAxWWsF
+LEa4TMkNIgsyTqxwTtSCZIIMkkI6RZGPhylLyxXJcGSSdK2YJn/67kff/+OHew9HJ30aDqUozHTa
+5iITyYFckDtJjekSMhbdTqmd1LIIIAkpSXO6/03AovmagcoN1axwxa0ty4U906dtCUffsmFYW60M
+fe59l+Mqw+HS0gSl0u40o4uGiMo4io7FVj+VzCsoVPhGA1UvVLCARUxpdTMwxpCtbPWYe+Uvq91C
+uoX5ISnzS7/LEN7FNzUWhVc+F+/hiIuPuOEt4ukQznJNerZsVmxSuBqNCa+tMajwBAoW9Zr+BbXJ
+duGtMe/fUfupOYf7S1bXq1ny8OCyZkTQhqtVtbA1ljXyi8WnR89CyS8KkaHV4Tu697Ba1jufSGBz
+zf4sl6LMzyVlmIiK7LGOc0NNr6pTS1KbLxTzdGjxtbV1lHAbz4qGOmO71ZaU5hfDmvTMR2RQK5MI
+Ske0MlyHIZCFWDAJixOne79gyn1dYBGQk8QiJaTCLNJjNyymU4ycteOjg+GDu5OHD4pXdreuX3n1
+3r33bt06amWT9fVkbS3LMrTb6frGdisDoSA7tklBxAUPnRuKmZIxBAITiwUnkDyhFluaGjNNYBMZ
+M2vMSPIR6IO0Z0xS2Vm1TVk/szVTw0XCRSKFQSGGOTOuI8bBFABENN+0PogWScacsWtNi3Q85n7f
+TSfpeJQcHrrhYHjweNTv82s317cv7d67ffDej5Kjo87UZVw6bVqSVJBZkwmRgBkQwyJToaLMHQBN
+DAGI7reUMmIkzWgzlVvgqIqwsrRr+bcgNWxcT7FcJ5UR27O7UEIYxXFhkeY+V6skRCQlxwPBcJk3
+vlxJmXVKzPVZqdYUguzl/rtUtkdf7FWbSmtt0vzVo1mRZh3DVm1OUyu4YkTEs0X0mYx4atQWpJYR
+tlPZTnMyPIvytows1ZYLl71ozqJe1l6IzaW6ZZcve8edyrhqyp7MW+1CxW9FsZ8DPtv0DJGhhaAA
+zZ9WD6QVv/qhRVXKsQaHQVPXAlDm0gJK3b1S7LyQ2VU0H3JiyaghLQyzKoqe7JQsACHfqxvKa1NM
+bb5ANUt6A12tZZq1DoU3J8rw4OyJqDarqZmFqwApVQgKIsCoDcf79pUBBYkAx8JEIkYIYkpyS4LU
+cYsA4dRJS7OuCU3ZDQoZDfqdYnJtPNr96P0Pfv/39wwG6+tZp0NpOtncTK7s9DbWW+2WXdtY661b
+WMcYZS0xVmAgEHFO7WmCnG3PWTcyZpQS5ZQwQSglM9tyJFwq7EoyK8YmVeo1AQoqxomMcowSssYW
+6IhsiCTiusIFYEAJKJlMpqPxFNRy3Do55oPHk/6g6Pcn+w+Pj0+KyTg5PHCjIQ36nKbrve76Wu/6
+ePh4NNwrChHkkEQ0RZ9YqNconJBjEkihIftBRtgQLCHxPAMlQxOQlMxGlN+YqgOejmUMv0lOTn09
+1F4qC+UvPDL30p2Nu8rpthwufk7wO79p9mc2Hmej2P9etU0ZFohn9nYs2qlXieJltV5A1fyZq0la
+8/zwp/mFkoiIF4DoMxmh8GpYjT+ER5rKQ6hC1KxYC2lb7cjCl0h4ssxm76URRxYWdaHAZmVVso8o
+3qR/4Y18MVbrXbU2WXjfZUU6P2t2n3l6hsjQmnhqdeSUC0kZkudXtWsXrVXPtL7Zqnup/QZaXHnf
+mU0p/GdOmujlpa2jEiJCICPegtMMSIfSerB8Lmsu3mPlUF+GJeM/rK54GlBGCIQBuDpNsxA4AgMu
+OK7WHgEY4tQcBBDIiIDBJIaRBBw2Y0nE5ezWgKvMu/3B1oP77el43MrZ2sLQqN1Grztst223m+9c
+WVvfzClxeYuu7m52uxmMEy7ETVtWksw4MRnyCVmsbU06BxM7mVo7gclgiUo9vSTc5axcsgAtcfXY
+eGpokPAks9Jrd9euTOXy8eEGpDWl9qSYOrECy0JHx8ePHk+m0+m0oMePhg/uH4+GXBQ4Oh4Phk44
+G49MURjmfGvrUuFuMF93bo95m8WBUpAFTGDp4dInj131CEDCJQPW7iLq2SilWUj5JWn4SiVpTzOt
+P1tusHDR8fTFS1SEDKSmwZI4l/9pgNbZBdWHcMkEs1Td+g2VJdhPDH4lhoIhj/JsqXrEkkrN1SWs
+2uoVJTTe9E3dJdKziHOLSN5eWjQZUchnnlrs3Hr6EjbSZEdnXCt80pKc/eSnkH/GSxYu2yFgvy+K
+sL0M9AyRoXl8uopIZa8qVSkKNLmqey+ypAEo+VilzM1fNeNUNcK3vBwoVUPTOOvp6t8cok2d76kE
+h4pmKbju7Tg71X+vQiWCSZjg1CamZpyK71DpPFja1kTEVTc0AhE4xySSACTSZfRY1h1vMl8qpsmI
+hWXCPDo+LvapEJlmufTWTZYPWaadbnLtml1bbxnLYMfFKE+51bZjcd2WvNp7feO1L2Y3ZP/g/ggY
+waRkDUhzOxiqbKzV85SqxDAi5MjS1EqfxG70dn/8zcs/dv3+cfHRdw9cPpxgOJ6y40xgC+cODo8f
+H5yMxzSZ2OHQjUcsYg0lzrWmBTFbUA6kjsnhkpOtgtcZa4wOy5hMCpjSg5Y1r1pFsKq8c1X8EgiY
+UJStKUz+CQgRqjx1BFTRUZat553xKzVsuf7gwi50xpfHqUsJlcFZ7yuoeGnJ+SsKN98pfaBOqbpw
+SbzKCJ++20p5Lc2miNqAptVVCc891W42K9/yXQohxzs/K6YREWdH3PD2WUXTOrTMZHSqu8RCI1Lt
+SGiYCufDU9f4mnPpwnv5X590pl0h+fQ32hIT4jLm+Ql57zPH86Fn3/7Wt184W4sM7YlR66lntxHX
+L6dZ7HGlDE86BGjBp1Pgs9ArY5wtpT8tQ2tioYfViolgRXMFE4Qu26gea1DThut0tzJFCIwISpdD
+PY9ARoOmEwzEQqy3XgAQEvGWN5OIsYyExTKyQtqFCAkBBWNScOFQQByPzXjfOhHnpjbhu3cmWV4Q
+iXDh3CSxE5u7QTHa2Bj9tW98+fU33up9Lr/74Aej1mhESIwhQArH7IzAkjGlj2CZe4vVPmUYBFgU
+BkMym9du3PiZn9+6eeV3/ui3vv+dj106ZOOEU5I1EVuIG094MsmZbeEsIU2T1FgrAMEy87QQk+QE
+W7CwdEQykVSQqP3NSLlbTyBqqDQl0SDAVG6x2rri+QZAJAZiSGyZRhyM0vuW53vqgo62etQ03UKW
+vUjO/pJbsQgqNZ97LO6ravcmqmjrglc1af390bPmLWyunciCMs9KtVrYah/O5ecv5MMRERcaccPb
+RcQT8a7zg7N4apyRm52HOp6T1brnRs+eoeSnRmRoT4+FtqOzd+LZYsy8RtZcv1ktYSHbWXzVyrKF
+Zrmz1KHp0+hjq9QKs+zys9wCc1MYVf/NiCUqz9FmjWcGSwGoMugIEazmewasplaDoCISXLl0agRI
+w2JgUjI5qOWEDay1ZE3BPGWeEgmRZTEMUIpCpscj0Eh35Qm4IJo6M+4X5mTaPnJXaPvz063HR5t7
+LhsZw2SYABROHJMyNCVmVHqzVuo/wwjDTYVGSGRtx119k65cP+Af3DlswyYgIeQGPVcIi4MBGUOw
+ZCwRFWLIlUbT8k5IWFCIc2JZLIthMRptRd0UhaQM9oGyg5KylZKhGamegiGjl5AYEg1SYtX3r3oO
+zj+KZd35iUbNGencitXKZZec2nU9P/RAmZVu3qhdfp5J85TvjNatMy5hPBFOJWar154iIj7biD6T
+5xbLqM5Z2NpCj4Aa5Qs991ZrXCtI1zLvodBgtVD4soPLXNBDmcuELKzgsnutLk99yfKFcsWXip4h
+MjSPs9OJZZ+xvAcvlD07uZKyUNpZnKGbpG4BeVMTlJ5MQaCQylIgkCrgiCAgaSsW/sNhr8l/vT/A
+WQbzsgnLV9xLkJKDCebcM5UkuLLAlYsYZu5klRkNTGUVUVrSSm5mMKsva6E1UD8zhIUFTsCwYlKx
+CZLEERWOjTFkMphURByzI2cSY8g4EY0SaSkhY40BoQAmNunabEuSy9N06zhde5x2XCcRWzAcAcRM
+DJIyFbdUrpmY+cEBRlhcIVJQluT5cdbaaK0V+ZZLtgjOkGGxjNSRE2JjSIg1cZcAzhFJmfiO4cQw
+qzVRRAhc7uojGIIh0S7AZUeoosdoDP+Sp5UuovrKkJKmGE3sDKKyYct8aFSdXu7FWv7QT7X2hO/R
+Ff3qiTDfzU4ZaP5Mf8QQeM6cO7ssFCjzX5+8lAvKHIw+hOOu9jZdMUeF4zcsauRmEREhInk753ii
+N8Iy9rL6kuc/K76Qm55nvGz0DJGhedQUlBW8aOGRpQ5IDZZVlyBzHoYLlzqaep5UeeJDnQynqbAa
+w0GUqVQ7ibyTlsiSON9Lpr5mU6xef8JyfdG3YXPq9Ow1KEr4F95YITKLC8JleA2tIFdb+UqyQzNb
+nJchIiiDoYPYMTRQu0mMsQI4ZgYLOVjiwrGIISpDRBAExACDWWDIipiCDYkxgCELsoTUIAcyplaR
+tEdpPhZ2pKxHDFlj1fFUewOzUbMMlXSIQAZEpmBmspPcTBI4C2fIsSEBbCKOGMRijDUMCGsGMoEI
+yIi4goVIYATiHKuVDmTKnkAEY8gYEhFRQluGYZyxeM8TlHVRGPuTgMo/szoJnl0ivHg5auOuxh+W
+Lewtgychtd5VozHLVjQw38M9BULQjSs7mmiUxcbmsVmlasu0S8u8oplowUbV5iwRLrKumJQqE2B9
+2TVspWUFiYiI8Igb3p4DnnpJrjaPNS1g4eQc/tScqFeYrRa+PpplXq0lrjavneVld8YTzmhSq7XD
+qUuZnzZeQnqGyNBChAqi16t88tYzaoQeyqBC4eGHU80FTbFNArO6Ls0jYXX0iMbHR5UeajXbXC1/
+4dCtTXwhH/MnLJwKQ4VYpEyuJaXSzwBWhJ70z8sxlxR0Rsc8i9D8XbM0ylJRIqWxxibK6Kwh0tRm
+wiJOmKpsApXqb4ymxgJE/SchJGJEDAtADGOEwVPN4WwcZEI8LqkyKWE0QpjF+6Nyn1cVbEOpIBlN
+CM1CTEaNfq58miyAYSGB1SRdqNhZVTOGlEYtgI2mUGcWdgIn4pgLiDMQAbO2GVW7//zzorI1tUkZ
+0AwBxlqIZgUQVLEvfNTS8umUtrnFPopqgF2Y93PZe271eNG/zazNNZm1E0KZ/ifPZ2qMEWVmZ29C
+qzIkUNWf5nd31gZyrRblrwIyiwNkle24eNzNSfY6x8ImKoeGc7UJqknYIkmLiHhqxA1vERHPCi8n
+PUNkaCFCtaapBa5mLwtXGrzSo2lzASgjqjG3cOF8xapMzRoQptxdpkstIz/KzbxToiqjYQGaymiz
+aj71mQRoVmEZZB6oGOOSVfyZlbHy1vR30XLOlHIistaC4JidsPoOlryhEkWAZq2u2IyaihA+NmER
+dswFiVM7E5gwI3VSMjUGERmIJ3ilXU0NlUgESnySMli9gUNRYFqSM5VRlaJ0biQNdl8GrIeAxZEA
+lBCRMAlLyZNKW5i6H3KVD1l9GKvm8cZR0s+mChbpxAnYGWICQ5iEoTvwSpIl3vAImmtAbR4qqZrS
+UymNkFWnqJrWrLaf+edurWVmz4iap4U9Z6GocFxIlca0bOGqwxtjnHOyxAod3kLHrHOueZrvbCKi
+vrKzIVM5c6qkJh+TBmYFLsn2onmmtGUutgf6D77KK+arZa2nTdQc72dZsomIiDgjXmafSV/ac1i2
+c4tnvlhWUyyfrfBnjpeWniEyNI/mcrJXd/SzWp9WSGj+WiN4wlIZSQDNTrZcf6qpR6pTeqVzmWa5
+rEbhJajse0qxanJqtagxzxq8PufPUaW2eXKznCG91KZWad6WsvAqwDMsCbjWrLRzt6bSJMQWNLvE
+26qqv8pC1dfPaN40KpkJlQ2uhjSCJbIonRHLW1YelN6op5YUtdVZjZQPScGJMLEIjJqb2JD14Usw
+K43CgDBLj6UdRhhCZExJAPUAK8kkkFDlp1pmFxCUpsbAzFJZeUiECWTIEipjmnPMXFlpyiCERDS3
+hkBVObXFjLJ9R2Qcs2MnmoZOvJfmrGFW6/phD+QKtd4FwFrr+dUyUZ60hAI9HfIkcMXw8fddSBfL
+LlHGxTGYGdzg25mIKrfbmUBfpBoR8mNwZn5b3EbB0oQuIqhJVLhGzPzQXixm0WAMa+onmXDFJCIi
+4tPGc/CZPCfU6JuX3zknJVmNFQuCEc8BLzM9Q2RoNagC51RVndcal6kptdXx8KCHbmIyRKyOhTBU
+aa9oLGb4v+GCfWgWqFG4pha7DFq1oiikMiCEtahV4VR4HToM4aiXNxfym8QvvHVozahVEMtbtanK
++guZWQQaukIYwkKGZvmsKoKlOjSR959EGdi+vCUZMkYdCp1z7AQsRIGA6p7C+q+nQgIQhEgJD6np
+jcgwxIlT4jRrhCafnR2cdQZmQplzXNRO5ZxTn0YuOZQa1rR4nh5USwLzLeUcg8haa8gSkSFT6fwz
+38iZpRLEXPmHlsRDQGAWYTG27E16b2Zm4YUdaUXv0j7jqVT4IWTsEmChEDVTe4sZAgrkuxmWDNta
+OZsLIsETms0MUhKkxfSq1o1rSyF+6Sc0iZc7Emty9F5lOB8hKZOuC4RdyTm1gn5gNsddrbKeGerX
+0Cruy9Zs5IiIiOeMZ2h2Oz82t7OTtKYCdhZF5bmtLn3Cu6xeKPy0S3KeF+BecnqGyNBC+PHgnJtO
+p36pPtQRa6gZi0NCUhSFXqUqnIhYa3nKJXtYLsR/aC7ze31OWdZZLGm1CnqSFpopvMCFFawpph4h
+k/Ql0UbDE04upkJoWFumha/GXHOhYg0sLHOkcRlCvVbvrypvURTT6bRwU9Cq2lUul5WazQ6AtVYV
+d2MMEZidCAtDsKBTUcjOglKZ2e43FpnFXywLWbNxiYQGnBq0Czl2qFz40iRNksQY4zfDBY0fdIB5
+0uilJTZhZgJZa33XOgsRCis4X8fZo9fG1+4Rcg/nXFOO307pf/UdsuaUW9v2VqNP/lptH5VW85ks
+imL+QmFePILCstWWM0KUpxVzdLTWSqgeH3w3C5rOf9DhbK1dMbeEzyjo8LN2aM4/ERER5w3P0Oz2
+HLa6ffvht8K7XBRL2rnCSzgnv5z0DJGhNWGMSZIkSRIbQPW8UweGP8c7CIVr2yKSJIk/s3ZJE16C
+V5uSJMnz3FpbyzzWxAqLX6fTUV/EJEmyLEvT1LtQYl5hDeuFQG/T2mVZ5kVpK2EJ26zZDfxBrymq
+TK2UtjzpXrJG4VfzK9Wh0zRN01SfY6vVarVazdZoauT+iDdETCYTX7Asy9rtlnNFzY3Tt0ntIAXe
+YrrxyR+31lqbJIlrlmrFWhoFNkYf3CXP83ar7ZxrttXqNQXtiiF78dq8BuVvFiA0p4Tk3DeX5+fa
+S5sFWPbsahxJJShjBKDSvNueb8mmEG2fcPOYc067kzFGe8VoNEqSxPe6ZrvVZPrbZVnWarW0SH4A
++mWFFWsKIRnTa/W+vudo2VCFS1lWQUXY2nr3NE2NNf4ST0RpkQXMFyb8QJU7t+4D1KYLz4+IiLhw
+eA7MbcVdVuCpSdrqt/8Tnf/UM1uosD1peSKeDi8tPUNkaCG8Lr6+vn7z5s2NjY3RaBTu6Fg4qhdq
+/yIynU7b7fa1a9fa7fbu7u6XvvSlo6MjZQ615f+ahJC8oVK1r1+/funSpbW1tddff308Hk8mE0/2
+muUJTRbhbKIVXFtb293dzfP86tWrX/ziF69evbp6ogkl+OlJzQs3b95cW1sD8Prrr6s6GDqSLVT0
+Q5lhTbe3tzc3N5MkuXz58ltvvTUYDFQPXlGw5i2YeTqddrvd69evdzqd3d3dt99+++HDhzWXzmbt
+atQRlUfoxsbG7u5ur9d79dVXv/zlL5+cnCgXrZGxhQ3oyQ+A8Xjc6XS2trbyPL958+ZgMBiPx75U
+obTVLxX1v718+bKKeuONN7TKIXluNksNaj7SWnS73StXrvR6vVdeeeXg4GA4HHqy3SxerWq1Ummb
+G2O+8IUvrK2tFUUR0tezwItdX1+/fv16r9e7evXqW2+9NRwOUdmOvD1t4YUh51e+0Wq1rl27pr39
+7bffPjk5SdM0DEmyojxUxdQhojzPr1271ul0siy7efNmv9+fTCY6nKUyQS8M3xo+U0/kOp3OlStX
+ut2uzgwnJyd+sEuwH6zWejVCpbh69Wqv18uy7M0336RgMchzudU9Pyzhzs7O5cuXtUZP+uwiIiIu
+BD7VrW5n5FrnzZK27M0bTsXnBy+Va8PLTM8w58K0+jwiAN/61rc+3eI8X3zznXf0Awc+Ufv7+3t7
+e2maqu0lBFaqLGFLSrWDRVW6yWQyGo3U+qEr5V5UU6VryiQiX57hcDiZTLxNY2F5VhAGrUi3203T
+dDKZDIfDcMn87NAKWmtVKe/3+6qR1yq1kNkutF8RUbvdzrJsPB6rRr6MO51aKtWn8zx3zk0mE/VG
+O0sdfcG87QuAippMJoPBQJtdlWxPEvzkfmrf8BUcjUaYV5HReGoLF+r01toZjDHj8Xg6ndb4cM08
+srAk/mRrbZ7nSZJoqXwXrZ1fQ420672ste12m4hGo5EnjauxbDGSiFqtlh84/hb6aMKWr13ueU5I
+VvM873a7w+Gw3+/XPGmXFXKhKUzbyhgzGAwmk4nawUIKVGvwWql8efSSTqfTamIfT9oAACAASURB
+VLWGw6Hv7eEIXdFEoTQdg91uV8egt/piZbeslYcC86OWyrN0D1N9/fan8Ap45513sKSnRZwKCvyi
+P42nExHxdOQtxEICtpDdhTo0vl/OXd/4O19fRqKeDrV5tfaS9RP72traK6+80m63dYbEC+JsUvlf
+rK+vb2xs5HnuF+NqZz7zsoXvnfCzvogvX7589erVVqv1bG/685fKPvBseftT0DN/yTOnc8o+9Gmt
+6NjRhjaDjszNzc1erxfqKMuWtJuX17QorwK2Wq319fWmkGXK00Lh+rfms/dEA7Jm+cnzfG1tbTUF
+WtF1QhNBp9OpCVkhtqmOh02X53nYVssuWVaqZbc+I5WtHfHcQJ8gFmnMXv6yW9TKo9P9kz7EsGvp
+vUSk3W43C7OMMCyro6LT6ZyxRqeK6vV6p56D5S3p+5UxxpcqbLFTmfDCr2obrwlZwdBW9Pywt9eq
+s6zf+kERvum1VBsbGzitozar1jyor8mzvLNr6siyM5+tShQREXFB8cnjlJzltBWWtN/7H/75We4S
+EbEMF856pogMDZhXj3QPTI3MnIWkheqX1+yxRNNtaorhJU3JqPYCNfXvs5O0U3lOU79coaKFEfaa
+ut0yybXtSRSYMvy9mt5iNWVx4QabGj2u/VorZJM4+eLVjocEcmH714QsvMvClm/+XYiFHWPhkVqx
+F66x1Soefm2ev7Dr1rjiwgKH1QxvcSr9CJ9UjcSe2lxN/lPrEgsH8kJRYS9d3a+arddknmHtwkIu
+q9dqToVgQqgVpiazdtxfu+IJ1vrG2eeWiIiIlxA1TvUJrW3fvPwOGuFwIyI+IS4oPUNkaCFopeNT
+DatXl1dQlKdblm5yjLAkT03SFpbw7EUKP3/C5fZTCfBTiArxdOqm7xIhS3yBautCknDqkTOKwnlS
+yp+0GDXSIoGTZ/gEF164+l5hz3zSTr76eS2k9Mu62WqW+2yf2jnpAxERERcLz3aTW0TEJ8fFpWeI
+DK2JT0g2QqVwxQlPIbP2eYXNbTVW+DU9dalO/Vo7HuqgtbX/ZqVOZc6hnKd4dqEqv6IiZ6xgU3jT
+SPjUaKrvCxX6J3qsz1wdX00aF46vZWX45C2G+UdQo0PLbt08LTz+RCNoIbNabQn8hGslYQuvqF14
+o1Ot6xERERFPjafzkzzjNqSLmDUrSr7okp8PIkMD5tXcJ9WnF57WlCDB9qEVxTj1Fk1/p09VnXpW
+ws/IV1dorqulUSOn8FmK1HwcCzX4hfr9Gcv5TPjwqeaUp7CkPSvSeCpOLdupayKfkln1KRBa6prr
+C6dee8bufSoWLgMto1srrj3V+zQiIiLiU8IzMaxdROU+Sr7okp8bIkMDMKehnFFVedLzmxee8fhT
+3GKFnCcS9WlobaeWYeGvZynJE9Vu4eN7IfU9i4QVX59C2rMqz7lS6rUwq7KbPbm05ucnFfKpjtxP
+UlkK/kZEREQ8T6xIjf3NhT8sk3MBlfso+aJLfp6IDC0iIiIiIiIiIuJTxApi9jTSLqByHyVfdMnP
+GZGhRUREREREREREfCp4ttwMF1O5j5IvuuTnj5eaocX8nhERERERERERzw2fMBPxRVTuo+SLLvmF
+4KVmaBEREREREREREc8Bn5Cb4WIq91HyRZf8ohAZWkRERERERERExKeCT07MFBdRuY+SL7rkFwjz
+ogsQERERERERERERsRQXUbmPki+65BeLyNAiIiIiIiIiIiLOKS6ich8lX3TJLxyRoUVERERERERE
+RJxHXETlPkr+LEl+UYgMLSIiIiIiIiIi4tzhoiv3UfJFl/wCERlaRERERERERETE+cJFV+6j5Isu
++cUiMrSIiIiIiIiIiIhzhIuu3EfJF13yC0dkaBEREREREREREecRF1G5j5Kj5E+OyNAiIiIiIiIi
+IiLOHS6KCh4lR8nPHCQiZzqPCMC3vvWtT7c4EREREREvE9555x0AZ3wTRdSgr2Ztu2/HF3TEBce5
+8jGLiFA8c8L2zXfeAUAAVr77og0tIiIiIiIiIiIiIiLivCAytIiIiIiIiIiIiIiIiPOC5EUXICIi
+IiIiIiIi4mXHOdn/ExFxHhBtaBEREREREREREREREecFkaFFREREREREREREREScF0SGFhERERER
+ERERERERcV4QGVpERERERERERERERMR5QWRoERERERERERERERER5wUxlmNERERERERERMRLBPvh
+ldf+52vb73a7d1JZHw0+//jBv/vxnZ8eOk0kDErevfbGr1/ZfHetsy/jN06Of+reB3/7Xr/jBVDr
+H3/t67/SA/rv/S/f+fiVWd7h5Pfe+sZ/ctmiuP8Pfu/dn3TBmQqevnK8/zc+eP/fOpjMdPBTbweI
+bf/uK6//+u7WX7TSCXhj1P/iwf7f+OCjr4+lfosK+cM//o0fPOrUDzeqsLxgkmz/8te//M+S6b/+
+vX/+S4du6bXg9VH/Jw72//qdO+8cT+0TnANgZeHPIuSzicjQIiIiIiIiIiIiXg6I7f3GT7z9K5fz
+rcP7//Lte69PsNdZ+6PLb/zHVzf+q9/9/s8UELv2j7705V/dTm/s3/433/t4h1rvbu/+ox//qW9v
+//l//e7dmzwvrnvt/+nc/lv98qikW7+xvYg4TB/+vR/e34U5bq3/X6/e+G9+cv3gu9/9O8cOONvt
+KP+/v/i1/+IS/cT9W3/3w0GPsjvdjd/Z2f3te7e+Pq6IU7H/H/zowZUZV0Q2OslPbY7lBQNwvHn9
+dxIA6beur//dw8fdRddehTnJWrc667+9+/ov7776v33wR//lh0edJzrn1MKfUchnCpGhRURERERE
+REREvBSw33/z7V+5nHztL777n98+7nhK8P77f3Bte4sBJH/85lu/um1++kd/8Mu3+y0AwC/cvvUL
+r37577/xhf90ePLfv388Yw6jB3/ZXPmnVzt/872TDADo0fb17+LoF47X/kl7/rZu8LX9h28ygAf/
+0mP3t//Sa//4lbV/708P2me7XdG68g8vJdc+/u4/eM/f/dbf+hFNKOA0Rf/rew/erBHIU7G0YABl
+/9+N7dH47i8e7fzqpet/mD7+uemyawHg3/9g4x++/ZO/9vpb/93R7//S44LOfs6phT+jkM8U4j60
+iIiIiIiIiIiIlwCSXfqfruU4/uA/CukZAB7/1O27n+PqhJMP/8M7JV8CACl+4tYP/50hPr7x2r8I
+bRtu8K/cG967uvuems0o+93rG+mj21+bhqLryIcHX3Dot9sndNbbuax9CGz3x1mtNqvu88QICwaA
+s0u/sUlXH9z963cebtjt39g85W52evg3//zDN5D9n69tHy6hTWc551Q8EyHnHpGhRURERERERERE
+vAQYdnd+QPjc/YfXlrCNYe/ynxA+d2+vfgIP/ureCHbjt7uhEyO/9uDe69mV/33NAnCtnf913f3c
+ncO1lVSGk9Y9i2wy6chZb5cNDz7P+MHnvvDrO+v37TJSYgZJchz8N3xC9hIWDKB7O9d/gNFffdDf
+OL73V6bmOze2908TmA4f/vwQrrf90XJ+seScJyv8WW50wRG9HCMiIiIiIiIiIj77oGGej8BXh8WS
+IBM0yPMReHfBCbw9mADrt9M56pCM9v6Nkzf+x2vrv3hwuL9z7YfTvb9/5EY3FkgeWTs05ri18U8+
+97l3Ufz8/eM26NHZbkeTvV96d/0/+/Ebv/alS78GdIeHP7O/96/dvvtTo8AvsPXK3/vZV0IRb737
+u//t/clprGphwQDT/mfXehh99NcGDD75V/cm/8f167+d3/+3R6vZ5+SNMdDOV5m2Fp7zpIU/y40u
+NiJDi4iIiIiIiIiIiHgK8Oiv3Dn61c9d/8N8+qfXOpcf/NmPO/xh87TWq7/4c69WX0b/f3v3HdbU
+2TYA/D4hOySYQSAJexUHogioiEodoFZUHFWrFkVxW1v1Vfv2rbbO1lFbt1atsxW1DkTqqljFDVoH
+FUXZe0MCZJ/vD0QCBAhqvyq9f5d/AOc5z/3k9GrOuc+z/FOezCtUU8D09IIUFzzbVpTxjC+4wW9z
+v40gxsYiRmY94c8/w8pr1p/U5M9PzJXWJlAkr0LTfADjDQM12yqKDdK0fFs9AOhc8gpEUtkpS9bg
+jMqmUwfShM9kpEzLG29KoHcZZmgIIYQQQqj1I1kqFRO4eSyqDox2o5FslYoJ3FwjBSjFbDqARlZ/
+jhlpWZTd0dUtQqbPYioDcxUMozOI1PkLE3NkJMlWK6VKFadm6ccWhSP0KteiHNeiHACihO80t6PN
+AWdx8J854urDOmX70pIWrxRivGFmz62tc0E5ukSjpFKVAKAq6qqWnZGIM7JSHZsIQaGn0AG0Kosm
+etqMlmlp400J9G7DDA0hhBBCCP0LsCoK2pOieCtRTnamjbGHe5aisC0pumfdoACFfcmSCbrCHhW6
+eqcQmuJhJbDUVgxVqUGVeuNrPOiV7mWlDTOQVwgHAAAkvzRraIXNJha3gJIjbmlW1mzDzLiRYjoA
+RHTqHlHngPVvnPSZ8kbjaViiKyyglhTZ6aCxDkJTyjSrTiWtU6udYIcQQgghhFAtQl0UmqMCrsMG
+GbfSMD2gMOKlkucUINRFoblqMHfYJOEoaw+bPZW5RLBAlp3upW1QKanxTs/oWVIcnJYna2GyZGI4
+PZWdTq/zyE5SOQkMAFWF8HXSs0YoLKRXaGCb+Xjdgwfra/6tTcyWAOOChKts5Cw9zeLwe/apoB6Q
+XmLxGmWa9UYqeethHxpCCCGEEPpX0HkkP5pD77DJ2WucKC+wRG6vgkIO94FQHMcoXpuf46zXeiY/
+msb02OHaJVyQHViiEAHzicDqpIApKkxamSY3ugc0pyx1+YNXa49J4TQcm7mdxILCPL/yChuVTsMw
+vymRxVI1AemFlmRNTxSVc8tSnGLQEWemkXcrqWIai9ok2j2ZsIIsm5VZ4K0yqI6oGi2Tfm8p+Su5
+zKu658qMfVcoyn6xkTQ31lqUStF5pjyaWWqwR5kpZZptvImVtCqYoSGEEEIIoX8HQqcYkXDHW2y/
+V8K/aiOOoAJPWelakrwuPaeLFgCA0MrHPrzTSeKw34p/wklWDGoHefnIJwlheQr23zDryZRwtIqc
+WankJSE/yl5aYgZUrVqqyJv+LD2kWFU7e40q3OEurFN1xfNf4jMb21egMSRdcJxPoZdk+anrnkmq
+emaVbnYXnbSgdi6ubpZoczsRAADoecoK9/zUCdnZAXJNnQl1ppRpovEtqqRVIUjSpP9yBEEAwOXL
+l//e5iCEEPo3CQgIAAAT70Sonupbc/W1+8P4DZo0S4ux23dGkJjEyS4nedaVrl3yR4/L9pHWrP9G
+UhOjHA+ca5OYxC4iVI5ucu8PUicFVrBfvprWMY9P7brxOYBT8sGdGTYvX+yS1JtLuy2+YgbmeT8c
+TfRkGZSsxtTYuBaFhKcM7aiufRvcbDgAUsm6cdThQDT/eQ5NTdFbWFW07VwUEpbeVUTWD1GD4f/w
+xIpidmPXqd5ZhJ4nqXDvVBQ0LDvAreYhr+majR5lFq47nuDNBgAgFYLloz0uVWgGb7q1wMNgZkwl
+f+nwjlc7PDq9rohT+1eze8u6fxYjXxV1349TE7oqfc++FCcaABDF5zoNX81r7NNIxsfvn6KgNXYY
+IfRW6x0QADX9nk3c+7APDSGEEGqNSKX5iRUdNsYy+B55/UflOgihIJn74LrjwgsWa04+8mUDWck9
+usxj602azC9ryPQMSz0z8Zb10dXef9x4uvbzHPt6w7mSJb9nZYXa1yxCV8Y/cdvYK2xe4ezP8qyp
+FHkO79wh2aZPeKU/3p3sqgMwLZyOcXGF18pYwj0oc0ZopbmWnp1scf2KdeygzK6imsyHVzRtVr7Y
+4AGGbq0wOvasYcOsqBRFATMzjRcb7bA82jZyyoPV48pr88Oma657lGAoXWqOyf+UXq8AANrlU7wZ
+HiUGydgrIM07pXz9Jb16upMmTbp+v4VlyNPJHXQvjjor8dkNodYO/y9HCCGEWh/S7NGODhtjqV4z
+764YJa9NQqanxEUJ+GYAJPXh9vZbb1J85sYtH1bBJAAABg3PHPSzx5wf3f4nU+wKN5hyI83voRT/
+do49dqqCDgBAFN+R3iXLB7XlRmfUjWte6eVf6EQDgPw+XrpJU+yOH+Z+9GUpy7Rw2hzxoViq5KO7
+P0x9GT0zdA6h1hu8ajav6Non36mlvUi1DQMACAuzOLTYc8+u9lva31nQuWY2S9M1N3aUpN8+LlBa
+5szsYLk1VnpfXuLHbWHb6qJblfa2evGz8oFg634LYcfCPu+bsLcVQqiVeCMZGlmVFnNg35m4xKTk
+7HKCZ23n2iVo9LihPlIGocs9PnVM7cAARhupi8+QSeEjvMV1vuJIeWLUngPn7iUmpRYRIke3dt4f
+TJwU6GQwyqJuPUy+jWv3kPApQzsKmvoE9c4CClvk6DVg/NTxAXZMwxEVzUWvjF86fP7VDqtPr+tu
+8GKs6t6yEZ/FuK+K+s6PUxuL03vVz1/5Wbw4V5txKGzCj8x5R7YPEVPqt4eg8ySO7p16BA0bFuDG
+e/kqklRm3ji650B0/POcMjWFaWFl37Zzz5CwsV1FrXrALUIIoTeHLBHuPc0At+fzhssNxxACVeU9
+LAcAyGLh3mgGuCbPDa6ovSUSWveRSR+e6XLouN29MQndXmYa9MoBAVVfnrdODn3mzgDQ02+csKD5
+Jnpp36ufoRlgyErdWHaXM1kKfSmz1KRwujJWGYDUQUU3rIgg6W/6BmhmUTZ2UVrMRIezBwXhnfLb
+vEZV+gLhiXuE1eicID/iUIz4RBy9+/tqzKbQW4CS4tBlkr2x8b+VaT/FN7mzGfqHvXaGRiqTT6xY
+tDG2gO8R2H9UkIMQCpKfPLi+feGFe2tOrvatfgPG6zX7s0BrqkaR9/jS4SPbFySUbts9rS3rxRjM
+yqSjyxZuvVkq8xs2ZPpoS31u4q2zR1eH/XFj/trPg+uMsqipR57z8Nyh45s+SSj9cedk1+aGNlSf
+RSN1VSVpcZEHDn6dkM/a+3m36iSqBdFNU/HH9hMpPhObeLnH6zX7s0ArqlpRkJ2ZlhgbvWd59OHI
+Kd+tHufOJgB0+RdXTFsZC+5Bo2aE2phrS7KTH12/Eh07aCRmaAghhExUlWyZoAXnoEJJIzf6qmTR
+X1pwHlhQvwCjsm8f5aGDFrHpZt3av5xSpbfrn+vwi83pJynuHXW6PMtTiTq/tWXcY021QS9n5lYB
+XaBmU0wNR5eUutIlt7e5HWCkB/nIrYyuzKCjVMqpcoPbLJWlZbX8eYYmK+wlc9j3VJCuym9DM6Hm
+ukfNmDo2jQQgcq9IE0jlR/0qLGxye/Kto08IinrninA3I/TP09tmPTyYb3R/No01pmdvtdfM0MjK
+RzsWb4yVe83cuWKUm8EgiqlxUTf4LxMKc3svf38nGgC839ebEzbxp8ijiaFLOrMAgKx8uP3zrTeV
+PnN3Lx/mVDPs4cNBPy+c8+P6/8ncd4UbZGAG9fTx4kyacuD44b8++rIzq+lG1p4F0M9fmjtyRey5
+Z1XdurBbGN0UAk+3yvuHf4wduup9fmMv0AzbAxAW9vDQ4s/27Pp8S/uDCzpzdDmXDsVWSD7a+cNU
+t5rQo0LnaNV6TM8QQgiZiKjKZyhBb2WrbeTmQVTmM5Sgt7ZpWEAvcFAD8LKK666GLS0IdnH86RRv
+ZseyokuSJIuCOe10RnZG0hPKKrMqDUWeYxG9xTkRtL0GyFlAFJsWjhAULPiSt2SlbM9S4R4AjrTM
+17/gg5E53oab8ubZzB5uY1hF+//d2Nyv5d1WVLWjCCCbUaYBoJlQc92jDtNu7xpbRdWyLkWagyS9
+n70eaIqBvdRRp6Sx+XnDrHH1G/TPo2qUNpp/uhHoVbxehkaWXN97Oh/cZs4b7lZ3EIXIe1gwAECD
+rb5pVh4ubMjIzJTrO7MoQJZc3xtdCK4z5wY7GQx74LiP/PTDM+GHju+/N2ZZN66Rb12GrLMb68Dl
+zCyFvjPL9DdVBNOCSwedRv+y/a8UvVE8n7DhFYt37TyS5DfNzaTkzszCY+yiiTETd509eDu80/us
+sqwyAKmDZd0BHtQ3PsADIYQQagEzZc+h5Vu3SO8XaR6fYYv6PHmPBfcbFsu1nTnE9sXPhNI//Mm8
+nmoKmH4nJcU9n22LzHgWJ7gR3+b+XUHMEYuYY9YTtvwZ1rZm/Ul+/vzFuVKDBSJ5Tq84R6t+FtV0
+zXWOkhxblRmAOs0qKh2kH+fb0gBA5zKgQHRKdiqGNXhsJc70Rwi9qtf7/qhKvpqgBeegno0NomiI
+rMjNrQQzXpvqtKoq+cpfWnAe2KAGhkPfPpJDBx/Fpqu7tTeS6ujlWblVQBdYsptNz/QaZVVVlZbU
+KUvSbh/ZfE1p0Xfwe6zXit44ms3gGQOOzj+24/KItUEmDnKgyXr0ku3a9/Rmuup9D0lnV/rp29vW
+HGCEBvm4WTX/8RBCCKF6SJZYxQRuXgZV52u0G41ki1VM4OZmNixAKU6lA2hkgnr5C2nZPbvjD24R
+R/VZ2crAgQoGGLtD8fMXfpEjo5NsgVJqreLU5DMtCkfQVa5+Oa5+OQBESZzT3AU2BzaKg7fkiKsP
+s5TtvUpavFJIQ1p6SgEAV2XxsqqmazZy1Ox5lHUuKEf7apRyqhIAxEVd+bIzUeKMkamONAAKyaCB
+XmWmfbmtMAAAoa6kAFVHxclqCCHjXitDI6vy85RAt7K1aKaDpzpH0mgVeY8vbN/2GHj9RnmaAwCQ
+lfn5SqBb2zSsgSpwEAL8lVWsBmDUq0ee8zB6y7ZE4PQa4NrMEEcAyD08c8jhl7/xu81cN78rj2h5
+dNMQ5p6hE9ud/2HXz497fdLetBsIVegoIiA7r0wDhKDXgi9HLFn5656lN/YAcKQdfP37fDBysLeY
+3nw9CCGEEAAAsJwK2lNF8edEOUMzbYzd61mOhW3NRPfOinKG1C2gZl+KYQKzsIdd/WEwhKB4mBcs
+PSwG29QgBz0YzdBYSnfP0oZJziuEAwAAkt85a6izzaZcboEmR/xGu6U0maIr2UDtUmTHAHi1OTmV
+3MhLdACImN09wvDvJda/paTPdNMDVeUoBChllerAonY+GzWnkABhhRA3NUMIGff/0wdfJ0eSDvzv
+t5/68l7lzZFhPYTEP3zRvJ6C5vuY+P0XfjFYRiP1GkV+UuzRPVs//ZK6bfVwu7/rm5EqCZo++OAn
+p7ZfHP39QNNOMdywjiruOWdb5EfP4q7fiL9//+7tmCMbY45FT9iyMawtG1+3IYQQMgXBLwoNVsWf
+cNhwomz5SIPlHLWM+ChBm4E5zoKi0EHqe6cdNp0p+XpIzfqKpNnTX10iskA2Nt2r4ZLxhMZ7fEZP
+HbdNUJ6shc8PhGnh9HJ2plZpx69NmEgFJyEfQFwhfKNPLPpyi8Nr7FNBPXhCicWr3lwVD6VXysD2
+w8dzu9YOhtQXi75bKb0QxQ2bV8akqj06qiHS6kJKxhTXFx9KkyWOfAbcfmVWOA4SIWTca307ECyx
+FRMS8zLKdL7sprrR+P0XfjFYSlEWP79ycPuZmDPXRvUe48QAAIItFjMhMTezYQ3a4tQiAAuZgF6v
+HhmdyhZYS60FHBPHB7Cs3T09X7zP8+7hLcofvXLnzrj+y7tzTY1OoTJooFcp645SINWVGqAyjLSC
+3X78ZM/oNXv2P+z1oSkt1BanFJDAtX450IKgC139gl39ggF0JXE75y6IOLDx9+AtwWIc84gQQsgU
+hM5j6qM5BR02bfEadzUv0FduL4DCFO6Da+K4wuK1gTnOhNZzxqNpuR47NnQJv5Md6K0Q6ZlPblmd
+vMUU9UxaOVFudAAJxyN1+bpXa49J4TTpNnNniQX+eX7tK2ysdJoC85tRsli5JmBeoaVZzeR2BefW
+JXGKwQOMWRt5N68qZtMPBQr23VhRNpWiKGRmpnFjo0Wpap3nlEczPbW15zVWs9EKSdq9k8IKStms
+UQXelgYvWnVVo49Jv4+R/DW9zIutaxf63O9i24OzOxeMye1kq1NmWZyPsE6ml/4nvMTcsMH1Q5Pm
+ziW+DtpmripCqHV6vfc3LKee7al/xJ+7mjP0Q6ODKGrK1eRIXt4e/LKJK7aviPDd9rETA4Dl2LOt
+2ZV7Z6/mDKlbgzrtUkwOMP172NGN1PPqCK69iwDupiUV67pzTY1OFToKAUoz645SkOcUakDoaGyU
+gpm4z4yQfdOPbYv292u+TZrMq1eygdqlq52R+6EZv/Owoc4Rm3KfFmhA3PLV/xFCCP07ESzFiOV3
+vC/Z7z3Dv3pEHFEOPKtKV5/kdeNyurABAAi2fOy3dzpFOuy/wD+xVVZMUTu4lo9clBA2QPF3jNkw
+JRzNLmfWZPLSdX7UPmmJEqgctdQlb/rs9BBfVe2L1HLhjtXCOlU7P/9lZ6ak6RkX5aLNX4sAAEDP
+k1S4902dEJId4Kapc1JjNRurjywWHL9Noftk+YnqTtgzU/UcWbp5pejkA2rnblqKMH/ZAc3R7fZn
+zzieLzRjCKqcfFO/nZHR1aruWQ1CS8bH75+iaPIjIYRaq9fL0Ai+X2iwZfyJPRtOdF4+0tVgEEVh
+fNSNNgODnevXb2bZ57P5F+OWHdj0+4D1g8QUQuAXOkh47/TeTWd8vx7iUDPsofLpr99HZIFs7Mde
+LVpKsXn60qd/FQKlo20bMwBTo1NFHh35EPnbhZQPp9Qsv6/JuhT5DLj9vIyPUmC6jQn3jVyxfy+T
+CWD87duLBpU/OrxmfyoIBk/oakGAXp6ZqbWy49emfaQiNSEfQOz4Zgd4IIQQav0InX3f5KV9Gy9A
+0bQdlrR6WOMFzJTDd/8x3Pgxre/qq5dNKmlqOApX3m+CvN+EV2hM40w5q5kyRo4SwrwNv+cZK0wK
++9+/2L/2d6qwZOwXJWNfKTStY2Lk5cTG240QapVe86GfYHtM/WZOwaJN+8ZWUgAADHNJREFUW8LH
+XQ0K9HW3F5CFKU8eXLsQV9h9bWDDDA2AIvSfOto2bN+enxMCPvVgExzPGSun5S7csSEs/M6wQG83
+kT7vya3ok7fyRD0/XTnRtBXrm6ZIuxsbm00jSU1FftK144cf6YWDxnrxCAAwNTqzXehsv4vLD86e
+XTBmQCdbjjLr4fmIM8l0r/+EdzY3nkJShD2njpJNOXi/CsDSSHuoGkVhdmba49jo2FQ123PKqpme
+bAJAnX547qwYgX9/v/aONlZsTUHSzahjsXJewLzelrjgPkIIIYQQQq3ca3fLECznEcsPeF86sPfM
+natHLkaUU3hWdq4+M9aNG9KFbWQ/NACgOw6fEXDsv5Hbz4/eOExiRrDdx357qFPkrv0X4k5sPV5M
+ETm4uo9ctCpsgPObGWVRfmXz11eqf2RYSF36TZsbNsKnZl6widEpwr7LDvCPbv/p7Jld5wurGAJb
+J9+wb2eM6WrVeNrEcB45zf/XJbFVjbaHxpM4uvedNCEkJMCNV10RzW7IrMmUS9dvR+2LLFHqqRyh
+1GXA9NkTQnyFmKAhhBBCCCHU2hEkadKu9wRBAMDly5f/3uYghBD6NwkICAAAE+9EqJ7qW3P1tfvj
+332DpqTs7TJpL9vIEbu0n3anOuK69giht0LvgACoWXiwiXsfTm1CCCGE0LtNbzvi4cF+xtY7pmms
+8VEHIfSOwa8thBBCCL3jqFylTcMN3BBC6J30zmdompS9kyftTTdyxG7iT7sn4sAGhBBCCCGE0Lvj
+nc/QqLYj1h7spzFyhGaBAxsQQgghhBBC75R3PochqFwrHNiAEELo36169jlCCKFWwNisWoQQQggh
+hBBC/4R3vg8NIYQQ+jd7IzuHIoQQenu0bD80hBBC6I3D/dBeDd6aEULo3YX7oSGEEEKtDWa2CCHU
+Kpnah4YQQgghhBBC6O+GK4UghBBCCCGE0NsCMzSEEEIIIYQQeltghoYQQgghhBBCbwvM0BBCCCGE
+EELobYEZGkIIIdSKkYrHhz8f06+Li4hOEEyRY6f+4evPPq+sXSZMX3Jnx+yh/u2lbIIwt/HoNWLe
+vodyw1XEtKmbOhEEQRAd1ydpDGsuOTOCSxAEwZ/wh6JuyWocK7eekzdeyTU8qflwAGRFUuSKsV2d
+LFkEQZhxLJ18Ppi8MjpLayREDXbIeXkTF6H+WVSerFPIF0cSK+oGbrZt8osjzQlqYFRZndMUl8bw
+CErfyLI6sdqMiizUvyyjfrK6LUF02Z6hM9IeCkvk7DNw8vJf4ou0Jl4HhFBrhqvtI4QQQq0UWfFg
+8/gPPjmZKfafMP7T0HYSyHoUdzVy0cCDl3/LOz2AB6T87oYxA+dHF7gEz5q+ZoGNLvXOb3s3TOx4
+7MyOc/umtmUZVkaBhzt/SZqzpB29+nd94e9bziqMRBUO37B1ggNVVZJybf83m+b2vlEQH7fciw1g
+WjhtxqFxPhNOkT4ff7Z2iVsbTd7zh9eift1zKuzTQbKapxbBkG82jLGjvQxJMB08WQ1bYrRhdFKr
+yHt8YcfKVaOvZ3AS9n4gooCpbWuJsmOLNicEfeXBaLo99lRlaVZy0uPbJ/cs+WjP2h0rLkb+15dH
+mHYdEEKtFIkQQgihVkhffnWWLQCnz/q4Mp3B31WZ5zfv+LOSJPVlf0yXAZgHbnqg0Ncc1ZXeWtWd
+DuD2eXxl9V80KRs9AZzGDLEGh0X3qmrKZR8IoLP8wnxp0Gb8ZblhyS8eKF8Uqrz3hTMAb+wlOWlq
+OPXTNe0AHBfFVdT5LOoqjd5oCJM0PEuXc7C3GXA/vFBeXb9pl6L8wggOmPU/XVqndvnvo7lA9DlV
+ahDLurcXBziDI3JfXHlV4ip3AK9t6drGPoWm4OqyrjQAq8m/l+qbvQ4IodYMRzkihBBCrZE+7/RX
+OzOgy7Ltc7rwDG/3dFn/WVM9WaDPO/317izo/NWmaR4couYoxcL30y3zneHpphWXSgxG+LE6TJzo
+knpgz4NKAADQZUVtiWUMmNXXsqknCZbL+17mUJ70rFRnajhNwbNCAOv2NkzDiggak0o0qP41UNgi
+PgO0Kh0JAC28FKYQBi77b6eKqMXf3asy8QyqyH/h7qUdIG/fqrMF+v+v64AQehthhoYQQgi1RhUP
+j9/UQMePQxxpxgsoHhy/pQHPScOd6hVgtRsz2hEU1049NswuGO+Nm9wu5/DOOAUAaNOOb7vNDZ7Z
+k99kvqAreZ6qAKa1jGtmajim0/teTLixYMrKY7fT5LpG6lWWlxgqVWhMyKD06gqFQqGQl+Y9u7F/
+8WenKkUh4d7mr3ApTEF3DV8bKkr5YfHRrEY+REMMl6HDXUB7NzqxyrTrgBBqnTBDQwghhFohvTwj
+vQKY9m7CRiYt6eUZGRXAtHdtWIBu3U4CUPgsT1Xnr04fTutU9Ov2G2Wgfhax455oxPRuFkYStOpE
+qLw4437k8okL7oDFoFAvc5PDUaxH7Dz0iU9F1JJRXR141DYu/qPnbzqfrqxzRtp6f4nAAD/wSEHz
+KVrq2u4iLpfL41u7+oVuKxq4/vyOQULKq1wKU1Da9F6ytJvm4hff3jY2W88ouqSDjIDS9EK1adcB
+IdQ6YYaGEEIIIVPQ7ENmdFWc3nol+/GhXY9lY150QNVXnQhZCO06Df06RjR01cntIdZmLQljO/yH
+W4VZ8ZE7ln3ykQ/r8ZHvPgly6v6/WwarKorH7Ii+YCBmS7+mO/MAAMBq3O7zly9fjrl07sTebyZK
+f58fMHxzYoszrxZ8EKfQNVMlmdsWHkozdf1Fkqz9kCZcB4RQ64SrASGEEEKtEIVra8eBO2lPi7QD
+eMbu9hSurS0H7qQlNSygzv0rB0DkYlVvHUIz2eCZPWdPXfc951myw4RJHVmgNlKx1bjdB8KdGTSu
+tYOzg8SCTrxCOIIp9Qqe6hU8FUCbd2FxQOD6lXN/mXZtqm31YXPn7n36NbFKonEcB59evV+cFTgk
+UJZuP+HzxRfGnxjMN7VtFBqbDrqqCg0JUJsR6pVyFdDZ9IY5Irf758t7756ydEXsiHmmtFCd+yiL
+BL69iN7cdWhJyosQetdgHxpCCCHUGnE8hnejwYP9J1I0xguYe4T4UuH+3gYFlI8jjqQAx29IgzXm
+KVZBM/uSV9Yeynab9HE7JhjFcfDp1bt3Lz8vN6mFQdbyCuEAAIBq9f6s6R0BUuIz3mR/F4XftpM1
+VDy+l6sxvW10aQcJQEFSgWExbUlKthokHSRGMkaq3Zg1s+3ydv9nz3NjyWw9qqQTx58DzWtQW7aR
+qv6e64AQegthhoYQQgi1RhSr4KVTbSB+yYzNd8v1BgfUWRe37rxfBRTr4CVhErj71dxdCbVbN5Py
++I2z1z8Dl1n/69Nw5CBF1P+/C0L6D5r65ceu9PoHm2mPaeF0JU8T60760pcm3MwAkHSQtjBik3T5
+d29lAUX6niXN5LYBTdqjpxU82XswoXbhENWzwzv+BL7f+/ZGm8fpsmB1EDNu+deXiptpUNG1tZOX
+J4D1xC8GiIj/t+uAEHoL4ShHhBBCqFUiuP7fRP2Q9cHceV1cT3w8IcinnYTMehR3NfLQhawPzo6f
+6smy6L321LepAxfN9PQ6N3NCfy+ZPi3ut5+2/pYmC9lycmkXIx05QFj4Lz9+/tXaY1I41eN1AT0i
+rIaND+7ewc2Oq8q8d+bHH06VCEdtH2FDBaie0FX6MDril0cG6y5SLX0G9XXhND0Xrezx76dOPqeT
+elVZxr3IzWuv6SVhC/sICJPbBsDptmRD8M8frerRI/M/EwPceBXPYw+u2/2Q2efHVX3aGI9uJg35
+5jOXzquuKABsjLSHqirNrt6x+uRfSm7vlZHre/OIZq8DQqhV+6c3ZEMIIYTQ30cvT/h50Yd9OjsJ
+qAB0gX3HfuHfnUuuqN32WFt0c8uMwd3drZkAbGl7/2Fz9/xZZ4fr6u2V269NUjesvey3wYwmdqw2
+orlw2uK4g8unB/s6izkUAKBZSNx7h62Jfv6ixdUhGur4fbKm8aANzmKJnLtP+Oa3lKo62z83eylI
+kiRJVdbFb8f5t5WaEwBsa7duo5adSa2qH6vO5dLlHRtqDlB/x+paDIFjl6BJX/8cV/jyQzRzHRBC
+rRlBkrgkEEIIIYQQQgi9FXAeGkIIIYQQQgi9LTBDQwghhBBCCKG3BWZoCCGEEHrnqR591ZYwqu1X
+j3B5eoTQuwTnoSGEEEIIIYTQ2wL70BBCCCGEEELobYEZGkIIIYQQQgi9Lf4P4P7kSXifx5sAAAAA
+SUVORK5CYII=
diff --git a/Documentation/DocBook/media/v4l/common.xml b/Documentation/DocBook/media/v4l/common.xml
index a86f7a0..9c41c32 100644
--- a/Documentation/DocBook/media/v4l/common.xml
+++ b/Documentation/DocBook/media/v4l/common.xml
@@ -856,8 +856,10 @@ conversion routine or library for integration into applications.</para>
 
   &sub-planar-apis;
 
+  &sub-selection-api;
+
   <section id="crop">
-    <title>Image Cropping, Insertion and Scaling</title>
+    <title>Deprecated API for image cropping, insertion and scaling</title>
 
     <para>Some video capture devices can sample a subsection of the
 picture and shrink or enlarge it to an image of arbitrary size. We
diff --git a/Documentation/DocBook/media/v4l/selection-api.xml b/Documentation/DocBook/media/v4l/selection-api.xml
new file mode 100644
index 0000000..d9fd57d8
--- /dev/null
+++ b/Documentation/DocBook/media/v4l/selection-api.xml
@@ -0,0 +1,278 @@
+<section id="selection-api">
+
+  <title>Cropping, composing and scaling</title>
+
+<para>Some video capture devices can sample a subsection of a picture and
+shrink or enlarge it to an image of arbitrary size. Next, the devices can
+insert the image into larger one. Some video output devices can crop part of an
+input image, scale it up or down and insert it at an arbitrary scan line and
+horizontal offset into a video signal. We call these abilities cropping,
+scaling and composing.</para>
+
+<para>On a video <emphasis>capture</emphasis> device the source is a video
+signal, and the cropping target determine the area actually sampled. The sink
+is an image stored in a memory buffer.  The composing area specify which part
+of the buffer is actually written by the hardware. </para>
+
+<para>On a video <emphasis>output</emphasis> device the source is an image in a
+memory buffer, and the cropping target is a part of an image to shown on a
+display. The sink is the display or the graphics screen. The application may
+select the part of display where the image should be displayed. The size and
+position of such a window is controlled by compose target.</para>
+
+<para>Rectangles for all cropping and composing targets are defined even if the
+device does not support neither cropping nor composing. Their size and position
+will be fixed in such a case. If the device does not support scaling then the
+cropping and composing rectangles have the same size.</para>
+
+    <section>
+      <title>Selection targets</title>
+
+      <figure id="sel-targets-capture">
+	<title>Cropping and composing targets</title>
+	<mediaobject>
+	  <imageobject>
+	    <imagedata fileref="selection.png" format="PNG" />
+	  </imageobject>
+	  <textobject>
+	    <phrase>Targets used by a cropping, composing and scaling
+            process</phrase>
+	  </textobject>
+	</mediaobject>
+      </figure>
+    </section>
+
+  <section>
+
+  <title>Configuration</title>
+
+<para>Applications can use the <link linkend="vidioc-g-selection">selection
+API</link> to select an area in a video signal or a buffer, and to query for
+default settings and hardware limits.</para>
+
+<para>Video hardware can have various cropping, composing and scaling
+limitations. It may only scale up or down, support only discrete scaling
+factors, or have different scaling abilities in horizontal and vertical
+direction. Also it may not support scaling at all. At the same time the
+cropping/composing rectangles may have to be aligned, and both the source and
+the sink may have arbitrary upper and lower size limits. Therefore, as usual,
+drivers are expected to adjust the requested parameters and return the actual
+values selected. An application can control the rounding behaviour using <link
+linkend="v4l2-sel-flags"> constraint flags </link>.</para>
+
+   <section>
+
+   <title>Configuration of video capture</title>
+
+<para>See the figure <xref linkend="sel-targets-capture" /> for examples of the
+selection targets available for a video capture device. The targets should be
+configured according to the pipeline configuration rules for a capture device.
+It means that the cropping targets must be configured in prior to the composing
+targets.</para>
+
+<para>The range of coordinates of the top left corner, width and height of a
+area which can be sampled is given by the <constant> V4L2_SEL_CROP_BOUNDS
+</constant> target. To support a wide range of hardware this specification does
+not define an origin or units.</para>
+
+<para>The top left corner, width and height of the source rectangle, that is
+the area actually sampled, is given by <constant> V4L2_SEL_CROP_ACTIVE
+</constant> target. It uses the same coordinate system as <constant>
+V4L2_SEL_CROP_BOUNDS </constant>. The active cropping area must lie completely
+inside the capture boundaries. The driver may further adjust the requested size
+and/or position according to hardware limitations.</para>
+
+<para>Each capture device has a default source rectangle, given by the
+<constant> V4L2_SEL_CROP_DEFAULT </constant> target. The center of this
+rectangle shall align with the center of the active picture area of the video
+signal, and cover what the driver writer considers the complete picture.
+Drivers shall reset the crop rectangle to the default when the driver is first
+loaded, but not later.</para>
+
+<para>The composing targets refer to a memory buffer. The limits of composing
+coordinates are obtained using <constant> V4L2_SEL_COMPOSE_BOUNDS </constant>.
+All coordinates are expressed in pixels. The top/left corner is always point
+<constant> {0,0} </constant>. The width and height is equal to the image size
+specified using <constant> VIDIOC_S_FMT </constant>.</para>
+
+<para>The part of a buffer into which the image is inserted by the hardware is
+controlled by <constant> V4L2_SEL_COMPOSE_ACTIVE </constant> target.  The
+rectangle's coordinates are also expressed in pixels. The composing rectangle
+must lie completely inside bounds rectangle. The driver must adjust the
+composing rectangle to fit to the bounding limits. Moreover, the driver can
+perform other adjustments according to hardware limitations. The application
+can control rounding behaviour using <link linkend="v4l2-sel-flags"> constraint
+flags </link>.</para>
+
+<para>For capture devices the default composing rectangle is queried using
+<constant> V4L2_SEL_COMPOSE_DEFAULT </constant> and it is always equal to
+bounding rectangle.</para>
+
+<para>The part of a buffer that is modified by the hardware is given by
+<constant> V4L2_SEL_COMPOSE_PADDED </constant>. It contains all pixels defined
+using <constant> V4L2_SEL_COMPOSE_ACTIVE </constant> plus all padding data
+modified by hardware during insertion process. All pixel outside this rectangle
+<emphasis>must not</emphasis> be changed by the hardware. The content of pixels
+that lie inside the padded area but outside active area is undefined. The
+application can use the padded and active rectangles to detect where the
+rubbish pixels are located and remove them if needed.</para>
+
+   </section>
+
+   <section>
+
+   <title>Configuration of video output</title>
+
+<para>For output devices targets and ioctls are used accordingly to the video
+capture case. The <emphasis>composing</emphasis> rectangle refer to insertion
+of an image into a video signal. The cropping rectangles refer to a memory
+buffer. The targets are should be configured according to the pipeline
+configuration rules for a output device. It means that the compose targets must
+be configured in prior to cropping targets.</para>
+
+<para>The cropping targets refer to the memory buffer which contains an image
+to be inserted into video signal or graphical screen. The limits of cropping
+coordinates are obtained using <constant> V4L2_SEL_CROP_BOUNDS </constant>. All
+coordinates are expressed in pixels. The top/left corner is always point
+<constant> {0,0} </constant>. The width and height is equal to the image size
+specified using <constant> VIDIOC_S_FMT </constant> ioctl.</para>
+
+<para>The top left corner, width and height of the source rectangle, that is
+the area from which pixels are processed by the hardware. The target identifier
+is <constant> V4L2_SEL_CROP_ACTIVE </constant>. Its coordinates are expressed
+in pixels.  The active cropping area must lie completely inside the crop
+boundaries and the driver may further adjust the requested size and/or position
+according to hardware limitations.</para>
+
+<para>For output devices the default cropping rectangle is queried using
+<constant> V4L2_SEL_CROP_DEFAULT </constant> and it is always equal to cropping
+bounding rectangle.</para>
+
+<para>The part of a video signal or graphics display where the image is
+inserted by the hardware is controlled by <constant> V4L2_SEL_COMPOSE_ACTIVE
+</constant> target.  The rectangle's coordinates are expressed driver dependant
+units. The only exception are digital outputs where the units are pixels.  The
+composing rectangle must lie completely inside bounds rectangle.  The driver
+must adjust the area to fit to the bounding limits. Moreover, the driver can
+perform other adjustments according to hardware limitations. </para>
+
+<para>The device has a default composing rectangle, given by the <constant>
+V4L2_SEL_COMPOSE_DEFAULT </constant> target. The center of this rectangle shall
+align with the center of the active picture area of the video signal, and cover
+what the driver writer considers the complete picture.  Drivers shall reset the
+composing rectangle to the default one when the driver is first loaded.</para>
+
+<para>The devices may introduce additional content to video signal other then
+an image from memory buffers.  It includes borders around an image. However,
+such a padding area is very driver-dependant issue. Driver developers are
+encouraged to keep padding rectangle equal to active one.  The padding target
+is accessed by <constant> V4L2_SEL_COMPOSE_PADDED </constant> identifier.  It
+must contain all pixels from <constant> V4L2_SEL_COMPOSE_ACTIVE </constant>
+target.</para>
+
+    </section>
+
+    <section>
+
+      <title>Scaling control.</title>
+
+<para>An application can detect if scaling is performed by comparing width and
+height of rectangles obtained using <constant> V4L2_SEL_CROP_ACTIVE </constant>
+and <constant> V4L2_SEL_COMPOSE_ACTIVE </constant> targets. If these are not
+equal then the scaling is applied. The application can compute scaling ratios
+using these values.</para>
+
+    </section>
+
+   </section>
+
+   <section>
+      <title>Examples</title>
+      <example>
+	<title>Resetting the cropping parameters</title>
+
+	<para>(A video capture device is assumed; change <constant>
+V4L2_BUF_TYPE_VIDEO_CAPTURE </constant> for other devices; change target to
+<constant> V4L2_SEL_COMPOSE_* </constant> family to configure composing
+area)</para>
+
+	<programlisting>
+
+	&v4l2-selection; sel = {
+		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT,
+		.target = V4L2_SEL_CROP_DEFAULT,
+	};
+	ret = ioctl(fd, &VIDIOC-G-SELECTION;, &amp;sel);
+	if (ret)
+		exit(-1);
+	sel.target = V4L2_SEL_CROP_ACTIVE;
+	ret = ioctl(fd, &VIDIOC-S-SELECTION;, &amp;sel);
+	if (ret)
+		exit(-1);
+
+        </programlisting>
+      </example>
+
+      <example>
+	<title>Simple downscaling</title>
+	<para>Setting a composing area on output of size of <emphasis> at most
+</emphasis> half of limit placed at a center of a display.</para>
+	<programlisting>
+
+	&v4l2-selection; sel = {
+		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT,
+		.target = V4L2_SEL_COMPOSE_BOUNDS,
+	};
+	struct v4l2_rect r;
+
+	ret = ioctl(fd, &VIDIOC-G-SELECTION;, &amp;sel);
+	if (ret)
+		exit(-1);
+	/* setting smaller compose rectangle */
+	r.width = sel.r.width / 2;
+	r.height = sel.r.height / 2;
+	r.left = sel.r.width / 4;
+	r.top = sel.r.height / 4;
+	sel.r = r;
+	sel.target = V4L2_SEL_COMPOSE_ACTIVE;
+	sel.flags = V4L2_SEL_SIZE_LE;
+	ret = ioctl(fd, &VIDIOC-S-SELECTION;, &amp;sel);
+	if (ret)
+		exit(-1);
+
+        </programlisting>
+      </example>
+
+      <example>
+	<title>Querying for scaling factors</title>
+	<para>A video output device is assumed; change <constant>
+V4L2_BUF_TYPE_VIDEO_OUTPUT </constant> for other devices</para>
+	<programlisting>
+
+	&v4l2-selection; compose = {
+		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT,
+		.target = V4L2_SEL_COMPOSE_ACTIVE,
+	};
+	&v4l2-selection; crop = {
+		.type = V4L2_BUF_TYPE_VIDEO_OUTPUT,
+		.target = V4L2_SEL_CROP_ACTIVE,
+	};
+	double hscale, vscale;
+
+	ret = ioctl(fd, &VIDIOC-G-SELECTION;, &amp;compose);
+	if (ret)
+		exit(-1);
+	ret = ioctl(fd, &VIDIOC-G-SELECTION;, &amp;crop);
+	if (ret)
+		exit(-1);
+
+	/* computing scaling factors */
+	hscale = (double)compose.r.width / crop.r.width;
+	vscale = (double)compose.r.height / crop.r.height;
+
+	</programlisting>
+      </example>
+
+   </section>
+
+</section>
diff --git a/Documentation/DocBook/media/v4l/v4l2.xml b/Documentation/DocBook/media/v4l/v4l2.xml
index 0d05e87..54333a5 100644
--- a/Documentation/DocBook/media/v4l/v4l2.xml
+++ b/Documentation/DocBook/media/v4l/v4l2.xml
@@ -493,6 +493,7 @@ and discussions on the V4L mailing list.</revremark>
     &sub-g-output;
     &sub-g-parm;
     &sub-g-priority;
+    &sub-g-selection;
     &sub-g-sliced-vbi-cap;
     &sub-g-std;
     &sub-g-tuner;
diff --git a/Documentation/DocBook/media/v4l/vidioc-g-selection.xml b/Documentation/DocBook/media/v4l/vidioc-g-selection.xml
new file mode 100644
index 0000000..c2652aa
--- /dev/null
+++ b/Documentation/DocBook/media/v4l/vidioc-g-selection.xml
@@ -0,0 +1,283 @@
+<refentry id="vidioc-g-selection">
+  <refmeta>
+    <refentrytitle>ioctl VIDIOC_G_SELECTION, VIDIOC_S_SELECTION</refentrytitle>
+    &manvol;
+  </refmeta>
+
+  <refnamediv>
+    <refname>VIDIOC_G_SELECTION</refname>
+    <refname>VIDIOC_S_SELECTION</refname>
+    <refpurpose>Get or set one of the current selection rectangles</refpurpose>
+  </refnamediv>
+
+  <refsynopsisdiv>
+    <funcsynopsis>
+      <funcprototype>
+	<funcdef>int <function>ioctl</function></funcdef>
+	<paramdef>int <parameter>fd</parameter></paramdef>
+	<paramdef>int <parameter>request</parameter></paramdef>
+	<paramdef>struct v4l2_selection *<parameter>argp</parameter></paramdef>
+      </funcprototype>
+    </funcsynopsis>
+  </refsynopsisdiv>
+
+  <refsect1>
+    <title>Arguments</title>
+
+    <variablelist>
+      <varlistentry>
+	<term><parameter>fd</parameter></term>
+	<listitem>
+	  <para>&fd;</para>
+	</listitem>
+      </varlistentry>
+      <varlistentry>
+	<term><parameter>request</parameter></term>
+	<listitem>
+	  <para>VIDIOC_G_SELECTION, VIDIOC_S_SELECTION</para>
+	</listitem>
+      </varlistentry>
+      <varlistentry>
+	<term><parameter>argp</parameter></term>
+	<listitem>
+	  <para></para>
+	</listitem>
+      </varlistentry>
+    </variablelist>
+  </refsect1>
+
+  <refsect1>
+    <title>Description</title>
+    <para>The ioctls are used to query and configure selection rectangles.</para>
+
+<para> To query the cropping (composing) rectangle set <structfield>
+v4l2_selection::type </structfield> to the respective buffer type.  Then set
+<structfield> v4l2_selection::target </structfield> to value <constant>
+V4L2_SEL_CROP_ACTIVE </constant> (<constant> V4L2_SEL_COMPOSE_ACTIVE
+</constant>).  Please refer to table <xref linkend="v4l2-sel-target" /> or
+<xref linkend="selection-api" /> for additional targets.  Fields <structfield>
+v4l2_selection::flags </structfield> and <structfield> v4l2_selection::reserved
+</structfield> are ignored and they must be filled with zeros.  The driver
+fills the rest of structure or returns &EINVAL; if incorrect buffer type or
+target was used. If cropping (composing) is not supported then the active
+rectangle is not mutable and it is always equal to bounds rectangle.  Finally,
+structure <structfield> v4l2-selection::r </structfield> is filled with current
+cropping (composing) coordinates. The coordinates are expressed in
+driver-dependant units. The only exception are rectangles for images in raw
+formats, which coordinates are always expressed in pixels.  </para>
+
+<para> To change the cropping (composing) rectangle set <structfield>
+v4l2_selection::type </structfield> to the respective buffer type.  Then set
+<structfield> v4l2_selection::target </structfield> to value <constant>
+V4L2_SEL_CROP_ACTIVE </constant> (<constant> V4L2_SEL_COMPOSE_ACTIVE
+</constant>). Please refer to table <xref linkend="v4l2-sel-target" /> or <xref
+linkend="selection-api" /> for additional targets.  Set desired active area
+into the field <structfield> v4l2_selection::r </structfield>.  Field
+<structfield> v4l2_selection::reserved </structfield> is ignored and they must
+be filled with zeros.  The driver may adjust the rectangle coordinates. An
+application may introduce constraints to control rounding behaviour. Set the
+field <structfield> v4l2_selection::flags </structfield> to one of values:
+
+<itemizedlist>
+  <listitem>
+<para><constant>0</constant> - driver is free to adjust size, it is recommended
+to choose the crop/compose rectangle as close as possible to the original
+one</para>
+  </listitem>
+  <listitem>
+<para><constant>SEL_SIZE_GE</constant> - driver is not allowed to shrink the
+rectangle.  The original rectangle must lay inside the adjusted one</para>
+  </listitem>
+  <listitem>
+<para><constant>SEL_SIZE_LE</constant> - drive is not allowed to grow the
+rectangle.  The adjusted rectangle must lay inside the original one</para>
+  </listitem>
+  <listitem>
+<para><constant>SEL_SIZE_GE | SEL_SIZE_LE</constant> - choose size exactly the
+same as in desired rectangle.</para>
+  </listitem>
+</itemizedlist>
+
+Please refer to <xref linkend="sel-const-adjust" />.
+
+</para>
+
+<para> The driver may have to adjusts the requested dimensions against hardware
+limits and other parts as the pipeline, i.e. the bounds given by the
+capture/output window or TV display.  If constraints flags have to be violated
+at any stage then ERANGE is returned. The closest possible values of horizontal
+and vertical offset and sizes are chosen according to following priority:
+
+<orderedlist>
+  <listitem>
+    <para>Satisfy constraints from <structfield>v4l2_selection::flags</structfield>.</para>
+  </listitem>
+  <listitem>
+    <para>Adjust width, height, left, and top to hardware limits and alignments.</para>
+  </listitem>
+  <listitem>
+    <para>Keep center of adjusted rectangle as close as possible to the original one.</para>
+  </listitem>
+  <listitem>
+    <para>Keep width and height as close as possible to original ones.</para>
+  </listitem>
+  <listitem>
+    <para>Keep horizontal and vertical offset as close as possible to original ones.</para>
+  </listitem>
+</orderedlist>
+
+On success field <structfield> v4l2_selection::r </structfield> contains
+adjusted rectangle.  If ERANGE is returned then field <structfield>
+v4l2_selection::r </structfield> contains the best match found by driver. When
+the parameters are unsuitable the application may modify the cropping
+(composing) or image parameters and repeat the cycle until satisfactory
+parameters have been negotiated.  </para>
+
+  </refsect1>
+
+  <refsect1>
+    <table frame="none" pgwide="1" id="v4l2-sel-target">
+      <title>enum v4l2_sel_target</title>
+      <tgroup cols="3">
+	&cs-def;
+	<tbody valign="top">
+	  <row>
+            <entry><constant>V4L2_SEL_CROP_ACTIVE</constant></entry>
+            <entry>0</entry>
+            <entry>area that is currently cropped by hardware</entry>
+	  </row>
+	  <row>
+            <entry><constant>V4L2_SEL_CROP_DEFAULT</constant></entry>
+            <entry>1</entry>
+            <entry>suggested cropping rectangle that covers the "whole picture"</entry>
+	  </row>
+	  <row>
+            <entry><constant>V4L2_SEL_CROP_BOUNDS</constant></entry>
+            <entry>2</entry>
+            <entry>limits for the cropping rectangle</entry>
+	  </row>
+	  <row>
+            <entry><constant>V4L2_SEL_COMPOSE_ACTIVE</constant></entry>
+            <entry>256</entry>
+            <entry>area to which data are composed by hardware</entry>
+	  </row>
+	  <row>
+            <entry><constant>V4L2_SEL_COMPOSE_DEFAULT</constant></entry>
+            <entry>257</entry>
+            <entry>suggested composing rectangle that covers the "whole picture"</entry>
+	  </row>
+	  <row>
+            <entry><constant>V4L2_SEL_COMPOSE_BOUNDS</constant></entry>
+            <entry>258</entry>
+            <entry>limits for the composing rectangle</entry>
+	  </row>
+	  <row>
+            <entry><constant>V4L2_SEL_COMPOSE_PADDED</constant></entry>
+            <entry>259</entry>
+            <entry>the active area and all padding pixels that are inserted or modified by the hardware</entry>
+	  </row>
+	</tbody>
+      </tgroup>
+    </table>
+  </refsect1>
+
+  <refsect1>
+    <table frame="none" pgwide="1" id="v4l2-sel-flags">
+      <title>Selection constraint flags</title>
+      <tgroup cols="3">
+	&cs-def;
+	<tbody valign="top">
+	  <row>
+            <entry><constant>V4L2_SEL_SIZE_GE</constant></entry>
+            <entry>0x00000001</entry>
+            <entry>indicate that adjusted rectangle must contain a rectangle from <structfield>v4l2_selection::r</structfield></entry>
+	  </row>
+	  <row>
+            <entry><constant>V4L2_SEL_SIZE_LE</constant></entry>
+            <entry>0x00000002</entry>
+            <entry>indicate that adjusted rectangle must be inside a rectangle from <structfield>v4l2_selection::r</structfield></entry>
+	  </row>
+	</tbody>
+      </tgroup>
+    </table>
+  </refsect1>
+
+    <section>
+      <figure id="sel-const-adjust">
+	<title>Size adjustments with constraint flags.</title>
+	<mediaobject>
+	  <imageobject>
+	    <imagedata fileref="constraints.png" format="PNG" />
+	  </imageobject>
+	  <textobject>
+	    <phrase>Behaviour of rectangle adjustment for different constraint
+            flags.</phrase>
+	  </textobject>
+	</mediaobject>
+      </figure>
+    </section>
+
+  <refsect1>
+    <table pgwide="1" frame="none" id="v4l2-selection">
+      <title>struct <structname>v4l2_selection</structname></title>
+      <tgroup cols="3">
+	&cs-str;
+	<tbody valign="top">
+	  <row>
+	    <entry>&v4l2-buf-type;</entry>
+	    <entry><structfield>type</structfield></entry>
+	    <entry>Type of the buffer</entry>
+	  </row>
+	  <row>
+	    <entry>&v4l2-sel-target;</entry>
+	    <entry><structfield>target</structfield></entry>
+            <entry>used to select between cropping and composing rectangles</entry>
+	  </row>
+	  <row>
+	    <entry>__u32</entry>
+	    <entry><structfield>flags</structfield></entry>
+            <entry>control over coordinates adjustments, refer to <link linkend="v4l2-sel-flags">selection flags</link></entry>
+	  </row>
+	  <row>
+	    <entry>&v4l2-rect;</entry>
+	    <entry><structfield>r</structfield></entry>
+	    <entry>selection rectangle</entry>
+	  </row>
+	  <row>
+	    <entry>__u32</entry>
+	    <entry><structfield>reserved[9]</structfield></entry>
+	    <entry>Reserved fields for future use, adjust size to 64 bytes</entry>
+	  </row>
+	</tbody>
+      </tgroup>
+    </table>
+  </refsect1>
+
+  <refsect1>
+    &return-value;
+    <variablelist>
+      <varlistentry>
+	<term><errorcode>EINVAL</errorcode></term>
+	<listitem>
+	  <para>The buffer <structfield>type</structfield> or <structfield>target</structfield>
+is not supported, or the <structfield>flags</structfield> is invalid.</para>
+	</listitem>
+      </varlistentry>
+      <varlistentry>
+	<term><errorcode>ERANGE</errorcode></term>
+	<listitem>
+	  <para>it is not possible to adjust a selection rectangle <structfield>r</structfield>
+that satisfy all contraints from <structfield>flags</structfield>.</para>
+	</listitem>
+      </varlistentry>
+      <varlistentry>
+	<term><errorcode>EBUSY</errorcode></term>
+	<listitem>
+	  <para>it is not possible to apply change of selection rectangle at the moment.
+Usually because streaming is in progress.</para>
+	</listitem>
+      </varlistentry>
+    </variablelist>
+  </refsect1>
+
+</refentry>
-- 
1.7.6

[PATCH 3/5] [media] v4l: simulate old crop API using extended crop/compose API

[Tomasz Stanislawski]

This patch allows new video drivers to work correctly with applications that
use the old-style crop API.  The old crop ioctl is simulated by using selection
callbacks.

Signed-off-by: Tomasz Stanislawski <t.stanislaws@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
---
 drivers/media/video/v4l2-ioctl.c |   86 +++++++++++++++++++++++++++++++++----
 1 files changed, 76 insertions(+), 10 deletions(-)

diff --git a/drivers/media/video/v4l2-ioctl.c b/drivers/media/video/v4l2-ioctl.c
index 6e02b45..543405b 100644
--- a/drivers/media/video/v4l2-ioctl.c
+++ b/drivers/media/video/v4l2-ioctl.c
@@ -1696,11 +1696,31 @@ static long __video_do_ioctl(struct file *file,
 	{
 		struct v4l2_crop *p = arg;
 
-		if (!ops->vidioc_g_crop)
+		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
+
+		if (ops->vidioc_g_crop) {
+			ret = ops->vidioc_g_crop(file, fh, p);
+		} else
+		if (ops->vidioc_g_selection) {
+			/* simulate capture crop using selection api */
+			struct v4l2_selection s = {
+				.type = p->type,
+				.target = V4L2_SEL_CROP_ACTIVE,
+			};
+
+			/* crop means compose for output devices */
+			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
+				s.target = V4L2_SEL_COMPOSE_ACTIVE;
+
+			ret = ops->vidioc_g_selection(file, fh, &s);
+
+			/* copying results to old structure on success */
+			if (!ret)
+				p->c = s.r;
+		} else {
 			break;
+		}
 
-		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
-		ret = ops->vidioc_g_crop(file, fh, p);
 		if (!ret)
 			dbgrect(vfd, "", &p->c);
 		break;
@@ -1709,11 +1729,26 @@ static long __video_do_ioctl(struct file *file,
 	{
 		struct v4l2_crop *p = arg;
 
-		if (!ops->vidioc_s_crop)
-			break;
 		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
 		dbgrect(vfd, "", &p->c);
-		ret = ops->vidioc_s_crop(file, fh, p);
+
+		if (ops->vidioc_s_crop) {
+			ret = ops->vidioc_s_crop(file, fh, p);
+		} else
+		if (ops->vidioc_s_selection) {
+			/* simulate capture crop using selection api */
+			struct v4l2_selection s = {
+				.type = p->type,
+				.target = V4L2_SEL_CROP_ACTIVE,
+				.r = p->c,
+			};
+
+			/* crop means compose for output devices */
+			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
+				s.target = V4L2_SEL_COMPOSE_ACTIVE;
+
+			ret = ops->vidioc_s_selection(file, fh, &s);
+		}
 		break;
 	}
 	case VIDIOC_G_SELECTION:
@@ -1746,12 +1781,43 @@ static long __video_do_ioctl(struct file *file,
 	{
 		struct v4l2_cropcap *p = arg;
 
-		/*FIXME: Should also show v4l2_fract pixelaspect */
-		if (!ops->vidioc_cropcap)
+		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
+		if (ops->vidioc_cropcap) {
+			ret = ops->vidioc_cropcap(file, fh, p);
+		} else
+		if (ops->vidioc_g_selection) {
+			struct v4l2_selection s = { .type = p->type };
+			struct v4l2_rect bounds;
+
+			/* obtaining bounds */
+			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
+				s.target = V4L2_SEL_COMPOSE_BOUNDS;
+			else
+				s.target = V4L2_SEL_CROP_BOUNDS;
+			ret = ops->vidioc_g_selection(file, fh, &s);
+			if (ret)
+				break;
+			bounds = s.r;
+
+			/* obtaining defrect */
+			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
+				s.target = V4L2_SEL_COMPOSE_DEFAULT;
+			else
+				s.target = V4L2_SEL_CROP_DEFAULT;
+			ret = ops->vidioc_g_selection(file, fh, &s);
+			if (ret)
+				break;
+
+			/* storing results */
+			p->bounds = bounds;
+			p->defrect = s.r;
+			p->pixelaspect.numerator = 1;
+			p->pixelaspect.denominator = 1;
+		} else {
 			break;
+		}
 
-		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
-		ret = ops->vidioc_cropcap(file, fh, p);
+		/*FIXME: Should also show v4l2_fract pixelaspect */
 		if (!ret) {
 			dbgrect(vfd, "bounds ", &p->bounds);
 			dbgrect(vfd, "defrect ", &p->defrect);
-- 
1.7.6

Re: [PATCH 3/5] [media] v4l: simulate old crop API using extended crop/compose API

[Laurent Pinchart]

Hi Tomasz,

Thanks for the patch.

On Friday 26 August 2011 15:06:05 Tomasz Stanislawski wrote:
> This patch allows new video drivers to work correctly with applications
> that use the old-style crop API.  The old crop ioctl is simulated by using
> selection callbacks.
> 
> Signed-off-by: Tomasz Stanislawski <t.stanislaws@samsung.com>
> Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
> ---
>  drivers/media/video/v4l2-ioctl.c |   86
> +++++++++++++++++++++++++++++++++---- 1 files changed, 76 insertions(+),
> 10 deletions(-)
> 
> diff --git a/drivers/media/video/v4l2-ioctl.c
> b/drivers/media/video/v4l2-ioctl.c index 6e02b45..543405b 100644
> --- a/drivers/media/video/v4l2-ioctl.c
> +++ b/drivers/media/video/v4l2-ioctl.c
> @@ -1696,11 +1696,31 @@ static long __video_do_ioctl(struct file *file,
>  	{
>  		struct v4l2_crop *p = arg;
> 
> -		if (!ops->vidioc_g_crop)
> +		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
> +
> +		if (ops->vidioc_g_crop) {
> +			ret = ops->vidioc_g_crop(file, fh, p);
> +		} else
> +		if (ops->vidioc_g_selection) {

Does this construct (and the two identical ones in the next two hunks) pass 
checkpatch.pl ?

> +			/* simulate capture crop using selection api */
> +			struct v4l2_selection s = {
> +				.type = p->type,
> +				.target = V4L2_SEL_CROP_ACTIVE,
> +			};
> +
> +			/* crop means compose for output devices */
> +			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
> +				s.target = V4L2_SEL_COMPOSE_ACTIVE;

You use

			/* obtaining bounds */
			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
				s.target = V4L2_SEL_COMPOSE_BOUNDS;
			else
				s.target = V4L2_SEL_CROP_BOUNDS;

below instead of pre-initializing .target. Can you use the same method in all 
locations ?

> +
> +			ret = ops->vidioc_g_selection(file, fh, &s);
> +
> +			/* copying results to old structure on success */
> +			if (!ret)
> +				p->c = s.r;
> +		} else {
>  			break;
> +		}

You can remove the last 'else'.

> 
> -		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
> -		ret = ops->vidioc_g_crop(file, fh, p);
>  		if (!ret)
>  			dbgrect(vfd, "", &p->c);
>  		break;
> @@ -1709,11 +1729,26 @@ static long __video_do_ioctl(struct file *file,
>  	{
>  		struct v4l2_crop *p = arg;
> 
> -		if (!ops->vidioc_s_crop)
> -			break;
>  		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
>  		dbgrect(vfd, "", &p->c);
> -		ret = ops->vidioc_s_crop(file, fh, p);
> +
> +		if (ops->vidioc_s_crop) {
> +			ret = ops->vidioc_s_crop(file, fh, p);
> +		} else
> +		if (ops->vidioc_s_selection) {
> +			/* simulate capture crop using selection api */
> +			struct v4l2_selection s = {
> +				.type = p->type,
> +				.target = V4L2_SEL_CROP_ACTIVE,
> +				.r = p->c,
> +			};
> +
> +			/* crop means compose for output devices */
> +			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
> +				s.target = V4L2_SEL_COMPOSE_ACTIVE;
> +
> +			ret = ops->vidioc_s_selection(file, fh, &s);
> +		}
>  		break;
>  	}
>  	case VIDIOC_G_SELECTION:
> @@ -1746,12 +1781,43 @@ static long __video_do_ioctl(struct file *file,
>  	{
>  		struct v4l2_cropcap *p = arg;
> 
> -		/*FIXME: Should also show v4l2_fract pixelaspect */
> -		if (!ops->vidioc_cropcap)
> +		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
> +		if (ops->vidioc_cropcap) {
> +			ret = ops->vidioc_cropcap(file, fh, p);
> +		} else
> +		if (ops->vidioc_g_selection) {
> +			struct v4l2_selection s = { .type = p->type };
> +			struct v4l2_rect bounds;
> +
> +			/* obtaining bounds */
> +			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
> +				s.target = V4L2_SEL_COMPOSE_BOUNDS;
> +			else
> +				s.target = V4L2_SEL_CROP_BOUNDS;
> +			ret = ops->vidioc_g_selection(file, fh, &s);
> +			if (ret)
> +				break;
> +			bounds = s.r;

You can assign p->bounds directly here, removing the need for the intermediate 
bounds variable.

> +
> +			/* obtaining defrect */
> +			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
> +				s.target = V4L2_SEL_COMPOSE_DEFAULT;
> +			else
> +				s.target = V4L2_SEL_CROP_DEFAULT;
> +			ret = ops->vidioc_g_selection(file, fh, &s);
> +			if (ret)
> +				break;
> +
> +			/* storing results */
> +			p->bounds = bounds;
> +			p->defrect = s.r;
> +			p->pixelaspect.numerator = 1;
> +			p->pixelaspect.denominator = 1;
> +		} else {
>  			break;
> +		}
> 
> -		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
> -		ret = ops->vidioc_cropcap(file, fh, p);
> +		/*FIXME: Should also show v4l2_fract pixelaspect */
>  		if (!ret) {
>  			dbgrect(vfd, "bounds ", &p->bounds);
>  			dbgrect(vfd, "defrect ", &p->defrect);

-- 
Regards,

Laurent Pinchart

Re: [PATCH 3/5] [media] v4l: simulate old crop API using extended crop/compose API

[Hans Verkuil]

On Friday, August 26, 2011 15:06:05 Tomasz Stanislawski wrote:
> This patch allows new video drivers to work correctly with applications that
> use the old-style crop API.  The old crop ioctl is simulated by using selection
> callbacks.
> 
> Signed-off-by: Tomasz Stanislawski <t.stanislaws@samsung.com>
> Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
> ---
>  drivers/media/video/v4l2-ioctl.c |   86 +++++++++++++++++++++++++++++++++----
>  1 files changed, 76 insertions(+), 10 deletions(-)
> 
> diff --git a/drivers/media/video/v4l2-ioctl.c b/drivers/media/video/v4l2-ioctl.c
> index 6e02b45..543405b 100644
> --- a/drivers/media/video/v4l2-ioctl.c
> +++ b/drivers/media/video/v4l2-ioctl.c
> @@ -1696,11 +1696,31 @@ static long __video_do_ioctl(struct file *file,
>  	{
>  		struct v4l2_crop *p = arg;
>  
> -		if (!ops->vidioc_g_crop)
> +		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
> +
> +		if (ops->vidioc_g_crop) {
> +			ret = ops->vidioc_g_crop(file, fh, p);
> +		} else
> +		if (ops->vidioc_g_selection) {
> +			/* simulate capture crop using selection api */
> +			struct v4l2_selection s = {
> +				.type = p->type,
> +				.target = V4L2_SEL_CROP_ACTIVE,
> +			};
> +
> +			/* crop means compose for output devices */
> +			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
> +				s.target = V4L2_SEL_COMPOSE_ACTIVE;
> +
> +			ret = ops->vidioc_g_selection(file, fh, &s);
> +
> +			/* copying results to old structure on success */
> +			if (!ret)
> +				p->c = s.r;
> +		} else {
>  			break;
> +		}
>  
> -		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
> -		ret = ops->vidioc_g_crop(file, fh, p);
>  		if (!ret)
>  			dbgrect(vfd, "", &p->c);
>  		break;
> @@ -1709,11 +1729,26 @@ static long __video_do_ioctl(struct file *file,
>  	{
>  		struct v4l2_crop *p = arg;
>  
> -		if (!ops->vidioc_s_crop)
> -			break;
>  		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
>  		dbgrect(vfd, "", &p->c);
> -		ret = ops->vidioc_s_crop(file, fh, p);
> +
> +		if (ops->vidioc_s_crop) {
> +			ret = ops->vidioc_s_crop(file, fh, p);
> +		} else
> +		if (ops->vidioc_s_selection) {
> +			/* simulate capture crop using selection api */
> +			struct v4l2_selection s = {
> +				.type = p->type,
> +				.target = V4L2_SEL_CROP_ACTIVE,
> +				.r = p->c,
> +			};
> +
> +			/* crop means compose for output devices */
> +			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
> +				s.target = V4L2_SEL_COMPOSE_ACTIVE;
> +
> +			ret = ops->vidioc_s_selection(file, fh, &s);
> +		}
>  		break;
>  	}
>  	case VIDIOC_G_SELECTION:
> @@ -1746,12 +1781,43 @@ static long __video_do_ioctl(struct file *file,
>  	{
>  		struct v4l2_cropcap *p = arg;
>  
> -		/*FIXME: Should also show v4l2_fract pixelaspect */
> -		if (!ops->vidioc_cropcap)
> +		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
> +		if (ops->vidioc_cropcap) {
> +			ret = ops->vidioc_cropcap(file, fh, p);
> +		} else
> +		if (ops->vidioc_g_selection) {
> +			struct v4l2_selection s = { .type = p->type };
> +			struct v4l2_rect bounds;
> +
> +			/* obtaining bounds */
> +			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
> +				s.target = V4L2_SEL_COMPOSE_BOUNDS;
> +			else
> +				s.target = V4L2_SEL_CROP_BOUNDS;
> +			ret = ops->vidioc_g_selection(file, fh, &s);
> +			if (ret)
> +				break;
> +			bounds = s.r;
> +
> +			/* obtaining defrect */
> +			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
> +				s.target = V4L2_SEL_COMPOSE_DEFAULT;
> +			else
> +				s.target = V4L2_SEL_CROP_DEFAULT;
> +			ret = ops->vidioc_g_selection(file, fh, &s);
> +			if (ret)
> +				break;
> +
> +			/* storing results */
> +			p->bounds = bounds;
> +			p->defrect = s.r;
> +			p->pixelaspect.numerator = 1;
> +			p->pixelaspect.denominator = 1;
> +		} else {
>  			break;
> +		}
>  
> -		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
> -		ret = ops->vidioc_cropcap(file, fh, p);
> +		/*FIXME: Should also show v4l2_fract pixelaspect */

We really need a solution for this. I'm not happy that this hasn't been
resolved yet.

What about this: if ops->vidioc_g_selection is non-NULL, then fill in bounds
and defrect as above. But also call ops->vidioc_cropcap at the end if non-NULL,
so that the driver can fill in the pixelaspect.

So the code would look like this:

	if (ops->vidioc_g_selection) {
		fill in bounds and defrect and set pixelaspect to 1, 1
	}
	if (ops->vidioc_cropcap)
		ops->vidioc_cropcap();

If a driver supports g_selection, then cropcap only needs to fill in the
pixelaspect.

>  		if (!ret) {
>  			dbgrect(vfd, "bounds ", &p->bounds);
>  			dbgrect(vfd, "defrect ", &p->defrect);
> 

And let's show the pixelaspect here as well.

Does this sounds reasonable?

Regards,

	Hans

Re: [PATCH 3/5] [media] v4l: simulate old crop API using extended crop/compose API

[Tomasz Stanislawski]

Hi Hans,

On 09/27/2011 11:30 AM, Hans Verkuil wrote:
> On Friday, August 26, 2011 15:06:05 Tomasz Stanislawski wrote:
>> This patch allows new video drivers to work correctly with applications that
>> use the old-style crop API.  The old crop ioctl is simulated by using selection
>> callbacks.
>>
>> Signed-off-by: Tomasz Stanislawski<t.stanislaws@samsung.com>
>> Signed-off-by: Kyungmin Park<kyungmin.park@samsung.com>
>> ---
>>   drivers/media/video/v4l2-ioctl.c |   86 +++++++++++++++++++++++++++++++++----
>>   1 files changed, 76 insertions(+), 10 deletions(-)
>>
>> diff --git a/drivers/media/video/v4l2-ioctl.c b/drivers/media/video/v4l2-ioctl.c
>> index 6e02b45..543405b 100644
>> --- a/drivers/media/video/v4l2-ioctl.c
>> +++ b/drivers/media/video/v4l2-ioctl.c
>> @@ -1696,11 +1696,31 @@ static long __video_do_ioctl(struct file *file,
>>   	{
>>   		struct v4l2_crop *p = arg;
>>
>> -		if (!ops->vidioc_g_crop)
>> +		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
>> +
>> +		if (ops->vidioc_g_crop) {
>> +			ret = ops->vidioc_g_crop(file, fh, p);
>> +		} else
>> +		if (ops->vidioc_g_selection) {
>> +			/* simulate capture crop using selection api */
>> +			struct v4l2_selection s = {
>> +				.type = p->type,
>> +				.target = V4L2_SEL_CROP_ACTIVE,
>> +			};
>> +
>> +			/* crop means compose for output devices */
>> +			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
>> +				s.target = V4L2_SEL_COMPOSE_ACTIVE;
>> +
>> +			ret = ops->vidioc_g_selection(file, fh,&s);
>> +
>> +			/* copying results to old structure on success */
>> +			if (!ret)
>> +				p->c = s.r;
>> +		} else {
>>   			break;
>> +		}
>>
>> -		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
>> -		ret = ops->vidioc_g_crop(file, fh, p);
>>   		if (!ret)
>>   			dbgrect(vfd, "",&p->c);
>>   		break;
>> @@ -1709,11 +1729,26 @@ static long __video_do_ioctl(struct file *file,
>>   	{
>>   		struct v4l2_crop *p = arg;
>>
>> -		if (!ops->vidioc_s_crop)
>> -			break;
>>   		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
>>   		dbgrect(vfd, "",&p->c);
>> -		ret = ops->vidioc_s_crop(file, fh, p);
>> +
>> +		if (ops->vidioc_s_crop) {
>> +			ret = ops->vidioc_s_crop(file, fh, p);
>> +		} else
>> +		if (ops->vidioc_s_selection) {
>> +			/* simulate capture crop using selection api */
>> +			struct v4l2_selection s = {
>> +				.type = p->type,
>> +				.target = V4L2_SEL_CROP_ACTIVE,
>> +				.r = p->c,
>> +			};
>> +
>> +			/* crop means compose for output devices */
>> +			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
>> +				s.target = V4L2_SEL_COMPOSE_ACTIVE;
>> +
>> +			ret = ops->vidioc_s_selection(file, fh,&s);
>> +		}
>>   		break;
>>   	}
>>   	case VIDIOC_G_SELECTION:
>> @@ -1746,12 +1781,43 @@ static long __video_do_ioctl(struct file *file,
>>   	{
>>   		struct v4l2_cropcap *p = arg;
>>
>> -		/*FIXME: Should also show v4l2_fract pixelaspect */
>> -		if (!ops->vidioc_cropcap)
>> +		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
>> +		if (ops->vidioc_cropcap) {
>> +			ret = ops->vidioc_cropcap(file, fh, p);
>> +		} else
>> +		if (ops->vidioc_g_selection) {
>> +			struct v4l2_selection s = { .type = p->type };
>> +			struct v4l2_rect bounds;
>> +
>> +			/* obtaining bounds */
>> +			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
>> +				s.target = V4L2_SEL_COMPOSE_BOUNDS;
>> +			else
>> +				s.target = V4L2_SEL_CROP_BOUNDS;
>> +			ret = ops->vidioc_g_selection(file, fh,&s);
>> +			if (ret)
>> +				break;
>> +			bounds = s.r;
>> +
>> +			/* obtaining defrect */
>> +			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
>> +				s.target = V4L2_SEL_COMPOSE_DEFAULT;
>> +			else
>> +				s.target = V4L2_SEL_CROP_DEFAULT;
>> +			ret = ops->vidioc_g_selection(file, fh,&s);
>> +			if (ret)
>> +				break;
>> +
>> +			/* storing results */
>> +			p->bounds = bounds;
>> +			p->defrect = s.r;
>> +			p->pixelaspect.numerator = 1;
>> +			p->pixelaspect.denominator = 1;
>> +		} else {
>>   			break;
>> +		}
>>
>> -		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
>> -		ret = ops->vidioc_cropcap(file, fh, p);
>> +		/*FIXME: Should also show v4l2_fract pixelaspect */
>
> We really need a solution for this. I'm not happy that this hasn't been
> resolved yet.
>
> What about this: if ops->vidioc_g_selection is non-NULL, then fill in bounds
> and defrect as above. But also call ops->vidioc_cropcap at the end if non-NULL,
> so that the driver can fill in the pixelaspect.
>
> So the code would look like this:
>
> 	if (ops->vidioc_g_selection) {
> 		fill in bounds and defrect and set pixelaspect to 1, 1
> 	}
> 	if (ops->vidioc_cropcap)
> 		ops->vidioc_cropcap();
>
> If a driver supports g_selection, then cropcap only needs to fill in the
> pixelaspect.

If cropcap ioctl is missing there is no way to obtain pixelaspect from 
the driver, so 1/1 value is used. On the other hand, if cropcap is 
present there is no need to call g_selection calls to get defrect and 
bounds.

I think that there is a problem with pixel aspect field. Please refer to 
post:

http://thread.gmane.org/gmane.linux.drivers.video-input-infrastructure/38440/focus=38730

The idea was to move pixelaspect to v4l2_standard. The value would be 
selected from look-up table using standard returned by vidioc_g_std or 
using 1/1 is no analog TV is used. It should work well because majority 
of drivers use 1/1 value. Only some TV drivers behaves differently 
returning values depending on refresh rate that depends only on TV standard.

What do think about this idea?

Best regards,
Tomasz Stanislawski

>
>>   		if (!ret) {
>>   			dbgrect(vfd, "bounds ",&p->bounds);
>>   			dbgrect(vfd, "defrect ",&p->defrect);
>>
>
> And let's show the pixelaspect here as well.
>
> Does this sounds reasonable?
>
> Regards,
>
> 	Hans

[PATCH 4/5] [media] v4l: fix copying ioctl results on failure

[Tomasz Stanislawski]

This patch fix the handling of data passed to V4L2 ioctls.  The content of the
structures is not copied if the ioctl fails.  It blocks ability to obtain any
information about occurred error other then errno code. This patch fix this
issue.

Signed-off-by: Tomasz Stanislawski <t.stanislaws@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
---
 drivers/media/video/v4l2-ioctl.c |    2 --
 1 files changed, 0 insertions(+), 2 deletions(-)

diff --git a/drivers/media/video/v4l2-ioctl.c b/drivers/media/video/v4l2-ioctl.c
index 543405b..9f54114 100644
--- a/drivers/media/video/v4l2-ioctl.c
+++ b/drivers/media/video/v4l2-ioctl.c
@@ -2490,8 +2490,6 @@ video_usercopy(struct file *file, unsigned int cmd, unsigned long arg,
 			err = -EFAULT;
 		goto out_array_args;
 	}
-	if (err < 0)
-		goto out;
 
 out_array_args:
 	/*  Copy results into user buffer  */
-- 
1.7.6

Re: [PATCH 4/5] [media] v4l: fix copying ioctl results on failure

[Laurent Pinchart]

Hi Tomasz,

On Friday 26 August 2011 15:06:06 Tomasz Stanislawski wrote:
> This patch fix the handling of data passed to V4L2 ioctls.  The content of
> the structures is not copied if the ioctl fails.  It blocks ability to
> obtain any information about occurred error other then errno code. This
> patch fix this issue.

Does the V4L2 spec say anything on this topic ? We might have applications 
that rely on the ioctl argument structure not being touched when a failure 
occurs.

> Signed-off-by: Tomasz Stanislawski <t.stanislaws@samsung.com>
> Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
> ---
>  drivers/media/video/v4l2-ioctl.c |    2 --
>  1 files changed, 0 insertions(+), 2 deletions(-)
> 
> diff --git a/drivers/media/video/v4l2-ioctl.c
> b/drivers/media/video/v4l2-ioctl.c index 543405b..9f54114 100644
> --- a/drivers/media/video/v4l2-ioctl.c
> +++ b/drivers/media/video/v4l2-ioctl.c
> @@ -2490,8 +2490,6 @@ video_usercopy(struct file *file, unsigned int cmd,
> unsigned long arg, err = -EFAULT;
>  		goto out_array_args;
>  	}
> -	if (err < 0)
> -		goto out;
> 
>  out_array_args:
>  	/*  Copy results into user buffer  */

-- 
Regards,

Laurent Pinchart

Re: [PATCH 4/5] [media] v4l: fix copying ioctl results on failure

[Tomasz Stanislawski]

On 08/26/2011 05:09 PM, Laurent Pinchart wrote:
Hi Laurent,
> Hi Tomasz,
>
> On Friday 26 August 2011 15:06:06 Tomasz Stanislawski wrote:
>> This patch fix the handling of data passed to V4L2 ioctls.  The content of
>> the structures is not copied if the ioctl fails.  It blocks ability to
>> obtain any information about occurred error other then errno code. This
>> patch fix this issue.
> Does the V4L2 spec say anything on this topic ? We might have applications
> that rely on the ioctl argument structure not being touched when a failure
> occurs.
Ups.. I missed something. It looks that modifying ioctl content is 
illegal if ioctl fails. The spec says:
"When an ioctl that takes an output or read/write parameter fails, the 
parameter remains unmodified." (v4l2 ioctl section)
However, there is probably a bug already present in V4L2 framework.
There are some ioctls that takes a pointer to an array as a field in the 
argument struct.
The examples are all VIDIOC_*_EXT_CTRLS and VIDIOC_{QUERY/DQ/Q}_BUF family.
The content of such an auxiliary arays is copied even if ioctl fails. 
Please take a look to video_usercopy function in v4l2-ioctl.c. Therefore 
I think that the spec is already violated. What is your opinion about 
this problem?

Now back to selection case.
This patch was added as proposition of fix to VIDIOC_S_SELECTION, to 
return the best-hit rectangle if constraints could not be satisfied. The 
ioctl return -ERANGE in this case. Using those return values the 
application gets some feedback
on loosing constraints.

I could remove rectangle returning from the spec and s5p-tv code for now.

Regards,
Tomasz Stanislawski

>> Signed-off-by: Tomasz Stanislawski<t.stanislaws@samsung.com>
>> Signed-off-by: Kyungmin Park<kyungmin.park@samsung.com>
>> ---
>>   drivers/media/video/v4l2-ioctl.c |    2 --
>>   1 files changed, 0 insertions(+), 2 deletions(-)
>>
>> diff --git a/drivers/media/video/v4l2-ioctl.c
>> b/drivers/media/video/v4l2-ioctl.c index 543405b..9f54114 100644
>> --- a/drivers/media/video/v4l2-ioctl.c
>> +++ b/drivers/media/video/v4l2-ioctl.c
>> @@ -2490,8 +2490,6 @@ video_usercopy(struct file *file, unsigned int cmd,
>> unsigned long arg, err = -EFAULT;
>>   		goto out_array_args;
>>   	}
>> -	if (err<  0)
>> -		goto out;
>>
>>   out_array_args:
>>   	/*  Copy results into user buffer  */

Re: [PATCH 4/5] [media] v4l: fix copying ioctl results on failure

[Laurent Pinchart]

Hi Tomasz,

On Monday 29 August 2011 10:01:58 Tomasz Stanislawski wrote:
> On 08/26/2011 05:09 PM, Laurent Pinchart wrote:
> > On Friday 26 August 2011 15:06:06 Tomasz Stanislawski wrote:
> >> This patch fix the handling of data passed to V4L2 ioctls.  The content
> >> of the structures is not copied if the ioctl fails.  It blocks ability
> >> to obtain any information about occurred error other then errno code.
> >> This patch fix this issue.
> > 
> > Does the V4L2 spec say anything on this topic ? We might have
> > applications that rely on the ioctl argument structure not being touched
> > when a failure occurs.
> 
> Ups.. I missed something. It looks that modifying ioctl content is
> illegal if ioctl fails. The spec says:
> "When an ioctl that takes an output or read/write parameter fails, the
> parameter remains unmodified." (v4l2 ioctl section)
> However, there is probably a bug already present in V4L2 framework.
> There are some ioctls that takes a pointer to an array as a field in the
> argument struct.
> The examples are all VIDIOC_*_EXT_CTRLS and VIDIOC_{QUERY/DQ/Q}_BUF family.
> The content of such an auxiliary arays is copied even if ioctl fails.
> Please take a look to video_usercopy function in v4l2-ioctl.c. Therefore
> I think that the spec is already violated. What is your opinion about
> this problem?

I think it was a bad idea to state that a parameter remains unmodified when 
the ioctl fails in the first place. I'm fine with not following that for new 
ioctls, but applications might rely on it for existing ioctls.

> Now back to selection case.
> This patch was added as proposition of fix to VIDIOC_S_SELECTION, to
> return the best-hit rectangle if constraints could not be satisfied. The
> ioctl return -ERANGE in this case. Using those return values the
> application gets some feedback on loosing constraints.

Shouldn't that always be the case ? :-) VIDIOC_S_SELECTION should adjust the 
rectangle up or down depending on the constraints and always return the best 
match without any error.

> I could remove rectangle returning from the spec and s5p-tv code for now.

-- 
Regards,

Laurent Pinchart

Re: [PATCH 4/5] [media] v4l: fix copying ioctl results on failure

[Tomasz Stanislawski]

On 08/29/2011 10:56 AM, Laurent Pinchart wrote:
> Hi Tomasz,
>
> On Monday 29 August 2011 10:01:58 Tomasz Stanislawski wrote:
>> On 08/26/2011 05:09 PM, Laurent Pinchart wrote:
>>> On Friday 26 August 2011 15:06:06 Tomasz Stanislawski wrote:
>>>> This patch fix the handling of data passed to V4L2 ioctls.  The content
>>>> of the structures is not copied if the ioctl fails.  It blocks ability
>>>> to obtain any information about occurred error other then errno code.
>>>> This patch fix this issue.
>>> Does the V4L2 spec say anything on this topic ? We might have
>>> applications that rely on the ioctl argument structure not being touched
>>> when a failure occurs.
>> Ups.. I missed something. It looks that modifying ioctl content is
>> illegal if ioctl fails. The spec says:
>> "When an ioctl that takes an output or read/write parameter fails, the
>> parameter remains unmodified." (v4l2 ioctl section)
>> However, there is probably a bug already present in V4L2 framework.
>> There are some ioctls that takes a pointer to an array as a field in the
>> argument struct.
>> The examples are all VIDIOC_*_EXT_CTRLS and VIDIOC_{QUERY/DQ/Q}_BUF family.
>> The content of such an auxiliary arays is copied even if ioctl fails.
>> Please take a look to video_usercopy function in v4l2-ioctl.c. Therefore
>> I think that the spec is already violated. What is your opinion about
>> this problem?
> I think it was a bad idea to state that a parameter remains unmodified when
> the ioctl fails in the first place. I'm fine with not following that for new
> ioctls, but applications might rely on it for existing ioctls.
>
>> Now back to selection case.
>> This patch was added as proposition of fix to VIDIOC_S_SELECTION, to
>> return the best-hit rectangle if constraints could not be satisfied. The
>> ioctl return -ERANGE in this case. Using those return values the
>> application gets some feedback on loosing constraints.
> Shouldn't that always be the case ? :-) VIDIOC_S_SELECTION should adjust the
> rectangle up or down depending on the constraints and always return the best
> match without any error.
ok.. but what to do if constraints could not be satisfied?
The configuration should not be applied to the hardware in such a case,
because it is not what the application desired.
Therefore the ioctl must fail ... somehow.
If the ioctl always succeed then the constraint flags becomes actually 
the hints.
We may need TRY_SELECTION to test rectangles without applying it.

I thought that returning the best-hit rectangle by S_SELECTION might be 
useful because
it gives the application some feedback on what the driver would accept.


>> I could remove rectangle returning from the spec and s5p-tv code for now.

Re: [PATCH 4/5] [media] v4l: fix copying ioctl results on failure

[Laurent Pinchart]

Hi Tomasz,

On Monday 29 August 2011 13:55:31 Tomasz Stanislawski wrote:
> On 08/29/2011 10:56 AM, Laurent Pinchart wrote:
> > On Monday 29 August 2011 10:01:58 Tomasz Stanislawski wrote:
> >> On 08/26/2011 05:09 PM, Laurent Pinchart wrote:
> >>> On Friday 26 August 2011 15:06:06 Tomasz Stanislawski wrote:
> >>>> This patch fix the handling of data passed to V4L2 ioctls.  The
> >>>> content of the structures is not copied if the ioctl fails.  It
> >>>> blocks ability to obtain any information about occurred error other
> >>>> then errno code. This patch fix this issue.
> >>> 
> >>> Does the V4L2 spec say anything on this topic ? We might have
> >>> applications that rely on the ioctl argument structure not being
> >>> touched when a failure occurs.
> >> 
> >> Ups.. I missed something. It looks that modifying ioctl content is
> >> illegal if ioctl fails. The spec says:
> >> "When an ioctl that takes an output or read/write parameter fails, the
> >> parameter remains unmodified." (v4l2 ioctl section)
> >> However, there is probably a bug already present in V4L2 framework.
> >> There are some ioctls that takes a pointer to an array as a field in the
> >> argument struct.
> >> The examples are all VIDIOC_*_EXT_CTRLS and VIDIOC_{QUERY/DQ/Q}_BUF
> >> family. The content of such an auxiliary arays is copied even if ioctl
> >> fails. Please take a look to video_usercopy function in v4l2-ioctl.c.
> >> Therefore I think that the spec is already violated. What is your
> >> opinion about this problem?
> > 
> > I think it was a bad idea to state that a parameter remains unmodified
> > when the ioctl fails in the first place. I'm fine with not following
> > that for new ioctls, but applications might rely on it for existing
> > ioctls.
> > 
> >> Now back to selection case.
> >> This patch was added as proposition of fix to VIDIOC_S_SELECTION, to
> >> return the best-hit rectangle if constraints could not be satisfied. The
> >> ioctl return -ERANGE in this case. Using those return values the
> >> application gets some feedback on loosing constraints.
> > 
> > Shouldn't that always be the case ? :-) VIDIOC_S_SELECTION should adjust
> > the rectangle up or down depending on the constraints and always return
> > the best match without any error.
> 
> ok.. but what to do if constraints could not be satisfied?
> The configuration should not be applied to the hardware in such a case,
> because it is not what the application desired.
> Therefore the ioctl must fail ... somehow.
> If the ioctl always succeed then the constraint flags becomes actually
> the hints.

That's what currently happens with S_FMT. Is that behaviour too limited in 
your opinion ?

> We may need TRY_SELECTION to test rectangles without applying it.
> 
> I thought that returning the best-hit rectangle by S_SELECTION might be
> useful because it gives the application some feedback on what the driver
> would accept.

If we indeed need to fail with -ERANGE, I agree with you, the behaviour is 
useful. It would make sense in that case to only update the parameter for a 
specific set of ioctls. The V4L2 documentation will also need to be fixed.

-- 
Regards,

Laurent Pinchart

[PATCH 5/5] [media] v4l: s5p-tv: mixer: add support for selection API

[Tomasz Stanislawski]

This patch add support for V4L2 selection API to s5p-tv driver.  Moreover it
removes old API for cropping.  Old applications would still work because the
crop ioctls are emulated using the selection API.

Signed-off-by: Tomasz Stanislawski <t.stanislaws@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
---
 drivers/media/video/s5p-tv/mixer.h           |   14 +-
 drivers/media/video/s5p-tv/mixer_grp_layer.c |  157 ++++++++++---
 drivers/media/video/s5p-tv/mixer_video.c     |  329 ++++++++++++++++---------
 drivers/media/video/s5p-tv/mixer_vp_layer.c  |  108 ++++++---
 4 files changed, 413 insertions(+), 195 deletions(-)

diff --git a/drivers/media/video/s5p-tv/mixer.h b/drivers/media/video/s5p-tv/mixer.h
index e224224..dc71e59 100644
--- a/drivers/media/video/s5p-tv/mixer.h
+++ b/drivers/media/video/s5p-tv/mixer.h
@@ -86,6 +86,17 @@ struct mxr_crop {
 	unsigned int field;
 };
 
+/** stages of geometry operations */
+enum mxr_geometry_stage {
+	MXR_GEOMETRY_SINK,
+	MXR_GEOMETRY_COMPOSE,
+	MXR_GEOMETRY_CROP,
+	MXR_GEOMETRY_SOURCE,
+};
+
+/* flag indicating that offset should be 0 */
+#define MXR_NO_OFFSET	0x80000000
+
 /** description of transformation from source to destination image */
 struct mxr_geometry {
 	/** cropping for source image */
@@ -135,7 +146,8 @@ struct mxr_layer_ops {
 	/** streaming stop/start */
 	void (*stream_set)(struct mxr_layer *, int);
 	/** adjusting geometry */
-	void (*fix_geometry)(struct mxr_layer *);
+	void (*fix_geometry)(struct mxr_layer *,
+		enum mxr_geometry_stage, unsigned long);
 };
 
 /** layer instance, a single window and content displayed on output */
diff --git a/drivers/media/video/s5p-tv/mixer_grp_layer.c b/drivers/media/video/s5p-tv/mixer_grp_layer.c
index 58f0ba4..882ad7d 100644
--- a/drivers/media/video/s5p-tv/mixer_grp_layer.c
+++ b/drivers/media/video/s5p-tv/mixer_grp_layer.c
@@ -101,47 +101,132 @@ static void mxr_graph_format_set(struct mxr_layer *layer)
 		layer->fmt, &layer->geo);
 }
 
-static void mxr_graph_fix_geometry(struct mxr_layer *layer)
+static inline unsigned int closest(unsigned int x, unsigned int a,
+	unsigned int b, unsigned long flags)
+{
+	unsigned int mid = (a + b) / 2;
+
+	/* choosing closest value with constraints according to table:
+	 * -------------+-----+-----+-----+-------+
+	 * flags	|  0  |  LE |  GE | LE|GE |
+	 * -------------+-----+-----+-----+-------+
+	 * x <= a	|  a  |  a  |  a  |   a   |
+	 * a < x <= mid	|  a  |  a  |  b  |   a   |
+	 * mid < x < b	|  b  |  a  |  b  |   b   |
+	 * b <= x	|  b  |  b  |  b  |   b   |
+	 * -------------+-----+-----+-----+-------+
+	 */
+
+	/* remove all non-constraint flags */
+	flags &= V4L2_SEL_SIZE_LE | V4L2_SEL_SIZE_GE;
+
+	if (x <= a)
+		return  a;
+	if (x >= b)
+		return b;
+	if (flags == V4L2_SEL_SIZE_LE)
+		return a;
+	if (flags == V4L2_SEL_SIZE_GE)
+		return b;
+	if (x <= mid)
+		return a;
+	return b;
+}
+
+static inline unsigned int do_center(unsigned int center,
+	unsigned int size, unsigned int upper, unsigned int flags)
+{
+	unsigned int lower;
+
+	if (flags & MXR_NO_OFFSET)
+		return 0;
+
+	lower = center - min(center, size / 2);
+	return min(lower, upper - size);
+}
+
+static void mxr_graph_fix_geometry(struct mxr_layer * layer,
+	enum mxr_geometry_stage stage, unsigned long flags)
 {
 	struct mxr_geometry *geo = &layer->geo;
+	struct mxr_crop *src = &geo->src;
+	struct mxr_crop *dst = &geo->dst;
+	unsigned int x_center, y_center;
 
-	/* limit to boundary size */
-	geo->src.full_width = clamp_val(geo->src.full_width, 1, 32767);
-	geo->src.full_height = clamp_val(geo->src.full_height, 1, 2047);
-	geo->src.width = clamp_val(geo->src.width, 1, geo->src.full_width);
-	geo->src.width = min(geo->src.width, 2047U);
-	/* not possible to crop of Y axis */
-	geo->src.y_offset = min(geo->src.y_offset, geo->src.full_height - 1);
-	geo->src.height = geo->src.full_height - geo->src.y_offset;
-	/* limitting offset */
-	geo->src.x_offset = min(geo->src.x_offset,
-		geo->src.full_width - geo->src.width);
-
-	/* setting position in output */
-	geo->dst.width = min(geo->dst.width, geo->dst.full_width);
-	geo->dst.height = min(geo->dst.height, geo->dst.full_height);
-
-	/* Mixer supports only 1x and 2x scaling */
-	if (geo->dst.width >= 2 * geo->src.width) {
-		geo->x_ratio = 1;
-		geo->dst.width = 2 * geo->src.width;
-	} else {
-		geo->x_ratio = 0;
-		geo->dst.width = geo->src.width;
-	}
+	switch (stage) {
 
-	if (geo->dst.height >= 2 * geo->src.height) {
-		geo->y_ratio = 1;
-		geo->dst.height = 2 * geo->src.height;
-	} else {
-		geo->y_ratio = 0;
-		geo->dst.height = geo->src.height;
-	}
+	case MXR_GEOMETRY_SINK: /* nothing to be fixed here */
+		flags = 0;
+		/* fall through */
+
+	case MXR_GEOMETRY_COMPOSE:
+		/* remember center of the area */
+		x_center = dst->x_offset + dst->width / 2;
+		y_center = dst->y_offset + dst->height / 2;
+		/* round up/down to 2 multiple depending on flags */
+		if (flags & V4L2_SEL_SIZE_LE) {
+			dst->width = round_down(dst->width, 2);
+			dst->height = round_down(dst->height, 2);
+		} else {
+			dst->width = round_up(dst->width, 2);
+			dst->height = round_up(dst->height, 2);
+		}
+		/* assure that compose rect is inside display area */
+		dst->width = min(dst->width, dst->full_width);
+		dst->height = min(dst->height, dst->full_height);
+
+		/* ensure that compose is reachable using 2x scaling */
+		dst->width = min(dst->width, 2 * src->full_width);
+		dst->height = min(dst->height, 2 * src->full_height);
+
+		/* setup offsets */
+		dst->x_offset = do_center(x_center, dst->width,
+			dst->full_width, flags);
+		dst->y_offset = do_center(y_center, dst->height,
+			dst->full_height, flags);
+		flags = 0;
+		/* fall through */
 
-	geo->dst.x_offset = min(geo->dst.x_offset,
-		geo->dst.full_width - geo->dst.width);
-	geo->dst.y_offset = min(geo->dst.y_offset,
-		geo->dst.full_height - geo->dst.height);
+	case MXR_GEOMETRY_CROP:
+		/* remember center of the area */
+		x_center = src->x_offset + src->width / 2;
+		y_center = src->y_offset + src->height / 2;
+		/* ensure that cropping area lies inside the buffer */
+		if (src->full_width < dst->width)
+			src->width = dst->width / 2;
+		else
+			src->width = closest(src->width, dst->width / 2,
+				dst->width, flags);
+
+		if (src->width == dst->width)
+			geo->x_ratio = 0;
+		else
+			geo->x_ratio = 1;
+
+		if (src->full_height < dst->height)
+			src->height = dst->height / 2;
+		else
+			src->height = closest(src->height, dst->height / 2,
+				dst->height, flags);
+
+		if (src->height == dst->height)
+			geo->y_ratio = 0;
+		else
+			geo->y_ratio = 1;
+
+		/* setup offsets */
+		src->x_offset = do_center(x_center, src->width,
+			src->full_width, flags);
+		src->y_offset = do_center(y_center, src->height,
+			src->full_height, flags);
+		flags = 0;
+		/* fall through */
+	case MXR_GEOMETRY_SOURCE:
+		src->full_width = clamp_val(src->full_width,
+			src->width + src->x_offset, 32767);
+		src->full_height = clamp_val(src->full_height,
+			src->height + src->y_offset, 2047);
+	};
 }
 
 /* PUBLIC API */
diff --git a/drivers/media/video/s5p-tv/mixer_video.c b/drivers/media/video/s5p-tv/mixer_video.c
index 43ac22f..f01e7d1 100644
--- a/drivers/media/video/s5p-tv/mixer_video.c
+++ b/drivers/media/video/s5p-tv/mixer_video.c
@@ -169,18 +169,22 @@ static int mxr_querycap(struct file *file, void *priv,
 	return 0;
 }
 
-/* Geometry handling */
-static void mxr_layer_geo_fix(struct mxr_layer *layer)
+static void mxr_geometry_dump(struct mxr_device *mdev, struct mxr_geometry *geo)
 {
-	struct mxr_device *mdev = layer->mdev;
-	struct v4l2_mbus_framefmt mbus_fmt;
-
-	/* TODO: add some dirty flag to avoid unnecessary adjustments */
-	mxr_get_mbus_fmt(mdev, &mbus_fmt);
-	layer->geo.dst.full_width = mbus_fmt.width;
-	layer->geo.dst.full_height = mbus_fmt.height;
-	layer->geo.dst.field = mbus_fmt.field;
-	layer->ops.fix_geometry(layer);
+	mxr_dbg(mdev, "src.full_size = (%u, %u)\n",
+		geo->src.full_width, geo->src.full_height);
+	mxr_dbg(mdev, "src.size = (%u, %u)\n",
+		geo->src.width, geo->src.height);
+	mxr_dbg(mdev, "src.offset = (%u, %u)\n",
+		geo->src.x_offset, geo->src.y_offset);
+	mxr_dbg(mdev, "dst.full_size = (%u, %u)\n",
+		geo->dst.full_width, geo->dst.full_height);
+	mxr_dbg(mdev, "dst.size = (%u, %u)\n",
+		geo->dst.width, geo->dst.height);
+	mxr_dbg(mdev, "dst.offset = (%u, %u)\n",
+		geo->dst.x_offset, geo->dst.y_offset);
+	mxr_dbg(mdev, "ratio = (%u, %u)\n",
+		geo->x_ratio, geo->y_ratio);
 }
 
 static void mxr_layer_default_geo(struct mxr_layer *layer)
@@ -203,27 +207,29 @@ static void mxr_layer_default_geo(struct mxr_layer *layer)
 	layer->geo.src.width = layer->geo.src.full_width;
 	layer->geo.src.height = layer->geo.src.full_height;
 
-	layer->ops.fix_geometry(layer);
+	mxr_geometry_dump(mdev, &layer->geo);
+	layer->ops.fix_geometry(layer, MXR_GEOMETRY_SINK, 0);
+	mxr_geometry_dump(mdev, &layer->geo);
 }
 
-static void mxr_geometry_dump(struct mxr_device *mdev, struct mxr_geometry *geo)
+static void mxr_layer_update_output(struct mxr_layer *layer)
 {
-	mxr_dbg(mdev, "src.full_size = (%u, %u)\n",
-		geo->src.full_width, geo->src.full_height);
-	mxr_dbg(mdev, "src.size = (%u, %u)\n",
-		geo->src.width, geo->src.height);
-	mxr_dbg(mdev, "src.offset = (%u, %u)\n",
-		geo->src.x_offset, geo->src.y_offset);
-	mxr_dbg(mdev, "dst.full_size = (%u, %u)\n",
-		geo->dst.full_width, geo->dst.full_height);
-	mxr_dbg(mdev, "dst.size = (%u, %u)\n",
-		geo->dst.width, geo->dst.height);
-	mxr_dbg(mdev, "dst.offset = (%u, %u)\n",
-		geo->dst.x_offset, geo->dst.y_offset);
-	mxr_dbg(mdev, "ratio = (%u, %u)\n",
-		geo->x_ratio, geo->y_ratio);
-}
+	struct mxr_device *mdev = layer->mdev;
+	struct v4l2_mbus_framefmt mbus_fmt;
+
+	mxr_get_mbus_fmt(mdev, &mbus_fmt);
+	/* checking if update is needed */
+	if (layer->geo.dst.full_width == mbus_fmt.width &&
+		layer->geo.dst.full_height == mbus_fmt.width)
+		return;
 
+	layer->geo.dst.full_width = mbus_fmt.width;
+	layer->geo.dst.full_height = mbus_fmt.height;
+	layer->geo.dst.field = mbus_fmt.field;
+	layer->ops.fix_geometry(layer, MXR_GEOMETRY_SINK, 0);
+
+	mxr_geometry_dump(mdev, &layer->geo);
+}
 
 static const struct mxr_format *find_format_by_fourcc(
 	struct mxr_layer *layer, unsigned long fourcc);
@@ -248,37 +254,6 @@ static int mxr_enum_fmt(struct file *file, void  *priv,
 	return 0;
 }
 
-static int mxr_s_fmt(struct file *file, void *priv,
-	struct v4l2_format *f)
-{
-	struct mxr_layer *layer = video_drvdata(file);
-	const struct mxr_format *fmt;
-	struct v4l2_pix_format_mplane *pix;
-	struct mxr_device *mdev = layer->mdev;
-	struct mxr_geometry *geo = &layer->geo;
-
-	mxr_dbg(mdev, "%s:%d\n", __func__, __LINE__);
-
-	pix = &f->fmt.pix_mp;
-	fmt = find_format_by_fourcc(layer, pix->pixelformat);
-	if (fmt == NULL) {
-		mxr_warn(mdev, "not recognized fourcc: %08x\n",
-			pix->pixelformat);
-		return -EINVAL;
-	}
-	layer->fmt = fmt;
-	geo->src.full_width = pix->width;
-	geo->src.width = pix->width;
-	geo->src.full_height = pix->height;
-	geo->src.height = pix->height;
-	/* assure consistency of geometry */
-	mxr_layer_geo_fix(layer);
-	mxr_dbg(mdev, "width=%u height=%u span=%u\n",
-		geo->src.width, geo->src.height, geo->src.full_width);
-
-	return 0;
-}
-
 static unsigned int divup(unsigned int divident, unsigned int divisor)
 {
 	return (divident + divisor - 1) / divisor;
@@ -298,6 +273,10 @@ static void mxr_mplane_fill(struct v4l2_plane_pix_format *planes,
 {
 	int i;
 
+	/* checking if nothing to fill */
+	if (!planes)
+		return;
+
 	memset(planes, 0, sizeof(*planes) * fmt->num_subframes);
 	for (i = 0; i < fmt->num_planes; ++i) {
 		struct v4l2_plane_pix_format *plane = planes
@@ -331,73 +310,183 @@ static int mxr_g_fmt(struct file *file, void *priv,
 	return 0;
 }
 
-static inline struct mxr_crop *choose_crop_by_type(struct mxr_geometry *geo,
-	enum v4l2_buf_type type)
-{
-	switch (type) {
-	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
-	case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
-		return &geo->dst;
-	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
-		return &geo->src;
-	default:
-		return NULL;
-	}
-}
-
-static int mxr_g_crop(struct file *file, void *fh, struct v4l2_crop *a)
+static int mxr_s_fmt(struct file *file, void *priv,
+	struct v4l2_format *f)
 {
 	struct mxr_layer *layer = video_drvdata(file);
-	struct mxr_crop *crop;
+	const struct mxr_format *fmt;
+	struct v4l2_pix_format_mplane *pix;
+	struct mxr_device *mdev = layer->mdev;
+	struct mxr_geometry *geo = &layer->geo;
 
-	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
-	crop = choose_crop_by_type(&layer->geo, a->type);
-	if (crop == NULL)
+	mxr_dbg(mdev, "%s:%d\n", __func__, __LINE__);
+
+	pix = &f->fmt.pix_mp;
+	fmt = find_format_by_fourcc(layer, pix->pixelformat);
+	if (fmt == NULL) {
+		mxr_warn(mdev, "not recognized fourcc: %08x\n",
+			pix->pixelformat);
 		return -EINVAL;
-	mxr_layer_geo_fix(layer);
-	a->c.left = crop->x_offset;
-	a->c.top = crop->y_offset;
-	a->c.width = crop->width;
-	a->c.height = crop->height;
+	}
+	layer->fmt = fmt;
+	/* set source size to highest accepted value */
+	geo->src.full_width = max(geo->dst.full_width, pix->width);
+	geo->src.full_height = max(geo->dst.full_height, pix->height);
+	layer->ops.fix_geometry(layer, MXR_GEOMETRY_SOURCE, 0);
+	mxr_geometry_dump(mdev, &layer->geo);
+	/* set cropping to total visible screen */
+	geo->src.width = pix->width;
+	geo->src.height = pix->height;
+	geo->src.x_offset = 0;
+	geo->src.y_offset = 0;
+	/* assure consistency of geometry */
+	layer->ops.fix_geometry(layer, MXR_GEOMETRY_CROP, MXR_NO_OFFSET);
+	mxr_geometry_dump(mdev, &layer->geo);
+	/* set full size to lowest possible value */
+	geo->src.full_width = 0;
+	geo->src.full_height = 0;
+	layer->ops.fix_geometry(layer, MXR_GEOMETRY_SOURCE, 0);
+	mxr_geometry_dump(mdev, &layer->geo);
+
+	/* returning results */
+	mxr_g_fmt(file, priv, f);
+
 	return 0;
 }
 
-static int mxr_s_crop(struct file *file, void *fh, struct v4l2_crop *a)
+static int mxr_g_selection(struct file *file, void *fh,
+	struct v4l2_selection *s)
 {
 	struct mxr_layer *layer = video_drvdata(file);
-	struct mxr_crop *crop;
+	struct mxr_geometry *geo = &layer->geo;
 
 	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
-	crop = choose_crop_by_type(&layer->geo, a->type);
-	if (crop == NULL)
+
+	if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
 		return -EINVAL;
-	crop->x_offset = a->c.left;
-	crop->y_offset = a->c.top;
-	crop->width = a->c.width;
-	crop->height = a->c.height;
-	mxr_layer_geo_fix(layer);
+
+	switch (s->target) {
+	case V4L2_SEL_CROP_ACTIVE:
+		s->r.left = geo->src.x_offset;
+		s->r.top = geo->src.y_offset;
+		s->r.width = geo->src.width;
+		s->r.height = geo->src.height;
+		break;
+	case V4L2_SEL_CROP_DEFAULT:
+	case V4L2_SEL_CROP_BOUNDS:
+		s->r.left = 0;
+		s->r.top = 0;
+		s->r.width = geo->src.full_width;
+		s->r.height = geo->src.full_height;
+		break;
+	case V4L2_SEL_COMPOSE_ACTIVE:
+	case V4L2_SEL_COMPOSE_PADDED:
+		s->r.left = geo->dst.x_offset;
+		s->r.top = geo->dst.y_offset;
+		s->r.width = geo->dst.width;
+		s->r.height = geo->dst.height;
+		break;
+	case V4L2_SEL_COMPOSE_DEFAULT:
+	case V4L2_SEL_COMPOSE_BOUNDS:
+		s->r.left = 0;
+		s->r.top = 0;
+		s->r.width = geo->dst.full_width;
+		s->r.height = geo->dst.full_height;
+		break;
+	default:
+		return -EINVAL;
+	}
+
 	return 0;
 }
 
-static int mxr_cropcap(struct file *file, void *fh, struct v4l2_cropcap *a)
+static int mxr_is_rect_inside(struct v4l2_rect *a, struct v4l2_rect *b)
+{
+	if (a->left < b->left)
+		return 0;
+	if (a->top < b->top)
+		return 0;
+	if (a->left + a->width > b->left + b->width)
+		return 0;
+	if (a->top + a->height > b->top + b->height)
+		return 0;
+	return 1;
+}
+
+static int mxr_s_selection(struct file *file, void *fh,
+	struct v4l2_selection *s)
 {
 	struct mxr_layer *layer = video_drvdata(file);
-	struct mxr_crop *crop;
+	struct mxr_geometry *geo = &layer->geo;
+	struct mxr_crop *target;
+	enum mxr_geometry_stage stage;
+	struct mxr_geometry tmp;
+	struct v4l2_rect req;
 
 	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
-	crop = choose_crop_by_type(&layer->geo, a->type);
-	if (crop == NULL)
+
+	if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
 		return -EINVAL;
-	mxr_layer_geo_fix(layer);
-	a->bounds.left = 0;
-	a->bounds.top = 0;
-	a->bounds.width = crop->full_width;
-	a->bounds.top = crop->full_height;
-	a->defrect = a->bounds;
-	/* setting pixel aspect to 1/1 */
-	a->pixelaspect.numerator = 1;
-	a->pixelaspect.denominator = 1;
+	switch (s->target) {
+	/* ignore read-only targets */
+	case V4L2_SEL_CROP_DEFAULT:
+	case V4L2_SEL_CROP_BOUNDS:
+		s->r.left = 0;
+		s->r.top = 0;
+		s->r.width = geo->src.full_width;
+		s->r.height = geo->src.full_height;
+		return 0;
+
+	case V4L2_SEL_COMPOSE_DEFAULT:
+	case V4L2_SEL_COMPOSE_BOUNDS:
+		s->r.left = 0;
+		s->r.top = 0;
+		s->r.width = geo->dst.full_width;
+		s->r.height = geo->dst.full_height;
+		return 0;
+
+	case V4L2_SEL_CROP_ACTIVE:
+		target = &geo->src;
+		stage = MXR_GEOMETRY_CROP;
+		break;
+	case V4L2_SEL_COMPOSE_ACTIVE:
+	case V4L2_SEL_COMPOSE_PADDED:
+		target = &geo->dst;
+		stage = MXR_GEOMETRY_COMPOSE;
+		break;
+	default:
+		return -EINVAL;
+	}
+	/* backup geometry if setup fails */
+	memcpy(&tmp, geo, sizeof tmp);
+	/* apply change and update geometry */
+	target->x_offset = s->r.left;
+	target->y_offset = s->r.top;
+	target->width = s->r.width;
+	target->height = s->r.height;
+	layer->ops.fix_geometry(layer, stage, s->flags);
+
+	mxr_geometry_dump(layer->mdev, &layer->geo);
+
+	/* backup requested rectangle */
+	req = s->r;
+	/* return results to the user */
+	s->r.left = target->x_offset;
+	s->r.top = target->y_offset;
+	s->r.width = target->width;
+	s->r.height = target->height;
+	/* checking if the rectangle satisfies constraints */ 
+	if ((s->flags & V4L2_SEL_SIZE_LE) && !mxr_is_rect_inside(&s->r, &req))
+		goto fail;
+	if ((s->flags & V4L2_SEL_SIZE_GE) && !mxr_is_rect_inside(&req, &s->r))
+		goto fail;
+
+
 	return 0;
+fail:
+	/* restore old geometry */
+	memcpy(geo, &tmp, sizeof tmp);
+	return -ERANGE;
 }
 
 static int mxr_enum_dv_presets(struct file *file, void *fh,
@@ -437,6 +526,8 @@ static int mxr_s_dv_preset(struct file *file, void *fh,
 
 	mutex_unlock(&mdev->mutex);
 
+	mxr_layer_update_output(layer);
+
 	/* any failure should return EINVAL according to V4L2 doc */
 	return ret ? -EINVAL : 0;
 }
@@ -477,6 +568,8 @@ static int mxr_s_std(struct file *file, void *fh, v4l2_std_id *norm)
 
 	mutex_unlock(&mdev->mutex);
 
+	mxr_layer_update_output(layer);
+
 	return ret ? -EINVAL : 0;
 }
 
@@ -525,25 +618,27 @@ static int mxr_s_output(struct file *file, void *fh, unsigned int i)
 	struct video_device *vfd = video_devdata(file);
 	struct mxr_layer *layer = video_drvdata(file);
 	struct mxr_device *mdev = layer->mdev;
-	int ret = 0;
 
 	if (i >= mdev->output_cnt || mdev->output[i] == NULL)
 		return -EINVAL;
 
 	mutex_lock(&mdev->mutex);
 	if (mdev->n_output > 0) {
-		ret = -EBUSY;
-		goto done;
+		mutex_unlock(&mdev->mutex);
+		return -EBUSY;
 	}
 	mdev->current_output = i;
 	vfd->tvnorms = 0;
 	v4l2_subdev_call(to_outsd(mdev), video, g_tvnorms_output,
 		&vfd->tvnorms);
+	mutex_unlock(&mdev->mutex);
+
+	/* update layers geometry */
+	mxr_layer_update_output(layer);
+
 	mxr_dbg(mdev, "tvnorms = %08llx\n", vfd->tvnorms);
 
-done:
-	mutex_unlock(&mdev->mutex);
-	return ret;
+	return 0;
 }
 
 static int mxr_g_output(struct file *file, void *fh, unsigned int *p)
@@ -632,10 +727,9 @@ static const struct v4l2_ioctl_ops mxr_ioctl_ops = {
 	.vidioc_enum_output = mxr_enum_output,
 	.vidioc_s_output = mxr_s_output,
 	.vidioc_g_output = mxr_g_output,
-	/* Crop ioctls */
-	.vidioc_g_crop = mxr_g_crop,
-	.vidioc_s_crop = mxr_s_crop,
-	.vidioc_cropcap = mxr_cropcap,
+	/* selection ioctls */
+	.vidioc_g_selection = mxr_g_selection,
+	.vidioc_s_selection = mxr_s_selection,
 };
 
 static int mxr_video_open(struct file *file)
@@ -807,10 +901,7 @@ static int start_streaming(struct vb2_queue *vq)
 	/* block any changes in output configuration */
 	mxr_output_get(mdev);
 
-	/* update layers geometry */
-	mxr_layer_geo_fix(layer);
-	mxr_geometry_dump(mdev, &layer->geo);
-
+	mxr_layer_update_output(layer);
 	layer->ops.format_set(layer);
 	/* enabling layer in hardware */
 	spin_lock_irqsave(&layer->enq_slock, flags);
diff --git a/drivers/media/video/s5p-tv/mixer_vp_layer.c b/drivers/media/video/s5p-tv/mixer_vp_layer.c
index 6950ed8..21c8d87 100644
--- a/drivers/media/video/s5p-tv/mixer_vp_layer.c
+++ b/drivers/media/video/s5p-tv/mixer_vp_layer.c
@@ -127,47 +127,77 @@ static void mxr_vp_format_set(struct mxr_layer *layer)
 	mxr_reg_vp_format(layer->mdev, layer->fmt, &layer->geo);
 }
 
-static void mxr_vp_fix_geometry(struct mxr_layer *layer)
+static inline unsigned int do_center(unsigned int center,
+	unsigned int size, unsigned int upper, unsigned int flags)
 {
-	struct mxr_geometry *geo = &layer->geo;
+	unsigned int lower;
+
+	if (flags & MXR_NO_OFFSET)
+		return 0;
+
+	lower = center - min(center, size / 2);
+	return min(lower, upper - size);
+}
 
-	/* align horizontal size to 8 pixels */
-	geo->src.full_width = ALIGN(geo->src.full_width, 8);
-	/* limit to boundary size */
-	geo->src.full_width = clamp_val(geo->src.full_width, 8, 8192);
-	geo->src.full_height = clamp_val(geo->src.full_height, 1, 8192);
-	geo->src.width = clamp_val(geo->src.width, 32, geo->src.full_width);
-	geo->src.width = min(geo->src.width, 2047U);
-	geo->src.height = clamp_val(geo->src.height, 4, geo->src.full_height);
-	geo->src.height = min(geo->src.height, 2047U);
-
-	/* setting size of output window */
-	geo->dst.width = clamp_val(geo->dst.width, 8, geo->dst.full_width);
-	geo->dst.height = clamp_val(geo->dst.height, 1, geo->dst.full_height);
-
-	/* ensure that scaling is in range 1/4x to 16x */
-	if (geo->src.width >= 4 * geo->dst.width)
-		geo->src.width = 4 * geo->dst.width;
-	if (geo->dst.width >= 16 * geo->src.width)
-		geo->dst.width = 16 * geo->src.width;
-	if (geo->src.height >= 4 * geo->dst.height)
-		geo->src.height = 4 * geo->dst.height;
-	if (geo->dst.height >= 16 * geo->src.height)
-		geo->dst.height = 16 * geo->src.height;
-
-	/* setting scaling ratio */
-	geo->x_ratio = (geo->src.width << 16) / geo->dst.width;
-	geo->y_ratio = (geo->src.height << 16) / geo->dst.height;
-
-	/* adjust offsets */
-	geo->src.x_offset = min(geo->src.x_offset,
-		geo->src.full_width - geo->src.width);
-	geo->src.y_offset = min(geo->src.y_offset,
-		geo->src.full_height - geo->src.height);
-	geo->dst.x_offset = min(geo->dst.x_offset,
-		geo->dst.full_width - geo->dst.width);
-	geo->dst.y_offset = min(geo->dst.y_offset,
-		geo->dst.full_height - geo->dst.height);
+static void mxr_vp_fix_geometry(struct mxr_layer * layer,
+	enum mxr_geometry_stage stage, unsigned long flags)
+{
+	struct mxr_geometry *geo = &layer->geo;
+	struct mxr_crop *src = &geo->src;
+	struct mxr_crop *dst = &geo->dst;
+	unsigned long x_center, y_center;
+
+	switch (stage) {
+
+	case MXR_GEOMETRY_SINK: /* nothing to be fixed here */
+	case MXR_GEOMETRY_COMPOSE:
+		/* remember center of the area */
+		x_center = dst->x_offset + dst->width / 2;
+		y_center = dst->y_offset + dst->height / 2;
+
+		/* ensure that compose is reachable using 16x scaling */
+		dst->width = clamp(dst->width, 8U, 16 * src->full_width);
+		dst->height = clamp(dst->height, 1U, 16 * src->full_height);
+
+		/* setup offsets */
+		dst->x_offset = do_center(x_center, dst->width,
+			dst->full_width, flags);
+		dst->y_offset = do_center(y_center, dst->height,
+			dst->full_height, flags);
+		flags = 0; /* remove possible MXR_NO_OFFSET flag */
+		/* fall through */
+	case MXR_GEOMETRY_CROP:
+		/* remember center of the area */
+		x_center = src->x_offset + src->width / 2;
+		y_center = src->y_offset + src->height / 2;
+
+		/* ensure scaling is between 0.25x .. 16x */
+		src->width = clamp(src->width, round_up(dst->width, 4),
+			dst->width * 16);
+		src->height = clamp(src->height, round_up(dst->height, 4),
+			dst->height * 16);
+
+		/* hardware limits */
+		src->width = clamp(src->width, 32U, 2047U);
+		src->height = clamp(src->height, 4U, 2047U);
+
+		/* setup offsets */
+		src->x_offset = do_center(x_center, src->width,
+			src->full_width, flags);
+		src->y_offset = do_center(y_center, src->height,
+			src->full_height, flags);
+
+		/* setting scaling ratio */
+		geo->x_ratio = (src->width << 16) / dst->width;
+		geo->y_ratio = (src->height << 16) / dst->height;
+		/* fall through */
+
+	case MXR_GEOMETRY_SOURCE:
+		src->full_width = clamp(src->full_width,
+			ALIGN(src->width + src->x_offset, 8), 8192U);
+		src->full_height = clamp(src->full_height,
+			src->height + src->y_offset, 8192U);
+	};
 }
 
 /* PUBLIC API */
-- 
1.7.6