[AHK v2] Call Imbedded C functions using TCC's libtcc.dll with single include file

[oif2003]

Hi,

Here's a fun project I have been working on. It lets you imbed C code in your AHK v2 script without extra dependency files (sort of, since the script will produce these files and the compiled C dll). It first extracts the attached copy of libtcc.dll and libtcc1-64.a to the script's directory (A_ScriptDir). It then uses libtcc.dll to compile the C code found between predefined comment labels within the script to a dll file. Provided that it doesn't crash, it also deletes all the temporary files on exit. The classes are a bit messy because I wrote them myself. This can definitely be done better by someone smarter. The usage is pretty straight forward. See the first part of the code below:

Code: Select all

#singleinstance force
;initialize, compile code, etc.
cCode()

;simple function calling
msgbox(cFunc.mul(cFunc.add(1,3),5))

;array example
VarSetCapacity(a, 5*4)	;setup buffer capacity (4 is size of Int)
cFunc.arr(&a)			;send function the pointer to the buffer
arrayStr := "["			
loop 5 {				;read each element of array
	arrayStr .= NumGet(a, (A_Index-1)*4, "Int") . (A_Index != 5 ? "," : "]")
}
msgbox(arrayStr)

;string example
msgbox(cFunc.hello())



;to call C function => cFunc.functionName(param*) as defined by you below
;see examples below
class cFunc {
	add(a, b) {	;match declaration with what is in the DllCall and what is in the C function
		return 	DllCall(A_ScriptDir "\cFunc.dll\" SubStr(A_ThisFunc, InStr(A_ThisFunc, ".", -1) + 1)
						, "Int", a							
						, "Int", b
						, "Int"
				)
	}
	
	mul(a, b) {	;match declaration with what is in the DllCall and what is in the C function
		return 	DllCall(A_ScriptDir "\cFunc.dll\" SubStr(A_ThisFunc, InStr(A_ThisFunc, ".", -1) + 1)
						, "Int", a							
						, "Int", b
						, "Int"
				)
	}
	
	arr(arrPtr) {	;match declaration with what is in the DllCall and what is in the C function
		return 	DllCall(A_ScriptDir "\cFunc.dll\" SubStr(A_ThisFunc, InStr(A_ThisFunc, ".", -1) + 1)
						, "Ptr", arrPtr
						, "Int"
				)
	}
	
	hello() {	;match declaration with what is in the DllCall and what is in the C function
		return 	DllCall(A_ScriptDir "\cFunc.dll\" SubStr(A_ThisFunc, InStr(A_ThisFunc, ".", -1) + 1)
						, "AStr"
				)
	}
	;==========================================================================================================
	/* C function start ---------------------------------------------------------------------------------------

	int add(int a, int b) __attribute__ ((dllexport))	//we need dllexport attribute for each function
	{
		return a + b;
	}
	
	int mul(int a, int b) __attribute__ ((dllexport))	//we need dllexport attribute for each function
	{
		return a * b;
	}
	
	int arr(int a[])  __attribute__ ((dllexport))
	{
		for(int i = 0; i < 5; i++){
			a[i] = (i + 1) * 10;
		}
		return 0;
	}
	
	char * hello(void)  __attribute__ ((dllexport))
	{
		return "Hello world!";
	}

	*/ ; C function end ---------------------------------------------------------------------------------------
	;==========================================================================================================
	
}

;unpack Tiny C Compiler's libtcc.dll and needed files 
;compile c code to dll, load it, and then cleanup afterwards
cCode() {
	global doc
	doc.unpack(doc.jso.file[1], A_ScriptDir)	;unpacks libtcc.dll
	doc.unpack(doc.jso.file[2], A_ScriptDir)	;unpacks libtcc1-64.a
	
	script := fileRead(A_ScriptFullPath)
	startLabel := "/*"    " C" " function" " start"
	endLabel   := "*/ `;" " C" " function" " end"
	cStart := InStr(script, "`n", , InStr(script, startLabel))
	cEnd   := InStr(script, endLabel)
	
	;LIBTCC calls to generate DLL
	progStr := SubStr(script, cStart, cEnd - cStart)
	hModule := DllCall("LoadLibrary", "Str", A_ScriptDir "\libtcc.dll", "Ptr") 
	Context := DllCall("libtcc\tcc_new", "Ptr")

	StrPutVar(A_ScriptDir, tcclibpath)
	DllCall("libtcc\tcc_add_library_path", "Ptr", Context, "Str", tcclibpath)

	TCC_OUTPUT_MEMORY       := 1 ; output will be run in memory (default)
	TCC_OUTPUT_EXE          := 2 ; executable file
	TCC_OUTPUT_DLL          := 3 ; dynamic library
	TCC_OUTPUT_OBJ          := 4 ; object file
	TCC_OUTPUT_PREPROCESS   := 5 ; only preprocess (used internally)
	DllCall("libtcc\tcc_set_output_type", "Ptr", Context, "UInt", TCC_OUTPUT_DLL)

	StrPutVar(progStr, prog)
	DllCall("libtcc\tcc_compile_string", "Ptr", Context, "Str", prog, "UInt")

	filedelete(A_ScriptDir "\cFunc.dll")	;remove old copy
	StrPutVar("cFunc.dll", filename)
	DllCall("libtcc\tcc_output_file", "Ptr", Context, "Str", filename)
	
	DllCall("libtcc\tcc_delete", "Ptr", Context)
	DllCall("FreeLibrary", "Ptr", hModule)
	onExit("cleanUp")
	
	;StrPutVar ehlper function straight from the v2 docs
	StrPutVar(string, ByRef var, encoding := "cp0") {    
		VarSetCapacity(var, StrPut(string, encoding) * ((encoding="utf-16"||encoding="cp1200") ? 2 : 1) )
		return StrPut(string, &var, encoding)
	}
	
	;delete temporary files we extracted/created
	cleanUp() {
		filedelete(A_ScriptDir "\libtcc1-64.a")
		filedelete(A_ScriptDir "\cFunc.dll")
		filedelete(A_ScriptDir "\cFunc.def")
		filedelete(A_ScriptDir "\libtcc.dll")
	}

}

;----------------------------------------------------------------------------------------------
;by oif2003 on 19 Nov 2018, written for AutoHotkey v2 a100
;----------------------------------------------------------------------------------------------
;Basic json class, call json(x) to convert between json string and ahk Object
;Note: proper json escape sequences have not been implmented, this version only
;escapes `" (escaped double quote, AHK style)
;----------------------------------------------------------------------------------------------
json(x)=>json.auto(x)	;if x is an object it returns a json string and vice versa
;----------------------------------------------------------------------------------------------
;This json converter operates as follows:
;	If given a json string:
;	1)	Replace all string literals with serialized tokens
;	2) 	Convert json string to ahk function string consisting of array(...) and object(...)
;	3)	Replace tokens with original strings
;	4)	Evaluate the ahk function expression string and return the resulting object
;	
;	If given an ahk object:
;	1)	Recursively print output using obj2str
;	2)	isNumber and isArray are used to determine the format of the output (numbers are not quoted
;		and arrays sit inside brackets inside of braces)
;	
class json {
	;auto input parser json string <=> ahk object
	auto(input) {
		if IsObject(input) {
			return this.obj2str(input)
		} else {
			return this.str2obj(input)
		}
	}
	
	;------------------------------------------------------------------------------------------
	;convert object to json string
	obj2str(obj, firstRun := true) {
		static output := ""
		static level := 0
		static noTab := false
		if firstRun {
			output := ""
		}
		
		if isObject(obj) {
			if obj.Count() {
				if isArray(obj) {	;if this is an array (based on A_Index == key)
					output .= (noTab ? "" : tabs(level)) "[`n"
					level++
					noTab := false
					for k, v in obj {
						this.obj2str(v, false)
						output .= (k != obj.Count() ? "," : "") "`n"
					}
					output .= tabs(--level) "]"
				} else {	;otherwise output as object
					output .= (noTab ? "" : tabs(level)) "{`n"
					level++
					noTab := false
					for k, v in obj {
						output .= tabs(level) '"' k '": '
						noTab := true
						this.obj2str(v,  false)
						noTab := false
						output .= (A_Index != obj.Count() ? "," : "") "`n"
					}
					output .= tabs(--level) "}"
				}
			} else {
				output .= "[]"
			}
		} else {
			if obj == "" {
				obj := "null"
			} else if !(obj is "Number") || !isNumber(obj) {	;don't put quotes around numbers
				obj := '"' obj '"'
			}
			output .= (noTab ? "" : tabs(level)) obj
		}
		
		return output
		
		isNumber(x) {	;quickly and dirty check.  Other ideas: use is Type first then do this
			return NumGet(&x, "UInt")   == x 
				|| NumGet(&x, "Int")    == x || NumGet(&x, "Int64") == x 
				|| NumGet(&x, "Double") == x || NumGet(&x, "Float") == x 
				|| NumGet(&x, "Ptr")    == x || NumGet(&x, "UPtr") == x
				|| NumGet(&x, "Short")  == x || NumGet(&x, "UShort") == x 
				|| NumGet(&x, "Char")   == x || NumGet(&x, "UChar") == x 
		}
		
		isArray(arr) {	;another quick and dirty check: A_Index == Current Key ?
			if !IsObject(arr) {
				return false
			} else {
				for k, v in arr {
					if k != A_Index {
						return false
					}
				}
				return true
			}
		}
		
		tabs(n) {	;create tab string
			loop n {
				tab .= "`t"
			}
			return tab
		}
	}

	;------------------------------------------------------------------------------------------
	;covert json string to ahk function string then feed it thru the function parser
	str2obj(jstr) {
		funcStr := this.jstr2func(jstr)
		o := json.funcParser(strreplace(funcstr, '"'))
		return o
	}
	
	;recursively evaluate the function string
	funcParser(funcStr) {
		paren := InStr(funcStr, "(")
		if paren {
			innerStr := SubStr(funcStr, paren + 1, -1)
			parenCount := 0
			argStart := 1
			args := []
			loop parse innerStr {
				if A_LoopField == "(" {
					parenCount++
				} else if A_LoopField == ")" {
					parenCount--
				}
				
				if !parenCount && A_LoopField == "," {
					args.push(SubStr(innerStr, argStart, A_Index - argStart))
					argStart := A_Index + 1
				} else if A_Index == StrLen(innerStr) {
					args.push(SubStr(innerStr, argStart, A_Index - argStart + 1))
				}
			}
			
			for k, v in args {
				args[k] := this.funcParser(v)
			}

			return func(SubStr(funcStr, 1, paren - 1)).Call(args*)
		} else {
			this.restoreString(funcStr, this.dictionary)	;replace string tokens with their originals
			if funcStr is "Number" {
				return funcStr + 0
			} else {
				if funcStr == "null" {
					return
				} else if funcStr == "true" {
					return true
				} else if funcStr == "false" {
					return false
				} else if SubStr(funcStr, 1, 1) == '"' && SubStr(funcStr, -1, 1) == '"' {
					funcStr := SubStr(funcStr, 2, -1)	;remove quotation marks on strings
					return funcStr
				} else {
					return "Unhandled exception, check " A_ScriptName ", " A_ThisFunc ", " A_LineNumber
				}
			}
		}
	}

	;convert json string to function string in ahk. namely, arrary() and object()
	jstr2func(jstr, firstRun := true) {
		static tokenBase := 0x1abf - 1
		static commaToken := Chr(tokenBase + 1)
		static colonToken := Chr(tokenBase + 2)
		
		if firstRun {
			this.dictionary := this.tokenizeString(jstr)
			jstr := StrReplace(jstr, "`n")				;remove newline, tab, and space
			jstr := StrReplace(jstr, "`r")
			jstr := StrReplace(jstr, "`t")
			jstr := StrReplace(jstr, " ")
		}
			
		if !InStr(jstr, "[") && !InStr(jstr, "{") {
			return jstr
		} else {
			inner := findInnerMost(jstr)
			innerStr := SubStr(jstr, inner[1], inner[2] - inner[1] + 1)
			jstr := SubStr(jstr, 1, inner[1] - 1) str2func(innerStr) SubStr(jstr, inner[2] + 1)
			jstr := this.jstr2func(jstr, firstRun := false)
			
			return jstr
		}
		
		str2func(str) {		;convert string to function
			brace := InStr(str, "{")
			brack := InStr(str, "[")
			if brack {
				
				funcStr := 'Array('
				funcStrArr := StrSplit(SubStr(str, 2, -1), commaToken)
				for k, v in funcStrArr {
					funcStr .= str2func(v) (k != funcStrArr.Length() ? "," : "")
				}
				funcStr .= ")"
			} else if brace {
				funcStr := 'Object(' StrReplace(SubStr(str, 2), "}", ")") 		
				funcStr := StrReplace(funcStr, ':', ',')
			} else {
				return str
			}
			return funcStr
		}
		
		findInnerMost(str) {	;find innermost object/array
			braceCount := brackCount := maxCount := maxStart := maxEnd := 0

			loop parse str {
				if 			A_LoopField == "{" {
					braceCount++
				} else if 	A_LoopField == "}" {
					braceCount--
				} else if 	A_LoopField == "[" {
					brackCount++
				} else if 	A_LoopField == "]" {
					brackCount--
				}
				
				if braceCount + brackCount > maxCount {						;Find max cumulative count of [ and {
					maxCount := braceCount + brackCount
					maxStart := A_Index										;Update max [ / { location
					closing := SubStr(str, A_Index, 1) == "[" ? "]" : "}"
					maxEnd := InStr(str, closing, , A_Index)				;update where it ends
				}
			}
			return [maxStart, maxEnd]
		}
	}
	
	;------------------------------------------------------------------------------------------
	;helper methods
	restoreString(ByRef str, dictionary) {
		static tokenBase := 0x1abf - 1
		static strToken  := Chr(tokenBase + 3)
		static escapedQuote := Chr(tokenBase + 4)
		for k, v in dictionary {
			str := StrReplace(str, strToken k strToken, v, , 1)
		}
		str := StrReplace(str, escapedQuote, '"')
	}

	tokenizeString(ByRef str) {
		static tokenBase := 0x1abf - 1
		static strToken  := Chr(tokenBase + 3)
		static escapedQuote := Chr(tokenBase + 4)
		
		quoteCount :=  quoteStart := 0
		dictionary := []
		
		str := StrReplace(str, '``"', escapedQuote)
		
		loop parse str {
			if A_LoopField == '"' {
				quoteCount++

				if Mod(quoteCount, 2) {
					quoteStart := A_Index
				} else {
					quoteEnd := A_Index
					dictionary.push(SubStr(str, quoteStart, quoteEnd - quoteStart + 1))
				}
			}
		}
		
		for k, v in dictionary {
			str := StrReplace(str, v, strToken k strToken, , 1)
		}
		return dictionary
	}
}



;----------------------------------------------------------------------------------------------
;by oif2003 on 20 Nov 2018, written for AutoHotkey v2 a100
;----------------------------------------------------------------------------------------------
;Compress/Decompress file and converts them from binary to string so they can be stored as
;plaintext inside a script file.  This class will autoload the json object at the end of 
;this file to doc.jso.  On exit, it will save to the same string automatically (provided you
;don't crash out, of course.
;	Methods: savejson, loadjson
class document {
	static label := "/* json" " " "attachements"
	static script
	
	__New() {
		global doc
		static init := new document()
		if init {
			return init
		}
		this.jso:= this.loadjson()
		if !isObject(this.jso)
			this.jso := {}
		;onExit(()=>this.savejson())
		doc := this
	}
	
	savejson() {	;dumps the current doc.jso object into json string and saves it
		this.script := SubStr(this.script, 1, InStr(this.script, this.label) - 1)
		this.script := this.script this.label "`n" json(this.jso) 
		FileOpen(A_ScriptFullPath, "w").Write(this.script)
	}
	
	loadjson() {	;loads the json string at the end of this file
		this.script := FileRead(A_ScriptFullPath)
		jstr := SubStr(this.script, InStr(this.script, this.label, true, -1) + StrLen(this.label) + 1)
		return json(jstr)
	}

	unpack(jsoFile, target) {	;jsoFile is a file object stored inside doc.jso
								;target can be file or directory
		cryptString := jsoFile.8_data	;str is doc.jso.file[n].8_data 
		
		;https://docs.microsoft.com/en-us/windows/desktop/api/compressapi/nf-compressapi-createcompressor
		COMPRESS_ALGORITHM_MSZIP        := 2    ;MSZIP compression algorithm
		COMPRESS_ALGORITHM_XPRESS       := 3 	;XPRESS compression algorithm 
		COMPRESS_ALGORITHM_XPRESS_HUFF  := 4	;XPRESS compression algorithm with Huffman encoding
		COMPRESS_ALGORITHM_LZMS         := 5	;LZMS compression algorithm
		
		;first call to get buffer size
		DllCall("crypt32\CryptStringToBinary"
		   , "str", cryptString	            ;pszString
		   , "uint", 0			            ;cchString
		   , "uint", 1			            ;dwFlags
		   , "ptr", 0		    	        ;pbBinary
		   , "uint*", s	    	            ;pcbBinary
		   , "ptr", 0			            ;pdwSkip
		   , "ptr", 0			            ;pdwFlags
		)

		;set buffer size based on previous call (*2 for UTF)
		VarSetCapacity(buffer, s*2)
		DllCall("crypt32\CryptStringToBinary"
		   , "str", cryptString	            ;pszString
		   , "uint", 0			            ;cchString
		   , "uint", 1			            ;dwFlags
		   , "ptr", &buffer	    	        ;pbBinary
		   , "uint*", s	    	            ;pcbBinary
		   , "ptr", 0			            ;pdwSkip
		   , "ptr", 0			            ;pdwFlags
		)

		;Create Decompressor Handle
		DllCall("Cabinet.dll\CreateDecompressor"
		  , "UInt", COMPRESS_ALGORITHM_LZMS	    ;Algorithm,
		  , "Ptr",  0		                    ;AllocationRoutines,
		  , "Ptr*", dHandle                     ;CompressorHandle
		)

		size := s
		;first call to get buffer size (s)
		DllCall("Cabinet.dll\Decompress"
		  ,"Ptr", dHandle                   ;DecompressorHandle,
		  ,"Ptr", &buffer                   ;CompressedData,
		  ,"UInt", size                     ;CompressedDataSize,
		  ,"Ptr", &dBuffer                  ;UncompressedBuffer,
		  ,"UInt", 0                        ;UncompressedBufferSize,
		  ,"UInt*", s                       ;UncompressedDataSize
		)

		;set buffer size based on previous call
		_s := VarSetCapacity(dBuffer, s)
		DllCall("Cabinet.dll\Decompress"
		  ,"Ptr", dHandle                   ;DecompressorHandle,
		  ,"Ptr", &buffer                   ;CompressedData,
		  ,"UInt", size                     ;CompressedDataSize,
		  ,"Ptr", &dBuffer                  ;UncompressedBuffer,
		  ,"UInt", _s                       ;UncompressedBufferSize,
		  ,"UInt*", s                       ;UncompressedDataSize
		)

		DllCall("Cabinet.dll\CloseDecompressor", "Ptr", dHandle)
		
		attribute := FileGetAttrib(target)
		if InStr(attribute, "D") {
			target .= "\" jsoFile.1_fileName
		}
		FileDelete(target)
		FileOpen(target, "w").RawWrite(dbuffer,s)
		
	}

	pack(file, description) {	; packs and compresses a file, it is then stored as plaintext
		size    := FileGetSize(file)
		sha256  := this.fileSHA256(file)
		dlltext := FileRead(file, "RAW")
		_size 	:= size
		
		;https://docs.microsoft.com/en-us/windows/desktop/api/compressapi/nf-compressapi-createcompressor
		COMPRESS_ALGORITHM_MSZIP        := 2    ;MSZIP compression algorithm
		COMPRESS_ALGORITHM_XPRESS       := 3 	;XPRESS compression algorithm 
		COMPRESS_ALGORITHM_XPRESS_HUFF  := 4	;XPRESS compression algorithm with Huffman encoding
		COMPRESS_ALGORITHM_LZMS         := 5	;LZMS compression algorithm

		DllCall("Cabinet.dll\CreateCompressor"
		  , "UInt", COMPRESS_ALGORITHM_LZMS	    ;Algorithm,
		  , "Ptr",  0		                    ;AllocationRoutines,
		  , "Ptr*", cHandle                     ;CompressorHandle
		)

		;https://docs.microsoft.com/en-us/windows/desktop/api/compressapi/nf-compressapi-compress
		;first call to get buffer size (s)
		DllCall("Cabinet.dll\Compress"
		  ,"Ptr", cHandle                   ;CompressorHandle,
		  ,"Ptr", &dlltext                  ;UncompressedData,
		  ,"UInt", size                     ;UncompressedDataSize,
		  ,"Ptr", &cBuffer                  ;CompressedBuffer,
		  ,"UInt", 0                        ;CompressedBufferSize,
		  ,"UInt*", s                       ;CompressedDataSize
		)

		;set buffer size based on previous call
		_s := VarSetCapacity(cBuffer, s)
		DllCall("Cabinet.dll\Compress"
		  ,"Ptr", cHandle                   ;CompressorHandle,
		  ,"Ptr", &dlltext                  ;UncompressedData,
		  ,"UInt", size                     ;UncompressedDataSize,
		  ,"Ptr", &cBuffer                  ;CompressedBuffer,
		  ,"UInt", _s                       ;CompressedBufferSize,
		  ,"UInt*", s                       ;CompressedDataSize
		)
		
		DllCall("Cabinet.dll\CloseCompressor", "Ptr", cHandle)

		size := s
		;https://docs.microsoft.com/en-us/windows/desktop/api/wincrypt/nf-wincrypt-cryptbinarytostringw
		;first call to find size (s) needed for our crypt string
		DllCall("crypt32\CryptBinaryToString"
		   , "Ptr", &cBuffer			    ;pbBinary   ptr to array of bytes
		   , "uint", size            	    ;cbBinary   length of array
		   , "uint", 1						;dwFlags    flags: 1 = 64 bit without headers
		   , "ptr", 0				        ;pszString  when this is 0, pccString returns needed size
		   , "uint*", s			            ;pccString
		)

		VarSetCapacity(cryptString, s := s * 2)     ;*2 for unicode
		;second call to get the actual string
		DllCall("crypt32\CryptBinaryToString"
		   , "Ptr", &cBuffer			    ;pbBinary   ptr to array of bytes
		   , "uint", size            	    ;cbBinary   length of array
		   , "uint", 1						;dwFlags    flags: 1 = 64 bit without headers
		   , "str", cryptString		        ;pszString  now this is ptr to buffer of string
		   , "uint*", s     		        ;pccString  size of buffer as previously determined
		)
		
		str .= cryptString
		SplitPath(file, fileName, dir)
		if !isObject(this.jso.file)
			this.jso.file := []
		this.jso.file.push({1_fileName:fileName, 4_uncompressedSize: _size
							, 3_compressedSize: size, 5_added: formattime(A_Now), 6_description:description
							, 2_dir:dir, 7_sha256:sha256, 8_data:str})
	}
	
	fileSHA256(file) {	;using CertUtil to get SHA256
		static cPid := 0
		if !cPid {
			_A_DetectHiddenWindows := A_DetectHiddenWindows
			A_DetectHiddenWindows := true
			Run(A_ComSpec " /k ",,"Hide", cPid)
			WinWait("ahk_pid" cPid,, 10)
			DllCall("AttachConsole","uint",cPid)
			A_DetectHiddenWindows := _A_DetectHiddenWindows
		}

		objShell := ComObjCreate("WScript.Shell")
		objExec := objShell.Exec('certutil -hashfile "' file '" SHA256')
		strStdOut:=strStdErr:=""
		while !objExec.StdOut.AtEndOfStream
			 strStdOut := objExec.StdOut.ReadAll()
		while !objExec.StdErr.AtEndOfStream
			 strStdErr := objExec.StdErr.ReadAll()

		r := strStdOut strStdErr
		SplitPath(file, fileName)
		RegExMatch(r, "(?<=" fileName ":)(.|`r|`n)*(?=CertUtil)", match)
		return match.Value(0)
	}
}

;===========================================================================================
/* json attachements
{
	"file": [
		{
			"1_fileName": "libtcc.dll",
			"2_dir": null,
			"3_compressedSize": 84960,
			"4_uncompressedSize": 156160,
			"5_added": "11:15 AM Tuesday, November 20, 2018",
			"6_description": "libtcc.dll for Tiny C Compiler",
			"7_sha256": "
e08569d34baf5c546c9a19c5e6d0b5993f196f41e5eaebb10e54c71b591092bc
",
			"8_data": "ClHlwBgAIQUAYgIAAAAAAAAAAQAAAAAAzpIAAJEp0wKkGpcShH6c5Fv8BTto1rYG
QNKeEac7qliWWeGIyWlPA+hBWEHqNyLuNbXDeJ7BX6jTBvgojGu6CNual7I3oY8a
955X/wye0WMnQjaiwsuxhd6rd7gqhJnYg71XVTPCIgI9Y2YSonj+kHIkFezMfHvV
dfLyhZcKn42OkSA8vTAiMWCvW41HrOqq3BXg1rV4b6qO0fYfGttpXs8UJ4c4NFVj
HLXisYojsrLvI9hCdLg0Wf0vwf7S8oX93hQ9zzFOwokx+0G342ihYkF/unR3hobM
V1OuSrOdroicOG1gZi2bqxlc38V4WvGZEFmS7FT0K6V1BUPw5R8PCX+jVHSoIlVR
iFH1rmTr2P8YLE6480R5bqNtkYWEbI0UEtMN8CtjCyQN5kl/omyGwy6DDi4brhUP
fpI/JBPfZrXeHxsZ9A59c5C1k6TA6ShaEYzoG7hUm3Bz1cbnSJ1GFljxJP9dXgxG
Y2gM6hAYFeQrXkvzqRjoMp15xGvPVoCMNzkIWXOZeWlV2ozuK0BkHk9X2cEB0Ceg
v7opJyAThJrTDMsRNlbHRGPv1ZNTuTWctiw6hwwlrc3jrEwxFdBwlcIIj+mCUJAl
VioeSzJX65/RqfCWiWmf/G6woZhG773YdRS3sNNdI8+moGv8Y+hlheu9XpBm+Abw
mV44Gq10wb+TYI86KFjZAfnwRRTCkwMIRHfKrd5ZNlkDSFmCwbzWiCXYSGX1KPsh
FNAVR1zD0M+dEcqm88Rx0X82PcjCTJgaufLJzaDvYQZ9sAVYnHN4CkyS5Kcxo8eG
Ognve2dlDTQCnaakTDi+3UNeLLSptB3MENznIExC1JXh44Ll13eUadhtdhbkqUmh
FENTBnKskYoB1qvnIZPWqqGXrK9xQ4Vr8dgL7OWTkMg+2qGk1ctkggnJHaBzBC+M
j6ScLwII5Ri6Q79puZtAqEyi3OEa9HERuKW5Woxi1oBJTtt/brZv7TtBHDyrcDLo
5HtLZ2F7mQCtGnyDwPotyPjOG815qKOoXE6LkIbsPsUu6hhKETZCQuPp32sd2e2K
kggl4fUu731rYZj4ZfQMahobubxId3tXfoSIE/xz5kt8UxIWI9+XqrUdMjLAQWzH
ZnBM9y2bIljN9FJZlnFN5e62MX0xW08hKOuD95rIc7JWv7z6njkeahOYlz9zk8Oa
J1+Qv4LBIRgDs7UZalS+dJNTmGwLZu+LtTeN1xO7ewxe9E/XSwue/WddF8N0c9DO
j11maF1M29rrFeWVOaozoi2WCdbym0mzd9JZ6GJiYhQGoZxHcoBxrIOrjSRAdE0f
txULVCwhVC4dfiy5WixoCS05b2DEK6Mmzh3fYWY2Li73mj8nw7wLz+5UGKdcMj0j
EDhSX36g7kMSrXCPEGhQ2A5DpShsCIg+GOyg2hbizpTTwz+DGGjwdmFHnm/m9xOb
LWwsGTW66JXwevlD3jySUTXAqbEjbe46z3VcvepvwzeAuAxwwia/YbqSJYWCtwIU
GwPFHahoh0I4cGfH+uIXOtBA1+nwyujy2phrls5vsWUOew2RrbUr1i3qBvZHm/od
INLz6Dyk5/irOmgwHnPQsIi30nePCcjncxP2cCX7ThIzNoLrTNBjXEiyyyd4niet
vM70avB6gK5xLvWFBQCBVRmguoAfh6ZI1fOGu07sAwHeASE1AW9vAplx0xiRWWmn
+zOAjBu62eU7VfUHHouYsg8XKv3oW2zfassAN8+P0bFOFruZ3tSxVF5qpVVBdlGT
kk7+eSXwqmLI5kFE9jWI9BszgJScoVSl2klO4u8B4ON071Aw6b/7EmRuTxkyJyTw
BU4v0aw5yJcgiWHzKlF0IGntjm4OU6Ld79vkLbsb9CTGLQrqi1DT0X/uCmGQzQjm
eUwPeIznWvY/Y8XeJYSL/mOdAZ6Cmz2UZtH+tFUsRUSmmcNK8jrSzae0kSlafQdz
3SSBPibxDDjXdSwI4OyNpPspTYjH29+TcDmNOT7RlyReL8cge5WLW3Ij2fWLnhxx
dlO8bWtTjlRp+dlE/wW9qrgWG6EXwxSYerb3dzYlVketnd5Az9oy5th4OZIFd0nb
2yQ1aHmUMmXojkRwxlDWujNZ2gHbLjr5ZnPqlTtqxfClp8nDsCK+NbfAMwIDwt/6
JPQ33IzPlQrwwrL45g+ofxldPhKpWGwUXzEPBr7uBXJnZZiWD4HksIffe8CG1jl2
oWyTLEx1i+VX2qm62VG50rWo+aWtrWi3S9xovu7AZb1NAaA2ixxPjlM4x61GHg1q
CvHy32qP+JPcDpSnj7zjgHGMXpgN4yb47ZpOPPJah60tX4tvemaX5PXMGYDfdEEN
ms05ZHu7k5nTzN/sXWoCrxdcJ2Jb4yRtZbq4vTq9HpfPqKLgdotf5+HQZ3KYiNN2
KFnCtN1ouPWsE60lJDxYP4+Ubmyg/M64Ectq3Fw1CqCar8iBnr0nPYVeOpGWeGbU
h9l9eS/aGgZpOr2FIsX4il+1wtju7pw0jebHFWreJx36fEmlsZIbTRi+w2lTiRC3
y3BjclRj3rN2wJqRlAXA/Xn8Ry+ZW5OXFWgBEdIKpwZCGqiBgdDKz91fNmurbu4Y
q7yBvCSesqz2w+IG81KcAwauMPUnLXqRdqNq7LB17fmvUrOKWsEC0B1jDKRUWy9s
Cp+RbPj12aedC6lvd55JdU/8P2gN26y+nwsNrWNvTOOMicSo/CEyLMqaAcsQD55e
OI6X6kQTuwkvxA5YMtPwezx5bG3s9PefA9AHP+OEvb9fcRJ8uHSlDUw5ZdU4FUGQ
+Gr/A1KXcqULpNw9Bte+85Oy2LRbhdUn+E31+EQNfB/Mm8ZeWd8jDFxSvWZiSMeH
sUvpnah6NXIauZ4cPhgVIorO7wFvj2yyGXITMMS9TLA0iRPPdt4CQ/2BMISy+S8n
ECRZ3FhO0F+XKRUYTSazSPX5DYH4cUSmiJ5q8hKGznxfkRsHcbwM0csWIsrUjNUj
t2CbLyDi2jeSp9glNJcE9BbwqPIGkcS4Nl+5OtbqcWYv/BtU26l2VoZQcIPBj8mI
Wp2cSutlC9cleCW8e7iru3+DX6R/th3OTVuo3I0czGO3PKhc6AqdRN8G/34eK1Iz
w6Ma4uc4ysSkP/iZZcYprdumMGoZPVsQuIANfqoTpJSHo4cNce/8SIvDdWQaGckj
C+BDt7Bum0EO6wsFG80WMicio/Gi+zqUTGkTODkVMovHIRv0vObLY6hKS63V/H/b
1fXPP1h9htOSb8+U5yXaumlGTAhVxY0r26ZkemivC9Bp9Le4BBK/xRZkFPm1sj5P
Dp9RC/5o/+1yT/ERznrXHHuDbkLoodWPc09spW0XU25VbJiIOINbSFscTWWOSgA2
PXKtjegT52uXXD/K9GaAPQqJDFJNg8smBpxJukMHsEUC46pyap8sXnyUEQEEGnID
RdhN6ZEgC3ysdlB7GNQMErx7Pez7FibLfFEoQnj41+5YL4H9cdkGneG7clEWGaAq
dvXWxz1QNh3S2U5whyIvoblPufztYUbw72pwttjlKksn3008sk9emm03iPe2bFux
aF6r7vSgYu5/OVmeCzQQ2FLGYCqfA0b9r5HyTwbRxJtdmbptxenzifclY274gRbg
H+jz8hy2CPvEXkQCxahmTUlRdoxEfYvdWx5/OvuoMbYbc4xZEiA6UmK4Yb37DCBz
HIe7nhN2IVXVXCcazKxwb/u3LSuVLeaRtKYT16ZnIW28tUOl2YK0XeMKtD4tPdsa
QmS0TSa+Clw6VLConOzaNmA37SYZDA50LCQdx4fBDIxu+3MhGbX5dYeT1TO9X4Ct
4zri9A4rhTHRi3vptJboEemTbIC4KHV6xpsgGf6C8gcIE4sNOPrqcwp8auQ3/3+o
tZMlnxutStQjfwM7yi5vaM5UDquSiVxE6dobtvSP9cObf02U2NuHMw9VHNfZOB5s
w86AtPCqgoY9N5SW/19XD4nyln+TySg1pivuNAE4zqzMIHbTJYb7ECitjXe+zdq/
gW9tHsfz/6ICZXrwEwXqKo5gbzWkp63wy+GtdHHPPNL3QSYD9mLoVlYMli84eQEu
yGq/NIsAqzeq0ANJh4bOWUcZyVFsWDq2z0v1l+gSAouqSkGEnPZ1zC5/N0knWOWY
UnwgHyy1YwZU6+f2FbhKL6tJB0pWoAuoDT+beQuFqlOfFCuXZ/jM9kbh/8AbN4Ts
O7urPZMDsJAsjOBG0yITOOukHX4wB4illKGxkX/MNCHcVQ3VJAPju3UyCCEMTbpw
39jTON5Y3X5itbArI2b4KH2hThZ86RKVqMHFJeg7M8d5m0CfGWQfa7mIFDIUbpOZ
EE1FxeYyL3ytIzvyCwN6VrxD+n6Hm1o94Ocy2ZimN/iOQwy2VwOeeDCfYfgkcgqP
DV6Bj5KoMIP0bqWAeoTs5DK8hoZAqmNUUetyhRNCwOzOZIh5+okley2OGhtJ8eE3
HY9JVL2PV7cHgyF+tXDkzY15aXr0cjVDTwzO3d/afQuMRdW6v2DOLQydp6oH+Mm8
3YJotb3WRaL5vM0efBZpA52Zrg3zOODtBFiOTTyPJptBFT9VexfEwxFzPYvX7smm
xhO8drnHSQTc14cfTohfrLrTMbRikCQfkZNgcGpy1cVReP8H0d8CPAImAZPIJetl
GD48gRyU1xWqhOVe+s1gL1MYdhwRrJogCam41D2JgnRPYJQ+rc9adxAm87pocjAH
4syr61Lklqm3DjjEkSVSHgW2AbolPXyZ80ciLQprv7nDJf996OKcpehSn+ZFkW0k
DeVTa6fAomhxTQdcJazgKGxz9sX6gqgGCyDLEuJZ+uIsHEIQmUws66vnoGhjXr9F
bHqCn8DkY8NDHj777QvLJTeDOwTLfEk8F0UI2kiCtudDJPbMNq0DGxQgKQ+bF10p
re4YKTOqz8Cy8O4jFWRtZ7b8sQVg43oqwjlp4BifiNgUryv+FKGQR2Olv7buKGbS
sauLdmP/Br5MkHRayBgaZt7SEqBnxk6Kon3fwZIxyatWyh5PReHDFPp/aY1lXomp
V0phRduaG8W/lOIgNIBqgyNzrEBWWSz+g/PVNUHgkdCRrI+bUxHTdLgQ2kyBqFba
WQc9mUnATQX37wUzd+qgrbrmpD+EVVHbAs2cXhg3nIExPLg/mo53pnuJERyuONJn
uaeSL871DiI7zPlKnp3GszopH7agZEktLvwWtu8bxDunW5UJU4En4ai2Sbr+PCbQ
hJmAGIhIWxk86rF8wfKbXXoB+AALDNi9dJzPoLCLQUmbvUn2fv0AAAAAfUSCWBOw
iJqksIlq2i/RnBgeZoVEjScGasmcDObL4LVx2W5Xmtjcs2O0E8Lk8gPfQPxKy5wv
1MPyYMZ2ojkg0Qo52NhPOKxSvlUuBspQ/3LRPIGWyzAXRlhGKdBwpCHfsKcOoSbk
41kDInPX9hltVDYHZ/mjK0nlGXh9ElyyxM8q/U4ZQVVlQYn+WitUQt21OWuXXqfY
+MllE2cvuEbAnyAP6+5JDZrASO4AHCDCskfhInJRatlqVKFI/21+z5XmwfzqZu+4
4KpsC5+u1IL6OyA7VRVAUbOTSAWUiAGYqM7WLLxI+KaasFEpHNV2RfRx9gPG0emn
2jYEDzPIzR9XwOW7r4ljBF1hAtaaapF1d9zTU9XIbOZ9/1sT3qN1Y7h9dstnlPEO
1Kb+XVccedes1Ujz81mGW/6AUGxHHkq5QdSBJ0YO4XXebp7tLlh2B+8uSjvAu3tv
S8i4D0jld+Oov/q/UfXVn5OZrhEwn9fO4BAehsyDfw08edNFQTgpJNyDJv+VKUaF
7TgRvIllqjMeR+ik0MrHJDtvWXr/l7UsJRa/2Lt0QLlxf53tH0Xh99XR11rtQxdc
vMeGWxKxrK2iSsJqjONNNNvutaCwy72DrWODeniDnOM+Y0Z4xT9DpHvCCnRnNq7E
YlKZfzRx47j0HbyCPWNc5WpXDVroyytDooHjWHSTRvWceaXy0bQQqxT7ayykDIyI
to1wRt3AsZzZtF+lmzPj/vKQFHt8XQ04wix9jGyrUjgPldzY3e1cN5SZA5FWcPb5
wnlks83DzqEl3APnhd9W5OcRWFaA1RhwlRZRN5MdKUNX0ZQsD/OolgYT2+QMVUiG
3YKNRBkli0fE3KQFf81YEhpKm0ADmLOjo3QYjDY9SfR1sVPKVrE2oavBKrwW3iYC
gnE52PswrX3wE7j78ddDactaS38w68Bd/+IQXmoY2lB+mXbIJ0sFcxctW9PAddtd
z1Q3NhmcLE7d7XvcvBcYUc42uz5I04vdGytlA+5GRP+QImn/LwZ9uU4MOnZDAJOf
CyuHCjm//O0cj1US4H+YJP0Gfj0bRBlFxrzmuVosBofhwAjGsr1HpVwTaszOKkQn
6aEutKyChPxGYb+vTZHQJ5yB4SwcOMF5yq+uZDTYbnWbMqddgI7p+e0zH3qWVi88
AKsvlzeM7+L7cwuEb1aW99dYUY16BqoVt952mUYo/OGhInr5NcQc9qyoAs03F+oa
y6ddnUziVGtmE81LofT3nYZqAa/VladIKQdIFIfUauQmB3viSppLlSu+VSxm6RyP
xVuQdh+r+oYOq/a3E/xXQpsM9XLpLywma+nP7vfVGLqM/2Hq6ZO7pUptUpz642r9
RhxaiIYj51t0U0zQR7SB0giw91zp2cZiqfwa5dGTFkaoRrjo6hTa1A5nAJlI5vRf
dZ3U0ktYmS55lhV5zWm9cy1T45pLivq1XBSOQ1K7SrjQZbJE2iRtLLEYfsN/wMJ9
5w8sHNB2U5vTUjJVF41tKu0an69D+8x3KwW1wRBxc7Ih1DXmndvrU0O12O+lJad6
ZDmsJPlU7RAIdQpNircL+E/VYjGSLczfgtk7jisWyYnhquIvlQTFgvFcmkgrno3g
2wB2VUsXcM4ZjKuNF7w8bf+KuHhWHkgR7KoYWUhgBCy4oKTSCzkwcBXl9RKPEJIy
an1QiFyCr1R4Cv1zC+9LDv6Ta/1FiXy2DllhALd/mFx7pdK+SCEebjDhQWwEGF4r
OBGOCDMBjvip7FvCQdz4DYryzEIg56PfQJVwcyVuDah17uY7rwjg5gvoAkdywO5c
029mFUAJfkpEl/8g4NXt0DKJ+IHJ8EGJzcjPVepbwHhPGCBooFhQURUoHEkUdmEd
7A27lZ3fjUhS/UydGJWEkF+9szy608T9HXP/7YFQpXqEd9gsIB7MdmCw4f9pS9PF
85FouwSMe8HaONUB9teiLjlJCIEqdGxE+DR8yYQ2qkUIM+3HrxHYkuQlOamZvWQr
ygXtMwY4UkwbXWdN4dHHdAL+f4cIwfShVtktjXYU0E1CE9o55fXBl2TBP05T6uQH
sBGdFUUyRrfoJm44BJXQTqhn1GTRSpt0cn9SimPtCtUDUYog4p2oQIBPgkbPuxFz
LfmAUMm8PswzCGpZwQXgRxxRZd5vVymLZlOJr1cCLQlYqzAvGiWthlhb7F3fdINr
PtVI3RzAgyPYriLljiHfUEXD4fiz2VstdC32FOreUhmouh1rYXO3s4qIEdIYGcpn
hB/I2PTbcOCjPVQLx6oXAsBn9tEB7B58yQNsiP3xx/hB02i0Gzv0mwjJ70WF8Lgs
z+/rEXv3zrXlU7zstgIrWyABnhu5yFaBJlNI4xi4HfeHmP0wpY9XBEGTvCjcgXfD
UCTUX2ao9m/b69ZZDW/urPxfq6I/Krr+lx38HW7kqFU0XjbX64//VmN76yo4brL/
KUvslRN1rxeUCub+qhhtE8Rop9dpAzcvOzCRKK6kZpNf+Lrrs90QDIMEPhrRUYxC
bsMM+CBq0xq2uZ3f3M9t7bc2pI8pfeF3uRT2goLUwz3L/6JUf77soiaHxN8fAAbx
KztNzOKbilbRg/t/H4ZG2ucJ03ZdePcu2YMB57XVbKvFLfVIdO6TwfSBXNpHRrEf
e8DHyCGCfWh2q1nUBnsk/Jn2Qr4S0DVi722bD5/OEfDLN3h8kE34Tyjn7PSx8Nnr
GJ9Q6fjD+BPwJfgc6qBABGgmT4br2mjgWzgCIcVw6XiAeA5JBUykbz5x2gf9edu0
PxWBxv0Yr0++8sVviPU2w7qN7Kr9PhdpV5pVm45fjFeEb8CwJRgQp/IO4iAN0zs+
XIRzYvUyktpXeAVWBcA0VQLIsX1CBUtmVEVhxiJamZjCbFhAt2HStrR7250aWO0u
eonUhGVQrLszeJD28ItSfaY+f+y0zDs1d+fN+H3gRvZvDoslthJevOwvEli4lrSf
A3iXXxb7p1Ur4JrQst/yrDa0pCKMqkCRRucpaz61lT98QqLOgrJQt3Ti70tTsiWK
kIC4X0zwwVDx8esc/gR3gg5FohGbf4jW+87Jjh6eHlKNCurCAkEdxjPoTmJTWrVe
wLNYJN6zIuVCHwbvMG/R8T8XHVdgDUKTshpfDHor8BaMsyD+N3c7m4C3sf/u3kbc
Qwvl6tnoWcZhEeN06IguQX14zXRf8d45Hs7jRhd6DwNgNQwm8FZLe2kT95qOrDOK
8b5sM3jxWhZ5NhGMEd1aIqppRt4nw5wmB4LRu4OG1LjyLKjgHJEHpV9NBiNnoZ41
o147iT8D8XO79H0RTZVjNp3zVL2/4b4sQ3BMNr8enmjLZI8QL0z3TJ4TfLZu5oTu
vVDolfTmbTgWLnngW5YcIgvdjdN8bNSfPA9tVhPG0Sr/QaAIuugPJzpktjohAppD
yR0cUJEvpYLYN4g+wCT6/heWeURPXvhoVGjWe8Ha4tfQs1/GdqCnLta6PzeP2s5z
XxmHeIM7uR+cvexjmFYF62z5YAui9B4HUndoTk8QCSSyWZyB2p01GVAi1wL8pLku
lD49pGnB7/CF7/H/gZvLAy9F1lZoZL8O4cRGn+L1S22dDSsFbKZvoCyV1FBfcdBM
yOXE1qvmV3wi8eN5Sz1vJrZudXNi4574v+KDDxTZA7reGBWoZA/9IciSbeXdqR1k
lScM7uHa+EwOxfBxbLpOQ3Se2PTr79DScgM0S5uwUs4/EAjQkmzyfR0RmkJI8xri
bdvB34kc0uctAvHyRZFLliE08y7DpfCJwo2YmzAPlFlJeNzF6wkHPBhLw4YzJucX
hxmTNEpmJEiEW7cZz6DhHEoG20edwYYHkiP4MAMgXM/zsPvUpJSIyFKDSERWz474
EdCdxjPdUcKwKzDQp3iZu/RTB5Eok6Ivt/Ytqb2+FFb1HAr+14R4fOmrTFcWcTXC
9RSBlEAE+kp+mY885OKWqjQFEf5TDktefQ6LLLHmrYO4XnmFgwwKRb0ydMfATpMZ
lTQW4sEbgAg1WX9L1HK9THle/ORWyOP5rP7BNcgwo+pU4Yf17n6ggozETlEfNtk7
tYiA79m4Eca1qIeCTvUcmXoZrZP0NXHfJQBg/8zuBP5BaCH7KScpksJHelSrfHwp
cM9J1Zl7cbXkFx4suA2ACKd0Ffrvbi6pCpX0VxufSPzl24hvGGTwef2G+FF927cI
we+HIc7A8TljoP4swxceA7rtgOY2M8CuRDPwz2aL8nhkIGHR8WHW2110yGaG6BNk
PNr7uGh846mPbp9nS1Lf9eiDz2x6YI5D6zmB642PT7k+3G/mosObPnN2/PVDMb24
Kw739ZTHt7/LGMCvDeqFMmbM+friC+r7g3N8CPGboWrCvqU/j/J32U/u/muW6/ir
y4zzzk46DtV3Lruf1M7M+8TvjHbJ0uI63yMGTn2HfM3B60u+OX5JbmGGdSMHncid
DgCrnxO/G3O3bMdvP+ZQL2UdDEjzaKZJU/HrAcW3hLAma+4th1jvPvgdAT/lDLIE
StOAUC1cr+cOPgtDhAiFE91s9DMCtAlmFB2qGV98m/nje+lhJwC335Fh8502rq+t
9uGn6XoCU4MAqiogT5x/sN5qb8Q9NBawU1HiaUCpoB0qI2hABS7NtKaD5kYla1Dg
gJc/Q2WwdA8zoXc+as1ccCt55YAqqBKo+cYGEWQFNTstmttk4rFxh/c3bPnokHXK
O9SSWOVseW7N3F3ZKebvMLhz/0sP6tuWssmVWnoHAPgcrPLIlEGRB8mOULuXbnbi
wT6U7xDdgWAcptv7MTipWPYFw3tRhwCGZvXAMi9ofCo51PCQ2cMEIJKS1kjmgNsf
T78PzbQokX0MJ75agwMWdX7Bh+nNNLH7YhngIxonoMuM2/T8FtWemrE/zIq3fAeK
7twjAN+Y3nET8AWpP5vMZC1y7+T7uKwJLAqG5449rkqwxAXpQmp7vNBY/N0CI4Ix
LD/7LaULUBbq/Y217pcefPVnNhyknlYl/RSUvHhLzHtwrHFPNZ8yxQKOruQ44hlN
W9VxuHE2Cz2mxK0gFIvZBdMuvYM/O0fwBQMaRHr309Cls/gEmf7JkDqfL2AZn0Vf
6aqBLy4sBr7sgqMNXiWc+D/w/+C7ff2JCAD6ewGX58mpXJBjNgbyKlS/u/ragFuL
BZDvHlKos/44/OocprJzXRkZoru7+/0NiwXPMj4XGULH00T4fHLT+Hghnfz3d3if
MbAdK350Zxy3hcikKLmySXHgM6fsN2O7WWpMAN5ieWOyIeRbwUf7ITwXMEjr1AWY
h/rlx2rr4yrkjtBNI0gC1cbDL50erCXQcBwXADFAnlQIPr1o6Q9z8/vWc9k1FCRX
FcD7Y/lhbff+OTOA+HXnvJi3cW/kh8CiaSSY4MxhAnIqQ8MhWgPt0IDA0A9s6ufF
PT4TmfK4n1QQ/M+C3yGxHC38TnWNfiyfmVf7PLfXY4kGCJNoCLYvvcH6yXsAHdUQ
UetHAPiA8A699oue6J1dr5b8EOMgvCeiwXYSmkNkfjKz8Fk/s1pPjSrUX6Fhu7L+
EITM6lcjdz/j9MVPkXQM4JAVghAfcQ6/WCy6ZVcogFe4HTPXt5kKlikYeheD1U5w
QB/Jye9+T9SLMbWcNXyHsnnIVf8jwaqsvDptRqxoQNHBeXXpPTjB+Iyr9ffJryg0
Hg+3LntKRvBblv87E14gmNbBsIvQz1uuazUQt4FpvT7ZfHUl77TqtKj602/6KYzy
vnnMfnYNkXEatrnAZh98v66psU1jNW2NE5c3N/4uXidSSDRY+65EmjfeVbHfsLC9
WRjsrFWQjrgEtEk1eX/8F7PObuHH9sEJ8JuYHjtwRMB0fybpYxWkd+qpxVkuyp/q
7oCBZwyG/pGzjUSW2KHUD+hjDpWCv7mIKBvTcCc253m9+g5VdO+Ywt3VHomn8/uA
0CM/dx6/n8v/GoG+a0lwn+w+fCHyDhA+z0g7tc0izRhLOvwRMTnZTAJI+dCZDoUH
ndsyyVlAsGhysIZJdUJwbSEZGUkce7Q8yGylhJa9FgkdmvZX9u+VYTEJS9MD018e
F7/C/mVwjNtPhRMn4+g0UqLKXutSGaVAgX5/seFwd+QKYeffIpTINWVOokRzJhK8
eh0DkZJl2KyLLsUdhC9nTuvvzUjMLNYhVpKPSB3EyBjfFwt6FPlcAVwGYnl23Jrp
jHCCZQa0TSc6rOgeD2+3OLCx52HYhvCoHwwG9jImOd793PkK731QaCKv/956KbN5
e1+Wc+SNJ2nSbL5pTgaCFJkrEm5Q0oxLpAdhN5GkQj6brQWvRXgq1CntWXhIhhah
xON6uw+/dMIBwzd7UObdlyG4tvpAFUdRoLlhJt4+k9GiP+s5QeYscvzsOQSkD3zI
8dDdkUV68BOKAHfw8/1ZgRoJKykdWbEBjuvy5bM51yqeLjBH85lkwwzz0H6x3qOP
QDhstrAGpah96rY4CQCAd5uCGBDr1r1+CGftO4RF+N53v9H2muFPRSi/m8fY93Q1
oJtAokdROJglxUCDYlPBT0HEhUjF36Fn2xh+CRQk0scCcAy8YiaT8A8qayn9wyFS
K7dlc7CZnTQUDhlEtpD4QITzm+rAwURdqWpgGJ9zqdCO40tWMY8WT/1RXftK9wLx
tmznYdk6RZVY2iRVMQH1G7bzSHvxnpQqONomkFNDETLezu9gI8X3+GqvcWXitguX
RJqWhz/3g8IeOEhMiNm7vaj4MkIdW1uAa49J/lCDQ3xoeNpZ680a2wmeWLcb24Nv
8AHgj/UgB7DdfYXR34v+kRJ812SupuUW+CaUslBkAoAQMgU1c3B2EpMpfgK0/aC+
VJkmE+CQ/GiiNvrIKdRMbZDev/5AQe1xOiwmucQFKjR4i4lTZX9NeHdxmkOaWn/R
fHe+cY7oIKdig3KVQodQfBgHkCABHUdpuAlRzCiBzZawKcDfHWNyptXxCERxpKLZ
jbFKNAU2iD/8zgirS95xixcqdPPmAUWKpZmAog9LgLUiqz+lXJPs164pkJacyIvT
QEuS/17EZUYOihMcZKasCFH6X8+k+w4NE4PxyiR9Uv356lwDtl9TA9yfvmUCnemE
X8ziydqugn96rLCFE5QxTMiOjQ11O7kJ/a+9IZqGRTT7xWqSFm0+vbP5v7mHrOCF
zEc2uk++0xGL4avSv2dyjOFYXQCQUhf9qN61v531WZfAwBIOzOcT/seDBzyHJ87N
OqQTf5t21atyMceqCyHlPaGWtKcX8BDmtxbfhhg74KdLfFSPQ6CUNshoACKf/Xiz
T5SHWbLPqNistu77dxP3YeZdPESRfsI7TJu1ATIZX2MTH/tK8KJtk3zXznYGEAW0
PQnNOKh4WR47R+q3iYZlFKPRWpOKM0CpPSITpjH3Ubxm7qZiVoPUyripDzK0GG2l
l7uPadpuMeTxEtEcGVxgr4CiVPZHwtibOHEiDVtNT+TEdrz54whYA5g7bRRKpYjq
3gnHlOaYcA0UnoBokcCbSWI8hFYQbjVtbJ4roFB/CuQOgGCGFotKRqAv/E4EyrhJ
2LK64G3X/T/6sFwE8vxLpyHi6N7jYu4kcJ4c0NO3HT81V2g3a+39wrMdC7oHMBCE
/HWxMCn4Fn3c4KTmwCehdj+HvH+A1j6WAppngJ2TTvj2UQS+kRsNS6MzkenW336H
INm4P2oZ796hWfHPfPppomDDkC15E3PoLiCF2s/g6RS9Lp9h3U8jrIF3NmsBn7KI
wwOZU6gCo8MXOIYAbC4h8ioITXncAbD/Xj8D6CdsC38nrmhmJ8Esro5fv/3szhQG
CAQ9AUHxCwY2ZzRF/4DwUeGBqvj3EESUMAzGszsZ/XzmHOSDUHb6qIcVp3iERD1L
aQHmSnsNVXDWAMecuuscRjSFnHAitoHm/MRPFLQelXA4jn6zjiZkrjM6jHeVzGDI
jRaA5oTQdY5BIwHlBFjajkiL1K8KuZV3BDIf3H1y3g500Mc6d/797ZdmUn6ZSzhL
buW9bj/BfOgjn75/Ta0v3+5mk9+5izVorbDat5iihdYCrlmbsqWqts4I276onRnc
bEckDoyszGVtdjPh9F18REzGkVViU5F+TTuZN8aexBBwdVmms9qS4X6Clm8zPwJH
mP6OIFxE59xnezDrKuLv41nQtUkkX3rVGCB98ICrrP8elznezdNSWQq+HbH8YN5W
76bXq29ItwXAfxfRTlu3x13Z8F+39R7UoTSyafdPdzxSLWyx6Lg0bZ+KDFSt4LjV
/HpwX3Q36lDug+/dHSwBpp1XTKakOWXtxUxpL31dy1EadJC5YP1dcEKEG/BABT97
WqFLhZ3T/Qn4sIvvDy5OygMNX5ikNyvARjIyvdjFFDi4Quu+4ixMF6YDzWeff7uJ
D6wK/R+0BdY8uKC88lJZv+zi4od6MAf01Ii0xjwo+PNwSqkIHJW/daKqfjZEwwXv
1/S/ihmp/LSHPtSWQYnbxUmJktaJQe47b1Helh7F6w86xMqE2bnfOofYGVj5NbBm
/p6HZp3s3Up9WN/9dlKfkc2hzDKHaPndNx8bAytbWvqIBrmrbJy/runDHggKBHAf
EOvuB8aHZvQgqdncaa09/ADBOBfIPwvnBj6+/zSOVzcRNh0cVweBZLEohBszoRKh
ppOd+DDZaGmd9ZGq+HY4XTy1Mxhcs+pg5bXfeuM77hwzxT97tEsGbDX3OR5bzmeh
03WcKwLRaAdt/TlCbemHNTBFzX0SmpFZp3ywM2H7ke5gMotEJug+qGvYf3cuEIka
mRkmsB9wgecgx7rKB23OyUltxbmPoSl6l3qI9WgAM6GrkBQxdOmKjLk81TmL+u1o
U+sdvottzwS7G/IpbfhXWGGxSlFgeOU4NazCkW727+dcNRmk9qkiCPESqEmO8R/s
bFXgwt6vphTblT8scntzfxlzDekcGQRI8xbS+hrAEL464rwbiwNZAdLkLVLj0rHh
fWRVDBA91OHs3PZs2uteQ7Cjf3Whc4MZ/cKFwmCuk1sO5K8MpT6TW7FLTDjRmcyP
kGFKrDAgkwHRJux4XO8yXoTB7WgXlLPcKLk4J2oxur4vroCjuYyf4DN0cf3eFHVU
BvNkqkg1El+B6aq/Zu5K0Ff9tsL45P6oc+4hX1o+ZJv++rraRfSU18NVXgxhILFe
bCo5Wp7TX1u7MJP3DdnVQXfo0/rgr5u5Cq+CLhPOX9cv4X4NsB36Lzf9ax+kOtOZ
NZglPz94DB0ygrNoAOvQevUh1Nmh8xrNDHTYExgaN25SaBY6AycaQ+8R0AFtDRn6
dO49bD6w2ik/NCg4fY4Coq+T21V7r1h6jeQ1JE27n0K5oj+sEHDyBpkx//B4EAn1
bUMNqqjfHaiII76A2iW3yWSpv7XowxTUdx2FwU/JvF3990/9T8JlemViUWN7RHP+
Bl7nXFDEOVNC5QCBUxXfyk1CZtjCXQRmSobExgkwPVZqhXu0HQtlACFe8I6R5mGY
31Fud/o+iZkBWGoUf+0fRGO48mXt7F2o5l0bw8v0+NBQFU6Ie+iQp4FIYKP0Rivo
TGCcgB564E+NioYNbpjxU0HAM7Bi1xNlVT5UAsgxoITMmjhq3V10VDDJa4mnXmmj
W0fd71S6mzmtfL5NuB/F9WVqF+CXuz7evX7V4MgfIPSdBUIajXIQ3koRKafPBymE
mNERAsevWgHnJDvscoCCrD9WQzI7i0nGeK7Ngv+rUxEX7EQT1/u9v0txu71SHoLB
IgE9nB6jMmdzfQezp4RdqTOMR8xen8NYXpM7NRnVtMNQO7OWO+7m0rzoN+gPd6lV
vvBu4iG8brdNXYZ+aiOe8KF45ZL4eXg54Cehd1e0fxLL45QyzOQT1uDT+7AjhnGY
XRYOAtW743C9qvjEK3eObbnOdUEdvdIoj3iRShf+eYRo9dch94ar52mat4KHj8Ok
b3FXr2FTLs8NJxdRDiO4jAEZGOEwIlWgJMarAqNiceXsKAjkYz/JgsoI3s6rA7b3
ljzJykfa0Wsxf8PMofnwN4JHBtVV1SdGgYhbpcohp7uvj9hks6goKJ2KcfDdq1XB
NdeG93lRY3IoIRgew126nmnWOlpArSrP0XOgm1009f/BmN15GFPrNH2O5CIHaFMU
cf2cO2KQ3v7Gbd80TfeYTio2CW9D02LLsfSaOQuElkWdvohDuMVqNz7rr63Vem27
+T5BP+teHITQt111+yTMturisuquT3c8PuwmXZfzNzGJ3q+Lj1ZgEOYZSfk8vUnJ
Hr37F0I1fkbUQ6ppmYr2sHKcPMULmjkGvjFGrw2f7LiT4rkzHNGE5K9PDsh1dnC7
PGz3ev+FOeWvzJHcfx02NIz0hf4WJPPfg+UBA3rXe/GecxOR8+Zss6tQW6d0pIfJ
S2iXFUrjce60vFMOUby8fwudeIOwhdYO4HqMDuqZMzQ0KcGlaEGB7rO22pMq5arW
s8/w3xUQfwq6/LTuzNtxmmg+RQuDSOUJiWbSI4qmLSmDf/VpgJQFZNN8ehKOvxgf
e1n1JXif6oMTbD1wwQh+/NIm0OHFdrsch005qyMAdj7nw8zieA/0rD4S07eHt1ga
DiV+fbm2zYfvtnrtWRWlxsvKq3QpCTjHIyo/DY6Bn1N+BrbX4CI53V6cBpoRcJM7
a1rBWqpwKT0rWiq6a7PRtKYFK8IkkZVRwonLITk8xUrKWsZtVRI8RtT/mm8TV1q1
TNOJhYI1t9XQwzqZn/BlHKWm1fEke82EVlvSjFel3giH/Qun/LOfq5tql2o3bvlx
6EjIZA6BA5401uOEV+3kWMsTjnCXDC8vqGyA5ymEq3vuS6oonYQObRF2188q55fA
hojB1EwFFnFsGmkruGRTcQhZdVewnfvzEDgfzDjjPsX4n7rXXJb3n+v8RxchDJfd
w4aJAERgQqXoQ3rzVYx0Xmp79av0EjQJ3ScGgiFxSIIPjdYIRZ/kmSBKVG/UNs/l
MFm9Pgl7ctFdTnClBE1vRoS2l2q85saQGVJIC1QAFpo6KYd6Cfjug1Du4hCYMYHw
8fIS2p3nTRb+QWy0fGoymxA8K84aB+q1Am3ZGzMry1PU0H0BjK5MrMcJpBVJIwxV
MUjo9otg6BvSwNX8Wlz+UY3TYwUvWR4C5TCh7FetjXtV+p9qfsCiTmv57LA0KxDe
tKKh+0+sfNM4OxT0BoCjEDedkFWrACi+bv3YHoU/nnvAbw1TVKWs+0JuA1jph1d5
oDk2alr1UivuolGjVj/dFEADQRi/BpA0NrdIkYLxqsnqdjgZE3iYYbK73jSR7nqB
FZuI0Db2zt005c5f240JaSCfg+lKExFDQlI0HqIbNFsloF+S5EKZhuQrgV8B0YvV
krhxwxtma8Inlvm4N5UHYys8MxQujKPAqEWh3gD6NOm8LUX1CZ7Nd6qPZK7P690m
puWcMf0E/aNxWlr5OsCVyNUywniarwnIKIdkTlubXCF29olkIicproNFiWFXP+ex
1cWl4SHW2kzgS2JErzOAMELduQmNhgghEaXp86eCTo5SMavghHCIpFO38Ht4dOrw
+eA8roMBYCn5BmFBjM/mSFW6ioWz6H3dp1KIpJKNHZMlIYxVIl+7H7biIZ0phjVo
OXZDFkRrAXnEI5gS1cJWZ9OreD/Vv46l8BVVDliFuqDKhe34IalpS9cP31g7fkOY
J2p7lb/fiJJ2cO6UaAdSTDcv0Hnw9xlJe4RRzVAxLJ9f28pC6GzA5cOtKzJHyfOl
anZsYzwIY8ubMP+CTp6wHrkhKXs9PC1+T0e9zhpW9yx57AGK+DnVdiTVwfDJXtaG
l4vQ/z2zMQwZYZwaEx1NTEpxio+wKJ2BC2BQFkKyCXyhaVbd4ZAhQmeIOuSpH1p0
ps8TXg3A0mK/V6ZZ/g1dYWHFLsFyQ7ro+hQs2wO5TiHnCxudPqzU9tIwcQ5rV1j1
RBG5rJEpcNcURaOigooY3/d0nBzwn28DI4d2+4t7ZHMzNTuUDn7n9xckPQxYsDyR
u1n9QPHP7W9Fmvz1K4abQql+jLT4JNJNamn+gC4dY91lfL9dOX9iAbycwC3L2Fol
/3chvUqigFC3ofuMg/4vtqeHLue7oNo4JpCSxVipIfjwn2EwTrxIvjccxlMdznZC
n/RIa1iu8/Bu/Y+UvBsf/ShEpjE37qAoYMyN2+BCf9NPIT245nx8XTbQ+X6nfGln
ZVE3aXWhAzub1A4ZYeDAxnQev9Xfryqen3XR7d/EMbE2mrXQ9W5NmjXw8eq419CP
M6cYF2c92+U/fT21fPISgGDeWFAlepfeAxKOTdP1zlRq005IcmMQblGPsDYrrU5P
6JUUwEsLe2E3DVAb+QJwW1DGXS/pMxColE/1XR/rOz/5b3UEkNGmKrM23CBJfj5I
O3b6uQaJii3+TgsJroPtBujt4nHx4T704hlpEtb8ciCai/Fy28l/eEjdyQgnmYxo
EVOYLzfGJBATAqRKLyt9zZ9PfJU4Jv6MR/GHwEs5bQQpW60MGUWwTOvpRo9I21a2
qATymTbwhqPoaULNnrTw/3Twm5sZ8eOE4MVeqIJBxut1OuTgiLQka4rLqwXfPXOF
KYLqEHgjFPcVW+BqcDs7FM1mHvksGBmuUCGYpgwDYa2UfvGkgXbrphR0YSFd2jDQ
QGZ0SE18u4FtaFUwnO0EULxDSpE0BCHDyCOeNS8MvF0GOo5cRPDSAvTa6L5htHzj
3vBU9RJjWNxlYYFUHBmuD/sNK2R1AB8Fi1htHFO8IkO0I0lCduhgIPIHWuJRC1hx
/IMzta+NFmjsYCSzFygxV72+s8XQ+lKTu0j4NHsQBIZOtuJIH4lw4bD7b3RCzz8d
KVQMi1llKp75cOCVZ8O9Y1B/6Dl+lQxrEBuRA9zcZd2yIMt4LReLiuIWhfQwJO7j
VgxU7WP++uH9ykcAQbsFWkNMTs99619G3riP6kqrfj+5ihbp2YG0NtPX8EmQPeh+
ewrBcMmkxWd/fZttcA5ou0EFAynwZYdp0B+GI9jJ9ouEhqfnZObAt2g0MuF+tPb9
fPV8/RuSto5mZAgn7Pan2NWuEftbMeIDfaxtjgJklScmld1merZKDfefrbVKCOQP
w7eAE8Gz+NKPUU8cTnYfm/SM59m94B5flCjAyTTLMc9T3F3YQUUavUa1jT/2lR9P
bbjS7a9sAL2iUsyIq/FbmmEUfo8+2s4wDfo46bTz+feT8+vTBx3dkdackkNPr3XL
IFXYMJdFESXdby4tWGpB8kR9za1NiTV/vZaew+53A6SETpkNLg0qvvVKT7e6WDyJ
MQpxaHr80ocXVGkbqApl42VgpZCd9k74z9cTqx7p5+m+EigntKeDyByZiPrJadlC
bNNscvmnBE9dhqhTIm0GFf/+00hWbPupmOGF5wEyrBKvVcwkfdcagQJBvxFp/Qiq
NQbe1CpR2zBdvjLo4O2oA+pp5zF4TuPrMjpTQkxKssRGzR7gzwdVJiSTsmOrB94C
jxfqjTJJi6fMA5pePpaC/4GRAhvSDncSL7Im8uioAZiLRduvlUZweplh5BSdPQLk
CKZ1kjTA8jJuym6UpkAzKUQFmINYvSPmjuBPTRWIT8TOfahpqX+das9MEGM5OT5h
2+wfGK2J7oQbGKCnQYIQ3i2/HUY6m2nC6xQE/o4DvmEtM8k862PFTA5k7EjmB0MP
Lz7vlsWmxTHcAX7Z5I7zpNXqd6CHP8cSdhmmoLinP/uNgzE1m2DT5CSn0E6XuTTW
ZYpawGjJsHJWpySTHqqanUOFUX09J467JVpow9ECZtadPu98INXW/OguOwiFBLRk
G92zwmP47MrRDOHrpngUz26yy1zQFt9BFTPD7PlMJoZmDzqM1h0pH7JqygIVIkLZ
3iXibNMmUwPzTCoUpzqHu3pMoicN6w7w5pd95miG27NaAzVJUyC8asvuqL4gQDtv
DoyThhT+9GG4RW+fc8jcn9+lTZXsJrvjuqITIzeomMZfWAMhXQuWIc2IoSNMZ6Tf
gRh1kL1qfmzyp6efqCu2Hxxc6whw6GBKzkjZp3vRpP3dCSWpQes7qvPccISVn78e
+PxjxqZQW8VzGldDCGv6RuY9IQVzgdqjZOmdnjf0iQoYQpd8A1+04IUxHM0xwby/
dUBTknreZHf7/gOnrNIBBmQJ59AiVdFX0jqXbawk4YeVqpfzvN+ooL7t+P6V+QCL
uPbbtLMfV0p65C4bK6n8ubbkfidNra9I3Epz34r6DRxYFXEwX8xqTojcZI2vNkyq
oLT+ZaXwNYzNflCnTRuUK7elTLLdBRaIs74RT2LJjFa+/+hi6nHB1qmA/8QMKvSy
LER56zTgD+Vm6pY16c+xUUz6tfCGKJDvUFj3MMd3rMeX4rDb2hWidjyqcwOh1IGN
TVf24nVBKkbx2pnAn1pQiPcsIxVufF2Q/OC3xczh7ntdcTvquJoZicMFp/+BVLRX
Ga80rzHdE4c9A39xEA7eqGyXdG1HxZ05ocPpuraa1091mkOqL2ySORWfBdup5if9
atEYaD7BjhCHMEVONQ7plqdes1S8Rg9YVaFxNy+ZZwasKgO0IeQ0gfz1EmZEn+7m
V72bg/ci+CvlUjknJBL9PlUeoojQWEpYgzitiS1rB7iGj35D1OCEtXrSKgDqTRoi
laQsCl8VsKwFpBvVTho9gvf8xghFW4KYDVMcIUvtjD+0S6jLxTu5w8g1vvr/deZr
L8aKe+Sm3LliFvxdJw/tPHO6qtKhmOM3xzkAHHZzW9eOgwYr60aLAkuSzl1dfMD0
863pV9Djq+MkB/lSE+hJjojAF0HhMkUcML5xRvk61TLWEfYKbAEGRT1Fp6LUi0rN
J9B/9Nl9tqIUoFFSAC0nzANTT0dZ9oQWYgioXLECwI80NClXJaffzkX9joN4OFne
WXO0b4ABcZXDvy1HW4Zd5J/Fnx3tDEDXgt6u8yqc43XB164OEFIedGkXhuFXe9K/
PqwWL4gAfOwS92591+4iIbfW+8VM7UvD5RrWTcCNfhIbYLMBZhn5X1By0C5BigPF
u9Bpebja5N5a970MCRieAo1FGFEgQwVzIxGiv66qdZyLzciHKWINnLguiG5CS25U
6NNiJAnoaYi6igd0GYBz/IOmyJG2YSXx9q4mK/T7Zd/4hbK02usjBqsAWp/SvmRJ
4fQ9/p5/lyAlXPKwxE8wL5VgS7CvLiWp1Awl7CJDDu9njLEfSkH31WQP6nHaiRz0
Zd6GRLoU119Kn7aggtT6+0hSX0kIHnYnPXJPPGsz63kppak7/g8udldlhq+flTmv
+fW3tGxfc5+IJucXASk7Uu0k5tKaxLVClCyNAJ0+9LpQcmak9rzwoX93jofLq9cj
3L/pQCN42R+QfZcZiolDcML95fSkLs2AxBpMjZul6a4y6kMvtCk8Tno4J08KmG32
6HRx2l72jJF1ysUUx8UCgYwae+ommo/6GkNeDnSvFtBQVltTZ/yBsll5AJgb498D
oXLpWfXmU2jPC2JenTeRUM2xeXWqNjk08zLhjW1Y25Ht2eTn4NsKwyNDP3gCahZO
LJO/fvCUzkfyG8uJPP/KyuxknPNyMjmTj3xB6sRAR2F+oNwfpU1uCzwgaTt0LZmC
6SGZ/+xucGOmxnaT1NZCKyqT3TSg0rXDz38zf0mamB+1rgUMVhQxL/+SBLfI2ZtZ
OrOonDdjt7PaKTPIbqIeXGyNYPwt+twrzTBalmETiPsNh3LddtsoPV8C/QSs4iBN
Sh3XtkCLJmxA2za3vz2u+/AbWAtG7xfdIL2Duq9rQRm5lKw+X2O+EcJQIvkYl1Ns
YynHb3HxbHGGJUhb0J9jRtNPCLdtq3fyFM1qfTOSXnU+AjGxvedT8XteHvdB9qua
co/72LL09ZTu1gmj5UNmNw9vGe+Civr0fEgCZLXOcwuM50jKt6pkDgMk/FFrEyhF
4ES9QvrZ3beVn70FS8Bs8MJIbh0Y6ugONJe83NZQK5RQ3S/i0C00r7JjMvBasZ/A
6DBEn0qF9dyrTa5nJtSJGEwLJuYGBzQ/NOswnsl+ziZjJiu2ryMymsMxjUq6nE8W
/z2ZYc0yuFGPodjjphXoUp91Jr1rsTtPkh51iqwC20RFGBYwnzKprCYuVZfXK8Wu
TLMoZsAyBalGRPw6uC8+5KjxDAEm44XE5RrovLvIsutNqr+WE/hJNUAKB3I55pQN
tg9DtlrCbZJLr4c7gY9f25U42KIPMZOaswNQr57oLhBapVUrz8weO7/WzWtS9kx9
jNsMJBUeViSWfNtcaC14qGlO0vNSBXjDZhmy2yLbjYREs4/7+xsjZOE2xLpk79sm
EQgK9hol7K0jQohMDuYvlMay4BJ4LqpHpBY+g7qL+KI07DSbmnjxbqHS74CCKKcZ
hkckxxVw6Cc9hBGZ8H/hYrvpIO7dePq9aiqDlUeWE+Z1l5riBp6rvTwsercmiyIt
0i+pJt9wSnZgUoVLH8iSkY/7Sv1FRA4v4L1/vo70xLlp5SgtuyMzGFJS6QR9j6/v
MJXXx6WzhFz7DRSkIqSp7k6spZYyGZGJFeuCUkwUZu4xfVK5l0RKj6aUmHr3//Nz
cJqvuyC5Eb5V4RQmk6/lHZOUWog9WA+uIVTxIabWguuCQT2kxoE+/bJKH3f25fX+
y36Ll4H4nZQOlZa7kBjCxan3Lg8NgOE1u8FqCpMB/ettN2haWQcsrsH/Nt4bBSGi
IoawLMe/lu+ddTVFZYrhAznFSIF18lhxBCyZ6pz57XHBoxkrgqisnnQpxuX5YvGj
k0m6cRVeTZ7HiuTviFjTvTycIgg8V0Xnkh6y72hk8oXGroapA6AtcmldWotNFjmq
zFG761pm7n8OBwRU3crWuMdMM/MqjusObFe3ARbxGi/L2tEzK5ceoLw2gtylO3HF
U/t7vq+ONc6NqO/EfOZCffiwd4Ztb4ACjCrREhYAyqBYDc55SMZ86MsHpzL5DZ4T
Uers809G9d8BO58ZyW7w70at8ag9OdKts/S8/MIdc1WTKeSYh1/pztkMN2xyNpfM
ZKc+uovOGuBzq8G3Ce/7Qs4xSRbzo7Toq3lJ6/Nztj5pT2DRZl4I7bjLInZd00jn
Q9SOuUKs2rqD0gIqZKRfcJLzjuZFrTCKQ5hxjnsApHijzJIYu4xETN3ximDjfCQe
YUG3xlqviyfk8bLAYlAwZYN6cGtpLk1glITpBrT+p/tFXCEiI6KVXsYTMPEyx67h
+hXn4mpd8Xbr8KutAhCtsxH8Gaqn4VDSLLHGZAzOpZnT//OBvtQ5xdyZZuOrY/vR
/hrDk5+V2y4XWkCNx5mAiYGODevxA5H/kaIp6HHf71Cqtn5khcBTJAaF0mGWEowz
pH87/oPEWx7dqTENQN1SHKQXH6rOEQ8MmildFCpxju6Npxy4WB992nD/EZYotDuJ
gO+mflE9tprbTdGLGDx30MlOS9HiIN0rQY59XFT82r9LlvXp3v69BXf57YN8O8PH
Aa/5sYGve2DL6A5d0C7v8ZSRmLE37sd95k6/U9/jQWGDZpiLJBU/fVOr11Q2fydA
bTu7p1L9rgb4h0d+Yrev1H3b1vY5WUoHCNDo5gi8IPCXn4+znZrc2vS5aa0mrKdv
pky8h4iUCkzRwU8aSe26OmTL1Jam/AGXLZVZfEsVugDA50Ovi3zoeJmaQ5/8kEO6
5aeVQSdMKfoEV82Nt0PCi8oWCHtWBBW5swLLNqcv14rxGtxCFZIMDy+lUoitSVpJ
Z6mL8XIII0gV+ORBghpA23FGT+RX0WAKtLVMMm0B40vLg5SCp1J0lXsWqc5JueGe
/QYpz6e8HK5gDP11FeZZhvXlFaDzW2Ywbil0mReUIMzCQRlBGapmsepLVcpIfTLk
dzrUr6qoXVG1lLQtDNM1M6urZtaqIQHCm4Yy5qJz1lcuOj4aj0WX0zlFTgP2FNbd
BJAfL5sKCwADOhn3volBKVSnlcezyrefvE0rJJTX9g3EzEwj+xs2lgB5ZVQKEWs0
KaOvBe0c2DIW6TS9H79m6/K+VGqW4U7xNrEfLkf2GZecYpgrKUpHr9L30zaiCba8
GLl2/7XOLfmD0i//bPY/qmqbDKL196p+joh8XeR4CizW5CXbLhd1C0TVg7Wz3S6T
M2JrT7QwBQmpkcJhrR0VzVx/8qJDP0IGpZC4BnL808ua4Tl3ySm4N2mNHshb6sMG
XMLu0VTeAnOTtbnH6/uqR1HpNXWhlNNxMr9/nFgpXr4DLYNh2UwK6nhpLI9ffMF4
gNRGcxzYATBQ8vU691b6S62MjzX3CJTrHMwRoXmKQS1QxSwqIAHMB+QKl4ubiXFd
TT37e7Kbl5VJXHyu5bzlsWlqGcp4cf3oGktk4lFm9S6meJgE1agywgBTFYWg3QJs
6NPh+zJ8Zojea2k1YUjIb1yagW6pnaIb5FaWYaML5bbSlzfAs0yPdvyYTPJSCqxr
g3YorRSQ5QZPa3gfEACca4H2Z8Wn4yB3CjJ2jUrPVEz6KSdWWhiigzHLjEru20CC
u5fb2Tt0gzw6IFdPbvRuZ+5ZNzFyGF8SnA3UwUwhC6lIIysmaLGvl3V1eK+vE0Ys
luMFkFFCJQV7sdBdcAD7QGAqsujFRiv+Is8ZMb92wMpxpYmnDke322NlWevUCm4c
nFNG42eIskRW8mrp/QH8ijzrrG8adcZGBxOHzDC7LFS8N9PGMZ5r1Ngq1aeK1uCC
vHY5T5Fg1AYILhmA785SoQu80vc2XAfLmZfQq/ChB9oOaPWuXigcqQk2gizjmX41
XPlhIctHe4rCafxq8Trvn70LXSqDSNOEqBpcLKG1grtwVcAzzhNBkqsOGrqZ7V1s
giFb/Qao5q9Zc4qX9ZYFltrb5X+HYCSzTx/hKNg1LUg0sE+B9JyBZ4L80jXiE9bT
UehPWm9T67CghTwWA2QfshC3jf2m0Fc9MKlPU3DVbqb07kdD+bscm0lM52mEtBL9
h0zioqK58qTLI/oC9SpSCC+zXP4ZsH+VRaSzIEGHFMuMIOdelBfDe/IXKItPa0g0
lBTZyYnxae2QisyyWy3DNZs+mXy9kkyj4TXnve2t2UaKjrEt2fhSDZvKYLDMxgpK
DHQVmQuaJpXQ9Ek7peAxA3Mzifpc5m3FGommpPBfOMBOkB5mpOqI+NCWapOQqbzU
Xf5T5cdg4m0A+hh5e3eup7MBm8Yow+N4afoRBR6Gp1GTtrSVxz1EkUO2FqymvtDO
3ulgpv0aGmEjf35aRCQ3tD4dGKPkQcO1xDD3tG8UgMGiplgZCC2t20WCpmvDEU1H
jOHTTAUAp82pZ11wYmgkZk0ZxXCdTrXSp9exL300fGOqTALmdLhS95BFDdE4Tjya
LbIskOiLS22saaU9Z0XoG5arwFp+vexvaNt9flooADV27sxmeTUayoxPv8vf51oT
+ifnCGSFIBZq31aVOyCmJQLIZm18KyvJHJ6tCbm9olXogk+UkUO3clMtBS9k/Cq5
Wxo5hi2JBmbZ8wZo7SSxz7bzU0xamYNgUgxUSUQlz3jZ/ATfXK+f7VekK1bdE9jD
N6XWICkAEa9/I15o/+6E50fkv2L57X4KkvhvOspNNaHjuk47qjDFJEeBz4DXom7B
b1D86O1gj2lFGl7by95eKs1Z1/9MkZHAiX2g6Pbt3y/jdjRktbsTLj/T9u2VWNPu
+UMHCM1TYDXhBcVAne+4BADeTwu5RNCk66w0daGzO0sOsiylfuEb2+3boAY0SfGU
gzwYsFPPHSLxBH9TUQlnGeEn59ZXiMbcwFPh89W11C6ckH4gjKom7Zi5V7XDi5Ri
SSCHhiotOgA0bejOWtnHNQ3O3Sb5VH9I6oq0u34/yeQ0ABnsRW83yVLGAIxITwuN
TPhLjcznBcklNKo/a3pJs60neKz/ziI8e12A/EVG+AcDcsJH5VeKw/vtwNtMhG+t
FbYJkfCrHz9LBTul9BqMZxL+hGtTpkLxsGqrnTVAyGs3MsjDa0A9nDYCGFU0ujrw
462s3Okfd+VbgQpYIEdjJABwnuw4mwUBlClwk7yoBKhbJTgYFWhFzEobfuy0kb4P
Y06AeYCsfxZhm52CPga6tDlow9Lasl3LXbx/3myG0oxXkV5Zcph3nktQaGcx/wDg
nlv/q0/k9tneQmDgnvn/p+JRdJbNk9N/SAgHMtIBp2NpgLZ5kEYaq+gFsqUXm/lH
KWr+Ewes0tT8hKkkd7WUeidpzCaAH/8Iqle/J8+TcFm+h+PIstrWJet4t0HRvVTI
SRFSLL4zJJSecYBXDL8cweJmsxeS6EocMllHUrfSYswzhdsZe45lauXVaz5ib2r0
ZNVPyPjG8PzVa+VFFsEGKTOovEHDdfCD38slwGe9g4BsQ28D5Jc44tHK+ha7LLVh
t1E53N/4AybaRqF3csUTq5s6dr9NsbDoiSR/aizGwy+zuWsdgoPrf+DB97zjw/f6
4Vp54qBX25RCbJ5YtgHU52Uz3Ey2nMLpRHsrXvZcoULWC8fburgaK3EccYjC/Fh/
jJIUcLnxef4bigHdFCjMpMSAN57n5Y5nw9OaC2RB4yEnhxDuLWLIM1qSqTKxTXMJ
mJw6L6uzB7TO4yyU35BjoI8oQru7MAYfFFR4HONxPqP3SkRJ/ToxgqTOtO8b5bs6
+7tkKkrQ5MPlqgBYn3w8Gs8B+mWQGR5EAr2oMBaRKUlmH2KYWOBUC6Mlb9HVEXdK
F48mU/upea+iQ+p36QeWdWZIsCsqpkNYfWeJT9b4+1yAgFcpjGb3OPBD5pEUtZ0J
YJiinwL/92EApEZVBPVLYdv+rn1xxQ3cZLPIiu6lz7bAjg2g32hiV72Y9Y+AE/1/
jCn9fRCOkKHS8o59sxHZLI5y5oszhDlod0D5JFBCIP7xj/2q7S3PmIZ229I3HAmq
EEx8aGARS6Wo9V4QHDKGzhEyFZMWiXjVkWcMEPrKoX/aHsFBq9EIweVr33s/G6k5
QMMB6HxPcjCQHyIEaSWBxrso3qAhjPhEhXzbA+zlzAPC+jpy37afVbp9x3yXee90
AGmrriN3uSl501mpdwcXpPf6BklqHzxvBu0R6ccL5DeoK7oEGHfy1NmD7l1VIV26
h9LEe0aU8rLk/8QkfaBpBoP74QYBmcWq97VmcViso6pSgvjixW+xftxraJ4q4tr2
Ghh6h89DPmId8otDAfsi6t1HrgAJE4qzwownyb45lmjkyNbaqi8PhXPiG8NreaDP
Lw9lnqQ4UnXYuExF9lrJapLkvSInUZAlFhgJgLLMo4YUINkpNFV5rHLDhjCM4zze
eb0+CAbjVMJy7/MfeAB9U9lADhKl4eK4B05W+jgMMoj9vG1XZxsEbLkR94pDQDEE
uHk6cD2PxE+eKc5ZIgwMV/X4whuorUAEul037RhmUIiT3OvUufutoZr+Gj92sxee
/HHNUzWmsLy8i36RrqSZwwwrGIS/EaRUlRYD9+XZw2Fj+t0UcoOSHEVeOZ8wE5jz
9WZjuODZDxLeaej520NyPbwCQtBFC5bu4PuiW0Y+5h5jZqYNbV0ZQkz3QQ1Q20U2
HpZVCbvUem9g//DMg2CEEbEHJRs3P2vHSDRH/06SGIxmEOJ7AnsGyfEGivw96rUu
QSMkO7HuKOWCryPY6AHDGFmwvCbS1MsO9n7WBaXrQ4euCaTN+sJbwfs/NWQm01c9
u2vwHKGoX0fq/CC2DoKERKDAdh/80pnc6JDVLzlr0/e7as28T6u4r72vPcg+lSEK
gAdwG1lkJ/H+Jh+GbQs4pQtKR00z8sE48Ab2AYw/fCU/OEa/yBv/VSdxvPb8jus8
kpVSO0b55njby3a4z9tP/bqJhRxk2tn+piFv628e2vmZvOekVso2ft8VfdRygpJL
hZnrTKYY6iJTouTOjFmPBJc6Tr33HZewXJAeTlHOMyJdxkeQRZhB2QYP8tSFUog9
7Px+hcyWGcM015uaUOg1U+aaQEhY9dSJLlGVznf67qi3dXJ8tcShvelBosdmhnfn
BL3SqhrkHSMz93XV2en2Nae6F5mb3axMD7Y5o1y5zu4Q/RbftzA5GeLoSIJqey7s
/VZXRUyxhMwOMjMzQpmPfZR3g2JMMRAs/O/n8XVXnI3WjlbkazOvEzGFcQFR3+yJ
qrniTz03evBV1ytAYLEWXIsLizdGWLR4OiLafQ4Si/IpOzunThfCXmNJ6i6tCtuJ
4KwkmA9vCqKNHyibADzYNdpr4wrgJpEwucvmyrzkvUWJp5KNs8kvRUoYfY1NbQAG
OkpVFaGGsFMRAggzsa75i5OzRuKtUVErQGZIyzbgyhGhHmFe+lcC/QZXyglCjIr+
mONsdfva5mb4XDTsN/M6mXm/z/f6naPfktWh1srPVR0KZAaYxpU3FR/RBmlRkQOD
nXMC3gl/O1uyPmjGjcnz617qndoGWvawJNLYg78IYFs/cRHqq6Xay6LH/p7zK8u9
R06Zc3tHtDK09+qfv0cv3T2gEaMTJ4SZk4vGi2l1W17vaQRDE1htS+H+LkT3Dr8k
LV5/aB9E2uLIhv90A1h0f4xzRNdQGzeycKB/nY7QlTEbihH6ovSYkEcgvN4ZKy+G
+YHY0cgDZoGuJ9YoI+ZTbPcQP0A/hoUOlR6RI0FWPs898S38NjP0oCkN5/BUwVhi
NskL3CwAfwBN0dWznUkmZ049lJ1I111iJWjUO49Ml53jGhJqpxDGQCiwy+ofxQKZ
pME0u4xXKx2RQ/FgAK2cgxF0ADjpvf1j9ncnxeIokK4AJ0DIaDJJ5YMeWUMR9h+y
37wuCTt+DRkigxpTKbZFeDJmx+VOKpZlLIv0xHr3UyMAr/fnFMvoGKK/iG+rQkzu
JfSAQzV2cypKyOxM22szJuibx0fJYzCSHNnk97CZUyUF+FEZuElQeeuruhiDM3oP
sZWkqMd6GUaTqfwWUwyxIb80ABslr0F2FH76r4eHY9/TVtl5cLgHEclENwVwlI2n
YI+UXMswjQFfdjTxrOjLiwp4C8vdRV2G3ZvHK4YfmOkMoSvKeWfpVG0u7pP2L5TW
XwqzzFRfRxtU4pg8VE8mbW5eEX7GhOa5V+lV6dcdANKcaIc6ZT4hNqp4oZ6C56vc
6YcklJLB+ggpdBBOT9CYy0UR135YGdbj6RirA3dtvyRuvNiOQdHZKhI7sOojdYlv
ohJxy6VKDUxb1RfRfkkBRS5br+or63n9CQcD9N6AZWoG7Z5KQXuDc7ehj+QK9scJ
OSA19Z/8VAWF9bweFOoD9QbC+oaOmW0lswhokCEMRmfytp4VSGA9K9XoC2jIiAAA
GE5FiRUU1Xaq5DYkODhfdJ8AcYmS9FGJNvhjJdBsPmqSN+ND8KT9PfwqUTXo//PJ
peoXnvoE29BCHlNy9S2dG4l9JrSDq2730ddOqimYRlnnaIGX/eS4jW8g75nT9zsF
xhPj09YX6VRxzH9NteIavS2Aji5QazjfzkGUmWplJWIxoRoqL4CVTcre/BDeIu80
UoVVm0KxyKA+JBMlDf0mHsyEffEtSPfbL/s9W0NSiMTw0Anj+tHsNyhiTd69NuAJ
8AISHtyHXfSPMnzgoC1Dyb5ovEtWhKPRbDf9HVl3Ki5+gZXjXLZsZzQD43VNx2E7
hfu7hjox1v/seUJh0i6ChxqL4LAx0c5zo7apD/60IZcWG+teMLOFVIdVZWy8KvJi
/6tIn6PJlO00+TFXE7jVW3k2vBqmk4PCpenxOY0fmkYhHsw4+pEHbRTukIeazRwK
cvtWJgIGAZUa/Ek+Mz86SOf4cRovhHCgGgE6hids9kX3unrNWstAF0cDgk+BQlam
v7NoNEnyUZz5rNswh7srnB/FOtkHF+d+53BD8xkzdVuu7WEgmToMJ3700nx++yTj
f2a0x6cBDOflM3YBdZ2xS4/Pc0LsBIE0OU2EmJSg5DoORj5zqL3dMq/lJrEy7XC0
dtvhbStHEj1fyZxSmq7xbOTzDW/ffnR5oDMhPI+Re2w1XuRUoX7vJ87tNUjQsm/a
mWciPROggvRIk0eBT0e1aM3njZX93raoza1k37ozh6q/DZcM4jbpnpdW9lWRjPf8
qhzg+1IqG+xl8wPzQeDe+aTWbpW8fWcUHJs+njdf75XLsPjcQqqoe2D0qbTMJuev
JmduS0lrqnVdGDV0BmtKDzYpOLldj7rx1UAAZxrYH80o6DbPbRAWZUhHs3bMgFbf
txhRA8esFHLFK8qr54UTE6ZnZb83BLnPfV3bPLhfsdsdlTsRc96WtAFL/wGL7qUa
4MIGAR1BSQYJp4/9sjlTFLTZ0+EOGm/f8dN70/A5V23MhfxYkEEBF9lJMjogOOj/
1eI+B39af3KXQjL+bHiy7OGqxnKOfJqhbkOjm41PX7fpAAOmPhiZuajZfdceHzWA
Qi/mGijEMn9iJYgaozP6Ydx2wCmjUcV/DwrnBh3TeY32v7WpeMNgl1AnD7pz4g3U
n1jbbtGPdaoYdRMZHkjeu60eIv5tARVSlk578pD3+hwmkQNkiYElkUcKfqweue2a
00rt2sRao0TnrHxJ3jD/u4tzme2hhvaVIDrVTMtdaLpBwTVgqiQQuEK5NlEflMVP
aE0CSa6DG9L5LVQA9jsJ0Vh/j0KlCVDwpT8BmkOUC/+18WiM/ITGUA8UXKVAHcFM
gUI3+oQCHrZrTILIalYYdmb/nZWwDxwqU6qGoQbpWJ3jsIZldC6ZffEiy0yNDeJ+
b1m9SFUDZlDurTjsdXrvrqNouXobeStMbMo4XNayuPf4AVG+jShlTeRT1+Gdk8D+
vnMkd/NKE0W5y5CQtUb7UwPZyuYNJX0gMYsjXbOjtBd0ZI8BsLdTJ1xDbBUncuAT
93oanpr+5qtFtsRz217NwdFXTkiMeu6rZ3zO4dAWQ6W9Fru3DhD61DQEhBvP+FpE
Name5je86YNigTBJgAC0PT1hvioFXEiGCMVfT1uq3VPEUt9LP5LPCwxCBo9WqNC+
CQj3cht6XrK+ARCJCtMki0LMtOOirxsy5Ong8q4jwIatRTvHNLUeGI/L2JEBsEbq
pVvXKwWMLQBOFGDJAYu0WWQyZOudgZ4N9PAo9Tcw33KOjfyY0FvKttUKPkuiDH5A
LfilEXo1GtqCdji7EYdajVRDrUXo+x8Aa5Roxsw/Wajt8OUwcYs2NBdAd4b9NcBu
jTko3aiaZzUyHrcwMqQUZlOpCr0gxFeO1Sy/dYPt5ngWvh9RAA4lJGROuDSux0aB
Z9bL1+w/EuJJxtaC1D0uQAXRwvaFTrhg1ZMFxmx3DfU5RjV0+XIg+NqR32f2wLPi
dRs8AJK2QYGUrr2RfA96eT4uG2ZzHKBC21DkMwD2I/r1hsUGG1VzX1w1sEHbFH7n
4sGO7na1qtXJvVw50cxi5AZnOD0BhPO02gvMHYYfhlrUnY1IPMSJMEeV+PDoSGJ5
DKt3JW/0rJ55MH2tNG2aZXKWaqoBAWm4/N5yl7jI4Lif5e5UxJ8dWEKJyKmpVVrS
gW2Ah8AMYVDk9q3NqVEYkA5WiB9YF7pKtwB0k+A0XXHA9LtQ3qCGDVNCGkxsD3oO
92wLHMpBNOYTDcUdR0tpAWn/UyVtqQeU6UD+e55twMAhiIX2KTFAbvqAyss9Olu/
d34KZX870hfnfrrYfgVmdpLeoGb9a6RSgaQUkHVgkY7RUr79m7WAL2n7+Qdoy3NS
vKJHsx/FzEI+BJiYIRDDWJAU+jkY/4kpFRbww1oEV9BZyHli7cMaOtE3y1G6xzyz
HH6q+JP2vNkJJHhQdabm0XLcI6Kt+SY4e8bk59UFFo9L+zukqs3XxISf6OVG6eXK
oTRuur4Mbf+YXiljon0WwmhIX7TjoPVU9hoxGzXbFHITi3rMVjlvD5wQ+yHoo+oA
l6fGn+1UPCC5MgEtE8aS9/wkRj3n+5AsdUUCty/u2XbU6EB91jNCXvmguCGAjOCD
Katre8HGcCREVYOeuqfUWaqVdxClO6yXFIByAdZxxvViAiGP6eWJbCQqnqBiUPJz
mRt6bmKgjJdcpm/LQ78VsQ4N7qrIIZDpG7xr7H989Zw7BP2YkToOOPvMi0kuPNyf
9CE5M/2ffNL7mWrL2qusQP5Nshegf8neT9tzee8rAkYJYxKp4FP7aWoTkcwEIBPB
hwQsA8vgU/uyf7Ec5wDwQW9WbSr7TWa8UR1uABiJ+eGA7VRC86dLI+Q9XVKgJqkH
3WzmA3Rzd3vbD2Igu8WjewAQJV4DZXfqdSz/4psk31P7BpmCoy7XVv7Y4vwAz3FT
vvkY0Gd90J2vMb4+uJ72cIKaVOtqeIvqp19mUc7ZhyGhpbFhse28AxBF1gUSXt57
/OQw/D9d/A+zd/8pz5ESVp/JyK5/359N5aezjEfkNo08JzGuGMikzvTWqcDeTaNm
5uQXZfuzABZXnc4lZgA7USgHCT9z4X/395ThQRr2dRGJFan6prYQ+ABJ2erRmV/t
IrNwZ/kwBPgjl1buo73RJDso1d2xhRCcE3l99aXdgjJe/5rE5wdtyYr9NE25lnmx
Zx5AS0tm1PcfwbCrEkxLauSpLdVQxlePANeeRg2xQfVvGjDso9xCHXxoO44JkLnz
QsdpPaMhOpPCEjl5xnKSQf1CFOZMVMiGLdIHxggT+wjk7vNjd2MH5bgTTh1+f536
00zBA0sQrO0a7FxWx7HROm9g58F7VXA9Nz0WiFNltlpBgbmZd6Bo1BVwhiajZsd2
UEWziVRc1MDJtwG+pDoy0UHuJ1u9u+KSnfUZaqSUFzj1f8NssYQ0NJsx5Sy3vTRQ
dQ3ZG8B3VUD4Uo0x4OAws8/HDzO53JcdBUqmulBd06hXAEZXVsLaAkbHCrgSD4MP
K6kwU5Z8QeHM0Y059FJLbqp4uKWTEvkydGImkHUjQCAYzU7zYdIroG31c5t2lpbb
YkWVDvZwEtt35FS7mP8i5urGV2S4qb/aoGalSs/wZHNBbMEiB61Bh2tLIGrpux0J
5DGHkkU6bC/62yT921SwG52C8O8HoNG7c0GKPh+ckYd3+icsG6MZfdabjEkZ9LJP
cBkFPXaZd2eMJPbT7sb9tPssgSwbVpMZ7l533t7+Pb9XzjEUg6GTh2Sm5/KGmRez
DqdbAqwMuOYI+I1yHxWQx5Ud9pazVLDCLdi4NQJGA2mYYQj/xVmJ6zrKrekF++RR
T/w+g+dSJ4ZEycJFmx4s3tlYKRY9XEUfPliZKIIxA/Lt8v3hKxfUhY8t7Rws0oc8
x+/xnQKa6JneNURKVdRZJF4F6tmePERV+Iz1jb7rEWiwQg8L1z1pyts5VtobJITO
WwSMKd9Z8kBMY+4XS73f8BWhr+ocKF2u7/mt2bxQ++PYZ4nH1BWqogONXBWPckRe
kxBzDyP2UVK5L//sOriorNUUqtW1dCyqMOgO2WpiVcTUao/6xNu8ZMi9LsEXeBx4
+QjbeV2vSISvQ1gBvCjswrUiuCzqTa8sFCogCIAfiWoZZ34HnpcQzxe3Jn7wWIC7
qCOwuSEw2nmQ9NEvPs47sKEltqsQX+hptovEZIkS/6USjFlQi9udvJG78YMWSrqK
+E+THejFKqmfv/694LxENB8keIRAEYYiXmAseOVGIJxAUoPlJMU/sgcBt3z8VQM6
VtfOF/kcJOMDUblQyovVgsRpU5q0HdE3PpUzmNBMSE7erBwzKkHOhfYhheW6i9HG
fiKEX3VaFNeEOMBvu3zCo18R2BqnfGq6OdDLie5r3o6J1y9NVYgzPmKO/3mqMFCy
tQD0VR72tPVYmJwjwyMHCpb+NjHor+VPdY5NMey11DQ5n0ymes44rX+3/c5YJ5Zn
uWW0L9Y2kcZ2BxMTtMdC6p0QfmLaVVG7d0tzPb23p58VLSG9gZUzH/8PFQhPkVtM
+4O0NQsaL7HjVntYhkH/3eExNDXwYz3sPkKdTB+sDxvYBlVNZWEeW5QpeljHzq9C
fLp3RdjzGsh+o9uKvnnatBc/mdmaJ58KuwkELNn5RkHNAjTj51WVhmxpFW2XCiiW
jvHPslICdRiUYLhdrgg6zzsizWnH1CrV4As/dPSmPhgY+UZDBqUMpv8OdIXS+Cg3
7iKOt+ICfmoXU8YVSk9XMdG8HJ4WWXP6+e8J7fZMc5hQpaoyBrmFyDJLR+ADH/es
7WFIvyj02ewzuyKDDIDoY8zP0Bd/4fQ1sBaTUsYwX6kAxflcmO9Nd7K3mLpf+n3I
X3qe/US9ASnKJdbRpyrcHv2S8lBTH4BM4UkmD5xp4BqtQ6WBo9hjRiiQSMGUZ5SK
1qOPh6QCmGZFD4v9eomv0+YrBRPUM9ztLRtRWFqTeG6/DMfntR4nw0Z1WoPyEQ4o
KzCZS6PDAO6YuSIfTDCYeM6ntRch92P5bGB9SGaz2ys0Sx/IQwBSKZTaPRgCWep1
rnfsL+QjlE5AMzsu5MFfd5bP0/MPQxT7fPc5JsvySEjqVENmB9NBRXYoZyAobNrr
SpIXqJKt7ore17ZRBxh+HnUXp+a3Hly3WTlDLy6V51dVFj/Ohcoje7S4h+C1PVwu
JcSPTssM5cz3fXnc1e7Go23tkxW3cHwQfq7L0ZzzxVqvZJ84GZYeZvMuNU7gPp/z
JsOCpQ3KaTwjJ/rZrqy346ZU+PQzPq+3nCHe8M7XH88jHJ3+kxdy2IT1X6FEArFY
F3bAP0V8lSR8t75x9jfO7u0l1joMtJ5p9dGaSVVnZ7c4WjY15epUBTKSu/WIyTYS
Tqw5iYjvedT2bz3GG7AkU5uf9cea24PYh04N6hi9Rxoe3GVPPxXpSBzswT8zjhUf
F6CQ/oXF9+scSqP4Sn/3qNENKLbn3TcyOO5sV3EKAp93qcCzmVkq1wWvXYz3Y3WP
j1ByR3XX8WvWfAKKBZ4bxR0Oh6+jutKrtuO/K2LUg8EZPtT8tjtkJuURveixXAbi
hQUtgLDYKIEUgo0lpsZe6YUxMeBvlPESJw3TD8FmqzoSXiX9AKqjROSz9BiLbu/f
SIvlRM4eugp5ciARsu8a/QyzWEA3Cx/jq+PCV15UD5dLOREkK8KxJidn981H049L
A8U8lzGZE8ysaZrc6TKRLWaDGN+Xoj2FbPcVnGZSVZBmQZA673PoV2dGoNwxw9+d
SFl8U5UnZrSqC8lEMwkHG4JpJ/ZKaKsGySAgY9yUecnCQiaL6lCMiGyg6KNW/N7K
yytFFxX+7HgG4MGZrjxAvewLj3CXCAA6zJeaEesag76D6p5OgAu4y649IFke0nfW
wJZSsxDfIqz6Ou7yl+Bbs7aycvJNFDulKrk2TZwXsDqtwqOFO04EYClYwwd8WiH9
i//hMpRq93xUHkxFFpy0yRkAdRW4bGnFyjWNy+OizJQeeJ4bhOGNFk0+gMQ9QDH/
OFA9WGZlPMpbeRGrGYYpVJtlrS7rFGxx9aPutHmpBiRhJUcqSjDPRB3Z9lAvNhs+
WNCHXtSaBcnkRJS+Tm1sTUgl7nuWKAq3Z5DjyqFa3yoJfrXWIuESiQQ9ybFv/JtK
Fe0GJlsk1IfsFNF5Phv0vCfoVHshlfXNoweRlP8SlFOQrr0+FTNVEzJXTVgS5tTh
SLZCwFr8RbuQgW8Uq6h0WCogYj0f5HE73+890ZOmqDWMBnykzSdgjK/F28ix22xp
sdBAzqLn04s8D9pJ1in8QnykcpckgPA15niYoaZYDkPcE40pu8TUYQmeqw2X3KFY
YRJp7cSFnxGHBZj3mfDqK8YIKcMFpUPFOw5ltQto6tcEMnsE6Bm6lcg6CVVog6vm
cwkKbWPEhm8UmslhpgHMyUfbOich57ZSB5LGID11AKk7iCJwdgJ8gCJ1rGNID0/y
G0S5+FM3SiMi2HVhFYrja9ui2LzgXlWFyypymJGbysxcU9SwZlk711RKfC3Rxdqh
2q4aouyQKjinWexUMEwnNG1OVYAH0zCqqvIy3r2nK6xxJa6qgMae5/4eQNxEDeAT
eewVXtjC/7RqejYhqJhyj+WCWF+oTSujcPQ96UttrFOzQ09hupG2mjpcprLjNIl4
ZhsNvcRSQaiEzdxUqJ53IBtnNPHcMcJyn4/m4Roj9h9mPAk4N+ihOoB2oz+BLlLw
NsTnrZDmhzJDYkBIrAMnTXVsggbQaPjIkeAt+fmR5QNIc0yyp/DVRlebgg95AEdA
d1VvHC7xIfqHXm3YK0UCHWSkBvahXssflKJW84MP1o/Hc8GWQDNSOSBKgc/j80aS
QoaWgQ9r6qiJn3G56F9zcHA+tNWFja2kmoVXDvHar7mA4PHgkA5woOAjQXNjdj60
RtgDnn7cd8L65yJJv/HzXPOzAkC+EQKYb0zDMfLNRCioZ/jAnYyoTYfAemkaxug9
vWseyieakjgZzo3liJeP4Llx5FzHKOKIQJFeB+DQl1iwWqGidAlcraC4MtzDF5fb
tfUQd/QkEHfs5sBpWBczHWFZt/C8Jrm9SXuLcbsuyCFS9fgGVKQxNuS2b/GbQl1J
OhLcWXT15Ytpp+RJMNpjjjogo1ZCJQ57gIcl4b+6o/jLy/uDSs4QD2ndrNWGA9u/
04xWQ/q058zZoJn5WOa8qHlpyIl6aUM0h3EnI58fE3XDzxs/ewILNi6rncafK/aa
bQdsRMfvQMBHAnEbnbdS6LlzrywB80k5rnw/asdzOaROWtQHdZS9xl8mtHVYMesF
fqIdAYank7v1I3PMJvM9gkIORNdPXD5/lI7/qFuK3KxnzbuEPcwEqDIrpoPKLVgk
br7gEmUoFJV1fvmW8Bif81NGRJYPrjNXkFJRCrLnRzq11hVTDIaxtHNGg0hZB2jQ
DhXdvTSid6gxKAeQ6zXMM49D6fRLJM4B+Yp2AUYv0lS1wrxLFPCWaOp32GXmDG1J
fAf1YlRWcfzmIBhsLmrB0KbWYcbx4x/ObDNz2g/FdMAH5AolPqEFN1XRM1G8mqqt
kCX4UCIYhjrv0PXnQo9HCc9s0pU/en/IWVgnMxJMguFv/3YGwrwrt5S3nLoo36EZ
F2S8F32SodRTO2cmV2LD5ddMLUfm4iDkrSrNOcoDTSmA0KKVBRDMCrPrIW2XFEKX
e3JhGsDtBWxrM2xCj4CUArkSHdOtOEGrqQGhvRU83pTXe2dpllHeW3yhhNyBKYWM
QzeKCeFcvV/HhTU7AaWpjP9X3O2ceWhw4dWumqC2NgOwlVGIjntEYwmixgSAT1mq
wJ0NBcMOACypZhq5+VssITpKrMqhJXPn8+6CXy6XD9nLsl3Fhway7IAI/iFFNDqW
ugYQ5Spgu2CTytUVCtXFFZ+h5Bc3Yxx1Uv6kJPjSwBQ9qiRdfcKL9hwUG++LqOQr
TE0PAcupHOCzMjuPfLfgbSGqjIVvAoGeJAR+z5HA7IwaMr8ilGL8umMoJfphCtwW
OMZJwauv8kmqQfsYCulhegyW/D1DYCXVBv65FMjnKtZEgqcn/e1DFWD2bR7rnHOL
DAqoyFtGDVtHOGWgJENOflhPLIh8bWZosxY8AEMBdlD3zPlBFG4alvCYi0p4SPQv
+o1ypni9vBKVlolzhUAtazMbUCGdvldWw3HTEPzORmmzgXMZxOmPoQSn1SQxwadD
ztviRA+0m6JLO5QTp0tzT+LUNpW7jw2hae8W45sLBb/wYhzzQ9qI+DSUXPQQaD8z
InZ+eeqvlB2WSt45V3CWWp2BAyz1Ovtjze/6GxgF5MJwu/CyPWcOypat0hkUUBGK
7wAV3UDQxWvpO6PyzH54tm3qwSgYUvuRaqZnDiyMNUvaNA8I7AwAu2Mkzn5UHajD
gBFQJBeObpdoiNKZPory6RMQ8QzO+B0gCWnr0tHJuVowMHtfHQU4glDP//B6P8z1
8fRXadFB0DqLdlvTgXULgKQGUt7cFcvk0cWcCJP4aPeijwIwLAsDZUAczbXIBwPg
Yo4RbcQMEcFZp+FyIAHe/N7eznk0ehLAcz62ReIuTAG0O2iqZchyxAgUGgCihCCZ
21CHnKGB/HW/UC8954vYTpas8JOzLXUDaR0aqFe2qybfgIY6D6c13N+3D4YixPKA
og7K70YwUX0o5I0rHAS8zV8CEuHVnjZQv5B8iQAC7OHie5Bgo+0rQFHYw7abubcp
5TnqaMnokrIpoM9RiBaPEouHAHDYzDdvgAD69QJMXhzIiz63rihI3v+53wHqFljb
gys7fRSJGUIh0G8KuiNfguviubtGAGVkXnf3OXcw6ygHqDnhd/qhXkjHswLPYP0N
AKv4+CcBOWWmsHz+xYnVVzil50D4fjwErggYk+D1EDU6mnCnRYBDkweZNstr8h78
begiZ9VYI5TvAbyL+d0E3wHLzf0OynXAxyeH/zFXX2WQBQbkaDyr9ialwQLn8SVe
6gSIWw0Jtxsp3i4ZNOSWmk5xgGpqIgCufO2FN6Kv92nN7cQgyB8GfAkDJ1XOuHRl
bKeb59VRo+bQYeHASZUO1Y8X6U5NVkKkX4o9mYzvtQGYJeHCy64j28LUehjHsWvm
BnrMmn32mzTqO/toILrzl6iHZp+RDeqFObsABe5TDHtMT1pPNhqHHmskyg2ymAAI
z7eALzxdWklGUlJE0S49oNNJzCBW4Pv02HHWX+NryPAl0vb5TY+JLtMeuNIpRRBb
WNeGxOf3+Qbi0zlEEmc+d5Ru+iofggBGiY8RPvcRPY3ud2147VqHQ+kQ3e+W3aHt
1mofkKBwfXUvGAjbvlJ857ez6kBPdZgNwnJ4gHg7XI2xdA6cJWlLDSuCyjG81yCn
ITYy/J1+aFwVW7d18sP4K7F98huiLRjnl0qdTwByWrd0lY6SyWg2zvhqhmvEiRFH
gYz0QH/lMT7jeYNHrUueHptqEWu7gcLl/3XFrZ+elj/Mkr2hzFYEPF9SAOH1gdtR
kMrvoAjICMXhQBbbRgjgAXIl63gCEIbMXD+6QOVUHt43ZCGASNr9z7AfnhIaqa9d
w8PVcRpbUVbCuFZPg4d4P3pac83FvPuZH/3CLkwk4lvgWEKvLKXJopiPuYO6a82h
1NDth0EvPLRrindPCEOejNqdOX3Pa8RLGnJcjVDSo65ZP+tyowe4TIWBNG9/5EnS
TmfSFL6dwg9f9BG3KEsh1nYdvQQBL+Gg0UMWyaR6NcDX4uv/iZCh9Wf49QP2SDcG
vXpz3Aa3kEjRWpxbbnL1B2BgCjqD1wx6DM6/u7YX/p4LzLcOJeKMndpZbfwLeNSQ
loavOJlOnA137evIGyTBnscWAg0ZDYdHybUq2KUCOfvjIqej/T048M7utyFTQlCq
TJo7O7izg/fxlH0QP5S+z/HSL/Cs9KPfGEv4YN8CFeFmxA8/ZtsbwBIn3ocQWYi3
tGo22eibrXTcRaIZuy0B+OqutNyBPJgyM3jtdCZ+gBltoHvZyN0txFF9PcFazoco
y4fl40zN8ZhfqPAO4V8b8k4olIHRSxuWR+auvJWzdqAZKjOmf/oln8QxaCHx5CHn
/Tv0sD0QIHIWEj6fnkUmRY05b7vt4jOjWW5hSy24wqwdUIaRiVjkL64QKVkpMnHP
OCMlc4smYwKuzpPrgtPzk8m0KcztsMYYzMzZSzFs5BItwApXxBtHP4IGJ4rhBB3/
18DnsBia/IVcxhNXrkxPyti+Q1MutVZEMWr8dyvxAGuMcnEBl1/IodVCCqL6Eq6j
MuapovOExzG/bwExfAOSZt7poKYrbi+bnrA18upOAkNOPhVYKphB8cMM1t0xVWIm
3nPR4lOOrboqwAdeKKFXaUzyNPm9Au0DfZbEnTN6O37tQg3JuTJq+AOwHPhR/EOt
rC9eEuKAEGg75k8Lur5bhY9/NHZGhsErA201bThTN2z1XIRCYlt1ITbbzTsug9+E
OB00P8Ms2VCo5wl5tc5Xx/QVO5Yi/uXKQBQG6qJ5wTAG6sIhoqhQDshocgb2BY/h
GPZQVW7U2MLjuM6Hxh1uIKO2LTsYOqJ3Bnt4AsIILEO6i+JdEnDxROKetLFwb+VB
4Hgqw+cytuaRnRt0s5C4Hdr73xpg5tP5kkyx14enJ5Hy++jsm1JNSN0cjCMBwGNU
IY0L6F3nOLqwU8gaw2KFGJCFnHMRWkAs9FFOIymXVp0JJTqjTEXMdimwiNMsIOQ0
9+JBWMtExtEyvF6F33AfL0oZte6zoeWu/QrivNZoAPmRJHxLBitFF2QzZxlSwICE
FzXKD8KgQlB87Ofkn+UlG9rZGtZk3GEZz0YK1xo4dEjicoPM8QIoHcwPCkz0qlsL
LqbKMjoL6Ipx9ht9SZ4YNzK7Yn51gGrAbWHh8Gem1LddUEsGlQZzOGpA5E8M/iNB
XMNatWmJ60ltAWD0Wxe4zeE6XiCib5Hx3aGzlshRP5ug0IDSCGsLgq7OCIp7pwvj
+r+EcsIB3Q8etgyHc9QuGNmtjKHqorxtE/jB60x5EgRo1qJWaHo5kjAA/tT6h8Ni
UK0pIkFFTXSJXjRyp1EKIBWKo1a4m141nZdURq7SxWRoU+l70r5ga+lUG2Jd9dPi
2fKomB77GVI/YEeJTt9HeYyUc83x+nErlT1clhDZGzCuMWmu5coITB1wRv77B28l
I/dFyLgEM2V8pM+vdyH8CtcGPNmQKwHHqht20L9p2BEE8DVYiIjqFWdgqwGJI7v1
akZv+NWA/CAL6ajgrPaCUWOPd3kG36Xc+B47YxOs50UtFPjyWM1W7OVZpYXAUCly
OWVhuTFloxAnS4rCc6hGZo5BrzsQLMuJvbkyr+s9j8iqkc9linL2nbA7wpBDOh10
Por71kc9c/gIB535nY+7SrkyUohCvCa0P4gTlJc710WJShxdt3sYOObL9U8+ynJv
/g5oDDVWhwIfBCO86Rh6qVkYV8AQi0+mSd26uGw9fXRjuGqjvPiy+HVNkigbiiW2
asSf9j+f/2gIe9HjNvtWIkbVs7ELgg/Pu3+rQQM5UDVDh7SBJbBqxA+4BiZN5aDf
PhdPjp7JKPjOXOD4T8NKFJmnoS6S0oC+GfDtRYhRVGKg6wT41nDi9eipzNsgTt9O
OLjanUq61VK22YrbrVCbIMvucd6RQLy3++u32tme2FQ7sGFARhe2/JGgeP/xWkzw
UrdgYq1R3CCnJfZqbRYZkV6UJ4Oiy3i6NrpHFEpz1srHii1Cd8I2SUfRTwErnpfD
ilgKC7ZgRJRdZIk74qquoWGmJMb/enF30Kb8dMzUsBYCp0rdMIVkDsgsd6lUyYTA
IWsI+d3GbF0UHHS3YWPIyee933aTbM/VUizEygQHU3u+WovlYznlED4KFgwYvq5R
NzbAJ+kOObzcjaNwhxxfxbYFE29oy7RzuCO8aqMpqzRKNz9grfv+UC3ppnbdseYY
d33VVqsKGdf/y1mUZ63Vrjor6VlpKHOrYFpXEXd+qzFy567a5OpsoazkRy0UUlWz
ndYUbwKf32wFoPC5DhD6eOIN8I/r+BnwRE3zw4yiiZibOz3cUqZzrR2NJY1dW2NH
q85YV6g2k7DaKjssEqHGYcgHZZb+4LKBnMn89C8r8E3ntEO/DjidhjokWlvaNRc2
WuVUpzMHkctscJZ5QySDz3k88U71n9ViqdqEdS5Axz6WtojJwjWQ7msk5GiJRQg5
MKIEdhTNB57uljSr8zgdzkKWsRwHrXxTkbQuQInOQxoX5kUtpkzrCJLLyNGPQhKf
AswDJfNmROkJFmOjFod1Twp8/CgXTrDOdl17N70qGtWIiN5uarjQ0qy2o2q2AVso
x1G4hBMjtnkrL+WZusK5P/ZH1kwMee6dcQJeVhfTzY6ZcFqjnUCxuxyUIZ06X7ZL
BmfnqKFrIrLDatbbuGE6r5J9zuUZ6qD+g+H6DrgsWFjr83sDh+a1ZUAEPUhDmScA
bwwv0LOb1gN8H7kY9KDuPkp9Ex9noJ+d0wcP0CDw2AGfzYHELLP3OC5gJIt2YH+m
Wy85tSsO/CutcXbkSsfZI9yycW5W2Xre5thxs26/K7eXUXfMVTkDx+527GBHd9oq
dZWNPFobTe8hvHfA7dBtNDKqIibI4VQ4nxsOqCXtseI7bM3DctNzjkD/Xb7NYHNO
eDhKT3uD2EPwdts3TzD77lqqnWxdok7PjdS0boscOzVytnG9MT0ghnqcr/stizu6
w9JywN4b+53kOF/lo1l7sSnvzVdZKuQ5B10WnshHBQpw0AhwFpIMAf5ayuhDBQTn
APrwdVrAJ8pCerJGKTvQFCgegTCo7Z5Z3hMzAwwzm1NxPcGOAnf6C7bHH8GGbRJ6
/uucDE0mkC6/hJP/8jqwSQHStrLf89Blxq7W6h0FxME6JMLy7aALGBZ2QHFOxzIm
3NbPd8apMir+WaCTgpWdVHOr//jr4kMvbXmMueyeyWbfHdiTEDsrzxR/7lsIq3DE
gRpmRN9ZnrUaXxbnbt9YC2FdVo+cB989/MiebL67Vezcz5lzBm6inXcLxLK5vX0O
Vrded/CZMVDd52TW/e3vssc/5MZf3aUBxmjPAsDC3QhYjo1tcsy/zxFV/mcPsIQq
dx8KqLDjK2rhaLH0ZgBTFknoo5nQxTK98ddwZa2ZBYM6vUZNBqJ56QFYA4A0bQY0
4JkgAKZvb5LhNdqWbKgIwPx/DeCdjqNsxMqdsSnfxR+ckWbdwXxBb+0iFsOCIgrU
BdLgEaIq19enNOIUB13u+9W/kTJ26jxGiiNumNtz29znkbIww7eBsmpuIJjJrmqW
s8EXjgQQltAHQU4eUy0iHDPByAjq1ef2f1h2+7hmJusqlOZKkL/qioxgX4eY4H7v
cvIRZN610TFzh2XPyEnZtVT1jf3gsH9spzb+f5b83GwXaUArcIkLAxkCVJT5V802
OhqERv/YFyQDbe6sg9JpLpBfzlyRdAG6FmDRshpykGJAr26SvR9/8aBwtJwH55NN
d8gXkpOD0gcwRrGpNvnaxRue/zib5F1QHD4zEeJVKpsAKVa57m8HETQh7UkgbKZf
N80qe3KStk330b5rg2rzYCPa+USHbYfOk+Y5W8ujuurYpaRjj3sDmP1mcGby4niW
E3o1JVGWS2a14MWeeI/dnOPyVOxpa7O1y6iKlW9uLou7E2QEc7reDcvWu823l2XQ
f0xrZ5DBhYmkgr5qq9HCN047w8xR2wowbfYbw3WnOdbS8nty2CAJOK6i31dXBbdm
etoz6Ms3/tYWnKZypoWNYSPMsQthkQBRU1odthkJzSsqez3trndlrAk0YA9ub5SA
62jt7DMyJy7vr5GSlqSE+Yphb5C5WXHOOYIA1Or+UviJ/+0d7NgOsF97f14n+2HP
r4WstxTywClvgsb7i3rKmj1AZWawgZWA+ZygqZXgkpEArVW6icptHw+GbaYtG6ge
tpfTEQx/BhfZdz8YCd+lhtq9Y6GahQdfNSAYV4i3IS+/uSdq3k5F7aFVjGSeQ+Px
l54wyloy2tjUOWM488Ltv+whhEw0Eu6flz2+x1j5AMaw4s3HbDzL4AShA5hITyUa
IYA+Archknrb22NKITRdBHeMturykSRlXTeS2ogfBuTSz5kT/j3Y2ImcOYhxVzQ/
yJjo7IZ7fQ9+Ua5oApa/E9DdzhGUlEDthxO35+Zb3N31W5Z1+4XEcw8jxfQHsdMf
NxKA2gDmrQb2Cf1PiD43otcg0xFoXMWeAZKRwnK0wLUkP0ljDvls7Ek085AcZWvd
G5cBmIjpZFap2q3L30QDBfZ2IfG7ts5NPsCJNDm2HIyNngBgZkzzn/jU1dV3/KPM
xdDzRYt7Fkxgea46So/81nh2Za95tX1ht6/+rayYLb1xMMu41k1BYO2A6IPK0g6g
uGysfYpke6cT84Ne6RSxB/gKwZU+u61FAZ8P+LG3rm/+B5EPHV8z7OjkHY6DUzc1
vHyYgKdmYxXswzuQtw1KENRBQ06gUC2xEkD+7eRgkDKULle6iAeAeoMm2PVOlqsB
Adalz36L3az71iY8AFbFDjL5MWjD5XsH6A2n18m757oarhMfI+Awtn6UuPMS+99m
ZZmAI35sCyz+mdhHlRC0M0VpJCAKYBvvWjL6kLWAUHv0xRcM9E7rs1+9aJlnmSRi
P1BZ2H3n0xcyCrIM0KKSFBHvlvjiWbiLAodN6+LA4vsvVAqgtyBZZjjedJ2mWQxL
ATt/WmzYuDeSso20FYXyX/fnL/8u4RcDW7y9Qfu2FZ0Ty0N2Z+Jr0eHfT+ellTj6
XOycnvNDe3+q3oQ6Cp3cNLvb+a3KN2JcDr8paJMb27goI4FZ9ZiReYC9dtmJO6XA
omVb6ej2ZR7W2GaKF/3S0a65fzPLXhI92IpoSUk5Di6rAdEvauo8BubG8ncBwpJM
e9UD/HX0Z2qjMDFncOCztcrKnL7PvYy4zifIIlo0JtvEiO7F9ZnXMLCtI0VY3+ni
OCxgxnaUpGWEd3HBhquXLH8j7bu39SuYSfgHLKkQMPidPdzo4rSJ9kDxbJzFUT4g
POFBPdaKzQKnLQgcGTx2xHE2uVJG8S7pLzSIuA0fHda+dFKMLp0spaIe/3xVNLre
meFsR025x87qnVxrHOrN2nu/gYOvk1wpHij2eF7a+9r6BtgAVs3uyn2nb8pKGPbL
wMWvht05gVeyw8YOWdZWaNP0WpLdDXjl+CtrGq2dvdT4d36ZlrcQArDxLZd+i58n
us/p5Sut8vjEKQv9gkK3L8RMaJ1ta5zkzES/3TfIX35xvtB4HTaFuc1HG7D7P6F6
ZTF0B0O/CGHXHACos2HQlGf1CkY060RM+nbJK5c8Ymt+VaYAR9599Mjvv0U98wqj
dvYSzKp14S1pTHj6NWagtlafFt7slXaOHRdPvD046XIcTKLCoS3aG63MI2TGDs8j
YyaFdk0BrOggV+AvaZCt9WBAmJR+3M7pFcBeavrwp5F6H+ulPmBRo9MplfvRTIMn
dgB//Z/LytDsYbFzYxmXCl808ScS9EbWrj5e0KMTSLvVLdtclkjPQR+yELaUA67O
fxr8gbkPW7nk6LLyS7koKC71i//QG0ntIEunxZmGX4hiJgy256qtNvssMfGHvWzD
/8ft6E9/HdLxcP1vHdGiI4Bjp6u7IfdDbQgufkqHw1YpfgFKtVnAz1vsypkqJ9go
Zpe0SB6ewPX0pyIeHD6OS5B+CwzrL+bb+48Hf1zjRNLKcbtYjNrRUf/L9r76gmvU
Or4n/8XKf/rUX/s09S3Y8vU9Ou2hjyq1dzQtFP/TZ7P2scQ/kj18S9F66AXoZqEA
ouLWCezgu0XVAd5vkJF80ozgSh3rZkuBrCgAyyqXI7Z1u6o8XaX1Ae1N9oZ76/5f
tJIt6gTtoForkOuBb2pX0i7R3ns0IfEGFtsG/mZOdpEhT+iT53did2ViwhYznn8a
0H4u3qDuAZoDLrIg+1gKtM6B12J3lD3QPl4I/Uix9owpXt2+LgtvhgPUui29KOL6
nRc6D4JAM864luUXgLSch7futxTxGs4BsxIdYL7t6PWnD5305nL8wm3fU8m42BIX
XZMH+o+P28cdJLpZsmP35x4yLHm9HFsbvxbLOMit+M05ly8Q7WJvNa9bLVM7dJJD
CF+vo7ElS7vPgPHjjAY7b59rWUdp5McXStO+TYx9Scbn8n0Pw3/G96bmMd+yt8oS
4kKoo8b3XqjobBDt9t/jl/eWA4dVlKOU4w53M16+rBF3R3WrtCoGOxxGbHW7BYAf
ZYTXesXvumnccetMmQHOLUnBTQqS3HDwAN+AAMRTLw71AtRdcnJT4HttG4myJWkm
IfcSHy3E4vC4EAyvOMRpzKUSuy46IZy9laelfvGt43jk7MLVK8Y6QDwRTewzIwWI
Rce8hXtTLgnMMUqrBuRoR0T1mhUF7uLHRBN/qOOCF2S0itNF3WeKrtGS5Xdpn166
BGacqY/1Vq5SfIrqE6H18/SmjWFb/bMMEDOe5e3UKmlTtfaJZ663tq8dW3dTYIgF
Mz/gWx7xObUBFkoEfucu+JdObMhCVs+9t/Ch991LMUbMxdgJz+mEQa04m5vAh8YF
VEWBeuv+ewspeBMUS6s4Bm8mtDMAnv0bZwcHAqMLxVFHJIQ709Pqj2Ca/YGzFf+F
xycW6LZ0NgKhKSUhwNyaYVaM5Fo8rB77NyeiojvbxwKzwktUL1WSRJaUBfRRsqI8
ofDi8m2OhEeyep0r5f8iin9E1voCfeNOjerx32ZnA/cnbtk/zX0WwD/+uOwI9WjJ
EWRHsCpLAwP1mzu4X2om/KSMAgPVq7aGf8YsqK0P8uUtS4dVc0M9AKAYaay0BKaH
x1a+xH6WBmvNBof7ey+SLdjtztcvUJ/GBvkVs9Z534Zk3XbctSzrtOespu2gmhW0
tnAty5J6Dpfd1uV+GXfmwv/CfFWx5a1FfAuXcoTMafVm3uoTJQmXtoto8jVJwIq4
GUGT7+60GkN2eXDn4i8A9g/uWMJCge4ErZDp1/voz9CXVls17drK0kb3jydKC3Vn
gVF7/BQTFoolSmFhVUv7RQDQlDVirjo3fw2Y4sFfAwBNnbFyAkzx7V9jtbBQatAd
yhGUAAwLdsPRa5LQmVXZNXQ9gmS1QHdeuYWZgBWT0OhGwJY1DgyKR1h9OesK3tr9
Zd7bL0XbVhica08HQDq2XgAgsBoBwOS4B4bHvGF71OwRJaK4XbTQfCYBLKPfJ56E
jNbOmoLuZLs5ZdxxpQGFKH/j7fA+gvCIgEL0XhPG66jZ7fLxX3/YrK27+MDtj+xW
L8l6OnaEoWlN484tcbF0Ka9XZXU7gtAKjCfLw7uX1Hl4R/l7Bs41geV3kCfQzdIk
WMjqTrTBGakz8U7xD6vgD60QtILoCRMUa98vrjBxu3YEyNWrtRAFxRjT3ivCAoDF
yRsV1cCwYe+BYXPyvPwOdNM2wvDmBCU1MCwRMFxWMBsdfs+5TNvVLHWpWYZbxxxB
ee4SigCbLi/W75yptmL9TnOivfyOmmF+Qry0xo87lpYTWoGycJS+WMbLzpVdCzMH
zNGihs3fryPQ9rhw/T/BBqf8Ca2Q/NLqmlYP7yqr2BFeh8ddWREUYlErihdp6M7l
xBp0p1iC7TU1F24hoUZyYHmN28zNFDX31Gso5BkWrBDzyHM/q0m0VI0d5msxyz8B
S95C8jrPnzUSmAqAytjGzu1AW1Psupiq2V5Xw19L9XibdvfwDvkqA8o/J6Dw3kXO
5Hp4x/zULC9sEmzw5he5rHFzwB1hIdvYgKGw/HdulBT1msAzW9o6/p388K70plEs
ETC3WNcG+e9EvoHTrGQvGXy48zm8ixTczwYAIN5zcNN21qsAANQW15n1Sll9BkWQ
lFA/e++yZByTuWv/qdUBALBAByykvRjnC40/3MlU7tarAE05O27Lv5y33is3oy7s
u+4P7L7CSSC+wqR9WsVFpDfWtcQ6IACT/ze6P0BRIy9ZCVDVJCyjgZe2o9uToMvd
nRY8LQNDY5uETuI6i6y/UPMyCp1d6U1jlyWehd+UE4aDU8rx2r69W/y1Z0XASuDN
BS33xxZzOeIb3RZ9RpICMZ+t+dXvj+3dgGn/+hp/Dj3rDLs1pDHGezXcr2wti/4g
HtjmXf4RGtuuAIwaADP/1C8SJmtVWlf63XrgadMZ2p0andnLnX8j1BsMrSNc1gxX
787u1lMMXuEqpNpCepneZcTg9XpXPNZ77UQFvyk/m6xk2WBrVsuMwYgaEaX0CwDg
lB1gMTA0aF2ytwq5ySzrtP88BmlaYq6mxVKFZg3GcDThMrC5WDapCS0tk3vFX6WA
LZ0kPLzvv8oGgqDij5/wJe1+X6TGMQMRvyQz1qHuY91gvuryq+a+Snk7qlW/CJXZ
w11l+vv1narf97WiAcFsopsMZmFP7wLAALOH+dcfY5h/DTKMsZj7ejCuyMJwkm8R
oyhu5GXd6n97Xc+55CK0sgUuyBDGeIulrSOyXNgO314k12JYZAH+d127+LCvEbih
GiM53m6vkUsyrAHcj4mpLpIPFTcCv5y05sa224BHpoZIZ5FqJcz86WXg76ePu8vY
gaX7L31jve67rmvc914RRLoYKubano1wifGfURBzwgNT6REWhKeb8Mf7YrpHe4cg
yPKwiOxaPPwy3V5/pZvMzBUtzf/QzWfdBoMrAID6T626+uqZxcZa350hagtd+108
WFAum6DYbgIhhmgvmX+wBy/Xfa/3Us9sh4VD3aKL8LvvmCL2zF/PN+HvK3vmb9j3
YjAnvL2WlmuxdJ50lCOuap9p4I59p4F7MlcoXroAoDT++Ws54Q+1E0aWTRjVbgIA
4FTDwismfmWneWEMo8aqdGlnVd0FxH/SXyHzEvGauyebcMUyoSvBejMAQAYzlWeM
obyHf3kH/1LM1CDT7dUrLKxvqxaQicFU12v4U2Ay9QZ/eiuqC8ejITWOiBcvVwJd
trBVWGtezMbqgQ/nQ0on/MleYZFr2NhAntnjjK+/Lb23DeJXSfdSruM6rmiPqvoL
uZBLdFk7In6tdJfrLABgdNBKLhLxtcTEL9S6C5cP2sjFR/wKZUYLI1R7jVZN6HMB
BYDR0A74tgwAgOVGpWNN0oMJjHS/7vdfumC8/TWl95l//k47YdS6CZRMCjazKyF+
AQDgz41SDZ9AgrXfpQmBrsXELxP410wYzQWrWzPNW8daTRe0gbErqVwTBrGU1QFl
+5dil8j8y/T9BdhYdimafwEgwv67VZz/JKGbOnodKWAb1eNWrqux76ew/Vyo3gv7
39dfELDR5+87V/xFNuBITj1pMuCsmXnd5MrL00RIBTo6K8XfZSvdTkgsvuFF2C5i
/+Hel1Ey+fMKMmhRXl4mWLcipHA7waRTXt4mgnYR9BcBHOIDH2zCRZJXXsnOLpCl
owIA/NFSR6lwxbJ6ZkHkhggiF0CMu0qCZU376rIxhmERZGKlBMFabGGxyrFYKbJu
wq6jiXWB3cGfLsrsFQhbDutS1N3Hb8L2zmC5t8l6JT6Nbr1s8KfbhaNn1zWHn/m/
IOK2fHbjqFrXAodxzM5NqASIcVypYVkmezWmKLMu36vOMSsNH39p54hWZmbMyCBA
Jpdx1PjpLF3OLLRy8TKG7PHdt5IE3wiDSOctbgFHgqoFpy0yRr7LLGdNjHRGR5ml
cyO5GHVVRyQAdzykv3QLDfO+U99filvA/VwKYGmeLiqJVMUlnf/+Ev2+FudksJNI
4IGM4VvmP2zFpxvYszG/HPAVf7YsPXPjRlEgjGkfrCsGf7AJ0jtDIKMLG0k2hQx1
mOWltaCNRWlZk/RWk1/vpYuKgW+y6vHhBSO2Tb8vDLxISjjWSKrc7pKb+QK/0952
lz9LOacaR+kJReLTQcqJRdGIyIlICYtEHIRylr7nXQSgqhWZ4DOvxFx0zhWrHni1
5gCA9EBL3ZaKRc4yX5gZAejYUrbxAZAJF5Ew1GyaYE2yRh+AgBZWw46IXyeah7cE
rOUMSdSopPwf5F6XncNEcKXLYZU3gWsxKDnmWraRo5HpX6nxQjCBbpDLOnIAEn+4
lZ+Dr26DEIASky5pL2/j16sgi9mgqXUC4EEkhMQmgqTFooN1hMQkgqSxpKB1bPsO
Cv9XYGhMiqQYcwIQGMi3+G/lxCALhAsPHzjyB603blJsDIpIJCIIakyKWCyaUlhk
ytqzQOeFFYsHLCJhBCWCAC1WZDmWsihBloBphBUtSNAF+9nScC3iqAGW3w0ThchZ
5qxrCxwjrGNXeIDAsURdxrN1LOkcgEBgnzxmDeCk6QVV8L/Jn9XL//mBlxrnZiuM
xKkwggRortWf49JB1IORvLbkE5Gs7W7T3nyRrIa94BOQtkDAgzt07RONEwmWGsNt
rYLXvbZgKBqtaY2C1fCBKTqK5nhbJ1ph+R2IQgwIQkRQr2AFoh7b0YPNINSDIxCh
EzHsQidI3z4IJxBd5EJUrAjgwUERtg/QCQjiwQGWK5FAUNU6EGX7cFGLWSts9JCR
PwgO1fiJ1HiZi5wofmHnXrGfQY0Sdhn4mHZ/gxqHETb7XLAOTPnQUMFas5puoXqg
Y6go6EAq1wy6hPxBBCu/nirk/7//cDoS8eAV7qKF7SKS5ewiE0AAdwI6QED2BjoK
CVEiEw4JUyISDAlVokldFppL2wqOA/QrVguVNVuGT7xo2VL9BwiI3y84to8RsGTz
pm74lEXtBJ19YQVd18LhPla1KHXbhQR0A/uDmwtjQ2MEPNiwxeyGbWtde0JHTljE
UpeNCGH2V7oB2OroBXXElA9BAfuDAAHVrOjWoAZAwIMxW9Za3moSPhgnAhdaVbyJ
np+IBF6LnpjkcheAP/g/1GjlEj5YmtxF3jNoH/NQBxAg/1yRmM3o6cQpq+dEpKvi
RKYrRnMFdX15YSxau9GvKRkea8nuFBxrNZayGQD+ilNwbH1LPoluyXD7nHcOEoL7
IBL0v8D1wgaLSArrxokbbb41rRCdhZ+xAVPvoVe1AQ2LSGoW+eBmxQL4g5ayrArw
6NnrK+bF8IlI0/8ABVLouVZmusWwbwv+of+zE5GucHXhE5Ma6C4XDsBPL1i0xn01
LzhEggeOUaj7L8R0NcErf8GxJa0feuU9nwlY3FqRl7cB1rgeBccWLEhDo6Xu901F
I5LOOkDAN+oVb3/kMtABF1rTGhUsYgsuWP+PGa8DLryqWKon9gEJHjyRqfq/GkDP
5aDDz0FiWLfQRW2pEPAWkchjiixnYUoIFpHKLNivwocL99IWoDodgGA6umMRycKW
sSLRPuY676/yvxXeQ8cH6ULgGACBr9KKxZU66cJLvsuJSFPGiUxWV1VUQcNbIMSD
SMAw18AxUgLdlatxrWoLFoAAlryg2i60lIWWQw9ORBpORAIIAI9DB2EfRKoCAHKn
yKEKIAQzgmkXAHI19sZWZq6ygBd2rnadcbAtZqNzAQYauS5xLfgL66KSGqpIJ8vB
Asd+c3ZuWgUjCihhV5yd5gHHrMzarzqmBeCscaOwZefmxFyASHeLyzr3emMt4Axd
ORdgKAAgMADdMsh4GaDg2tBhdGFkLmBQACDhuATXLWdMHDAOZ9HhldG5XKsCYHBF
nGaLDFAAwYXlBsoqFvziriMAATSnrAb7IcttFyCDdgBAgKwFo7YA5LqYLbhUszkW
0JatxDCubiGsWAl5AAEpC1o9AIAAcgAKAYEFERcA+G3AWjYqdAAJhmRVEZT2XhKF
hgaXMrK3NpCpJ6KKNQ3ErU4OpEwMhO7NzS1sDKQtTO7sTQ4OZC4NjapyZQrADWlO
oAVw0P1wsADHAEAZAG71/2+1ElQAAwCQWk3+kQAAxS6/bzt9QIL5RIc4b1id1oeX
g1ifbR7EoyhM97tN/TS/Uagb4PYbkA6eST3wr+iN/Wc0K34mxYqTIBK+2fHn89go
JAZTbqbV+gEqzvjcKxc11lP+zatTONyta4UggCmTMdIdS978E/C0fJSIvr5Y/rno
a62OJbz3hoKxPFe8YRWD1d5cPSUYdhFR9iaOtvV6awjqbE83PK5lZQir0KrJ+4kI
L77ZFV4dUdxneiGlIdjG/kwQFmJxEbLR8yFhNWXp8KZJEr3FhAHJV6M/MCRRoLKr
nB0i2pYrHYhFml5Ub3UPoN/B3AYfPU9RJdYQlB4Xiy38R5UukLwQ1WDDQGH+IW/E
0Cw7aNS2KntFb/7VSDKPtF6aMtI7/swnj+js+GAZ+NU/oeWLiu1hHe5rVYZsWqGh
1A6g1WumXRuTfaipC+Ib/NhA+krh9RZNc3ufbi4OLceppZ589dYqe41xOA7gEfgU
BH16sSrxodnDhlWo5bzn8nt/4RMO9Uk+lVCTF3QJUs/9PlNu5RbPPc8S4Md321ZU
zxVj5NWysP9ktHCpzIx29E85EtMo/CX9p/8IOmM12R4s2fAuY7rKYVWqTXPv1GAO
GgTo1mmteeZGaISOq5C7nScVM4Ns8Q0qk68rjZGxp7z22KU6FcKcbKRQaM5Pnlg7
UkgkDDqQjKL0yAoCzX2/As3irY3DQWct5nIWX0Aysj4+poPpe/Wx3nNoxH9lif4H
tWPti0u2v3gWO2Db540o7Q77dGRJPiZ+u2h4foRxVdywNc4JMCn4MhZSzD/3tfNA
Xc9G/mwMhVyqqUXFNtqqMBhttVCb9V52nSJQGtUGH+c1wrp8qiZiqmQ+/4zJ5Xkq
S7553ieVZk8vbKYb4RVlmy3Z2X2It/ja47B7VSejWDtus+uXMbxUM7HOOWHmjNKq
yllhFAOjoa3TJ2uNNDjJjW7GP6eawHZMECBRQb8RFfLHDlHIY/Gu6bAcecXhmXg0
d7xbY/LWhvFx7kFr9YGedMQStVyfq/rTRZcOXs3GuQ/9226cWdePFJfn70iX99CJ
vntAk81W77C8Gb8f0nnK99GJ7uUfa4vmUx4iaQQMV97wY2pNdjDooZ6cGYZssTbs
cB8CvCqQuYtr8h5FiPDFlAhp1EU+GWmVadh7xzl0yf/5htGJZZQ29ZkE43xVgwRH
jvpNeC8Jr9Wj4NRgUFIJJCPDzwh5mDVjiQ2LYGZ949cLFOU5v/o8/rh84Ct8fXSY
/8XotrUp9K6Q+BAJ3j9gknKW+n4eYga9s9Ks7J46+GvAJAmr8GuOyzbPYq7Z0IL+
GJJ6qEFecACotC5xogHlHsPBnYSMNTl4G4IJ1QUguYfFeX5lVIlpgam1xLvdCRxD
W7AZpjxetGK1rn+x5i3Fwo4O/t1pS8/IdzDkvLKmoS4HCC1iMzbgiLRLotbcTiK2
D1NASuq57wspGTV2EnHrzPwerCxY5dFXnzBrjB7w/5DkJRT824Hy9WeCc0gkuQ9+
kE2DWU/3dEXqRIswdWwe7kR4AI2/iN4OxS6ZeomRPct6LH5x8TWPDS2RPEDPPtRz
LhAHSMotKExeuVIT79fJiACZ9b30z3/In4kFgwyd1UdTEJzRJN9GzhjeRFalrp4B
s6YcyKWp6vO8HvPTPE6dHwyIEPdUsDL8XQUVpVPo9JIiKet/yeE1NT8NycclPv6c
waC/gmZTCXd2iFQvYz0pX8VdOv/WAMqs01/nYZO4p++svAGIi2E0y0l5/gEoDHb6
usr/Wq8y30J5kP4M3edv03v3v8yTPcSFEtW5V2WtZtj8pgWQDfkCU6DFPeJ52kDY
e2cxtE5grFiij2/rXNWE9Nt4yMG4U98bIcrWkh0RopIBl8oiR5kImfYl5d4zknZN
hs5lUF5XhbXgJLDQ9Ska7Fk3+NUfCLhdPfcnRz1duWDFJUSL6GdccoTfCTIACE6q
AbAsHWcybjxOULH5ouSi3F+PYejOf/y1Xz2286eJD+WA2WWubrDeTCkt2GjDUT/T
vOUqm1ribJyYjnb9sTE7ME34x1FXaOJ9DMTEIZbQQy/kRsrJHeHGl/U2eRw8TsBd
+7YaNBf/+SH5JkykVG1b0f8M4SKVtNc/iNrkmo3DvYIkEpKEKl6PuL3ETtEvsVVO
fFzKb4WdZV9JF45Wr+nPOkEyXoVJkoFsHxoARQQ8j7cFm13gY36rDnbQ1Gm0qFzD
wCCb5aqyWi+4YuQZdX9sCE3Ua+um0h7J1W3PQu5xFP+XalPtg5qerKU2CwAvcLuJ
wiYcf47pX09XZ+upPP5CnUa5G4eeCj3AWcpo7ZGvT/B2eQnFR3BFJ1RcUAuy506O
yETXhVFIjXyhTkz0IeGEnLbeX2KLGRjUadS1CXb3Q2IYyKMgLsOOWwv0b5RmVGgj
P0N08u7nWsp5RDNJhFZ+QT52KhosWCWDV1GB+sTYI63iV2wzZE1sVNwLzOoiepWR
9B3h0mrR1sF+jRGRoAuodV8/TcPMbqiW9l1AA2Hc8wzB8Ym5YSnFKMoE71M9UUki
Sbm99ksfgpPXW0oKOgnFghNoosClqPQOtTIyQNkTEob4BxKmqqynZrz75FhHzmZO
Q8gCRo+S26v78+ZeDx75I+L8iYixncMe19CY6lbjnNliUHhSyqd9lFSFVfQKS3v/
hTpY8IeB55PYWGTSMqpyH2iEJUsk0An2AhWCz/pnVC4r7B/fLmp2e7J0Mqztfq/f
oMCP8//BAj4YsIhE+fftoxTn/5Eg6yJBQKiOJDBnpHKStP67jkBy74QyNr70HHAO
juPU4YVP34/bPi6R8HaYTH6Y4+1B0U4CauitjsZ7odWMUOud1rqliJWuILs9IGMM
5v7LlvcaIFT3MJaxPZhNExR2jpJ5OMICcOCleZTXGdTnPzBE8aEy0wkMo+ECD3n2
Xh3GFwi9L0OdH1kvF3XN54pV1+OiOC1S5PBmQBwFFt1j6g0md9xCfxHXuEp7NUr0
aP8KNEmUmwLe+qwtqwUC5C6nXR9MLKLa/UJ4zic/pmjC+nhtQHdXQ0cPrV0daFEs
Xrk0y2SvFF/pcV557lcPMxScRhAqz5ICeiXsf8Gbg/WMRg6zphScf/CWXwRAHQAw
/TQSHaDgu0kDvSMzF1pLfVia3/wN3rkBzPkfIYCzL+xhRhMvQm7ENZZHUMkaHlsT
Jf27pg+/OMV/46qtkXSasN5QGTHFaY2MeP0bl1WXQKZe27y2s/pvXgwmfH20zQTL
oJ8D+Ps8zdjusVqjAdcsFWsrZVqArrL9o7el2ynFCMzxjwyAxLc7cRmdpzGzzMVP
Y7tV+0VJd65JA6rlGctP4Fi8Mmv8S0RbzM0nf5gt+9/0FvkCylWbxxW15cv3tvO3
kyJMBhWFXrjCNCByXiSCvw5UbJ/M/SUcVfMf73jGGZ6v2CPr6w8H+9b32xfTIEsy
anmlnmhSwGMRVAtcTrtzZcnpFYAp3GX6bUsrrjROW3M19QRegMH7ih5tjJKUu71g
5DjdEqm+EltjJUhI4JMv/xzgcWdUvKUIdD+aa+VDfW06ThGN43ykKy4UeIcspa1i
ZO8Dt/BsHeMWuZPldXeQOjXBiAcpPjCkKTB+Mn+hbQgBdiyQoMZeCBkjRKC0iYwQ
krE18viRmgwSBSQoGv4JOSOaAZH1c5QHzV2Ut997QMM+9giywmv9RoVt8svn1AVF
ixxt5K50uyfFI3Z5N31L75lTe5E9phw+ozE0IVZm1VTAfBT10KSlYyWh7pxxCtdJ
XnPqzHVj8J0Co7MDiB32QCchQKMj0mKBF4+VlEiLg8/4a1upvcQElZ3Lu0nAeGkG
fkgH3T/CVexUJH2N0Dk/oIqvjcUg0IOP9BFqYlHgTDwL+Uvh8AEcstBjf0HXHLUX
BCyaN8QckBIV+slKNHO/07SeqmuDNibB202cZeuF/iY7l+d28ix2/Ly2nAE1bP8K
krB3qGSFm/uxmU3hrECL3Yzl2ZXXzkhyKHwVBxuuop6psocMt2iLaMb3MWchGamj
3zVy1A+gT4+Wp+5U8b3ZaQbxaJKG7P+ARm8Zm0Nlbsr5uP5IYnm55smDo6Js2v+j
5fe+ifN8jFgzPpk58pC8CWG3SjUZzzO+exKvMPGOBSiNuxFVwHoG1nlOkVmCTn5v
C3hpu+akofAkSXVRf9+5MZl09iQlJKCkHJheSYym/cfEzkm6rGfXdWXM+faeyg1t
IGVR5k3kj/HLzg/FzbiRtMbI4sugGUM9RJT9USAoTxsNPb9KSWYcUv+Ew2np5aQi
4JGrFKQJzfxzeu0mBDGRBy/TFx47M8wmDsAIc5ei8+A+OAaBNITFpaaCWKnJj5n0
UMq+x9oiJHvgmPDOt5y9TSISH7BZzZ3kiMZEcKssEYB9Branv7B5Qu+0wTarFOMX
p77nrf3S1ePo5Lzczf86rnbM2PDY3rbzYn7Hfcvk6laGK/k8p7ho4wkyjaHA9K81
d56ptlH5Y+g+pb/HwYcye678bC4oSbxKPJ5yDW4XrHdyBbF6Is09ul07MxhnfJc6
wbLlxnRITGlikZZcj3e7aMhmFimWYual1qtugalpVJ1FLbmWEzxmAuEuxhKhWdKd
Zf/OtcGPZXHTUTCg6SBrvCClyyMkmkJbjpRsFCQwhrf6m+1TCnDlpWCglfd0qfRK
DZm3rMgNPP0SggbQ9L3mYxMMGh5ZRhIKCvZXwu63R3juQRIvi39zDQA6pbkfxgnm
o0A2mSTSHU8d8VwayP0M159INDwvgtNDOS67GTWenoLpppJGnQ5Kv0ArBvSZ9Ipo
Aq3xy4iaoYVrNKgYwQC6FL4+fR7Tei/9qcfb35HfCPVhaov0Z41JVDk3UiVhollx
hygEtvvX7pHRxGj3OSxFno8UixdW2fFvgkLkANY3mips/fQ+QA7WIja5MNXLFoql
M9Fwi14U50KhH3PXovI/UG0bT2QfA4NPG+wdVN2aylF8DsIOWKLofIan1gxh3ieP
Ur8U7M+XAdVc1T/CqZUKNi7r3lbpzbYmteeqCbhq/cHzUGTdKDp43C/alxVmo99Y
DReCTPWWjHMo1WjxG8eT/ePbcv8p6qq8/1I9Be5sUG4+Mxbaku34IGnjmzsEHsBN
MdPc52Tt3QLQQzNpvqPaNdwbMd/8ZSj63XqAVfW3eN72/uxRW/wxegO/y3qFgjHk
Q+OhD7H9nJQPcWRGpeuS3KjDmxemopzvyueJ0uEGmHWwsAjcCKw1l6jrVoYyCDnE
rsLLmWzKo2azmMD8oBXxI22bZ8Ha52EesxONfNsIslVRsCFvUP845q8WND70d1BL
i4fY6aX6CA0p3FfODJcFcpoqGbOHWdKeOzSdhz6WrWBsq5M6NQi2isgp90kfD3BS
FQsAAAAg/NTfGj9Qks4Xiqw/8pbaT6U0gU/AzAz53ID/yRyu+3A9pPx161fFVdxV
vVbBvntq8gvXOJUSb2Df+IkIvnorLYwg0UbHEYovJyovMGSE/eLOL+nIic1pEZsc
YzJWBYypbchsE0Th2ZLCMdGKN+giCMQAq7xLZtWENwF6KN6nGMZ3d0qRMD6JVILh
XNWJ8w+mICguZFK9SpWvDegzJtx7dyMgQrQE6QR4AX2zqfFISJKD3NFabQ9EE2vQ
wZaBtADJKqY6n93QamKSeTrmwoMi9LqXxK48VFDDUhvWEmJo70i3QVMN3W3amzSY
LQBYCjt7vYb9bIkTR449ARxO0DBxwiAo06OJhR6XEhTLyBZGJIqYEBFw3TXRKRYV
hEW07mp3C3oFYLXkUraRkbHTlsaBBeYoJZRpcvHSUzW3apFcF3XjQuRK9lP9XgPx
ZMhYSJniGWmxQnbUVrLYFKM67qJelXrhwiwNUj6ppJmOvT7vSebY0D9w460sHqmQ
FLnXXLSRknQKcOyyoFskDOfhQsYGagzld+OB/PWt/ZgW5bdro86mNbGC7SjNKF96
Ig+hyUZ50qKFP0ppVmfCb0gV85HxfhQUlhpxmmUT4wr07xIDgxE0Xs0qaPhtUS5I
6Z+HLSfgTN2wYLexI3S1IaGCsni2dtFEp1X3GkNjYJzH5zXv84lvpjI6qaRa6pQV
rpPiQYPKFh6fEtDfY0tmoeVoYdvMIhlqpYlOqOw7ylcn/rQiMqsFJZlmRIw4Nani
E+hOclnP9wiSWRch7n5tATy3wXPZxI3ICH/uXnvtA187GOrWrds9ty4f1HH0rvS3
AE7SiVIUseFy05dqpIRhokA2FrJELkBob3LVw6rXho5WeIDpehEuZ2VlX4LoGGXo
ZgEtPQg+S2zDZpOCwr/gO8Gfh55Y6ZH+XUgiLYjQPhTDZx08BWzFlqvRdaWALRqB
6rF2dh74u2vVBmrBq22bo1hejf/Q/xbmzggsrSTCrFD1LnykgjasUZ9elzOprYnI
s/LgZtNlRP+b91+VrXGBmTbt4fyqDC7g0tyKTLpLm03OSYO3D32tIt6VvYVmc0Eo
FyLAa2gFj0VOsWHRchqid2nKmBCC5B3daqD+Agh2FW4aW2vz3U0/fUpEnDhKtZpU
ZnjIbIwtwGMSghieflYEBlcc62106Nq+yJxMn0VGr7O/K60Qsemo2VQbW9EK7TSn
dLWKiModic79ED5qE+8URH1JiLOWfG79J5QiBqki2sfCIPS161YL9TaDzQDTS9rC
XrRc+yznjJcU0BhqlI61v4tdvxjL0M9UE9QpVW4MK3YLUNpb/l4TWtGHpBe6fAtX
oxtbZnurzr+iLMcet8Yu2IwoqNPmG6L0Ln49G+1NuZJcxc12cxd42LHrYSe18Yin
TXpY5uV+jTaypbHcTsImOVsiqyfpKwj6OnZyiooAJPqCrnFieEBoSB5bRFCXNyB4
5DsbgQIo8ouO2Gwx+ImAGTP3xQEPqXHcqrg4BPRVtRbP7ComJnaGYMxKwmwlNMk1
pQcyt2JfP4b90XjNvaAv69jw5z/WVcUdVgZuxJh1K8KBxDftmWara4MipzufebQI
IPbDqSufff6Hv8IAtInIZi2UhQDZBS4AoZncIpioceJHlimHAou7lQrTXy4qSbNQ
lUgPtEU95KGL0ErtSLbDVYl89PAYrg2aooJd+zY9uSciHpTx9vXUh9Xnjkwm5rd6
MVIe/J3SGMJWfcoy9WyWcS/uQdVl1EDWxvF0V/nle1wtRmD2m5mACzFXFEeIuOQF
KI7IfAAA08g1d4nn1MvnGfDilie57DF9urT5M0WYZ3XpojTomIz7O+lhwbWZJfiF
IjKd/3rw8iImDFH4gD6plo4xg2RupKqCHva3QDwTw4mNRt6c0Oa/rdVnJzEyMQAn
RYkcQ66A08d9btncSzRxQLRhfpLZesBDYCKZ1ncNC8PGohCo1jAZ6OJ069Mw06JF
m99aVoA2X2bIQ231y8sxhs05Wm+DPsI+B8X20F/BRwriQPRBv7kqLuxnplEBMi+g
B5K2p3z+72uO0dKz3wmB72AeJHGNQjDT5hQuQLI2BRhFa2QSQVqze/RpTTlML8L3
IOmzkthKsCmRPcCoXsQzSCnZnM8kvAyEFWa3z/4mSE5gnhDP2PWAiV/TpBiF7ASS
/eGH2XzAXE3spRS7R58TuqHbm0WTaEmSkcQAsQNtxi/CaTz8AnlMX5LxaYPTT2Sj
f5vf12w2UJ91SKLYEWZGFsiN/iSYGRLMKM7H9ezc7MMhjgSSMcQDMZ3I1pKQrT1I
pPoJyyaPqo4ks8DN/vALNicU60DxwD5LwH7toWQmQTKb27VRsR9hYA9tds9pZNeG
fZspYT99Bgj9HcE6ZsNGaCel0ZEnt+sawXeS0UymT4D6rIY2z4gSN/UH/BoWSDZs
TqAdI87jI/DF/zGa2bUn8ST914nsR7aRYl6/FPfyjCrAocueE2D2n1GSXMDtmYDn
vwXYII6P/ct8xINKnzZs2ZY9gyiPIIqZ4gH2YagtO30W0EeSexH0X6cPmxmA/cnN
XFB+5OMk+q09j2gZjDMrDkIOUpAqyHhd00a9vuxKXzds9j1xuFeqyyjPrwkv7//C
PnRe6Up9kFq31itiu71jPLza/ezzgb5DxqLO377PiPGfkkrn5OuY8AfsI9/nQM6d
LL8py+vmW7usaVb7Di8kTe+u4PgdwpZfnebVt3oObLxIXutPAa9fy9bza0ctXCtq
35pRK+41b71cT+rT8npRzzSilmnP+tCEmqQx88Mb2mmDfd6clVvLUcDj9GbtuPgA
X75Ha9bGe7c6/pXQy1vz6fAU5itr75rybh2850Z+b/lmubfq4e9Q9WPNvxZfHpba
/uKgzTVmHby5Kmtfpe4tz9rGg/Ckeevgye8lKC+ePgXcdeNBz29lPMj8xgt4IkG4
TAs6Fm8YX7i7juz6XPW7P9Ds3zf4d+841dw3/Izfy+0bP0+inoO/ph0/0Oa9Zvd3
N36ex/pUF9e3NXc9vk6tnWvxNaQm9bv7II+We6Wx/a2Vdz2tNtai9R6/68drynqz
9qWtH7jHzyhfHzTuNXo3fsf4ew48+1M9Xou0ck2rfbnrPSTx9d4Ef72rN+8NxU+y
levf2lh+Hn2pH8O7v701bT1+/JziunydqB/mtO/ttoese0i9v3RPUtCuMKzKVgvy
IjKw0uHwBPjwy/EQXZTweWwo6aBH0QXKSlnDts5E5SbrA5ut11OTl2CDh1nMiOuC
PvOhswS90DxRQxTSD5Mb7CwxIAgA/UmK00/OFGr/o2l2PCF0cI5BTV9HqZqeE6Bk
rMxovxriL/7VWv/0rN3zbwDsX9VwwMXSP9bO2vt4UEee1c0SSjuCto09S4T+6Hlw
UqGQYSXr6kG46yNwCiMAIbn4t+HXHRagKiwjs5wNHz48uIRDVXOq5+ygoZyYHGXg
mDnBBYqgJcfdEkJ3EiZx/L9UhZh5ibNJHFCimQARErT3AeFjvkpjZbxwVzOz/bT0
0tz5UnWCJvZTCu55bKyoOmN32cci1cJMTXghIYTIzhXEOl5vim9UPi0ae/kDNWuN
uP7pwKqbiFjzghsQfIMEWK797kgulT0uPcHMu8K3RHO39JGcK66oulKyssdvWKcG
64MjXZwWjdRIc/n2a2iXEqorGdLEJw6eqHkTDwhkHXKyvjD1C/V5P7SIhGm9cwoZ
LJMr6DT+2dgFyYM6XfOhHzam7/YO4nSEYZ2DLcRdJzwtVm7zr+I803G/M+JDXnKq
aVV94VcNlalqcqpA8EFc6mUW1aPAqbqT2NKyh7ffE1rNJ6h8QqjejgLqCBdQdQi4
I8/qdwMr0/dqW4LK6dwYrkCTblWiUM2igRyvafVuPPX9oIG1rz7gXmFRvp5PsPFl
Z6/LKGR65KNyU5MN7lMEBNLm5ZhZ73fUlPtL3hfca9zq8wmRhXE42vmADtGpETh7
D4A6CO7FfkWHHFtumpl8ZWWlVDy3oxTg8ASCwvwCPjV5or6UyO1PorlHq4AZK4TA
hsejM7gYlUkoAQkTXhR+I8dNWPxb49xciP+TNpaIOKnWJm2baq5ugvxu9x7HkeQN
CJ8bDK1ZwcC/croT/oCPCKMS9xRg39AcrTbDxxHoEcJVHsLczrHsC75eRetawqx7
xYYnYstXBiBgRIm/5a0LomesDwaOxxBouAsMoU8yKs4pI/8ihxtDMt9CR+l8vsDM
Hsqb/jEaE1QXkNf3kiSqop65PidrhM7F5e/76wvoHBFNE0Tu/bFdH+Y2ek5kyFhB
UBz96dv/dyi3BBxUph2/OOKFmiyaQGhodDvoypZ6XWrTCq1HgudDy3Hv+TZna1BA
1K3dDorWVMr5EC1cQw5uIOhFUNsv2l1/IBFf7ORBHJ+aE6y/qgnn/P5pMIM6hllN
btMTj2JGftARKHQ3bRYRrMn63eh5MnN39VlmR9KzYmdf1gaqilZu42R7QKDCv7O/
6aaUBYSgGxVJ/vSL1YM9hLV9gRNUagCt/DS0MV0PtudI7rL6R7IgcMQHtIdYuFRz
vf9fZuQ+fqXCYO8d81RaRCJNVELcBFZ6g/OZptok5zpl1wl5eOc0yFgR6mcG+NiF
/UePsFKK6n8G6UPYOfAAJabEZkPQSnjgN300UCP6tVNr1NM+6LpDjcsQcCGJuI8R
xwMw+zme0Bca/Sfper36ZYbL9GTcwafAIbMgMtWVRZb3GwNSjvo3SM894Jh/3X9o
p7mQHJpdpZNXS6HGgw2yefaSa9sEdIFFl7KjyvEa31Vv08DAxjaimr32Yf+VwEV3
AhE29lCibYV8nuggwioMemzAX5CG8P6dH1ChQJoKbtAKVBAhMlAWScjgrW98xamd
gETkvCB/Pv2YM3Sqd6l04N3tB3JrdrdgSxzpMzKGiaF+L/x/GDsgZbStAACZcTQ0
W3gwMfYJE3jCVYyp2qksD5oAwYj+TEEvjtFzbVfuOEYB9LD2ShFbZkE0F1DcBY8q
82SceVnNIPCNtb9ztokIuMYqUF9IO9j38KjCbiL1Fm/QY17sfKYdB7Kas0XilZaz
MAYI3I43jUqGRA6QgBSLSaTIAs9Xurl/EEq3zUEBCbKit7vrtCGzS652wCeVTD4G
De5KTheqgi+xjsOsff9QYQPC9nPA/BeymW+2CFQoHI4xV966K3LMJwAXWEYi509u
Et2jSLa7ZFpCitwQu70MPa/n+YtPlDHZR8zILwauFRP8QG/ylVQ1B/IcML7Z1Zx9
ZRvmTwDe4RwwXzPtjr+EeNiFTEITmPvesC6yOjLUPj28tzBNuTgJAkfsnzhmVKS0
kbNvECtvTv9sHAYAQ74VZ719rlAqjMq1F8Wwy48iZYk8Zbe2qSh6pJ0JJhxQDGKB
aF8MEngTvAw66HI/bEPCQLZwif5n2PpufejPcLQCkybqMwKoXjKBBu1NOTNPemSy
2uI0ITIdsIjtSbcSzQ5McwIMTBQHohbkUFbSef0JZEbINYP0irXhisVFCzKoITd3
ufFDciNwVwv29pmRY+Ah/Ecx/Q7DP/CmnfNt/beMDHi+4zAUrD72Um6xPczUzOxB
55dXafuMM3tlwLeL766oqfFUgCIqPvlBxVgvbvNmILSKcTM3RZAVsgBFt0JCW5gI
Fxbp+tOobMEQTyzNFLMijHE1V/wHYCwOiEWmdvRkiEVGzQhwpMDrsRLsmfv5BQ5p
vwy1z+ynrLXCL6Gn668h4BArGkK9QE+cs5m+D5pknffXRlSKFBCNCmYAhBfeBh8I
wvoH/qUA+FFxv+3alimbDwhA5Pe1D/rnbgXOYhxyIkgDHnE9+1tCLhyun5wajRVV
qSQA9cIe8g2hgQpCzJjtx0hExhYENqpnpQzS04LvMfcokuVHrJyYOQYgqPiiOp5B
yMlHAAXLc8e9fCS3kPKExHDTrl7IdfDqVFPCLemx9W9lurB0IFqupRr+CtUsHHSc
9pwFOwhJTPffNMk9iqlCMN+EoWqcciePFazPqjqvDwhCLKZOEapcNAeQJdIkaivJ
pGzAqHm8q/o5/Uz/8oxyh12tpyrugcMaPkc7MpC+T1INn9NE8Kd46kTS6BXELzwX
kipeWiQkvdPxh02p3/up6t1AGQR+ReEPELpRgOBYkkAg7okG1c/45bwLIWBZVEbE
/76Eq/Sheou7Lvkvg8xc7RBbVF7oK6sIAMIsCj+MkMPmi78647SUkTsk48dhK0bc
lUZnX0on73l4SoL1xXZ5z2p1bgO8pQ7hQURgqXSPmVKTEEaowzyrxiD+3zR1dkKo
WXgiOVoEwmDm6nng+xRY1fki524+BMuO1MiAEVXxW2CZ+02Nq8nIK/7sFqD/Icu+
FLbkp3xoVfBF9RVXCF4ki3/sS3sdvqSWfTWTHnP6BeYZJCcHGwZPdYOcalYjOT86
WokYxQBIyh0sS5hn5cjyLELiTz4r3rSxvnM+jd6uuj8ApTkmvreBN3zIAAHyOyZ9
gYJJ026vEzyvMKnSXZux1dJbnjacQh1sqBHoh4vBku25YxemqOvz+8/ffh+68JAo
8XB6ugInLmr7Q/2KweOFXbMnksGunp8k0gVWA2byQ/YHLjTV2D9cGBy0h7p/969S
qUgRxCXFpbWynW1EbspfJuZkQITVRf9/DM1jST8HqDwuG5olkACo9Pf3/0bNsfh2
oLlX8Be8ePAMzYBGanpQ+/osXQYBIOqI4OnwGgG5cFtHyX7NrpRCesxk5Z/8Rm6L
JUlFcFeRDeId9mR8vnDLL3/BeKMZYeccM73MLg/xKdXJQMC8cS+J4Ij4zFup7ctD
du6GmrOuYsY0PJVdfjT0AELTAz+siLh48yQPJVctPZtUNyIkeIRvv5MjwjcM/EyE
DnFdePY5n9gQfe3Dp4/HxSc/ire/PXkGf708+c0dT30keRoLZwBU9tl4zJXQ/wE2
h/AXi8CcW2GYdFf0HWu50bkut+4W6x0oZ9AC/NN1v9Lv97KXQaOgPybcw4r4UXXf
BIw8JYddcVnPCwHdO5sch09Y1skgZZrGiL/8YbYPv89fe7Ml/kaX8eiE8DS/x/UW
j2rIl1AkXqbS74W38MtH+N+vtHIg8BnR3lcC95Qq6ySqWO+bVIcHo2ibTQLka67r
u5IXvNbBB83SWh2ZYA6m1OG7oK2MWvbwYeI6qxjm3QQ5/IpiOVJJl8/uWbLKftWY
d9PwZVAMyp6NxmH4F0XEvXgB337ifZaCiU6DdBkuCQzftJNVLXwfnXhrjFJNmG4n
KX3Ct9pp2Qb6tnLXt5m6tP17NB0HI7a3ScbfvJGEU+boLD6wqngdmk55X28hXt/2
+vz9AT125OOAY8ZmnwochOg12l5BNWicCi8nA9V5G6RJl33R2KMSNayLYhD9U7bg
19Q3cKF+dEU7Ys1t9grVcWf9tgAI3Rt8ZE041Ucx4j/9qFfMV3GQ50hFEBfftlX6
KjiHKwsO2HLUnuasF0zZVqeAJzjQLppTH1u6B86QJHewcPF3mFDiw7XA6C7KCdaA
jcjpJFofLfXc88Iy1RiNIwzdVNSAyS7jLkBUm2TjKtE2wa/bKcGANgjVfz0kpsPA
5PxUZYkrvY+j4weQKhKY40Q5qxkbaUFUc6T0scWpbjfMvg5qFqtEMm7CxBJ5joJ4
BoJBHFZ2aPrQEaOAWZQI+/R7o427JsizAXn8WEk/rMyNr4Si8ubORMi4xHUGirG6
oelQVIcr1nbLVmi3m8+te/tucOHrB8X64Ek6bz1vt+5ydZjffwhXSNCnh/cX6ODC
fd6G5gJb79V/SrKUjAqDYCGxK6C/ND/O2odDIMpnjqVPsQqXwX8Z5uy4CRVhNpgx
T8zL84w1kCJs5ZLLjSxzKIRxU0UC5r6ko39g8SaqfSU6pKX8/HkdiCnHAqJ53Cga
3VK1WVb8bZCcXR5BzrzKMJXckbEqErJp2XtA+l41pyB2Fioy6wBOBJE+BHlgAIna
zadX6oyTpzy2uZwYBXd+Q+fUsg46LuSNKz/MyTHndtUMjQtz3+mocwWgNXoEVrj1
+VbUYsEpToc2iDOsKbmID9U1hVZuRX7Y1DJ1wySiTEx8C/Ounh8AkDsM45ggcWkB
1me68AXsIlxBi9LIxgGa9cPt37qENIu2aMephiAXH6xBYNq842dC80Pb3DM6+S4D
d1pD9Gv0872rO98fUSNskbHCa42l8pthD8/qt+kpo6LLosaqslzUug9anHcybo8j
vlyK0/5c3ENrPbkV0n+wus85xP3lCsXwIln1l0qvbEUe9oCn3FloGu9bwubWpTL8
eyFUFUhyQtS0xuZemNUWzG2zlMKqEyagQm0cDkoIIDXjtrTZOXa27/PnTswJTKIH
XjHmt8Tt3/fY9t1vLIb5xQu/C4ioHmI1IZT9BMNvCsWcsBQolDp2oFGv8gEWLExg
btsJ4Ujlp0IpjVl6nNEudDu0MKtCvwP+u4xMn9i3jj4R3LeET8x0Pi3rMN3K6LCj
0saUBOaYlOWa1Kom8eehae8KwmJSeh5ROeW0SU/Ji3P+Rc9kehlc3jpYXtRQzmls
ShYwGy5WKLl/vZkQhfuIipai5oXmH6PrU4KKi3YIS7AjSEYYNMczAHgyYmU/sal3
hqc3TfrEofnzFvF7wbO30YQnWyIjzHt7hVn5g4vtMdFgdmvC3opHm6m7lHKL7bIw
3UAbBeB8UbsjtEk7HvYGcLJjUU5oN90e73tavXzx6S26jF4A3HcwX/gN2/WZILAR
f1tO+gQaxFD18tEDARjAx0bsIiVNik5ie4OgK4dHHPBxXA81Vnbp811ZdfZHvH40
ybyA2FZCsqeSmAlY6K9CejJT4x2dlfVQiZ1jNiNkz8/cVTGzDWK89c4q8yoYb2IT
SFyl5k3ZDBQTyCLET1pqMLP7aLLZxBDkiSYqB80AIMbviTwyEj8mBjjZ8L2A66jB
00jvcxw2HOp8m6YIm6NP6egByvlVy5nNze+r2UTzr58xJsyB0vfEcfeQkOWPMVQm
jWtJ8YoFO7m9GBgJty0+0IUnfoLDvObKfEZa+EZ2bBDLZXxk148HIfhJXuxm4GpF
RhwYnvHiR9iQTgv2nF3IYzVO4Z4xwVt+0ZryGp5YSE6kut98la0TMRnuK2syXnAC
fpwXhCLvcXzGAFlckvFTrtQywlNO1Nkv0oGu/RqEKWhunMnBTUKaxhhJJiC8MRMb
CLOEggwTk2P0xsW4OaRz6z4mYHkZTJ2UqmmxerEH3wPbwlSoqSXIao5aNoZrYHW7
eEWu/TX3U+QSiVbHxpgQFyNSc95/9LjLHeN2wFuDsqMedPavrxGhG7gwGd6ynx/5
8/p6f2G23aOE9Gh8GLTbrAG7PVsj6hkFJBXauRvL21yvTyJLunH69j7fw023mAg8
FjgayqGGI3vML0OE2jsDEopfRt9Ap7gNWFHLIQklWgP6e9zvRai3T9W8b97DMi87
RNi4MiZ/LtGIZXAlfyueAmf88CDkRyXiD+2e7HvgRFXmSeXNknMeuM40ABJEGRE3
R7yFHlp0uzrKoE8xKPuxkYHJBvMnJ+QAYcnahy+gRKh7kY1p+eJdKtSAbcHluFRb
c6PwH6OlxshASH+gkzotevR+19DSh8T1sen6CZOXOWMaI+u9Uz40cLP4Dsvgbicr
/vyAWkfYZtuWEoZxZEu7dq3WdaKmSKSsNJvCLzdRyRHwmocSFdpBCBogI1ZD0pRu
8VmFZ4IfV8FVw4EmYdXJoFxcYYl6hhppCVNREq0IBuQWHnaJLPKbLIq3WKfKpKZb
lMp8dICKy1+/ifmS6qQB1ogOnqtdBP4MCDeD0T01iQ8RuaVubWoa4uM0Q019x3IN
727a3uDAFS3nBY+Hq7zMGHHu42YY8vl1xVz1EMSfMrKo0zzwLT8vdPSHFWtS71xz
BCYh+DUU7RPgJPOx/lMI5EJFER59zbfwgGhihzoZ/igpr8f4Tx0ckCJIVzip1SP8
G8so/1dvzEUpfyQ2w1+dA5CW+VVzYCIorU8DiXLpX5lch46am3xriuTlH1B9FsLL
N9TWBa18BBfNEe13PrZD9Ee2xD+EM2InuE2XSO5hIa2QEPMZZ4Cz3PALGrEJsL7v
g3CWh4Je3xZBMFCmOOdgnE/iZPwGhb0d7RIT1rGd4jhl48xoR3V5RVzquxoAsDpV
mV/uUrjQQ4PZ/ftkw6muZz/TGvPxevnzJnYQ/t38VtBOkz2l9Vvpap423Ia47LB0
Zs7oonylceKufEBEq8/aVSXjnKBP1idrP6q9SrmFodBVUWbubuM+qHLVDyxcPRC4
uFw1MKJgPOx4JJhIxSX226b3GZFaqIdsRrh4IJtTWZd966NYEHO7A3TP/P//jiLa
G5f1hkjmOXsedN1GUS8AWQJHAQMt0ArNtCId546owN2ycbB+eOw+1wgqOX0o73/n
ECtZVyxiDxK4azL7Ow//cvkAGGS7P8mV6HnpD3n/BM+Mz6IDE8P4R/HqxwYt/byz
EG1rMT+3RGP6WE/mqvw02rIKIlZlocMod/v7EU2ziAh8AXKytiuq5u1L4mYaw7iW
l94U0nVtbQrR/WcOlDLMBh+n0wBhjLk2iXDMlw/TGi+e0yxNOgKFnFmp7t9kKFsv
JRriQflFd9/UcORtUhsnx9fGVuxhZXWSulwTQLmdv8XgBc3Ywpn3DYjAl+mHSDP6
j3DX8pi5U0wOTwN5bO6/c2HV5UW0tBhPGdrwGuP1u5EfUmef766Wi+kNoEjFJh18
lhUHeBzCgqOUnFjM0Wq4aPDV7DZsMO/hjTtTO0QXGtxu7I8pRM0r3JjTb/oJ5+cx
1wjYjH174R4pW3YBBrHb8jZLinkF7XzHKVtrcQA//65ExLWMUrOGebv8p8GhSIqm
602ep1KFrz8aZWO01zFvNhFSG+mHsvxksBMUsMoF7RtXX0TQ58YAJ+RsYiv33AoO
JOpARh3FQQYCYhtbdVOCWJxmcOzWDNUIZ7LVa/anV6JgCmPIL5I8rq7tN6GZZ0WU
IzsPOpg7t/IjEFg9cpf8agGEAKCJ1HwwQWqhj36MMQ1qklFLyMwmWtO3Dtmx7jFA
kdivgUQlvKMKPhv7c4u/mMFZU1hQt9gFFQB9eH6KeoC4JLXpJbcU/CBtoaVnAPBc
MRiyF+tQgbBDEqGpMRVQq/8bif5RtstUxJnUmRFUxmqu4dzm42IaMFhou0QJQXuB
u9wXZNimsb8NkU/S0zDN1qlNCFgFAlBaTOaJYEwCQXw6y3EHnxUNOBQDyOYoJCBM
X3x1zJIII3CyxzV7N1QUSbpODsK/1G0ysvxKszMrB404/85z7RaAxNtAi8sW96Ca
N/UrlXvHpw7cehtlrJr1v0UAXL7V7Mck7nZ7LFj4Gb1i4D/ImTYz0Ja1BEWZnm7l
z9LCuGOeEEHg0hVUb28o4n91ZIlZjSk1+42HVyzzhu99SpWx9poRrGZSY8dy6vSx
zr1YmO4v5Jw/HRNiJfkqeCo5tfcfJjwYG9TdYCq+cpc70A1/enc9A+sIHjE261xf
0BAwW1G0iVbjl3RLndgVPkJIH+4NlX0qI3C/3QY26ouDjTWQ9BhKQ+nKrRyKJm5n
hb3rDxHFlUXPa/C4572H+5tLBm8UJHcrHrTXzzhH104JvumnAIIUqqvuBouGZgG+
MYgzmRURE6/iEnrxQ5gd+EaVPsgzHMNrxaBnSOq7+TSlpexnB7Rwwt51a6YH1lsh
OTStVAfI9aTkNcRaGAh+gqHP6W51HHXZU7PHFjsQwxOrhrwlzPWX8f8cuC5bv4As
MGkbVNguWaVDu1jZ+13d02EqrBKXu4FkPRJxDKZP29zmN0RvQ7A0C2UkSIScGT2t
BVMJo2K9Al3eVt9WEsqfHROHBaXBpEXkw5OGBTYTRX5QTwnUjnBYYKBPKApRiWdu
C4nR43+PNMsv3YYovdLgX+nU08WzMOpqDu7bpUTfimGL3wTVesSbYgq1nFfuLB4s
0FbXi1TNFl5iSCKCtBc/WqR4jA7PHrXbDvX0BdmyQHMxKi9M+Bh2VzXNm6v4vCbi
VpyhSjGXwFWFn5P9cWEl1t0sit8zh+eRs7BIszR1T/AShGQMEwB9USU0ZG1zImqv
tEjVRwcnHavCl6koTPvYpTml175NMc3JBqdShoWZMWJBkJarQyHucFCaulqwgN91
aTcE1LAs9LOFrUayyrAKnLN77EJ/nQoc6CchccgKJVhBg4h1kStikWeDdqeWGlQA
x/lTrWWhRc4h6Tp4a9zuUrZryMexnWkF4/c9GubkVBF5Wq5vUwZAsU98wSJ15926
2mbXdrnaAahhzSvvCkwAtnUKBrA7OvERe5iVEqjZ0gV09JtrLZKEOi9HJXgvFMJ6
5duUiMqhkvA9TPiz3hxwPU0USdoJVdk6Ar6yiNi2J0C2f1Y6F4G6Tbm6w5YqRPR8
Nq+YGWwmiUTqX4IjJ8EZ6FbuwKYLy6d/dgYWWuvwyfkTNcNQGxUqPLSQQneejqOp
yqJHLpmXDT+6CFJm8Bii4qZpfx7s8hlpjl9jpyfSRS3+hJkilS0QT6kmX0VTyFxF
11saNoop/6LdekfdHHQzZC8O6y9ofP3aQQ+6q/strmqIFRwUkM8MklSmcWZaNS6n
GZyq2zSZLEr5abEQMa06LOnSi7HNzvuIMxAZl73stRr9GqiiZkqH6SfTxsXol7W/
w+RJAzOkZfCG0ygCwgN0ZD8XH2UZwoSUqaHxgX+aC6LiJyHOyvOVpROCvIIOETbx
Uwbi9038LqtOnALYHdJC5JxkaToWdgnqyO9HAYG+pOOqAaR1Yg8pVWzhrZPZ/gRR
Mnrw0S1SORW8RaTW/VT5dQjrpfreddZpfYsX5NyEdFUQevu0rmRiNaLAElVPGWmt
CINx+SFBo9ZYPFPfQUlMNBBh9wjkZkatAVNpnop4sk6H9foSNrQW0ClEJUBGdAs9
RtAgnjkrnmquqUdpJpW+8FSiWx5AniLR6h/8ijRjHKr6wctH+qiiOXyOeqlx+dVb
9QYSR6gdZoRlh5dL5oRg/DwSGUYRH6GsPlM9AuHLuEr9bnzBTuVjMKaRO8om8KKx
eHi7zqp8CBp305PWczmy7BDC4mACAEZTDgKJ2bQsyV7EAOS7yLgz6UopkC4wAsut
GMlNJYoavBpuOj3qB8lPCzQuvW5mgP/ItlOZTmbmCHBVMyGmMMQYaC359XhFXqJj
VNW0FdEI0a9CPoxIZG2gNbUi5XQLwheG9QAfBbi62gGoFcxQ+ZPuaBN4jAN26dVi
bQ73vfKurOwaoeEYaxLTnJxHtQzIykeQAtedg3zO0332kedi45RSd92n009k1cM8
lfA8w3gi7XqkpEvTNY0V5Mfe8Pe5QzWI5ll+d56+z5nwZ/9gmUouKnOqpQ55ZYdB
iJAZBYCEPmdi1k1YPTCfFmThgA1n0cldbNIHE0DBVGym5a5oCzmz1Acultb4e6jb
17P7COr8lLc8BJ1ytNUloxRvo1h+OQqQVWGfLvOdLufiJW6t4/syPrJ0w8XUG3X5
+CC16dXD8UWG/f1ObOJ8EZ22+SGpO8ybEa9nzVO/ra5PyhcpEr2pSIYmBtV1w1ko
9WZEeg8c0iIzfFgPacuvfl5jgv0oY/2PjE3GHQpVxsawm81jO9ucW+l7da+SmWht
1yi1P39LwfCH3Ju2tl2Gab93hQFMgJeP4sxWWSsZ9t/sMvSDc54Q0owPVTx+IpMS
/3404HjJ0rNEUXdlC8o4pxELkZpLzvz/lJjHVdE+4w8VQdS8V7NEfDaaJe3RTyKH
T8XOYwCzeEzwQ9SMjIQL1baIJdKyWuDX30/t/Qurpx4j1F3i5/GXr3EU05+e0dTV
Oj38WLEyA8VeeDVYEwyIkhzCIFn45JkHdzgoRhsBpb68yfa0U4J3EhKQy4bYnqco
bOo/hrVxYA5o6vxeYZ5UHOZlUS0PopvoQE91vo/aL5wBQlkl2UanQRihLdHYKygZ
CeQVuWsRRXy9eStuWei4EyEunYFAr5fKnlvz+ZDGDna/q/fWzQCg6FMO6/g1gmkp
3Rix9IYHs9R6HeBRCSr0ca9Vbp+S5OOKAwk5jXBE9fFUOHDIuYsQ8zzS8ON4Oqph
Jw5rDmIcPexvvV3gUvw9UFW83+K0o8bWvW1/G4Pxlu0z7vJj9mdSEfvck1GF0BrO
RMvx1NzUgIeEnAet3zaSEmHxcJEhmNe3u0jNaPHY+eiAgjNHZRp6R+wfP3+j4zGV
0Ay7tG7lrsgiqJ47ucl1eEs5fzAyVUwh6JXcJflw/fmC0vxdLlO1KNcRkQIdrX3t
ap/WQH2R4ZkjTjvMI8DTEz87gsR86COhiD6iktArf9Wo8GgAkJ1IB5ZlQe5PptF1
jahQsQQll5LmJPhZwRKKU90Li0Mqn6k5CQJSWnsGEiBHpqX1JFH0vwyVuKuLzkY3
Qaj9CwMWZtV31sEPRGVDVcv8V8pGPqrhrVZNnp6TPqF7DBtdMhCi9i1kPpRxZVbx
5zJTIvGB07ArhY9w6vlAyZrpUJzoHcA43XZOPo/0Oxfkp40FiWyfl5jaDB9419rf
FJRh/zBVrfMHz0McKJCDFIxh3X23RGqFDY+AQ1e+eY8xM9SXrWsKFCq7nnxbTCs1
rvghFQgxo5iU8jS9bwhtUM42/OwDCmoEEsA+T1hvfKwgdr2JItnkpe0AKU0kE570
oNMLk1yvVX6Wpy/vN8S7HS7nGUDEubf0y9t9btJJqWXgpDoSqcJFjZ9tdHxcsaON
34fbeyqVBHFW5c8gWDCpB9ALE2u3X/pxsWn1WZHcNfas5ltXmWtyZGXGAL5yfz8a
k/hUvw+eWI+T1jRuGUj31SK8UDFbd37qboqos2iNdtrB3BGItaOehIDLdCOBbg8M
U7gwCvg6267NjSncxIV2L9vmueTBS5H8CogKhfLA81FwpgoWQSmdIh2JD6tPptbW
k37iVzkE9ESVn/o/nsdcpOhIMSQpr139rMgHqu+X9tkva6cVyJTLMRcQV9IKg4Lq
48+Ozcg1dyouD+35Fgl6huxZbLG/emieKcN8yoqAe8J1CLNDFtQVyuTG6T3WdhvH
iclQRmVGahMFEgltduWV/tEsR68rpac0YEIgpUrzsFfnpKOgzsqD4WJdsgpfad8F
pwEXCuT95hMegWtq1qjbU8O6JPVpExf+m1+8X8Ota5Gu7Uu+/Umhm5or6OtHLdT7
dqGzhyIT/QXBi0gPfzPu/dcpMr6U+TIe0B85paO96sM1Wow+DFf0bbXxBUPvfd+t
OSWoAcek3fTbo7DxrAH5UfzdufGKjsa75mGqM4m0abH3bnf6d94/TW03Z9EbSoMU
i7UhuUaKSZkdLl6gCzQEu3Dm6ms99lTrs63kxb77vuvKDxqpasg27Rc64EzmU4Bk
VvxdvS6mUKVhiwsUR+qH2TEJV6JnC4aMpsJ/Q4BXkv3IjQVvtAnLgfcfniw/EDBW
10NAZf0w0iT54K/Fg4L+tX8wALXZAC8GcIh03619Y2Qg0KrHQ6918iRxk/NcRNjY
jUeOwhdysc+TSocun80/pZDY00mB9LYrFK3W5VoIO5Gw0ZITqUPUQMqBjgKvtHVj
HMUI4+W3INFqL2y94yOsInRY+41xAXfCJ+EXVvzgRoq3OSwlh1LJaMnpft25Z/gB
7ImTEXjoghXy/tdnVDRXnmgrpoRskTiyQ5lmKmxcGRGaCSQrG3Fi/tSM6v3Ojc1b
MK34/qEvgIr7KaAx0JHboEDDTq2tginFr5gcHYrDGvRfjxaYTxw4QzvehHjPXIgd
BM5KK9BGHXJu39qYAdeA0vpvxiNupDOBh+7F6SW7J9QfOURaXqub32EqB+jzxbR9
nGDo10hzCBvA5iqSBGUIlznMDFqu3QqGX/7AMZ0mIbGo4e1LmxFwIFSeTpG7qo44
EOIJ4hQf7cAxUa9vD8xtE6YOQC/Yz9K4MtKGQHJwmAwC6j/NJhNXX9c5fHHLQk8n
ex8DVwcI/PxtQs9xW18AZW+utk2krnFSip1zs69IcetULBuOxzOKT+2e6vD7qjSR
VPhGxVCk+Arg627Q0mdlNMcwwTT67fhTiT4nL49Nyac77/Jh5pCiR+ieURYj/uoS
Rswxo60MSAYEKgBoHuFuvT5cmAEe8Q610Hk0H29Ty5N+oXMLhziY9JSfiTnP2w8r
QK3+Y0Ti9KeQ1LPVaHXgi0RnOh4WjKh/j6feaAKgwnfyyWLtIO60zTd1fk7t2Lin
hhwzw2oH4LD6ZBVGOWRGrmdE0uSKZO+BjXlHMshqr4TqDb0ezBWiKiOlBCgDPnA4
ZO8BVjXArlaIYCEJD4Sgg5SCYzs8BxczQVdWuIUTgOWgO0soKUESOhIvOvEmO/Sr
68Py5QDOI3g/W8kMYOQVCj3OVpHRhHEfBcJYuqx5eqCDs+aP/s/w6AgXezFHFqat
jfevAnviD62WAckvRNhD/hmN8ieBQWAS1O/ab3z5nJ3chEMnhQsU5Aiy27UFhplq
V/jKxmfMbTtaawMLs2V3APt9X5yPgXy9KC/wAxk8Byb8lCVwDfhN+a+1u39eS5wU
FLh869fqTmDW4EUDYqbC5rUF4WZGUPVvTlBg/UmEzw/e4ZCghpDM2i4BqvxHgfzm
JjTb+GEqcMWRY5I9uK01ZLZD9drRUQ4/FVLR2uWUX63xGFgOkPW4zHsm3e2mHKT/
2Pq++AFmFXV4pX4hJfi/aivfS/EI1K7leYC+VcmUlWWB/hm/nlEeHpOHuXR8UvWX
wTHT/p6eZd1X10GLgUrivbkHrmu13mze7B6j+vle6b4sL/pDiH9aHyPWP1qCKmXh
0ekpb3/O0Q0BO1k5fqwGV7LiCqsOK7gqppsOWTvrkVW+F8MHHgkwybZCkMCvaXX/
O6BeKPBmiYIl5FeYQOpNr9YQHZL+w57w0Pd4dzV16NDolUbn447jIftHD+8G9of8
Z1huCURALhEjfe6VE1FQ/yS6Y0yS59kiOoV7ZiAsWJ8OjezlP6VoLe+Bqp3lydO8
5FwjaeLBu3TP4pYiLk8ND+kn0YHMn56rAUQyCMiGxusDX+Pk97W94Ob71Dhb2IuH
0U9CcLjvevJ9L3y877Sj573FZfgH5X/2VXh0uVO2CzAhmu7hjew3tUeAd9bwwYb1
J2FS/vZaCG5aDH8hAEymNBkrXMamkY1WDdXlIK/bDFrYyq6Op/gY3jeRefHaDD/T
B2P22s+AxqAlH5+zf5pNSjcNyRSn3FnY5VTIE5v4R99cC5u3MTbdChec5/jf5m5t
eqGYasC75zydu+qqZeKmM7W48UcdRys5g8nss4igPBOm/iuJtH7I2OoH1DXsh5NL
KBMwx6gSUApMDvcIGUZJ+A9XxYiisWNxvZZKwAHG9ENdIiCiqGLuUci+mAno8Hdy
BEFGLihEBAVoeKDO4jSOC/spfwqOdkE56UFwpBIfGmcgjMfRHlEjCesRIZjFnW46
gZI79mMKQQgTSuBiV2GQYxSMJLM1zBi0etXfmNEJwYM8IsHVgQMjMJh17ukAc9yc
svEpS4jcovya/fmVvJ7ucwMinJU8D2YMxb3iKeLKiTKj00FzifMthWgkKDOXVvAz
b11HPbH5HsMhMmG2+QB46/kohUkRdFSniFuyb+uoXRWOSttc/IkYbowwOCPfsboq
nI2zFnSn01aFxrliUpzEl2xN9qvYi6awxAjsb8FLb8EJBydfnz9Y4E5tre477Rk4
9DCkWB1bS2/CcFSG/3EyRD5oTs82WyQTIuJLNis/k2zNakCBDV/fIOJZeTHCujIT
tQ3L4gUIBtiXECcKlzxDUGMjFB+lCqycgJk6krQUqm6umxygdYbMiawZ1LPmUcsv
i3AROmzDEkRXbrt1+UklYOjSga4899YOHbduDiAXA4zatVrH4bk5R6j9/gp07UTD
PpBn1MAcZXoDj873oxJEjmxjO+9wZXvznkhgjqeMKuv/WI5KUj3J1JhT+dpldRjP
+wrT3ib+dxUinALQKzgZNE4OLKgc1tluJvg+EpmR9jjXlssgGkWTioxFM+WzblhM
s+kkwPrH/mqkpTP9PWd+QNb5uL5nQKP5fuEELuRMIOz+Fi7bxqsk7SP4yWTB561K
/GT8hzPbUuKDOO1Cm66TnivsFaLmkNzVZYN612/6KwW8FPuamumsi5MyKBvEp6QJ
nBEMNMpveBMRsIJaxj2OCHubIRnUkvNEUXuyw2H42Rf3+rk12hwiuaYauSKucnZl
otW02oCrxn7lhmBbZOeBdHxsqkZlMqDCm4qWDRI3C7BAziCUeZNh+xuw7l3AR2jJ
eb/dgUILdqkLZkrDoRc0AUK4jpWtm9xa5ImnZt6LYbgckC6nnNQBgaQD6ljBVjpY
6JjsZ4CZmXF5IWadXYfZYVsGHzFddnbfENcI/hNCVi8pjBhAg8aIVs7uPJ3qzPkM
MDkr7iTSYxaVmf9GEMZU9ozK4JGflz9hhF859pElimwX2q+h/+yNkXnAeWJLt+VK
VOMA50kIB7h1P+Sk66oSPhtmO75pjjlRNJrlto1EHsA3cBXdXvIB+8Suy6BDOHYN
cr6FcrMnIEhFpymRb14OVpDBcjJYNgPrbPy+pSiX3VR61/tkLNSkQpymj1xtr0wy
6zpgq6f59UC5kBMC5TDulpyae+7RVGeYzJtOtR5MWpdRXNKT9C7c01isAASMkykT
hHdh9jpeuHzBPHLJ/vC+WhPXUxO85ywewGuL0bjceh4uBwcIQWae728GI2BQj+dA
H4SgiVjhb0cJl8Y3Qyy3f5tQ7yoOFqpojkeBB/Y0szMCR0D1+S335LppJGAZIFdR
L2TEHXn9wES08h7iuvIJaV250FFMUFdujIhfeRFJXZlVHJHxK2c6rqT7ypFI58qa
zuWkqAxDZJVDI0blw1Szsh+q5sqpTU1XTkQ9XRla9WsgBsjQDUcWtCD24ENlVBLR
SoMFlpJc5iImHHqyn/Pe7ptyuQbUENJVgnjT1RKr4XzcRFoF7kXP8YmraWrzLldI
ZyQ9eGvPy/9pRsLPtH9XbHiN6yIYtlYOENQ0LWWAjJKRdBK6sig7zC+5qwCs+1RE
VY4r+yKUgztksbJezLbsAy/53Fc3HPp9I0n6JqOIrNL37KW+rgM/dX9M1n7NtZIa
FvYTonU5jXo6FkPdWez6JrhFW0Kf39G+WasitG9516vkkWy3bD4t7kvkCKVrrQlF
m6iW882W1L14CefsiNgaKvIDM0LNmIs6koLJUVwt8veINuNBILjhpniwqYhVgFDv
Ca8+DqOIXQKQaRmAf/GGd2lBdblxgEKBSreb4Auj3AfyF9YYIYY3zr8ig8cFY7AR
R/LbgWD58OaxEDbPxI5IJOnIaJi2Cr+XsdqPm228A6xdq8a8ol3mSizv8OjZRrTu
OZuEWTdYFN0VN/H0ZFZBliI9yF3Za2tsDoR6lfrfI0O6x6u+T6X75jj94UoZkH4D
FjtmCL3ueX7kFEhPWKBPJ6Sn1AO+acW1aeGPyfjNM8s1TCaJPJxGNr1sRITYXfzi
jx32smZRTSEa+nGlvXMFo+TtmKl0CbPdaRbex33Vse2pGUzXFO14KjgC7LNhIY6H
8DVihpykbCNdaHYkuPe1FbtUU8NHmURyPHarj1/PozSbnPCMyP74XAx/3cj6KdJ0
ISxoIbOM29+jm8eWWz/bCW8NOukBadtwTK5jtVSHQzsb7Lfh2aWr66IB30Jdx7Qx
1ATKZ1qe6sgSBFQJQd0+tWjGpudPrHZEF3vxV3/4WclLU76Ge6vLtfdOt4Gy2Ta0
tcusn0XncaC3Y5OR/3kfzPpMx//GlG3OOjXcq2eeJQNhcZWuoN+eE8F8KuywMnTv
oEchINBgH++mK3OdmWOsXNrXt+S5bNDROo0D7MWFBzK2PN+AULzDWqXS7jX3h6Sx
dVthDotKpxC12FvxruOxydiHt22LlQMK4NwhIe3d93MKYW+nK+0pjV+PAVavQQdy
KX0vR1OS/14q1Oa7X/jouF5Vs3YEoBJfOVVmazHCme64763jmmw+25cfaRZXSMc6
HLsu55sBNmReGNNzXTGLmdFi5289IdITxYvLZQfTDNApIPBQ7GaxNRPXJZhbtr1l
1oSEJjWTwXF8hdn0fwiD5yDI0UukDzKmScyy22FFys/TK++ybp20uBVVZYUO2Uz4
4HIBpJNQsGOlK7iU7Hib74c+ij9/AZmCQe0MlIOm8rA9AEg/0+f7L6rZ2RwhBDEB
oty1nJ4cvPTJVtlwvUbrWN+xT1qfAFfbf9sYuxqDlLGkD786qfblek3ULjp63Btu
aRhE93rhN/IjWRn2nie/Ayi67NJ985D5Sjc5wJi/lPQ6uPHihqZtJaI8oZNQYuSk
OGMqd7AIGG4pA937imC+fqvRnb+d6yDO0L865m3lnQuUHsukke6wKedlN7LhyVtA
EY0h1s0Fo/nFMUd/OqRZ6alNeUxmcTtX1OoUMh0Cm8bdznhswM5DL8KlBkufe4XT
Zj2L3adCZxCC0R4O/Gf7dNn5Xda9aySnTD+Lr5ABJHj8f/edmt5weWvTIn5M/Kpr
ZOmRym4JWD5IEBnpQCvRNwsXNHtwnz1gY2dN6b4vZA+V5lcoZFaWVj5cRa5TXF47
QmmWxeEwGUKL4EXz+EjZHpepJKMvYhqIpeuoFHSda3fAYUO7kzK9ycFUwDfChZkw
BgfvBVRwnLuoo87QcLxdHzsL9zz7p2qBqjreXJ1YAsQTj4Bma5JPbJ04EuTY85LT
7TBFO81kMCx86QglvpGtYmqeqYju8M3GvfLoEuXpzarljKyRgXQtiuxGd1s6aqx5
sifikAt3j5KkMGjLyGvP9uA+CD42n9HklP+ZzI+i8sLS7S1y880x0RnEcZgQw0kr
DdAH+uQ+rmUZMzbUU0Odk0tca3MPYezXZU9WtTQ/qUyLhT3mIBAGUg+wIxyyGFgV
lbvO9ocRTUGmMolUEV275JRqnJMxv88rwmouiEeqVR7wmfufKGuakxNKhlp22mZn
6Oqe+CeEKeSGEE4kTh4r4UShdlomBKlWpW+JseaTQLDAjTxogE6BXk3QfRQ5aYg5
YIZ+FOWv3+/rNysR2NbHxBZ+XwfzjtN9lMD92ep82Aq369zcXeWvV5jM1uBOBQic
T6hQOSAFSZ7RoJmAQQMWZAgA8Y5zF7RtSjQ+EzzShTtJLMg32TMKNgZ5WVZ+FYDr
oIHnN1QspU+rf4EqFzfhqVM0qkcvH9ZuOyLsaj7uuzRHOCAyzbFv2a8nMHwrqjke
6QOpDSVuVUc9fDpEYjeUPPJvsopQ9RRKZNhMcObK0RofT9rBwbiO2RcbCGv6WzYU
n1MJ0N0ueqkFBUMkGZUzv5mIgSVNXHXRdwZXQ0LUivmCNKu1fJkeSpSc4j3V9491
DxfundsL1T5Qye+uZG/rB/fekcvDgu5vfN1FkkeYf2kcEgIhkq+hj6MOHO8vDeKm
nZ51ZjCgETITXfP1iE5RxAMYcwO5rxcE4wGJZlks/RCgPGGx1/5eIfCeFi503Hfl
HNbP8QL8NPstFItIuDaTUh9vsuGYc42Gxd/48mMjZ2rXiNLG6rB2rCG3T3ucB1UX
6D3DvKjATDyuIkOipYafeGIoFNHsLspB2Gi8BggIbr/k9nlTWYN7jciRK1jAMzEX
UPDPiLRHXmjzgzCGEncwYwJAOECaXFTVjQC6cpyRC3JUbKQJibgj0vfg70soC9Mf
6kDWsaydR/SMgEsqUsYFhgHInmq9zB599SuUS8Juy/1hfUkHXv2Upu4KSVWYFoKd
7G0mtMA+t9tzc7ZNOTv9PjipdpwhHmCx+7erKd1uaEnt/F69jePr4nRmtmyqlGKG
GlTrVWDsOO/m++Fx36uiSQIsN/XT8EfMltsuq4tpcJqjYOTpwIHdpS5X5EM+RMC/
eXcqPYm5ryNcdKvQB5VXCIFrCtE+9mgoFS4gI8raw0u+kOhchPhjgh2bPcCROAx3
PDd6QtDE1jpAGEKycQqx4HE1oK9DX5G6Fb5LFtkdrfsCXTfTJw9qsZvVJieyi4yv
Y+0f75nnud08TcQ7MODvjlwSe+coe0Hq+T3xC+tFzV6QmXZltiE3rpv6ILTqEf/b
fR3lHPSEhKyGRTO6wVxUbOeJz+ShIwkigjd9fBxCqR559aRkNeP5vWEx0aBT62O+
Bf2ZQ1OBPNOJG6gyuaToJAZjQQsp/ceErBNGZmbShp9xouUDniX0GqFENK4ItUs5
K5xIn4fS7Lcc8Qrm4OmWESFVeWwv5o8MHqOCnArsryd1qm2r/xDMkBSOKdxRVAgY
fS6JrkRTYFitCGFw67txQRP4D/wdkQLmxD60CdmC+5gLQiNDBGmX7IBhwufjeAwv
7/ut06zI70zVfc3AUl3nXJkFfDL1ALewOr6LI6xY4vYoCgxdAKvpTsmLOHo/CNtF
NkfnU/W+bIgmK+rqW5QcgGkBTVvzIgLFFWWu8YwX7egKAlk5eMTSD5lyv/qPr/MA
/8oF3uSqugxLh+NyH8LcWXI+bLYBIrnvkI+B5M35Bplekv5jw8XaDpDpx0UHZmKR
4FsuNn+7hWAPJKnL622IIU9nGZDhZDarQ/9R+qfLU8Ce/vC5NombUWlR4oYfK8iL
D7dBgHccLAj4Fl8jdnIJUxG4h6vfv+yUSC4KzTgpFyNnubAw126VC/EHKgr5BeFN
KFVPm6FQaRKGXsUnIahS+QynoW0M4Kgdjt2QfT2DI/ymbho1qlL7mVCYO6CMnrlD
DdXzpbKJHo7Oe9bJohmKpB2ctncoRmc84GHgBOf1SBDblyXb4JnlOOfO+qlBBHZ0
nYYHMkM4pRk5VlsDx9SndcFFUvMJ/8q8qGnqjqwfZNXkDnRXe2iRBRXvqBjEsadS
FKSfECHDvu6KLFMqahcGVvu29QpQcD6d2tudhqgdL0zbeGUUtoXJQMstsm/aD/8f
ZEyY7FkflvhVoNqpCeWfCVW0QN+iSAr4VEQ+oPAE1Ba2luRb5IWfYu/MFtGpidfo
zzW9h1l5zRJaXUuo5uD1dqAUMPKmpmr1VXeorKeNOW5R19zNtnlp1myVcmGDYQHj
vzhlvP0i4yRxttipD70uUqcRXwDyZBMCH3uswfF8lIYXXM5f+3+IPzg8DlhonGVQ
knHipbCg7kvu1Bw5Eq8c6QZ2ltJIeetzcBdN+OljgfynPhgXZimfZpLgkwe6IaeL
LiINv8Aj9jvJjxzKkFUhPnTRZMniH8ILPXQULOh3ah/P++W/xehjqTrALT+N0Dzy
Pkl4P1wAXwr4nIxEsZlF6vUsscBdZ6O8x2CKc0/CCO0LLUOsNCyoQqfdiLFO6G3i
UzDBRLnUOnaYDxeYv6EOtkIYvDvfe6ZJk5GcNIL4XKg9ZXhMwMFISEl5mMxC6A5i
A1pxiNzLk9wZLwS+y2z8DMMKD6z7OI13TFzZj4suH1bHOz/FjGipbhLqyE2j9eV9
SpOEcSsUNglbk4JmZnzfmjWnlFmrU+2I29gQxjlfPgKpuE3Ndzy2d/tXpLILubIw
DXC5Cx7ZQ8CrsIEBAB+C7ECGyBIdpC9QFvYkm0k92yxIbv9FSG1JfeN2Z4nZGt5C
9K+XbDY6oJbvqhVh9xv0MYLZ0h/KVlwOxx0sC0wcgq5DAddIE+H6BIh68uFEgBs1
IXQF0ImM8a2PjcKUixCM7DEckGMUZrGsak1Tjz4HXCinquXoCzpYw1qg+ZX9PyUk
FWM+iM0CJWPNFZPPwqtz+s9qbID4va+1qJowo3m7BhI8T5LC5Itef5E+FPwrO6Bz
Ix+YGzJTEc2sZIvZI5DQCtB+MCj7ZFM7Trd8wE0/AVWOkXL/r0LUcmNf8kGXCuVn
IRt9xTqY9cvj0OLPSwfu9ZWIEBn7xAHjccs/1qu/Lx0aLxwcLxvlnv1bPKRIv7I8
TtDWaC/RUH2fCu3w/eRn7/FTJPvlusa6ogDaAi0CrFE6jKeUVgMrrcIpLe2uYayg
5GLcmzAgcLirZf7MiNvhbnYCkjm0mcw17KqAG9rd7UXMOY0Vopj1R7m90U0CeNyO
QnRU4VNKACPwaScWpekDsO2zcP2AweYd/HrzgWnMYw1Umi7zt6wEj/Qk9D+1DGzX
0q50MTYrQkxOXRPBK5vlHDJVYfeMjbYE75wMxotAPaYWKjRdXw6eORXIF2JTP5kn
SKslP5jF9YHX9mBK7VFgZlEhGXj7OBle96+lr8AzZ3sUOnL37TsmLwMjq5JnRfTf
jm4Pratx6QTIbqK7OtO305fWAM0vPrum7Y+Qx5rxWDGlpYOVHbgbklvB2YTAQPPJ
gmrIlvRRvVYLP3/7dDvP+BT9QVUNxnm/rj65Ahoiq21SwViT6xYfLwemm7l4bXlq
fj91GhqMbVDx3jRCpKH9yP5w49mSt88g5DRWQcGMFQOvtOKxGi8kYA6ke/zkLQeZ
oY6IjuoVyX33JrVB7B9+ZiEsXd+BlPQRnQpC4HE4HDVO1I+7sVw2W6JNdUAYxm2J
Osb97Y2kpCwgKVxfFjtyAokCSmUMoqt1AAAuCmgZUeqiq3LTPZ+JbFuj8bC6AKfA
w4/TiXPncEj3pmDt7R9Oo1kVZQflA4Oqkm6b8Z7upsy8PeiTugDq/REjXC4EveQi
8uogdrFgbyXxWeQLlQrXjKnewOY9t8jI14SmySKL3Zi4BBnRn9ne9mNARsVsgESu
HxZsjmP5bbyWQpGBfhSzHLKE6eFX2Md4rVr9Oo6YN1d6H1r2cemHJ9hJMYAnMXq4
ENN7WCpHVDzMn3xddvals3UyJmuxFCuuxMnzngrIj1r+0cdVyR3rZ+C5Q9Xi4j4I
gaGRT/xUbK3YR8p5FI/187doiLk/zm7J98ej9oojsG5gG9uzKqIZwf6bC3SWj2hB
xPrsrv1mtDi/A4qQ6aWY9Y1v9rXHWea0d5jGukeibuFlLV3EMGlVgbyLSI8o1lYv
43YQPQLMbyYiJKKl5nGQoZ9fTtPrcRvthiUbMG/ZPj72tvCgWdraBuWKhAILMnDD
zFlP5+gL+lhLlFghOuw28uQMjcSOf+PQtttyAfYkd2cIGFCuDqudRyp8PRNsBF8F
6z3Z8RpGLz3RtC3Qp8EWTXac5pbFghgEj8JDX0fT+LQFtYV88CB34YJiGur4sDUf
krG/ZDY4gbGoz6zqRs0LxG58eOqpNhpfJdx2Xy9waMQd0/QywrirF/e/z8sqeO0D
Gdhn/AAAnLaMI/xw1tHNeJ6yErQfSwwfQKEdmqF+g17AdCE81BAXbIimIAKXKaVD
JL921hdBgb2oIRv8e4rro0ObKDPssPKoDttJ1vfjTBT2Kka7aIfSRPIDXvnEBRLC
POJCkTtXXvN7jimJF0g6fRRtt+wKw4jcwqN6k5iBecMf0UlEn6dDo2StwBIzctRY
gUXrAdzj+rQsGC/EIdWxni3DrM5kFjSZMEo5Baxv3zuXAnyR65bIw4SQhzHpub98
sEIvEO/w6S8sZ5wH5TV3h18EQ9V+jHWDnECPVNi5avdglewJSby2bG6ixdUwkxpF
zYToun3iM7ZOkSDOUz6GpdSH0WysaamPvk4v52Csmyjy4serHYxXHiWvySbP7tqk
CfPMuUtF9fXRPnT5sm2e/cBmO8AR91I20ppx8jLO5wxGspJLg8JsBX3lUHcLi4QZ
dDRJ6dZ6TokOcl2Q+8ZFqLWAS8ZK4GNOKwxqHJkOgbBpUdYhMecNXZmwlaLVuBiC
WXcRfQ8TmiXXIKOM8bpjvM7s1vUP3JNt4Y/r9wxd7bS2ipnA3eIcfWLL6dcQz1/H
S+etg6YrNwdddHp0xvFHjvLGY4J8WMhewB+3NuC7bOP+8ME/KPR0WfVIemT9ifXg
Zzf32OX7wzL/W4fqLNlHkuHlohfXeYxvnaZkrLGKR09f98HICbZ4Hm+Qr2+8IZs5
9nUNFWHiDabC5o3JTY4ZT6ek+iL/T+mWzqc1jn07lTmGPCb78usu8GyvYdCxKf8b
XAetDoMXhq80GYueqRdvbXIm8l3yfkoy9mcETIZh8+sNi9hWcuDirwhmVBgASqTd
HyPfS7zBeKuaDhf+nj7PHdVzfIZdEv1Ldy+CHlEIY1DAa0Vxz21y9noeDOK6C7Ik
rUMMNrsP8elNHgkIFaxSoYFESU6xTTlrtVKHctfHxuFv3jSADAxtLx2PyIKt80iy
S4oOwIGKDhNJsC4RntPhK2pboaBzGODgBfjcrP9HrMi6863ODDTUTaKrL7l6wmeF
ve0GWCy+IC1ledSKXzadkJuUU9DU7SC4FcmTlnOQEAOlwWolT92ifki3f/ELKyry
tNm0XfgWSZURwpI6iPWPmoiadMb2I5AylJBU4eOkBd+vIhJEJtHg7ONC5fVVlINH
nOIi65gY+CckrGmR3bguxyG40syAndWs2pyjvdFQX2uo6XAjwIqIWLJCoKox+GSe
TIrgQz0b7N4hlPJWREY6h0JrppDaYRfMV/VWZL75n/gZ/aJ5aJd6lNHBlLp9haoQ
OTmwnvIYS06IwCKPcEi/c9FQCL9F11CdD7W5+DyOBp4VqtAiA+/inrc4Z2i7ilHc
QvA548u51o4LQc4SzgZmDxAoAOgZ/JRWGiTeuD+iBmlyPnh+TQ1c/3BDuXHDYXG4
zgfhqVf7I72IumZ8iFwWNfXT54Y7B+F6rXRkbrNIRL+D2kSqH+VzWj0fQ9z7cCk4
HHuED+AND979j7amVXXHxyTkIRiyKQL7aAse5gsrZ0kwzQAITd6OQZDBZGwwSouU
uMW8+ebdjWlKXLyF9Qu534bUImwfC5mgl5eRfjxXvByeFTY7o5Mcj1zf7ub4aApB
/MDi4ppW746tl1p+3g/1a6vYNipF/n23clH2H8WyutKJQF/26VrPjhIIHvmK9jUH
hOHUFo563qbPRigxZHlW2zAF7eRtnCvN4WcsZY4DQVSaV3cR2FbXOryNUHTIJaFT
bmJ93hGQh+szKUA7XtuFEfGbE2xZ3GwuTqSejKEXma0nrDwzUinmMhs/KTpNZQs/
jRTcBZloKiuHdlDyhOy7b0lAp1ydd21vc0G/a9U6nkPECQ1Likt1+iSiomBupvDh
9OILss7g7PA06yYe176ZofDCvphW28MTe/vhwHFT2mvp7DYNPltqz0F844jhoSOH
s+zEsH60gayn9rxF5l0xMbrwuS3S1Yy9ww7iH6HXkbfWKhBmxK6Qb9MeNyBixct9
YGt5FagpgNpQ/3LMjbzYzvxx1O/66NuCUCdYl9Zho82+5HBVvByEm8768zKxLKEL
JJn+zoyNqHq+2550UyF+fhOiLOF/248Ld2bySvl5XK05nDrR2mE23cgSRi+V4ba6
3OehAv2glPx9adedsZQR94UNDYc3oG7c913Iajnc9PY2/F6xQBxEnIXkeCEbQOqp
Dl3t72Y85r1pUBjpg11Ol2eRi/8id4zoMnIAzI8dy+RRD8dZ4i5QwcNxMXiBFFcL
x7WpNbumQ6DjuaCxahqjTSQi6Fy0g4kQm5sa1AbvMEMY+sIJ37Ok6CNH4AbCVMoK
3Gwh6vX+nAlX1WyYC+5Zlp3pOm6H63wgVNSTWcUfXGDFEiTbr3wlVpXgHuaNmelT
HYtlM7umzYelCJEJiLylmT9b9HC1yS2ixA28DcOB16i4G7ROf9lfUyOmMyiGym2Q
hb5PK2VVXlH0IXKa0sqQtVGizuDOfQ/7YyhOr/xWo+RhsKFhA7++pA1mS09GUY9p
sxBYa1xDJaLxHjOfGFSbXb2iZ0v1meuZHWnwN2Y0MmJSxly2EySD9M6BhqRvg11/
DjxhcQBhPuU0HD5e6JzFQ9s72Ls+Qh3cBsKrL/Z7jPD00GRyC9YBZjKAQFggJ/ps
rsHYfdmFNmTOzqCtAfnoyiipCfKrc+/E6JfpNfb2a/IIlPx5F31gVELS4KCgeqlE
bl6kGpDNMX638zKCTWw9cSczQ+QVNA+IiAB8eJieEeF3ygt1ke/5y31N2v5UMtvi
k3knkeCL8TmsMPNBvnRDD5/kPHKAu6nLxh2e/ZX0nIHS5UqpkUjbcUMPv22olJvM
+GwsENj/8TbJVL3aRw4Xux/xsBQtX1qM3rwKf+gWkBUSDaSZD6szYcC8ZkKyGpys
Zli0vnmpPuszOi6nfXP3Fj7lg4gLOIEKSX/2QAULef2RUl1EgaWw6iLV13YVZvji
Jv3tXekUFl4hZD/Ta3CGGD0jPwMfNSAsDWxRvHpwprxp3H/W4JXehVBvmKWcX3FQ
KUvTz8YmwYeOUNCAk87tTKbGIjWc4J1N/RTaFB+MtT7HuBjxMuLo0MX2hecu8mis
buoUuYTEdDxX9QTUf+IdMn9RAJFz35qA1UmaS8eGT0S35MwtDYXOv5bG4gRxJyaf
udQ7biccCh5NlzM8L8a1D34+o9R5LrOJ9Cxs5v8wkf1RhxX3tlfsBNWx+jHHT4Mm
iFNfIAIvoLzd9MyY/Lkfa7LrnJq3B6NZ5S8zXD2Q8R3oi2hGhffHQ2neWQddZgpR
LgWCLH5IZgFv33b20nfByyxdaHsHKUWM50m4wAWE9l8G2/yxkHhjOzlnvQ83k9kd
9+2W5rkOJ1NDSkKYYtAfEypHIBbVTqrUM6nCJqhi7ydSzb8/jJS6Q7M/fsmBJ28X
9LaGfpH142lcNqRKlunPsP7SUm2OMSgikRYktqGdv0/5jXAzsq03n01F0ETkMRX3
QUj6NpTOND49mn47yQTMESn1LfLzgM+xDKMTcUYjQbLvQeSZi2KRgQXJzEwVxvh9
CitY2gZy0l38u3Ozd53SsQvUqjUqKLbNsouxPcMTdlzRG4AuF3olGnMnAFQlSLGr
PfoU43kHl3Xep3U4KONiTr9etzkTHksLz95fzDBG43q/gYmvwutQQM01FdtR3U3S
jp8EKx32AUKjSXHIBBa0M+QDyQbZh0h+VqaL0W0KgFP98UsxEm2Hs6Foz3yyQadb
IumMFdmkDlT4I6Rws+nLSMumwWfk0zgfVXz0ySF02efXpocqioCRD0dmuSOo9/XI
1wO4oLkK2fCPHn1JsN0HwxKOTNO4LVtRaS1xs0vVY3BH8O6jX8Pm7QSUvlh7OgNl
KGhImQuL7XCwoKwQT0t8HfweYB4w6Tok6b8NJaf9sG1x94TfpNShq8aIQ360uZt1
cnh5mOVgNSjQjFhPB2p7hQHQPA6sn3jaSQhIRFDnpxooQmq5tv3UqDVhDuRmxO7x
LEMfs9FDHwfwGbpf36J7uSwLUofDMoOMGCqtkHG9cA9oG7QLMAR7QOvHsvuubsG/
lkTBcKLJ8Bp2iSLTPuFpWE+OamjueB/aulESmFN+RPhEuzQRRjT2BeF39EVynSu2
FOeaz6MGtOo9pG/vxJjDe1OoRRBiJnYMx4UQj1c0064xFpF5q8P6LqCq/4e8xePE
mPcvgrqkIp7vP5PhbTk+1mthuoJkP/pjcUpDSwADJMmtWJ41uHyUuTrdxkk2mqFM
XrzFyHq6ec7doeQoUqI5CQzg/14W3UsNNa/I7Uc2P10OgDGgLyOe/LDtaD5APC1k
MdrQ0IoZTuHpULTevC4noXg02XxwbSEfxwddT7+0C1i40lZX5h86tG5QJ7wyD03s
h8TxTTWWrcakbC5NC9TmI2je4IA8Uno3QCLUJiHUyDc3h7sA5nlsp+AZOaimH/a4
+6FT+5hQ3GFYvfaofX/BvupBPbH6oazH3dWAiyXl0QXZPpKyagQ9ZbG4A91rIybU
Oeo/PY9dUw3HwfRanKRmm+7ycHyqRvFRSULNls2dtfgJ7vewKCH/NPTNk5VqI1q7
c99yswbOBMM8c6NnHWXyRYp+fj4rHSprHC0GdiV2Qx6gjLuWvJ1OKpI4wb5/lAx6
pZEMPo82CUu579s9oTaFrXTXs8zGvk8rtJ9ZyOVdfpwztOxmDquYi/p87Klbx6SO
wEwGDElNkd3a7uEGPXfIG6WblgUJTaMPwU8MaZUC2sfx0g80HOaWqPgVofCHt631
6/BmD8OWkrXBzh7hxx2zY1afVrKSHgs4nTATBiGAmUBtDQDowwZRBj5sEZBegL5+
eKOzJln7pmS4Ivm2fYxcX3+40Jgpy+uqcHzV5cKGCUhchRqa9F3jiw1avsfniPmQ
PCwfoqdDpIEsqih0YwULcA1pjA2b7Eslx7aO0+8IjguXuP/WEt81KyT1FZ5kgdIC
q9q/zweedKQVSqUhgZc/spyN2WqQCJjOJHji/hIDlBNQKX+qvpfdwpty/twRf1eJ
mOfgd9GitwfkiNQ4g+ibF5BE+8aGC8XeRxFNmabB4pLgONwIdgi1aad1CkpOu2fw
BKiZoD0l/W5IgDAAHxJZi3KLqQh6Z8ZoaD7Sx1JC2wuC1kAL29EHimYGHyLxpY3t
O+azGyUMjg6mifEcXkFliPcVGGI8gsm/FkKFNb8DKIUPMgcPxMcJ2RG0tgaNvlb3
8jb59zVefrBp1he3+uJSt8EYcNLIe1fUEdJx5wwmbJb8hsbclA2NzpRe+GIE2mqK
mlOgTGbDD++pOU9j0Vi+If8hISGxfEAYtIt6ITFdc4h+mBBDW4LomIPo70Mgd1NU
GlCoOwk5vA8TkKI9NxO/GS+9IZVPSmW1r30aeeptnxJhP2Tp+X4zNGUiKP1wkHkm
pCp0Hmf8ciV4HSCQV+3yoMJ5aRDKqz583aZ02fv8SBg7uj1N7zkl0Ekyb2AYnwkI
FQa3R0yJQLv0Ml5aLHw4D2+FC2+AJFo+a2DSfiTWWZghP+Ws8MssGCJAh+VLL2Tb
pvviX15On36rWus5AyKToNGjr5D0+Lu2Hq7v/330ykTkYXtg4ZOmAVyGN9jjZwHC
4onnxRbWVv+nQKZ8F1ZRrkeBY7m8Cpya5O88hi++/+nlTLq2dW8LRP3YKcvFL3yz
if2fT2+7oWraf6HhkS7oQaIt72YbbsmOycN+JjxEQ4E+2L4sHl2vWU5jTcKZoGMv
rMWloyBKembs1sB9VaMl9xqjQrOp8VZJQyP0xN9ozLAb53IL9B1gvJUkeRxggbpo
nb3WKb7B199KqYEo09jeRAvl9I1rxLgwbLEeKVDPEOFoIJqZnRrd6yUjs0pucACg
2vMH6UV7OwBJfsoFB+elDe2xM5tM23DhER4aSELzg3vrx+Sv+WkHtChKmTu4OJBn
14ESEWlpcgWFg5UzUMBUEuhQSKSiFxSvkIdV7xoMMINu3LHEIBOr/87E7biRHr14
z10V73slwxYDMtZ7P01OW4YoUcoT8DWfyA1xIUSmAdk6cl3b358U1Z8gEDLjYDVG
GgoqBuGCGx6NESEWC7oMzOwcGRtnzJV5cfnLNSnLfsepAexhcGNbsf6eLSlZ7GD1
oryL65WutH+Nt1QdBGzXM2J7xL04Hkp674fFwFvgFJ10jPVW6aFdsTBgAkJgIsp9
b6yNRZxv4/QXmaYzuzuk38vjiGSdkcetXHz79h849yXCJ2vJZaeNRTLIU2NATcjQ
Ta235wzykBNZ6Cnq4V1WTjNo+1MxTi4qvak3VbULyVgYDt2881Fs7SJpTZHeswMI
ZnrsFbm+QntAKwa8V94D3NFpUFeap77hd4wucXKZmTj93aGzs1om0cFyEYNSc4DP
QXs6GdN+MdMm/dInnP6Lpqmpov9H7fh94xFhe7UCL1wzOSdxsnsbH2vTLeqEm93G
gLFEzMRtAiT59PiPzGJdFFYJIOF+LQa6SJG7tHA4hCOuO1mv1CZ+QZVkLyUqDO9L
n4TNsHNZJlsbIOO+Z1hDY+diFj/gw5Y5wmDF3FYIYUXVmGShyFUxY1xndqBRKcXC
ULK+0b0jqOyvjfqsEMb+lueXVVKyySRZkrnYJg77mUzh0DWlDzBr5kAZWcqsh7eN
SgPOUbjS/dpQk/I3MOaZkqLdi32DFj+y5PyK3+J1zGy1rECzepmU5upheemkmNa9
NKGgQ/GsZmZvyf4oL8kbM8ov3BNmNg3HiXknBi6T+K6PTpiI1xxaxNWJp4J3WUG6
QYpXWM7vbZU4rga8bFqbpO3kPf9d4XLfhkPtQv74YKZyqj3znXeC8OblxPBuLlaZ
X/DpNXEmo/4J8I/9Nx1OKIszYiMdrFE9Y+0IHoz2Lj9cHGYifK5EfaEVaAFxeEHC
J137UMg1AVousAHP/ryJl1a3IMaCOFPmaElJ/RwhfpvH6AU8YzKHIoz9LOnKdMZp
utjfod5tgrpsffmZTcjv3AbMV9Bu57ARg9UD6DOS48d0tgIoeydx+VxN5EvrEyF7
AdwHx/Hd3AHPtkcDlqcBy/xoH7BaAZnWGZk4a2GL1/jWx/oDgxv7/gOc8QrIUssq
BygaEPJkTZggL27oiKAzKeYi1pIEGMcK2ydFqxwPrBiTB/ntMV3DjUNioz7oClYH
gu8AGnuYD5da8LxmBFKW3wNAYNuibDlE4Bjg0pn/C0vm33/NGDiPwHzEYMDSI1XO
Hjha6M3EiSRc6KnShDfcdNcr1SbLOyKlfni9rTx51/t7UJk4BhpK4rzAm926IjOq
2WU708EDQbtDsuvquHZSpy/dIWhG+2xaO9gCCkSO27f922JpVt0V03m5NF8O3UZy
foTJ204QNzout1hH4ckeC4D0TLWhy7nWrBuOjKUC7YiKLVCOCrqibYnZspQVUNU7
ohf1nneGMX4MoeRQRBYNpmuKInantiUHymFDqK5ksSX7Zu3n+U7KNIBocHKCNyb6
53eBEC/QSiBi83wD8fRadTYj6MoO0z2uaOE46gLYVkIov54IIfvPGIi/u/d27wA4
mx/h8xQLby/bDf2tgKEHQg7IWnvyKGMi0hD/k9nHKG0N3/p4yHDkgZozIiLbvDDp
PY1JyJhltb962BA8w3OaWWy7Gj6m6JDm/LRhF7oxwtNsj0BnOxBO328XmcaKboJh
60YtPJkBqAzDTcj+ifmbBg4611KUf9WYKB176+N0Fcsd9AeEvtrdFkFFwkfv3gXH
6u4ozLnCc94FkGZQZo5WEyxDCYZ/Ip9ObHfQx7ZcuBRKtGTJKSQNuMU9RPBPoLfr
/SRAOVBbQKgGnVWLXSFdMF5V2WUw7kbnKC0VZq3OMahucvC4EHzWENV1F0Wi3RAy
BqqcntyiUkfGisiYRwvKNZdHjl08yljKKif205iYPuhgOnfrzmk5RluMWB6qMg1Q
K2LL9GFd4uRp6h9+AXwZFCNIL4aqsa7K0s6FCpeeOYN9NGdQee0KYCyi0lQQMkHc
iszBPKMbLFSeFqMHRzAwAKhuRa1HDEu9TundagjN0r9meqdn5S52UhP0y3FdMTlP
MoiBTrhihAlnDHO7Q9QR+CCUBdExYfWLQO2s00iNFO2L4tFdXkIgf2tx7JUSZBUk
FTRL76nuZASF44pe3JEMDFX0YYwUEErEBiJd8vfnKUZpYBeXp3oKod8MegIs31Wd
ORr88IUzBGYkLDR+INgwoGmTVeFiUCTSWaTE3zU5M1ykDmD9D2TkeL8UpfCMYFnL
BNFo+qgFe/r3m1pXo8VYBF16sHXj+P+4qvzxW8FgMQ0gcqZs7mK1yl9oMUB0UqqB
LWEyRPXXtr3JcwwRmIcD4A50NhfNsvXgQILFYuho76TX+Ij0WV6VyODW/8AQOciv
cjESEksY0wQwdTVTV0TdSN3LComuGVt+QbQWzVu/2XPtE921/lpQRsxNMmJmzPYO
XWWkSGq/1I1Rnbv2B/lAI8cY9zUCyOb+QYwNUgQg4nIboixMiEexrKqiXNevynMF
tWgMeAA3ctLKm49lzxywuKkMX5hDX9Aey20uVIslNebqCSSJNDFoZ1Yz7mbOZOX6
nGzBMJRHcM8yfvOuWaV0UwwKzhx+8eB8mqcXPyMkZ+xKC/GJFylrRk8hrKXL0h0X
zaxNMurC2O6KEbdED680O2eUEGIxnC3siipfwVsWSqnZNpASmUpOjlZQQmssphKG
EE0h6nOXsQkgRqAywrjo2GSGhddECVqTfikdXboEzgjVyRQhdSJQYy23RZjwKAkP
7dEpkGsfqszWtTBEIIFrsatEzNoWiTTrD+CBeSDWERsrYrXqAsMzKM3U8rmDebun
SIdoH83Ro1n51elqLKxYazGb+lnFWkmIMzM8f2oJJzioHnLmn+7CIGTLjFVSDkSN
B8/ZCix7SjAks3rSaaO9tlnB45lXMHk7rkCFRP2XokWX6R42uKJblJ+IyFN/gu8b
FtVnjpYIVsJ24npOEgSjooIq5lOu2RUAY5zYEvjBQeC+URHi1thjDqUCdtqPY8Ue
TFByRn77jbE1LmGtMDMwTygeVUm+xWkBg8Wq5uzCKFmI0KpOipC9R2lQN2wn6pm0
/FmpuZn78jZRreYx7yM1REJ6iJx0EREp0REB0XZbOyoHMjqIaBbIhVi2SFhiVKdU
siA2DGjwzy76BXqZOSGzPryIf1FE5S47wJZM+zr07qf0/WpHaIwmrWKwRfSqQuZ7
UniWeEBIWiRb5pW6pcwRE5v5L1/IBLY3EptocQ2TErKSWVqe3wuPN4s7LYLB45C3
nGsi0GYr2FHm04ZVC4iv/B/s0DJRBVaFRdspPsFne+GrrBvVSAiHcue4xvBvs4by
hRbPOMfxtkC2O9op3NLuMCt4zgP2sdD0ySS9G4rLz9xRky7POosfz1AWGCYyb5IG
vFMarp/S84sZ3db30m4ZLIybsiI8ia6w/iteWuGY4PViBPKnkTs5cqO/6g+ZUkWw
rGh8BUz/klkxVYCW8Ljalk9iGdceVwEi4TGNTVCDWt1ycGkMzH6PPL0YW2zx2YlF
UU5jaHAufihXT/VZwDxGg9bWPh2iEskszHSP1LFpTcN7IDuX2V7bNNeI1LS9eIXZ
rgNGVYzfG+5zayWvGRNtbfI6+8qy2QApdwaZ8DD6/3Bf8NEJ1dTDtytbpF+iZNma
mLzkhbKZrVekGMrb0jZKHxEXQOnOrw3XOGRF04Yu8BJmKLTsP6MZGSyFO8a0tZqu
NOA4c74kw1jvSPJ3nh30E0VujH4lZiuOK9i9KbFg5efQZwM77eF0Q4llIhDJz7dS
y7XuO5fgz7bhXHaeGzeRUyq3ypMa7imVsHrmUQ1hU5ql/c3EgBUgzkMognCbooVk
BqLkLKfRPyEQVT2/oXmCjfEqKJfKRvhzykvdtBA6rINcZUcnv3h74eetO0U47SU8
5LlhDfGhgKc7Cs+N1GpeFcR8FNwrUTldmxCBdjdBGGaT/S6tB53Odg6g6/H39imT
rLxZpDwqKrkvwXch9q49MJywMiGwO4V1iKl6/vaOehx3scLcxy5M1NSS/CvJne3L
61Im/txyL//NRAccCP3TVjBsYn7K83tlVs7cysCozjX3sen5cgCowqhwM2nRx477
hAWnoroSN73hjXtfbkcoGlarbgtdztWue0tVx67cunxWn3vCKb1mt5RsI2bJNTV6
8LERjb6lWxSsPerbTyUuPKdI8Vxx9Vd3uiqFTltoNfjpCYqZUW3PqVoAznPGVufs
LM6T5KbfBP3Egv2YD9M1yEnFbDh+iZnI7410fI+6oFaOAzZruLpOcOWdklzzb6ak
Lhx0vvRhyPqWQ4oOcDwxvK6+ckq1s+rZz+ZIblGnadoSt/skAfb11CQ7aO8bzypH
IDcxm+B6oWLtk2vH+11RNSXvXCaR5WwmZisXsaD227VRo0jd90j6zroT3SsxT2VL
3ZXTtzPVp68Q1dJuJPcz8EYXkOF7zqt5SIFyUO/DCl4lIjyrXGG9V7w6Q5GOuoPk
/to1he8fBVcnx6Tt9ulNLKvPqPKGVQ0N2SVPBHzJR4bhCkVjf6LZ/gaRimsn6+JH
/KPpJefsHghOLmZQruEwpwrTQKma9mWeNLdOM1HqGU1ykLI+P5RjVn9Ef2QlOvs5
Z1xrYU0E/VKB9c7+uB+A4t0p6wi7anJ11ePc8WS4noq8a/CEjz2dR3nWgo8j87dG
AeAAVDmk45oQWFZBOEYnmYh1aJS7dhiDoGFdgVOmpeKab8lxrGRifojg2zscT+zJ
pjheAEIdWzyG1+Fm2snVZKhqNXBxwcxcL9XcuHqRvgr/42Pp/KY6oehzinproC5K
4NYw5SNOdbM1ThM4Uy4Q0N9rM8YWdZCuB4+iCzPEdAAx1XsR0H0whur2m1XJ1yRZ
90GOtRHI47UVk0sc5M/B+Xg5ryOD9k7pAb2oq3h23hkco/E1dGI/M4gvj5o8nriC
6Xo1PjLumpd5R0XMHpr+LSf//X175ZZG+/Qx3V6qoBZqiqnnYLb2SeM535GM99+E
B6COAVhLc2Jg62xVZWmMGHHEfLVjx2pM9TCrEuyTpiPkVxDP0zHcssP1ihKCTWwB
Y7baeifLO+NzudUVyZvWwFCuDq+x/HutCK4UbwfTdIv0v1E53Wp2RTqIVp496Gjq
P0+7CntPIdKCgzqg9V7OJf+nkozUbpRVHE8NTADPJket7lAm3BerrRwG1j6aMdCs
IHdcQWViW8VAEAPxThmAtfbpKv9wzuqO6+6qcSh2DOvEK03RreHeb/GQu93cUI5d
HqPIy6qQmdGM+/x46pT8bNDCCshTSOSc86ECpHT7Z0ZWU3P2I4PdLKebhMKyalbS
jhpS4HvB7GwLtnvKSrc/cNV1e9YJbp3/chyYwHaDRuADCW0QG6DoYhbxEuI6nxkx
fj0if/EwTRez5iiWPCH4mcnzb8pAX6GCKDetS6jtIfioA7FSHl/He6gAnlm/cZsf
zlgTsE+AbM28Py0k5yyuOV64Hv/Ctw9IbT+cEtKYjW3TtbxR2mNxnAA+FZa8ZKvr
dp9f5LyyT9umPpAVcypf7JvYY1hcxrlovznDSzJannsPmkt92Wl7ByrpMa6Tptg3
06fqleO/1YKtaLT+6x40fKsc7kL3PDMo2GZmKH8K7+OlCT2L8YCVhXFmPu/Z5VjT
yLZ+XNoOEJ1SWVA7dQm/lL8R/zwPlY2r7TvHxWdlj9DtMyAldCktG5P2bsCbirG+
g5X7kTnBR3JnI5c4aJjFLahEsFYfoUoWRtWNmC6Fp+qf7di9cJlIB2BkbCfapXh4
NelckfWzWN8QSPFCEYKDLqHtIqNkTQ8HXi0vwca855jJXXnHpsDBkeLPnsrlmPQY
YmZNOH/ij2WlF2vny0yRVTczq28yMHB6U3l7T5vrnz05e+kX7g5YRWMjtrq//8g+
h+oVcVM/mXjtpOyfbJEjbPoKRVC6SOVsi5BPJgts7B6vIJ9pDQECvXXXI3FjaE8r
MXigKALpvOr4KXsB5DUPgBeyDfdQDk+2zAqzuN7YllYezVyfKF26vGYWHVy3zQ0H
h6DbfKY+S40N64UN47LJ23QwZ7Ho5ITafp67rCqLC/aUOhMWUvtkT2OQ85XZ1st6
HRY3XDG2Ifq6P68LDCFMS/3Jw+ydgjuV8S3RsXLcljJKGnJhRTCqYedLXeqTPIH3
92chjwA+Vxd2PI8baG2HqLXul24ahF+Hduha7O/LAaGqn8zguELC9eOooRv3LMte
9zSB1fmC/+ZWxywZbVX039VpozcirxeudZEu9HGUuVugK9jJrf3sKX69pDWYChO8
PsQ72b2/nS0rFdEX6RBam/rpnjMcwbQlc+ApqG/w4B3iWt9wbxuM/8Rq8Lw2d7Cr
ht+Xs2GwYRx0963wp5lkU7GsNIGCtov2Qow3WnZD2N6vpVNOQ0qY7mrOOWabt8sb
Hd3lC+fOHJvtY0lB5yN34bYlNyyFPhacbvrt0CeX0O4f/pV0Im2fTu405gywBHjE
CSLekdhWOxsdqj//Q2nsuppbjWLt6TQY/ljFQg5q5uJm6U5W/kpqhugOv/3oaOay
E3y3ePjMKMFU/kEFfiI2uFy36eTepr6BYruTFOQdotM9f+tVQA6PTQ5DkrinPLdO
Mm8hN3571dq2hbiz9LjeCtOYVYT/mPLvvutEkPiN8b3/XHd53gjcNayAD2pDQcl9
uJbhAHkIeIs1CvXdX3vgqcpCKnYH+rZQLIKO5bFqgUfikzf8Ngn8JocLcRhxBjbT
sFRnF1b522tHRx4IgRWXVHVNq5E/Qi7+f671idql5xFHvNZE77EoSJPdywkj8r7d
V9/kBCMys92zKoqpwDP7355vt12ND5vcmG4DvOcYL9Vj7HphxNblHg9uwc6aKnZV
Mm2MSl/p5b+Jc2zv7N/cPVccWKiLi345bBTun4oUDW41L9VZW13H0V2KaF0zDPqV
niWRIxz8XAbXZV4zLe6nQv/NzO0bQp6iC6RPwBvuSts8q/8EVBwWFsv7nCkE4cHH
oWTgrSD6HNnyikTbWEzUeP53wlnXS/TnJf4Jqw1tPwezHL9uwZ6K1iEWc59ZQePb
INybkGryHUIeVl1g0SCIR7+hw8t3zl3Y3CVUXhHuvFejGBHcUj3t1W3w9h+waWMO
yAHuAS25jU9N2xe9Su6WXMfyYhEkN2Ee3fMJuAg3AA2rEgSi9SpdWg2kGzIY5M+F
2B+Brr/5wva+qK63lhZ363g+2TU8PPVV8pA30rw07MNiDkkVjjM5TmH+Idx1WVez
vUc0g1TQPl2LAiCcToXfp4utXhkeTGNMw6MneritzrdsMscI/FXhFvWKDrDThfXk
3pSENuUD/1H1++unWf69s8A9orz7Jx1V7oO941kYgD/Tq1Nhywv2FIAApvMWoC0i
/XvuS2kwjU1XOZB2UX2ma202U2Vrh2FDoPrxqPyGjmLt0xn7YMIrSpnFxtD9hPCH
sfnJ23GuT34EZxzDDUcXcZD9vtGQNytraEILhQkiZmHFQBJY2tZ+Oa/KJ9X71L/z
Ispe7uLD5Zcm2nVc+KA+x/vUWb7VbeDbvpy/WOMKXU8tiytNn5JW7LRCfIm0QWdm
EeO9Fxvydq10L2JoVPQbLIHb4Aj33lObxwGJi2JhXq445x+i6ehQ5PNHxCLe/Lfu
6XXVm9MQPY+Gq4XX/WZ01oc+2wkCyYBo5lAcZGEt4MjZ5MIOrqlNKo5plQbPn+eD
lcT8Ig/RB6McfbbLSiumCmzf1vUuNkTdk4Y4KDW/avD/aMdu/YQvk+13zwR3QxpM
bm6G0/uWYuBDtlLuyQ8byxp2iO8GBXDwaQ1uGRPEk5073Cx1PCMB7tEkinMq49qZ
iWKyK0tqmUVTXAwco4ZshPgC8b+hy7idmfnCVSlNny/9BTWMnZnvxKMcrK0RvjqU
gD2Pjj8hjr/R8qtKO1YN6fFqT3/pTOr2ZdSEGOvQpac/b90/B2ufmycKsnmuWEvc
Dy9R+mF4tBrIuW0+bgaWlE27Dl6LKb3qgfizmV0abaT/x3fV7fqG9rEN8vAPtIZu
AW57cDaigKD9xtRI6Set5a6152raR8wyqKlpd9jq515jLG5NNeOoi4BJ1MXA8gBq
rO0eoloPurMAdX4iKQGY4jov847bJGtCoO8pGn9nUzy/oB02wt9HZ2y3U/a3jlHG
k+o6y2+jA7klGAa8GX2a5RSeA+dqKge0L+g65wmYtx/GPI0QMzrDZnv8n6rYcBKv
3Mzzldhl2ACHRTFj062+6Vzc25kV8dU18jZ+3JDcQUbiGx5g7F8XRvEEnKG31i4n
dhBdeTEbRZW3C/VB8UgUyEt8U3wFAB+GdrdGnsg3Xn9Hs+KtLrHfYNTLi7RFJhZf
G+1a6qv4cAVDdl61zuglHunZXB3je+JWwQy8SuHDzI4arsCSP1YeYcevl+rtPmys
kf3oU9Zr9I8bMDIrnmar/jJKLTibzbTSwu7te2eyb3im5HuCe2vV4NRrvCGXM2yG
N2zW80LgRdbEjxuPztZizqWvWC1ewI5BzKXhgq8lZv68dP1VjbuAy6arZgW2Qn9X
yV0Ax678YhXhMIS7Ns5SvBJA2mPvRKIzl4RN4ndyFNRdvn1jQcqyL3djmusv6OI/
Y6Yy1OKude3BFwSVucUhD2hnMuRtP3wb8ZYWLmfMhjXejMNrZkf1vf9bx1Q2d4Pj
1PerTZ4Ez3hnk7DQO/zhrkRdsVYVDNwlE6L4PIIw9m3xRrfDttPY5VgGx2SxJDfv
/BH5DTuTsx02RA4OCWkzEEIYKW1/3Og+GVXn6/xbj1T52l4mvOpAvZpb0b9dHahP
Ji2zt/vGRz8qCc/uSr46rdWO7YQXXdo7fa5y9y8BwBh9xE8MBRDhb2LW1Fdw/z1M
t6vxULh03lkhLnqd39TkchinFzXMS/ixNAbIYb93YZDwCrJQ93omShGnr74M1by3
oWC4AT23uiDT2Op+/2s6ORMuLTUyeYKX2DG9+gxxmG7YqIAa7wqwAIrtzRTEaW7u
nMhPzTLpw2AqkHa7rCOo6tV6YjyddhBeSmdsS0DZVE0BILunNU1WZ1u+5KadLJNf
+DzJbO6uXdcs4L15+9+dscoGXrXWIaTWwlM+rUHW4edmkCvmJQzAQDlNTbxZaXKq
NP9ddIU6pf/ULj/hCdFZfBn0FZATJxmWvhxyI+hLetp9cXHdP1Pfa+txVztVC9xS
gKBJOHlEa3G7wGock22pDuIok3FXUH8YrvT5spYiRdIXkVjIMngzA17/oqsIy7Mj
6S5hS8GrRy7Ovpx0Vx42ut1YfGnu9G8qjz5Nr+fxJzyJV0qk/a5YGkzFjQ0gJMVW
AnG+bEUeqxHrn+m8g5zXVXY1JD22jqnF/BJvFnwNXrgxO5vKBNpmXEIHVf9sdKZm
mworU4wI1H08P39CVJKCyYT04p86/rweuhfXO2h0s5/9MN8++Sft8IxYYiR8Nfc2
O1BuR7KgxfunvjzdNsBPToOYYze2KKFKxOFzOzQlMAhAYQ4Awc2HAYOuSeW/eNcd
xIzdvQOU8kk7U8K3eUdCMJWB2eIuKHw6pFrN7tbm7ZVOrLqdfGvTD2K+VoOgOn1J
3hX/5iydlPgSxFKY/Ri2wKVESVzorQ6zufvv/tyuApNFtAFixbJ6HyarVvAK26MG
xWrBxMVOwzr50i5qaDG+DvlSJdND5QQEAWARdny6wgY1GOTiuQ9ujo36VSV8KzCK
vf+HadaWgQUhwMj931nhszRwxJYByLxgTas+4mQnW9IwoieFGcnGwZv9yCC5dWnL
2kapzF25SCfSrfJi5TlUDD5mZs9AGTu7LUXOJLP0jz7/BWchBGGuMEPZ1hM/inVc
FJvSUfk7kZ4p1rO2T5xKikkUvRlQgQ4MEvzunzAIreQ2fm2hlzDKNelFOHxHJTEM
J2O9yABSbmYNaPE3YS0ZlivL3lIWEJrevHLNInzAh6HKsBxrITzpKOzDHBtFJ8ve
kmVHS1rXzuLoKMGxbW38Ejd1/XDqRa4LD0uGSWOBduYykC2x4BWpCX+2DnHGwvYa
l/P//QowhirHyzs/Xu9/vwyHT7Zn7RjPBTH9EWml+I5IJSV4RGqc+d+m6DCD1d+W
egUv8HoHRa8cvLxWyZSMpi8gsMi+YILN9lnwiw9pDYparrtRzoBw6VsT3mLlHLll
XbnH+l/Y2ra4zxV22W6HbeUKIVrnSI3Cm17BrSxwN7Fcfku8l2leYbz082LEiGol
BwrpSrkvGUvAgRd+LaPVTK0ADHVd4YWMtNL4dZtwl5f+bZTNhIHLgF8vlGCQe8Ew
7OiFQpjkXkiEWd8LVfzcXyacNXumKFrUfb1RrpR9rWxrOBXLYrE0XjbAm7fZ/O5o
o7cNws8P4fMxQTZIj1I4Mq6L/PNzwWvCko5ymOG9cnMirCZTMNpsaxTY6/Nxy1rc
SrSWn7ciwp8b67XPuhbzxM+uXImhnVYhU5Nl25m3ScV2hIh9C8U2F7UkW8onYRiG
ala/Rgl/+9lyZfKhODSSQdgvWOKRjmKQ5ldFOK9ybzmsZVvbNq5aB2pfo3nuytkI
hsd+ucL0l3hNl4cmfLnloZ3G/LS6rZVYu2zCXfv3RaIrmvC9NEoSVYpXlmEckXOb
G2tG10YtzjnMhTHPD+Uaa3IUTO+lOQquxVZ5L2ftz1WKBy31/NtczM6WAStcVScW
w40MGICfgbUQJvkh3kYphBmEQUNk2E6maGa+zyy6oWu7Lnbh9xD1BrYRovzWkO9F
UXdk4HvOhGGsORu2sWdHHeW52DOucQhT9rYGohvxo3bPlA2obhy2zPTGjIv/ChQL
N/sZsGKb+2KKoUbl3BezXF/nLF8ZSGHIqkbB4yWFH4tHgaMvMIYaxpE6Cij7LPpL
kJYx3DrR9c/6tPRM4ZbEYlmgzilOr5AapfYc1Eq5wpX9XGLVm4Nc1c9VrnhzzGIf
1XYDEkthRLUcBbzYPRTkf5yKrtEUX7MjnULNDgphxiAsOygYub6NgtssmjpusF8b
FO5d8nq3LlbR/1yAuGH/K5Tq2SJpbVd/C7yVYnfImVIa/0axsPJECB+TQ10pJrfW
q51mwyidQld6DcNIrV6DWYjz3nMXd874eHtzNd+H4vuDM/BcL4bZsqz9Yj/oZKd5
tPSL2ctZITJXcxactlKWIBd2LiweDQnaYC3ORlikLwONvFCCbeYFwzD1eaEQNpkX
LPTmRpz4LQP/RWIVmamNEmZk+8Igg784DKuN/sEasYOtfi8wRo/4Y2T3AgJL9TTr
+6jf+gVsg08YKuwohC9oNcVQq4ZhsFuZgoQK2YkRxlH/LjKojsSKdElo8GUQYZiF
bmFIZ1ampHTDVoILoT31HGrc6vqvhS33TbyqyBhGYCEuwRWphWxIrG83T46SGAlx
GoQ+EBa8tPBVK1zwI2OMGyKjZrS6q725XVXgU7eadAmmuep9W1O4T6CGcbCAY1Vv
34sdRt1gWTFq1fSgWMhmMJxCtRqMFudedMVOK5ILYX+/IRFG+DcUOoKfF5FGzEDb
G8UxEpa3qtmzg4wFx4y+McmLcCct49hs9PWY/0gPYc/Aq76+6mMzq1nUoINNbE0G
sgXgVWTAEPSj0g3Yvg0a3LUrrC47PXbd4bhz/7dA4tJ8cKFcgPXulRZtVnCrqndc
ppWw9W1tSAczl3rFCnvVawUD0FVw30s4H/bfP+hczS9sxc+i/8cAwPAQGccnMv2P
XWoaZRKT0AG/IDAkRMYKliJDhwhv10rHAGPm+voHWthdB/68srUYbku+ftaz//6B
LevQCdK2D8KU188W7Q/czMWoa/EfnLhAbtL+QCvaa9kYiLoV/0GU9RXrlfKhpX8Q
OKahrsh/8K/uv9DadjAdq+Wti9XC5Ys661prwJ/pJED/3CP7txI+KPgP/sdo1Cn0
D1rO9qbDELAhAh3/H48hWdwyH17RueN/4AYdcOH/P4A9enpi9Rlb/f/7pxc+EGR2
fKlaNExVcFyRz6OHJzJZXRa0D3UWYPVwDWXO/vUHelw3GqcC28xC/YE161h+IpNy
IlFDnSXtIhFwYpLlyzr9gf//WWzoKCRMiUTSMSRQiSBQicL/yYlEIFCL1xlbSGxt
29ywSAQQQJZTsIiE6TCI0n+mXsvZ1IqLvwCghA/thVa3/C2L18hN+HCQnbEVbRt6
tiMtemJQ5WVtjXBV8Yee1ZeEYjHpwW+EDqB/cKA9GKk8henCdnURyeJuFuHDv6XC
uz2DVX+utewA0ugi0/+/RvdVs4t6r8Cs4Psfk52IBBxTlG2XyYLiRibrWZ+KRST/
S91RQHY+gIAvk5qd/38uPHTj//xEJPlEhnXLWZTdRqTLN4XuepZm0N66KEi8EvmK
NvD4Bnlwos6ilqUiccFqZJjcwRrlQeFEBPBBi75BBYsWGCOzByItJyJNWV1VUQVV
BVkFXQUNfwV5BXUFcQV1fXltIREPIsGQ0KFYNZq4Fl35vzINaFi8sBtasUhBBwQQ
AJpYYN9xnerfnv//ffP0FDoLxYrvdqEFe9xyYXKocMG/wWXHFrfNBYnCRZd+dtYV
sBhswd7iXtBZ2NZWoeYFxxgf352jVxoO1g9nKGywTkFHXlgEj6RN216IdIW3N8hg
HT4L2NKVuCvOQboOM64I9i3NurXJQHjtiPHoRw9EVrcCuH8WKvcHIkH8XSEMUmdF
5pI6q9tKLJF9gzBuLdkr/kIvnX1hkUddFb6Vb/9/WdoW/wdVKG/o8olIFrWV7QMd
do7/ke9DEAZde2FRxf+ebtVe57ZfQP9gUM7VqbHJnJ14/J/UuS5eJNGFnoMEf5+E
nMgkHeNq153DFByQBPz6kJRstoSeiGQxZpbGh/ycIBjrlWD9BgOyloVYv0ofDDLw
A8sfDFpab69Y7WOKrHLNxFCXXFgU/I+U4PtA1JzINID5at2gh0z1fzfpeIypPYY8
pgi/irXGi4CLTPSAZD2rYAVnGICB0sAeQI06TV3LhRUw7AJbo4wFmHMuX0XPkvNo
Y8Ext10P7N8KaLdGcwsw4Cy+iJ7t5lHdgmMLvdIxFeo1wyh1lyrAsdH/IMAAtn3F
/7GFpQ8e0QEAjLMTO9YEc4mZsgBXrXbWHRfQW+la+bnUqm+KXVabOQZDXHsVcmau
9Z836qzUXEBn4WZt3weLvNZ5LRSx8opqBWZNsLi1Tliw8KGsck2gK9of3NYCuVIN
ragOOm8xEC1u7FuLdYAB0+ACy4+1XQb+R3IBMP7/7+cffIDOQQIYUPW2KpmpzmX/
mri+LXnLW15L2u2CY0vcgTom/EEAgAGZdGtZ/5qIh3mLhncBAkj1C47ttR7kLfp6
1BnhD/7/G8Ciw6M8ZCcCAJA7owdjVbEAAVx/BVkP8smXeAoRiLVssMoDkjz06wMJ
CdMiu11C/iD0UmMERePxP8at9BrDunSMha3N4UOC/iD0VOM/8uD14fugUIcl27I/
SLEOYF2LK2AxG+BVPdSt7A8G+DVe3AJUeIUPFrpLFY1IcJUrBB3U/iDuuvE/kofv
w/+/ggE6e0BQeiKTeuL/PwoQOkBAhllDIxIDH35OkMldAv5gELSFrMKVbC37W8Va
2BXgD6ZWrUSfQ43G8CYAAF9C992794/vVCTUdA8VQalQNJl10+p3UUSqkOUHihj+
utsXW7Nmvaku9tFvZmr1ArzJJTqGazUDZTEVKRFd9eGBiKF0ruXwn4czBDJBU3Di
eSRcRsB6BPdLNijo4cUvBPiG0Fd6iMVOLCNgs/HBbSlTV/XUZr0KSeK2TKF+xGIl
XnQAvlyAmeynRD5llehlkZoHRhJ+266nbK7VMMPtjcyx0cUKIaUdMBx7IgbB27wa
UpUtph+Dz66rcq3Mdz+q83wsFk0PlkyGf7I3eTc6+W5rrlcvY8igq5EnMcgxYz+4
fnomE/cYHNTShVxBO4vs1kI2vBrcA1egHHcsFbIf801WlQ++qwnm5I0vISC1xrAC
ObAiDZV4hz8PvueTSO4ILAJMThWpXxcHDScQvweAYZM7tRtkoq+87V/uzdFp5NmI
yGfH3E8a4dUX7rhifDT616sFSUXb19exqjfsJA+PPLliWapC7FnBL4CjDGX/KRRm
QeZkGpUTeukHYS03oPHlTnVoVEiD4Vsy2VEAztLdcWak6KiWo7YZjAhtHF7PDRbO
QpUDASAKMzhbJXpSRb35LnnTz6XZvjMEdEezILt0lP+Z4eZ9cAE0LlkcSNKhy/uW
8WtuT+1Gk8PQT+wEvZWCg9tREo6v4B2cIX9YJy6rY8MJo4c5k/3QQzO0MpujAoFH
/0Y9UB2pXTLagmng3f0VYbwZ5fL5SGkHXCzORiElONDyQwwvBSzF58qyUQCCYQfa
801QZMhucybUqFpVBBAV4foC5zKv9Cm0V0+kmii8rRokBlnWHbVklJS/LWYcO8CV
GdtLLNZt7QggE2B5jtfTHZMDy0HIGn2IIZrk7PLYJMv/JnYX4ldzp/7n1y3vVbbF
9MnoobHdRDxACw3KsJLWLoCHlKvDbqlowq+WDCzTCwodxMS3/ldq2O+voPvtXOm5
OJW0lmNxYlGl1kSz3uFDtfzDhT3BbK6+AgaHoFoPTougT7H96iqaVRAjEfOxm9V1
SMLGpoVOXlEWln245CfJJcpNWIzbV0wUP1EzdkIlmQutU9iZkhDtVZ33eTHxLG0Y
Nd4107SZOQSqXAwjqT1YNOYzkKy1cL1FU4zcYzDjUJI5mxZW3b1nySvOCKZYIH3C
CtbueuAH+DpGutO1pmVVXitzxzNYiDsOGpXeKpn2gwVnmy5UWI7zi4WwwicK/1sV
pO3HwtAYoxB1llwJfnL+gLqVOElXjVAsecD4K0aJ6EPemKWcCdOOsET4daqYh3H5
9H7TyaCdtYYk0bG96S6w/A8/o2OAK36Y7w66uajFWznRWH8YPUC+y3XznCksV/Do
SBjVRUKmmUyxNKOSr/H8Aa1hjJjF3htBr5R1QXgKRokcygh9RKmS2xiA+aZamXms
VTKc5yuecwhSg9owmW5xFxsCQjQgxZf4DHUnXfnVnRD7YiMRLTpw56kAFWHqm2QM
UTWSFwVQiKx70JYpRmkNMnuz2wiuo1iPC7MO9DMQ4qvU4dl5JlfaF9PVOteAITd5
CCPjnfLwwLE6wB/axth0wxP/3LGVOc3/f0xZR40hd1b2YKT0Eqh7q13jiHtEavw8
xrglEa0fNdMMOVjj+zdY9i/1e0SXkAmsE0ChaLfOIbMNdVsq55ca3Dg6E0k/9yIt
aKm1n5PwgzKi+KywLsP02DY89JcU90VhDgNQ0z4VJ8UWKacfevmzfDznAarwRw/B
Um20/wkX9fbWWKrcmCM2n4i9nUN1ZbOvWLLz+TnRayoPI79zJwXJNxfMu50c3O9v
gomgKVge0ssq0dOuahpaz8KlDeTVomJp0km76AQVCqVFwgIe1M7/nYJGoJUDZtKy
tcon7fbYVGr/+Z2BJYt5f2XOVmpBQnyM7ftI6dLDsZWN29LcVCaNLuYkM4QJronI
cPYsCxjzdVBEuDbw4nbihXk5Aj+4HMT3s5xVU5rHNg5fZT88H9Zy09+/n3X72K62
qu1pZ9pC03VNw7p9bFdb1fa0M21h6bqlO4J/N/S7PJN7Wbvy4RXWQZOC/k36Ud12
b3pPyVsX5eM1KZxklczi+R6r/1SC8t3y6GezDcuW+KZh1NHHq6O0W3wpaEvsciQH
aookJZPqIw434GAJpOFVfUWpqRmnhj7lW2salD+qbQP5Tapm4Cv28Pvdxu6FjKSV
koCUuKcYZuGk1UyfAp4yyMKff9fXmBGJHilqRKbXxtT9SnOdC4hmmvIR6ff8vdSv
ef68L3nm62h0PE/1+CMeDtJk8fOdwzkeCwxGTiIAC8gsLpJmJ1K43rWIESpru7t1
OyRSBkx5BCYzpZLMW+lohcTICjLbzBVA5ZUl/k5b1V8pFNTGpgE1TumYvTP3bxM0
C6xy782e6rPNbjRwDUTa2RsB5kdiX4HtK54P6eDglSN9WcM595B3Z/g+vgCqFDrT
dORfA2gPwG2rlzA9UGVYTEeiBcWWhdMIYSVW9zeuwN5/DK/TQL4n3GmyMaAKaAUH
kPeQYwS1IRUGNC3mitjGr0YvoUDhOcBPwWYA38zhMqIOvDDResjPDVQS/5CeG0iq
u8ASbub4VRkkIPGwHg8QlmfmnwyuUuhwhJtvRUJoaEemFchj9KFE7lsqm86hejy6
r0NsWZ1ALomVoR1Ds+w+YWbHtwoILWB7V71MShwtxRTQoynUbjvfv58IavWuSuhd
CXa6kf+Sqa3Pl7OSq5LT6UuEmMJvnqXal0FJdflZa6LKKorSCSV7qnbwDngmeF3S
tTj4JWeFANfUo/RmPloKeFhggwqRSpd4iYbvUVylWKR+SGpc33KF5gD1rT9O08He
YcHcR+Il7NmPrNSBtyM/SA+iJjdCGcgl915FAF4PICG89S/lJX8Bkmw/REIv3k95
TcOyenqv0VfWl0lqwGNYfMF/WDeZ/HwvpOYD7y2JeKRLsvRSPEICZkn1l45WHjoD
9m/mTs7b3seiLz/b3n7a/55/fvqpV/f6/Biwul1eVD/LYEueNv88uZSnM/N1Vs2g
b8bMj7lSV7wuP3ZkRrax+zePrf4zzp9LmTkbZ9W8mat1ejJcDtvxMybP1Rk5w2bP
zMk6ruS8DJfJ9v8zbs+Hdz5hnp6p/H8jnwFvmfDa3ydnA8NbJjN++H4p8NydecD2
2rgK3fzMvHx79MLingLMfYBVBa7nodpHCmNkH8Ees3BLN5SyfSsFX3sPEDPP6Vrd
fmhYXZGgqXY5nws1dn2BoG8XFmdVvwc2poJkPkP37AYPHtsFba/e/VPdUHSx7HF0
ZT9Ahzbrz9sn1xYuizECjOz1AL9qn6Az1b/3YVDtMzSDelwvRD+Qhjc/Veif37TY
RXoz/PB0zh/SjL75kUaYvk6S//NzGu1zkI7B43JUz9G3Y3Dpy32Gh7nviafxYrPf
K7vWJk93pLOc+6nNakATmQsHSvgCP4eQJXZA1IM/1BmO/RiiOWr8rGyeQTPe+KV7
+xHPIRwLwSaP52lJNzVTO3mdPchE65J/hhVMUk4m4EKFjz8l7cdgDmjG9VEuk5Lq
ZXvhtF6ZiI3hCZQ6MvBObx6/85I7Z5D1/s1JXXYDbdSwDbbdPdp1zhAzur04+jPB
HVDrbGVjuC8+C8BAKLpx9fdS0eOYJMAN3AAc+JbefLucdZSBgWsZr4zRxfaVRw61
b2zL6N/Vq42+spWZn7049BVc7nQ7aB7yE+vW85rZoOzi/EtyvG8TaOPRBk5+QygO
rmIX+nl+5n0K6o1SNT30CcOmYiu/h2z93Dv5bWT9omxaozeYiN5lSYWbBgLtDqtH
JBE1nbJ8MrSP1TCQ0E86fmaDPeYdC4jjon3mfmU18pO/xx9Aw32jE9bvpYJ/imVG
P7wA/Yg9oO/P2TutaZwBtqu6PiStM/VniJAefhCDGeJeyn7U/cCuXW1luTeWgiFz
dj7T1nLvqT596HOUVTVF0l0SHbBM+FrqgL/BK3H/e6WT+kxm+kQ4WVk7G55pjfl5
M3nJC3+zVtk4Rw6MzuTVmA0zcXKoHE+Lzozp98kAOn0m0ZjQstAkCZyw5OHCz11H
cx60r75oV7QLEi99wA33gUpfJfNzlCj5kziZYQvBm6HzhNSiCNHKz4KCWJ2cpqgg
vSYpp0+khg+6A0ksDViUqkvzwUlS6Pgp4AI3tNXKR3SiJ0jzIC6oesDRcbEV3qNH
YeJDYUMpVKzq6zE2EVRMWPAK4WygVGQtpE9MR3oV0Y5QY+1cuUKN9eHQWfBE51R0
fOpIr0V6fChsKIWK5Yw3c68O1gAMKqVh5yFa+AmnF4SdlFhZvRzg9Ghn4l4fHTL6
GQZNd2ZU1CNy3ZxV5wpJAPP4SdjZQUbMVQIjpOjW0KRUKi2Vll5gl1dgeBeBBBLI
KvoF5Qhptdi98xFeRXrFxyo+DrUYOeyYGGyxM2pmLCnT9BN4zOG8dKkoubNnfK3w
Jm1sM+xkq+UZpXxoA4/ppKTOilRiw84q9EKkEkBJxiGknvCAh7OCJjD0LhbA0vcQ
GXnAIH3cZ9KiIFd/yCcKqRPrYOR1phfg8hBwYYSti4osKqXAbf3Ds03iTwGgAF2X
Ea4EazLYqZEJ/bpF3lEgCkItFoxExXMy4WOSiOgqGMpahoVICsvHfX0KwMsrOnmQ
TdCQ4V7kY510MacgUtXY57VIQleESIRcfYCUiy2vFxXAZBlXfDR7oRehXh91kIC1
WfhrtQOcT7kgvGPZWYBIverRp4MBhBDxOZhUMPU49JFRJdP+sK9LEB+AZRcVVHnk
ksB4EB0wVRbAt0WguJdyneeVR6GTq8IFgQfRfkEYWuuwzw4D4hOIg/QaMoWWgDAe
COkgkJwaFaO8YugFIl0muPG7kIAwHvKA8pQopg5UnhLF1CnUReUpUUwdqDwliqlT
xEPlKVFMHQooT4liuqBZeUoUU4cCyosxTCCKgBLFcnJIMUfCQIcOiVl5ShRThwLK
U6JYTrCuA+fhBMcYsOz4bmjlKVEslaZ9zE/6VmstTCDLgmcz6qxCLwhxfubpr2y1
1sIEsix4NqPOKvRWIptIjEvFM7zVBrJOKEafijhFx9QmkIVnMOqsQg8u70FaEp4S
izqrGogRxIuEjjEPgUQicWGin56eHqysrAwWRqlQKo0Ums3rgnBRuBgvEmYRLxI6
FhUHdjAjBmElvJLbA1GKQ1jNOqvdQ1kW2adgZ0N4ZlMer5NJtmSfjh6ga5817HNS
J4XSHu5gRgzCSngltweiFIewmnVWu4eyLLJPwc6G8EwpQGydTLIl+3T24LY6y1Zn
n9tUShdkKrcFspE9ySmBRO1gZxS9UqcSii7IlNiB0+NtmXqs6FvoUafTs5N6ctQ5
hU5hhABhlGtAImkkh4Dgp6MUmhUICgEwRA5HJYQ8pgEfHNCHmPjQwZjYpBwnIBog
EK9jrZHMEVGAaBTiRULHxCAkG4LtGkx5OEnZsi1FD1hOWN4SfWK4xwHgSFjoDgHf
QzyrZ/mMlcWLhI5VE5WnRLECMShPiWKhIShPSU4Gl0AIIZYghBDWACGE/GYNIYQW
8SJhOeQhhBCOhREvEpZDKAuUp0QxdboaPihPiWLq5HSPD5SnRDHVMJDoTszQNTAy
qGg9ysypKEZDCGGT2RNCyLIQIYQW+hQhBCeFwETvjDltfPRE74w5DfQ2mOidMTeh
Jkz0zpjTtFDBRO+MueQbMNE7Y05MTQHaGXPahgmiOTAxtIRgonfGnKYBE70z5tA1
IhDsJ+iAislNsBgsQXGgpBSoDVTpPpHuNdK9rvWqpKZNbd/qGG/xFC/xVEEfS3O9
vFQxUj3P+3wlFgDqAFFYKagUUgooRQQkDUAlTUQbNIc0EeEUB2RVk+CFmSoXXZFE
0rrjlTyddSxe5fo2hBqhaC0TUsJWpw6oGQxtRfrw8e+ixwedfHz0es6fASao4rAo
ZyCfQN4rVwA5Bh8NnSUrx3Ay/BxtNkUbnnFnDYeLEzS4oK+iCEgM8pCBZ7TylXOA
78p17Z4a2GFU55ENNvS4F4PIgHlmD4uUBwyqPr6wUPVnZt0QwGezVb9X0R8So//T
GP3F6CdG36CaKGTuIwPZtMA9D4+7FG63tS3P+zNG7GqDSEQCFHU9t3kn9hBOsYLD
7T8+7MDhpEzHPoTbEDKAt6VYzVxDZqioHWCm9/Z0gptXPDalh7J9CLZa8oHnJX8Z
6Yfn/TLO927Rk3bPit3Dvov36/u7BzOeaW8vSWiUFYVQt+kIMOMK32dqWOMa3ZPC
QTjR/bZXQAu0YOehDzYUPPC7+zkEkhCTNTMsPzlnY3UHoFO158DAppaD+XIJh15A
kqUGR+J8YIUzNrLW0v2AsL7zGwzYNSrErzu0e1CD3+ypY8PLpMCANWCKHuRArbIz
xDLACH3Rw6nRao9vfAvYvvmtFRpQlF95B5ov11LOKHPWbMm33dnwGbI5A2wpW1aT
BPDLEu0DM5/yv/GXZ2H5mS8NJmHNM+A74TcyEoxjp+z54SRBw4jrl/HYO+dZ6J3C
dhLiqSl2k7dfNvGANewPJRzgl8Wbr0f6gHdwDyGuaz/77/U39vqie+7Onpzf8/bx
Qah1VtVCRGANdDggpUhweSE7wDwgCqAXDKXNpKVKYhEPWKNqns+gUjgAGg/QCS3a
mO+Lpx4W9AIM5ZDnAJKe92MR6NVIBqw9jbXf29oDIoAWWoJusxPBPIKymgUS4oAp
tGdc7adM/I4JRZ0CnFkTccGcMBTm9aWluZVK6yVj60cubf/IvScf+fDtyEfekVF1
R0a8fGRsd+Tai5IlEyFDLn/kyLUxzHbttau/dGnahw8XH3l29EeWPDsyZNiKZchF
s7C2zAAWzbrk/R3VK9T8TvITSBnSkAWtvMI3cGd2SBeANYxdAzXnABAB1NyOYHAR
HvCEL+VFlAdC+aS+L/xO9L74165Tj8/tK6TF7b5RYckPwUzu1b5ykD1/Xv0xXWV0
r734UN/gi/qT//l7rz3/dTkaG+UgyF/tS2LgT6rW1k/Bnoi/4wN1iP/4mocNsoF8
wbqhOTAH98PqsnsA9sMd/35Q6KDMB4lQaPuqH/S3Hv3MhvTD/wX7hfRhfTgfffkt
/hd995/0Sz/6ipT6F7K6Z/+BlfuN2X+Ut/2u/rxThUXQIkzUXciLtSp/dqBZ40/t
Ff4EX6HT/vp+TtfnxL86Z/eaPT0rL3nX5rx9t3fFnnE/8F1Ml0v1EOv1Av9uVTm5
L7Z9Tc6SiEzl1kPwfRVK3+A1WI5cw5dXnxxPqNfQ8ukT6ZPotZNDnzyv+DvGk+KK
jUM8GZ44r+fLhSfBk+ADk/aLMqjZy5vXhAlwAY+iUaPLf6vCxLfOnzBhHgHLpUfR
W13eW/sv563Q5ezX/MuX1//LlU92J7qVyNef5E5w65Inn9xW+sttJ8hr/eW1E/Wr
dDntJP3JbF1fjn5dys+vG1/ZIPv5hct3Vx+gL/gZXw74+8LBH9V8dZrUm37wsss0
9g+kCMlYNCI3xdRa9uD1wj65ruLxyT3Ob7xSl5tf8XyKVyy/IvkVx5/0xwOxFfcH
tuISvdb0cQfXCkqoPbbeo3YLtxsTq1TEzxNrRPzaCcNr+r2Nt/WzQj8B9xFtnWCU
8Js+a7IWEdlnM4UfRJR0wmqpX+DfAakGSnFEuAWP/Su1gFfwioGoDoBf1Jpdpzd9
0zuGfgeIGCqtMRiNR9KLNAL56HVqqLnpM9U/ZSTyzdX1VDR2ADxx1UseqlRLRinN
riQisl8uOrlHEMRy4Meg5EvS97J/OjgZK+Au/cL4ruhltAgcnG6FUQC5wcy/1P63
VyhHwz2eMHmF4RaD0i9riLZBYBqM/vgxm6a/f76anoBDQ4JlI1nRa/7QU7a9q3sd
4F3lzxf0tPv0efI83U6dpydsFVqcdbuK2Ly2ucP2vHLNQq3aSfel1WfhXp5Z6S+f
1e1x/XvC/OWyi3k78J1/9HxzV/sbQ62/cWn62huVLgKw6IQx6QOIKrMD+2P/ogW3
2196I6jJjblIv/apv7QPWtSgRLAs/+iN4ORB/vM3Bp9LxD2JXdjk8r5qL7rn67pZ
0AJYlL9eL+/+Gs4bgun5yg6AXy/Sf3K+lnX6RsIi3pI85e9tALAngmLl5Hr5toq2
4o+o5aEFf/S++o9CrfmhY/eB/QPbl9+u5Hm/UpdH7V/54m6NJA27gEeESI8zzixY
y1uLXFEu8EH9OHZAGFQvF63U/PhLREzl6oQQAasIsArz/8Vj5F/sBeNcpBYpQmVj
vNzoeNWqtDqFEpJV/6PrKMsA0Vec9HXlsxo6/KM6IIhcI6oNES0/nbxR/6CZP/e9
mBiEXtxzpGxOsW0QLY7bhmKA9IWT3Jr+8nLwdVySR8TZXeyTq2cBiP3iuMEoaAVM
7ItzL61896MO6OOSC3459Fi5eqtyzd8bIFdc05ccF4bfcX/x5lEdl9XluFgOybXk
2C6UlnNWu8odUXZE9YTLcuURrxwX5AjA+OrAp9CK5yJUii/jikeOA5HVHRq/6ScP
wF7FmYjpSCiotrX5xa/nADFAPaa+OEBu8e3BqNYGi6MOtMFf1R4sLoDZA8VBL674
3W76xbEHd0eK44xLsO5qcxh3XAG8qEVaeBFhX7xzgBq8gDbyYMB45IuDxoHz4Amj
XxQFxzOKWq6DenTxyPGC1hfHlArFAWS7jTtW/hoKPeND34OqPOOlC3lQ538NfnR8
HLxplE3uf/U745dVesaZ4G/ui0t+F0QPXpbX1+HBm8+6k/STy9wra8Zps/XaP/GM
R6+HcecFGAeG8eU5feORB5ErDoJnfHhABmNVY+dA4Nt+Y6TZR0GRvvhhTJ1sY2+G
l3YzzJRfjoeGOc7L4wwo/eQGqQCuP0ZpnlKA5Y4ioDRJaPgUwyoJY9CY0qYOWU5i
WIEAD21iktQyPNeMGP1+4usDBXKG+dvJyBK9lwRwgtfJwHUySFK/SgiaQKUyDKt3
WE1ikqHXwX5WJOVhIN2ngA6AgBDrS41lkOxbGfxlIEE/BZ4jARIHiCB9K9SAIwZ0
aRWbYYCAZo/wtQ/1wc+zEIyBdqCjEBQH8MAG1gb3d8gGDGAFsEAWUAauQAluwfeB
0EFoyGcYfKgkU9bJoTs1HmWa/YuaP3SHjUf+zzu+lOnrakn9Uk11Y3VcYUTnMo2T
PvXeMwvjRRPePFG6rnA6/4dGQze2yQde2M6A/1kfL/Wn834r+Zc5AnJMLbvqdf7V
kSV0PodeuXMCYXQzIH+UpzW9EzufRSqcY+/Pw7eGunHW51zLHX+sXz0KheJOP/JA
00RzspIpG6tpuAzyHOBxqoGIgi+TLyQ9IULlmfuvK7lhIzX84aaeNieFAn3N0AGI
pj4By6IgKX8hFD7uihsCTrlzQDXRIByBInqAGLTNbaPhAaCDZKmn2kTwkTcu8wXz
SyiaqByd4WG+MDakcACTaoY1bNS01jDcJIGI1yEA9G+JMAGVQxg2RhheaZzKWJQY
hBzDvCgtcmUDfQHCnBD35SC/BJlMXF81yTAwHpob6NruBMccS6EDrpdGwwr0Fciw
zv+0e7f9absidEaSVSpplEmkwgwDrHc8y1wmk7MaWKFRWklcRC1rQH+EpF7Nf89S
xQDDJASM028t1qJBV2QuxrNEfZafMm79QtrI0B0gWY/WJIfZX8Wp4/cUqA16tJkt
9SBsIdVGR8QGBwwYXgyg12FcyK0PTlUMLEm4+YT5KyGsVG5DyPu8vOElZlksq6Tm
Dh2k30LUMNTSD5mABjIdK4G2e6ARQGNg9JtCMPkUyyB0wupaYOGJwdLf8EgYkYbI
gni4+G/1xb6uQPugsOln9JkW5aoPDEf+5DLSp2DAIyZNO3dCtlkS+8KIHhg+5bi1
FXWBpgoDBXCAdvWTDJyateMhKDRypnTmycA0VXUyZlpTQEr2cVuGdPISoex5YxZZ
J6MCTKCzSSNmiCa5GOQVjPgHrUuSagIJq3zVkFFSMCBKbFpTNM5FBFooXM8NB9lw
UPyvNpPQ2qTDuGVIf0sYNnhggHBYEjYYpD3YiV0oSpJdayxDyBEUAOlo6A2EQO4B
Op22H+hDU4jLJmtyF+gfP48poZYYQqvhmItsebYEl+32lh7i4nRnQktlCtX0MRTI
aQcglMItBA6g83DDwMqyvNCxN0RuoEovBSMsBIO1jVCFSBk2SINtO+5fHMSmn4q4
jXhhcChPmA5wHMj8T7eAoML5EkqJBEahHSi1WZNicMQ5aAJsGe5ShmEsU+q0S7Mj
+5mQ0jD/hc71CroNrFPSogsoP00tcSG3eMx/nFMlkSusf7C3NPO+zYk8KubPWsav
cULFRaBO9T/DGwUVMJHGpg2ikGGDwyQZoZ4JUSg1ggDF6KsO/0COKk0q5EQSH8dF
KTeohDwJCUlDKf0cU0ghnI8r1z9A1p/71+9vPd3/3dSQTyor56v32iVk0vOx9KqH
Ql9VI78zmy5Iwkxe7ktTFsIKG6xpZCBQ08xD2NGxSkqFES43sNChDcIxWJBAB7DB
SmehFHY24kwgnQ8Zo3ydFYKQ/ucqpmxFlVtUvEW8JJbgwVtGyb66aJkOPiKQEc6A
thRZIK92urxA0Av1cCIufP6d0q3DmP174R43o12ooq6OEb+lD2jAwqEAgmib+pdn
0toVVpiuh6RFMAwIzht16IuiSoNyvQt4Ja/sh0625WVUqVQqWO1zdUvmf8fmXaui
wc8Vq0uzqMXKlYsIsHmNNkEiKO2ZW8n6hSZuP2toQF1noilSK1Z4muqIq8+zIDvr
JIRsVdZyQus6GnMNgB3CdjMlmtBq2ISlmrRTCQnHZaQqXdpc5QOntHE5HHf/pS2d
h/9FtpGRhVX4cnV0ZXJfVjTY0urEvr6y/wyrmmuDXZTScWQa/2ZvGMeQXfRbl+uK
nbkNavNWOLHYUZh1kJMuIl2XSy67P+9CYABoYxa8zFn0X+Zc2ZwVi+stS2ODqyMD
KKuz7DnLgG3sr1kOatPBa09a3yqzBGLNbNZkqvDnwiz+v75ALsqV9cKC6eDg6iwH
slxIz7pJ2AZdpmhvCY3uzK2iv/oPS5MLs8MCjAswpUQXlg0kgDCI8Sh1XkR2GY51
qs2BgGUD0OmPNlY3d+GDrk4M5OokOAx9voF05MijxZY9ZyBW3LZpYKkiu5s3EK3A
lcIlLmvX3WJjI8PGZvNbOwBjFhJXsohtiJ1VwMbmsBjF7SWuO1khG+al0kCul00T
ILowC3U+BQIhuxJIc0lhcpZIysgATnZOPChNWKsv0eK0XbBbl1Y+pDX/vWVjKVkH
gLRfAHobXsX1fpeha21YBd5pl+GZ/p9RXWXMVxhyqYawFWnV8/3/Y/gDAMxd18M2
VuVbb+zNehSLhTQ6trq2bFrI3to4Ue1CTVqlBjCHeTCWNhcmxqFoFqtceel6Rxpm
ERqbjEBWQ+a/dZNZC8rKxvDKNuLJSMhgIRdm4aw5q4YwtOwkzWHtW+6L/V8gaPy/
yZXpAXQ2tNCliV0IDI2OLO0OU5ewszK3jRRmmNVwTglLGisqY4NruyAUiCWnZQPI
2CwiALJabONjSWzW92BRk+lfJoahpjA5S4NZjJKGV8ZmljkluberVl0bXONyBUoa
Rr9VPXJlaWZpmMYAkGWoGkgeWViZHFuYaT+WrVmKqezF6odb3QvdWN11p3Ta5sJ0
rgVaPVU2i4Yza4g86wMhy606aLWWCLfyb6z536uGgi6BsFp4sVYrBacQAdrK7xI4
uvURSLuCQau+6f/fYAvguh+XE6xgxizNIbPqhU2srYp/LoxLH43+S0O5gNBVBi73
2ey32JMLABnXPptAQObq3tLsLqyp7jeVZPFbeCV4MCBtb3JmGKy6/FEGl0cHUnbm
FoY2BjDkVGX0RUU1BYDdwq3ODECFZa4Ew0doQId7RWZFlvxXRMjSvPgtunQp4XLd
I6wUFriyytUc10Bncm8uIBaCooNrq+jCANjexNqy4bGoZq7FilNzF+BwntN1j5zV
fgWA5fMiOguHu/P+Mr20uWsfb1YJIGwWC7mA7MCA8Fj/qwzO0iFrI2X4cvcGdw0n
urS5q4Y4ARcrsP8BYGYw2wRjFaPsjq6i5yCFxe3MwpeB23rQHKz6AwvAys//9+cf
+ffflwcQIxsLq9zS2LTSASijuzamTG4bxZWQsrEwNrg5jxuRVfZpdXFWgLm0LRxY
RVIgbmVodyBoY99JsPktp6E7ufTPymfD37LBLU2DWB//3Dzs3trGAOLY7rSIRfY2
BveW4YrWAxaPsjG3MrkyCwBIntxbW1kbSJ4VkDLrZ9gsf5SJgVR1bSCb+25lbWdl
cwAW11iw6Pi/PlSGErM3jRXe0ZzonHQYwQGRewOhqehlQFhirBJKSkC2noC43b25
rbnVcewA6Jor2QLR9Hd7uwBHzoIH5qPmSlyYAPDC6Nzy5kBEQiGTC7tbGwsTA7kW
kxkmNidklsxkKLCFjb2xefKqtVBVcKt+89//3REAgK1MLIwtAxe3tzS6MLkyuDdO
Gts2rm2xjggAK8FKlzMULn+Qk7GSE4AytjSzzSiRlVnlsC5isY3FLnNpZ2VyIf5w
b17+KRepoGAv+UKbq4MDCWs7C5ODs9S3eDArs4BoBEAhawdXjbs3NjO5Mrs3kBB+
toQ6yxl31gklIDp4aWZmdXOc/nRjZXJyb2MWnVuYZTZvY1YMZ2V0Fr1bGsjcCZsl
RWVyaHQAc9n9HfpuZW5vcHhlAHRpZ2lkGw5hpILNL1cm1lbnlg3jrsysJYZb2dob
3fXB3FzZ2FtFXyYHl6kPSBhImV3a2YU6IHNlb2QW+pb6ZG5hICJzKi4lIlY/0i58
AJ0yurkwOB2A6uS6NwsbDQeABWDuTC4MJM/NCpq3NzoQy2jurBvm6kAwuMFQBoCz
16nyYUosgYCQyZSAzJVs7VNZTXAHMHG5svCnk3tDm+OwGqCYmDr4jYySiKSooLAS
iqCyqL6KtJKuEzD7M7c3NhDtUVAHUGEyM05JV5f6NDZfNjh42PtERRX+E1IXwOkp
aUqqyGqDnykGppLPibnQJ6Kaqqx8DGU5JVFZv7Dev5FxyXGBAcDoXchKtADW+pz/
lvrb/m55ZJgc3RyGPtpcGJoFIIyuLW+uynd7a2t7G7NEmLNKCKMLI6vu6fDK6FwA
xNLYMBicnr6OnJKWhoosGjD0IfT1paHPVuXPkbnVvYm5AKTBhbml3b146++UkdWx
jbmlvfQJ7QF8fREVOR0lTTlVfUkFIQ19fQH4lLmlmZWR8QDEAGQkmL2BkLmVWQHQ
6NLKQOgqfLmwMji4MBC6Nze3sDGQk5GREwC6uTQ2ELkyOqt+uTC4bf4wMYCTuZIT
kLK2MDeQN7mxsDYQsjS2MDu3tKs+axbt3sX2DdDa/c/TmbEF7Zed5SdnbvX//siJ
"
		},
		{
			"1_fileName": "libtcc1-64.a",
			"2_dir": null,
			"3_compressedSize": 6978,
			"4_uncompressedSize": 41706,
			"5_added": "11:18 AM Tuesday, November 20, 2018",
			"6_description": "required file for libtcc.dll",
			"7_sha256": "
86e592aa356e3f5159700a3e16aa7992204d545961b27ea8cb626fcb34b1594b
",
			"8_data": "ClHlwBgAXgXqogAAAAAAAOqiAAAAAAAAJhsAACwNFj1VbdKUmtfYetVVagzAwtVU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"
		}
	]
}

Edit: Requires Cabinet.dll (Windows 8 or Windows Server 2012 and have "compressapi.h" and "cabinet.dll" and link to the "Cabinet.lib")
also the example has only been tested on 64bit version of AHK v2 and includes only the 64bit version of libtcc1.a

[Helgef]

Hello, I have a problem, it says,

Code: Select all

---------------------------
Error:  Call to nonexistent function.

Specifically: CreateDecompressor

	Line#
	461: COMPRESS_ALGORITHM_MSZIP := 2
	462: COMPRESS_ALGORITHM_XPRESS := 3
	463: COMPRESS_ALGORITHM_XPRESS_HUFF := 4
	464: COMPRESS_ALGORITHM_LZMS := 5
	467: DllCall("crypt32\CryptStringToBinary", "str", cryptString, "uint", 0, "uint", 1, "ptr", 0, "uint*", s, "ptr", 0, "ptr", 0 )
	478: VarSetCapacity(buffer, s*2)
	479: DllCall("crypt32\CryptStringToBinary", "str", cryptString, "uint", 0, "uint", 1, "ptr", &buffer, "uint*", s, "ptr", 0, "ptr", 0 )
--->	490: DllCall("Cabinet.dll\CreateDecompressor", "UInt", COMPRESS_ALGORITHM_LZMS, "Ptr",  0, "Ptr*", dHandle )
	496: size := s
	498: DllCall("Cabinet.dll\Decompress","Ptr", dHandle,"Ptr", &buffer,"UInt", size,"Ptr", &dBuffer,"UInt", 0,"UInt*", s )
	508: _s := VarSetCapacity(dBuffer, s)
	509: DllCall("Cabinet.dll\Decompress","Ptr", dHandle,"Ptr", &buffer,"UInt", size,"Ptr", &dBuffer,"UInt", _s,"UInt*", s )
	518: DllCall("Cabinet.dll\CloseDecompressor", "Ptr", dHandle)
	520: attribute := FileGetAttrib(target)
	521: if InStr(attribute, "D")

The current thread will exit.
---------------------------
OK   
---------------------------

I'm on win7 atm, perhaps that is the problem? I'll try on win10 later.

Anyways, looks interesting, thanks for sharing.

Cheers.

[oif2003]

Sorry for not specifying the requirements. I am still learning to use Windows API.
According to https://docs.microsoft.com/en-us/window ... uffer-mode:

Windows 8 and Windows Server 2012: To use the following example code, you must be running Windows 8 or Windows Server 2012 and have "compressapi.h" and "cabinet.dll" and link to the "Cabinet.lib".

Also I think it will only work on 64bit system since I have only included libtcc1-64.a
I will update the original post to state these requirements.

[oif2003]

I made significant changes to the script. It now contains all the header files that comes with TCC (as a json like string), and the script will only recompile the dll if changes are detected. C Code can now be broken up into pieces and are combined in the order they appear when the script loads. The script is too large to be posted on the forum, so I am only posting the code part of it (without the TCC attachments). See GitHub link for the full working version.

Edit: Now can be included so it doesn't mess up undo for your editor
Download both files to test it out:
https://github.com/oif2003/AHK_v2_64bit ... c.ahk?ts=4
https://github.com/oif2003/AHK_v2_64bit ... e.ahk?ts=4

Note: The snippets here are for your viewing pleasure only. They are missing TCC attachments and will not work. Download from GitHub to test it out.

Code: Select all

/*
	libtcc for AutoHotkey by oif2003 
	tested on AutoHotkey v2 a100 64bit only
	24 Nov 2018
	
	This script uses Tiny C Compiler's libtcc.dll to compile imbedded C code
	See examples for usage
*/
cFunc := useTCC(StrReplace(A_ScriptFullPath, ".ahk", ".tcc.ahk"))	;changing default to file with .tcc.ahk extension 
;-------------------------------------------------  FunC ends here :( ---------------------------------------------------
;========================================================================================================================	
;unpack Tiny C Compiler's libtcc.dll and needed files 
;compile c code to dll, load it, and then cleanup afterwards
useTCC(cFuncAHKscript := "", directory := "") {
	if !cFuncAHKscript {
		cFuncAHKscript := A_ScriptFullPath					;defaults to current script
	} else if !InStr(cFuncAHKscript, "\") {		
		cFuncAHKscript := A_ScriptDir "\" cFuncAHKscript	;when not given a full path
	}
	
	if !FileExist(cFuncAHKscript) {
		MsgBox("Error! libtcc locker script " cFuncAHKscript " cannot be found!")
		return
	}
	
	if !directory {
		directory := A_ScriptDir "\AHK_cFunc_Temp"
	}
	
	cFuncdllName := "cFunc.dll"
	,cFuncdllPath := directory "\" cFuncdllName
	
	;read c code
	,script := fileRead(A_ScriptFullPath)	;getting c code from this A_ScriptFullPath
	,startLabel := "/*_C" " func"			;but json storage is in cFuncAHKscript
	,endLabel   := "*/"
	,lastp := 1
	;loop read each section of c code and combine them to cStr
	while pos := InStr(script, startLabel, true, lastp) {
		cStart := InStr(script, "`n", , pos + StrLen(startLabel))
		,cEnd   := InStr(script, endLabel, , cStart + 1)
		,cStr   .= SubStr(script, cStart, cEnd - cStart) "`n"
		,lastp  := cEnd + 1
	}
	
	;calculate SHA256 of c code to see if we need to recompile cFunc.dll
	cHash  := storageManager.hashString(cStr, "SHA256")
	lastDll := fetchLastDll(cFuncAHKscript)	;fetch last cFunc.dll and hash of its c code
	if lastDll.cHash == cHash {
		DirCreate(directory)
		,storageManager.unpackFile(lastDll.data, cFuncdllPath, dataMode := true)
	} else {
		;load full locker object
		locker := storageManager.initialize(cFuncAHKscript, AutoSave := true)	;save locker content on script exit
		
		;unpack everything in tcc64 folder to "directory" folder
		;todo load and free library these dll: decompressor, crypto, ... etc
		hcrypt32 := DllCall("LoadLibrary", "Str", "Crypt32.dll", "Ptr")
		,hcabinet := DllCall("LoadLibrary", "Str", "Cabinet.dll", "Ptr")
		,storageManager.unpackFolder("\locker\file\tcc64", directory)
		,DllCall("FreeLibrary", "Ptr", hcabinet)
		,DllCall("FreeLibrary", "Ptr", hcrypt32)

		;LIBTCC calls to generate DLL
		,htcclib := DllCall("LoadLibrary", "Str", directory "\libtcc.dll", "Ptr") 
		,Context := DllCall("libtcc\tcc_new", "Ptr")

		;set path to our include/lib folders
		;~ StrPutVar(directory "\lib", libraryPath)
		;~ StrPutVar(directory "\include", includePath)
		;~ StrPutVar(directory "\include", sysincludePath)
		;~ StrPutVar(directory, tcclibPath)
		;~ DllCall("libtcc\tcc_add_library_path", "Ptr", Context, "Str", libraryPath, "Int")
		;~ DllCall("libtcc\tcc_add_include_path", "Ptr", Context, "Str", includePath, "Int")
		;~ DllCall("libtcc\tcc_add_sysinclude_path", "Ptr", Context, "Str", sysincludePath, "Int")
		;~ DllCall("libtcc\tcc_set_lib_path", "Ptr", Context, "Str", tcclibPath)
		
		;StrPutVar("", options)
		;DllCall("libtcc\tcc_set_options", "Ptr", Context, "Str", options)

		;TCC_OUTPUT_MEMORY       := 1 ; output will be run in memory (default)
		;TCC_OUTPUT_EXE          := 2 ; executable file
		,TCC_OUTPUT_DLL          := 3 ; dynamic library
		;TCC_OUTPUT_OBJ          := 4 ; object file
		;TCC_OUTPUT_PREPROCESS   := 5 ; only preprocess (used internally)
		,DllCall("libtcc\tcc_set_output_type", "Ptr", Context, "UInt", TCC_OUTPUT_DLL, "Int")

		StrPutVar(cStr, _cStr)
		,DllCall("libtcc\tcc_compile_string", "Ptr", Context, "Str", _cStr, "Int")

		;filedelete(cFuncdllPath)	;remove old copy
		StrPutVar(directory "\" cFuncdllName, filename)
		,DllCall("libtcc\tcc_output_file", "Ptr", Context, "Str", filename, "Int")
		
		;pack cFunc.dll and store hash of current c code as its description
		,storageManager.packFile(cFuncdllPath)
		,locker.file[cFuncdllName].description := cHash

		;clean up
		,DllCall("libtcc\tcc_delete", "Ptr", Context)
		,DllCall("FreeLibrary", "Ptr", htcclib)
	}

	cFuncHandle := DllCall("LoadLibrary", "Str", cFuncdllPath, "Ptr") 	
	onExit("cleanUp")
	
	return cFuncdllPath "\"	;add trailing "\" so we can append function names after it (for DllCall)
	
	;StrPutVar ehlper function straight from the v2 docs
	StrPutVar(string, ByRef var, encoding := "cp0") {    
		VarSetCapacity(var, StrPut(string, encoding) * ((encoding="utf-16"||encoding="cp1200") ? 2 : 1) )
		return StrPut(string, &var, encoding)
	}
	
	;delete temporary files we extracted/created
	cleanUp() {
		DllCall("FreeLibrary", "Ptr", cFuncHandle)
		,DirDelete(directory, Recurse := true)
	}
	
	fetchLastDll(cFuncAHKscript) {
		script := fileRead(cFuncAHKscript)
		,dllStart := InStr(script, "cFunc.dll", true, -1)
		,dllEnd := InStr(script, "`n", , InStr(script, ",", , InStr(script, "description", true, dllStart)))
		,cFuncDllStr := SubStr(script, dllStart, dllEnd - dllStart + 1)
		,dataStart := InStr(cFuncDllStr, '"data": "') + 10
		,dataEnd := InStr(cFuncDllStr, '"', , dataStart) - 1
		,data := SubStr(cFuncDllStr, dataStart, dataEnd - dataStart + 1)
		,SHAstart := InStr(cFuncDllStr, '"description": "') + 16
		,SHAend := InStr(cFuncDllStr, '"', , SHAstart) - 1
		,SHA := SubStr(cFuncDllStr, SHAstart, SHAend - SHAstart + 1)
		
		return {Data:data, cHash:SHA}
	}
}

;=============================================================================================================
;storageManager.packFolder()
;storageManager.unpackFolder()
;storageManager.delete("locker\file\")	;deletes all attached files
;storageManager.packFile(FileSelect(), "locker\file\someotherfolder\subfolder\")
;storageManager.unpackFile("locker\file\test1\dir.h", A_ScriptDir "\testfolder\new")
;storageManager.delete("locker\file\test1")
class storageManager {
	static   tempDir := A_ScriptDir	;todo: change all A_ScriptDir to storageManager.tempDir
			,label   := "/* storageManager" " " "attachements"	;label used for attachments
			,script
			,locker
			,saveScriptPath
	
	initialize(saveScriptPath, AutoSave := true) {
		storageManager.saveScriptPath := saveScriptPath
		storageManager.locker := this.load()
		if AutoSave {
			OnExit(()=>this.save())
		}
		return storageManager.locker
	}
		
	save() {	;dumps the current locker object as json string and saves it
		this.script := SubStr(this.script, 1, InStr(this.script, this.label) - 1)
		this.script := this.script this.label "`n" this.json.auto(this.locker) 
		FileOpen(storageManager.saveScriptPath, "w").Write(this.script)
	}
	
	load() {	;loads the json string at the end of this file into the locker object
		this.script := FileRead(storageManager.saveScriptPath)
		,jstr := SubStr(this.script, InStr(this.script, this.label, true, -1) + StrLen(this.label) + 1)
		return this.json.auto(jstr)
	}
	
	delete(storagePath) {	;deletes a single file or folder
		path := this.parseStoragePath(storagePath)	;parse storagePath
		fileName := path.fileName
		path.folder.Delete(fileName)
	}	
	
	parseStoragePath(path) {	;helper function for parsing "\" separated storage paths
		path := Trim(path, "\")
		,parts := StrSplit(path, "\")
		,fileName := parts.Pop()
		,parts.RemoveAt(1)		;first chunck is "locker"
		,op := this.locker		;first point to this.locker (which inturn points to global var locker)
		for _, v in parts {		;points to each folder inside locker until we exhaust the provided path
			op := op[v]
		}
		return {folder:op, fileName:fileName}	;returns fileObject and fileName
	}
	
	unpackFolder(storagePath := "locker\file", targetPath := "", options := "R") {		; R-recursive
		if !targetPath {
			targetPath := DirSelect("*" A_ScriptDir, 1 + 2, "Select destination folder")
		}
		path := this.parseStoragePath(storagePath)	;parse storagePath

		for k, v in path.folder[path.fileName] {
			if v.HasKey("attribute") { ;indicating we have a file not a folder
				this.unpackFile(storagePath "\" k, targetPath "\")
			} else if InStr(options, "R") {
				DirCreate(targetPath "\" k)
				this.unpackFolder(storagePath "\" k, targetPath "\" k, options)	;recursive call
			}
		}
	}
	
	packFolder(folder := "", dest := "locker\file\", options := "R") {	; R-recursive
		;prompt user for folder and destination folder if folder param is null
		if !folder {
			folder := DirSelect("*" A_ScriptDir)
			userFolder := InputBox("Enter folder name for storage")
			dest := userFolder ? (dest . Trim(userFolder, "\") . "\") : dest
		}
		folderLen := StrLen(folder)
		
		;loop through file/folder (recursively if "R" flag is present in options parameter)
		Loop Files folder "\*" , options = "R" ? "R" : "F" {
			;contruct storagePath string from dest and A_LoopFileFullPath
			storagePath := dest . SubStr(A_LoopFileFullPath,  folderLen + 2, InStr(A_LoopFileFullPath, "\", , -1) - folderLen - 1)
			this.packFile(A_LoopFileFullPath, storagePath)
		}
	}
	
	unpackFile(storagePath, targetPath := "", dataMode := false) {	;in dataMode storagePath == raw data
		if dataMode {												;and targetPath must include file name
			cryptString := storagePath
		} else {
			;parse storagePath
			path := this.parseStoragePath(storagePath)
			,fileName := path.fileName
			,cryptString := path.folder[fileName].data	;base64 data string to be decrypted and decompressed
		}
		
		;parse targetPath
		if !targetPath {								
			filePath := A_ScriptDir "\" fileName				;default to A_ScriptDir
		} else if InStr(FileExist(targetPath), "D") {			;
			filePath := RTrim(targetPath, "\") "\" fileName		;if targetPath is a directory
		} else {
			filePath := targetPath
		}
		
		;write empty file if file in storage is also empty (data == "`r`n")
		if !Trim(cryptString, "`r`n") {
			FileDelete(filePath)
			FileAppend("", filePath)	
			return
		}
		;https://docs.microsoft.com/en-us/windows/desktop/api/compressapi/nf-compressapi-createcompressor
		;COMPRESS_ALGORITHM_MSZIP        := 2    ;MSZIP compression algorithm
		;COMPRESS_ALGORITHM_XPRESS       := 3 	;XPRESS compression algorithm 
		;COMPRESS_ALGORITHM_XPRESS_HUFF  := 4	;XPRESS compression algorithm with Huffman encoding
		COMPRESS_ALGORITHM_LZMS         := 5	;LZMS compression algorithm
		
		;first call to get buffer size
		DllCall("crypt32\CryptStringToBinary"
			,"str", cryptString	            ;pszString
			,"uint", 0			            ;cchString
			,"uint", 1			            ;dwFlags
			,"ptr", 0		    	        ;pbBinary
			,"uint*", s	    	            ;pcbBinary
			,"ptr", 0			            ;pdwSkip
			,"ptr", 0			            ;pdwFlags
		)

		;set buffer size based on previous call (*2 for UTF)
		,VarSetCapacity(buffer, s*2)
		,DllCall("crypt32\CryptStringToBinary"
			,"str", cryptString	            ;pszString
			,"uint", 0			            ;cchString
			,"uint", 1			            ;dwFlags
			,"ptr", &buffer	    	        ;pbBinary
			,"uint*", s	    	            ;pcbBinary
			,"ptr", 0			            ;pdwSkip
			,"ptr", 0			            ;pdwFlags
		)

		;Create Decompressor Handle
		,DllCall("Cabinet.dll\CreateDecompressor"
			,"UInt", COMPRESS_ALGORITHM_LZMS	    ;Algorithm
			,"Ptr",  0		                    ;AllocationRoutines,
			,"Ptr*", dHandle                     ;CompressorHandle
		)

		,size := s
		;first call to get buffer size (s)
		,DllCall("Cabinet.dll\Decompress"
			,"Ptr", dHandle                   ;DecompressorHandle,
			,"Ptr", &buffer                   ;CompressedData,
			,"UInt", size                     ;CompressedDataSize,
			,"Ptr", &dBuffer                  ;UncompressedBuffer,
			,"UInt", 0                        ;UncompressedBufferSize,
			,"UInt*", s                       ;UncompressedDataSize
		)

		;set buffer size based on previous call
		,_s := VarSetCapacity(dBuffer, s)
		,DllCall("Cabinet.dll\Decompress"
			,"Ptr", dHandle                   ;DecompressorHandle,
			,"Ptr", &buffer                   ;CompressedData,
			,"UInt", size                     ;CompressedDataSize,
			,"Ptr", &dBuffer                  ;UncompressedBuffer,
			,"UInt", _s                       ;UncompressedBufferSize,
			,"UInt*", s                       ;UncompressedDataSize
		)

		,DllCall("Cabinet.dll\CloseDecompressor", "Ptr", dHandle)
		
		,FileDelete(filePath)
		,FileOpen(filePath, "w").RawWrite(dbuffer,s)
	}

	packFile(file, dest := "locker\file\") {	; packs and compresses a file, it is then stored as plaintext
		size    := FileGetSize(file)
		sha256  := this.hashFile(file, "SHA256")
		dlltext := FileRead(file, "RAW")
		_size 	:= size
		
		;https://docs.microsoft.com/en-us/windows/desktop/api/compressapi/nf-compressapi-createcompressor
		;COMPRESS_ALGORITHM_MSZIP        := 2    ;MSZIP compression algorithm
		;COMPRESS_ALGORITHM_XPRESS       := 3 	;XPRESS compression algorithm 
		;COMPRESS_ALGORITHM_XPRESS_HUFF  := 4	;XPRESS compression algorithm with Huffman encoding
		COMPRESS_ALGORITHM_LZMS         := 5	;LZMS compression algorithm

		DllCall("Cabinet.dll\CreateCompressor"
			,"UInt", COMPRESS_ALGORITHM_LZMS	    ;Algorithm,
			,"Ptr",  0		                    ;AllocationRoutines,
			,"Ptr*", cHandle                     ;CompressorHandle
		)

		;https://docs.microsoft.com/en-us/windows/desktop/api/compressapi/nf-compressapi-compress
		;first call to get buffer size (s)
		DllCall("Cabinet.dll\Compress"
			,"Ptr", cHandle                   ;CompressorHandle,
			,"Ptr", &dlltext                  ;UncompressedData,
			,"UInt", size                     ;UncompressedDataSize,
			,"Ptr", &cBuffer                  ;CompressedBuffer,
			,"UInt", 0                        ;CompressedBufferSize,
			,"UInt*", s                       ;CompressedDataSize
		)

		;set buffer size based on previous call
		_s := VarSetCapacity(cBuffer, s)
		DllCall("Cabinet.dll\Compress"
			,"Ptr", cHandle                   ;CompressorHandle,
			,"Ptr", &dlltext                  ;UncompressedData,
			,"UInt", size                     ;UncompressedDataSize,
			,"Ptr", &cBuffer                  ;CompressedBuffer,
			,"UInt", _s                       ;CompressedBufferSize,
			,"UInt*", s                       ;CompressedDataSize
		)
		
		DllCall("Cabinet.dll\CloseCompressor", "Ptr", cHandle)

		size := s
		;https://docs.microsoft.com/en-us/windows/desktop/api/wincrypt/nf-wincrypt-cryptbinarytostringw
		;first call to find size (s) needed for our crypt string
		DllCall("crypt32\CryptBinaryToString"
			,"Ptr", &cBuffer			    ;pbBinary   ptr to array of bytes
			,"uint", size            	    ;cbBinary   length of array
			,"uint", 1						;dwFlags    flags: 1 = 64 bit without headers
			,"ptr", 0				        ;pszString  when this is 0, pccString returns needed size
			,"uint*", s			            ;pccString
		)
		
		
		VarSetCapacity(cryptString, s := s * 2)     ;*2 for unicode
		;second call to get the actual string
		DllCall("crypt32\CryptBinaryToString"
			,"Ptr", &cBuffer			    ;pbBinary   ptr to array of bytes
			,"uint", size            	    ;cbBinary   length of array
			,"uint", 1						;dwFlags    flags: 1 = 64 bit without headers
			,"str", cryptString		        ;pszString  now this is ptr to buffer of string
			,"uint*", s     		        ;pccString  size of buffer as previously determined
		)
		
		;combine every other line (basically format with 3 instead of 1 coloumn to save space)
		;we could do more but I'd rather not have line wrap
		strArr := StrSplit(cryptString, "`r`n")
		for k, v in strArr {
			data .= v (!Mod(k, 3) ? "`n" : "")	;set to three columns
		}
		data := "`n" data
		size := StrLen(data) + strArr.Length() // 2
		SplitPath(file, fileName)
		
		destobj := str2obj(dest)	;destobj is an array. [1]:points to object base. [2]:points to file write location
		; writing file data
		destobj[2][fileName] := {	  originalSize: _size					;uncompressed file size
									, packededSize: size					;estimation of packed size (1 char = 1 byte)
									, added:        formattime(A_Now)		;when file was added
									, description:  description				;Used for certain files, ie: storing hash
									, SHA256:       sha256					;	of compiled dll's c code
									, data:         data					;compressed binary as base 64 string
									, directory:	dest					;pseudo directory where the file is stored
									, attribute:    "F"			  	  }		;reserved for future use
									
		merge(destobj[1], this.locker)	;merging destobj[1] into this.locker (locker in global scope)
		
		;helper function for generating object structure from string so we can merge it with json structure
		str2obj(ostr) {		
			ostr := Trim(ostr, "\")
			parts := StrSplit(ostr, "\")
			_po := po := %parts[1]% := {}			;po points to the first level of the object
			loop parts.Count() - 1 {				;_po points to the last (where we will put the file object)
				_po := _po[parts[A_Index+1]] := {}
			}
			return [po, _po]
		}
		
		;helper function which allows us to merge objects.  x is merged into y
		merge(x, y) {	;by reference, x, y are objects
			for s, t in x {
				found := false
				for u, v in y {
					if s == u {							
						if isObject(t) && isObject(v) {			;this rule may need to be updated
							merge(t, v)							;to better handle files of same name
						} else {								;being added
							if isObject(x[s]) {
								y[u] := x[s].Clone()
							} else if !isObject(y[u]) {
								y[u] := x[s]
							}
						}
						found := true
					}
				}
				if !found {
					y[s] := isObject(t) ? t.Clone() : t
				}
			}
		}
		
	}
	
	;-------------------------------------------------------------------------------------------------------------------
	;hashFile(FullFilePath, Algorithm) - valid Algorithms: MD2, MD4, MD5, SHA1, SHA256, SHA384, SHA512
	;-------------------------------------------------------------------------------------------------------------------
	hashFile(file := "", algo := "") {	;using CertUtil
		static 	 cPid := 0
				,lastError := ""	;stores last error message: strStdOut
				,Supported_Hash := Object("MD2",_,"MD4",_,"MD5",_,"SHA1",_,"SHA256",_,"SHA384",_,"SHA512",_)
		
		;return last error message
		if !file {
			return lastError
		}
		
		;check to see if requested algorithm is supported
		algo := StrUpper(algo)
		if !Supported_Hash.HasKey(algo) {
			return
		}
		
		;create and hide command window if we don't already have one
		if !cPid {
			_A_DetectHiddenWindows := A_DetectHiddenWindows
			,A_DetectHiddenWindows  := true
			,Run(A_ComSpec " /k ",, "Hide", cPid)
			,WinWait("ahk_pid" cPid, , 10)
			,DllCall("AttachConsole","uint", cPid)
			,A_DetectHiddenWindows  := _A_DetectHiddenWindows
			
			;clean up on exiting script
			OnExit(()=>cleanUp(cPid))
		}
		
		;run command and get output
		objShell := ComObjCreate("WScript.Shell")
		objExec  := objShell.Exec('certutil -hashfile "' file '" ' algo)
		while !objExec.StdOut.AtEndOfStream {
			strStdOut := objExec.StdOut.ReadAll()
		}

		;parse output
		start := InStr(strStdOut, file ":") + StrLen(file) + 1
		end := InStr(strStdOut, "CertUtil: -hashfile command completed successfully.", , -1) - 1
		if start < end {
			return StrUpper(SubStr(strStdOut, start + 2, end - start - 2))
		} else {
			lastError := strStdOut
			return
		}
		
		;cleanUp function called on script exit (OnExit)
		cleanUp(_cPid) {
			_A_DetectHiddenWindows := A_DetectHiddenWindows
			A_DetectHiddenWindows := true
			DllCall("FreeConsole", "UInt")
			WinKill("ahk_pid" _cPid)
			A_DetectHiddenWindows := _A_DetectHiddenWindows
		}
	}

	;-------------------------------------------------------------------------------------------------------------------
	;hashString(String, Algorithm) - valid Algorithms: MD2, MD4, MD5, SHA1, SHA256, SHA384, SHA512
	;-------------------------------------------------------------------------------------------------------------------
	hashString(string, algo) {
		;These are the supported formats, maybe someone else can get the rest to work?
		static Supported_Hash := Object("MD2",_,"MD4",_,"MD5",_,"SHA1",_,"SHA256",_,"SHA384",_,"SHA512",_)
		
		;check to see if requested algorithm is supported
		algo := StrUpper(algo)
		if !Supported_Hash.HasKey(algo) {
			return
		}
		
		;continue if algorithm is supported
		hModule := DllCall("LoadLibrary", "Str", "Bcrypt.dll", "Ptr")
		,size := StrPutVar(string, str) - 1	;put string in str variable as UTF-8 for later use
		
		;See link for explaination of steps taken below: 
		;https://docs.microsoft.com/en-us/windows/desktop/SecCNG/creating-a-hash-with-cng
		;-------------------------------------------------------------------------------------------------
		;https://docs.microsoft.com/en-us/windows/desktop/api/Bcrypt/nf-bcrypt-bcryptopenalgorithmprovider
		,DllCall("Bcrypt.dll\BCryptOpenAlgorithmProvider"
			,"Ptr*", phandle
			,"Str", algo
			,"Str", 
			,"UInt", 0
			,"UInt"	;returned error code see winnt.h
		)

		;https://docs.microsoft.com/en-us/windows/desktop/api/Bcrypt/nf-bcrypt-bcryptgetproperty
		,DllCall("Bcrypt.dll\BCryptGetProperty"
			,"Ptr", phandle
			,"Str", "ObjectLength"					;getting length of object
			,"UInt*", pbOutput
			,"UInt", 4
			,"UInt*", pcbResult
			,"UInt", 0
			,"UInt"	;returned error code see winnt.h
		)

		;https://docs.microsoft.com/en-us/windows/desktop/api/Bcrypt/nf-bcrypt-bcryptcreatehash
		,cbHashObject := pbOutput
		,VarSetCapacity(pbHashObject, cbHashObject, 0)
		,DllCall("Bcrypt.dll\BCryptCreateHash"
			,"Ptr", phandle
			,"Ptr*", phHash
			,"Ptr", &pbHashObject
			,"UInt", cbHashObject
			,"Ptr", 0
			,"UInt", 0
			,"UInt", 0
			,"UInt"	;returned error code see winnt.h
		)

		;https://docs.microsoft.com/en-us/windows/desktop/api/Bcrypt/nf-bcrypt-bcrypthashdata
		,DllCall("Bcrypt.dll\BCryptHashData"
			,"Ptr", phHash
			,"Ptr", &str ;&pbInput
			,"UInt", size ;cbInput
			,"UInt", 0
			,"UInt"	;returned error code see winnt.h
		)

		;https://docs.microsoft.com/en-us/windows/desktop/api/Bcrypt/nf-bcrypt-bcryptgetproperty
		,DllCall("Bcrypt.dll\BCryptGetProperty"
			,"Ptr", phandle
			,"Str", "HashDigestLength"					;getting length of hash
			,"UInt*", pbOutput
			,"UInt", 4
			,"UInt*", pcbResult
			,"UInt", 0
			,"UInt"	;returned error code see winnt.h
		)
		hashsize := pbOutput

		;https://docs.microsoft.com/en-us/windows/desktop/api/Bcrypt/nf-bcrypt-bcryptfinishhash
		,cbOutput := hashsize
		,VarSetCapacity(pbOutput, cbOutput, 0)
		,DllCall("Bcrypt.dll\BCryptFinishHash"
			,"Ptr", phHash
			,"Ptr", &pbOutput
			,"UInt", cbOutput
			,"UInt", 0
			,"UInt"	;returned error code see winnt.h
		)

		;read each byte and append its 2 digit hex value to hashstr
		loop hashsize {
			hashstr .= format("{:02x}", NumGet(&pbOutput, A_Index - 1 , "UChar"))
		}

		;clean up
		DllCall("Bcrypt.dll\BCryptDestroyHash", "Ptr", phHash, "UInt")
		,DllCall("Bcrypt.dll\BCryptCloseAlgorithmProvider", "Ptr", phandle, "UInt", 0, "UInt")
		,DllCall("FreeLibrary", "Ptr", hModule)

		return StrUpper(hashstr)
		
		;-------------------------------------------------------------------------------------------------
		;helper function
		StrPutVar(string, ByRef var) {	;from AHK v2 doc
			VarSetCapacity(var, StrPut(string, "Utf-8"))
			return StrPut(string, &var, "Utf-8")
		}
	}
	
	;=============================================================================================================
	;todo: implement proper escape sequences at least for AutoHotkey (perhaps during token/detoken phases?)
	;json-like class.  for internal use only.  does not properly support json
	class json {
		;auto input parser json string <=> ahk object
		auto(input) {
			if IsObject(input) {
				return this.obj2str(input)
			} else {
				return this.str2obj(input)
			}
		}
		
		;------------------------------------------------------------------------------------------
		;convert object to json string
		obj2str(obj, firstRun := true) {
			static   output := ""
					,level := 0
					,noTab := false
			if firstRun {
				output := ""
			}
			
			if isObject(obj) {
				if obj.Count() {
					if isArray(obj) {	;if this is an array (based on A_Index == key)
						output .= (noTab ? "" : tabs(level)) "[`n"
						level++
						noTab := false
						for k, v in obj {
							this.obj2str(v, false)
							output .= (k != obj.Count() ? "," : "") "`n"
						}
						output .= tabs(--level) "]"
					} else {	;otherwise output as object
						output .= (noTab ? "" : tabs(level)) "{`n"
						level++
						noTab := false
						for k, v in obj {
							output .= tabs(level) '"' k '": '
							noTab := true
							this.obj2str(v,  false)
							noTab := false
							output .= (A_Index != obj.Count() ? "," : "") "`n"
						}
						output .= tabs(--level) "}"
					}
				} else {
					output .= "[]"
				}
			} else {
				if obj == "" {
					obj := "null"
				} else if !(obj is "Number") || !isNumber(obj) {	;don't put quotes around numbers
					obj := '"' obj '"'
				}
				output .= (noTab ? "" : tabs(level)) obj
			}
			
			return output
			
			isNumber(x) {	;quickly and dirty check.  Other ideas: use is Type first then do this
				return NumGet(&x, "UInt")   == x 
					|| NumGet(&x, "Int")    == x || NumGet(&x, "Int64") == x 
					|| NumGet(&x, "Double") == x || NumGet(&x, "Float") == x 
					|| NumGet(&x, "Ptr")    == x || NumGet(&x, "UPtr") == x
					|| NumGet(&x, "Short")  == x || NumGet(&x, "UShort") == x 
					|| NumGet(&x, "Char")   == x || NumGet(&x, "UChar") == x 
			}
			
			isArray(arr) {	;another quick and dirty check: A_Index == Current Key ?
				if !IsObject(arr) {
					return false
				} else {
					for k, v in arr {
						if k != A_Index {
							return false
						}
					}
					return true
				}
			}
			
			tabs(n) {	;create tab string
				loop n {
					tab .= "`t"
				}
				return tab
			}
		}

		;------------------------------------------------------------------------------------------
		;covert json string to ahk function string then feed it thru the function parser
		str2obj(jstr) {
			funcStr := this.jstr2func(jstr)
			,o := this.funcParser(strreplace(funcstr, '"'))
			return o
		}
		
		;recursively evaluate the function string
		funcParser(funcStr) {
			paren := InStr(funcStr, "(")
			if paren {
				innerStr := SubStr(funcStr, paren + 1, -1)
				,parenCount := 0
				,argStart := 1
				,args := []
				loop parse innerStr {
					if A_LoopField == "(" {
						parenCount++
					} else if A_LoopField == ")" {
						parenCount--
					}
					
					if !parenCount && A_LoopField == "," {
						args.push(SubStr(innerStr, argStart, A_Index - argStart))
						,argStart := A_Index + 1
					} else if A_Index == StrLen(innerStr) {
						args.push(SubStr(innerStr, argStart, A_Index - argStart + 1))
					}
				}
				
				for k, v in args {
					args[k] := this.funcParser(v)
				}
				
				return func(SubStr(funcStr, 1, paren - 1)).Call(args*)
			} else {
				this.restoreString(funcStr, this.dictionary)	;replace string tokens with their originals
				if funcStr is "Number" {
					return funcStr + 0
				} else {
					if funcStr == "null" {
						return
					} else if funcStr == "true" {
						return true
					} else if funcStr == "false" {
						return false
					} else if SubStr(funcStr, 1, 1) == '"' && SubStr(funcStr, -1, 1) == '"' {
						funcStr := SubStr(funcStr, 2, -1)	;remove quotation marks on strings
						return funcStr
					} else {
						return "Unhandled exception, check " A_ScriptName ", " A_ThisFunc ", " A_LineNumber
					}
				}
			}
		}

		;convert json string to function string in ahk. namely, array() and object()
		jstr2func(jstr, firstRun := true) {
			static   tokenBase := 0x1abf - 1
					,commaToken := Chr(tokenBase + 1)
					,colonToken := Chr(tokenBase + 2)
			
			if firstRun {
				this.dictionary := this.tokenizeString(jstr)
				,jstr := StrReplace(jstr, "`n")				;remove newline, tab, and space
				,jstr := StrReplace(jstr, "`r")
				,jstr := StrReplace(jstr, "`t")
				,jstr := StrReplace(jstr, " ")
			}
				
			if !InStr(jstr, "[") && !InStr(jstr, "{") {
				return jstr
			} else {
				inner := findInnerMost(jstr)
				,innerStr := SubStr(jstr, inner[1], inner[2] - inner[1] + 1)
				,jstr := SubStr(jstr, 1, inner[1] - 1) str2func(innerStr) SubStr(jstr, inner[2] + 1)
				,jstr := this.jstr2func(jstr, firstRun := false)
				
				return jstr
			}
			
			str2func(str) {		;convert string to function
				brace := InStr(str, "{")
				,brack := InStr(str, "[")
				if brack {
					
					funcStr := 'Array('
					,funcStrArr := StrSplit(SubStr(str, 2, -1), commaToken)
					for k, v in funcStrArr {
						funcStr .= str2func(v) (k != funcStrArr.Length() ? "," : "")
					}
					funcStr .= ")"
				} else if brace {
					funcStr := 'Object(' StrReplace(SubStr(str, 2), "}", ")") 		
					,funcStr := StrReplace(funcStr, ':', ',')
				} else {
					return str
				}
				return funcStr
			}
			
			findInnerMost(str) {	;find innermost object/array
				braceCount := brackCount := maxCount := maxStart := maxEnd := 0

				loop parse str {
					if 			A_LoopField == "{" {
						braceCount++
					} else if 	A_LoopField == "}" {
						braceCount--
					} else if 	A_LoopField == "[" {
						brackCount++
					} else if 	A_LoopField == "]" {
						brackCount--
					}
					
					if braceCount + brackCount > maxCount {						;Find max cumulative count of [ and {
						maxCount := braceCount + brackCount
						,maxStart := A_Index										;Update max [ / { location
						,closing := SubStr(str, A_Index, 1) == "[" ? "]" : "}"
						,maxEnd := InStr(str, closing, , A_Index)				;update where it ends
					}
				}
				return [maxStart, maxEnd]
			}
		}
		
		;------------------------------------------------------------------------------------------
		;helper methods
		restoreString(ByRef str, dictionary) {
			static   tokenBase := 0x1abf - 1
					,strToken  := Chr(tokenBase + 3)
					,escapedQuote := Chr(tokenBase + 4)
			for k, v in dictionary {
				str := StrReplace(str, strToken k strToken, v, , 1)
			}
			str := StrReplace(str, escapedQuote, '"')
		}

		tokenizeString(ByRef str) {
			static   tokenBase := 0x1abf - 1
					,strToken  := Chr(tokenBase + 3)
					,scapedQuote := Chr(tokenBase + 4)
			
			quoteCount :=  quoteStart := 0
			,dictionary := []
			
			,str := StrReplace(str, '``"', escapedQuote)
			
			loop parse str {
				if A_LoopField == '"' {
					quoteCount++

					if Mod(quoteCount, 2) {
						quoteStart := A_Index
					} else {
						quoteEnd := A_Index
						,dictionary.push(SubStr(str, quoteStart, quoteEnd - quoteStart + 1))
					}
				}
			}
			
			for k, v in dictionary {
				str := StrReplace(str, v, strToken k strToken, , 1)
			}
			
			return dictionary
		}
	}
}

A simple C function example:

Code: Select all

;make a copy of the cFunc_Example.tcc.ahk and place it in your script's folder with the same name
;but the .tcc.ahk extention instead of .ahk, then #Include it as below
#Include cFunc_Example.tcc.ahk

hello() => DllCall(cFunc "hello", "AStr")	
/*_C func
	#define DLL __attribute__ ((dllexport)) 
	
	DLL char * hello(void) {					
		return "Hello world!";
	}
*/

MsgBox(hello())

A potential use for something like this would be for prototyping C functions as replacement for existing AHK functions. Once the prototyping is done, one can either export the dll and remove all the extra stuff, or simply do nothing at all (which is my preferred way).