[PATCHv5 0/4] v4l: extended crop/compose api

[PATCHv5 0/4] v4l: extended crop/compose api

[Tomasz Stanislawski]

Hello Everyone,

This is the fifth version of extended crop/compose RFC. It was updated after
Laurent's review. The patch-set introduces new ioctls to V4L2 API for
configuration of selection rectangles like crop and compose areas. The last
patch adds selection support for s5p-tv driver. Please refer to discussion
below for more details about api development.

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

Changelog:

v4:
- removed returning best-hit rectangle on failure of VIDIOC_S_SELECTION
- fixed typos and naming
- removed enums from structures
- code style cleanup

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 (4):
  v4l: add support for selection api
  v4l: add documentation for selection API
  v4l: emulate old crop API using extended crop/compose API
  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       |  281 ++
 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           |  339 ++-
 drivers/media/video/s5p-tv/mixer_vp_layer.c        |  108 +-
 drivers/media/video/v4l2-compat-ioctl32.c          |    2 +
 drivers/media/video/v4l2-ioctl.c                   |  114 +-
 include/linux/videodev2.h                          |   46 +
 include/media/v4l2-ioctl.h                         |    4 +
 14 files changed, 4210 insertions(+), 209 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/4] 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                 |   46 +++++++++++++++++++++++++++++
 include/media/v4l2-ioctl.h                |    4 ++
 4 files changed, 80 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..b7471fe 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -738,6 +738,48 @@ 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
+
+/* Selection targets */
+
+/* current cropping area */
+#define V4L2_SEL_CROP_ACTIVE		0
+/* default cropping area */
+#define V4L2_SEL_CROP_DEFAULT		1
+/* cropping bounds */
+#define V4L2_SEL_CROP_BOUNDS		2
+/* current composing area */
+#define V4L2_SEL_COMPOSE_ACTIVE		256
+/* default composing area */
+#define V4L2_SEL_COMPOSE_DEFAULT	257
+/* composing bounds */
+#define V4L2_SEL_COMPOSE_BOUNDS		258
+/* current composing area plus all padding pixels */
+#define V4L2_SEL_COMPOSE_PADDED		259
+
+/**
+ * struct v4l2_selection - selection info
+ * @type:	buffer type (do not use *_MPLANE types)
+ * @target:	selection target, used to choose one of possible rectangles
+ * @flags:	constraints flags
+ * @r:		coordinates of selection window
+ * @reserved:	for future use, rounds structure size to 64 bytes, set to zero
+ *
+ * Hardware may use multiple helper window to process a video stream.
+ * The structure is used to exchange this selection areas between
+ * an application and a driver.
+ */
+struct v4l2_selection {
+	__u32			type;
+	__u32			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 +2224,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..9dd6e18 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 *s);
+	int (*vidioc_s_selection)      (struct file *file, void *fh,
+					struct v4l2_selection *s);
 	/* Compression ioctls */
 	int (*vidioc_g_jpegcomp)       (struct file *file, void *fh,
 					struct v4l2_jpegcompression *a);
-- 
1.7.6

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

[Sakari Ailus]

Hi Tomasz,

Thanks for the patch!

On Wed, Aug 31, 2011 at 02:28:20PM +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                 |   46 +++++++++++++++++++++++++++++
>  include/media/v4l2-ioctl.h                |    4 ++
>  4 files changed, 80 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..b7471fe 100644
> --- a/include/linux/videodev2.h
> +++ b/include/linux/videodev2.h
> @@ -738,6 +738,48 @@ 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
> +
> +/* Selection targets */
> +
> +/* current cropping area */
> +#define V4L2_SEL_CROP_ACTIVE		0
> +/* default cropping area */
> +#define V4L2_SEL_CROP_DEFAULT		1
> +/* cropping bounds */
> +#define V4L2_SEL_CROP_BOUNDS		2
> +/* current composing area */
> +#define V4L2_SEL_COMPOSE_ACTIVE		256
> +/* default composing area */
> +#define V4L2_SEL_COMPOSE_DEFAULT	257
> +/* composing bounds */
> +#define V4L2_SEL_COMPOSE_BOUNDS		258
> +/* current composing area plus all padding pixels */
> +#define V4L2_SEL_COMPOSE_PADDED		259
> +
> +/**
> + * struct v4l2_selection - selection info
> + * @type:	buffer type (do not use *_MPLANE types)
> + * @target:	selection target, used to choose one of possible rectangles
> + * @flags:	constraints flags
> + * @r:		coordinates of selection window
> + * @reserved:	for future use, rounds structure size to 64 bytes, set to zero
> + *
> + * Hardware may use multiple helper window to process a video stream.
> + * The structure is used to exchange this selection areas between
> + * an application and a driver.
> + */
> +struct v4l2_selection {
> +	__u32			type;
> +	__u32			target;
> +	__u32                   flags;
> +	struct v4l2_rect        r;
> +	__u32                   reserved[9];
> +};

The v4l2_selection doesn't have "which" field such as v4l2_subdev_crop and
v4l2_subdev_format. This field is used to differentiate between try and
active format / crop. Shouldn't we use the same approach in selection?

> +
>  /*
>   *      A N A L O G   V I D E O   S T A N D A R D
>   */
> @@ -2182,6 +2224,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..9dd6e18 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 *s);
> +	int (*vidioc_s_selection)      (struct file *file, void *fh,
> +					struct v4l2_selection *s);
>  	/* 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
e-mail: sakari.ailus@iki.fi	jabber/XMPP/Gmail: sailus@retiisi.org.uk

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

[Laurent Pinchart]

Hi Sakari,

On Monday 05 September 2011 12:25:08 Sakari Ailus wrote:
> On Wed, Aug 31, 2011 at 02:28:20PM +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                 |   46
> >  +++++++++++++++++++++++++++++ include/media/v4l2-ioctl.h               
> >  |    4 ++
> >  4 files changed, 80 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..b7471fe 100644
> > --- a/include/linux/videodev2.h
> > +++ b/include/linux/videodev2.h
> > @@ -738,6 +738,48 @@ 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
> > +
> > +/* Selection targets */
> > +
> > +/* current cropping area */
> > +#define V4L2_SEL_CROP_ACTIVE		0
> > +/* default cropping area */
> > +#define V4L2_SEL_CROP_DEFAULT		1
> > +/* cropping bounds */
> > +#define V4L2_SEL_CROP_BOUNDS		2
> > +/* current composing area */
> > +#define V4L2_SEL_COMPOSE_ACTIVE		256
> > +/* default composing area */
> > +#define V4L2_SEL_COMPOSE_DEFAULT	257
> > +/* composing bounds */
> > +#define V4L2_SEL_COMPOSE_BOUNDS		258
> > +/* current composing area plus all padding pixels */
> > +#define V4L2_SEL_COMPOSE_PADDED		259
> > +
> > +/**
> > + * struct v4l2_selection - selection info
> > + * @type:	buffer type (do not use *_MPLANE types)
> > + * @target:	selection target, used to choose one of possible rectangles
> > + * @flags:	constraints flags
> > + * @r:		coordinates of selection window
> > + * @reserved:	for future use, rounds structure size to 64 bytes, set to
> > zero + *
> > + * Hardware may use multiple helper window to process a video stream.
> > + * The structure is used to exchange this selection areas between
> > + * an application and a driver.
> > + */
> > +struct v4l2_selection {
> > +	__u32			type;
> > +	__u32			target;
> > +	__u32                   flags;
> > +	struct v4l2_rect        r;
> > +	__u32                   reserved[9];
> > +};
> 
> The v4l2_selection doesn't have "which" field such as v4l2_subdev_crop and
> v4l2_subdev_format. This field is used to differentiate between try and
> active format / crop. Shouldn't we use the same approach in selection?

We definitely should, for the subdev-level selection API. This is the V4L2 
selection API, and V4L2 uses a VIDIOC_TRY_* approach instead.

This being said, I wouldn't mind a 'which'-based approach at the V4L2 API, but 
that got nacked pretty strongly during previous discussions (I'm not sure if 
that was on the list or face to face).

> > +
> > 
> >  /*
> >  
> >   *      A N A L O G   V I D E O   S T A N D A R D
> >   */
> > 
> > @@ -2182,6 +2224,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..9dd6e18 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 *s);
> > +	int (*vidioc_s_selection)      (struct file *file, void *fh,
> > +					struct v4l2_selection *s);
> > 
> >  	/* Compression ioctls */
> >  	int (*vidioc_g_jpegcomp)       (struct file *file, void *fh,
> >  	
> >  					struct v4l2_jpegcompression *a);

-- 
Regards,

Laurent Pinchart

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

[Sakari Ailus]

On Mon, Sep 05, 2011 at 02:52:03PM +0200, Laurent Pinchart wrote:
> Hi Sakari,
> 
> On Monday 05 September 2011 12:25:08 Sakari Ailus wrote:
> > On Wed, Aug 31, 2011 at 02:28:20PM +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                 |   46
> > >  +++++++++++++++++++++++++++++ include/media/v4l2-ioctl.h               
> > >  |    4 ++
> > >  4 files changed, 80 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..b7471fe 100644
> > > --- a/include/linux/videodev2.h
> > > +++ b/include/linux/videodev2.h
> > > @@ -738,6 +738,48 @@ 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
> > > +
> > > +/* Selection targets */
> > > +
> > > +/* current cropping area */
> > > +#define V4L2_SEL_CROP_ACTIVE		0
> > > +/* default cropping area */
> > > +#define V4L2_SEL_CROP_DEFAULT		1
> > > +/* cropping bounds */
> > > +#define V4L2_SEL_CROP_BOUNDS		2
> > > +/* current composing area */
> > > +#define V4L2_SEL_COMPOSE_ACTIVE		256
> > > +/* default composing area */
> > > +#define V4L2_SEL_COMPOSE_DEFAULT	257
> > > +/* composing bounds */
> > > +#define V4L2_SEL_COMPOSE_BOUNDS		258
> > > +/* current composing area plus all padding pixels */
> > > +#define V4L2_SEL_COMPOSE_PADDED		259
> > > +
> > > +/**
> > > + * struct v4l2_selection - selection info
> > > + * @type:	buffer type (do not use *_MPLANE types)
> > > + * @target:	selection target, used to choose one of possible rectangles
> > > + * @flags:	constraints flags
> > > + * @r:		coordinates of selection window
> > > + * @reserved:	for future use, rounds structure size to 64 bytes, set to
> > > zero + *
> > > + * Hardware may use multiple helper window to process a video stream.
> > > + * The structure is used to exchange this selection areas between
> > > + * an application and a driver.
> > > + */
> > > +struct v4l2_selection {
> > > +	__u32			type;
> > > +	__u32			target;
> > > +	__u32                   flags;
> > > +	struct v4l2_rect        r;
> > > +	__u32                   reserved[9];
> > > +};
> > 
> > The v4l2_selection doesn't have "which" field such as v4l2_subdev_crop and
> > v4l2_subdev_format. This field is used to differentiate between try and
> > active format / crop. Shouldn't we use the same approach in selection?
> 
> We definitely should, for the subdev-level selection API. This is the V4L2 
> selection API, and V4L2 uses a VIDIOC_TRY_* approach instead.

Oops. I missed that one. :-P I was only thinking of the subdev nodes. :-)

-- 
Sakari Ailus
e-mail: sakari.ailus@iki.fi	jabber/XMPP/Gmail: sailus@retiisi.org.uk

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

[Laurent Pinchart]

Hi Tomasz,

Thanks for the patch, and sorry for the late reply.

On Wednesday 31 August 2011 14:28:20 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>

Acked-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>

> ---
>  drivers/media/video/v4l2-compat-ioctl32.c |    2 +
>  drivers/media/video/v4l2-ioctl.c          |   28 +++++++++++++++++
>  include/linux/videodev2.h                 |   46
> +++++++++++++++++++++++++++++ include/media/v4l2-ioctl.h                | 
>   4 ++
>  4 files changed, 80 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..b7471fe 100644
> --- a/include/linux/videodev2.h
> +++ b/include/linux/videodev2.h
> @@ -738,6 +738,48 @@ 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
> +
> +/* Selection targets */
> +
> +/* current cropping area */
> +#define V4L2_SEL_CROP_ACTIVE		0
> +/* default cropping area */
> +#define V4L2_SEL_CROP_DEFAULT		1
> +/* cropping bounds */
> +#define V4L2_SEL_CROP_BOUNDS		2
> +/* current composing area */
> +#define V4L2_SEL_COMPOSE_ACTIVE		256
> +/* default composing area */
> +#define V4L2_SEL_COMPOSE_DEFAULT	257
> +/* composing bounds */
> +#define V4L2_SEL_COMPOSE_BOUNDS		258
> +/* current composing area plus all padding pixels */
> +#define V4L2_SEL_COMPOSE_PADDED		259
> +
> +/**
> + * struct v4l2_selection - selection info
> + * @type:	buffer type (do not use *_MPLANE types)
> + * @target:	selection target, used to choose one of possible rectangles
> + * @flags:	constraints flags
> + * @r:		coordinates of selection window
> + * @reserved:	for future use, rounds structure size to 64 bytes, set to
> zero + *
> + * Hardware may use multiple helper window to process a video stream.
> + * The structure is used to exchange this selection areas between
> + * an application and a driver.
> + */
> +struct v4l2_selection {
> +	__u32			type;
> +	__u32			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 +2224,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..9dd6e18 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 *s);
> +	int (*vidioc_s_selection)      (struct file *file, void *fh,
> +					struct v4l2_selection *s);
>  	/* Compression ioctls */
>  	int (*vidioc_g_jpegcomp)       (struct file *file, void *fh,
>  					struct v4l2_jpegcompression *a);

-- 
Regards,

Laurent Pinchart

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

[Hans Verkuil]

Here is my 'better late than never' review :-)

On Wednesday, August 31, 2011 14:28:20 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                 |   46 +++++++++++++++++++++++++++++
>  include/media/v4l2-ioctl.h                |    4 ++
>  4 files changed, 80 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;

Here you should insert this code so that this ioctl handles the priority check
correctly:

		if (ret_prio) {
			ret = ret_prio;
			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..b7471fe 100644
> --- a/include/linux/videodev2.h
> +++ b/include/linux/videodev2.h
> @@ -738,6 +738,48 @@ 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
> +
> +/* Selection targets */
> +
> +/* current cropping area */
> +#define V4L2_SEL_CROP_ACTIVE		0
> +/* default cropping area */
> +#define V4L2_SEL_CROP_DEFAULT		1
> +/* cropping bounds */
> +#define V4L2_SEL_CROP_BOUNDS		2
> +/* current composing area */
> +#define V4L2_SEL_COMPOSE_ACTIVE		256
> +/* default composing area */
> +#define V4L2_SEL_COMPOSE_DEFAULT	257
> +/* composing bounds */
> +#define V4L2_SEL_COMPOSE_BOUNDS		258
> +/* current composing area plus all padding pixels */
> +#define V4L2_SEL_COMPOSE_PADDED		259
> +
> +/**
> + * struct v4l2_selection - selection info
> + * @type:	buffer type (do not use *_MPLANE types)

Why can't I use MPLANE types?

> + * @target:	selection target, used to choose one of possible rectangles
> + * @flags:	constraints flags
> + * @r:		coordinates of selection window
> + * @reserved:	for future use, rounds structure size to 64 bytes, set to zero
> + *
> + * Hardware may use multiple helper window to process a video stream.
> + * The structure is used to exchange this selection areas between
> + * an application and a driver.
> + */
> +struct v4l2_selection {
> +	__u32			type;
> +	__u32			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 +2224,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)

So we decided not to implement a TRY_SELECTION yet? I'm fine with that, BTW.

> +
>  /* 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..9dd6e18 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 *s);
> +	int (*vidioc_s_selection)      (struct file *file, void *fh,
> +					struct v4l2_selection *s);
>  	/* Compression ioctls */
>  	int (*vidioc_g_jpegcomp)       (struct file *file, void *fh,
>  					struct v4l2_jpegcompression *a);
> 

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

[Tomasz Stanislawski]

Hi Hans,

On 09/27/2011 10:28 AM, Hans Verkuil wrote:
> Here is my 'better late than never' review :-)
>
> On Wednesday, August 31, 2011 14:28:20 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                 |   46 +++++++++++++++++++++++++++++
>>   include/media/v4l2-ioctl.h                |    4 ++
>>   4 files changed, 80 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;
>
> Here you should insert this code so that this ioctl handles the priority check
> correctly:
>
> 		if (ret_prio) {
> 			ret = ret_prio;
> 			break;
> 		}
>

OK

>> +		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..b7471fe 100644
>> --- a/include/linux/videodev2.h
>> +++ b/include/linux/videodev2.h
>> @@ -738,6 +738,48 @@ 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
>> +
>> +/* Selection targets */
>> +
>> +/* current cropping area */
>> +#define V4L2_SEL_CROP_ACTIVE		0
>> +/* default cropping area */
>> +#define V4L2_SEL_CROP_DEFAULT		1
>> +/* cropping bounds */
>> +#define V4L2_SEL_CROP_BOUNDS		2
>> +/* current composing area */
>> +#define V4L2_SEL_COMPOSE_ACTIVE		256
>> +/* default composing area */
>> +#define V4L2_SEL_COMPOSE_DEFAULT	257
>> +/* composing bounds */
>> +#define V4L2_SEL_COMPOSE_BOUNDS		258
>> +/* current composing area plus all padding pixels */
>> +#define V4L2_SEL_COMPOSE_PADDED		259
>> +
>> +/**
>> + * struct v4l2_selection - selection info
>> + * @type:	buffer type (do not use *_MPLANE types)
>
> Why can't I use MPLANE types?
>

Because the selection has nothing to do with "multiplanar" stuff. The 
VIDIOC_{S/G}_CROP does not use it. Therefore the selection should not 
use it either. Only memory referring ioctl should use *_MPLANE types. I 
would really like to avoid forcing developers to implement this 
non-intuitive and confusing business logic like it happened to 
VIDIOC_S_FMT, and VIDIOC_STREAM{ON/OFF} ioctls.

>> + * @target:	selection target, used to choose one of possible rectangles
>> + * @flags:	constraints flags
>> + * @r:		coordinates of selection window
>> + * @reserved:	for future use, rounds structure size to 64 bytes, set to zero
>> + *
>> + * Hardware may use multiple helper window to process a video stream.
>> + * The structure is used to exchange this selection areas between
>> + * an application and a driver.
>> + */
>> +struct v4l2_selection {
>> +	__u32			type;
>> +	__u32			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 +2224,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)
>
> So we decided not to implement a TRY_SELECTION yet? I'm fine with that, BTW.
>

OK. This ioctl is needed for advanced cropping/composing negotiations.
I think that the constraints would be sufficient for simple use cases.

Best regards,
Tomasz Stanislawski

>> +
>>   /* 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..9dd6e18 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 *s);
>> +	int (*vidioc_s_selection)      (struct file *file, void *fh,
>> +					struct v4l2_selection *s);
>>   	/* Compression ioctls */
>>   	int (*vidioc_g_jpegcomp)       (struct file *file, void *fh,
>>   					struct v4l2_jpegcompression *a);
>>
>

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

[Sakari Ailus]

Hi Tomasz,

On Wed, Aug 31, 2011 at 02:28:20PM +0200, Tomasz Stanislawski wrote:
...
> diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
> index fca24cc..b7471fe 100644
> --- a/include/linux/videodev2.h
> +++ b/include/linux/videodev2.h
> @@ -738,6 +738,48 @@ 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

A minor comment. If the patches have not been pulled yet, how about adding
FLAG_ to the flag names? I.e. V4L2_SEL_FLAG_SIZE_GE and
V4L2_SEL_FLAG_SIZE_LE.

Kind regards,

-- 
Sakari Ailus
e-mail: sakari.ailus@iki.fi	jabber/XMPP/Gmail: sailus@retiisi.org.uk

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

[Tomasz Stanislawski]

On 10/12/2011 01:48 PM, Sakari Ailus wrote:
> Hi Tomasz,
>
> On Wed, Aug 31, 2011 at 02:28:20PM +0200, Tomasz Stanislawski wrote:
> ...
>> diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
>> index fca24cc..b7471fe 100644
>> --- a/include/linux/videodev2.h
>> +++ b/include/linux/videodev2.h
>> @@ -738,6 +738,48 @@ 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
>
> A minor comment. If the patches have not been pulled yet, how about adding
> FLAG_ to the flag names? I.e. V4L2_SEL_FLAG_SIZE_GE and
> V4L2_SEL_FLAG_SIZE_LE.

Hi Sakari,

The idea is good. I preferred to avoid using long names if possible.
I agree that using _FLAGS_ produce more informative name.
I'll fix it in the new version of selection API.

Regards,
Tomasz Stanislawski

>
> Kind regards,
>

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

[Sakari Ailus]

On Wed, Oct 12, 2011 at 05:08:20PM +0200, Tomasz Stanislawski wrote:
> On 10/12/2011 01:48 PM, Sakari Ailus wrote:
> >Hi Tomasz,
> >
> >On Wed, Aug 31, 2011 at 02:28:20PM +0200, Tomasz Stanislawski wrote:
> >...
> >>diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
> >>index fca24cc..b7471fe 100644
> >>--- a/include/linux/videodev2.h
> >>+++ b/include/linux/videodev2.h
> >>@@ -738,6 +738,48 @@ 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
> >
> >A minor comment. If the patches have not been pulled yet, how about adding
> >FLAG_ to the flag names? I.e. V4L2_SEL_FLAG_SIZE_GE and
> >V4L2_SEL_FLAG_SIZE_LE.
> 
> Hi Sakari,
> 
> The idea is good. I preferred to avoid using long names if possible.
> I agree that using _FLAGS_ produce more informative name.
> I'll fix it in the new version of selection API.

Thanks, Thomasz! (I propose "FLAG" and not "FLAGS" since it's a single
flag.)

Cheers,

-- 
Sakari Ailus
e-mail: sakari.ailus@iki.fi	jabber/XMPP/Gmail: sailus@retiisi.org.uk

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

[Sakari Ailus]

On Wed, Oct 12, 2011 at 05:08:20PM +0200, Tomasz Stanislawski wrote:
> On 10/12/2011 01:48 PM, Sakari Ailus wrote:
> >Hi Tomasz,
> >
> >On Wed, Aug 31, 2011 at 02:28:20PM +0200, Tomasz Stanislawski wrote:
> >...
> >>diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
> >>index fca24cc..b7471fe 100644
> >>--- a/include/linux/videodev2.h
> >>+++ b/include/linux/videodev2.h
> >>@@ -738,6 +738,48 @@ 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
> >
> >A minor comment. If the patches have not been pulled yet, how about adding
> >FLAG_ to the flag names? I.e. V4L2_SEL_FLAG_SIZE_GE and
> >V4L2_SEL_FLAG_SIZE_LE.
> 
> Hi Sakari,
> 
> The idea is good. I preferred to avoid using long names if possible.
> I agree that using _FLAGS_ produce more informative name.
> I'll fix it in the new version of selection API.

Hi Tomasz,

I'd also have the same comment on the selection targets.
V4L2_SEL_TGT_CROP_ACTIVE, for example?

What do you think?

-- 
Sakari Ailus
e-mail: sakari.ailus@iki.fi	jabber/XMPP/Gmail: sailus@retiisi.org.uk

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

[Tomasz Stanislawski]

Hi Sakari,

On 10/14/2011 07:19 PM, Sakari Ailus wrote:
> On Wed, Oct 12, 2011 at 05:08:20PM +0200, Tomasz Stanislawski wrote:
>> On 10/12/2011 01:48 PM, Sakari Ailus wrote:
>>> Hi Tomasz,
>>>
>>> On Wed, Aug 31, 2011 at 02:28:20PM +0200, Tomasz Stanislawski wrote:
>>> ...
>>>> diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
>>>> index fca24cc..b7471fe 100644
>>>> --- a/include/linux/videodev2.h
>>>> +++ b/include/linux/videodev2.h
>>>> @@ -738,6 +738,48 @@ 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
>>>
>>> A minor comment. If the patches have not been pulled yet, how about adding
>>> FLAG_ to the flag names? I.e. V4L2_SEL_FLAG_SIZE_GE and
>>> V4L2_SEL_FLAG_SIZE_LE.

I thought that it may be worth to drop _SEL_. The constraint flags could 
be reused in future ioctls? I mean S_FRAMESIZES or extensions to control 
API. What do you think?

>>
>> Hi Sakari,
>>
>> The idea is good. I preferred to avoid using long names if possible.
>> I agree that using _FLAGS_ produce more informative name.
>> I'll fix it in the new version of selection API.
>
> Hi Tomasz,
>
> I'd also have the same comment on the selection targets.
> V4L2_SEL_TGT_CROP_ACTIVE, for example?

It is logical to use _TGT_, it is sad that the names becomes so long :/

Regards,
Tomasz Stanislawski

>
> What do you think?
>

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

[Sakari Ailus]

On Mon, Oct 17, 2011 at 03:31:17PM +0200, Tomasz Stanislawski wrote:
> Hi Sakari,
> 
> On 10/14/2011 07:19 PM, Sakari Ailus wrote:
> >On Wed, Oct 12, 2011 at 05:08:20PM +0200, Tomasz Stanislawski wrote:
> >>On 10/12/2011 01:48 PM, Sakari Ailus wrote:
> >>>Hi Tomasz,
> >>>
> >>>On Wed, Aug 31, 2011 at 02:28:20PM +0200, Tomasz Stanislawski wrote:
> >>>...
> >>>>diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
> >>>>index fca24cc..b7471fe 100644
> >>>>--- a/include/linux/videodev2.h
> >>>>+++ b/include/linux/videodev2.h
> >>>>@@ -738,6 +738,48 @@ 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
> >>>
> >>>A minor comment. If the patches have not been pulled yet, how about adding
> >>>FLAG_ to the flag names? I.e. V4L2_SEL_FLAG_SIZE_GE and
> >>>V4L2_SEL_FLAG_SIZE_LE.
> 
> I thought that it may be worth to drop _SEL_. The constraint flags
> could be reused in future ioctls? I mean S_FRAMESIZES or extensions
> to control API. What do you think?
> 
> >>
> >>Hi Sakari,
> >>
> >>The idea is good. I preferred to avoid using long names if possible.
> >>I agree that using _FLAGS_ produce more informative name.
> >>I'll fix it in the new version of selection API.
> >
> >Hi Tomasz,
> >
> >I'd also have the same comment on the selection targets.
> >V4L2_SEL_TGT_CROP_ACTIVE, for example?
> 
> It is logical to use _TGT_, it is sad that the names becomes so long :/

It's not _that_ long --- we have longer ones e.g. in include/linux/media.h.
They only need to be just descriptive enough...

Cheers,

-- 
Sakari Ailus
e-mail: sakari.ailus@iki.fi	jabber/XMPP/Gmail: sailus@retiisi.org.uk

[PATCH 2/4] 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       |  281 ++
 6 files changed, 3634 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..6d93832
--- /dev/null
+++ b/Documentation/DocBook/media/v4l/vidioc-g-selection.xml
@@ -0,0 +1,281 @@
+<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. 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>Selection targets.</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>__u32</entry>
+	    <entry><structfield>type</structfield></entry>
+	    <entry>Type of the buffer (from &v4l2-buf-type;)</entry>
+	  </row>
+	  <row>
+	    <entry>__u32</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

Re: [PATCH 2/4] v4l: add documentation for selection API

[Laurent Pinchart]

Hi Tomasz,

Thanks for the patch, and sorry for the late reply.

On Wednesday 31 August 2011 14:28:21 Tomasz Stanislawski wrote:
> 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>

The documentation looks very good. Thank you for your great work. Just a couple
of small comments below, mostly about typo fixes.

[snip]

> 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

s/specify/specifies/

> +of the buffer is actually written by the hardware. </para>

s/written/written to/

> +<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

s/shown/show/ or s/shown/be shown/

> +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>

s/compose target/the compose target/

> +<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

s/does not support/supports/ or s/neither cropping nor/cropping or/

> +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

s/horizontal and vertical direction/the horizontal and vertical directions/

> +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

s/the figure/figure/

> +selection targets available for a video capture device. The targets should be
> +configured according to the pipeline configuration rules for a capture device.

Do we have such rules written somewhere ?

> +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

s/a area which/areas that/

> +</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

s/by/by the/

> +</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

s/reset the crop rectangle/set the active crop rectangle/

> +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>

We support sub-pixel cropping, but not sub-pixel composition. Can you remind me
of the rationale for that ?

> +<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

s/by/by 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>

If they're always equal, why do we have two different targets ? :-) Maybe "is
usually identical to" or "is most of the time identical to" would be better ?

> +<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

s/All pixel/All pixels/

> +<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>

How would an application remove them ?

> +
> +   </section>
> +
> +   <section>
> +
> +   <title>Configuration of video output</title>
> +
> +<para>For output devices targets and ioctls are used accordingly to the video

s/accordingly/similarly/

> +capture case. The <emphasis>composing</emphasis> rectangle refer to insertion

s/refer/refers/ or s/rectangle/rectangles/

s/insertion/the 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

s/are//

> +configuration rules for a output device. It means that the compose targets must

s/a output/an output/

> +be configured in prior to cropping targets.</para>

s/in prior to/before the/

> +
> +<para>The cropping targets refer to the memory buffer which contains an image

s/which/that/

> +to be inserted into video signal or graphical screen. The limits of cropping

s/into/into a/

> +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

s/. The target identifier is/, is given by/

> +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>

Same, comment maybe "is usually identical to the" or "is most of the time
identical to the" would be better ?

> +
> +<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

s/by/by the/

> +</constant> target.  The rectangle's coordinates are expressed driver dependant

s/expressed/expressed in/

> +units. The only exception are digital outputs where the units are pixels.  The
> +composing rectangle must lie completely inside bounds rectangle.  The driver

s/bounds rectangle/the bounds rectangle/

> +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

s/reset/set/

> +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

s/then/than/

> +an image from memory buffers.  It includes borders around an image. However,
> +such a padding area is very driver-dependant issue. Driver developers are

s/ issue// (?)

> +encouraged to keep padding rectangle equal to active one. The padding target
> +is accessed by <constant> V4L2_SEL_COMPOSE_PADDED </constant> identifier.  It

s/by/by the/

> +must contain all pixels from <constant> V4L2_SEL_COMPOSE_ACTIVE </constant>

s/from/from the/

> +target.</para>
> +
> +    </section>
> +
> +    <section>
> +
> +      <title>Scaling control.</title>
> +
> +<para>An application can detect if scaling is performed by comparing width and

s/width/the width/

> +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

s/the scaling/scaling/

> +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..6d93832
> --- /dev/null
> +++ b/Documentation/DocBook/media/v4l/vidioc-g-selection.xml
> @@ -0,0 +1,281 @@
> +<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>

s/current // (?)

> +  </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

s/rest of/rest of the/
s/incorrect/an incorrect/

> +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,

s/to bounds/to the bounds/

> +structure <structfield> v4l2-selection::r </structfield> is filled with current

s/with current/with the current/

> +cropping (composing) coordinates. The coordinates are expressed in
> +driver-dependant units. The only exception are rectangles for images in raw

s/dependant/dependent/

> +formats, which coordinates are always expressed in pixels.  </para>

s/which/whose/

> +
> +<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

s/they must/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>

The driver can adjust the rectangle size freely and shall choose a crop/compose
rectangle as close as possible to the requested one.

> +  </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

s/drive/driver/
s/grow/enlarge/

> +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.

You know that I still think that hints should be hints, and that ERANGE should
not be returned, right ? :-)

> 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

s/field/the field/

> +adjusted rectangle. When the parameters are unsuitable the application may

s/adjusted/the adjusted/

> +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>Selection targets.</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>__u32</entry>
> +	    <entry><structfield>type</structfield></entry>
> +	    <entry>Type of the buffer (from &v4l2-buf-type;)</entry>
> +	  </row>
> +	  <row>
> +	    <entry>__u32</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>

s/is invalid/are invalid/

> +	</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>

s/satisfy/satisfies/

> +	</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>

-- 
Regards,

Laurent Pinchart

Re: [PATCH 2/4] v4l: add documentation for selection API

[Tomasz Stanislawski]

On 09/23/2011 12:41 AM, Laurent Pinchart wrote:

Hi Laurent,
Thank you for the review. It looks that spelling highlighting is not 
enough :).
I discussed some of your comments. There are still some open issues.
> Hi Tomasz,
>
> Thanks for the patch, and sorry for the late reply.
>
> On Wednesday 31 August 2011 14:28:21 Tomasz Stanislawski wrote:
>> 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>
> The documentation looks very good. Thank you for your great work. Just a couple
> of small comments below, mostly about typo fixes.
>
> [snip]
>
>> 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
> s/specify/specifies/
>
>> +of the buffer is actually written by the hardware.</para>
> s/written/written to/
>
>> +<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
> s/shown/show/ or s/shown/be shown/
>
>> +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>
> s/compose target/the compose target/
>
>> +<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
> s/does not support/supports/ or s/neither cropping nor/cropping or/
>
>> +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
> s/horizontal and vertical direction/the horizontal and vertical directions/
>
>> +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
> s/the figure/figure/
>
>> +selection targets available for a video capture device. The targets should be
>> +configured according to the pipeline configuration rules for a capture device.
> Do we have such rules written somewhere ?
The pipeline configuration rules are not a part of V4L2 doc yet. It was 
discussed at IRC meeting.
Do you think that the RFC should be posted in separate patch to V4L2 doc?
>> +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
> s/a area which/areas that/
>
>> +</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
> s/by/by the/
>
>> +</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
> s/reset the crop rectangle/set the active crop rectangle/
>
>> +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>
> We support sub-pixel cropping, but not sub-pixel composition. Can you remind me
> of the rationale for that ?
Do you mean that OMAP3 ISP supports cropping with sub-pixel resolution?
I thought that pixels are natural units for images stored in memory buffers.
But I would not be surprised if there was some weird fractal-like format
providing images with infinite resolution. Do you think that the sentence
"All coordinates are expressed in pixel" should be dropped from spec?
>> +<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
> s/by/by 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>
> If they're always equal, why do we have two different targets ? :-) Maybe "is
> usually identical to" or "is most of the time identical to" would be better ?
Good question. I remember that once Hans has said that there should be
no margins in an image if no selection ioctl was used. Therefore I decided
that default and bounds rectangles should be equal for video capture.
I am interested what is Hans' opinion about proposal of softening this 
requirement.
>> +<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
> s/All pixel/All pixels/
>
>> +<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>
> How would an application remove them ?
The application may use memset if it recognizes fourcc. The idea of 
padding target was to
provide information about artifacts introduced the hardware. If the 
image is decoded directly
to framebuffer then the application could remove artifacts. We could 
introduce some V4L2
control to inform if the padding are is filled with zeros to avoid 
redundant memset.
What do you think?
>> +
>> +</section>
>> +
>> +<section>
>> +
>> +<title>Configuration of video output</title>
>> +
>> +<para>For output devices targets and ioctls are used accordingly to the video
> s/accordingly/similarly/
>
>> +capture case. The<emphasis>composing</emphasis>  rectangle refer to insertion
> s/refer/refers/ or s/rectangle/rectangles/
>
> s/insertion/the 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
> s/are//
>
>> +configuration rules for a output device. It means that the compose targets must
> s/a output/an output/
>
>> +be configured in prior to cropping targets.</para>
> s/in prior to/before the/
>
>> +
>> +<para>The cropping targets refer to the memory buffer which contains an image
> s/which/that/
>
>> +to be inserted into video signal or graphical screen. The limits of cropping
> s/into/into a/
>
>> +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
> s/. The target identifier is/, is given by/
>
>> +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>
> Same, comment maybe "is usually identical to the" or "is most of the time
> identical to the" would be better ?
[as above]
>> +
>> +<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
> s/by/by the/
>
>> +</constant>  target.  The rectangle's coordinates are expressed driver dependant
> s/expressed/expressed in/
>
>> +units. The only exception are digital outputs where the units are pixels.  The
>> +composing rectangle must lie completely inside bounds rectangle.  The driver
> s/bounds rectangle/the bounds rectangle/
>
>> +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
> s/reset/set/
>
>> +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
> s/then/than/
>
>> +an image from memory buffers.  It includes borders around an image. However,
>> +such a padding area is very driver-dependant issue. Driver developers are
> s/ issue// (?)
>
>> +encouraged to keep padding rectangle equal to active one. The padding target
>> +is accessed by<constant>  V4L2_SEL_COMPOSE_PADDED</constant>  identifier.  It
> s/by/by the/
>
>> +must contain all pixels from<constant>  V4L2_SEL_COMPOSE_ACTIVE</constant>
> s/from/from the/
>
>> +target.</para>
>> +
>> +</section>
>> +
>> +<section>
>> +
>> +<title>Scaling control.</title>
>> +
>> +<para>An application can detect if scaling is performed by comparing width and
> s/width/the width/
>
>> +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
> s/the scaling/scaling/
>
>> +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..6d93832
>> --- /dev/null
>> +++ b/Documentation/DocBook/media/v4l/vidioc-g-selection.xml
>> @@ -0,0 +1,281 @@
>> +<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>
> s/current // (?)
>
>> +</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
> s/rest of/rest of the/
> s/incorrect/an incorrect/
>
>> +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,
> s/to bounds/to the bounds/
>
>> +structure<structfield>  v4l2-selection::r</structfield>  is filled with current
> s/with current/with the current/
>
>> +cropping (composing) coordinates. The coordinates are expressed in
>> +driver-dependant units. The only exception are rectangles for images in raw
> s/dependant/dependent/
>
>> +formats, which coordinates are always expressed in pixels.</para>
> s/which/whose/
>
>> +
>> +<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
> s/they must/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>
> The driver can adjust the rectangle size freely and shall choose a crop/compose
> rectangle as close as possible to the requested one.
>
>> +</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
> s/drive/driver/
> s/grow/enlarge/
>
>> +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.
> You know that I still think that hints should be hints, and that ERANGE should
> not be returned, right ? :-)
Yes.. :). There are pros and cons for hints, too.
(+) hint can be ignored therefore is easier to implement them in drivers.
It may speed up adoption of the selection api.
(-) It is not possible to prevent hardware from applying the configuration
that is not acceptable by the application. Such an unfortunate operation
could mess up the whole pipeline.

I found two ways  to solve the cons. The new ioctl TRY_SELECTION
should be introduced now or in the future version of selection api.
Second, the pipeline configuration rules may help in this case. An 
application should
configure pipeline according to the rules. The setup of stages before 
the current stage
is guaranteed to not modified. Therefore the unfortunate selection call 
could only
mess up the stages lower in the pipeline.

The constraints idea was OK, until I found that the content of ioctl 
parameters is
not copied to the userspace when the ioctl fails. Therefore the application
receives no feedback other than ERANGE. Moreover I found out that is not
easy to calculate the best-hit rectangle that could be returned. A lot 
of code
must be added to driver to support it.

There is still one more problem with the hints. Examine following scenario.
One tries to setup 20x20 rectangle using SEL_SIZE_LE hint. The ioctl 
succeeds
but the driver returns 32x32. Does it mean?

(A) it is not possible to set a rectangle smaller than 20x20
(B) it is not possible to set a rectangle smaller than 32x32
(C) driver failed to configuration consistent with 20x20 (or smaller) 
rectangle.
       It is not known if such a configuration exists.
       Should the application continue the negotiations?
       Size 16x16 might be good, if the driver did not implement hint 
[ignored them]
       and rounded 20x20 to 32x32.

The solution using constraints was consistent. The ERANGE is returned and
case (A) is valid. If constraints were transformed to hints then we 
should allow to
violate hints only if there is no configuration that satisfy the hints.

What is your opinion about it?

Best regards,
Tomasz Stanislawski

>> 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
> s/field/the field/
>
>> +adjusted rectangle. When the parameters are unsuitable the application may
> s/adjusted/the adjusted/
>
>> +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>Selection targets.</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>__u32</entry>
>> +	<entry><structfield>type</structfield></entry>
>> +	<entry>Type of the buffer (from&v4l2-buf-type;)</entry>
>> +	</row>
>> +	<row>
>> +	<entry>__u32</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>
> s/is invalid/are invalid/
>
>> +	</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>
> s/satisfy/satisfies/
>
>> +	</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>

Re: [PATCH 2/4] v4l: add documentation for selection API

[Laurent Pinchart]

Hi Tomasz,

On Friday 23 September 2011 14:36:51 Tomasz Stanislawski wrote:
> On 09/23/2011 12:41 AM, Laurent Pinchart wrote:
> 
> Hi Laurent,
> Thank you for the review.

Your welcome. Sorry once again for the delay.

> It looks that spelling highlighting is not enough :).

That's what review is for :-)

> I discussed some of your comments. There are still some open issues.
> 
> > On Wednesday 31 August 2011 14:28:21 Tomasz Stanislawski wrote:

[snip]

> >> +<section>
> >> +
> >> +<title>Configuration of video capture</title>
> >> +
> >> +<para>See the figure<xref linkend="sel-targets-capture" />  for
> >> examples of the
> > 
> > s/the figure/figure/
> > 
> >> +selection targets available for a video capture device. The targets
> >> should be +configured according to the pipeline configuration rules for
> >> a capture device.
> > 
> > Do we have such rules written somewhere ?
> 
> The pipeline configuration rules are not a part of V4L2 doc yet. It was
> discussed at IRC meeting.
> Do you think that the RFC should be posted in separate patch to V4L2 doc?

As this document refers to them, I think that would be useful. We're talking 
about pipeline configuration using the video nodes API, right ?

[snip]

> >> +<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>
> > 
> > We support sub-pixel cropping, but not sub-pixel composition. Can you
> > remind me of the rationale for that ?
> 
> Do you mean that OMAP3 ISP supports cropping with sub-pixel resolution?

No, sorry. By "we" I meant the selection API.

> I thought that pixels are natural units for images stored in memory
> buffers. But I would not be surprised if there was some weird fractal-like
> format providing images with infinite resolution. Do you think that the
> sentence "All coordinates are expressed in pixel" should be dropped from
> spec?

I don't know to be honest. What bothers me is that the spec allows sub-pixel 
resolution for cropping but not for composing. I'm not sure if there's any 
hardware supported by our current drivers that could make use of sub-pixel 
selections, but I don't see a reason to allow sub-pixel cropping and not sub-
pixel composing. The solution might be to disallow sub-pixel cropping for now 
though. If we do that, can we later extend it in a clean way ?

[snip]

> >> +<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>
> > 
> > If they're always equal, why do we have two different targets ? :-) Maybe
> > "is usually identical to" or "is most of the time identical to" would be
> > better ?
> 
> Good question. I remember that once Hans has said that there should be
> no margins in an image if no selection ioctl was used. Therefore I decided
> that default and bounds rectangles should be equal for video capture.
> I am interested what is Hans' opinion about proposal of softening this
> requirement.

I think it's a good requirement for now, but we might find use cases later 
that would conflict with the requirement. If we just say that the rectangles 
must be identical, applications might use the BOUNDS target instead of the 
DEFAULT target to retrieve the default rectangle (if they're identical, why 
should they bother ?). I'd like to reword the spec to make it clear that that 
drivers must (at least for now) have identical defaults and bounds, and that 
application must use the DEFAULT target to retrieve the default rectangle in 
case the driver-side requirement gets lifted later.

> >> +<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
> > 
> > s/All pixel/All pixels/
> > 
> >> +<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>
> > 
> > How would an application remove them ?
> 
> The application may use memset if it recognizes fourcc. The idea of
> padding target was to provide information about artifacts introduced the
> hardware. If the image is decoded directly to framebuffer then the
> application could remove artifacts. We could introduce some V4L2
> control to inform if the padding are is filled with zeros to avoid
> redundant memset.
> What do you think?

OK, I understand this better now. I'm still not sure how applications will be 
able to cope with that. memset'ing the garbage area won't look good on the 
screen.

Does your hardware have different compose and padding rectangles ?

[snip]

> >> +<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.
> > 
> > You know that I still think that hints should be hints, and that ERANGE
> > should not be returned, right ? :-)
> 
> Yes.. :). There are pros and cons for hints, too.
> (+) hint can be ignored therefore is easier to implement them in drivers.
> It may speed up adoption of the selection api.
> (-) It is not possible to prevent hardware from applying the configuration
> that is not acceptable by the application. Such an unfortunate operation
> could mess up the whole pipeline.

Interesting point, I hadn't thought about it.

> I found two ways to solve the cons. The new ioctl TRY_SELECTION should be
> introduced now or in the future version of selection api. Second, the
> pipeline configuration rules may help in this case. An application should
> configure pipeline according to the rules. The setup of stages before the
> current stage is guaranteed to not modified. Therefore the unfortunate
> selection call could only mess up the stages lower in the pipeline.
> 
> The constraints idea was OK, until I found that the content of ioctl
> parameters is not copied to the userspace when the ioctl fails. Therefore
> the application receives no feedback other than ERANGE. Moreover I found out
> that is not easy to calculate the best-hit rectangle that could be returned.
> A lot of code must be added to driver to support it.
> 
> There is still one more problem with the hints. Examine following scenario.
> One tries to setup 20x20 rectangle using SEL_SIZE_LE hint. The ioctl
> succeeds but the driver returns 32x32. Does it mean?
> 
> (A) it is not possible to set a rectangle smaller than 20x20
> (B) it is not possible to set a rectangle smaller than 32x32
> (C) driver failed to configuration consistent with 20x20 (or smaller)
> rectangle.
>        It is not known if such a configuration exists.
>        Should the application continue the negotiations?
>        Size 16x16 might be good, if the driver did not implement hint
> [ignored them]
>        and rounded 20x20 to 32x32.
> 
> The solution using constraints was consistent. The ERANGE is returned and
> case (A) is valid. If constraints were transformed to hints then we should
> allow to violate hints only if there is no configuration that satisfy the
> hints.

I agree with that, drivers must not violate hints if they can be satisfied, 
otherwise they're completely pointless.

> What is your opinion about it?

I won't fight too much against a constraint-based approach :-) Not that you 
convinced me that constraints are better, but I can live with them.

-- 
Regards,

Laurent Pinchart

Re: [PATCH 2/4] v4l: add documentation for selection API

[Tomasz Stanislawski]

On 09/23/2011 03:13 PM, Laurent Pinchart wrote:

Hi Laurent,
Thank you very much for your comments. The crop/compose setup is much 
more complicated task than I expected. The discussion is very helpful to 
find the optimal solution.

>>>> +selection targets available for a video capture device. The targets
>>>> should be +configured according to the pipeline configuration rules for
>>>> a capture device.
>>>
>>> Do we have such rules written somewhere ?
>>
>> The pipeline configuration rules are not a part of V4L2 doc yet. It was
>> discussed at IRC meeting.
>> Do you think that the RFC should be posted in separate patch to V4L2 doc?
>
> As this document refers to them, I think that would be useful. We're talking
> about pipeline configuration using the video nodes API, right ?
Yes. The pipeline configuration should go with the separate RFC. For 
now, I remove this sentence. Then it will be after pipeline RFC is posted.
>
> [snip]
>
>>>> +<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>
>>>
>>> We support sub-pixel cropping, but not sub-pixel composition. Can you
>>> remind me of the rationale for that ?
>>
>> Do you mean that OMAP3 ISP supports cropping with sub-pixel resolution?
>
> No, sorry. By "we" I meant the selection API.
>
>> I thought that pixels are natural units for images stored in memory
>> buffers. But I would not be surprised if there was some weird fractal-like
>> format providing images with infinite resolution. Do you think that the
>> sentence "All coordinates are expressed in pixel" should be dropped from
>> spec?
>
> I don't know to be honest. What bothers me is that the spec allows sub-pixel
> resolution for cropping but not for composing. I'm not sure if there's any
> hardware supported by our current drivers that could make use of sub-pixel
> selections, but I don't see a reason to allow sub-pixel cropping and not sub-
> pixel composing. The solution might be to disallow sub-pixel cropping for now
> though. If we do that, can we later extend it in a clean way ?

Video Processor (VP) chip that is part of s5p-tv hardware is capable of 
subpixel cropping using polyphase filters. So the hardware is already 
present.

I have to ideas to add subpixels to selection API.

1. Introduce struct v4l2_frect similar to struct v4l2_rect. All its 
fields' type would be struct v4l2_fract.
2. Add field denominator to v4l2_selection as one of reserved fields. 
All selection coordinates would be divided by this number.

The 2nd proposal could added in the future update to selection API.

>
> [snip]
>
>>>> +<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>
>>>
>>> If they're always equal, why do we have two different targets ? :-) Maybe
>>> "is usually identical to" or "is most of the time identical to" would be
>>> better ?
>>
>> Good question. I remember that once Hans has said that there should be
>> no margins in an image if no selection ioctl was used. Therefore I decided
>> that default and bounds rectangles should be equal for video capture.
>> I am interested what is Hans' opinion about proposal of softening this
>> requirement.
>
> I think it's a good requirement for now, but we might find use cases later
> that would conflict with the requirement. If we just say that the rectangles
> must be identical, applications might use the BOUNDS target instead of the
> DEFAULT target to retrieve the default rectangle (if they're identical, why
> should they bother ?). I'd like to reword the spec to make it clear that that
> drivers must (at least for now) have identical defaults and bounds, and that
> application must use the DEFAULT target to retrieve the default rectangle in
> case the driver-side requirement gets lifted later.

OK

>
>>>> +<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
>>>
>>> s/All pixel/All pixels/
>>>
>>>> +<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>
>>>
>>> How would an application remove them ?
>>
>> The application may use memset if it recognizes fourcc. The idea of
>> padding target was to provide information about artifacts introduced the
>> hardware. If the image is decoded directly to framebuffer then the
>> application could remove artifacts. We could introduce some V4L2
>> control to inform if the padding are is filled with zeros to avoid
>> redundant memset.
>> What do you think?
>
> OK, I understand this better now. I'm still not sure how applications will be
> able to cope with that. memset'ing the garbage area won't look good on the
> screen.

The memset is just a simple and usually fast solution. The application
could fill the padding area with any pattern or background color.

>
> Does your hardware have different compose and padding rectangles ?

I assume that you mean active and padded targets for composing, right?
The answer is yes. The MFC inserts data to the image that dimensions are 
multiples of 128x32. The movie inside could be any size that fits to the 
buffer. The area that contains the movie frame is the active rectangle. 
The padded is filled with zeros. For MFC the bounds and padded rectangle 
are the same.

Hmm...

Does it violate 'no margin requirement', doesn't it?

>
> [snip]
>
>>>> +<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.
>>>
>>> You know that I still think that hints should be hints, and that ERANGE
>>> should not be returned, right ? :-)
>>
>> Yes.. :). There are pros and cons for hints, too.
>> (+) hint can be ignored therefore is easier to implement them in drivers.
>> It may speed up adoption of the selection api.
>> (-) It is not possible to prevent hardware from applying the configuration
>> that is not acceptable by the application. Such an unfortunate operation
>> could mess up the whole pipeline.
>
> Interesting point, I hadn't thought about it.
>
>> I found two ways to solve the cons. The new ioctl TRY_SELECTION should be
>> introduced now or in the future version of selection api. Second, the
>> pipeline configuration rules may help in this case. An application should
>> configure pipeline according to the rules. The setup of stages before the
>> current stage is guaranteed to not modified. Therefore the unfortunate
>> selection call could only mess up the stages lower in the pipeline.
>>
>> The constraints idea was OK, until I found that the content of ioctl
>> parameters is not copied to the userspace when the ioctl fails. Therefore
>> the application receives no feedback other than ERANGE. Moreover I found out
>> that is not easy to calculate the best-hit rectangle that could be returned.
>> A lot of code must be added to driver to support it.
>>
>> There is still one more problem with the hints. Examine following scenario.
>> One tries to setup 20x20 rectangle using SEL_SIZE_LE hint. The ioctl
>> succeeds but the driver returns 32x32. Does it mean?
>>
>> (A) it is not possible to set a rectangle smaller than 20x20
>> (B) it is not possible to set a rectangle smaller than 32x32
>> (C) driver failed to configuration consistent with 20x20 (or smaller)
>> rectangle.
>>         It is not known if such a configuration exists.
>>         Should the application continue the negotiations?
>>         Size 16x16 might be good, if the driver did not implement hint
>> [ignored them]
>>         and rounded 20x20 to 32x32.
>>
>> The solution using constraints was consistent. The ERANGE is returned and
>> case (A) is valid. If constraints were transformed to hints then we should
>> allow to violate hints only if there is no configuration that satisfy the
>> hints.
>
> I agree with that, drivers must not violate hints if they can be satisfied,
> otherwise they're completely pointless.

So the practical difference between hints and constraints is that
with hints it is possible to apply configuration that is not accepted by 
application. Moreover, after calling {S/TRY}_SELECTION the driver must 
always return the best-hit rectangle, which may be difficult to compute, 
even if it will not be accepted by the application.

Surprisingly, it may be easier for the constraints to be implemented 
correctly than to implement the hint.

>
>> What is your opinion about it?
>
> I won't fight too much against a constraint-based approach :-) Not that you
> convinced me that constraints are better, but I can live with them.
>

--
Best Regards,
Tomasz Stanislawski

Re: [PATCH 2/4] v4l: add documentation for selection API

[Laurent Pinchart]

Hi Tomasz,

On Friday 23 September 2011 17:22:27 Tomasz Stanislawski wrote:
> On 09/23/2011 03:13 PM, Laurent Pinchart wrote:

[snip]

> >>>> +<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>
> >>> 
> >>> We support sub-pixel cropping, but not sub-pixel composition. Can you
> >>> remind me of the rationale for that ?
> >> 
> >> Do you mean that OMAP3 ISP supports cropping with sub-pixel resolution?
> > 
> > No, sorry. By "we" I meant the selection API.
> > 
> >> I thought that pixels are natural units for images stored in memory
> >> buffers. But I would not be surprised if there was some weird
> >> fractal-like format providing images with infinite resolution. Do you
> >> think that the sentence "All coordinates are expressed in pixel" should
> >> be dropped from spec?
> > 
> > I don't know to be honest. What bothers me is that the spec allows
> > sub-pixel resolution for cropping but not for composing. I'm not sure if
> > there's any hardware supported by our current drivers that could make
> > use of sub-pixel selections, but I don't see a reason to allow sub-pixel
> > cropping and not sub- pixel composing. The solution might be to disallow
> > sub-pixel cropping for now though. If we do that, can we later extend it
> > in a clean way ?
> 
> Video Processor (VP) chip that is part of s5p-tv hardware is capable of
> subpixel cropping using polyphase filters. So the hardware is already
> present.
> 
> I have to ideas to add subpixels to selection API.
> 
> 1. Introduce struct v4l2_frect similar to struct v4l2_rect. All its
> fields' type would be struct v4l2_fract.
> 2. Add field denominator to v4l2_selection as one of reserved fields.
> All selection coordinates would be divided by this number.
> 
> The 2nd proposal could added in the future update to selection API.

The second solution seems the simplest. Drivers will likely not support 
arbitrary denominators, so we also need a way to report the acceptable 
value(s) to userspace.

[snip]

> >>>> +<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
> >>> 
> >>> s/All pixel/All pixels/
> >>> 
> >>>> +<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>
> >>> 
> >>> How would an application remove them ?
> >> 
> >> The application may use memset if it recognizes fourcc. The idea of
> >> padding target was to provide information about artifacts introduced the
> >> hardware. If the image is decoded directly to framebuffer then the
> >> application could remove artifacts. We could introduce some V4L2
> >> control to inform if the padding are is filled with zeros to avoid
> >> redundant memset.
> >> What do you think?
> > 
> > OK, I understand this better now. I'm still not sure how applications
> > will be able to cope with that. memset'ing the garbage area won't look
> > good on the screen.
> 
> The memset is just a simple and usually fast solution. The application
> could fill the padding area with any pattern or background color.
> 
> > Does your hardware have different compose and padding rectangles ?
> 
> I assume that you mean active and padded targets for composing, right?
> The answer is yes. The MFC inserts data to the image that dimensions are
> multiples of 128x32. The movie inside could be any size that fits to the
> buffer. The area that contains the movie frame is the active rectangle.
> The padded is filled with zeros. For MFC the bounds and padded rectangle
> are the same.
> 
> Hmm...
> 
> Does it violate 'no margin requirement', doesn't it?

Seems so :-)

> >>>> +<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.
> >>> 
> >>> You know that I still think that hints should be hints, and that ERANGE
> >>> should not be returned, right ? :-)
> >> 
> >> Yes.. :). There are pros and cons for hints, too.
> >> (+) hint can be ignored therefore is easier to implement them in
> >> drivers. It may speed up adoption of the selection api.
> >> (-) It is not possible to prevent hardware from applying the
> >> configuration that is not acceptable by the application. Such an
> >> unfortunate operation could mess up the whole pipeline.
> > 
> > Interesting point, I hadn't thought about it.
> > 
> >> I found two ways to solve the cons. The new ioctl TRY_SELECTION should
> >> be introduced now or in the future version of selection api. Second,
> >> the pipeline configuration rules may help in this case. An application
> >> should configure pipeline according to the rules. The setup of stages
> >> before the current stage is guaranteed to not modified. Therefore the
> >> unfortunate selection call could only mess up the stages lower in the
> >> pipeline.
> >> 
> >> The constraints idea was OK, until I found that the content of ioctl
> >> parameters is not copied to the userspace when the ioctl fails.
> >> Therefore the application receives no feedback other than ERANGE.
> >> Moreover I found out that is not easy to calculate the best-hit
> >> rectangle that could be returned. A lot of code must be added to driver
> >> to support it.
> >> 
> >> There is still one more problem with the hints. Examine following
> >> scenario. One tries to setup 20x20 rectangle using SEL_SIZE_LE hint.
> >> The ioctl succeeds but the driver returns 32x32. Does it mean?
> >> 
> >> (A) it is not possible to set a rectangle smaller than 20x20
> >> (B) it is not possible to set a rectangle smaller than 32x32
> >> (C) driver failed to configuration consistent with 20x20 (or smaller)
> >> rectangle.
> >> 
> >>         It is not known if such a configuration exists.
> >>         Should the application continue the negotiations?
> >>         Size 16x16 might be good, if the driver did not implement hint
> >> 
> >> [ignored them]
> >> 
> >>         and rounded 20x20 to 32x32.
> >> 
> >> The solution using constraints was consistent. The ERANGE is returned
> >> and case (A) is valid. If constraints were transformed to hints then we
> >> should allow to violate hints only if there is no configuration that
> >> satisfy the hints.
> > 
> > I agree with that, drivers must not violate hints if they can be
> > satisfied, otherwise they're completely pointless.
> 
> So the practical difference between hints and constraints is that
> with hints it is possible to apply configuration that is not accepted by
> application. Moreover, after calling {S/TRY}_SELECTION the driver must
> always return the best-hit rectangle, which may be difficult to compute,
> even if it will not be accepted by the application.
> 
> Surprisingly, it may be easier for the constraints to be implemented
> correctly than to implement the hint.

I think the driver should always return the best-hit rectangle, regardless of 
whether we use hints or not.

-- 
Regards,

Laurent Pinchart

Re: [PATCH 2/4] v4l: add documentation for selection API

[Tomasz Stanislawski]

Hi Laurent,

On 09/27/2011 01:17 PM, Laurent Pinchart wrote:
> Hi Tomasz,
>
> On Friday 23 September 2011 17:22:27 Tomasz Stanislawski wrote:
>> On 09/23/2011 03:13 PM, Laurent Pinchart wrote:
>

[snip]

>>
>> I have to ideas to add subpixels to selection API.
>>
>> 1. Introduce struct v4l2_frect similar to struct v4l2_rect. All its
>> fields' type would be struct v4l2_fract.
>> 2. Add field denominator to v4l2_selection as one of reserved fields.
>> All selection coordinates would be divided by this number.
>>
>> The 2nd proposal could added in the future update to selection API.
>
> The second solution seems the simplest. Drivers will likely not support
> arbitrary denominators, so we also need a way to report the acceptable
> value(s) to userspace.
>

The driver could set denominator to zero for G_SELECTION to indicate 
that no subpixel resolutions are supported. Moreover it is easy to 
convert fractional value to integers because rounding would be 
controlled by the constraints flags. This operation could be done by new 
helper function from V4L2 kernel API.

[snip]

>>>>>
>>>>> How would an application remove them ?
>>>>
>>>> The application may use memset if it recognizes fourcc. The idea of
>>>> padding target was to provide information about artifacts introduced the
>>>> hardware. If the image is decoded directly to framebuffer then the
>>>> application could remove artifacts. We could introduce some V4L2
>>>> control to inform if the padding are is filled with zeros to avoid
>>>> redundant memset.
>>>> What do you think?
>>>
>>> OK, I understand this better now. I'm still not sure how applications
>>> will be able to cope with that. memset'ing the garbage area won't look
>>> good on the screen.
>>
>> The memset is just a simple and usually fast solution. The application
>> could fill the padding area with any pattern or background color.
>>
>>> Does your hardware have different compose and padding rectangles ?
>>
>> I assume that you mean active and padded targets for composing, right?
>> The answer is yes. The MFC inserts data to the image that dimensions are
>> multiples of 128x32. The movie inside could be any size that fits to the
>> buffer. The area that contains the movie frame is the active rectangle.
>> The padded is filled with zeros. For MFC the bounds and padded rectangle
>> are the same.
>>
>> Hmm...
>>
>> Does it violate 'no margin requirement', doesn't it?
>
> Seems so :-)
>

For S5P MFC is it not possible to satisfy 'no margin' requirement in all 
cases. The default rectangle is not equal to the bound rectangle in all 
cases. BTW, the MFC is mem2mem device so its API may change.
To sum up for MFC following inequalities are satisfied:

active <= padded == bound

Do you think that 'no margin' requirement should be downgraded to a 
recommendation status?

[snip]

>
> I think the driver should always return the best-hit rectangle, regardless of
> whether we use hints or not.
>

The problem is that when the VIDIOC_S_SELECTION fails (could not satisfy 
constraints) then the ioctl'a parameters are not copied to the 
userspace. So no best-hit rectangle can be returned. On the other hand, 
if the ioctl would not fail in this case then the configuration is 
applied, causing pipeline messing. We have no-win situation.

If the application accepts all rectangles then it should never use the 
constraint flags in the first place. Moreover, the application can 
always remove the constraints flags and try again. At least, the fall 
back is done explicitly in that case.

The VIDIOC_TRY_SELECTION could be added to cope with more complex 
negotiations.

Best regards,
Tomasz Stanislawski

RE: [PATCH 2/4] v4l: add documentation for selection API

[Kamil Debski]

Hi Tomasz and Laurent,

I have commented on the MFC case below.

> From: Tomasz Stanislawski [mailto:t.stanislaws@samsung.com]
> 
> Hi Laurent,
> 
> On 09/27/2011 01:17 PM, Laurent Pinchart wrote:
> > Hi Tomasz,
> >
> > On Friday 23 September 2011 17:22:27 Tomasz Stanislawski wrote:
> >> On 09/23/2011 03:13 PM, Laurent Pinchart wrote:
> >
> 

[snip]
> 
> >>>>>
> >>>>> How would an application remove them ?
> >>>>
> >>>> The application may use memset if it recognizes fourcc. The idea of
> >>>> padding target was to provide information about artifacts introduced
> the
> >>>> hardware. If the image is decoded directly to framebuffer then the
> >>>> application could remove artifacts. We could introduce some V4L2
> >>>> control to inform if the padding are is filled with zeros to avoid
> >>>> redundant memset.
> >>>> What do you think?
> >>>
> >>> OK, I understand this better now. I'm still not sure how applications
> >>> will be able to cope with that. memset'ing the garbage area won't look
> >>> good on the screen.
> >>
> >> The memset is just a simple and usually fast solution. The application
> >> could fill the padding area with any pattern or background color.
> >>
> >>> Does your hardware have different compose and padding rectangles ?
> >>
> >> I assume that you mean active and padded targets for composing, right?
> >> The answer is yes. The MFC inserts data to the image that dimensions are
> >> multiples of 128x32. The movie inside could be any size that fits to the
> >> buffer. The area that contains the movie frame is the active rectangle.
> >> The padded is filled with zeros. For MFC the bounds and padded rectangle
> >> are the same.
> >>
> >> Hmm...
> >>
> >> Does it violate 'no margin requirement', doesn't it?
> >
> > Seems so :-)
> >
> 
> For S5P MFC is it not possible to satisfy 'no margin' requirement in all
> cases. The default rectangle is not equal to the bound rectangle in all
> cases. BTW, the MFC is mem2mem device so its API may change.
> To sum up for MFC following inequalities are satisfied:
> 
> active <= padded == bound
> 
> Do you think that 'no margin' requirement should be downgraded to a
> recommendation status?

In case of MFC it will be active == padded <= bound as MFC does not fill the
region outside the active zone with zeroes. That pixels are not modified.

The 'no margin requirement' as I understand should not be imposed. I can imagine
other hardware than MFC that may have the default crop other than the full buffer
size. This will be especially common in case of various tiled image formats.
In MFC we have 128x32 tiles, but the movie size can be any number (If I remember
correctly).


[snip]


Best wishes,
--
Kamil Debski
Linux Platform Group
Samsung Poland R&D Center

Re: [PATCH 2/4] v4l: add documentation for selection API

[Hans Verkuil]

On Wednesday, August 31, 2011 14:28:21 Tomasz Stanislawski wrote:
> 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       |  281 ++
>  6 files changed, 3634 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

For future reference: please put binary files in a separate patch. That makes
it easier to review the non-binary parts.

> 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>

I wouldn't call this deprecated. It's part of the API and we will just keep on
supporting this.

I would instead refer to the new section on the selection API.

>  
>      <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>

I know this phrase is present in the crop API, but I've never liked it. It makes
life very hard for applications if the units aren't in pixels. The main reason
the crop API was written in that way was for analog video receivers: while analog
TV has discrete lines, in the horizontal direction there really isn't a clear
'pixel' concept. However, I've always thought that was a bogus argument since
after sampling you end up with pixels anyway.

In my opinion the selection API should deal with pixels only. The main driver
where this might cause problems is bttv. I'm not sure how the selection vs crop
API translation would work there. It might be best to just keep the current crop
implementation in bttv and make a separate selection implementation. I'm pretty
sure the bttv driver actually does/can do sub-pixel cropping.

With respect to the origin: I think I would put the top-left corner of the
default crop rectangle at (0, 0). Strictly speaking it shouldn't matter where
the origin is, but it seems to me that that's a logical choice.

> +<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.

Same as before: I would always use pixels as units.

> 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.

I would remove the 'align with the center of the active picture area' part.
I think the second part of that sentence is sufficient.

In addition, just like with capture, I would suggest that the origin of the default
compose rectangle is set to (0, 0).

> 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..6d93832
> --- /dev/null
> +++ b/Documentation/DocBook/media/v4l/vidioc-g-selection.xml
> @@ -0,0 +1,281 @@
> +<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. 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>Selection targets.</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>__u32</entry>
> +	    <entry><structfield>type</structfield></entry>
> +	    <entry>Type of the buffer (from &v4l2-buf-type;)</entry>
> +	  </row>
> +	  <row>
> +	    <entry>__u32</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>

I would remove the 'adjust size' part. It's not relevant here.

> +	  </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>
> 

BTW, I think it might be a good idea to do one more post of this patch series.
There have been several reviews after your git pull request, so I think it's
just a bit too early to have this merged. One more round is probably enough.

Regards,

	Hans

Re: [PATCH 2/4] v4l: add documentation for selection API

[Laurent Pinchart]

On Tuesday 27 September 2011 11:20:29 Hans Verkuil wrote:
> On Wednesday, August 31, 2011 14:28:21 Tomasz Stanislawski wrote:
> > 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>

[snip]

> >    <section id="crop">
> > 
> > -    <title>Image Cropping, Insertion and Scaling</title>
> > +    <title>Deprecated API for image cropping, insertion and
> > scaling</title>
> 
> I wouldn't call this deprecated. It's part of the API and we will just keep
> on supporting this.

I think we should still encourage driver and application developers to 
implement the selection API and use it when available instead of the crop API.

> I would instead refer to the new section on the selection API.

[snip]

> > +<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>
> 
> I know this phrase is present in the crop API, but I've never liked it. It
> makes life very hard for applications if the units aren't in pixels. The
> main reason the crop API was written in that way was for analog video
> receivers: while analog TV has discrete lines, in the horizontal direction
> there really isn't a clear 'pixel' concept. However, I've always thought
> that was a bogus argument since after sampling you end up with pixels
> anyway.
> 
> In my opinion the selection API should deal with pixels only.

What about hardware that supports sub-pixel cropping and/or composing ?

> The main driver where this might cause problems is bttv. I'm not sure how
> the selection vs crop API translation would work there. It might be best to
> just keep the current crop implementation in bttv and make a separate
> selection implementation. I'm pretty sure the bttv driver actually
> does/can do sub-pixel cropping.
> 
> With respect to the origin: I think I would put the top-left corner of the
> default crop rectangle at (0, 0). Strictly speaking it shouldn't matter
> where the origin is, but it seems to me that that's a logical choice.

For sensor drivers I found it easier to have the pixel array origin at (0, 0). 
It might just be me though.

-- 
Regards,

Laurent Pinchart

Re: [PATCH 2/4] v4l: add documentation for selection API

[Hans Verkuil]

On Tuesday, September 27, 2011 13:11:35 Laurent Pinchart wrote:
> On Tuesday 27 September 2011 11:20:29 Hans Verkuil wrote:
> > On Wednesday, August 31, 2011 14:28:21 Tomasz Stanislawski wrote:
> > > 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>
> 
> [snip]
> 
> > >    <section id="crop">
> > > 
> > > -    <title>Image Cropping, Insertion and Scaling</title>
> > > +    <title>Deprecated API for image cropping, insertion and
> > > scaling</title>
> > 
> > I wouldn't call this deprecated. It's part of the API and we will just keep
> > on supporting this.
> 
> I think we should still encourage driver and application developers to 
> implement the selection API and use it when available instead of the crop API.

New drivers should use the selection API and old drivers are encouraged
to convert to the selection API. But the existing crop API can't go away.
And applications can't use it any time soon (it takes years before all customers
are on kernels that have the selection API).

And anyway, an ioctl like G/S_CROP can't be deprecated. It's been part of V4L2
for ages and it just works fine for those use-cases.

For driver development it is a different story, but that's outside the scope
of the V4L2 spec.

> > I would instead refer to the new section on the selection API.
> 
> [snip]
> 
> > > +<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>
> > 
> > I know this phrase is present in the crop API, but I've never liked it. It
> > makes life very hard for applications if the units aren't in pixels. The
> > main reason the crop API was written in that way was for analog video
> > receivers: while analog TV has discrete lines, in the horizontal direction
> > there really isn't a clear 'pixel' concept. However, I've always thought
> > that was a bogus argument since after sampling you end up with pixels
> > anyway.
> > 
> > In my opinion the selection API should deal with pixels only.
> 
> What about hardware that supports sub-pixel cropping and/or composing ?

That should be an addition to the API: sub-pixel targets etc. We would need
to discuss that in more detail (how is it done? how are the sub-pixels defined?
how would you represent it?). We may even only support such things on the
subdev API. I just can't see any 'normal' application wanting to use sub-pixel
cropping/composing.

> > The main driver where this might cause problems is bttv. I'm not sure how
> > the selection vs crop API translation would work there. It might be best to
> > just keep the current crop implementation in bttv and make a separate
> > selection implementation. I'm pretty sure the bttv driver actually
> > does/can do sub-pixel cropping.
> > 
> > With respect to the origin: I think I would put the top-left corner of the
> > default crop rectangle at (0, 0). Strictly speaking it shouldn't matter
> > where the origin is, but it seems to me that that's a logical choice.
> 
> For sensor drivers I found it easier to have the pixel array origin at (0, 0). 
> It might just be me though.

This was just a suggestion from me. We may also leave it to the driver.
I don't have a very strong opinion on this.

Regards,

	Hans

Re: [PATCH 2/4] v4l: add documentation for selection API

[Tomasz Stanislawski]

Hi Hans,
Thank you for a quick review :).

On 09/27/2011 11:20 AM, Hans Verkuil wrote:
> On Wednesday, August 31, 2011 14:28:21 Tomasz Stanislawski wrote:
>> 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       |  281 ++
>>   6 files changed, 3634 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
>
> For future reference: please put binary files in a separate patch. That makes
> it easier to review the non-binary parts.
>
ok.
>> 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>
>
> I wouldn't call this deprecated. It's part of the API and we will just keep on
> supporting this.
>
> I would instead refer to the new section on the selection API.
>

I decided to mark the selection as an experimental API for now. I agree 
that it was too hasty to deprecate old API.

>>
>>       <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>
>> +

[snip]

>> +<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>
>
> I know this phrase is present in the crop API, but I've never liked it. It makes
> life very hard for applications if the units aren't in pixels.

Why?

> The main reason
> the crop API was written in that way was for analog video receivers: while analog
> TV has discrete lines, in the horizontal direction there really isn't a clear
> 'pixel' concept. However, I've always thought that was a bogus argument since
> after sampling you end up with pixels anyway.

It looks that the problem is the scaling. The unit system should just 
guarantee that no scaling is applied if the size of the crop rectangle 
is equal to the size of the compose rectangle. Am I wrong?

What do you think about adding the mentioned requirement?

>
> In my opinion the selection API should deal with pixels only. The main driver
> where this might cause problems is bttv. I'm not sure how the selection vs crop
> API translation would work there. It might be best to just keep the current crop
> implementation in bttv and make a separate selection implementation. I'm pretty
> sure the bttv driver actually does/can do sub-pixel cropping.

The crop simulation using the selection api is applied only if s_crop or 
s_cropcap are not implemented. Therefore a driver can implement both 
APIs separately.

>
> With respect to the origin: I think I would put the top-left corner of the
> default crop rectangle at (0, 0). Strictly speaking it shouldn't matter where
> the origin is, but it seems to me that that's a logical choice.

OK. It is logical to put the origin at (0,0) but why forcing it? Maybe 
it should be only a recommendation for driver developers.

>
>> +<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>

[snip]

>> +<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.
>
> Same as before: I would always use pixels as units.
>

The units system should only guarantee that there is no scaling if the 
sizes of the crop and the compose rectangles are equal. I prefer to 
avoid forcing the usage of the pixel units in every context.

>> 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.
>
> I would remove the 'align with the center of the active picture area' part.
> I think the second part of that sentence is sufficient.
>

OK. The first sentence is redundant.

> In addition, just like with capture, I would suggest that the origin of the default
> compose rectangle is set to (0, 0).

I think that (0,0) origin should be only a recommendation.

>
>> Drivers shall reset the
>> +composing rectangle to the default one when the driver is first loaded.</para>
>> +

[snip]

>> +<title>struct<structname>v4l2_selection</structname></title>
>> +<tgroup cols="3">
>> +	&cs-str;
>> +	<tbody valign="top">
>> +	<row>
>> +	<entry>__u32</entry>
>> +	<entry><structfield>type</structfield></entry>
>> +	<entry>Type of the buffer (from&v4l2-buf-type;)</entry>
>> +	</row>
>> +	<row>
>> +	<entry>__u32</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>
>
> I would remove the 'adjust size' part. It's not relevant here.
>

OK.
[snip]

>
> BTW, I think it might be a good idea to do one more post of this patch series.
> There have been several reviews after your git pull request, so I think it's
> just a bit too early to have this merged. One more round is probably enough.
>

I am preparing the new version that covers issues pointed by you, 
Laurent and Mauro.

Could you state your opinion about Mauro's comments?

Regards,
Tomasz Stanislawski


> Regards,
>
> 	Hans
>

Re: [PATCH 2/4] v4l: add documentation for selection API

[Hans Verkuil]

On Tuesday, September 27, 2011 15:36:15 Tomasz Stanislawski wrote:
> Hi Hans,
> Thank you for a quick review :).
> 
> On 09/27/2011 11:20 AM, Hans Verkuil wrote:
> > On Wednesday, August 31, 2011 14:28:21 Tomasz Stanislawski wrote:
> >> 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       |  281 ++
> >>   6 files changed, 3634 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
> >
> > For future reference: please put binary files in a separate patch. That makes
> > it easier to review the non-binary parts.
> >
> ok.
> >> 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>
> >
> > I wouldn't call this deprecated. It's part of the API and we will just keep on
> > supporting this.
> >
> > I would instead refer to the new section on the selection API.
> >
> 
> I decided to mark the selection as an experimental API for now. I agree 
> that it was too hasty to deprecate old API.
> 
> >>
> >>       <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>
> >> +
> 
> [snip]
> 
> >> +<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>
> >
> > I know this phrase is present in the crop API, but I've never liked it. It makes
> > life very hard for applications if the units aren't in pixels.
> 
> Why?

Basically it is a lot of calculations that you have to do. In my experience
you just want to crop to a specific area of the image. The combination of
arbitrary units and origin makes it difficult to calculate the right cropping
rectangle. Actually using sub-pixel cropping is something I have never seen
anyone do. Perhaps in 1% of the cases you might want something like that, but
then I think that is something that should be explicitly set up.

What's the use case for sub-pixel cropping/composing anyway? And how would you
use sub-pixel composing into a buffer?

> > The main reason
> > the crop API was written in that way was for analog video receivers: while analog
> > TV has discrete lines, in the horizontal direction there really isn't a clear
> > 'pixel' concept. However, I've always thought that was a bogus argument since
> > after sampling you end up with pixels anyway.
> 
> It looks that the problem is the scaling. The unit system should just 
> guarantee that no scaling is applied if the size of the crop rectangle 
> is equal to the size of the compose rectangle. Am I wrong?

That's certainly true. But not really my point. In the vast majority of all
use-cases you deal with pixels. So that's a natural and easy to use unit IMHO.

> What do you think about adding the mentioned requirement?
> 
> >
> > In my opinion the selection API should deal with pixels only. The main driver
> > where this might cause problems is bttv. I'm not sure how the selection vs crop
> > API translation would work there. It might be best to just keep the current crop
> > implementation in bttv and make a separate selection implementation. I'm pretty
> > sure the bttv driver actually does/can do sub-pixel cropping.
> 
> The crop simulation using the selection api is applied only if s_crop or 
> s_cropcap are not implemented. Therefore a driver can implement both 
> APIs separately.

Right.
 
> >
> > With respect to the origin: I think I would put the top-left corner of the
> > default crop rectangle at (0, 0). Strictly speaking it shouldn't matter where
> > the origin is, but it seems to me that that's a logical choice.
> 
> OK. It is logical to put the origin at (0,0) but why forcing it? Maybe 
> it should be only a recommendation for driver developers.

Making it a recommendation is fine by me.

> >
> >> +<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>
> 
> [snip]
> 
> >> +<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.
> >
> > Same as before: I would always use pixels as units.
> >
> 
> The units system should only guarantee that there is no scaling if the 
> sizes of the crop and the compose rectangles are equal. I prefer to 
> avoid forcing the usage of the pixel units in every context.
> 
> >> 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.
> >
> > I would remove the 'align with the center of the active picture area' part.
> > I think the second part of that sentence is sufficient.
> >
> 
> OK. The first sentence is redundant.
> 
> > In addition, just like with capture, I would suggest that the origin of the default
> > compose rectangle is set to (0, 0).
> 
> I think that (0,0) origin should be only a recommendation.
> 
> >
> >> Drivers shall reset the
> >> +composing rectangle to the default one when the driver is first loaded.</para>
> >> +
> 
> [snip]
> 
> >> +<title>struct<structname>v4l2_selection</structname></title>
> >> +<tgroup cols="3">
> >> +	&cs-str;
> >> +	<tbody valign="top">
> >> +	<row>
> >> +	<entry>__u32</entry>
> >> +	<entry><structfield>type</structfield></entry>
> >> +	<entry>Type of the buffer (from&v4l2-buf-type;)</entry>
> >> +	</row>
> >> +	<row>
> >> +	<entry>__u32</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>
> >
> > I would remove the 'adjust size' part. It's not relevant here.
> >
> 
> OK.
> [snip]
> 
> >
> > BTW, I think it might be a good idea to do one more post of this patch series.
> > There have been several reviews after your git pull request, so I think it's
> > just a bit too early to have this merged. One more round is probably enough.
> >
> 
> I am preparing the new version that covers issues pointed by you, 
> Laurent and Mauro.
> 
> Could you state your opinion about Mauro's comments?

I haven't read his comments yet :-)

Regards,

	Hans

> 
> Regards,
> Tomasz Stanislawski
> 
> 
> > Regards,
> >
> > 	Hans
> >
> 

[PATCH 3/4] v4l: emulate 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 emulated 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, 74 insertions(+), 12 deletions(-)

diff --git a/drivers/media/video/v4l2-ioctl.c b/drivers/media/video/v4l2-ioctl.c
index 6e02b45..bb99c71 100644
--- a/drivers/media/video/v4l2-ioctl.c
+++ b/drivers/media/video/v4l2-ioctl.c
@@ -1696,11 +1696,29 @@ static long __video_do_ioctl(struct file *file,
 	{
 		struct v4l2_crop *p = arg;
 
-		if (!ops->vidioc_g_crop)
-			break;
-
 		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
-		ret = ops->vidioc_g_crop(file, fh, p);
+
+		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,
+			};
+
+			/* crop means compose for output devices */
+			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
+				s.target = V4L2_SEL_COMPOSE_ACTIVE;
+			else
+				s.target = V4L2_SEL_CROP_ACTIVE;
+
+			ret = ops->vidioc_g_selection(file, fh, &s);
+
+			/* copying results to old structure on success */
+			if (!ret)
+				p->c = s.r;
+		}
+
 		if (!ret)
 			dbgrect(vfd, "", &p->c);
 		break;
@@ -1709,11 +1727,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,
+				.r = p->c,
+			};
+
+			/* crop means compose for output devices */
+			if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
+				s.target = V4L2_SEL_COMPOSE_ACTIVE;
+			else
+				s.target = V4L2_SEL_CROP_ACTIVE;
+
+			ret = ops->vidioc_s_selection(file, fh, &s);
+		}
 		break;
 	}
 	case VIDIOC_G_SELECTION:
@@ -1746,12 +1779,41 @@ static long __video_do_ioctl(struct file *file,
 	{
 		struct v4l2_cropcap *p = arg;
 
-		/*FIXME: Should also show v4l2_fract pixelaspect */
-		if (!ops->vidioc_cropcap)
-			break;
-
 		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
-		ret = ops->vidioc_cropcap(file, fh, p);
+		if (ops->vidioc_cropcap) {
+			ret = ops->vidioc_cropcap(file, fh, p);
+		} else
+		if (ops->vidioc_g_selection) {
+			struct v4l2_selection s = { .type = p->type };
+
+			/* 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;
+			p->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;
+			p->defrect = s.r;
+
+			/* setting trivial pixelaspect */
+			p->pixelaspect.numerator = 1;
+			p->pixelaspect.denominator = 1;
+		}
+
+		/*FIXME: Should also show v4l2_fract pixelaspect */
 		if (!ret) {
 			dbgrect(vfd, "bounds ", &p->bounds);
 			dbgrect(vfd, "defrect ", &p->defrect);
-- 
1.7.6

[PATCH 4/4] 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     |  339 +++++++++++++++++---------
 drivers/media/video/s5p-tv/mixer_vp_layer.c  |  108 ++++++---
 4 files changed, 422 insertions(+), 196 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..7952794 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..6abed42 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,191 @@ 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)
+/* returns 1 if rectangle 'a' is inside 'b' */
+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 = NULL;
+	enum mxr_geometry_stage stage;
+	struct mxr_geometry tmp;
+	struct v4l2_rect res;
 
-	mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
-	crop = choose_crop_by_type(&layer->geo, a->type);
-	if (crop == NULL)
+	memset(&res, 0, sizeof res);
+
+	mxr_dbg(layer->mdev, "%s: rect: %dx%d@%d,%d\n", __func__,
+		s->r.width, s->r.height, s->r.left, s->r.top);
+
+	if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
+		return -EINVAL;
+	switch (s->target) {
+	/* ignore read-only targets */
+	case V4L2_SEL_CROP_DEFAULT:
+	case V4L2_SEL_CROP_BOUNDS:
+		res.width = geo->src.full_width;
+		res.height = geo->src.full_height;
+		break;
+
+	/* ignore read-only targets */
+	case V4L2_SEL_COMPOSE_DEFAULT:
+	case V4L2_SEL_COMPOSE_BOUNDS:
+		res.width = geo->dst.full_width;
+		res.height = geo->dst.full_height;
+		break;
+
+	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;
-	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;
+	}
+	/* apply change and update geometry if needed */
+	if (target) {
+		/* backup current geometry if setup fails */
+		memcpy(&tmp, geo, sizeof tmp);
+
+		/* apply requested selection */
+		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);
+
+		/* retrieve update selection rectangle */
+		res.left = target->x_offset;
+		res.top = target->y_offset;
+		res.width = target->width;
+		res.height = target->height;
+
+		mxr_geometry_dump(layer->mdev, &layer->geo);
+	}
+
+	/* checking if the rectangle satisfies constraints */
+	if ((s->flags & V4L2_SEL_SIZE_LE) && !mxr_is_rect_inside(&res, &s->r))
+		goto fail;
+	if ((s->flags & V4L2_SEL_SIZE_GE) && !mxr_is_rect_inside(&s->r, &res))
+		goto fail;
+
+	/* return result rectangle */
+	s->r = res;
+
 	return 0;
+fail:
+	/* restore old geometry, which is not touched if target is NULL */
+	if (target)
+		memcpy(geo, &tmp, sizeof tmp);
+	return -ERANGE;
 }
 
 static int mxr_enum_dv_presets(struct file *file, void *fh,
@@ -437,6 +534,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 +576,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 +626,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 +735,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 +909,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..06fa13b 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