From 4567dd4b7a9556921097064ee5293c954804f5b0 Mon Sep 17 00:00:00 2001
From: Qianqian Fang <fangqq@gmail.com>
Date: Sat, 16 Apr 2022 14:05:00 -0400
Subject: [PATCH 01/13] output in bmsh format

---
 README.md      |   9 +--
 src/meshify.c  | 178 ++++++++++++++++++++++++++++++++++++++++++++++---
 src/nii2mesh.c |   4 +-
 3 files changed, 174 insertions(+), 17 deletions(-)

diff --git a/README.md b/README.md
index 18f7650..31f4aed 100644
--- a/README.md
+++ b/README.md
@@ -55,7 +55,7 @@ Options
     -q v    quality (0=fast, 1= balanced, 2=best, default 1)
     -s v    post-smoothing iterations (default 0)
     -v v    verbose (0=silent, 1=verbose, default 0)
-mesh extension sets format (.gii, .mz3, .obj, .ply, .pial, .stl, .vtk)
+mesh extension sets format (.gii, .mz3, .bmsh, .json, .obj, .ply, .pial, .stl, .vtk)
 Example: './nii2mesh voxels.nii mesh.obj'
 Example: './nii2mesh bet.nii.gz -i 22 myOutput.obj'
 Example: './nii2mesh bet.nii.gz -i b bright.obj'
@@ -165,7 +165,7 @@ with the resulting meshes have the file names `D99_pu.k1.gii`, `D99_cd.k2.gii`,
 
 ## Supported Mesh Formats
 
-nii2mesh can save meshes to the GIfTI (.gii), json, jmsh, mz3, obj, off, ply, FreeSurfer (.pial), stl, vtk.  [MeshLab](https://www.meshlab.net) can export meshes to many other formats. Therefore, one option is to create a PLY mesh with nii2mesh and use MeshLab to export to your favorite format.
+nii2mesh can save meshes to the GIfTI (.gii), JSON, JMesh (.jmsh, .bmsh), mz3, obj, off, ply, FreeSurfer (.pial), stl, vtk.  [MeshLab](https://www.meshlab.net) can export meshes to many other formats. Therefore, one option is to create a PLY mesh with nii2mesh and use MeshLab to export to your favorite format.
 
  - [GIfTI](https://www.nitrc.org/projects/gifti/) is a popular Geometry format for Neuroimaging. The usage of base64 encoding leads to relatively large files and slow loading.
  - [OBJ](http://www.paulbourke.net/dataformats/obj/) format is very popular, and may be a great choice for 3D printing. The use of ASCII rather than binary encoding makes these files large, slow to read and typically suggests limited precision.
@@ -173,8 +173,9 @@ nii2mesh can save meshes to the GIfTI (.gii), json, jmsh, mz3, obj, off, ply, Fr
  - [PLY](http://paulbourke.net/dataformats/ply/) is an old format that is widely supported. The binary form created by nii2mesh yields small files and quick loading time.
  - [MZ3](https://github.com/neurolabusc/surf-ice/tree/master/mz3) is the native format of [Surfice](https://www.nitrc.org/projects/surfice/). It is small and fast, but not widely supported.
  - [FreeSurfer](https://surfer.nmr.mgh.harvard.edu) format is simple and used by FreeSurfer.
- - [json](https://github.com/fangq/jmesh) creates human readable ASCII JSON files in the format described by [jmesh](https://github.com/fangq/jmesh). Be aware that other tools create legal JSON files to describe triangular meshes using a structure that is not compatible with json.
- - [jmsh](https://github.com/fangq/jmesh) files are in the [jmesh](https://github.com/fangq/jmesh) format, which inserts a compressed binary stream into a human readable JSON file. Supporting this format slightly increases the size of the executable (using the optional `-DHAVE_JSON` compiler flag and `cJSON` files).
+ - [json](https://github.com/NeuroJSON/jmesh) creates human readable ASCII JSON files in the format described by [jmesh](https://github.com/fangq/jmesh). Be aware that other tools create legal JSON files to describe triangular meshes using a structure that is not compatible with json.
+ - [jmsh](https://github.com/NeuroJSON/jmesh) files are in the JSON-based [JMesh](https://github.com/fangq/jmesh) format, which inserts a compressed binary stream into a human readable JSON file. Supporting this format slightly increases the size of the executable (using the optional `-DHAVE_JSON` compiler flag and `cJSON` files).
+ - [bmsh](https://github.com/NeuroJSON/jmesh) is a binary-JSON ([BJData - Draft 2](https://github.com/NeuroJSON/bjdata/blob/Draft_2/Binary_JData_Specification.md)) based mesh-data container based on the JMesh specification; both `.bmsh` and `.jmsh` support data-level compression
  - [VTK](http://www.princeton.edu/~efeibush/viscourse/vtk.pdf) refers to the legacy VTK format, which is supported by many tools (unlike the more flexible modern XML-based VTK formats).
  - [STL](http://www.paulbourke.net/dataformats/stl/) format is popular for 3D printing. You should use any other format unless required. This format does not re-use vertices across triangles, this results in very large files. Further, this means the meshes are either slow to load or appear to have a faceted jagged appearance.
 
diff --git a/src/meshify.c b/src/meshify.c
index 4cfe7ba..b8ba83d 100644
--- a/src/meshify.c
+++ b/src/meshify.c
@@ -449,7 +449,6 @@ int save_freesurfer(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt)
 }
 
 #ifdef HAVE_ZLIB
-#ifdef HAVE_JSON
 
 enum TZipMethod {zmZlib, zmGzip, zmBase64, zmLzip, zmLzma, zmLz4, zmLz4hc};
 
@@ -520,18 +519,34 @@ int zmat_run(const size_t inputsize, unsigned char *inputstr, size_t *outputsize
 	return 0;
 }
 
+#ifdef HAVE_JSON
+
 int save_jmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
 	FILE *fp;
-	cJSON *root=NULL, *hdr=NULL, *node=NULL, *face=NULL;
+	cJSON *root=NULL, *hdr=NULL, *node=NULL, *face=NULL, *parser=NULL;
+	const char *pyparsers[]={"https://pypi.org/project/jdata","https://pypi.org/project/bjdata"};
+	const char *jsparsers[]={"https://www.npmjs.com/package/jda","https://www.npmjs.com/package/bjd"};
+	const char *cparsers[]={"https://github.com/DaveGamble/cJSON","https://github.com/NeuroJSON/ubj"};
 	char *jsonstr=NULL;
 	int dim[2]={0,3}, len[2]={1,0};
 	size_t compressedbytes, totalbytes;
 	unsigned char *compressed=NULL, *buf=NULL;
 	int ret=0, status=0;
+
 	root=cJSON_CreateObject();
+
 	cJSON_AddItemToObject(root,  "_DataInfo_", hdr = cJSON_CreateObject());
 	cJSON_AddStringToObject(hdr, "JMeshVersion", "0.5");
-	cJSON_AddStringToObject(hdr, "Comment", "Created by nii2mesh");
+	cJSON_AddStringToObject(hdr, "Comment", "Created by nii2mesh with NeuroJSON JMesh format (http://neurojson.org)");
+	cJSON_AddStringToObject(hdr, "AnnotationFormat", "https://github.com/NeuroJSON/jmesh/blob/master/JMesh_specification.md");
+	cJSON_AddStringToObject(hdr, "SerialFormat", "http://json.org");
+	cJSON_AddItemToObject(hdr,  "Parser", parser = cJSON_CreateObject());
+	cJSON_AddStringToObject(parser, "Python", tmp = cJSON_CreateStringArray(pyparsers,2));
+	cJSON_AddStringToObject(parser, "MATLAB", "https://github.com/NeuroJSON/jsonlab");
+	cJSON_AddStringToObject(parser, "JavaScript", tmp = jsparsers(pyparsers,2));
+	cJSON_AddStringToObject(parser, "CPP", "https://github.com/NeuroJSON/json");
+	cJSON_AddStringToObject(parser, "C", tmp = cJSON_CreateStringArray(cparsers,2));
+
 	cJSON_AddItemToObject(root,  "MeshVertex3", node = cJSON_CreateObject());
 	cJSON_AddStringToObject(node,"_ArrayType_","double");
 	dim[0]=npt;
@@ -539,13 +554,9 @@ int save_jmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
 	cJSON_AddStringToObject(node,"_ArrayZipType_","zlib");
 	len[1]=dim[0]*dim[1];
 	cJSON_AddItemToObject(node,  "_ArrayZipSize_",cJSON_CreateIntArray(len,2));
+
 	totalbytes=dim[0]*dim[1]*sizeof(pts[0].x);
-	unsigned int *val=(unsigned int *)malloc(totalbytes);
- 	memcpy(val,&(tris[0].x),totalbytes);
- 	for(int i=0;i<len[1];i++)
- 		val[i]++;
- 	ret=zmat_run(totalbytes, (unsigned char *)val, &compressedbytes, (unsigned char **)&compressed, zmZlib, &status,1);
- 	free(val);
+	ret=zmat_run(totalbytes, (unsigned char *)&(pts[0].x), &compressedbytes, (unsigned char **)&compressed, zmZlib, &status,1);
 	if(!ret){
 		 ret=zmat_run(compressedbytes, compressed, &totalbytes, (unsigned char **)&buf, zmBase64, &status,1);
 		 cJSON_AddStringToObject(node,  "_ArrayZipData_",(char *)buf);
@@ -565,8 +576,14 @@ int save_jmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
 	cJSON_AddStringToObject(face,"_ArrayZipType_","zlib");
 	len[1]=dim[0]*dim[1];
 	cJSON_AddItemToObject(face,  "_ArrayZipSize_",cJSON_CreateIntArray(len,2));
+
 	totalbytes=dim[0]*dim[1]*sizeof(tris[0].x);
-	ret=zmat_run(totalbytes, (unsigned char *)&(tris[0].x), &compressedbytes, (unsigned char **)&compressed, zmZlib, &status,1);
+	unsigned int *val=(unsigned int *)malloc(totalbytes);
+	memcpy(val,&(tris[0].x),totalbytes);
+	for(int i=0;i<len[1];i++)
+		val[i]++;
+	ret=zmat_run(totalbytes, (unsigned char *)val, &compressedbytes, (unsigned char **)&compressed, zmZlib, &status,1);
+	free(val);
 	if(!ret){
 		ret=zmat_run(compressedbytes, compressed, &totalbytes, (unsigned char **)&buf, zmBase64, &status,1);
 		cJSON_AddStringToObject(face,  "_ArrayZipData_",(char *)buf);
@@ -575,14 +592,17 @@ int save_jmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
 		free(compressed);
 	if(buf)
 		free(buf);
+
 	jsonstr=cJSON_Print(root);
 	if(jsonstr==NULL)
 		return EXIT_FAILURE;
+
 	fp=fopen(fnm,"wt");
 	if(fp==NULL)
 		return EXIT_FAILURE;
 	fprintf(fp,"%s\n",jsonstr);
 	fclose(fp);
+
 	if(jsonstr)
 		free(jsonstr);
 	if(root)
@@ -590,6 +610,140 @@ int save_jmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
 	return EXIT_SUCCESS;
 }
 #endif //HAVE_JSON
+
+
+void write_ubjsonint(int len, int *dat, FILE *fp){
+	if (!&littleEndianPlatform)
+		swap_4bytes(len, dat);
+	fwrite(dat,len,4,fp);
+}
+
+int save_bmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
+	int markerlen=0;
+	const char *output[]={
+	"{",
+		"N","","_DataInfo_","{",
+			"N","","JMeshVersion","S","","0.5",
+			"N","","Comment","S","","Created by nii2mesh with NeuroJSON JMesh format (http://neurojson.org)",
+			"N","","AnnotationFormat","S","","https://github.com/NeuroJSON/jmesh/blob/master/JMesh_specification.md",
+			"N","","SerialFormat","S","","http://json.org",
+                        "N","","Parser","{",
+                                "N","","Python","[",
+                                        "S","","https://pypi.org/project/jdata",
+                                        "S","","https://pypi.org/project/bjdata",
+                                "]",
+				"N","","MATLAB","S","","https://github.com/NeuroJSON/jsonlab",
+                                "N","","JavaScript","[",
+                                        "S","","https://www.npmjs.com/package/jda",
+                                        "S","","https://www.npmjs.com/package/bjd",
+                                "]",
+				"N","","CPP","S","","https://github.com/NeuroJSON/json",
+                                "N","","C","[",
+                                        "S","","https://github.com/DaveGamble/cJSON",
+                                        "S","","https://github.com/NeuroJSON/ubj",
+                                "]",
+                        "}",
+		"}",
+		"N","","MeshVertex3","{",
+			"N","","_ArrayType_","S","","double",
+			"N","","_ArraySize_","[$l#","?1","?2",
+			"N","","_ArrayZipType_","S","","zlib",
+			"N","","_ArrayZipSize_","[$l#","?3","?4",
+			"N","","_ArrayZipData_","S","","?5",
+		"}",
+		"N","","MeshTri3","{",
+			"N","","_ArrayType_","S","","uint32",
+			"N","","_ArraySize_","[$l#","?6","?7",
+			"N","","_ArrayZipType_","S","","zlib",
+			"N","","_ArrayZipSize_","[$l#","?8","?9",
+			"N","","_ArrayZipData_","S","","?10",
+		"}",
+	"}"
+	};
+
+	FILE *fp = fopen(fnm,"wb");
+	if (fp == NULL)
+		return EXIT_FAILURE;
+
+	markerlen=sizeof(output)/sizeof(char*);
+
+	for(int i=0;i<markerlen;i++){
+		int slen=strlen(output[i]);
+		if(slen>0 && output[i][0]!='?'){
+			if(!(slen==1 && output[i][0]=='N'))
+				fwrite(output[i],1,slen,fp);
+			if(slen==1 && (output[i][0]=='N' || output[i][0]=='S') && i+2<markerlen && output[i+1][0]=='\0' && output[i+2][0]!='?'){
+				unsigned int keylen=strlen(output[i+2]);
+				if(keylen<256){
+					unsigned char keylenbyte=keylen;
+					fputc('U',fp);
+					fwrite(&keylenbyte,1,sizeof(keylenbyte),fp);
+				}else{
+					fputc('l',fp);
+					write_ubjsonint(1,&keylen,fp);
+				}
+			}
+		}else{
+			if(slen>0){
+				int slotid=0;
+				if(sscanf(output[i],"\?%d",&slotid)==1 && slotid>0){
+					unsigned char *compressed=NULL;
+					size_t compressedbytes, totalbytes;
+					int dim[2]={0,3}, len[2]={1,0};
+					int ret=0, status=0;
+					switch(slotid){
+						case 1: {unsigned char val=2;    fputc('U',fp);fwrite(&val,1,sizeof(val),fp);break;}
+						case 2: {int val[2]; val[0]=npt; val[1]=3; write_ubjsonint(2,val,fp);break;}
+						case 3: {unsigned char val=1;    fputc('U',fp);fwrite(&val,1,sizeof(val),fp);break;}
+						case 4: {int val=npt*3;		 write_ubjsonint(1,&val,fp);break;}
+						case 6: {unsigned char val=2;    fputc('U',fp);fwrite(&val,1,sizeof(val),fp);break;}
+						case 7: {int val[2]; val[0]=ntri;val[1]=3; write_ubjsonint(2,val,fp);break;}
+						case 8: {unsigned char val=1;    fputc('U',fp);fwrite(&val,1,sizeof(val),fp);break;}
+						case 9: {int val=ntri*3;	 write_ubjsonint(1,&val,fp);break;}
+						case 5:
+							dim[0]=npt;
+							len[1]=dim[0]*dim[1];
+
+							totalbytes=dim[0]*dim[1]*sizeof(pts[0].x);
+							ret=zmat_run(totalbytes, (unsigned char *)&(pts[0].x), &compressedbytes, (unsigned char **)&compressed, zmZlib, &status,1);
+							if(!ret){
+								int clen=compressedbytes;
+								fputc('l',fp);
+								write_ubjsonint(1,&clen,fp);
+								fwrite(compressed,1,compressedbytes,fp);
+							}
+							if(compressed)
+								free(compressed);
+							break;
+						case 10:
+							dim[0]=ntri;
+							len[1]=dim[0]*dim[1];
+
+							totalbytes=dim[0]*dim[1]*sizeof(tris[0].x);
+							unsigned int *val=(unsigned int *)malloc(totalbytes);
+							memcpy(val,&(tris[0].x),totalbytes);
+							for(int i=0;i<len[1];i++)
+								val[i]++;
+							ret=zmat_run(totalbytes, (unsigned char *)val, &compressedbytes, (unsigned char **)&compressed, zmZlib, &status,1);
+							free(val);
+							if(!ret){
+								int clen=compressedbytes;
+								fputc('l',fp);
+								write_ubjsonint(1,&clen,fp);
+								fwrite(compressed,1,compressedbytes,fp);
+							}
+
+							if(compressed)
+								free(compressed);
+							break;
+					}
+				}
+			}
+		}
+	}
+	fclose(fp);
+	return EXIT_SUCCESS;
+}
 #endif //HAVE_ZLIB
 
 int save_json(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
@@ -597,7 +751,7 @@ int save_json(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
 	if (fp == NULL)
 		return EXIT_FAILURE;
 	fprintf(fp,"{\n");
-	fprintf(fp,"\t\"_DataInfo_\":{\n\t\t\"JMeshVersion\":\"0.5\",\n\t\t\"Comment\":\"Created by nii2mesh\"\n\t},\n");
+	fprintf(fp,"\t\"_DataInfo_\":{\n\t\t\"JMeshVersion\":\"0.5\",\n\t\t\"Comment\":\"Created by nii2mesh with NeuroJSON JMesh format (http://neurojson.org)\"\n\t},\n");
 	fprintf(fp,"\t\"MeshVertex3\":[\n");
 	for (int i=0;i<npt;i++)
 		fprintf(fp, "[%g,\t%g,\t%g],\n", pts[i].x, pts[i].y,pts[i].z);
@@ -985,6 +1139,8 @@ int save_mesh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool
 	else if (strstr(ext, ".jmsh"))
 		return save_jmsh(fnm, tris, pts, ntri, npt);
 #endif //HAVE_JSON
+	else if (strstr(ext, ".bmsh"))
+		return save_bmsh(fnm, tris, pts, ntri, npt);
 #endif //HAVE_ZLIB
 	else if (strstr(ext, ".json"))
 		return save_json(fnm, tris, pts, ntri, npt);
diff --git a/src/nii2mesh.c b/src/nii2mesh.c
index 1d9ae1d..66cebfc 100644
--- a/src/nii2mesh.c
+++ b/src/nii2mesh.c
@@ -243,9 +243,9 @@ int main(int argc,char **argv) {
 		printf("    -s v    post-smoothing iterations (default %d)\n", postSmooth);
 		printf("    -v v    verbose (0=silent, 1=verbose, default %d)\n", verbose);
 		#ifdef HAVE_JSON
-		printf("mesh extension sets format (.gii, .jmsh, .json, .mz3, .obj, .ply, .pial, .stl, .vtk)\n");
+		printf("mesh extension sets format (.gii, .mz3, .bmsh, .jmsh, .json, .obj, .ply, .pial, .stl, .vtk)\n");
 		#else
-		printf("mesh extension sets format (.gii, .json, .mz3, .obj, .ply, .pial, .stl, .vtk)\n");
+		printf("mesh extension sets format (.gii, .mz3, .bmsh, .json, .obj, .ply, .pial, .stl, .vtk)\n");
 		#endif
 		printf("Example: '%s voxels.nii mesh.obj'\n",argv[0]);
 		printf("Example: '%s bet.nii.gz -i 22 myOutput.obj'\n",argv[0]);

From d1c6edd95cd2bb9d9165cc5f9d084117a05d254e Mon Sep 17 00:00:00 2001
From: Qianqian Fang <fangqq@gmail.com>
Date: Sat, 16 Apr 2022 18:31:36 -0400
Subject: [PATCH 02/13] support -d 0/1 to export double/single, support isGz in
 bmsh

---
 README.md      |   4 +-
 src/meshify.c  | 173 ++++++++++++++++++++++++++++++++++---------------
 src/meshify.h  |   2 +-
 src/nii2mesh.c |  14 ++--
 4 files changed, 134 insertions(+), 59 deletions(-)

diff --git a/README.md b/README.md
index 31f4aed..07ce588 100644
--- a/README.md
+++ b/README.md
@@ -173,8 +173,8 @@ nii2mesh can save meshes to the GIfTI (.gii), JSON, JMesh (.jmsh, .bmsh), mz3, o
  - [PLY](http://paulbourke.net/dataformats/ply/) is an old format that is widely supported. The binary form created by nii2mesh yields small files and quick loading time.
  - [MZ3](https://github.com/neurolabusc/surf-ice/tree/master/mz3) is the native format of [Surfice](https://www.nitrc.org/projects/surfice/). It is small and fast, but not widely supported.
  - [FreeSurfer](https://surfer.nmr.mgh.harvard.edu) format is simple and used by FreeSurfer.
- - [json](https://github.com/NeuroJSON/jmesh) creates human readable ASCII JSON files in the format described by [jmesh](https://github.com/fangq/jmesh). Be aware that other tools create legal JSON files to describe triangular meshes using a structure that is not compatible with json.
- - [jmsh](https://github.com/NeuroJSON/jmesh) files are in the JSON-based [JMesh](https://github.com/fangq/jmesh) format, which inserts a compressed binary stream into a human readable JSON file. Supporting this format slightly increases the size of the executable (using the optional `-DHAVE_JSON` compiler flag and `cJSON` files).
+ - [json](https://github.com/NeuroJSON/jmesh) creates human readable ASCII JSON files in the format described by [JMesh](https://github.com/NeuroJSON/jmesh). Be aware that other tools create legal JSON files to describe triangular meshes using a structure that is not compatible with json.
+ - [jmsh](https://github.com/NeuroJSON/jmesh) files are in the [NeuroJSON](http://neurojson.org) [JMesh](https://github.com/fangq/jmesh) format, which inserts a compressed binary stream into a human readable JSON file. Supporting this format slightly increases the size of the executable (using the optional `-DHAVE_JSON` compiler flag and `cJSON` files).
  - [bmsh](https://github.com/NeuroJSON/jmesh) is a binary-JSON ([BJData - Draft 2](https://github.com/NeuroJSON/bjdata/blob/Draft_2/Binary_JData_Specification.md)) based mesh-data container based on the JMesh specification; both `.bmsh` and `.jmsh` support data-level compression
  - [VTK](http://www.princeton.edu/~efeibush/viscourse/vtk.pdf) refers to the legacy VTK format, which is supported by many tools (unlike the more flexible modern XML-based VTK formats).
  - [STL](http://www.paulbourke.net/dataformats/stl/) format is popular for 3D printing. You should use any other format unless required. This format does not re-use vertices across triangles, this results in very large files. Further, this means the meshes are either slow to load or appear to have a faceted jagged appearance.
diff --git a/src/meshify.c b/src/meshify.c
index b8ba83d..b922522 100644
--- a/src/meshify.c
+++ b/src/meshify.c
@@ -400,6 +400,25 @@ void swap_4bytes( size_t n , void *ar ) { // 4 bytes at a time
 	return ;
 }
 
+void swap_8bytes( size_t n , void *ar )    // 8 bytes at a time
+{
+    size_t ii ;
+    unsigned char * cp0 = (unsigned char *)ar, * cp1, * cp2 ;
+    unsigned char tval ;
+    for( ii=0 ; ii < n ; ii++ ){
+        cp1 = cp0; cp2 = cp0+7;
+        tval = *cp1;  *cp1 = *cp2;  *cp2 = tval;
+        cp1++;  cp2--;
+        tval = *cp1;  *cp1 = *cp2;  *cp2 = tval;
+        cp1++;  cp2--;
+        tval = *cp1;  *cp1 = *cp2;  *cp2 = tval;
+        cp1++;  cp2--;
+        tval = *cp1;  *cp1 = *cp2;  *cp2 = tval;
+        cp0 += 8;
+    }
+    return ;
+}
+
 typedef struct {
 	float x,y,z;
 } vec3s; //single precision (float32)
@@ -618,49 +637,75 @@ void write_ubjsonint(int len, int *dat, FILE *fp){
 	fwrite(dat,len,4,fp);
 }
 
-int save_bmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
+void write_ubjsonfloat(int len, float *dat, FILE *fp){
+	if (!&littleEndianPlatform)
+		swap_4bytes(len, dat);
+	fwrite(dat,len,4,fp);
+}
+
+void write_ubjsondouble(int len, double *dat, FILE *fp){
+	if (!&littleEndianPlatform)
+		swap_8bytes(len, dat);
+	fwrite(dat,len,8,fp);
+}
+
+int save_bmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool isGz, bool isdouble){
 	int markerlen=0;
 	const char *output[]={
 	"{",
 		"N","","_DataInfo_","{",
 			"N","","JMeshVersion","S","","0.5",
-			"N","","Comment","S","","Created by nii2mesh with NeuroJSON JMesh format (http://neurojson.org)",
+			"N","","Comment","S","","Created by nii2mesh with NeuroJSON Binay JMesh format (http://neurojson.org)",
 			"N","","AnnotationFormat","S","","https://github.com/NeuroJSON/jmesh/blob/master/JMesh_specification.md",
-			"N","","SerialFormat","S","","http://json.org",
-                        "N","","Parser","{",
-                                "N","","Python","[",
-                                        "S","","https://pypi.org/project/jdata",
-                                        "S","","https://pypi.org/project/bjdata",
-                                "]",
+			"N","","SerialFormat","S","","http://neurojson.org/bjdata/draft2",
+			"N","","Parser","{",
+				"N","","Python","[",
+					"S","","https://pypi.org/project/jdata",
+					"S","","https://pypi.org/project/bjdata",
+				"]",
 				"N","","MATLAB","S","","https://github.com/NeuroJSON/jsonlab",
-                                "N","","JavaScript","[",
-                                        "S","","https://www.npmjs.com/package/jda",
-                                        "S","","https://www.npmjs.com/package/bjd",
-                                "]",
+				"N","","JavaScript","[",
+					"S","","https://www.npmjs.com/package/jda",
+					"S","","https://www.npmjs.com/package/bjd",
+				"]",
 				"N","","CPP","S","","https://github.com/NeuroJSON/json",
-                                "N","","C","[",
-                                        "S","","https://github.com/DaveGamble/cJSON",
-                                        "S","","https://github.com/NeuroJSON/ubj",
-                                "]",
-                        "}",
+				"N","","C","[",
+					"S","","https://github.com/DaveGamble/cJSON",
+					"S","","https://github.com/NeuroJSON/ubj",
+				"]",
+			"}",
 		"}",
-		"N","","MeshVertex3","{",
-			"N","","_ArrayType_","S","","double",
-			"N","","_ArraySize_","[$l#","?1","?2",
+		"N","","MeshVertex3","?1",
+			"N","","_ArrayType_","S","",(isdouble)?"double":"single",
+			"N","","_ArraySize_","[$l#U\x2","?2",
 			"N","","_ArrayZipType_","S","","zlib",
-			"N","","_ArrayZipSize_","[$l#","?3","?4",
-			"N","","_ArrayZipData_","S","","?5",
+			"N","","_ArrayZipSize_","[$l#U\x1","?3",
+			"N","","_ArrayZipData_","S","","?4",
 		"}",
 		"N","","MeshTri3","{",
 			"N","","_ArrayType_","S","","uint32",
-			"N","","_ArraySize_","[$l#","?6","?7",
+			"N","","_ArraySize_","[$l#U\x2","?5",
 			"N","","_ArrayZipType_","S","","zlib",
-			"N","","_ArrayZipSize_","[$l#","?8","?9",
-			"N","","_ArrayZipData_","S","","?10",
+			"N","","_ArrayZipSize_","[$l#U\x1","?6",
+			"N","","_ArrayZipData_","S","","?7",
 		"}",
 	"}"
 	};
 
+	float *floatpts=NULL;
+	if(!isdouble){
+		floatpts=(float *)calloc(npt*3, sizeof(float));
+		for(int i=0; i<npt; i++){
+			floatpts[i*3]=pts[i].x;
+			floatpts[i*3+1]=pts[i].y;
+			floatpts[i*3+2]=pts[i].z;
+		}
+	}
+	unsigned int *newtris=(unsigned int *)malloc(ntri*3*sizeof(unsigned int));
+	memcpy(newtris,&(tris[0].x),ntri*3*sizeof(unsigned int));
+	for(int i=0;i<ntri*3;i++)
+		newtris[i]++;
+
 	FILE *fp = fopen(fnm,"wb");
 	if (fp == NULL)
 		return EXIT_FAILURE;
@@ -692,20 +737,39 @@ int save_bmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
 					int dim[2]={0,3}, len[2]={1,0};
 					int ret=0, status=0;
 					switch(slotid){
-						case 1: {unsigned char val=2;    fputc('U',fp);fwrite(&val,1,sizeof(val),fp);break;}
+						case 1: {
+							if(isGz){
+								fputc('{',fp);
+							}else{ // write node and face data in BJData strongly-typed ND array construct
+								int val[2]={0};
+								val[0]=npt;
+								val[1]=3;
+
+								fwrite("[$", 1, 2, fp);
+								fputc(isdouble ? 'D' : 'd', fp);
+								fwrite("#[$l#U\x02", 1, 7, fp);
+								write_ubjsonint(2,val,fp);
+								if(isdouble)
+									write_ubjsondouble(npt*3, &(pts[0].x), fp);
+								else
+									write_ubjsonfloat(npt*3, floatpts, fp);
+
+								val[0]=ntri;
+								fwrite("U\x08MeshTri3[$l#[$l#U\x02", 1, 20, fp);
+								write_ubjsonint(2, val, fp);
+								write_ubjsonint(ntri*3, newtris, fp);
+								fputc('}', fp);
+							}
+							break;
+						}
 						case 2: {int val[2]; val[0]=npt; val[1]=3; write_ubjsonint(2,val,fp);break;}
-						case 3: {unsigned char val=1;    fputc('U',fp);fwrite(&val,1,sizeof(val),fp);break;}
-						case 4: {int val=npt*3;		 write_ubjsonint(1,&val,fp);break;}
-						case 6: {unsigned char val=2;    fputc('U',fp);fwrite(&val,1,sizeof(val),fp);break;}
-						case 7: {int val[2]; val[0]=ntri;val[1]=3; write_ubjsonint(2,val,fp);break;}
-						case 8: {unsigned char val=1;    fputc('U',fp);fwrite(&val,1,sizeof(val),fp);break;}
-						case 9: {int val=ntri*3;	 write_ubjsonint(1,&val,fp);break;}
-						case 5:
+						case 3: {int val=npt*3;	write_ubjsonint(1,&val,fp);break;}
+						case 4:
 							dim[0]=npt;
 							len[1]=dim[0]*dim[1];
 
-							totalbytes=dim[0]*dim[1]*sizeof(pts[0].x);
-							ret=zmat_run(totalbytes, (unsigned char *)&(pts[0].x), &compressedbytes, (unsigned char **)&compressed, zmZlib, &status,1);
+							totalbytes=dim[0]*dim[1]*(isdouble? sizeof(pts[0].x) : sizeof(float));
+							ret=zmat_run(totalbytes, (isdouble ? (unsigned char *)&(pts[0].x) : (unsigned char *)floatpts) , &compressedbytes, (unsigned char **)&compressed, zmZlib, &status,1);
 							if(!ret){
 								int clen=compressedbytes;
 								fputc('l',fp);
@@ -715,17 +779,12 @@ int save_bmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
 							if(compressed)
 								free(compressed);
 							break;
-						case 10:
+						case 5: {int val[2]; val[0]=ntri;val[1]=3; write_ubjsonint(2,val,fp);break;}
+						case 6: {int val=ntri*3; write_ubjsonint(1,&val,fp);break;}
+						case 7:
 							dim[0]=ntri;
-							len[1]=dim[0]*dim[1];
-
 							totalbytes=dim[0]*dim[1]*sizeof(tris[0].x);
-							unsigned int *val=(unsigned int *)malloc(totalbytes);
-							memcpy(val,&(tris[0].x),totalbytes);
-							for(int i=0;i<len[1];i++)
-								val[i]++;
-							ret=zmat_run(totalbytes, (unsigned char *)val, &compressedbytes, (unsigned char **)&compressed, zmZlib, &status,1);
-							free(val);
+							ret=zmat_run(totalbytes, (unsigned char *)newtris, &compressedbytes, (unsigned char **)&compressed, zmZlib, &status,1);
 							if(!ret){
 								int clen=compressedbytes;
 								fputc('l',fp);
@@ -737,24 +796,36 @@ int save_bmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
 								free(compressed);
 							break;
 					}
+					if(slotid==1 && !isGz)
+						break;
 				}
 			}
 		}
 	}
 	fclose(fp);
+
+	free(newtris);
+	if(floatpts)
+		free(floatpts);
+
 	return EXIT_SUCCESS;
 }
 #endif //HAVE_ZLIB
 
-int save_json(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
+int save_json(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool isdouble){
 	FILE *fp = fopen(fnm,"w");
 	if (fp == NULL)
 		return EXIT_FAILURE;
 	fprintf(fp,"{\n");
 	fprintf(fp,"\t\"_DataInfo_\":{\n\t\t\"JMeshVersion\":\"0.5\",\n\t\t\"Comment\":\"Created by nii2mesh with NeuroJSON JMesh format (http://neurojson.org)\"\n\t},\n");
 	fprintf(fp,"\t\"MeshVertex3\":[\n");
-	for (int i=0;i<npt;i++)
-		fprintf(fp, "[%g,\t%g,\t%g],\n", pts[i].x, pts[i].y,pts[i].z);
+        if(isdouble){
+                for (int i=0;i<npt;i++)
+                        fprintf(fp, "[%.16g,\t%.16g,\t%.16g],\n", pts[i].x, pts[i].y,pts[i].z);
+        }else{
+                for (int i=0;i<npt;i++)
+                        fprintf(fp, "[%.7g,\t%.7g,\t%.7g],\n", pts[i].x, pts[i].y,pts[i].z);
+        }
 	fprintf(fp,"\t],\n\t\"MeshTri3\":[\n");
 	for (int i=0;i<ntri;i++)
 		fprintf(fp, "[%d,\t%d,\t%d],\n", tris[i].x+1, tris[i].y+1, tris[i].z+1);
@@ -1124,7 +1195,7 @@ void strip_ext(char *fname){
 	}
 }
 
-int save_mesh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool isGz){
+int save_mesh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool isGz, bool isdouble){
 	char basenm[768], ext[768] = "";
 	strcpy(basenm, fnm);
 	strip_ext(basenm); // ~/file.nii -> ~/file
@@ -1137,13 +1208,13 @@ int save_mesh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool
 #ifdef HAVE_ZLIB
 #ifdef HAVE_JSON
 	else if (strstr(ext, ".jmsh"))
-		return save_jmsh(fnm, tris, pts, ntri, npt);
+		return save_jmsh(fnm, tris, pts, ntri, npt, isdouble);
 #endif //HAVE_JSON
 	else if (strstr(ext, ".bmsh"))
-		return save_bmsh(fnm, tris, pts, ntri, npt);
+		return save_bmsh(fnm, tris, pts, ntri, npt, isGz, isdouble);
 #endif //HAVE_ZLIB
 	else if (strstr(ext, ".json"))
-		return save_json(fnm, tris, pts, ntri, npt);
+		return save_json(fnm, tris, pts, ntri, npt, isdouble);
 	else if (strstr(ext, ".mz3"))
 		return save_mz3(fnm, tris, pts, ntri, npt, isGz);
 	else if (strstr(ext, ".off"))
diff --git a/src/meshify.h b/src/meshify.h
index 5a4eb52..6329ae5 100644
--- a/src/meshify.h
+++ b/src/meshify.h
@@ -5,7 +5,7 @@
 #include "meshtypes.h"
 
 void strip_ext(char *fname);
-int save_mesh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool isGz);
+int save_mesh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool isGz, bool isdouble);
 int meshify(float * img, size_t dim[3], int originalMC, float isolevel, vec3i **t, vec3d **p, int *nt, int *np, int preSmooth, bool onlyLargest, bool fillBubbles, bool verbose);
 void apply_sform(vec3i *t, vec3d *p, int nt, int np, float srow_x[4], float srow_y[4], float srow_z[4]);
 double clockMsec();
diff --git a/src/nii2mesh.c b/src/nii2mesh.c
index 66cebfc..7d8b3e3 100644
--- a/src/nii2mesh.c
+++ b/src/nii2mesh.c
@@ -174,7 +174,7 @@ float * load_nii(const char *fnm, nifti_1_header * hdr) {
 	return img32;
 }
 
-int nii2 (nifti_1_header hdr, float * img, int originalMC, float isolevel, float reduceFraction, int preSmooth, bool onlyLargest, bool fillBubbles, int postSmooth, bool verbose, char * outnm, int quality) {
+int nii2 (nifti_1_header hdr, float * img, int originalMC, float isolevel, float reduceFraction, int preSmooth, bool onlyLargest, bool fillBubbles, int postSmooth, bool verbose, char * outnm, int quality, bool isdouble) {
 	vec3d *pts = NULL;
 	vec3i *tris = NULL;
 	int ntri, npt;
@@ -203,7 +203,7 @@ int nii2 (nifti_1_header hdr, float * img, int originalMC, float isolevel, float
 			printf("simplify vertices %d->%d triangles %d->%d (r = %g): %ld ms\n", startVert, npt, startTri, ntri, (float)ntri / (float) startTri, timediff(startTime, clockMsec()));
 		startTime = clockMsec();
 	}
-	save_mesh(outnm, tris, pts, ntri, npt, (quality > 0));
+	save_mesh(outnm, tris, pts, ntri, npt, (quality > 0), isdouble);
 	if (verbose)
 		printf("save to disk: %ld ms\n", timediff(startTime, clockMsec()));
 	free(tris);
@@ -223,6 +223,7 @@ int main(int argc,char **argv) {
 	int quality = 1;
 	int originalMC = 0;
 	bool verbose = false;
+	bool isdouble = false;
 	char atlasFilename[mxStr] = "";
 	// Check the command line, minimal is name of input and output files
 	if (argc < 3) {
@@ -239,7 +240,8 @@ int main(int argc,char **argv) {
 		#endif
 		printf("    -p v    pre-smoothing (0=skip, 1=smooth, default %d)\n", preSmooth);
 		printf("    -r v    reduction factor (default %g)\n", reduceFraction);
-		printf("    -q v    quality (0=fast, 1= balanced, 2=best, default %d)\n", quality);
+		printf("    -q v    quality (0=fast, 1=balanced, 2=best, default %d)\n", quality);
+		printf("    -d v    double precision (0=use single precision, 1=use double precision (for bmsh/json), default %d)\n", isdouble);
 		printf("    -s v    post-smoothing iterations (default %d)\n", postSmooth);
 		printf("    -v v    verbose (0=silent, 1=verbose, default %d)\n", verbose);
 		#ifdef HAVE_JSON
@@ -283,6 +285,8 @@ int main(int argc,char **argv) {
 				preSmooth = atoi(argv[i+1]);
 			if (strcmp(argv[i],"-q") == 0)
 				quality = atoi(argv[i+1]);
+			if (strcmp(argv[i],"-d") == 0)
+				isdouble = atoi(argv[i+1]);
 			if (strcmp(argv[i],"-s") == 0)
 				postSmooth = atoi(argv[i+1]);
 			if (strcmp(argv[i],"-r") == 0)
@@ -378,7 +382,7 @@ int main(int argc,char **argv) {
 				}
 				char outnm[mxStr];
 				if (snprintf(outnm,sizeof(outnm),"%s%s%s", basenm, atlasLabels[i].str, ext) < 0) exit(EXIT_FAILURE);
-				int reti = nii2(hdr, imgbinary, originalMC, 0.5, reduceFraction, preSmooth, onlyLargest, fillBubbles, postSmooth, verbose, outnm, quality);
+				int reti = nii2(hdr, imgbinary, originalMC, 0.5, reduceFraction, preSmooth, onlyLargest, fillBubbles, postSmooth, verbose, outnm, quality, isdouble);
 				if (reti == EXIT_SUCCESS)
 					partial_OK ++;
 				free(imgbinary);
@@ -395,7 +399,7 @@ int main(int argc,char **argv) {
 	} else {
 		if (isoDarkMediumBright123 != 0) //user did not provide numeric isosurface brightness
 			isolevel = setThreshold(img, nvox, isoDarkMediumBright123);
-		ret = nii2(hdr, img, originalMC, isolevel, reduceFraction, preSmooth, onlyLargest, fillBubbles, postSmooth, verbose, argv[argc-1], quality);
+		ret = nii2(hdr, img, originalMC, isolevel, reduceFraction, preSmooth, onlyLargest, fillBubbles, postSmooth, verbose, argv[argc-1], quality, isdouble);
 	}
 	free(img);
 	exit(ret);

From f00991aef1dc7938b27a6a33aa070d1287d795e4 Mon Sep 17 00:00:00 2001
From: Qianqian Fang <fangqq@gmail.com>
Date: Sat, 16 Apr 2022 21:53:17 -0400
Subject: [PATCH 03/13] reimplement save_jmsh without cJSON to reduce exe size

---
 src/meshify.c  | 115 +++++++++++++++++++++++--------------------------
 src/nii2mesh.c |   4 --
 2 files changed, 53 insertions(+), 66 deletions(-)

diff --git a/src/meshify.c b/src/meshify.c
index b922522..7e91599 100644
--- a/src/meshify.c
+++ b/src/meshify.c
@@ -11,9 +11,6 @@
 #include <time.h>
 #ifdef HAVE_ZLIB
 	#include <zlib.h>
-	#ifdef HAVE_JSON
-		#include "cJSON.h"
-	#endif
 #endif
 #include "meshify.h"
 #include "base64.h" //required for GIfTI
@@ -538,47 +535,54 @@ int zmat_run(const size_t inputsize, unsigned char *inputstr, size_t *outputsize
 	return 0;
 }
 
-#ifdef HAVE_JSON
-
-int save_jmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
+int save_jmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool isdouble){
 	FILE *fp;
-	cJSON *root=NULL, *hdr=NULL, *node=NULL, *face=NULL, *parser=NULL;
 	const char *pyparsers[]={"https://pypi.org/project/jdata","https://pypi.org/project/bjdata"};
 	const char *jsparsers[]={"https://www.npmjs.com/package/jda","https://www.npmjs.com/package/bjd"};
 	const char *cparsers[]={"https://github.com/DaveGamble/cJSON","https://github.com/NeuroJSON/ubj"};
-	char *jsonstr=NULL;
-	int dim[2]={0,3}, len[2]={1,0};
 	size_t compressedbytes, totalbytes;
 	unsigned char *compressed=NULL, *buf=NULL;
 	int ret=0, status=0;
 
-	root=cJSON_CreateObject();
+	float *floatpts=NULL;
+	if(!isdouble){
+		floatpts=(float *)malloc(npt*3*sizeof(float));
+		for(int i=0; i<npt; i++){
+			floatpts[i*3]=pts[i].x;
+			floatpts[i*3+1]=pts[i].y;
+			floatpts[i*3+2]=pts[i].z;
+		}
+	}
 
-	cJSON_AddItemToObject(root,  "_DataInfo_", hdr = cJSON_CreateObject());
-	cJSON_AddStringToObject(hdr, "JMeshVersion", "0.5");
-	cJSON_AddStringToObject(hdr, "Comment", "Created by nii2mesh with NeuroJSON JMesh format (http://neurojson.org)");
-	cJSON_AddStringToObject(hdr, "AnnotationFormat", "https://github.com/NeuroJSON/jmesh/blob/master/JMesh_specification.md");
-	cJSON_AddStringToObject(hdr, "SerialFormat", "http://json.org");
-	cJSON_AddItemToObject(hdr,  "Parser", parser = cJSON_CreateObject());
-	cJSON_AddStringToObject(parser, "Python", tmp = cJSON_CreateStringArray(pyparsers,2));
-	cJSON_AddStringToObject(parser, "MATLAB", "https://github.com/NeuroJSON/jsonlab");
-	cJSON_AddStringToObject(parser, "JavaScript", tmp = jsparsers(pyparsers,2));
-	cJSON_AddStringToObject(parser, "CPP", "https://github.com/NeuroJSON/json");
-	cJSON_AddStringToObject(parser, "C", tmp = cJSON_CreateStringArray(cparsers,2));
+	fp=fopen(fnm,"wt");
+	if(fp==NULL)
+		return EXIT_FAILURE;
 
-	cJSON_AddItemToObject(root,  "MeshVertex3", node = cJSON_CreateObject());
-	cJSON_AddStringToObject(node,"_ArrayType_","double");
-	dim[0]=npt;
-	cJSON_AddItemToObject(node,  "_ArraySize_",cJSON_CreateIntArray(dim,2));
-	cJSON_AddStringToObject(node,"_ArrayZipType_","zlib");
-	len[1]=dim[0]*dim[1];
-	cJSON_AddItemToObject(node,  "_ArrayZipSize_",cJSON_CreateIntArray(len,2));
+	fprintf(fp, "{\n\t\"_DataInfo_\":{\n");
+	fprintf(fp, "\t\t\"JMeshVersion\":\"0.5\",\n");
+	fprintf(fp, "\t\t\"Comment\":\"Created by nii2mesh with NeuroJSON JMesh format (http://neurojson.org)\",\n");
+	fprintf(fp, "\t\t\"AnnotationFormat\":\"https://neurojson.org/jmesh/draft1\",\n");
+	fprintf(fp, "\t\t\"SerialFormat\":\"https://json.org\",\n");
+	fprintf(fp, "\t\t\"Parser\":{\n");
+	fprintf(fp, "\t\t\t\"Python\":[\"%s\",\t\"%s\"],\n",pyparsers[0],pyparsers[1]);
+	fprintf(fp, "\t\t\t\"MATLAB\":\"https://github.com/NeuroJSON/jsonlab\",\n");
+	fprintf(fp, "\t\t\t\"JavaScript\":[\"%s\",\t\"%s\"],\n",jsparsers[0],jsparsers[1]);
+	fprintf(fp, "\t\t\t\"CPP\":\"https://github.com/NeuroJSON/json\",\n");
+	fprintf(fp, "\t\t\t\"C\":[\"%s\",\t\"%s\"]\n",cparsers[0],cparsers[1]);
+	fprintf(fp, "\t\t}\n\t},\n");
+	fprintf(fp, "\t\"MeshVertex3\":{\n");
+	fprintf(fp, "\t\t\"_ArrayType_\":\"%s\",\n", (isdouble ? "double" : "single"));
+	fprintf(fp, "\t\t\"_ArraySize_\":[%d, 3],\n", npt);
+	fprintf(fp, "\t\t\"_ArrayZipType_\":\"zlib\",\n");
+	fprintf(fp, "\t\t\"_ArrayZipSize_\":[1, %d],\n", npt*3);
 
-	totalbytes=dim[0]*dim[1]*sizeof(pts[0].x);
-	ret=zmat_run(totalbytes, (unsigned char *)&(pts[0].x), &compressedbytes, (unsigned char **)&compressed, zmZlib, &status,1);
+	totalbytes=npt*3*(isdouble ? sizeof(pts[0].x) : sizeof(float));
+	ret=zmat_run(totalbytes, (isdouble ? (unsigned char *)&(pts[0].x) : (unsigned char *)floatpts), &compressedbytes, (unsigned char **)&compressed, zmZlib, &status,1);
 	if(!ret){
-		 ret=zmat_run(compressedbytes, compressed, &totalbytes, (unsigned char **)&buf, zmBase64, &status,1);
-		 cJSON_AddStringToObject(node,  "_ArrayZipData_",(char *)buf);
+		ret=zmat_run(compressedbytes, compressed, &totalbytes, (unsigned char **)&buf, zmBase64, &status,1);
+		fprintf(fp, "\t\t\"_ArrayZipData_\":\"");
+		fwrite(buf, 1, totalbytes, fp);
+		fprintf(fp, "\"\n");
 	}
 	if(compressed){
 		free(compressed);
@@ -588,48 +592,37 @@ int save_jmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
 		free(buf);
 		buf=NULL;
 	}
-	cJSON_AddItemToObject(root,  "MeshTri3", face = cJSON_CreateObject());
-	cJSON_AddStringToObject(face,"_ArrayType_","uint32");
-	dim[0]=ntri;
-	cJSON_AddItemToObject(face,  "_ArraySize_",cJSON_CreateIntArray(dim,2));
-	cJSON_AddStringToObject(face,"_ArrayZipType_","zlib");
-	len[1]=dim[0]*dim[1];
-	cJSON_AddItemToObject(face,  "_ArrayZipSize_",cJSON_CreateIntArray(len,2));
+	fprintf(fp, "\t},\n");
+	fprintf(fp, "\t\"MeshTri3\":{\n");
+	fprintf(fp, "\t\t\"_ArrayType_\":\"uint32\",\n");
+	fprintf(fp, "\t\t\"_ArraySize_\":[%d, 3],\n", ntri);
+	fprintf(fp, "\t\t\"_ArrayZipType_\":\"zlib\",\n");
+	fprintf(fp, "\t\t\"_ArrayZipSize_\":[1, %d],\n", ntri*3);
 
-	totalbytes=dim[0]*dim[1]*sizeof(tris[0].x);
+	totalbytes=ntri*3*sizeof(tris[0].x);
 	unsigned int *val=(unsigned int *)malloc(totalbytes);
 	memcpy(val,&(tris[0].x),totalbytes);
-	for(int i=0;i<len[1];i++)
+	for(int i=0;i<ntri*3;i++)
 		val[i]++;
 	ret=zmat_run(totalbytes, (unsigned char *)val, &compressedbytes, (unsigned char **)&compressed, zmZlib, &status,1);
 	free(val);
 	if(!ret){
 		ret=zmat_run(compressedbytes, compressed, &totalbytes, (unsigned char **)&buf, zmBase64, &status,1);
-		cJSON_AddStringToObject(face,  "_ArrayZipData_",(char *)buf);
+		fprintf(fp, "\t\t\"_ArrayZipData_\":\"");
+		fwrite(buf, 1, totalbytes, fp);
+		fprintf(fp, "\"\n");
 	}
 	if(compressed)
 		free(compressed);
 	if(buf)
 		free(buf);
+	if(floatpts)
+		free(floatpts);
 
-	jsonstr=cJSON_Print(root);
-	if(jsonstr==NULL)
-		return EXIT_FAILURE;
-
-	fp=fopen(fnm,"wt");
-	if(fp==NULL)
-		return EXIT_FAILURE;
-	fprintf(fp,"%s\n",jsonstr);
+	fprintf(fp, "\t}\n}\n");
 	fclose(fp);
-
-	if(jsonstr)
-		free(jsonstr);
-	if(root)
-		cJSON_Delete(root);
 	return EXIT_SUCCESS;
 }
-#endif //HAVE_JSON
-
 
 void write_ubjsonint(int len, int *dat, FILE *fp){
 	if (!&littleEndianPlatform)
@@ -656,8 +649,8 @@ int save_bmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool
 		"N","","_DataInfo_","{",
 			"N","","JMeshVersion","S","","0.5",
 			"N","","Comment","S","","Created by nii2mesh with NeuroJSON Binay JMesh format (http://neurojson.org)",
-			"N","","AnnotationFormat","S","","https://github.com/NeuroJSON/jmesh/blob/master/JMesh_specification.md",
-			"N","","SerialFormat","S","","http://neurojson.org/bjdata/draft2",
+			"N","","AnnotationFormat","S","","https://neurojson.org/jmesh/draft1",
+			"N","","SerialFormat","S","","https://neurojson.org/bjdata/draft2",
 			"N","","Parser","{",
 				"N","","Python","[",
 					"S","","https://pypi.org/project/jdata",
@@ -694,7 +687,7 @@ int save_bmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool
 
 	float *floatpts=NULL;
 	if(!isdouble){
-		floatpts=(float *)calloc(npt*3, sizeof(float));
+		floatpts=(float *)malloc(npt*3*sizeof(float));
 		for(int i=0; i<npt; i++){
 			floatpts[i*3]=pts[i].x;
 			floatpts[i*3+1]=pts[i].y;
@@ -1206,10 +1199,8 @@ int save_mesh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool
 	else if ((strstr(ext, ".inflated")) || (strstr(ext, ".pial")))
 		return save_freesurfer(fnm, tris, pts, ntri, npt);
 #ifdef HAVE_ZLIB
-#ifdef HAVE_JSON
 	else if (strstr(ext, ".jmsh"))
 		return save_jmsh(fnm, tris, pts, ntri, npt, isdouble);
-#endif //HAVE_JSON
 	else if (strstr(ext, ".bmsh"))
 		return save_bmsh(fnm, tris, pts, ntri, npt, isGz, isdouble);
 #endif //HAVE_ZLIB
diff --git a/src/nii2mesh.c b/src/nii2mesh.c
index 7d8b3e3..94a4c1c 100644
--- a/src/nii2mesh.c
+++ b/src/nii2mesh.c
@@ -244,11 +244,7 @@ int main(int argc,char **argv) {
 		printf("    -d v    double precision (0=use single precision, 1=use double precision (for bmsh/json), default %d)\n", isdouble);
 		printf("    -s v    post-smoothing iterations (default %d)\n", postSmooth);
 		printf("    -v v    verbose (0=silent, 1=verbose, default %d)\n", verbose);
-		#ifdef HAVE_JSON
 		printf("mesh extension sets format (.gii, .mz3, .bmsh, .jmsh, .json, .obj, .ply, .pial, .stl, .vtk)\n");
-		#else
-		printf("mesh extension sets format (.gii, .mz3, .bmsh, .json, .obj, .ply, .pial, .stl, .vtk)\n");
-		#endif
 		printf("Example: '%s voxels.nii mesh.obj'\n",argv[0]);
 		printf("Example: '%s bet.nii.gz -i 22 myOutput.obj'\n",argv[0]);
 		printf("Example: '%s bet.nii.gz -i b bright.obj'\n",argv[0]);

From b131c1a65cd267819d6c1834a97673ee85868b87 Mon Sep 17 00:00:00 2001
From: Qianqian Fang <fangqq@gmail.com>
Date: Sun, 17 Apr 2022 16:48:57 -0400
Subject: [PATCH 04/13] accept JSON-based JNIfTI (.jnii) file as input volume,
 'make JSON=1'

---
 src/meshify.c  | 215 +++++++++++++++++++++++++++++++++++++++++++++++--
 src/meshify.h  |   7 ++
 src/nii2mesh.c |   8 +-
 3 files changed, 224 insertions(+), 6 deletions(-)

diff --git a/src/meshify.c b/src/meshify.c
index 7e91599..80e4d18 100644
--- a/src/meshify.c
+++ b/src/meshify.c
@@ -11,6 +11,11 @@
 #include <time.h>
 #ifdef HAVE_ZLIB
 	#include <zlib.h>
+	#ifdef HAVE_JSON
+		#include "cJSON.h"
+		#define FIND_JSON_KEY(id,parent,fallback,val) \
+			((tmp=cJSON_GetObjectItem(root,id))==0 ? fallback : tmp->val)
+	#endif
 #endif
 #include "meshify.h"
 #include "base64.h" //required for GIfTI
@@ -482,10 +487,15 @@ int zmat_run(const size_t inputsize, unsigned char *inputstr, size_t *outputsize
 		if(zipid==zmBase64){
 			/** base64 encoding  */
 			*outputbuf=base64_encode((const unsigned char*)inputstr, inputsize, outputsize);
-		}else if(zipid==zmZlib){
+		}else if(zipid==zmZlib || zipid==zmGzip){
 			/** zlib (.zip) or gzip (.gz) compression  */
-			if(deflateInit(&zs,  (iscompress>0) ? Z_DEFAULT_COMPRESSION : (-iscompress)) != Z_OK)
-				return -2;
+			if(zipid==zmZlib){
+				if(deflateInit(&zs,  (iscompress>0) ? Z_DEFAULT_COMPRESSION : (-iscompress)) != Z_OK)
+					return -2;
+			}else{
+				if(deflateInit2(&zs, (iscompress>0) ? Z_DEFAULT_COMPRESSION : (-iscompress), Z_DEFLATED, 15|16, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY) != Z_OK)
+					return -2;
+			}
 			buflen[0] =deflateBound(&zs,inputsize);
 			*outputbuf=(unsigned char *)malloc(buflen[0]);
 			zs.avail_in = inputsize; /* size of input, string + terminator*/
@@ -505,12 +515,16 @@ int zmat_run(const size_t inputsize, unsigned char *inputstr, size_t *outputsize
 		if(zipid==zmBase64){
 			/** base64 decoding  */
 			*outputbuf=base64_decode((const unsigned char*)inputstr, inputsize, outputsize);
-		}else if(zipid==zmZlib){
+		}else if(zipid==zmZlib || zipid==zmGzip){
 			/** zlib (.zip) or gzip (.gz) decompression */
 			int count=1;
-			if(zipid==zmZlib)
+			if(zipid==zmZlib){
 				if(inflateInit(&zs) != Z_OK)
 					return -2;
+			}else{
+				if(inflateInit2(&zs, 15|32) != Z_OK)
+					return -2;
+			}
 			buflen[0] =inputsize*20;
 			*outputbuf=(unsigned char *)malloc(buflen[0]);
 			zs.avail_in = inputsize; /* size of input, string + terminator*/
@@ -535,6 +549,197 @@ int zmat_run(const size_t inputsize, unsigned char *inputstr, size_t *outputsize
 	return 0;
 }
 
+#ifdef HAVE_JSON
+
+const char *zipformat[]={"zlib","gzip","base64","lzip","lzma","lz4","lz4hc",""};
+
+int key_lookup(char *origkey, const char *table[]){
+	int i=0;
+	while(table[i] && table[i][0]!='\0'){
+		if(strcmp(origkey,table[i])==0)
+			return i;
+		i++;
+	}
+	return -1;
+}
+
+// decoding JData ND array construct {"_ArraySize_":,"_ArrayType_":"_ArrayZipType_":"_ArrayZipSize_":"_ArrayZipData_":}
+
+int  jdata_decode(void **vol, unsigned short *ndim, unsigned short *dims, int maxdim, char **type, cJSON *obj){
+	int ret=0;
+	cJSON * ztype=NULL;
+	cJSON * vsize=cJSON_GetObjectItem(obj,"_ArraySize_");
+	cJSON * vtype=cJSON_GetObjectItem(obj,"_ArrayType_");
+	cJSON * vdata=cJSON_GetObjectItem(obj,"_ArrayData_");
+	if(!vdata){
+		ztype=cJSON_GetObjectItem(obj,"_ArrayZipType_");
+		vdata=cJSON_GetObjectItem(obj,"_ArrayZipData_");
+	}
+	if(vtype)
+		*type=vtype->valuestring;
+	if(vdata){
+		if(vsize){
+			cJSON *tmp=vsize->child;
+			*ndim=cJSON_GetArraySize(vsize);
+			for(int i=0;i<MIN(maxdim,*ndim);i++){
+				dims[i]=tmp->valueint;
+				tmp=tmp->next;
+			}
+		}
+		if(ztype){
+			size_t len, newlen;
+			int status=0;
+			char *buf=NULL;
+			int zipid=key_lookup((char *)(ztype->valuestring),zipformat);
+			if(zipid<0 ||zipid>zmBase64)
+				 return -1;
+			if(zipid==zmBase64)
+				return zmat_run(strlen(vdata->valuestring), (uchar *)vdata->valuestring, &len, (uchar **)vol, zmBase64, &status, 0);
+			else
+				ret=zmat_run(strlen(vdata->valuestring), (uchar *)vdata->valuestring, &len, (uchar **)&buf, zmBase64, &status, 0);
+			if(!ret && vsize){
+				if(*vol)
+					free(*vol);
+				ret=zmat_run(len, (uchar *)buf, &newlen, (uchar **)(vol), zipid, &status, 0);
+			}
+			if(buf)
+				free(buf);
+		}else
+			return -1;
+        }else
+		 return -1;
+	return ret;
+}
+
+void read_vec4float(float *vec4, cJSON *vec){
+	for(int i=0;i<4;i++){
+		vec4[i]=vec->valuedouble;
+		vec=vec->next;
+	}
+}
+
+// parsing a JSON/JNIfTI-encoded jnii volume file
+
+float * load_jnii(const char *fnm, nifti_1_header * hdr) {
+	char *jbuf;
+	int len;
+	float * img32=NULL;
+	cJSON *root, *jniihead, *jniidata, *tmp;
+
+	// reading JNIfTI/JSON file to a string
+	FILE *fp=fopen(fnm,"rb");
+	fseek (fp, 0, SEEK_END);
+	len=ftell(fp)+1;
+	jbuf=(char *)malloc(len);
+	rewind(fp);
+	if(fread(jbuf,len-1,1,fp)!=1)
+		return NULL;
+	jbuf[len-1]='\0';
+	fclose(fp);
+
+	// parse JNIfTI/JSON file
+	root = cJSON_Parse(jbuf);
+
+	if(!root){ // if not a valid JSON file, print error and return
+		char *ptrold, *ptr=(char*)cJSON_GetErrorPtr();
+		if(ptr) ptrold=strstr(jbuf,ptr);
+		if(fp!=NULL) fclose(fp);
+		if(ptr && ptrold){
+			char *offs=(ptrold-jbuf>=50) ? ptrold-50 : jbuf;
+			while(offs<ptrold){
+				fprintf(stderr,"%c",*offs);
+				offs++;
+			}
+			fprintf(stderr,"<error>%.50s\n",ptrold);
+		}
+		if(fp!=NULL)
+			free(jbuf);
+		return NULL;
+	}
+	free(jbuf);
+
+	jniihead = cJSON_GetObjectItem(root,"NIFTIHeader");
+	jniidata = cJSON_GetObjectItem(root,"NIFTIData");
+	memset(hdr, 0, sizeof(nifti_1_header));
+	if(jniihead){
+		hdr->sizeof_hdr=FIND_JSON_KEY("NIIHeaderSize",jniihead,348,valueint);
+		hdr->scl_slope=FIND_JSON_KEY("ScaleSlope",jniihead,1.0,valuedouble);
+		hdr->scl_inter=FIND_JSON_KEY("ScaleOffset",jniihead,0.0,valuedouble);
+		tmp=cJSON_GetObjectItem(jniihead,"Affine");
+		if(tmp && cJSON_IsArray(tmp) && cJSON_GetArraySize(tmp)==3){
+			cJSON *row=tmp->child;
+			cJSON *elem=row->child;
+			read_vec4float(hdr->srow_x, elem);
+			elem=row->next->child;
+			read_vec4float(hdr->srow_y, elem);
+			elem=row->next->next->child;
+			read_vec4float(hdr->srow_z, elem);
+		}else{
+			hdr->srow_x[0]=1.f;
+			hdr->srow_y[1]=1.f;
+			hdr->srow_z[2]=1.f;
+		}
+	}else
+		return NULL;
+
+	if(jniidata){
+		char *type=NULL;
+		void *imgRaw=NULL;
+
+		tmp=cJSON_GetObjectItem(jniidata, "_ArrayType_");
+		if(!tmp)
+			return NULL;
+
+		if(jdata_decode((void **)&imgRaw, hdr->dim, hdr->dim+1, 3, &type, jniidata)!=0){
+			if(imgRaw)
+				free(imgRaw);
+			return NULL;
+		}
+		int nvox = hdr->dim[1]*hdr->dim[2]*hdr->dim[3];
+		img32 = (float *) malloc(nvox*sizeof(float));
+		if(strcmp(type,"uint8")==0){
+			for(int i=0; i< nvox; i++)
+				img32[i]=((unsigned char *)imgRaw)[i];
+		}else if(strcmp(type,"int8")==0){
+			for(int i=0; i<nvox; i++)
+				img32[i]=((char *)imgRaw)[i];
+		}else if(strcmp(type,"uint16")==0){
+			for(int i=0; i<nvox; i++)
+				img32[i]=((unsigned short *)imgRaw)[i];
+		}else if(strcmp(type,"int16")==0){
+			for(int i=0; i<nvox; i++)
+				img32[i]=((short *)imgRaw)[i];
+		}else if(strcmp(type,"uint32")==0){
+			for(int i=0; i<nvox; i++)
+				img32[i]=((unsigned int *)imgRaw)[i];
+		}else if(strcmp(type,"int32")==0){
+			for(int i=0; i<nvox; i++)
+				img32[i]=((int *)imgRaw)[i];
+		}else if(strcmp(type,"uint64")==0){
+			for(int i=0; i<nvox; i++)
+				img32[i]=((long long *)imgRaw)[i];
+		}else if(strcmp(type,"int64")==0){
+			for(int i=0; i<nvox; i++)
+				img32[i]=((unsigned long long *)imgRaw)[i];
+		}else if(strcmp(type,"double")==0){
+			for(int i=0; i<nvox; i++)
+				img32[i]=((double *)imgRaw)[i];
+		}else if(strcmp(type,"single")==0){
+			memcpy(img32, imgRaw, nvox*sizeof(float));
+		}else{
+			if(imgRaw)
+				free(imgRaw);
+			return NULL;
+		}
+		if(imgRaw)
+			free(imgRaw);
+	}else
+		return NULL;
+	cJSON_Delete(root);
+	return img32;
+}
+#endif // HAVE_JSON
+
 int save_jmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool isdouble){
 	FILE *fp;
 	const char *pyparsers[]={"https://pypi.org/project/jdata","https://pypi.org/project/bjdata"};
diff --git a/src/meshify.h b/src/meshify.h
index 6329ae5..1224c7b 100644
--- a/src/meshify.h
+++ b/src/meshify.h
@@ -4,11 +4,18 @@
 #include <stdbool.h>
 #include "meshtypes.h"
 
+#ifdef HAVE_JSON
+        #include "nifti1.h"
+#endif
+
 void strip_ext(char *fname);
 int save_mesh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool isGz, bool isdouble);
 int meshify(float * img, size_t dim[3], int originalMC, float isolevel, vec3i **t, vec3d **p, int *nt, int *np, int preSmooth, bool onlyLargest, bool fillBubbles, bool verbose);
 void apply_sform(vec3i *t, vec3d *p, int nt, int np, float srow_x[4], float srow_y[4], float srow_z[4]);
 double clockMsec();
 long timediff(double startTimeMsec, double endTimeMsec);
+#ifdef HAVE_JSON
+float * load_jnii(const char *fnm, nifti_1_header * hdr);
+#endif
 
 #endif /* MESHIFY_H */
\ No newline at end of file
diff --git a/src/nii2mesh.c b/src/nii2mesh.c
index 94a4c1c..06bb62f 100644
--- a/src/nii2mesh.c
+++ b/src/nii2mesh.c
@@ -293,7 +293,13 @@ int main(int argc,char **argv) {
 	}
 	nifti_1_header hdr;
 	double startTime = clockMsec();
-	float * img = load_nii(argv[1], &hdr);
+	float * img=NULL;
+#ifdef HAVE_JSON
+        if(strstr(argv[1], ".jnii") - argv[1] == strlen(argv[1])-5)
+                img = load_jnii(argv[1], &hdr);
+        else
+#endif
+                img = load_nii(argv[1], &hdr);
 	if (verbose)
 		printf("load from disk: %ld ms\n", timediff(startTime, clockMsec()));
 	if (img == NULL)

From 8905521d4bde3547deee22252af703d209c6c593 Mon Sep 17 00:00:00 2001
From: Qianqian Fang <fangqq@gmail.com>
Date: Sun, 17 Apr 2022 21:44:36 -0400
Subject: [PATCH 05/13] change jnii data to column major to match nii

---
 data/README.md      |    3 +-
 data/digimouse.jnii | 3669 +++++++++++++++++++++++++++++++++++++++++++
 src/meshify.c       |   24 +
 3 files changed, 3695 insertions(+), 1 deletion(-)
 create mode 100644 data/digimouse.jnii

diff --git a/data/README.md b/data/README.md
index ca0b770..ca90f6e 100644
--- a/data/README.md
+++ b/data/README.md
@@ -4,4 +4,5 @@ This folder contains NIfTI format images for evaluating mesh conversion.
  - `BET.nii.gz` [T1-weighted image](https://github.com/neurolabusc/dcm_qa_philips_enh) after [Brain Extraction](https://github.com/MIC-DKFZ/HD-BET). Two spheres have been added outside the left hemisphere: an anterior, binary, hollow sphere as well as a posterior, fuzzy, solid sphere.
  - `pve_1.nii.gz` [FAST](https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FAST) gray matter segmentation.
  - `pve_2.nii.gz` [FAST](https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FAST) white matter segmentation.
- - `D99_atlas_v2.0_right.nii.gz` is the [Macaque Atlas v2.0](https://afni.nimh.nih.gov/pub/dist/doc/htmldoc/nonhuman/macaque_tempatl/atlas_d99v2.html)
\ No newline at end of file
+ - `D99_atlas_v2.0_right.nii.gz` is the [Macaque Atlas v2.0](https://afni.nimh.nih.gov/pub/dist/doc/htmldoc/nonhuman/macaque_tempatl/atlas_d99v2.html)
+ - `digimouse.jnii` [JNIfTI](http://neurojson.org/jnifti/draft1) formatted [Digimouse Atlas](https://neuroimage.usc.edu/neuro/Digimouse_Download), see Fig. 9 of [BlenderPhotonics paper](https://doi.org/10.1117/1.jbo.27.8.083014)
diff --git a/data/digimouse.jnii b/data/digimouse.jnii
new file mode 100644
index 0000000..71d993f
--- /dev/null
+++ b/data/digimouse.jnii
@@ -0,0 +1,3669 @@
+{
+	"_DataInfo_":{
+		"JNIFTIVersion":"0.5",
+		"Comment":"Created by JNIFTY Toolbox (https:\/\/github.com\/NeuroJSON\/jnifty)",
+		"AnnotationFormat":"https:\/\/github.com\/NeuroJSON\/jnifti\/blob\/master\/JNIfTI_specification.md",
+		"SerialFormat":"http:\/\/json.org",
+		"Parser":{
+			"Python":[
+				"https:\/\/pypi.org\/project\/jdata",
+				"https:\/\/pypi.org\/project\/bjdata"
+			],
+			"MATLAB":[
+				"https:\/\/github.com\/NeuroJSON\/jnifty",
+				"https:\/\/github.com\/NeuroJSON\/jsonlab"
+			],
+			"JavaScript":"https:\/\/github.com\/NeuroJSON\/jsdata",
+			"CPP":"https:\/\/github.com\/NeuroJSON\/json",
+			"C":"https:\/\/github.com\/NeuroJSON\/ubj"
+		}
+	},
+	"NIFTIHeader":{
+		"NIIHeaderSize":348,
+		"A75DataTypeName":"",
+		"A75DBName":"",
+		"A75Extends":16384,
+		"A75SessionError":0,
+		"A75Regular":114,
+		"DimInfo":{
+			"Freq":0,
+			"Phase":0,
+			"Slice":0
+		},
+		"Dim":[190,496,104,1],
+		"Param1":0,
+		"Param2":0,
+		"Param3":0,
+		"Intent":"",
+		"DataType":"uint8",
+		"BitDepth":8,
+		"FirstSliceID":0,
+		"VoxelSize":[0.2,0.2,0.2,0],
+		"Orientation":{
+			"x":"r",
+			"y":"a",
+			"z":"s"
+		},
+		"NIIByteOffset":0,
+		"ScaleSlope":0,
+		"ScaleOffset":0,
+		"LastSliceID":0,
+		"SliceType":"",
+		"Unit":{
+			"L":"",
+			"T":""
+		},
+		"MaxIntensity":21,
+		"MinIntensity":0,
+		"SliceTime":0,
+		"TimeOffset":0,
+		"A75GlobalMax":255,
+		"A75GlobalMin":0,
+		"Description":"Created by Qianqian Fang for BlenderPhotonics, see paper https:\/\/doi.org\/10.1117\/1.JBO.27.8.083014",
+		"AuxFile":"",
+		"QForm":0,
+		"SForm":0,
+		"Quatern":{
+			"b":0,
+			"c":0,
+			"d":0
+		},
+		"QuaternOffset":{
+			"x":0,
+			"y":0,
+			"z":0
+		},
+		"Affine":[
+			[1,0,0,0],
+			[0,1,0,0],
+			[0,0,1,0]
+		],
+		"Name":"Digimouse Atlas - downsampled 2x from original 380x992x208 volume downloaded from https:\/\/neuroimage.usc.edu\/neuro\/Digimouse_Download",
+		"NIIFormat":"JNIfTI v0.5",
+		"NIIQfac_":0,
+		"NIIEndian_":"L"
+	},
+	"NIFTIData":{
+		"_ArrayType_":"uint8",
+		"_ArraySize_":[190,496,104],
+		"_ArrayZipType_":"zlib",
+		"_ArrayZipSize_":[1,9800960],
+		"_ArrayZipData_":"eJzs3Qm2o8qxQFElQyjPf65+VbeT6ARJRAhx91nr2/Waz3YCQgiJ5HaTJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSdIZaEXMtp7UaiHNu52r7tSRJkiRJkiRJkiRJkiRJkiRJkiRJ
+kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkhRa
+a0VMK5GKnFbqpEONw+EchoqcdKbMuRUxZc6tzilhJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEl6r1qrUVoF
+1FoNVOS0VgMVOa3VQJxzO8N/FTmXWm/1TipzOaf8eJ3MlDnF79vpTNn5TqlTwPyDShxJkiRJ
+kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ
+kiRJkiRJkiRJkiRJ1639VxFTAbUaqLUSqJU7qVB7gZMItZc4edDFnI+lD/nO8FmNUzSegu1T
+w1S+TqvGU8Lc7pnU43WVU8S8wEllyk53LudUnY6WObcipsy5FTGSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJElv
+UKtR/lbEFECtBmqtBqp3UqHWaqAip73ESYPai5wkqLWhyKkaTwn032obr7ccZ/isyrmTUp27
+9ZfpVOwHBcwnVPD6mQwnazw1q+1WtNomThLzdwOVMLeStXarO9u5XdjJZMqc+tP4XKbsY1bZ
+x8aqj8EfUIUjSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk
+SZIkSZIkSZIkSZIkSZIkSZIkSZIkSVJXrbUipkJqtU461Gqg1kqg1mqgVgS9xsmDipw2roh5
+b2fKlDkpUJHz31KH4e///f3PXOdfQ/KA5lZbgvNvhX1U5QxXczJ3uDY3mkyn5e4Ht5rd7ctp
+6U6bbpycw+iUqXIymI8N9BInh7m1muHcWg3z34orcgp26hknjXmEEplXOJnMPXQNp+zyQdVl
+l1sRI0mSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEkdtdaKmAqptRKotRqoFUGtBmqtBmpFUJHTxlU5SdAVnWEYsqFP
+JttpX85Q5QyZTrtzMqE7pyU6X8sd7QcZzvBTtpO/gWYHE+/cr7TMDfTgJK63tsRcwKnaD1Jf
+pzXDqXPaPJPktOzh3CbvpEnObdaJZ8qcuRWXwNwmp1RJzq2IuU326Sonh/lvxdUwV/vUOILy
+mKqrB6+4HJLK3EFFTjJTdpmv7LKlJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSLlNrRUwrkNpnVU6y1FoJ1FoN1Iqg
+VgT9XfaQ74yHkwXVOcNQAf3H1DjT8WRA/5hhNKYU5+9unQ99M7nOD1PmZB4TWo3TlpxgqC1C
+mU7aeH5GkuwMo5KcZSYW4oQ4rcRpacxtmUl7/bRrOalMvTNmot/naobz7WQP5zZzRpXBfA4o
+fTgLTjwz92Eh5dNClXNLPoJ+V/Rh7tZqmP9WXJFTxJQ5tyKm6qrYA5Tq3IqYssujtyLmAypg
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSJEk6W621IqYEajVQayVQazVQq4Faq4FaDdRqnDauykmCipwpU+akQP8WPJQ4
+w1DhDBMmA2qXdCZSvDN8leq01toclOkML3CCoba03mKd1krG02qduxU3FDkpA7pbYzOHhEBn
+GPfeziqTOJ6q7ZPlrK62PKdlOW2NyXLymAdnzCQ5Eyb0OFruTJkqJ5L53kDJTJlzW3KCmTKn
+1TDzn7EyPs1VOdOPpnkfTiucW+b7232tzClhyi6+lTmvuTia6FRdVC67SF510b/sS4wPqICR
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS
+JEmSJEmSJEmSntZaK2IqoNZqoFYDtVYD1Tu5UJHTWg30EicPaq9x0qCxkwRNmDInBZph3tmZ
+YzIgzqmdvwsdhiEd+qdUOMMlnQn0pk5rX9BYSnNGUjRz5wzv7rRHJ2u9fS7xtU4c9IncOQ9U
+rHM3oKwX0P2elrmBJkzSjr3OJDpF2ydpP5jsBhdzWpJzW2eSnAmTs79NmRQnk3mBM8NUOXFM
+mbN4LhrMnMAJZZadWGbxs0/4h5Ka4XwOKJ8pc26p7293zV06yHBuVU7LO60eOSXMy65dpzkv
++W4hkan7julWxFR91/gl5TNlXzpLkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ
+kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiTpXWqtiOF0OiXQFZ0KqBVBrQhqNVBrNVArgloR
+1IqgSzuJECfCyYOKnHZxJwu6vJMDTZnLOSlQkTPHZEAXc+aZt3UWmDInGrqgM/xXvjMM804w
+VOx8QvdiLPPlfC3/Bwp2vqHxugt2hqEAemDG0Ps5IybLaS9wZo4+gczjgJL2tzEzpgKdjyUv
+QGHMeDCjNRflTJmUHeHZcMKc1Z0gcTxj5mpODDNxkobzKmfC5DhTJsWZYWKdtsiEHa/XRxP4
+dnoKJ4ypd3KZUziBzPeOnc2UOYvHglhm0QlmvlZcvjN/6SCc+RxQPnNrM+MpcjKYv1AJU/bV
+wtW+Mqv7LvgVPwpIdW5FTNmvQ+p+VvOfVIFIkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ
+kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiTp99VaEdNKpHunJaJ3y25f5TqtwBl1NScBeq0T
+Di0wnN/ozIAZzp2Yxdw5t2znwax1wpkHJ/ON7nGhVU7eacl0qWlv2xmLnWE4nFKn+tNCulMA
+1Tr5UJGT+Q467+RKbVSVk/thm3PcyYE4UQynz8lgOHHO1fY3DodzwHEpnpPjLDBlTjRU5Cwy
+nE4nFip0hv/Kd4ah0vmgHr1QprUH535sSc43lDGgO2a6kZKYCZTmDEnOmElyJsx7O+3Jansz
+p02dkRTmfCw6GZoOJmdHmHMyNlCZ8+TVkzeeImfCxDgzw0nZPs9365z1Nj2/CmHGzr/dL2E4
+t+nxpsCZ7mspzixT5cQwt/a99Quc/OHcv1BznbbKVDlhzLoTx3w7ycNZdQKZNSeS+d6x053F
+z9qxzG3pmBPMfK24fGd+QOHM54Dymdv0nCDNqWBmLovlMGVO9g+uF6A8psxJ/b31AlTk5DKZ
+v7eelfIZSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk
+SZIkSZKk+Nrfipgv6f7PSc5DRUyCtOREQ4tOsLTihEJrTiS06gRC604cxMlgwqAihvPeThTz
+y5ww5rrOnBnHPJwlVjkTKJ5po7/MGk6xc0t35gZU5AQyt9Fis4ZzgrP4UObln7KKnGiGw+Fw
+ruosMJw+J5rhcDgcTo5ztfefsu+yqpyiT8Fv6iwznE6n7KtTzpoz/C3dGYZlJ/ja9fBlTbwc
+Z5iMLdIZK/dQINPmRxLuLK2yUGdt2wQ6M/tACvTFtFzn+XCynJQDwsxLtMpJeQE9Mt9/Fe+M
+x5G0v03XWc56m+7TWdvn2d4Wv32WoAhnZr1VOC3r9TPDpBzfHrfP5+unwsnar6f7Ws7bwpPX
+zjs7icyns3IaH+vMvj7DnXzm43hd5qQzZ3GimI8dYfoZLpz5fqEmM2dwIpkVJ5T5hl7mBDNf
+pyLpzG3+TSHeuc05Ccxt5nCQwfwdUMFau+X+XHQNymIu5+T97HENynQmvx9Nh5KZLyid+SdV
+KJIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkvVlF8/cWTUd8K5r4uGqCZQ7nik7V
+67TMKTvASZIkSZIkSZIkSZIkSZIkSZIk6Xf3eB9L2l0trX3fatTu+vxn4cxyRUwMtMUJgDYx
+Zc5x6Jc6hyEOZwfD4QQwZ3OOMidzDjPnco4zZzp7i2BO5BQxbzWc8zgxzFMniPltThRzEieM
+OYcTx6w6gcwZnEiGw3nihDIczjmcWIbD4XCeMpyTO1c7fbvapx9Op1P1aZtzBmf4r3ToL/P5
+f8nO34bvEp1hXNZ6W4GymKwNNBlOjrO+ccKc2Y0zhDtz+9p4QGlO/HrbwmQ5Gfv1jDNhgp2P
+g2jWeCbDyNk+03WWM55hesxJ2g+e7gXB2yfXKds+442TtF9PR1OwX7eW9jqd2QWSjwcL+1qh
+E8C8xElcbVucCOYVTuZq+zhezx8FIpkXOKnMpzN7VItkno4n3MllfnbsZGbVCWTWnEim2slm
+vt+5s5nFAUU7t7RzqS1OPPOxhfKH829AFczc5cQiJ4eZQkVOFjOG8pzp/X9v7txJucw3lM3c
+6h6jJkmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJKm8oulHS6dTLZseNh0qd3KhqnmC
+OYedS0wYzeFUOi94oaYyZc7l3lDLJpC/mlM2IX4R8xcqYSRJkiRJkiRJkiRJkiRJkiTprsJf
+Ztf9or3sDoowaLygNi6I+VrUZPmR0PLCQ6FtTJlzGNrqHIQ2M2XOMajI2cFczjkCcTic0zu7
+GA6H0+/0M6d0DjBndI4w5zu7Psac7cPPUabqs+k25zizyQlgzuREMBucEOY8TgxzGieIeeZE
+MSdxwphzOHHM1ZxTbB5OnxPH/ConkOFwnjmRzG9yrrYfcE7uXO30gMO5pPN2n7b/LmsocqrG
+04a78pxhXAY0wzxKSczHaox2nq20MGd9nUU58xsnfD+Y29cmAwpxvpacut4ehtPmlXBniQkf
+T5tngr6PWR5HoLOytiKdTUzk9mlrXITzbF+L3j5fe1zy9vkaTdJ+PWWSXqejbZPvfC0z17lb
+aMpxdGZ/TnnbnllvGavttuEgejkngNn0vnAxJ4K5PZwdZDttzQlh7pxUps5p604Q88yJYn6c
+XKbMmXujy2DWnEhmxQllVt4Zcpzs4Sw50cwXlO/ciphbzpnhHFTDvM7JYaZQlnMrYsqcWxHz
+AKU6dY8Dq7qp+Z9UoUiSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEnSWTMpm6TPiiZpLJpz
+snYSzXyoalrQ8mlOrzFva9U8tK+YV/dyTtX8yhzONZzLTRzOiYAu5iQy15uovt5JZb6eHlvk
+/IWSnbKPQGUPEihiJEmSJEmSJEmSJEmSJEmS1FvR7z2Lfihb/8Pst7+jqk0KXOyiEQUtLDna
+2cQchzYyh6HNzjFoO1PmHIH2MJdzDkC/2+mHOKd2djJlTi/E4XA4vU4nwzm3s5e5mtPJ/Han
+lzmp082c0+lnzugcUMquhWx2jimnc44yG53DzLmc48wmJ4DZ4kQwG5wQ5jxODMNJcoKYszhR
+zC9zwhgO57kTx5zDudr2eT9nneFwOAecq50mXu0s/h2d4b4k6C/zCI2pOGbsPEpBzvDofKzH
+aOeDaEtDiXLG+8CsFOLMMPH7wfxwwp02ee3krLdZZbIbvKnzuYfPFOG0pUGEOkONM3wdCVaZ
+uO3TPqZWrnDayqiOO4/78iIV5bSfN4fU8bTv8aQ6P0usc+agFCfl+DY5GNQ5CcyMk7IbnMs5
+zoxfp+nOKlTkBDD1zjIUwZzICWGeOzHM7eezT7LT1p0g5pkTxfw4ucz6eOKY9QNCkRPJrLyA
+QpnlAQUzi+900c6tiLnN79Xxzm3uZZrAzF5OzHCy7v58mTOBkpgJVOSkMSMo0bkVMXdQLvMN
+ZTOfVAUjSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk/d5qJv2qnSwtHbqqk8yUTWZXNWde
+1dR8l3Sqtk/Z/nbB41uyVD8raN00p4nQa5yrzXd7OScNKnLGDIdzBaf4dTpwepyB0wX9PH2s
+yEkfz7dU5KQxXw/Wyx7O3YMcK5yvMSU6n091bdnjud3tB5nMPZTrXPDJCDWKJEmSJEmSJEmS
+JEmSJEmXqu5HfpW/jqy7s67uBrGyGzWCoMcFTZUg6GdZs0QQtLLsUKjI2cochbY7h6AdTJlz
+ANrFHIB+udML7WUu53RCnKs5fRCHc73hcDgczgGni+FczeljTut0Mr/d6WV+udPNnNPpZ87o
+HFBOeM3yGHO1S8pbnaPMRucws805zmxyApgzORHMiZwQ5jxODPPrnCCGk+NEMZxzO08Yzsmd
+q70tcDiBzlOmzHnHs/iPWRqHu1lI05zPKTtnqDBmmFTg3M95Gua075lHF9da0Ef6YbrWMpzx
+YFL2g4WdYAwVMUnOZDeIcDYokc7HVLeJTlseRcL2WWcOO0+B2PWWDm0bTbSzsqECnOEBKllv
+ec5ouWmv0xc5S9BhZ1KeM4ycBOa2uORoZ8Oxus45zNw2vflczTnO3H7ODl7vBDBnciKYb2cF
+KnJCmB8n6X10qxPE3Nr6iotiPp2l848w5sl44pzVHS6QWXMimZUdLpRZGVCRE8z8/ahVMZyl
+U5Fw5mNABcxtfEaa5aTdnfsqZwolOWMoiylzbkXMA5TJlDk/UjLzBaUz/6QKRZIkSZIkSZIk
+SZIkSZIkSZIkSZIkSZIkSZIkSVeoci6uusnFrjFbWtUsc69wEpnLTZpXNTffdZ2r7QcXPO5U
+zdZ5gelHWxH0Kufd57vlBDlvPsHyVZ3hWs5wLWcodYarOEOtk759Pqf5zxzP9HF32c7X7pDt
+fA0o36nZPu1z3852ksdze4UzJDqjB82kMbfH12mm00qcLyjdud29o2Yy9ddIk5nKBzBIkiRJ
+kiRJkiRJkiRJkjZX/GO1/F8TlkCtVUhjJQx6XNQMEwM9LGxWCYGWlhwMbWSOQpuZg9AO5wi0
+h7mc0w/tY/qhszq9UJGzm+mEOGVOF8TpgzhdThfD4fQxHA6nn+Fcz+lhOGUfsy7m9DG/3ulk
+frvTy/xyp5s5p9PPVF1TPuE18kNM1VcLm52DzNmco8xG5zCzzTnO/EongNniRDC/0AlhOFlO
+DFPlnGa1cTgcDucYU+ZUnSVGOv/mNHyYjTbDGR7KcGaYKZXnDMHOx5ZZHUyE8495stICnLZp
+6wQ5MxsneD9YGs5kQDnDmWyeyPG0RSTQaT9ilrM8iOjx3M9QnwM9XTxng7O2PwQ6q/td8HgW
+oUhnBTrGTPaD3OPOI1TlZJxXTReYc/o242Sstl96wT/Cef7OE+Vkv8f9c7a8Z0c5z6DjTLHz
+BCpyApjb6jloHLPBCWG+nazzgm/nGRTDPHWCmDsn7erEBieMudsR4j/DbXUimTJn+RUUyyw6
+wcztVuXMvwWFM58DKnDmznUTmNmTuCInhZmBipwkZgKlObcipsy5FTF3UC7zLaUzH1IFI0mS
+JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS9BurmVSqfDKussnF6mZLe/9Z5l7jpDHXdvIYToRT
+tr+VHQ+uduDJg17lXG3e1jInCbqY8730ocipH08KVO0Mpc6Q7Qx1zlDgPE5Tnu4MnF3QUOR8
+jmeocYY6J+/1c3tgPqgS5wrjGT3FMcUZDyhrvd2Ktk+ZM33+S7qT+P5zu1txuczPgK7iPD7h
+Ko95fNRZpnMrYuqe9FCjfEIFjCRJkiRJkiRJkiRJkvT2lf52KP/HXQ8VMZk/w0yC7hc1o0RJ
+d8taUEKg5WWHSluZg85m5hi0gzkEFTm7mDKnH9rpdENFzl6mFypy9jN90I7F//nzp8rph07o
+HFpxO51u6IzOgRW3izkAndT5jsPhnN7Zy3A4B5zdDKfS2c9wCp0OhlP3MfhiThfD6WN+vdPJ
+/Hanlzmp081c7Zr/LucAU/WVzA7nEFP1TdbpnIPMVucoczLnMLPNOc6cyglgfqMTwVzN2cBw
++pwIhsPhcKqdDczlzqrinSHZGU10Gu9MlTnrbZyZtZax3hZGU+VMoCRmAr2H87WUu8Wn7Ad3
+zA83RQKd7z8tHHlCnLYwiHjnGVN2QYyz6Czt0gnOChTnrEPBzhJ0iHmRswaFOiv7XJFzjJl5
+neacJs4v9HXOQea3OkeZkzmHmduWE4MYZwsU4ySfUn056+/Woc46FMB8OWnnH9/O0wGFMN/O
+IhTDPHWCmB8n5V10zpmDwph1J45ZX3FFTiTz80qNvjDxKmfp0BPNLDjhzL/nieSvtdvtNvvx
+KsGZOxnJYMqcKZTDlDljKIspc25FzAOUydxDuc6tiPmU8hVJkiRJkiRJkiRJkiRJkiRJkiRJ
+kiRJkqYV3fBedWe9G/glSdLlq5kbqXqup2ToFZN+XWAWs1YDjZmrOUkMh3NJ52UDutqBp2z6
+0cs5yfPD/kx7y9nhDHXjGYrG89cZsqDXOEPairtj6pyvXSHbadnOUDSeUufnpZrljIaT7KQe
+eVoR9OjkHbJnh5PuJK+34b7EHeElzl+pyElgXuckvtFVOLeRk/XGfe/kHQ4enJbq/EDVTg4z
+fYDSuzujJ2mlMR9QAXO7ewRhJlP3JcOtiPFACUmSJEmSJEmSJEmSpBPVSn6d0h4rYkKlu2VN
+mTDpflmzTIx0t6wlJQRaWXgktJE5Cm1mjkE7mDLnALSLKXO6oZ1MmdMLFTlbl/7nz59D0A7n
+S8p3+qGtzKfTDW12Dg5or9ML7Xb+XMU5tOJ2MIcGtMdpVU67pvMn3WlVTutdcWd1WpXTruZ8
+xTm1s4/hXNTZyXBqnb0Mp4/h9DGndjoYTvJVl+s6XQynjzmt08mc1ellfrnTzVR99XNK5wBT
+9Q3gDucQcz7nGLPZOchUfa99Mucwcy7nOHM152LD4XBO5wQwHM5m52qvn6udhbyfM57hMtqZ
+KrNUiDNRplDOcMLX29dinkIRzvAxI3Xi9lnYCZKcWSnD+TcB+ufiM7bPz2juhzXd2Y5CY+d7
+cBXOQgFO28Bc7rfdnFc767t3mLNyLAgfzzJ0hHmR06qcFegQM92vF8cT7aSstl974fpiF8hd
+iD+1c5ipc7JP3L6cDVAAc3v6Zl3mRCjfTtLZx9TJeXfb7EQxP84sFMY8gYqcQObOib9w9AjV
+MGXObWHPjmbKnNvsiotnbrMn7wnOLfml892UyXGmUA5T5oyhLKbMuRUxj1CmcytifqBk5lPK
+VyRJkiRJkiRJkiRJkiRJkiRJkiRJkiTpNZXcUF10f/it6E70qjveP5mh6g5+Tg80lDnZzNea
+u47zT6pgJL1DlWciVU7ZGU8yVDVn0QvmesqEWg3UWg00dt59trSXOVWz2Zk1j8Ppdy7zOh1S
+oRc4Q6ZzmzrJAxpyB3THXM7JhF7jfFAXcIZK5/s19PbO8BonAbp3Ml9BnAPOcLHxTOffv4jT
+LjaevB1hxhkqnE/sbZ3xAaHSSTsgTJgcZ6JkvXHnHw4etk/LdG5Xc2aez5PCzDzY6M2d2+hp
+lFlM1UX5uidKFDHVP98o+Jauyin9nVUB8xcqYSRJkiRJkiRJkiRJv6by31ik/tZmUuTSV5gw
+6W5Z80yMtLjsYGibcxjayByFNjMHoRM6R6A9zAFnF3MA2un0QnuZTOfPnz+HoW3MRwecTasq
+ANrkBEA7nT9VTie0jZlAVc5uaKtzdAt1OF3QZufYgLYzZc6h1+oZnXZgxZ3SaVdzWrGz/1C6
+02lVTrua06qcdjWnFbx+7uOc2tnFcDjHnH0Mp485u7OXObmzmzm3s5/h9DGczKuWL3G6GE4f
+U/Xdwm93eplf7nQz53T6mapvTs/oHGF2OIeYqh8EbHYOMmdzjjIn+13IuwznlzqHGQ6Hw+FU
+MJw1ZzSJYqTzaDxOphntDDMFO3Nj+YtMpBRnZhuFMBugJCd2+8zva/HQ3WJSN9AX8WBNiaNO
+GzkzfxXptKUhRDub4nDe0Vk+EhxlJs4aFOY8gS7mHGHG+9saFOms7XLBTsl6W+kQcz7nGPNr
+nYPM2ZyjzMmcw8y5nOPMbcuZdQBz+3eEXqcimNvqhYk45vbkk1UUc5s+RyKF+bu/rTlRzJMB
+xTE/TvgFkDGUc13idc7Siotl7gb0Giea+YGSmdvsIS7BuZWstdvfAeW+RH+gGqbMGUNZTJlz
+K2IeoSInk7mDcpkvKV2RJEmSJEmSJEmSJEmSJEmSJEmSJEmS9CbV3IBcekN14R3iydDFnG9k
+KBpPkfN3bo8CZ7iK067p/JuZ61LORWb0qJ85xPtPL3Q1p+SAXeWkQ0VHntZqoNc4ZZNXVU3G
+VTaJWdasbBzOtZ2hxvmeRZGz1ymBLuZ8Tds5JEEPzpB3HtceB5R3Gvc4oCFrvU2fNZTrDEPy
+gK7uJO/YjxM6c/qcjImcX+O0Wiceuqgzntf77Z3xVP/v7Qxt/DyjPKdVOP9Odmqcku0zgXKc
+u+NB0nt3Gw8o6Vyk1hle4aTtB3dA3jv3CErarT9X3Jh5Y+d2NWfuuTkZTJnzBWUzV39ERhrj
+e+7jUC5zK2Kqf5+WzhQ+WcTzSyRJkiRJkiRJkqRfUvGX65U/ssj8WXYS9LWoeSVKWl56KLSJ
+OQ5tZA5Dm51j0HamzDkE7XEOQLuYA1CRs5NJc/78V/tzGNrC/NQPPSzzqfMnwPn+37vm9EKP
+S3y+4nqhZ5unzonZRFucmX0uhRlBrQM6mXMYKnK2Mo9Q2w1td9rVnAn07k67mtPKnd2H0n1O
+u5rTqpx2NadVOe1qTqtyWvpx5zEOZyfD4Rx0djGcPub0zk7m7M5eptPZzXD6mFM7HcyZnR6G
+k/TlwsucPua0TifDqXF6mV/udDPndPqZM/4i4AhzQucdmPP9nuZizkGGk+scZTgcDmcnw3m1
+M5mxM9T5J7TJBKRTKmI4U2MKBTDPB5PhtHkogMmH5pilVRcwnBkrdDyjJS3vBLHOFxbtLPwP
+b/NSvFM1Hg7n5U4/M3KWjjfhzjoU6KxCRc4BZuqsQJwlZ3XPPsK8zElifq9zjPm1zkHmalco
+NjqHmXM5x5ktToCyxQlhbv/OcbLe3MbQyrtoFHObeS5GBrPuxDG3tY/Ygcx/UMrlghlnEQpl
+lgcUzPw4Q65zK2IWVly8MzugBOb2dehJf4jNJ5D+dJmJk8NM34WSnDGUxbzISWNGUKJzK2Lu
+oFzmS0pXJEmSJEmSJEmSJEmSJEmSJEmSJEmSpKtWc8Nu1Q3IRXdUv+AO8aHolvdM5+HO+uFi
+TsV6+zevR77zMbVHgfNv9sQCZ6hxPqB85gPi7IeK9oNW8zotO+6UOlca0FDjDGVvDLkr7u5o
+UOG0Yid9rqdqJ32SrGTozkk9KEzHU+bkzP5W47RXOIkb6GrO44lvyzv2jJ2sd7sHZ8h7V+UE
+OVkfU2ec1AFVOVfeEVKPpFfbEV7hZG6gaqdVOhkTEr/UiYdGTkt2hiKnjZ+fluW0Vum0Amco
+ckZPAOJsd9rFnEToZ5++36/jT38fneHuWRYZzt3hOum9u40GlHWOsMRUOBkncfdOyx7P3fKz
+zhC+jgSP7wqp661lOrcXO9HM3ZqrcrKfkTG34hKY7wElD2fuAUopjEdkxDhpzEt+/3SxJ3Fc
+5IkfRcw3VOSkM1W/u5QkSZIkSZIkSdIJqvvarvLb9RxpisRD80YktCLEQc+REGgbcxza6hyE
+NjPHoB1MmXMEKnJ2MQegnU43VOSsLfLPd59/PABtc769Xmi82C3QMef+f/Gy0wtNFvnM6YRW
+hxM3oNWtEwhNF/wcynGmUOuANjgTqO2HtjATKM05Dp3MaQedrcwslOK0QwM6odOqnHY1ZwK9
+u9Ou5rSrOa3KuT/9vYTTrua0Kqelvm/PxOEUOjsYDueos4fhlDu7mPM7+5jTOzuZXmcvc3Jn
+N3NuZz9zaqeDObPTw5zY6WI4fcyvdzqZ3+70MpwSp5s55y8pTj+cU/6gpsg5wuxwDjHnc44x
+v9Y5yHA4nPM7WxnOy53xJLGRzgRZxCKcsTEHRQxnjISvt4nz9VexzszGabOThB6EFveC4B3h
+fjGJzmRRKy+f6I8+y1Cs08YzhOY5VeN5V2cfwzm3081c3Fk8fsY6Kwfqg8zLnFUo0lmBDjCv
+c3KY8X5d5Ky+gN7RyWLO5xxjTuccZH6rc5TZ6BxmtjnHmU1OALMFCmGeOjHKXyfrlGDqZHwe
+nUIrF6gCmS8n/nrO2FmGIpmfAcVeBVtxxlCwswRFMwtOOHO7vdJJYD5X3MO1owzmY0CtwEl+
+hZY7YyiLKXNuRUyZcyti7qBc5gvKVj6kCkWSJEmSJEmSJEmSJEmSJEmSJEmSJEmnr+z+1opb
+aavuQH7FndtFd6IPQ43Thppb+If3d9ornMQd4X4sRc5Q4nyM6N2dVu98TPFyMadgxpVU5/bo
+VMzs8jHPT7rzNdFPtvM1zU+Sc3tcbSXOcEUne0f4nsIq17mbKCvVaVXO3YgqnDRo7GQde+ac
+DOilTgL0K5x4ZnSCkLdjc87tvO4Al73iLuK89B2oyrncO93VnEyozGlD6seGH+f+WQ+JzlDj
+tIfxJEx8/Oi0Yid+wuiXOHd/kecMnC5nFOfcTiy0YISfX30td5gwac7H6+f7D0nOx9nB3UlC
+hjM8VuTk7W/DzIBCmQfn/g8pzt3Ss05FvvbqYfQKyjru5D8i4+4IUOBMoGCmzFk6Yoc781A8
+M78n5DnZzCxU5KQwUyiJudyjOIqYst+NvcLJZG5FTN2TRYqYqt9dfkH5TNkPViVJkiRJkiRJ
+0our+yKl7vvBLKnNlC8ES2tEIPSciXA2KBHQNuYwtJU5CG1njkF7nAPQLqbM6YZ2MpHOn/8K
+h2aVr+7+brTzZ6UD0B7mCLSZuIOOOaOlrUkxzJPxdUFT5umKPOTMMQtQzyaaLHHL3tcBjZY4
+3slXnH3QZMHboVhnVtrtbGDmoN0rbpMzhZKcBeh9nQm0c8VtZRagBGcMpTlz0Fs77SVOy3Om
+51tv7oxPVNKc8alKvtNynXY1p1U5jdPn3H+mTHXaz1lrrvNTkbOZ4XA4/QznBc4OhtPHcPqY
+8zv7mNM7O5leZy9zcmc3c25nP9PldDCcoO/Mfp/TxXD6mF/vdDK/3TEcTtkPhPqZUzoHmD3O
+EeYXO4eY8znHGA6HU8BwXuzMTXUa5iwwc1SIMzVCnQnz9RfB6206nPsJfOOd9rjS5kcUwGzZ
+DwLPrVf369hz+CXkiLOwvCUp2lmKwzni7GRcCTm1081c21l8Nwh31qF+5mXOGnSAubyTxLzG
+mZsRP8fJYn6vc4zZ7BxkypyN0GHmXM5xZosToGxxQpjnTgzzDIpSnjhxzO37gfK5zD8o/NP1
+shN+tW3qtIXrH7HM94AmUpETzSw44cztNuckMD8DKnEeXq0ZzOeKezhLzHLyn8jzt/wHJn1B
+NcyLnDTmEUpkypxbEfMNJSufUL4iSZIkSZIkSZIkSZIkSZIkSZIkSZKk/mpuPC26kfYVdyAn
+Qo93bg9VTtGd9UPagB5HU+NUjeffzHnv7dxvnGs5n+staUcockYHgxJnSNw+o3U2JDtD+5lU
+KMW5fb88v2dJynTuVluN09KdIdd5mJ38408lTv4G+p4gKdf5mYqpxsmGXuDkHkpf4ORMxlW0
+4lrRgF7qJECXddpFnaQdjvMuTkt15nfsKzlXegdqNU4rcb7W3RWd3CNCqdNKnWSo3kmYKPjB
++fnzJZz7v7iaEz7T9lKcPid4xvXf44RCC0T4+3e183AsSHj7HjEfpwgJb98/i78rbT+YZd7X
+GcalOj9/jGdun8v+OTdIOueZvnhanjPfWzrLUCxT5ixC7+osQOHMvBPPzENFTgYz46QwM1CR
+k8Rc7lEcVc4rfnCXybzASWXKfnhZ5tQ+KsWzUiRJkiRJkiRJ71P1NzZl39ulSFMjElpYejT0
+nAmBtjAR0DbnMLSROepsZQ5C25lD0B7mCFTk7GP6ob1OJzSzoD//ynb+3PX1N/77j2jnz3KH
+oO3Mj3SQWTeOjWgX8y0dcTYxX1IQs4oecqYbIRSaMhtWZMeamyxzy/6335ksctuLaTf0uMQ2
+ac3ZA02XvAmKd+ahvc5zZg2KdWahDCcA2uYsQtHOEhTNLEHxzhyU4sxAOc4UenNnAr27M4aK
+nJbmtCpnfIpf4bRMp5U7Lddp98wVnIcTvSs493FSGQ7njZzNDOcVznaG8wJnB8PpY97A2cVw
++phuZyfT6+xlTu7sZvqc/cypnQ6GE/PV6S90uhhOldPHvPAXG+88nNM6ncxZnV7mpE43c06n
+nzmlc4A5o3OE+cXOIYbDuaKzneEsOdOZTlOc+UliY5wFps1BMc7PIJZWXKTzM3lrqHO/mPvt
+Er19Hhf0ZD8IPElcZWLPrZdePdFOe5x/P9NpCzPtJjih49nJcM7t9DKcEqebqXL2MW+22hbf
+dKKdZ1CR089MTnZ+k3OAGW+fVSjSyRrPjh3uELPjhRro5DGncw4yZ3OOMidzDjPboABmixPB
+PHdClOdOEPPMiWKeQHHMbe0oHcjc2tIliVhmBYplbm3hIkswc2sLl3Oindv8daNwZt6JZ35W
+XOKzGyudmRWXwty+LiQnM7fJmXWak/q8y59GL9E0p4gpc25FzK2IuYNymW8om/mE8plbjSJJ
+kiRJkiRJkiRJkiRJkiRJkiRJklRY7Y2n2dJL7nSuunO7zEmDRsxQ4vydNaDGyRrQeLUNnA4m
+bUd4kTNw9jtfE17nOj8zryQ6ww+U6wx3c3nnOkOqcxttnlbkFI2nZe0Hd3t2zYCyd7jJeLJW
+3IyTe+SpcpJfQi91EqDXOvHQxEkaUJsfEIeT/gJqVU6rcYYa53Mb5Tt3Ky7emR9QlfPGG2h+
+jnLOPqdVOV9dzUl9C7r0gOInJH6xEz6RcxH0eicW+kVO7EzonHAndEb8+cLfwBeYZOfrFDv+
+SsID8V3W9hmGOSbbSdvfhnGpzp2X4zyurVxn9mUU7Cw+JSPayWdO8Yb6ls7rz0iDnVd/NAl3
+5qF4ZtZJYOacDKbMmUI5zKt+AJXFvMhJY6p+13e9R4tUOVU/8Cx/VEr+40VqFEmSJEmSJEl6
+q2ou0eZcQx8vK+erlMeFtWmRzsfiZpA4aGHh0dAGJkTa5hyGNjJlzkFoM3MQ2uEcgfYwR6Ai
+Zx/TDe1lwpw/HwVDS8yP9e+//xyF1pjHQp1l5l466Kwi99Ah56lyBNrHfFP9zlamE+pweqAe
+5k/HJpphNsgRzpYdY/+Axovc+Jrd64yW2EaFDeh+gWNkDep25pCn0H5nuTUokFmFQp0IaJOz
+BIU7y1AsswTFO/NQgjMLZThzUIozA7Wt0CmdKZSz3sqcCZTljKG3d9rVnFbljM4n399pV3Me
+zl1Tnbs4mQyH807OVoZzaWczw3mFs515C2cHw+lj3sDZxZzf2cec3tnJ9Dp7mU5nN3NuZz9z
+aqeD4UT9JIBzIobT+Yua0zp9zGmdTuasTi9zUqebOafTz/xq5wDDyXeOMBxOpbODeUdncerO
+UGd+9tZwZ2H21ghnwtz9d+R45pz284SEPOcTiN4+jwta3zyRJ1VVzuorKNRpS3vBEWjhf/jS
+TLvhTPCK45Q4vUyVs5Ph9Dm9zC93upnf7fQzr3BWzqqDnSfQAWZ8kngG5whzcSeNOZ9zjNl+
+QChyjjIncw4z25zjzCYogtnghDBPnRjlqRPFPHHCmHUokLmtHNUimdvy8TOUuS1eBItlbi38
+Us5C8xeNwpnb7NWpeOY2ecZUoZPAzK24FKbaSV5rM6/UTCefmRzhspzRW0MacytiypxbEXMr
+Yn6gZOYLSmduRYwkSZIkSZIkSZIkSZIkSZIkSZIkSTp5JfcbFt2oWX8jbd0dyGV3VA95t4g/
+OkOVkzSg0Vqrcf7NYFXjZO0JbVyOM2HqnJQNNN08KeOZDuZSzlDjfE7ukewMVc6Q7wx3qy3z
+dfpPKHC+J+BpSc5t5GSNZ+IUbKAS59tK2kKTF1DWnjDzQi1zclfcC5wE6LrOwzRwmU7j9Dmt
+0kna4dr8gDi7nFZyQLig08qcz//OhqqclubMQ5w+5413hHkn/VBa7bwv9GonfOLjImjZCZ6Y
++vVOKPSbnKoJ1zmdTiC0AISfms4D8R8hH4ivz44/U0hHO8Nj8RtonQl2FplYZ5iUs19/L73E
+ud/v8pz5l2uss9z7Oad4Q31H5wRnpLHOyz8yRDuv/TAcz8w6CUyZMwOlMFMnh5k4ScyrnCzm
+RT/sy3NuRczlnLJnmFQ5dc9KudUokiRJkiRJkkbVXAGsvkIbKY2WNf6CIwi6X9qECIQWlh0N
+bWEioG3OcWijcxja6hyFNjvHoO3MMeiMzgFoF3MA2un0QnuZOOfPf4VDc8hnodAy89hBZyvz
+KB111ph76YjzxHiAsp1vKZv5lnqdzUwfVO3sYLqgOWbj7n1sOJsGuBtaZNalo057KA56WGKb
+9AzqGc5UeX5Q7XDmmKfQ7vW2WAz0lFmVYp1VKNJZeycPdRahrc5GZgUKdpagcGcBinfmoY0b
+aI8zC72zMwclbJ86ZwbKcabQmzsTqMgJP44uQHnO+Lz17Z1W5bQq5+Ek+RJO+2aSnZ84iQyH
+81bORobTx3Be4mxmOH0Mp495B+cXD+cNnF3M+Z19TLezk+l19jInd3YznD6G08dwgn64cx6n
+izmv08ec1ulkzur0Mid1uhlOhdPPcAqcAwyHc0VnDxPo3E2pOjNVaJizPFFsqLNChDuPf4hy
+psP5+XMktGvzBJ5VJTEzL5+vmXxn1lr0WUjCNLvzy2vR41lilipyqsbD6WI4fU4v88udboZT
+4fQzp3QOMFd2lk5xIpg7Z/FUqtg5xDw6q1CRc4zZvt6KnINMmXO7czKZemfuakEcs8kJYLYc
+SUOY504M88wJUp45Ycy6E8esOoHM7ba4P4cq/znpT/75coKvgK04M1K4M344UxJzmz5jKoWZ
+dRKYrw30CieFmTo5zK1mrU137CTm1mqGc2s1zD8o9yX65eQecGadROYBKnJSmVsR8w1lM59Q
+PvMXqlAkSZIkSZIkSZIkSZIkSZIkSZIkSVJPtTdQZlOvuGM3U3pkhrQ70VsNNFL+q8L5N6XQ
+xZycFTfZD3KcMVPlJK23ueFUOEOhkzIRysxw8p3PyTCSne85RKqcjAlxplCKc/sx7mbYznM+
+p6EucYZM5zZ2krbPdEA5O/a30+72g+RXUOoGmrxOy6CLOS1pT5jdEa7htMwVN3ZagdOKxlPm
+NE6n8/WHZKdxjkFXc2yg0zjz0NWcN95A807ZK+h9oVc70dCiEwwtO7HQCZxQaM2pmtD7ck7V
+hOtlTtVE9flO9IfvGaHdP8Yixxm+r2JGr7gxcnelJ8MZHovfEe62er7zfQk71xkmpThTItV5
+fAUlbZ+lxz1EMS8/vkU753hDDXTOcGYVyZzgFDuWKXNe/CE1nHmtE8/MQhnMjJPCTJ0c5mVO
+EvOiH9xVOWmMZ5gEOKnMFR9icqtRJEmSJEmSVF/NBaaaK2avuOAc/vXwLBIIzS06QdrARDhb
+mAhom3Mc2ugchbYyR6HtzjHpjM4RaJfTD+1jypxuaK/TCe1mgpw/X8VCi8xjh6FtzAg67Cwy
+I+oQs4o8Qgecp8ohaBdzT2U7f7qc/Uwf1OP8OeDsYXoG1MP0DGjqbHF3D2jCbNxeB51215Yh
+9TntsSfQnx3O/RLbpOdQhzNlNqy6/c4cs2Fn2OvMM8+hXcxaVc4qFOmsQaHOCrTR2casScHO
+IhTtLJ48RjsLUJmzCdrjzEMJziwUv97qnDkoxZmBipzo484S9O7OGHp7p1U5rcoZnfInOg/X
+S67gtB8m17k77891fuLkMZw+5zhzNWcTw3mVs43hvMjZyHD6mDdxNjOcPuYtnB3MEWcPw+lj
++p19TLezk+H0MZ3ObobTx3D6mDM7PcyJnS7mvE4fc1qnkzmr08twSpxuhnMlp5/hcH6DM5mM
+NMiZZ5a0KGcViXa+/pDsjP+Ut94eRpbiPNtCcc7jQ8jCnLmFZUyzu7C8vzMuh+5vS07VeDiR
+DKfP6WV+udPNcCqcfuaUzgHmNztHmBc4S2dSIcyPs3zKdk3nGHM65yBT5ty2OYeZcznHmTsn
+ldniRDDf0LITwzx1gpgnTpTyxIlj1pxA5cdJZpadWOb2KUycYOb2ecQZO9HM7fNC25DM3L4e
+aZby8KeJk/TQrPtmnAxmxklhbkXMbXKdsshJYr6d5OHcWg1zG10Rz3NSHm+4AOUP5/GzYyJz
+K2LuoSInl7kVMV9QOvMBFTCSJEmSJEmSJEmSJEmSJEmSJEmSJF2rojsOi+7UvL/DtepO2txb
+kEugMTMkQWNmGKqcnAFNnZwBTbZPjjNmWtJ6mxlOyXiSnJnVlrLi5pgqJ2XClbnhpDtfk0ek
+Oncze6Q6VeO5m4860Rnup72Od+5nlLqYM6Q6P9DdFDyJzsP+lrjiCp0hdQtNjzxFA/r4c6bT
+rua0eidhTrYRdC3n+0+5TuNwOGd0FqAqx4o7jXO5Af2SPa5sQPHz6hZBi07OvMfp0IoTCp3B
+SZhnOx06hxMHncSJnj/+8k70p8jp8j8vyAUPaIKMpnWOd4Zhjol+LsISE+sMowElOT/XfFOd
+YVzLc9rnhfnxfh693rIfkPG1Ty8ob3d8O8kbUBhzkjOeIieQOcMpdijz+s9AwcyrPwwXOfHM
+rJPAzDkZzIyTwkydHKbqB2plzq2IeY2Tx5Q5ZQ8XqXLKHmJywaeLSJIkSZIknb3a6z7h0v3y
+8i7Q3i1vjERCc8tOgJ4yMdAGJgLaxARAG52j0FamzDkIbXeOQTucQ9Ae5wi0y+mH9jFlTje0
+1+mFdjt90HQxf/4rHppTRiU4M8qclcYchrYyI+kAs46MoH7nOfMg9TqbmHvq3M5mpg/aP5wf
+KHk4XQPqcjoG1MV0QBNn10u2m9n1qu122n2bhtTltLYP2u7cL7FNiltxdwucMs+hDmeOeQrt
+d+aZqAF9L26BiRrQ4uK3SoHOKhTprJ8CxTFrUKyzdu4Y6ixC0c4SFO4sQPHOPJTgzELv7Mx/
+/npjZwZ6b2cKJTljqL2706qcVuU8SKlOK3darvPw6SKReTjvT3Xu4mQxHE6Us4XhvMzZxHBe
+5WxjOC9yNjLv4mxlOH3MezjbmUPODuYdnD3MGzi7mPM7+5jTOzuZXmcvw+ljzu3sZ07tdDBn
+dnqYEztdzHmdPubXO53Mb3d6Gc6lnG6Gw/kdzvIcoaHO0vytwc49MiOFOu3hsUMxzsxq+xlX
+mnO3WVKd5emCo53HPSHTabM7WopTsL89idPFcPqcXsZuUOL0Mr/c6WZ+t9PPnNI5wPxm5whz
+QucQswMKclY/LB5nzuYcZcqc2xez6hxnTuUEMFucCGaDE8J87XDpD355Np4g5okTpaw7ccqq
+E8ksO6HKshPMLDnRzO370Vm5zK3NXZyKZ263uctgRU4GM+OkMFMnh/nZEaqcXKbcSWZu7RHK
+drKHU+ykMx9Q7qHg26lg7j7SpTJlzq2IuRUxX1CRk898QBXOrcqRJEmSJEmSJEmSJEmSJEmS
+JEmSJO2r9Aa9wjsoc6lWBLVWIo2ZLGiEDG0ocdIGNFGGIqdqPDnODJMCTTZOjjM7nAJn+Heb
+/WWcDybdGSqcz7mu88fzMxNGrtMqnK+1NuS8fm5jJtl5WG25zpDq3EZM0n4ws2cXbaB2lQ30
+MG98qlO14nLnrBntcEVOq3FajdM4HM4bOQlzNF7MsYFiofd1LjegF+9x7wstOTnz9+ZDy07G
+vMf50JoTCa064fNf50NPnOB5w1/vxM63zolzYj9/zyx/9AjCDOdnkuroz99PmdDnIoyQhFnR
+58fTkpzhkclyhrXhxDl3C057PMLMcjOYMucEB7haJ4gpc05yZhXnnOLUN9I5wWeTIieWefWn
+7nDmtU48M+skMC/7qVXZT8eSmLGTxbzISWNe4+Qxj9AVnOs99aPsaRyeXiFJkiRJ0sVKuxzz
+sMjEy5k/CxwjodDcwjOgZ07Zt9AxUJGzhYmAtjmHoY3MUWcrcxTa7hyDdjhHoD3MEWif0w/t
+dLqhvU4vtNvphM7rdEHTpfz58ycBmlEmxTtzyhx10FlkxlAaM6a6nSfGGOoezhbnXkoczqN0
+amcz0wl1OH86nB6mZ0BdTseAuphvKd/5pHY6kzWyFeoczr6Dw44BPS61td1Qx2prj0U694ts
+43KcCbMN2uvMMBugjc7P8maZ59DGFfe9uAVmC7THWanKeQLFOevQJmcTsy6FOitQrLN2Mhzq
+LELRzhJU5Pz9J7HOPJTgLH78eldnDnprZwbaxBx3tg1n//WJKmcMpTmtx+lgRlCi80DlOo9n
+/flOy3Yezscznfs4nE0MhxPmbGA413e2MJw+htPHcPoYTh9z0NnMvIeznXkLZwfzDs4e5g2c
+Xcz5nX3M6Z2dzNmdvczJnd1Mn7OfObXTwZzZ6WFO7HQx53X6GE6R08lwapxehsPhvKOzMLtu
+tDM8lurcPxcq0bnzspz7lTULRY1nfeuE7tdVzuK2CXe+HxsZ5yz8z/7Eapyq8XDCnF6mytnJ
+XM3pZX650838bqefOaVzgPnNzhHmhM4h5nzOMWY7VOQcZU7mHGbO5RxntkFhztKntzjmczxr
+UAjz3IlhPtfbshPEPHOimHUnTFlzApE1J5ZZcoKVJSecmXfimdvw4SQ8mmvsJD3RbOxkPQlu
+0cl7gP2jk8qUOa2GeZWTxdy+ryOXOmnM7fFaf5GTx9wevoMpchKZzx07fTgfAypg7k7ki5xc
+5ge6inNrBXt1qVO03v5CQ5FTNZ4K5pJOAfMXKmEkSZIkSZIkSZIkSZIkSZIkSZL0Wyu876fu
+RrNsqz1U5WTe6lwDjZ20W+troDEyDCXO39uR39mZrrWcFVfkTHe2IeUe1KlS4gyFTsoL9Ue4
+G06i8zEjcIVzP0FFnvMD5Tg/AxpKnOFhopI8535vy3kDKndy19vDESHv9TN1rrOBWu5cJaMV
+V+J8x+lzSk55OBwOJxeqcqy4WOh9nd+yJ7zvLlc1oCUnZZrgAmjFCYXWnPBpnAugdSd4+usC
+6TRO6HTrZ3Aip6m/tDMMP/+Z5kymdU5xhhkm4fEL80y0M/xcKo2fFX1+vbUap2U7872Tc6ID
+Twjz+5wY5jlU5EQxZzlVLHLimFN8Ngl1lqFY5tUfUqOZF19PimdmnQRmzslgqn4B9bJfdCUx
+r/ppX5GTx7zESWTKfkpa9jSO8sdxZDOFs/xLkiRJkvS0x8+oaR+O7xabea1sfCEui1p3Lvir
+lLIvbd/pW+gtTAS0zTkObXSOQluZg85m5iC0wzkE7XEOQLuYA9BOpxva6/RCu51O6LxOn/R6
+58+/gqD5hY+LduaVCGgbM5GOOGvKROplniEHoV3Og5TJPEi5zp9Dznamb0AdTteAepw/+50u
+pmNAXcyPVeB8SBXOn+3OmNl9bOhzfl4ZW52N0MNS232hA1pm8pzW9kMdzpjZCu1w5plN0Dbn
+Z3lzzBZo24r7Xtw8swEKcrZA2521qpxn0BZnC/NMCnTWoBbpPDnpDnQWoSKnRTtrH4re0pmH
+EpxZ6J2dGai9tTOFtjl7mTJnAmU5YyjN+U9qe5k+535U2c7jeXKi8xCHc0HnKcPhxDnPGc4v
+cDYwnD6G08dwXuVsYzh9zFFnK/MmzmbmPZztzFs4O5h3cPYwb+DsYs7v7GO6nZ3M2Z29zMmd
+3Uyfs585tdPBnNnpYU7sdDGcPoZzMaeT4XB6nF6GE+b8m4l2ZjraDGd+It9Q58GIg+ZXW7t7
+AlXieB7/kDKeYVjdPpHHgypnaZXFO21uT8tx2ucTJAucSKbK2clwOEeYX+50M5wKp585pXOA
+OaNzhDmhc4g5n3OMOZ1zkClzNkKHmXM5x5lTOQHMmZwIZoMTwjx3YpinThDzzIliVp0wZM2J
+RFacYGbBiVYWnHjmw0l4ANi4uauTKc702m4Gc5te0EthbpNLhzlMmTN+tl0S8yoni7m1muGM
+nDTm9vhQwIs5ecy3kzycByeR+XKyh/O1Y6cztU7+aitzbvnHto9amZP7TvrtfJ1ZFTityila
+b4XOcLHxZDMfHxkKmH8jKlAkSZIkSZIkSZIkSZIkSZIkSZJ0uopulCm/Yyr71tNWIrUiaOyk
+3Vr/0N/bKd/aaRNnKHCGd3dmVtvVnLR5UMZO/rwuQ/Z4vidtzhnO7WEgQ55zK3Ye5vWocFqy
+kz2hw2SnLoIKnNxpV8bHgyzn9hKnFa24CzhzUJXz1iuOw+Fw1pyKzwylTtWck5dzDKgXqnLe
+GFpwiqahjYcWnWBpxamZjjhYWndqpnGOhJ45VdNsl00bXjYNeplztWnqs5yviz1DJDTL/IWC
+Z5CeVe7mDc5xhlkm3JlXMtZbsTPeainQGElx5ityApjf6EQwJ3rnjmHKnLOcKr6dsw7FMaf4
+EFTkhDKv/zRc5EQzL72wmMDMQSnMi35qVfbTsSzmVsSUOVU/Vbyyk8ncQ7lO3XT1RYzp6iVJ
+kiQpo6KPdLe7z46ZH/XH162SqBUmlHri+FVKN1P33XAAdC7nOLTROQptZY5C53MOQTuYQ9Au
+px/ax/RDe51eaLfTCe13+qAOpws6s9MDLS7rz3cR0Mri74t25pWZIR1ylpQZ6oCzqhyEtitj
+qNPZwIykLmcb8yAlDqcb2s/cQclOD9Tl/Nnt9DH7B9TpfFs7nQ7mUzql08f8g/qGs3NzdTo/
+L/QdB7tDTKbTWhe012npzhyzUdrm3C1wymyFdjlzzNY38uPOBmifs8BsgPY4a0U4G5gy5xkU
+5qxL//6FIGdFarHOEtSinXno6x8mO9//MNCZgX7+WaLz8M8inbbM5Dntf/+V5LQq5w763/8e
+oCyn7XN2MhPnGwp2WpXTHpk8p328cEbOE6bvctids3E4nEfn+y+v4fz85ds77YFJde7/Ks95
+rMh5xnB+hfOU4fQxnF/gbGA4fQznZc4mhtPHvI2zkTnqbGU4fcx7ONuZt3B2MO/g7GHewNnF
+9Dv7mG5nJ3N2Zy/T6exmzu3sZ07tdDBndnoYTtnPrjmndvoYTpHTyXA4K87sbLTRzrAwLXGm
+M5HinM+Fz44mwVmQopy79RU6BfKz7ZPoLE9QHe20pQmdM44H2fvbehzOAYZzKaeb+d1OP3NK
+5wBzRucI84udQ8z5nGPMZucgczbnKHMy5zBzLuc4cyongDmTE8FscEKY504M89QJYp45UcyK
+E0asOrHKohPNzDvhyryTwNySHv815yQ8Nm3GGcZOCvPhBD88b94ZXTfMdb6pJOY2vhaa76Qy
+F3fSmNc4eczt4dmQFU4uU+7k7gXXc253X4/lO7nvCd9O7lvcj1Oyff5W6AwVTsX2KXb+W3XX
+cL5ePlVOLvOz4pKZTylfkSRJkiRJkiRJkiRJkiRJkiRJ0umqvIGlgGr3VTlDjTMMaVB7HE/a
+/VljJ2tAYyZpQJPhJA3oNU7LcmaYlO3zGufj1t10J/EG4S/hjkl1smeNaCMoa8KAaudu/oPk
+41vyje/3u3WRk/n6mZsZKcUpgx6PPEVO7Yq7mmMDcThnc6bM5ZyKU/lLOlVzNJY5CVCVc7kB
+zTtvPKDLrbkFJ1xadIqm1Q2X1qBIadUJhNadsnmcy+alLptn+3LToNdNU//u0/sPo//OcT4v
+xsXOhTyr3F0xTXKGWSbcmVfCoY+5sGeYtBVX4cw9jDLcWYjT5RxnzvUOVOREMGXOec6sipwg
+pu7RIuf4zBDorEGRzOs/PcYyZc6LLyOEM6+8UprBzEA5zMRJYsZOFnMrYl7j5DG3IuYV0+Kn
+MmW/Ja2b3r2IkSRJkvS2FX1iKPpoUvUZaHKZJ+dT3iITbK07ZVfm3+w3HGf6asuPOLqd49BG
+5yi0lSlzDkLbnWNQkbODOQTtcg5A+5xuaCfTDe12OqEtSx7/4qbK6YE2OeO/Ee38WfoHkc6f
+ryKg5aU/9Ln+hu6fFG5jPqUDvynchsysvn5nXZlspk7nmXJsQHuYMdXjbGQepFynC+pg7qBk
+pwMqdvYxd1LqcO6o5OHshQ45f/Y6ncx259hw+p297kZogdkOdTntrgxnhkl0WuuE9jltXOCA
+1piNUICzCdrpzDGboe3OPLP1DGgbs1qVs+nMMcLZciIc4qxA3/9KiLP+OSXSmYMe/nmUM4FG
+/zjMGUHtf/+rcP5j/vcgJTn/+yzBaZPh3EM5zv/+N4YCnTYznBSnzQznC4pk2sxwto1np9Nm
+nIzxtJnVluK06XBynPb3wLab6XBa6xhOn1M1npc47QJOmzCcXdDP30h17v5GkjM+DXnC9Dtt
+13AOOI9xUhhOH8P5Dc5zhtPHcF7nbGE4fcz7ONuYt3E2Mu/ibGU4fcx7ONuZt3B2MO/g7GEO
+OLuYfmcfc3pnJ9Pr7GU6nd3MuZ39zKmdDobT+ftuThfDuZrTx3A4v8ZZnJY4zYmbMnjJaV9K
+xD1Ma87nsNLW293qSl5vw7C2geKctjjfdrjzcMtSqtNm7mJLcuapFCfmlrktTtV4ghjOtZxe
+hlPidDPndPqZX+0cYM7oHGFO6BxizuccYzY7B5mzOUeZkzmHmXM5x5lTOQHMmZwIZoMTwjx3
+YpinThDzxIlSVpw4Ys0JVpaccGbWiVde6mQwt4xnps068Y+0W3KGCqeNHjiXxNza6CpokZPF
+3Nrjdd1855+Uxtw5qcN5jZPHXNpJZK7r5G6eSzsl+3Wyc7va8eD+m9lU5xOpGE/7/L401/lX
+uvO1T//3n4nMF5T+8vneQMnM7ePUt4D5KxUYkiRJkiRJkiRJkiRJkiRJkiRJOmEl98nc3cRf
+5aTfA/bTUOXkQSMnbaqARyZtQBMnZ0DtJU7e/Y1FTpsp38m7VW+0D1Q5FeutxBk+5qBOc+6h
+EqdVOT/zriQ7qa/T0R5X41SN5xLOFKpyLjegN3cmEIdzAedqr9OJ8+bvQFPnvU95ZpwMaI6p
+g6qcokk0LzigN4YWnDqoaB7acGjZiaVWnUDpiVM2v3LZfNFl81+XOWXzk19tXvf3nnf/5zJZ
+5Ky+s8rdpb8oaNmJXXGbRhPtfD8WMOqpZkvjacXO+O/mPO8j8PGQq85c7+L8ggPcC53jzKne
+uSOYsjO405ySBjFnOZcPY87xISiQWXMimRN8Gi5ygpkXX3+JZ174+JcM5XVX5pOYMZTG3IqY
+qp/2lTm3Iqb+t5fJzq2I+ZAKFEmSJOnlVZ361p3JF340Kb3PLfOKwpoTKa07YdATpvC3In5b
+0e28z1d125i6r2yPQqdzDkLnc45BO5wj0B7mCLTP6Yd2Ot3QXqcT2s10ShsWG/IzpQ3Lnvll
+T5TzsOgs5/u3SX/+fP2Nyb8T4Hz9z//z1dyAA4bzZ66v/wW90CbkS3rYToecZeYvFOSsITPb
+qc95hkyhLmcLM8ZSmTtov7OH6XF6htMD9Tn7oU7nT6ezl/mRcofzI2UP5wuqcrZBx5zNAzrI
+nNR5/P/bfUTdP5z9e/keZ6zsgTqc1jqg/U7rcjZBy0zsgO6WOGY2Q5ud+eFshvY5M8xGaIPz
+s7RZZvuJ1ianLTJbpLbdWe0Zke48/FvHnZWPKLHOHNT+9794Zyr9x/wt3GmzzD0U5DxC//sp
+0/nfQ7FOW2LKnP8lOS3XaUvD2eDsYb7fpoqcCRPutKs5bZZJcFrfcHouv17MWWDe1lk4GuQ7
+7c2dNsu8sdP2M31OmzI5zu6zt15n79lot9NGTJozrsh5wnD6GM6vcJ4ynD6G80JnA8PpYzh9
+zPs425i3cTYy7+JsZd7E2cxw+phDzg7mHZw9zAFnF3N6Z59yemcvc3JnN9Pn7Gc4fQyn83f+
+nC6Gw+G8rbMwW3C0czfNcsCdONucgFuLVp02e/9SijMPxTlD1XobUYnOwraJd9rs3WUpTpud
+CbuPeXrcCdoN9h/fOKd2OhnOtZxe5qRON/O7nX7mlM4B5ozOEeaEziHmfM4x5nTOQeZszlFm
+o3OYOZdznDmVE8BscSKYEzkhzHMnhnnqBDFPnChl0YkDVp1wZt6JZ2adBGbOyWBmnBRm6uQw
+dU70gwBXnKHEGVr3pEr7nAOzUe11hmzm9vjVSL4zVDlDKsPhcEKcXIhzbme4rjOUjSePubVW
+stq+odyzg39QDXP7PJdPVyRJkiRJkiRJkiRJkiRJkiRJkvSLK7qBJf126pGTfi9TCfTADIn3
+oj9CJc6QN6A27r2dCVPhJN4O+KCUOLm3N9Y7LfUGx/FekO1kT7bRJlCOc7XjznRHSHImA+L0
+QWlOGcQJgTgcTr/z9u8MY+fNT0UmTNlkg2VO1SSN7w39jgG9MzTvxEtLTrS07MRSq06g9MSp
+mig4DnrqlM1LXTXPdt385InzrT9OT1s1nqr58FOcr3nNcp2f2eAetGjncb6+Cid2xY2ZNs8E
+O4tM+PMxlpiMB1fMPnguwZmNc23n5e90wczlnBM98uNiz/y4ykM/wp1VKJA5gROprEFFTjDj
+MTOBUAbzsivZScyLvnlMYx6hRKbqp323IuYOKnKSGdOhS5KkX1LRCU/VmVXRKVzVqWLRme+t
+6BS76rPJzIfUFHf8oTvps+QaU3f58oo/rfDbil7mvX+KkAJtdaK/6n65cxDa7hyDTugcgvY4
+R6BdTj+0j+mH9jq90NoiZ38x0gntd7qkFeTeO/xzqJWxDLN/jnZ+xhPye6hlp/35r/nhdEDL
+q+vPd3P/I44zw0h5sHrvjp1fW7O10X53xFlEPqCHDdXvrCqfA+rcRD/GM2W0oTqdjUgv1MHc
+QcnOn91OH7Mf6nX+FDtboV7mW0oezk7oCPMJFTh/Kp0t0EGmzNkKFTlTZq+6xxn9f+1/h9jp
+tO92Qr3MHmi301oXtGXFlTpzyg7oqLPr3OcAsxXa5cwxz6G//0bb6rQl5Yn08O9tcVbbgkQ4
+s1D739+2Q1ucOejDeZAynP/9L8OZfqr7331xzkh6ZL6gEOcB+t+sswr1OGNmy4A2O63cmTKh
+Tit2Zpj/RTJrzv8inbbOxDntak6rcto8E++Mj6Abd7cg5+lwOK90Wo3TMpwZqMj5+gdFzirT
+4cyfU6U733873GmzTK5z93fjnR/q/m+lOB/UduaAM+pizhOG8zucZwynj+G80nnOcPoYTh/z
+Rs4mhtPHvI2zkXkXZyvzJs5m5j2c7cxbODuYI84e5oCzizm/s4/pdnYyvc5e5uTObubczn6G
+08dwOm/D4HA4b+ss3CcV7yxM55znBE3pvMJ83ScVMkX1snP/30nOMKysty5m0/Z5lEKdRylv
+PJ/S3N8Od9r8fY0ZzpyU41SN5/JOH8MpcjqZ3+70Mr/c6WZ+t9PPnNI5wJzROcLscA4x53OO
+MadzDjJbnaPMyZzDzLmc48ypnABmixPBnMgJYZ47McwzJ0hZdsKAVSdaWXDimVkngZlzMpgZ
+J4WZOjnMy5wk5ja+8l7kZDGlTu/cWvuc4e4aaKpzd4W6yMljbg8PoCxwhipn4OxpeIWTCA1F
+A3p8wG4Jc0En8e20ZkAvcarWW9HrtMopOh7kHkfvTxAymU+pgJEkSZIkSZIkSZIkSZIkSZIk
+SZKuU9HtOPk3VD8w2fdMldzyPp6T4N2dVu+k3j73wBQ6SUyV87APlKy26+3XnAPQ2zs3TgSU
+6Nyu5lSdWV1uxXGOQ5wu5gofgXzUimDqzrGrZhssmz2xbDbIOqjKqYOq5h9NgBacqolb4601
+J1Jad+Kop07VhMTZEywPsdAiMwyh83iuOKED2rDaQqBNTJoT9PSndedhF0hzfqZPC4UWmIkV
+7Cwo0c4ik7beJtstx5kw4Q+ueJg4ONFpC09vTHBmexPnbE8WuZpzlPFokUwogjmRE8Kc5zND
+EHOWD1tFThyzCkUyK04o8/LLCNGM58zEORnMy34lkMW85rvuPOYVX2ylMndQjZOsfFAViCRJ
+iqnoBKHqRKTojKfqzKroRLHcyZZmPjKkoOPPjknjW2ZipVWn7GpfHPTMebOfPGxg6q7/l31v
+kvLN/Sudsi/Q3uUbzs3OQWi7cww6oXMI2uMcgXY5B6B9Tje0k+mGVpc5+4uRPmldmXW6oK3O
+0V8pbVpt45HFMt+DCPg91CrzZzKwDOfP35acvdAT5rOZf5zBzFIHnM/VMyZ+pO5flz4dxqMU
+5awq/9X9KtphfED3G6rH2aR8rb7dUI9yB2U7fzqdvczeAfUOp8r53r2TV9vPyyh3tf28jJKd
+v22HDjGfUIGzFTrKXNN5Ch1mNg7oONPndLhbnNFiv16z+9/wdjmt9UCbnelwwqGl4eyCNjrz
+zHZowwvofnljZivU9jlT5in08O9udOaYNWfy725yZpU16X//tddZbZkZS8ecWeh/P4U5M9D/
+HgtyJtD/xgU57QkT5rRNzhq00WmrzIYBnc1pq0yg04qdWeaps535glackOEUO/NMqNOu5rQq
+p7UFptRZYd7NaZwep72tMwu1UmeNCXE2DGe/M4W+/sFFnO9/kOv8/INgpy0wqc5Wpse5w+7/
+To4zrchZZzgvdp4w/2fvzpYU17EogKb8mnHrAZr//9VOZlvjmZHN3hHdVTdRetWRZRswSHC+
+wxkxcGQMHBkDR8bsyaEwcGQMHBmzG4fIaB0qsxOHzOzDoTO7cBiMxuEwCofFzO/wGLHDZGZ3
+uMzkDpuZ2+EzcGQMHDhwjulImKbTnGbZybGaOZriLAZzr3eYVJ+p3NB5VfH402AGcVq/+Tmp
+yRg7jZ3j4NyoGKcquThR9XzOETFwZAycIEfIfLsjZSZ1xMx3O3JmSkfBzOhoGIajYuZzdMx0
+jpKhOlpmMkfNzOXoGZJjwMzkWDAEx4SZxrFRho4V03LMtt91zJW648DUHA+m4rgwpePDfMxx
+YnLHizmeY7q45WSOH3NzliiHNcmR2Hm/7+7qLJHOEuU4Q2l77yXAOVo9vgXlC+xGOEuUs8CB
+4zvefmLK2Z7glqgLkCNzfaYYwiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAI
+giAIMm9ivmAU8dXtn+2364OYAzgv4vaFs907KdxJrl+hTNu4OT9wDBw/Juz0djjnJ8r5OZoT
+deF+Q1EOOg7OoZyfgzpH2UHhJ56wS2rYS6Cw59hR09nFTQMYNa1h2DSNYdNO7huqOnFQ0ESn
+DlbHMaX6jiEVBQ2dsJmPXWdyXhbjGSmbzFpydWx7jtJtXk5ejQXU2jnuzrKEOKvZ4EyHdoMp
+SrJ1lqW1lJ6x016xz9RpDQMXx3D9tLZz770Ypxo4MgiOyNEyYc5Xri1ysEU/9rW4yDSvTYyY
+SV492jFhTgeyVCZwbJmmY8zEvaEUxGChGSPIizn0pzg8mbgPPcTd4rxaEQiCIAiCbBJ0lYu6
+nAZdt6OeH0Q/3znIE7jyma+PmZqJcqLeq7CV+s4RPyEQxIS96xv3NnbY2/9h9zPC7gPt5UYd
+2VFC8zk6iOGooBkdDcRyFBDPkUNMRwqNNmv1iZEBYvaRkaFT+7mts17LWP0BPFqvFR1oyGTV
+ZB1o6JxOpxWZPWjnnE4rqPxsj5Vz2qR83IWpUQZOiTyy2U9S57GNJnJ3RJ8upVdiWM9QuULr
+/SRgTgTjFbHDMDbSpA6bYTricph7SOwsIofPvA8j33KCnD/o9NhHnt32DBUKcrQMFTqYo2dO
+pKGtZ6ZySkbAChzRyYHqlAwPYjspiSDCDmoyHGjsbDaYEhtav5igOjkzhLLWNKdUuk5K57w1
+yakxHeh8D9upM00onc+lNHZaSgs6b0OAOkJbOucxcQqoYJ6Q0smhIKfCGDlp6AwhmpNGjJWT
+opzUZ2ZxyMwLCnIazLnPzOikSKfFWDopyklRTkpdp81wnX45dvVIuw2ObPfM6jSgIbMvJ+3X
+qUHPhw7ivB4ydQqIxOid9wOuzuoBYyc1GHPnTW1/6ODU0mXgfNrpM3A+7AwYOJ91RgwcGQNH
+xuzKITBwZMyOHBIDR8aoHSKzF4fK7MQhM/tw6MwuHAazB4fDKBwWI3d4zPQOk5E6XGZyh83A
+kTFw4MAJdgTM553GN+Z8HLsZqkmOwYzbXafReWbOuwr3epaofuvsIFvH9Euag+O0Dtk7VUnC
+EM47UU4ROCJHxMCRMXCCHCHz7Y6UmdQRM3M6cmZKR8HM6GgYhqNi5nN0DNlRMrM5WmYyR83Q
+HD0zlWPAUBwLZiLHhBk7NszQMWIGjpXScuy233PslarjwVQcF6Z0fJjCcWI+5XgxH3LcmM84
+fgwcOE9n9Za7MxPmPKX9O8t2nVg/Zwl2FlcnvwMX4NykKMcLKm5e7txJH3KcmG3H+Z541pAb
+84auJ1RH5gX5Xk6fVgSCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAgS
+koCvOq8ZZyjmu9tvxvcreisnqJ6ofotzPJmwYX04J+q084IO4/xEOT9BTOCXdo/m/ODLzgiC
+RCfwChQghT+3CnuOHTYvW9h8dmHzAEbNa+glVZx9QzUnamJQF6oJGWNdx5AaOWEz68bNSLwv
+qLXt63pTllADeU9y5+jkjNfU4QXj4pTVWEA0xn6m+vU0eosd1GKsR0LH8ey4pb5Gm8MOajBO
+HVcyHks9mK3TNnCqgQPHwMHaIpM7h1vE5ONPSY2ZMGeeF0E2zCwvHq2YT69jYs50HUOmB5ky
+Ye+/BDEtx5ppQPYMVs6xgpyYsCVTPrImhyOzkXyd8A/AuDMPKMAJ+2AKHLETwRzv8zxhThBz
+pGEdc7qOuvwEXeeiLtxBT0TyJ3BeWMVxwVqONdVxAu90BzF20tDBDXWx43af+1NO2LvYYW/L
+h9022ct9ILKjhOiODprQUUEzOhqI5SggniOHmI4YGm/Z5BMjY8TmMyMSRgKJGBfn/VcNNHRK
+UQT1lFO1MJHTU/6yhrKHTZ215OScsqggOlPR9E4DySC102GEn/pcbfy5hQ5yh5QOBbk5Jz7E
+I8qdxHY4yFpiOmxG5vCZJ+RdDq8edbcRITHzPlp9y1mdFbwdxkhQjLarcwpw7qFBauYORTlD
+KMgxYCZ0VAwFMmFmc/LfYMs0p8IwoaGTbTIlETQ+lW63mBITurd6/gLVSYkF5c2pTvF7XeT8
+F4lTKF3o/AzXqTFt6LwOw6krTeecheq0mIaUMwSoIzShkrFwCqjCPCGVk0NuThozNk76gFNn
+hgOB5qQoJw2YB6RmXtBhnBTqNJn9OWncbWbOoBwbJ92fE/g7aeQ0GTgfdhIciTNiduYka6cB
+BTnPB52d14OGTg0iMBYOpRwD5/2QqVNAMc76EVsntRhr5y1tf9pjZE49B3O6DJxvcfoMnA87
+AwaOjIEjY/bljBk4MmZPDoWBI2P0Do2BI2P24lAZODJmHw6dUTkMZg8Oh1E4LEbu8Bixw2Rm
+d7jM5A6bgQMHTrTDZ77Iec+CbTFVOcExmXudUo97vyW7Kd5pvab/3imh35z3z3oiec96HlLt
+x+ZOXRIwhPNBlFPmYI6EgSNj4MiYr3eEzLc7UmZSR8x8tyNnWI6CmdHRMAxHxczn6Biyo2Rm
+c7QM0VEzczl6ZirHgKE4FsxEjgkzdmyYoWPENB2r7Xcda6TuOCg1x4UpHR+mcJyYTzlezE8Q
+8xnHj4ED53NO1OnA17FdXbnpbO7uODucScJkzrK9A+fnLCFOfv/N3XlK/s5yNGeJchY/p1ht
+28nJd5AX85OCnDXkeqFbn3o8mRvle81GEARBEARBEARBEARBEARBEARBEARBEARBEARBEARB
+EARBEARBEARBEARBEARBEARBvBIycUTEtFI/mymfopy4iebCZsoKm3AwagJFL6nixEEeVN2x
+57qOJTWCoqaIDZvyNm6qYO+pj00numsim6V/nJzNrHB+TsH4TFFeYTycGuMwtft63jnDSRwb
+zG3drE1RXo7xSGj1m8XyaRSn+LmPU/zYYwkGs3XNBk5ltTGHjmsFDhwDZ7ZFP47maBmsLuIK
+HcyxYMKceV7U2TBhzgiyYgaOGRP2tkgPsmQ6jinzeceWaULWzGff8LNnPvlOqQsT9lZ22D2A
+sFVtfoKYuLtBP3DgwLFwDnFC+MgJO+6m7UFvcQYxxlLPCXsJFPbK8YD3a6Ocw9wXNoWmcsLe
+jHW5L+wCUZ293M4gOx73Az/q6KAJHRXEcTTQlI4C4jlyiOlIJcqWLT5rQ1EsPtQjYSSQiBFA
+zc2vGIsPjTSrWNVTK8zKGfafiXPL6XSqlmjsnE45tH1cyzy3d3qk+Q/RlrNsmG0snQ6zlfRM
+U7F1OozsICr2ykDRO69f7yo36MSGOB1W3Uts50Qn1hDTYRrcghQMq6A9OIJ+EyispcgV5byP
+Vnfn9Og7z2473Zg75Oo8Q3EMGFJBe3MGkAUzn6NjCI4JQziZhjpaZtxxJSMrkOukV/gMw0mJ
+Bz2bMZ2UOFAqQnQSwznfI3GKf16nlPMrXKfshTZ03obh1JSmk84NaOjUmQaUKxTovrUWU4cq
+zpnk9EJj9E4hVRkLJ0U5acw8oX04aczYOEnrEJkwJ40YKycdzUl9Bk4PCnKK62jutBjmzZgO
+czQnwZnZGTCTOk0oHct5Prw7pw6NmWmdGvR6zNd5P+bqrB6zdHKIxqid9SO2Tmox1s7byn7o
+4FQT5PQYODIGzqedPgPnS5wBszdnxMCRMXBkzK4cAgNHxhg4JAaOjNmNQ2TgfMahMjtxyMw+
+HDqjchjMDhyOsgOHx4gdJgNHxsCBA0fOzODUJ/X2cqqTYfs4If3m/G3QZel0W9T+4TP9cR3l
+pEqXuTjll0C9HKPDVHTeETBw4hwJA0fGwJExX+8ImW93pMykjpjhOXJmSkfBzOhoGIajYuiO
+jpnOUTJUR8tM5qgZmqNnpnIMmJkcC2Yix4QZOzbMyDFSmo7Z9nuOOVJ3PJiK48KUjg9TOE5M
+7ngxP0HMTxBzaMeRObRztHEQdZiGnXbCnKjTtadjvCp1y9nerfJyFu3sqEyHMyudyMnv9MGZ
+yikW23Zy8oK8mHVBvleGl3KF/Jh1Ra7MjXK+aCMIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAI
+giAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIIRHzV/1s5kgKYlylo09hFTZTo5NUc1ywJmSs9R07
+aeREzd1qJhGcg8xJbDuRWgvZrsjj5eRrGbk4tVWmHByjxaxGTn3RLPu53YMdi3WzaI5tQVTG
+yynqtF4bocU4rMFQZaLWeoDzEWe6RTLgCKGDOVomzJlrGZMdOVgvZXJnphePQY4JM83KLGGO
+EfPxpWaCHTMmzOlBhkrPMWU+/w5mkGPNtKD9OmFvmh9/XSg4kztHG9c+UtUJO8OZSy3GmOox
+cc/gwu7UBTFha0biduDsztHeetnTe1Y0J+zNy6O96Rv3rvxObs/QHR00oaOCZnQ0EMuRQzxG
+DnEdKcR2hBDfkUmU7Vp8koPIqD/UMy7C5rMcNKb8+IONs9q40Yc5Os7779sK7ZxHOacWLYDa
+9aTTqYDkPVd30p3JoW0bJfPY3KkaKdTosqazkTTOc3e3GBnUYtqKjUNgRAdRxen22ZURrNO7
+Bl5/7Sl3iF1QxRkoV2i9l2TdNkbeETkcgO8oFFbHqRxGQcH1aBgKpChndbT6dtv7Mujbbcv7
+aHV1HmeFE8HRjerTyxlBFsxEjglzGg/tWEfJjB0bZnwyDXXUzNAxYgSOTGY7r+sJefMSJ61C
+rOHWMvGclMhQOt+y/Q2ikxIZOq9Cgdbby5m2c87CcQqlDeXMGxo6NaXllMwLGjl1pu7UGKLT
+YOqQ3OmFxuidHKozT0jhJI7ThAhOinISgTFxktqhMRSnPxCIThozNk6KdTqMkZOO5iSS02CY
+TpKWw3TE3ca6GxPlpF63wZE56ZBOi9mdk47lPBsYOU0oyBkyszp16PXo/pwa9H7Q1aEwBs7q
+MUsnh9YPmTqpyRg7qcVYO0+u+ImPw2HgyBg4H3e6DBwZA0fGwPmsM2J25gwZODJmVw6B2ZND
+YeDIGDgyBo6MgSNjduKQGZ1DZ3bhMBiNw2EUDouZ3+ExcIIdJgMHjsbhMgTHZkLnrtCaP3z3
+jmO/LZty/L5Fu+029deCe/3W3kHGTuUroE5OvgiDm1M9TvmM7LxzMEfAwIlzJAwcGQNHxkzr
+CJlvd6TMpI6Y4TlyZkpHwXAcDTOho2Lojo4hO0qG6miZyRw1M5ejZ6ZyDJiZHAuG4Jgw8zg2
+zMAxQpqO3fY7jj1SdVyY0vFhCseJyR0v5ieI+QlifoIYOHAKJ2pchzlRp50wJ+p0fQTHePHr
+lqOaG3U+53GP76W5OkuUsxzQWVwHduZ4MVnHuTHrgnydd0Wuyp1yLgVBEARBEARBEARBEARB
+EARBEARBEARBEARBEARBEARBEARBEARBEARBEARBEARBEARBiImYCCNgvqctEzj1V9TUeZ5T
+JBUJg1yoquMA9h07aeQEzXVqB42duDl8DzFZ8GaOMz/HfCq1lqJdLGns2CyaNXTqq2Z5OeZQ
+y8ktR8e0oCZj3HEtp6jTxykYj0ULqkzU4ghw4Bg4063GAeczzmzLpWBZFhkERwbBkUFwZBAc
+GQTnG5xJFjeycw5X0DQdB0cGwYFj6QwYODJmZ86Q2dcz+ZmcHb3k/k5nN+8lEZndvHdJdsLe
+lNdBEzoqaEZHA03pKKA5HTnEdMQQ15FCbEcojTZqdb97oDzvq6s/BDNQ7tsvPy9g6Lw3bvFR
+jj7TqEYAjZm6w4W6zL2cxqcsDJ3yZ2KoV83pVPzQwzmdNpBucLe77XTKoGI36Z30ZMrIoAaT
+UovZQFEOGeIrpk6PkTj59hcCsx3dIuexiS5zhdK7KKbzOmMOlSu07j6RMy7mHYaT73s68oZY
+Dmv7ckfEMDouyLHoNgqkYVYHq7fzrInqSJgrdPvD3zk9nRGkG23PkB0dQygoyLFhQp0uZMMM
+HSMmyhmee2yYZeQY9dpwvXgjZ3hVLR2W/G7LdZ5nOwq1asncP2mVgXG+JW0jcbrQeRW2k/3j
+iMxaIjkpD1GhQO/tFUoTKpk3NHJqSsOpMVSnzjCcM8lpMFWozpCcXoiM2skhNydFOYnCPCGN
+k/QOiUkUxsJJUU6KctKQgdOBgpweY+WkozmJsnv25KQU5BB2T5TTYPbnpB06PSjIebYIclqM
+lTMqh3uX/sPO6/G9OXVozJg470ftnAq0enCHTgGtH3N0No9ZOknCSJwVlf3Y3GnkYE6HgfN5
+p8fA+bjTZeDIGDgyZm/OiIEjY+DImF05BAaOjIEjY+DIGDgyZi8OldmJQ2Z0Dp3ZhcNg9uBw
+mB04LAZOtMNj4AQ7TGYOpzFNuaejnUue5qi7Tdpvls6yjWM97YKMHbsJ6wdOsQiDkKEcpybz
+1ROcSg7m8JmpHQEDR8bAkTFwZMzXO0JmVkfKTOqIGZ4jZ6Z0FAzH0TAMR8XQHR0znaNkqI6W
+mcxRM3M5emYqx4ChOBbMRI4JM3ZsmJFjpPQdM6TlWAJtx0GpOC5K6TgxPzFK5vgxP0HMJxxP
+Bo7eOdp4CztOo047jtCHnKDLwhEc6zW2m04I5LA4ed8Zzj+ldB63Ehdv5w4tMc7i7vxkjheT
+OW7Mz8/acWTeFTkzN8q7FgRBEARBEARBEARBEARBEARBEARBEARBEARBEARBEARBEARBEARB
+EARBEARBEARBEASZKs7TMG0UdylmaqmwyZhyxkuqOD5gD7K0Bo4ZNHLC5lTdG0RwDjEp8Xbu
+MTdHvVgSCTJYxGjs2CzONXSWOmRfT1pcoBpTK8nasVsHjOYUdfo45W4zdlKD8Vi1oMpErY4A
+Bw4cBQTnI85s66VgXRYZdDTncAXtx/n4q0drZ6a1c+AIITgyBwPhG5yJ3pKFAwcOHFNnzOzK
+ITBhzo5emQQ5NOZwzl7esiI7O3mPlO7ooAkdFTSjo4GmdBQQz5FDkzpiiOtIIbYjlASOCBpu
+1Oh+91Cp3vC2dl431nPP1Fk2jO4zFiTH4DMWwnIMnT7DhQhMKyZOjdEMuhZz2+jp1KWN6jmd
+Ko6055rMqZK8QgMm1ZxTXqK629rMBlI7HUbiSBgJpGWIjogRHEMC5e68i+I7j3/niLkfRS+I
+xawWqx0zz9AhQadpnRNHkDpsYu0QoCBHslNKhu6ImNXB6umsr7ZER1TO42A9ERzdKDg9Lrju
+zunlDCATJswZQkbMZI4J04OMGJqjZ6Kc0SnOiHmdTffuPH55GXVc6TDk9aHHdZ5n1SGVztc8
+2yaek1bpKudV1r9Ec1IiQudtmE6iOuc8HCcVoSoEqBgwY6fGkJ2K0oKqzpnm1JmqU2doToOp
+QQ2G5PRCdZ6Q1ElERu2kKCcZOBRmDbWZPTkpykljxsZJh3R6jJGT4MicdDQn9Rk7J8kZOJ92
+nm0O5jQYM2dQDvMu/cedV4tjOO8WNk4LGjI2zrgc9qdCPumsHjZzKtD6UUeHxAg+tdNhTJ3U
+Zmyd1GSMnadW/szDqaTNwJnA6TBwvsfpMXBkzP6cPgNHxsCRMTtzhgwcGQNHxsCRMXBkDBwZ
+sxuHyOzFoTJKh8zAkTFwZMweHA4DR8bAkTGTOEv725q2ziohjrYcej2OzrK0+82tHlen2XFc
+hnD82HzdfexUJ3j3cCwYODIGjoyBI2PgyJh5HRnz9Y6QmdWRMkxHzMzpyBmWo2BmdDQMw1Ex
+dEfHkB0lM5ujZYiOmpnL0TNf6RgwFMeCmcgxYcaODTNyjJSuY2Y0HVOh5TggFcdHyR0vJXP8
+mA3kyfwEMfGOL3Nc5xjj4AOHqSv0idObI/QhJ+jyA4ftLDHO4u68pmcOcJYQZ31/1Mv52Tpu
+zNbxY35+Vo4n867I+wnClQowEARBEARBEARBEARBEARBEARBEARBEARBEARBEARBEARBEARB
+EARBEARBEARBEARBEOT74j+z1FpxlvLJi7yswnGiao6H2HfspJETNTmoGTR2wiaJjZvE13Xy
+4/UaNnqnAeWr/jg5+kWMCI7J4k9jZ/GBGr0W4BgtmzVylu10ba5OdcExe6e6rJmPUzIes/zX
+mLBVC+B8wplvWQk4cAyc6dYxgSOE4HzGmWxFm6MtaXOMl6n7dOZ6HwHOx5zDFQRnbmemZbvg
+zO1YMHD8nD2NNwqzI4fE7MehMWHOXl6iUpmdOGRmJ+8tT+iooBkdDcRyFNCcjhya1BFDXEcK
+sR2hJHBEEGnDBvfVCYjJ/W4RI4AoTIDzYrSfgiEwzyXxtmVZOlvGzVk2vaYb3CTm9l/F46ZO
+53EjZ0mFksE2zumaskAh1Ge20Qw6jnOVtiU6Mae8L10dCSRh1pArY+YMGHbHyZjN4JY7o2IE
+x6qEuUGrvuMyj3/kmPmDbv/Pdx7XGCrzCL0gSaeVEMO5/hKL4BUkqoLvyHpL7oiQ1UHk7hBH
+gq7XlvdR5FjO82D1d54ZQjbMNI4RcxqNuFhHzYwcK+Y0OFStmChncOoxYl4n0yinBVl1m8Sh
+u+/Bugx2UOmQK0zpvDrGufU8249eKZxfuTVOPCet0mPOm6x/i+SkRIPOeXhOIjoFs4LGTipC
+ZxhOyTSgGvOGBk5NqTt1hujUmSqkcVpMBWowL6jn9BLlJCIz6LixkywcArOB2oyBk6ZyugOB
+5iQKY+GkiZxnU5WTyOXsxEnf6lQZzl3GARPtaPvtD4qpJyUKA2dup87YOf1y4AwYE6cDBTnv
+JkFOg+F++kRajo2zarAzpwoRGAtn/bCZU4GCnM2jdk4ObR80dFJbGb6rLJXyB4ydZuAYM3Am
+cDoMnM87PQaOjNmf02fgyJi9OSMGzkedIbMvZ8zAkTFwPudQGDgyZj8OjdmNQ2T24lCZnThk
+Bs4nHDoDR8bsweEwcGTM0GlOuG3rLO+EONpy6PW4Og+iJjk4tZKYDHG8qb+0TTh+THYP5TgN
+mSWgkYM5bAaOjJnaETBwZAwcGTOvI2O+3hEyXEfKfLkjZniOnGE5CobjaBiGo2Lojo6ZzlEy
+VEfLTOaombkcPTOVY8DM5FgwBMeEGTs2zNAxYgaQmdJxDI2GYyzUHRckd7yQreOorB1X5ieI
+eUHezFEdbyhqHISP66jD1Bf6wOnN0wm6KBzdibmaBjjPe1bOzhLjvO/0uTrvO4pezE92B9vN
++Umb27ABjvsJ++14Mq9d5P9EBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQ
+BEEQBEEQBEEQBEEQBEEQp/jPLLVmYmeXcrNKx4fsOlFzXBpKQydsstO4SWLDJtfdE9TasnIx
+HqKjXsSI5lSW/bF3bFZ/ohRUhVwKSvYFVZlUqcjYeS+b5VtPcxkw62nxm+u0GTvp1m8Bzp9U
++2HYsgVw4MD5lDPf+iJwhFCUs5OOi3Lm20FKZ7alc3bjfG1BcD7kfPz9is84+9lBkzm7OfPM
+5hyuoIM5WuZLHTUDx5OBI2P2clkgM/tw6MzhHA3EYeAIHQU0pyOHmI4YmtWRQmxHCPEdmTSZ
+o/7kQ3/ry+MP/f3urtJiBFCXWZ5/ejqpw/ChDnPb+cu6LAXUYTbVFGXZOPkYqHxgwMIpdon6
+QxYNZVn1XStap/GRCh1Ud25/nv7y+OORvENVzprJohh0HEbh1Lqtydwk2S6qOKnrPPaTldNg
+XuMhxmFDMsXKGTJcR8wsPEjGbA8iN+YGrfpO5hCYx1HEd+7XZzrzCBl6MjfD3+H2GhcSbn16
+R6n4OpuDleQIy/ljXlV5dtv6kufqPEJ1lEyo04OMuo3qaJnTaGQbMaOCzJgoZ3BKsC2n6Vgx
+r3Ocr/M+me67ntdvL/z9Q3afJaT1f5EdYoXpfM+zObPftv/Gds7rpHVIzvoXqEoGUZzNP6wN
+5cwGIjiJ5pTMGho6qQidWUEjp2QakMqpKXWnzhCdOlODGswb6jktpgJpnF6ozBzOkMmltvOE
+TJwOo3ZSlJNIjIGTopx0NCeNmX05idptO3JI3bYXJ0U5KcpJUzivVkFOlYEj2z1wZMycTht6
+N3F1Vk125TSgdYsgp8GYOIRy2J92GjC7c0po+7CZk0M0RuvkDxo6a6l4yNTpJMhpMnC+yWkz
+cCZwOgwcGQNHxuzP6TNwZAwcGbMzZ8jA+aQzZuB80CEwcGTMjhwSsx+HxuzGITJwZAwcGQNH
+xsCRMXtwOMw0zvJOiKMsh1GPv1Offd3SWTZRMOPx1uo4a6c1Eswdm+kICE41QQ6XgSNj4MiY
+qR0BA0fGwJEx8zoyZlpHyHAdKTOpI2bmdOQMy1EwHEfDMBwVQ3d0DNlRMrM5WmYyR83M5eiZ
+qRwDhuJYMBQoyLFhho4RM3CslL5jp7QdS6PqWAM1yMvYOJ7IynFmnpA78xPEHNOJGgbuTvTh
+4w0FOeFnN2coyAm69sDROc8bVs7O686Yr7McyHkuG+7L/Pxs7sI6Oj8rx5O57qIH5MvcoZAn
+IgiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCeCVk
+tqygeZ9SO1GOJdVn7KShYyQRnKhJVeMmo90TRHP8Zj9WLvpDcwxW46FAFqv+jJ3W8k9e9SiX
+SyLVU44DF+elGULk/ePlFA9YT4vfYhym368yUdP8hzmHKwiOzIlaJwPOgZ0ZBzYcGRTloOM+
+4hyuoPk67mjO4Qo6mrOTI2g+B8+ypc7hCoID54AOyoGjdBjMHhwOswOHxcCRMWGOGJrVkUJs
+RwjN68gggSOCJnHMbgoOGaO7giSm4Gyd571UixvrI6bhsCEhY+dUmA1m5LxvdL+UbVU2zrIu
+5/0TeUEjZvujTSO9U/0Ugm5s05jTI3JoyJw2EUNt5lSLeGzzmJN0cAsYUUWNbmswRT1KJ9/7
+G2gzGuTO/TTWdB7DgQnVmDRmrJwRsz6MPBkbZ8ycFr1DUTaDW1gOzVn1nVs5+UEkcUjMI2To
+0ex+dfZzns3uTwPYDHkPbfrrSjAZakGinaJw1Iyrsz5WPcu5Xw0JkLbbbgfrKcC5/0F1pMwz
+oU4H0nYb09Eyw46zdZqQGUNyDBiKY8H0HeNea0JWzPtk6u30T6Va5/nLvs5m73IdqpvOf1n9
+PtMhVnh+596eNw5ew7NPnbdJq5Cc9S/QmQ1EcVIiQQWzhtpOg2k6FWYIleNyCFUZipPqSgOq
+Myuo61QZe6fO1KAWQ3E6MXJGTAE1Ga2TqM4LEjqJyKidFOWkcKfHGDgpykmxTpcxcRIcmZPI
+w0Dv0MrZiZOO5qQ0hdNlWI6inK92utC7VZBTZXbnvBsdwlk1MnDa0IgxcoblTOo0oHULR2fT
+wsapQRRmR872cSungLKHzZzUZQyd1FHa7/oLnJuVaoq90wocWwbONzltBo6M2aPTY+DIGDgy
+Bo6MgSNj4MgYOJ90xgwcGQNHxuzIITH7cWgMHBkDR8bA+YhDZvbh0Bk4MmbsvCZEL7/G7+Oo
+mKkcizUFqNUovxzOGQeqiQ+GTnPAWTv1774zGdJxumQTHng5tTAZODJmcofNwJExUzsCBo6M
+mdgRMfM6MmZaR8hwHSkzqSNmeI6cYTkKhuNoGIajYuZzdAzZUTJUR8tM5qiZuRw9Q4OCHAtm
+IseEGTs2zBCyYgaOGdN17JSOY4k0HWNkAzlsu+I4K0/HnblBAQoye+KGW9zhE3U2cIeCHOdz
+9EcdR8j94nZo53m/ytl53RgLcXwH9rocT+dv+xHMz3rhcE/n530X1pV57aGAKyqevyEIgiAI
+giAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiDI3hMzIVNqJIgx
+trqMoTRywibtjJu7dVcQyQmbxddzVmLNWjxkR7tIDg3SLy5EcixWMSI4NssL0eqx30MNJlXW
+s/JylAsmERyD5bnIUPlzh3nxq0zU/PuHc6LWR4AjdKLWyYAT70w54OAcuCB03OTOVxcU5aDj
+PlEQHH9nD896pnSiVr2Dc9yCeM7Rlo2EM7lzsFVXj+ZImSiHyczebZOWc7QlmMMcGcRnDueI
+oC90TG4KUpgIp363ztxp3BW0dlo3H/nQmKneuPVxDO7gCxl7JzX2kp1T7pw1ZuWUnZX9t6XT
++4GNU+6T4icWzrrXTs9oxhyDuUYMjZhTFkPnsQheLqgKahbTYE7bwaBwxoxkcDOZwqFCrXpa
+zlXa7CUpkwZMPhrEzvVsOWLWo07k3Dt/yHALqnUaiWEWVOkyNkNwqnuHwjCPVQWzrGpyc7KD
+SOLQmNPtACMXtN3/HOceIvQ0lvdLDxYjcFL9okZ1+tBmr3ANRkGifcKvhzvG8lCPVTWzgjy7
+bVkfRJ675341pDpi5pGRoy4n2BlBVszAMSuH5ugZkmPA9I8gu3IojiHTcwyU9znO3ekOBDun
+P+B0zva3vZznHknb/yY7NPf8zGsDLIc40M/r3J/AdAdcvtVX6z51zpJWITjr5h0oV4hOnWlD
+JbOB2E4DqjFraOTkirmT6koDqjMrqOtUmZrTYvrOc3N1pgZpnE7IzBsSOTnk5iQqo3XS0ZxE
+Y/ROinJSlJNinS5j4iQ4MieRGTg5FOOkKCdN4bybaR1iOVFOjdmf826mdrrQwZxVqyCnylg5
+o3KYn976tLNucwBnzHA/XTdkHJ1tCxunBgU5WQMjp4BojOBTll3G0EkdxdR5SbWHTJ12Wgwc
+OA5Ok4Ezg9Nm4MiYPTo9Bo6MgSNj4MgYODIGjoyB8w3OmIEjYywcCgNHxsCRMXBkDJzPOFQG
+jozZh0NnCM5iMlM5wXklyNEwNKcxybuhs2wjZsb1RDlGKyRwHAVDOk7rw83cWW6Hqo6Rn3eC
+HCYDR8ZM7rAZODJmakfAzOxImIkdETOvI2OmdYQM15EykzpihufIGZajYDiOhmE4Kobu6Jjp
+HCVDdbTMZI6aIUJBjgEzk2PBECAbZugYMWHOADJjuo6d0nMslSZkjDydzX/aG48tO20YQb4g
+MceP01mmyvhLjufNuuML+V4JvsNxhB7AEuM87yI5O8/7VX7MDVoO6XifeJaQct4F+V8ZbseP
+u4IgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgiG/C
+Z2TyoyoTAXqgXcZOGjFhc3YaSRTnaJPEWkA0J2y2YLfZj3Vr5FAh9WI8NEe/6A/JWeoL8tg7
+9fWFPJxUGQnW0GP77k573Swnp3jA2HnOb+bvvOYHNITqTj1Hc6LWRzhcxx3N2cNAgHMg53AF
+RTmHK0jhHK4glnO4gnbgHK6gKZ2o1cHgCJ2jrUYX5kStFng4Z/ZVI9FxcztsBg6c+R0+czTn
+YOWIHAEDR8bs39Hf3aIp+Z0aF8fkJloXeDIGd9F6ZbQZQ6e4w6m7Ez0o53VTUHuDuO1sek19
+Z73PrHtPBw2ZbfdZO0OGC/Wdv/9dLpfrhxJesoOzXLbJyrJyLn3GysmrKRwWRGdSeYPdwFmu
+/Xb722kdqdNkTqWhgZpMM6ZOB5KN7aqxDBgT57ahdrcJxzaXuUknNlTttaUyzNqDQeqkQTk5
+JHbG1bALKkshMjpnIe2b3BlDlSFAc5jHkLgc5oWosntovXa6jUmxQx0EV+jEgBTOieFsOkzA
+UA/Wt/F0eAy1oGcxsk5jO/zNl04PkpdRKCRHylDPCQbOuyjP3XO/To0g/SiIck6hzonmqJlB
+QWbl0Bw9Q3IMmL5jVw7FsWCCnMHrfDPm76lLjNPvOK3z+l1XZ7t3nZx0Pp83ENchued3nhtg
+ObQD97zJvT1rXL+Ogq50zpNWITjr5h2oYDZQ06kzbajCrKGhk/IwmEFBlWE5gurMoKD35iqK
+h1NlalCLoTkNhuO8oabTCZ3ROTnk5iQqo3VSlJPinR6jd1KUk6KcFOt0GRMnwZE5ic7AyaDJ
+nArD+/SJvByWo+g2OGPmaE6NMRvXg3LgDJkdOU1oyNg4mzZ7curQtombkzUxcWoQhTFwSOXw
+PzU6YLyc4nErJ3WV5t0SvvOWao9ZOr3AMWXgfJXTZODIGDgyBo6MgSNj4MgYODIGjoyB81Fn
+yMD5pDNmduUQGDgyBo6MgSNj4HzIITJwZMxOHDIzk9Oc4N3L0XyBn8NoJvUgIrX5FTgMtR71
+BAtjp7VAgqMjZzTj2snJf8xiaOeD6nICDo6emd5hMnBkzOQOm4EjY6Z2BMzMjoQROCJmXkfG
+TOsIGa4jZSZ1xAzPkTMsR8FwHA3DcFQM3dEx0zlKhgqpmbkcPRPmUCALhuCYMAQoyDFiRo4V
+M4DsmC5kybQhW6WFuSg55okgCDJvYo7+oNNM0Pks6sQZcxkIc4Iua5uL6FGc580dZ+d1FynC
+WfzHwfO+WJDjylyhiHJ+HhXhaSGCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiC
+IAiCIAiCIAiCHCRRk8oczUEQBEGQoyR0piRPqzEToLXaZeykEWMkEZgwJ2xS1aNNRhs2ia8e
+ojpesx+XK7F4QLWFZRyc9UJG14WGLKB+PWvHflrv9zJGy3tONfuCHlt+7p/3TnJxtOsLkRyL
+BYaGTu3o8XFuVOWHDk41UQ4KghPrRC1gAUfozL9gyqQdN7/z5WeEHeyhOZ3DFRTl4Fw6uTP/
+DprUiVq9DY7QOcRqgevX4L6OGqJ1VpSzTpQTtarn4Zyjre4KB47UkTBwZEyUs+NyavcAdltP
+9Y6GxBkxy+ZPOSRkTJ3VvTpPZ3nfq9Pf3hoytXuCAojBbDUjZ8nHgPLWOofRFNRmntvPYAfn
+8k5l0Bk4BXN1LpekgDq9dimyHXNa59FFJZP3nt5JVSe/86126kwxGJTOPRXnT9qOBQOm5pxO
+KRtzWud0OlWUa8yd02vT28igjtPI9gykczrMSTbm2I5sbPO77Spt9pFTt12hzWCQOwPmFh4k
+KsfKoTA8SMGoHSLDeuqTEQvZYV6HMub6q9Ry/tqeyFDO0J3rwbraR7xuu/4beaFB8lEgcZbV
+i0MmQ9xDz+56OVyGVtC6u0QI1xEJW6YHqRni9U7r3I+DoaPvttuxeqI6YibMuWfUcVbOqCAr
+ZuCYlTOXo2f6jh3TH3B2TJSTxo6Bsnre4+10B4JZty39Aad0Nr/d6ziVkx0UTs75ltXvcx2S
+e17lsQWWQztBnLe5t2c46R0Gc++97oG63eSmOYPZQjymDVWYDTRyUh4Gw3AKpg7VmTXUclJD
+8XCqTA1qMTSnwVSgpvOGmk4ndEbn5JCbk6iM1klRTopyEokxcNLRnERgduWk73PebTVOopcD
+J4OO5STqcNM61HKinAqzP2fVDg7dWbfTOj0oyBkxO3M2rfbjtKAxsytn28bCqUJZk105FShv
+4eTQGP6HbQeMmZO6iqHzlqoPGjq9NBg43+W0GDhf5TQZODIGjoyBI2PgyBg4MgaOjIEjY+B8
+hTNk4MiYXTkEBs7nHAoDR8bA+ZRDY+DImL04VIbvCOc+IG25OcW7bT1th8ww65HPUcJj5BMs
+zON0xkGQw2B4jrwclqNgyMdP5cfmTj0sZn6Hx0zvMBk4MmZyh83M7fCZqR0BM7MjYQSOiJnX
+kTHTOkKG60iZSR0xw3PkDMtRMBxHwzAcFUN3dAwdCnK0DNFRM2EOCTJgwhwCZMKMHRtmCFkx
+YU4fsmN6kqnSpuyZGuWj5JSj8qS8CQRBvjwhJ7On4w/FnZ1DoHDHF4q6fl4Bk5XPx87z9k6E
+swSMg8dNMWfnCXkzdwfPpBAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAE
+QRBk1wn6OjS+pqxiDvQ15SM5RxtvcJSOMxN2Ho113JW7E8AgCIIcJaHXaFcqdRPEmElDZleT
+dlKYPU2qSnOiJqMNc8ImC9ZC7Q3nC6S4QOsVXxaTWbsGzKoq33pWvRdUj31B9037F7RyXv/l
+5awKeQ9vYydl/ZW8nPIo9XJec+r5Q590oibgP5wTtUACOg6OFoITAkU583dclHO4gqKcwxU0
+qRO1+BQKgqODvt7xXF3P4H0lorOCohzHVRYXfUFkRwmRHIOCaI5+JBAd9dCmOpvAmdsRQHDg
+iJk9OyZvM4+VKmPu1N6bFzAjp8FYl9NijJ0mY+s8n3tUbqBYOh2GDREZrTNg2uWYOQPG1Hn+
+5fKX4vRj46zvON6YoiwTZ3lU8UrZexbOEugUjLlTVnO5/SDJoSaTLmVsnSaT7ySds7Sd/Ma3
+xnncRW+WI3ut1WKa3SbcQy2m7hRjQemk04nmkKEak/6YmnO6/9jKSTfn9Nxynovk9X2l2x5M
+O5KhXTpp5IjGdu7cwyhH4/S77RYmJGXCHCYkZjbOEJKXwytIwWgdosI7hsycASTvtT9o03l0
+hnDG2UKnNcRxFg7zCKmglEG+zvJ+f4DNrEb3kFn4+0biCAGBY6F0IH05y/UginKGh5C+27bn
+BD/nFOWcCI4V84KinAYU7OiZvmPHzORYMP0zj5mzej7SdEyYGOd6kgtxTv2BoHO2e9fLee0Q
+Vyed73lvgOmQ3PM6j99gOVlfUJgn1HHybaZ3GMyt87rngzbTgwrmvpfITkokqMJsoJGT8jAY
+ulMoDajOrKHuOKgxDk6VqUEtZgV1nAZTgQhOBWpuv+W0GZ2TQ25OojJaJ0U5KcpJJMbASUdz
+EoHZlZPmcXrMfE5SddsXO4m8e3bipCiHunsO4awbBjkVZnfOut1enA60abZ/Z8jsy9m20jst
+KMjJGgU5VYb70WFpOQZO3mRXTgkVLWycNFBGd0tkUOVhMyf1FEunn4M5DQbOdzktBs4UTpOB
+I2PgyBg4MgbOx50uA0fG7M4ZMHA+64wYOF/hDBk4MgaOjIHzOYfCwPmYQ2LgyJjdOESG7Uin
+WCBu+/Vt7nzOCB9HPkfJRM4D8HYWi3L24dAZpiMuh+XkjzAY8nirPWDtNH7OYTTn0SCHxczv
+8JjpHSYDR8ZM7rCZuR0+M7UjYCSOhJnYETF8R8ZM6wgZriNlJnXEDM+RMyxHwXAcDcOAdAzZ
+UTKzOVqGCOkZkmPAkCATZwzZMGHOCLJiBpAd05VMmbZkzTQkB6YCuSgF5aesJV8FQRAkIkEn
+s6CzZtTpOcgJuqod0Lnf3HFmfp63kr2dn8dc1+7OTwpREARBEARBEARBEARBEARBEARBEARB
+EARBEARBEARBEARBEARBEARBEJ8Ef/vRVwqaPOADcyE4QlGTO0TNIhHkFAycqZyjjbe4WVg+
+5HgxYc5PlBM2S04QE+YccHaEECZsMo6oyUVCnQAmzPnBhFlfmeL49xhvxWXN5TSaugliwuae
+tIEITNjkoFFznRpAX+qETa7rP1nwc2URJ+e9QspiMs1Vn7kSrgVt1rCxgBiOwzTYi7lThV4D
+4LFuUoSTkg3U7Lb06jGTkdDbP+//1BdUdTYbT++VgDycaqKgozlRE/3HQUdzjrayxOGcqBVG
+pncOV9DRnMMVNKuDguConMMVxHaiVjs7giNbeFngbCA3J1utNsoRQRTHoiCyo4SmcnLIzdHv
+IaKTtAXN5mSBAwfO8Rwh4+GoF7KnONkzA6lDYCKcJmPrtBmmMy7n+RdPZ3V3xtN5br7ae7bO
+5k8np9drhs6q1y6XixJqKpd02/xf7n/qnHY1l4fyTNl7NuVkzKXcSTZOniBnuY0GMUSv51IO
+hr04fzuizmQ7Sencd0WLkb3WYjHFmFMwS4e5iId2nWk64pFQZ9KJCgmdx0cPTidjqMncodPp
+9df7f1V2ktT5e+752PqpkksxtsX1pNr2V5KBc79Q953TSXAM5c41I+Yv3JFQYygOF5IyWyjK
+GUJyhgd90KEyrLGtYugnH0U5p/t5gwYpmCt0/X+u8+gFhnMPqaC0gSQMraCX4es8kefIESik
+jlv3l5QhO+JCyI6euR1DMQ5hIBj02u1YHUEWzmnsmIwChqNl3hAcQ8eO6UOGTJTTHdgOjK+z
+etrTdAyY6zkuxDkRxoFm2xWnBqmcbLB6Oa/tujrnZ14b6DiVYU2Tz+s82nOcvC8ozLMkhvM+
+qLvQOU9KaezUlC5UMDcoCZ0mVGG20MBJeRjMBuo6hdKAGgzBSQ2lDqmcBlNxWswa4jsF1GYI
+Ti9HcxKV0TopyklRTiIxBk46mpMIzK6cxOk2OFuIunt24SRNt83opKM5VAYO3dk0PJhTYayc
+UTm8j1h+3Nk2g0N0xoyJk7XSOw0oyMkb7cipQSRG7xRNTJwCKlu4OJUWNk4aMVbOSqo+WmfE
+H71vBo4lA+e7nBYDZwqnycCRMXAmcDoMHBkDR8bAkTFwPuwMGDifdUYMnI86QwaOjIHzBQ6B
+gfM5h8LAkTH7cWgM1xFPfUDe+muOd9mMEVwnn9Vjj87SdqgMxekwls5iUc6kTv6YkyNnyOOg
++oi9o2VU59Egh8PswGEx8zs8ZnqHycCRMZM7bEbm8JmpHQEzsyNhBI6I4TsyZlpHyHAdKTOp
+I2Z4jpxhOQqGA6kYuqNjyI6SIUNBjpqhQQYMxbFgKJCNM4SMmBFkxgwgQ6cnmTJtyZppQPZM
+VXJhCshJ2UqOyItyNxAEQQ6VmPNmzEUgzAm6qP0EXj0PtX/wfABBEARBEARBEARBEARBEARB
+EARBEARBEARBEARBEARBEARBEARBkH5ivr0V81Xu7bfGgxg/KOi79kHf6S8ZF6fCuEBBTpWx
+d+pM2JQYh3OsITj7dIyZuDllopyjna/DrnOfm4sn7PmOl/MTxEQ9HQ17ev0Bx5V5Q87MUR1v
+JnoSkyDG8/q2/a99Pp9qKqZSV7GDRowRNGbC5uwMc442p6oems2JmlzXfbLg15IfXgW9Vhd6
+Sj5OZXEZf8dgF9HL8Shoq7gVdC/B30mvkXYnLKBBv63qc3DSWrEpqO7cNr5mnTquZXo7BhDN
+eSbK2QH05U7UyhLTO4cr6Nudoy0Bgx00uxO1thE6Do4GinIOVxBlw9kqpVGOCCI66oKojhaa
+ySnXq3V0lAWRHIOC6I6uIJqjH9pERw1xnDXk5WhPcmQnCxw4u3Xqi5dbO4010q2d1lrsIofA
+6Fd+Hzjdqqyc1xv/Jo6YMXKGjI1TMCVnyKz/9HCyKi713lM7OXOp7yStc9vqZZXGWFA6961e
+ihg7LcbauafiqJ5hKxiOQy+neB7PgujlXKF8H2mdGlMbC0qnzZg6HeayveipnB4jfWnCZIqx
+7ViOaAdx67kIR0LJXA8SBiRnluXEgGTObTid/vLa5vrv8oJqzM1ppDYYpE6HuUPZMaTpth50
+4h9DtWGQ+s417KtQTlwzZk6nxISKWojOieeU3UZkmJDCOSkdKsMqSMHoHDrDOYY05TwOaHfn
+9DhvUCAN8wcJHMapIAvBWVdygwTMatiNnMfHEWUM2XlfS0QMwXlUIxZ4jo7ZjFY359rj44L0
+5dyc0ci26DbKqcfCuSXKGUBmzHc5dswb6jgWTLhTg+x7zdkZvEIxK+fv3BPinKIcwjhQbTrA
+yQ6KjqMZbu/x5eqcn3ltgOUQTxDndR7NGU7RFxTmWRLdSevQmTuURk6daUOFcofITspDZ7aQ
+p3MmOgXSghoMwUktpgqpnAZTgVrMGmo6TaZw2gzB6eVoTqIyWidFOSnKSSRmR06KchKL2YGT
+4MicxGB24aSjOYl4Eu28PCUmyFF02+6cTUM4VGfbcCdOGxoycMaMm5M3C3JqDPMT1+JyduQU
+jQycClS2CXKqDPuT98NqduakgWLmvKXGw2ZOP3UGzpc5DQbOdzktBs4UTpOBI2PgyBg4n3d6
+DBwZA0fGwJExcL7DGTFwPuoMGThw7JwxA+eDDoGBI2N25JAYnpNNv+7ivGaSl33fnYfIJ4zQ
+MpbOElLOskzgEBm+IyuH7QgZ+jCozylFdghQYzzzGGrH1R+xddoTpRk7BsweHA6zA4fFzO/w
+mOkdJjO78+XlTO6wGZnDZ6Z2BIzEkTASKMiRMWxHyHAdKTOpI2Z4jpxhQRqG4agYuqNjyJCW
+CXNokJ4hQRYMAbJhxpCVM4DMmD5kyHQlW6cJGTMtyJypSx5MCfkoOeSmrCVXBEEQBJk5QdeA
+qItNnBPCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIMj3JOZLr7Ff4XWG
+PvHVZz8o6Cvjla+me0A1xsGpMlEzB9hDQU6LCZtBwhYKcjrM4ZyoKUvgwNmrM8WBaumETfkT
+5RxvaqEgJuxpYtSz3goU5DgxYa9+wpyoV40HcmLGdHmIxr3CilGMobZiCnWZuDkUo+aEDJvj
+MmzOzv3MQUp0ouZuDXO0ENnxnlz3tRKHn5OtkeIElauxRDkusznXFpdxcOpr8phDWyTKMYGG
+TlqtzGPtpA1jAjUGQtoMAL+C0nZVHoM91HSy8mId9wnrX70YBXk7r8A5aEFcJ2qpDDhC52hL
+s4Q5hysoypFBcI5XUJTjuMqVaB1cviNdapXpFKt6+tVzrILK5VD9HG1BMocPURyLjiM5BiNB
+6LAhmqMviOioj1WGoyqI6hSQp7OGvJx8D7k5WeDAsXZaq4rbOsUpbd/O+61lA2fIlFc4W2fF
+eDrLqByeI2d40IC5994lVQeDEXO5Zrn9f32Eq50rc1mn3ntaZ6k5t84zdarMtfNsnZJ5xtRZ
+3mNgwKicNlMZDHLncZahMTontRmxU9s9deY+6OycRjX1saByeoyh02UuwmfyAkb0VF7ASBxu
+OZd8aPuUc0+Uw4dkjItzGjgkqBwGKZ3KZAz7ECqM6wYqTgayX3WXzNJl7hD/1X2lnqXvnG57
+h3uxK3fOqJ5b8l9iMY+uIDBsqNg3VIcJ5c5gsHUg7u6hMjwoyNEwJ8YxpHGW+yFNgjTlnB5H
+tLtzypwOpGIeITgrgXEqEDvL81QgYcjO87OBQmZ9GPWZNLwSWDjS3RLrUJ6ZmjB/fR7g3A/V
+AWSye6KcE93RMqNTaZBj1m2DjrNjSI4B0++4YzoWyuoc5+ksBMeAOa1PpZ7OibB/rJ0SUu6e
+7W+7OdlB4eS8N+vqpPMjrw2wnOzf2Mp5nUdrhvNu2oXOWe7NR05N6UI5c4eS0GlCJXODyE7K
+w3DOdKdgGlCVITsVpe7UmS3UHm9VpgqpnAZTgVoMyWkyhdNkNlDD6eVoTqIyWidFOSnKSSQm
+yln/gtBJUU7iddvRnIKhf6JKt3vmc5Jq90zoJHq37cNJUU4KchQMnM8624a7d7KGSqcNBTlj
+ZldO3mznTtFM7dShIIfETOpUoLKNi1NpY+HkUK2Jg0Nm+N9YGDFWTkpdxdAZ5GBOnYHzZU6D
+gTOH02LgTOE0GTgzOG0GjoyB83mnx8CRMXBkDJwPOwMGznc4IwYOHENnyMD5BmfMwJExe3Io
+DMvZzPHuVs6y1B3LcpZ1BOUQHTVDc16Cr7P0yrFzlq5DYxj9ljTlkJ2XJmPI++f2Z+UxD0fB
+TOW0Q2b24dAZODJmDw6HUTgsBo6Mmd5hMlKHy0zusBmZw2emdgTMzI6EETgihg8JGa4jZSZ1
+xAzPkTMsSMMwHBVDh5QM1dEyVEjvkCADhgKZMGPIiBlCZk5fMmR6kCnThoyZFmTO1CEHpib5
+MAXkxWwlR+UlORsIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAf
+T8x3KmO+IRr/jVdPKOirwjFffa59xdoBqjJR30wP+6a9sdNkwmYoMHU6TNTEDpbQfXu/v7/H
+cF7MZx0zKPX7zXxmlAYTNQNLmGMEwZnbmWfABTlGzPGmSgpi4mZkinKiniaGTfwUxIS9KIma
+XwrlTOxUlbBjJ+wVYxCzw1dyfcUMGjI2EIEJc/YzZyeNCZvrNMyJmiNWC9Ed58l13ytxuDn5
+ii9eULG2jItTW8Nmx059UR5zaGtY7CGio4YozhuydrJFswwKag2EtGI8C7qdcl4DzbOgojod
+RHP0Y5vuREEp1vFeuUB9xYuCqM4rR3OEEJwoJ2otkzBn6rVm0HEHdPa/WJNoPVe+Uywa6VRQ
+uTolHKqjhSiORUFChw2RHIOCpA4XojmHLCjEUZ/kGI4KojoltHOngPbu5JdvNyfLnpzmctW2
+TnmWcXHeTI+zcCh1qZ31e5Z+9SzravycCtPQtOVkTLMqnbOqq8/YORtP5/SYyzV35qKFOszd
+udz/dHAu63IeqR9JunKu//iMufVeWZOunPu/vmTMnYK5LPWdpHQK5rWXLJ2lyZg6PUb+FLvK
+NBzNSwYdQ3aqTGp0m53TZWpDQeF0FSMnpX4xds6IyQaDJyN4yaAtR+qMmHIXiRwaw4dk5bg4
+JwOnNQqu2z6t0nUIUN05NfIqjX0IFU5qGZvC8mOIz4ycU60eD+cqlb9l3W2PcCGpU0Jk59Hl
+RIcJFQ6VKSVqt7EdBiTdO7cwxrbG4Vzu1M6m9+gOp9uu0onmqHbPMyxnETMs57FHlU4LeiGP
+9z9EDNV5fchNpjAchcFwlMx2vA5Gm5yhnBIsyrmdEgKcU5Rzojsq5pY+FOTYdBvd0TMfcCqQ
+HdMvKNaxVVydzTnO1RnXY8BcTz0dx3AUdMfBTpztb3s5z606O+/Nyhwinc6PvFp3Bnbh5P/G
+Vs7rPFrTnVXLLnTOcm8+cqpMD8qZO5SoTko0qGRukNhpQTXnTHcKpgFVGbJTUepQndlC7eOn
+zpg7DaYCtRiS02RKqOmsoYbTC5nZiZOojNZJUU5id5vQSdxyZndSlJPGTJSzaT69k47mJBUz
+oZOO5iTqSVTrpIM5CgYOgYFDhPJ2O3cIzJ6cotm+nbKZ2qlCQU6llYdDZLjfjCAwJk4OxTj1
+JiZOkjGSb650FUNnEDiGDJwvcxoMnDmcFgNnCqfJwJnBaTNRjilzNOfzuyfMsYR6DJyPO10G
+zocZOHM7fQbOlzgDBg4cS2fEwPmoM2S+3anPIjNmeM7yiLOjYBjOsvg7yzqO5TyFyHL8nNf2
+qw6FYfRbajCmzruu4ockxuC0E+TQmDBHC1GZnThkZh8OndmFw2D24HxxOTtwWMz8Do+Z3mEy
+UofLTO6wGZnDZ0SQhJnYETF8R8awHSHDhoIcMcNz5AwL0jAMSMeQHSVDhdQMETJwKJAFQ4Bs
+mCFkxYwkQ6cHWTIdyJZpQtZMA7JnqpAHU4F8mEJyYzaQo/Kw3AUEQRAEQRAEQRAEQRAEQRAE
+QRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQQwT8gXEmK86fuQbomHfeI36Am/YF5LDvmBt7bQY
+Y6jNRH3P3n7igN9fb+fB/DYkU+f3twk5MK4FrZgjOGno2EBrxtFJgU5Ev4U6/ePHcuaaLmM6
+Q06U0wucwzskKMixYCjQvpwhZMTEzTA1g2OnxM1jFcSETZcVxBzstWlQOUGDoMmEvdIOmzrP
+9pVpADRiwi6kYU90DCASE+aoISITNtdpmBM1R6wSYjiuk+uuFy7xKqhYWMbbsYAozAvycKpL
+8thDa8SkIkqv+TlZrxlAlHpWkLWTGo4YajkpdwIgkz3UdNKSLTmlg9rOuyqLnhs4Kaqg9Ng5
+b8jNSSZjm+TEFGRzsFI7LimvD2TnFTfHBJrJSVGOATSXs02UI4HmcrKlCP0cNUR11CNO5HgV
+9DHHabWmRV+Q0PFZTesLHC5EcsIKMoDmciqHKhMiOpXlpL0cXcdRHW1BDEdVENlRXh0UDgui
+O+VBtHOngPblVNaTVwy4zj9+WJ+BUzlveji1K6iD82a6nNZZMz3IzBl0n85ZqIzO2TLL4y/m
+zqqGFWPuPLZ5uVxuf//789LuPblz2+blkeXSZzhOrZrLJo+qlFDupJx5lmXqpArzLkvhsJiy
+JrnTZpZK34mdBnNpjAXrcp7ZmzNgxM9IeY78NRDLUbwaLvZPug+stnMxcZal41wqY1vk3G+U
+9feRgUNiRI6AET3DZuybNyN4aZLvniFj4ozOBg9pu4sEDM25qB0qsx1yfuVwC+o7p9P1f6fr
+Hy71nIrkDPMQypl0qjM5uGRjm++MUndGEN85PfYO7+0XgXNN8WtODhuSOhXIhalJNOc+fBhO
+AVGdhccUkJfDuAwpds/DWVflMgzu0Enk8JhHCB0X7vAHNcd5Io+3VGQM2Xl8BkjKbI6ijrNo
+DJKj3P+xDuGqasPEOKfrKWEARTsa5pa+YzPaMijKqUB2zFSOATOTY8EEOYNXKIZO6jiG3bb0
+Os7Q6e4gOJUtezuvrfo6SeVkv9tjzre8G3Oc4h/ZyvmdZ2OykzYhKm9p5NSZDnQukv8qy2lC
+pZNDPadgWk6FYTgl04BqTA61nRpTheoMxUlNhuFsoZbTYCpQiyE5TaaENE4vVEbrpI84bUbt
+pCgnRTmJwuzJSVwnZwydbjnkj9Ypu206J7G6bQdOCnTku4fzUU5NOTM6KcpJVAaOFQOHwGid
+JhTkFO3gUBwKsyOnbLYbpwZVWnk4tVZBTo1hOgVELUfpVNtYOGnM2DhppFg5aaD0bjqbBs7U
+Tp2B82VOg4Ezh9Ni4EzhHKycozlNBs4MTpuBM4HTYeB83ukxcGQMHDi2Tp+BA8fUGTBwvsMZ
+MXBkTJTD3N5SfO/YxVkajnG3yRmqs6zjWM5L8HU2jGR6EqZT7zc75zUvuXS2FbLzLqz4mYdT
+CYUJcwygIIfG7MYhMntxqMxOHDKzD+dry9mFw2A0DofZgcNi5nd4jNhhMrM7XEYI8ZmpHQEj
+cSSMAJIxbEfIhDlMSMzwHDnDgjQMA9IxZEjLECE9Q4MsHAJkwowhI2YEmTF9yZLpQbZOEzJm
+WpA5U4ccmBrkwpSQE5NDbsxG8lQQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQ
+BEEQBEEQ5HMJ+SJdzBcDg77oGPPNzdoXUaO+Vxv1NWFjqM2EfY/b0ukx1t9//73G3/n9dYfe
+SgOKcoygNePobBhHaCbHZoKPIOe3dIq5M53qKSbptGBq/ZZDXo75/iE6NhPXfMBpMEYT8UQ5
+/euPpXOzmorRgCMEzoecsJmfjuZQIAsmzBlDNkzYhFlBTN8xU6Z41WjJhE3+daxyPj8I9vrW
+gb8zYMJO1HFXnrAr9n6eUREdLURlwpyoOVWVEMOJmoxWBQ22vH2nwqugYqEcZ8cCojC+TnWF
+IXtos5SRQUUE5u+/QhwTiOasYuvkw0BdUMvJJPVQIDsRUHItKL2WtLIoqOOk1VJda8i8oJSt
+CeboPDrPoKCB81oOTFvQ0EnvPeQPrf5wd5JuD40dm3s0EzkmEBxXRw1RHIuCZA4fms3RQrM7
+Pqs1BTpKKMqZfwdN2nE0Rz/iiI4aojrlR1PCHBZEdpQFcRzNyZTuKD88NGVBiucJDKfoOT9n
+K0U5HIjjaArqbXT4Mwunds3JY+BQGAOndmWzd95v8fU5C4dSltJZYhwyo3NuzOWW8k0KO2fF
+XG5/6QwGJXN5ZnlWZe0sG+byZi6mTo25PH5k6FSZZ++pHAqzHXoyKGdSi7F1ukyt7yTd9pcm
+E+fUx4K5c9mjM2LEz3x5jvxVKttJed9JmKFT2UdCp3naecfA6ZzeDJ2lex59MYJnvhlDqUf0
+koFfzSJxyl4b751rI5VDGwT38JyUhap8xhlDBOf0F62TM+m96W36zBCqOyVTSMwXwzlz3VxV
+yTjuIVQ6ozTqGUB85yEVHd51isYU5y+l0oekThUy7rYm5OLUJB+nlAjOfZTymBP5EFq1ETi3
+Y/XEdATddmNOFEjF3KQY55axY8IwnMe40TsN6IVc/ydUCM6rmuv/iRmis2h2DaseQ6YOmTCE
+pwkWDuUUZ1RPGuwhE+aWozn9U48d8wmnhOyYb3QsmP6XHMycpevYdVv/yZVdt526BxCcjzjb
+X+8cQCrntVFZPVQ6dZxxPdnv9pnzed2Y4axaDpjzO8/GZCdtQlTe0MipMz3onCf/1Z5TtG1C
+BaN0GlDJFFB1XDeZulNjcqjp1JQGJHZSk6lBdYbmNJnSaTAZVHd6+ZDTZLROOpqTaIzeSVFO
+Yneb1qGWI3TS0ZykZKZz0iRO1lrupECH3G1RTsFwPpqq6TbWR2CP5iQqA4fmFA2DnJLZlVO0
+27dTttu1U2m3Z4fGzOlUoFqrHTvVVnonh8gM10ljxt5pNDFx0kixch5S53ErZ5AqA+fbnDoD
+Z24niIEzidNg4HyX02KO5hgz2D1wekyYYwsdzOkwR3MsGeweOIFOj4HzcafLwIGzT6fPwPmw
+M2CO5rC315jlx7qcpfwetYezNJwRQ3ae249y6vvHjFnVEeA8/+LovObgEjGCo1Q2LRLfETGH
+cywgCmPgkBg4MibKCS/nX5Qjg4jMy/n3TwRRmZ04ZGYfDp0JdyTjmsGozgdBDodROCxG7vCY
+MEcKcRmhw2bCHBEkYCSOhBFAMobtCBk2FOSIGR6kYDiOhmFAOoYMaRkipGdokokzhmyYIWTF
+DCRDpguZOm3IlmlC1kwDsmeqjgNTg1yYEnJicsmPWUGeCIIgCIIgCIIgCIIgCIIgCIIgCIIg
+CIIgCIIgCIIgCIIgCIIgCIIgCGKQkC+EBX2P7kNfP3SQqog91GRsoQ4T9W1kS+i2ud/fX2fn
+obhDL6YB2TOu0JpxhFKY8zt0LKDM8SooZ7wKqjiS2UZljgNUdyQzWrKdKqRmGk4uWZdzG28V
+yMWxhxpOKked1mkep1GO6YALdCjnURNnfP0xclKU88SaiBrqbtmwnrAZmY7mhM0wdTQnbMas
+mRwDJmz+ryBm6Ngowa+2P+0ci9mf02cs36OYwwmb2jDsirCfKynR2cszKrITNQdp2FP4sMlb
+nSejXb+J4Oc8F7FxLugq+Be0WpUnaaGxs3lHxNPZSPbQstQcMTRWbN5LYjvGE3t/wrGAWk6n
+ImOnNeI8C9qu0ORXUPZOqbGzoraQvZNWTgSUtpCD87rQrcedi/OsRAmRnHzRNhfnBaggniN/
+qkBwVoXIn/vwnFf27uSQi1MpKMrxWQSm0nFu0Kccl2V6Ah0tRHIMCiI7SmguR99xkzlqiOrU
+PgTj4lQgH6ey3qqToykoypmxoHIPeTmK5wkcp4CiHAbEchQfHmI7wneWeE4OaZxltdEaZFTP
+8t5idf31bQz6jcIYOCRG77yYvqdxLn8hMhbO9Y+Lu3O5Z7SXFM5t65eX02V0zrJ2Hp3X8MTO
+ppp357XKsmRuzsXYWUrmIVs6S415xs7pMpfKM0WRs3SZ+ljwYJZK1/GdPvMcH0KIvG+eZyK9
+c03PuSic/JeCnKEifaPHwCFBAqfoOr4z3ju1se3h3MN2uN0W6/D3T/YbqX9CeETw0iRXKI7k
+DmTB+DhlOZR+u+RPFbi7h8hco3ISmeE5OVMf16ehM4LqzqmItXOqMxWIN+IK51RnCqoY2rxu
+axmFtrAgPvOCWG9cSZxTZRS4OKdTBWE5RIYPSZ26ZN1tLcihnCo1du7HAtchH0JpBfGd26G6
+qYrWb9xyTjeG4Ch3zx902joNSO2ceM59bwoZqnP/5KacGTvvYv7+J2a2R1G7nNv5/b5HfR3F
+rmE4WmZ8SlAP6AcT4nDq0TBXaDCyjZzT6AjycUrIjBkUdFDHgPmIU0B2TPc2ml05/duP+3NO
+3YFgycCZztn+upfz2qjIIQ/1pHGKXyYwz7Z0J5W/3GTOz7zajpyq0ofOm9wbJ6nThs7nEtqm
+45SNqUwFYjkNqGRKqOlUlAZUY0hOajJ0J4caToOpQXWG5jSZCqRweiEyaieHgpwWkzk/fCd9
+wmkyBk6KclK4Q2WETjqak2IdMiN2kq6c+Zw0hZM31jnyYcD5DKym24ycYTmsz/RGOenTTtEQ
+DsUpGwY5JbMnp2zn4lTawRk7tXY7dogM87seH3Oqreydeiu9kyiMhZOEjMZpNTFx0pAxcu5S
+73ErZ5Qgp8rAmdsJYuB8m1Nn4HyZc7ByjuY0GDhzOC0Gzlc5TQbODE6bOZpjymD3wOkzcOBY
+Oz0GDhxjp8vAkTFRjmCDjcmErJ3WrEVWznuiLMmMOJwq7l/ka0CWTjHFtjmzWTLU33n+1dFZ
+z2zHZsyO0iBnxOzMGTJGEMP598+VWTlyiOH8+yeHmOXEOTKIwmy6bW6HxHzIEUA0Jsp5thY7
+xHLU9cgcN0ZbT5BDZnT9RmeiHdH5msFoHA4T5qx2EE9hMuLnO0xG6nAZIcRnwhwJJGEEjojh
+Q0ImzGFCYoYHKRgOpGLokJKhQmqGBhkwJMjEGUM2zFAyY/qQIdOFTJ02ZMs0IWumAdkzVciD
+qUA+TAF5MRnkx6wgTwRBEARBEARBEARBEARBEARBEARBEARBEARBEARBEARBEARBEARBEOSd
++C9peUmf/FKgudRSXL4c+usN3ZW/OENPxhl6KQ3H8FvPv13IzPntO1ZfF//9HUA2zNix+Zr9
+7yaSORlljguUKo5gekF2OV4FVR2HgkqnPp2lEip2T9PRzruRM7+N+Tn37VQke2c9x6mrYw81
+nCrk4aTKdLpOTgE5OiH1WA7sVDnvxDhNRuukKGcjtZmwCZkMCnJn4Lg7KoYBBTlKZrYJwPYz
+0ViMEjfNWIwSNplZEDNygpi9OSMmbLSFTQUYNbVh1Kkt7ooQdonTv0cxmRP21C3qqbXva4XN
+C1Q/J3sPwctZlhDoBvg7z1LW+8jByftMBREck3dE2I5UaipNx3Ym7GUVC4jiWPRcy7GGmk6v
+53bp2EIdZy0l9dHahVYnH+37sX3nfQXSvvE7cBqQvVO9PLgsKvAccJtxt2MnvfpNBY2dVyVr
+yNNZDwYPZ7V5OUR0CsjZSdKCKE71PmeUI1sFZuhoCyI5BgXN5eihL3XU0GyOZMlQkVODohwG
+RHd0BTGcymqrLh23j4I4Tgnt3ZG/5GI5CojrSN/x4Tnyz8C0NmcNNbbVc0SvIbtbqnlWzpap
+1GXibJ9Lt7tP6Ty2fLmGxIidF3N1rn9rffxS4zw2+HRufwwcKlT5zcsmo+4TO5fC6TFC51Jk
+NBhETslcRjvJ1OnsJGvnonKyX2o7184LcO57yd25GDtp6TD1sSBwrqOKy9CcXBmUU+s7rrOM
+nfo+kji9UfCI1kk0RuTkvyJhBM5YqZ3nnJyoesqu4zpj5hGdQ2bYjrCcKIe9f2QO/7WWyBHc
+GNy2Jp531E66P5+mhOfk+5NYUAkxnNXrBPOCsj57MKd7nltc/dXCeZVzqkTn5Ew6NZhSYh1C
+BdNNxjDeReA5G6w8hugOgXlBRZfTHRJzg0qkC0nKuabO2DsNyLbb2pCDU5c8nL9QLw6vx++H
+Ap8hHqppBQnKuUHbDnTptit0CnFuoTuLhhk7m1EgZojOFbntThOnCr2Hmr+zqIYAydGPtJKp
+QTbO+JRg4hBOPTbdVpxMvZzTMhgJVs5oxJkxYU4fsmO+yvFi/Jz+3br9OdkZoepYMKfutRvO
+oZ3trzMdsv3aKNGp185wEttZNyUrbCdtM2DO16zabn6352RM1zmvkv/ewCkbk5Q6xHJa0DkP
+x6lVT2QqUNOpMQ1I6qTmezVVqMKUkN6pMkSnyVQghdMLjSkgtpNDQQ6RETgpykkfcFqMiZP4
+zo/ISdFOk4ly8l8QOinWIXeb2ElzOEVzsZNUu2dnTtFY4STN7pnRSYpu433o+kucsiEcglNp
+GOSUjIFDKmc/Tq3djp1qu/069XZKpgIFOVSG6yQKY+60Ghk4icCYOEnECJw0UMycYeCYMXC+
+zqkyUY49A8eQgfNtTp3ZhcP5apvGqSbIITP/RTn/qaTpnBTlqNJg4HyX02LgTOE0GTgzOG0G
+zhc5BysHzqcd+Vw1PCbIGQSOOXM0x5AxctbzmbEZurOaIVoyIw6Pec0U7V3PsyA3JsxprOpK
+YwzP1oZOL31md86AWTn//kU4/25xY6Kdf/9U0JD5lCODxszHHBEU5BCYPTkMZuXwoSCHwhg4
+JGY/Do0Jc8pxzXOojNIhM8rjlO3ITth0pnCcmAziKArHkZE/UeQxYojLhDkyiM+IIAkjcEQM
+35ExfEjqMCExw4MUDAdSMXRIyVAhNUODDBiSZOMMISNmBJkxA8jQ6UGWTAeyZZqQNdOA7Jk6
+5OFUIBemhJyYDHJT1pAngiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiDR
+CfjOTMx3jUK+PFX9zlnYd+hcvhP4+/vrLD2UOuTB+Bb0ZqqO4Zdqf397kAPjWNDWcYMy5rc6
+6ZuDU5/EzsL5jXDychqOGvqY8yuZlJHi/NIcJVQ6vx92VFC5expHqtopmN/m5MDmTiP2jnnH
+tRzrY7Xt1GYFNXcakJ+zODv1ghyctJlY198xq6dy3lk5VgOu76Q8lk6xcSMnh9ycRGbUEzLR
+FOWAo0fOwAlwFAwLgiNyVAzd0TFh85kFMWHTpsUoJGdHzNEcAnM4J+jgsYCCHCITdkmIu5Rq
+33SZzgl7jug4e6vV2wcjJX/B7et4Q7Wlcnyc56o8aojQa/nPjZ2lsnfkEMkxGN0Ux+TNFxJz
+AMcaajrGO0jmmM7xblpQx9lKns5G0jlUKD8pWDsryNd5r3KmeyN76KR3z2muQ2QnGwz2TmPU
+eTn53QaHgp4DIaSg6x9JURC94x5/dXTS2hFCTGdVkT2zgRYRRHcqP3Wtx9VRFzSbU4d27AiW
+8pQ6moLoju7zXQxHd9+WBUU5CojjaAriOfJXDiynLMjLEUM8R14Q15G+5GI64nctOls0hZr/
+7Nan7YSv7ZpKcynk7CG5syzV54WNUsVOxpR1iQqqK5e/tJh8hIicRy2XW3p7SeU8uuzyzKOw
+vsZ3NsVcVpqt8+imnDF3rju4QFycSjFX5z74dNCYuaczGEydTudZOr1Dydhp7iXLbrs8T0Xe
+ziXQaeyjvTqtscB2HheetlPfR0zmdYFrQxcpxGIeMXAojMTh7J1n30lebGXtaUyYU/Qc0yEw
+j8HNhfjMPXBEDvdFnWAY3Bnmay2ZUzuEnOph7iChcw3HSR9xXifR0z0spwutkfcLktMrr/+0
+c+6vOU8bZp3C4RxB+b+pTlQl1iHEUDKo8v6CFZNhjFOPxHlCeZf3IAlzgyqIvXM61Rl7hwmJ
+dk8PsneuUqmNnEXg/KU4hAbO/YwjYpZtUaN+EzknviPqtkeGjg1Dd4S7p+ZUoQdyc+QM3Um+
+zvrhxcqpQM8Brdk3ZEc51k7Xg2gA2Tjjq7dVOTHOaRmNOBvmmn5BB3X0TJjTHQh23UZyLJgg
+p38TbY/OuN8MmGvg7NsxYtgOnd52B8t5tWT8+wXOqindSVwnbUJVHk03P+g6W6bvlG2pTirS
+c86PlL9l6ZzX4Tm11iSmCvGcBnTOQ3eqSsMpmApUcyrvNfSgCkN1mkwNkju9kJgSYjsFFOTU
+GQMnfcRpMBZO+oBDZUROinJStNNiRrvHyhmVQ/7U6E4cKvOAyLvHySmbBznS3fOAPuyUjXfg
+pCgn0ZkoJ2eYH1YXlwPnc06t4Y4dErMfp9puv0693V6cAmo0s3ZazYKckuE6SViOymk2MnAS
+gTFx0pixcdJIad9ENw6cqZ2DlQPHjoHzdU6VOZpjz9g7nJVAilb//fcf2WFMu1Eq/5ElzkQv
+VYYIGThUqPJDgvPff0yIzDTrgcNxuAPhc06DKc4HUQ7vjKBw7pKU4TiqBDkHK+doTouB81VO
+k4HzTU6b+XJnMKOQlTOaucjIGc6QFOQcrJwdOlKG42jKYTjd2dlGDpPxd5ZlBdU5k27bOuwJ
+fmROPYa7p+eYlEMYB0bO6NrTYywvpkTn379/Ec6/W7yYl/PvnxYiOf/UTp8xcwZM4UghmvMv
+3pFBI6biiKAgZ8jsyxkzNYcPBTlkZh8Ogak7TIjiVPcPzyExBh0ndxwYtUNkoh3plYHK1Apy
+YVQXbgaTP4Fz2TkbyG1I5wVxw2PEEJcJc2QQnxE5AkYCiRi+I2P4kNRhQmKGBykYDqRi6JCS
+oUJqhggZOBTJhBlDRswIMmMGkKHTgyyZDmTLNCFrpgXZO1XIgalBLkwJOTGZ5KesIFcEQRAE
+QRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEkSbiqx8hX5n54FenzKUWYwzdtvj7
+F1/oqdQhyy85/v4GOGnl/NYm4XJgfqtz8u3J2TK/nAnv7R2Tbz3/5o5HQbnj1XFEx+Bb6b+F
+U2G0UM2pMubOb2tSPmuneo7TOwXTcpTTLcznKKA4p2TajmbejeM71w0+Tj75IevhVKcFdXOW
+KGdxc5ZtopzFxqmcrqOc5t6RQ3WnOaw1TgGl94ArGHOHt7IUydlKlW2bOYnMqGd+ohgKhjvD
+FJxghwfJma92FMw3OxombH62ICZqGrgYZTZHzUQ5c3WbHgpyqEzYyeBw5+q4a3bUc524J2/a
+VwvuUHeThu9TUByTd15GzO0vBlDfEaz6I6yHv+wP12m/g+DlWLwpMmZs3nwhOuohR+g3k4La
+Th+KctwgRydFOddTW8AOykrSQQOnDRk7Zm/MD6HWLjJ3GpC9U4ccHAuI56whV0cMkZw65Obk
+CzraO09hC/k52VKY9s57+0KI7SR3p/JTe0cLTefUoR07ug+sKR0yxHCqy3p6OJqPLrKcygtW
+J0f8BFjrUCGeIy9oUqeE3BwZxHVKSO00Pqho7NReLVYr0jltpnhI4Sz1px11SOwsfcbKuSmX
+vzSYfCjImJdyy2DdcjLUV/6c2/833sCUO0vuPKuSL5BdcRrKpTPG5U7JjMrhOi3mvpd0Tgal
+KnOPnZN6TGcnWTuKerLf6DutvjN2mjvJstsekRbEdaR3UHhOa8w5ONWeM3bup4uIem7/L3A2
+rfunnXcEBW2ZxlnU2ElxDkWRvBrOWpOq0Tskpn4+dXBuYRYkZeDIHOaLxyRzijsNTk71EPJw
+LswdpHBYR2qbOf3FzGmVc3rEwVld4k61jJ0OtHH+RtBtc1WmIjFG9rZdC6hClUPIyikhakE8
+JrMYRyqfeUuFQnPIzF2qKG1HVM41VaUNiZ0WZO40IIIjgE4n4sB+PPo4FfBDPFRfj2qcbRea
+d9sLCnFuGXacdvewnEW+e4jOq5jr/6ycCvQea2lRMDRn0Y0Bej1qJ3+Htu2omPEpwcQhnHps
+6jktoz1kw1zzVY4d85WOARPmdD9OaOf0bz7GOgbMqX9J3aPTe24V6hgx0zose9WU5zxbMioQ
+OKumNOZ//3u2HI7rOjOG0tNJTCclhvNodHPSwNluL+UhMK+m2X93nIIZOOfzufwVkdOBzq9w
+nWrzodKSWk6jfApThRpOg2lADk4NypkaVHOKQdl3SobqdENxSkjv1BgLJxGY/Tp1xsRJ8zjl
+70icxC9H5qSjOYnLRDk/kzuJN6p34kiHAedTyp93xsyMTvq0U2urcVKUk2jPdCoM0xGXsyOn
+2nC/Tr0hnIFDZPbiNNopmcJptdM6ORTkNJvZOu1maifJmHmdNFZsnIfUbWHj/En9h0tG6AwC
+Z2qnwsCZ2wli4HyfU2OO7vx3jb/z3yOk7bG+cVZlaFLtuwsk57//WFDDqTJr57//eNBSh3yc
+oHoqP+Y6lD1U+6GDQ2fa4+0ATtqR02Aa5zffchL3DCd3kpIhO09JyDAcVWjDAM7BnRYD56uc
+JhPl2DJwjBmmI58Th8uEOcK5hEyZfTmNV28khuEse3BMGQtniS3H21kO5lD6rc1EOXQmzNGc
+q1fOv79wVKHz7xEf5uX824/TY57Qv3BHDPWZWOffJh5MlJOMHFI5mSOBgpwRszNnyNQdNhTk
+jJlYJ2eYEIHZk0NhGvtnRofE6B0a83x+4F2O+sJAZWoFeTDlEyv7sVaHnBjN21UcRgHxGLHD
+ZMQQ25FBfEbkCBgJJGL4jozhQ1KHCYkZHqRgOJCKoTs6hi6pHRqkZ0iQBUOQjJghZOb0ITum
+K5kybciYaULmTh2yZ6qQB1NxXJhS8mK2kJ/yhlwNBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQ
+BEEQBEEQBEEQBEGQqIR8KeNTX5lxoOqIuXTf4u+vM3RHrnF1XsoNKueSsmPezi99mnOB87tx
+fKAt81nH5suuv/M4aihnquPNAKo4Vcbc+W1N+aZlcqd+ktM7OdNyVNAnHQ8oyKkNg7ajmm6h
+ZD7vaOap4DBhjhSaxbF6StJ07leHyjXCznkwjWlBzZwlj4tTKDnk6CwOzrAgT2cJcIrBLXX6
+0P1oVRdUcR6ng02HmXRcqjGpOaO73ElVphWFk+iKcuYnsqI4YfMCRwYdzJEycEIcMTOnI2em
+dBQMxwli9lDOfLP0RZVzOOdoJ4O4k3Xck5CwZ29R86oKJYkTNfGt9US+9bdd7KGmYuu0FQnU
+c1LtlqAQ6jKGPderp/WOVaRjN+d2+x2rfTq2e2js8FbCljjp+aaYt7MpS+cQIJuRTSio0XP2
+Th3ycnQ3AEjOZyEPRw8RnRrk4tQGnZ8jL4jsKKFZHSnEdoQ3aehOdUVHx3o2kJeTsvs1Dt32
+esot6TiJs4mDU31a7+NE1RPj1DrOxZF/FlPtECG2IyyI6Yg7ju/Inl5xnbIgJ0cISRzJsx6+
+U0Bqp/qyx96pv7wSQgJG9ImRMVPhBM9FOkynLDPnsiyXv7R6j99xpbDN3xYvtXI3/2XgXB51
+dSPptseWi6psnevuKJmRM4ZKpeZ0DiWJ02Iut9Fn5rSZe4ycgdLdSUNnC5WjmjgWePuny9yO
+2Fbf2TrtnWTp3LMrZ8w0BoO10zwx2Dv1rjN3GvvIev9cZE76iNM9u/WdAZQ5NKg65ujOQu02
+vrNliE79GRCj24jl1C+uDs41vILmd3gdJ2d4L+/FDvPtCqlTuzwElUN1OMwtRs7pxHQ6UIs5
+3ePhrKHTK88feDinRkyc+1PrFlFzOCN71WZJXaSAOPc5N42GTAlR62EymVXsH4pDZd5SyTQh
+mXOXaoy1c6oiH3eS2HlApdd1rgOU6dykE/EIejuEg7QW4v3u9IbkznZnWe+fl3TKBsVg90id
+E8uRjAOmc//UnobJBnfHoVwTtM59ECx2TgmpBxvX0SnDQ9XEGV+9jXotyrlmKkfPwHF0DJij
+Of2bnHblHM3pXroNh8FEjg0zryPFec6zJX3jknpWTUnK//73v2dLhrNpOobSlXlBdCfxnPRw
+/qd0RtDbScUvd5xcGTj3Jg+nCMvpQc8mVaXnVJt3nPNfqr9j6Zzf4Tmtf9eQaUANp90BQ6YO
+1Z02U3POeahOh6lABTOb08+YqUF8J4eCnBpj46SjOYnPzO2kPrM/J3G7bSeOd7c9Ie9yjuck
+xrl6N46w23ifIv+wU22rcVKUk2pOvaXOScJyDJx6u5040t2jdxoNrZ1WQzhdh8pox3WQ02xm
+67SbmTqdZmonxTu9VnoniRiBk8aMjXOT+g2MnGGCnJKBI3NcGAwDOIFOhYGzM+e/vzgwmfPf
+I77Of6sQtseaSK/BEKDa56Epzn//saDa1DgUJ2dGUG3GmjYzg9OHWszOnfIBF6fywMCRQLUf
+jxi208jQYY9sM0fCEBzumUfs5JAdk1/mvMqpXk41DNVJSoa0e96UEOE5mlC7Dc6hnQYD57uc
+FvPtjnhOHDYT4TRfWA0ZltN8ojuPw2fcnebLHQLDcJqvEm2dJcYhMQa7ZyrHchTAYTmUw6fJ
+fOBs8O+WMdRrMXb+PUMsjslEO/8snA7zkzM7cHpM6cihsfNvGwfmo44I6jO7cwZM3RFAQQ6J
+iXIKhg8FOSPm4w4PGjI2zpgJc34MHApjMRA0jjWjd2iM/sTDcpJUoTLl80SHMd2AXJjiibwT
+o3r7jcMoIB4T5kghLiOE+IzIETASSMSEOWxIyHAhMcNz5AxLUjF0R8fQJbVDg/QMCbJgKJKR
+M4KsmAFkx3QlU6YDGTstyJppQPZMFfJgKpAPU0BezFZyVO6SM4AgCIIgCIIgCIIgCIIgCIIg
+CIIgCIIgCIIgCIIgCIIgCIIgiCghXy34yDc/XKiqYi41FVvotr3fa65/yedEMmV+f59OOfeS
+PfMH1eZ4smd+fxnzdWuYSMdj0OXMhx01lDO/jRnFzJ37sWoNFd3m5+RMw1F/uzrCqXVby9FA
+UzrKr9nTHdW0AQXj4FTL6Tia6RamdBTzVHzM6TGK+T26jtFTkpqzZWyeY+XO32Z/n0BqTBNs
+5FQT5SxRzko6iPOWDBwSJCxoDieVE/kKnRwqTwZGzgZKlVg5qc/YOanL5DMTK5zUU/Lzqcbp
+R32cjqHXyH79RMQQCtoW4zhj1qK//kzlpChnm4M5MgbOwRwh8+0OypnaCTtKhZjM4UNwDulE
+zXx7OMcSWpbGnRNTZ+kyZnMtjxhDp6fYzR29vLQGaeSk9fsg+huDMziPkd2ADJ3Uc3hQ31mX
+dRyn9q48F5rLqa9a79BxVcjF0UJkR3moEp360ergVCGPgrT3nMiOEqI7ug8q8Rw5xHBUBTEd
+KcRhapCfs4V8nMrShJ6O4DanzOG/Pc9kyoJ8nPKZ46777Tne+AOB6YiPVL6TP1fwcVLWa46O
+pN/YTLmDnBxZQRM7BeTlSG4MMv/p4oJGSv3dCn5BIiZ/RONcLu+NlRobajN/zuXy2KaHc8lS
+7z21kzOXxk5iDgSKc7n3Xy/6butXZe2M3vab1fnbXMPp7ySWc3sq09g/t8ghFnORv5+dM12n
+t5OYzoBp9xyr35pHz8Pp7COGc01/95g5XeYeC4fAXOpv+Zk7rTFn7CytQWfvXKr7yLzfLnVn
+AHGZe9gOu5xgh/uerMzhv/e7bji4JoycLrRhqE7jECL3G7WcS/0QMt89t0Q5JRTldCA5Uxty
+NIfLTO6wmPozOQ/nwhpwPed0Onk7p2d8ndMpg+oofQdtGpVIlsIh3617t3i87GkjpcO4dbJq
+8vcrXaSAOHcF122GSkUS7B8Ss6XKcdCCBMxbqjANR1LOG/J3TqeaEenUocdjC2VMV6HS6zsL
+27lJJ+ItjfSCBM41V2fbiYPdI3dO2c5yce4hOotkHDSdCvREZOOA56T757Q0DM25XawsnRKy
+GQVDx4lxcsZXVZtyopw/aTDijJhr4Pg5Bsw3OhZM/2aqmTO4aRtUj+Hu6T5FiHVsGDhCnOtI
+BwfLWTWlbf1/r4YcZ9OWolyT2E5iOul/K6jt5NtLiQc9mHvXJbKTMyPnr8XTKdJxKq170u1x
+jtMsx8epMR3o2YDr1Jmmk863NH6r7TR/oc6cX+E5TabunM8jqO60mSp0Pg+hqtNjKs75PIYM
+nJwxcgooyCmYMKcGCZwkYKrn0VGinPQBp8LYOWkKp/obMidFO9Rum91Jmm6b15F1G+tj16xy
+9us0WsudxHF+duAkcbdxP+b/OafVUuekmHI+57Ta7dRpttun024X5PyYOu1mu3Q6zdROIjE7
+chKFMXRYjMS5UYMGRs4wB3P+z969rieuI40CjtyznjSQ8INu7v9WB/BJhzqrJCCt2vub1QHj
+NyWVZdnYTsEM5190SmY4/6ADMD/e+b5Fe+d7icbO9x4Nne8kfJnd+c6DWx16hyPpFAwD4XeO
+qx0KAp4e0tgRXnxNMBREOCDj4IjS6eWsb9qd4i3S0ULWcrM6wFstHCkTDW8WB3rH4qAMMe5w
+jnKEs41uCEQ4aPBOAbkx+eyglxOqGaETSyZG7IQqReHUBcwM5x9zEGY4+Kza12GeIuPlELN3
+TwedFDCM0uEYp3TwOY6rg0/Zejsu3UPMdD0dYuLu6VDHo46OiKkvA+LoTcCIHeKgt1U6/5BT
+3T1v4jgzEuf8CBySjG58s53X4JMypKN0gnWqszlnqWNjVuf8Vg7OLND57ALpHLOkZaxQJ4di
+EMcE/TCHZPwcmunqlIwB6uQwDOpooU4Ox7yZwzI+Ds9g289LOgLGw5EwqOOcjsMAJ2P6OhUT
+ESEDTEjdaxqDmjDRkYleUTBVp2E1TIWjYiogpWOFtIwR0jMmx8BYIBPTzVFDRkYLmRkdVMFo
+nBpGA9U5YqmWETrVjFDycASQC8NDTgwn+TE05OkQki+DQt4MAvkzINSCAaA2TAG1YmKqpTFi
+xIgRI0aMGDFixIgRI0aMGDFixIgRI0aMGDFixIgRI0aMGDFixIgRI0aMGDFixIgRI0b0iT7X
+yHe55P9Zt2T4SzDiDS2rPJ3u/1s8QsiXOT0CfLygu3KHmjon0vG7h253TuATnpycE+c43XyY
+Ok2qO2dOyBOrvJnTvBE9zam/2zVnWjhQOohTfZfwqzm1d1d3cILKqbsrvWCe75ghrVPz2IAO
+TlA7FY91eJpDMTaop0MzwAMhnZySySQHp/jloUd21jtTEiF9OOjUyinDDL2os0ieTtY3lU4G
+CR3PhBDHv+F6dFC8jeaJ2Z2sg0IRMViRTwSBTFgfelubzw5hf0Cm2tlOG5RDddpyXk6gmOWM
+gotDR229ZU7eO9uaffMpqyDJw9GByi1xjAyXT5pThSMphPrhTebkD+Bv5mTzq/ZOaO9EPzRz
+st1FK8fldKme6fUEvW5PBPxxTq8nNhqgTo6RedlHdw5nOFWOEhpOb6fXs4ndEsKOVX0TmqZu
+Dq34ODuD5+WSTyyq/iat1XGCeEf7R3Zf3kHjpzka6Kc5Py6hF3SqLk9RMNI/816dT811PQqn
+CnpFBzoR2MQBoFaO9SSMzrEnpHTMZ5X0ju0smcFJoUZOkVBDx/K9utopoJdy9EzxxzBbOXlC
+bfPZobb5KBMyO9HP/6BjYcoxrpWj/wJFsMYeDnbI6Olcr8S5Ay1EKLfYVgZ+T1zvXJeYHv8L
+TqyrnWsRYOMpK1vgIJ3k7tygW9sx4eGsndTDYc/6vZ9Dd5KWwfrnsSk5OfemQZilGPC/xi13
+HnsvkqH6qJdDQ7nDMUQXyfvn9tuSDl0LcocpgiXeyJEwaDE4O7ZvAdTOhBaddz73/6lzJMwc
+z3QoSN9snR3lnXxGB65tdwfZh8scdhBNILCLhPmImUf0cgBI5iiZV3eUiuo7AHs6YGm3cRTt
+VtE7V82WWuNoCoFwLvdo7Fy2aOhc0ohecnC244QLEbkj/6Zhd+bBmlIKB9qE2Ha7feLCMDlk
+cgJnABJwzOXEpFRZB57OLrV2LiiDQFbnAhKsM6mdFSpBirmXp9K5GJwHpHUe0uW+CV3Ezr3l
+9M497syFhcxlEENyx9ZsUXA91NO5I42dNZvb/1UxeXE3KAOlU8eInTqFvSDBxwH2qohTl448
+n0rnHq/kODDDaed4ML2c0Mehr3/x6x6J48DcIGqK4OiQU5FOjuPW89KODdc61iyVzrZoUyde
+VrLyv3//rstpnKB0/t5jXjJwDsYIoL9/d0jhhDzEThGUAyxOM8HkAEvTUOjiPN5WOCTj4iRr
+ghkcWt9XOhiDOX8egX4Kc/APgNCfLXQOwUDOnz8s5O4gEOhQDAD96eP8+SOA3sfJGd7ZxgPa
+CT/NCSQjdYATjxRkdwShbjao3VSOMB2jE97CCR4O8gFTGeyQNJ1ejq2sd8iSzr/tBPm+p96R
+puPtiBjtZf69nPA0B12yzgnhOY6Q0Tu2dGodfDlXh1huOLhDLedY1nLmhZ3Q3SGXqneChPFw
+goBxcW4St8CHj8PGcFyY4fyTTsEM5190SuZZzvcSvZw6iXO+42jnfH87QaTzXYQjszmlYoc8
+HequWsIBGQrCHzlncVBoiqOXI3k8ToN8IMboqNPxcPI3LQ4CUQx9JbnZKd9s4ggZowP+kR5J
+OhiEMMWDauSOboTDmQYO/BbngFALB5Awhnh0BF1usIMyREgcj5mIzAm1jNSpniqKnbqAmeEE
+5vnEfg7J+DnUBNHRoeaHOPOyDrHfoRwb08shFvBxrOkoHWKS4+nwjItDTA3dHWY0wBiFs2Ri
+S0fuTFWOkmnePVOdY0qn5dbTqdmiYnuFZnur7vEZRM+PoNLx2Cmcz6Sz3JpaX25nDpqCfVe6
+O2fWCYEvatY5yxw2GOfs5KAM4NRAKscO4cwHwNill3VsEMF4OhTzATPDYRjM0UM083RHDXVy
+GObdHI55M4dlfByeeStHwDzdcWaw/ZzCETHgfKdBOtCEtAkDTLCbMACkUCyOKeRMFaRhKiAd
+082xQlrGCOkZk2NgLJCJ0Ts2Rg9ZHSVkZnSOndFBNY4CqmLkUCUjljo59YxIcmF4yIlhITeH
+lhwZSvJlUMibQSB/BpSaMCXUiMmhZsyIESNGjBgxYsSIESNGjBgxYsSIESNGjBgxYsSIESNG
+jBgxYsSIESNGjBgxYsSIESNGjPi3o8+V68+4FL8JhdyS0esOE1dpXt/pFgF6WKIrc5oDfCij
+P3ODoGcI+TMn8DFsXkzknMBHIvkzJ8WTjbXOKQmIaeG0gCBmdr76OF9frhDEnGamixMKpgoC
+mw2ug35O5d3IBfN0p+5u8Rd0rJDaqbmd/2lO0D9a3eo4ZwQ6NGN2aAZ4sqGPAzCZ5eIEzKmC
+Mmdd375W8OmgtQ6wzv3f0YuVzjQVv31ERryjA1RA9G83J+maUJ8Q4oTC+fz8jPrI1QmZ8xnV
+go+T1/Ti3KLGKaHC+dzC2HCgU2yikRO8nH10iaDICfZCCIizR3U+yVEW9RzyqIMqnAdF/vWD
+eyr1+ewdgjA3aNaWZdo56TLuTtGURuejXEem9HPybcrfKZvOOmALnGRqVbVHZWJKop0DTHra
+OOUj69s7oYuzvtDGKTfXJg4wKrRwAKZhPtlrLRwoejmv+shGs9PrUZfDGY4BGk53p9czdofz
+6pCLIzi2c3CIQ2JPZ2dIz8PZQZdz81zbkJCjQ3aVq0PET3N6PX19OK8O/TRHDr2iU3MBkc6x
+QxoHgt7aqeghnQNA7+2UUCOngHo5MkjNGBN6YSeHGjr6k7IWJ4OaOkrIxBgSsju660XsTA9H
+30HPdOhjRR+n+AYmwKCygxAF/cWtCaEfvz6CODatc9a4LoH3k4tz3ZxHVtAsRzeWksiVzEqV
+kJ0JtflAzhXK292ZS48JL4cbId7MuTNk27nlw3WSk8MWg9KhGLKTxM5jJWbG2cGbTshM9z8i
+zzN4H0md+/+RzBKVziM6ORLGwREx+J7c3UFScnWImpM6onSIcc7Xuf4zDgEZGWRAdU8H2YQk
+DjOE5ozVmTcLMXQFu8i9e64dHQDq5aBQDQOVQgMHLDl/By7tJk6n/rHVgZ7RFDbmXNZo6lyi
+8HZ26IIG7yDQ9vY2r8aR0pF/57Q7C0QygCP8SiNegiYgyeSImAzS94/YSai2zi4BDgipuyeF
+IIZzVMzlAhKccy8bpbNCJejsbICkssO+sNp5SJf7JpS1omv/rPFgpM59qzY6l+mSOyW0d89k
+ZeaQOI+zEx2c8LjR1NMpoOoqeFXHlykgH4a/VaOzU8fcIaaDnJx7/IOOB/MSjmOz/TCHvlzE
+kSEvF/FrNjIfz+6hpiLDcXZMuN6xZal1Asb7Ovuyzg6+sGDlf//+XZYLGifonL+PmBfUOCHo
+oL8rVISKYSGbAyzOQCYHYkgnBD+HgILNgRncCTqHYVBneVvrYAwKbe+DDObgDOL8uQXxIcSh
+PoEyJKV3IOjPHw7ycP78MTokQzsY5OD8aeTkUCfnTzMnUA4CuTuKfDgmhez5qBwZAzk8E0M/
+zAky5tWd0NsRdg8wDxGGaiu1M8910KU/KqHQyRE2W0W7zZCQ6eVUNNsMGdJ5XecWMsbVkTIW
+x5JOpUMt9oYOudj7OfRinZyPaicY0qlwmIUcnNDLuUnsEj4OH52cj+G8spMzw/knnYIZzr/o
+lEzufK/R1vn+doE45zuJVs53Hk2cQmnjAIwdwh2QsUIAY3a094WSDA6Rjytwdra/NeHgYNDq
+FE8v8HWmLDo5POPiZG8SjrIQSMbmgBDJNMqnfJdg7I6MIYdr2gGfIc47qhGOyOZlHM0eiGJY
+B4RaOPJdN6EIbvwRz0SobERODsFrsjxYtVhMwLg4u4QppgfSIguTMx1DOpbDBUs6L+yQRe3n
+kEMB6qiZXo6NMTvo+04Ol46TwzI+Ds+4ONvsQ80YHNvTw50ZD2dpsNaOiKkug63M2qaz13MX
+p/XWI2V6OV5V0Mvh/nTBCznnW5BO4qmY3TkvQadj3feUDgmZy21zzpwTRIyDI9mToszqnOUO
+xXDO+SyBBH/1Q+Pwta1nPgCGLAVjOrBD1HaNUzAYZG82rWNNR+cwEMF4OhSjdJCn99odYmN9
+tkMyfg7NoI4a+mEOw7ybwzFODsu8l8Mzb+UImKc7zgwyD3FnlBOrWkc8IzUzwES+CSM/AKp0
+6i7ekTNVkIapgHSM2VEyZkjt2CA9Y3IMjAUyMXrHxqghK9PN0UF2RgfVOAqoilFAlY4UqmWE
+UD0jgjwYieTkcJAXw0iODCX5MijkzSBSAwaEmjil1IjJqIbKiBEjRowYMWLEiBEjRowYMWLE
+iBEjRowYMWLEiBEjRowYMWLEiBEjRowYMWLEiBEjRvyU6HL1dZ8rvZ9zhXwDCrmDwRla13m6
+/0/+uBVv5XQP6ElF/sodAp6G04A5QU+pacCcwIfhNHBO8gcB650T5zjdQxc7J4jxcU6nEvpy
+hVDn6+vL0QGZ00NxhUAGcWog2vFLCHOCbz4wgzmVdwmDDhi9nLq7qxVO1d3iCqabU3OXvcox
+QbBje0qrzfGFIOf+iv2xYmInWyn0bEMPJ//lwac1VjvFKvcf45dtDsBsa8xRI5Q4cRPFzvyv
+z88IqnEgJkTMDfJ2kirYnc/tR1cn+uFzCStE51M6G9TAmSLmAbk5xcbzWQtFDvD4VD8ngqTO
+p48TooCdeTC3OtAfJNhe+iwTsjgBcbbtP2PMTrqxlFGfz0d3h36Ocm0dSJ0Qp1PnQLOc3X5k
+8vhPA2cqO23dCVU45fQwHyCipbTOR7GG/OdylAjODvxyvYNFPrg2daJo5UB/cay9E/o4wd3J
+96tJOTTIp0QskJFp8EjAXg6yC/R34OPiBg4cwxmOGhrOcGodDTQcG/TTnGd30ET+JQkvhz5W
+NUGos/+znROK451GjjSG0xoazo92flxCL9dwL+kAY3cbx35ArHIg6K0d4KvvNk4J9XJkkJax
+JqR3io2omWO5GNPg5Am1c/Sn/CyMBbI5QX1O9sWdFPoRjgoSr6mRwx44OjjQ2XdwIQWEGOX3
+ZJUJYcr1GsL1/j9oZvXOQ1gCb0BVw8GriJzr9MgKmrj5OmtWYEKVTs7AjmaMEykIExT7Bpmz
+dRIV+nYDoHswJ7C8HHaEUDqHAwz5OweEYfrIx3nUAgk5OVd3B2fIPlI6uMLVgpvz2GFUOuuv
+SqXD1ILCIZUlHNpNwlgcC1PvyBi85twdJCWhI2ewtvN0qNp2da5v4miYbg5c2+4Osg0JnEnj
+oJsQ68xbhRy6wl3k3j9XGBI4auanOVDJ8Y6BkTsV6cBb0Ps693gb57KF0kEg0Lkk4epEZyYu
+RNQ6+ykQSikc+VdBIYNoBnCE3zTESzAGIJkcEZNB0v5Rp5NRgANCNmeXDI6GWSGIIZxHb+qc
+C8pQ+dwhpXO5wAoMhQ3SO5e9LcSOun9W6L4F5bmRzWZx7vFgsjZ07Z48M9aZTyT3cO67BU+n
+gJZms1WB2jFWm8WpZIptFnGcFcypZIC9XZN07ttqF+fCFIKjQ26pjsxw3t7xV5o5xYDwFMez
+e6j+eUuHmFp1csLTHZPOOdgnWjvbshWMwAldnGRhwdr//l2WC5xD/FKs9PcR+Yd4p1hc5EAQ
+6QDLuzk008KBGAbq5IQuzu1NkZOtB2ZwKJgcTKGd2YI+hTQbzmAO8QmbA0MMgzjkRyDmzyOa
+O3/WaOv8MTokU0J/+jjhjwBycP60cgKejq8TfByWSZw/r+7wTAI9xUE/8OLOBgVZub2pgy+f
+O0HoRDtEoyNjlM5H4YgDcPCF38kJPFPj7ENhZ0fI6O/26O0Ejql0tuAYP4dZwMvRMBUOF8Nx
+cNoxvZwf3T3DeTXnYziv7Hzk8cOcRsxPc356Gfx453sNXyaHvqNo6Hx/+0C0851HE6dQKiDC
+gZgGDsiYIdRBGCvk6GjvC2UcFOrkqO9ztTnpU/skT5PhHBjan78APfDBzdme8yB/rnOFsxqd
+HOZqJ0cnexdnlA7NkFfgVzjF220cEUPvfigHf1aKr4My3B0fcgZ7vrvMQSB/RzxDoBnegSDS
+kTPENBFl4MFT5eQQydQ4kpkvzUidXULW4+YwwTBeDtM77uk0djjmXR10AR9n3fMoGa3DtpqP
+M7HpuDnE47/cnKmPM22OmtE4a/83dkRMfbNt1dzW2Tca+tlVlc6+dZrSkTrRMNC02aYkOjnU
+gh5V0C0d5I8Z+TvsIyh55/wIEsL+OJPCOZ9JR1puCFM6EkifzuacOYc5UBQ65zML1Ww9q3MW
+OIIJiM5hEzIwHwCDQYJslA4MVbTa7BRMNweEXsfBmRd07GMb4QAQv/l0cihG4RgP5t0dkkEd
+dcPRjMahE3J0wkTMQjwdYrbDMBbHwmgdbA7fyWEZtQM/7riBY2NcHAHzdEfBiB3pDrWCAeeJ
+/tmA8+sWDHTA0NYRHJnUMLUXCYmdOkjOVEEapgLSMXaoj6NVrFAnx8BYIBOjd2xMN0cLWRkl
+ZGd0UI2jgKoYBVTpSKFaRgrVOyLIgZFIPgwruTG05MkQkC+DSu4MIrVwAKkNU0jNmJRrzowY
+MWLEiBEjRowYMWLEiBEjRowYMWLEiBEjRowYMWLEiBEjRowYMWLEiBEjRowYMeLfiy6XK/e5
+ALvPJeXtr8WHL/f3htY1nk6n+3/ym939lQdU3rvfgLlBwL37DZhGTiiclfn6+nKECua0ZpM4
+XreCnaLYmNiphCDnFKJ8fv3ydE6nAvrKHJd79To5p8L5+sr7pwqCGcSpvmmzdL6+fBOCmS2f
+JzmVN9XiTsjD14nKurkDRy+n6i5uBWODAuiQTM1d9k9xKh75pnGg5yVWTxZKp2CmKPyc4kFS
+0c/R65VO+ZtHU8bPz2CGUgd6YOL2789b7O9UOPBzJpd/f86xvWV34KdMpowZgp3Q0qHSOX4W
+kKez/nCMnE9TQruDFcF0Z2Ln057QiXM+P1OowgHLDXP00NZuuHPMHUtCpRMVdUMn5AzkzJDK
+WTsIfG4dVNZVToCd5enaQLtZneW3z51lR+qXD+YsARaCzvmIHQxydYiGCzlT5QDQliMwwjk6
+8TZ1B8K2+3Z1siHic/FCYydbzu7kT72f0OYMdQ4SZZ7NnLgFTTtUwikmv9kO6sc4wdlJJ1jF
+bt3L2SA4HcdH9eX9kha4n1NCybt+TqZlr3s72PO23R3sYcHuDvJ3RfwdOIbTHhrOD3Z6PZR2
+OM2hn+a8SQdVOvB+ugrCmF6OjHm9ghuODRrOz3akUC/nbRqul/NqHaRap+1vsxjysR936xwA
+asKYE9I6wDF+G6eEGjm26xEsTga1cvKEWjGWhExODjVzQjdHeZ2xkckSaunoILOjTIj+lamD
+E925bFIhj4F0J80JhDnUUjkSBQFrnOwU//Ua8PZTfduAMNctiG4yO1sm1yjuqLOz/e7XPOA+
+MjtrFA7cdoohAXZySHQ6wcXB+sjuHG5RQtdKCHZKaCmGHg7bR3rmBvVyCmgeJYwQ6kAJXTs6
+V6rtFM6Bdug+8svH3QE3IK4WJM76iy4O1jtkLQicfaSkGKbmxO12W8f1yihUbQsdZv2bg9aC
+zBEyRM15Oo9pSo0jTufRds2dOeyOinlyPijknI+7g9W2c7Oh8znWmbQO3HSckxwiSKCrzdH2
+zyNe2tEzvRzFGeYKR3XBVZ3TKx/AQaCa7rkqCuHJzmWPds4lCwdnee/RpYhCktLCDgVEMrkD
+lRzTbLcPXDgFcmTfaMQLcAYgiUcEvZNCQB14OQllcORMJOmcRzNbHIiBnGB1LjgDQWGDtM4t
+EIVy1P2zQbItqCadWbo7RW5U/5icS7g8GJkz2Z09Mda5I85OAW29U8kwTlW1mZxKptiWEKeW
+6eRwm6oP89hUOziPTVXiVDKP6OWQI8JwahwXppcjqDcHpdh5N+qefg7VP57l9gJO+JmOD2Ny
+LL7BMSWqd2z9xjnU8maGdbLF+fX/vS0UymCcYnkGeQTAlA7NtHGA5SUOBGkdGhI5xXogxsvh
+GBp6ZQdhKCeI6i1dC8bg0PK2zsEZzCE+gTvUR57r0AzikB9BlD/eDrjD/XOP5s6fP12cP39Y
+CHRoptwVdnEixtsJ7+WwTDasGx0B8xTnj8ERNlt1PlIndMongPkQy9vKLd0fGpwgZJIdlcUB
+J+EEFCJIxKjvJniaQy1c4cRDYU+HXLbWkS5b40jHwgAc/WihPo44fpjzMZzh9HM+hjMc6rvt
+4byA8zGc4fRzcmY4Ts73Gm2d728XqGAy5zuJZs73txNEOTlSA5XOCkFKAwdmzJDaMULPdlDG
+BgHMyzgW6A2d6EId2eOLbM6+buj5FSYHgvZVQw9chhiTs606foSFIB1twy3rnmDG29mx7G0v
+h2HIOwqMDnhzVhtHxNQ7xbvMHSy2MhDfara//WQHYYjn5TCOeCpCZ8M70pmVhaHnifBgXe8U
+koGROYKZvMmBFqQZ9G8JqB06OKaXI+weMdPLwRbwcVjmvRwrY3XwJVwcPp23cgSMg8Pt3ihG
+4YiY6nSmqYsjZSqdqdIxpdOu2aZKxz2dn+Y8t3si5zxH63zOfZzzmYHqBjfAEWRkd868w0/b
+eOd8FkAVW8/inN0cjAEdBKp2cgaBXshBGcSBIEm5/TAHZ+SOZDjQOyUkcAhG7EhG604OxUid
+aeIhk0NCekbq8PnQjF8+To7pRKXFYTagTg7HKBxyv+DpEGcOWEbloOeReUbnzFYfBwgBI98v
+ODjCHWoNgzne6YDz3gYMdLzQgtEcmPg4xpAylY6YqYQUTg2kYSogHWN2lIwVUjPdHBNkYCyO
+hTFANqabo4WsjBKyMzqoxtFAVY4cqmPEUC0jheodEeTASCAXhqfcGFryZAjJmUElfweUWjCA
+1IgpsKbObjVnRowYMWLEiBEjRowYMWLEiBEjRowYMWLEiBEjRowYMWLEiBEjRowYMWLEiBEj
+RowYwUWfi4i7XBjd5UrvDpfII4SvtK3vdI8QP0HX0QkpAzm+N5iclgjATdsNmJP0qbm1zsp8
+fX35QSVz2pnIcbtzKnbC5vy6hatziiN1FqmBc1qYr1+R43IP3amPcyqcr9JxuPewcGYm6R8H
+J2d2Jyq4Gohz4g2o3ikYzKm8CbVknB202VYo5OHqPF6EHRtEOUg4OhRTdRe3hqm5K13FODks
+U3E7/66Aj40pHo9T7UCPwYGek1TlgI/biV/Z3zI6Ye4W6PFB84+fc5ghpIGS1+7/+cyhCgd8
+6tLy788cMjvIs53mn46fMWRICKqpgjkeI+fTlJDEOYKODqKdCWBsCS0rPGmczybOEXLU0OrA
+0Op8ftYmtDnoRgo7Rgh2JswxJ7SPoWlRuzsBOMQmnBnSO1sRF0w+GjRwtsHNo90+8rUmTghI
+Qup8SGcJdweF4A3I6EANN7k5ZEJbrbs6RULRpruktIi+TjoQPZQlNXcH7LX1HbMTpnJlYNQ6
+2cqQPNcXvJz414dmW22cqCiqpjxCJy5BJyfqn5ZOwJ3g6oQpRfYfvJ0iiWwS0cLZX9kXcHKK
+o5Wak+ekE2nQG85O1v02SOKgGXk72CTF3UHipzkKaDg/2en1VNrhtIaGY3OeXQjE3/jwc9CZ
+h6+jYKoKQcO8XMEN5zmOFBrOkxwhNByb8z6F0IgpdhltHGDf1Cgf28V+aqc8+G7kFFAjpptj
+gV7ayaFmTtA6RiZLqJ2jTejlnaBrOHpV1Hxe5TAIddigqgTOId5PIZNzvUWigJ6L81jJ9bok
+huQjh/B8liCKQeEUH5yWPPbAe0nxXUPxsfmT1wSaW68qoTKb0nm0HpiUvLKxXy93kLazOUsc
+bhFETBY653CAoCvaSUbnADpLhfs7EMQ1nsY54A7fSRanhCZ8Q/J1rlwxyJ0D4azV0MWh+8jN
+YWrBy7mPf1TLOTpkF/HM0h58HdQ56w4hclCmKp85rqGHc1+HoNmueMmJnHklAgavbYXzkHBk
+rrkah1p36hB95OjMMZzOjo7BaptzJp2DzrkZZ9I7cNOx+UwqZ44O/fOvODAUahzFFVd1zE9z
+TP2jdu7h4FwuzZ1LEo7OvUdhhBHVzgYRDCABJUe323quhWZyByptrn9CuHBKDsmvjEwYUbD5
+ODkpBNQB5BiYlNI5j+wVzi5pncnmQAwEhQ1SOheCIRxl/8xQ1OZCZzI495ibfLqw0NY9k4W5
+Q3dmFls6t5jWzAhnUyqcNTEKinqyjhE5lmqzOpUMU3HdHWcFcyoZ9nIEN6YYElo4j221i3P5
+ec4l/e6hpYPm41TWUseF6eOEPNo4zGVDnk6n/unlUHXgWta848P8SAe+HZFwDL7BsRRI2myA
+Q32kpZMsblDK+4bBVWW/lz4XxKEZzvl7i/wjuQOtqPwAy8AQ7QAfcHI4poUDLU9DL+3AjLuD
+MCSEMriDMoQT7ojOwRnKyQK8pCtdicEhPoI61EccHfIjCIQsXDwXoc5BF4YdSRNADv0Bo1NC
+t9f+/PnT3HkoNAQ6DAPspHo4G+Pv5MO6zeGZADIv6giYbk54pkMt/+pOqHZkTLqDZ5livyCP
+zk5YHSFjdIQLVzjisWM4JaRnLHfJ9HLE8cOcj+FUOw2Zn+b85DIYjo35cU47qJPzMZzh9HNy
+5uc733M0dr73cGUy5/vbB2Kc728niHS+i2jhlEoFhDqgYofUjhEqnQ+a6ebYoBd2LBDAvI5j
+gN7cET1ViHcYCLjaH2MqHOiBy2g6dgd8rrObs60Zfnw07ugKIX2ot+xhWVZnAv+GUwNnMjmq
+kcfASJxiRTWOZldHM1ZHyzCOfCrCMJyDQOV6GIZ1QAhYTy0DSdCKHJzAK4EYCOSO4MiESUfq
+bBS8FjYdhUNHJ8fEVDjY+84O+r6TwzG+DrHAezlG5lUdtgpcHWoJD4bbRD0cbidKMmInnhI0
+dMRMXbNN3Zy67pGnw++tfZy6MnB3HKutzjnPIXGo34hzzmc5VOGcGcdr1DlrID2zOuc+zvks
+gGqa7QNg2IS8HC4hA/MBMQhU0z1PdkCokyMpa5SRO6JxR+2UkMTBGbEjGkfrHdF+gWCEzvRK
+DsWgTgq9kkMyfg7NvJ3DMO/mcIzJMTAWx9BqUmd7frw1HbFDRoXjzMDzqn6ONwPOe3WMxskk
+fwY4zmrC1F/01MmRMpWQnKlyFEwVpHLskI4xO0rGCqkZm6NnbFAnx8IYIBvTzdFCVkYL2R0V
+VMGooCpHDtUxcqjWEULVjAxyYCSSD8NKbgwjeToE5cxgkj8DU22cgmrGZFZbZ5NaMyvVwxkx
+YsSIESNGjBgxYsSIESNGjBgxYsSIESNGjBgxYsSIESNGjBgxYsSIESNGjBjxr0Tna3sbWj2u
+wMYuKG9xHf7pdLr/R/JM1grlzjyg4p5gV+Z0ihz+YbZWZnVOAbiZugFzEj4EuNpZma+vLzcI
+YE474+ZA6aTOr1+/HCCIWbahr4fz6xHVEOf8ihyXW85OufMVO9UJIc5pYVLH4V69U1uHSyft
+n/p7HLF0knqrd3Jmd6INtQbC0gnhyY4NwqqgjzO/BjN1NyNDDhpeDsN4ORxTc1c6zyTPX6l3
+KKQCCgmEPDcVenKN1YnXBzAhfH6Gz9DSmV/4nCMYIaoPYmZ1dsjooM/0efx8PH5uYYLwjo6Y
+4zF2VsjdyZg7pE4IcCAmd9QJlb0zQUzqfHo7E+poIaDcJsD5/KxMiK7rtdgAxwEii9oxobYO
+NLotTsnoocyJi3oeyuB8KhMKYuezxgmAQzZce6eq3UIOPf7Xp+A+8tWW4e4ooEnbP09wsEq4
+Qdv615mCq7NvuseNMTs4lIxEx4WZoWCeI8xrhlpte/Fz/W+1kzHYO9ubPg4lNnKAMbaVk+ye
+1n94OCCz1oZhNo+vH3bivHycKWeKB0j7tNtUMPk0wseBJvjpbKWFk7y0LuHjlNPUVPF7yGHu
+5OHlhEc1uECcs6f1cxzkobf+Dho/zZFDw3mK89OefjucxtBwXtsBIfLgx8/B5x2uDjG/8c0H
+PTfi7ahiOMNRQMMZjo8jg4Zju9jP4hguXtQz3RzTZawWxwJ1ckxMATVzQjcngdo52oTsji4h
+sxNUDvtL4zNgP4eZz2ugCibtIZNzvQd7FKRwkDWszp4Y7IghypkDZ7I3Kp0r0UvyhPKPTaVz
+xTvJ5kQnqa9ZoE78k945lBDcduIxDmiGwz1ySHT8raqDwwGAZIf5FieH8E6yOQfYmfvIDqEM
+APGNZ0inn3MoGbaLPBxJLRi6p3TmYvB3yoq7J9XHYWrBy5mYYmCd5dfkHbqPOGcSOmwtsO3W
+ywkdndsq2O3nSu3HZc5V5pClLXDmtUjS8XA2CO2diRrneGdbD5POEvWOLP5pJ5gd3WUP29uT
+0kGHbc6Z9I4CsrfbI17ZMTA/zFFcN1TjaK5PqnBU10HV5WPpHzXzCAfncgtnZ8pGt0sSnk40
+ul3wqG+3HSKYUgIrji63pYto5pIzEMQ5DAFADZ0CauWkENA9uDP/VkImpdo6F9IBoLBCSudC
+Mbij6Z4YghlX57Iwsoqz9s8S8xnI+39pZ+ueG2RgFmj+B+ss50RNTgRS0JLO4/+3dyxVkAf9
+paCfQ1eCG9PXQb/ScGKATRV2ahmhU8dcoCGhhfOIV3C8im128K/QfJ3QxbmkXzm1dOKUWrZb
+iL5HbFNue8+At229oTNRe27PMiAc13LjHR+mp4OMB/4OfPfeCzj6XyDeeEAHZXRUWgZBkk68
+vJopxzcJI3Uiprg/GVlRMDhB72TtLIFCyoicnGGcv3//BogpHEZhnL9/U2g/P0I6AENDqRPf
+0tnaWf9NOSBDQoWz/Zsqgz4OorDOvqDIQRnaiRckHEE6lJMuCM97pekQEPEZxKEY1IGWLbef
+agdclnZIBoNgxt2BF61yuJ0UED4Oy7yX83jtj97hfz2A0Ts8Uw7rf17XETDdnMA72IlLZwc9
+Qbp9WuTkexCm2fwcaBlof7p9WsaIdiHQ/nT9sJSR7aowRxEq58PuSMdCJ0e27Ds48o26m/NR
+5ci3gkpHHD/M+RjOcPo5H8MZDv6V83BewvkYznD6OR//mvO9RUvnOw5HJnO+v52gwkmg7zxa
+OAVSA+EOyJgh1EEYbwdjrJDesUHPcz44xwR1cgCGdwzQazt66IlOeCEHgqibNdFmMziU2MKB
+HsLh78CPdXZ3Jq2jLDjs4eHOzrzyCUuHclQj6ZSEiKl3CoZ2NLvuZzglwziaKQ/JkGWAQ9Ca
+SIZ1QAhcU9CmQx4voAo6EIidIGPqnZhCFeqx+HJnoQiFTEfjcEExjg6lwIw1H+JJP54OFW/n
+MM8Sert8LMxPc9yZ93DIgUbACB1y2JQ4MiZ2OK4+HZFTmc56LMU2X70TmjtJq72GAzORc56D
+cKYg2Iw453zmIFE6nHOmnVWrzucshCrzOXs5CPNRMgREzkEFzlnlUIzKYSCzkzM4ZG62JzsY
+1MvhIJR5QWfby3k6JTQJHJwRO6LxutrZ164/XFQ4U+poDrI1TrbXdnUiKFk37pCM2AF/aOCw
++dCMwJmSvVt7h95OGUbjrNM3C6N1sDMHro5pwBE7O1XByMdrKl7M0exQjQzmeKcDznsbMNDx
+gpLROcIDEytTf3ZHxlRDUqabUwfJmSpHwdRAKsYOKRmro2WsUCdHz5ggC9PN0UM2ppujhqyO
+EjIzSqjC0UA1jAKqY7o5UqmakUEOjETyYXjJzaEpT4agvBmMauFAVCOnoNo5CdWUiaDGziY1
+dz46MbPUxRkxYsSIESNGjBgxYsSIESNGjBgxYsSIESNGjBgxYsSIESNGjBgxYsSIESNGjHCK
+zlfCtrNaXxgNr98Zitd4ukcoHyDkq8zMCbjHuaHjCwHMDQLuQX5DZ2VOm/L15QSB6azM1z38
+nSKdhPG70Sh2wu78ukU1BDHLpro0269fG9TGeTBfv365QAhzWpnU8biFLnO+GjknkVN97+Hp
+Oc7WPUm92SE0nc2JN1R3J+BO3T21z3EeL2GOBYKdEDsF4+aUa66GIIdlDND+UUaZ0L/nrnQC
+mUn0HJbJAgnaKE7Ew8EfHPN47XMOI4S2S86szifwp6+lzpQGyBxX59OUkMgJx+PO2CDemZnY
+WSG1Qz5Pf2YSxwCxzjQdS+fTwwGZwpksDlrWS+fkjEtCkJMz+h4iE5rg3rEkFEpIkI7dAf8U
+we2fmKOFSickTrGReiUUhM6nsrSTXs83nqmRE9o5H4wT3J3ilM4CU46x4UIGhYAnZHew59bF
+zo4ahzgwoRJq6kTQ8bhMSYJ13wA23CrvTnBxig11fSViNsfcbnlC0Ui0tNyGhjoHbLS9j8Lq
+BIODQuRDe82TK3ql2EveDlaJrg64D/RzksecxhOI//77z3LYoHUmb2cqnOUnXyd+7HHUP3cn
+uDphSyAug7QmnJwpz6aYGHk40Hw4L3EXB5gP51uSjwNOvFs4cGPF0cABJU8n9HKIZ3r7OngM
+pzE0nOc4Umg4wxmOq4Pv1SocANI59oR0zBt00L/tCKHhDMfHkUHDMTkOzLs7xf6pVT4GR7O6
+GohAiN23iwOca+EgWz6sUkB1/SN3eMjqhG6OquHMTJZQtYNXg6dDlp0GYhXpNlSTDrMR1TvX
+e1DjmxainJv00PC0vJwtLSSvSQwJnKt02BYz0YdSB2NMzrQ3w+FwuKbB/Vl5Bsp/u2lGbpE2
+HdV2FmdjcsjVCRFzyLpouro6hz2ueVRAlBMKh206sXM4EAnxfeTiSE7GmJyitPke8nCuE18L
+QudAOpKiszhlZZNjnafDlgLnTGKHbjo3h+kjxpmEDlsLXnXw2k6+lMyhak7i3FYhccjaFjjX
+3AHHA2Y45Z15LZJmI7tI6Fx5h64FqXOVMfXOlewdR+e2jrvSwrlXEL3aLPCac3UmfD5Ht9uk
+S2cet039o3PmGI7J6dM/msuTKhzVZVBV6cCQe/cgW2qDcgMrgXDAUedyi5bOJQ8/J5AORQo7
+KH5bwOSQ+Hq4dIELgzg5LFJA8Cbk4uQQcJoWdeZfSsZkENBslDMpnIRSOUHrXEgHgPTdk0Ig
+4+lcCAZ11P2zOAE7QYt2j96Zt+nHR2//aejMcfvs/F8SWpRHvZmY3eOdZYOuYvJuciu3EqIS
+cmOYSvB18Ivz+zs1RnT/BOdU5XLfVGVOFXN5bKoh/eoEdOqYOaibGpxqYHeQdvN34Jtb3J3Q
+w4m/DmvqxF3UygnZptrGie+owp36bOYRIb6kpE2zPZypvXPZth/CcWEu2fU+b+9kUDMnu4Or
+dHyYdUcHOGQ62lyX7RS6bZhYVdhC5wTcoRmpEzNiJwQtFCtI/9CK3JnQeoPXEwxOSByw3ThG
+AoXUAfNhGdr5+3craY0DMCT09xbhSU7IHGAlICN0gtyBGQqKGNoRpEM70YdkDobQTvKxds4l
+c6C74dNVEAzlFMuWdS13UKhcEth+kjWQDObATAeHrwPagSGYIR2GkTnI/K3KgRfbGaMj2H1k
+kTriz9md+OP8xwQMctF3hYMwrMMzgt0H7wiYBHq2k/xoddg9SDcn/SLI7PC7kKSHSkfI8Ns0
+4QBfDdgd+HyieP0KB2AMd3uIB4+3cmTL1jiaraDa0TKmu37EW0GlI44f5nwMZzjIufjh/GvO
+x3Be2fkYznD6OR//nvP9iMbO9x6eTO58J9HK+f7u4eRKDYQ7gFIBoQ7MmKHCWSHMMUKYgzJG
+6IUdE/TKjgXq5JSMxNFDRkcNvaND3Yfs6EzZGXEXp4SSb5METJWjSMfokOn4Ocl32CWHO8oN
+NXKgtBo4YOt5OSszwdUNMewEgXCwYjA7SLOZHAIq10QyVPeYHYBhHAyC1lTlwBC0IvKx67yj
+nGFr0qGPS+gdnCad8nhOquDPmpI5O0Ur+COtxI4sejlodHJAZjjDaePATC+napXinek/6mB7
+TvFcR8GADvBaA0febCKmV7PhDvBai+6BopMDM5FzngN1wNf1zrmPcz7TEPRqnQNC8ngN53yW
+QkzZIcwHwLRzzmcF9PpOzlRAGIM4ZuiHOSjzbIeH5MfZ/g7O2B1dOq4OwUgc6T6bYgSOeG5g
+cjZIPAchmZdxqJNfCsbNYRjOIU/m+TvVjKzd6hmn8aCTwzN6RzlOx45qIiKfUtc5tnTA+WgD
+BprH+xdb5NgPGERM/ckqGdPNqYWkTKUjZuogBdPNqYBUjB1SMlZHy1ihTo6esUGdHAvTzdFD
+NkYPWR0lZGaUUIWjgWqYbo4cqmPEUC0jhOoZGeXjsJQbw1CuDk55M5jVxAGoVk4utXMSqSUT
+Q22dj17OJv0YZ5Y6MCNGjBgxYsSIESNGjBgxYsSIESNGjBgxYsSIESNGjBgxYsSIESNGjBgx
+YsSIMvpeN+pvIdcP+1I04ialazzdo3w4XhPmBNz37sskjisEMaDjej9GJ+e0OuCd1f7Opnzd
+wt+JmWlldsftBiA6nXbOks6vW9RCELOU3Or8+uUAEc7XHL9+RZCHc0qdL8ixQmg67RyEyZzq
+WwJPQqf2HkfUCSnj64TdiTfUeidncMcCodsO5VTdu/sMZ34FZQxQAKD9pcIA/jyw2nlYwO++
+EsljUiodgonCAGUrIZXPW0B/+Frs5L8rpITwOYcNyhmIml87fn7uksnJodK5KTtzh9QJCZzb
+K8dj5qghiROOmWNoOd6Zs0kdPSRwAGbtIqUTCAdMRw8BjohZWq4mIa4IvBJK0/F1MOixhWKO
+quFCCckcY0LgXwi4/xNjrA70sC/S+bQ1HHTkK3CMUMpME+V8ujoZFP/b3nBB4ByNTgyFHAoz
+lDjbj6axFEpoidT5vTvWfLDHzUZQ5IQXdfiGi6B798xzrFDhAJUwpdCDqXdKZpGPMRMejJ8T
+N+MMHZefPrdcXZz4h0fTAb9GvZN11vGYvW2bxVEO9VxvXweQGjnx7um///5r4RSzlP/ukJ8z
+lc788t35b3272tmgLJtpcnYWKG+1Fs5UptPAgY8kZsdwzgJ3oAnx/Z8R4/OUQ8RJNlwPB5h5
+FxNXHyfFth+jNx0d+g+BtXCgNx0d8tnBns7DQl53dxDI28Hipzmv9rjY4QxnOHZoOF4Ouuus
+ckqol4P/0UlnRxm9nJcvuOF0Ybo5Img4w3Fi2jn6iyRtjP5qTM3a8LcMznJkTR1ih2KXa0gH
+OknFQqZmEyghKwVr9whmIrqE2NUJoeHkK8N7StFBvEI58oQEDvW2l8PUtzwhZAXXR3C/RNp5
+dmfV0MYTO9gvek0gvJOkDYc5h0PkSEdtvXM4pBDfU3JnWsv0MEfWdnVQ3ALToxUOWySO6IhV
+026wIzsyVjg7kzbcJOojsXPAHFkfmZxD7vAtJ3USpkhI0EUejqQUfBy+h0xO1kGTpBREzoF0
+RDVncorK7uawtcA4yQiKO/zwQzvLxyUO03ZMswkdvpMk3fOPOnQpWBw4G7rmeOe2ConD1Lab
+c6Vrm3Ue65A4dC3InGtzZ/28kLE5UzSjbuhMsXOVMHjJkc02ZUciXDJEbcvKQBiPcbuDs6Td
+yQGhF3G8GH9HcZVNjaO5mqezMxkdZR3cfzM1M0e9c7mHxYGgtd1i5wKHhxPXAcIgmN4JAiaH
+xJfDpQswRuFM66kNnSNgUmhxcoioN7mTZQSdmiPrWspk0uPj4nbTObEE1QEAqbsnhxo7l5xh
+Tiua+md3onWT0MaoncvCyK7EDfFCOufyGDrmj164Dloztjhz3Jw7x3xZt6SjL4Msim8hvMqt
+zIrsIF8Hh7ycpeXQrxocnQxq4jwqu7kDfkfdIJ376otKQBy78oDCmhDjVDH3KKBGTvH1/lOd
+aiaCGjuPHoqG05ZOQBy/7ll2dFNrpxwS2jRbxDR1LlN+5UqrMsg3IMDxYJ7gTIjjwhQJPcHh
+mk31WwT8gUO0o+y8tXZRh/6YFAomJwSrg7cbw8ic3cDqgGNkUKSInaB3gsHJGYGTMjKnYAQQ
+7YArARgWCnoHZDwcSTr+DswwzrIQuv8pV4EwDLQuJM0HVWgnWRBw8jUQDOXkizZyAKbCYfZR
+2YMFSIdk2J3UNOUTuDZOedM6Um4081wnXiBnjA67d2/l5O/nDOJwDDvetnHK93MGdliGHW9F
+Ds+kEPR+xjRz5iGBdCQMvweZtqtpvZwcSK1aB93WtnVzdVDrFPsE2BEy+Nghc6QMt02TdV1+
+A8FD2NsJkzuaYB2I8XeSeAdHsxVUOfLN4KPOCfp0bA4WxDfCTdbf2KG+4PZxpvJfTR1kcHPv
+H2Rw86434s5AXyeJj+EMh/qKdjgBH6t7OR9v6mAxnJd2Pv4553sJdlWqu2UwRSBRd7HkTOZ8
+p9HI+S6CcXCIcEqFgUwOqLDQyzoYIyhvJ8cGFc4H65igV3Ys0Es7BsjmqKGS+TcdLeToTKrh
+2uzkJ/if4gDMizv59y+v5ig3oOL7pMYOAhGObsSmHYjp7qimCHpnf1fBlN/7KhwcIhxDPpgD
+rqrG0c2wdTc6p8clciUQOwbeUR0AVTmKAzpVucHHwTzi44iil4N1EMhUnT9QpDOc/k6vOtCU
+tX+7+TPDsTKAY2fQ/UwDB4TkzSZhXsCRMpUOFJXd4+acH4E68BtSZnfOZxRC86lxAKhJPggk
+ZTjnTDmakDtVEMKszvkZTg1EO+c+zjmPl3cwBnHM0Es4JWN1UMbsaCaihMNBmnn16zuqw4Q6
+B3q5ypHPDSiGdRRTkBpHMdUhGcZxY9wchqEdv3QE+bgwgnrr48iCZfSOeiQgHZxRzHVzR7M/
+7eaYWg2Zv7lXATy/bsBAxyXaSYjOMYeIqXdkTDUkZd7EETN1kIKpcTRMDaRzzJCSsTpaxgp1
+cvRMN8cCWRgL1MmxMXrI6ighM6OEOjkVjAqqcuRQHSOGahkpVO+IJA9Ggvk5pOXL4FYDB5Sa
+OADVysmlds5HJyaBmjofvZyPXs5HL+ejl/PRRxkxYsSIESNGjBgxYsSIESNGjBgxYsSIESNG
+jBgxYsSIESNGjBgxYsSIET8r0uvpWl3GB14B64/RjBfFKz5SvsbTPei/seLGnIB7d32Z2Mmo
+Bun0dvxajnQcSwFmTvCt4u7OznzdwgPC09mYds6EOV43GiHp/Pr1y9U5Re22Kjfn1yOqILh7
+5hFuYb5+/Yog13QIx+POttT5gh0bJEhn7Z9Gzhfm1N7iiKWT1pvNwYstcuLt1Ag92Qm0o4dg
+Z/6ZcOruRd6J1IleW8e9KqeIFEkerWxzyIcmp4gNytdBMp+PMDUd/LtCTAifn3aodCDp/uLx
++JlBtU4B3V+JmDukTUjiPJLJHC0kcBYmdvQtxzsQo4ckTqlsXeTpANk4QWU6gDNDNQ7QbKij
+fC6KIR2TE1AHKjanhNiidkooSYdwdJUQ/e5Qs7GOEcqKjXQ+bU758CjIOSY7CIXzka435G7i
+HBPW6oTCmUBnfcHsZFEmdPvn79+/t5+dnCXBNKHc8XuGUS8nJA33+w7NPwRnJ2TO8Xh/8XMp
+UEdnh2ZnfVnnUNC67a7QzTlmbzo40QixOcf87XonHoiWhI7l+x5O9MNcdMDvUe1kw90dgvL1
+dJYBCFzA14GPI4IKQpyQOvF+8L97qB00oYJZ1vzfHG7O1McJpRM12+Y4dNAEpjOtTnByFihP
+p4UDTL2nKW02pykC4EzuDnAoMS1OtOk6OOUUP99mnRyg+do5EBS928QB3m3hQO/6OZsFvtPL
+kUIyh4jhDKen0+txvsMZznCiQPc0vg6+R3tPRx/DGU5PRwT9MMeDGU4a4vG0zpGP273ajYeM
+681T1TvRXo5qt1qHOFFAQaZ8mAP5dcE6R3IFjCEhclV0qM6+vIETFGetlL818ValQ5WDn8NU
+nbzhBOmQ73o5it/CxFwfcf8vA1U6CzRreONJKwFTDofD7pAlV+Mc7hFiB89b6+yrOhwy5zrR
+nSSAdmb7nQ9rXOPwctYePewRl4Ks6RT9gztVEMEkDScsBalzwBxhF9mc4AdpHEnbyZzDc5xD
+zghazuQkCU2iLpI4OVMUwss7dLOVDl8KtDN/XOQwkJvDNR7dbkJH0Esu/fMzHYoxOfmeYa2F
+Xg4FCRx6fIscqu145/ZpYR1UOdfSwRkcopwprPPpNs7K3Dv2CkAGhnJC5MQQ3j1ExZHdM8XH
+IXw6VGlLyiCF8EabHrVtcrLGp2uAmizoHGLLSRarc4TxsxzFRSkVDHqCDncmqyP+w8+LM5ma
+DZluezuPEEJha7j045clnJ2kfy5wODmBYRBM79xPTF1opYDuHVuWNuMEziicaTmjLnWWJSXO
+pcJZNmsRU0DAaVoiH4VzuSRnAAPQQ3T/iJ1L5uQ39Lg5kSRzgqndImhfAfnVSbJUpUOdJ7U7
+D+iyFnVD5/IYoeaPlns82NHXwR7wd19O5QZLvRwccnFAqIVzj7wW3tnZSxtxgosTVfaPcECo
+hQNVdmsHvBfErax7OSXUpNnmTSjE+9U26dzGg5WhnVomuu+JcqqZ6IoSwqllmHpzY2T15sA8
+w5kQx4MpE2qTTmcn2oIUzab6LaZsAix2lEU/ZSOc1FFuw9sxnc7ZRyStExCHY2TQvjSWD8tI
+nb0QwLrmFBG05wGMO8hKCkYAGRyAYZ21X6Zox804EMNCUf9jjiQdzgm7A41v8nQYiHagFWCM
+s4MypBNWJwgdnKGcdEGBQzDcziOFWjjFkqxDMRgEIC2cQkAdKcM5BdPIKa+kRhyGkeezvuLo
+gOn4O/HbzZzsbanDMdyAK3R4hhlwC8bFARcQOAJGMhL2cgLjiBh87Ihn1q5OkcXOtHWm/ewB
+4QgZfJsuB2vIkTL4Rg0xhSNnBE70YrY/1QQ7GICn4/2czYp+rnGIrTpFWjrZC1UOuhkQ6dhu
+K8F7x9dBgvpC+K2cdQzFGVcn/0K4mYNupW5Ofh6+qUMw7+XsHRS/2MABYzj1zPs40KV8DZxi
+nwMz7+TAkLNTnBl/dweLH+Z8/GvO9xYtne84mFWhIxvAZM73twJChxzO+S6igVMiHIQObZQD
+MyTk6hCQxUEZAurlUA94MDim7bVwPl7HsUAmxwC9tqOGSua1HC308o4ScnSo0c3bkQ+jZqc4
+48owP9TRFnZ5ptrHgdPp5ogO5RJHuQd6fUc3FVE7+7sapsZRTUnJemMc1RTb24HXREJ0GcAS
+ytQ5uYQzxI5B5MQUpTg4wujloHvuTg7IVJ2n6OdAr7o7mu4Zjs2pYDqW2z/r1DDwZmpPB909
++6aDzwO6OVKm0oHiX3POcyAM6Mi7Z3fOZwxq5BQQzvg7EOPtoCdbFfu4zTmfCUgRCAM6NRDj
+nH+Wcz47QRjzATJ2aDhMKE6DUA4HqSa8qwMwjKM6vrI7qsNFf4dgWAdco57hHM3UwO6QZ0BV
+DOmomFrHh3FzGIbtH6d0jOOBmnFyWEbvaAcc2sEZqMt4Rr3/qXIU8xDIETB6B3hN7tTNRzUO
+NY93YBwurhIx9Y6M6ebUQlKm0hEzdY6cUUHFYKBx5FAdo3FqGDlE3dThmlClY4TUTDfHBBkY
+i2NhLNBrO2rIyGghMyNzypuy20CrU8GoWq7KkUN1TDdHCtUyUsrDEXieDGW5OwjVwoGkNk4J
+NXJyqRmTQQ2dj17ORy/no5dzh6YezkefdFaoPTNixIgRI0aMGDFixIgRI0aMGDFixIgRI0aM
+GDFixIgRI0aMGDFixIjW0fOao34XUfW7+qzf9YENTdTx1RjGixIwHpSQaXAx+ekW0A2Nzs7p
+EdA9wq2c/IZkV+eUOk4JYenAj0ls5JRv+jlxs82vfH19NXN25usrdszQsxyo1WLH6z4jLJ1f
+vk5WBV9zhF/3qIJg55Qwi1MFwcxjC9qYpk5Anfo79ZB0HBxROrlTfSdlwkTODEULejkhd7Ko
+dELMUE79LbWn/Z9NnSggZxuQKpx8v4YoJihbASjly1igYh1oK97f/HyEBSp/VeLJjJ+fG+Tg
+YA8SOh4/7RDoFNBD2Zk7FHSQyJmZ1FEmJHBuPx8zRg/xDsgYIcJBmLWL2jsz5OggjBKqdVTP
+KyHLAHVUCUEFR246VQmhI9ycDsxYnGLUT6oNcQwNhzy2H2y2/WdLQuDjy+4/5k78s8kp9twz
+mzjHY1J++k0IitI57uHoBMqZX1UNcnLosf7ft1ghp4TmHtuhlXk4wdEJixNl9HuFXJ1HJNDq
+BLUjgro4AXSCpzNl0HFnbpCXs49EKzQ7y9tKB4Wi8W5zjpsS1pHKwdn/vRTd0mKuTjquzhC0
+RLWT/PRwwN/E05kHuoLxbrdp3oVHb/73XwNn3tcet/r7bw4nZ2u4bJby3xbKAyGFE1InuDgr
+5OUwG2oxuXN3HlA5Wc0dnzkP7kxuDnQscfuPv1MeSzz+kzI+U4Si7RZncnYgKnuos5cD5ZSM
+5g2d5P0GDvi+lxNZP8bZrD5Ol3yw+GlOr8ffDmc4w/nBDv6Nk6eD7s+881FD5nZr0nDKdQ7n
+ZzoOjAgiPy+t8HdxpNGJeRfH7U/AeDk8RDtSptKRh9pJdnLEwWJ21KXPhzyENzvg5yOEvgpG
+DqEOuvp4yRpHEd2cCGrpBE+H6it5QhKmg8OUntiRpCN9t657uF+jzjkcwvX2/0K4XgO1e6h0
+Doc7tAY5ykX/VjuHwsGYJJTOYYnIETEUtOe/rutwKJzro5N8nZ2JGs7RWaAD4si6SNw/hyRS
+pwqSOwLF6sQNJ+wimXOgHBHk4UjaTuQc8siYCoh2gppBnHQZ0rlOoi6qd2SlQDuT0LFCKyN1
+BF1EOxPEFI6kFuh2g50D4HBtx9cB7zxqjoFcHEE1vKHTp92YkvNyuIM93gEgxKFazsvh+ohg
+gDkV66AQ59w/28spIN92C5uTQeV+YQmi4pgyWNcgSoc6kyF0rlIHazmpE0l470z4ZEHuXANb
+bPNiBqdcA6d4OLLo5CCH4bgzWRz0LB3hTHqHOKnp6sxHkuCmivePybmHtBCQOrisYYKEzgUO
+bwdhYEzfbvdzUyQBQfMVi1JnrU4Bc0mV+Tx6DhHOJHUuuQNsRGi7KRggowKi+0fqXC5BD5kc
+sO1IJ0TtJmdiKOlgxpkX0zi7tK2AhKqdab9ymnf07bZAlwvytReSj7IMVuiCOjlkK7c4ZAnV
+O7HU1pFALs4FaroWzmW7oL21E2gnuDjx3RRtnXV/18Npn88KJcN2C2eWQvKlYDsnvamhuQPc
+q+PGRO3W3HmshHeqmM0JnFPH7E6gHS+Ga7d6J9+AIKdSWSWufxyY2JkQx4MpE2qTzlOcCXR8
+mGLk0Tia38PuqJp1qzPMYRQptA8EOifonaB3QhICJt5jy50QtFA8suXbD7aOXBFAUf+X46jC
+4aTYKcZRDUM7IdpuynEH/jzMiJwAOvDnEYZ0wus6GOPsoAw72sa7hXQ7BT6PM4QTkjQkDsGw
+o3oxs8IdimGH23wYzRxpOogDLMg6JMMP6/lEvpET7bYD6dAM5+zHpx2cSDE7zP6wqQMx3k76
+ptzhGHogFDssQ2/SUkfAcE6IxlAvp3gvG6sxR8JIaiZiGjpJOu0cvg5kDF6cE1BuT3SkjMTZ
+XywcMYM5kFLMDzTBpgMxL+wgW0F3J36xysHKk0rHdl8JORY4Olj0coj7c7yVHg466LybAw7V
+bR2E8XbiV9/X4QY3dyd5sYED3ZX40cThLkdqxry5wzD1TnTiVXppiNHJv2P8EQ49Gvg6yesN
+nOSMdSsHucf2w92B42Wc7y08mdz5TqKZ861y4Apgne8yOAeFcAdQGKjchQocmCEhV4eAypkH
+76AMB63/aOws//DIB4cM/UM5KOTtGMaFwvl4JUcPvbijhUrmxRwl9JaOZjdX4RCjgbcj3itU
+OKq9j90Bjq9fyVFvqI0cmEEciOEnIpQDQ3anWJXd0U0R7O2mm/I0caB1aZ3obQ1DjgeMA0Pw
+qqoc1ZGJtdxACVUCMV5LnESilGpnw2hl3s+JTh0Qjij6ObJTIQ6OmBlOf0d4RszBAV/t5Lxx
+s4HQU/OpYZ7r+DPOgzU+i3Z1qJN5UkaajwIyO9Thh8U5P6LWgZnIOZ9hCJ/eKgaD3TmfEYhw
+LPnQDrTGBg7MVDolBDLujioQZnPOZx/oRZzz2QminbOXgzGIY4Z+mIMyZkczEd2cgmEh1Viw
+OgDzIo5mHlrhIEO43fHYk/KOzx6OdVzmOULHi3FzGMa6/TzL4RjM8U7HyWEZvaPfRDcHgAgG
+cHhGPT+oc4KUAZtNwIDzN4Kpdu4StX4iJIzHxVWdHBFT78iYakfI1EJippujgYrBQMEonHIH
+q3HkUB0jhyqZl3Py0DpGSM10c0yQgbE4FsYCvbajhoyM+oR5U2eHzIyu5SqYbo4CqmIUUKUj
+hmodoVTPyExnB6X8HVhq4UBSG6eEGjk51IrJoXbORy/no5fzgPIH6rRyeuSzS42ZBWqujBgx
+YsSIESNGjBgxYsSIESNGjBgxYsSIESNGjBgxYsSIESPePTpdYdDziomOl4C0hvo7P+Kio6dc
+rdXt8rNu19O1kkqmDYc7rhjDuFkSx4ESMrWQmGlwkffpdAJvbfZnTifwAcr+znpvdXbLlKez
+prM+U9+l5TjHq4ue55xOcf+E8HWPVk7G7I7f7TIv4njdZ5R1z1fh2CAinWlTEsbHSdPZnV+/
+flVBsHNKmdmpgZDuOYWoBlo4MJO1m8MNjjETOQ/I0wkRkzppVDtxEI7rHbWgs2y/rZ1toLA7
+xXPLSmfan0VsdKYpWkfugAuZnGkCoDKZz3sEAwQ5SUZJ/38uoe8iiAEnBrcXj8fPWmhioPsr
+EbNC1c5UMMcj4KifTkA703TMGD0kcGbmMwtly/EOzNwhTUKsAzVaBHk5E+UoIK6ucUbXchIH
+RLQtBzlB6HxWJtTOgQds3lFXAvQ0/fmVzEnKQl8JAXpKyOOV1DkeU0juRPvufJwuneMW5oYD
+gnJmSjX4kFCy45nX//t3BlU7+Q5uYe7h62RQ5CyQYTAlnFXKnLBUnIPzqMENKh2vfOZIMrLn
+o4E+dyf4OwF3PDsohto426BXOL+DoxONrGsXHRNINUnAoXhkXaB7ewVnZ8qdGzT/MDPrYWS1
+k/z0gNYffq+/ibezzLDgjP2caZkxbi/89whnZ50qHI/TRng6U+5MoYUTUmcqnf90z+XBnAXK
+JnctnAlwgr/zgIpJsdmhEgJih7TPTaISAiJPx2cPhCekft4U5QDU0kWTt5NT4QFFTCNnq8Lm
+ToJ4OsxJLT8nYMS7OrvV3EHTUR8NsxD2jq+Dx3CGM5zhDCcOfPz/VxwZVH5My1gddTg4otxe
+yZGs51UcAcSsQFh6tY50S3qXfKTxMg79cfFA18thoWc56qHa6kz5GUtZTvp229ZMHpOGrFEr
+HeSvWekh0Il/QpVsSbWjiF5OEJ/kka1N4tCQ5FcmSsHZod51cpjN1M1hBiJpwyEfPxwO/G9Q
+7xwOG3S9BumwrXYOs3NdQzqvVzqHzBEfP6iYwxZRPiKGgLYltlXtTNRwVzdnLd8D7Aghcbsd
+MKdyr0o6h4TxdFLGsbKlTm0PkcxznGtNB9HOIWFkfSRwCsavslWOqI+qHWkxUM7cJM9zDs5O
+EDqSWmD7B2AOBcNDJifkEN96Ho6km97Q6dJu80Fec4c+ZJU4EAQ76v5Z3gLmOkT/THQX4c7a
+DPJ6oyAqn07Oo+FuH1U4pv4JD+YWhYMoVM1JnAKiGJOzrkLsoNuqzLkKmIeE9pDQSSTUueKT
+ErGzSzjj48ybEqEsS+mcacodUQTkMJxwJj1DlBzlqCHilCbaPwbmSmysVB0YHHTwkTqXPUyQ
+rK4vSIASWHKs8/hfzAEx8PQcWW/3IAkAWi640zoCJoEUV8OFBRIzMTQhENk/YscEWRxQop0Q
+tZucYTNCu+e+mMJJofJMupuzS9sKyISM7bY7YdI4yjLYoMtlmkQ9VOFccqaVMwcCuTurlH+r
+4u9cdgf9qsHRIa+UdnEu8/oJJ3g66a6ogbPn0dxZmebtNvVycqhBuYFQg3Se4OxQi2bbnGhT
+beoE1qli5O1Wx0QjQujlBMqpZKJ22wJyahmoEACnnolaDnc8mGTfMGWOYzoCx4WpdcS/RrGl
+ahxFvtsIt1Zc7jCKFEraTeXoBotk5FE46catdKD+kTC8lExBModYQcFwUHltlCQdgJE4yAEQ
+9nFIYTczvQMzpBMipxhHkY8jjMSZF2znBIODMc4OyjDj09TJiaB8vAY+jivcOJjk08IJ28rT
+YZRyKIYZBzlHzMgHKLAO3Jxi4os6NAM6CbM5oY8TejjAcXD2aYahHer4tN5J03FyyBGKOn9Q
+5WTvyR2WoTa1+HCbdniGqs3yqB5xJAzexvEu4Sc4yXNgKEfEsEUzsf2jdCAiZGUAOUIGd6Y9
+CEfKoA7ElI6Y4Z34xdyRM5gDZVMc/qiCa7amDtg77+GA5ckwJgeqz4n5YtPklLHv4Vo7iVcw
+Xs6i9HHQQcfVIQY31zogGXcneq2BQ4/Vb+eAg05LJ3m1k/PRzklebOBsUnMnTMUlVm2ckDsf
+jRxyNPBw9oMEotk88tn2pK0dYGbQot0Eo4GDI2McnfTlNk4o7lKWON9KCHqVdb63kDoSJne+
+kxBKeuf72wminBxp4wBKBYQ6MMNBYA1QDsaQ0LZ1lqWtdxgo8aocAurkTLuTv2VxUAjIo8rB
+IJzxdZAhFHQ+JA6aEMZYHfW40MkpGaGjhIZjg1wdfOvxdhSbqd3RjG4VdQDMQV/IUQ8I0Jz6
+lRztnoFyIMboTMUdBC4Oko7FUU6tWjjgypRlEE3kVYxucvDBHTDgDDG+cY7yyARzWAaACKbG
+ySRKqXQiilbqHWkYy9rg9MpHduqg2pGdCXFwwJff1kHin3BqVtip3F7RqWOe6fgXW6d0ujlg
+2KsNPzh0dYiDQ5NzvgfINHBKSenATOScYYeYrCsGHcDJoOc7mkEUclKISMfknHEHZlTNxjto
+qNIBHSEEBuecn+HYIYxZnfPZB/phDsp8wMybOwXDOrqNdHFKhnMUE6oXcpRDNcVgzjnQex5H
+h9qRqhnGgRkwaIZuNwVjdDSChPFyOObNHJaxjm9ODr5GsNh5BtkvtHLk0xDIETDqeWK1I41e
+ThkSxsERMfWOjKl2hEw3pxISMyqHvQTRB+IvdfSB2Cs3/ZyKdORQXTqqhKoca213ctRMN8cE
+GRiLY2EsUCfHxgjPL0cbajsnvX7C6vAQdQvECzqqUqhgVFBjp74KZJAPs0mo6uaArHP3KCR/
+B5ZaOBDUxCmhNkwJtXJyqJmzQlNrZ4bWvU9rp3mzpVBTZ5caMzPVARkxYsSIESNGjBgxYsSI
+ESNGjBgxYsSIESNGjBgxYsSIESNeJTp9I9/pEoNO1zL0ujaj07Uz2VU6nZhuTrerqFpBhdPr
+8rN+19M1sRDH2yIYV4pxvDAJ40FJndaX9jpJGqflxeROELy6UwjxX95q6Gxrz26ydnVOp2jl
+KdTOyaKZ83WPJs5pdqadqYde17FBsBN6OKfVmXYmdrzum4qdL8jxuQ/stHZPnE6tI00ndVzu
+07sxoUingXOPIp3M8bqRskgndzxuDN3v+nqqs7xXzTDO+mZVPtMeiLO/a3SmNELqFEspIYzJ
+nH2Zz1sYukjmrIscP+cI6oRQZ4OiBY6rY4cKJp+F3F7YmVtoIaFzVwBH/dAAxpkyRZ+QxJkA
+5g5pEhI4MLNAfg7G6CCyrKFCM7Yc50zxZlOfEJHOhDIqqN7RPBaFKDbKUSSUddDS9Um1ZeuO
+y0/dcOAz7ufXjoUSQ8qGC9DDOwDnaHaoQ/sHDTqrpG84xAnJZnpMwzEhwPm9xOw4JZQ4x8w5
+mgY5HmrnhIdzxJ0HJHTIhEIENXRW6LFS0JG3G+ukUJmP3zOZIEdd2FJo6aM2zjro7VATZxtd
+t5Em6qDg5kRD+F4LW0JqB4XiPcXm3P6dObUJTZATVieEz3WRWif+YdkZzD/clehXcXTmienq
+7K/6Oo89+Oz87/HCf0v4OtPuHP93/C8K3aMEMCc+W36D/ndn/vc/dyekzv/+92BaOFOazyP8
+222BtglxOyebes/OsXR8Jot73DuojQMcVE6hYHx2qb2cXNqGA/VzrTgnlcIC6b+B4p0cCul3
+d22chGvspO/6Ofnp0yzez4moLg78lqtDPLPa18FjOMMZznCGEwc+Lns7U/pjOyc9OO2UD8to
+T2Pbw8ERVYUH08eR/UG1ekYY9c3m5HBMH6dXPgvWx/EobNbAJ+8qSML0cYSloHTKlQoTUjvZ
+Pk7acNp2m6bsjGW7/skddN3JO3onTY/KRn6ygnO436KPEzwdsumkkEQRloKD0yUf6Z9ctTCH
+w0G2ciGEMwZI7Rwi53pt5hw253pjrleHMW5bZF/PYYsH4uvs6zlAjgQhoSKfA+BcxX0k7p9D
+H+eAObU9RDqH1KnZe5PMnlB1xQmd6h6SO0JI4uRM3EFtHbeK6+ssa+AcUdPxTsmkhSDsI4tz
+8HVCLydgTtpwoll9vSM7evDJh289B0fUTY4OCb1dPkwxODls0eEMOrwdig11ZZo7/C6caDaN
+87CoUuC6R+GQJcc4V9FAWu3cP6twQkCP8ngHSgjsHrLmeAfKyNlZVyFsN6q4RU4OYWVAbEMy
+J5Uwhpr9oM79V0tWElhmXkwOLc5UzJ94Bd+C0HbL85HEo4PgThL2j5TRXPxidihI51wuQsrs
+XPZo6FzyQJObz9WXEFXXy+kigMnJOOCzgKRzD9Iopbmy5c66GQiYGJqwkqP6R8pE0DRhkotz
+CYHLiGw3KQOnRDsrc1+uzqG/0TA6u7QIHBT2dlMxG7QCMkdTBYUTmjrLaLStn66ECmeOrQay
+HnLYfHCopTNLZRe1cUqorYNdKe3hXOJSgK8wD25OyBvO34nTaOlcdI6ZiRxJ/9idBIIcn2a7
+gJXQIJ3UmXo4O9TMmUROFfMEJ9D9U8dAQwLoVDLxiLAG5NQyQqeayQqhoVOOcW0YgePCJPuG
+x796OPp8xL/HlDdc7jCKFKpxku1BwNicbLujoYmtAykjdwJYB1JG0HCIQ3y6VLi6LEY4iQMx
+Agc5osM+DSrcBtDFCbGTj9fYpxFG4ITFSesA+TTGEE7o5xTDAeegDDNw4OMO+GmcoQeOKa4D
+3iEYeuBI0+EciqFHDq5/5Aw9chTDta+zv7tfkwlup3KGHjmK4bq90y2fQDsMQzrFaN3cKY+3
+6539vWKv4OfEb5VHC7jDMVTNAOn4ONk7CodncGdj4qqDHQGD5y53JAyefL7raeXsVTYx9Vbp
+lCDsyBi8M6N8ttcaOFsZ0I5QYZ1pAu9lWD8qZjBnmetg8+vlo3IGq5qNgb9e0ACJk7/aydkZ
+Nyfg3ePrAHUzgc5HpVMWzlbUvk4eU+REL7s722aDpeOXT/aPNs6GNHe2KmjdbmRVv60Tv/i+
+Dji2tXRQxsURpDMckAnFLoG6xMHsrFxjZ+XaOns2RPc47ufaO4Jyc6q3kmnQP5BCXfL02g7c
+au2c7GXW+d5C5TBM7nwnIXfyV2nnOw+hU75KOYUibTogcAdQFJC4f2BGXgxCB2NoKNojMJsP
+79AQdNRjdCgInhk0dPI3LA4OoYzNwSCYqHAQCGee53yIHBjCGV+nHAaqHeWIWjKv5uigBg7Y
+Ra4ONob6O9io08YRMXZnNqTdY65rYhAlHPWAgDXZmzhws0l3PpGj3dPBt37VOuW6tM3GTUgR
+RrmTq3CIoJ3KqW+1o2Y4B4aI9dn6B4TI3xspBJCpOHDECk7kKA6EVQ6zLtJBOsjd6ZWPZXjz
+c4Rl8HoOEsNxdPwZf+cFy7qC+UecBtXWywGjkwMyT3HO4OeIUys25/wIgFE5MPM8J4Oogw+b
+cz5DEOEottI6pzKfBNKmU+HAjK7ZducMO/iTgVXpgA68vcriVZzz2QXCGMQxQ6/inH0clHlP
+B2c+YIZzdGPB5hRMG6dkzoHe84BvUAzjoIyfQ+1H9QzpYIyrow2acXMY5t0cjnFyWAYZD9zT
+gcc3apXqESd25Ltt8ZdKsINOq7wdcUiuAHBwRFcauORjYhyOT0VMvSNj3sYRMrWQmOnmaCD+
+GqoXcBRQ7qgYOVRMtRo56J1kDRLq4mj+elWVk4TeMUEG5sc5BsjEiJxkM7UxEii9JKitU9ts
+OmeyMwLIJR0BFLdbBSNKqLYKpJBHPpKW83E+spWUkJODwGV4O5jk78BQAweCWjAQ1MYpoUbO
+CvkMByy0jzttnebNlkMNnVhqyjykqYMyYsSIESNGjBgxYsSIESNGjBgxYsSIESNGjBgxYsSI
+ESPeN/p8f93rq/JnXGLQEOp7rUl3590v0imcNlDJdLtaq9/lZw0kxHGXUMeZohxPinG8LAHj
+Qgmd1lfCekkap+U10U6QZOV9Llpve7F/tO7JA8JTmOCfGjpfDj0kcL4e0dz5yhzPu1h6OTFU
+OJ63/+zOV3tnQhzH27M25wty3G5rm3o7X7CjhqyO0/2Nq/PV1JmAdHJHCVEM5swF4pcO4qyV
+WAdNUYDOXvJGZyoiZr7ypXQQxQBlfXvx8xb6LpI62yKfnyZI5qxLhOPnZy2EO9v7x425xTya
+qx2AWXYLEZM6qoQ4Z337eEwZbUIyZ8oRNSRx8iYztRxVBjtTKsaEcAdlFqjW2d/AGBWEOfvr
+AWU0LZc528q31wOejiYhyIk3HNqRQ6mTM6ATb7LGhHLk/lJabscl1D2UrLXIZsrL+phD2koA
+o3AexO8IUjcc5oS4g+ZUfv/ec9KXtsaZY4ccEgpRIRxz52gZE1jnmDm/lY4QOoLOA/JxFqip
+E2bnuCuQ45fQsbUz3/LewZkDdz4N0wQZ9HuHHJ11dAUT8nO2/cU2pkFOdQdF+4rFSUYe3UiK
+Q/EuKS6FEDsODZfs+iImhNVRHqJgTvzvmFnUoD3+Zp3HnrVwjlvKTs5jD/6//8V99N8crs48
+HVqc/61EDFU6U+rcpPv/uDuhcP7XyJl2hnRq5wj3sp1oJ3g48SHL5hwbOKGXE0mQo3tEBumE
+vBKOxyIdt6c2xlAIRTp+U4Tdua86Zxwf2/jYsz6cx8r/C5bvCIVOdsAcv93EAQ4z2zjl225O
+2XCNnPR8bwcHfM/TKZ9A2crBYzjDeUMH22ze1WEhH2diKa98uIz8HDoc283fyfcyj58atFvp
+oPs3V+fxN2lJxng2Fv4SoNqh18A1mafDU9XMo8k8HG4Nga82B4eYGyohH4Z1mI9PsjKoduYq
+aOrEp1165CPbUDlIwnRzHEaecr0Q5Z8PtOtp4aSneeUMB9Gf7eUo6rrSCfy+1MnplY/UISER
+45CQjGnoHDbIpYNQ5nDA3jJBOGOAtM7hEDnXayPncIid6/XqsQ9aFojWczhE0NXZ2ceWQ+xc
+l6jfVPMFD6Aj7iKpc0AcKeThVPUQxaQdVLf31jhu+eRM3HCVg5zYqawE2jnoHQRinLThKib0
+83vL5ymn8oArdkqmcMwNxzhRB013q9IJAkdcC2wdQE7QQ5wDMakjq4V3c9q320yxvWRxsoK7
+Q2w9uDiCsnNz9CfN5zfw4QBqN64a8HQoBygEpuie7+DDW+kslM2ZQ+rca7uLQ1c27dw+q3AI
+hnckO4al3QJxVoF05t9SXgdELfAO1HRwu1EQ7kybU0J6Bx13psgpIJBRJ1Q6WSchzEqpnJA4
+cU6EcvuF1E4IRS/cT4hQyJ3Amk7jXKHXskZzca6Xi8iRXcyDO5cLDRGbq9C5RGFqOryup8i5
+5DG/CjvgSXTKCY8huDAgMobAmkPbbVmSU3IJq22qf4RMDO0lx0N65wI57FV3UbMJmVvkZ0kK
+iKoDhXPJnAJCy+C+mMK5xM6+BhwKtnxWaeubvI+IMtAxlyyh0Mq5ZA59PWmFc5cuF2yf6unc
+I264lk6UUZJZG4eFvB3sSmkH5xKXHOIEL2cbFHo4SQ81daLDfX8n3lZb5nPp1G5wxTVgwE2o
+rRNexalhwA5q5mQlBzt1TOpQ9ebnBMqpZBIn4E4tA00TAKeeAbbUJkxe2VMHJyCOC/M6DvN5
+6S9SjAgqJy5UnrE66QZBQjVO6OLkiqDh1gUf/zAzTRyA4dstWVrkQAxdMQUkcUDG3YEVpjLx
+ekM/rHaCycEY0kl23CIHZehNoJjCuTs7o3FwhtwEiHEH/DDB8E4QOxRDbmqpEwpHwZCbQDK8
+9XIC49AMualpHIahnLTc+jhLtHPSpVGHY4TOyjk6+1vxNN7Zid8BDuecnPQdjcMy+MJT3Gzt
+nEnjCBhs4ZShHQmD/lI9nfxfsCNi8F8q25W2cop9HObIGMxJ9qXbq4AjZLDsgUEUdMQM58Dz
+6+WTcgVr5dVJsvrIHA0DO3s6hKML0pn8HLBswGardALCFPl8VDpF4cBMvZNHXAX9nY8mTvqP
+Nk4JtnGAPXZLZ0LT8XHWsr79H5KOq5PtGFo5+Q6okUNfTeHLwGOovxO/+rbOWtNUs/k5eT7u
+DrxLeFsnHtra9s+mEOXmUgd9HMHg5tU/hTKcZs73Gq5M4XzH0cz5zkLOKJwcETqhGNpIB1AE
+EDiEUg7MsFB5ZoJ2MIaG9rl7vcNmBDEWh84ILjeTQ0AY4+ygjM3BIJwxOgiEM00c6K3C+RA5
+MIQqDRyYMTsIhCjejoKROjrI3xGWdaUj3kxrHM1w4OE0bjcdY65rYtAhHP2AQDCeTnk6p5Wj
+S4edWDk1m8wp10UwtGOe8jg6OoZxcEjJGB2twjowpGdYR3sEZKprUCJ/bc3oRh+gkkyls2E0
+4uOIQtU9vRw782zHu9mwGM4bOjUr7FRumrKuYP4Rx7/Yujngq/6OnPnRzvl8Lj+GTtXNzvkR
+BaOEYOZVHOoYRzOIlk4KEY5qbhA5585ODJGMfNCBnQyCGbNzBh3ifKGq2UAH2FrF0cnBmM05
+n10gpWOGOjko854OzqzO2eZk26rJIXcHU/IfnsEdao+gmVDFTq480iEZ6Sle1tEzNoeafxjS
+wR0iDIzJgYJh3s3hmL5O9ejGMuB4IFs3dnkt6YCzKnj1G4NcXks74gDuIGnqRCFg1I7oSoM2
+joQxtJuJcTg+7eTImGpHyNRCYqabUwUpmCqolbMPbgZHDuWTLR2jcpKflY4Yqkvn9RzkBrwG
+0BMcA9PNMUAmRuSkW2lbZ5dsjgRySEfnTM2d6maTQC5MN4eHnBwJ5MHEEOI6OR/FWrDMKh1U
+bu4gUgMHhN7ZgaAmzgpF22kbp4TaOovWjCm6qJmzSEuzNWQe0tI/bZkRI0aMGDFixIgRI0aM
+GDFixIgRI0aMGDFixIgRI0aM+Iei/bfKMdNa6vpNeXun11f/fS4BAS42eWunZPpdDNTtKqoG
+EOx0u/7MHcIcbwl3fCnScZQYx43iHRdLxtRLYqdSUjhNL+11ggQrV97+V+NUQ5LGmhwgSQoe
+F/tLMkihds7XV31COBM7X9W3Lwjy+ZqjDnoBZ0qYyHG8y4h2DBDlTL2cKWISx+3uOc7xuh1w
+c76aOhPruNxGOW3OF+QYrpCmGdixXIpNM6CzVUilM7V1pgTAnb1EbDciA8o0feXOOkhoIcbJ
+y3qaPudYLv93d9ZFjp8J5JVQiLvmphw3RwsJnAAxn5+6LmLaLezZHFPmDim6iHOiZD7zMCVE
+OpBiTIhyJkhRJsQ5j//CjArKnYRcfsCYGTI5UHKBdnQP98g6PkosIL1jg7JC3l8MkLO/1NKJ
+N1lxQrEDMIVzXCJOSPXUmtKB8nkYvyNIvLHmKy+gaDBYcvkdZaRtOBTanbXJjr9/R43nlRDo
+zPF4xyWhpIMA52jZVmEobAkVzpKQ1KGgyDlijnqQoyHK8UwIc/wa7gEdcUd+XyoPHSHntzIf
+uodCDjV0EEjbbmzDpVDp1Ce0jeNtnX3HBCbk6JAtp3XwQ/z5P7lzNLYb4xQ9NEOP7Vd30IU5
+UT9lW+saPs60O9Pxf5AzNXBS6L85PJ1Hef/vfyv0XxwezgJNm/OIXs7/AKd2F3Tv5qmDEx2l
+tHVCL4eD3JxAFsI6Zrg4s7Q7xyIdLyeFjkU6rtDuHDfG3Ymg4+2nO2L4MlLmhNmJRtf9bU9n
+SSg53dDOgY6aHZ0Nau1kJ38aOtuJoNYOeEajhYPHcOBAuuVt8+nkMK3muEPt55CWjzMF6o+R
+OuaTXZ7SzJl6OQzjOVH0d/J1/gAHgCjGdjI2XSk+KdBC9BpEjOprhuc68Pc2eodjnBwRwjI8
+JFKaOlMc7Zx17b0cbpcgc4hPRunwDAdxnxa2mtrJ1yktA6UDrJLdZ5vyCfkeIfgUAv1Z8dbD
+QsxnNVCN41ZwkhV0cnrlI60DEpIoHgm9jONUcNhnDodDYkkcCkKVxBGG1jkcMqi+4NYV7Ws6
+bDH/fHUZ4grnkDnXq0vFrUusqzkcEuh6c64zVZdQttwhd+aQFlytc5UpYudAOHUNJ3PqK4Fi
+blBnp77ipM61suJo57A7lSW3vDnBTJJQ1TxuVibeEY8+VD68UzvIMc7eQdPDqnQCxsQdJC25
+akdYcz4On5RDu9lPWXDOQe+AkMaRjnNezsTUg8kJ1zwszvwGvplCDlvfLs5kOpmtdiQ1h3dP
+LyfI2221vJ28sHmHKWu5c6V3EZwj21Dnura32+3D0g6amNqmnPvnhc594KlyYAhwmAkq5tw/
+MDe7rN2uzLSEdcCM0HpDIbTddgeAEIfYFbH9A0kgc29jvBZkTogsDJnnWHXOogGvQR0EQRrn
+Gi4XxkGHbo1zuQcFXXEIr+spdi5RcA7YSZQTrmtalzw2H3SA041ou61LFgRGxg4wdhP9I2IS
+STXwaJkcUjnL4jLncglhP7kEtxxVB2LmAYWsh6YWztp4EwaR9aZxZilxEokoAx0TQWuTNHRS
+qI1zly5Re5E9VOXcQrqrq3UukdMynzijZCfh7hQQmNAbOZe45BAneDnlxtrSCe2dFYIL2zsf
+7IJ5DybZVvcuck8n76Dl3w2cAnoBp4bJHap/qpxLTyfbVGGnjnmGA90R5MVAu2/IqWXSIWEe
+fACnnsnGuPs/mzDpmN3QufD5uDDlkPAsh/m8dBOrc5ItQuEEnRPEzlThhGBziu2U/nTO8O22
+Lpjv53SM2SE/XDJ8uyVLyxyAoRzgKlOJAylMxRDbD/phmHF3EIbsSmq8dnL2lSdTOHYUxRiy
+L/N8eEfJIE7wdmJG4+CMxgmcQzDUJlAOo5mjYMjS1DkkQ5ZmMYy2cSaVQzOsg4zXzZzW+ez/
+pB2Gobbptk7KROesSIdl8EYuBlE3J3m9HKy9nPR1qNlQh2cCyQgdAYMunDmhkZPn08rJyi1Q
+joTZls5fTpz1RdCRMcjS5diGOUKm1pEyAmeP0hEzSPapg9aBnIGdvarv/ym/x1g+qWAIJxML
+RxmYEzEuDtCfeTpuDsBE322WZ/lMTtGh+Vjt5eQBp+Pu8IxjPru4vurv7HuCeFBwd8BdAv4d
+01s5+6vtHOycyzs6IXc+3J14z/MDnOmpzoe3sxdbU2fq6ST/aOek/2jjFF4jZ26uKWca1UHh
+fDg7sPK+TnhuPjkDON9LtHW+o1AxKuc7izZOrvDOAvBlEDmlwkLxUC10QIWD4qFa5mAMDUU7
+nmpH1kcODt90JePrYEVtdFAIZ2wOBuGM0UEgnHF1iHTQS68ZB4QIponjmQ8EPYj2DjZUw4zU
+KaBoDG3qBHQMdXbChDK+DjJU++ejKeua/tEw5rrWjQbSAQ4sa0T5cQ7EsBMrsnvk6cgcYGU4
+Qzv2KY+fo2MYB4eUjNXRMpyDQGqGdSCIWp+prmGJZhSbacUBap2zU7SCb6hiRxa6YWc4O9SH
+wWI4b+hUrK9iFPVw3JvNMqkyMX2cXvkgjjvTzxEzP20weIpzPjdjYud8j+xT+JGHq0McSVU6
+KUQ5qkGUdqgjQ7NzPiMQxii2UsiJIbd0eAdhzM75DEBEsammiJyjDozZnPPZBfphDsrAjhjK
+67GRk29eOIM71Pi5viVPh3L4kVrOoA69R9CNBZFzzhyGUQ2hkXPOHXJHqjiVzDpUGJgPkGEd
+NQPnQzPdHMufBQwQxDl6BnL0ismRrpq4Mgx34OkOtPadsTnKSLZVnjE4wKVuLZz9kjoNo3ag
+sa2RY2EcHBFjcEzpGOrAxFQfBwuZaqiTI2Z0UFFtjZzcUzDKhFbG4Cig7EINHSN3tjyWXlI6
+YkhxfFDr1DAv51B3W/hCIRpIGzsVTDdHBmnnOPaEIqmps2h9nEdKNkYEbcfGvRx7s4mgqboK
+FAlVO7KEqptNCHk4O4TJTs5HuZI2Dk43dz56OR8/zfnYlbbOR+RMxhmixtm0RgywFTVyoqZr
+12qRtHRPS2bF2hsjRowYMWLEiBEjRowYMWLEiBEjRowYMWLEiBEjRox4w2j63XXJNIaSr5Z7
+Oc2/wG4O5U6fr/77XMrQEHqm0/hioP5O46uoGkKY4y3hji9EOK4U7fhJnOMlISuX38Za5Vjv
+9VEz3hDKyJ5bWeUonxlVkw7yo6+TVoHLNdFSpxbCnGjVkwMEM9kt3CnknU6eXRX0Us7XVxfn
+62uGthfaOtH7Xk4Kfc3RzJkSJnbc7pqKC6yDM0VM4njdpcc6TncdThv0VTqG64ktzpKnh7Mx
+0xfsaCGOCZijvH6dYSBnrxBHp2y3/VfQQMnKCwRwosVszrKGCXWWhY6f91DfeCZ2lkVmRg+l
+vVI4IWWOx9XRQnDvZ866QMTcQnWfAVJmiQMzC6ROCMznAc1vZ8jDUUCcE5auyRFtQrmTiet7
+EKPqoczJU6MYFZQ6SBMijKrlACfPCWU0EOKEXk5UGcD6j2ooXmvIAnWiTVYKxSuVOcc5rAkB
+Tz5anGNErEqUkLC2i7WnUIiczfhtSIhyQprP7vzek9I3HAzdnGPG3Jw5Zsih4Vjn6JQQ7fxW
+OTQUNghxPsVzH2FClOMJAc7v47oJiRwKmtaWO+KOeNLIO0mYHTPk7YReTmAcjw4qob2DPnUF
+h0NTR4doOV8Hh7QOcey9/Rso7nmgMM2AYWcefsp4jBMuzu4dj/+DKCdnn3Qf//c/ELIeckEJ
+PaoBcP67h58zrc7/UuG/3akdEe4tN+3O/3LE0Zli52E1cALg/K+FE3o5oZcT1xsAqR7BQDtB
+4NTPrTYKdLYjGicnxM6xTKexo/xKTeREW+pxabNJ6Sg76Li9pP1iSOUct6P+KBydFSoRRyeq
+hMbOBkFMAwdMx9O5xeIA7/g5+1wBetfNwQBfB9hi2uRDK7711suhUnJyoCFtOKyzfj30U/Lp
+tJ2y2by4k6+xkVOus5WTZjR5OdlnsnUKWk0I5Z+Bvw2qdpjf1CsfZgWBHXNkDs+wk4N6R9g5
+AohNQwrZnamrIyuDWmf9F8vUOaEchYxQsXIgKVG9qZxyjW0cYNY5gXy1U6QT/6cC4hhZm9U6
+moGnygm9HHkdVDoz1sWRVkKn/qlyFANCneM08mCfORx2SFpwFIQphwiSMgInWdHh0MM5HFLn
+6lIJ26+cKyt09XUAZnVWqQoSOfL9g9A5HAro4QhHuArnep0h6e5O5BwQx6ESSOewpKNwMEjk
+LJKXUzC7c50qK4F2IkiE4ND83vy7Mk5VJSwM69TuhehmOxxSxg5xzlbZ8sGnxtHUdq3zGE/f
+3Tlk7WY9JGadUDgsVOmI96zPdx4flTn3/9M7ESNyZquHIzhLRncP4hyyXCZ+XKh3prl/mjhF
+B7E15+eov0SzOdcWziF32H240SkTWq7wMjm331LoTOtZU63z+IjGYXYRuPPIB4XKDprWnHTt
+tjgIhDB4MVD9s6xB5lyn9ZJCqwNBgLNASM1JnGte35CyJQSHyLlP2JeOetQG7FypDUjqzP97
+uVwQY3G2LwWkzrL9LHFf/2UNEaRzVuqSxr7mC+gAENpu+5K5skN5crHDQ+n7JYImF+3t1A7L
+JFQ0wAmdZXERc7nM7UtOE6g6EDuzZHfEzAPKGi4VyXpTOPdIoCw1sg6UziVPKJYIR8ukEONU
+pHOHJqzlfJ3LlLQcUQmVzgWtbWcngeLsvJ1LVnJNHR6qdwoI6qDQ37EycW3HxefuZAk1dood
+XtN8mjqXuFu2f3uX2wWpuAYOCPk32493iP6pYsBN9alOJZPt7fo4S0BOLZMNCZhTz+TThNTx
+S6eYjkCOAwNsQoXjwjg4sqzZdpMp7IJsPlKGXnJKHaDe/s/evSg3juMKAA1Z6SRWdXemPeP/
+/9WNrQdfAAiAAJP0CnXvjEeWeQwSop7OchVHJ/CddubhO0Hq7CvW+x/yw7Wid8gPtww9ks1E
+ynMAhh7JZsZmORBDjyRRb/iHQYZOndhO0Q/DDJl6tf3EyHAQhv5Ok5w6H0a/oYzSQT6LM1Tu
+YodgiNwjMY+Cn6WYrpP+o3Ek6VB93B4okg7J9Jzjdeg5NEM4caaDzNftRzsMz2mu7xg6sXC6
+dSB1oHQYTo9BnTodSydfbu0EZNV250M5fSZQDDsfOydQDoNBnAAxmMNhAsX4O+0x1QxnXwg7
+LIbst+31sRR0eEzoptNxmAy8Nrj1gA6XoZz6JeCwGfhrwc5T7QgUzAlUOswf5HSdeg41cYB+
+7g2Pzmk6Oqu2CA6P0qmjm46N09t4bJ2asXdC6exLfZzj5bHUs9+gfYKts78+lpo7eTpZuDtA
+Wds667+gzcfOSSBwa8HEqeecv8YpGHMH3iUQjx6MMmV9+znlVuTiHK/SclcnW27thMzJFxs7
+eRkUbzg59Q/Rnlycdr9wOgyHun+BO78eIWBUzq8UonRkzq8imOkA40M6v5pgMaGe2minVbqQ
+wgGVDlTuEsacLgQyqIMy7GIYdnBom0EBxtRBi1rpYBCuKB0EsndgiGDQR6K/iANBVLd9eQeA
+sF2CsROzrfTTnJbhOjW0M8AcauqEtOPxdVJWrOHRO7KyHhofAaOtN0KhHPGEMNkBGcqR7oGo
+fCDmazlAY8JuSwekcgdWBhysQZWjOyQ1dKRMz0EgvD1dHSAQxWidVsIVeAeHMs0JKntoBp2M
+ohQLhxd/oQO/McmBmREHXj6JOZ2eM2d89LO1lJmylX5NR898tmPdbSLHnnFw+MzfVtX2kw7M
+FM7v31/Yqbuv7/y+R9UUfoYTD0eaD+xgkP4Y5HcDKRyEyZzfjdNhxpwMMuw2wEkQpwyMHIyR
+Dk9yfssc5E8IdZ3fv1uIYpDQOPJscIZwyGzgOUfo/AbbKBjmLbm+Q9X03mvuzpEV/cABw6Gm
+AozROj1AwuzO78oh/yL94ZSLVU6H4V2A7zg0g/QpzXym02HYt2EgB5qucQZY6ubwN9HCAQ4P
+UKdNq8uIj3tjhOZQe6f2fJ3qxkKfkTvH3CZKRzU+UVwFyjoQZ6NyHv/KFnk5kt3OaD5SRgxp
+GaGjTkfsbP+WMjIo1pOowJGXQtp+JIxq6tE4AuiYdBTdJnDqyU3G8KG9wxTVJnYyxs3RTNQD
++agd2QBpR4fvrDs5fTqSfI7XCoYHxcEqECSUbacqRjj1zHD2QdI5PGi421jO3mMj6bCdx4sB
+hwEd+YQRhwsBf9XNw9lf650CAmUj5yk0jfg4e7sQncbHwsHkNiFr5wlmXJ3g6Tzl2Qzu5XhQ
+LjkwTdeNTNd86DFIPkwxRo/9gpezSvs86qckyx0544wzzjjjjDPOOOOMM84444wzzjjjjDPO
+OOOMM84444zPjjn3xfzu9EKMN5Tfip3EeEJhEhTmQDUz5Y78pEcMHCGI8XwG5HMc34eBHCHU
+MYaKpuPow7Uyx+NJnQBD5lToQFZSM/xOEFBolWMjcRwLiukMS4RT/8bQmKkdk4pgMQZQf3iK
+HjRkmjKwgCAHTGiw6ziOBUQ4mGvGdBy732Jgjj4h2Kl/G/Pz5+iPWFjOz4+Y5QxuRDLnWGLl
+lN9+d7L3TZ19Hl3H52f+vq0Tk3NPKe9SW+fe5M/cSb6xE8PPn60jfgi77/wEHSnUZXDH4Oen
+IFM6woRS03JH9bvdYivsdFuQ/0wrb5rphPD6KoaKprvOx38vy+sjhD/UKnJokNwpGSkUmoQi
+7DzeWpbkaKEIQ/nMVjAfIYHahELjJOb11dApzx2PSnttQwBBTp7Px3yNKXdHARWVXR6yIYwu
+IdhZSwNhJFC7AbUQyhg4geUooNoJLOeVvYdIzYY6cCdtS+yEUquNExpnORgx1LZeO0ueRoqj
+58adddCOJpcFgiwSWketdd4yydBZGudtw/aOG4cQZ43HOzYJkc4Dkpc20nH7SCAOt+K4CS2o
+Y5cQ5rwdlcBxeNAE5wEtYMeJJlMKWifYai5wcPaETBxpQmmAJHMp6ew7wAlOC6kdxiULuOdk
+e2/WpREQku29WZdGljo0Dn3uDSW0QpbO+gJwlm2esHO2I4VniDJxwuHEsDxPceKHA0A/fvyI
+3GMEwnlAazU8t86PR1g5MTm79CMPEydUznPDGDmhcp69nB1ano/wcUIoE/JzAsMZPxbZpWcY
+Et3h6DphlhMQR/a32jhOBi0ZM8PJz6DtnLQFPTbVUF4PsHNi5lSIl5Ptz0WOcIBaxdAJhdO8
+a+ccEJSOZb9FIh0zJ82lYDpWTswdaAVT50PCVjDtNzgVUyc0t75dnOO4Z5IzKx9nZz/6xdcw
+ymdPydvpddv3cjaEYAwPfCnFuN6MHbDJTkKadConrv/v7XBGR3cttkqnO4cyoc43ZUxuLKfL
+hO7kZuAcd1Z732XMSZmMVgKDid2tZ9BJ4+/vHC8dHUbrbKj3aT4lcdpWGSNj4bDL2qjfvJ30
+pEXXoaEeI6i4sXyMCq73YfZ88E2cnWOsY+GwYqzf1gOe0YT6Du+AZ9Q5Lv5PcIJdv1XtXC4X
+RrsSCHAuazg7l0vlxP7ZAgOq17xcauhmUnE4s0O3G9/BIYK5bMwd4u4hxpzAPh4xcMYgglmh
+1G9DHddzVma84kjnsjqSysYgktkdwVxKOtt3bZ3L6nxkNFoJuwPnczg3EydgTOUMVEK2AuRc
+ykLQH/ZIHS3Ecz4k/mw65AhqTuVcksOtOZ2TEor9y74WTjwcDdRj8gHi7llx5/5RgaO4prQx
+fIdRDGQ6mJMX3H0zCv2TFE0ZVA7rUEHnVB3HmFDHnQ9gr29zp+o4xgU5Q4ccJNrhDdBW2x5O
+kxAuWDo3tYMfhsBO79pSx2Fuqbdj+8EgtN8e69+4TlZzMESPzw1NCGKohDrODcsIzIeASGdt
+geckCJy7GQ4EtcyNnko5zv1lZqQ3LJzHZxJ0vV7D+q+PONoOAYQAEHP2VdfmrkWkpq/ZN6Eh
+PJ/UdxWToPSydSLTSVErh5SZj28UZVBfqSJsTpVQ5Dj7agxmK5HjYkwAh4h2eMwOUQeMNs61
+7jiuwx6cgqo6Lro4d6oquUwyda7XKqEsI8KRM9c6IS+nTgh3hrqtSKja5dk612r83Zy856j/
+1flh54qUnIvTh4YZtOaM0/F18rVn5VNBzs4OBWcnUE4wca75sID9Zu+kV+bddoUr4e9xoptz
+ZTtjDNRxn+oMMtD+28UpNiG83oaZqU4JAc44AxSCC5NDmMNohLFOU3BihzeIzZwtdLibcjNA
+tcNlRE4UOiFwoZF8QpjiBKmzryhzaoZ0ikNEqK75DOm0p0FMp2XokWwgVrcBSmfV5pjU2DnG
+BJ93+h92dmAGXPd4j9h+up/9Ok7JyByUsXVwhlq3PfLtOARDrUw44EdJhufUdS1nOs7xOrg5
+UeZ0mI6DzNffx0lvtAzl9BjUabdSOyfATnveOOSUy9utlHK6TEDWjPOd2Hf6TEDWjJLxYTD7
+6rBTMt/eOV4G0mExsFOW27503AEZ/Lpl4fAYwmlWBR0m080HujOTOVyml0+eF+CwGYbTXh7d
+P8hXNghi4vESdqSBOemljRN4k+i4U0fdbe1VMR8n+DjgLgG/6G/hIOlY9tvxal/q6QRoMrDt
+t9p5snaKfUKKv8HJSQ8nFEx9qcrMCb10LBw4HRcnTnMy0cmpdz0gM+60Re3ppJf7cmOnSie9
+4ZLP/ipb7unkyz36bXtZvOHnUIxRHcxzaszYOdKZ4YQ5Tg4CR7yI8yuFLJ0Ysx+C9JxfRbCY
+e/MHCB2Kts6vOnhMaDcjymmUHpScZivCHUjpQHg6uIMw/YT2F+U7mIMxnKKzcXAojU5oZjiF
+g0L1NjPqYFA8wsiBIYpBH1X+Gg4IeTgQFCnIzokuTgulqnZ14lQnAFOoo8NguA44QIJ01M7a
+Pnt4BuuAvZkqHTEz6gAK5UgnBJIxdGiIcKR7BsqBmK/ltG1Jy617oAgzYZ9E2flwEsIc5Cf2
+tINDUFvCWZTjgN+ZmhFoBoNghjoM6TmiMxPRwUHltBKmkBsQw6kknCGcThm0FKGgF8clDiv+
+Tgd6x8HhM1pnnUcnOWDYd9v2YoYDpOVRblAxeDn1O05O844pgzu26Ux3mjdsGdRxSQc4sPJw
+oDdsHXR2c0hngoP2mpfTvSxq4zRpMZzfUge6tuPiAKPEcRoI2zHbOvgBAL7zQZjc+f27hPDS
+JfZxTOd33VbPqd9wcpo3+s7v3xXEGp4pDvfILXd+Qw7FCI7cIOd31lYnG8Y9n8b5XTvdXoO+
+ityhGPSIF2cA53f+jSmHPYeqHWT7IRjKoRVZOrjDSEbAYA4V2C7Bz+Ezdg7N4Ntph2m2UabT
+zjum6TTzdU8JRzZahxlpCiUfNhh14qc6XUZ13NvWgYujYZR14O8oGb2TLZvkcBipc5S1kJFC
+Ry4HxGQ0Tr6Ay8icgxGnI4OOXtuT4jMiqJncnJzD0jjyntMxAqeedWQOGxpkvq4TdA4XGmWE
+zv6fkxw5I3P06XChcrb2coZHh51POmF0drKkVIwgnzDByecDncOBytltkqNkOJBFOpKEwpDD
+TigMOiUEwUbOU6EAOVo5T6FpAx2fMeipaQHLZ9AB4RnOU+04MQky2PuwHMsyoKH8wMrBaTL6
+cDyYA0oTtg+zSd7Z5JZPBZxxxhlnnHHGGWecccYZZ5xxxhlnnHHGGWecccYZZ5zxnWPSXSS/
+O6OwM+fumzeU3y/3hMIcKIQ5UO14QY3jA7WM8x15Zwh0PJ+Z8IUQZprj+ZDOPbwea6kQt+d0
+WsXiQTfKiWUYS6hjLCH9liR7B4FspLqqIchAarYeGBqmAgmF/PfGpk4AHAuI5YwPU8M0k4JN
+PfQdmycgGY5JRq0D/BpvHAKY+tH+pu88neDgIL97H4IEToKsHOwH9gOQ2FHukXjOz58/D0cH
+wU71e/OfDyffqAydiDmqXzAgTplQrEMMYUyRUMPIH1kmHSKkCWkdaUJc514JIxDP+fmzdWQQ
+g/m5x0jXZQ0jzsH8bA/zVU7kOtkHVE7kOMs9Xl9ftx4YTQhw7gt3RQ4hCcFOxuyQWcdtxkcs
+BfMRkoTKhhEHZgYgIKHDeQVCAOUtB8DZ96UQ8yoo7q4TcEaSEOYUWyWi6DpO42gSAo9014W2
+TggQRDt8CHcC5RybErfkmtYrqHD21vNt1gjKnaUIYc/1nQV2DiiwIMpZi/BocalDkhDpPKBi
+VNZ4e8skg44rEiqcNR7vWHRcoJ0HZFEJm7P4O7HrmGxCWcdBztvCr7jeNrQnhDrciuP0XLX1
+VA53v9pzQr2FKh0KWuc40nm1cYCE0gC9SgaIgiIE2TvH3g6BnJ2ldPjH2l2nqbnFyYEh2eGI
+zlkUDnWtB3U+JFMHGaB7PCYkAyf7SfWyPD+DlrXzTDoWhfCIuwNDFk6CnmHnx48fJs4hPdfQ
+jz38nB9FGDkhd54dnU3KIC8nZM6dcnNC4TxDzvixyAY9I5DoTkrXCWhCkxz8f5bWwFkyZooj
+faKE4zRQeSXSyVnqq2lGTth2DZtTIYZOMUItY+eESDGG+YQpTl4IAGM0kRb7BigdJ6ddwcjJ
+9kEgY+YcUHuZ09KJYSsFbAUr5zgyneRg0DfLB31iwNqJHcms3zopmTgb4J7PDhADZOHQFWCa
+T1fTMHCD5k69PW7/q4PjTvvF6xuQm2frAHeiewoLaj4CptMrOjkDR6+2B500VoNO51t3pmk+
+RLeaaq/LfUUn1MOQXGunZhPUWbMDVa0CkIsD3IPutW/icDcfmQPE4Vj2G+X1Vxlx+MMz5rAO
+DgwdjmbjDBZc99P8ARpzBDHgCLbTIefYVYwWQvfDx0G8hUO1sidk4wi2exV0fOm09uUeTk6l
+ZJAoVb5zuQDQ3WJ5bOfSOnvJsfJiOpdLC91u/MpWOZfdsZjjCCY5gtA4l5W5sUdn2Old3pE5
+NXOHPphb/zJSH3q8tzWBOmErbDfncjgMgYTW9yLSb0dCaaVxB2COhPas1ZWQrUA4UVBysxwY
+6joP6LYbbs6a0G2fTDkx5tzGjrP5zjGdqs6Ie0zmbDvVfgeizuOjXSft8BTXYHYnYs6lYFjz
+HOHg/XYp8+HswfHxoZxQ91s3NOVWD5Cfc/kUhzNESifvuL0UpDcbOM6ldhQ3NdSO8KYGywE7
+jgjUQQ9DkISUzvZJsYOBdL8xnTRCaC10HNYWVEEOznaksB+UEBn1HHoXFPZ/5cc9INR1EGjL
+4zg2LSGFcwOhW+YcWVDFjTrbh+6ttczVzNk/tbUWrtfrKjzi1jqdnsP7LeXzUIrYnSvq1FJ/
+fD4aqpndebw81pRCdcqNskvrq0FnXw9UymBBeB1wmUOKFSRweMwG3XKnDnp8uM4maR0+s1F4
+xxk6H1I5b0cv53rFS45w5MxVkNCQc0VHyNhhQ0PDcy16LlAVN+rkCQVP54qUnO3wXOuawxIa
+d65IbRt3G1pyJk6xOpyQpxNmOcGz365dJ2idq9qRMVVkzvHKyWk2VV8nuDpXoLKNZx3Aib5O
+nOoE0hlkyk1olkPUwSRnmAG2VMAZZ8rKRhwLpkhI6bC+S9NxjcNh+qs1U5wwHe6mPOgElRMB
+h8swnKB1whwnTHFCEDihcKA64DJ0B7enJ5XDZrA1P97YOgs9tSc/zXOOd6l5B3cApuOEznbK
+d6BVs3dxB/2WoNJxiHnnsx2EeawbsDWbA54BJ1TnI1g6PAdnTB2CaVYecCimXjl7p5lGOw7J
+cJ1QONBHaQZ3oq2Drh2J+VrBfA2nXNXKCXUZFHsFK6dcHGVOlwnIiuT5tt5pFpPXD6ydCsKd
+PoM4EIM7DGau0ywtJ+tOv3EY1AnVTsHFASZR3GExoBPzyQ24zqdxAuo0a8IOkxl1uEzHAW/M
+JIetrIdwqAPfXsC+n8oJHSfImBAC2G37S9wZDmjf4+DEfHjAq+SWzv5yltO5eD3K7N0G3pQx
+cZB76c7OsdSp37bXIGPiFPuEFOYOMll75gPO1bbO+gphLJz+pGPp7K9mOe2hm5ETpzo1STzi
+MMJk6WzLfZzj5bHczynnBBdnf5Ut93Ty5cYOPIXOc57cnHImdXPiHi5OM+f4OaFkXBwgHbbz
+awulAzON8ysLJqNwfpXBY4BqIx+1/NUGN51mayUcgKGhutfy91AHVHoZIbsEjUNndBwYotdf
+KwdlcKgY+HomVTgYFJvBd3Y4uwWOg0C7w9r9sBwYSun0j3aYDgjlRR3qTdXOabZRC6eF0oSW
+vxjtN4ZjMj4NlKbnbFz8nSbd1nkacQIwhSKMzkndxNxM1U659Xg5+S4OSNXKOaoanq4hRrUB
+zXL2fjN36pbohAhHuGeg9j0ww3KapoApzc/BOo50ZIc82VTt72AQ7YgOFT0cgKEHqOMgkJjp
+OiAEMvSG2nVaCVEUTr0Sj6EcRjolhSvtiaLG4cR0Z6DfRMynOTAz4sDTjoMD7oAsnZg5/VPg
+0XKDL1o6lQGz33SOvN6+rWPKENPOt3Sk3fZ9hsd/Nsgg6nx+3EmTaS+dsVlnn677zlg6wGzt
+Vm3TnPKd08FO2SuHxVAONEU6OOBU3GPkDtgKAI06s/KxHZ5Ov5EMtArD+f1bmA7r3lLj/L6H
+JJ0R53fRVC+d5loVztTO77ypjtOuw3B+/y4gikG3HoLBHVxBq1rhUKFhmvFxd4LC4TOK/RyS
+Ds18XSfCTocRO3GuU2/JPearOkePCZmhenN1dMxIvU1yRIy2DkTbjgLSpmPg8BiZA0w6TEbt
+CNORQdlsIGUkDjDp8B0+lM+hcoYPpWdaDsjFactaxAgS0hb1N3GEDBsaTOerOcPdJnW06TCh
+4XRkzv6fXo4BIxmgfRZ1dIoR8s5nhBENkLdTbqZf3GFA5Wbq55QbkNbhJ+TtjM9uLQTSJuOT
+NwvnaFMHWbsQbetgsun49CBf5wlm/ByjzYcPPSwH56lhoguzQjH6O09VNl7MbrmVwBlnnHHG
+GWecccYZZ5xxxhlnnHHGGWecccYZZ5xxxv9VTLrpMun2Tph0HynMgcInOI5QqOKbOzXjBbWO
+DwQ4nnfKvSGQ8XyUwRnCHMeHWu7h9fBMnYXXUzqQ4vG8CYCMP08ncYwlwjGFCMZUovKxhDqO
+mdR1jLYlaOsBpUEK3k7NoRDmQLXjBXWc4PaAapuFBdQw0G8/DSDUebyslg5ArYP8jYVBCHCw
+n70fS52dEQhi8N/X78stHVsIdsiEVD8rwB060RmOJiHEwaCohWROPh3ZODCUplVrB9wJKSDK
+iZijgFAH3q3OcvL9kfJXrpFifv78WcxFYihrF3N+bvFoevkITc/l7SLp5M6yxvEBJ2djXu8R
+RFtr0TDdb6FghBDPWReVzAZJE6qdkKcDMjKom9DhvLYh6LmiYSihsDkL4KggZAvaHYhZIakT
+YCf8xBBRQgGNbEb7dIcP4U7gOPwR4iTUccwSOlo9ttO0yXIhwgm1s7VeTg3MnqOcADhZmCZ0
+/9cCMgcUWFAnoYezwM5KMRMinYA4b285NN5xa0JbFxXOGmYJdZwHZFMJq7M4O6HjvO0dx3C4
+CS1gQkab0AN6OAvqGCUUj6MQTyf1HO68ju8d0pwAO2/H3DMKRSghrdPZ3xGQtYPVgmz3rXFW
+SehQ1xK2wxEYkh0mDDqLs7PsuybNyRDmwJCpQyS0zntWhbBtQs/PcOctBoWQoA8GdcK4c0DP
+zs4GPT/jkI0TaOfHD5PxwZwfKayckJznBrF0QnKeXZ0aKh3JnYeOk0MflJ8Tcuf5uWRmOcHQ
+CZgTPJ2lTcfMiZCTXRrycFZoKa5AuTlLeT3NzCk67r53Ky9zGTnVADUXO82couSaS4OW+WRO
+k43l+MScmeU0Kzj0G5SOnRMilY7Njm49s4tosdk6Yc0GXsHOWQ8WkfvF1g44NqbOziEr2Dho
+8+b5zHHS/VNXJ3aHx8rppWN1gN35Ijbz2yzn8Gydet5PVTDo1F/7c5z0n4NO8xksHbIa5Eyt
+grq5ExkbKceBGyUXqaCqTejm8PbK1imbi5OcbFgMHaCtyHY6EPzlfR2otrjlZpXP6KFI58Oz
+HH69daAuwx6fIUcCTRqfUYexNx13ZvUbp85MHD5DQ90Pbx03erB4tNZxRgvhaAxrJh4J+eYj
+mLEpaG8srXz5CHbLUqdkCsk0n0opoY1ieGOORSVgTAYJHBzCnRzqA0xn/cqXCwwJgnYi6OyQ
+IJ8B53Z3Hm+PDNDBxJZZodvxNVj7op4DpPNwboZOwPK5HE4fGMknJcR2EIhOZ09IslsdceL+
+v8einnvCDnUcfinonMvab8OTaa/fLo8NiNyzmzlrJVg5MHPvtwd0S04HHHE+4l5z29oezuV2
+SxKv5nROyBnWsamFwzkiGXRSQp3QOe0AKZzAcALkUKCFs4+Ng7N1XChLgehCrRMOJysFP+c+
+07Eu/JHlRjiX5LBqm8qHdEJyOLWNOoHphMpBRDqf3gCFFRp0yIRqJ9taIcnA2deO+Qcl40N2
+3K11KKiTDw7hDgiRDgHdSqeEgOg7IHSrHfDCPcPZz6PWQ8LCuH4E4uB7CLwOtrUfrV3raJ26
+FDROw2zO/dW66k0BJWRduVU2aH0V9t6laxsdnweEKFVweg53ApoMAsUS4vVbEDC7RG1ERs4q
+aR0Bs1J4x1k6HxJ6UGLrXCMfGmEqJ7o5eELGDh+ycwI1QENlcED9fIadKzLLuTjQGYTp8DQQ
+4oyngyZk7hxQDHOcMiETp1gb3rFaONXq+TEW2G9B6VwxBxkf9fBU60NzgpdTQ+blhiTk5kSO
+M8YcTlbiLg4A+Tn7ABHOKAPshf4Sh6yDYabYUj2dlBHRbxbMtU6odXot8L7JsMNMuq6ExuEx
+3fUGnSBwgtoJgesUG2oUOsHGETG0k+95pE7gO8WRQTM+9McD3wnFIWKz/VAfrxV4xeztNO8E
+Vyfg8wHhtAy0YsVQDpvZ1gzYasR8gDoQ81gz/Plj6IDMY80/qNPs6PoOzDxW/XACvCLhHN+S
+6YSes7/iOSjzEQwnNuNj6USpQykrtK8Ib6V2ToCcYhplOB2mcEqmvg1g5hRRXKIonQA4PSak
+LXXE6TJ3B1zeHPb6OO3hdaCGZ9wBzk+tnf3FlHxY/dZnPpwArEZep2gcBhPA9eJ0JzIcDkM4
+x6uOw2JmOgQDXhezcmLhHIsRh8eE0MknLXV1soAdLkM68I2MzGErUBzjU2RV7U7hQpU7geGM
+MdBcDTjDAUzVfk7Tb0/WDjhXuzrxE5wnH+d4NcNh3CwZZJpJ9MnHaZY6OWsZeDp5tU1xkLnN
+yLm3Ts7Vdg49V38vJ8LD4+TsrxBm3IlTnePlBCcSZWDhBKjarJ2i2/I3/BzuozvDDsF8P6fa
+Mxg7ZVVnudXOINQyLk6x6ymGytSJ/G5rnF8pmIzG+VWEOh3a+dUEN50SoZ1WYUIhK7u+AzI9
+KLt9Vc4JqIMwJIRNoSoHhZox4Tg4g0LzHcZ0zXEQ6HCybWjMgaF1bov5FAqfMuaQ3NlyCZYO
+BE1yspYNnQbqMOYO0m1qp4aqdJpuNXYeL9vBgxids1rAQmuHmNsMHXIOnedADGuCm+ZUDeVV
+LXNkM2m9kXo7wEyAMSyn7ph20mE7ol333jhcDmqnbqjdZ5s4TUNDDgq1zGQnINtPxxEcyZPp
+dB3+mUlWb8C7faeBYAbeV0ucikKYo+MEZQCdCPcUjUM01nO2E626+4ydUDrkMZXWia3jkk85
+j3LSGXHYh6KjTjb/pPfcnOq9b+sgB6WGTFEH/g48j07Kx3J4qHw+19ExhVPtVf0ct1mnZVx2
+CtA06pkOfx836AA7OQcngU5Mc5aV3nFxgK3UY3i+3qRjMBt4Ong+CEM47Vfl5CN2oD7xyIft
+cC4c4A7J1LN1n9E50dbpMPzJDXc46bDuyTEcjMku6bDTIRyUKS8djDo4I99IiTowZiwdivmG
+DskoHHgi6DByB5tyJjkdRgzFyU41t3UZoZOlMcfZ/slmRgohLbN3wI2HweidbKG9o07nGzks
+ZtzhMTIHmHGYjAya5OSzgZSRQEcmKocNFZObnNH0nMrhQ/oqEDmDDBv6ax0lw3SG02FCY0X9
+f+vUc7WCETnB2ak6TsNoBsjPMWA4TlkGf5ETBhwG9L2cPjQ86QidwXwKCKJN6q1oFs7RzNnb
+hWhb59EwILfMqAPBUBl8W6eB6lpxgx6WPfPUKE7OE+B4MJs0gdkprwo444wzzjjjjDPOOOOM
+M84444wzzjjjjDPOOOOMM86gY9Itikl3QybddgmT7u+EOVAIc6DPcdygUMcsxwlqHccbvv4Q
+6HjekXeGPtnxezbjCJeHTSrB8OkZlmMOgcguTXFsIcIxlUjHEKIdOwiuNvu66zlWUt+xmR0Y
+joVUTAe4NAyFSVCYA9UM9ItMC6jjFMtGoMbJGj2c4meTts76sl6sh0inXa6F2uaIX/Hvy40c
+/Gf8eghtzhgCWyP+LsH2jpHT7TlDB/8CGkjlKCDEQaFZTnrPxulDExwFRLVVLxiBOt85Vx//
+uXzEmNN0U7ujW5k7FKUQ0U357m57vSxaCO6lkLeeYkmOtLjzVnvOB/CyOq+vWw9o+o1wfv4M
+ufN6DxlUNIs5Px//uXfa6xZr6Rg6P9f/fimZD0gyRP0B+rk6Ly8Vs0HWTiHswYeydkMAoc2B
+mFd+z9WNt074iSnKhGAHT8Y2oUBCsxw+NOiwR6jnrLudpvm0LVkmtLe5tV7MQNyeI5xQOUsV
+op6jnMB1Rv80zuEskLMttoFoZ+GXAs9ZSudtjXW5gbNCqHOXDDtu7aHF0Yk9543fcR1odxbC
+Gd+EYjoOhaHFbk4gE1oEc0JvkgOg1HFGTl4KqPPK3X93nRqqnXEowgktdT4m+28I2ihZPv2e
+A5yHZO2AUO6MQpFwFjsnHfaA0CJ1qItXX8ZZLDsOdtawLYTnZ09nz+iDQSETZ4Oe3Z0w30Eg
+I+cBoc6PH2ZOOJznrPkj7JxwOM81YuuEw3nGnOFdHZBQ6QRDJ0voThWO5NZQ38mh589w9vNy
+D2dpGWcnujpbxy35NU8rp0loKa/c2ThNx92nz+K6nY+zzdL2zkfkTvuuWT4xg4Cr+HZO1nMt
+892corIBxs5JczbEeNTBJAe+TchyGDvUew5bNo5OmObc/4EOjpkTd6e9beji4GsYOeu/vJ2j
+s/B731/K6TKHg65j6+Bh4XBC41Tf//hPKi0dUzn1C51Tf6RyOFWgu+aLdBsdcgZRO9yow6oC
+hgO22Vmmgao260aBRQYO/HTF/so0n6o5N6f6dGRtpQyobLX5MD8fgQOMObsMzJyuJ+i3NrJ+
+83a4+dAQ2+nHiGNWCFmLNGPVb/AXF9SBkdMPloM0aF4Hki+ugXrOsZzxPfoOnk3mWOSDQmmX
+ZOLg39eo4oDmLpcK4jJMZ1fukTtsRuJcGieYVELV2OUIH2cbnssFgAQVh0Opqdo5IJOKK5zL
+BYJEMxLpRNhJkKUTUOegBua43KmZvOe4DgYdDQHp7FA2x405aD61wwidkyCug0CZAzGHw2ZG
+nOzMSFtxWb+ATgaFUYcYniKhEYjpSPbfqvFpnW50HJj5cG63WyhqW3NG3EvnA7rdI69tzaWR
+I5+Oc4t5KZCQrt92Jx8hBcTtt1sYS6jvXFqnE0oHSMjF2RO65Y70YinH2Sq72D1QmZHlxnCq
+UkAhrXPZnaq2MUjthMLpbkTjDm86xRx63mkdxZU4Xj6XwykTQsSv4fQKLjXeqwVifEJ/AwoF
+lF47OcWeSObEXsfdAEc2v5U9TjEbVO1aRU7qcbzXcuemdZrLB1lcr9fGqUpB4GRrXx+x/eua
+mMZBS4Gut5gzRazMHQ/wwUIfSsOzrgwoG7RmGYqjLOyopOfAShlgz/GcfWUO80hq34ljRUc5
+ITKZAlI43HQ2qqxtL+cu4ZVAOjLmowiLs9bo51wLh4ZSFYidj0Ah1OFXNQzNcuohMnauuUMM
+UBoe/lYKO3THJUbpYCNk3G0HFGlotNuYThoedTqp58p51brbDidOcqpSgJw45FxzpuPIZ1HE
+AftN323l+mkDsnVCaJwjSEfYbVqn/pzU2YaogCycNtotFXYGmX3aziBjZ/9kNmlHB2f/aL5X
+dXDC+3s48mE4Sub9HkdCM5x2C/pMR8k8oLzgcsjXIcen0xjvi/SdPsPJOdt5qxxu34ZqQhA6
+7JIM1QbUOCyl37v1ZWCJEwIXyg7j5U5gO2v7ezqPV3wnsJ3EEHXAZMD1HktTGhGeR0UMtGLx
+Pr6dUg6HMXAahudI+61ltvX+/AkEY+b8MXUAZVvxzx1aXwaw22ydRzVXq9UHcH0HZhoHYkT5
+4E7YnTaI4530NTnMI/pO4DoUw3Sq+U3OPBwESh6Yj5nTGR8RQ3TcUW77JVk/p7z0Qjo9BnXq
+WYd2ugzpBH8nJmdfRG0+w/kEIB+VE8jhAftNmw+RTuQ5rHQ6w8NwGAzSb0fzdg64mshhMahT
+gS5Oapyx/fAYMPJuOxbaO0eVxQlORG+YFI5egeZq1BlhYOcJcoYYaLKGHRsmwN2WLoaMMXA6
+rTMaeVVDjJETP8MBr/o7OBBjOT7lCy8ngcdCcyd1G7hPsHX2l8dSJ4eY3BycbKm5cwwPns53
+cmDGyQnuDjKHznKenmyhmA+Pu7O/+kuc/VW23NjJpmrsUMfeyd/wcwrGzSkV4lGxMacsAnMH
+mUN9nODuYBuPsVPObWRZA86vNdjM4RCzTu38yoOfTpMP7fyqQp0O6dRKDyLSoRyAYWW0vyje
+aZ0dAhkSQqdqykEYAsq6rf1poNxBodgM/piDQVm18R2CwaDDgZJychpJ5YBQs5EWmrETYpoW
+DBwASi27OhF0RsenhZo5tDuPmjhNvsbO+rIdPYDRORhg7VBzm6FDzqHzHIjpz9ef52TTGYgR
+jmiGS9eM4MTUDtxtsdheO4yJw0jnOLDiM83sxuk2hlMznX1pxxEcWpX91rytdNp08rNSuYNA
+AINeoxpwIKZw2nd7DiSBTGe67juNhLSU14HOKSXsG5P1BjPQiXBHCdtMGuAO5DvdKKeDijJ2
+QuHQx24THQ1z1EEEHMN0ihskzsOTOeWbHg60/XxbB2bc6uBrOSqGcizT+QudxLEcHbMeYIPT
+gUO3RWh6cxse1mRttFdwTQc8K3Hptva0xLTbpjvbP7N33JzqHVPmb3Pwvant8OCztdghLhGl
+g9F2FpU6wHSPpMOaDXQOPrthDOY0/QE50cZBGbzbUEblpNYtnH46Tb3hDO7gjKVDxlFu6yaU
+3rB1sqou3yAYS4diBhz21KZ04A20w8gh8Uxg4xyQsYNNbT3mqzvVXNBllE6Y7OyLzZ09jXLj
+6TMDdZAt9XRkjNBRTQWDjqAIxJBqE7VxmIzIGWCmOQLoEMSDI4OyOXRf5OKExpEw8oQ0oyOB
+1NuO2tEx0xwm9FmOmOE5o9U20WFBtaNgOI5FOhpHw0ic4Ozkx25aRlEHbk41PhMcPcOBJjkW
+VS3L51s40o5TO13IxQFgK+epVBrJzNnbBWmb6SBvF5DNHVgGum2C03SuMRR8nae246IH89Qy
+Ps7TnHR2KXecmJ3yqoAzzjjjjDPOOOOMM84444wzzjjjjDPOOOOMM84445vGpHsHk+5SzLod
+EuZAxY3fWY4j9DmOGxTqmOU4Qa3jeCPWH/pUx/GOvDfUEi7PZgCpuDycAfWZx9MmUCYeUJlG
+BukfD6Sd4tGZaA4BTsz+R3N9HYeHQXqOlUQ7dlDoQFaD1HVsUqo3Hy+J5RjMd/W85gWFOVAI
+c6COUywbgWonAE7xKJ+xs70ulw5AjVPuhKDFNgz6xwKGIKA9/Ff8A7VAtmcIgc3hfy9ADdHN
+oe8YOXRCGuiTHeovLaggujHiPSOH/NMRioSyD7MSWpZFBaEOmNDyiO1NP2dZXj7iDomHCHcA
+aHUOyMzJF8WD+YDkCRHfvtw/fLxMjhyCv3zpbHvYZXeWzZFAeaNM5+Pfr6+vwuLuOVkse7nd
+mR1ycF7uzq5IIb6zppKYD0jQc4RTnRevzGsRioSAyJSPeHkFgg8RTnHIuEDMB8TtOZ4DI5KE
++s7jJeUMQ9noIN1mkxDXGf2LG5RzFDk3oe4A5c7a+rKFqORYzt7oUoao53pQ5iyQw+25AUfU
+c5QTkrMAzEYxe27MWUwS2jpubTBv/W0LIyf0nAdk1nFtb9k6MXadt8WgtHFnsXdi3xmdfCIO
+pY6zmBNwSOX0E2qg0nkd391lcxxMWe1X8Zpbinws9t9wQqsky6cPdR2jhEBnETv0CKEdJ9x7
+Uw5ecSqH3Ij6jsG5Aw2tO9oJHbdYOVkhPLs6e2U/f4S389HOM+EEEyfMcsLhIJCdE6c4gXJ+
+/DCqgxV6LqAfeRg6YXeeW2Zzxs+9C+e5dSTPlPQcKiHJrSG+87AcnSWHSsbUwRI6Lq+aOBFz
+0lVcD2fvuCW7dufRb2tCS3GJ0MZpByjPxc9ZasbKKaHHrZMyzPIpnPZugZ2TQcDdAhcHuBZt
+5IRpzn6QADMe/QbeKrRzjnzAFWycmDngbU+HfOD7q1ZO2OsAGhyuw9gxhB2a5ED/U9hmzpYC
+VmsODpKN2X57c7Bes3GOoUdq2twBboabOp331U7ZcEqHAMeZ5OCjM3zfpEzH04nIRCOGTNKx
+dShIwkAtRVa59SG4SXLZqEM+xNHdXGX5QM7+0tk5XtJOB4K/uyIfM6cXow4zHbYDfvOs3Iz6
+De4hQT40xHb6MeiwIZYDbTxFPn1v0OFNO0wndp1+DDpcZsjJhmVsgPpOzNawcWAmgwJdDgwH
+ayH3LfoNLSxGd7GgXnNuzuUeJcRlJM7lAkCRK/aco6wvlxoqKs7EyZkEZVsWowPlziHZVELx
+nS8XAJIwOEQ5l8bR7xySExCnnXtGnZppe05f2vnnW+dyfIt9E9J2HJ3PJX+bFzrnkr09BGUd
+AzGtoxwgjlOcNSgrbv1sQJ22EnR778OBhyevBGZtk3UQyHxks7ZqfFqnGzrnA7rdRAckVL/h
+zOWD+YiitBUDxHVuZc3pndhx+NM2PT5oPpfcYdWc0mk7rhNK59J2nI+zJlTVtvAiptQJh4ND
+WueyOdxpjixrygmbw6xtI6db22rnsju8msMcet7ZE0qOYsfAzCfACSGghVMVt9xB59F9fHKI
+rgXcCfh+u3RYewi1s+8a0i4vQbJ+Iw54jnR2pztz0+ODO1vzH9CtSUjjYNCtcm7KfLJiBZTr
+tXGKnmtB1In5gBbEI1qHPiei+21b/QpEVQclBHQhms/xIUjZoCKzvBZaCB2fbWVEAVLLh0jq
+RAaTSUTR4c7jMzxnp9QOm6mhxkOdKHRWah+iJjEXB5iFSIc/PLtzw5wW0jvX+waV91x0cq6Z
+Uw8R5SiY0qEgdRnkEHC4hTuabjsy6jmD3YZDs5yAOcpuYyaUHDWDQBAzyxnqthVqNiFnJ3o6
+V2BThZ1RhjU+BunQzlFurCOdFOFarh+vLQQ5QeYA67cZGTgFtL5qNyHYETH3fts+8f7+3kB2
+zhHvj9idEIO7c01XY6K5854514MhnCFmy6caIB8nrzdrJ+xOWGfSGfm0GxDk6JhyfOqpx9C5
+Ht32EaHv0I1RK6VsGA6L6eY86DBLZVspO+eSOdwZI62ncUIeLCVNPI3DZPpOOUB8J3CdShE6
+oe+sCxtG5NQM7IS0Yq+uh5i6AqROw4w4xPhizp8/+/rBwmmZsDEf0Pqf9fvEfkHC1E4TCgds
+p+f0+o3J9J1QnmtpndB1jrR4DtbA/S1Dh2zkDw4dVxYb5/iabIZyjmxcnUjUNeTQDJFPzYw5
+eCHUDO30GNRp0vkSTpc5Hb2DMuUFKy9n5xhOn8GdwiucUDsM5g7NceDILh40dWDI7Bo4PoZO
+pK5bVs4YU289zk620NPJF8LOgCJxbBj4NkbmDDE8J9gwxA26sdZLp7k/92Tu7MDf5OwvIMYK
+muU0npOT7bLhe0w2ToTK2supZwNPJ19o74Bzm6vTvbdtztg7u/CXODnj6KSBmeFsr3DG1sHL
+2mb7OUQ/Jw2/a79h3ebldGY3I6dRpjk1M+hk3Va+8T2dfM7pOENQ5Ocz4sQB59cR/GzqbZR6
+9rpCOJLW+dUExzlecZ2WYUH7C24+EENDqXFGGewOzBBQLLqtehN1MAaHdgeYQz0cSFE5GGTu
+IFDeb/4OUNOUQzEwVMwF7DrQOtCRgd4BoDjHySrNcHwoBy5spdNA8nR0zoptYvuOmYPNAz1H
+OEDofOPjYBDEsBy421CKcGgIceAisHYCUmzm+YR0a6nPdI5DQIY4rh5x2paKWeeLOpIjq2/h
+CI5I0yYqrwMEgpiheoMhkOnMB32noWAGvrcoc1hndHkdMBn4/JRUDoh9rIM6vaAOQrwcxrnP
+V3diPj79U8ZBBx4fh3T+NmdOWSMTz3d36vcmOQjzbZz6LUvmCzim3TbLwcvAIx1or+CRDjSN
+TnIwZsRxT2dyGfyVDo85nYoZHB5gukecoc0HmIYxplhV2m2cdAKQkalTTm7zHAaDOzhT35Qb
+cejYW2dXgQ4qC42VjsaRzwW2Dsl8XQebcmhmzMkhYweb2jqMGEKcLqN06rnN2omVsy93cuqp
+rc8onQ1zc7I6yBYyGOX4zHOEjMwB02ExX94RbKJiCJpyuIzaETICZ6TXJFA+uckZNpQyEU1s
+Fo6I4ffcQBVoElIOjwJSMkxnOB2psy8QOyyonUO9HV21fTGnmdwUjNBRp8OBLNKROGEkHX4h
+7Cf9Okbeb3+RM8B8RSe4OiZbjwia5QyNTx/ycADZZvMpm4VoO2dvF6RNnXvDkGzvADBYBhOc
+pnONoeDrPLUdN7Cb60OxcByYDfJnVih3nJinYoP1Q84444wzzjjjjDPOOOOMM84444wzzjjj
+jDPOOOMMm5h1TX/S3YNJtynCpPshYRL0KY4fFMIcqHY87/NNcBrG8/7oBAhy/G4s+0Ow43nr
+fwufZyaAVGY5Y8/SCRwPCK4CeyhrO/81nPkDGkXLx4Mmx6/+zJ3qSSDzR04AZ0vKFgKdaN91
+9fgkyPRxqoA4ZWozHBuJ41g8IxYmQQGBoP82YqCfXFilFDAIlq2cbdssf8NqAdUO+Nt6A4jl
+FHO5kYP96H0MQlo0h6AG0Z/XD0BYezRk5OB/L0CdENoeDemdWDVHOBoIcai/tDDLUUG404GM
+HBhaHqGB8I4CnOXlEcv6rdycZXNeFAlRTr1kZzQQ8fXrJUvpyCDSiZjzss4LCgfeieKOFKKd
+YlnGfNR2lPUc0ma7LIZMeX19FU4L2JcP2V5t/a+S2SEDp1gWY6lIoZ6TombuEr/nUpu1Aji5
+8QhFQlDkh4fxpUZkEMN5vIaUO8TtOZ6DKIKE+k6g8mFDTGdpasAwIcpZtiXsWaGbUO4sRdh2
+XOYsix7iOgvlDP7BmsNZG60Z24S6DnNj5ToL4KwUr+c4HQcKb28HNJrQvgWByiMMHTCft7cM
+Gi45hvM20WGWNtFx2xEXPj4fYbgJ9RyzTajrWM0JHed1fNbubkKiAwUauv8LgJbMsdkNIc5D
+stx/o84idbRQ5gxDZELC45F5Dg5Re6G5zrKYnDugm+rDefzTaoBwZzF1AlEJZs52vrc8Pz/7
+Oiv0/IxDRs4DmuGE3UEgOyfOccIsJ8RnDPrxw8N53trOYxHcEGA7z75OIJxo6RAJbeeX1s49
+3JxYOkvLWDkRcY7Lakb9BndcdvXOxVl2JV0ktHFC23FLeSXSyVkqxsopoeV+L6gMs3xKp7l8
+a+dk0NJejHZxgKvRLg5wbd3OCZOcSHWb2XyQ5QOu4dBvwB0JDwcYHDMnHgelrk5MB9nP8a9x
+wlpsYBlYOWFz0FUsnJgcsM/sHfxxCwMnjfwzMjhmDr0C1+k0kRwCtOy2QYedDvnQjWE6ZBik
+w+g2Eye9NHKwm+r7S/ILCdKBhoI7PgIHajK7A93x2E7EnP3lUEICpwMxnYg5x0ubfFCHVwZm
+TtfjOTAzy4Fxn3yYTAdKDfamHRMnwo5g8xl29jqwygcrN8t+i92ytnGwfMrdXA8dc9KGiq0k
+dYCPFgXXkxhOwAq32gENO9jnrSqu15xVxbXO5XKpoOPlsJOmg8saZUKp4tTQ3sJWB5dLDRWO
+PiHMOSDRFIdDh1MxhyQquI4TQSeD7JxHY5cLAEkYHOo7NhWXt1QzKSG+g0HpK0POxdZB83lA
+vd2BlWMylx7tcB1lx2UOxBzQwSgrjuWISoEcn8B2uhCVT+g4kllb2W9tQr0YcSQQ7cBl/XBu
+H1GUtmKAji+LMZcHs0Ib0MlM6VxWh18KnX5DnTYhelIwdMjQOhvEn7cHnWpWsHcumROGHHza
+yUeoLAUcUuezlfaN2XMIw3DCrS0FUT5Ch1dzmNOZD3KHNZ+O51MNkcaJDOdBrUxcP+jmHOUd
+cAh37v/PdmIqBo3TnRAqaP2osN9op+y27tRNjw+6467TKUZI42BQw9xIht5O87P6Iq5X2MFL
+AXXSjA8okJNJQGa4k61+BaLjMKCMiZhySNdWCsyEcieiCpiY3ukypZWcGjJxDkrhyJgcyirc
+wWkgL+dKJoQ5Ue6sUEAku3we0PUaYcjSWWMVmI6euUMhm/ExyMbpd9ywwxyg5CjTQSC8DGyd
+YO7kEsPRM1dGx5k4IGTfbXfoGutNCHH6u9JO1Nsq6IRB59gGSefx7gjDHJ/hbjtm0u74DDop
+JdIJA922frbtOJgROdn67/cAIYN0sk8cztXVeX9HE7IZnvUT75lzTTVl6OTZ5E5KyMkJoTpM
+AOtaxYTMWZuPM5yD8XTaox7IUTGlc01HwNZOqoOrhUOtczhHTVPjw2GQlQ4khzQOZxNL66z7
+IcThMSxns2pH1AC+2j+FsiUkcALTqRknJ+uurBL4TpA5JcN3QtcJoVwvapw+U6+Cb6e4Uyvt
+Wu0aHYfHHKsF5H1b58+fPx8vQUbhQK3szB8YyZjGKTuEZvoOng/iwK30nYAdh+gcCsou/3Yd
+rA2OE/gO2sD9PcrZLpozHfrL4k5Mp1och2ZoR1JvHAeEasbfCbUTWqfDjDiSdPABarptLB+8
+EEROlwmMekMcUToMZ1/wbRz8Ta7TZ2inuOWEOwxmmhMM+o3lEMGsg3HC3QEYXydbhjkWzJdx
+BpAukzlDDNMJwxsO0xkNqKi9nOZxqCcXJ3GuTuE5O9ikY+eEg/F38EnUzKHn6m/n9DbSb+aA
+k86Tp5MttHe6c+j3ciI4V5s7e/uznPoJK2MnpUGWtU0hlKCPkw+Po5NXG+eZpyGn3XocnXK5
+m9NhBh12Ot/DQYrA2sGKzdiJw84vAdNO1QznVxYDTsvkzq8qWE4QOzXDggIwt5FOqzC6LuVV
+LpI6FITN1LQDMxSEF7XGwSFcIRyUmeagkLWDQZMcogq+uANCVFUbOrtg6gBQMYd+mgMwSidk
+l1pY6WyQJh+018ycvAqgVI0dEaMpbJr5tk6QdFt3R0dsPoJq0znZwYGdgzE6R3SEQM6iSgdg
+8nzEjuQITuFkK7CZvN/aN7sO/whbujN9os5LcGbcYZ4BGTgZhTLkzNMrN1EQ+ZzO5ztEvSHM
+gANPo5YONb15ONAOyN6BO85+fOBCcMhnUh2IHA1DbT+mw0NMB05l0Lz1vR02Y52PVxn0r+8N
+p8O8jqh3jkzmbD3AbsGrCnwdfHrzy6d8Z1I6xg66+fgNDy+db+NUb0gd+GpKNx2pA833HAdl
+UKfLcG/G6J18Ev0cB2c09XYMjLMTsOEhGH0+kkln2GEzCkfFTHPkEOJ0GLGjTMfK6TE6h/Gw
+ziCEzDl95ms7VbcxGI3TzG32Tio4ISNz4Kr2dKTMuMNjRM5AOsMOk5FAUBWwmTGHz0xz+FA2
+uSkYthMHHSkUtY4CUjFcZzQdLjRUbXxnPB2ho05nmsOBDLrtSzsahuGYpKNwVIyg34K3Uz6p
+oWPkdaB0+lCc7owwX9AJpyOBjMZnmpNDkGzmPFVMCRltplm7kGzrYLK/8wQ4ddK2UMn4Ofkj
+FB4ONEQezA5ldeDkPE1iHlDOOCk75VYBZ5xxxhlnnHHGGWecccYZZ5xxxhlnnHHGGWec8ekx
+6QL4pGvtky7qz7p7ECZBYQ4UwhwoTILCJOizHCeoYRzvW86APtPxgEDH9U75Fs6PMjhDUKd5
+QODoOEBwGcSRp/YEjj2EO7ZQlUHumEJFw4Vl+5BG7WSS5cNHVU8VkuVTTvWQeEGwk0M21cBw
+TFIi+y3k/2nFgL+7sYICDLWLBqEAQ8giK6f9gWTVd1YO8ONvGwhqs1lmAPGcYQhsElg4usXC
+LdpDcIvg0iEIabADGTnon43QQ1iDFDTklC3jf2dBCaHNoVAYcpopDTZetBDqQNDLGkFxtIW2
+C0DLix5KzfZ77uVFDwmcJXOC9DFfwqkXZI48oczpJfRSOjIIz6dO6OVlBFI6WwcYORF1Fuk5
+Cz48lPP6+iqcFuh8IuQsy+vrARk4AXQ25SEJIK4T48a8ZiGAUjsNkzrusXerkXsoEoJicx7M
+8lIjMqjj3KH7/0PIAwoGfzYiHYRizGvgJsRziISYEOWExIS6BpatwNkjxHO2ZpciRCMkcRbI
+Mei4jiOC2M7SMIuktkccSUJ8BwjzhBBnlXh7oq5zbwYi3t7edmg0oWNCAJW3h+TrvL1l0HjH
+hW3XhDtvbKcDwcNTOAalve7t4CrYwmZOeIxRz7FIKPYSMprkArUB7c6r0ayNzAiZwzza7uWD
+zDy5Y5EQBZntvylnkToEhM5xK/TKn7P7EO4sU51FcDbU6bhZDrHz/vinVccRCT3iuzlEIWyO
+xbnQ5jw/P+OQQT7bXvX5mYBsnDs0xbmfuT1TkJkTn6c4oeeYnHvf45mE7JyIQT9+/FgE15XY
+zvPWeBaL4E6KzFk+xdkup9o4CXpguSO5ZTzgiP56Vs8JqHNchDZyQgEdNZCudds4VUJHpaWL
+hEZOCS2bkl2L9HKKZCydJXeWpX7fyIlFaW8HH/5Oe5nYzskg4Kq3iwNcXLdxYuFAF/HtnJA7
+zRp2/XY44AoODngr16HffJ3jqAe6k2O2n7s3fTBeTpzk5PkgDy5ZOY9/7UXt5cTkhOMGlL0T
+MyfOcdAnfEwdKsYZ5EEycydLhwBnORZXsTn9ZnD1P0tnJB+JY5MP+H1zh/xCIqdtijk8XafT
+ZFYGHU+UDukMJVS2CDrHS0cncMvALp9e8JxHexP6DU+HV25mTje4DviV+UwHyhjEYUN8h2L6
+4KDDrQO2g3SbZb9FfDYwrQPMyUelnxur31AnFqto992dL1sUwuM1ITGcgBVUWXF0RhwH+7xV
+xfWa83Mul0sFHS8tnH18LpcSKitBDaUW1kYuW8COPqGssZgxCRIc8VBQ1djlUkuiQuA6lwsM
+GTlAtyVIwuBQ4VzqKJINI5VQtMRwtJV9fB5KZ4VE+WBQxkDOJetVXugdkznucOB+ax3lAGUO
+xBzQwSgr4WAoJx+iLjSQT1EKno6ktpWOeDqd5cBQ1gbu3G43wZkdnQ/qXO7M7RZTLYw5GLM5
+t7y2R/pN4NCQ1tkg9nw66GwZOTqXWwZtjUnPG1hOllDwdC55xx3zqYOzJxQmObyNSO8clcCq
+OcwJ5LRTOhyIYNj5lMUtc1aINT5bca8WlpeNk/UdAuHO/SN859iMkJGiyoB2bjdJQrTDmEhr
+R54PXdk1c8x0MKR1mnT24kY2JbreAgZdWyYVAwShThrRFrkH6bQQnc+2/nWNyzWPYShkUKY0
+QToNhPfbujamwNxKKJwuU1tYzZk4iUJrmx4fNrND6ACZOauEVoKxg0qGzgYFJqR3HtD16u+s
+EcCNCHH0zAeUWog4NO4cOyJfJ6u4vOdwR53OMSu4Ote1DjqVEMadlbpynQEmDZK3c1D+zjUc
+dyhaJzH8fQ/qlLsiHyeVE+FE1qEBEXvz+QAhzlA2yemNz4Dz0RUpDzKfe2iV949YP11Bts77
+I+6f3s5SLJ20/vt7gqqpFHZESRwfeC+cctI2ckLO7M7jPNfOuYYr4oS0DVk4m5Y5R6VFXydm
+UwLhqJjKKRkn55hy6HrTONX41BfQIUfF1HWQF5vGIdYBGMrhMOhaGdObD1gMvlb4J4d0+QSG
+888/GUTVAUdhOoFweAzb2frO3gllOlst8J3AdULtiPKpO5zpQPMo1UDN1Ksdy2CG69DMsbBZ
+TeY0Hy/XAt6umWHnD+Ug8wHmQE1syp8/eDLoPIo4YBs7QzhR5sCNHA4TahhD57E/besNdpAm
+eE7gOmgTLCekQ4TO8OAN3N/7g0LZcVUz70jSWYN2iqsITk5zXfFLOB2G5YS/y9n/m3J6DFlv
+5g78Vn1lbNhB3sKdYOrUEOF0mQeEvhcjvD81d5D9du0wmA8If4vbbyyHCH8nZrN119Ez2RzK
+qGsTJy1zcCAGdfRMO7c5OzCTOwNIN53sossQw3YMgioDS4e+PWcJVY+kfGcHuK/55JUPfnBg
+6RCTqJ1DztV2Dr1PcHCyZQ5OZ59g5YDMLOfJ0ckX2jusbjNymkcP7J0d8B6fvXlnJ0/Hud4O
+hnjUxXYedXSyKZTqNksnX+znlIutHTibv8DpMIMOOx0rp1pu6yA1DToD0C6w+q1xft2D7+wv
+RM6vPLjpVEfvfedXFRwIOr0iflsCKKLe63cb5dBQOi7gdNvuQAwNIXsElUNBqEI5CENBOPOV
+HRQiuu3zHZzBILzYHBxoClU7IIRP1d/S2dvnb6bKfALBEI6iEAI8Vds6ZFXbOaQCM2MOxHwJ
+h4KApuTd1negtsRVMN1BIYhJByETHOj4kOHIjniO6c3IwRl0fus5oiPFtFeQO4CEMdKDt6f6
+vITJSA+qGqegcMbC2SgCCdTEgzDK80aTdPgO8M53dqB3Jjm2ZYBMoeYOus+2dcQHB0PjM8GZ
+lY+4rL+DI2G+gzNnOpjhiHdys7rNeHpDGf30Br4xKR1jJw0O47KogdOkZdxt+QVlT2er6naU
+vr3DZAaPeac51XJjRz65IQ52aJY70Bu2zq4Ium3EkQwP5vQYI4cM1CEYrROgXYOxkzTmHKp1
+wKdBzJ00hQoYrSNl5E6c7kgYOTTVabbRLqNxQjsX9B0hBM85DObrOqGZ2ziM1NmTcnbUjGJ8
+/B1wI+UxOkfOSJyRdFSOghl02IwESrtSBcN34pjDhvY+S46IkTnF5CZzRFAx6zg5eVYKhg3V
+de3kNJuP2OFBw+nwHIN0vqQzwExzGJAJw3eO//Z1BhmBo51zuE52DVHPCOpg7bsJzki3SR0t
+04ds0vn/c8I3c3qQVb/lDiSbOU+VUkE200FqF6SNHVi27jcaKnen39apeq4pFQcnO0JwcJ4q
+5Q55MCsUozvzgGYwG+VWAWecccYZZ5xxxhlnnHHGGWecccYZZ5xxxhlnnIHGnCvTsy6CT7ra
+HiZd1g9zoPz2pScUJkGf4/hBYRI0yakZL6h1fCDAcb0R6w2Bjuud8i2cbmEDjgcE9JnLsxnQ
+4HhAYBU4dB1cbvYQ7NhDiGMOpYZbKBpCZbN+KQUSClZQ01E5Zvg0VdtPwBJ7JzaOkcRwLCCg
+1QhDYxLkxHbRMNRzimVWjiMUIAhcOAYFoM16mQUEtdksG4fAJtuFwxsS2CLkDEJwi/aQwEmQ
+kUMnpIMkzgiU2uBAYdipdweIc3wJKweEXh4RBpx294YyLy+ahLB2Ieglh3QOAOGMBkpOtxJe
+RiDUIbrtUQvCx3wzp5fQy0hCuEMyL9JDfKLfIuUEITTiSIaIcmLXEf94Gxoewnl9fQ2yniPz
+iaCzvD5i/SJyp2bqZbuyMXdJAEmdpMgg2onZyxq5hyIhKHbnXiXLS43IINqJ+78hZIPMnI9/
+YMxr4CbUdTasGRthz1FOfpay1vOSh4eztrssABTGocpZQMcgoY4jSojvtPEqgDrO9gp2JD03
+7ownFI/rV4hjlFC6dAAZb29vm8RKqNNxqPP2iAc0Xgl752HMCvGO7DtOAJ23IwwTIp03k9Je
+Ow4dns155U0+GmcpHYOE7oVAQa9GCaEb0CJ2uhsRNiMkZxyKxMxj6QRq17AIHW1CH5DZkRzt
+pDnbGZrqLIKLJJSDVvbD+finxTF9z1k2x7sSLB0iIVOnl49ggHDnmEufn3HHIJ9tp/p8D1/n
+Dk1xPs7cnp8pyOZcdZ4T4mQHgcycvd8QiL+h9pwS+lHEIrhO32Mi5QhuDcmcEpI8QsB3Vqx0
+gp0TUWe/5mTi1Allzn4ia+NkFVc46fKdp5NfgrZylmaAluJ6rZUTKmeprngaOR9nXIWz1CuY
+OXnJLQ3j5LSXiV0c4Cq+nRMnOLFwoJsSdk7InWYNBwdcw8YJhQPd0HPIB7xxaOKsZw0HM8VB
+7oRaOFvLRzoQZJXP7qRHK3zzSay5cyRwbKJ+Ttic9aVPHWROOG50eTpU2DjHyyGHnQ6RmLGD
+r2bB9IfHxmGkY3GXgeV0oaJJOJ/9djf5ffgOOBDM4RE44Ijn6QzlAzYJO0MJlS2CzvHS0cnL
+bVI+vTDrNxMHZ3jlZuZ0Y8ShdgUyqO+wIY5DMNzx+WZOPxhORBzzOmA4Yx3XcUI+QL1OtHPo
+Omc4AeuXegdEQRwH+7hVxeXtYQ6XYTj413ZzLh9RJWQwJWStJSaXnJzLEYDTYwioci4XChp2
+9rYulxayqTg8nR2SMDhUOJc6imTDSCXQzsXWQbotdyLTwSA6nSahfvT67ZOdA5rhPN5nlgLp
+PD4NMtnGupeCCsry4TnKhLpOmxDNUE6UOL0Yc0ZP8DWO5iiu73xAt3uk/8U2zZUEjnNbg1sK
+WmeH0nw65KAMkJCPc7llkKcTMmhrTHoJk+VkCe2C9FopzzkSunFqW+9cGoeCMCdKnU5CVD7E
+5lN23E2fj8y5DeXT6bfcWSFiW7KogzRGOGTl9CC9E243WOI64XCiyDnGSOLE7gbUMLfb9kGF
+090BVQmZOzCDX4VBxydsmx3MXK+Ig5VC14Gg6xV0KIjut/q8fjOuGEQUN1nXj1dXJGycHcIU
+zBM7a4n2mZoKcG3TdcBjMmvbQTQM4fB6rYLQkrNzaIhwhEzWdQBE5qNykEvshs4Dul4DuIMg
+HCmzx9HvHCfqnWs2xDik77bGIRMad46hYeRzv6iiZ+5fkpePeCutoPu/aSiNodb5kK5dJ9WK
+nkl59Rz+PoGIals1L+vk9PvNxAnFuYpfvxFOYoac7q57rjM0PO8f8ZiGGU5QpxPe31eo2T+Y
+Ohvz/n6l54NRZ2few8NBt1Mdc6z/XjtZQdg4oWTe94KyzufxidYx77f7J4K3s3OZ0zmCG2I+
+w2nPTpyc5uwEcjTMVVFvne+NrkMwkMNh8LUypTMfsBh8tfDPP/8kSeUUPYGt9M8/CdI5ge0M
+jU/1yVFnkGmd6OOEOh2ZU3cE7oDBdZoPtm9TDNdpPwi9jTOhYUCHx7SncUIH+Fx/ROQO9Dkh
+w3HAz23v/flTLv7vPy+nhCoHnt9gB/5+B1M4/5UOcv4DOkg/HMwfZIWHk152HLSJ5FAQ18E/
+x3a2vtM6jyP1vnPsutXOPVhOqJ3ji9o56UCEdDoMI58jToftYNerGqf7JSkmoterdA723iwH
+v/5WO12m5+T/NeQEC4fBfEC4ELH9gsaBmeMJPHB/au1EZydkzrEMdfTMllC5ATk51K3AT3EG
+mPxB444zooD5PLUOedjPlxiOBTPFmZUPff/U1Cn/295JczUyG5g6+ORm58Sd8XRimkOxbjNz
+micDnr67Q97TtHTKsHfAhzawhwKGnQ5j5nQe2hhnQlMCPg783JOTE2rLwdk0cvOx2v90ZgMr
+pzfrWNY12W3jDjSHujrFUnMHZr6tgzBeTr24Zb6X0++2IScdt7k6e/sa59c9RA5nL1c5v/Lg
+OIF7dJA7v6pgpiR1aoaXEXM2SE7L9CDwcFfl0BCmkA7I0BDKKBwK0jgYQzg4o3Fw6Js6GLQS
+7s6WyQwn+5ezI9hM1eMTUEbpoJBoM9U7Mkbn4FOo3iFyARnSEU4Isxx8cDBmtiPcAc11wLd0
+Dsy0F3fZDgJhreHRcxRHVmBaXUdxpMierYnj6y4jmt6a8xIuo63rhqKTAW7DkIz2PEuazndw
+wDdOp+eIGPV5PTKPmjtInI6to2zuL9x8RLPb6Ux3RIzeARdbO5OYeel8qoMzX3x4kHAog1lb
+zxRHcHVv1IEWWzviOVTvgMulDtaOsYPu+o/34eUE89kOxcxy9rc592I6Ticd+IKy2GFFM4gk
+oz/5cXeOy/0SRu4gtxU6jMoBGHNn7y8ho4KApR6OipE70EKGY3HEw2FUTjVIXk61kbKYL+yo
+mC/pxP0eo5yRONDcxmUEzjFV5wvdHNn+QOuI52kF1PabhBE567/nOCkfEcOHmrJ2cg5th4SO
+dErYHSnDdWKMRW2LHR60EvrhYTrxCDUjcPRVzYWaWWeSo2G+nKOc2gbycXVGGQa0p6OdcyQJ
+pay0DL8Q1s5zdPJpR80wx2c4nf87p9wp6B1uQuG7OCXUsqO70taBMzRznto2Wseg3x4Nw7S5
+07iTnKfacWISZFcGtFOEg1NCw7MOA0pH1z7OU1FvH44Tc4f2ExJPZaMcR+aMM84444wzzjjj
+jDPOOOOMM84444wzzjjjjO8Xcy4ZT7o4PekquOv9FsjxhbzvIEGOJ+R/TwxyPG8jfYrje/vN
+H/o8xwcCHP8bvo4Q6DhADTH4ZBOXCaOPUHEdHwgaHA8IrAIHCC43ewh27CHEGX4QEXOa30MZ
+QwGFTPuuaNYRChQ0/JQg0zGEgFarWrCRGI4F1LSKQibP8OWNRmyRp2Pz8DD8rCMIDWaED4ft
+GEFNhjoMug5qsnHGMwKbbBfmifo6gxDcIOqoIbhFPCFtLaRWmD2nhCROVt4mTg8acJqpBlJe
+1lBBmANBLztk5sAJvQwkhDot9PKSQzqHk9DLCIQlQDtyCO0o2nmRPueLOzX0Ujuqn+wCO1HS
+CUKIcGLHEUEjjmSIcKfuOMgR/0YcOiqolhTM6/7VLPJBnGV5vUcQlQI2Gu2yg3ndQgRJnUO5
+h6AUaCdmr2tECUGRnBiXlxpZIYs/TrE792qElBUycwjmNXAT6jvrMC3N4MgSopwHtFXDcoeW
+IkQj1HH2A6lHu8sCQWEcKp0mzBLqOKKEhp1XXkIdZ/sH7Eh6jnb2f1IOr+f0+by9WSWUrlHA
+zi5ZJIQ6b28HxCs5Cgpov729JYh3ZN9x4Dp4O8IwISqftzeT0l47DiuD3THYVlFnKRyDhO6F
+QEFGkw/ubJLA6c8KBGS1e6Bm7LtkuBsKFCQ7wlInlObSUcjWwSFyn2rodBK6M4vkIone+fin
+4iRF6jz+addxaCEYOzQkOF0dcgQDhDusjjPot22n+nwP13weCT1PcMLhYJCRE6Y5cY4TdgeB
+7B0YstgDlQO0Qj9+rO3/eMQS7JxYOXksgjspMqeEgp2TDdCKlU6Y4ezXaEycEEqoTcfZSRdt
+jZwAOtmFOitnaZyluFZs5RQJPTbV8kqxkfNxxlU4y1KtYObktb00jJPTXiZ2cYCr+HZOnO5A
+dz9snJiOelanWcPBAdew67cZTpEPeG/axIm5A99sN3P2GQ55AMfCiblzXHH2ySdsDvbkklU+
+YYMSa+4c3//YRN2dLRWfOkgO+iiRrUOFjXO8HHLY6VB5KZyyNTOnn05/eGwcRjrTnC5UtEk7
+5BfiO+BAMIdH6DRNZmXQ8dgOWFnsbutB4FeHnQ4kSadtan4+vRjKx3580G7jlZvIaT/M77Zp
+Dg31HZuE6BYFmw/TwcuAWwcsB9mdcfdyo455HaBfnHOww4GyL95Ct5tkQ+U4CDPNueUVZ+S0
+HyydfjDGB+6WFeIyeifcHTYjcy73KBOKxDdhQs2qly0gZ6ASMGaX8kpg9KDGudQOI7jO5VJB
+Wb8ZOpfGEVYcCpHOmlBWAfqKI5kVyiYlfcVNdfZ2Wueyvz1acbkDMJfie4w6W0DOAe0rKQ9L
+ec59YFaqm9mYk8ZIeZz9CQ7IFND6wtO58WtuxLmthyT7mooLFtknEecSqiOfTmKUg26mVUIr
+pXbWj+PO7XbLM9JcsdgdIp/L7hy7PK2zBuoU0BTnZuDgTOuQJad3yo6Dr2iYOJcsoT1cnNRz
+t/42ZOPcNkeWkMK5rduqwiGng2qA7uHnlPlsHYdJZv3WKW5D5+bk3OqgNiK9ExrnFiNaC7RD
+QS2zFZ3I2XtAks5WDLJ8Og7CRGwHgfcbfr7wEdcr5iClQI0PCl2voENN3Hi/YbVw3QKCbjds
+I6K6bVv7ioXEAaBieHAF9eDaRodnXZnB1FRrkA43m5piT3BK51qMTzNGds5V74iYPKO2Fiyd
+B3QN8A0qS2eN9bN1PRCOjtkhfwe2XBxGQuMOvPN2cWJocnLot9XpQBbjE+OV7+iZLUjHIp3D
+iZOcWfl8GScOOrE78WxOHMwHmBOMnfd7hCvP0Xfb+xof35RZBzomvO9QcHXek+PZb++1E3uO
+qPl9/ffG6eYjZNYPzHBCVgR+zrV2YufIaqAKQuF0jhStnPa6EuRomNqpO87MUdRb53vjq+AM
+5DAYYrUQ/nlE1XVCJ3Sda3LyEyGRU/QEttI/maPLJwicgfEJLAdOR+DUnyTzqVcGnLF0WI5F
+Ovd6axS+03yQmbbQaT/Yvm3gAB+E3sYQrsNkqGgYwIE+5+CAn2vf/m8PF+fPn0pRO3A/HMyf
+mlE6MBMOZoV6TM9BFMJB1qcdlAmJ2TsOX3fEeVzyyJxeqJ17WDm9D5/O/4XT/TCfGXfWV/9+
+poMdX1dOlwlkr0X0Ot+XdUgAP28sHS2TJwKfl5g70dVJUJaZhwPF6Vg5wUEBDuMDcFPFx/EI
+J4e+LGbpVAusHeR59id7B3yI2csJ1RBNcp78HCIdk3qDfqnx5Ojk4eFw/rjDN3LAB2tc8pnl
+MB7jMnFayMsRPOxiGuZOmnO8HfApdk+Hmt4snMhgTJz2KS5zB3my08eRPsyndIDFp6NyWmZ8
+fuOl4zOPfmtH8lB0il/3kDG9B3ca51cWbAN6/Jp0ftWhZkinYfgOgzmclulC8mfwEYeGUIZy
+QIaGEORLOxSEMl/ZISDNb9pQRjQFuTncnemgI9h8ug4OiTZTvSObDrr11nOYjNZBFVsHV7SO
+NBtTh8oHZuj9zzwHZqY5wsn6iTwOIRgieo7mSMTKUTB9p5U0DMepJBXDc3Kr05623oQh3HxO
+53QGHRFjfV5/Oqfj4Ug3H2MHZU5nd8DFkxycUTvgUnMGDvt0/i8cgpnlWDJfoKqVjngyMHXM
+y0A8h6odcLHYQU+ljxVMHOKSChlCh7p0o2VQR858aceaGXD6d7T7Dkfp3qDvOZy/oGzidIDd
+kTBiJx6OiFE7VTg4KkYMzXLAYDDfyeEwFpAbUxY3Lx0FFD/FYTISB3zSzd4B5zYuo3E0DN8R
+3PMzd/iMqN8GGElCQ8zAxDPJkTFSCPvrE/bODrk6adaRMkyoOXDzcbY84iQnDDAsSHpAbeVo
+GKYznA5zgIYZnjOejnyOUzIMxyQdjqM7+hA7haZl2FOcuxOPGGL4zlg6Padg/hpn34oGHNYA
+7a8nOSNM4UCslfMU6lacnKe2DR8Ho6c7Tc96QPgPZS2d4mjHwQE3Kw8HgFyY0hnc+UggL2aT
+DHZxXMrbOOOMM84444wzzjjjjDPOOOOMM84444wzzjjj28Sci8au9w0aZs61dn/I/5ZL63jf
+DZnuOEJT7orNc0Ids5wZ9xOnOrPuw867sex7R94XaojRJ5uYTBh+hIrp+EDQ4HhAYBU4QHC5
+2UOwM/58INPZnzcwd5rfDBhDYQ5UtOsIBQKyfCSEctJDSNYOBNmkxHAsILibIMjuoUTob+EZ
+PTTadawgqJc8IGg4ArRwEOI7YxDUZr3MIiOoydYZhuAW7SG4RWDpIJSayVvEHe0UBLVNJqSE
+wByQX/EnyMxBoBc1BGcAOy+P0EGYA0EvO2TmwAm9DEAC5+Ulh7ROH3oZgZLTrYSXEQhzgL9Q
+UTrCx4nT9+913MvLCIQ6TUKlE4Q9hzs11DgiiMin60h6biQfSUKJAY4+cGcJQojKB3GWZXn9
+CNkIEU4FJeZ1DREkdXbkgEycmL3OUxmBGiZPKMbl5eW1CcHWCjTfOPfSWlplg8ycOwMqH8FO
+qO+sG8pjbJZ6hB7QsPOAtk34TixlWCZ0HLItQOzO8F+RSQ7EyBJiMJizQbyEBvIRJdRxtn8Q
+DhOinf2fsLNDrJ5T5/P2ZpUQPT5vH9CaEyuhzgChztsjHpBFx2HO29sOWXRcwMbn7Qh2x3V+
+sNvJ5+3NpLS3vQ86PhKnN2nDzpI5zN1D14G309KxgLD54HDC+KxNTXDL7hjtHgIKLXbONp1i
+kN3+m04oOaOQrYND1C7V3kGhx4Gd5CKJsuMex3WakxTpAC0rNN5x5KZq7tCQoOOGnMXkXIjT
+cQb9th3EPd/DNZ+H8zzBuUPPJPTtnDjFCYeDQFZOOBwYstgDlfms0I+t/R+PWIKVk0Op/T3W
+dDycEgp2TjZAK1Y6YYazX6MxcfaZZ482HWcnXVZzdbKrd0ZOAJziWrGVU0DLut3klzyNnI8z
+rsJZlmoFMyev7aVhnJz27o2LA1yNtnPidAe6+2HjPBrOnWYNBwdcw67fZjhFPtA9YzvnmHng
+m+0mztoyXmxGznbJLzG++YS1CGDIyAmbU/y3tRMz57iwbe8c/fSMPhFj68CZWDr0CvYOASqY
+srWs26jMxE69eXBGR5VP6SDbv8JpPlI0XHSbrVOjLEdyfwZqKHfILyRIB3HI5hUONOLsdKY5
+PWiSA7f5GU6nebEDbvn8dCRO+2HuVipwwHDIp+P0Y8Tpd5eNIxifESerwX5ePAdux358gAZv
+t5uH07R4M4TSWrBz+AyQ57Sx5bMXgoUDNrI7W0I9hufAdZAn1A+WgyfEZRgOEg+IzQidyz2S
+c0sVNwAhzCYVA2TrXFKEfUpgVxwOEcwlGFYC5VyOATJ3LhcAElQcCpHM5hyb10Al0M4KHbOF
+ldMwmRMtnK2B1rlDyOyncPZ2QCf/InpobwZz1oSybVR5WJqvAjGPEVoTipFz8q13wlbZcbM8
+naPmtAl1nX3yue2l7e3c1npQHo10mcwxygdxio5j1JyFE8ec9ZOYk/ecs5ND3VpQO0VC/f2r
+dnxyZ5uD5B3Hci51v5HSgHNAxyTn79x6NTfiXG5ZjDkkUzn0weOIE25FiK/NP97obD6tE7VO
+lPTbrVN0Vk6vuAfGpxqeW366InRIqGGmOVvZ2ToIo3OIHRBk4BsqUW9yhziew/MhoesVTgfd
+iRP9RjhX2CEOFnrjA0jXNbA6EDpp3SsWmMMthM2JtIKDGofD1JLIWTuOyRQWyOAOu9cqaD8P
+n+EAB6ikI2J2KDAdbTobdL2m4SWhAWcNZiEMOzBlNzwd6Rs74Bxn76ybUJ2SSz53pwNZjM+H
+c53hrMF0Rpmv4dh12+mI2982IVfn/R7h6u28r9F9gNmG+YCa8HFayNJ5n+O8yx1R+/sHnJ39
+E+ETnHbfDToS5u5cH/+XO82xooGzc2W/MRwRk7xJDrn5KBxqjfe9LP7555+u01XIb7Mio07o
+OteNGXGKT2Ir/TPsBInTrwMeg60HpyNweMw05woygDPIXEHG3gG20cbBG2g/iDtg8Bzgg+37
+FMNzoA8ycpA6bOa///4bcMDP1e//l8LH+fOnYrQO3A+JMXJgJiTGxkGYkJjagdenHUzZ1vpT
+OPjKdk43tM7jyoqV0/vw3+v8+++/M5x//+1BJs6/Y06PCbni7ITv43SZcNSas7MGh7FwOOVm
+4tRbafdCeeHwGU6czndzwl/p2CrYZSRjBb+s/NUd7FkUc4f1qJCb8/RdHTieTseCOZ3TMXB4
+c6iBw37cctThPpU27ICQn0PdkjHstyoxt3yq/vNyuoxZPsVicwfZgL6vA8fpfGkHYL6Bo3ho
+Xelgf62A4fz6JYbkzq8j+A60p6OdX2VwGOQHbqTzqw4Gw35kPTkN04N0DsB0INlvWIYc5B2x
+Q0IqB2Z6CZk5go32ezi92mYzQw5c2qYO/ssf43zwX2x65MNmlI7wl3Nah/r1KekIJ4R5juDM
+1CefjiObsK0dhBHv5J6o4wPKwaPrAJCCYTgNpGE4TiWpGJ6TWzqG7zBDXW82DsZoHelmejqz
+HXj5JAdljM/rT+d0XJxZdc2+LjrmsG8rfBsHXDzJMWeQmOQQzOnomL/N0bUo3kgJh/jbR/LJ
+AHeoP7YlngxwB78oaegQFyHW98GlYoe62EHEV3U8GNQRM1/bsWYAxyUdxKEaVGw8mEMy8rkA
+GR8y5MdtKkfLTHPkkI4x2W9PcjjMN3JYzPdxeIwG6j2xNepkj4bJGZWjSIfvCO75jTiDzJdz
+oB2pgBnZgCTMgCNiBqBJjpD5ok6qbqnDgmIzuYkZkZO2Vl9H+L+yLIXag24Fw0nosxwNwxug
+8XQUm6qO+bKOkpnmCCE103V0h4Zip5x19AzD2Z58dXWqSxcDDg2VV7BGGElCzo5JtzEK28bp
+Q+YO7Fo5T00jPv32aBiS7R0AnuM8QY4Dk0Gu6eyO0U6hDwV3pyw6P6ZOyIupID/mAe3TtSez
+Y/7GGWecccYZZ5xxxhlnnHHGGWecccYZZ5xxxhnfI6Zdmp4CTbmm/9TeaHRn3O9STIE+xZl1
+G8kRmuSEOmY53/z+aOs438B2hiDH986/L1QLcfjRJhazQ/6ODwQNjgcEVoEDBJebPQQ79lWH
+OOZQ1rArVLdbQHaD1Cbgk1HTboZFQwj4/k3PWUhgs/kCI4h0ssc5DRno963RKCWg0Ygt8nSs
+IKiXoIRGIWg4wCEahIA2A+yMQUCj9SITCGi0WWTRdVCbDhDcpD10NNNLKIf0TpkD5Sgh2OlB
+Rg7y9wBifHnRQkgGcEIv99BBEuflJUFWDgS9HJA8IaxdwHl5GYAOp5/QSwnZOEBChSOFktOt
+hJcKsnFa6GUESuMhc4IQwp0aWlpH/gtxcHfdcyQJjTniX9bDhx+4s0hPYAMOoc7yEa9BNkKk
+EyHnw1hDBBFOlVCl7JAwIeT4MHtdIfeQ1BwyGtWyeHdem9A4LZP/MYq4tIoIApqvOu5x8AEq
+qzP+t1Dievr9YO75PAraKaH9UGppwzQhnNmhcYdOR5jQoPPKnea6/fZ4BToJMnBCz2FCHSdQ
+jmVCuPP2ZpVQOuOBnbc1J14p9AboIcHMKn1AHIdR2YDztseekLfzGKTBhI4NFe22exhUwg4h
+ZSB0+qUAOUvmvPJ2D10H3k5Lx2TyAZ1NkuweOhA68Sybs3D3qz0HhZbDGYWIqecR6xwXTPar
+fYd9DDzujELoVJqgxc4hoI+QnA1pO2515CcpGsew4/wd444bcvgzQndTXZbnZ8Ix6Lf1nOv5
+Ea75THPu0DMJGTlhmhPnOGF3EMjegSH+hMB2CujHI5bg5fwoYhHcSek5VccVTnBxVqt0gpUT
+Sud5adOxcULpPLfpGDkBcdKlLVcnu1Jn5JTQsg9NuiBo5YTaWcornkbOxxlXUdlLvYKZEwun
+WcHHaa/eujjAXRY7J0xyYsH4OLHIB7q27uCAa9j1W3KgS/hm+aQZAbw3be+0NWDmrE0fDAQZ
+OuHYdGY4d8TPCZuDrmLhZAMC1sA3c/ICwxgjh16BDbEdApQz1ffPuo1KTOzU2zunCrT5RPw/
+9U79idbZX41BzSeQfuukJXCgHuJVAcMB26SXOTiROzwCB9qFsbutC3GdXj58B+k3m3yqVnGn
+G5J0qHwsnebDPv3Whkc+tNONIaffXUyoy/Bm0W/h3G43wfgMObdZDlvpQH1ny2hwgHrOMYk7
+O7eew7yYtK8NtbI73UQY0OEArd1udhUHOpePyCBDJ4/LGllCjy/ByUvjHNDhjFQcztyhsuL6
++eAQwVwsK4FgDoitaJ1L8MrnAjt76CGSKaCximM5wd3JoDA0Z6/vbt+0ZY7aztZSQT3nkm1D
+rFKg+y0i3ZY5zJpjjA/E5JPPDCdJTs7ecduOSDtAEic7+nF11prTXRjpO5d8gBi13XUQpq0E
+GlI7CcqPGzXO+lHUuRRO74huxMlrrnugpe63GvJzUs8dRTfB6dTciHPJnHRE5+CUAzTJ2ea6
+KQ6eDwgpHfKwBHXwowPEiVt5ix16PoAdtBjwfuvn05QBUXQD49OW231GRYphwGkZour0DpAO
+Udwdh4BgBTubxOut44Dp7LXdQp26RqHrFXXAoiPqmnCuV9g59kXi8YGk6xqW9XaPe5u1QUpc
+KO+2cGXEmBO5TC05OoUlctaeEzAHBM+ldB2InGtW2q7OCsHn4KQjZLYAxweARh0YcnBAynB4
+ZJAJA0AuDmOADBxwH+TlNEl59NudmeFcZznX0/m/d7aPBqajRN7v8fHpZkqwdd7fN8jXeX9P
+kGe/vWcQzxlkeo5VOq7Ou9wRtb99IDg7+ycUjjidj4+ECc4VcKotFXJEzPVY3dk5ouixf/4p
+ZwRDZ0tvVT6i5/SbodY6mCEn+yS6xj//jDrFJ9GVhp0QONA/o05gOTAjcGpm1BlL5wozfIeZ
+zgEpHTYDbTx8p2GI7oUYptMy7O6FHKwB6IOs1mUO+EFohf/++2/AYTH/pVA68Pc73v7zp2J8
+nD9WDsyExNg4CBMSUzvw+h0HY0JikoOu3HXwz1VON0iH+uD97RnOPeY7/97D3fl3C1/n339n
+OCkbEqKcHhP4zHdxwhTnESyGcnjMfIdca9zhbKWWDr0S7nAZxuRm5IQ+Y+MwonXC6Yw4tgzm
+GCvI5SprBb1seToS5nR0zOnomNP5FAd99NbawaBJTsMMOzB0Oj0HXv5dHWwDMne4zOmczjdx
+ZD9j8XAAZshh7+ROp2DUzq8tfJ1fRXg5v+pgQHyGcHqQKJ3DaZkeJNpMBxw0KAditNDp2DG0
+o4JMHeLXjdaOaDO1zwdmlI44nQFHMosqHekvG3sOno7gTK5wYAh3pOlMdyAIY4Yc4Q5VWNb4
+cYjpLIocV+kZnpMsHSJxuKGuAyEj20y/uiOddk5ntiNjjOvN3oHjdP7fnEl1PWv7kW4+p6Nj
+1PlMcsCY5FDMN3RI5v/HIS63y7celCH/nNMkh/0HKfoO+de2FOnATu+vetk6KAOH3FExX92x
+ZT7TUTFKx5oBnE46wtN51Okx0uNDU6fLwA7FWDnkX/xUM9Ldqdqx2G9zmG/ksJjv4/CYb+Mw
+GYGj33ZEjuao7Ws7Iwzb4f6xsnFojBkp7EmOiNE7MubLO0KGBY3WNN/p/zk0A8eEYeYz7qgS
+UjA8ZzwdVcE5OXVoGAWkY76so2SmOUJIzXQd6u8eGTrlZqpnOlCc49Rn4JOcEabfb0kacroJ
+GeXTqbhZThZjzDTnqW7Hy1lbhmRrB4RnOCDk4UCQiwNAjo7VJNqF/iLnaRJTQo7MHdqma1fl
+jDPOOOOMM84444wzzjjjjDPOOOOMM84444wzyph0bXrGpfan7LL+LMf75sEc6DPuukxzHKHP
+uS027TafF9Q4f8P93gkQ4Ey78z/tUQYHqBa2J3W8mR3yd4JLQtDgeGQEVoEDBJebPQQ79lDW
+NADZSXWZeUFNwz5Q2W752J4lFAgoGkKAE4v/DjYS5VhCpGMH1QVWP/gajSSeMw71HCsoQBC6
+zMqBfxlsAQFN1oxJRkCbjVOkaeQgv2Aczghq0gMCW6QhG4ZOSAtBLSK/Eh+CkBYJR3d0AmdA
+JqSCkASQhF4+QgdJnPDyskKGDgS9vOiho+cZCb0MQKgDQIfzeFfjAM22zvKSJSSFDqffcS8v
+JWTjtFDuBCmkdaRDlJwetNSOCBpxJD035sh/WQ8e5eDOIj2vzJx2U42Is3yEcIT4zoG8riGD
+sFbbjquYHVIk1Dr5iVCJrJIiIdqJd+e1DklChLN13LqzXhpFBsGDkdnbMQHEvL4KSuFoFHRK
+5aOeAcjKebxe8nhd/ylKiOcsUKzQLIcJdZ2223LnlTvNtc2XTsCdBI05geUwZ4Vhxygh3Hl7
+E0GshBBnTcrXeXvbIWbJqZy3NYwS2isbzmaT2NsQzcDOUjpGCcFlsIVJaa8Q5CwODgnZbKtE
+Qpsk2T10IGzieUiq3RDmoNDyptuvglCgIMleaCQhyaTNSKjvjEIdZ7kfcBk5NLTMdBQnKdKO
+M3SITdWu44wT+nxnhZbn52cCMui39fzo+RGf7lj02wN6JiEjJ8xyQpzsIJC9A0MWu7rKKaAf
+j1iCl/OjiEVwJ6XnVB1XOMHFWa3c2c4rLJxQOs9Lm46L85wxpk7AnHQZysYJoLNkV7tcnGXf
+cNJFNSMn1E6p2DlFKSz3y8tlmDmxcJr3fZz2aqeREwsHuHhr5yQIukjs4gA3C+yckKfTrODi
+AOHgQFfW7ZxjSoBuFFg5MTlADVg6938SjNF+7nCwZy6M88HXMMqn+01sHRy0cOIcJ85z6BW4
+UKeFLB1Tp/r+qdvIvFROBdUvXBze8DCg+gONw0lH4TSPl5s76L1hCwdsM1/EGx6hUzfKrGqp
+02yK7G4bz4fp9KAynyamO90Y6bbALgOZA6Rj70DBH54hh7+ZznNoiOlwPLVzu91mObcZ/XZ3
+yIMPQyd1HLwO96IIw7k3hRaelXPbBLQQsuVDzm13kJXGnMvlcG4kUyTad6p2Lpc7tOdDOsyE
+QOdyyaC4h7lz2SINENMhIOCDl8q57ZWNQTrnkhxexeWhco6E6u6xcC6XNiEH51LEUXHcPd6o
+Q5ccAyKZBnJ2jq6zcmomQfdiMHDiHGfvkta53I6eC6wh4jgAU09y2tOGot8Ih11znDqgnOxg
+YdSBmBJiHM/ZOB0Eh/rOpeq3XtepnVAzTs6lccgO1DvFCK0MAVEOvvm0UK8gCGftcpQ59qve
+Tgl1jkq640M4ec91i87G6Rf3iJNDt3T25ens2BRHvAGpHbzfQEjrULVgOT5U0aEOfnRAOpL/
+vfTN6cwH4BSHjtFIv0EMBg04MINAHYeCJMyAgzC6uhbt5277FRnA6tQ1Cl2vqAPWdqeuEed6
+RRx02sb7DU/ougZWb2Al9MbnI65XAMnCxmnb7UqQA0F5t3GYGhM6UeZcdc4KCZgEgSWHj4/Y
+uebbEN8RdttuXeHrZdbOR4DjA0CDDAI5OCDl4zCg0eHBoO/sQDshj+F5bKt1Sh5lcGdmONcP
+ZopzPZ3/e2f/qKsT3u8RHpuQp/O+BrBXxZwRZoVmOO+hDkvnXe4MpuPqvMud0XQ8nP0DQeBo
+um37RFA4cgZwyi0IciTMNX2gdKKxk6LosX/+cXNSfh/KR/TGh9EOsdbBlJDQyT6Jr/HPsBP6
+zvVg1E4oA1nrn1EnCB1lHdQMsh6cDuBw03FymAzSbWynYdDvM+SwmSu0kbKdliGGEVCYDsCw
+u1fggB+E1vjvP54Df9EusxJH+Dh//lSM1oH7ITFGDsyExCgcoA4QJiSmduD1Ow7G1E43aAf/
+XGIMHOJzj7cnOOH+7uH8u4WDc4+aISAD599/ZzgF4+eUjM7pMfOcEKY44bMcfDXCYTGf4hCr
+WTrUasNOYDFfwGEyB0SvZOAEBkOc//CdMMthxKc7tgzquDKHY6wgl/nsGfwy+fd0nk7Hgjmd
+L+U0zOmcjp/TMqdzOt/eAZjT2UL6M4kv7oh/XnI6XQhiTme+g73FcH59BBvSOr9SMC2N86sM
+YwZ19BDt1IweIp2WUUP/Tw7EKCGYUTrS2eB0dkY0WdP1RjuCX4AN5aNyZPlIf6nZceh0+D/U
+zB0I+hoO/FbXaSGUGXMkO9Qhp5QohgiWs2lKQuoMhbXzP/buRbttHVcAaKiVxrHSk7ju+P9/
+daw3HwAIgCBjp8S6d05i0doBCVGyJKvSsu7OynTnkR2kDnCmO1R0JxfSsn7wOhB8rb7QETLd
+wR2K0TrQixUcMBo5JPN8Ds0QDv8xtyUOdYJaXm2oQz43SuFQDOexps0dVbfRj9syG57cY71s
+HRGjd2SM2hEyWseYAR0F88gOzYgPEDGHLgLNnAM6dE2LP8ZhTmYT1aYDOwRj5dBVAC9kMNLD
+Ay1jcRzSyOEx3dExD+foN9FnctiMwCliuE5pOvx8ypiSupYwT+CIGL0jY/RQI0fKcBzmAwVL
+He4DBWs4YoYBfaOjYHgd18RJJlENo9mCGjk65mEdJSOF1MyjOGFV65kcRD1eyc6JZ51GTglD
+Qj/NCWfrMiZTca0cs27jQ8XOS7yWSgwMt3Ag6bmdFKrkJFAjpxYTQ42cekwI1XReGjGbVBvp
+0aNHjx49evTo0aNHjx49evTo0aNHjx49gmh0crrlufYGUPOLFO2uutSEvsVpdvmtHtTIcXG0
+cp78Anbq1IEAp9mtDDUg0KkAJcRQB0qY5Zag2kwtCBqcGhBYBRUgxJml6k4FKBn/ALKT0lXX
+KbvQ8SlbKHEG/3czKB58TxosoZxjBeFO8EsDxwRyuDPtH8wkyolr3cxJKtsOco0g0Ilu6raA
+IMdBLxZC0Drj1wLeyEG+i1ecEbRKwCmGwDXSkJGDfa29DALXCDpFELJCwtEdnSB/OZWQCoJX
+iEAzoYNkztuuWTkw9HYPHYQ4MDQxb+OogSTO+LZC8xDZOAC0MndHAaFrxZ2l5wYjJ31pd5Za
+kEH7SvMJec6SkOKL2/BOFGO2hORfeFc5kp47VhpDHEf+oID8AAXOm3Se85xMQr5y34SEI4R2
+E+qMpyWUUJpQ9ErEbJBtx91/jJQVEj/RA3bWHds9xrdTEpKEMs4eY8qIII4z/QIxp5M8IcJB
+FU1C9MeEZa3jGuuPW0I86Fgr4bgxiNPunQwchzqj7zChnONo58Sd5pK1Cx1uzxGOyzjjVnMW
+CRGMaUJUPiJI7by/r5RJQhjzPsUCMUtO5bzvzmjRcSuEOe8Sh5EQ1m8zxJ4UaGcgnbtkWNpw
+ua0hmE1pJwOtm1Chs0CQM4aOBYROCFKHgAa0FFZJdqCQyQd1lkluZB9sqxMaJZN2SUJCh/rs
+ne24UfApheo3GhrHhk55x7V0WnQcM6FyJ1txso4jnWmOe71H1XyWhF5fScjCcYeDQRb9tkBN
+HNfKcUNjB4HsHRASnAWWOb9+rf+Zo4rz6gGbM/CvpOQcCnJ1nNnynfWDhYXjCMdVdF49ZrvC
+Utc5zj6YOPtMGjjLuVJX0Rm3Dec4l2LkuNgJFTsngKbZJgorJ9iGUsbKGQIHuF5Yx0nPpdk5
+g88kUC2nUj7e0cgreArSLh+3M1DYO0Aylo5bN1VgbGo42BVwG2dZ+ZJNfSf8qa6DhYmzM7j3
+TM4+9kT3mTpUmDh5RnOWNFovp9uUTrDG7Te6++TOEDrHL3T3mTmZUVL1G/RbqUO/3auCwn4L
+1oo7hvkg14ZZTNaJVppsO3tVWzrANsrZSEvz8X8v3QUF603ezC4DiQP1DWsSLXfYZZBzoJWC
+TmG/5d7NLbcyh7UrtXGMCoF64+22OeWHCLRzc7tTOEAZ57b9jDDscwg5J5OHoTMMVDVwIbZT
+2HGYcV6dm8slVOScz+fVuafkqML2Fsids+/cHDXvMDsOd85ePtTmw0sI+KtWZoMy41PgnAMn
+Bw0sCHDOkbNJRQkB7zsn0DCQlXD8KHHOqTOVHG//oHN2yBU7CXQGnEzFaZxzGGHFlezsaGdL
+yBk7Z9i5HbvwOo4HHfvWyg6HyTkDwmyVwJjneM6AOS5ilJ+DHNe5QzOm7LjNwZigEModhzoh
+lC8GG8frY2vHhxi1YOGwSi7vwEy0X3VT3VHDZOCw6kHvyCDKwTefJYycdWhxx8VbK1EMZD4Z
+J+i5tRpkCbHG55wWt7QQ5E52hHIOxTRzgJJr5KjHR+YIK1vrLMVt78R1IN1S5wXZzRSe4rAx
+IpwsBDIIlOm3R3AQxtrBGP7FYZYDFwG6CeUcDHK4w754Py/Ym0PK9R5Yt4kd/PPC9UpAcCHg
+/bZDVwjxo8xZI10tEHkHgsRMZMmcpdv4ziFJnUHoXDcGKjnaETGLdYWvDODjo3PuAZ6qp+tA
+5zA7rtSZpDYORFGOngFSquMwEmrkmAzPNa24Gg60qVbJZ3LirqvSb9chGaI6zrU7/7qzvZPr
+6JCvKVx15+trhZIpwdT52iK9Uog5JenMELPfyhi2U5hOVefr8ZwSxlV21jc4hSNm7m9ROLLu
+2t8TOtGMYOFsPwaZXLKOiEHyu9wjmHjkTmYMd+ZyKXC8dxItLpcEkjlBCaFNLoWOcwznejBK
+x/EckAEcbjq1nJhBGl6aO07jJIqs27gOm7lCGw/bSZms4xQOwBDTAaDwHIjhpi1w4DemTf63
+hqmzL/3zxwWK2smkY+XAjDuY1XFlDsK4g/njv4wxOQdj3MH8QdvwHfx9B2PgEO8Lnb9r2Dvz
+EWjMEJDamWJx/vpRz/n7lwMVO3/bOK6REzMaJ8dM8dMdrN0DOBwmdtB2z+LwZh1jh2iGOzzG
+8Rji8w/TcSzGwHEc5pkcx2Bwh8/MUK4J5kgYTiBOXWZ3rBn4tKU9Q1xeeErnpTsWTHceykmY
+7nSnnpMy3enO0zsAo3XEXzR6eIeAuqODfpgDMQ/vEE+VsXXweCTnv/9aOP/NUYPxnf+OqOn8
+F0Q15782zn9xtHK0EMxoHfFzB3GHgsRfCt0cgCEc+ZdP9Q4GNXIQprUjqwPi68GWDvGddIxB
+5x0yHbzjLB3qO/Z5hz+RUl/lZziOyajKIN1vZxUThxfyzUd5vNMoH3zCbpQPynRndeDj+OfN
+p42D1XUjB2ce34Fe7U53GjoEo593GjnQqz/MoRjL8zuNHJL5hxzGE9j4DO4Qn0Hl1YY71BOq
+zB10mZlDPnBLPBkoHQVDOgJG6YgZfbeJlId3hIp+OrBlHtcRfsymHGpwpB/nKYhwxB+vCIeq
+aUOHmgn0TOLQM04zR8tA/YYqcLAYgw21kcNjnsZhMg/nqCc2saPfdgQQsvXyGb5Tlk6RI2C4
+A1SaTokjYQo2IBGjd2TMwztCRutImQdywG3U3gGnNjGTh1o5UL8pGFUh/DBHwyggHfOwjpKR
+QmrmMR09I4OewRFARcyPc9hQIfPjHCZUzGxQRjRwELi+A0h1mBR6dieGqjkv3+LUY0KokVOT
+8aG6zksbpUePHj169OjRo0ePHj169OjRo0ePHj169PieaHMOvNXZ9rYXDxpeDWl2Fakm9C1O
+s8uJz3991LWBYqaZ0+rCfyUIcJrdMlEDAp0K0Lc5QxUoTWW99bW6UweCBqcGBFZBBShY+RD/
+WMsZ4p9rOdWg2NkpYwhwhgoZRVXmQYMpBDtDSLZwjOo779hADMdCcpjj5v2DGeQwKHqlFHIY
+FL9QCOWc48UyCHOAF4sgB0HJl1bKIdhJohgC15g6xZMdvEJ7CF4h4BRC8AohpwxCVkhDlZ0S
+CFsfDO3L6jtO5ZB/dBJvb2+jDhI5b1OMowYiOyeK8c2HrJwEWpm7Mw5iSOEsCQ1G3z9Oobcj
+nLjn9rWKnDcn7Tm8m+KX3t6ihDQQ7Ayo87YsbuXIH0iQQhlHCmHDkexXD+M0hRPWnNw5nTQQ
+1k3JIfC2kZ5OOyQpBdSJPzwEyeyQ+Mkh6WFOyIwBMceyixAmRDnTL2PCCKG8M/8GMGvPWTk4
+c4f4pZBzEOa+F5r+I3bQgvOccY31x9MCCR8lRDpjGKfd40PeWp0DIMgZCxx4X5d35AnFjNeX
+sDNuNad6ppTU4SZEOI7lMCG18/5umRDmvN9jTYp5HEw5DnPe3yPIJKH6jiOd97UarBJCxmeB
+DEsbLrdV0kw+Gmgt7VIH7bkxdOoltEqq3RDmEJBuvypzJmmZe1zxM+0GGhLuv5s51GdiZFI4
+oFFwToFg6ISmeEAHgY7DK9opHiBWQgaOazRA+cq2clbodYqqjjscHLJw3OFgkJUzNHFc3imf
+SVeojeM2B4YEJxO4Tgz9ukcV53Vb+xHLxFN8jDA7jnDWA2QTx0voNYYkN/1InInynaGN4wwd
+FzmvHrN9iq7rHB/WbZwBcsbtUk01Z1y3T+9UipHjIme9pHGEiTNF4ExdFoaVE26r6XIjZwgc
+4NSTnTM0d6BTdhUc8IK7keMNEHzx0yyfvbLhBnb9tkJALrbOMidAfWadD37LhZWzrb26A/xU
+Mx88TJyttwjumZx98IneM3WosHNoTcFEf/+x8dg7Q/groBs5Q/ArBfAhOp+BNTzF1xmY3cZw
+6LdHXDVn4JWb0AEvcXKUvBOvNmF4w1PieBdsbR0XzpUBW9px+BsHL5/KDns2kDnwJWhwgb3j
+/afAidaavDu7x9Y4qbKmk1eKnaDo6ji3mx1EOze3f8kAbMH/bJ9xbsvasHyCBWUOva2aOZkB
+YndczrllCoGbEPL283lzXGXnvDr3jOgRKnHOU2zOzVEzAjMhwjkfDrWdFjgLsyXErwSGE6wF
+dNB8JAkFqzlvsXUcPcOJEvJWszNHJdyoEZJ1HO3cUMUxK4FggtLmHY4UOuy9EN85nwGolbNZ
+WQeHSMZ3bmU7b9oJILLoZE7MxAnpPzbwHVYtZJwBYTyIV3M5Z8g6d4hTC+UOrxgy44M6MVSW
+zxp5JztEHAdi4tLOQdp00tJeD7zNnQjKjZOJwygIvQNCFfIBIZWDb6ZrJLWNMgwHZ9Laxo8X
+ipwEknYca3hkI/QUzvmnO0RtWzrUtG2dD9Z3uJObDrC5VOhkpx0zJzsfwAwMEeMjmd9KnFy/
+IQpccjlHtJ9baw6CtI4zcwYKul6v2OgI++34s0CFgGR1sDvXK6h4UVhvC7SuCxZgDHIgyF9M
+rRqTKjtXisGdoNvY4bazzgJnkDMzxb07qdC5yhyndq7gGSa8DtTOJAkcRRkQUisnhUwcRkLd
+SQM4ZiQYUyeGTJxJiruujnNNhujfccqYn+Ls76zquK8pXHXna3HcNdlSUUfPbFB95w7FZ+ox
+p4iZId74NHIKmZxjlU4K2aXjKjvuOrd3Tt5vImZ9i8KRddfmJHVA3MOhdZYfw0yGnCNirvEb
+ltVe7lHq0I0O53IpcI53Ug0uhU5QQniTS5njHM+5sBwug3bcpY1zKXRi5psdmGE7iSJLh+uk
+TN5xcofPXMGqZjoAg08HIMNyIIbq3gThOSATNzsW/A9srnXAFv/7X4GTSefPHy+VCarj/Akd
+uDHHQd53MH+QFjIHe9/BmDjo+w5mdv4uoXXw9wXp/D1C5VAdMS1enb9/85DamWJ2/kZRyYmZ
+Zg4MlTopU8Fxf5yFk2Wca+Vwmed1kIaEw2BMnIfOB2tY6MQQ2g53WIxjMsWO4zHE5zm5QzUr
+dhyLMXToVpjDVRzjGIRwBMwKZdpYOE7KaJ18QI6zZxDHnKEu/zyj89IdC6Y7D+UkTHe6U89J
+mTpQd7rT0IEYpSP/QlN3smHpiL//o3WIZc/Yb1KmO92BnP8qMYHz3xzVnf+2qOv850VF57//
+BBA+vSGMzhF+pY1wSIj6WuijOP8JHclX9Co4GKNxqG+KZx3B+FBfSZc6BEM5KIPMB4x02F80
+ix3Hy8YRDM9ZKRIxcjjR2AGXWTrU9mPqEFAjB2ce2kEn0u7kHeh1aweDajjQy40cgulOd7rj
+OUKmOzrmsR0wGjk0QzjkM5DsHOpDaCNHXgV0t7VwiIN1RVU/iIMulTK0w2dKHIFS4AijOw/t
+5Bi5I/08r3TEn0d0jvxzj8pRM5BDPd/Y0CEmNj0DOvjcpmZSR3pYwHQSqBIDJCRS9E4d5lkc
+LvNojvi8q86Rn981dfhMkSNg2E5hOuw6KGQK6lrEPL4jY9SOkHl0R8o8ksN6LF45BM0Fz+wA
+oWAe2dEwCkjHPKyjZKSOlpFCjRw9I4MaOSWMBHoOhw0VMs0cLtTIKWaYkIHDgSwYDlvDgahK
+TgzVYmKonvPy05yXb3BqMj7UyKnL7FJ1pkePHj169OjRo0ePHj169OjRo0ePHj169OhRHI1O
+6je6SNHqakj7q0jNrr41u5z4A67DukaQawQ1cmKmFpQ6dSDAaXZvRg3oW50KEOzYQ4hjDaXA
+ditvfacGBHXZJlVz1vUfXwOr5gy7YwxFjB+mEM6skrmTMpYQmY8dRAyPKZR1jKoh79hADMdk
+FuI4FinF00EtyOFQ8Hsh5BwKRb+XQTnHe6kIwp30xRKI5RjsKGIHe77f8aqpk7xcCiErTF8u
+hJAVAi8fUGWnCMLWZw2JnHWhBiLWlcbbsrCy8zbFqISwzsGct3Gcl1o5APS2hgqCHQh6eyuB
+NM7bvLiB8yZPCHFS6O0tTsjkC+LJtvqWQlZOIKWOCNpWq3IUDySIhyPnOGEpeOtNGf/FwzjN
+IYQcDKWHVxGjhrCEtoiUxRGUAuIk0DLjnE4hJH9ySLzBhD03jG+nJGZI48AjNP86powMwuo4
+qgOIuUNiB82HYk4n/gixHEAYhQlhjqOdcRx1CZHOuK/c+2mHyhy/NEYwZAmhjmM5bMhbq3Mp
+RDhbKbRxuAnFK4+gvHMSJiR13t8tE8Kc93usOUkrAYQQ5/1dDuUTopzRMCHM2RMycAZ8fBbI
+ZoQGBHrfwqwSppXgCb2/S2bTgp5710xykoQ2STNro/kgU8/miHdDWD7YFLc75Y+0G6iExiOf
+0oQGMiHxcQLxUZVMqJkzToclgpMklEN23BSSkzEZh4SG4o5r5fA6zsBx7AEqdDZofL2HQSGg
+zrqpvr4SkImzQK8U5Ewcl3XGRo5RPhPUxHG7A0NmjtudBfp1j/v/Lj/8quK8bs4Ro+BSSs5x
+ARQ6ztDxEpqoyHGVnADaPsBUdlxN5/Uogv20Z01n3LOxcRJoUXymjjPOSnB+w8hxobMofhMT
+xwVzwuQky60c52cELDVyhmCIgMtrds7gMy0c8DKrvQNfzTVyDgi5Jmnl7BsrfMHYrt/WTQhh
+LMfHP33+5M7gMoyZQ9+bYOhkIBtnqTcKMnHm4UFvtjBzthJo5FBloDwJl1zYgK52iB3o7weT
+quAMwa8uUwU6J/zbczMOH4KcKLs6TpIcBypkDqs0nzyB7KstHW6v5Z1ovYhi7aBMRedYfV4p
+cHaGkQwDIvMJr3ZXc5j7BLEDztOsrVTqxOvbBsjWSXdw/G7LOPR72VtPkXO7ZRISfOamnRt9
+LBq+XuLc0tWhCRk4WAs750YXAhsqdFypc96czF670Dmfz6uzUpjjQ3LnPMXu3FCkNKFzCJFO
+QULn0MmUnLFTmFD6V22M13G0wzp9CfxVqUMNkYFzvvGg42fJ+ByMvLRLHe7uTuCc/ajnBIxf
+CbeyoxG+Qw+S0DmfyyALp+hjg9BRf3ykGR9ilZyBcxsYY5Rxtr+TdFjFoHUSSNlx6+IBY2JH
+e74iaAQ5IZQtBRtnLjmy+/ROCOWGycjJ1wPDgRkYwpgSB4KEDqPbUoisOcoZ8M0HcQbh+Dgf
+wp1kI8J7ztChh6hkfJo55+9zEMbaQYvb1hnQ4s46FAPlg3WerYMPEu7kpgNszhY6Q3YzxdKR
+5pNNyMbJzjsYA5a2vq5RBtyIsg6238aKADkQVjrX6xXPh/vP167Dg0PXJUzqYM/+eoWVI8rq
+bYWWVaEGpEEOBLkNOhxOaB0nY3YIZCydObbOYDvSbvMkaBui60DBbJDAGXTOFeg2CHI7pHT2
+UWI5TttvsETWm95JoFZOCtk4+YSeymFsQRYOZ0qw6bdWznWIRwhnipykErrzIM72PrajQr7u
+4eo7X187FG1Bps7X1w7FUwLq6NOZoXhGsHS+jkiOEjCnKJ3JIevAKp0UskvHKRwF08pxCkcI
+zO9QOHLm/h4nrwOFM/8YAcGmCjgi5hq/Y13v5XIpd/w28Rt25g7R/Zb/+6lmB3O56B1/aPPO
+hXKYCuVcyhzHdC5ljmM6ECNwYgZzLm2cS5mTKNjfU+akDMNxmIO+n8+wHCwfgEGnA5hhORCT
+30rD5pYO2I7vsBjK4Dnw+/bFf3KCjfPnDw/KOsj7DsbGwd53MCYO+r7Q+buF0sH/voP5cygE
+pXWmZg5iEIh0CGaO2YkZGCp2UqaKAzAg9AhOjnEuqYGmDtSwO1kHbEg4DOY7Hbjh0zpIQ9zh
+MKmDNSx0eDsFewdtlzpO5DgegztMxoeoVpjDZhjHIA/g8JkdohsZOE7MKB2XZTBHxjACcpw9
+Q10uqch057GcmOnOQzkJ053u1IMApjvdeXYHYrrTne7ome78aw7M/HDnv//+a+H8N0d+XYrn
+Dmoc6ivCAicHkd9KlzgZqNj5T+BIvgpYko+FQzOek2I8x/GZ5ZlgWocTgxdspszhp/MUTrrs
+mR1omaVDzTumDgFVcCAIZ7qzQz/IwY4QzB3kSXp85/Pzk+nImMj5nKM7tRxxGXyP89nGYY5N
+qcOtAcyhGLUjTOe7HB5T5jg2A33DmWa0+x9Th/jYZulQHw+lzAM4xMdD+fCoHPFkkO22Bk7T
+bsMXmzpmjNnpt+50p6GTY+SO9LyB0pEfuKkc8WkQnaNmZI78bAvp4DOo9GQLCQl3CDwmdaSM
+0qnEQPlIFC5TPPH8MIfLPJojPh+qc/QTm9QpTKfIETBFddDIkTAFjojROzLm4R0ho3WkzI9z
+dJCceWhHwTyyo2EUkI55WEfJSB0tI4UaOXpGBjVyShgJ9BwOGypkmjlcqNjhQeUMD7JwGJIN
+k8csHUKswyRSNSaCKjovrZyXVs7Lj3XqMgdU23lpxPTo0aNHjx49evTo0aNHjx49evTo0aNH
+jx49nijaXDpodJGi0VWX9lfFml1ObHYdtiL0PU6rC+XNnGpQ7LS6k6GZUwcCnCoQ5NSAQKcC
+BDv2EOKYQ5hjDKGMMUQ4NW+lWp7kNdhDERM9xqmSM/hhK6HMJpk7sWILEemYQrRjBlHDYynl
+HRuI4ZgUOMexSAnfTG0h53hSKcR1SiHSCV4pgxwFhS8VQQwngIwdF307sxiKHeyrzqUQ1ymF
+4BUCzgFVdsogZH3mELI+0Hlz2yFXVeftHitU03lbQgmBHUQ5C2TlpNDbWxEEOhD05kPyntM5
+8oS4zttbGYQ6A+G8DWIId0LqLU5oMHQG0jH4xjvHkUEk40GR46Sl4K8acPYXD+M0hxTKOmtE
+jBgSOqeTpZMcXa3OeDppoWDNy09QIYxvpyRmSJXQsDkucVJmhsQJRWUcOxBzhwQJgQ6POZ0E
+I8TJB2MkCcGOyzjjKE1I5YzjDkkfWRQ5wa5hPFa//f8GsRPCHC/DEY6958qcAyId7jaEOy7j
+CEvBX6tLoazDLQVvpU7ivL8LN9Z47QGE1cH7PdaUDJz1mWUwM0Pj0nEciHSQhELHIiF4gN59
+SLyt8h0PsqoEMqG7pJl8MIhw3jWTj3yEZI4ioZ1S7YawfNA5YZ0VTBxq7pE6OETuhOyczM5u
+c4qh3F5VuPsuc0YjJwONo+BkjNqZYihO6Gc6y6b6WtE5oPH1HjhksqVO0OsrAZUX3C69UpCJ
+41o5LusIzv1RjjscGLJy3OHE0K972DnucF63tR9Rx3lNHMlZ7ZzjQ68RNAiuB2ScIKF7RI6r
+5YxJt1V3ts8vVZxXnzF0Bti5b6LHdQ8bByiESfEur9j0WzpAY/Qp3cgJoXFMPqObOC4qBWC5
+mTOQjKEzHAxwYsPI8fZ28GVWewc47WTrLBByud3I2RPCrrFaOfPqYcLS2S8J1Ha2+BlOlrFy
+krPptRy6CqzH52c4+SpgQkyHbKRx4pUuU059J1ttPCd5T7jWIV/VFg6rClgQ/f6nczLv36nK
+DjOdQofba4XOYOfwmJrOvnYOU+TsSeWZLEQ4m1LZOZj6DmufIHegFXITkjnxFXU2I+w36Mo9
+6gSv68fndnNkPtGCAue2HiNi+fAdgpmcG7Xc2iEGyF9Q5Nz4ldDKIaGs4+j5ujSh8+ZkaqHQ
+Od9jd0wglDkHCREba6lzJESVQolzXiNgOJOP0jkSuhGbqsgJ1pM4VC34kMw5n6OOo2uOl9De
+GnK8hHiTnGR8zpjDgJTOOWCKjkpJJqiE3N6IhkgmdvKQ0jnXciImTKjk45bAKfr4mHHOkZPr
+O7UTV0IGYjoJY+2sHZ86KUT2GwpJnVwpaPsthnI1Z+SsNYf3HsuBGLAUcOgJHBgSdhzHEW1E
+JU4CEUVn6VDFTTr4ZgpCc3HrHZwBS6GVI4JYw3NOduBSxxU4kgEqcLCaM3bmGbWNA/ed+fhg
+Y1TiwHO21BlaOblpB+s2awdjpOOTgTAFnrezdSDan5o713sQkMaBoOseBuOzxvWKK7Alc9bs
+5zXhBqRJnWF3eEEwIOQ8SMCsEMwQztFtkgg6vaIzS8A2lKkDhXMFr6fQdaBhlozY/Tb/STrn
+ug0TDbkjIbWTQngdqPsNhMh6M3RSyMbJJ/RcTr6yTRzGluqsoExCNs5V4hQw16QS6qTTHcX6
+Gzju6x6uvvP1tUNsR83MTjwl1HAmKJ4RUKeAuUPJ0ZUh4zlfLo4q6QAQ4igYp3A0zAM7Kkbu
+SIE1mjjTjwew/C9+wbaICfO7XIgr6koHgC+XCSpxtncevwKLL3PQ48NB8HYe40Opw2UqOo7p
+XMocx3QuOYccHhcH1uzSxrkUOYmCNYQZrsNmyhyAqeEIGLgKeA7EMKo6aG7qLEsghuPwGLCV
+xIHfJ1MMnD9/sgbLQd63K0YO9j7A+fv3by3nz+r8PYLjpPsF9O87mD++gkoljpuZv2mIHZSZ
+mjkzh2DmQBgIKnVA5lkdF5eazskz/4gDNCxz2OlQjmU63ck7YEvcYTAgBDc0d5CGT+IkENYO
+dXhMAvEd8HQt10GbFTuOxWAOn3EcxcJxcqbIIdtYOC7PYI6ImaRcA8hxcicboGMfL915ZCdm
+uvNQTsJ0pzv1nJTpTnee3gGYKlB3uvMDHZDpzqM4MNOdlo78y40qR/ElSp0D/mjuBI/UY3xz
+Qekc6+Z9caHUAR8kYevsT1et6AxBxEsrOWzmOZxkYR0nXfiEDvmkQ0uHelabqePQGRtn1Psf
+cMdQwQFfZzqfbZzPe3Ad+HW+w7fKHT3Ecj4bOeUQwYD5dKeaI512WuXjtaqaj9oR7Uy/2ckz
+YL9VcKR70/w0Cu8CLJxgdcgeTTo8qROuTcDUcMDgOul+W+SQDH24g/ebqYMe3ULjQzM6R1xt
+pEOkA7xW6BDLrRze08INHElkmO7oHCvmpzkPMjzNHM3pEA1jlFAjJ8+YOAwGcwQTNc+BIHwH
+p2cApwqTOkKmzDFnwH7jKyWOKLjMkzhs5jkcPvMUjoApcSRMgSNiHt+RMWpHyDy6I2WaOTpI
+zjy0o2Ae2dEwCkfFKKBGjpKROlpGCjVy9EwzRwKVMBKokVPG8KFncZhQMcOEDBwWZOEwKCMm
+Z1kyFGbvgFotJpIqMgFU1Xlp5by0cl4aMc2cl0bMDLVgevTo0aNHjx49evTo0aNHjx49evTo
+0aNHjx49viuaXXRpeLWq2VW+Zpctm12HbXVduSbU6kr5Nzmt7jCoBjVyEqYSBDhVIMipAYFO
+s9tn7CHEMYcwxxpCHVsIZ5rdsmUKkY4hlKw6/KpZJSd9XFQNZ4jCUiIYU4jKZ5MaOGYQXAb2
+fYfUm7UEbjwVIMeCykcpdmpBXKcUohkXz0R18gleKSsGhuMsEqKc+NUSKHGQryAfcl2nFGI7
+xwIjB3/AbAmErA93lJDAebuHeoj4ztsSyoSQDsIdJcR23t58yMpJoTcPUiQEOhD0FiZk841d
+YBN6eyvqOa7jM29ODuFOaAXOvBm1csq/iQ7tgkLHiaGMs8c3OU5aCuHKOc5pDi0ErRt0Tqcd
+copHRjCd0xHChGhn79VZGU8nNUQNfuCc4ph7ztgZE2VNyLjfIEYGsRyYOZ3kjn8QnUAYcxJU
+QsYZSEeQEOAkCaXrH8dxHSHpo5HiQvactNjGcYPYCYUrdi6GJmf0V7+HsOcQx8twhENYCsFq
+XQqhjjAh3HEs5yRMKGVI5/39XVjbuOO2OoCU93fhCB1rjZntSBtx3te+k1YCEFln1CQEOXDH
+vfsJiUsbSwgbIA8qd8iE3msn9L5DkkoogVSzaW2HgLDS3ijR3KNyFknm4NA6GzVw6IQ2pxDa
+dxcYpD3wkTmjqUNB84GD5JBe6YzT8Ynk1IXWmWIo7ri2znKY8Ppa3xncnXnFpHLngFo5r684
+JPmsiji7RDmSwkadVWrgOM9JoV+/zBznOa/b2r1wVk4AvcZMLecu1XJc6ESQ5HJAxnGh85qm
+U36wmHFcTefouHG/UGDjIAl51yPqOfepzbvsUcWZ5gEXXoswcqLKXhXv46aVE0DAR2cTJ+o6
+aHkFB1xu52wQfJXV0Fmg9KyTpbPvVscGzrB2GnTt07LfZgBmjB346rel4wb8ar6hs511ru40
+6rccY+RkGSuHuKfD0iHuUbF12vRbfniUp0mjldZ0huDXXBnYOPnhYTnpm5LVZhkOBLzJX212
+zilwkuSyTLHDTKc8H04VcBwbptThdtvDOJm3t3IcayO1cHhMFmIoDRzu6BjkQx63mTmVxide
+J/5vehfmE+9JCSZaIOw37823G73HLnK8uN1uxNLYyUC0I4HKHbznLB2yFKycGz3z8BPiOPg/
+rGbnZGqB3XEMh4LYJ8eQ95/P58O54SXHrgSU8SHmpCB2zqFDVly540NoyQ1MiOVQtSB0/Obn
+cwoRDgviOjfWfkjUb2fI4c1yEufsReggnWfg+B2X3R3JnHOJg0Pf5ZzPBJQ/xjJxiFqQOueM
+k+s8rZOMUAZ6FGcb3tRJoZJ+W+soYdKElGf88k5a2gORE298ACdOaKk5FNI7YCmg0BM4MFTB
+gSCEQSEOk25ERHGXOJKNqMg5Jw7adaSDb6biUngIx+WcuOOImisan290sJp7YgfsOfvxgYco
+7xAMPGfDpVCSjqnDn3eUzlY44nTEDj0foAxY21S/kQ7JyBxigK73MMsHd65HQOMDTAl553ol
+FJBKFYYzr4lAAE7mrL2MrxeDIIZ2BhFzD5BAoW2R3DmopBQy4yN2ZgkobXvnCp52xh1pGUQZ
+cfNZ/iKVc4UqAs/nDmkZACLrTe8kUCsnhQrLjZ3QNzhVB8jEYWypNvnkIaN+a+UkI/RNjhnz
+Y5ztfVUd93UPV92ZGamjSOfra4fiLfV7nLJu+/oKIKLfTNKZoMzNCEbMInEcBeMUjoZ5YEfF
+yB05MUddx+uCXeA5WibM7nIJpgQbJ4Uvs4Pkw+u2oFXyhsO5lDhel28vQA0uS1AOU8Ea+ozW
+cUznUua4No6LA2l1uRQ5PKbUSRS04aXEYTPXC9PhMoiDMHpHlg7LgbKRVYG1My0AGY7DZfZl
+CcJyQCZpBreydnIKw0Hety3+8+dPHmE42PsOZnb+rlHJ+bM4f4PQOOjfdzB//iZRxUkZCKId
+lJnaOYcxAKR2prByMoxDmRQqclwrx2GMyMkzqJM0TBzgkPz7HXa3VXLSli8J1NzJM9/tAC2/
+32EwiAO1rOCALcscEJI5LKaZA0BwO8xhMqmDtEMcLpNCbMcVOVizYscpmFIHb2TgOAZj4rg8
+Y+O4LAOf9pcyjAAd+3jpziM7MdOdh3ISpjvdqeekTHe68/QOwHSnO8/uQEx3HsYBme58lxPf
+nwozhQ7wRJYaDvSwoQoO+EwjO2ddM/zcMYTRO0NtZ1gfzQQ/CcrUGbBsrB0xU+gkC+s46cKn
+doCFT+hQDyBEGdX81taBlvCcz8/PMobvcKBS53MLNSN08hC2SOiwhknrfJY7ONMdU0cJdcea
++WZHxZQ51DMa7Rx812nqoIxsp405+XRMHG91WK8VOC5lBM8izjDf5/hvxRnJoXXspMc7+PAI
+PpGkDrA6dq8VO0ymyMEfp2vs8KMR053utHQyTHd0jJGTZYygRg6DQR3BnkfvSA4/eAwIiQ52
+mQzgyJhSx5jB+o3LlDiS4DKFDpt5DofPPIUjYJ7BkTAFjojROzLm4R0ho3WkzIM7YkYJNXIU
+zCM7GkbhqBgF1MhRMlJHy0ihRo6eaeZIoBJGAjVyyhg+1MgpZbhQucODDByOZMIwKDOHlgwZ
+yrJmEK4WE0sVHV+qynhQZWeTqjMr1MB5acT06NGjR48ePXr06NGjR48ePXr06NGjR48ePXr0
+6AFFw6tvra4mNrw+2up6b13oh10pb3Xp/5ucVrdMVIMSpw6UMnUgyKkBgU4FCHbsIcRpdeOR
+OYQ6xhDu2EKE0+oeNEuIdmrevUf+S7ZGDvBYqrqOZ1V3TCXSMYSSIqgkpdUGS9YOAJlIiVMJ
+YjkGEM8ph0jG+7UUopzgheqODUSMT/xaEYQ76YslEOLgr1Z2jm9AWznoV6q3P6CJo4WQFQKv
+vt3D2kGYAkjovNk6KfT2VgYhTgK9FUKQA21CbyFk6ITWWyFEOwcVOoO9s1pvhQlxmCne4oTK
+vyIOMYkjhZhM6LhWjhyi1/97iumHcTdOczjp1kqn8XsJdzinkw6ieytxTqcAMnI2Ztl8xnE8
+nbRQ3pkXjxNzOlVyht05AeEk0w/tbEshZoLkj3YhHZgRJcRwhgFxTpIRIp0lMGaG7Bys22QJ
+ZR1geMZ9U+InFA9QbN63nRTZIX4pRE6SneeMQQgTAh3vlbuzrHOMQwclzH54lQCB4yo77+/C
+2sad7cAUVMTOS/DH85z3ObYRYm5D3lpdClHOMkbikkuDdlaIPSngjqPGZ4YkHUcm5KiE3reE
+eE4Owp13q4QcvAVFTrWEQudk5RCQaBMiIbgSxioODtk5WEKjxkGhbdrDoM0pTYhyRoWDQMfu
+AoGkxz1KZ9p+xsHIcaizxCD50IU660+0U1jZKzOvaHx9RRzRx2Isn915nQJzDPpti6qOixwY
+Ku83niP5rIo4LnJASNJxmOMiJ4B+zWHjbNSrD/0KwspxgTNRlRwXOa+1HBc5Y8rYOC50/ISc
+rYN13LhfKKjrHHN6DWf0shFd1c87QEJj8LGpijNOBRBe87ByAihGLJ3BZ9IPtCaOC0oBXG7n
+DF6nVXUWCDrZYOgsYzRuO6TKDnDKydhZ1w4jxs4KNXGwsHPo5VZOLoycTDZ2zpCxnssZXK4S
+LJ0Wdd0mny2nQgj648Pz85WcaJYZ2jm5ecem3/LzG8fJrIHnMKAsMTRz6I3UxmGVAcPJrsEx
+9gvlzsBLp9QZ2jnOpN/ya2Cl8yQOe3iyEMfhMMUOqwpKHUccuxc54JVU2JF9RE1XGxloOtHr
+0n7z6otSip1jQG43jFBAxNtvWajI2eOWgyTnRBgOPkaWDlULgoQyzo3eTg0dcoyCP6HIyRSD
+qUNA7ISwFZzPPoRPcoXO+R4uYBiznNw5nwOIW9qlDjFEAzMhgjmfGU4AMZzg79qcICGs83gJ
+Qc3PkIPWAi8hotfCjruvDuk9A8dPCB8mnXMWO0dYOdljLL5zPuNQ7vSlpUP3Hds5k052kLRO
+Wgk09GhOzIBOSb8NiJNCZM3lnYHp0DWn7jcIovquwAFLAYN4DsAgJVfBEdV2kQNACFPkAAmJ
+r2yxHLC4ZQnpnKW47R1BzdEONhuYO0MbJ9NtwREWXdv2DlJz1g5W2xUcwQCVjA88RE/hwHVt
+7yAMf4BKHe5ND/OSAT3ayTD8mzgcA0KOECTOvpCYSK/3kEDZ4QGhqxf68QlbXK8kA0ipwnDm
+NRFIykEM5QyHs1Io4UsgQzjrYObWHQRs5PKZIBFDUcT4qJxFSiubqgOdcwXPB2fqTePcJYkz
+t9Q51ytnQiiqgz2lPGTiJBBZb3pG5lSFyuvtJzr5GcHKyV2rM+q37JRg5mQ6zshJKoFgfppT
+xNR13Nc96jsz8+WqO19cp7Dbvg4onhHs0xE6euYOuWRGwBw54zmTxBufQiaFYEfBuFaOkzsq
+Ru6olNqO19VsR9FtyYhuL1wuF/SKuj6d5IWJQS8MMx2vVfqOw7mgF7o5zPHW/Vdg+aXQ8Yd2
+ewVqcVlC6TiXOmCbS5HjHAPyGZ0TM6hzKXISBnMuRQ6TufoM5XAVrOXF2mEwiEMOLo/B0uE5
+/F5zJQ7EMIraZzgOyOB/D8hw6oDHwH+NwGGlk1HKnT9Zgekg79uYe0y//t1C62DvO5g/B0Jg
+GQfth4P5kzAQVO4ADADRDspM7ZxDmRRSO1PgjMzJMM0chzLGTlrSj+wUMN3ROUlLwskz3+6k
+Lb/fYTDf7QAtUYfDlDhO4sAQ1BBzeEwzB4LAdojDZb7RgduVOqyDN/B0ldCJIUY63vkdtYM0
+MnBcXrF28DaII2F2iGoCOU7qOCGDfCeHB5HLrZxc/DDnpTvdydwU0J1/16kDpUx3ulPNAZju
+dOfZHYjpzsM4INOdMHi3rGudfc3AY3NgRuXsq4aeAmTrDJ5SMx8/woXVHBajcSimmhMvtHNU
+TKGTLKzjpAvtHDKdOg6wtIYDLW3koIzYUabz+A64lOd83qOB87mFmmE5n58MyNbBIZoxd8TM
+4XwKHGyp2EEhknlCh37uraFDPlLT0qGCwVg4nHT+IYeuZTOHzSicENkc7QO/5A4JGTj7zw2c
+7DjJnZhhORST3W17KzdyHOQMFRxHp5NzSAZwwnezGYHjyHnN0CGjlVP2z0mImCZOq3wyz/Tu
+DuqoJ2tDJ8OY1Zuto/lA8oxOlpE64o+/XMdbseasAQNKVos6HAZzgM/VNRxzBnagswSYw2NA
+aDs6ZOVT4Ei6jcsQHZfK5k4eljKFF84aOXymyBEwz+BImAJHxDy+I2PUjpB5dEfKKB0xo4Qa
+OQpG42iYB3ZUjAJq5CgZqaNlmjkySM+InAJGBDVyihgBVOiwoUZOKcOFyh0eZOBwJBOGIVk5
+GcqQoSRbBtWqMKlVjwmpus5LI2aT6jOT1ETp0aNHjx49evTo0aNHjx49evTo0aNHjx49evTo
+0aOHYbS5mtjo+mjr673tLmBXhVpdkv8Wpx7U6p6J73JqQYlTCUqdKhDAVIFApwIEO/YQ4phD
+mGMNoU6rW8OMJcppdVOdJUQ7dlDGqXbfY/JtrzoM8HCq2o6plA5IHQgY+aGGBDjIwwRrO7tU
+3bGASCf+FqqtE6zcCso5rpUTZlTDiV8pgnAnfa0EYjoHZO2AL+shvlMGCR01BDjYF6jfttct
+HYC5hz6hvDMczAYZJUQ4eghxDil01BDWccf0FjArZOn44TlvuoR4zvBWmpDc0UEk4/0SOnKI
+zMb9/o04Q7Hj99bvJaYXPWd9Pk4dZ9yZcdRAVAn8Ppxxc05zOHFxU2X2+4A253TyII0zANWc
+OqeTFiK2Ga/f7s4UJy/qOG8xI00o78xLT2k40UZEMAPJnEZRQpSz5woxwoSoftuXwI6oFLIO
+zpwGQUIZZyAYUUJ5x0E1IB4h3NkPGBPk2Jb4CVHOMi2PKRJARc7+oudMKx8jh99zsZP8yxfb
+KscodAmFifiOi4E53t+3hGQjlDKk8745p3LHoc77HLqSAxxHO+sQSUs7Zdbn/mHOCsm3oTRo
+Z4HMHCqhUVLaD5CQowphgnSzNjehwKnYcVqHgqBK2J135e4OcXBI6OAQUtoVHBKycrZZL+cU
+QsfsikD1nXFjxqG8444pPHUmaZz255bO/TjhFaKmKHf8A5/xFYNMneF1CtwpmhEG7yoD7og+
+fRPjMxwOCD2R4x0Pv4LQr1/zABU7LnZe19V7MUpOA2PODo2vrwcVOL9MnI3ynNdKziz5zmvA
+ODvHeQMUQ+t2auM41Bm3WaO2Mxg7DnS2ucnOGSDnYJgQw0kq2zmfMXP8hMb91aOJmeNBCWLl
+uGBOAD/+2Tj+EMHLDZ27NO+n02SsnT3qOa6V41nQIlMnLedaDhrd6Y6hg1TzszpZ5vHHB51h
+TB10viyCcg5HNHEYkM6RDo/akUc5w0ut2GF2oUE+HMbA4UV5tzVx2AX+KA5vLdUd9rTQqNuy
+0GM47LIudcw2oDyDQPHLQmcY9kHBP1YZOOl9AnimRg4GqBICV7Cs4na7SSCxs8UtC9k6zFIo
+dYihsnT4JVfi3OgpLlhW5NC1YOoQEr/jWM6NN8tpnPPZh2o6HkSVNhPCmTt0yw8R+3RsocM+
+vQz2wPkMQHDncRMC3wA46CBJnbjXAAfsPWbHEUwEYcOkdc5CxwszJ7M7lzhnwskeNuiYBJpq
+gew7Iyc7SGznzHAISOtIEzJ1KvQbXNp40WWd7b08B00pnw/CQNsQ0XfcfmM49CDpHVltFzii
+2n4GB4Kw2uY5MIMUtyghtYN1XZEjqLnHcLBZh3YgqIaj6LeMc4YYsOTKxgdy4NJu5SBQgXOD
+d0P2jqTgmA5S10/rIIy1gzFQzVHO1hrpNKzX4P0DlQ8FXe9h5eAT3NUL1vjQzhz3VVEMIKmd
+K4GkHMSATsLsFGosAQpChxcaZ6kCmYNKpDPImVVi3Q3nPEjhXMF7CDLjo3Hu0cq5Cvptbqp1
+knqwrwM2dDi6OhA66nqDIaIOivotn5BFvf08J9lUn9y5ZqceI+eamXqclZPZgn6yo1n519eX
+YziF6UxMC+fr64AqOl+eE2+phsPjNsdJHDGzpbNDrH4rYBaInHdKa82TWHUgZyIngb7V0TCO
+7jgbZ34X39Exe2fXdPYVzb95wOVyyTh6xn/l7qAXhpmO1yhhrgdzQS8Ms5gghfQdB5PJh4ds
+DZM3eI4/QCLHucSB21wuMSRxnGNAPqNzYqaSkzCoc8k4VLdD5yDgdpcLyylkrpciR8dYOEje
+ZQ47HYcwLAdQajggAzrT6zCjdqi0U4XjMNOBm9k54FG7wkHety79c4/7b3+90DnY33cwfwIF
+szIO2g8H8ydlAKjcgZgUoh2Umdo5hzMJpHamIJiHdDLMHUKZ53SATYfhvEROCdMdnRO3JJw8
+81QOg8GdpOU/43AY1ElbfrfDYjAIaJg48GnUWg6TgSGo3RM7WUbjsA4Sqzhgq3InhuBG3+wI
+GM6HBfj0aIGDtoEcJ2MOCG/xAjrSaOW4HGPlZKOR89KdR3ZipjvdqegkTHeUTh2oO1ZMd7rz
+7A7EdGcO6hvPIKNzgjupeA9WVTKD9yPrIS9FDvi0GdNu8x4pTt6OVpoO/nieek64tJoTLTVz
+NEy5Ey+t5CRLrR3kgZEIo3DIbOo4wNJndqClZo4unRIHWvrEDriU53x+fpYxPOdzjurO5x5V
+nc9PDlTsfH5yoAwjdjBIyygdLF25g0CNnAzzbI6eeUgnx9g4mU3HxPF2ohWdgcm0cgiGM+8M
+Q+bgw8QZorB1gk4zKAOOU3N8gnyYDsUgjvfuRs667jqO/+511XmHZPJOkJg6HcgB11JWbfzj
+UUvH5Y8PTRgqLNPpTi2nVR1oZwOmM7RxhjbO4J1zVTIcJ5ywdQwDGpo4x8opJ8/Qjr9uwmEw
+lBPuQgsdHNpWHO63tQzqDF7QhwdFjocMIalj8k7uKL7IGZBQM4x8TNLhFUJ5OpwZYWdLGPau
+rqzXyi7UCpgSR8I8gSNi9I6MUTtC5tEdKaN0xIwSauQomEd2NIzCUTHNHDGkZKSOlhE6akYI
+NXIKGBHUyCliBFChw4VKmWYOEyp3WJABw5JsnKxkxeQoS4eQbBmUsmdArRoTUlWZA6rMbFQD
+pkePHj169OjRo0ePHj169OjRo0ePHj169OjRo0ePHj0eIJpcHm11wbfxBezaUPsr/1WhVvcy
+fI9TDWp1s0niVIK+z6kDAU4NCGJqSIhjDmGONYQ6rW5BM4YIp9nNe5YQ6RhCtGMHZRwzKetU
+vDM1+l5ZTcdcArsq/aZcK6fObeSH44GVnPS7hrWdXbJ2jpVH39K0dhJzqOIAyRVDWccIyjth
+MRg70XZ6QIYO+D3gUojrlEJZZ4hfbuKoIcTxfkn9qs7bPQoSyvVb4EySMiHACaD95zcPsnQG
+/+dheNsdHYQ74cOk3gohyplW+Hv73XMGY2di5pheGVfH6SDa+b06LnHKvyN+jMnGLM7oOfKE
+KOf34bjdGQcVJHXGcXTr1mvlOMAZT3M4cUJIKoizMicnhnAmccadmSFZz+1G+hSPxDkYec8h
+uURlvTinkx5iOPPiUxyjtbMsTBxhQhlnXZYq9zBz9kUgI0so72CMLKGsgzMiCHf21+s6+8su
+Xf++Ld2XWjkudsYl9lKQQWgRRM44+o48IbSmPWf0HWlCkOPc4QxuPDLxGGVCsDP/PK9zjOL9
+fas54eO40ly2I46YmJXD0SXkOM77+wHxt6EgIRdDuPM+6rchJ3JG5aSQxCJjzgJZOA52DkjX
+cQhEOJUTevcTauUIOo6CHABFTvGz5rbI5lMJquGQHWfnDOC2ujnSwwT6qYNpRolTltBiQD3n
+ObJPd8TgQJVw7BvG5a+xcabdNwDNu1kDxz+dNL6+xtQS9g4sGTpT0b3Wd4bdwSBX+tTOVs6w
+Mcv4bNAvLywc//jx9fWQfOeXheNJr0fUcHbJc14BR3a0SECvWEJmjjs2VCChrfpNHId23Dg0
+cUZn67iw4/xeE11SYzgudfyDfzvHS2ickeAzhpnjJ+S9KHM4hTDvVHcm/lhm6AzL/AxfKzRy
+ws/kwOIqDgA9neOffIYWmzl7UvAiU4eI7nSnOz/ZwWYYWwefMQscMBsRw4O+2fF+qeY48h9B
+t3SEYeDwMitneAVh4LTJhxmlDrfuShnu5lrs8JhShx2NmEKHP5kW5mMG5RwuU+jw/4LSfkN6
+Lnld7OzHBtQHKzOH/Ny7NLN0EASA5OPDMOQJESu63W4SqMRZIHSITB1uKRQ61EgJII6DtrBz
+buRMGv4NRc6NrDpbh+g9NsRybsQ0Z5oQbzpVOedzAGHN2BDK3CGv59Ckxc70huNNZwAC+457
+fjn8y7b3nBMHHSNmQmivAQ7YewbO+RZA8DAxO45iwoSwelA7Z8Kh97Mi54w7uf25xDn7ATjU
+zlztpB1HbbMURDKwQ0BaR5qQstsaOmBpozWXd9b3nuNIHLK29Q60DeFdpy0DtOQQqMAR1XYr
+B4XyjKy2SxwIwmquzAGL294BNyK464wddIzKHEHN1XAECW2Lh0b5LOWDMbAjuXbP67bkQAGv
+7SpOk3xa9Zuo4JgOUtdP6yCMtYMxUM1xHP7+53B4J2TXhQMx71zvYedgh1UzswYwPsA2RPbb
+0v56JRSIAuqAdtzCRFCsxBzEMJ2NQok1QILn5FbNhIwdVCLLTeOsEqewd2eS5M7VQSdqqW67
+t1UwU8gcVbftUBMnqQfCGUocBuTXweM7MfTtTvUBCpY+vJPfp1o5uWtoRv2WnRJsmGzHGaVz
+zVV2d8KVf31t7yKdcmaHajpfs+NqO19LCB0tsyRETwgWzAJxnQJmgziOmAmcSWKNj5xZahqH
+vtXRME2c+V18R8ls66rouEOZfvWIy+WScTSpuOQVC2dvlDLXg7mgF2x5jrdq1LnkHWZHeRDQ
+YHWofmMqWMuDCUZI5LgmjosDbXWhHeLdEIM6lxInZTDncgEgrsNmLiCTOmW9dr2UOdx0Ch0l
+I3QARZoOxwEZTrFZOHjvQgrHYaYDN7N2MgrDQd63Lf7zZ/rtbxAaB/v7duYO/U3D2JmYPwCT
+QhkHY1yGSSCtMx9QEUwM0Q7OzEExz+ngjMTJMHeokQNtOnKniOmOzolaEk6eMXEYzAM4ccuX
+GGrtcJjvd5KWmMNivt1JWyIOj0GhRg7Q8Nsc8GytDMoxT+ZAzYodAMo6zsQBWyEOn2nmxBDc
+CHCcjIkgBoN+80fgIE1MHJdlrB20hY3jZIzeWSx8maVDxQ9zXn64UwvqzkM7CdOd7tRzUqY7
+3Xl6B2C0DvkV4edzyK88Q0yxw/2ShJrxH2dT18EeNWPpEE+0ARmTfMKFdg7JVHNYTLkTL7Rz
+SKaSw2UKnXRhFQdYWMOBFj6fQzKtHIwpcMCFdo6u2/QOvJTnfH5+lqXDcj7XqOt8+tHKwSEl
+gzkYRDMP5HzGoWFMHerY2sjJMZaOrttETo5RlBvkZDZRKyfPWDjD0MIZWEyxM/AcnOE5QxuH
+y6gcjLHOB3Va5WPreO+26Lbvdvy3t3IcczqgGLmjS4d5+FZabf7hKMEU7hMQB1pJaTrRxwXt
+YZvUQeOHOcXlZufQDM8p3kofyyme3HhO+SQqd+Sfr7jOMDRxBpaTZTJQrEhPtugdySlEtgMw
+aoeCLBnCMU2n2GEyuGObTqnDZZj9hl76M3A8DF3MZsouCPOZIkjCPIEjYvSOjHl4R8hoHSnz
+4I6Y0UEK5pEdDaNwVIzc0TFyqJGjZYSOmhFCjZwCRgIVMc0cNlTINHO4UCOnmGFKFg5HsnGy
+khWTkQwZUrJ1UMqcgbFKTExVZHyqMrNK9ZUePXr06NGjR48ePXr06NGjR48ePXr06NGjR48e
+PXr06PG80ejCcqMr5a2v/FeGWt3L8B33ZlSEWt1s0uqulkZ36SRMJQhwqkCQUwMCnQoQ7LS6
+M8wcwhhriXBMIcppdTeiJUQ7dlDGaXW/qBmUdYwkhtPs3mELiee0u4283f33tb9PgPyzqbZO
+8B3KmvkE39as7pRDOccK4jpDK6cQwlaeOmUQlgHgFEE8x3nfdq7mxK9WcQb/xQIIcBzgBGNk
+6QRfDB+iqrN0hvj3YXh7e1teN3Vm6Pc99pcWRwcxnEnanBUydYaN2TLaHA0EOccA/T6g6YW7
+45Q9Rzq/fycJOWVC1Pj8DpxpZng7/oZyZ4CdZfVHjdRyptfHe6xjZea41LkrpykUkMTZmBkS
+9hzSZ2m5zemcTj6kdYYgkrL2mNMohRAEcHzmDgl7juMszCkMYUIoMxyT6LT4lIQMyjnrspRZ
+es7E2ZcByj1EI4Q5fhnGQ+NDdg7YaeqEUAdnVAlhDlwDXsmZOQ4otW2bFSQEOw53xiWkCUmd
+0XcEEOg41BnHEJImhKYzuH3zGT3m/V06QkBCDnSmHA7mfattYSWgjFu7aPTi/f1dnlAEBcri
+jBDzvlWC+AFjEbMdSs3OmDrvo7ASFujjI33i1vL7GMe7D0k77u64iLF2yEeZEc4MjfJJDoQA
+50hoVE1yiJNJyKTjlg/cSMFZOi7rCKaELJRzzDoOGR/p1EM/pC+B9A56Im6AMgoc3YFp7Oyl
+UNdxWcdZOsPy2RRwRuHHVbrbJuc1SWmudnvnNZTWWCd1E2dYHQyydIZXBLLrtyFxfh1h4bjE
+eU2cX6NogBBn2JllgCbp/n++88ugEPzDus2ZwtzxpMrOIb3CkJOdbMadTYITGreDPgPH21Jj
+Z5sPjBwXddzRa/vGbOO4MKGUMXTuO6HQcf6e0NSZ4s64XanhbJB79V+r4CyQd6HGb2DpwJ9i
+TZ2QApaaOVQyz+gAH8nrOHS0cmTnX7rTne48mUPMZpYONWtaO2yFC32jk5zHNHBEK/xHHA6U
+WQNvoMrTaeXw4kkc9mbUKJ3uVHKMmCz02A6weypzsO3Hwjn+WOIgwcghPyaCUJmDKWnPKcYn
+j8gTotdFO5KEiBXdbrcMZOugHSg5yUM7N/KIMVxS5pD1IEiI4eAtBAllHLoSnJ2zWXBa/I7j
+OET3WSQUOUhC3svFHXe7EfM2E0LfdQ4zQkLhDMG7zucEApMycM6+g40R9zw28sedEwcpBW7H
+AW/dmNC5DfAwGTjnWxJ0QlJnZaKEkAJX53M+o05md27l5A4bRM75TEHENitzzpSDFUNjh4Bo
+B4YsnHPeIUqB4QygA29CKMRxBr6Ddh2n22AHKQUE0g6PtOaewZHUtr2D1FyJA0FYbRc58P4B
+7DpjZ96JQxDTgRlBzVVxACjnILPOYzhQzdn3GzxvlznAkRyyCT2vIyqEgvH5XgeBmA7CWDsY
+cwM+7xc4WK+B25DauU5h5OytEeaKYOwTv26H4OPEaxTZMsj12+RMK3KUsodTO1OsK8kYq4QG
+2+GF3hExuETWm8ZBJNIZVM4kJZVNO4POuV6TTZUcHkMHgo6FaufKmRGC5UonKQfCUdeB2NH3
+Gwc6mDZOQb1JnMI6SOaFJ3fyU8JzOdecY8RccxXXnWTtHKeQ+ZrCVXe+2jhfXz7EdrTM1/xW
+egOyYBaI60gZ35kgpiNmAmeBGI6cCZ1J4tSBnHEaR8G0caY3CRwls7yrtnOsK1Aul4uh43Ym
+ZvOOKpf4pYuBczRLmevBXNALtizGX3fKhA6VD7OjPChtcSlznIsdpM1lDdjJDI+LA211KXES
+BnUuJU7KVHH4zMWPas4FZrgOl+E7lozUAZgaDsQIu43jCBis2iydY1mCsByQ4TbjO8j7juXz
+//z1Q+Ngf9+6+M89XKjAVJkzMX9SBZAyDsa4HBNDWsdNyyjGypmCdEKIdmjGkYypQzACJ8Pc
+oUYOsOUonDLmn3XyzEM4YUvcYTCP4EQtv93hME/ksBjCiVt+s8NjcCdpWeagUCMnbdjIeUkc
+8Kyw0KHTeWQHhIBmiMNmvtOBmsEOn2F9VoAdV+hkGeqbP3wIbGPvwG0sHJdnbBwnZB7e2SVs
+sZmzSOhCQ4eKl+505xudWlAjJ2G60516Tsp0pzvVHIDROuR3d5/UGdYfOIzSIR//Us0R3Ete
+5DAYCydaZuhQTC0nWVin23hMsZMuq9NtjRwuU+gAy2o40LIKDrjseR0Jo3IU6RQ48LIndCiG
+53zeo7rzuQeHsXBoinQw5nA+P3mQLh3UQSFrB4FoxsyhZmqWkzCkI2aEjjodmTMTBGPkLJk0
+cVx9Z8inY+Fs41/XGQoZpjO0cQbfwRkzh954ip0hjBKHl065Q07XBgyaD8Bkn1tf6BxVXe6Q
+u+2KTrgC3vhQDM/J/As2NRyc0TjJOkrTAY93gJWUpgMd90IryTNsZ5XglZg6eBSXgZ1DM4/l
+FG+ldk6GYTnFk5udk2MeyWHsFLIMw2HsfPKMTT4MJwsNeYfD5BMacnXAYjhOZjvlOTloXznm
+MJn8AHlQQTocZ4PA5VZOJrhMocNmyhw+8xSOgClxJEwJ1MiRMWpHyDy6I2WUjpjRQQrmkR0N
+o3BUjNzRMXKokaNlhI6aEUKNnAJGAhUxzRw2VMg0c7hQI6eYYUIGDkcyYRiSlZOhDBlKsmVw
+ydyBsTpMQtVjfKmqclD1mR49evTo0aNHjx49evTo0aNHjx49evTo0aNHjx49evTo0ePfizZX
+5BvdYtDoXobm92bUhVrdbNLo5plWd+m0uh0ocVrd3lQHApgqEOhUgGCn2a1u5hLqtLpJ0Bgi
+HFOIclrdxmkpZRwrKMdYQXnHRuI4FhLPaXe7eqvb79t9n6DV9yPKoOzK/S/RVnYsIA5zSJXz
+MYC4TimErTxxCiEsh9QZzJ2Bciy/Ohd9wT36an01x7VyoodwmTrLmn9P4S/RQrgz7M5vb0FV
+57e/QAfRzu/Q2V9v4qgg0vkNO4PZd50zjhUUM4mjgNB8GjmOdOSQ0Nl+cAYPJYg20t0ZhvG0
+hJMnBDrLfyPnYE5ODoHdFjkxsyakfTrFvrVDzjCOnjOKE4oZb98TMSc/RmnNJUjsLItDZYEs
+nXVhrMhrjnCODgWY06nciQ8OQOYkGyGGk4yNJiHQGRjpCKGcQzBzzxk5A+VIEso6Ll39PjU4
+fkK5OgCccdwhccexnXENi4SCanMgY5JQkI4bIef93aASgnQCZ1c2pyghv6o9Zxw9Rp3QB5TN
+/BvivEudBfr4UDmjtOM+PtInry2/joijS+hjgZwLocMZE2fUOumT17xCAJxR2HELFBt7Qpjz
+rnLgODqOcKyeNWc2QBmolRNDe8ctc7aFM/jbEOoUQ9sGtewHqjnHdrtsK5AzGAyQt90eVRCl
+IzsAzqQzDIgzVnTGgKno+OEMxmd3puoeX19fUads5gkeCTo5O/Tr1/w/9/9IP+WLnF9HjAbO
+WtdD5Lz6zq8qzgS92jsztB0Irc70v6lTugvyDutej7B3PGkEoXEwcg5p7rMxdEbpyWbC2Sth
+icARn9QmnXVGgBzpBZuMM08vuzMm6Zg6O+QORXpdiOGs0PTbjARXviyd5Ojbe8HUicJfbuUk
+ULzcyvEtaJmdg+dSxUGWGjvoUjvHEYptHVDx0xwm1J3ufLtDTmjWTv18REyZI0FNHHrnU+ZE
+Zq4LTRxGNGJ+nMOBfphjwvx7jg3TnUqObq3yz3SP7QBQmYPu4Ewc+tMoDD2ywzqqihqUjQ/f
+yUB6R5ZQkSM4y0Ot6HYD/mwUUju3yaEKwtDJ1TYbop1MeYeLtQlNDoEkCRU4cyQrVCWUd6hx
+MnbQcQoWsJ117tze6UPYH8NOiHB86Bav08BZ4nyOILDz1M728/kegXODx4g7QMBbMWet8drO
+vjGpIFy5R+qkUImzMmlCUC3wCoFieI4XMudMOsAQFTtQJUC1oHLOOQeH1A5UcUZOwIAJ4aVQ
+4KQQVXMcZ333OZfQQBQdzxkAB4TQMeL3W8wgJWfviGr7GRxkUhBeeWQ4EIQUdw1H1nEMBqvt
+Fg5WC2UOH8o6QysHnN1oB6htZreJHKjmKjiiLegJHLAOmA7CYA6/4L7JwSCEsXYw5sY+r8hy
+sF6Ddg9653oPvoNASf+CzBoGjvfxF2VSK/krGc4EXa8hFCN7OJTJ9tswMfM6MsbaCgvG+GRW
+zYOsHUzKO0IGkyo4k8Qr7HXZXG4a55qeus84g865ihyvrDVQvuNKx2eO/AC5xo6+DgCIdrR1
+wErIY5o4JfUmcArroJWTn3qsnNyUYNRvOceZOXS/GTHXXCU8jbO/iXQKma8ptoOkes5XE8d9
+ffkQ29FlMzlO4qiZBaI3VBNm7jmmI2VCZ4EYjpiJnC8XRyUngUBHzjiRo0zH3Yu4iTOFwlEo
+MeTc5XIxdLw1RankHR3jrl/+fHMxcI5mnhIunJgLeqWb53irThm+I+gpP7WgwYV0sum4MOaX
+wDaXNVSOiwNtdSlxEqaOkzJgy4BROACDOJeLsQO3u1xAiOlwmcvF2oHTxhiewx2cQgdiip0i
+Jqw2f8I2daYFMMNwQIb751g77u/fv9P/z6FykL9vW/xn+uVvEmIH64dVmSJVACnjYIzLMTGk
+deYz9RQTQWpnCjOHZhzJhNBDOBnmDlGMoQNsOQqnkPlXnTzDH54HcBjMQzhhy293OMwTOSyG
+cqKW3+zwGMKJW/54BzxbK4Yo5gmdpB3icBnESduVOjDEdfgM6ADNGjkvgOMkDOTk0iG++fP9
+TgpBjQycGALb2DsMRum473DgFjaOyzFWzk7xmBJnlrBFpg4R3ekO5NSCGjkJ051/0UmZ7nSn
+mgMwakf6RcoCppmDPC8FYiwcyT3ez+BwGAMnXlTJSRZZMk7IPLyDPyrSdnjQCQFmyhxoibGD
+Tm+2Dv7gH3MHgaz7DVmAMPo6aOOg0R0iiKeHMJzPOViO/GnbMcOhNA/1BpicRBxQ5Z3PKEjG
+0MEhYweDyANROwfdjdKM1KGZvJMyoIMdezycw+u3HGPkzEZ1Z81F1218Z+0xZTpsZxuYQidX
+b/v4Fz65KuPshUamU+wEHxIr9ltNB+g2/WywOZx0XMEsqnFU3YY6SbftP327QzFoHQRr4PWb
+xolWUVrV6PyGOkoGcZKV5BmNk64kz8gdaCVmTuYw3s7ZLHglpcMTfc6ij3YL0uF+nmvkFA+P
+mZNhZI5ybhOPz7c7WYZ//qAsHcF5iqJ0ROdDpOfC1ND3OizmeRweUw41crhMocNmnsPhM0WO
+gClxJEwzRw/JmId3hIzWkTJKR8w0c1SQgtE4GkbhqBi5o2PEkJZp5sggPSNyCphmjgAqYpo5
+bKiQaeYwoWKmmcOCDBgWZOLkJSMmSxk6FGXLoJA1g1hVmNSqxwRSVeaQajM9evTo0aNHjx49
+evTo0aNHjx49evTo0aNHjx49evTo0aNHjx4PFo1ummh0E0iru00a3T3zHXcDVYQa3d/U6kaq
+1Gl1Y1gdCHJqSLDT6t49cwh1jCXCMYUop9n9ooYQ7dhBGccMyjlWUt6xkThOu9vI291/3+r7
+BO2+INHqCx/tvsFS8xs5wdfdKzsWEMs5JFvHW3H0hIVWju1X2sJHEJgMEToo2K+VnN+/44VG
+zseH5/yewwJCneFwfn+PY/PdU9/5DTs236Vt5TjKWfvT0PGY38kSI2d5VMhvxFFBiOMoRwPJ
+nKGNs03eCkjqOGUtSJz7+k9TLF41577y02mDpAnxnWEYT5sjhzhOzJxOoytyBtBZFo0eo+g5
+X4meTEQwp5O0FEImoLwuGyLl3nPChPYeG4YEOv6CWNkgueNHzDiAmXpOklDeQZgFKnJCKB0b
+TSlkHXBw5AnlHIKZN6IWztxzLZzChHLVNu6TQ1lCQTqpM447JHBeaMc5APETKui4IB03QsyR
+kLS0PzDHpc77PeQJzdDHx0fqDLFzMBukcD6AdAjnXdVxh+NwZ0ydUZFQskelHXVC6TMF59+T
+YlM7L4fjXAR5CSGOuOOgp2gHHWeRz+wgj+tGnPetEOQPtZM7qt038sxHePuxdQZfKnbQz6mr
+O/pQDWf7YcQc4ZE2nc4OgY5qgOB07s4RAWPhBLuIxJnzq+ks1vJf6Ue7jDPEzhbSfEBod4bI
++XWEpTNUdtzxNHcfevWdX9WcV8Ax2YAS59Xc8Q8fYccJzzAiDgC9Bh1n5TjaEZ8xRZ1DQpyl
+kYGzW2nBHUdiRs5yDLk5Liw2c8fNM9o9lmT8A1hL55i+JyQ882TqBJ9cwoNkriOD4k8Wps8/
+xghrh3yOfA0HWmTeb8hCawdbaNlvuCKAGA4Z3emOBPo3HHIOsHPIKc3OkTClTojWcuLcCEjP
+xKlZJJRznFHHMZz0fGMth45HcgyYZg4H+mGOCfPvOTbMczvAXFfLiaE63SZPSOcAH1PqOCn0
++A59UBVDlfJJSqGWE0PVHBlU5vDPJhU6nlTmUMeHhg55GBodpOqhzNGukZP/BGTScZECggbO
+fQ23Obbfsg4NgWnMb78dgXWgdoCCs6Chg2atcOZ3HX+jB629RzvsjosrLITAztMNULSmWwAZ
+OkGcI+hegGkjfmXjzjl0jnHCElI5Z9CBoCLnDDvpGHEHCFUgqOA0AsGADsFQDsWAAwQMkdI5
+n7XQQzpn3wEhewdMSHWFxmu1vv2cg/Di5jpDwsAO1nWSfjvnIXSMihxJzRU4otoucWCo1EkZ
+2JFe4mQ4gtqu4UBdV+bwa7uOk0KlTnlCW4NtWEEHSUhyj8DeAppEaQcqOW6/CRywtOs4mn4T
+OzdoC6rhQAVX6CCMICGWg6XDd+JmsnSMHTQdoOaYDgRdr5TDO6+Yd65HWDgDAl2jiIZH3G8D
+BMXIHssEnnQGDh3LJ2hewyqhxiYhkR2fxWGH2pExqGTvwFIN57r2N98ZdM5d4m1BGzM31jjp
+yU06n0FYbgHEd8Rl7UFROdSogyUEjroOmFD5+LAc5ztqhu0M05e4zRwAMimDZk5+X2fkZDfV
+53KuuanUiLnmKruWE0Pf4cjX/XWP7W2kU5TO1xKusvO1OU7mKJktIa6jZhaI3oCKB2eH6AnB
+hpkgniNl3FcM0QeLSsclzldUBiaOkzp2jL0zv0HnSBWw2y6Xi53jlr8cyibvSNKZVwp12MXC
+2Vutaz6Qq8eUOl61uC2DhTkWzg52IZU1PN7fuI+P9yaPyTg8Y0sofoeB45LAGl220DgsptxJ
+GdS5FDgAgzkXYwdud7mUOFzmernAkNphMUKHOzg481AOm8GHh+NADFqVCMNwQIaulkSxc/7+
+nV/+OwXUPuvAjLcfmJEksg6PWZv9mcIBTAIVOTMDKgmUcTBm3pk60gkhtTMFyYQQ7dCMo5nH
+czLMHaKYh3OyDLzl/OtOnnkqh8H8W07QEnU4zEM4YUvMYTHP4/AYyolaJg541rE7BKNwcIjn
+cBnUidvBDpvBnKRddzgOzeznq/gMDKWtQEcU3+gArRo5L+VOCgFtajhQGwvH5Rkbx32Hw2G0
+jifBi82cTUIWGjoThS6xdfDoznM5laCE6c6/6KRMd7pTzQEYvUN8e9fcEXzhrJThfv1H6xDQ
+kzt1GbwO6jjpAmMHe7AIyJQ6wMvmDvI4kQoOn+nOgzgI053ufJfzOUcd5nA+j6jpfAbRylFD
+OecziSpOyugglJE7ykfiSB3to3eEDnbkbuygnxCYDgShDO7gjMghPvFYOlnGxsE/V5k6K6F9
+ohTKRM7O1HWOD29VnWFgQY0cgsEdlKnuFMxuwnzoJ12qnIQpmw5YjkEZYE64Bl4+5Y7zHF23
+YfNbvI6yjfSFfZxYNunwHcbzTuUOuJocw3RchqF3PFnG+1xCM3bOYqHrMXUKopGTYaycHPNk
+TpZ5LifPmDgMppljALGY53F4zNM4TKYYauSwmTKHzxQ5AuYZHAlT4IgYPSRkHt2RMkpHzDRz
+VJCC0TgaRuGoGLmjY+RQI0fLCB01I4MKmGaOACpi+E4Zw4caOaUMF3oehwUZMBzIhGFARk6O
+smNoytZBJWsGkSowEFaNCaWajCdVZhapPtKjR48ePXr06NGjR48ePXr06NGjR48ePXr06NGj
+R48ePXr06NGjdrS52eSl7d0ztaE29wO1ur+p0f1arW4Ma3UHWqNb3QCmigQ79hDimEuo0+w2
+TluIcEwl0rGDaMYOyjnN7lFudtO1jcRyDCSm0+x7C82+iNHsiyXNnGbfyKn6DaPgMRvmzr7y
+6LEhds7HR+oMzR27r7R9zFDwFI+qzrbu37/D5UbOx+zsffV7DgOIdn5/o2PzndDA+Q06Jt9x
+fSTH4rvBHzMUDk8152P5+TfmGHyp+uOAfkPOmmmp88FwhgbOPq3aOC7rlD2U4CPjeI/lKnE+
+Ms6SiQqClLisf+/MaQ6ngATOxsyQ3vGJ0ImZ0yiHQicYrYC5d9W4O4qeCxwHOSszeoyi5zLO
+VgEuZE4naULBmpFnyd1fi5T7EBU4yLPx7q/EygapHOxZfyAz9ZwkIYCJIIRZILGDP/IRdZwE
+yjre5pkmNBg6WDpLQtKOwxy42BQQ4DC7zdIh05GVHFnW95/TtY/7JCSvhI8PyJl/BhgPElbC
+BwilzriGouNeBM6qvL+/KxP68CCi33ZmgyTOy+p8QOUGOO/vB6TpuI+UiZwxccRzgv95xHMG
+3NElBDmulbP8EzKmjls/MLo0kDpQOCuEPTXV1tn7SeSI9qqeQ0OlDprQ6o4+VMHZ0xutHZfM
+OyF0snKCdI4fvQPsgLFwgqLY9jx3b/QYoQNCwZ5oBGOZQkodjwGcX/cQf+IinXmHEQlrmDiD
+xyCO9JMdXAig82rvDAfjOa/WjoOc1wpOcDwMOa6VM0hPX0mgMeo2k+e3tnISyL26mDFxfGwc
+5xVHo2PvrEesW6ntM20Nx7vWtS+u4mzThLfYzIml6MDI0CH/tQdTh/hnGGo40AJbB1MkUBlj
+6xDLTPvtARzxmbju/EyHC2FvR6caWwedOW0dPlPusJQyJzl9RaBF+XyHk4FaOTyIweSq4vkc
+4IRjHQc5b8Z3mEwzhzoWaeVwILZDRSPmqR3VhwbF3w5tsVW6DYCe2gGmhjqOHNIxAPTkTgLV
+c0KppiM4y6N2hFB3Iojp5M+9UY7/a4GTOdgVQRmF/ARk4XA+zZV33KLcbt7vcCu9s5+hvN12
+B0mtYIC806C3PdAPC5KEwFxc4NywgdI6QSXf/AC6KXlJNj573CII6ryBDzGdqfOA3jNwEsmr
+czghI8crdDghrQNByV0xVRygFoqc8xwsxw+pc14dCEqHSO2ct4AGCKiFckcIyZzzWZuQ2oEh
+zRUaqtsQR3UlyG+2vP98zkADWnTcfCAHgrAxUg8PWgr2jqTmJE7MNHMEtW3vIBNqkYPUtqzj
+1A44RmUOVtspxHcgxtRZO/xbHXZpF/Yb5gggvQOWdp182jiiQuA5CGPtYOlYOxhj7KBMWnMl
+zvVKOUwoyTxV9gAZI+caRnE+XnsU2WM72Er+SNQ5GsQQZuwUHPlum6DMyhkQa3gEDCZVcGCp
+hgNBVZy7xCvsbenSWuEkm2rOGYwcGHI+pGAWSeBMH7J0TlwN+TrQOle+ox0euaMen9gBoT2b
+uo7Xa7JZVOcUlkE8/dRy8lOPlZObesycTEJG45NzjJhrruK+w5Gv++vra3+bI6ECx30t4YSO
+ktkyquR8HcFwLJgVYjoixbnQcbl9t475iuP+fp4jYlLnK3cXh006i2TtgAzPESgOZmhHng6i
+8JziTpuYy+Vi5xDZWDpEl13yDgNwuON2ptjZywUff9LhdZv35kS5+swFu9LNcFwQoeEt5zhc
+JOy5oM2lxEkVqKnv+ANU4mCtLpcU4jpANphzKXC4zNVXKjohI3bY6VzMHQ4jdbTpCB2IQcrS
+3IGZK8ZwHEE60xKQYTggg7f6+xdsb+P8jUPuwMzW6s+fOQUghA7CuFWZAmRiKeNgzNTMOZIx
+cqYgmRBKHAHjaOYZHYrhOxnmDpGOD5U58KYjdUqZB3PyzFM5DIZfBv+Ow2EewwlaYg6LKXHg
+0461HB5DOmHLp3dw5hscJvMATtQQdrgMATVy4nagw2dKHGfgkAx5o7/ISZo9jQNCaatGzksV
+J230RE4KAW1qOHlG57gsY+S4HGPluFbOLiFL7ZxFwpZZOlR056GdmKkFdeehnZTpTneqOQBT
+4qBfcbR18IcW2OcDShBj4PCeWlPu1GawATJ3kCcv2Dvgg0VApsJm+sMcmOnOP+YgTHe6U8PB
+GN/5nKO283lETefz0wTKOZ9RWDMvMKOVFI4KyjgQ82846ifvPKaTeXyalZN7TJuRg33eMXay
+TNbhbKfBU9Tq5TMwHILhOkN3mA7G/ARnYDkUgzpoOs/gpFC0inZOfnojGaZz5IQyLCeG4DWp
+J9EX5HjU+BgEczRKhoGO41UM23FlDN9ZKSUjcgoiw1g5OaY7OsbGyTNP5TAYC4fDWEA/zOEx
+T+MwmVKHyxRCfKbIETDP4EiYAkfENHPUkJDROlLmwR0xo4MUjMbRMA/sqBg5pGSkjpYROmpG
+BhUwIqiRU8TwnTKGDzVySplmDg8qZ3hQI8eC4UA2TlayYjKUJUNQ1gwmVXAgrBYTSRUZn6rM
+rFJ9pUePHj169OjRo0ePHj169OjRo0ePHj169OjRo0ePHj169OjRo0ePfzka3Q3U6Pamb7hf
+qyL0TTe6VYMa3brX6iZB0KkAwU6z2zitIZQxlijHEiIdQ4h2mt2jbAZlHSOJ4ZhILKfdFwqa
+fRGjFGI7rb7B0u6bP0UQskr+g3m1zkfghM9AsWTu4fZnn8QPWzFzPmjH7KtzkWM2Qlnn9z0M
+IMTZeuv37ybO79RRQnLH5juhi7NW2e/KzgfpWHxn9+NwXANnLu2diR2D7zp/+BDqKCCM+fCY
+mo5DnUEFSZ1toihyPuo5LygDOsd+Qu985B3/mWkVnWPfV+DETOoMw2kJDcRwYubkFD2HMtHs
+dl/1xpxGRUKps70SMeN4KoEix3nhFYBzPrP1nN5xYMxM4MhLIXDgwymAmXpO78DP+ru/ECGa
+nnMHhDy70Cu0BNI42D94gTjLEMkd7BGwGCNMKOfcf0GcOSGx84E8whJNR5hQkkzEEM4MSRNC
+0yEcRcd9fIDOQDoneSV8wOOTdaQJfcAJTT8ma/cmIYnzsjofPGecQ9txHz4UdJsDlPH9XVFx
+L5Hjss77+wapOu4jYlLnYA5H2XHhVjoAzvv7Aak7LmLqOOnpo6jjEkc3QPBpqpwj31SR02Fm
+jpdQfWc+ROAkVOAcu9X44GBIxyhxNIcjA8gER1Y2TjIfINBp334MnOPHMYYWxsmOrpDTvr7p
+7w/utbD8V+yAULCHWPcI42nfOdzDiT84ZNIZDmiNX3MYO0Po/DrCxBk8pqKzJTSEzqu9M+Qc
+/QfIFNoOT3bnNXbKn0PqHT3+CAeCXl9dWAYmz29NoGnNUTo2z4kNocFz9vMAJk6c1e4cpxtq
+Ov5FtSrOMRvti+s4kWfppFawSOAUPPj2iR2Dy5AFjPmDo9F/IMO6377bKT5U/Fcd1ZnFn+2k
+02YNB5qeKzhMRQDhDkcpdYKpkxTLGJ+jc7NwvN116ZTNdPCMTPqtpWMyQDSzlloDx8uqO1KH
+/ifB7BhHTj1P6VBh78AFUSEdEKrRbQ2dBKrAgAlVcQDouZ0UqsMAx6l1nPRQta7DPv3SnQMK
+9xTVnOiFagm1caRbam5t7EUFDv05ywjKfmg0mXk4n02jBmJn2wRvN/8VY8fbzm8bhKVW7qzM
+GrgjgJI3bz/4DqQkkHR8Eufmbg7sPWtnHimo8wS7OqYD955gn8p2brej0BUJiRwa0jkglAyS
+gQNAUM0dP2qdFKLnPLlzngOCoDFSO2fUgYuBAxEOBhk48wCc92jlgBBeDFxnPv/lM5iDpCQY
+nzAdEBrQohM4LnKQIXoi53zmQM/rCGq70IEn7kInYZDahrYhewceo1LHAtrbrD0OOCYJ6R3R
+abik6cM5stN9LOeMONb5gA5UCFXG53kdjBFsQBwHZWyd6xV1+GdfEieGrnOgDPdkRc65hgFA
+WsehyB7bBC44O7a38P+wK04ciQF/ISufHcoRe1ISyG8zsA0c4o2PhIElXhkIHQCq49wlXmEX
+O8wtaFu6NtY5jLNj7oAGlZMklOu3qbmCuUNRNeTGR+vEVceoA6Vz5Tvq4ZE5a9XUdqZ7gPTD
+wxggkzKQOfpeu+aPEUwcxtRjlM83OSlkwkxBOzbpyBzdusWOGPmaY3tfJWdVDojrKJUdciSk
+cr6icAJHkk3iuGkLYjklzAzRM4INM0HmDsRMEDk+Zk4CgU6xknHk6XAZ0LFJ52LnkMzlUttx
+C5NzrJhiZ3tvhkEdZrcdb67oBEUEGoeDXYHOOi6KwPBaXDgOFwmdoNHmkP0mcJBWly0UDqCA
+LX3Gh5gOxMDO5WLt5Bmxw2WuF3OHw0gdbTpCB2JaOSATQ07k8NOZ2qodkIH+Gr9ppFg5f6NI
+22cdmNla/Zl+ihWIyjkIs372+DMFyMSQ1plHg2IiKOOgzBwkE0KP4dCMo5lmjg8ljqDb7hDJ
+sJ0c45yJU8o8mJNnnsFBTjh1h+lwGP7m8884LIZ2gpbf7PAYvvNSz0HT+QaHyZQ6XIZywoaF
+DgFlHSdgcCdqBzmS0KRj6VDpPKETN6vk0IzGgaFGTtLouZ20URUny6icBAKamDgx1MiBWtg4
+LsdYOZ4ELzZzVglbaOiQ0R0TphbUnYd2UqY7/6ADMN3xAvsqvHk+gscXFTu87+UUMbBjnw78
+iIwaDhSNHJDpjo7pzoM4CNOd7tRwMOY7nM85ajufR9R0Pj8tIJR5AZQCKOPEjFqSOzqIdiBG
+BzVycOZRHfppY2ZO5rFmVk7u8WlGTvYxbTZO8pRJASNwkocy1nHyTNaBIcQpyIfjDK0d636T
+p9PKoRjmfm7oDs+JVsFxSIbpuMLZDTuuMt4poA6xuiInhswZu+NepuPKFL7jyhi+s1J1GKvP
+cznmyZws81xOnnkqh8E8k8NhDCAe8zQOk3kWh8uUQo0cPlPkCJgSR8IUOCKmmaOGhMyjO1JG
+6YgZHaRgHtnRMApHxcghJSN1tIzQUTMyqICRQEXM4zllDBsqZZo5TKiRU86wIAummZOHbJg8
+ZOVkKEOGkmwZlLJnQKoOk1gVGZ+qzGxSfaZHjx49evTo0aNHjx49evTo0aNHjx49evTo0aNH
+jx49evTo0aNHjx4/KBrdc9ToPqpGN4a1ugOt0S11re7d+657EStBgNPsLs4KEuY0uwHWGCIc
+U4hyLCXasYMyTrO7u60ohmMisZx238QohbhMu2/ktPqGUR2H/eRXpfNxj8UZUs7O+fhYIfjJ
+MfUcq57LOGZDRDnTC7/vYQDFf+/mrMzv302c36mjhBAnSKeC85F3TL7jujofQbdVdD6GD4c5
+Ft8N/jgCZQy+U/3BcxQQ4fy2dF5QhnIKE0Ic64774DjrtFfgRAzs7JN4XWcod2IGcIJdbD1n
+EZQQw9kZd5pjhXROwsTTwc7MkDihrJMyJ6dICHLWl7xCm9Y7nkqg1HFpTIrHzFChAygLEzgn
+cUKRAx203V+ImdM4N1M70DNgZ+YUh7TnAgc8Cg1LwO86awdS1iFSOeDB+wBns/acpQMzS0LS
+jttrLWFwR5OQzww8RlgJGceRjrjjAmfw0yEcRUIfcEJZR5BQgXMSd9wHXHCQM3qTnbjjPgLo
+YBJnXELjJAk53FmZ9/flV1fQccHWAzvv7xukdxzljIAjg7YBcgznvcBxkLNEAlVyXMZRQUJH
+Nmf7cwIERV2nd3bIRc5WgWFxFzoucfb0wn23Pz66w6voROXxSwydLB3/F/BoxOn6LUwh/Dk5
+JJ0Z8YF2UmKhsxz7etb9x1/j9vG71PF7cBjD+DWFtTOEzq89TJy9DIa6jgucAXaczKESGnDH
+mThuu8gQOK/2jv+E+h16dU2c+6seY+S4xJkrzN5JoHnNG7NWpMTBt9QAGjxnL0gbJxql3dlP
+Lho+KDaG1tfWnyo5+1a1La3mBHmZP2DX67FwgbGDxk9zTCaE7tRzDI+sHsNRnFl8bEd+ZhGK
+aN6s5DAUC4ejGDgsxSQfhiKAiFWYDlCOWTGUs3YwqLzb0uO37rAc8HBUCZGOGwr/fUAm4yX1
+c5zchGrmbFMqYpkx3t2EEGXo+CcUqjruOEPSwtFCbGbnGjkgVMuJoQoMCNVzQqiKA1zbr+pI
+TiM8vBNNdVWc/SxtbSfdPzy3I595dA6wX63kNBsg6Uz67Q55ICU/sYgimU9x0l0DylB/vEVC
+Q1q1YG7SXVC6gvW/t9sNzg6GdAM0MzeKiXuuxJljW12iyRLKOkdaaUKCfTfDmSio9wbJro7n
+HN2HJmTk7B2ohCROkpSBA0LJIBk4AFTwKRV/G+gAY1TinO+BDBEOiZy5Y85nDSRwlv3O+UxC
+5s6ZV9xKxx0OCKE1J3N8BnKmPwXuOoEzxzkHIWNU4iBDZOGcv8VBIMghobyDTKjWjqC2zR2k
+tsscfm2LnITBSi6FeM6AOhikdAbEYW9Dhf0GO8LPwiWO5DPdw+cDTAkSB2BMCpvjYIyxg6ZT
+4rCmndaO4DN3zrlOgTLsz9wJE0HXIACHCQGOQ5BUEpwUOZr47wAAwAP+RI6z/215ZQqoJ3j9
+tkA8BYHY48NWYIjrSBhQquOkUoVum4O5AVk4nJM8R4PBxkEgz5mbix1mxzkf0jBTyByndq4C
+Rzk83ITC4VEybGe+B6iBM5+zHtSMpN8my8aBoGC5VmHsU42c7Ixg4jCmBBPm7uQqwYSZIjNC
+ZY73HrYjJb7m2N9HO8p0VsSHuI5A+QrDPaKjZ1aI55QwM5TZUE2YO5T5eGKTzlR09FQqd0Bm
+ghzDKWYyjjgdjOE55Uwr576Sy8XMoZkQquC4lck52fVv76WzKXYc7bisw+k2/714pZU6QQml
+zrZgYS7YFduM45IIEK9NkZMyLmGuPnOH5A6gQC0Dxh8gpsNkrr4SQNbOpcjhMteLvcNgSKeA
+KXTYvdbMkYxPCXPFyprhgAziLMsAxsr5GwTQPuvAzN7KpQpIaZ3lWP3PPRygpFLOwRg3LZqY
+PwgTQRkHZeagnQAqdnBG4NCMo5lmjg8VOY5m2E6OMXKyjMO2HWuHZphOcTqP5TCY7qQOh3kQ
+x2/53Q6LeTznpaKDpeM7POYhnKAh4jCZIsfxmTJHEFym1CEgnHlKJ2xWzYmaPbtDMs/nxK3K
+HRhq5GQYKydp80xOCqVNTJwYAlo8l+NyjJXjSfBiM2eVsIWGDhndMWFqQd0xYrrzDzoA0x0d
+U+bwv3BWxMCQfToOfJRVFQeIRg7IdEfHdOdBHITpTndqOBjzk53PKao7n0dUYHbns4nzGUYt
+5zOJVo4OwpkXhNFBj+xooOdz6MeamTmZ56dZOQXP1ZU4ucfBGTnAg0Cf2UkfN1rFSR4CauQg
+6ZQ8IKtBOuh+oZWDMGUPFvs+J14HwyEZ9vFB6Mifsi11lN3GP94pKzf4+M14X3o4BgeKPKf8
+uJfpuEKG7biqTPg5qx5j9XmukZNlnsvJM0/lMJhncjiMBdTI4TFP4zCZZ3G4TCHEZ4ocAVPi
+SJgCR8Q8viNj9FAjR8ooHTGjc+SMDmrkaBiFo2LkkJKROlpGCOkZkVPASJz/s3cvyonryhqA
+R6zaNWeGqUBI5f1f9QRfdemW+ibFJv3X3msIOP7SkmyMwULDcKBBjo4hQ1rmYI6aIUKDHAOG
+BJk4bciGaUJWTAuyc2qSpVKz7B2Q6sKUVj8mofoym9Sd8Xg8Ho/H4/F4PB6Px+PxeDwej8fj
+8Xg8Ho/H4/F4PB7PsIz8/Nm4D9T1lb7lo4j9oFGfrvy+T4t2oWDGXkIdYwh3Rn1G2RaqOoZS
+wzGTms64D/qPu0Ji2JUlo66UUUNkp9MlRtSZbKXO9XpdHFuoZGYImtDFmEEdu0v0cses5epO
+CP86O0sx//4ZQRBzjZlMGuXYXHt6XaHYMRkKsHNdhlqpGDvzmAOqkUIY84SA3hFDFedfLwcs
+B3AkULMcIwhjrJ1fiBOqjqagK+ak0GWMsz5XiJ2cAZ3oSamjk0wC18/ZJ7WTQBgTympC+P3M
+Ahk7Uf//XiIqCHLmu9IBEDbmd5AUhDshZf7+jiF2QaVTKM9t8+/fyBFAxXADpk39+jFlfv9l
+t1zhlMeHU6MljKCLMgc4Dr0Urba3nNwByoGYZXBLHeDo/dk5BcKHKA7IzC3HLSgeA0WzwY6o
+INRBm83aQct5QuyGS5gIutSdyxBHUFDabomDM/qGIzvKhtuZqvOb5fwqnIA7f5N9kKqD0q0n
+FEwECZ2SgZ0NCvKGi/c5886/6rCf7EBnPpoGnP/b6xF2UCgDdJDMiQsCnEL6/X8KJ+ANh+6y
+Zc/eUEELjEBc5xfmrCMdOECQOyW0/2Dq7O2U9A4KBbYTQ1A54LFVUDlgOfOhb2z9/fu//wle
+OAQoyY77b5b/fcXamYZdSvxP5oDQJWYgh98/DCcEa2eBLv2dS+RcVsbeic8ZAM5SMMshQCtz
+2Rg7p4CmptrKsXNC6sy7gK0cQyf+soK/ywn0hLGcKDYZD/udwdpJoXWzWh/s5qR19XD229GD
+hk41h3SOP2OwOwd3jjmwFY7+EK4DVFtNsUvr4gC76H4O9jXLXKjK4A9aOm3FxCF8F5ipYwO1
+mYlCNbVz+SYHgdTNVhxTnd3JoW4OCbJwMkpTUMsp3neWOW1mfQ5CISsnenoAITNn/TQUAtk5
+IXJKyI5JT1z0d+CWs3SSMz58h8zsdZVQP4cNSZ0UsmfyL1rs6YRi2PVwooHX2dmgIU7o3W7A
+0XAnhw+9mmMFnbuDBAUd2ymhPh00zCkgCwc6lGIXJGP4BaGr//zcmM7OZ4UpIKnzOTubUnLp
+HRrnmcvnypQOB2o5c5AxxzjmoTmfyFigP3cTnc+lv3KHfCyCOSCEfLaDAnGccjDQO0jnxBE6
+MFT0kdCJ/2Soh8rBIHHWFwJ/vsKG+M6fOQhk5ISwOn+QsS06y5MuO6/iT6Wg558Cl8RxEgaE
+noy5A7XcBesjlcMYcxqHM+Y0DDLmPqF3Hjo4/LNjTQccCuMcoI+UDjq2c4jp5AwyEuTO0ujd
+HaweBOIdyYsd7mlFhZP/Jsspme91tAOBwXAcQvegjK2Dl6Nyit3bGCc8Hg+M4ZxeLp0YesSx
+dgKEQJTMiX8FIACP89o+crbfailToIYgNtuFwYAQp3uICggxHDoDSZ2cQiI7TObxIA5srZNv
+Qt/s7Assi3OdB9dZIL6TjYV2sz0hNvMM0wlS58FwhL3Dc7YPnnV2wvIhICFD6KCo1S4XKUN3
+gqZ3sn1cN4awpVo5LciCeTqtEWfiPNPoISuG7jBXepuy/1oP5xZl/b1Qh7TMBtk74QZBdUdf
+zgqZOwUzQYHmqJhb+VYX4uiYL6jhsMuBmSdUbTcr5pZ1T+hUDs3RM7ZOlbnfcYjn4MztyfR3
+pmoMnGWxBpNCgENTOjvRr6LKwqBOu9nW9WPOsgals68dLmjbTS8O9s5w3YnXDTn7QneNk6y6
+7KF9qftd4eQrxpaMmaSDNA603F3l7MtHDvT33O8IJHcIDNeJ6i+OO2uMxgnoUup6IKaDAzLI
+VoYxYgdm0u0nXr7t0Mr52DM9fq88zzGYgCGxZeHMx+rv78+bJVNSLQdjprxPgZkMajhVJlSZ
+FFI7OMNw6sxIp8IkkMoJRk6LCXWG6jSZYQ6yifIcNXMsh8C4830OhTme8wtzSIxsM/0Oh8ac
+wgl0pu7EC36vQ2V0DiMiRnJdyfc7yWLnd9LFBjm/ujm1ck7oZEsNcn7pHRiql3M6J1+mk1Ms
+Y+GUULmIiVNAgxxgCRsntBgrJ6LgR+2cRUIes3RqGeTkTC/InUM7JePOD3QAxh0ZM8oZxLgj
+Y87rwIw7B3EQxh13ejgY484hHJTZnbctPZ23OP2ctzcbqOG85TFnfoGMFOI7MkjgiKAjOxJo
+kFNhuI54ynWeU51IyM6pT1h0SqfCWDpShrWdKsrhOI3eOY5D2mEjcyprHZjZJrXjMlxnnRPW
+yinW8k0Oe5bt760HWE1rvNUZ+PjN+LkUdQQMzTE47qU56uP4BhO9LlExDGeh+jBGr7OazLmc
+NnMqh8CcyaEwwxw9RGNO4xCZszhURgnRGZXDYDQOhzmBw2LkDo8RQ1zm4A6bGeaIIAEjcSSM
+wBExfEjIcB0pw3TEDBMa5CgYDqRi6I6OIUNa5mCOmqFBBswwhwCZMARokGPEtCAzpi5ZMhXJ
+mMGsHgxA9WJyrK+zUd0Zj8fj8Xg8Ho/H4/F4PB6Px+PxeDwej8fj8Xg8Ho/H4/F4PFPGfHJv
+0EcRR322ctCnOEd9LHXUB2BHfaQXduwlzBn1YWhrqeJYUnXGTmo6w65csJFIjgFEc0Zd+qOG
+yE6fa6b4c7iwnOszs1POs2JYTuoYQgAzQUMdwx5CHGwaHBvnmjgAY3RNaOJAjNE1rpuDTx5k
+6lwrcxQZONc4mGNwEXLh/Pv3r0dBqfNvytfd//1nW9AVcv49nVRSOhmzOf/ljvJqdLqjurr+
+mjn/hjhbOTOkH3Nt5wvKGcU0C3mzxU6UdUfR14me/GycADnrJHCXLk4oGBGENVsIBRNxRk45
+vp6r/j1lGwsdnMvO/P79VwRRnHm9v2PIwsmPdeaf/v5WQaVTHFM9f/gbMV8QfygUTnEkOjOJ
+85tfUO6kU2YizAopnAvg/C2d39MicqcoZ3Fy5gmxCkqdopovB2bmlrNzpnIAhltQ00m2HHXD
+pUw62mBG1nAC57exgzQbe2hDzoXiSApC6rkYOr/K8RaozkXlJFsPOgxEI672zGPl7FDGLAcf
+A5ww/VgZ2fx99goBDgpJnoSqjs0ubi8I7iAUEjtFQcvPsBO4T6pJQRlTgYQOAO37B0snTE7Z
+O+UB3MwE8WFcdv41npG8OEoIhk5879/48OpvtLDISUdB3E9/t8z3/e9/F/nxfAbFwyFR/veM
+lZO8hLvszP+WKF6fQM76JNvNWdaTOGF3JOMAhaJ0dALkXFYmSE5ZtJ3LUk4PJzk7sZRzCStj
+6CSnW2Zm33qDwGlD2w8pY+ZsVHwj2isZOul4iOszdpKTYoli7ASz92qaDhZ33BnpjJo5+uUc
+gyORDlBtPfkuurdjAdWZUDwd9HASTwlVnGopdk6rc1hOq5ruTnrgof5cAsF5Gt/tkCHUSSG0
+m2wdfDiomWEODTqRU1gdHSuo6TQhI2aRyjfW7J2w7BFgqJNTUIZOiF6jFhUZMvMzuKIemZNC
+lkxITmClkKmzaFs/9XWiM4BDnATq6QRWQWwmhgY5Ufo4gh3cKMeo4bo4IujYTgF1cYCCRnVQ
+H0cCHdopoRM54KEh+1CEwhCcJoQDnxWGXxDOfIbkbEj+8QTmsVXViYopyuIeW+HOZ6gw+V0a
+Z17R53QL6CXesVXF2QMeFVxYEOak0Kxlg6Gbk7ce52ARbA/YKXtJUc+6yZTMJ3YCgeJAygVp
+t8vl89PGSV7bABV94hDfed74gzoYxG236Z8/X8Eg2Vkr8Hf+/MEhbDDIHRC6YINB4PxZg4w5
+e4cxFjQOClk7GGTuQF2EjDmlQ9qfipw/fxoFPZmy6Xo4UB9pHWxs5xDZuUQ7t9ZI0DhgObij
+bTeawz17KXTYZ0m/zckZtN2U46BwsOGWjwSlgw5rpUPefGwdfHdg6oTH44ExrJd0pRNSZQrC
+6Jzl8O1RpnDILx2jxaLfAQjA49QTO+uvtZQFKlqB3GwzRGCeKVub1z1EhgcpGEDq5eRQN+ch
+dnjMgzqylU6+qR7IWZbnOU8o6SOKw9lI4xCceJHJETBcR9JsVGipJKw7axFDd9YP58gYshOW
+TxsJGbozWxZM2xG3GmXXY8A8KAcJRs6j4Vgwj2fHNgqyYKaQHc5Kb3Pi3+rg3KJsv9cYcVpn
+g6iOkHlKpVNCox05s0B1h19OyTyh1ltoBtVMUON1g0k1s1Otx4iZtlhDh8wEkKE6KEN01OXY
+Ojjz5dzvVk6oVXO/p5DEWZZqMUrnCdg4hNaqOSujcda1Y86y1nsBsZx0hU3mjr5jW3VCvsqS
+mcfIveVUh0HInVxZltqZ2AlEp+iQ/I5tuXsUpIO4Ttg6bfudhLFwbvCCd2uHwvCdADhtJoZI
+zvJANobbDrOeaPFQdXTtFkIJIVuZoROQpZZl5Q7MVP+akjFyPrKUizcdhImPoXMFoloOxkx5
+nwIyuVQ6tHJ2B2NYTpVpOAmkdnCG4dSZUGcSSOUEI6fFhDpDdZrMuZw2g+wKIEjnNBiSY1DO
+7vwqHfBE0LGdfcHvdyjMiRwScxAnWhBzaMxpHCJzDAdjBNdHvJpTg+LFXsDBGXcqTrLU+Z0a
+c0InXcjAQaBBTrZMLydfxsKBoEFOsYiJU0DlEjZOaDFWTmgwZk4kgY/aOZOFPZAzWsidUzol
+44473RyAcUfGjHIGMSd2QMYdGeOOjHHHnR4OxrhzCAdlxjtvb/E/vZy3OB2YXwDTz3l7s4G4
+jhRqOAUjhfiODBI4EqjC4I4AcsedBvP9DptxZ6RTXaN0/hiKs18DDE/iLHNgZp0Qv7+zQSMc
+w/4pVxNPOSaYGxZ2SiabdJBbDnj81tx2BJOgQ06LgdJgoONeCUN1IknE0J1V6sNkr3+6MUav
+swY5beZUDoE5k0Nhhjl6iMacxiEyWofKDHN0EJ1ROQxG43CYEzgsRu7wGDk0yOEyQofNDHNE
+kICROBJG4IgYviNj2JCUGebwIDnDchQMB1IxdEfHkCEtczBHzdAgA2aYQ4BMmLZjwzQhK6YF
+2TlVyJCpSbYMStkzINWHKah+TIL1Zjwej8fj8Xg8Ho/H4/F4PB6Px+PxeDwej8fj8Xg8Ho/H
+4/F4PHEGfYZz8GdSe0ujPmc76qPDoz4NDTr2FMZYUzXHkmo4w66RGHbNx7iLWAwgEjPuYiYt
+lK7ser3ON/iTuHCc63WFoOlvzJzrdYOsnbKcyYGnDerjFIy9AzNWF2teYwdijC4+vW4Q5thc
+TLs5V9SRQjCzba3P/Pfff52dfwtjC11T59+UmTGAiM5/Zs4VdP6VjvJydMQBGk51eX3OjHb+
+lYxqWoK6E/o7Xy0XiogdnPkXr3/dHdk5AXCiWeDsnUxZIGsnL0YMoU6aeNY8CQQzhbMov8P+
+lG7hZE9z84+/52yo3skOqpYffmdQBydmZBDkXFJnuvn37+8Imh9WOiF1SmaCmAWVTjLH5OL8
+zZzf7IIK50Jy/k4LKJxcWZnMWVpO7BTVPNf3F3B+2zghd3KG6/xqOEizSQtqjQK986vpgN2z
+jARrp2TmgrROcxj8XrZVJoTvDHBH0nDILrQyDHQdBD7zGHXQr8wJIa2n6ggbLnfmGDqh4UAQ
+d8D9ajn505zG2aFEmH/Edgh2DXdZIQsngjJn254AyNDZdw+GTij7Z/4JhoLA+RWvOnai+1Jo
+/ysMnW039zdSNIe/WeLd9uXvnKRV2Q4MJc6lZIydZdBtzv++YlvPBXX+J3RqUORMP/Zw4vRz
+Aurs3WfihNQJqxP1HtNpQ/sdyb9GTja5f+wEWyckznZrde2clUrd9SdTJzmJlDCdnOWH6BGu
+03w/MD9E6eUgccedkc6rzRw9bMbtYY7lTOXpc4EGIjD9ndUygAgGDpm2W+VxI6fRPSyoqQx1
+1B1EYOah0MtJmI7OqHqSlwz6D47QHHzUHczBGSJk4ORURycbDR2d/H3nbk7yUrXUDJ3oVZDU
+oTFhES7A85G1E0Y44RI9haeQKRO206XFwYKtEwMp1MURQiwmXv8oJ469A0PndkqogwMWNMoh
+QGxHWBDfgY7jOjkF1HZsChrl9Gk4UUFHdsqXXL2cly/IwAGPdc0d5Jiaf0zaUpAXI6ZOxOQc
+uyBaMWVZ3INfKlM0H/OglKDAo4F5rChlsiJFTvoa8TO6H62I72yvRD/3TD+UvaR3QsIsQTcm
+CoQ2GY9hOlHHQPV8fpaAtJ71VuksXWXiRBnlwJD0rBX4S3++AkPoWBA7f7ChDTed3EEgpI8U
+DghhY0Hi/FkzykEg6NhE6ZDHnM4BCzJw5t3bn2pBl2nM5Z3ErCdjwILUzvL2S8sBB52gfwY5
+f1IHgbhH2C0HLoh/1vfbnIz5A7eaeT1Y9+QDQVsPOt4ySFlPhbF00MMeWydUHc4roJLZoVBl
+eKf/IWfJ4/H4DI/PxxYj5xITn9H6YUnurL8HCSXHe4WaLHohKTNUNDO3eyjOMyxIzpRSN+eh
+cDgMAxrk6JrtkW1CoxwcUjoPvrP+BtdJ+ohSzwzxmCmUgkICdXOUvcN09neUJQylg/YWmxwZ
+Q3fm9+INGAxKhoGQ4TpChbSl2jiXB8MRMvkuoeWImSmthpM4tznJ75AdNjNTgANBinJSyN65
+pQmlA0BqZoX6OzNEdBTMBIW6wy0nQMwX1DqeZ1YDK22HWQ3G3FpvCRoxt5DnexwrxtThMBJn
+/dUqc7/flU5Y1tRilM66rnqraZ3a6jMmhXgOCSE7ciVhpA6hzcIjYu74W7Y1pzbC1mKmQX/f
+InGqI3nKstg9cpB2qwyDADjPRaMmm5e7mzvzknExj8c9jYUDLqh1AuQ0GbYTIAf4c5ROgByo
+dXVOiFItR9k/AYKQrVnhhFBClVEZIEbgBHCpjySheEJtOwiTHEN/AEmXbjoYM+V9CshkkIUD
+MynUcqpMqDIJpHdwhuHUmZYTQWqnxpCdBvOELJwmE+rMwZw2M8ypMxFUcQiMO32cfUHcoTAn
+ckjMeRwacxAHYSKHyOicQGaUDj1ERu1UofHOr1dwoqVewYmXGuT86uhUynEHd5KFTuRQXpv2
+c7JlzuRAUL5IJ6fFyJwCKhYoHBOofNzKCXXGztkp8DFLpxZ3jBh33OnmAIw7MubEDsiMcgYx
+7sgYd2SMO+70cDDGnUM4KHNOB2eGO297OjpvSbo5b9/jiKGGkzNSqMIgjgwSOCLoyI4EejGn
+xuAOH5I5o+pxZ5BTZQz3B+YOMulc2+HtsC+WTm31CGTqXNB2qzN0Jy7DzAGYdDLAjk4ilndS
+HObxm2QKWokDheaE3sx+HK9iGM4q9WGMXpcMctrMqRwCcyaHwgxz9BCNOY1DZLQOlRnm6CA6
+o3IYjMbhMCdwWIwcYjJHd7iM0GEzwxwRJGAkjoQROCKG78gYNiRlhjk8SM6wHAXDgVQM3dEx
+ZEjLHMxRMzTIgBnmECATpu3YME3Iimk4ZkwDMnRqkimDS9YMInVgIKsXk1ldGY/H4/F4PB6P
+x+PxeDwej8fj8Xg8Ho/H4/F4PB6Px+PxeDwej8fj6ZauH4ge86H1MR/DxxVTqMqYSS3FCiI4
+o64yGnd1lu3VZtfr/C9/EhcOc31mdgTTuAgc0XQ+ZOd6XSHJLEjMciqO1dWam4MwRs51DTxp
+kA6CnGtX5xo7+93//fefBQQ68+D+Nyv/xZLeuWbOv6+Ujv6y6sz5N+W//6wgmBnt/Csd5XXv
+iFN2kO46/pzJnNDb+VcyqvkPUOdZUdA7WPdEDhCrcr7Z2Z8u7JwAIdvTuaGT5hJFAhGd59rT
+6QZNnOx5Ln4aFxYEl5MeHyw//f5K2I/sDMpJnfWH33Oed/Rw1pu/1wRBy8FO3iHPf/7ujqAg
+0Ek6fmV2R1IQ4MRbyeb8jZ3fv+c7Vc6lcErmd1A7OTOt8W/u/OY2HOqEliMqqFbOZWIy5/c4
+RwLxHdlI4DvshvsFOiF3cmYuiOsU0CAnZmqOroNCSMqB+yeICsKcsOx1gIJEAyFgzpQOHcR0
+xA1HdoLMiaGkf5ZnOQsnLygdb8sTkJUTcOcCFWTq7Luh3AnywyuwnLAelKRQUDhrBcVwK51o
+SbFTMNFe7u/OrEsKHTBTH01O3qbc43mCc0mdi6ETHSvOTvSkIXNgCHb+9z9z5xIxl7nVns7/
+jJ19+5mh5T5NPSi0Z78rqrW3c7F1stMGYXtptP3MdfBNqHTiJ0M7Zy8ikrafTJ0C2h+xdbDv
+q+gwg6vVOxstB4477ox0Rs20/HLOq824PWymcttDUjOnuibs7WEB1HDgZzlTJz/i0UFtpgIZ
+OPGRIgpZOxhk3m56aJCDMiFpNPXnLCjO872zYQ4MGTvokDNwcqibQ9mGbJzQHN1WTA4VZZk5
+yX67qxO9Uu3s7F93J3SITIhe1mdQJ6eoyNoJA531DBzbYTDIFwSe2wEgcwYpqI8j25Ee1BE3
+nMARFcR1QKhHw0Etd2oHOl7s5EgK4jtAQX0aTgYd2CkPFns5OdTJKQrq5vAP4USOoKDWHw6/
+6LEtCH1tVRSkcZJXVrnHP/alMUVh7GPSilJh8vuETsGADuu9raaCjbpkGYFTvrTe33DMF1Q4
++Cv44m5Nu23KZ5Tpp8rWJKpn+TdxPmcHZeQ7nk/AmSozdlIobkJjB4HsHRDCOsnYQcecxgGg
+y3MwDHGQLpI6f/78gVsOGQsK5yl1dKae/rM4MCR6yZAjkYMUJHvtWDobA0Oy18Jlq8XOH2zM
+5X3E7Z/pb/3zp1oQNBa4zpQ/f6oFQVA3x6CeP21HcDJW4khOLh/EgXvH3EGHWzYSBMx3OBVG
+72wQujMwcp7U9N8aw3xdAjPR+h5fgRnWK61o0eg3Z2FRtuQOp6DUmX5zXuUDD9BuLQdoswoQ
+QflvsR0CM4UHyZ1cYjp0JoO6lcOBzuHQR7bKYWyqumYjO9FCF4HzBSVdRHL2fQ4vTGc5FB3g
+PJuOzwgcUTmUDooaTNo7HCcsn86RKCwnTAXJGJYjbTPirkfPPEh7BBsn3ic0HSEz7XoYDn29
+tynpr3RwbluiXyI73HIWqXRgSFNODDUcfrPdbiBk7eTMCoU6pGcWiOgomOewa73jxCwHZm63
+5usGE6VwCsii0eaGC3YOzpg6DAZxGsCyQGdnXVGDudccQrNVVh8597vOoSjPcu4ZxHQ4jMKh
+IQsjd6jM4tyFTm2EQcwdfyu1yrSdr1/dlaeDvTVccULbef5mxNzxt6CrTouZFrvHkbQbUM9z
+0f2HksEHAsuZl0yqUTvT/aCzSBATQxqnXEzrBMCB/hyiExAnUJ0c4jnbwuUwtnRCkmo5yWaK
+jzeKE9bBVi71sab1xAA6gZKPPPkCTae6+vcppVJKFg7IZFLLqTJjHYxJoIZTZ0KdGeZEUN1p
+ME+oxlCdJjPOqTJEp82cyiEw8B4HgtzhOPuCuENhTuSQGLLz67sdGnMQZ18Oc4iMzglkRukw
+cgQHY9w5hBMt9QoOzrhTceKFXsBJFjJwMGiQky7TzakzIgeEGo5VQdkSNg7zXIidUyxg5GRS
++bCZE2qKpbNy8N3mDpJBTsm4487pHYBxR8ac2AGZ8zo/ohx3DuIgjDs/y8EYd2SMOzLGHZ3z
+FqWj8/ZmAVWYXwDTzXnLM8oRQnxHBh3YkUA15tsdAeTOoZ0qYzje3GkwyPxZbYexw76sYTIM
+55LGxKmWYlgP7qy3OjvJDa0DKVBdDEZwXCUqB3LqDJwWAxyPShiys0t9mPg4Xs7wHHnazKkc
+AmPhUBh3ZIwBNMghMlqHyigdMqOEBjkMRuNwGIXDYhTQIIfJHN3hMkKHzQxzRJCAkTgSRuCI
+GL4jY/jQIEfKMCE5w3IUDAdSMXRHx5AdJUOGBjlqhgYZMEdyLBgCZMM0ISum4ZgxdciQqUGm
+DA4ZM5hkz4BWJ6agOjqbN8DweDwej8fj8Xg8Ho/H4/F4PB6Px+PxeDwej8fj8Xg8Ho/H4/F4
+PB4PJd0/Tz7kk/hjrmDAFUuoqphBLcUIIjDDLs8652Vt169MNyTTxfCY68KwZ1uiO9ehzhVj
+zC4LHeRc14CjQAsV5Xwldv77iqlzjfO849+i2EAg83T+/ftXOnIIcf49szIWBYHM4vwrHe11
+4mRHClWdf2YO3D2bEwpGNy/BFXH+lYylEzbnWVEIeqjtlBnlKObBKPon2DoIs+x3QEQEVZws
+ySSA/ZxstsFOTjmtoZGTPqNuazd3QuQkk/8JIYKTH5QsP0ocoHtK5vecECQFkZwQO79FBcFO
+SJtt+vfv76igi4mT9EnOzBVxCyqdbPbP5cbf2Plt4OSzjM43/uYOF8KdUHH4BaFOMqr/lg53
+JMicIHMC19EXRHSEBRVO6O1ci3Iw56KvJ4SongA6gesAUIiDOBYDIeTB6uEXlHRQRycuCDio
+6uFkBzsXMyeHEgV8XtifvRVOyB0ACnJnPYtUHLitm5DeiaAAjLZln5AyCifsv15AIYH25Uyd
+be8z/fA7Xo7ntE6RZju9vg5w2GA9/+TlkksDnHU+9H5ONA+61KlBeYN1ctIRkA0ItoNDo5xk
+88mGt/FMpNCxidRhQFGMHcsz9FUHizvuyJhDO6/WPwee0fnYzqgZt19upnLTQ1/s2VQCVZX0
+4KOPUx7EayCCMs4xeBdf4/BPlNadMMYJwxwMMnDSN8zUR78ok1Y0zlFCNEf/sqHilNtQqdk4
+qQW9SLFzAvSqvoezFRWAgoydDZA6RCZgDWftYAV1c4LIITPKT/q9mMNgZF+s6E7QfFSW7Qih
+Yzog1MOBeqiXI3vi1js/s+G4jvTIiu0AB8C9HElBfKcsqJNTvhR6tYK6OYJjbImTF6R10LMG
+gmPfmlJx2MekJKbw+AVVlPijSfWKpM4lZ8CPJqid9NU13E/JvSLnQmH0Tr7e7Ufsfmk9uVuv
+S+18Nuo0cj73TD/VGN2GGkNPZyE7O1tpYxz5SSuCswfpJGsHGwwqp4SeDNhFOqeA0DEncva2
+gXrIyEl3ot2cbF8NOrKXJgjz588fDLJywuI8JYTJ247rbJv7nzmwU3YS20kZuCBgMBAcEBrk
+/NmCOTYHvk1HctK3xiCO5GR5tZxRDr5HSEeC2sGG26elg49qG2dNTdE7lxZgV0+yvscDUriv
+6JJKoCfSx5bcYb3QKtrsK8s6H4mSeTpnUZ4rg4QI4r47gznVPOvMfqsHs2SU8xjlMCAVczxH
+1WyMXYLWoW6qumFALyha6nJhO49L0kXEciaIxUxhOxOkcXBI1z1cJ/oUEJ/h1LN9akbAMB1h
+5/CcpfW0DAopR8AzpF2Cnsn2PW1HyDydqO3snNuc9BfoDvnvv90Ayd65Rdl/q9VBinISyNy5
+3UCo4bCb7ZanixMKZq0o1CEeAygLFCwdmPmCmscIBtXMTgMyYfJ6SseGuYUsR3bCsqIKY+HU
+Vo8xJWTCfDn3u8ohKROTQTyHyigdqjIxfZ2wMSnEcZhMzakN6+oGkzfa7KBv2dYYgpMw9zv+
+1rDOyZhezvMX7z2c57LRT8+lEicaCWQnlM68aIUROAF2ng9FjNqZ7wf6I4vSCbBT/j06J4AO
+2I2YEwjOvvAoJ7bwuoVOyLKN6SQfaYpnVL4T531KocwSzkBOjVkdgMmkplNlFgdmEsjCwZgY
+ajl1JtSZYc4ONZwGM0EGTpMJdeaETpUhOm3mVA6BGeYguzZzp86QHINyjuSQmPM4NOYcTiAz
+ws1H8LF4d+ydfakXc3LG1sHLcecATrTQKzjxQidyMKjKnM9JFjFxQChd4vROtoSNU0L5AkZO
+eW6nk5NIwKN2zi5Bj1k6lZSMO+6c3gEYd2SMOzLmvA7MjHIGMe7IGHeO4WCMO4dwUMYdGePO
+AZwKUzhvfZ23KB2dtzHO25sJ1HLe8oxyZFCN+WZHBB3ZkUAv5lSZn+LwmRM7kql3+M4lm/qF
+xIDPC7hz2cIsB3Hqhl09bceknlqbBdnco5ADMutUObJmYx+HCJuNf7wjYwCnzgT4iwSITiQ1
+GShNJjruVTAsR5E2Y+IQmDM5FOZEDokZ5uihQQ6R0TpURumQGR3EYM7gcBiFw2IU0CCHyUgd
+LnNwh80IoUGOgJE4EkbgiBi+I2P40CBHyjAhOcNyFAzH0TAMSMcMc6iQliE6aobm6BkSZMEM
+c9qQDdN0jJgWZMbUHTumClkyFciWQSVzBpZ6MIDVjUmororH4/F4PB6Px+PxeDwej8fj8Xg8
+Ho/H4/F4PB6Px+PxeDwej8fj8Xg8ndP7s/jffEWGKVRRDKWGMux6pmHXgQ27rq3LdXrgrE6G
+zPV6XZwOUMJMEDzPjplzjR37HsqcaycnZ76gmPnvKyZQwVyvO/PfHAsIcK6T8+9fDydmrjPz
+b2VMIMi5TkwP55o5/6aUjva6d9gJpSOFqs4KGWxEdedfwegmQLhiznNoBwMHLmcZbzNU5NUc
+xbwepTPvd+DYOpUc3ckZwEknNTQq55of8hSzJ5o58VR80+pTyM5JS4l/EEBUJy2th1Mcyy0/
+9nBC0EKIEyDn9zOmzrz+5K9fmCck6SHAyTaU9cbf32skBZVOvkUu//7dnd+/xQ0HOiHedjJH
+WBDg7IP6MjGxE6QFYU6AnaWg/k7QO1eiw4WwDqr1j8RBGi7aGzx/yB2Dhit3aH3q+YLKp22D
+en7lzhU4PLByipdZJEfZcNDhjoFTQjFQ7q+tnExZoYSROwFusR3SOztU9svedGYOnmTL/R02
+RuOAJ5CAYx6JQykopbo6xUGD+fyTlwwa4cR1sZ06hDHGzr5uvVOBolVnjPHEnaUT5E6z5eZ/
+Q7Il93CszpzXHNMz9FUIjjvuSJlRDp9xR+iMmmn51SaoNj8QMYQO7hge+oLPpPZOfsymhNqM
+DdRWxjkwZOFQCrJ2kO8Cs/lmiaSY7Ki3q9OpnvS1CFyQrTPfBj/bY1vPZdkFlePOxAmjnJAR
+5YZk5KSlAQVZM2spOXRqB4DMHaQgc2YfawMcxf6A7MAfWbNnhjngUVYnp4DO7EANd3ZHCrEc
+CHKHCI1yZNAPd16yoCGOFDqsU7466eQUEMkxKKiXk0OjnG4dJCpI4gTBwTy6KuT24sR3WdUD
+HIfaONkb9KDDfe+x5cAnq5J7LdoNOyfWwQGKDPz3bOkMeu5X7+zrxtrPxEmqwU9lG9Tz+ZmL
+HZzPObNTWY7k4NBn5Kz1gZyR87ncRltP7kzri5z5X2wwCJ1tdZuzM0krshxIyZzPzfk0cyIm
+d4pRoXCSs0WwI3wtjDMIZOFkgZkhjvhkUs0BoGnMZYOhhwMNum6OYbv9+VNx7I5H/9Qc0cly
+vlPsTjXtFqrlXJIu0jrYaMv3pxInahKMmaNz5h1cXRA5eVvNT2b9nUAsh/tCqzkAHl8pFfYL
+LYh5ZMwaU2df4wNJCUnKwdaeQI8H85WwhFkyynl8g9OCRN0jKOgMDmfE6RzyJqRqNsY+IRYu
+7O75ch4CZ/rrOM4zJCdrM51TgVTdwyhosDN/rEDGsJzpg1oXEUPqoH2oTf+XMCxnxiQKbdej
+GwGPaUtlOiIm2yUQHOp6b3O2X7g8W5vukP/+25r4V1qOuJykpEez4VROBJk7tzTrr5EdGbNB
+DYdXToHsTdfYglgOxKyQoQMzTyhJL+YLau551I0GOBCkHAOb02o4kjM9XmHaHURgauu3cyhK
+zgBQyyExeofK3O93imPAaBxym91ziOXwmL7OzoidQGPuW4Y5lct5cScQnIRpO3A5JOcep/Je
+N8t5Lpv9mDiVDqo0W+HMa9h//FrqrnUC5jxiJnPuZs7zoeWnh4GTtVDqPFZE7awLF07xB1Ed
+ePOBHbCBNU40bBoOPrAJTkiTDOo4H3vKZwa+E2LlfUqKrFSStlP+4VFm571QCgl0oFd/NQdk
+UqinE0Mtp86EKhNDB3EazAThTATVnSYT6swPddrMOKfK0BwCM8wpd6CHdUjMeRwLZrjzC3Vo
+zDCH2D+oQ2XqzrYU4jDiTkcnZ4wdtBx3as6+kDsMJ1roxZyCsXRq5UiuxvlmJ17kBZxkERMH
+hNIlzuUAULaAkVNA+eNWTqgqlXfNNFT5kKlTiTvuvKADMO7ImBM7IHNeB2ZO67xYOd/cbO4c
+w8EYdw7hoMw5HZxxR8a4czLn7a2r8xalB/OrZMRQ23l7s4DckUGHcQpG5FQZd36KU2cO7YBz
+4hAczn7nsqajc4lj4BAU9lSDUodZDt9BvqdJ4MBMiBX+TDWhhBAnrYrJAE6Vwb7diu/UmQBv
+pU1mP06kMmAYjiZtxsQhMGdyKMyJHBLzco4aIjJah8ooHTKjc+iMCuIwJ3BYjNzhMXJokMNl
+Du6wGRkkYI7sSBiBI2L4jozhQ4McKcOE5AzLUTAcR8NwoEGOjiE7SoYKqZlhDgkyYCiOBUNw
+TJg2ZMS0HCumAdkxVciSqUC2DApZMwhkz4BUHyan+ik71t3weDwej8fj8Xg8Ho/H4/F4PB6P
+x+PxeDwej8fj8Xg8Ho/H4/F4PB6P54XS90P/Q67JQC8xsYRwxBSqM2ZSkxl2wdmo6+fOdEFg
+sUpwlio1VK4Rms7H0rlerwvToaBYmaHY+e+//4yglHlCKRNBFs51S+T8958dVDjXmfm3MTtk
+ylzne/79Kx399ejXDPr3TOnIoZpT9I/aucJOGOP8CzkjhqBm251nRSFLF+dfrpg615qjmQjj
+WjjB1oHLuQJr10GHdgTQsR3xxDgtJ5+ksY8DzAYpc3ImgfbVR5C9E1chhxAnL6f8oYsD/Wjs
+FMeMls68PtS5mDjpEI6c379/iwuqOskm83vODgkKqjOJ89vKuUZrh5wvSQKVDVc6l9T5HTo6
+f38XBbGcSsMlHdTPCUkHJU6QOmXDhSzqeoCCoOdTdT1yR91B4PGB2gEggOnulPsDlRNgBtof
+BL1TtBaw4wmbI4WgbgnQaRjRU1D7vFgB6Y7i6FAvJ5/6urMT7V1lDqnhyqfy/k4QOg0IYawn
+7sQY6xk1IaKHg35TgbUjnjpeApV3ipjjTkXqzrEdGePOsR0283LOqBmdX20i7GETiNsfWA1w
+4CMDMVRTLvOX8phAJMfgWKTObJga+l4npIrBsSLJAT9p0cnhfz8TxUleMfZ0knOkAYJsmMQB
+W87IiV+TdHe2m0DLWTkpWZ4c6eXkBfVxyh7q4IAFdWBCNL67OhsU39fDUe5IBzl0Bnju7lIO
+UE8fp4SO53AYzRPQIR1Fw3Ed6RPdMR15w7Gd12q48jDbHZlDhXiOvCC10wca6XxTw/Vx5E9C
+aqiTU+y0+zmiV1tsR/jqhO+EcY7g1YnMiSArB3idkEBGDnSmKtn9mDjgCbH0bisHuX+/beDU
+ziLZ1ZOerOrm0Bi1Q2S0Trzufs4lY1BF56QFrLdhTu4ARxslrnais5WfzzQYqRMV8/m5Qs//
+PO/+zJcWO3Gbrc78z+USFWfhbLc/k1w+LZ0on1DEZ3lwB4R6HCeSmC4ONLQ7OcVQ6NJuwJg7
+jYMw+dDu5QjfzQCJC+4Uu1Ohs+6u8VbL9qcS5tJSPpf96aeFU1PW6JzAZ4hQ6VQbzcqZ0mb4
+L7Qg5xGt8bElYbjH8ZASr/JRxMjZV1cSG5Rtqxqnkq+/4PJgDgSJM4flgL3TAXIHdFpQyZAd
+1sjWOXQoBuZfozcbw0krmX6R4zyiPuI0G4uZQytI3jtKh8sMc0gdFI20efDwGVJB8UDjjTWZ
+Mx9+XnQMyZG12YP47K1U5n3Pg+NQV3ybsi3/ZDo6uzT1aRMSM09pv7erszde02E32+0GQrZO
+CLcbDJEddilpHzUcTjkgs0KNLZXhIMzcdIHqyJlbSFJ3xK32dNoHIxbMjfBOHcGZF6gwWbvV
+HFEZmANBDYainMihMve7yqEzKofaZvd7BmGOAdMqSOlsTKOgSrNVt8zduY9wgt7hlnOPPyhr
+7MTMFzTKsWq356I4E0N0B3giCJnz9Ws8B2SgA6jk3udiSifkf/ru7MfWBcNut4A7z4fnUspy
+pE4OAZVjTgFBzr40WM72+POWjRNLAcrHR/i4f8jaLVtVorzPmYQkrWfU0gH/7jWL8/5RpsoI
+HYBJobZTZUKFSaSmU2fGOhgTQS2nwcyQ3mkyocoMczbIwKkxRKfNnMohMMV+zR0acx6HxpzG
+ITLncAKZqTvbUphDj6wcd47gbAu5c0RnX+jFnJKxdGrluINC0SKv4MSLdHSSRUwcGBrkpEvY
+OADUZEROAWUPmzmhyhg6sVQ+ZuksGnivOYPEHXdgxh0Zc2IHZM7rwMxpHYR5NWcQ446McedH
+OShzTgdn3JEx7ny/U2Ne3nl76+28renpvEXp6Ly9GUBsRwZVmbHOmzsSJ2fcaTIv6QzYTMGC
+0HVd9nAZhnO52DoUpp9zsXaQcpTNVg64QQ7GbBPHKxiaEy4hmQJK4OxShdmr4jM2x4mDHAJz
+JofCnMghMedxaIweGuRQGaVDZnQOndFBgxwOo3BYjNzhMXJokMNlhA6bGeaIIAFzZEfCCBwR
+w4eEzFEdKcN0xAwPUjDDHAakYuiOjiE7SoYKqRmao2eGORTIgiE4JkwbMmJajhXTgOyYqmPI
+VCBTBYesGQyyd0CpBwNQvZjE6op4PB6Px+PxeDwej8fj8Xg8Ho/H4/F4PB6Px+PxeDwej8fj
+8Xg8Ho/H4/np6X25xJCLZjDEFqophlKLMXKazLAr6M505SGJ6XFhKDShjwFUMjBkxVy/kjn/
+fcUKipRZ2p3//ksgk3KuG5Q7NlDOXLNms3WuiRMQR3/he+n8K/tH4xTNNjv/vrJCJmO77oSM
+0TrXOM9mW50iHRxLqGy2eaeAMsZOwBjdxB6lg2eUo5kQ5dq7IJDpUNChHfFMP0dxnru8ZFrD
+Dg44u6W9c8kjg6hOdLuLkxTR3Ul/NHWWFeZzZ0oLghyk61OotxMGOmKo4Uzr/T1FVxDLWSC9
+AzechUPpoN9ZwzGdSkFJ9//u4YQyv3fIbCA0nKDY9RzOCTonNJhouJk5yfqLgScdBxEE1bGt
+trxD5uABnhq6OelzXRA5NGijLt2cEO/nRjhpYWyH2nDZ0yvfaUEgYz/RJajYO8CzkdipQ/OE
+690dJCJn2BShg5hhzkGnCH01R8z8bGdUOa823F5tYuLD70bZzqs9zZ1zovLyqE0H1ZnL8pU5
+vZzseFfwZTkk6BJ9789aU5eCttPjMyT59h8Kk78eKQeEkZNXo4cQJ2St1s2JX5RcgHMJtk6I
+nBQydbbbegh14j5ZTtB3ckLi5EPB0Ekrywrq5gSNQ2I2bpQjP4nAcuTlvJojZn62I2eGOSzI
+nfEOBzqFw4CYKxYfWo1ymJD8WPGojhT68Y4QGuVwj9/GOQdvOJ4jH3F8R/YqiOkUUC9H/GpL
+Cb2EI4HYTgb1dfjvdbfW2SrIxIFPxJo76PneKAZOeiJJxxDPV6GFqZ2Iwc+X652smk7Ohcro
+HDqjcpI1R2dJVR/hqBezrx0pS+zk6+vlIMF6ycT5fGb+BxsMFs7n7Ez/vSxmB+czdpbb8rcZ
+mk4cxdsmHAfoJL0DMqOccih0cKZBZ+lMDQQ485ATOYhyAeuBxoLUuTQZC+dCYPTOpmDM5Hwa
+ORXmc9nRadut2mZR2E45CkK9nJwROnMGOY9olY/H4+v/WRfxX/+ATLTeR5FiExI669oQ5lFs
+Qxqmls8Hvx4Bs2SUw4MGOWX39Gk4G6cNKRzOiAMYqsMa2gmwbHxkhrGphhxiNNtXHkRH0Wxf
+0PM/NEjDzJE6TOa4zkXEEPcJ+0Cb/89mmM4C8RmakzabQCHu4jQD4BnqHkHA3J5ZF092CSSH
+xcTQ40GA2M5tS/QrDIdZDgzZObcbCLUcVrPdimy/ZuiEktkhsiMoJoYaA4FRDuLMUGtLpTsY
+M0GB7MiZG+XzfQYMxSGUE8BhJnREdez9k6TiaBQDR8RUHBWjdsjM/d6E9M6TySCeQ22z+xjn
+fi8glsNjSI6inLvWYZaTQPbOfYgT9A6baUAcJ2TPEAYO+JwTUijonZD/6SsT4h8f9zsCEZ2A
+O2H/4aF1QgChsN0flt/SOSGAUABi4+S93oJ4TramhHnf8vzpY03x1EBw4L87ZM5HnnQ5I6dQ
+cqjtVJmak0hNp86EGhNDWifUGIbTYurODjWcJhOqzAmdUHU2qO4QmFBljuVQmJdzqgzJITHn
+cWjMaRwicwwHZ9if6nXHnZazLaRnfqRj0D01p1KOOwTGHQ4ULfIKTrzIqRwYajBWTrKAkQNA
+6eNWTgFlD5s5ocoYOolUPGbprBh0t7mDxJ1DOxDjzmEckLF3BjGv5sCMuYMw7siYV3MGMe4c
+wkGZczo4446Mcef7nRrjzo9xqkzhvL11d97m9Hbe3nQQzXl7G+K8vakhivP2Ws6bgVNn3Dm4
+88vIaTGAU1+hdG4XjnPZ0tO5XEwdCtPRuVSdJlMMbFI5oxw+M9bZpV4M9cBqW7/0O86IDjwz
+Fp0xOFAkMedxXqwcoqOGiMxZHCqjdMiMzqEzwxwNxGEUDouROzxmmCOFuIzQYTPDHBEkYCSO
+hDmwI2L4kJA5qiNlmI6Y4UEKZpjDgFQM3dExZEfJUCE1Q3P0zDCHAlkwBMeEaTs2TBOyYhqO
+GVOHDJkKZKrgjjGDQeYMIvVwAKgLU1j9lNjqrXg8Ho/H4/F4PB6Px+PxeDwej8fj8Xg8Ho/H
+4/F4PB6Px+PxeDwej8fj8QxM3+slBlzOgl0FNOiaJlupyoy6tG3YpXrDrnAc5oy6AlUPFStE
+5g+yd6KZiv4zg7bVXL+yMJvz33//GTvXJRXH5ELxzUkmqjJ3rlsqjsGF/JlTjA0j50pzFNC3
+OiH8+2cLFd3zhJ73jHKMW26sc02cGiOFAOdadzQzr3yP04BGOYoZeHiOfEahF3OuLecS/VcG
+NR1wFk1z55JnlCOFUGdaY8kskJkDCWoHGNfw6rdbNg7WK2E/Jh7giAqiOen2ZDYQit7Jttse
+TsgnVLV09vE2r9rKaT1xd+qg73MuRk74DqdgDJ3tVTD4rB1vRFKneZoi3VjFe1LK6ZDUmW/0
+gIY62zNsdyfZqfKdNgTtu/s6+30Chzy04/2cxCFAxV0ihz+jpowZ5hx1Rs3jT6k5iPEZNXs7
+SubVHCozzBk1qoc5wybYHbV3G+aMelYY5hz+6RRdIfYugK1THh72cLLD0JSzc/JXCVlZlk5y
+BN/LmcZA7BhAmBO3XD4gzJy8h7o5IanGoiDEiV73mhSEMYkYcqiLE5aX9d2dvaoXcoLupT3d
+CaOcKId1ZIw7gxwh83IOF3JHBrkjg07gsKAzOBzoFE4/SP4yiOmIISbzcs4QaKQjfV13RKeE
+OjlFD/V0ZK/reE5eUDdHDB3VyaC+DSf5/KWuoI5OGOXEsXDqH2M3c2yZ2nm+tqh2LgnTzcmY
+Xk685hqjdMiM3ZFietZ3gKN+j4bMdHSiRoN7ycbZV44NBhOnzVg5X//5/PrfJzrmDJyvGj6f
+eTpLyrL0zmVzYsbauWzMZ43RPv9AzOd0l9jBlEvo7SDMHPEbW7ByCYgjfgHEUsqxIHM2Bq9G
+6ACtFlBmcj4tnDWI8yV9pmOulzPFzKkzZs7jUWUEL7QQZnceefJNSO4sq4OZR74NiZ1tfZDy
+fMDWqeRyeTyYEOQQpEcESZkLpSQL59ksDIcCgd1j7+TGhdhmCcN25ucEGsPbVEuHWA9vEwJ6
+Z5hDa7Z5rFAhhTNF4XAYqqNUImiUU4digT6kFc7yOS02w65nhuQMvd0ExZC3VL5y+8q2MPXs
+pYx5SptDGtlSZitp6lB753bLIaZDQUK4JQn7A4bOrcz6a02H0WwAs0GGDsisUHPAaZnb/Ktm
+DsbMUHNLVZczOVF0TsCZG+mTnk2mJqz1EHalDaatTE674eoOQcn7B3YMGL1DY9SOjIEhC+Z+
+v/d3Jqa/MykZxHMY1WgcYqvdBzt3ocNlWgWpygmR0yhI59yHOEHvUJ4O0nJiiOzkR4Pr318p
+R+I87wOd6O7nD0onwM6ykuj2HYE4TkmFIpgDQIATrajOcBqu7oRMeY9SUIHnQH/3ml35SPLk
+4uUITo0JsDJLPKfKBJTJpKZTZxYIZBKoqxNBLafFhBpDd5rMBKHODp3JwRmqQ2DO5FCYECrM
+MGeDag6N+ZFOyeyOBTPKWReqOERG5wQyo3Tocee8zrbQizkA446se9xpM+5woGiRQY4JgznW
+5QxzYCheoKOTLGDkAFD6uJVTQNnDZk6oMoZOQhUPmToLBt1r78B5MQdi3PlxDsic14EZcwdh
+zuq8WDnf3WwndVDGnWM7g5hzOjhzSqfCuCNj3PkxTpVxxx3QeXvr7bwtGeUIoTqzO29jnLch
+zttbb+eXOyJmqPN2OKecjEDsNBBYajJl/xAYC4fClJCdc7F1ejH5Dq6zM0lB6hAY6gGCshqm
+A88oZe0gD5EYgwOrQQ6NcUfGnMWhMkqHzOgcOqNyGIwKGuSwGLnDYw7vMBkpxGZkDp8Z5kgg
+CSNwRMxxHRnDhwY5UobpiBkepGCGOQxIxdAdHUN2lAzV0TJESM8cyjFgKJAJ03ZsmKZjxLQg
+M6bu2DFVyJKpQLYMClkzCGTPgFAPppQ6KTnVk/F4PB6Px+PxeDwej8fj8Xg8Ho/H4/F4PB6P
+x+PxeDwej8fj8Xg8Ho/H4/EcOd91ec6wi6eMoYoz6uI2O6jBDLvGcdQlm+MudR116a7eoTH2
+jm7apTZzvV4HONcpoTKjnMmV79feTlLOE8Idg5kJriRHP9PCdYeO4KhnqDiao5zZ45o5KGPn
+XKuMGPo+51p3VFPJJA66IzV2rlVGM9XP9Uc78qmYfo6zbbTJ1mvoTKu95OnhgDF3rCGuc9E4
+AIQxxg7KzNCJnbBP3bpPrsp3sIGQdEcnJ6Qrj28qnQA46d4ndWw6qKMTakzaQXpn/hdgNkex
+oZJeBhvsEA7lxJTUIUIJ091Zf+rlXLLXrRKH0UPb7Z5OFBHzgvNPHnQCSsX5ikEMC9Iww5yf
+OgPlaWa6dOfQDpEZ5ozaG7ycc4p5iTnOqPmchzn2hwfxoW5HJz12t4BwZYcuBlDVuXR14nMu
+802DloPrSRvvYlAQ5ORfNHUxKAh0MuhiUBDsJCdcTApCnES06KGmsxSkO1nOeCn8Wk5QOlQm
+jjvuHNyRMMMc+Tlsd4Y4fOjgDhtyRwaJHSZ0fIcHncBhQaOclyvokE5+RuGADgcqTpGc3Cmg
+no70BfERHQ10SCeHujlhlJNCDEdVUEdH/GEErhNnkMNhvt2pfxa7h2NzrUHzrza6pqGpGF3S
+0GReyEHey7B2Yqa3k97o4VxajKFTZYz2B1HfWFwdhivb23PQ+3Q2DsSUZRkyn8l9iobDmc8p
+Yfk3P3TTO+u7cp9Jnvd9Wjrbu5mF82npbO3zCSTf/cidvRcgR/5Cq+yeUGWsHYjp4IBM0Wy9
+nGkofI5xPkUOrDweuJFuQyrnETuPNQvxKXrhiDmPXNkie0GHdM/ScqWSO0QINJ4rgoTdeTai
+0pn3ojjzBc2d1d158B2k1drM7pAgrHs6O/NIaiNcJ2emZzEmQ4HAZqMwzE1V6jA3VXE5j3HO
+g7EJiZklJ3A4DLXhUoG8hSqc+VN1XEbgTBCXEbQbdXcDM4z+oa35drtti9LPXrJH2W3Ksjj9
+dKyMeUoLRNuCBI2WQs8YO7csOWTTbLkSDwdDB2B2qOnQmw10bssv0h0Zs1bUHAhUB2NmqD2w
+iQ7O3EIUHRNChUkcFGoyNWFxKHuehtNWJodcj4JhtZuCSR0Mqjk0huPYMYhTKYfM3Ec4X8yd
+AOEOkblPITricoLaYZUjd2jM7X4voQ5OgBwQUjk70yzomx0aEzv3js4ddiAIZurPn2ZOoDgh
+bbZGw0HOdB+85vi2jVNC61r2WzpnXx5kolg5eTuF9yiFxHSAv3tL7Lx/rAmS8VZjAoDMUhqC
+U2UCrBRU26kzKwQwCdTViaCm02JChYkgvRMqDN1pM1Vngw7iEJhQYyydoHdIzHkcGhMqzI90
+iMxZHCqjcgKd0TmMvJhTY0Y7AGPqVMpx5+c42zLucJx9mUEOxBzWQaF9iZdwoiXO5cBQvEBH
+J1nAyAGg9HErp4Cyh82cTMofNHRiqXjI1Fkw6F57BwzIuONOH+dHlHNaB2HO6mDMSZ2fUo47
+MsYdGXNGp8a4I2Pc+W6nzrjjzimdBuPOeZy3r/R33pb0YUpHBpGdt9dylMzRnLfezVY4+Lou
+a0Y5ANR2fn2PQ2FkU3qkDUdiFE7gMKIpV/CWMi3HwCExfKd4rItTPmTJVKauojH644MXc4jM
+WRwqcxKHzOgcOqNyGIwGYjHHd3iM2GEyR3e4jBDiMyJHwAxzBJCIOa4jY9iQlDmoI2Z4kIIZ
+5jAgFUN3dAzZUTJUR8sQIT1DcgyYIzkWDAGyYZqOEdNyrJgGZMdUHUOmBpkyOGTMYJA5A0Md
+GAjqwpRUNya2+iIej8fj8Xg8Ho/H4/F4PB6Px+PxeDwej8fj8Xg8Ho/H4/F4PB6Px+PxeDwe
+z5wRV8582+VT9hDmjLq8bdhVgXZOnRl20aYR1GaGXbs76lrkUZdWG0CDHCIzzLG6lP96vfaE
+ImaEc71GEDKjmMHUEdfrBuEzlw1zFFDInRpj51zrjnaqkutwpxc01LleMwh3pFDpXF/NCVVH
+M3fRNzmNGDr2PYTUo5t7lua0IFPHGmo70nlH2c5l+VHvQAO7dDapiwNM3WrkhMgBu6qXk489
+Uyd+vjNwAGgbV/sISyGFEyAndHDWIHtrqw5qZZQzWdutvs4eiXPc2Q0P7gybrnEQc9TpGvUv
+6ro7PEjhcCANM8w53MSQp5kZcpRDhAY5esadYzsk5vXOlg9ihjnnePr5wU6PwxCzsy5Vx/Ds
+Tg0yPY2EO/j5KnMnbKePLlYQ2G7peYOLBQQ4ccvNZmdnq01fEMSE+CTiiikhxInEQU5aXeeX
+wqMc5RkeuhPFnYEOn3HHnaHOoc8tuyODDu0IoGM7fOjgDhuSOlzo8A4TGuW8XEHHd3jQj3Y0
+JxM4THqGpKcTQ6Ocbh2Un1vq5agajutIT1lwnDDSEZ5KYDkpxHL4kKye4z8z8Bh33KE4Zpc0
+1BW7SyekjKFTZeyc+GOkHZ0GY+TszwDgW1umznYLXGIQY+Ikn/Bdb9k76QeJsbLUDsyYO9Eq
+19Wr3+YEmy0VP7/yZD67OdPKPxfns5szrTxKvl8wci65k3eRjQMxYofBfBZjzsIpGVW71Zyc
+KQacjbOuG3cYULPR0D+E5aDK03l8MY81+4NWzsw84AhfCWMKxpg5DeYxP8h1mI1WdBYVQnon
+DHJaDNcBmGeaTOSQIClj4hAY5sgWM8xNSOiwT1pp6mFsqlLmC3pwdglyZwoZ0jFSZ+paBqNx
+OIzAWT7oxlLojqYWoUPsmXg5+obKHmW3KcvC9NOkMmaFBA6txW63BPp6MqQ5jHJuWdbfMHZy
+5gtaf4nj8JkJCsYOxGxQ26E2G8zQISWzQO2BQHNw5haiEJyaEipMAinKqRKzQ9kjNJi2YuJQ
+GJajYGgDoebwGRyqODSG5Zgx3ZwQ7ncChDcbkbk/o3Do1TAcZTkJxHN4TLsgI6dZkMrZGanD
+LaerEyKnBamc+zc4d4kT6k/UECNxAsEJge+UDAjt98/ruzMgwNmXB5gkVk7yGuSZ9ygFxHTK
+P3vPew4FcFOlODUmcT62zFi0GMGpMgFAVipO26kzG5QzmWTlAEwCNZ0WU3MiSO8EnImgltNm
+RjoYQ3YIzBP6dmeD6g6JCRXmWA6NGeZUmEM5REbrUJlTOIHOUByA4X9U8Ac56yLuvL5TYUY5
+2zKDHIhxR9Y9P95BoX2Jl3CiJWwcBBrkxAsYORCUPN7PaTOySyNqjKWTStlDps4uFQ8YO2jc
+cQdlTusgjDuHZk7qoIw7MuaUToVxR8ac0PlJ5bjz3U6dcccdU6fBuOOOpdNi3Dm4YwQNctqM
+OwbO29tbfX2K2TbIf/NyVbJ0lhIuI53che0IvwGTzQi/usDAoTAHc9QM35ExbKd4yNSB53Rh
+MHQHecDYwUJlTuKQmXM4dOYUDoPROBxG4bAYucNjDu8wGanDZYY5MojPiBwBI3EkzDCHD8mY
+wzpChg0NcsQMD1IwR3Q0DAPSMWRHyVAdLUN01AwNMmAojgVzIMeEaUNGTMOxUsY5VciQqTmW
+TAWyZVDImkEgewaEejAA1IcpqH5MpHVHPB6Px+PxeDwej8fj8Xg8Ho/H4/F4PB6Px+PxeDwe
+j8fj8Xg8Ho/H4/F4PJ49Iy6cGX8lUDdoyCVUg648gxljCENsnYpiCdWZYVe7GjlNZtjFyKMu
+rh51rbgFNMihMcPmDBjmjJrSYZijgw7oWMztcX2moxMzM4TOYKeCUuc6OThk5lzrjnbOmuue
+gE0waO30KahwriMd+4YDnC4FFcy1MteksRPwiWeVk0tlzjZPZ3fHHMIcHDJ2UMjawUZDDwfo
+Ht3kbLADMQd3SghcuZmzpsm82qx27rijYI46u+HxHR4kZw45jeI5XqMe8MW9zhl28uVgM0OO
+OgunZ17OebWzvoc6uzyIOc9mOsghMsN21+4c3OlxfACepzB3TM+G4I7262uIzkRovo6H7vTo
+IKjdQnqi9GIBlU7xvVl7XV2ctMAOTn7+7WJREOjk6hjHpOEoTpRBjDsHd17t3Jg7MublHBnk
+zjBHBB3ZkUCjnJcrSOQIIJnDhw7usKGjO1zo1ZyXK8id13HSMzHHdDhQevqiqxNB53dSqKMT
+RjlhTLslGeQwmZdzjn4I99MdIXNKx/JT30LG0KkyZk70fonJh32bxRh9qLjWNhXG2jH7VH6T
+WRztu3U0Rv32I5np6Gxv0xm8bUutpp+zrv3z83nj81PlNJjPJ/M5Mc9/Ojjze6hfVUzCzChe
+lzTKiVL0kYVzKZjPYjCYOc+1h571LO9vT84GFTseDlRjFgeP0tnfrQcY4QtUTLmExwP5G0RQ
+hYGSjTktExDG2EGZyYkbVOUE3JnDdsCebjI2Tmg7bEjIcB09o3GaDHunLWS4m5CMybbVfs4T
+Yo0EqTOF7qgYuTO3+QgHezKwc5YP8DGYHWI41acCQyfwmixhmg57mN2+si7J2FK5Y/k2J3R0
+bnGm5SUOj1nbLhAdejm3PF+/EvetUTkFM0nmDsR0cEAmhSy6B2HokJJJIK0TKgzXEVTCcRpM
+U/ly9l2C2CEwsVOBqg6FudE+Za5miAO74tAY4i4BdyRMy7FpNZFDZO5foUCYQ61G6dCYuZwE
+Yg4DFkOAlM2mdZjMMOfe1blDDgxpnKicZkHf61Sfp0GmBYHO1z0ERu0ExInunX5L6WzLF8ye
+99K5i52EmlcfBS8IdVAmz3sN4jk1JnM+pgD7OIJTZWLnI05oPgdlTp3ZoY8s6VJmTs5kUtNp
+MQFlEkjvBNyJoJbTZgLO2DoBd3bIxsEYskNhDBwSM85BGaJDY0LAnQ06gkNlDuQAzOZ0Lmd9
+3iYzOocRd9w5lgMxZ3TWJUwcYfe402TcYUH7EoMckDFzGuUc14Gh6PGzORAUP2zmlFDyqJ2T
+S+ljlk7AGVtno8r7rR0s7hgy7siYszoYc1IHZc7p4MwoZxDjjow5o1NjTuhUmfM5dcadb3Ya
+jDs/w2kx7nyr02TccccdOePOD3AIzOGcfD70zo74KyO5zoh6sK9ENXRmQTE3BcNBmo7ECBxR
+OXxHxhAdnOnjlI8QGfV+Z5BDZZQOmTmHQ2dO4TAYjcNhTuCwGLnDYw7vMBmpw2WEDpsZ5ogg
+ASNxJMyBHREjgAY5QmaYw4TEDM+RMzxokKNhGI6KoUNKhupoGaKjZmiOniFBFgzBMWGO49gw
+LcdIaUF2zDCnBlkyFceUwSFjBnOsGUTqwEBQF6aEOjEZ1VHxeDwej8fj8Xg8Ho/H4/F4PB6P
+x+PxeDwej8fj8Xg8Ho/H4/F4PB6Px+PxeF49Qy7RGXMx0Jhrm77nWq0+0Jhr3CDFHEIQa6jC
+jLre1Q5qMGdzWsywq8WHOaOusrdwKMwwZ9QsCMMmjxjmjJp04yQOmRk2KcrpJpO5Xq8jnOt1
+geDZU5VQyswOChk41+sKofPBGjt9IMBB5k/t5IinnqU7FUnthMRB287cQUaD3gmZA29GBk7I
+HDAWTnsHN2w2M3fccUfuiJmXc4ZNbziIGeYc8RWDyjnefI1ncYZNDHmwcyJ651gnkwycI53s
+s2BezSEwZ9p+Bjk05uVOkb6ac5bn0+90FN/Fw3B0X5JDdtRfX0N3lv+McYwbDuqf0AGCnB4j
+oXSKYX2xgAAnP83Xz8HUzs52q6+zZ5RzgnMV7gxgjv/NH+64I3FGfXPOyzlC6LiODDqwI4KO
+7BwaOrQjgI7t8CF3ZNCrOUfvoFdzDjsQfrCTnI7hOixokBPHnTGMO+644447Oqe1QqtPyzeZ
+IQ56mYGtY3g1Q4O5IJ6lEzMdnRpjdzh6SRj128Ptavo6WTmfn5+ZZeNc0nImJoVMnHilM6N0
+2kyYlM+ikwycdZWfn1A7iiBEgZx8OaWDfGxDN7DJzPaoDIIZTMl2QNp6nv88ypR/hIJZAziP
+h70DMk9nqqu3s7afmVNjBJCoHEOnzkQODdIzGqehPPgjW8iwdwkSZoJ4BYnKeTpxH/Vzpiic
+qT2IzA6JnEsPp2iyqeG7OrwmU9TDZqTtRljz7Xbbl9t/k+NQ/v7blHnZeFOlM5RK9gSpw1JW
+iN5uVCdnJiiQHWqzlcyzkwQOn0khEwdmEsjCwRi6oysnhvROwBlyQS2mQlg6LeYWvRKSM03F
+xiEwsVODag6FoW6pWkbv8Jka9O0OlbnTICVz/4rGIVeTQZ2c+50KDXWUTAyNcjBI49zv5II0
+3RMGOfc7HYKd2vM0WI7MCRQnWDhN6PlbdxiiOsvi4KrnvH8Fd0AIdzJsA9ZonZAnKySCkB4i
+OQUT5z2HgrSeKpM6H0uKJwfUoTIR9BEnW8jQ+chi7QSYSaW202QCxsRQ02kzw5yAMRF0FIfC
+VJwNMnIwhuqQGL1DY76gQQ7K0Bwqo3HCOIfMqBxOXszBmdWBGHd+jrMu4c6PdqqMOy3GHZaz
+L2DkINAgJ3rcyoGg+OHTOaWUPGjohApj6sRU/oCxs0jFvTCjceC4c2gHYc7qYIw7MuacDs6Y
+OhXGHRlzQqfKnM+pM6dzGow7MsYdGeOOO3ZOm3HnGx0C4447Z3MojDvucB3VdA5EApt3ncoc
+0MEmwujhyL9TgMxgEI3h9s8wR8hoxxuVoW6n2Ki2dpCdAZnR7d/ozCkcBjPKebFyNA6HUTgs
+5vgOjxE7TOboDpc5uMNmZJCAkTgS5sCOiOE7MoYPDXKkzDCHB8mZQzoKhgOpGLqjY8iQliE6
+aobm6BmSY8BQIBPmOI4N03KMlJZjxjSgQY4hU3MsmQpky6COMYNC5g4M2TMg1IMppU5KZnVV
+PB6Px+PxeDwej8fj8Xg8Ho/H4/F4PB6Px+PxeDwej8fj8Xg8Ho/H4/F4PB7PmTLmoqPB11B1
+hQZdFTbmGrdvvDZw2LWOo67dHHUpqq2DM2e8IrnKDLuS28xpMIOufzeDjuOYQARmmDNqOoxh
+zqhpREbNiqKGDueMmrbm5RzzaYXgCWF1TrKi6+popp5tO9frVpBiKl16PRM1yAFj5bTijjvu
+uKNn3HkdR8Mc8bhK5xzvAFvpkKGzOMNeOR7rpbCeOdapCgtn1Cked7oxo2ZWPZFDYk60Hx3k
+EBl3juMov72G6GBfynRSZ/uypBFOBwhqtyFOpw7CnPL+DhPJa78wierAGeW82kvuYc6rnbJy
+R+iM+uYPd9xRQj/cEUNHdaTQYR0hdFxHBh3YEUESRwId2nm5gkY5Asgdd16yIHfccUfMuOOO
+O+644w7DMfv0v4ixdjDG1tnepbN487HGXLYbOWTo1BhbZ2f076biTFRXR6dgMsysnpKxdy5Q
+NWnb2Tg5A3SShUNgmA6N0W+pTWe9VT5q5pRFJD+blVPsrVPYzgEYYUHV9T7SFGPOxnkU+WK+
+/iuBGNVssXUuGBNDSmbqB4pDhSoOztg5zx4nMTqnUspjGnRcBy2n4XAhpG+aDnPEQcalNqAX
+KO4jsdNSlmgdIqNzmmOghJjONIQedIXjZE3GMBQOoZRkKcaAYynhNmVZMNpSOQ7NmKEwOxey
+Q2ZuaQKzHiEzlxTMnYJ5QsHcAZgU6sgkkImDMDF0EIfCBJShN1zTwQ2RI1KsnJbyhLZdD8mR
+MrfoJZe0HApDbbiKw2UojpQh7+IMy5E5gnIkDpG53+80SM0kUFfnLndYDKkgC4dSkKbZ7nc6
+pHDCIOd+ByB7J4AOBn2rUzkegJk2BDlf9zSVoHbmpcFVz3l/JndaIwFzCmwTlqAF4UxAmMXa
+b79XIKaTM0neMyiInSpTOmG39qUITp1JoI8tIXu2s3Q+4mQLGTgBYnKp7TQZzEmkptNmAsbE
+EOrQy5khiBnm7FDLoTABZQ7nkJgvCGGoDpHBnQ2qjmsqM8wJKseAWR2IEXzCxR13DuGsC9g4
+snLc+THOuoA7LGdb4MUcmDFzGuWY7UcHOfvDZg4IDXKiR+2cEoofNHRyKHnM0kmp9AFjJyCM
+uYPlxRyEcUfGuCNjzungzCmdCnNGp8ac0Kky53PqzOmcBuOOjHFHxrjzE5w24843OgTGHRnj
+jjvuyBl3XsLB5kM3di4XHKIxx3OU303Jq0c++YHWITK88dbd0U/0z3LkjHJ/MMihMyqHwZzB
+4TAncFjM8R0eI3aYzNEdLnNwh83IHD5zaEfASBwJI3BEzHEdGcOHBjlS5qCOmBnmsCAFw3E0
+DAPSMWRHyVAdLUOE9AzJMWAojgVDcEwYAjTIMWJajhXTcMyYumPHVB1DpgoNckwZHDJmMMea
+QSB7BoR6MKXUSdm1zoDH84IZtN0M2AOszAhomji3P/NrmoNqgDOqfzwej8fj8Xg8Ho/H4/F4
+PB6Px+PxeDwej8fj8Xg8Ho/H4/F4PB6Px+N58Yy7DqC/NOiisEFXnw26zG3Q5XTfc3VgL+f7
+rqrs4UDMqItRh11cO+paYWtokIMzw65NH3Wp/bAZCoY5RlCTGeaMmuBjmDNq/pWXc0bNjzPM
+GTWvkDvuuPNtDplxxx133LFhXs453PGb1jnYhI0ncobNQHmoV44WzoHmunRHxpzJoTAnckjM
+yznneaJ7MYfIdHDgr8mxdtRfxqN0rI98169/GuAE8GumjJ2AfZ1VB0f15U88qLj3NC+BDue8
+2ktunUNnhn1DgjsHd0Z9I4c77mihn+28XEGjHDl0UEcMHdWRQod1hNBxHRkkcESQOy9YkDvj
+BoI77rgjZtxxxx133HHHnfM4EqaXY/HmI4UZ4hi9mSphJBCBGeBs70FnWD+mpxMzHZ39jfuy
+k8yd5EYP51JjuBClGngTMi1nuzn/28GJ2woeC+YMcpeFs6zz8ajJemda5yPLfJeds3yuJmce
+810iBy8GcJZIoEqzYYylEyqMxIGJ5zAjMQqn2jPzYIgHdzfG0Kky80Zk4NSVvJOETKgPgRIS
+O0RG7CydS2UUDrFntO1GWbfM4TG3Z7bFtt/jOQTiFkHRpspxKJVsUOA6gmoWKTz2PY9ZOTkz
+Q+ZOyUyQtQMxCdSTiSETB2MkjoThQC0nhApDdxpMzbBzWoqR02boI1vHkJ1KORTGwCEx5F2P
+XTlCh8+IHGKr3e9ECHHITAI1HXk5CcR2OAwN0jj3ew6NcnBI4YQ7oyD5MIiYYU4bEjsJI3Sq
+z9QLgzgYBDn1I4KFSZ1mQaUz3YOs+/nf9ylGTii058/vUbROyBLv/BOHB+VOziR5f8cr4jlV
+JnO+SqLvElKnzuTQx8d0J2lgi52PLU8qWsbW+fhIIGMnAEoutZ2msjo5k0gmTsCcHbJzIKbh
+hMihMLizQWYOzJAdEvOEdA6R0TpUJmCMtRNUDp3ROKw0HJBxB2XccaeDgzKjnHWBF3Ng5nzO
++rg7LGh7+DWc/WEzB4QGOdGjdg4A9XEKqM3InEyKHzB2Iim929xZpPzODg4Yd0wZd2TMOR2c
+OaVTYc7o1JgTOlXmfE6dOZ3TYNyRMe7IGHe+02kz7sgYd77PoTDufJtDYtxx51wOjXHnBZx1
+OnRopvIujmJKdIpTK4jIkB3tpASschSXbpPqwRuOyhzMCcpWU26ndOYUDoPROBzmBA6LOb7D
+Y8QOkzm6w2UO7rCZYzt85tCOgJE4EkbgiJjjOjKG7QgZNjTIETM/25EzLEjDMBwVQ3d0DB0a
+5GgZIqRnSI4BQ3EsGIJjwrQdG6YJWTENx4ypO3ZM1TFkao4lM8zBIVsGdYwZzLFmEMieAaEe
+TCl1UjyeF8ygTWbUtjlqJxCWaQb7O/PbFGOcS2/m1zKDbXdngvypwOPxeDwej8fj8Xg8Ho/H
+4/F4PB6Px+PxeDwej8fj8Xg8Ho/H4/F4PB7Pt+S1LtgZcr3OqKsDB12GOOpyx0HXVX7PVaK9
+oJIZdhXvMMceGuQgzLCL04ddbD9qjoJhcy6MmkJi1IwYZtBhnFEzo5zKITDDJsgZ5ughGuOO
+O+64Y+YQGXfccecHOK+2fxt2/DbMGXbge6QpKE/1CsidbsyZHArjjoxx5+BOpwMEzbfXEBnt
+l/EQHe13GB3MUX8nExG6rF8zNaCgUc7AgVAo53llQnW0kDudnVFfXeCO0Bn1FRbuuPOSzqiv
+mnFH6GigQzoK6JiOHDqoI4aO6kghtiOERjkvV5A7MsidYY4IcsedgzsSxp2Xe/5xxx135M6r
+7d/ccefwjoA5twO8mdrDgd60tXfgN4fNHeQ9aAnUYi7LLaVDYsqyLJ2E6edcKuUYOpdaOWxI
+ylg50Yc39hsKqM0ErJMMnOSjKHlZEofAxPeZOusHax5J5rtM65mdxyOHpn9kEN5uObNG5MDM
+E8IYWwdVZI6AuRg6NSYZ3DqnwsgctvJYRreB02DmjHIeLCdZ/4XDrJDEuTAUhcMwNE57zbfb
+LVqM0UFkJtzWLAvuWxDPaRaSQtGmynLozBNKPsRq59zyPCHOhkpiCmUpaYRzkzlsJoZsykGY
+CDJxUIZTUIsJAWc4BdWdmsFyqkxLMXLaDL2DKg6BYTtChuzg5TCZBoQ6JIbtGJQjc/hMHUIc
+Yqvd7/cBzpOJIb5DL4cKaZrtfs+gPk4Y5NzvDEjuhHsJdXBihlCQeCtNnHZBoFN9pl4YA6d+
+RAAx7YYrnemeCvE+JXOaBSFOKLXnHe9bsILITsgS75XfozAbLndyJkniwAOB6FSZxMmkjs5T
+Iu/jUqfOZNDHx8d0Z8LYOx9rsmUsnFAqhURwmkwAmRRqO20mwEwCmTgBZmKo6VAY1NkhOwdi
+6A6JmSCVQ2RQZ4VgZnOoTMAYaycEucPLIAdhPqqMO6/mYIw7Mie4c2RnfdgdlrM9bMUcxDFr
+NthplWN1eDDI2R80dEooeszSKaBeTkAZYyeRkvutnU3K7rV34AxyMMadQzgoc04HZ07pVJgz
+OjXmhE6VOZ9TZ07nNBh3ZMzJnCbjzk9w2sypHALjzvc5FMadb3NIjDsyxh133PlGh8gcysGm
+Ke/kqKYqP5qjvQSZXA58fb2ls7eb4tJtioP3EJmhbj/acnTbKZ1ROQzmDA6HUTgs5vgOjzm8
+w2SkDpc5uMNmju3wmUM7AubIjoQROCKG78iYwzpCZpjDhMTMz3bkDMtRMBxHw3CgQY6OITtK
+hgqpGZqjZ0iQBUNwTJi2Y8M0HSOm5VgxDciOqTqGzBEcS6bimDLDHBQyZjDHmkEccwaGOjAl
+1AXZoW6r95wig8bAqMHWfatJmWFOZ+gpzO9SdHeWt0N6O8vbLn2ZX9vbO52dX4vTm5kr8icF
+j8fj8Xg8Ho/H4/F4PB6Px+PxeDwej8fj8Xg8Ho/H4/F4PB6Px+PxeDyeM6X/1SDh1+tdTTUC
+GnKZaH5F6iCmkxPKC3k7QWXO7ADMsKu5h10EPw4axAybDWHYJBKj5t4Y5oyas+RsTosZ5oya
+icedb3QIzMs5FpA77gx0SIw7MsadV3debVwfDTqRM+xI5NWOFN3pxpzJoTDuyBh3fqKj+pIc
+qoN8K5Mxg375kzs1aDZ69E9W0EBnTAfBX83VwcHizrGdUVP9uyN0Xu2rJdxxx53XL8id3o4O
++sGOCuI4GuiQjgLiOXLohzti6KiOFPrxjhByxx13XtCRMYd9XngxR8r8dOfVxsHLOS93XOWO
+O+68qsNmhjky6Ec54DvdMojEZJ4ts79vX7yDb+lsHxAAPilg6OxrN/l4Bamabk704Q2bj3Ew
+mBSzc9L2K6oycOKmQged3rkATtlLhuU8vhLfmS6mdqbN/5HlcnnErIkTSmaLyOEztg6FMXBw
+Jh4LXRkRxGUmyMqpMY9L3EUapqqs0TskRuVMDU9jVkhWzoWKqBwGwm04BvO1xO12WxfjDTiq
+ctszLRptQkyHykxQ/ETEc+jMBpk7tyJxr3ZkEsjKgZgY4jhshgm1HYyJIINmCzgjcdi1GDq1
+UphOjWkpnIFQcdqMiUNg+I6MYewSMIfLNBy02QY5bKYBaZhbuN9HOF9MDAkcWjn3Ox1SOOGe
+QW1HtIne7xnU27n3dCKGUpCJQyhI6iQMoSDQaT695U67IJBpO0HvTPdUiPf38P7+fgcdHEKc
+UGrPO963wPUwnJDlFu2W31GnCeVOziR5xyGmU2US5503suVOSvV1wjq+t0VoTp3JoY+P+V7K
+s6rc+ViTLkJxWkwAlFwiOE0mwEwCmTofeThOm1mhgokgGyfoHRIzQ4CzQS2HyASEWR2E2Rwq
+84TETuA4IcgdVkBmmPMx1MEYgYMwr+YEdw7hVIfB6zjBHYmzPuoOy9ketXNA6MWcNmPyvL0/
+ZOoUEMGRMDkUPWDsBIQxd3YpvdfegeOOLeOOjDmlU2HO6NSYEzpV5nxOnTmd02DckTHuyBh3
+ZIw73+gQmDM5FMadb3NIjDsyxp0Xd4iMO+6cyaEyJGeap7y/g89T3sdRXUqrc8gMwVkIELJ0
+onr6OpEkZojbzygHvnSbwaj2B4McDnMCh8XIHR5zeIfJHN3hMgd32MyxHT4jcgTMkR0Jc2BH
+xPAdGXNYR8gMc5iQmDmmI2cO6SgYjqNhDuioGDqkZKiOliE6aoYGGTAUx4IhQDZM0zFijuJY
+MQ3HjKk7dkwVsmQO4JgyuGPLoI4xgznWDOKYMyDUQcmdLkQKdSQip7cyO/2VYc6gZhs7CvpD
+QzadZCsd5XSFJmB5n6K3cxnjrO/v9GR+Re8jdXV+7W9X9XVWqLPyldC/0Twej8fj8Xg8Ho/H
+4/F4PB6Px+PxeDwej8fj8Xg8Ho/H4/F4PB6Px+PxeL4tft3ECTKmk17rOsFXvKyuPzTomuEQ
+hkA5M8zpIwHMMKcDBDLDLuwfNU/BqGkXhk2+4Y7QGTUJy6g5ZdyRMcOcUVMyuSN0bKA24843
+OgTmTA6FcUfoGECv5hyrgwycY0Fncl7tmcGdbsyZHArjjoxx5+c5yi8XIjrqLzFSMdYO/q1Z
+XRzNl2aRoIkY6PTuIItvAaM4SDEdHCyjnFFT1rvjjgnkzrGdww04d9wZ6ZxlQ3XHHZajhH6u
+o4MO6KggjqOBDukoIJ4jh364I4bcccedUTs4OXPIJ7pBjob5yc6rjYMzOBxm3HGVOzLn5Y4T
+X815teMQd8Y6XGaYI4TckUEv5ggYEURYq8mnONqKzacrKIxFQaJy7B3sY0NciFLOZbnR24n/
+7egkZUmhppOWJXUqwiPJ5TL9Y+48kBg7GBNBgxgLB1Xi0dCRSRwGxGWeo87MqTDSgSBQIkjI
+TG1PYLTOusmbQ+wGM3Boq1c77T//9pW1H8VOTblF2ccLw+EzM3RhFiRgFiiIHA6zdRLdoZQD
+MAlk5IBMDNk0G8JEkIUTUIblNBgciSGtU1dYBVWcliJxRAzDwcshMBYOi2lDgx0RY+BwmSYE
+O0TmTnaQ7iEx968wHVE5dwakLCeGOjv3vs7GbNAopwqJt577nVWQ1AkWTuWZGmIoEOSEphNk
+TqaEKvT+HsL7O+hUIMQJgBae619zZxZUOKHIvlt+t3NKJkrTwSGpw+2gzKkyiZNKPZ3nwBM6
+dQZwQiA+2+mdNCZOCn3M4TstJQBKLpk4AWQSieC0mYAw5s4qfeRhOCRmgQpng5oOkQkwszoY
+sz/PUZ2gc8jMVwBmhRoOLy/mgMxHnXFnmAMzr+aEoY7l9vMjnPVBd0QOyhg5zXLO5WyPWToA
+NMjZHzJ1CojAyD5UxS9H5gSYsXcCpPRwnlT4yO/q4gBxx5oZ5VgyP6jZLJ0ac0KnypzPqTOn
+cxqMOzLGHRnjjoxx5xsdAnMmh8K4I2PckTHufJNDZNxxx8KhMu64Q3XwCd7pDMHB5ynv5Kgu
+paU5+m8UYJSjuk6TVs8IJ6BDgcEQtx81o9lOX8xhMXKHx7gjY47ucBmhw2aO7fCZQzsCRuJI
+mAM7Iua4jow5rCNkjupIGS40yJEzh3QUDMfRMAd0VAzd0TFkR8mQoUGOmqFBBgzFsWAIjgnT
+hoyYlmPFNBwzpu7YMYdwDJmaY8lUHFMGh4yZb3asFcSxZyCng5I5XYTc6YjETl/m1yDm1Zzh
+w6AzNHzreSVnfT+ks7O98dLX2d7g6cf82pm+zq9BzK9fo5xfg5h1bHdnPB6Px+PxeDwej8fj
+8Xg8Ho/H4/F4PB6Px+PxeDwej8fj8Xg8Ho/H4/F4PB6Px2OcQVeHDb5u+DWu5x10/WsIQ6Dw
+TY49FCClT0UQM2oeiR4tN8JBkIHOqFlYRk0q83KT8Yyaw2iYM2ruJ3eEzqipxk7mNJlRM8EN
+c0bNoDdqQsBhzssVZOC82oA7FnQqZ9hsly/WboMcAnMmh8K8mjOIcedQDvBtSeYM8rVMZ3X0
+XzJFcp7GAGdheji/cgeu5zwF5c6wgQB+SdurTfHuzsEdNeSOOyOdo21A7rgz0jnNhvpDHS3j
+jjtHdIZtp1rocI4Sojs66ICOCjqio4Hc6e8omAPuEHTM4Z4YBjla5mjOq/XPyzkvd8Azyhl2
+YDXKebnjnVHOqx2HDHMUkDuv5MihQQ6TeTlHCv14RwgNcviMDJI4EugwDvjxCnMH+RyHtYN9
+XGSUw4bqzO7knH05F7guSydhOjvpjW5OeDyj/uAdbkxrf+SxdgpA59SqqTM2DsIk3WTgYK0m
+dZjMNDDMHFTJukjsTK3SUEROKJymIhrZnOYqGZFDVGKG7DCZYsDwnTZwe2YfLTKnqtyiLA4T
+Ijm3WwnxGk7ALE0nczhMKlk5gJJAXZkIMnECxuyQgYMj3IJqTKUWrlMpp46YOU1G4kgY1sjG
+HALDcdBmG+RQGIGjZNoQ7LCZjk643+9Kh8owIKVzJzriZluYHert3Ps69zsLkjp3kcPfSu8l
+xHcaz245QykIckLTCXcI4jnTHTXjGSsHkr7ufJ+DODWocEIl71tO49SYyGE3nNDJKloXIDtV
+JnESqasTjbttCaJTZwDnGdKTnYETh+Q0lML5eKa/87GG6TSZADMxZONE0kcSjkNhVukjD90h
+MjOEOSizOWTmCRXMCrUcVkY5YZQDMB8Nxh2YcecMju32M8ipMO4wnfUxd1jQ9tAgB2dMHEI5
+Js8/vZyAMH0dEiNzAsh0cALE9HAmKb+riwPEnUM7NcYdGXM+p86czmkwo5xBjDsyxh0Z446M
+cecbHQLjjowxcEiMOzLGHRnjzvc4VMYdd9yRMz/QwWb1NnbW6cOVl4TSHd1E5SQHaTwGQ+yf
+Ac4lTs960B7iMLTtZ5QDXlHNYhT7g0EOjzm8w2TckTEHd9jMsR0+I3IEzJEdCSNwRIw7Muaw
+jpDhOlLm5RweJGcO6SgYjqNhDuioGLqjY8iOkjmao2WIkJ4hOQYMBTJh2o4N03SMmBZkxhzD
+sWOqjiFTcyyZAzimDO7YMqhjzGCONQM75krpdCBKpxeSOh2V2OnKuKNl+kLfMKx7OoN2BsOd
+5X2X3s6lt/NrYyaor3MZ44xgvqDLGOfXXk9XZoW6M7+mTuqPeDwej8fj8Xg8Ho/H4/F4PB6P
+x+PxeDwej8fj8Xg8Ho/H4/F4PB6Px+PxeDwej8fj8RwoI667H3Tl/ZjrurPLxzs4AWJGTfPR
+QUKdF5vu5eXabdjsQqNmS3o559Um5xo1p5mZ02CGTTk3zDGBCMzLOS9XkIUzasANc44EufON
+Tps51YZ6HOZMDoVx59scEtPHUX6LEc2Bv//J2sG+ZqqT06GDaIyts32b1QBnZLv1cMCCejtI
+59g3HB533HHHndM533lk5Y477rjzcxw94447P9d5tf2BO9/mHGtguyNyDJhDOa/WP+64M9Q5
+0RMQzTnPmSSio4aojhYa5JAZJfSDHRXkTn9HA72Yw2KGOXLohzti6KiOFBrksBkhdGBHBB3Z
+kUDHcOw+ldJgEMjW2T/Lo/6cWpO5LLeUEJXp50SfgOrvbLfzR82Yx+OLecTp4jyg2Dsgk1TU
+kUlGg4UDM+YOzjxkTg5Mfy+i5D2kc6rIQzjiSK1l7JAU4cBmMzKHxaRjhQURmdst3OYszkXq
+NJg9aUFch8zc0gFqWM4tj8JhKKlk5YAMG2oxiBJDBg6uWDqhxuwQx2HWwnbwcpoMq+FQp81I
+HAlzJofCsLZU2GEybQceBkyF7kjG2v0+xLnfOZC02SYmgjo7997O/c6CpN1zv+fQqZ37vYD4
+Tmg8u+2DgF4QVE7bud+5BZXOdEe1mBDMHEh63vv+DOJUocIJlbzPyZluDgJZO5KCcqfGbM77
+u9apMpHzPspJqXUBqlNnMmcfENsC3ZwsNKehnM1pMoXzMcXeSaWPNTyHwsTQx0cJERwas0kf
+SZrM9nxKZmboQ+hwUjIrZOuEkhnrVBjZm2Wl89HDARh35MzLOcbbzzc6wR2Jsz7iDgvaHhjk
+VBiL5x9KOcd2AqT0cALE9HACwHRxvqT8jhqjcIq4406LcUfGnM5pMGdzWow7MuZcTptxR+YM
+Ytz5RofAnMmhMO7IGL1DY9yRMe58j0Nl3Hlph8y44855HDpDcJDLDY0dfFrvPo52AnG6U0KW
+znIRiXqif0Y9uWTqBJQxdtChwGJo26m+HPn+gMcc3mEy7siYgzts5tgOnzm0I2AkjoQ5sCNi
+juvImMM6QuaojpR5OYcHyZlDOgqG42iYAzoqhu7omMM5SobqaBmio2aI0CDHgKE4FgwBsmGa
+jhHTcqyYhmPG1CFD5giOJVNxTBncsWVQx5jBHGsGdswVkLFXCqcHUTrdlNTpyHyH05P5DmdY
+/3SEBm0937OZdoRe1Vnf4OnsXMY4+ztWvZxfIXnXtxszzPkVv9HXkdmhzsxXBjEej8fj8Xg8
+Ho/H4/F4PB6Px+PxeDwej8fj8Xg8Ho/H4/F4PB6Px+PxeDwej8fj8Xg8Hg8x3adFWJFXmRhh
+0HX3OTNkjpReDsSMmlqmA4QwZ3UwZti8TKOmmRrmGEI1ZdgcbcOcUVPoDXNsoAM5L1eQiXOg
+EWfjHGYWSndkzLm2n0EOgTmTQ2FebIrdV2u2Ho7B1/FQHPjrn6wdk2+Zojs9OojE2DuhF5SV
+M8KpfX/aKZ2AtZr5wEbjjjvu/D97d4PlKA5lW9hiAuHMmv9cKyPCPyAkENI9FyHvvd7rqszq
+9rcEGGMMAscO6stpZsY/UsTB+RTHgMHRORYMDg6OFsLBwcGxhXBwOnNGO8B2c0b74ujmXOdM
+XyHj5rRC3TmN0Oc6bdBgzgGmCfpopwHq06mHBnMOMtXQYacS6tepg3DqoBqnBtp8vfS1L+ZO
+7iKbCmeHcXBmlyYZXHi34+TGdUHn+/VfYvyfLJl/W/Xfn6Z//1/mTH/jWqADzL9xVTtZJqH8
+XawmCyeF2Do/L5Vh/jnzVdQ0nH9OTok3hXpnUzBzCpRa56iyfAvVOBVMuVM8nLDa7VQ6W8jX
+u1ankGl1tpbY11cztD+cr3UNzhFmIdk4aWUOHXMOKoedzeFsMG+o2dlUjg4oy+woVs4uc3DB
+ZZwC5pCTWT1HmCLIYDgNTgnj5ITQ7hQx90NQpRPu/zrgVA/nfp9LMue+dHahSud+vx8bUKtz
+lzr3SmfJhANMKZRwgsBJLLaw69zvCeio8/PnDeTff7VzktK/v/3zr5gpWnArJ2z050/SKRlQ
+z07NgoudLcbQ2WReTnqDs3Z+Sjlb0NLZZubOgtI6ryX4+u+lzg6TchYVOnuMkbPLrJwYsnJi
+qWo8JUwE/fddEfN2ypgF9d9/S6jAOdJSmUEK5795GifEzBOyd/5LOVtMnRMzbs5/l3aCk5Nm
+3Bzz7Xp4J+DUOM+/v6oT0swgzvuvzZ1wmKl0QoKROGGliJwQITJnnZOzyeDg2DrbzOWcHQan
+jrmYs8vg1DE4JzoFDM55TglzIaeIwaljvJzBhtPsFDI4dQzOKU4xg4PT7pQzOCc4B5h+nOx0
+26bOc1rv5nm9S53WCet3nMeNbEnI2pnSs9YfYg4stxgydZaSbjwLqYE58D71cpYdZHDqGJw6
+pm/nONO1U8HUODVMx04V069Tx3TrVDK9OrXMhzvVzEHIyWlgjjgtTIdOE1PutDHdOY1Mb04r
+U+g0M2VOO1MEWTAFjgmz79gwu5AV04ljxmw7dsymY8j04FgyG44pk3dsmZxjrOQcc2bt2BMp
+R6REjkzxYnAsHK/twM2RQSftDfwcEeTvTC7O+wcrjXN7Mw9I50zzHy5FzDe0+KVP6LgMZzYg
+LfOC1Myv5KAQEREREREREREREREREREREREREREREREREREREZE0/TwPc0V+Y7cLNNRED2tG
+4iQYl7l/ru2kGbeJprzmzXKbPc1t0jkraI9xc7wmH2TB1UI4OHbOLuM16anXHK5Xmiu2o+Fc
+yRlsOCsn9bQkmSOAUkrb05/2HZunWe06+cdz2Tq5pWYCFY3H3Ek/BEw0Hi9Hvdzm8xxqnWxe
+jteU9cMtOBwcnGqnnenqGRY4OFYMzuUdEwYHZ0hntLO93ThGDA4ODk53zmj76+Gcix2IfJ4z
+2hctN8ftRMVoJ/rG+yWjGerNaYWcnGLGzWmDPthpgnp0GqBDjJtTD3XqVEO9OrVQt04l1K9T
+B3XsVEFOTg1j7OSuGaqCShyL6/sKHJPrCDec8GIMrovcW2bpa7sMmWn9rw1Qnvn77PGv9s60
+YGbeZOlMGWbpHISKB/PDGDsp5Xc91TpLIvP6s0ycfWaxzVU6BYqFU8TUOtXLTOP8/G981Ttl
+zNerWqiE+ZrX6BQqMWTlxEgsKZm5ZOLklPmIjjkHmeMDyjtbymEnu9i2lRnUNpxdxt0pgzLO
+PmPiFDBVTgVzzKkdTphX6xxklM79fm92ypgZJHPu94NQ5WK7R5DIud8jSOPcV84ulHLCAad0
+QAkn7Dn3+xo67nz/8QBzyImYLSeEpLMHpZ2U9Fzj97gqJ2z05zsvZ8U4j2cbCpGzxeSckgFF
+zibzcKpW0HEnARUsuKWzzTyc9dZQ7oSjzoI66uwwkfO9BMOMKXb2mJQzr9DZZfYgOyeGapwS
+JoaKmZqz8P5OCP/9p3f++03t/PdfBEmc/2aJnBAxbs5/Mue/kZwV4+UEjRNGc8I5zvNvr+uE
+FINzxJn9pcAJXk5YKTvfs2qdECkyZxUOzi6Dc7Kzw1zN2WNw6hicOganjsE5zylhcOqY6zhl
+DE4dcxWnlLmIU8zgnOGUM15OEzOaU87gnOAcYHDGdY4wu47VnWb7TG6+bUvnNX148/1SBeNJ
+z79v7gSTif73hzOlF94xpnQ7UDshuy2YO+k56w8y1fuDwZyjDE4dg1PHVDkVTM9ODdOxU8X0
+69Qx3TqVTK9OLfPhTjVzEHJyGpgjTgvTodPElDttTHdOI9Ob08oUOs1MX047U+QYMCWQCbPv
+2DC7jhGz51gxO5Ad04VjyGw5lsyGY8rkHVsm6xgzGcdaSTPmSsIRGAlHpMSOjLk5MWM7XpuB
+myODTnqb+jkiyNNp+2mn2Gn8Cemg8/rFSub8LLf3T2NSZ/YLnMZ5LDj1cH6gxQ+KMucNaZl/
+0NtRMs8RqZVfyQEhIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIqJBEs+PETn6O7vlM3FE
+zABzpZw0J8vFpzBZMQoogVg7acIc2mK8Zp1zm0XPzRluQFdzhhuQk7PHeM3e6TUZ6aUmPXUa
+TgHj5TgxOHWOBbN21k9LkjjtT2UqcgyeMrXv5B6bZewYPZ2r3rGdCtvscWMFTmKrvvR4MuvH
+eEr0nDLcFO84OEZOV88UwOnbMWCGc0b72oiDU+bYMDgix4jBEUE4VY4Z81mOHXPiM5QsX33D
+0TCnPWUEp2tHxQzuyJgOHOV+NP5rlRPiv1U5caM5lzvw3XPcvmhd6wv3PnOtE2MljtsJ0uuc
+kS9j2qHenFboY51GyMkpZ9qgHp0WqEunATrm1EOdOtVQr04t9PFOJdSvUwc5ORWMm1MDFbyq
+yfWKRYyHY3T9Zc1waqBdJ5hcd5d/+b+LFM73AP6uWi4+o/GsmTanWPmBrJz06ydXUoOzpzRA
+BxkDp0RZbNwK5/s/x9uKhEll7nz/96+vLwtnA/l6V+vsMnNkBR13MsrXOoWTYOqgTSapLCkL
+J89UO8eUGdTsbDNWzo5yfMFlhmPt1A7HxtlnTJwCps6pX2qlUN1wgo8T7vf7Madu9dzvR6GU
+s7/Y7ktI5dzvS0jk3O/HIScnxcSHA3nmBVU4Ibg5m9B9WSG0cn7/nGeCqbOGnmv8HlfnhK3+
+/FkzAufPv3LOHtTulA0ocnYWm5Wzyfw42QVn7eQ2uB1o4Wwzv86f1aYtclZL77Czw8ydOVXi
+PF+ihImhP8v/WOrsM7GzhAqdAmZ7QEVOaV7OkipmcE5w/vtO7/zn4vz3n4vz338xJHH+O+pU
+QI7Of4ed44ybE0ZzQmozUDghuDvvv5I4YcUoncXfaJwQMypnFY6AwfkQZ4fBOdfZY3DqGJw6
+BqeOwTnPKWFw6pjrOGUMTh1zFaeUuYhTzFzDKWdwTnAOMDj+zhEGx90ZbDg45zsb02AfvN+j
+hLGYEL1oPAb3S+06wWZi/P3xvIYldqb0wjN1QtY5yBS8f0yGU/s+PcrguDqHGZw6pmungunZ
+qWE6dqqY404d8/FOJdOrU8t8uFPNuDmHoAbmiNPCdOg0MeVOG9Od08j05rQynTnNTJnTzhQ5
+BkyJY8EUOCbMvmPD7EJWTCeOGbPt2DGbjiGz5VgyG44pk3dsmaxjzGQcayXl2BspR6N4MbGj
+YnCu5Xhtb27vHzdHA/28cttPLsVO409Ihxw15Og8fxR7YQrnDb1GJWFOcdRv1IUjYr4h/VL7
+yWHtLCGtcnssOrlCRERERERERERERERERERERERERERERERERERERETUadr5PiLG4RZyH8jJ
+cZjB5DRHCIVTHLdJc7SvroE2FD/Hax49N2e0eQ5x6hgrZ4/xmiX0UpOe7jOXcgYbTkeOEyNz
+Gh+WVOqsnv4kcjQLLh5L6ulcxo7V07l2nPxTwIxn3HZyvMaTfmSWzlkPx3xG9LTiNvO620zy
+bgPCwcE51enoQBGnzjFh3By3h2X04hgxONd2rBgcCWTHdOEYMj04lsyJD7Wxff2co1FGf/qH
+jDnH0TE4nTs3J2ZgR8rg4JzknHLdltdD/KzHt+Vc8GKXHcbNcTu/43ZizOs87KVOLBc5br9o
+tUOdOc2Qk1PKtEL9OW1Qh04TdMRpgbp0GqA+nXqoU6ca6tWphT7eqYScnONMHdSRs7rmSuIk
+ru3SjMfmerh9J1G/Tv61/j57/Lntoca7ytuaQ0bO30SL7bvV+ZsklguwBtodRQ5qcHaZeqdW
+qXfKBZ2TYI5BDUyds6F8PRM64WtRs7MzklboKLOEbJyUsoQOOweYOWTgZJWFpGXsnG3GzNlh
+ap2jjJGzyxzf4lLOPnPYSa6eA0qLc4hROvf73cs5CtUyM0g6nINQjXO/R1CdE0qZNuffn0qd
+e4MT9pz72imADjv3ewI67vz+sVA57PyNnLX0+7cx84QOO2GzNVM6oPRiK2cUToopXXCRc1ip
+czaXWviz4exBh5w/KanC2WZ+oLUkcv7Ea+q4s8f8On+iUR12dpmZ87ae/63MCSVMDP2Z/6dC
+pzAvJ3g5WcjaCTjNTjmDc4Iz/9vRnOtu1+kBeTn2y20GiZ2XdIIjWD9vycH5ocqdBmY4ZxGO
+gsH5DGePwaljcOoYnBOdAgbnPKeEwaljcOqYyziFDE4dcxGnmGlzyhmcOganjsFxdw4xOKM6
+xxicOmfnxXLTRts6G/Ngmy62jXm9rZ2n5uAkp6w/yJQut9WYTJ2QZYydhdTCFLxNLbbq6t2B
+k3OYwaljcBydCqZnp4apcKqYfp06plunkvl0p5b5cKea6dOpZ45BTk4Lc8BpYvpz2phip5Hp
+zWllCp1mpi+nnSlyDJieHAumwDFh9h0bZtcxYvYgM2bbsWO6cAyZLceS2XBMmbxjy+QcYyXN
+WCNJR4CkHA2zckRM7KgYHBvHaztwc6Tvn7YZ6g4w859dZM7k46x+R7q2s/5hTOMsfuy7vHNb
+OxJmOSDhDiHEj9vWMIsFJ/5kcFg7S0jLvCGt8ks5GERERERERERERERERERERERERERERERE
+RERERERERJ2mvRs+cvSQeqKU2BFD+plfYkc8l4C/I52D4QxHCCmd2YuGoIPi1z7DueDEgJsM
+Th3jNaum1yShl5rzdJ+51HD6WWwmDA5OZ475+2f9fCmFk36SlWA8Ts4PkV5y5o5wQAXrx3ym
+8vTmNtzM6ziVjtdM/zh1kAWD07nTzxGPDYMjgqyYD3PMGByFY8e4OR08zISHphx1jIm0o0DW
+jkgZ42elrKNjhnaEDI4B5ORIGX9Hy7g53pe3qBkcnBkzzPvUfTc63tVU0ZVCQmetejhup128
+TleZSf04/DJT7RhAZU4zVMi4Oa1Qd04j1J/TBnXoNEFHnBbokNMA9enUQ5061dCnO7XQYM5h
+phLCqYNwqqD8a/19pHX+zlI5f6MMBrQjmA2oALF28ky7U8schYoYLyfFHHPqGWsnfL2ycJLG
+V1Q9dIiJJCGzgGycpLKAjjvlSiWUczaYBucQU+NkhrPJzKBGp5Qph5LODlPvHBuOlXOA6c1J
+rZ495v6vo1Dvzr3dKWKOQsed+z2CKp0QypgaZ64UO0eg1XD2nPt9DVU4v38sZHTOPekUQGkn
+pn7/6r6u1gkbJRiBk1LsnbTygo46h5niAS2co0vN3slSx5wCJkPVjGeP+fMvA2d3OH9+Cm3O
+rvKC5qN6/pdSp7A/sxb/wZZZOAvJ2MlC1k7wcjKrCAfnE52mN+rsb6WOdLmlB3RhJ4zmBC8n
+eDnBy3lIDk7wcoL0eGfuHGBanHlOzGhOL6sH51Rnl8GpY3DqGJzznBIG5zSniLmOU8bg1DE4
+dcxFnGLmGk45cwnnAHMF5wiDU8fgjOocY3CcnYPMZznpyZytnfz01BrHZEr0bSfk5l43ZJ6T
+bSchY2ea/7OB2XUy68jUWUjC8cwl5XLLd5jBqWNwHJ0KBqeOqXCqmH6dOqZbp5L5dKeW6dSp
+Zj7bqWcOOQ3MIcjJaWL6c9qYYqeR6c1pZQqdZqYvp53pyjFgShwLpsAxYfYdG2bXMWL2HCum
+E8eM2XbsmE3HkNlyLJkNx5TJO7ZMzjFW0o45knQUSsLRMCtHxMSOihnd8Vo/Wmf+C4LQWfxU
+oWOWjgZ6M3Jn9ROPxln/ZKV2lFtC6te+azvhDEf4Rl39FityVhuck6NhlgtO+UF3W+wRdMwM
+0jL/8lGIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIg+Pend8AvGBRJPZBM5ckg+M0/k
+qCH91DwR4+ZoJ3vwcUJwgYLSCfmcGK+JAS/obDJes116Td55rblInZheVo4Rg6Nh3Byvdw9O
+N85iWkCVs5p/0BYK+5C9k15y9k56QLZOlrGfED2tuE28joNzOaejJwrgnOn0cyRiwwzn9PLN
+xIpxc/p4iMVgD8sY7KEcgz38g6d/HHXMjZQjQdaOivH62eLmxJziCJmRHSUznOP166+/o2Xc
+HK+rGpwdOeN8eQsOjo/j9f7x3e2Msrt2/zQd72Iqv6upfiiFGjOq4W06bqer/M5bjncJwrV+
+AipxDKQyxs1phnpzWqHunEao3GmDDjhNUI9OC9Sl0wD16dRDnTrV0Kc7tZCTc5hxc+ognDrI
+ycm/2N/fpM7feSbQxutvQG1MWjF3cozFgithDJwixtTZYLycBHPQKdkGvv4ldr4WWTj7ShN0
+iFlKNU5utWxBJsNJI61OOVMJZZwNxtLZYlqcI0zdFpdytpkqJ7nY+nBCvXNsOHcf534/DqUW
+2z4zg7ycQijhZPaeC+bwgNZO2Hbu9wjSOPeVUwbFzvcfipiDA0o5G1Cjs2Tyzv2egOqdNfTv
+7+6rjgwo7SRaM4cGtHQOKfZOWjnihBInxzyhw85RpnxAC+fYyrF3DFbQ3MkzecreSUrP/3TA
+2VOS1lGntD//SjDWzp9HMSMZz7P53yuduWTthLSzyxw/v4eDg4OTgqROGM0JXk7wcsJhp455
+QuM4wcsJf6SHIZkGc3YZnDoGp85xYnBOdAoYnDoG5zSniME5yyljLuMUMldxShmcOuYaTjlz
+CecAcwXnCHMB5xCD4+0cY3CcnYMMzpjOUaYHJzNptLWzMT+1uRPMZsLedF5cM7M3nrenGs5s
+BRnMVF7nHGZ23j5eTq7BnOMMjqNTweDUMR07VUy/Th3TrVPJfLpTy3TqVDOf7dQzXToNzBGo
+ienPaWOKnUamN6eVKXSamb6cdqYrx4ApcSyYAseE6cexYXYdI2bPsWJ2HDOmD8eO2XQMmS3H
+ksk7pkreMWYyjrWSdOyRpCNh1o6GWTkiBqfJeZ/aVzqL3xDkzqR++0Q/iqic+McXuaNccItf
+rYTQ0pm8nMnLmS7vrFeQxnFhUtu1xLn5bNbRgJT7a4eNbQUpnTkkVOaQlrk9DhLUCBERERER
+EREREREREREREREREREREREREREREREREVFVXvfEO919L54A6CxHDemnaHJ1HKacusWzW0lf
+XOVkFbd5Aa83m+Km4TLXpZmxzVzRcdoGvGYI3WaGc7wmpMWpdLwmJr74fM4WzwDbduZzp9lD
+K0c0oIWTfvScvZMekMhRL7eQfhSc27zrbs5wA8LBwTnZGe2Ap58jRSfHiunkmQ+jOXZMF2cq
+LJkOHFPG7aEcwz8tQ4KsHRWjPS+ec3TMzYlxc0b7tWdcR8vgNDpixvtXZjnjOAe/E0NE/ee3
+1xnoIievj7lRj96GuMjpnK8/c8jtyiq/01V+5/nGu3Tj6tcGqKQSxwLqyjGQnJxCphnqzmmE
++nPaoANOE3TEaYE+2mmA+nTqoU6daujTnUroMDOcUwcN5uRe6+8rGyj/+htQI5MwPJ011Obk
+GIMBFTG2Tp4xdQ4xEifB1DsZ4utRo7PNfC0zcAqUJmjDWTMLqMopQpaQiZNjZpCWqRxQ2tlg
+TnCOQElni2ly6pgDTtNwGp1N5ivca6DDzv1fXs7dwgn7TAW0Ho7ESQxn07nfI6jW+f5TAXN0
+QLETNp37fQ117Tz+uENUQGknkv79ec3YOMsSyhs64GwzacXcyTGHFtzCOcYcGtAZzrG1Y+1s
+SVVOjtmQygcUXtAGk6Oe/63cKcrLWVEy58+/1ozG+fPAZn+tc74TOhkIpxcn4OB4OqHOOcy4
+OWE05y2pnXCSs89UOsHLCV5OUO8OZpCPM8uJ8XL6WWw4dQzOeU4Jg1PnODE4dQzOWU4Zg1PH
+XMUpZS7iFDM4dcwlnANMi3OEwalj+neOMTjOzkEGx9c5yuDg7DqpSZbNnez01CrHZuroLefJ
+eTjpubBtneyADJn5CtI6G1uCrfOi2pm63QFOlVPB4Pg5NQxOHXPcqWM+3qlkPt2pZTp1qpnP
+duqZLp0G5ojTwnToNDHlUCPTm9PKFDrNTF9OO9OVY8CUOBZMR44Js+/YMLuOEdOLY8XsOGbM
+tmPHbDqGzJZjyWw4pkzesWVyjrGSccyVpCNQUo6EWTsaZuWImF9n8nLeZ8P1ziR3Jl9HCc0Z
+N0cIhfXvSQ7O5OlIoCWjG9BZzjSYo9veXFbPzWmzvq2Ho9rBuaye2y3eDETMajwqZwnpmAUk
+VL7zUb4TrhciIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIhqq9TxtTrPOKaA0Y+5k
+GKepB62hPHNJZ4Nxm7jzgs4m4zZ/q5sz2vy6wzle8yxf2HlPnaZ0FnO02UMrx+LpXEVODIkc
+9XILU/qRc17zobs5o81Xj4NzPaejHYKTY8O4Od0cwVk5fTzyYbBnPlzS+ZSHS1z2IRZJyF45
+7akPIiV2ZMzNibk5MXNIyozraBl3R8y8IJyuHTnzgJwcB+Zb8mGIiKipoT7lnI9C5NCgR9du
+zmjfstycEP+lygnKkxZhKyfG8VoUt58Yxvut1gQqcSygIscAKnPaoc6cVqiUaYX6c9qgA04T
+9MlOC3TIaYA+26mHPtyphY4ybk4lNJhznKmD1q/yN0rhxEYaamWSir2TYUwgJ6eIsXUOMC1O
+nnFxQvj6snSSyNerRmeT+YoycAqUJijvJJh2p0hZQDZOhqkfUNrJMdXOQcbWyTOmzgazeLce
+d2qGo3Xu93sNdHSx3X2c+30BtThh36mAEk7YZSycUOLcK50Fk3fuK6cYipyw5dzva6jFSUH3
+qDbn+X8dISFWDkMh7XxT739NKHbOtvKGapwDysEB7Tl5psE5xBxbcGc4ibWzCVk6Vito5iSZ
+LarC2cvLSUoSJyGJnJh6/a298+dfK0bkPPNy3pK9E3BwVhBOf07wcsJoTvBygpcTjjtVzBMa
+xwlzRukEj80gCqdrp4TBOYvB6dspYnDqGJyTnEIGp47xchqZT11sjU4xcw2nnMGpY1qcI8wF
+nENM/84xBqeOwfF1jjI4QzqHGZyrOpnZnEVOhrJzfoUcZOos/tnI7IwnAxk6z0VmNLV3ltmY
+qNz87WM48/qmk8vJqWBw/JwaBsfNqWJw6phunUrm051aplOnmunTqWe6dBqYHp0WpkOnienP
+aWOKoVam0Glm+nLama4cA6bEsWA6ckyYfceG2XWMmF4cK2bHMWO2HTtm0zFkthxLZsMxZfKO
+LZN1jJmMY608nUmsJMejYBKOhHktt9fpYw3z68zOU4uYIZ35DwlejnA7mBycxXCEC27t6HYH
+Ts50giNbQTi1zuQ1nhO2a+nHto8Trx0XR/gBNEWQiHFzgg+zhITMDJIqP1LwUIiIiIiIiIiI
+iIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiI6PrJp2dbMUovxQigNOM2w6HXhI1u81y6OV7zg17Q
+2WTcpol1c0abxnc4x2s65ws7s6nTdM5yijZ7KOxCKieGRI56uf1OfWvzDL1NJxsODk49hNO1
+Y8P0c2Rl5fTxxIcLftVy+yrMsyWMIWsm7Zgrfg99WEEaJXZUSuTomJsTM4ekjL+jZdycmxMz
+nHNzYnAaHAfmG3JhiIiIqDWvowPPg1E3Z5yjeBycvGMur7/Va85bxC8a5imcsGYGvFrI72oU
+tx8dTaASxwIqcgygMqcd+lCnGSp1GqFixs1pgw44TVCPTgv00U4D1KdTDw3mHGSqISfnMFMJ
+neb8XWXh7BkSJ82snBqogDEZkJNTxbQ5WcbWyTMOztdvhs6GspbqnW0ltgyZlbIYk5WTUCyc
+IsbNaVhBaSfD1A/oGGPsZJnFm6jZKWO0zr3JKV1s939VQceGc78voCYn7Do1UMIJe4yJE/LO
+/R5D9c7Pn3aUmgFFTsg49ygbZwXFTK0TMZG0UiqgnPMsZRg7OWIBVTmFRM2AznCKl5mdUw4d
+d8o2tMoBvZ2wytB5/i+nmB2qysnn5WQxhZOSNM5Kev29tRNRSif8+fMnUiTOn3mHoAbnBWmW
+2/BOCfPpTkg4ivWTcrzGI3GClxNGc4KXE7yccPztU+eE0Zzg5QQvZ1ZHDE4dg3OWU8bgnOQU
+Mjh1zmDDwaljLuIUMzh1zCWczx3OFZwjzAWcQ0z/zjGme+cgg1PH4Lg6hxkcHJx6Ju98z3/s
+4OQnwhY5RlM655nFP4XOEzJhtpwpNyA7Zr5+tM7WhmDqPK3131YwVbuDwZwaBsfNqWJwvJw6
+5uOdSqZXp5bp1KlmPtupZ7p0GpgenRamQ6eJ6c9pY4qdRqY3p5UphNqZrhwDpifHgilwTJh+
+HBtm1zFi9hwrZscxY/pw7Jgtx1DpwTFlso6t8nRUj59cOcsTlObKezxzSMDcXsN5QQol4WiY
+hTN5OZOMcXWmgR3lduDkTKc4GijgXMmRbXB+znTCctN90K03Ay9HwtwWS03pzAcj3I8uhvP9
+PzTM7TYt032e+jDLAQmZxRoSMjNJq/xSugMqIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIi
+IiIiIqLPTjiT2RJRzgG3YqRWSOaj2ENZZ7TpJ71m7TSFPsvxmo3WzfGaxRen0vGazfnCzmwm
+OHtoiaQgWyf/eDuVs5JEjmYFzTYDw2fobTnZcHDMnH4eJ4DzEU43RzxXczr5amLneH1F7eE7
+tynj/cwHtZKBBEzCUShrSKREjkxZOkLG7RSpv6NlXpCacXbkzAMayHGbo5qpsImIiIgokdNR
+ot/BNU4lhIPjuV07QImzFJITJKsXFZ2/il9Tdd5v+ZphmT3z+5phlb2Tyctx+zXQBCpgTKAi
+xwDqy2mHCp1mqDenFSp2GiEnp5xpg3p0WqCPdhogJ+cYUw8N5hxlaqH16/xdZuPsICnJwEkp
+AifNmDsZ5iynCipgLJwSxtYpZ+ydr0eGzoayghqcbSayLJ1YWYzJjFkrJk4J07TgKp3DUNpJ
+M+ZOhmlwahkLJ8cs36tC5/6vSuiIc78voDYn/A2bzBtqG86/P20qdQNaDyft3OcZOL9/3GZq
+BhQ5Ie3c72mozfl+pS2l3Xkxex2G1k4J07tzdLEdh85wHv+naifUOKVQwpEM6L29hXAIqnPi
+vJx9ycrZ02ydvPb6j4ZOijrmlDIr6f331s6Cmv2lwPnz0/3Pn/DHwflN6SQhHByVE0Zzwsop
+YirOXI/mBC8neDnBywmezvPflU7wcoKX887JKWNwTnIKGS+nlcGRMjjnOKUMTh2DU8dcwjnA
+eDktzAcvthbnCHMB5xBT7xxjunc+ezg4dQxOHYMzonOcwcH5JCc3y7LIyUhmzkPIQBXMtmM4
+dfS2k4bsnPBYN+kFZ8dsTSBuOZw5pVxsmzk5NQxOHYMzmlPHfLxTyXy6U8t06lQzn+3UM4ec
+BuaTnRamQ6eJ6c9pY7pzGplSp5UpdJoZN6cIMmB6ciyYjhwTZt+xYXYdI6YXx4rZccyYbceO
+2XQMmS3HktlwTJmHM/38PyHz66xPHBorOcecmTuTkFk4D0mgpBwJs3R0zDnOJGNuCwan2lFu
+B0M7wv3BQM4pu+vgNR6xE7yWW1APx/fjdHHAI3Tma0fnLBSdM1s3ws+f+Tbw8z/FzuufIuc2
+LZIxswX3nYxZDEg3mu+CD3P73bh1R1RERERERERERERERERERERERERERERERERERERERERE
+RB+bdkaUFaOVQpQTI7KSjD2VZdwmn3Sbs9NtDlK3OVXdnNHmvHWbK3g4x2suZ5xKRzCn93L2
+NI2znBBQuOCykMyJJZEj3xAmu2fObTq5cOqg0ZxrraB+HBPGzennkMfJMWK6+c7g5Jgx4z1Y
+wuscQhayZjKOOZOGBEwCkigrR6TEkI5xOqc4h7SMm3NzYtycmxPj5tycGCIiIiIiIiKijvM6
+DSM6iZ1gzKX4FVUnTKOXVJ3/jV5Rdj57+YohztzJ5cQM+LO9CVTiGEBFjAHUmdMM9ea0QsVO
+I9Sf0wQdYIZzWiAn5xDTADk5Bxk3pxZav9DfKIkTI2vIgkkpAifNnOTUQQWMtZNjjJ0s4+SE
+OHvm6ydTJ6uspRZnS1lJls5XnImzh7Q6meHsOMehzFJLOU0DKh+OvRN2mcNOcvWkmaYt+8Bw
+7v/SO/ffaqGVE/7tNfPMTGp1Qsq5r51jUOyEpHO/J6AG5+ff/73UFlM3oOVwfpUYut/TUIsT
+v2aqCme12EqcCih2ipirOKWLrWKLq3OOD2juBB8nhHLI2ymGwirNgM5zNLuelFMCHV1BSacA
+s3M2xfd/NHQSlMqJrNnf2jtvav5XEufPMy/nDYmdF6RgcHBi6BDTrbPaI6ic4OUELyeM5gQv
+Jxx+m1Y6wct5h6NkcOoYnKGdYgbnDKecGc0ZbDiXcA4wOHXMBZxDjJcz2HDqnWNMtXOQ6d05
+ynTuHGa8nDrm4xdb385xBgcHx9mpYD7FSU9+bO7k51k2dX6FLGTs/PzTxUlDNUzeeQ7IZirs
+JLM1r7etYz6zd9YJ2e3N3Mnk5FQxOKM5dQyOk1PJ4Pg4tcxBp5r5bKee6dJpYD7ZaWE6dJqY
+/pw2pjunkSl1WplCp5npy2ln3JwSyILpyDFh9h0bphvHiNlzrJgdx4zZduyYTceQ2XIsmV9n
+Sp2hNGUejuqBgElnEjIZx1pZOpOOSToCZulMMibhSJj1ctMwK0fE4OAkHeV2vdjryB3hzm3h
+KPduic8fpRPkTpg5yvWzGo52POHnwcEuzg+lXm7hfaCodH4ft+yyWQfp6pm9TeW7Hfkh4q8z
+Y77/qXKeu7bHP0XM7X2I+MupnNvSkTGLAemODhaSlnlJaoWIiIiIiIiIiIiIiIiIiIiIiIiI
+iIiIiIiIiIiIiIiIqJPEE4hEilYKUT6KSko5qhkHHay8Y0ttOl4zkLrNqOo2Q6ybM9oMvm4z
+H7s5o81M7eZ4zRx+4QW3mBtS5cxmzJKuoCkLWTi3hCOZbXl/OPbjST/a7sIbthDycnpacDh1
+EE6VY8O4Ob0czFsxnXyrs2OcH/igZ7KQseLnuJ3nWUMSxev0WAzJlCWkZGaQlnlBaubmxDwg
+B+fmxBAREREREREREfWd43k/t/Oljtevmr9yxjH/tSnDCC6+TCqW0OL1VszlrlXcZQa8IMUC
+KnIMoL6cZqiQcXNaoe6cRsjJKWfcnCbIyTnCuDn10DHGzamGVi/0N07irJQYMnFSio2zPxqB
+k2ZMVlABY+3kmIs6RUits818fSd3vp4ZQHnma5ads8lElJ0TI2bOzmCiRWc1HJkTvWESjL2T
+ZFq37EIn3P/V7iwX25q5P6p2VsMJyeHcW6HY+f7D/Z5TZlCz8/1ieaZ2QEsn/DJL6H5PQm3O
+fbe6AS2cEqZyQEunhGlx/tY4h6Dji61uQC3OEWjmBL0TXnsCkRNqnIoVFKJUAxrdUb2DGp1i
+aOWIdj1rp4QKNs6uKnHW1uw/GDtLS+s8rcVfaJw/j7yct4SDo3NC7IgYNyd+p8qc4OUELyeM
+5gT92+cF+TjvcLp2ShmcU5xiBmdkp5zBqWNw6hicOqZ/Z7Dh9LnYuncOMr07nTKdO4eZvp3j
+DM54wxnNqWBwcHBwtp3s9MfVzLaTlsycB5CDrJ3feZ09nDRk5ryWmN1U2ElmMbG31NnatG2d
+bFUMTh2DM5hTyeD4OLXMhzvVTJ9OPfPRTgPTo9PCfLDTxPTntDHdOY1MqdPKdOY0M2VOO/OR
+jgFT4lgwJZCTY8PsOkbMnmPFvB27U3pZZ8o5dszL0T2lbeZMScdQeawf3SP09h1bZuFMOibn
+WDMZx5xJO/ZM0hEwS2eSMQlHwqyXm4ZZOSJmtT8YwglOy23205Xe0b1H3R3tLvTliHfVL+cx
+JhdHvcHNHKflJl0/IU7DjOy4bG6v94/WkR5SvR3todvTUR8i/jqzA7fvf8id33+KmNviUeX/
+OJVzWzI6Z36tjnA4c0g4mrmkZoiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIrp7wjpKYGcm5OTFE
+REREREREpEs61UakaOf1iBmhtJqyxmuqH+GEdg5Q0hHNn+gAZR1jasuxnufUA9pxvOahdZtX
+128+YhtoNGe4ARU4XjNt4+xC8cy3kgFNGUXmSKaO/hEWima5LaaeFI5nORdgev1casv2cnra
+lV7K6ehgBKcOcnKMmF4cK6aTr1t2zCZkyWw4pkweMma8zlekIXslCUmYFSRSYkfGLCChMoe0
+zEuSM47XqhERERERERERERFdIK97ez1OzDqd0fY+Qe/2g4MxtHg53e9B89db/+5kfjlpWrGD
+0i9uD/XjXOuSoRLHACpi3Jx2yMkpZJqh7pw2qJzBqWOaICcn/Xp/9c7fKJETM1bQnhJBNk6S
+sXfSzClOLVTAWDtFTLtTpGicr++MnYyyloyZr1l2ziYjc76iTnFqoBTz748ezi7T4OwM5/6v
+Nig5nNi5/2bphL/fr5hS2qCYCffYud8TUONwwvMF04yVE8J9p1po4ewzb6jJ2WdqB3TYqRzQ
+wilhKgc0d4qG4+bULbiZU7K1VQ/o+X/zs1dzcEJ/ThUUKqCOnXAJpxwKNZCBc2hP2uIc+Qhq
+c/ZVhZPQZn9v7cyt+d8pnH/9+c3LeUNi5wXhdOm8/sLJKWYOOjEkc4KXE7yc4OWEGqeCcXOC
+/G26CgfnCINzhlPO4AzsHGBw6hicOqZ/5xiDU8f07hxlRnP6Hs5hpm/nOFPlVDCjOYMNp2en
+hhnNqWBYPTg4OPZOZjZnayc/b7Sp8yByUhWTc57/onY2IFtnsnUSzHLGbaWzNYO43WKbU4m/
+t3Yy1TE4gzmVDA5OjVPLdOpUM5/t1DNdOg1Mj04LgyN3mpj+nDbmFCf/zbeZKXVamc6cZma5
+HeScdqZse7N1lIutyDFgenIsmALHhJlBmdNgRsyeY8W4OsbnprYc3ePt5k7mMW2GzMNJnQSz
+VB7bQcqxZbKOMZNzrJmMY86kHXsm6QiYlKNgEo6EeexHZ46GWThCZu4Il9rKUTHOTlAvttnn
+to+j3BfMHeGube4od6FnOF7Lzc2Rfijchltugw1n8X1uIEd6SPV2tIduL0d8iPhw1Ee8D2d5
+9YTMeR4hPjCVc1teoyFjbmEB6ZwFJGRmkHI0T0u5aoiIiIiIiIiIiIiIiIiIiIiIiIiIiIio
+t7T3RkSMHHK4vQin2dHeVjKDHLZsp/cPERERERHRh+X0Xcvr2+Psa7d0/oNlXo7XhDUqKeHo
+5rNzgJKOar5BByjjSKaddJA2HPPpRz2kHcd+ulsxtOsYQfuO+bzHDOiijvVE26c7V5rYPYKS
+My0bOVNkaOanXg5FN0H1w9h+GpwZtFhuYsdrBb241d8Mt4u7lNPRQQJOHeTkGDFuTidfG8yY
+bciQcXPykKni9r375BMW9syJZ64kygpSKREkZOaSlvG8csiJISIiIiIiIiIiIiJqzOfMudMv
+Ad4/bPj9UqN8eOAZP3AZQ6+XWymmUOrVFdCOc7ULfneZa12bVMBc6erLIsYAcnIKGTenESpm
+3Jw2yMk5wFg7f79TO3+jvBwraEexcnYZhZNiBE6SsXfSzHIDN3AyjI1zcDgGTsr4+voKcufr
+Nxsoy3y9snByTPj6ykCmzoKxGFCC+fenrw3GyglK5++Gc7+3Q+vh3L9bKD/ZOO/B3J8tmYXU
+7ryZRC3Q0tlkZlCbE3aYFmjh7DE2zv5w6qH5Zl3A+DsHoaNO7YBmTsnqaXa+K2HcnEpoZOfg
+CjoEHXfqBjS0o1tB4Rzn2J6nwVHtslfOPjz7b5ZOjM3/2tx5W4u/kjj/+vMbDs5QTlg65cxR
+J3g5P5KLE3DqnHc4aqeJGc0pZ3AGdg4wOP7OEQbH3TnE9O8cY3DqmN6do0znzmGmb+c407VT
+wdQ4TkzPw8FpvZSit+Gw2HDGGw4OzlWd5By+5k5+umBTZ2ueZXPn8S9q5/VvVszGeCZLJ7Vg
+ps01ZOdsbwmGjmAm7Izzi6X+UuAkc3IqGRycnp1a5sOdauaznXqmS6eB+WSnhflgp4lZOvnv
+VqbOxne4ViZyNqDBnEam1GllOnOamTKnnbktGS9HttiKHAOmJ8eCKXBMmKWjG86+Y8PsOkbM
+LzRlHTPm6egeazZ3hE9pK3AsmVvIQqZM3rFlso4xk3OsmYxjziwcIZN0BMxjB7dwFMzcUTIL
+Z9IxM0c5mvcH0MNRMfEXR5w6aBRH+yZ9O6MtNzn02h84vX+8nFH2B0MPZxhHfBAyOzzwcOQH
+VbOvWXrnzUxK53HI+8BUzm35tHIZs3AmoTOHlMwM0jI/lHLNEBERERERERERERERERERERER
+EREREQ2Q+GaPJSOXPO5fuZ1zQ5vyGvw5I3TC0vGAtLd8vBHtPRIzR7tl/64Y9Y0y8ykjHHYI
+8tHc3lucmLlxowwRERERdZDPoa/XUbbPSYTl92EnRikFJyh2tPOL6aG1I5xmTg8lHdU0gA5Q
+xtFM03iiI5lG0wHacMynU/WAth3b6W49pG4c+3mPpVBHjvU826c7xvOgnz8gK+c10e1sxiyB
+8/u6i3m5FCtoWidacF5OvHYkM26HBKQYT7xli7aDrnalJk5Hn3XXcnYhI2Y4p5OjUjOmj68N
+hkwP37dMmdO/EFszp56BESgpSMOcM5O8TllAUuYtqZlfykMhIiIiIiIiIiIiIqKh8/llw+mn
+Gqefnpx+4nL6ye6k3zklUkpx+1H9ipdKbzNu19hc67riAuZKl+EWMe1OGdMODeaUMq3Qmc5f
+B+fvIjNom1lC13NiZQmZOQlG4aQYowW3y9g7+4yJk2aMnL1tINoxKIbz9VOwgTLOvz9/faWg
+ZifHGA1o5Tz/bOtkmcxiM3Tuvz2Y+90EipiXsszM2WaWULuTZZZSPRMeW0CemUNtzg7TBpUP
+x9DZZpqgubPHzKAGZ384LQN6bQe7a8fGKWIaFlzvzkEoHHRqB9S/cwzq1qlccGc4yg3hFEf3
+Tg3nOL/UJhqMnBTs4iysxd/aO+lkzp/fcD7cCQvnAHN4u64cTs37x8t5hYODg+PsHGG8nAZm
+NOcIg+PuHGJw6hicOqZ35yiDU8f07RxnunYqmBqnhunYqWL6dRgOznDDwalzKhk2N5zPcdZT
+3gqc3CzLts7WfM6GzovIQabO81/Pc4yY+VZgOeV2YsFszoRt+vYRzLiddDbeQsZONpwqp5bB
+wenYqWY+26lnPtppYHp0WphznI1vCbbOJuTkNDGnOBtfrlqZ7pxGJl4/Lo79l9+soxpOodPM
+nOTImK4cA+YcR8cUOCZMP44Nc9tYL5bMrzP9bGqGJ8HSzu9ZlpRjxswc1WPNZpDwKW1JZ9Ix
++QVny2QdYybnWDMZx5x57HjkTNIRMHNHySQcCfP8YJCum5kTtKNZfRFWMSc5MiaCcHA8HSF0
+iqNjvJyhV8/1nTCmoz46eB1WuTjqYzdnR37M++vML55QMd/Q/CoNoTP5OHNIybwhrfKwPBAi
+IiIiIiIiIiIiIiIiIiIiIiIiIiL6qMQ3lSwYPeVyo8yCkV6BP3d0UFg6k5ejvS/Y1xHeVhAz
+sg3hd3N+38cidabZFKBCZz6Tg4hZzUwhdeRLbQ4FLeO1u3b7+HlCaoWIiIgumNMhgtPBiOux
+ld+xohgKTtDy+7CX4zVNlnzaLzW0dpTTsumhlKObNk8PnetoZmk80ZHMbukA5R372Uc9oC3H
+Etp0rKe7dYD2HMvpiD2gfcd+WuqTnWtBOPXOz4nyaZE5FKLns60RswHNXz8t2Tj7AzJy1pLA
+WfxaKxxPvGV7OanHFpg4HX0GXcvp5mDEyunlKM7M6ePw19Dp4fuJqXP6F0hj5uQTCfbMiWeu
+JMoKUikRJGRuPspMUjO/kF4hIiIiIiIiIiIiIiKiM/P56cnppzSn3+x8foL0+eH2rN+hJVBK
+sYcyyjUvZt9iLnex1R7D5cu1jAXk5JQx7VBvTiO0fr2//3Jw/s7TOX//5iBT56/I2VZEzpox
+W0E7jJWzxwicJCN2QjoLp4Cpd9LDyTEWzo7QCEXO8w/3+13kvJX7IhtoMZyEspZanfA3rcRQ
+s5NlLKAiZgm1O1mmHSp17obOFtMIFQ9nASmH4+e0QCc4u4yb0wB9tnN3dw5ChzZrnGqndkMI
+RyF35xgUwjEp2DhxG8whZ4eJrcXfWzsPbfU3GmcdDs5BBgcHBwfnNOcQg+PtHGNw6pzBhtO9
+c5DBqWM6dw4zfTvHGZw6psapYTp2qph+nTqmW6eS6dUZbDi9LzZWz1BOLYPjwuCc7mQmPzZ2
+tuZZNnS2J3S2d9ITBls7z3+1YzLjyUJGzHxEplNuJ9aAZGrvhLOc4VvpfFOJaaMbmNE+fTp1
+qhkcnH6deuajnQYGx8TJHu22Mktn47B6PKeJWTl56JqOiOnOaWTOclTMOU62ZqYvp53pyjFg
+enIsmALHhOnHsWF+nGnjQMeI+XU2TiA6OVbMzDE927bpSB6ftg+ZMnnHlvl9AyUcYybnWDML
+R8g8djxyJukImOeOVD2c1A5bwSQcCbN2NEzsiJTYkTFuzs2JGc654XTtnPH+4X36sc5gwznF
+GeDj9Pf1nweJYud9MDqG84ZkTvSFW+nMrwbRObf5VSdC5jYbj5J5SdqDECIiIiIiIiIiIiIi
+IiIiIiIiIiIiItpPfTvBjHFwXO6QOOVeDOXl18t7MWRQ8HFixu1+XZzjzs/9JXpnEjvviVPV
+znPGWfFyc7hXZumI9wdeTpAz8QwLMmY2xYJsZzB35DdmzW+ekzK316JTMw/MhyEaMq83qqPj
+Ajk5XntSV8fty7CX4/WR6ub4nUPwctxmXbn+uQqvkxVnTcclg9aO2+kK3Wx2euhcRzSroQP0
+KY5kFs0zHcHsox7QhmMKbTmW0KZjPN2th9SLYzmNswe073hN5z3cNOimC0734JK5M61SOFuE
+6Xg2B2O4gryc148MGcnMeZYZkLnztBTO+q3q5ayycbr5DDJidiGcKsiOcXPcDrPP/35iy5z+
+Bd/c8TrRc94ZMo2ygmTMGRO8Sxm/nxrcfnIiIiIiIiIiIiIiIiIiokw+v9n5/tLp+ExZt3t2
+fBQRtFY0UNK56m0NWeaK1+ZvMpe7kn2X4frySsYCcnLKGDenGXJyShk3pxFycsqZ4ZwmyMk5
+wrg5DZCTk365+09i577ICNpRVpCRs1KMBrTP2AyogDGBSpgIEjp3UyfPtEOlzt3LaYSKmTan
+fDhuzt3I2WOaBnTEaRlQ585hqEunYcE5OWFgR7lhh0NQ/fYW4u5bpqGzcpOKvfPCor+SOImc
+GBwcHBwcHJx25xiDM6hzkMGpY3DqmL6d44yXU8Ww2KqcCqZnp4bp2Klijjt1zMc7lUyvTi3T
+qVPNnHtFwNlONYPTNYODc5y5pJOeldjW2Zr/2M7Zm2lZ46QgE2dBCJ3lBMspyIZZzrCsdKJV
+JHSitSR0svNTX2AviuPh1DM4ON06DQyO3mlhIid/HHpVZwOyc7YO4N2cJmZ4R8SUb9e2joop
+3u84Oa1MZ04z05fTznTlGDA9ORZMgWPCuDryh5s9HcmJvYxjfV4v69ie1ttwRE9qWzua53Pt
+QqZM3rFlso4x87tD0DOPHY96qeUcc+a5I1UzyR22gEk5CibhSJi1o2FWjoiJHRUTQTrm5sTM
+ISkznHMbzBlt/fg7vE+rGBZbh47/6nFzpNAP8DjoVTuvg+tBnJekdp7f57TO++up0LnNrjtR
+MrebE/O96H42AzVDRERERERERERERERERERERERERERknf52ghfjAfncIXHCPRLSa7zD3NFB
+8zsklFCIIJcbXGXXrYe143Gbs5Mju30hxQzjTGrncT/O8y5+oTPN5woQOLP5CIKDs5jTQ8Hc
+loxq9dyWNzIp75paLTcNE60hvaN898wh4c4gAXkc8OidmxNze9yn53Ds6+X8QF6Ow/p5bAou
+K+h7ybkwyr3OSc4gk2D4O2NMFzCwo58uwAEKTlBwgk5yvKavcpv1y20WM7dZ2dxmmRPOmneS
+o5pt8DRHMxvkBziK2To/whHMpuoBbTim0JZjCW06xtP3ekA7jun0yh7QruM2nbfX9OS2juox
+H5ETz0YsghbTK69MM2dapBvPtA1ZO7l5ys2c9y9AScjEeUHrDULgvB+QInZmiZxudtlGTDef
+qWZOHwc9hk4XR4uWjtvh/Nnf66wZvxMw5525kihrSMU4z3yrZ/x+ork5MQ9IzxARERERERER
+ERERERERXTPHn27HuBnN6YIEnwsszrpcRAOlmMveDZJlLnmvwSbjd2W+E+N3Yb4TYwKVMG5O
+O1TGDOc0Q05OKePmNEJOTjkznNMCHWHMnft3auc+ywzaVNaSlRMrZtAuo3BSjBFU4NwNnBLG
+YkAljMWA+nLaoROcDWYJKZ1WyMkpXD0RJBzOKc5xqEOnacEN7Cg3uBDKoZbtIJRDwdCJyzHW
+zguL/07hpMLBqXBqGRwcHJxRnYMMzpjOUQbH1TnM4NQxXTsVTM9ODdOxU8V4OYMN57hTx3Tr
+VDK9OrVMp04189lOPePlDDYcHAengfmI61xwTBljRzEHckxkpyU2dHYmQLZyovmPE1A9s+WY
+TumccdJTYpsw841gSswXbOcIp6iOX8nLWVC65baQDJnR9tYf7TQwODif7rQwq885Hyd73Iaz
+52ShJmZ8J8fY3ovj5oiY8v2Ok9PI9Oa0Mp05zUxfTjvTlWPA9ORYMB05JsyPs3EezIp5OznI
+yTFiZk5SsmJ2HDNm27FjFo7oAV0JSKY83qh6Zu4omceOZ7VynBxzJr0jtWeSjoBJOQom4UiY
+8xwNEzsiJYZ0zM2JuTkxM0jLvCG1c3NiRnN8V8842xtOE+PliJlRF9twjhby+tgOTtAP8PhS
+IncekIfz/UVL6dzC+2uw1Lm9vtZrmdvNZTTf+RxVERERERERERERERERERERERERERHRxzTo
+jTJud5qJryIOM0gohYWjgyJHBc3vKBAOKPg4Iawgj9upp7Gcx/3oakbmJLa2cZz3LAtSZzaZ
+g9BZzE0hdILWWQ1IxNyipeblBJVzc1pu8QpSMYklJ3Ju0YJTMcsRyedYcLl5bjYeueN006GL
+c/N0tEfXkSO+izI4DWhcR7uCnB3tF9Tb+7MhiAd0huMyy4+XI4aWjtOpCvWx1czRnxORHiwG
+pwElHPnZl6ejnmXu5ei/drs4s8mvtU7wcoK3o5l1EsfMkcw++gmOMZR37Geh9YC2HOvpez2g
+PhzbaZw9oD3HcpptD+j5aur5yV/MlJPsnen9B3Nozvy+vOGz4GJoWqR30jO82znvlxc7YelI
+ZtyOtus1ZOnM3qeq8fSyyzZz+viss2P6OOixdNyOSk//emLtZCBzJg0JGLfp6leQiIkhGeM2
+X73b1X3eE8mrlRsTkRIREREREREREREREREREW3ncqWAzwUWp1yX4nadjcONaDoopQigDHPR
+m0HyzIB3Gjgx1tf/qyEnp4Bxcyygrpx2qIwZzmmFShk3pw0qZ4ZzWqDUy91/0zr3WTrnHmUG
+bTMxJGOsBrTHWA3oqFML7TJGA3Jy9hebDVTCXNTJMhbQZzr3qzhFm5ujcx/ZqYBCIRQsnQ3I
+1smq0X8xZd7Y6i8FTjIcHJzxnEoGBwen3jnK4AzpHGZwPJ3jTNdOBdOzU8N07FQx/Tp1TLdO
+JdOrU8scdJyY0Zxq5rOdesbrB9pPdgYbDk6d08KM5hxgcPp2LJn0JL7GztZ8wXbOcl7iBGTj
+THFO47GdatnJyW0FSmdvS2hgMm8fvTOnDBdbj3s3nL6dFgYHJ+Xkn/dg7eShCzr5Qzc/p4k5
+0clBV3S2tjdTZ/1YEZEjYj7WaWR6c1qZzpxmpi+nnenKMWB6ciwYT2frQ9SKeTni5469Hc1h
+wdzZhIyYuWN9Zu+AY8ZsO3bMpmPIbGwIpspjh5BwjJmZIx3OYwcnH05mR2rOpB175lRHwKQc
+BZNwJMza0TArR8REkExZOkJmDkmZm4/yguTMr+TBUG1O68dxe/NwvN4/OPWOEzOQ4/Wx4PQx
+5/Vx6nR04O84He74ON/fG7XO7fvHmMnBuT2+1asZv49tIiIiIiIiIiIiIiIiIiIiIiIiIiI6
+O8f7StxumHK8lNzrhjatFIKPNDMmIRQNR3YFdoR83/CsZh6Uy33B13aSjMdt6Bonwbg401jO
+a1oCqTObzcHaSUw/q3YmJ2eM8bxuY9IOZ+UElXOLlpvcmUMK57ZQfhwJc1sNR8NEkNC5LRac
+/Ih0IGcxy88wTnB1pnEc/YI7w1EuuOUuTu44D0jvyLeExae3l6ODwkmO+pzI9PoO5OLIBrR2
+5LOLSQ9KQwQFEZR0xKdf9N+2Ykd7mmdgx+G8iI8TnMYzmBO8HclsquvFNogz/5PQWaws+1l1
+M3k5ptCWYz3tsQe07dhOS+0BPV7uZ5NWTrT9dKbfE7JqRz7V9tJ5/bvIyY7GGJqWyR3hvN5z
+JyyP4WQrKLmijJxoHnQPJ7FVGzpvKLVVW++yHZxbcjPTONkHMxkyfgcjeciWyTrGjN/k+2fO
+ii9QUpCG8buoy21+dy/HbcLTMSeS91CIiIiIiIiIiIiIiIiIiIiI7HO5ksPnAhin64acroNy
+uq5rzfhdDqefbEgDZZlL3gqyxVz3xonTHSNol3FzTKACxs2xgJycIsYAcnIKmWaoO6cNKmcu
+69y/s4aSSEayY+7zdM79roK2mDWkcsygHcbNiSELJ8VYDWjXsRnQPuPm3Md26qACxs2xWHCD
+OYsXGM0RvoFCrjxj67y91V9JnEQdOzVMDYSDg4MzqFPH4DgxOJ7OcQanjsFp/9LYmVPF9OvU
+Md06lcxRp5b5cKeaOebUM106gw3nAovtk50WpkOniRnNKWdYPTiXccoZnA1nyky0bMuk5/A1
+djZmC7Z0olmJjed0zjsryMjZHZARsz2fs6GzM54WJrdZpyAbZ5pWkGQ875dVb2574eC0MjhG
+TubQwNrJTVN+YScHXdZRHCWe5WxsCNd0sm/UNqa/ewkGcxqZT3Vamc6cZqYvp53pyjFgPJ0p
+e0LHjnk6W5CZs3FQYMXsOzbM2xF9Xq8d7YN5dhwr5uf9k3fMmG3Hjtl0DJnf/Y796alNSMnM
+HOlwnjts05NtG46aOdexZ5KOgEk5CibhSJi1o2FWkIq5OTE3H2UBSZmbj/KU9AoREdEpeX3M
+OTlehweDOnLoB5mcBjR5bXEODBERERERERERERERERERERERERERnZ7fhdcDXUHsf0ObVlo4
+uguWF8j3fch653Fjtd55TOngwUyiS9dTjv4+Z5UT1o7kXeTkxMxrChGxMzk6igWXY4Zw5rNG
+CJ1J6CSm05U7yuW2noY4aJzbE9EO5+2Ih3MLScjeeS+4OSRzlgMSMCtI5kSQjFlOvqM63Hk5
+7wWnYtycm6vzhHTM0vEaj5cjXHC+jn7BBacBxbtSL2g0R30OwduRn6twd8SzZM0ORkZzpCdf
+JjHk78y/nkid+eSGOHWO7uvwFKQDGt7xWj+DOUHthKWjPt/n4cwZN8cY8namlWML5ccjmPb4
+5YSggpyd57PAZNB7KMnZ3e2d2eGbAgo7kMqJV5OxM83Go3mzxk608JSObgW9hLVk6ry/K8SQ
+FbOcb124flbzuss+HN5QWGfspHc69p91mb2b+Ye3C/MakJh5TjioHo7fnPhuk9W7zSK/gkSM
+3/Tu483v7na54s3LufkoRERERERERERERERERERERESaXK7oOeF6K/mt6mrptMv73C5XdJgL
+SgQ5OVnGVtpi3BzzG0HkUC+OEbTLGEFOTgFjAjk5RYwB1JnTCpUybk4j5OSUM9bO/V/2UAK5
+5yQBk4TMnPt9E7Jy7ncZtOWsIQ3j5thB28wauroTQ507u0wM4dQ5lVDYh+wd3QYX1u0wZs5e
+ODg41QwOzpBODdSzU8GM5tQwozkVDE7fn9odO1XMcaeO6dapZHp1aplOnWqmT6ee6dJpYHp0
+WhgvZ7DhdOg0MZ/rtDE4fTuDDQenb6eYwck7z9lb9UxupmU7J5os2Hia0LxjO6fzm9kbkJWz
+giydjcU2GTKLzc3FeT8xUu3M5nGWbgbTYumFOBtmPUu9yNkNB+cyTgxlPrKv7OQgSyY7v/tV
+nQ3I3vEYT3aLa2KSjmA4Y39Z6MFpY3DETiPTm9PKuDllUDvj6ex9UbBgfp2d7yRWzsZBjhXz
+cvKQCePvSA4PU47i8CPpCE66FTtWzI5jxvzsd7KOHTN3lMzvflRxQicPSZm3o2VyH0DWTMYx
+Z9KOPXOqI2BSjoJJOBJmDYmY2FExNyfm5qMsICnzgsTKA9IrREREROu8DkO8jndGc4iIiIiI
+iIiIiIiIiIiIiIiIiIiI6GPyu7DX6X4pB8jrRjOnO+dOubHx+0ZkJ0cFrRwRtB6P/obd543v
+YuZ1R/plnfjN87zD/qJOzLym+xrEeU+AIHfCQM7k4Sxn27B1bqc5wdcxZl7QFE1ELXSUi23l
+yJbbLenYM68BLbZrgZNccgrntW2/HQmz3uQ0TAy5OSrmJGfCOQZNTivIy3FfQU5vVDdnlAGN
+Nh79R9D6s9vLkR4inOFIT77MHeXsb6c4wrM83o4K+hBHd3oMp80RbQjDOw7rR3cWbvk+VZ7n
+eTtPTO9MZzii86SvZ005OSFoIGdntblZQ1uO9fTXYf1xqnJmzzXTQCtHNKCEI3kTrRbbckxm
+TvxF2NEJMif/oEM755ZYbj6O8p2afPcIdqVpxv4zyGE4P9CpjjXzgtTM7xrSbgQvyINJQBrG
+b3b3mxOzgJTMG9IqL0nP/EguDBERERERERERERERERERERERfWJ+11u5XT+mhZyu7zvpski3
+yzwdpgRTQRnGzRFPOSWCNhjJnS1qyMnZZuygPccI2mXcHBOogHFzLCAnp4gxgDpzWqFSxs1p
+g8qZazr3n8yhNJOB7Jz7fQsyc+73TcjKud+3of6dDcYU2nTW0MWdFWTirBkzZ2c4Gke43MI2
+ZLYdrF5oJy+nFnJyDjM4ODijOscZHByc/p0qpl9nsOH0vdi6dSqZXp1aplOnmunTqWcOOQ1M
+j04L06HTxHyu08Z4OSw2rdPI4GidVgZHyuDgWDilzBU/FdLTElsPJzOJr7UTTXprPOtpbjzW
+85HmEGMnOxjj5eY0nLfjtHp2B2TEPKbxlm8G7+nCFxNgC51MVs5eOJ/l5La6a44n+UkqctKQ
+rZMfkLGTha7qJGYqFzlJ5rpOpsGcNgZH7DQyvTmtTGdOM/PjbB/vmjm/DzbzcPIHH1aMm3PL
+PvPFlilwTJi3k4WsnB3Ihtl1jJi5IzhsK3asmB3HjPndwemZTceQ+f1g+GW0j016QcrR3PKf
+dMZMzrFmMo45c65jzyQdAZNyFEzCkTBrSMTEjoq5OTFLSMjMIKnydMQIERERERERERERERER
+EREREREREREREREREZFLTvdL+dz+5XyfmVzyuhFw6UyTl6OCYmYSLbu143DD7uOOdLUzyZz1
+cCbJ5h3CSlI4MfOc7svLEU5H8JzYUuFkhzOME1ycycOZfJzl7CG2znp6YL2znD1E7KjGE08Q
+rBrPbcnonNsZznt/YM7EUx7rnd/JdzQfcytIdXgwc2abgoRJbHJS573cRMxZjoo5yxls/Qy3
+4HQDWu15Lu6s9nBaZ/bJ4OJcfwV5fdStHbdDBOnJl0kMRYzaiQ5/R3N0Z5Nw2hwVhIMzsqN+
+o4663GJHdRpueEdz3nfycRKMMRQ7k9TRQ6vtwM3RQAlH8x5KOMIFNzmNR+/cRndUe57bwgky
+Jj/Dv7FzyzjWTO6ZH/bOLeUImOeA1MwvpN0IXpALM+Ks6zcf5QXJmR/JQyEiIiIiIiIiIiIi
+IiIiIiIiIqJPzfXCOzHkc8Giz3We8eWk4ruTxU6C0c8Mp4PSjHTmJCWUdyS3BKmhLcbNsYO2
+GTuoF8cI2mWMICengDGBBnOKGAPIySlkmqHBnGKmETrLuX9n7ySZDGTo3O8bkJ1zv6sgJyfL
+JCGcfUe5fp5Wymhyci/4IU41hINTweDg4OA0OocZL6eOwXFyKplenVqmU6eaOebUM106/TM9
+Oi1Mh04T05/Txnys08h8qtPKdOYMNpzRnGYGB6ecwcExcQoZUyc13alisSWnbzUfTno2WnNn
+mrYgI2f6eTac3lmNxtjJLjXj9ZMfju2stHnG1NkYjsRx2wxmE96m9jqjfWPEqXSsz4SsdzgS
+J7Fjk40nDV3YEewQ1q/n5eS2uMs66f31aGdGOQM7upPZP5syIzphWj2swJz5dbKfoabO7xcs
+LXML7yeXn++0M29nC7qkk4cMmLmTgywYN+e269gwc0fxfXHmbG4IVkwnjhnz2mEnHTtm5kiZ
+3wORtGPJPA541KO55Y+sjJmcY81kHHMm7dgzpzoCJuUomASkYVaOiIkdFRNBOubmxMwgqfKE
+1AgRERERERERERERERERERERERERERERERER0Ug53ZjleZuZA+R+f56Wim6gnJxuCJ1UUMxM
+omW3Go7HjcGPG+yv60RbwfNWfrkTNE6CCApo5UxyZzmXg85ZQkIn6JzVNj1pnNVym0RQ5Exu
+jn4FRbOUyJygdOIBOTiTzw5hUm4GbyieFEfq6BbbLVpyQufmxKSWnIKJ5qTWObeVo2FWjohZ
+OMLhrDYEnC6d4Qbk9Ead7UpFzmqXPZAjhbxW0MoRnxNx+kg9w5GefHE6tHo4uk0hOR7hMan4
+WD7j6M4mjeY8INl7NePoTsM5ORPOBRzdZwMOzsyZYkd0dgynypnWjua0bwISO+LT8mrIy3Fe
+cNMJjvIHQSdncnCW0Ht/IHVkP9PFjm44uWeL2DvJh7IImH+Qy3BeD+NQM7efEQX5cG4DTro+
+l6TMGxIzREREREREREREREREREREREREREQueV5/qYV8Llx1ug43xDkxHjPq6aCk4zDTnQjK
+OdKp1HSQk7PBmEKbjh20zdhBvThWkJOzyxhBTk4BYwI5OUWMAeTkFDLDOY1QMYOz7dzvCifB
+SKCkk4EuMJ7MK+J8lnOIaYBwcHCqnYMMDs6ITi3z4U4106fDcHp2GpgjTgvTodPEeJ0J6c5p
+ZLycwYbzqU4r86FOM/OZTjvT1c8k7QwODo6YwRndKWNMndT0rfaLbUrNFixZbKnpgq2dKTO9
+rrEzrTN1ChmzQ/hBnNdGIF4/2bUjGc+uYrbc5i+d2OvYfaNP7dMUzl44e056RVk7qW0aZ9/J
+QZd1MpC9E/wcl+WWDucsZ+cDzs4pgRqZh7MvmTiZXecJTivzcrRHOyc4m1Az05fTzsycDcjJ
+MWDmThZyciyYjhwTZt+xYXY3OCtmxzFjPJ38nseOeTvS0TwOrPTMxgGcKZOHjJmcY81kHHMm
+7dgzpzoCJuUomASkYdycm48SOTpmASmZN6RVfikHg4iIiIiIiIiIiIiIiIiIiIiIiIiIiIiI
+iIiIjuZ0l5nT7Wzet+epIacbKE+78dTrRloR5OQkmOFu3Ha7r17rzKdZkDKziSN0znJ6CrEz
+6R3pgEIMDeaoNuzscC7qRBt2cHEWK0voTEJnPgXtEM4t7ZgzmQHZO/PJiJXMGY7o03QBzRwN
+4+y8V5CIGdUJozgx5OVcfsGFNyR9o5624NTnEIZ11OdEZF+0Tne0J198Dq08HSl0riM8y+Po
+KBccDk7CkX0I4bQ5j3Oksg/VU5zg5egORpbLTXcssmTGdVRnL9UDih31BjfFkNwRfQ/KjUe0
+guTOLV5squ+PZzmixbaYeV/+lcHDmUHB3REwyYfZSJzb6tEIGuYf5OTc5L/NvCDttpaCpMxb
+UjNERERERERERERERERERERERERERERuOV6H6zjpoRNz+akVV4zfzIrjzRCom3BKC2UZN8cU
+2mBMoS4cO2ibsYN6cYygXcbNMYEKmCs5JYwF1JfTDBUyOHWMm9MIOTnlDM4JzgHGzWmBPnk8
+OHUMDs6ITj0zmnOIYfVUOQ3MaAdVox3Dd/fdp5HpzWE4OOOdqHJy2pnRnMGG05VjwHyiY8GM
+5hQwrB4cT2e0vTXOaU78ilOKMXXWk/hKFtt8ct1YsmRS0/jaO9O0NSIrZ1pn68TrZj3jtqWT
+GI6tk9rUdE6KGcsJUbZO+H23xojddhBSY1A4exmOx8XJfewYO/PRJEGr8bxfPL0ErZzZcJyc
+NKRx7KETHcmCO9NJ1u5s7whsmN+p8N2cfcrE2dtZGzp70GBOK+PvaD9OC51m5gRnA2pn5k4e
+GswxYHpyLJgCx4Qp2K6dHBvm5zhkyzFi5o7isHoBeTDvASmX2o5jyPwekMpHs3Xga8rkIWMm
+51gzGcecSTv2TNIRMG5OApIwa0fDuDk3HyVydMwCUjIvSYwQERERERERERERERERERERERER
+ERERERERERH53M3mc3Pe7EZAJ0YMnXKjptd9pzpp7XjdgOzmXPnO7fnLT0JozrwnWhAzOihi
+XpDOkY4nZlRbQogg1aYdIkj2FjrHCT5O8HHCAM7ZE65c1nGbQcZ/Chnh7mDuKHc7S0fKzGe/
+ljJrR8N4O68VJGJWbyAnR8W4jeesAXk5l9/ghhsQC87IufrsYiuHkzy1jttJHq/pBsdwhN+F
+b5ljeRwcjRNGdabxHOW34dGc2VfhAR3hzyZnOLKT/2c5QXc+KXJkZ2CW27Xw/JjT+rktxuPk
+KMdzezlBOp7bbDxSZ/bMAinj5iQeauTkaJgnJGf8rnz5J3kM5wfyYfwutiIiIiIiIiIiIiIi
+IiIiIiIiIiIiIiIaL9/ry8XXy/tcmL+8AcBvsoJLTyKQYPymtXKbp8ttwjblDIFCyMnZYEyh
+TccO2mbcHDOoF8cI2mVsnH3GBhrMKWHcnHaojMGpY9ycVsjJKWZwcK7jlDNuThPUodPC4PTt
+HGDY3Lp2mpjRDnZ6O0hsZT7zK0kz05fTznykY8Dg6Bg2g64dC+YDHROmo9PJTo4Jg6NybJjB
+fozBubwz2of2RZ1J6Sxeb0pjBsxiCvl4umCFM80TLrYpSuTEjPF0viWK0rFeP7nhGI8nu9gk
+ToIROyHJyMYT4myc+YBCQrFx4lGkIEvn9aLi5TZ7WfMd6XI8yU1At9xETpiNJ7MZWI7nuV6S
+IzNwHjuB2Tag2q6j1/ZzJO+f1TrROfGbVOhsvnuMnN13KU6l08rgNDtbUDMzdzagwZx2pivH
+gHk6m3tsQ0e92EocC6bAMWH2HRsmPk48zTFi9hwrZuZImRmkZV6OeDjPL0BqZuMkrCmTd2yZ
+LGTNZBxzJu3YM0lHwKQcBZOCnBwNs3JETAzJmCUkZGaQVHlZDgoRERERERERERERERERERER
+EREREREREREREdFAOd0F6HW7offtk473g/rd4KqD3sLkdGfwpBxRWDvqO8Qn4YDCwtFBkSPb
+FJKMdH6FydEJozrW0HJzCy7Ooos6WQinD+fkmV28pnYZzbFn3By3uWqcmNOmqrn6lDhOjN/U
+O2M7DKg7hwVn43jt4tyc0T6C/Gaz8zoUcTu0cnOufEyKg/Mxzgjfha2fY5V1hOf6TnAmHJzV
+VNsyZ5jldvN3fh7ONMh45Nvb7NFWgzgvyMlRM885/vXO82lQHk6YtD/avyH5aCJIycwkMfOg
+HBQiIiIiIiIiIiIiIiIiIiIiIiIiIiIiolFzuTLf544GnzsnwjInhskXqhm/edSuOgFdjrGG
+8o4ttOFYQluMm2MHbTNujhnk5OwxVpCTs89cyilg3BwDqIjBqWOGc5ohnK6dUgYHx9NpZD71
+7dPI9Oa0MqMdhHgdI3od8zoxPTkWzAc6JgxO1wzO1R0bZjRnsOF04xgxozmsHhxHZ4/BwTF0
+dhmBM3k4UzQbra0zH01G0jhrytaZJqWTYmLJ0pmmPKRjzBdcZjSTsZNjNM6aGc2x3g72t2nR
+dhDPuG3oxMNIQLbODNJvB79/1o4nvRFInPQnt2A8yWMEC2fFiLbr2SL7fWSBaLtebQBejmg7
+WDNe49FuBxuLDeeDnA2omfF0CqDBnHbmuX7yX00FjnCxFTkGzHP9JD+snR0LZr69neyYMDNH
+yuw6RszucrN3pMzv95KsY8ZsO3bMe8GJmQ7ujjFl8o4tk4WsmYxjzqQdeybpCJgUJGHWjoZx
+c2JIxdycmCUkZGaSVvmlHAwiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiKqyulmQ5/bGr1v
+01RLp9xI63Jj8ORzp/NzAoTRHAkUEo74Dn6lE5KOdIKF+XwbSkf6Zv0Qx2tCD5xKCKcT59wp
+ZC7suM1Vc6KjYIabeme4KXFwLKDRnOEG5OUwIBw1FJygsxy3afO8jkXcHK9juOGc0Y7lcXBw
+cFycCQdnIOfm7IRRnOGOsN2+Ag13WtHtZMXNiZlJYubX8kCIiIiIiIiIiIiIiIiIiIiIiIiI
+iIiIiIjIIJ8bTnzubTnh1qOLTyaxZtymN7vwPHcZx21iRWMoy7g5ttCGYwltMRd0NhlDyMnZ
+YdwcI2iXuZazz+DUMSYQDk4pg4Pj6bQzXb192pmuHAOmow9tE8brELGbQ95rMb04VgwOTgHD
+Zo1j6ewwbG5dO2aMl9PHYhvNMWNGc/pYPTgnOzsMzmc485ecPJxpmj8wUuZMWme20J5pnbcy
+CZz1aFYjMnXyjOnZvcnHmaYtSMa4OdYbQhGjc8y3g6QT4oycvcVm5KxeXrQdrEai2t7iZSZY
+cKnVs9oMbJy9jUDkJBSRo3gDpbeCFWTupLZqgfPczMXO82Ul+52dTQ0H55LOz/tyG7Jzknsb
+O+b1OefkbDJejgFzhqNk5sc7JzsmzMyRDmffsWF2HSNmz7FidhwzZvZ9wcnRMq/vp2Kmh7sv
+nBxb5uy7fcyZtGPPJB0Bk4IkzNrRMCtHxKwgmXNzYhaQknlTaoWIiIiIiIiIiIiIiIiIiIiI
+iIiIiIiIiIiIiIjILafbJ71uB3W679TrRtpTbgzWQTNi8rlz+zlxhJejvrP+NUGFltFuC6c6
+XjM54OCIoNGcD9kQruu4zSHzAY6CGW9OHCfmJEfGLCEhM5zjNmWRl+P1VXjkBTfGgE5w3HYJ
+bidfvBy3kzxejttnt9exiJvjdQw3nON1jI2Dg4ODg4PTrTPcAc9wR77nnB4b4TSc24UVNyeG
+iIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiOjsXG/auv70JatbK9UTrWqhlHPd+QHTjD3k5OQY
+a8jJyTO2kJOzxeDUMXbQDjOcYwU5ObsMDo6ds8+M5pgw/Tg2jNfeerDh7DhWSh+HOobMlmPJ
+dOA4MTg4rs4VdwcdDAfnfGeLGc0xZFg913UMGTYDHEdnk8H5FGebwenHeT3/UuHMlCkFWTuT
+jzO9kzjLxZYYkMhZSSpGAiUUpTNNG5Ad4+VMcWM59ttBwdZm58SjEWwIM+a9I9U60yR21lub
+/Yawv1GbObujubazQjROSB30mDhhxWi2t9VSc3DCiI7D9nau085Ejmw4Lyf3XcHYyX4nMXSC
+03jCazw65uVsMFd01MwJjpTpx7Fhdh0jphfHipkdX0uZbceOeTva4Ty+N8oZt4sO8pAtc7pj
+zLjdTOJ1b0wSUjAJR8KsHQ2zglTMzYlZQkJmLmmZX8vBICIiIiIiIiIiIiIiIiIiIiIiIiIi
+IiIiIiIiIhowl3tBb063nXrd3+p1w+4ZdyC73VHtdoe4m+N1Z73bTAFujtcMCziVjgLCwfF0
+PuKNOpijYMabE8eJcXPc5t5xYtym+HFiTvimJXZuXo7XV2E/aLQ15L0lDDOg0fYJTvtSr332
+CZ9BfietvByvYxG/s3A4dc7lD7JxcHBwcHC2oMEcGXPOhNFuh/JKx/0rnZh5SnqGiIiIiIiI
+iIiIiIiIiIiIiIiIiIiIiIiIiIiIBPndjDjAJCnxLdDXnh5wzfhNrymAnJw04+ZYQznmok6W
+MYYGczYYUwjHnsE52+liOHbMpmPIdLAT9WFMFbcjg7OPdJwccwanb+fczc3tbYrzWU6Owfko
+J8vg1DGXPBQdzTl/9eB04Aw2HK8v2lsMzsc4mwxOP870L50zVxyc6ZnICZGjGk+IIJETM6IF
+l2CkzjRlIRkTQdd3vJabzNli7Jxo5SjeqXMn+041cuLhDOdo1s/eaK7uxMrVnNXOQPU+XTmC
+Hc/KCTJnvXK8HP32lmQsndxBr8ZJM4ZO5quCGbPcrgdzMoyXY8HMHeVwChwTZuZIh7Pv2DDd
+OEbMnmPFzI6vpYy/o2Ue37PSjiEz3BVip/8KbMy4OedeHGTPJCEF43WTh9c9KytIxUSQjllA
+SuYNaRUiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiolc+t7d63UjrfF+w443OUuiUO8Td
+7nh3c1TQyvGakmA4x2vKCBwcV8drypVLT+3yATu4wRwN4zcnzimOTPE78L05Me7fTNTMA9Iz
+P5AHQ0SN+e0S3BwPyGmf7fwZ5PaZ6ub4ne4bzXE7fTmAE3DaHbezyzg4Azo6ZjhntM+f8c6+
+eDl+Ezk7Md+QA0JERERERERERERERERERERERERERERERERERERERIKcbn8+YwKBy0/vvGKG
+m8xVAjk5SUYA4VgyozkXZTKOOXPmzsBeOXMicQlz3oMSnBicSme4efhx6pzhDnmdGJyPc5IM
+Th2DU8fgdMHg2DI4XThZBqeOGc4xhQZztphLO9M0CZ054+FMWmfBrCWVoxpPiBzVgMIeZM28
+nUnqTEonORytk1tBl3R+XlzuPF5c+AaKtwClEzOKN+qpjtdyc3KCxtljrubEkJOzYjTOmpE4
+CUbhpBiBk2Qu6aSPrUXj0TELRzicM5wM4+WYMCc4UqYbx4iZHSee6lgxO44Zs+3YMe/vC1rm
+5WiXWg9nLE0ZN+fs332smXMvBhAw413Dt4J8HJUSQUJmLmmZh+WAEBERERERERERERERERER
+ERERERERERERERERERGNmdtdwS73H7vfUK2FzrgTXQk53cF/ljPY1Ad+zsWf+4RzNWe0B2Zp
+mOGc0XekKuYkR8b4zb3jo8wgMfOA5MqP5KIQERHR1fI6GHE66nE6hvM6Het2VOp8kI2Dg4Mz
+muP9ueDkyJkb0x4TERERERERERERERERERERERERERERERERERERERER0UfmNbdDmOfEMJdr
+Z8wpW4GO8ZoA14k5w3FicCodtwdmODF89Hysw4aA4+kEHAtmOEcDrRmJk2Cu7KQYnDpmNMee
+YfV07aQZe2gwJ8fg1DE4PTh55uLONCmhGePiTFonODvTbyrn/ZJTSEnmzGtEE84hxs1JQkJH
+Np7HiyeXmw20GIaT807jrBiRs4JEy22bubwTRM7OcC43nrCpiJw1I3ESjMJJMRd2koxg/yZ2
+HJgznDTj5dgwrk7QL7Zdx4jpxbFidhwzZtuxY97H11rG3REzHZxCMmVOP3Ftzbg5p/6+JGDc
+ftR2+5H+pIuQdIzbRZZvSawQERERERERERERERERERERERERERERERERERERERHNc7rP2euG
+aqcbxL3uRD/BGe85PMM9f8XLufzzSnBwcHBykJOjY844QpAyjlPvML0PERERERERERERERER
+ERERERERERERERERERERERERERERERERERERERHRh+U1Ma3LLLu/E/oO5DjNTozTwPg9aASn
+U+fm5bi9gdx2pF4fDJ6fdF7OUCtoqHeq7+ML/B7H4Pa8Jifm+k83Cj5OzODUMdd21sxwjgJK
+MTh1DE4d4+aYQ05OjsHpwskybo4ptMFonGlSOu8XXTOGzuJlp3hIGmeaZNCKiaArOylIwTg7
+iuX2BLKOEbR4/dR2YOlMUSInZlTOWeNRrZ/BneDjBBcnVkTOmpE4CebKTopR7HecnCTj5dgw
+ZzjKxbbrGDEnOFLG1wnafc6uY8e8He1wNh1D5uWIGa9TB+efCrFl3E4knnxm1JxxO9/v9nvM
+aD//xZJMcfvxfC5pmR9KTxAREREREREREREREREREREREREREREREREREREREQ2d0+3hXo/d
+8Lrh3evOenfHa0YCv+cgjPAghKGdAZ4ggYNzmiNkzthhSxnHKXF8FCIiIiIiIiIiIiIiIiIi
+IiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiKqzecBI/6PmnF7RI8QcnJC8IHO
+ckTQirm2s2Yu7SQYCTSYk2Su66QZnErHGsoxF3WyjK2TZ2whJ2f5wpPKWSqTmxNJV3Oi9T6Y
+s15uVtAceCR0pikLWToTjoUzDeUsN2uZE1ycWLm4s2YkToK5spNivBwj5gxHudj2HCtm/nnq
+5EgX245jxmw7doy/o2Vejph5OmrG6zvw6acOjJmzT+2YM24nRk88cS1h/H4ncfsdy+t3uYWk
+dW4uCBEREREREREREREREREREREREREREREREREREREREdE6r/vdnW6s97qD39fRQ04TLLyn
+chjNGWQKDBycER33Hdwozs3pg46IiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiI
+iIiIiIiIiIiIiIiIiIiIiOiR03NznJ8QJ6ZC8IGCDxSCD3SSo4JiRuSsmGs7a0YD4ZgxCsjJ
+STNujjWUY4ydLGMMOTkbjKWzxQidSQVtjud6TrzYpkns/ACT2nm+fAwZO9M70QqKmRgydTYg
+oSNZQQlG53htByHLqJyYETkrRuOsGZwCR8iM7CiZPhw7ZuZIhxMfH6gYd0fMbByOmjJe3+Xc
+nJO/a5szaceeOdURMCeesdQwfieuvU74LyAlM5PEDBERERERERERERERERERERERERERERER
+ERERERERERHRuXlNr+A0j4PXhBFeM1Pg4OC0Qg6O1w6OiIiIiIiIiIiIiIiIiIiIiIiIiIiI
+iIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIyD+n5zTxILp6Rg6Fd06MFAo+UDjHUUEx
+4+aIoLUjgRKMmyOAksx1nTRjDuWYizpZxhhycjYYN8cSwmlipp//p3amd6M5C8naCRnHDooc
+2YawdHQbnK+TY67qBFdHyJzhrBkvx445wZEyb0e6dm7vN6qYGe3o2utLyf/t2AFu2zAQRFGv
+73/oOm7StLYMBIhm2LLvXeBDFmFx91Xn7MxuM2Nr1K6tDtatXDKZ1kastklcsxoNZn4rZSsA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHTMTSlTCM10QtMJ
+zVRCM53QdEIznVCp85hJhZ47kdBBJhIqdQ4ztc7poReZszuvMmeHNuu8zmzXOTVU7lxvCp3r
+h1bnusfzvIXm6Q0FOvdU8Bx8Rg4OXKiTPNcbd54ymXOdzdQ74Uy7k84s75ycaV16F3dOzxyH
+ApnWzLhuBs5klnVCmdpq589QMNNavX2WwhUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAKBnppSZRmnelTLh0EwnNJ3QTCc0ndBjptbJhJ4zkc5BJhIqdQ4z
+gVCp8yKzXefsUKnzMqPzlc71p3TnWurMU6X3fs4N1c/bdbNO63db1Tk3s7xzcmZ15+zMdrfE
+w04g07rEL+xEMrWZcdEMHMu0Vgd/hJKZS6fyGUpn7qlGBAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgDdzU8oUQvOhlKl1oqVZ0cmFZjqhUucxEwo9Z2qd
+ROgos10nECp1jjM6X+1cO53rTed5wg+06znQOaNzemZt5/zM0k4gs7KTyByEMpllnVDmsZPK
+tGaf2sx4KWVaI/2vUDpzD+UjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAQN3clDKN0pRC0wnNVEKzoBMMzVRCs1fnMZMKbdZ5ztQ6kZCOjs6pnURmYSeS
+WdfJZJZ1QpnWpeoxVOrkMrVL/KWUqc1Yl1KmNQMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAwPfNTSlTCM1UQtPuZEPT6cx0Qks6udDs1ZlFnVRI59/q
+hDK7d1KZRZ1YZuuvXDBTu+zUL2/hzKV2h38LVTIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAPwPplO5KWXyoflQyuzRmamERufbnWBm504ys9u/waVT
+qXfSmfdQPnMPNTIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAwF/qB/iV/u4=
+"
+	}
+}
diff --git a/src/meshify.c b/src/meshify.c
index 80e4d18..b030c38 100644
--- a/src/meshify.c
+++ b/src/meshify.c
@@ -618,6 +618,26 @@ void read_vec4float(float *vec4, cJSON *vec){
 	}
 }
 
+void array3d_row2col(float **vol, unsigned short *dim){
+	unsigned int x,y,z;
+	unsigned int dimxy,dimyz;
+	float *newvol=NULL;
+
+	if(*vol==NULL || dim[0]==0 || dim[1]==0 || dim[2]==0){
+		return;
+	}
+	newvol=(float *)malloc(sizeof(float)*dim[0]*dim[1]*dim[2]);
+	dimxy=dim[0]*dim[1];
+	dimyz=dim[1]*dim[2];
+	for(x=0;x<dim[0];x++)
+		for(y=0;y<dim[1];y++)
+			for(z=0;z<dim[2];z++){
+				newvol[z*dimxy+y*dim[0]+x]=(*vol)[x*dimyz+y*dim[2]+z];
+			}
+	free(*vol);
+	*vol=newvol;
+}
+
 // parsing a JSON/JNIfTI-encoded jnii volume file
 
 float * load_jnii(const char *fnm, nifti_1_header * hdr) {
@@ -733,6 +753,10 @@ float * load_jnii(const char *fnm, nifti_1_header * hdr) {
 		}
 		if(imgRaw)
 			free(imgRaw);
+
+		tmp=cJSON_GetObjectItem(jniidata, "_ArrayOrder_");
+		if(!tmp || (cJSON_IsString(tmp) && ((tmp->valuestring)[0]=='r' || (tmp->valuestring)[0]=='R')))
+			array3d_row2col(&img32, hdr->dim+1);
 	}else
 		return NULL;
 	cJSON_Delete(root);

From 3cdbdb13c27db2bcfd55afa8ae5f385b5e4da725 Mon Sep 17 00:00:00 2001
From: Qianqian Fang <fangqq@gmail.com>
Date: Mon, 18 Apr 2022 14:18:02 -0400
Subject: [PATCH 06/13] fix gcc error when compiling with OLD=1

---
 src/meshify.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/meshify.c b/src/meshify.c
index b030c38..f989e4a 100644
--- a/src/meshify.c
+++ b/src/meshify.c
@@ -594,13 +594,13 @@ int  jdata_decode(void **vol, unsigned short *ndim, unsigned short *dims, int ma
 			if(zipid<0 ||zipid>zmBase64)
 				 return -1;
 			if(zipid==zmBase64)
-				return zmat_run(strlen(vdata->valuestring), (uchar *)vdata->valuestring, &len, (uchar **)vol, zmBase64, &status, 0);
+				return zmat_run(strlen(vdata->valuestring), (unsigned char *)vdata->valuestring, &len, (unsigned char **)vol, zmBase64, &status, 0);
 			else
-				ret=zmat_run(strlen(vdata->valuestring), (uchar *)vdata->valuestring, &len, (uchar **)&buf, zmBase64, &status, 0);
+				ret=zmat_run(strlen(vdata->valuestring), (unsigned char *)vdata->valuestring, &len, (unsigned char **)&buf, zmBase64, &status, 0);
 			if(!ret && vsize){
 				if(*vol)
 					free(*vol);
-				ret=zmat_run(len, (uchar *)buf, &newlen, (uchar **)(vol), zipid, &status, 0);
+				ret=zmat_run(len, (unsigned char *)buf, &newlen, (unsigned char **)(vol), zipid, &status, 0);
 			}
 			if(buf)
 				free(buf);

From 288ac4a2a8864cd9b005912a30104d3f50818275 Mon Sep 17 00:00:00 2001
From: neurolabusc <rorden@sc.edu>
Date: Tue, 19 Apr 2022 12:52:50 -0400
Subject: [PATCH 07/13] Fix issue 2
 (https://github.com/neurolabusc/nii2mesh/issues/2)

---
 src/MarchingCubes.c |  4 ++--
 src/meshify.c       |  2 +-
 src/nii2mesh.c      | 10 +++++-----
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/MarchingCubes.c b/src/MarchingCubes.c
index 91bb128..2cb6e6a 100644
--- a/src/MarchingCubes.c
+++ b/src/MarchingCubes.c
@@ -1094,14 +1094,14 @@ int marchingCubes(float * img, size_t dim[3], int lo[3], int hi[3], int original
     return EXIT_FAILURE;
   }
   int npt = mcp->nverts;
-  *vs = malloc(npt*sizeof(vec3d));
+  *vs = (vec3d*) malloc(npt*sizeof(vec3d));
   for (int i = 0; i < npt; i++) {
     (*vs)[i].x = mcp->vertices[i].x + lo[0];
     (*vs)[i].y = mcp->vertices[i].y + lo[1];
     (*vs)[i].z = mcp->vertices[i].z + lo[2];
   }
   int ntri = mcp->ntrigs;
-  *ts = malloc(ntri * sizeof(vec3i));
+  *ts = (vec3i*) malloc(ntri * sizeof(vec3i));
   for (int i=0;i<ntri;i++) {
     (*ts)[i].x = mcp->triangles[i].v3;
     (*ts)[i].y = mcp->triangles[i].v2;
diff --git a/src/meshify.c b/src/meshify.c
index f989e4a..42eb3fe 100644
--- a/src/meshify.c
+++ b/src/meshify.c
@@ -362,7 +362,7 @@ int meshify(float * img, size_t dim[3], int originalMC, float isolevel, vec3i **
 	//printf("Bounding box for bright voxels: %d..%d %d..%d %d..%d\n", lo[0], hi[0], lo[1], hi[1], lo[2], hi[2]);
 	for (int i=0;i<3;i++) {
 		lo[i] = MAX(lo[i] - 1, 0);
-		hi[i] = MIN(hi[i] + 2, dim[i]);
+		hi[i] = MIN(hi[i] + 2, dim[i]-1);
 	}
 	double startTimeMC = clockMsec();
 	vec3d *pts = NULL;
diff --git a/src/nii2mesh.c b/src/nii2mesh.c
index 06bb62f..2d2fc7a 100644
--- a/src/nii2mesh.c
+++ b/src/nii2mesh.c
@@ -178,7 +178,7 @@ int nii2 (nifti_1_header hdr, float * img, int originalMC, float isolevel, float
 	vec3d *pts = NULL;
 	vec3i *tris = NULL;
 	int ntri, npt;
-	size_t dim[3] = {hdr.dim[1], hdr.dim[2], hdr.dim[3]};
+	size_t dim[3] = {(size_t)hdr.dim[1], (size_t)hdr.dim[2], (size_t)hdr.dim[3]};
 	if (meshify(img, dim, originalMC, isolevel, &tris, &pts, &ntri, &npt, preSmooth, onlyLargest, fillBubbles, verbose) != EXIT_SUCCESS)
 		return EXIT_FAILURE;
 	apply_sform(tris, pts, ntri, npt, hdr.srow_x, hdr.srow_y, hdr.srow_z);
@@ -295,11 +295,11 @@ int main(int argc,char **argv) {
 	double startTime = clockMsec();
 	float * img=NULL;
 #ifdef HAVE_JSON
-        if(strstr(argv[1], ".jnii") - argv[1] == strlen(argv[1])-5)
-                img = load_jnii(argv[1], &hdr);
-        else
+	if(strstr(argv[1], ".jnii") - argv[1] == strlen(argv[1])-5)
+			img = load_jnii(argv[1], &hdr);
+	else
 #endif
-                img = load_nii(argv[1], &hdr);
+	img = load_nii(argv[1], &hdr);
 	if (verbose)
 		printf("load from disk: %ld ms\n", timediff(startTime, clockMsec()));
 	if (img == NULL)

From 1b7403da6d4c3dc95b1d12ec3c2caa1f5fcae777 Mon Sep 17 00:00:00 2001
From: Qianqian Fang <fangqq@gmail.com>
Date: Tue, 19 Apr 2022 13:24:28 -0400
Subject: [PATCH 08/13] report an error when the specified .jnii file is
 missing

---
 src/meshify.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/meshify.c b/src/meshify.c
index f989e4a..add8850 100644
--- a/src/meshify.c
+++ b/src/meshify.c
@@ -648,6 +648,10 @@ float * load_jnii(const char *fnm, nifti_1_header * hdr) {
 
 	// reading JNIfTI/JSON file to a string
 	FILE *fp=fopen(fnm,"rb");
+	if(!fp){
+		printf("Unable to open the specified file %s\n", fnm);
+		return NULL;
+	}
 	fseek (fp, 0, SEEK_END);
 	len=ftell(fp)+1;
 	jbuf=(char *)malloc(len);

From a41c4bc59f15e53c55938b3eeed1bc07632c9735 Mon Sep 17 00:00:00 2001
From: Qianqian Fang <fangqq@gmail.com>
Date: Tue, 19 Apr 2022 13:57:55 -0400
Subject: [PATCH 09/13] fix all gcc -Wall --pedantic warnings, #1

---
 src/MarchingCubes.c |  2 +-
 src/meshify.c       | 43 +++++++++++++++++++++----------------------
 src/nii2mesh.c      |  6 ++++++
 src/quadric.c       |  2 +-
 4 files changed, 29 insertions(+), 24 deletions(-)

diff --git a/src/MarchingCubes.c b/src/MarchingCubes.c
index 2cb6e6a..9ce0064 100644
--- a/src/MarchingCubes.c
+++ b/src/MarchingCubes.c
@@ -1141,7 +1141,7 @@ void writePLY( MCB *mcb , const char *fn) {
   if (fp == NULL)
     return;// EXIT_FAILURE;
   fputs("ply\n",fp);
-  if (&littleEndianPlatform)
+  if (littleEndianPlatform())
     fputs("format binary_little_endian 1.0\n",fp);
   else
     fputs("format binary_big_endian 1.0\n",fp);
diff --git a/src/meshify.c b/src/meshify.c
index 762554b..58ff991 100644
--- a/src/meshify.c
+++ b/src/meshify.c
@@ -443,7 +443,7 @@ int save_freesurfer(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt)
 	fwrite(s, strlen(s), 1, fp);
 	int32_t VertexCount = npt;
 	int32_t FaceCount = ntri;
-	if ( &littleEndianPlatform) {
+	if (littleEndianPlatform()) {
 		swap_4bytes(1, &VertexCount);
 		swap_4bytes(1, &FaceCount);
 	}
@@ -452,11 +452,11 @@ int save_freesurfer(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt)
 	vec3s *pts32 = (vec3s *) malloc(npt * sizeof(vec3s));
 	for (int i = 0; i < npt; i++) //double->single precision
 		pts32[i] = vec3d2vec4s(pts[i]);
-	if (&littleEndianPlatform)
+	if (littleEndianPlatform())
 		swap_4bytes(npt * 3, pts32);
 	fwrite(pts32, npt * sizeof(vec3s), 1, fp);
 	free(pts32);
-	if (&littleEndianPlatform) {
+	if (littleEndianPlatform()) {
 		vec3i *trisSwap = (vec3i *) malloc(ntri * sizeof(vec3i));
 		for (int i = 0; i < ntri; i++)
 			trisSwap[i] = tris[i];
@@ -714,7 +714,7 @@ float * load_jnii(const char *fnm, nifti_1_header * hdr) {
 		if(!tmp)
 			return NULL;
 
-		if(jdata_decode((void **)&imgRaw, hdr->dim, hdr->dim+1, 3, &type, jniidata)!=0){
+		if(jdata_decode((void **)&imgRaw, (unsigned short *)hdr->dim, (unsigned short *)hdr->dim+1, 3, &type, jniidata)!=0){
 			if(imgRaw)
 				free(imgRaw);
 			return NULL;
@@ -760,7 +760,7 @@ float * load_jnii(const char *fnm, nifti_1_header * hdr) {
 
 		tmp=cJSON_GetObjectItem(jniidata, "_ArrayOrder_");
 		if(!tmp || (cJSON_IsString(tmp) && ((tmp->valuestring)[0]=='r' || (tmp->valuestring)[0]=='R')))
-			array3d_row2col(&img32, hdr->dim+1);
+			array3d_row2col(&img32, (unsigned short *)hdr->dim+1);
 	}else
 		return NULL;
 	cJSON_Delete(root);
@@ -858,19 +858,19 @@ int save_jmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool
 }
 
 void write_ubjsonint(int len, int *dat, FILE *fp){
-	if (!&littleEndianPlatform)
+	if (!littleEndianPlatform())
 		swap_4bytes(len, dat);
 	fwrite(dat,len,4,fp);
 }
 
 void write_ubjsonfloat(int len, float *dat, FILE *fp){
-	if (!&littleEndianPlatform)
+	if (!littleEndianPlatform())
 		swap_4bytes(len, dat);
 	fwrite(dat,len,4,fp);
 }
 
 void write_ubjsondouble(int len, double *dat, FILE *fp){
-	if (!&littleEndianPlatform)
+	if (!littleEndianPlatform())
 		swap_8bytes(len, dat);
 	fwrite(dat,len,8,fp);
 }
@@ -951,7 +951,7 @@ int save_bmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool
 					fwrite(&keylenbyte,1,sizeof(keylenbyte),fp);
 				}else{
 					fputc('l',fp);
-					write_ubjsonint(1,&keylen,fp);
+					write_ubjsonint(1,(int *)(&keylen),fp);
 				}
 			}
 		}else{
@@ -960,7 +960,7 @@ int save_bmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool
 				if(sscanf(output[i],"\?%d",&slotid)==1 && slotid>0){
 					unsigned char *compressed=NULL;
 					size_t compressedbytes, totalbytes;
-					int dim[2]={0,3}, len[2]={1,0};
+					int dim[2]={0,3};
 					int ret=0, status=0;
 					switch(slotid){
 						case 1: {
@@ -983,7 +983,7 @@ int save_bmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool
 								val[0]=ntri;
 								fwrite("U\x08MeshTri3[$l#[$l#U\x02", 1, 20, fp);
 								write_ubjsonint(2, val, fp);
-								write_ubjsonint(ntri*3, newtris, fp);
+								write_ubjsonint(ntri*3, (int *)newtris, fp);
 								fputc('}', fp);
 							}
 							break;
@@ -992,7 +992,6 @@ int save_bmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool
 						case 3: {int val=npt*3;	write_ubjsonint(1,&val,fp);break;}
 						case 4:
 							dim[0]=npt;
-							len[1]=dim[0]*dim[1];
 
 							totalbytes=dim[0]*dim[1]*(isdouble? sizeof(pts[0].x) : sizeof(float));
 							ret=zmat_run(totalbytes, (isdouble ? (unsigned char *)&(pts[0].x) : (unsigned char *)floatpts) , &compressedbytes, (unsigned char **)&compressed, zmZlib, &status,1);
@@ -1081,11 +1080,11 @@ int save_mz3(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool i
 	h.NFACE = ntri;
 	h.NVERT = npt;
 	h.NSKIP = 0;
-	if (! &littleEndianPlatform)
+	if (!littleEndianPlatform())
 		swap_4bytes(3, &h.NFACE);
-	FILE *fp;
+	FILE *fp=NULL;
 	#ifdef HAVE_ZLIB
-	gzFile fgz;
+	gzFile fgz=NULL;
 	if (isGz) {
 		fgz = gzopen(fnm, "w");
 		if (! fgz)
@@ -1099,7 +1098,7 @@ int save_mz3(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool i
 			return EXIT_FAILURE;
 		fwrite(&h, sizeof(struct mz3hdr), 1, fp);
 	}
-	if (! &littleEndianPlatform) {
+	if (!littleEndianPlatform()) {
 		vec3i *trisSwap = (vec3i *) malloc(ntri * sizeof(vec3i));
 		for (int i = 0; i < ntri; i++)
 			trisSwap[i] = tris[i];
@@ -1123,7 +1122,7 @@ int save_mz3(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool i
 	vec3s *pts32 = (vec3s *) malloc(npt * sizeof(vec3s));
 	for (int i = 0; i < npt; i++) //double->single precision
 		pts32[i] = vec3d2vec4s(pts[i]);
-	if (! &littleEndianPlatform)
+	if (!littleEndianPlatform())
 		swap_4bytes(npt * 3, pts32);
 	#ifdef HAVE_ZLIB
 	if (isGz) {
@@ -1221,7 +1220,7 @@ int save_ply(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
 	if (fp == NULL)
 		return EXIT_FAILURE;
 	fputs("ply\n",fp);
-	if (&littleEndianPlatform)
+	if (littleEndianPlatform())
 		fputs("format binary_little_endian 1.0\n",fp);
 	else
 		fputs("format binary_big_endian 1.0\n",fp);
@@ -1287,7 +1286,7 @@ int save_gii(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool i
 	else
 	#endif
 		fputs("               Encoding=\"Base64Binary\"\n" ,fp);
-	if (&littleEndianPlatform)
+	if (littleEndianPlatform())
 		fputs("               Endian=\"LittleEndian\"\n",fp);
 	else
 		fputs("               Endian=\"BigEndian\"\n",fp);
@@ -1329,7 +1328,7 @@ int save_gii(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool i
 	else
 	#endif
 		fputs("               Encoding=\"Base64Binary\"\n" ,fp);
-	if (&littleEndianPlatform)
+	if (littleEndianPlatform())
 		fputs("               Endian=\"LittleEndian\"\n",fp);
 	else
 		fputs("               Endian=\"BigEndian\"\n",fp);
@@ -1388,7 +1387,7 @@ int save_vtk(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
 	vec3s *pts32 = (vec3s *) malloc(npt * sizeof(vec3s));
 	for (int i = 0; i < npt; i++)//double->single precision
 		pts32[i] = vec3d2vec4s(pts[i]);
-	if (&littleEndianPlatform)
+	if (littleEndianPlatform())
 		swap_4bytes(3*npt, pts32);
 	fwrite(pts32, npt * sizeof(vec3s), 1, fp);
 	free(pts32);
@@ -1402,7 +1401,7 @@ int save_vtk(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt){
 		tris4[i].y = tris[i].y;
 		tris4[i].z = tris[i].z;
 	}
-	if (&littleEndianPlatform)
+	if (littleEndianPlatform())
 		swap_4bytes(4*ntri, tris4);
 	fwrite(tris4, ntri * sizeof(vec4i), 1, fp);
 	free(tris4);
diff --git a/src/nii2mesh.c b/src/nii2mesh.c
index 2d2fc7a..ed43a05 100644
--- a/src/nii2mesh.c
+++ b/src/nii2mesh.c
@@ -360,11 +360,15 @@ int main(int argc,char **argv) {
 			omp_set_num_threads(maxNumThreads);
 		#endif
 		int partial_OK, nOK;
+		#if defined(_OPENMP) //compile with 'OMP=1 make -j'
 		#pragma omp parallel private(partial_OK) shared(nOK)
+		#endif
 		{
 			partial_OK = 0;
 			nOK = 0;
+			#if defined(_OPENMP) //compile with 'OMP=1 make -j'
 			#pragma omp for
+			#endif
 			for (int i = 1; i <= nLabel; i++) {
 				printf("%d/%d\n", i, nLabel);
 				float * imgbinary = (float *) malloc(nvox*sizeof(float));
@@ -389,7 +393,9 @@ int main(int argc,char **argv) {
 					partial_OK ++;
 				free(imgbinary);
 			} //for nLabel
+			#if defined(_OPENMP) //compile with 'OMP=1 make -j'
 			#pragma omp critical
+			#endif
 			{
 				nOK += partial_OK;
 			}
diff --git a/src/quadric.c b/src/quadric.c
index 0e195a3..86c418e 100644
--- a/src/quadric.c
+++ b/src/quadric.c
@@ -435,7 +435,7 @@ void quadric_simplify_mesh(vec3d **vs, vec3i **ts, int* nvert, int *ntri, int ta
 		lossy = false;
 		max_iter = 1000;
 	}
-	int iterationStartCount;
+	int iterationStartCount=triangle_count;
 	for (int iteration = 0; iteration < max_iter; iteration ++) {
 		if ((lossy) && ((triangle_count-deleted_triangles)<=target_count)) {
 			if (!finishLossless) break;

From fca6bb580f1aab474653ede1fefe7aa2cf6f2b90 Mon Sep 17 00:00:00 2001
From: Qianqian Fang <fangqq@gmail.com>
Date: Tue, 19 Apr 2022 14:13:42 -0400
Subject: [PATCH 10/13] slight update to README

---
 README.md | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 07ce588..6ef1584 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 ## About
 
-This tool converts a NIfTI 3D voxel image to a triangulated mesh. It can save meshes in in the GIfTI (.gii), mz3, obj, ply, FreeSurfer (.pial), stl, vtk, formats. You can use [dcm2niix](https://github.com/rordenlab/dcm2niix) to convert DICOM images to NIfTI. The software is written in pure C (rather than C++).
+This tool converts a NIfTI 3D voxel image to a triangulated mesh. It can save meshes in in the GIfTI (.gii), mz3, JMesh (.jmsh, .bmsh), obj, ply, FreeSurfer (.pial), stl, vtk, formats. You can use [dcm2niix](https://github.com/rordenlab/dcm2niix) to convert DICOM images to NIfTI. The software is written in pure C (rather than C++).
 
 ## Compiling
 
@@ -52,10 +52,11 @@ Options
     -o v    Original marching cubes (0=Improved Lewiner, 1=Original, default 0)
     -p v    pre-smoothing (0=skip, 1=smooth, default 1)
     -r v    reduction factor (default 0.25)
-    -q v    quality (0=fast, 1= balanced, 2=best, default 1)
+    -q v    quality (0=fast, 1=balanced, 2=best, default 1)
+    -d v    double precision (0=use single precision, 1=use double precision (for bmsh/json), default 0)
     -s v    post-smoothing iterations (default 0)
     -v v    verbose (0=silent, 1=verbose, default 0)
-mesh extension sets format (.gii, .mz3, .bmsh, .json, .obj, .ply, .pial, .stl, .vtk)
+mesh extension sets format (.gii, .mz3, .bmsh, .jmsh, .json, .obj, .ply, .pial, .stl, .vtk)
 Example: './nii2mesh voxels.nii mesh.obj'
 Example: './nii2mesh bet.nii.gz -i 22 myOutput.obj'
 Example: './nii2mesh bet.nii.gz -i b bright.obj'
@@ -174,7 +175,7 @@ nii2mesh can save meshes to the GIfTI (.gii), JSON, JMesh (.jmsh, .bmsh), mz3, o
  - [MZ3](https://github.com/neurolabusc/surf-ice/tree/master/mz3) is the native format of [Surfice](https://www.nitrc.org/projects/surfice/). It is small and fast, but not widely supported.
  - [FreeSurfer](https://surfer.nmr.mgh.harvard.edu) format is simple and used by FreeSurfer.
  - [json](https://github.com/NeuroJSON/jmesh) creates human readable ASCII JSON files in the format described by [JMesh](https://github.com/NeuroJSON/jmesh). Be aware that other tools create legal JSON files to describe triangular meshes using a structure that is not compatible with json.
- - [jmsh](https://github.com/NeuroJSON/jmesh) files are in the [NeuroJSON](http://neurojson.org) [JMesh](https://github.com/fangq/jmesh) format, which inserts a compressed binary stream into a human readable JSON file. Supporting this format slightly increases the size of the executable (using the optional `-DHAVE_JSON` compiler flag and `cJSON` files).
+ - [jmsh](https://github.com/NeuroJSON/jmesh) files are in the [NeuroJSON](https://neurojson.org) [JMesh](https://github.com/fangq/jmesh) format, which inserts a compressed binary stream into a human readable JSON file. Supporting this format slightly increases the size of the executable (using the optional `-DHAVE_JSON` compiler flag and `cJSON` files).
  - [bmsh](https://github.com/NeuroJSON/jmesh) is a binary-JSON ([BJData - Draft 2](https://github.com/NeuroJSON/bjdata/blob/Draft_2/Binary_JData_Specification.md)) based mesh-data container based on the JMesh specification; both `.bmsh` and `.jmsh` support data-level compression
  - [VTK](http://www.princeton.edu/~efeibush/viscourse/vtk.pdf) refers to the legacy VTK format, which is supported by many tools (unlike the more flexible modern XML-based VTK formats).
  - [STL](http://www.paulbourke.net/dataformats/stl/) format is popular for 3D printing. You should use any other format unless required. This format does not re-use vertices across triangles, this results in very large files. Further, this means the meshes are either slow to load or appear to have a faceted jagged appearance.

From 2c28bbc7c2b328fc8790021fd7b1c343001d19d6 Mon Sep 17 00:00:00 2001
From: Qianqian Fang <fangqq@gmail.com>
Date: Tue, 19 Apr 2022 14:16:23 -0400
Subject: [PATCH 11/13] update URLs to use https

---
 src/meshify.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/meshify.c b/src/meshify.c
index 58ff991..4bfa9f4 100644
--- a/src/meshify.c
+++ b/src/meshify.c
@@ -793,7 +793,7 @@ int save_jmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool
 
 	fprintf(fp, "{\n\t\"_DataInfo_\":{\n");
 	fprintf(fp, "\t\t\"JMeshVersion\":\"0.5\",\n");
-	fprintf(fp, "\t\t\"Comment\":\"Created by nii2mesh with NeuroJSON JMesh format (http://neurojson.org)\",\n");
+	fprintf(fp, "\t\t\"Comment\":\"Created by nii2mesh with NeuroJSON JMesh format (https://neurojson.org)\",\n");
 	fprintf(fp, "\t\t\"AnnotationFormat\":\"https://neurojson.org/jmesh/draft1\",\n");
 	fprintf(fp, "\t\t\"SerialFormat\":\"https://json.org\",\n");
 	fprintf(fp, "\t\t\"Parser\":{\n");
@@ -881,7 +881,7 @@ int save_bmsh(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool
 	"{",
 		"N","","_DataInfo_","{",
 			"N","","JMeshVersion","S","","0.5",
-			"N","","Comment","S","","Created by nii2mesh with NeuroJSON Binay JMesh format (http://neurojson.org)",
+			"N","","Comment","S","","Created by nii2mesh with NeuroJSON Binay JMesh format (https://neurojson.org)",
 			"N","","AnnotationFormat","S","","https://neurojson.org/jmesh/draft1",
 			"N","","SerialFormat","S","","https://neurojson.org/bjdata/draft2",
 			"N","","Parser","{",
@@ -1042,7 +1042,7 @@ int save_json(const char *fnm, vec3i *tris, vec3d *pts, int ntri, int npt, bool
 	if (fp == NULL)
 		return EXIT_FAILURE;
 	fprintf(fp,"{\n");
-	fprintf(fp,"\t\"_DataInfo_\":{\n\t\t\"JMeshVersion\":\"0.5\",\n\t\t\"Comment\":\"Created by nii2mesh with NeuroJSON JMesh format (http://neurojson.org)\"\n\t},\n");
+	fprintf(fp,"\t\"_DataInfo_\":{\n\t\t\"JMeshVersion\":\"0.5\",\n\t\t\"Comment\":\"Created by nii2mesh with NeuroJSON JMesh format (https://neurojson.org)\"\n\t},\n");
 	fprintf(fp,"\t\"MeshVertex3\":[\n");
         if(isdouble){
                 for (int i=0;i<npt;i++)

From c67012602b784a854aa15167e96a0c9cbee3001f Mon Sep 17 00:00:00 2001
From: Qianqian Fang <fangqq@gmail.com>
Date: Tue, 19 Apr 2022 14:44:25 -0400
Subject: [PATCH 12/13] remote instruction on make JSON=1 for jmsh output in
 README

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 6ef1584..d818e74 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 ## About
 
-This tool converts a NIfTI 3D voxel image to a triangulated mesh. It can save meshes in in the GIfTI (.gii), mz3, JMesh (.jmsh, .bmsh), obj, ply, FreeSurfer (.pial), stl, vtk, formats. You can use [dcm2niix](https://github.com/rordenlab/dcm2niix) to convert DICOM images to NIfTI. The software is written in pure C (rather than C++).
+This tool converts a NIfTI 3D voxel image to a triangulated mesh. It can save meshes in in the GIfTI (.gii), mz3, [JMesh](https://github.com/NeuroJSON/jmesh) (.jmsh, .bmsh), obj, ply, FreeSurfer (.pial), stl, vtk, formats. You can use [dcm2niix](https://github.com/rordenlab/dcm2niix) to convert DICOM images to NIfTI. The software is written in pure C (rather than C++).
 
 ## Compiling
 
@@ -174,9 +174,9 @@ nii2mesh can save meshes to the GIfTI (.gii), JSON, JMesh (.jmsh, .bmsh), mz3, o
  - [PLY](http://paulbourke.net/dataformats/ply/) is an old format that is widely supported. The binary form created by nii2mesh yields small files and quick loading time.
  - [MZ3](https://github.com/neurolabusc/surf-ice/tree/master/mz3) is the native format of [Surfice](https://www.nitrc.org/projects/surfice/). It is small and fast, but not widely supported.
  - [FreeSurfer](https://surfer.nmr.mgh.harvard.edu) format is simple and used by FreeSurfer.
- - [json](https://github.com/NeuroJSON/jmesh) creates human readable ASCII JSON files in the format described by [JMesh](https://github.com/NeuroJSON/jmesh). Be aware that other tools create legal JSON files to describe triangular meshes using a structure that is not compatible with json.
- - [jmsh](https://github.com/NeuroJSON/jmesh) files are in the [NeuroJSON](https://neurojson.org) [JMesh](https://github.com/fangq/jmesh) format, which inserts a compressed binary stream into a human readable JSON file. Supporting this format slightly increases the size of the executable (using the optional `-DHAVE_JSON` compiler flag and `cJSON` files).
- - [bmsh](https://github.com/NeuroJSON/jmesh) is a binary-JSON ([BJData - Draft 2](https://github.com/NeuroJSON/bjdata/blob/Draft_2/Binary_JData_Specification.md)) based mesh-data container based on the JMesh specification; both `.bmsh` and `.jmsh` support data-level compression
+ - [JSON](https://github.com/NeuroJSON/jmesh) creates human readable ASCII JSON files in the format described by [JMesh specification](https://github.com/NeuroJSON/jmesh). Be aware that other tools create legal JSON files to describe triangular meshes using a structure that is not compatible with json.
+ - [JMSH](https://github.com/NeuroJSON/jmesh) files are in the [NeuroJSON](https://neurojson.org) [JMesh](https://github.com/fangq/jmesh) format, which inserts a compressed binary stream into a human readable JSON file.
+ - [BMSH](https://github.com/NeuroJSON/jmesh) is a binary-JSON ([BJData - Draft 2](https://github.com/NeuroJSON/bjdata/blob/Draft_2/Binary_JData_Specification.md)) based mesh-data container based on the JMesh specification; both `.bmsh` and `.jmsh` support data-level compression
  - [VTK](http://www.princeton.edu/~efeibush/viscourse/vtk.pdf) refers to the legacy VTK format, which is supported by many tools (unlike the more flexible modern XML-based VTK formats).
  - [STL](http://www.paulbourke.net/dataformats/stl/) format is popular for 3D printing. You should use any other format unless required. This format does not re-use vertices across triangles, this results in very large files. Further, this means the meshes are either slow to load or appear to have a faceted jagged appearance.
 

From 848cb1d0113d531affb66e57aa91e0136adf975e Mon Sep 17 00:00:00 2001
From: Qianqian Fang <fangqq@gmail.com>
Date: Tue, 19 Apr 2022 22:51:23 -0400
Subject: [PATCH 13/13] stop encoding slash in JSON strings, see
 https://mondotondo.com/2010/12/29/the-solidus-issue/

---
 data/digimouse.jnii | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/data/digimouse.jnii b/data/digimouse.jnii
index 71d993f..3405870 100644
--- a/data/digimouse.jnii
+++ b/data/digimouse.jnii
@@ -1,21 +1,21 @@
 {
 	"_DataInfo_":{
 		"JNIFTIVersion":"0.5",
-		"Comment":"Created by JNIFTY Toolbox (https:\/\/github.com\/NeuroJSON\/jnifty)",
-		"AnnotationFormat":"https:\/\/github.com\/NeuroJSON\/jnifti\/blob\/master\/JNIfTI_specification.md",
-		"SerialFormat":"http:\/\/json.org",
+		"Comment":"Created by JNIFTY Toolbox (https://github.com/NeuroJSON/jnifty)",
+		"AnnotationFormat":"https://github.com/NeuroJSON/jnifti/blob/master/JNIfTI_specification.md",
+		"SerialFormat":"http://json.org",
 		"Parser":{
 			"Python":[
-				"https:\/\/pypi.org\/project\/jdata",
-				"https:\/\/pypi.org\/project\/bjdata"
+				"https://pypi.org/project/jdata",
+				"https://pypi.org/project/bjdata"
 			],
 			"MATLAB":[
-				"https:\/\/github.com\/NeuroJSON\/jnifty",
-				"https:\/\/github.com\/NeuroJSON\/jsonlab"
+				"https://github.com/NeuroJSON/jnifty",
+				"https://github.com/NeuroJSON/jsonlab"
 			],
-			"JavaScript":"https:\/\/github.com\/NeuroJSON\/jsdata",
-			"CPP":"https:\/\/github.com\/NeuroJSON\/json",
-			"C":"https:\/\/github.com\/NeuroJSON\/ubj"
+			"JavaScript":"https://github.com/NeuroJSON/jsdata",
+			"CPP":"https://github.com/NeuroJSON/json",
+			"C":"https://github.com/NeuroJSON/ubj"
 		}
 	},
 	"NIFTIHeader":{
@@ -59,7 +59,7 @@
 		"TimeOffset":0,
 		"A75GlobalMax":255,
 		"A75GlobalMin":0,
-		"Description":"Created by Qianqian Fang for BlenderPhotonics, see paper https:\/\/doi.org\/10.1117\/1.JBO.27.8.083014",
+		"Description":"Created by Qianqian Fang for BlenderPhotonics, see paper https://doi.org/10.1117/1.JBO.27.8.083014",
 		"AuxFile":"",
 		"QForm":0,
 		"SForm":0,
@@ -78,7 +78,7 @@
 			[0,1,0,0],
 			[0,0,1,0]
 		],
-		"Name":"Digimouse Atlas - downsampled 2x from original 380x992x208 volume downloaded from https:\/\/neuroimage.usc.edu\/neuro\/Digimouse_Download",
+		"Name":"Digimouse Atlas - downsampled 2x from original 380x992x208 volume downloaded from https://neuroimage.usc.edu/neuro/Digimouse_Download",
 		"NIIFormat":"JNIfTI v0.5",
 		"NIIQfac_":0,
 		"NIIEndian_":"L"