From deee2d021b63c303f9f091e5165f57e6a3cc61f9 Mon Sep 17 00:00:00 2001 From: CoprDistGit Date: Mon, 5 Aug 2024 01:31:13 +0000 Subject: automatic import of Xaw3d --- .gitignore | 2 + Xaw3d-1.5-debian-fixes.patch | 647 +++++++++++++++++++++++++++++++++ Xaw3d-1.6.1-3Dlabel.patch | 162 +++++++++ Xaw3d-1.6.1-fontset.patch | 60 +++ Xaw3d-1.6.1-hsbar.patch | 260 +++++++++++++ Xaw3d.spec | 397 ++++++++++++++++++++ mattst88.asc | 843 +++++++++++++++++++++++++++++++++++++++++++ sources | 2 + 8 files changed, 2373 insertions(+) create mode 100644 Xaw3d-1.5-debian-fixes.patch create mode 100644 Xaw3d-1.6.1-3Dlabel.patch create mode 100644 Xaw3d-1.6.1-fontset.patch create mode 100644 Xaw3d-1.6.1-hsbar.patch create mode 100644 Xaw3d.spec create mode 100644 mattst88.asc create mode 100644 sources diff --git a/.gitignore b/.gitignore index e69de29..39e9f72 100644 --- a/.gitignore +++ b/.gitignore @@ -0,0 +1,2 @@ +/libXaw3d-1.6.3.tar.bz2 +/libXaw3d-1.6.3.tar.bz2.sig diff --git a/Xaw3d-1.5-debian-fixes.patch b/Xaw3d-1.5-debian-fixes.patch new file mode 100644 index 0000000..2a2aedf --- /dev/null +++ b/Xaw3d-1.5-debian-fixes.patch @@ -0,0 +1,647 @@ +diff -up Xaw3d-1.5libXaw3d-1.6.1/src/AsciiSrc.c.debian Xaw3d-1.5libXaw3d-1.6.1/src/AsciiSrc.c +--- Xaw3d-1.5libXaw3d-1.6.1/src/AsciiSrc.c.debian 2000-11-27 14:19:36.000000000 +0100 ++++ Xaw3d-1.5libXaw3d-1.6.1/src/AsciiSrc.c 2008-10-06 11:42:13.000000000 +0200 +@@ -51,11 +51,17 @@ in this Software without prior written a + #include + #endif + ++#include ++#include ++#include + + #if (defined(ASCII_STRING) || defined(ASCII_DISK)) + # include /* for Widget Classes. */ + #endif + ++#include ++#include ++#include + + /**************************************************************** + * +@@ -1007,7 +1013,9 @@ InitStringOrFile(src, newString) + AsciiSrcObject src; + Boolean newString; + { +- char * open_mode = NULL; ++ mode_t open_mode = 0; ++ const char *fdopen_mode = NULL; ++ int fd; + FILE * file; + char fileName[TMPSIZ]; + +@@ -1049,7 +1057,8 @@ Boolean newString; + XtErrorMsg("NoFile", "asciiSourceCreate", "XawError", + "Creating a read only disk widget and no file specified.", + NULL, 0); +- open_mode = "r"; ++ open_mode = O_RDONLY; ++ fdopen_mode = "r"; + break; + case XawtextAppend: + case XawtextEdit: +@@ -1057,9 +1066,17 @@ Boolean newString; + src->ascii_src.string = fileName; + (void) tmpnam(src->ascii_src.string); + src->ascii_src.is_tempfile = TRUE; +- open_mode = "w"; +- } else +- open_mode = "r+"; ++ open_mode = O_WRONLY | O_CREAT | O_EXCL; ++ fdopen_mode = "w"; ++ } else { ++/* O_NOFOLLOW is a BSD & Linux extension */ ++#ifdef O_NOFOLLOW ++ open_mode = O_RDWR | O_NOFOLLOW; ++#else ++ open_mode = O_RDWR; /* unsafe; subject to race conditions */ ++#endif ++ fdopen_mode = "r+"; ++ } + break; + default: + XtErrorMsg("badMode", "asciiSourceCreate", "XawError", +@@ -1078,11 +1095,14 @@ Boolean newString; + } + + if (!src->ascii_src.is_tempfile) { +- if ((file = fopen(src->ascii_src.string, open_mode)) != 0) { +- (void) fseek(file, (Off_t)0, 2); +- src->ascii_src.length = (XawTextPosition) ftell(file); +- return file; +- } else { ++ if ((fd = open(src->ascii_src.string, open_mode, 0666))) { ++ if ((file = fdopen(fd, fdopen_mode)) != NULL) { ++ (void)fseek(file, 0, SEEK_END); ++ src->ascii_src.length = (XawTextPosition)ftell(file); ++ return (file); ++ } ++ } ++ { + String params[2]; + Cardinal num_params = 2; + +@@ -1094,7 +1114,7 @@ Boolean newString; + } + } + src->ascii_src.length = 0; +- return((FILE *)NULL); ++ return(NULL); + } + + static void +diff -up Xaw3d-1.5libXaw3d-1.6.1/include/X11/Xaw3d/AsciiSrcP.h.debian Xaw3d-1.5libXaw3d-1.6.1/include/X11/Xaw3d/AsciiSrcP.h +--- Xaw3d-1.5libXaw3d-1.6.1/include/X11/Xaw3d/AsciiSrcP.h.debian 1996-10-15 16:41:18.000000000 +0200 ++++ Xaw3d-1.5libXaw3d-1.6.1/include/X11/Xaw3d/AsciiSrcP.h 2008-10-06 11:42:13.000000000 +0200 +@@ -85,7 +85,11 @@ SOFTWARE. + #ifdef L_tmpnam + #define TMPSIZ L_tmpnam + #else +-#define TMPSIZ 32 /* bytes to allocate for tmpnam */ ++#ifdef PATH_MAX ++#define TMPSIZ PATH_MAX ++#else ++#define TMPSIZ 1024 /* bytes to allocate for tmpnam */ ++#endif + #endif + + #define MAGIC_VALUE ((XawTextPosition) -1) /* Magic value. */ +diff -up Xaw3d-1.5libXaw3d-1.6.1/src/MenuButton.c.debian Xaw3d-1.5libXaw3d-1.6.1/src/MenuButton.c +--- Xaw3d-1.5libXaw3d-1.6.1/src/MenuButton.c.debian 1996-10-15 16:41:20.000000000 +0200 ++++ Xaw3d-1.5libXaw3d-1.6.1/src/MenuButton.c 2008-10-06 11:42:13.000000000 +0200 +@@ -53,6 +53,8 @@ in this Software without prior written a + #include + #include + ++#include "XawAlloc.h" ++ + static void ClassInitialize(); + static void PopupMenu(); + +@@ -179,9 +181,16 @@ Cardinal * num_params; + + if (menu == NULL) { + char error_buf[BUFSIZ]; +- (void) sprintf(error_buf, "MenuButton: %s %s.", +- "Could not find menu widget named", mbw->menu_button.menu_name); +- XtAppWarning(XtWidgetToApplicationContext(w), error_buf); ++ char *err1 = "MenuButton: Could not find menu widget named "; ++ char *perr; ++ int len; ++ ++ len = strlen(err1) + strlen(mbw->menu_button.menu_name) + 1 + 1; ++ perr = XtStackAlloc(len, error_buf); ++ if (perr == NULL) return; ++ sprintf(perr, "%s%s.", err1, mbw->menu_button.menu_name); ++ XtAppWarning(XtWidgetToApplicationContext(w), perr); ++ XtStackFree(perr, error_buf); + return; + } + if (!XtIsRealized(menu)) +diff -up Xaw3d-1.5libXaw3d-1.6.1/src/MultiSrc.c.debian Xaw3d-1.5libXaw3d-1.6.1/src/MultiSrc.c +--- Xaw3d-1.5libXaw3d-1.6.1/src/MultiSrc.c.debian 2008-10-06 11:42:13.000000000 +0200 ++++ Xaw3d-1.5libXaw3d-1.6.1/src/MultiSrc.c 2008-10-06 11:42:13.000000000 +0200 +@@ -74,6 +74,9 @@ in this Software without prior written a + #include + #include + #include ++#include ++#include ++#include + + /**************************************************************** + * +@@ -1077,7 +1080,9 @@ InitStringOrFile(src, newString) + MultiSrcObject src; + Boolean newString; + { +- char * open_mode = NULL; ++ mode_t open_mode = 0; ++ const char *fdopen_mode = NULL; ++ int fd; + FILE * file; + char fileName[TMPSIZ]; + Display *d = XtDisplayOfObject((Widget)src); +@@ -1128,7 +1133,8 @@ InitStringOrFile(src, newString) + XtErrorMsg("NoFile", "multiSourceCreate", "XawError", + "Creating a read only disk widget and no file specified.", + NULL, 0); +- open_mode = "r"; ++ open_mode = O_RDONLY; ++ fdopen_mode = "r"; + break; + case XawtextAppend: + case XawtextEdit: +@@ -1141,9 +1147,17 @@ InitStringOrFile(src, newString) + + (void) tmpnam(src->multi_src.string); + src->multi_src.is_tempfile = TRUE; +- open_mode = "w"; +- } else +- open_mode = "r+"; ++ open_mode = O_WRONLY | O_CREAT | O_EXCL; ++ fdopen_mode = "w"; ++ } else { ++/* O_NOFOLLOW is a BSD & Linux extension */ ++#ifdef O_NOFOLLOW ++ open_mode = O_RDWR | O_NOFOLLOW; ++#else ++ open_mode = O_RDWR; /* unsafe; subject to race conditions */ ++#endif ++ fdopen_mode = "r+"; ++ } + break; + default: + XtErrorMsg("badMode", "multiSourceCreate", "XawError", +@@ -1162,11 +1176,14 @@ InitStringOrFile(src, newString) + } + + if (!src->multi_src.is_tempfile) { +- if ((file = fopen(src->multi_src.string, open_mode)) != 0) { +- (void) fseek(file, (Off_t)0, 2); +- src->multi_src.length = ftell (file); +- return file; +- } else { ++ if ((fd = open(src->multi_src.string, open_mode, 0666))) { ++ if ((file = fdopen(fd, fdopen_mode)) != NULL) { ++ (void)fseek(file, 0, SEEK_END); ++ src->multi_src.length = (XawTextPosition)ftell(file); ++ return (file); ++ } ++ } ++ { + String params[2]; + Cardinal num_params = 2; + +@@ -1178,7 +1195,7 @@ InitStringOrFile(src, newString) + } + } + src->multi_src.length = 0; +- return((FILE *)NULL); ++ return(NULL); + #undef StrLen + } + +diff -up Xaw3d-1.5libXaw3d-1.6.1/include/X11/Xaw3d/MultiSrcP.h.debian Xaw3d-1.5libXaw3d-1.6.1/include/X11/Xaw3d/MultiSrcP.h +--- Xaw3d-1.5libXaw3d-1.6.1/include/X11/Xaw3d/MultiSrcP.h.debian 1996-10-15 16:41:21.000000000 +0200 ++++ Xaw3d-1.5libXaw3d-1.6.1/include/X11/Xaw3d/MultiSrcP.h 2008-10-06 11:42:13.000000000 +0200 +@@ -113,7 +113,11 @@ SOFTWARE. + #ifdef L_tmpnam + #define TMPSIZ L_tmpnam + #else +-#define TMPSIZ 32 /* bytes to allocate for tmpnam */ ++#ifdef PATH_MAX ++#define TMPSIZ PATH_MAX ++#else ++#define TMPSIZ 1024 /* bytes to allocate for tmpnam */ ++#endif + #endif + + #define MAGIC_VALUE ((XawTextPosition) -1) /* Magic value. */ +diff -up Xaw3d-1.5libXaw3d-1.6.1/src/Simple.c.debian Xaw3d-1.5libXaw3d-1.6.1/src/Simple.c +--- Xaw3d-1.5libXaw3d-1.6.1/src/Simple.c.debian 2000-11-27 14:19:36.000000000 +0100 ++++ Xaw3d-1.5libXaw3d-1.6.1/src/Simple.c 2008-10-06 11:42:13.000000000 +0200 +@@ -56,6 +56,8 @@ SOFTWARE. + #include + #include + ++#include "XawAlloc.h" ++ + #define offset(field) XtOffsetOf(SimpleRec, simple.field) + + static XtResource resources[] = { +@@ -148,11 +150,17 @@ static void ClassPartInitialize(class) + + if (c->simple_class.change_sensitive == NULL) { + char buf[BUFSIZ]; +- +- (void) sprintf(buf, +- "%s Widget: The Simple Widget class method 'change_sensitive' is undefined.\nA function must be defined or inherited.", +- c->core_class.class_name); +- XtWarning(buf); ++ char *pbuf; ++ char *msg1 = " Widget: The Simple Widget class method 'change_sensitive' is undefined.\nA function must be defined or inherited."; ++ int len; ++ ++ len = strlen(msg1) + strlen(c->core_class.class_name) + 1; ++ pbuf = XtStackAlloc(len, buf); ++ if (pbuf != NULL) { ++ sprintf(pbuf, "%s%s", c->core_class.class_name, msg1); ++ XtWarning(pbuf); ++ XtStackFree(pbuf, buf); ++ } + c->simple_class.change_sensitive = ChangeSensitive; + } + +diff -up Xaw3d-1.5libXaw3d-1.6.1/src/SimpleMenu.c.debian Xaw3d-1.5libXaw3d-1.6.1/src/SimpleMenu.c +--- Xaw3d-1.5libXaw3d-1.6.1/src/SimpleMenu.c.debian 2003-02-17 07:45:07.000000000 +0100 ++++ Xaw3d-1.5libXaw3d-1.6.1/src/SimpleMenu.c 2008-10-06 11:42:13.000000000 +0200 +@@ -51,6 +51,8 @@ in this Software without prior written a + #include + #include + ++#include "XawAlloc.h" ++ + #define streq(a, b) ( strcmp((a), (b)) == 0 ) + + #define offset(field) XtOffsetOf(SimpleMenuRec, simple_menu.field) +@@ -755,9 +757,17 @@ Cardinal * num_params; + + if ( (menu = FindMenu(w, params[0])) == NULL) { + char error_buf[BUFSIZ]; +- (void) sprintf(error_buf, "%s '%s'", +- "Xaw - SimpleMenuWidget: could not find menu named: ", params[0]); +- XtAppWarning(XtWidgetToApplicationContext(w), error_buf); ++ char *err1 = "Xaw - SimpleMenuWidget: could not find menu named: "; ++ char *perr; ++ int len; ++ ++ len = strlen(err1) + strlen(params[0]) + 2 + 1; ++ perr = XtStackAlloc(len, error_buf); ++ if (perr == NULL) ++ return; ++ sprintf(perr, "%s'%s'", err1, params[0]); ++ XtAppWarning(XtWidgetToApplicationContext(w), perr); ++ XtStackFree(perr, error_buf); + return; + } + +diff -up Xaw3d-1.5libXaw3d-1.6.1/src/StripChart.c.debian Xaw3d-1.5libXaw3d-1.6.1/src/StripChart.c +--- Xaw3d-1.5libXaw3d-1.6.1/src/StripChart.c.debian 2003-02-10 18:18:00.000000000 +0100 ++++ Xaw3d-1.5libXaw3d-1.6.1/src/StripChart.c 2008-10-06 11:42:13.000000000 +0200 +@@ -315,7 +315,15 @@ XtIntervalId *id; /* unused */ + if (w->strip_chart.points != NULL) { + w->strip_chart.points[0].x = w->strip_chart.interval + s; + XDrawPoints(XtDisplay(w), XtWindow(w), w->strip_chart.hiGC, +- w->strip_chart.points, w->strip_chart.scale, ++ /* ++ * patch: ++ * ++ * w->strip_chart.points, w->strip_chart.scale, ++ * ++ * this to avoid a subdle bug of extra spurios scan ++ * line in this widget. ++ */ ++ w->strip_chart.points, w->strip_chart.scale - 1, + CoordModePrevious); + } + +diff -up Xaw3d-1.5libXaw3d-1.6.1/src/Text.c.debian Xaw3d-1.5libXaw3d-1.6.1/src/Text.c +--- Xaw3d-1.5libXaw3d-1.6.1/src/Text.c.debian 2008-10-06 11:42:13.000000000 +0200 ++++ Xaw3d-1.5libXaw3d-1.6.1/src/Text.c 2008-10-06 11:43:16.000000000 +0200 +@@ -76,6 +76,8 @@ SOFTWARE. + #include /* for isprint() */ + #include + ++#include "XawAlloc.h" ++ + #ifndef MAX_LEN_CT + #define MAX_LEN_CT 6 /* for sequence: ESC $ ( A \xx \xx */ + #endif +@@ -521,6 +523,8 @@ Cardinal *num_args; /* unused */ + TextWidget ctx = (TextWidget) new; + char error_buf[BUFSIZ]; + int s; ++ char *perr; /* frankie */ ++ size_t len; /* frankie */ + + ctx->text.threeD = XtVaCreateWidget("threeD", threeDWidgetClass, new, + XtNx, 0, XtNy, 0, +@@ -569,10 +573,17 @@ Cardinal *num_args; /* unused */ + if (ctx->text.scroll_vert != XawtextScrollNever) + if ( (ctx->text.resize == XawtextResizeHeight) || + (ctx->text.resize == XawtextResizeBoth) ) { +- (void) sprintf(error_buf, "Xaw Text Widget %s:\n %s %s.", ctx->core.name, +- "Vertical scrolling not allowed with height resize.\n", +- "Vertical scrolling has been DEACTIVATED."); +- XtAppWarning(XtWidgetToApplicationContext(new), error_buf); ++ char *err1 = "Xaw Text Widget "; ++ char *err2 = ":\nVertical scrolling not allowed with height resize.\n"; ++ char *err3 = "Vertical scrolling has been DEACTIVATED."; ++ len = strlen(err1) + strlen(err2) + strlen(err3) + ++ strlen(ctx->core.name) + 1; ++ perr = XtStackAlloc(len, error_buf); ++ if (perr != NULL) { ++ (void) sprintf(perr, "%s%s%s%s", err1, ctx->core.name, err2, err3); ++ XtAppWarning(XtWidgetToApplicationContext(new), perr); ++ XtStackFree(perr, error_buf); ++ } + ctx->text.scroll_vert = XawtextScrollNever; + } + else if (ctx->text.scroll_vert == XawtextScrollAlways) +@@ -580,18 +591,32 @@ Cardinal *num_args; /* unused */ + + if (ctx->text.scroll_horiz != XawtextScrollNever) + if (ctx->text.wrap != XawtextWrapNever) { +- (void) sprintf(error_buf, "Xaw Text Widget %s:\n %s %s.", ctx->core.name, +- "Horizontal scrolling not allowed with wrapping active.\n", +- "Horizontal scrolling has been DEACTIVATED."); +- XtAppWarning(XtWidgetToApplicationContext(new), error_buf); ++ char *err1 = "Xaw Text Widget "; ++ char *err2 = ":\nHorizontal scrolling not allowed with wrapping active."; ++ char *err3 = "\nHorizontal scrolling has been DEACTIVATED."; ++ len = strlen(err1) + strlen(err2) + strlen(err3) + ++ strlen(ctx->core.name) + 1; ++ perr = XtStackAlloc(len, error_buf); ++ if (perr != NULL) { ++ (void) sprintf(perr, "%s%s%s%s", err1, ctx->core.name, err2, err3); ++ XtAppWarning(XtWidgetToApplicationContext(new), perr); ++ XtStackFree(perr, error_buf); ++ } + ctx->text.scroll_horiz = XawtextScrollNever; + } + else if ( (ctx->text.resize == XawtextResizeWidth) || + (ctx->text.resize == XawtextResizeBoth) ) { +- (void) sprintf(error_buf, "Xaw Text Widget %s:\n %s %s.", ctx->core.name, +- "Horizontal scrolling not allowed with width resize.\n", +- "Horizontal scrolling has been DEACTIVATED."); +- XtAppWarning(XtWidgetToApplicationContext(new), error_buf); ++ char *err1 = "Xaw Text Widget "; ++ char *err2 = ":\nHorizontal scrolling not allowed with width resize.\n"; ++ char *err3 = "Horizontal scrolling has been DEACTIVATED."; ++ len = strlen(err1) + strlen(err2) + strlen(err3) + ++ strlen(ctx->core.name) + 1; ++ perr = XtStackAlloc(len, error_buf); ++ if (perr != NULL) { ++ (void) sprintf(perr, "%s%s%s%s", err1, ctx->core.name, err2, err3); ++ XtAppWarning(XtWidgetToApplicationContext(new), perr); ++ XtStackFree(perr, error_buf); ++ } + ctx->text.scroll_horiz = XawtextScrollNever; + } + else if (ctx->text.scroll_horiz == XawtextScrollAlways) +diff -up Xaw3d-1.5libXaw3d-1.6.1/src/TextPop.c.debian Xaw3d-1.5libXaw3d-1.6.1/src/TextPop.c +--- Xaw3d-1.5libXaw3d-1.6.1/src/TextPop.c.debian 2000-11-27 14:19:36.000000000 +0100 ++++ Xaw3d-1.5libXaw3d-1.6.1/src/TextPop.c 2008-10-06 11:42:13.000000000 +0200 +@@ -66,6 +66,8 @@ in this Software without prior written a + #include /* for O_RDONLY */ + #include + ++#include "XawAlloc.h" ++ + #ifdef X_NOT_STDC_ENV + extern int errno; + #endif +@@ -809,6 +811,8 @@ DoSearch(search) + struct SearchAndReplace * search; + { + char msg[BUFSIZ]; ++ char *pmsg; ++ int len; + Widget tw = XtParent(search->search_popup); + XawTextPosition pos; + XawTextScanDirection dir; +@@ -835,9 +839,20 @@ struct SearchAndReplace * search; + /* The Raw string in find.ptr may be WC I can't use here, so I re - call + GetString to get a tame version. */ + +- if (pos == XawTextSearchError) +- (void) sprintf( msg, "Could not find string ``%s''.", GetString( search->search_text ) ); +- else { ++ if (pos == XawTextSearchError) { ++ char *msg1 = "Could not find string ``"; ++ char *msg2 = "''."; ++ len = strlen(msg1) + strlen(msg2) + ++ strlen(GetString( search->search_text )) + 1; ++ pmsg = XtStackAlloc(len, msg); ++ if (pmsg != NULL) { ++ (void) sprintf( pmsg, "%s%s%s", msg1, GetString( search->search_text ), ++ msg2); ++ } else { ++ pmsg = msg; ++ (void) sprintf( pmsg, "Could not find string"); ++ } ++ } else { + if (dir == XawsdRight) + XawTextSetInsertionPoint( tw, pos + text.length); + else +@@ -849,7 +864,8 @@ struct SearchAndReplace * search; + } + + XawTextUnsetSelection(tw); +- SetSearchLabels(search, msg, "", TRUE); ++ SetSearchLabels(search, pmsg, "", TRUE); ++ XtStackFree(pmsg, msg); + return(FALSE); + } + +@@ -982,13 +998,26 @@ Boolean once_only, show_current; + if ( (new_pos == XawTextSearchError) ) { + if (count == 0) { + char msg[BUFSIZ]; ++ char *pmsg; ++ int len; ++ char *msg1 = "*** Error: Could not find string ``"; ++ char *msg2 = "''. ***"; + + /* The Raw string in find.ptr may be WC I can't use here, + so I call GetString to get a tame version.*/ + +- (void) sprintf( msg, "%s %s %s", "*** Error: Could not find string ``", +- GetString( search->search_text ), "''. ***"); +- SetSearchLabels(search, msg, "", TRUE); ++ len = strlen(msg1) + strlen(msg2) + ++ strlen(GetString( search->search_text )) + 1; ++ pmsg = XtStackAlloc(len, msg); ++ if (pmsg != NULL) { ++ (void) sprintf( pmsg, "%s%s%s", msg1, ++ GetString( search->search_text ), msg2); ++ } else { ++ pmsg = msg; ++ (void) sprintf(pmsg, "*** Error: Could not find string ***"); ++ } ++ SetSearchLabels(search, pmsg, "", TRUE); ++ XtStackFree(pmsg, msg); + return(FALSE); + } + else +@@ -1011,9 +1040,22 @@ Boolean once_only, show_current; + + if (XawTextReplace(tw, pos, end_pos, &replace) != XawEditDone) { + char msg[BUFSIZ]; +- +- (void) sprintf( msg, "'%s' with '%s'. ***", find.ptr, replace.ptr); ++ char *pmsg; ++ int len; ++ char *msg1 = "' with '"; ++ char *msg2 = "'. ***"; ++ ++ len = 1 + strlen(msg1) + strlen(msg2) + strlen(find.ptr) + ++ strlen(replace.ptr) + 1; ++ pmsg = XtStackAlloc(len, msg); ++ if (pmsg != NULL) { ++ (void) sprintf( pmsg, "`%s%s%s%s", find.ptr, msg1, replace.ptr, msg2); ++ } else { ++ pmsg = msg; ++ (void) sprintf(pmsg, "string ***"); ++ } + SetSearchLabels(search, "*** Error while replacing", msg, TRUE); ++ XtStackFree(pmsg, msg); + return(FALSE); + } + +@@ -1164,13 +1206,20 @@ XtArgVal value; + { + Widget temp_widget; + char buf[BUFSIZ]; ++ char *pbuf; ++ int len; + +- (void) sprintf(buf, "%s.%s", FORM_NAME, name); ++ len = strlen(FORM_NAME) + strlen(name) + 2; ++ pbuf = XtStackAlloc(len, buf); ++ if (pbuf == NULL) return FALSE; ++ (void) sprintf(pbuf, "%s.%s", FORM_NAME, name); + +- if ( (temp_widget = XtNameToWidget(shell, buf)) != NULL) { ++ if ( (temp_widget = XtNameToWidget(shell, pbuf)) != NULL) { + SetResource(temp_widget, res_name, value); ++ XtStackFree(pbuf, buf); + return(TRUE); + } ++ XtStackFree(pbuf, buf); + return(FALSE); + } + +diff -up /dev/null Xaw3d-1.5libXaw3d-1.6.1/include/X11/Xaw3d/XawAlloc.h +--- /dev/null 2008-10-06 08:37:32.418005377 +0200 ++++ Xaw3d-1.5libXaw3d-1.6.1/include/X11/Xaw3d/XawAlloc.h 2008-10-06 11:42:13.000000000 +0200 +@@ -0,0 +1,10 @@ ++/* $XFree86: xc/lib/Xaw/XawAlloc.h,v 1.1.2.1 1998/05/16 09:05:23 dawes Exp $ */ ++ ++#define XtStackAlloc(size, stack_cache_array) \ ++ ((size) <= sizeof(stack_cache_array) \ ++ ? (XtPointer)(stack_cache_array) \ ++ : XtMalloc((unsigned)(size))) ++ ++#define XtStackFree(pointer, stack_cache_array) \ ++ if ((pointer) != ((XtPointer)(stack_cache_array))) XtFree(pointer); else ++ +--- xaw3d-1.5libXaw3d-1.6.1/src/SmeBSB.c 2003-08-04 17:27:58.000000000 +0200 ++++ xaw3d-1.5libXaw3d-1.6.1/src/SmeBSB.c 2003-08-07 15:02:39.000000000 +0200 +@@ -52,6 +52,8 @@ + #include + #include + ++#include "XawAlloc.h" ++ + /* needed for abs() */ + #ifndef X_NOT_STDC_ENV + #include +@@ -712,6 +714,8 @@ + int x, y; + unsigned int width, height, bw; + char buf[BUFSIZ]; ++ char *pbuf; ++ int len; + + if (is_left) { + width = height = 0; +@@ -720,18 +724,24 @@ + if (!XGetGeometry(XtDisplayOfObject(w), + entry->sme_bsb.left_bitmap, &root, &x, &y, + &width, &height, &bw, &entry->sme_bsb.left_depth)) { +- (void) sprintf(buf, "Xaw SmeBSB Object: %s %s \"%s\".", +- "Could not get Left Bitmap", +- "geometry information for menu entry", +- XtName(w)); +- XtAppError(XtWidgetToApplicationContext(w), buf); ++ char *err1 = "Xaw SmeBSB Object: Could not get Left Bitmap geometry information for menu entry "; ++ len = strlen(err1) + strlen(XtName(w)) + 3 + 1; ++ pbuf = XtStackAlloc(len, buf); ++ if (pbuf == NULL) return; ++ sprintf(pbuf, "%s\"%s\".", err1, XtName(w)); ++ XtAppError(XtWidgetToApplicationContext(w), pbuf); ++ XtStackFree(pbuf, buf); + } + #ifdef NEVER + if (entry->sme_bsb.left_depth != 1) { +- (void) sprintf(buf, "Xaw SmeBSB Object: %s \"%s\" %s.", +- "Left Bitmap of entry", XtName(w), +- "is not one bit deep"); +- XtAppError(XtWidgetToApplicationContext(w), buf); ++ char *err1 = "Xaw SmeBSB Object: Left Bitmap of entry "; ++ char *err2 = " is not one bit deep."; ++ len = strlen(err1) + strlen(err2) + strlen(XtName(w)) + 2 + 1; ++ pbuf = XtStackAlloc(len, buf); ++ if (pbuf == NULL) return; ++ sprintf(pbuf, "%s\"%s\"%s", err1, XtName(w), err2); ++ XtAppError(XtWidgetToApplicationContext(w), pbuf); ++ XtStackFree(pbuf, buf); + } + #endif + } +@@ -745,18 +755,24 @@ + if (!XGetGeometry(XtDisplayOfObject(w), + entry->sme_bsb.right_bitmap, &root, &x, &y, + &width, &height, &bw, &entry->sme_bsb.right_depth)) { +- (void) sprintf(buf, "Xaw SmeBSB Object: %s %s \"%s\".", +- "Could not get Right Bitmap", +- "geometry information for menu entry", +- XtName(w)); +- XtAppError(XtWidgetToApplicationContext(w), buf); ++ char *err1 = "Xaw SmeBSB Object: Could not get Right Bitmap geometry information for menu entry "; ++ len = strlen(err1) + strlen(XtName(w)) + 3 + 1; ++ pbuf = XtStackAlloc(len, buf); ++ if (pbuf == NULL) return; ++ sprintf(pbuf, "%s\"%s\".", err1, XtName(w)); ++ XtAppError(XtWidgetToApplicationContext(w), pbuf); ++ XtStackFree(pbuf, buf); + } + #ifdef NEVER + if (entry->sme_bsb.right_depth != 1) { +- (void) sprintf(buf, "Xaw SmeBSB Object: %s \"%s\" %s.", +- "Right Bitmap of entry", XtName(w), +- "is not one bit deep"); +- XtAppError(XtWidgetToApplicationContext(w), buf); ++ char *err1 = "Xaw SmeBSB Object: Right Bitmap of entry "; ++ char *err2 = " is not one bit deep."; ++ len = strlen(err1) + strlen(err2) + strlen(XtName(w)) + 2 + 1; ++ pbuf = XtStackAlloc(len, buf); ++ if (pbuf == NULL) return; ++ sprintf(pbuf, "%s\"%s\"%s", err1, XtName(w), err2); ++ XtAppError(XtWidgetToApplicationContext(w), pbuf); ++ XtStackFree(pbuf, buf); + } + #endif + } diff --git a/Xaw3d-1.6.1-3Dlabel.patch b/Xaw3d-1.6.1-3Dlabel.patch new file mode 100644 index 0000000..0feb7aa --- /dev/null +++ b/Xaw3d-1.6.1-3Dlabel.patch @@ -0,0 +1,162 @@ +diff -up libXaw3d-1.6.1/src/Label.c.3Dlabel libXaw3d-1.6.1/src/Label.c +--- libXaw3d-1.6.1/src/Label.c.3Dlabel 2011-09-19 15:42:36.000000000 -0600 ++++ libXaw3d-1.6.1/src/Label.c 2012-02-25 14:44:33.766774776 -0700 +@@ -416,9 +416,16 @@ GetgrayGC(LabelWidget lw) + static void + compute_bitmap_offsets (LabelWidget lw) + { +- if (lw->label.lbm_height != 0) +- lw->label.lbm_y = (lw->core.height - lw->label.lbm_height) / 2; +- else ++ /* ++ * bitmap will be eventually be displayed at ++ * (internal_width, internal_height + lbm_y) ++ */ ++ if (lw->label.lbm_height != 0) { ++ lw->label.lbm_y = (lw->core.height - ++ (lw->threeD.shadow_width * 2 + ++ lw->label.internal_height * 2 + ++ lw->label.lbm_height)) / 2; ++ } else + lw->label.lbm_y = 0; + } + +@@ -444,9 +451,11 @@ Initialize(Widget request, Widget new, A + { + LabelWidget lw = (LabelWidget) new; + ++#if 0 + /* disable shadows if we're not a subclass of Command */ + if (!XtIsSubclass(new, commandWidgetClass)) + lw->threeD.shadow_width = 0; ++#endif + + if (lw->label.label == NULL) + lw->label.label = XtNewString(lw->core.name); +@@ -460,18 +469,20 @@ Initialize(Widget request, Widget new, A + + if (lw->core.height == 0) + lw->core.height = lw->label.label_height + +- 2 * lw->label.internal_height; ++ 2 * lw->label.internal_height + ++ 2 * lw->threeD.shadow_width; + + set_bitmap_info(lw); /* req's core.height, sets label.lbm_* */ + + if (lw->label.lbm_height > lw->label.label_height) + lw->core.height = lw->label.lbm_height + +- 2 * lw->label.internal_height; ++ 2 * lw->label.internal_height; + + if (lw->core.width == 0) + lw->core.width = lw->label.label_width + +- 2 * lw->label.internal_width + +- LEFT_OFFSET(lw); /* req's label.lbm_width */ ++ 2 * lw->label.internal_width + ++ 2 * lw->threeD.shadow_width + ++ LEFT_OFFSET(lw); /* req's label.lbm_width */ + + lw->label.label_x = lw->label.label_y = 0; + (*XtClass(new)->core_class.resize) ((Widget)lw); +@@ -549,14 +560,16 @@ Redisplay(Widget gw, XEvent *event, Regi + if (w->label.depth == 1) + XCopyPlane(XtDisplay(gw), pm, XtWindow(gw), gc, 0, 0, + w->label.lbm_width, w->label.lbm_height, +- (int) w->label.internal_width, +- (int) w->label.lbm_y, ++ (int) w->label.internal_width + w->threeD.shadow_width, ++ (int) w->label.internal_height + w->threeD.shadow_width ++ + w->label.lbm_y, + (unsigned long) 1L); + else + XCopyArea(XtDisplay(gw), pm, XtWindow(gw), gc, 0, 0, + w->label.lbm_width, w->label.lbm_height, +- (int) w->label.internal_width, +- (int) w->label.lbm_y); ++ (int) w->label.internal_width + w->threeD.shadow_width, ++ (int) w->label.internal_height + w->threeD.shadow_width ++ + w->label.lbm_y); + } + + #ifdef XAW_INTERNATIONALIZATION +@@ -646,14 +659,17 @@ _Reposition(LabelWidget lw, Dimension wi + Position *dx, Position *dy) + { + Position newPos; +- Position leftedge = lw->label.internal_width + LEFT_OFFSET(lw); ++ Position leftedge = lw->label.internal_width + LEFT_OFFSET(lw) + ++ lw->threeD.shadow_width; ++ + + switch (lw->label.justify) { + case XtJustifyLeft: + newPos = leftedge; + break; + case XtJustifyRight: +- newPos = width - lw->label.label_width - lw->label.internal_width; ++ newPos = width - (lw->label.label_width + lw->label.internal_width + ++ lw->threeD.shadow_width); + break; + case XtJustifyCenter: + default: +@@ -745,17 +761,20 @@ SetValues(Widget current, Widget request + if (newlw->label.resize && was_resized) { + if (curlw->core.height == reqlw->core.height && !checks[HEIGHT]) + newlw->core.height = newlw->label.label_height + +- 2 * newlw->label.internal_height; ++ 2 * newlw->label.internal_height + ++ 2 * newlw->threeD.shadow_width; + + set_bitmap_info (newlw); /* req's core.height, sets label.lbm_* */ + + if (newlw->label.lbm_height > newlw->label.label_height) + newlw->core.height = newlw->label.lbm_height + +- 2 * newlw->label.internal_height; ++ 2 * newlw->label.internal_height + ++ 2 * newlw->threeD.shadow_width; + + if (curlw->core.width == reqlw->core.width && !checks[WIDTH]) + newlw->core.width = newlw->label.label_width + + 2 * newlw->label.internal_width + ++ 2 * newlw->threeD.shadow_width + + LEFT_OFFSET(newlw); /* req's label.lbm_width */ + } + +@@ -764,15 +783,20 @@ SetValues(Widget current, Widget request + if (checks[HEIGHT]) { + if (newlw->label.label_height > newlw->label.lbm_height) + i = newlw->label.label_height + +- 2 * newlw->label.internal_height; ++ 2 * newlw->label.internal_height + ++ 2 * newlw->threeD.shadow_width; + else +- i = newlw->label.lbm_height + 2 * newlw->label.internal_height; ++ i = newlw->label.lbm_height + ++ 2 * newlw->label.internal_height + ++ 2 * newlw->threeD.shadow_width; + if (i > newlw->core.height) + newlw->core.height = i; + } + if (checks[WIDTH]) { +- i = newlw->label.label_width + 2 * newlw->label.internal_width + +- LEFT_OFFSET(newlw); /* req's label.lbm_width */ ++ i = newlw->label.label_width + ++ 2 * newlw->label.internal_width + ++ 2 * newlw->threeD.shadow_width + ++ LEFT_OFFSET(newlw); /* req's label.lbm_width */ + if (i > newlw->core.width) + newlw->core.width = i; + } +@@ -843,9 +867,11 @@ QueryGeometry(Widget w, XtWidgetGeometry + preferred->request_mode = CWWidth | CWHeight; + preferred->width = (lw->label.label_width + + 2 * lw->label.internal_width + ++ 2 * lw->threeD.shadow_width + + LEFT_OFFSET(lw)); + preferred->height = lw->label.label_height + +- 2 * lw->label.internal_height; ++ 2 * lw->label.internal_height + ++ 2 * lw->threeD.shadow_width; + if ( ((intended->request_mode & (CWWidth | CWHeight)) + == (CWWidth | CWHeight)) && + intended->width == preferred->width && diff --git a/Xaw3d-1.6.1-fontset.patch b/Xaw3d-1.6.1-fontset.patch new file mode 100644 index 0000000..0f3c8d2 --- /dev/null +++ b/Xaw3d-1.6.1-fontset.patch @@ -0,0 +1,60 @@ +diff -up libXaw3d-1.6.1/src/AsciiSink.c.fontset libXaw3d-1.6.1/src/AsciiSink.c +--- libXaw3d-1.6.1/src/AsciiSink.c.fontset 2012-02-01 12:24:00.000000000 -0700 ++++ libXaw3d-1.6.1/src/AsciiSink.c 2012-02-25 14:52:46.802779081 -0700 +@@ -513,6 +513,8 @@ Initialize(Widget request, Widget new, A + { + AsciiSinkObject sink = (AsciiSinkObject) new; + ++ if (!sink->ascii_sink.font) XtError("Aborting: no font found\n"); ++ + GetGC(sink); + + sink->ascii_sink.insertCursorOn= CreateInsertCursor(XtScreenOfObject(new)); +diff -up libXaw3d-1.6.1/src/Command.c.fontset libXaw3d-1.6.1/src/Command.c +--- libXaw3d-1.6.1/src/Command.c.fontset 2011-09-19 15:42:36.000000000 -0600 ++++ libXaw3d-1.6.1/src/Command.c 2012-02-25 14:51:26.075372823 -0700 +@@ -218,6 +218,8 @@ Initialize(Widget request, Widget new, A + CommandWidget cbw = (CommandWidget) new; + int shape_event_base, shape_error_base; + ++ if (!cbw->label.font) XtError("Aborting: no font found\n"); ++ + if (cbw->command.shape_style != XawShapeRectangle + && !XShapeQueryExtension(XtDisplay(new), &shape_event_base, + &shape_error_base)) +diff -up libXaw3d-1.6.1/src/List.c.fontset libXaw3d-1.6.1/src/List.c +--- libXaw3d-1.6.1/src/List.c.fontset 2011-10-09 12:01:20.000000000 -0600 ++++ libXaw3d-1.6.1/src/List.c 2012-02-25 14:53:16.327465260 -0700 +@@ -362,6 +362,8 @@ Initialize(Widget junk, Widget new, ArgL + { + ListWidget lw = (ListWidget) new; + ++ if (!lw->list.font) XtError("Aborting: no font found\n"); ++ + /* + * Initialize all private resources. + */ +diff -up libXaw3d-1.6.1/src/SmeBSB.c.fontset libXaw3d-1.6.1/src/SmeBSB.c +--- libXaw3d-1.6.1/src/SmeBSB.c.fontset 2011-09-19 15:42:36.000000000 -0600 ++++ libXaw3d-1.6.1/src/SmeBSB.c 2012-02-25 14:50:19.056358107 -0700 +@@ -207,6 +207,8 @@ Initialize(Widget request, Widget new, A + else + entry->sme_bsb.label = XtNewString( entry->sme_bsb.label ); + ++ if (!entry->sme_bsb.font) XtError("Aborting: no font found\n"); ++ + CreateGCs(new); + + GetBitmapInfo(new, TRUE); /* Left Bitmap Info */ +diff -up libXaw3d-1.6.1/src/Tip.c.fontset libXaw3d-1.6.1/src/Tip.c +--- libXaw3d-1.6.1/src/Tip.c.fontset 2012-02-15 12:10:38.000000000 -0700 ++++ libXaw3d-1.6.1/src/Tip.c 2012-02-25 14:50:19.058358017 -0700 +@@ -248,6 +248,8 @@ XawTipInitialize(Widget req, Widget w, A + TipWidget tip = (TipWidget)w; + XGCValues values; + ++ if (!tip->tip.font) XtError("Aborting: no font found\n"); ++ + tip->tip.timer = 0; + + values.foreground = tip->tip.foreground; diff --git a/Xaw3d-1.6.1-hsbar.patch b/Xaw3d-1.6.1-hsbar.patch new file mode 100644 index 0000000..1f3987e --- /dev/null +++ b/Xaw3d-1.6.1-hsbar.patch @@ -0,0 +1,260 @@ +diff -up libXaw3d-1.6.1/src/Text.c.hsbar libXaw3d-1.6.1/src/Text.c +--- libXaw3d-1.6.1/src/Text.c.hsbar 2011-10-06 13:17:19.000000000 -0600 ++++ libXaw3d-1.6.1/src/Text.c 2012-02-25 14:54:41.996656624 -0700 +@@ -495,8 +495,10 @@ CreateHScrollBar(TextWidget ctx) + (XtPointer) NULL); + + /**/ +- ctx->text.r_margin.bottom += hbar->core.height + hbar->core.border_width; +- ctx->text.margin.bottom = ctx->text.r_margin.bottom; ++ if (ctx->text.scroll_vert == XawtextScrollAlways) { ++ ctx->text.r_margin.bottom += hbar->core.height + hbar->core.border_width; ++ ctx->text.margin.bottom = ctx->text.r_margin.bottom; ++ } + /**/ + PositionHScrollBar(ctx); + if (XtIsRealized((Widget)ctx)) { +@@ -519,8 +521,10 @@ DestroyHScrollBar(TextWidget ctx) + if (hbar == NULL) return; + + /**/ +- ctx->text.r_margin.bottom -= hbar->core.height + hbar->core.border_width; +- ctx->text.margin.bottom = ctx->text.r_margin.bottom; ++ if (ctx->text.scroll_vert == XawtextScrollAlways) { ++ ctx->text.r_margin.bottom -= hbar->core.height + hbar->core.border_width; ++ ctx->text.margin.bottom = ctx->text.r_margin.bottom; ++ } + /**/ + if (ctx->text.vbar == NULL) + XtRemoveCallback((Widget) ctx, XtNunrealizeCallback, UnrealizeScrollbars, +diff -up libXaw3d-1.6.1/src/Viewport.c.hsbar libXaw3d-1.6.1/src/Viewport.c +--- libXaw3d-1.6.1/src/Viewport.c.hsbar 2012-01-24 14:56:03.000000000 -0700 ++++ libXaw3d-1.6.1/src/Viewport.c 2012-02-25 14:58:18.474098582 -0700 +@@ -244,7 +244,7 @@ Initialize(Widget request, Widget new, A + XtVaGetValues((Widget)(w->viewport.threeD), XtNshadowWidth, &sw, NULL); + if (sw) + { +- pad = 2; ++ pad = 2 * sw; + + arg_cnt = 0; + XtSetArg(threeD_args[arg_cnt], XtNborderWidth, 0); arg_cnt++; +@@ -262,8 +262,8 @@ Initialize(Widget request, Widget new, A + XtSetArg(clip_args[arg_cnt], XtNright, XtChainRight); arg_cnt++; + XtSetArg(clip_args[arg_cnt], XtNtop, XtChainTop); arg_cnt++; + XtSetArg(clip_args[arg_cnt], XtNbottom, XtChainBottom); arg_cnt++; +- XtSetArg(clip_args[arg_cnt], XtNwidth, w->core.width - 2 * sw); arg_cnt++; +- XtSetArg(clip_args[arg_cnt], XtNheight, w->core.height - 2 * sw); arg_cnt++; ++ XtSetArg(clip_args[arg_cnt], XtNwidth, w->core.width - pad); arg_cnt++; ++ XtSetArg(clip_args[arg_cnt], XtNheight, w->core.height - pad); arg_cnt++; + + w->viewport.clip = XtCreateManagedWidget("clip", widgetClass, new, + clip_args, arg_cnt); +@@ -283,8 +283,8 @@ Initialize(Widget request, Widget new, A + * Set the clip widget to the correct height. + */ + +- clip_width = w->core.width - 2 * sw; +- clip_height = w->core.height - 2 * sw; ++ clip_width = w->core.width - pad; ++ clip_height = w->core.height - pad; + + if ( (h_bar != NULL) && + ((int)w->core.width > +@@ -509,23 +509,13 @@ ComputeLayout(Widget widget, Boolean que + XtWidgetGeometry intended; + Dimension pad = 0, sw = 0; + +- /* +- * I've made two optimizations here. The first does away with the +- * loop, and the second defers setting the child dimensions to the +- * clip if smaller until after adjusting for possible scrollbars. +- * If you find that these go too far, define the identifiers here +- * as required. -- djhjr +- */ +-#define NEED_LAYOUT_LOOP +-#undef PREP_CHILD_TO_CLIP +- + if (child == (Widget) NULL) return; + + XtVaGetValues(threeD, XtNshadowWidth, &sw, NULL); +- if (sw) pad = 2; ++ if (sw) pad = 2 * sw; + +- clip_width = w->core.width - 2 * sw; +- clip_height = w->core.height - 2 * sw; ++ clip_width = w->core.width - pad; ++ clip_height = w->core.height - pad; + intended.request_mode = CWBorderWidth; + intended.border_width = 0; + +@@ -536,10 +526,8 @@ ComputeLayout(Widget widget, Boolean que + &clip_width, &clip_height); + } + else { +-#ifdef NEED_LAYOUT_LOOP + Dimension prev_width, prev_height; + XtGeometryMask prev_mode; +-#endif + XtWidgetGeometry preferred; + + needshoriz = needsvert = False; +@@ -553,31 +541,25 @@ ComputeLayout(Widget widget, Boolean que + if (!w->viewport.allowhoriz) + intended.request_mode |= CWWidth; + +-#ifdef PREP_CHILD_TO_CLIP +- if ((int)child->core.width < clip_width) +- intended.width = clip_width; ++ if ((int)child->core.width < clip_width + pad) ++ intended.width = clip_width + pad; + else +-#endif + intended.width = child->core.width; + +- if (!w->viewport.allowvert) +- intended.request_mode |= CWHeight; +- +-#ifdef PREP_CHILD_TO_CLIP +- if ((int)child->core.height < clip_height) +- intended.height = clip_height; ++ if ((int)child->core.height < clip_height + pad) ++ intended.height = clip_height + pad; + else +-#endif + intended.height = child->core.height; + ++ if (!w->viewport.allowvert) ++ intended.request_mode |= CWHeight; ++ + if (!query) { + preferred.width = child->core.width; + preferred.height = child->core.height; + } + +-#ifdef NEED_LAYOUT_LOOP + do { /* while intended != prev */ +-#endif + if (query) { + (void) XtQueryGeometry( child, &intended, &preferred ); + if ( !(preferred.request_mode & CWWidth) ) +@@ -585,12 +567,9 @@ ComputeLayout(Widget widget, Boolean que + if ( !(preferred.request_mode & CWHeight) ) + preferred.height = intended.height; + } +- +-#ifdef NEED_LAYOUT_LOOP + prev_width = intended.width; + prev_height = intended.height; + prev_mode = intended.request_mode; +-#endif + + /* + * Note that having once decided to turn on either bar +@@ -600,7 +579,7 @@ ComputeLayout(Widget widget, Boolean que + + #define CheckHoriz() \ + if (w->viewport.allowhoriz && \ +- (int)preferred.width > clip_width + 2 * sw) { \ +++ (int)preferred.width > clip_width + pad) { \ + if (!needshoriz) { \ + Widget horiz_bar = w->viewport.horiz_bar; \ + needshoriz = True; \ +@@ -615,7 +594,7 @@ ComputeLayout(Widget widget, Boolean que + /* enddef */ + CheckHoriz(); + if (w->viewport.allowvert && +- (int)preferred.height > clip_height + 2 * sw) { ++ (int)preferred.height > clip_height + pad) { + if (!needsvert) { + Widget vert_bar = w->viewport.vert_bar; + needsvert = True; +@@ -629,38 +608,22 @@ ComputeLayout(Widget widget, Boolean que + intended.height = preferred.height; + } + +-#ifdef PREP_CHILD_TO_CLIP + if (!w->viewport.allowhoriz || +- (int)preferred.width < clip_width) { +- intended.width = clip_width; ++ (int)preferred.width < clip_width + pad) { ++ intended.width = clip_width + pad; + intended.request_mode |= CWWidth; + } + if (!w->viewport.allowvert || +- (int)preferred.height < clip_height) { +- intended.height = clip_height; ++ (int)preferred.height < clip_height + pad) { ++ intended.height = clip_height + pad; + intended.request_mode |= CWHeight; + } +-#endif +-#ifdef NEED_LAYOUT_LOOP ++ + } while ( intended.request_mode != prev_mode || + (intended.request_mode & CWWidth && + intended.width != prev_width) || + (intended.request_mode & CWHeight && + intended.height != prev_height) ); +-#endif +- +-#ifndef PREP_CHILD_TO_CLIP +- if (!w->viewport.allowhoriz || +- (int)preferred.width < clip_width) { +- intended.width = clip_width; +- intended.request_mode |= CWWidth; +- } +- if (!w->viewport.allowvert || +- (int)preferred.height < clip_height) { +- intended.height = clip_height; +- intended.request_mode |= CWHeight; +- } +-#endif + } + + bar_width = bar_height = 0; +@@ -705,7 +668,7 @@ ComputeLayout(Widget widget, Boolean que + else { + int bw = bar->core.border_width; + XtResizeWidget( bar, +- (Dimension)(clip_width + 2 * sw), bar->core.height, ++ (Dimension)(clip_width + pad), bar->core.height, + (Dimension)bw ); + XtMoveWidget( bar, + (Position)((needsvert && !w->viewport.useright) +@@ -730,7 +693,7 @@ ComputeLayout(Widget widget, Boolean que + else { + int bw = bar->core.border_width; + XtResizeWidget( bar, +- bar->core.width, (Dimension)(clip_height + 2 * sw), ++ bar->core.width, (Dimension)(clip_height + pad), + (Dimension)bw ); + XtMoveWidget( bar, + (Position)(w->viewport.useright +@@ -780,7 +743,7 @@ ComputeWithForceBars(Widget widget, Bool + */ + + XtVaGetValues((Widget)(w->viewport.threeD), XtNshadowWidth, &sw, NULL); +- if (sw) pad = 2; ++ if (sw) pad = 2 * sw; + + if (w->viewport.allowvert) { + if (w->viewport.vert_bar == NULL) +@@ -926,7 +889,7 @@ GeometryRequestPlusScrollbar(ViewportWid + Dimension pad = 0, sw = 0; + + XtVaGetValues((Widget)(w->viewport.threeD), XtNshadowWidth, &sw, NULL); +- if (sw) pad = 2; ++ if (sw) pad = 2 * sw; + + plusScrollbars = *request; + if ((bar = w->viewport.horiz_bar) == (Widget)NULL) +@@ -997,7 +960,7 @@ GeometryManager(Widget child, XtWidgetGe + return XtGeometryNo; + + XtVaGetValues((Widget)(w->viewport.threeD), XtNshadowWidth, &sw, NULL); +- if (sw) pad = 2; ++ if (sw) pad = 2 * sw; + + allowed = *request; + diff --git a/Xaw3d.spec b/Xaw3d.spec new file mode 100644 index 0000000..9468aa9 --- /dev/null +++ b/Xaw3d.spec @@ -0,0 +1,397 @@ +Summary: A version of the MIT Athena widget set for X +Name: Xaw3d +Version: 1.6.3 +Release: 7%{?dist} +Source0: https://xorg.freedesktop.org/archive/individual/lib/libXaw3d-%{version}.tar.bz2 +Source1: https://xorg.freedesktop.org/archive/individual/lib/libXaw3d-%{version}.tar.bz2.sig +Source2: mattst88.asc +Patch5: Xaw3d-1.5-debian-fixes.patch +Patch7: Xaw3d-1.6.1-3Dlabel.patch +Patch10: Xaw3d-1.6.1-fontset.patch +Patch11: Xaw3d-1.6.1-hsbar.patch + +License: MIT +URL: http://xorg.freedesktop.org/ + +BuildRequires: make +BuildRequires: libXmu-devel +BuildRequires: libXt-devel +BuildRequires: libSM-devel +BuildRequires: libXext-devel +BuildRequires: libX11-devel +BuildRequires: libXpm-devel +BuildRequires: xorg-x11-util-macros +BuildRequires: bison +BuildRequires: flex +BuildRequires: ed +BuildRequires: gnupg2 + +%description +Xaw3d is an enhanced version of the MIT Athena Widget set for +the X Window System. Xaw3d adds a three-dimensional look to applications +with minimal or no source code changes. + +You should install Xaw3d if you are using applications which incorporate +the MIT Athena widget set and you'd like to incorporate a 3D look into +those applications. + +%package devel +Summary: Header files and libraries for development using Xaw3d +Requires: %{name} = %{version}-%{release} +Requires: libXmu-devel +Requires: libXt-devel +Requires: libSM-devel +Requires: libXext-devel +Requires: libX11-devel +Requires: libXpm-devel + +%description devel +Xaw3d is an enhanced version of the MIT Athena widget set for +the X Window System. Xaw3d adds a three-dimensional look to those +applications with minimal or no source code changes. Xaw3d-devel includes +the header files and libraries for developing programs that take full +advantage of Xaw3d's features. + +You should install Xaw3d-devel if you are going to develop applications +using the Xaw3d widget set. You'll also need to install the Xaw3d +package. + + +%prep +%{gpgverify} --keyring='%{SOURCE2}' --signature='%{SOURCE1}' --data='%{SOURCE0}' +%setup -q -n libXaw3d-%{version} +# This doesn't apply cleanly, but has not been applied +#%patch5 -p1 -b .debian +%patch7 -p1 -b .3Dlabel +%patch10 -p1 -b .fontset +%patch11 -p1 -b .hsbar + + +%build +%configure --disable-static \ + --enable-arrow-scrollbars \ + --enable-gray-stipples \ + --enable-multiplane-bitmaps +%make_build + + +%install +%make_install +rm $RPM_BUILD_ROOT%{_libdir}/libXaw3d.la +rm -r $RPM_BUILD_ROOT%{_docdir} + + + +%ldconfig_scriptlets + + +%files +%license COPYING +%doc ChangeLog README src/README.XAW3D +%{_libdir}/*.so.* + +%files devel +%{_libdir}/*.so +%{_libdir}/pkgconfig/xaw3d.pc +%{_includedir}/X11/Xaw3d + +%changelog +* Tue Aug 10 2021 Mohan Boddu - 1.6.3-7 +- Rebuilt for IMA sigs, glibc 2.34, aarch64 flags + Related: rhbz#1991688 + +* Thu Apr 15 2021 Mohan Boddu - 1.6.3-6 +- Rebuilt for RHEL 9 BETA on Apr 15th 2021. Related: rhbz#1947937 + +* Mon Jan 25 2021 Fedora Release Engineering - 1.6.3-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_34_Mass_Rebuild + +* Sat Aug 01 2020 Fedora Release Engineering - 1.6.3-4 +- Second attempt - Rebuilt for + https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild + +* Mon Jul 27 2020 Fedora Release Engineering - 1.6.3-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild + +* Tue Jan 28 2020 Fedora Release Engineering - 1.6.3-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_32_Mass_Rebuild + +* Sun Aug 18 2019 Hans de Goede - 1.6.3-1 +- Add source tarbal PGP signature verification + +* Sun Aug 11 2019 Orion Poplawski +- Update to 1.6.3 + +* Wed Jul 24 2019 Fedora Release Engineering - 1.6.2-16 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_31_Mass_Rebuild + +* Thu Jan 31 2019 Fedora Release Engineering - 1.6.2-15 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_30_Mass_Rebuild + +* Thu Jul 12 2018 Fedora Release Engineering - 1.6.2-14 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_29_Mass_Rebuild + +* Wed Feb 07 2018 Fedora Release Engineering - 1.6.2-13 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_28_Mass_Rebuild + +* Wed Aug 02 2017 Fedora Release Engineering - 1.6.2-12 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Binutils_Mass_Rebuild + +* Wed Jul 26 2017 Fedora Release Engineering - 1.6.2-11 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Mass_Rebuild + +* Fri Feb 10 2017 Fedora Release Engineering - 1.6.2-10 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_26_Mass_Rebuild + +* Wed Feb 03 2016 Fedora Release Engineering - 1.6.2-9 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_24_Mass_Rebuild + +* Tue Jun 16 2015 Fedora Release Engineering - 1.6.2-8 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_23_Mass_Rebuild + +* Fri Aug 15 2014 Fedora Release Engineering - 1.6.2-7 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_22_Mass_Rebuild + +* Fri Jun 06 2014 Fedora Release Engineering - 1.6.2-6 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_Mass_Rebuild + +* Sat Aug 03 2013 Fedora Release Engineering - 1.6.2-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_20_Mass_Rebuild + +* Wed Feb 13 2013 Fedora Release Engineering - 1.6.2-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_19_Mass_Rebuild + +* Wed Jul 18 2012 Fedora Release Engineering - 1.6.2-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_18_Mass_Rebuild + +* Wed May 2 2012 Orion Poplawski - 1.6.2-2 +- Drop static from -devel summary/description (bug #817935) + +* Tue Apr 3 2012 Orion Poplawski - 1.6.2-1 +- Update to 1.6.2 +- Drop patches applied upstream +- Enable multiplane-bitmaps and gray-stipples + +* Sat Feb 25 2012 Orion Poplawski - 1.6.1-2 +- Rebase compat patch + +* Sat Feb 25 2012 Orion Poplawski - 1.6.1-1 +- Update to 1.6.1 + +* Thu Jan 12 2012 Fedora Release Engineering - 1.5E-21 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_17_Mass_Rebuild + +* Mon Feb 07 2011 Fedora Release Engineering - 1.5E-20 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_15_Mass_Rebuild + +* Wed Dec 1 2010 Hans de Goede - 1.5E-19 +- Do not make missing font sets a fatal error (#658526) + +* Tue Nov 9 2010 Hans de Goede - 1.5E-18 +- Drop Xaw3d-1.5E-lex.patch it was not applied for a reason (#587349) + +* Mon Nov 8 2010 Hans de Goede - 1.5E-17 +- Also apply the Xaw3d-1.5E-secure, Xaw3d-1.5E-thumb and Xaw3d-1.5E-cast + (replacing xaw3d.patch) patches from http://gitorious.org/xaw3d (#587349) +- Apply accidentally not applied Xaw3d-1.5E-lex.patch + +* Mon Nov 8 2010 Orion Poplawski - 1.5E-16 +- Add patches from http://gitorious.org/xaw3d + +* Fri Jul 24 2009 Fedora Release Engineering - 1.5E-15 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_12_Mass_Rebuild + +* Sun Mar 15 2009 Hans de Goede 1.5E-14 +- Fix a bunch of (potentially harmfull) compiler warnings + +* Mon Feb 23 2009 Fedora Release Engineering - 1.5E-13 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_11_Mass_Rebuild + +* Tue Oct 6 2008 Hans de Goede 1.5E-12 +- Remove obsolete PreReq and Prefix stuff from specfile +- Fix BuildRoot to match the guidelines +- Require base package by full EVR from devel package +- Drop non relevant Patches and Sources +- Rebase the still relevant patches +- Actually apply the still relevant patches +- Add a patch from Debian fixing an infinite loop (rh436998) +- Add patches from Debian fixes various potential bufferoverflows + +* Tue Feb 19 2008 Fedora Release Engineering - 1.5E-11.1 +- Autorebuild for GCC 4.3 + +* Wed Jul 12 2006 Jesse Keating - 1.5E-10.1 +- rebuild + +* Wed Jun 07 2006 Than Ngo 1.5E-10 +- BR on bison ed flex #194184 + +* Wed Jun 7 2006 Jeremy Katz - 1.5E-9 +- rebuild for -devel deps + +* Tue Apr 25 2006 Adam Jackson 1.5E-8 +- Rebuild for new imake build rules + +* Tue Feb 28 2006 Than Ngo 1.5E-7 +- update Url #183314 + +* Mon Feb 13 2006 Jesse Keating - 1.5E-6.2.2 +- rebump for build order issues during double-long bump + +* Fri Feb 10 2006 Jesse Keating - 1.5E-6.2.1 +- bump again for double-long bug on ppc(64) + +* Tue Feb 07 2006 Jesse Keating - 1.5E-6.2 +- rebuilt for new gcc4.1 snapshot and glibc changes + +* Fri Dec 09 2005 Jesse Keating +- rebuilt + +* Wed Nov 16 2005 Than Ngo 1.5E-6 +- fix for modular X + +* Tue Nov 05 2005 Warren Togami 1.5E-5 +- req individual X dependencies +- remove X11R6 references + +* Thu Mar 03 2005 Than Ngo 1.5E-4 +- rebuilt + +* Thu Jan 20 2005 Than Ngo 1.5E-3 +- bump release + +* Thu Jan 20 2005 Than Ngo 1.5E-2 +- enable ARROW_SCROLLBARS, MULTIPLANE_PIXMAPS + +* Tue Nov 30 2004 Than Ngo 1.5E-1 +- update to 1.5E, #130310 +- fix compiler warning #110766 + +* Tue Nov 23 2004 Than Ngo 1.5-25 +- rebuilt + +* Tue Nov 23 2004 Than Ngo 1.5-24 +- add patch to fix build problem with xorg-x11, #140475 + +* Mon Jul 26 2004 Than Ngo 1.5-23 +- added requires on XFree86-devel + +* Tue Jun 15 2004 Elliot Lee +- rebuilt + +* Tue Mar 02 2004 Elliot Lee +- rebuilt + +* Fri Feb 13 2004 Elliot Lee +- rebuilt + +* Wed Nov 26 2003 Than Ngo 1.5-20 +- added missing Buildprereq: XFree86-devel (bug #110601, #109692, #110735) +- fixed arguments in scrollbar (bug #110766) + +* Wed Jun 04 2003 Elliot Lee +- rebuilt + +* Wed Jan 22 2003 Tim Powers +- rebuilt + +* Thu Nov 7 2002 han Ngo 1.5-17 +- fix some building problems + +* Thu Sep 5 2002 Preston Brown 1.5-16 +- -DARROW_SCROLLBAR for rms + +* Thu Aug 8 2002 Than Ngo 1.5-15 +- Added patch file to fix i18n issue, ynakai@redhat.com + +* Fri Jun 21 2002 Tim Powers +- automated rebuild + +* Thu May 23 2002 Tim Powers +- automated rebuild + +* Tue Feb 26 2002 Than Ngo 1.5-12 +- rebuild in new enviroment + +* Wed Jan 09 2002 Tim Powers +- automated rebuild + +* Sun Jun 24 2001 Elliot Lee +- Bump release + rebuild. + +* Wed Feb 28 2001 Than Ngo +- add requires Xaw3d = %%{version} +- add prereq /sbin/ldconfig + +* Tue Oct 10 2000 Than Ngo +- fix link which causes faulty update (Bug #17895) + +* Mon Jul 24 2000 Bill Nottingham +- ia64 tweaks + +* Wed Jul 12 2000 Prospector +- automatic rebuild + +* Mon Jul 10 2000 Bernhard Rosenkraenzer +- Restore Xaw3d 1.5 - the addition of the backward compatibility library + killed the current one. +- get rid of the CDEBUGFLAGS="" hack, the current gcc fixes it + +* Mon Jul 03 2000 Than Ngo +- fix Imakefile to static Xawd3d + +* Sat Jun 17 2000 Than Ngo +- add backward compatibility libXaw3d.so.6 (Bug# 12261) + +* Mon May 15 2000 Bill Nottingham +- fix unaligned traps on ia64 + +* Mon May 8 2000 Bernhard Rosenkraenzer +- 1.5 + +* Sun Mar 21 1999 Cristian Gafton +- auto rebuild in the new build environment (release 21) + +* Wed Feb 24 1999 Preston Brown +- Injected new description and group. + +* Fri Dec 18 1998 Preston Brown +- bumped spec number for initial rh 6.0 build + +* Fri Nov 06 1998 Preston Brown +- added security/update patch from debian (the X11R6.3 patch). Thanks guys. :) + +* Wed Oct 14 1998 Cristian Gafton +- handle the symlink with triggers instead of getting rid of it + +* Mon Oct 5 1998 Jeff Johnson +- remove backward compatible symlink. + +* Wed May 06 1998 Cristian Gafton +- fixed the bad symlink +- BuildRoot + +* Mon Apr 27 1998 Prospector System +- translations modified for de, fr, tr + +* Tue Nov 04 1997 Erik Troan +- don't lave an improper return code from %%pre + +* Mon Nov 03 1997 Cristian Gafton +- take care of the old location of the Xaw3d includes in case that one exist +- updated Prereq: field + +* Mon Oct 26 1997 Cristian Gafton +- minor spec file cleanups + +* Wed Oct 01 1997 Erik Troan +- i18n widec.h patch needs to be applied on all systems + +* Sun Sep 14 1997 Erik Troan +- changed axp check to alpha + +* Mon Jun 16 1997 Erik Troan +- built against glibc diff --git a/mattst88.asc b/mattst88.asc new file mode 100644 index 0000000..88871af --- /dev/null +++ b/mattst88.asc @@ -0,0 +1,843 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v2 + +mQINBE6HVy4BEADACp0EU6HZ4KyFx/qfhzNarCfnlyEoCFY08k516UaHrUOrYWPp +ukoahcceA/M3H/xM0CGIn6uiuG/Cq7+qODAZNBsr6haIbDaqSUt+953b5qCSbD65 +LBR8TXvW+9KkXPhXTKi/osYBdmsbFLeVLqU5Kd4QJqWKRLtuo0ENbFkQPVypEJk8 +Ozg2zZ2yeSQAy0pgeFh8lezI7A23yj229kFq0EEfeqHpgifIzR2hNIhS5pTSOt8V +RDapO3FpOmxPPUMsaJ1KATD92+SgbZW8evW7ffz4QUiQiFsfTSOTCaTFu8qpu6Fb +a9u/u6mTrJQGRdqDcFp3iWjEUOVr0gUdLSr3zey152PBRaC26/eLqH8PFgCerBkn +o9vso0Vr+Kh63OOQeDHATZGy7tMHbWW5AEXVkTpNoSRYr48pd6u9Z1TfWVcovNAZ +tWiFVKKxniTa4MZY2czOSyh2YahCbEt3P0DoNihy3YHhTvW1k0Os2x5yCsfpGzp3 +U8x1apfQqAyRNIa9SptLpQ7xF+lv52D9kp3XdkWXw1BFY+nmm/FqoC4tKU8AmbuB +n3SX/sYjq3Z6aLoBOmZ849G0Zp1xEYHCbfWBxvqhIc6dlPc3Y9uYV01+FlTzX9Mh +THa8p6oABrXbWRJpkOvaVbdDhXON+02Jlvawy3T3rwVkuEfEZu8akv7miwARAQAB +tCBNYXR0IFR1cm5lciA8bWF0dHN0ODhAZ21haWwuY29tPokCQQQTAQIAKwIbAwYL +CQgHAwIGFQgCCQoLBBYCAwECHgECF4ACGQEFAliRYVIFCQ3McSQACgkQD91oLZdM +pyrfpg//VJ/E6j0Bc1XIOeVPjZ/C8a9pJ85JvLfh1vLtB5EJM6mc9/D7GJkCjql6 +tscZfBVewNbHq+Bt9DSXCx/9e5B0xtYOSvaigeYt9/PxEndbsFKOJ/+s7P1XGsKV +JRZtezr2VhuHDLQfChqKjhCR/XqA5WZQ96jUK/lS7kPEtKRwRJK0vW9Hj1bD3gh2 +cNQA/1THncZkihZpFJhUdK3382ZlLU2f5EIlgMSquVeMKmlvU+YJgwXp8YH4JPRh +UbcBZyGCzYgOtBBSmh+Y8vzxhjpLNzpnkV46zx4Hguz9xcOa1XqXILxIuXGqm1pD +D1tv37Wf78KcjL7qqKl3Gl8q6eRYqyv7c/7Bt96sxCzVBWThQr8/fz1c8TWnmUz9 +xi1cg94PWAresR878Cr4aPCFtJQ4ZHzlymPAt8sc2aW8l768159h6B2HwFUnaBsV +CbCGDDu1/hMxamOR9jQZCw9UMNKKIDoNMTKmeD5DAeo+S4Vu0a/5rFbVL5/s47Vx +Ypoh5QP8uDmuwawEzf7GnErNXSkdqIvhWRfR8e/0sna/DTybz/lz6/bMBHsGNmL1 +n4ZMBBqvlVTy26UT9XqkLZdQAmGQy0x1r9VW9szMdmaLEM5vTvR0qQXoyQhnoNuJ +PEVvvuDst8WS2xuJNdodRIZ1R+dZFZx4K3tIw6Zs8UXAN7W8LxCIRgQQEQIABgUC +TodX5QAKCRBNVR2Dbeu/nZneAJsFow7CYUzQywH/Wy1ZIcCa3yiAlQCfdcPdrxs4 +KG1VxNSVHAJVc2iVJ/GJAhwEEAECAAYFAk8gkBIACgkQc0FhntM3FgxedhAAzAk6 +wTeVmA3QiIfzajBaeN+Qs8u1lYNSJPhhti4QEe96fDyRBROSzQu1WsZsqdTUtFmg +I3/71o3ntFfhol+m93mtZ5xL4AMVPV9A0b2cMUvM0cTHQEeeKfFK2EVPWyWJIHlk +yz9yAZ6bpOTZUzl/LfMCIksgdnBd9zR2EZjKWIT4eyCCOb7Wl4KvmRe1bn9nB27j +J8j+ERo4Ix2Z5ShMxXcJUHhR38MGyoA0s00A6rR2rc/4OyZpGD6F8BJy61d48H8V +ADUQf+KmYJZEjpzFZIGM1kPL0slBkk+4JCpB+P2JLMMbLoFQleFmWeIpCko9Z4G/ +XbFhvfcK7dedDjyPXqIkzSa7LML9Ocinnsw3KIh4O87QYGOv0vUzcxxZDz0U7Uyp +UXTBxwDv46aiXPzdsbzEquepqrODsBGeS1xltgxNutevwn6g+0n6bpseTxDpzCUd +f8Wc0mmIAlFvBL4lMowPrx8wMpIB0S0CV9f3upIgInQWlXJ+pgAlEpsQWUYLZ81Z +lQHZyfAiiVglg7bnxjvs1dECFpYh4X4JohMcGaZS7/aXKdiqdkyivKJfu+4iQHrc +A5qkfT+uyZNT96D0bBgncZfsUMBFgsYhqrUMB0XcRC8JKpgo3yuKZqrBa+ZbK6Pv +wsu1L0/A46viU3WnSNEcnysJibjE6sr4WaFIlhqJAhwEEAEIAAYFAlHwj1kACgkQ +v1PGm3YdjgpxzRAAnAVP4bQJ/Cav+EWwS2mCZPcMqN4jajKuBCirTMf0XqMZGFpG ++/6aTA8FwfryuNlW9A85KzAohRBkAWkuHY/mvjuCWGncSdBKnl73n1AmFJLcieV8 +rYO3P8snir9lzBmqNifChzhZ9MRhY2F5OaD6FRaEIbHplQ66dJJY1gMVWrAXEYxf +dbBW6fdUikDeXSZAdTM91xvC3rb4e2UO93cdqMbc9nJBjQ0bkj3fGscl6ytpFrgR +b8+l1FY5TaisiN+dYv3kAzgZva3wbgGdYcV1cVaogZ5QkNiYog9KA3in7/3gnqN+ +7sjQs6nerGHDqFavbxrADi8ehhcg+6JQtbZGBt+dm4C2X76Y5pjgf9hcx2BZ9wKg +mGQvbcXNYpb6HwfyBMj9RUnQe+ky1SpcZdhP64VqW2gu7XLJpaW469XaHGL/AUp+ +uQhddr/guT0qUvMDQWyKLZHnxv5wEs+beENsRbaNAI1c3tTZHk1qiHux3e8kxx9W +wgdqffQTvM2YQAjk4W7tCEKpkbbLd+4Jg5K1R9vlfYcJvjE+CarDM6AmYTlJmPAl +xBC2qrSMg6pK36VY6JXjwztAj4BAuM4O7OmvOPpROwKxEimxbkIrKvxVE6MjdbaX +WEYF3x4p7VlYkKX/nI5tLsBxSolJ85JcfE0w+1Jibg3oYFuoBK58Mcrw4mGJARwE +EAECAAYFAlH4UY8ACgkQCJ4WlhQGiO8uKgf9GkCNMX0TKfoxRPgQkdiiLr/X1P+9 +3TwBMf7cuANUss4yrstairDdNRcwWSc3rI4pb7wl4uqM7HezbrK4XMOe2pRIocUe +O6PqaR6URM1HVlwk9KQPzxqucABRs3p4TvaVIrxVdYRkx8jQmRzxKkiYA+68ArSM +0ne3SJwPiGqppqZ3XtpSqlwNs5IPiPktsHsnTJfbiT4CEAyy9jPsg6t2KgnBVH1k +Rm9+BpXEdcK1zFFXnPH2BJ2U0vadjcZQk5CeP0lbV1tKkXbHJEGlygJnf5KNRdoZ +vDc4l30nkX/UTEexmNY/dd7+pSTgQ6jRGxQxehKWQM/qiXThrgPLoIAocokBHAQQ +AQIABgUCUfhWKAAKCRBxqIKCc6qWRoFjB/9yo+V3vRS6z1wxT1/lSV3mwRIEiflf +ucn/B2bH8IyBqKXUv1eRuN2CL22zAeik3OMFeLSbQjpMsqogHjbKicpDJ9lcrVg1 +QpgWpmoWAa32ZbDD59VTwy3XQEd8PlODUGAKGtMSp9v/LERw6yRmwmChlFlVkO37 +tVMzWEEGxKZ4L/oaDnr0Lax4H8qgZw2vd9StC+loeLJ3w+JDOZfRWMi55mi4GQCr +QgNMsI5Xs9WplI6xeAC49Dp7jUaonoV237HBBIKnixiQMwRxunvYwW2iz87k3PhP +x1UhLNLN5UEuwilFpAB6fQ7/udUREtMLlYboslaggGi3Oo0Elmi8nDociGIEEBEI +AAoFAlH4ToIDBQE8AAoJEIOZOJ19Ur9bgKcA/RW4W9kVo2AdAobvCkJkhbUb1STy +MvwkPqynKtT1nHmRAP9la458hiIDUKOClUQt6TvCw8a64WLRK8X9dfFhJB/EEokC +HAQQAQIABgUCUi5O0wAKCRDbIhppAAAAEbI4D/0YKs7rS6QgQGJrqhik0ZCxee23 +O3cK0FS3jQSl3SMNWF97k05f0LrObm4s2zddu+Xz6R6T2rNm7OzvijnXN0ChOGE0 +gIK2+8Z4WxmyIeLCZlHEVZ45wQgyLDpvwvhcps0NloiBoijDHigvzYaXyCy7o27T +9XV8hH8qu27psZKityopvFnsvOrPctbYS0I7Luzom9Mr62PtIbNod8mvufQQ1/zD +Rr+yKz6iKKAORs5F3F3K7VOn1y/v62kZabFxWci6vAwFq6e4qtrO+nntkMBRfE/C +m+ReKDNQrQrrKscb198SgrmGDxcuU3kjJXnQzyWe/2iLq+lhCXEUFvY9ZfFYlLap +/v0ZM2icACGp40PZ3RJqowzQ4LpB1a5cEDwq5Tx2SaqE/4jwfpz70XnAxWgjOxfx +OELJ7jdf+hpDZy8/ZF8Z83xlz8lnNu/mfefN/P/Hnvn9RVvySUOwsJBjlji4ZQTy +sloJBpNocyVCs6VqawJzpP7jV4m0J9RDJKpNgcUes/vwGuuqESwb2SmJs+CGePx6 +NOunInR+lEoZ3HKDt0MT/pkrq01vVGZLi5pZ1OZNh8wrRaIufQQ40p4dy82+LjAP +I9d2VYzMwKmE5EO9NMahMuMYyfJGU6QJKIrk+7fFIRMhX/qjQkSFFwR4l9bfW1Wn +1cmE1Fxf1Dpb6rq4RIkCHAQQAQgABgUCUi5KgQAKCRBgAjO6nlTcYXDzEACQWAsM +CHjux6lN8Z1yXJOzMPW0J3WjV3N1rSEuuRDgjTlLB0lvkpR/30lH5c+JFqjxoq7S +DuOHiad43+y256PZp5KthGklT4mzTOb28VFzjKn9qniV4zgTQJ261Ivzyu6prf3U +GNrcQClsMBAzW9Cd2H/57PEkl5jMGunVavZRvB8nd3+vXemwKWik9GF5h19li5xh +2ohp/wF+YxyMWIa7pL8oYlcx1FwoxDIpX+EVaK4rpg/yhd2i5EtD6IQROw8RkiDc +I3If81OubDSfE0sQiuCn2aDp4EgL9D/063ret+7VltqRKZP1tq/crMaGptgWX0IJ +waDt3dDdwbh+XPmwh8DPtXQm9LQgrsZm5Nlh7ix5yykQCfwPZOwKmF9RV8XUw03E +IOUzUGHyQhweIcIlgpPUHNiiXjxzdWNSEbXpkkMZXwDm5e0940InsZOYXcyCQW6a +kEmXdof058hy43MmhzTPgmYA0qS8l/4au8uACwRDkXVEEcV+Yqabp4sWFnm/Lnbv +3VzOAw0cpTok1jGjeWiixfBwf38N4vLSCyR4QQPyW4ofGktLzkPXZm7VEyX4dulH +l/fI5wr8iKgGrZfLVMzoZFZa60gobAZ0aHznTi0dd3wJl1mOSyZkqR/4ImpD9fCM +h4cODRz9SkKjslSTd6KAk9D1QvSJH18yhBdIoIhGBBARAgAGBQJS3aT1AAoJEF9Y +DsCshAMPNBsAn1rzQqWerbLELqGas7AO2B1efaJZAKCCvYfO8Lgd8RRVKlu6vUpx +BpalyIkCHAQQAQIABgUCUt2AWgAKCRBbW9oHHUnMOJvvD/sFeGC74Vo4Rtl9/2hv +43mTJXgLDXmkJbtUONwlzqQ5/tQi9IotzDyUqOOxxiSoYQNPPuCWGhgIIfyxRLzq +8TZeQZ4PDlRm9B8lxdOdBhyNJqlfp/uYx5urccrqSOwz7sIC/gBzNjr0za4f7Ud5 +WtQ0ukST5Wk9Z5Zf5OpcNFftTkw2VT91j8uHKXvRuQ0SNiiXv+24PID8XA6WdqYS +8mhyI8FnVo/MloucztIWs02DEMDUG+SL6KcAeaDnugx57lg7NN6QVDfCMDovTD4k +co0VII4s989CtzeNOT87/olr9dzrZIqCXoiK4HMGlYmgAhhepQpgn+cobLrc+rOy +3S/IGYIPXarZBcBRG6OHq2DGhwQP8IKfngJarazOj6yhUHfguGniKiW/z2ZoBCK/ +9kHzTM3MFN8P2MzyJ7GJeFhChrA7jf7zBZyec49r6f+4OpLx+uz+vK2pvaH9CPZH +uYzV0vtVNopyUn6zi4yz00gYJOXoq1oeTuGxvblHiR0qZFapT36lWh6JiMc0J3SQ +YMDrRmwW57z6DGRHBbQXmh7/paaqu6EJGYvgIJpVV4oTvAzwRHn9DkAnw3aJogho +ne/wDAVqoXFnwvpxdnC3dKQpgvjSfjyVGazK0fNvcDvl549ciDfkF0fL+CAX/wpS +m4ASVEKfACsi+88zNNV9rfD0Y4kCHAQQAQgABgUCUv1DRQAKCRA3+Z9oyvmS6+gM +D/wIjK0FvsOfUeEkc+aBDFl++aVAcFhAGK21iRhrhbKdmYKJ5ifiOI2OkFPZIt/5 +0DHW6kdnUj+XhXVR4Og5saXgTqYq5iQSG6xERDm+fHehoudmfF7vxyH/cX9Z3mth +H6wPHGdhIBJxWtOH41m8888AzUJivUCgJ+xr3ng27o7S6qdHjcyqzyiWUmwvz1jb +t4KF4Cf8dpkTcZrH/vXZsch/uxuYV2RvhbKArF2Ye8IG4qgZap5grMu//zcoSxGe +1OMt3u8z+E68xTLqNcetBNO7AROE2onRe1vuBNtF+dTDdeStNQ7COVsSGTyYkJ8+ +xRLiNCeyR62tlH8+cyceV+vMlztW/qVr2D4lcemckr2XWv607CQNmTBGGHSxZhUn +9ZfHr2H0zl6HowvvmWs7ZouvzFcj8QS1+baK9zaowIU46kbpRUT69saVJ1bxNleB +XE3+wMFzyVlXC/fJKDls1UEp+APhXaDzpSY35vN/YbRPFtps3C+4xbKG8EHyihSG +Vm2xWXUJ3OndLeC2X6W0Yu7Deu6KraWOVBde4+AEd9rxT1xIvU41R9fEzd4tyGwa +pXcwM6o1W2l+YAtgu85gvcli/3rRpfnj9V9+gcVzC+bP1OcG/5Pve5j3FVmhiHFQ +LORh7DfDxL6XCMY6Bqi/jcBDUKN4MwuIKk4h2qG500L13okCQQQTAQIAKwIbAwUJ +BaOagAYLCQgHAwIGFQgCCQoLBBYCAwECHgECF4AFAk6HWL4CGQEACgkQD91oLZdM +pyorzA//VdiX712S2MeQH/xdv2xpHPuUXsgdOo03rggxIYQ8HQ16wUKCRZw7G2hh +OuLWde3uWB7ojWU8MifjaDlcm6csSD2YXmDz3YnpPJuwuwQtVyazns9QrgTMWU0j +t92TGMYH1xDq99KNPpFPvtsHm83AtE37RY0ptssGzxAi83Ehk4tEnWM8qDlWDs/v +4MEgDzBC+T1vkbVHd1/gXPrz23nFxb0NVx2wKw+9NZFv4q87ptYbK2tz2w4LNKFg +6AvZe5da6xoBeeFbbQSegzBsBwC1zXGn0praqAYsqJC086JISKNW3uZdMrZ+UXaV ++Ci3+qzNxTejgcbe8KgAjnYMLl8V+VB5Y2PEol1yqGOhRg6uTEiR79Jkap8fW5+S +z/asVHqT1KZ8O4ln8s5GsPBrV/3ZHOpws5y0Y7kRXvwf+jLWIoRdpQRbT9DCeW3V +Qk8plm3/HgBwGSUq7bUSbsISE0O1amcZmoIH7sb9986LWHEiGLrZjcHFovLee0EN +nJC0AB+MVp6ZJifnLNwQePAR5R1Mo4Q5UUbUP3u/lgBMB6V3ASoV2nqynFVYVwku +eZhyqlc63h7JdcW36svFiU8XqJ2/ea8wG3dFcrLnaqyFP4kov5C2k2h44jCH3Ox/ +srzUqozHOA3sqUNCFUBt6QyC0CV61eNA0lwUxU/H1pr4zMGjqGOJAhwEEAEIAAYF +AlQBasgACgkQupx4Bh3djJt1axAAtBi8uuIA0JPqZnmf5OFOmUv+hBUO1xn+WvbZ +hsdiMZ7yjnVaC/Y4+E767xXF/r2CfzMeaUdpNtaYpTc1lxEFIluhVnQ2JVxEorjH +CnwbNpLLTOqoL5nmD+1/KILiPn4DHR6Wg/ixsehmrOwZVbDlLlVxvBufzymdsxJH +RK/V1gwWtLY+zzP6MOtqhG2FuANJlp2v/uCADvRCcONAuX2pfhfJhC8BIBtMzHck +cq/l10B5cQaiQGNBPL1wj1W1Wfpaff2G4LJDULLABwx13PTCMDz+pPNyncnnCbSz +JqGVWikvXO79bN48kZsS3h6jTtCye2thubhQvqSMLEhIybIHTCR27jzWnURvBDqt +tegZlQ6XNEH9Lup2oL/XAtULe1NDHqlBc+WlcnW2w7fzTcRcVG/EZ5rQ2lm4/Y9I +zjajorQuYcaC1ONIxfy5W7PE4m2QO9BEwppLUZMMrm4W8ngd10Pj17FsIHO5Qzwn +qhuJhGh6eHmwQQY+uv2myTDf6spC0pJ/1BX6iIRysiHUcwyTtPE3ZOrqdKzbY90M +981F9s+Y9y7QrHW8QTlTAeUpGcNkHVMhVDb0Dfb0cwtORD12h0NQRQRboND+G/UO +g0BbJkT4KdAMNVEDph/QMAe/YDyUV7/5++ckZ1HV7+Z2MT6lW+ApVgt4fLx98ys/ +rHwrx1eJAhwEEwECAAYFAlBZwsoACgkQAi823TnvHyK5NxAAqS0RRE58Vxw+BB+i +eapZGKm8xBj8HXGd9l5zrhQgnGbKDjZf+KItE1aSVJYPf6AZ32n/qgjL147/8Nz6 +JelpDi8Jr/VFbmOpx9RYvt1Grcc0hfJLhd8B3q5efNPyUuYQl5ie68Cl0WjNMSJm +Le8kUSjXJRTLpYgoHGZ0Z8h4EpItBJ5JC9vDV16vKQdltKMwMmdVfrYRTjx8HPNi +bY30dt/gyjLDNZcbkE2PdDw/jDnwmtXgM4xcVA4qmci0M4geQU6OwcgbuVYZ7+PI +Ruh3TUKgfJSyQhzXpioSzPo8Yyys/lfBllm158RxcXYCEA0VrjXz0JeDTOl7ntVC +O2/gdZ+525AzFQqeXj3bz7Whudw79agvH6f1S7fmFSqpvUq11pUsizb5usTgtW8u +OPOfgqySHI113pgV8qd2co2lPNvLeOi03jNHHixNaXcSAbc8mj5AHKiUrHYoPxuV +FUX6eXDDQ7yoOtDW5QVRQTpYnoUbvh50mwgBl8gnvtX80NsmGUdIEl4AhTUOL3rQ +vNQ6JAq73PUwt79wBt50KFSu7+WMWxuFI+jRjUR3zeXkA5XvOFxZ8rzRk2K6Wape +p49vUtoOwLOD0yk5T5Y3ustqDbGwl0FsZxpZWtcbl0gfydYDdRyD/EvQrkNZbvVC +W+rupA7kBEgDbRDTQcQ0eqzxEE6JAhwEEAEKAAYFAliTa/0ACgkQaJTq+9heXjn9 +VA//XBzjd5NqoyP4KGBiGGPxJzViVfU1H8bQuHiH6bZFLKCBq3EUTtfSyTkTTU83 +oxheTPulM61zuYmA52hExViwxCmE4q+ey9klyGOVM/sMZjIS555LN7E8Av1gYT2R +wg76CdgDKe3KSClXSw/iAxd+dIFtF/br+5J1rlIbbSgYE2ucZIodz9u0uGmfs7lQ +UfjEeiRuw8NRgiw0v+g7GF8qP7XraHLSuYLHi7gMm4RGreVbpSlvG7pndf8HOjFh +hNtvPQkK528O64sB51BQJ+w7NX9+d5AEfz/5w+kAl1rayP2sLvXLpMXZ4qwzINt3 +LRQGRnjVyu8UqwOdDndNJ0GbkBD4+fHfJBkNf1dn3HuH0MjRo3W1N0dBYgT1ZsSl +QVHXSLxMTE97TD9LgBiyTzKpYcx+tvfV86TOF39EkOG2mKBQIGXRBM8keuNiTVvr +fUJvj/ntjjFSvTQzU8SGwQNg3RbilRBDRTgcBjRISGA38uHmJqtWRluLNt6Do8uN +RX1FNvI99Z7rx2ESZfkWqA3ifihNnDgOejTNdH0QNA0qZ2dx6latrwDpnL8xLvLM +Qv1V5CoL2cPMFqHUhMONqPnA3UBLEjiCzcTAdkR+x47+OKJsR2b3ZI+NIVidDVQa +KD0L/mjfcBaHJZxxsAO87qajkfEPQfKh3mrkiwDwDXDjLVSJAkEEEwECACsCGwMG +CwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAAhkBBQJUAJrJBQkLHN4bAAoJEA/daC2X +TKcqOScP/0GlobAvU1lBkyzuEHP+QehmHnmcVPxvBloc9HtPf67S2XdCqky8F7/w +k544auPcJUnIG8/9mocQrEm8oU7NMIgLWXg0OcNw91U454vKyKlxMVzzh5QDNSaq +SiKGkmNlVSqP2Ywx9gn2THe4fOjHhPddbKHK03ChZe9WL6H3S0QNFtJyT8hf5UnO +gbW5QALNGh3wVGacV2KGaXWcxNbFz8TvIW8soZk6AQLT7X4+Ia0q2rSOxlxBkKDx +3ufoAUO1r7ftKe5Lzd9DsBJZQc1hdAR22s53w85MH6SC23McgFFSRaNGHDggnrOC +owtGhVtpo03m7LektyBLLZCpUlulULnaQgt2KJFybIaloNFsrepFRGFlFHmVYpZp +ssaueWtiIQOvuEWRLP+y6299vWCQxMrXG6viqGrgBZnh1g2InW1wRYGtjM1XTVgR +/UdHGPw1xMbrrWY4oK1ethkOYch2m/Ikbzt57Kst9gdF6l2Nd6dSq9PNvdB0wRce +XKydb71QCaTH7BEZi4XXHZMWyLF19HHbBQPqwrwUOqO2p9AEFEUHuN74pDNjOcO5 +gDLWbid48hsplV74pmkpeUq92ZkMSbfcZJ5ITPrKQwk/+MUKYgNhE//2/Y6Sr4kt +VZ8ikXNcDIlFsRZ9T1DIX599WLAFOaaxw3YtWjJt6t8j/+s1JsP/iQIcBBABCAAG +BQJYm1zIAAoJEPuFkLfEylJ5ki8P/Rrq/HrlnN60uW2/93gzIPNzgorlKDt1nHEX +SESibwRQ1TX3dkc3MZtqcr3hvMs5ZTGkZsE/cQVvlHafbDepmYIRlF9MsYUa8iTW +Px2bruSX+GSyMgI21IblmzsyxJKSOio2KvrYNY9ka6vGojyV9Oa8KiaNHgscpkPi +LwCZgBdn6xjDAt0XUv9q05qHt/UJR/gTinmcPuVzCLeiIqXfuLuYUBzCPmy63OTQ +VbyYvPACSTuaW2g8m/K+SPGO7Up3BsGM8nUsD2NP9SwMf+ogEg1/u1/eT9+FCJZv +xeiDzcwKfoDgBbhH8hHkTyJNMj54teC0DVR69uYf/LSvi/zG35PKDoNX9FrDvLKw +etMHzKDdL5ey+XHL9HcL18G4FnXIU8HKWfQWT29ugYXkG40oLNrzY50CLeCmQ8qr +oW49F3Qls+b8bqnkdn+UokXGIdkIZfBvjYhzDbrdbTs27ZwLehMB/iR0eH39zsCV +cKCVgHhF6OGFqsMapmjCiBaaUSEv1izGbS7HhNIlkoDZUxFUy8JKixiLGrPruUt1 +lcksjuYoLf24bEAI85eVLjdgAP8SsxGGVeO8Pek0O8P/wWruzvZRemrqBYptuUez +KW3gBfIGTYl2kDueRnVrRj7ja8Sr+bQ+m3pFEJWqcOqeGxoYh7Kw7g61eWhA8jAZ +/HmhLKJsiQIcBBABCAAGBQJYl3nVAAoJELsf5ofv27PsRwgP+gLntBfFEdzmIEGH +w5k3ZLYgbXc4oBMimDf591+wDNRlpCtYi76PBeRbhCUKXghVnV7iTLCBtMs6XheQ +AUfZPHwxS3/bl+/RL8bPD9UJ2vQDu3qijhhSnN3n/HUfdNpiBwaEvIobOZoYoncc +THTSHxhz2VTn2HlC+K4yTMVhC0ENrBIYGttNjf4ENf7aAOuDy7XzCamrDjuVqQrC +6E7RF37k3pAwteFcUqbv3TkKL1llw5m6szTJ6lxFbI4SE6OwVjMATp+WVdcL4jO7 +0R42d+aSc3Bz+0qDkbE1j0TcQURq4STwwLBXhw+o9saYBojSIdLIJtPlNbV0noLt +2P1XVjsB60dFrJ7OMYE4wNRYXlRhq8Fxdr3cAj6X2st+KkHngk9gmGWCMxHGAbK/ +HFtH0yfFINTnNjpO2CST6GlU4hxBVHAlNo0MUWrpol//8D3hzKPymxJTxWsd5jOw +bhyht6qkAMgKjlAinEM42TB5c7Wu4I6r0HTOXBH7sd7ZzTi2mxqoauI2xSAMB2If +vJFmXwMMlxb93huNS8Fup+wBxXW8Y0OKxcTC15hJlBVAotZO6ti11YrDTUiWRkDK +K2jooe39ZVXbrT8e6q6vHQuT0+MoYnig/DUrQWjWD8SAMY+oXmZ/BvB8UYD98ZLR +4FZGaQjij0EknzQ47MH31czidr/NiQIzBBABCAAdFiEEKV7xtutdyaayHT1OCwgk +Cpb2ZXEFAlkrANoACgkQCwgkCpb2ZXFGgQ/+N0XNsGSRGp83YBdNg2qDAOSSXN0o +fB5bYp2rux3V7eMyS8toQoLSr54BlDCTJaLpBoWsbcsLjiVKcs7CEWM4N1X2xN4i +dV/sClsTyXn8Gzksn0uisTEZHii4x/83OQj1lQ8x5GOVPBLTxxCWZWEzHBypp70/ +o99SvSRBbpZ+N/08fAcnx6z29HF8sGJp+YiWk+trb6eo7jKljN35qxummhalGBGw +5KrdREEQqJXF7DfcNyl4zuwWO6i9dwNLlH9d9rQNuZ324yfBlFfFiVsGG4ntwfuH +UVfFCJMhdJtJr6Szw49z3IdtuwAzSZH54MCAB5rUweOYxhJIjdEVG9lGL23NZQvN +VY1jICr4cMXQs0vKxgJBs2qa+ymz4BxAWWuohmF6wFLCwqBD4MqX/vVsVRhm5ekg +0gqfPAG7JvA0xYIOpHVxMN5e/euXOSydfWhPo1x7CCi90i4P16Ste7Q1kPf/bUrC +wrlRA+2kZeL4REaJ7JM+OjwjhI35eaCz6z9g34ZWUspeDHRksd/o11D5GF1rKcIr +Owmf6Rt6X/qp2WlBXlAxrO/d7FNtj+khdYzAPiOSbjibl/rqsm3hx1kTOopOCpXn +PwPOy5lfoFX6bVNYZ+dNUff2V2I+JwCgj+EKTvYfzDYG7ofA/VelKAYUTyhxIXua +nREp0HqEeQDc1ZuJAjMEEAEIAB0WIQQ1sX31dSV3ygxUHOuUv99EhK0ULwUCWSsB +FgAKCRCUv99EhK0ULw8lD/9dVHGI1sTf7PjOz9O736gbmv0SqN8mlaZlKE+Qp3HE +kn6OhDqx8Yq7m+sYsF3uVmCJXpIyv7OyajTVUkXY+gqSrEA5TF3ppi0XqHCjypuC +u135QnCbsJxfD8WXamZZRXwIal19aKleimEnPMU0ZuEZqJeomNV96x6Kl46NiL68 +jl6trLx80HbuETzYg9M8IQxZXxkRmZAHQYA3udh6YOmaEPwO6mNe//rij66xkEX8 +/XWuEIBpX1Qfmrna7HyL6rep471tQDPehTZ4yn3Wrdvin+fWFUo5bfKMJnmYUb7y +iMrSE640dC7F+TRDWYPbiNr8/zk/SpOCf+ynGIE7J5vrPERmWvyEIT79tPZZK+xt +46QF6ztDSqKlAkhaepcfmq98YP2sc1mKIOk+XXZ51K33iaB1W//4LQc+lEnHlqQM +w/lIog/c+OTGIRrAkVlElQPMsiPnD5Xo+xdIM7D17z3+bLU4F788J/oodvL8wfXy +2zEAawQnNcGmbGaSUJVQ95Q0BfW9Jx7e6zzBUbuRQuMqFGvLXq5pII3/y85Z0bAr +pOTyxSmYYlhto09N6AiNSrMH2nNj9V6FG1CR/J3PFQRNQKj0ow13O3wSxmeMmuoM +EmjfsnKfc9RHjVmJBf+D+BLPluyG5pCVXHXU3+H1Aa1lyZB8hSo7igSejkDTUl9+ +Qoh1BBAWCgAdFiEEccS3ViC8dXCLS9slTJX6qz6wc+wFAlqV1i0ACgkQTJX6qz6w +c+xZ5AD/ZTbIdTJ9AojnY1o5HEeJLA6+4mR90m7JyxwYLF8rILkBAP/lAqGFASYD +a6g5IJrezdPKJvtbraTBdks7iqhY+uUJiQIzBBABCAAdFiEEPl//1KPLqt/aWTlf +G9n3G1fVkrkFAlqh8g0ACgkQG9n3G1fVkrnY1g/7BwrOdv8R3hVbYsF23cYSH42j +Qc7aya2hFyh326PHAqWsCF5g+YeAfvtHGziGw50/X11twYKIbVCaAg5yFd1wnhR9 +4Abfthoc57EUnPtDmVs7DXla/eml2KaSaXSz43XYLhE2shQIowNBn7Bu+DlOkgkc +eeuSA5YS9OADIDEuBXNfrel0F5nBjlPSfJy3PKfeWKAV4jvWJf0KsAAzSoAYNfmh +1pGkl/FzAmVpIHvoTJZOlJeKdiEi5053MFZrU9ex351Yl1Mg4W9a5DeCANXaBHDQ +mRSJGJdOoZ4lDSxEcSqNlkqsnGmRT+3xp6jljG3S+Jrf+fAifjDoR7n9bqDBKhcl +vR10zoc+mhisWSaBCMV+eV7f9X632qxILlvQtJ8ocsgQ+nKJFvbtx6TkCXuIfYJy +T8aaDu08lpj6L6VJUEBZ0g7TPfqbNV3n0Qu7pusrEZF3oNaj+CN4XYXwhkJLSZoF +0s8CNe2LQMHKK0YL7IuFJk5ZgjOmEkyDFJ1omGAUe98K32Ms4BMcI472IHsgEJv4 +mUmGf95ZT0faW10NLStpHWSYvMBtmxir9UW8fDg2QYHkvFwEG4fsXameO0Pyurjh +i3RHMKz21X83uJs7khHsmvUlOFiIzdmpIP1t21RRwJzhFoEgljG2v4vl8shu0tLB +piJOOAnYmj03Xu3GSnKJATMEEAEKAB0WIQQlGwzc8HsyrQJCG7+/Z0yIiRI9KQUC +WqH21wAKCRC/Z0yIiRI9KU5FCACdiR+BBnKqHslmRQECKFXMHVQEukvddoFa2hmi +jn/l4KqdYNA8UipuA3R8hLSgFokKDC+4I4LZP2iRDnDEYP49zjd3LGQ0HPF9Fovj +zQlAdEu/tUneinMbPL/OlLmhJC5hNRPQOdDl0Pwt3KBDl2/kqQ+xa/Y5unTwOxeM +Ky19FT7okuNQ6VAeL32H8eZfN8GLyJYQHPRwQD6qbiqyYd6d2xxRwQRJlv3vcCB5 +wmgUWByjc4XuAwElrORankSK4fcAaN46PZcdvgtLX5t05NIyVudKKrP9jmaPOqwy +PbgFx/SG1ObWNry0QHEvEdvIH57QWtRLyFlfKknv7qgXtFlAiQEzBBABCgAdFiEE +JRsM3PB7Mq0CQhu/v2dMiIkSPSkFAlqhsbgACgkQv2dMiIkSPSm06gf+NyiGn9Ev +B9oND7TAlU9pB0uPL09OfxrviV1Wf21dlfkg62tY1u0rfqCQlZEDVA81ERHDhFJy +xYrsfQYlTrPiNFy3vRVJ1tCezAdzHV+p81MTIxKeWMJrvRhfG5tpFlElnfI9ogtx +Y1ZNeHSvjzCO6iHDjwVBXe61ofK4Dt49E3JatbwNfcE58yRxHMRmNPns8DjawgcQ +1EGBS9rHy7TROGbge9NCnFkW8l6sFJkn85J59fHKUo9ybf/aCtLgDuI5CfHtHByp +wJ/bDkIhEdEopKn5+i/Vd10OKOlw/zIgOF+g8JG2tqFjdrXjP6XA83xlphgRCOPq +slfwr08yFIfhw7QhTWF0dCBUdXJuZXIgPG1hdHRzdDg4QGdlbnRvby5vcmc+iQI+ +BBMBAgAoAhsDBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAUCWJFhUgUJDcxxJAAK +CRAP3Wgtl0ynKt7vD/4wL2Al4uTOSosCRD+zuCi5GbHHs/NjNQlDd7DPslre48yy +sJ4CAMSWj84N87bx51gocgIeyjt3M0W6Q+RRhQqqnTafXI7kGLnqaOyyiGHgy5tP +JGHrUNYTgl113wwwG9u0QwSdztC3LzU8VXokRGAutvjv78fSf/w8ZNxa/Ldpk8Fs +d1EKktSlRqkYa8oGwFtMVZ+Ha2GeezC1Cb0eQ4JG8FEdYIKDnIW/vHQhz7Cxj6rz +Yy/hFdKOHQrWDIWTSthBxFqR+lnAgkclrJwa3znJljKtzeoksA6pbiGcVmubeSl3 +4G08N9IzXmfwEG0GX9+nGWlVFVt5PuwyJge3PCWzRa7/4AYPMZSsAhhEmTny2FaP +AyiiUjp7hLUcZPL4TQxMPL57BNDWp64q/w14TnxKir8ZOFdxcxq+54r02LrW+cwS +IKdCeJ9MSBmF8saXP4JqGiHjN6CCHQ0Lm7l+usOMxsaqM4+2FKEqUwdRrdo4ry35 +T3Ei1/enBIFJFuMTbqyi5sERDMns6KWLz40pQnrj/Yj7+Brts5WEtGl+WdVjcvPz +pv/tWbdyOV+iR4kLejszdlWz9e5rk3tmWchkVuv8amyPyIYHTEkN42XpAvwGXuEc +a3NOIbQmJ/S039Gdcf1l+LbwwKd3DnC2GClSaQ2JEo00Ii4om7bu+fComGtVhYhG +BBARAgAGBQJOh1jbAAoJEE1VHYNt67+dhjsAn3iBWAuRzfWIDNoGIdoen+utKv78 +AJ9hRUtmk5CClP3Zz0QxJ5LzBRkTSYkCHAQQAQIABgUCTyCQEgAKCRBzQWGe0zcW +DObkD/9l0bJ+FEramdIWtxgtFO4YPK2/Wob7AWdzLUVqEK9nvSN35sllbAgZNR6S +lWj8q+7XMvX5wqm0wMNpO5geDBvU45bXykdDqjlYJ6ETiqtMupZ4eyDRjHrDy7BV +tO+nesOWwubEUfnpGbyK0dxPVq/taXa5W2xQDLKbevWxBI8eDHauIYqX/Qwc0JpC +tbC1+20eQ+P2bPSVBo/TS6KLOq+FyTuKqPuDmYnjqXzVoyudPI2na98Be0LdkeCl +HIfqvN7Usqwfatwe72WD4rLdDtFPu3qxjpysPZRHKkSC6iIpHeFcHUoFUCI5rmoY +kaOZKcm6yAR18x3vMe/6zQG4yqeT5WgDSPSNO5g1bA71Qhw8w6pFsI4ygsHOXz5J +9F1qkzLIm91mx2p8JL2icLnhyYRiCfX0jChyMmmtyyS3HedI0dR7HZ0ssOfYI6gq +IcqElYMfsIoTsFy/JDDFzsE0PtO7TtDCGG/XdCBIrbJo3AZmXW2r1Jf2QqRdli+Q +rgO2f/PYIaKg96Zg9YTERn3cg/6Ms3U6Z9H7J0xyP1UP2bKr0UdL7SjcYc6xPxDK +zwux/npLsSbe/9rCbJEFB7Ow9HzBTbp4D7i1k/9e/wZreOMJLbe8WTCC+mY5fYkQ +9F4dLlpKHX/BuF1SU2lA1bXCWuXP86mJVbVrQjx/abg1+F4nF4kCHAQQAQgABgUC +UfCPXQAKCRC/U8abdh2OCiViD/9OGfHH11a7OU81HhNfTF4vHTKnE7J0huEehRbm +13c0IYxbFHPODY1+2SXwZPQWLQV+gxThndpav1FxkdCjzd77hBur2L3gsfM+Ivkp +JzU/8stsiriNXb+tdhXjf+GSAS6O1l9sTkD1cPzlEfEib63o1KkVyaXTNTR4ZxHK +7iS09ONBw7LneTSxiwV5J/xfQHgSbhxP6hO/SBCYEnu2tFXYEtpEDjLRWh0i9LXb +I2DvyJEJ0i9jbLN2YRBjNjVoVpl/YLFT0J+Xqx+47n3/jOo3DppvSLhG+U62Y873 +01MlmxhPoifTSQ1SRLEAbFQTKb9PPV0h+RW5k28he8qrA2mIxOO2LQuHqiLP20mG +I/hMZJ1G2lj5TO7QbVYDIG/nbmJIF/+sypdGOU0G8F4QAMjX5OpQ6uEAf16KU5Dj +AYbzvzwMfvLijdMgScVwyRQTHjj5mnH7Gv21fNm62OWijP8nPOXY2mXiN7wpWlpT +Q5ofkM8In/HYUZof9bRqlYLR6MVd7PpFFR09Yeur4e6nykYRpUjP6BY0iONrRCaR +fA7vriIXmV2SNc+DZX9teL8saT1Dci6rCFBkZ5KtMjjGElF1pyslSsnD4GY0iALw +BrSiVDLJl9ME/CAZk5m2u01txIoKD2s4xGGTPOZLBJ7bv4BmqxvB8pLG1WVzDgVc +hhnkZokBHAQQAQIABgUCUfhRjwAKCRAInhaWFAaI70Z0B/9RptSPucocuO4ScZ2r ++z1YwNXP5kByy1SYl81BPBwnCy0/SlJLoKf+Nz7I2vVReo6zOfRxG7toEQqkb24S +XWx4trixPE9jRoB+E7j/xAqPtxYFkEOLCIHIrIabgMj/okFTjxS3g81NT8uQjxLg +6fFl11NduzO2aSVaGSWpyRWUwy7INS13oIdmfB9S0Xm/W0kuOZ5kBdG0lYD36Hn9 +/3d+L2i43eRGeCul3UFBdcKO1LIWVQETCIInaTG8EB9LeQ4FcmPOXrbp3PtNdMo0 +DgkEMirzkTvQ7HLjZGbZZcMLDSI9yC39nCMwKyoxqYBbFBECJ+yvIHNHWMc9Ns0H +tQFziQEcBBABAgAGBQJR+FYoAAoJEHGogoJzqpZGkDUH/1Nr/mlbl9OH8z6TpPeB +L/wSYJGmYyR2sLA67fZa/kJOGD7Bk2oAn7jaWo1nODG6uR4AqxjvaFctLNLzx/ne +LAw6Y4uxaDgsZ4KVmd4hbGVNY7VRBbPGST5fsU3auRv6w25dPmTo+GTKeBFwhi1R +loYleQhgVEDa+gXovdfMHWdm7RJxtieL7OS0wXH/aRC5MUcmhOoitSHSASJo3ozr +kjr49l1nQKa9vZSMo3G7inbyZGrw8Wjjp/3xKMrqCpq/YtnHuB8lg/SuO1wU3rHF +RJON/voLhB8u+D5+0k9rGZOGFBrxWATsGRY/hNYQWkfTpV7R+9NtXa8lv0yerG4B +Ui2IYgQQEQgACgUCUfhOhgMFATwACgkQg5k4nX1Sv1vulQD/W6nAmqWNNPgvUWhL +MsIAQ/ANhRkC/eSuIEzp/kX5zXQA/jiAL6aHkdWqJMNtPf2W8N+XAI8q/BLVRaiU +ZvAB7viniQIcBBABAgAGBQJSLk7TAAoJENsiGmkAAAARHDUQAItmAjp9Nx3Y/FT1 +Pa9XQe/5gP7omK2wIKYgtzpwX6MP50KQcIlVqUDUX+icsHA1DC3P9GukBN10JG05 +GBiT24Ae+S2+c9SAXKh2M1R1BR87aVObOjtC/POPerFJ+bMgCYE+oK5pgVZ9InKF +ibabmfggTezbpHqKKUHgGC/d2YfcgzmwvOZEffxLs1BJV50JeBSDrh9TOLIu1//o +p31RInYJe6AoVrgIQazLjbmxYa5zsqPLBT1FUmH3a1aOTaZg73XEWsS0b2G2XfEQ +1hITiem88B25eojdEOL7R6yycSNp0KsgVu7NNTd1p+Mub3B54cn0dUsbve0giWD5 +8AFYaPmqCZS97sFb57m2wA0C/+HBWNuOs0fyfP/UE31IDQgvz9YHn63WrHLAkQlW +ca2/6UP+sqWuP15Pqai2Z+PlvkNAeyrmbwhDeI8YVmkBR/RJ+Oc5Tt9m5ZHvpFCd +fNT4Mny+WE+Tq5yT493zJ4iAWDejt3cvYYk07kJdp+ygJ5QL8K3qlvznytb2cYbQ +oD88htEu2dkpzP6zqaxquxCQy1Kkk+NuNpJWwz0e/+YCu7mJp7loAtDPFDytZ/Xh +lef+KBo6YscA1drmnNj53Us8QHjYOaO0iiQL8pFnAjK6fKZyvRm7RD64PAmxWzIP +eDmVDyaYWzVAqNuhfkOLWuaJALRuiQIcBBABCAAGBQJSLkqBAAoJEGACM7qeVNxh +w0sQAJecd59z3wG1xzEYJO643Uv1XihfzHXZ4CrhlrQPG1J8cTz6Eyvb2R119X9A +dsaNX2QAcyqSxQSMV7x48q+PT6MTiJ5UE8ZmXdNqBo5gTvPN6wAaQuV8R91YBmSE +vk1PGP5PlMqSTBfe7xy4oAPEwlGNXU8BIRKSMTMEQe5/TF7Ry1kwMXmb56TBuehC +6xXXBo2f2es8oWgbhDBrfkMQI2ALEICrWVxhLso7lV6DBO7hnGeOodefTYLp+tjk +fMhdZZPb2EfP7Z7WbHhebg4bmj97Pj0X3HVdHriDa1KYcDpzrGPiW7kfE4ByJCBv +q63ud65zbo7jStjgUk86z5mlrAudO9zlS9ygrhwWZck7GNs3l5MPW3rPfY7B8pBy +vjDzBLBoPxRCTxW3xE/DkA7edWA1Z3HLb/b1QjTA2dvX7Q/sEEh5EkNFrYOK+FOD +yj20BAzmvSRVLl+YJH7mxfZ+r9Er1Vk1iX6aTFK0XAqEn0/ajZZl44gh6P2jGj9N +eAzV1CrxMQ6zEfrUu3zftGpJuTONLYL8lEy/YBqJX54K/u/vUe9nUKWxmfZvuPk5 +2R9IQV45opRCxvedrX5NnuzjfLULCKPseuNkNAvzGDHp1ZhCVgszKnJYV3wjmjZe +7MBuwVL4mlb+bzfze5x9iKrebdm/uOQmt9kqJoAeNLK/wzbtiEYEEBECAAYFAlLd +pPUACgkQX1gOwKyEAw8ZvACfWmWLuZDFW6KazJTJPVxoZM0RfJQAmgMf43nzfQB2 +1gLlko7315aOzDptiQIcBBABAgAGBQJS3YBfAAoJEFtb2gcdScw4kHcP/3+ccx+z +kB7okDtOTV+x687cMkLyPGfT4hLfzNnZE0EUbjQA6cOj+VcfmBio4UPG18MIqCJx +j8DDe1TnPmAjUKiHjJrkOywlTCk5BhIDFATi3TvWfajamGmtQk0BrOAauBL9VZVw +gzUEg8DwtZzzcDy65JWtN5DYauXHgZVAz5IxB+ET3WHG7eA2Hzt0KBNMJPqJTDl9 +7E6OtMK9yWAE12s3wbjf+EtcmsH/FHEXhLKjFmOMYX9uvvo8apMgxL++McQW7dw1 +xwad4RSaPNHcRqC1CJrQtM8O4sykJVhIH+BC6mP2sjShtJDp+TZeHgVkmzG7Vums +12fCc0A9q3Serc12sJa98MNPY9Qze+E8Vbbgv4XIPGDJX0FTNfDPZScsrK4AWFHn +RhvM4xJSVI86iIdTHuBnaHQzIWwxtJG+6/yG5iiR/OLX8/nmycGIX4B0hPrn3l2y +ge/qzFQb2czuAKEMRTDqpNEAlF5P6RRrBQWA9/69tL+Pz7mbu0zzkYT1LAZhaGtz +1MdEY30ngIcZ6do8jcImY7l5hb6gDFs7aMU6n6WcqFFafLAqwEYz0iwutd3xIvso +D6tadZGrtzGCY+T+OhiEdZT6/1sY8CMOlUTLkIYer4kkjrLrvaokQjCohqbUXMFz +uXGE0eqeBkNR/cgM1qlFyvdpp3bxj2A0JsoJiQI+BBMBAgAoBQJOh1i2AhsDBQkF +o5qABgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRAP3Wgtl0ynKvl+D/40zsVN +d/MiB47EZO9yEIdBII//9tE3Y6NZ55WY1vPnaZNwy/UFPxxbt1FrS6igqQon7FzE +qaSwNwCx2yyAF3hdLZkPM4LJQe7uva7kzbb9fQRHgJ2zW8ajNi/EPt2zEALY9GIl +P8Ys+K9X7NsNtDlJ5r9OzYC5KmqgKaoJQlnFJwUIEuRiNkV/Bib3FWgubHAanvoo +vjeJr5YVf9uPINYBnydtIcXWz9y+BpUqaIgreJws5ZNBsfLjBozjZlwMkF2x7DWT +KBUl6UyQh4GZG3tq/mxgOYWTFhSLWJ1W7yD0Bv09n0N9ZUJOBxEvJNwvRrslJw3C ++hXDL+VrQfzzjnlIE/wiSpNWTjBN5Hqtd7uubPQu3y/PANAOOXfkAvbBwebeCnYA +4FyLvTwoN5yOTEKwcg3CTPrT3rl6IQXfIkxOlHkuoMJJgo5k/GXWtD74o02YBRoJ +6DnjdofCSUmCIrdXc/ep/z6SSwtOv3A/2B2uAPVxW3xGnMjSCBuSAWZwKY2bo54j +IzO3H5uxshKW3MdT27RO3sRtAA5Y2Rxjm3TgTiU2UoSQcIL+EONbLDl2iZR4o4AX +I0RnOJWTviysMtYNQ9228Hd0SuPEzEwX5ogn34aOpiw8D4a4/O/5ZNhQFXx+2xXM +0YW5vCPQzgUn7/M0cP6HxvWyZa71Zar/WYzRuYkCHAQQAQgABgUCVAFqyAAKCRC6 +nHgGHd2Mmzk6D/4pTjM8VO8KKHZuCPJ2HdFAkOhZBm77c6WEQ3fLYhH/f6BYRBYL +hJ1qPrllPUkJoxYnWAz5WrRRhy4S6ggQMEEyipQlhyy6TlQNAe4wjqGR6xHjRi94 +4F/n1KEsO2Qt9EVu9zmTHLVLJSnerleEsGQEcRB2hLTkUdj32ynxNwUSpTDI62AU +rTdAu7ABBOG7zhYz0o1uWRW0saZ3rvnjPO12Fk4QOC2EgaCj2FW4KsHt1V8Y8DGN +jTZBfyPbqUYBLMqXpyWtCESNd6WL+Gve50cjl+SM2+anYZ7Q5bMg4zPrZ53WuoBq +Edpo4Fxvts1EPFKI8gxurTLJzIkJJd1Aipd+sebTf3d6avK7TA3nCijNh380gcZI +cVIT1xxA7UMcUc+KEdI1HCz+0co1Jzg95u0gcx6ckrR3R/9+o9whTms2Q4PXItPV +XPLVnQOaBsDG1SAEwRnMdMTNUFPcA05H5GL2eKRMhFJDQ/5PyEKUXpkZPJ0k/FW2 +8H6nyofL6QCnAUTmEMio35A9Po8GFwb1rhsq5Hkq1Ee8IxtVr9iRBNTdzR+wUD9N +5b+/Tt/Z83bfRAaImW2XbaQvTlqfZNi6b/n1+tTMmrak/hYDWQHXgJb+V7neNeb8 +UTrVnR3bgT5lGkmkBRtzAIova3XJp8IwN3RQFVavNCmwc4vf3Uik1hMZu4kCHAQT +AQIABgUCUFnCygAKCRACLzbdOe8fIsRND/4gkv9LgBJXpcPzaCr7roIpj4mzIXfL +wlTNNoUv0+j5lY7u+uNGWmfl7P+k0F1Mxz3Qn3/jZlik1cPMO6h9H4Nc5/KUsfYp +oKy/T4tYY1rXIA2rUpbRDQooocqHqz8Mb9pYqAf4PISEF6nlZlRQMhMairYAKcRi +E1OV5Y0sDUhfad9afttvZ7stPY1pzjNcm2SGxR9e2M1HLx/jM75E72GyCg3zRBpC +s7LXU5VZ0Bg9jcvmmuI7Su7h5ZsDXyJZfZ0kR7slrNfVz9/D77GUkwI/0/8Z6gyu +Vr4VmWQLIpS8TGsJfCpEHYFcoTnpgswoyKyzqZVmAcOlzCZSGOmKqgzWLgH1uDRK +ClOf/ip/WNe28E3lK5gUn1AteImCSk4ZRmpBUmZhZkwJoChO8TrGH2zBxD5SqPvs +0lB1tVsaTNb7ch3QLhMKFae43nhes7BKxKEn/yyAbBhc80QWNhX7NXDznvUFBM7H +rdGWZhgB1dfNbPkfPC/W49eIGZMgQH/2JUEITnVxZj+weJxv3GvNyaWfVjAJ0dFm +GgdpUUc8NVnKHOThD4SgyhGhCof9RDT7fWMRVoKqZa9wgfFlZbz4jGoAD9cFCMpr +RpX1ED/ILyMDj+PmDEA6k43ax2nrjZMLed8InqvvA0V/YaoRM55n8adWfgFcZ3SX +/CeZJxkDID6BwIkCHAQQAQoABgUCWJNr/QAKCRBolOr72F5eOQPcD/93rxcg8MpY +d5sjdQMlAlmzgtvsmNNHqqK92vs+Wql42+8QG7V/UKHaN7Y5MKLLEUplamDQS5gj +dH3dVaEHlW7U+5I8c1WzwcBkg1gC+krmJggY8OzNFwFQIUiNXyBrWptA0PX7mw19 +rCRM7qit9y1WforgwI0vTlDobQPzL5sNm6rClXZGUGeESzcWpoMAc6Z1jotR32we +2378CrH0NsuVv/v+2VxqKahljf878az8Yx5QtVOd/yiFzkIBYEOTmJGwz2RccYdc +azPSeao5T6lL0SnKPbRJElDnNWPeWJp6A04tk7ARB5vK/cqVUSbPvMRMffygC36J +swh2Z678a06UbTFT7jvZ3lYewIL/FHMARlSMfO7WagS0MrdGEvLf+1I6YdPkHUcy +dBl3DyKWqTRuf6FxAS+1elHyHE9dKXN5PAhch5Odacd780gFGKyYUsCHCy+WBE02 +WTUXthd51+j7stOSpjObLAdwl2b8rqi2WiV5BMs+5myfXpnY24WCkvVBR57azWgZ +WpOPtj2B8tKBWLrKTpNWP3NZILM+uMbaJbRWj4ArU94Knz/oaeoDK3SGcSi4bjLu +WvWy4ReYx1mtceOYSFraEZ7zn7Y5Si6xT3h7yigbu0A0iSVIWkjmqqdXgBaGUBiN +TksXYGjxVxCCoK69ttVUE9Ue6djxweiHGokCPgQTAQIAKAIbAwYLCQgHAwIGFQgC +CQoLBBYCAwECHgECF4AFAlQAms0FCQsc3hsACgkQD91oLZdMpyqh2Q/+Nj0yek3s +zbawJMVP2RQ6VS404ofePwPHophrujwe3cTWAkqEs+CfjClVlvk96KGkPTvaXOOU +8F7csRn/bXQW7HKrVae/FqAApJU95S9hV5oHc3qeJijrPhcBB9PWa34k7MRxFF1R +qW9f/5jWaoZcojjY8s9O1yU83xur7/aBb8pSVCYjTPYEm4DzrXOrYD/jSHxCpbQV +SlumhWL4OV7KtPmMl6sMvDAdY+9yfIc3q82DlyOs+/dVcsQTyTSPZAZTJw9/3keU +S1PcbP4+qEDCDlEsb+N0ze2AK41upk5hS56I19pCLgKc7F0yakhmfc0S3dXqWfIZ +yVtiLYu1WmeRGx/XEJLk6XeHHkvQyg4nQMLQ/jgfvY20ktyr6e5xUul8Wc07e8bP +D4b45hMP3VjBwNnnaX1VluxLemUZjShXb+Ptz5B9MfWiDWOUZepLE4QmRflc40qf +S6dj4fUp3FrexpyAE+lWNA+lwqgUXOpHMU8pcsNr/1XtdzhE77pAhS1vO1j5dKhc +h5pLJFtYgZmi50SfNm6mZs20966JPKmYG0iSrblMFEM0b6krUFP9SYIb+BalbVXd +zNkT8Y74iaHMf9ZU5rIGMjzCmMQF/n58oCjonGD0DEK9nTeg8pPuL7ToqdY3Uy0w +K9I6IYUOJvM91xvABoi3IwJKF+JL3jNCCmGJAhwEEAEIAAYFAlibXN4ACgkQ+4WQ +t8TKUnlGaw//VgfpQQvZMSDl4/kr3+W18V/samYsrU8e/YZaEHE38AY6cQ6rw/E9 +Fn580OBnb0A8he1Lyw1oP9qOxt8IeoAUnUKCFzd8nDCeTN3lSzIRhnw1quUdNpQP +Y2ynyk8YezWI/n5xuKYMZIyG7mOZOalDfH7nnridXoROkT4Slr5kKyW2L46dEspK +L1MOlZAnrj4Po1ydBETU240Clj7T1WGjEaj3fcKnoJg0rIYooXk2t1zgRFiRoByC ++P1gLBsrK7GM7/NQyacIbY2EiIGHoXwKjsw9HeuAu8oP1yVaObvjmuLeP09Z5uDS +Fk01HbANJeBDZhUkTAB+TU1jFIdVXSD2qCf+RDgQeApQzCxUMDe3OeucR53p+SRc +vOGdGYecrvznjZUg0tjW3Rymy6Cum5oUXP4NWFnox0rrmstDBCLkyp5F/5hK6A85 +y2N222qefQDLzaJanIfi9cdCf8jmd908nSS6bM7qFrQkuZi2COsdX1qT3UegcJE1 +XNI5Tsc87nLjz/FbWPYZ15zqu2lsUxIR60iKsXD62LeweXblN08qxr2rodpSNiOh +U8XO9Z0iR7EuNiCLuituX/l98XHtq9Jdctdj1mw2BZ9Id0Eo9+sZyyM3yQDXwXWq +n/JSFLKcz15F+SRVIjLdjHjeGq6bo+v5bPZO/2viuQ+hVjnu4ArXyviJAhwEEAEI +AAYFAliXedUACgkQux/mh+/bs+zK7RAAwnRBk9be79n1cEcxmYnM6HeVxz87pmeW +LkdT8iJ7nHAJFAwdCoEuVSsaUfotGWpV/yytqB8O06OUOG3Pd/OpfXmpMcLGIO6F +83IVkzqnz2IZ1Z41vgobVI4zeCsO59/irZ3gHVzoc4jOsUhRkCL/Rap07moGi6uf +/IdcvTRVY6p2iac4mWJk8oBeMVT5GhdPiu9rE6MvkDSsyhW99yTwk0da2KGJJ37A +9d/WCMo0mBDEQZFQ8v2HjajMJst4MHY9cMP0M5W3FNUQmpqKYctr0l2Eq3jPekR4 +a/AV0ISPP+GUWGyzlVzLGxswqAIh8dAU46ivFZJ5bBbshIDfJp2hLXVm+NOKhEma +YIZ6oSIU++iSioqTdDqPUfIBQC9laToIW8T0jy4y/eTIY1FSi4nuTPxWFv6EPvP4 +6F0BXwkyNt9lUWEzQkJTAxpWhJ+Vj8bV+YRaTJWSLxC/T+rf08V+blr9/3NbaMt5 +OATODWvJYxBu1mPI0lckaUv5muU4JfK2q0ySRoKmu/f2/lX3gaLbtzhkuFUtsnZo +DuSYMrYsJAL+F3eO0HpBx9VwHdCk80jLVHeoHIbexdBSTH2bRZu8iRnoU8vRckaO +P8s5z4nEmGGeb/YhjCF1Cg8fZz8jv98V/G1lgWPP4l6jHAaFHvPM1NLRoCZTJN2X +ejW4OHHUujyJAjMEEAEIAB0WIQQpXvG2613JprIdPU4LCCQKlvZlcQUCWSsA2gAK +CRALCCQKlvZlcbz7EACRsGz0LOmUBc+iu4bJ9wFgalrAh1hC3bOu5EpYWfofmfPR +LA1VVzLx5jY+PiLl/hhOBDRTDDVWSz0oe4YTN/EHU6c8zkqDj1Qt4K2CA/ZuAk7c +ophcgtYZ01Dh6j6Vq5E1cwEXbgJQaJcnDXRgNg1beY3N8dj7KLlM5mOpB4Y2ZRMk +rmRhzDgeGPPdv20BJoDww/idc46R9O+P63FzxLSD7kA85kTTSSI2S46sqFCt+3Au +uocUaed31fFLz1Ay0xJCAeHKhGPzh1W0EJo6GPi6BiofcPhK15W895qf0lM6tJrF +rK36gKS+sz3Sxntef+TrSt6kfUxQK9ea84HDVUhB/GpLW/XiSig7tvpRxWEZKZlF +zneLsW2JpJ7KOabl7EydT6bRYI9mlsR02dLost4oBNI/wx7c8slN82fhoOLbbhfT +aE9UUqSFJUSqYCbw8xXK0s6NBQtkE4Y7RfCYimlYG6rwITh5Ob35LHojwbI0AMI1 +NeSom+0ZvRYBc1kUTpBvLoJNCQTdt8NbUiwwpEOftpYnmf835L7EczcnrTFZQJQc +6k2lfaeNPBl0qsav7c8K/cFqOjDj0DJlO+18eTRXVJD15zxmPIazyQBjEfvTEAy9 +YIQgGtVo1v4iarXoD1Mb5/6pppMt4LC2PkunQxJQtDPmF9qxy2id+cWMvNC1+4kC +MwQQAQgAHRYhBDWxffV1JXfKDFQc65S/30SErRQvBQJZKwEWAAoJEJS/30SErRQv +qL8P/2tGLSlGEX1pZLUg6Td5rMJx2XREOelnkPymQHpzsgx4hPC5fjeGmUpQnm3E ++ou3DS21ZX95uozKQ/RCU7G3kyppt35CFTFQk3mjbw5wIc5tJ7AWJcDvX1VJiQZ5 +N7nerMX1lTzOvShnUUF6ve9tv83g+0rD1ZLEeQrThpteaHJBqg1Yrm5s2hk1F6q/ +lJb1Eiw22bz81197NR0QkqxorOtkutqvl3vJF7wIzwboXVx1nFKGUN1VBlM9pu36 +ha4Awk+J5U6Xk95/B9Axh8gvk+df09XA5ys/OKUkEHl/u+vm/g4gJVPP4CzmNvbu +gz7cCSe7LMN0vh4SIiGzZ3qR16ShPe0dNxP9NzfaNapOxdRzqG9/aK95KtJJ1nxU +OrIf4RTBRCoWoRa22sjAMM6h3yAli/CasRxKdCN4tFDde3gd9gCE9e1H6Qpn9p8S +HkhIKKhMCDgpkzQ17j3uRwMeKgtt9yyAm5rv6ZOuLo+IOI5rpRCkNG24lHa6YGbB +M7NXkFZTQiodchMLTk/jeXZOqb3HZhjltr0SezX4ThEh9hdeIqiyM9tYpbPgQKQB +2wXvspdvO/+AJ+H5gRQ7JsuT+1Eddan86aphmrzBfxPEUi9mM2Ot17v+IQDSl14g +1j1D7DD/RWhq9FmJHQa50lDudt2VmRiVqIrfqhbvdJfJmLmLiHUEEBYKAB0WIQRx +xLdWILx1cItL2yVMlfqrPrBz7AUCWpXWMwAKCRBMlfqrPrBz7GwnAP9WHczPYpO4 +XlFxFeA4yhPDkAj8h0sZZRiNE+eVPP/QhwEAsnptBai9VxpsqcXm9WatlYg0+wBj +03OUTtDrg6afJASJAjMEEAEIAB0WIQQ+X//Uo8uq39pZOV8b2fcbV9WSuQUCWqHy +DQAKCRAb2fcbV9WSuemiD/sHM0aKGkZdtoQb5t/C+6EG/7OAiIxyq6c1hjBW7BB1 +mju6A49x5jGx4lCmwHCMzTW6vl1b0vqdCAPhBvFN2fEV8avmfKo91C5Kmp7yITCO +q5RkZCdJIIT8PKkorpGFEvaBwyNkDczetvU86imzGlu/Y8raMiwdY4pZU9rhZjad +ncBrKsTeB534mQUQdiB1h4v8RkDF1dkmubv7Akxhr5NIXeVkchbVb+a7ESdzXwhd +TlORbQtKF3QLYJFbyK5i7dcZojNayf5AU8Q3ebGro9NKmgqhRnrVnZDXz70+S1+j +cyPxXlU7tJSxMPbsSb3q6wRDrolocKzwMl/inUuoMIxFWaDpUGCEZlsLtjC32h4X +si8ZhZt+Nzn7d/5gXvdHcG0ljChvwj+93SbP73nJomcZM7TpgsvssWLCpx6E5Bbv +EPvpLM7lQXHbgv7XSAw9Dj0jAeD0Fdmn7joHY4DW3rCqKvZTSn0ByIVE4glmynEs +cFoXrnMm99z2R4pjXzkt4gI3zLnumCqGJBc8l2Co+IC72E67O3PptkisCGDf8b2t +z5TWs3vN2BEV11GBmWcadzGI1oMAbInc2IreziJwr4KHFAccNLu/eWNftoX7t1s4 +ptr7HKuDG1N9jJJHnQEqfS8T82IB6w+M+9DxNIAFP9mq+eCgnxatxhevtMGeoriB +C4kBMwQQAQoAHRYhBCUbDNzwezKtAkIbv79nTIiJEj0pBQJaofbXAAoJEL9nTIiJ +Ej0pM8sH/jybs2TsdD8IHcVC6hha4BPvOZN4QGGTod+ixEfQrltY58Nkqn4uGLff +XzUp+cLBGF7krG4qCDIhu+hz+Gw+P888nbL30gq55bLNr0fogm5ufiiKYA5qAwtz +nwQFCmME0LeKmlDXGILXOMDh2W3//MxlG0A5D4SCOp2fgkTgJ07SSGa0vg+XvK5j +xCqoXhQWQHNkcMgxyzOkMBIJsw8OY0yFb6d9SumKL0JqduNcA83k4YmP7pE18mcf +VnACGoNy/jMTyK9lSl8epCi2Qk3mODHBX/bBiUheFBqPQ5P9ElyMF2vkS72Waujs +yNDfAb7Y7ECsYlp7kLRwyqVCx9meLz2JATMEEAEKAB0WIQQlGwzc8HsyrQJCG7+/ +Z0yIiRI9KQUCWqGxuAAKCRC/Z0yIiRI9KUAzB/4ruOox1vMYBobE/b8LDtiMKOW+ +fNBuuBmtmFz9QxGLNMtCKYVQKWnf5vFlc5rSdO6Epx2xUQUGVUNy1c21Zn795dNd +ab76BrZFSdHbFe4lIlj+oEfQR9gzhPCeOWnZ3RQ8iIf6sTYmcull3pmSw9zIInAe +JeDi94Z/ZU8bP31Z/hkPKkeuubAV4o0JkZqiXTP30RD41IoTeNhncg6N7JoSmIrU +/LMgvCXBeWkl6tWk1fa/hVX12elK6tTS0WQWgU5GvRIiTo4pvtGuA12c34BRvABg +4DrYomZPIDNGFXUrJqBTMhXZKp+s91E/+Fxg8yECOxpahTlNz8uPr1OLMWv5tCNN +YXR0IFR1cm5lciA8bWF0dC50dXJuZXJAaW50ZWwuY29tPokCPwQTAQIAKQIbAwcL +CQgHAwIBBhUIAgkKCwQWAgMBAh4BAheABQJYkWFSBQkNzHEkAAoJEA/daC2XTKcq +GDUQAK0tzSrWZhv6w/WBHIiPqBia70Drw+lCETvZHKJAZW5QenHNUD2uPbmNBdCV +UFvVj85sjCD0m0geTXgxhvYyGCY7MeRs/ofdX6qaFGHEIdZoznT/+ezMGjKYMZWU +wyYXTno/y8yag1HgZtMl80u8u77me7rLsh4w0+q0cDHroJhyJ3aaG0HxlNy0LgKM +cve8wm9oTJnSf/83lmc2reQbis4Gcau7aKNHgus5dZbnu7vQRqp+FrGyeOllLj2f +FUwsyajSApz5MpEs41IG/85/9lbZRXeafifWMR6B8EZc90BEFF3MLURxleoc4ZWF +2r7bacOWhqW58nxLV5rhtTbjTS/GjFDN0tlV6joQhuW4iuqm7qM6aytKqSPxaSa6 ++rigbhemI9utzqcY/jRccjojE+KM2yNeP+UhnLAQWhChNf1BNGW4Cbcv5MdDSNZ2 +NTvJZFlHaj6BemPKaGIJWYeoD415AjbnFydM7MRMxHBJKz8Q/fYtQnmfeYWpqhEk +P+gKCkaluotXvOnjyRzczhLnUulJWlP9kBlZ+19vQXTLDo7UvOFUQjx+BB6/yaN5 +NstvsDQ9JZteGyM1D4lA1zyxdxIOnyrsAVwKKEUoD19k/KnHHfy4KViJiQ9WpDki +Hjmb8kUhRoVz4QQAO4u8ivldJaHklGSyfL8RvNwI5STbzwU4iQIcBBABCAAGBQJR +8I9dAAoJEL9Txpt2HY4KQvMP+wTTdo//9l+oH3ocI3klK+wOB+RGdO8ZpOo45LwY +gcm/InfDs72N3NMg1saS20zbbTBffzD0KRUUo00PDYlxrdFJ92NvRbIzedSm98+N +Vew6B15nSUGVb7pmcUVvP953X5DxVpx16lzRpdsGPq3C2z9V8FlvBHVG8BM6iKHD +BvCLg4ZT4QMIV78k21yY5xXEE7tMvhWFaNH6SMkHFQAOK4kx9i75c+6jfhcpNKuL +MpEKRdlypzdL3ZouSwdn54W49pdcMaosstQBIafMtoTVmUaSGtiTNQmbIFBtGNRK +IIjqHXONO2eoeLoH357HppE05SUNijp5lb+8aQYqx5eQwzpX9rluw+3vma4c7VeB +sq+/VsuFvM14nPnJOZtk3agN0JMRFh445s4hxK4kf9xsIVXYBhRLjOc2yoz20IvX +aOZyf44HJbCoUQgFQIWem6hHshCassXm0/qvf2K/J4NLhfp1Ud5gcHlq4EZLPqX5 +v21kYd+GYUbiBsixc58UoQjslIRAjoyM7mBWHvPoeNG0T/2Ekj00xqvPKihfgdg7 +0GPmIDCtg7KPz4KQH5dwvg84iknHWHhFQYd8tXJXEDWv2pudcWjxP0fY+SVZJwmZ +BlN8BZpHdvch/F5idx4nBTMXn6S30hnLGkE/D6OAUair7h5+G56sQ+AG6mEG9u9J +isHIiQEcBBABAgAGBQJR+FGPAAoJEAieFpYUBojv2twH/1qI+4nmI9VDAGh0XcPK +nYuASG0nci4QiH/Ylf/epYwZGVUMOCAE1vhwXfYgoDq2Dz1aYy5Qg2gc4ZwwqHnQ +W24V1wgu+XdAsg/W5Y0wIoVJFUK2PvQeJ7R8gCgBNl8jHeqP+TLZUPQgArPRhHGw +ntwqhO8ZYnV+6aL/H0X+GmXUKeZ0DFOGf8ji/L73iTDeXftUaKpk213opoZVpHDS +u64TfLsFVdb0nlueXOtflk7PkW2L3qyqH/HPTFwDJfuKHLLx9lcfYLdfM/C6ovaM +Vjq/BxK0AQJaX8WCU2YDWZauotizaXSIMEME+I4KrHnpVufzXDMj6r0ubovNfRWy +7WKJARwEEAECAAYFAlH4VigACgkQcaiCgnOqlkYIEgf/fT8VcGqzB+oOxWUR2wly +oTGXO8VxnCySi/GHyaNLRRoDmzPfSbvYy1dsJyWnd/3HAetIfNP9tP9OEgIgz1uQ +lMas4kImFo5SIHOq0qm4/TJ4WGumq8XAL/8WtCJh0UOkbtp709xba1bjXtjYdbFG +eR6gadya0WsitXYpZjwcBz0shLr2UWhLdXULptAipYInw8FJr1Ns7yDlVIPstUBA +bcaHOYl61VO9kpWAhFEz7OzaCAlvbN1MQBNCuLP+9Dv85CRTQHERrzEPkPHDt6Ds +Yw50n1/dJPAnw+6MAGaNoxNzOPL7Uhr89ooILG1gmsOFgMcvo0jsOuI8IXEAWKA1 +wIhiBBARCAAKBQJR+E6GAwUBPAAKCRCDmTidfVK/W8bPAP9MD9zF/fYKcIhhi7UP +pkDSUXr/GAE0Ga7IULWALexelwEAkh2E5WzGsY1JsuJGTYO+HwxINVfMg4Gv/6nW +svApM9uJAhwEEAECAAYFAlIuTtMACgkQ2yIaaQAAABHTkRAAmMczTHogoKuaTxYN +ryx3SgQ4pxO4gSL6jqUUQZWbkTqQpwqlF+350nJI0lKkTlzvK9c9IV/2GEUZj4WL +tesfmI2PeXbaEeVMTEp1IHFy9oPO8908oh8Tw8vNF7SCeaGUGDt42sHG8qHUNfsd +9kdXt2smGFm7dEgdUNsjzrjFPhRFj/T8+p0ode1KpSz58S/t+Q2LpMnnf4hDJTAX +ECZBAk9hM8N/rWOjs12XPJKlFxnqCsdyuzDov8mjffQmlgnpCgSt2Nq5tcfn+ToZ +KFCwfjb1xwlnsQSUEDJsQLsSt01PT/Ew//lnHuTd7QVRnaemNaSH5P13BL43tPms +pUdQIkpGvC2dmmaiuR+ExwUfxziD0D4eFqqnNZ1cM+G1tFV6yD3OY+vYyroqydkU +w2T6fbAV03aAGCmepOiZacOLAlx6kqVJgkyr+xqM0XKbudRJwt2GP28rsnIvouYR +Hxh/8dmma0y6sxiyE5brUXGBl3GLxFrLpjGqT+5v7zOHjmZLELRFIJMNWPG5Xm2P +2NDmQ/pdWTEsHnfnyd1yB8weqB08YULw170YRRdYbKGkuz9KfCEvLaegNLQte+yM +2nxZjQd0NNywYd/I3Kc4yKJnR/ySd8FMvwmizfl89a4PFSnG37HGvFhGJYZTmHl/ +UqlGM6F4z2E1AGKRZJATi1wHt2qJAhwEEAEIAAYFAlIuSoEACgkQYAIzup5U3GFD +6A/9Hg6MHXkjmm3oUdM5HUF/CXWd47z0ePrcHcI+idP9VtElp6jaDASIqPp6T+W+ +VmnGJOn8jfEYZ777a1wmRk14+ry0wS8v8a3cM+Ihe9u2ZxOzUm2CE9gnyiwqrJ9H +7c1P/CNGyrIGr0QfS7SLzD6mOnWqMGZW8rQ0vVAPZf+QQe+cVJqOBs6PTTL4eFIN +lqyIoEtfysGP9dp1NXVpxb8RAWaApqBJ+dT00q5RCIxh7CjcuhjdGKFH1/oV0YhG +cF0GHF4HZr7fnRFDroSC/0dHY1ubpLyJQynilTmi0B54y3ugK01XluyG/hRvmFEK +7g3jZOmsH2zGp9P3eaViYX00ncAVKx7522VLu/T8Yi8td0DZD4HycW2MF/ms2L7C +zDUm1KNZ4F3tQOKppigC7VnfPxgy+8HeP1KLWi1wlX6H2PJ+xbe5bIU9RojWbgQd +lko4UI+XU9GHugKzX8rfjy3F5CJg4SCItKnKTZiP52c+bunoqTMV4LE8Y0qFsSCP +cDp11JsT2bjMFhhu6RUyb96E8218KyLo50q+sEIOGUiSn+HkaM/5O3TInCYCA/D3 +4B0Y45UtFc/p3evzn0g+ag8rWsTIzZpeD0jm9xsVKFhXT/eHqtBR6qt5ptuNLLsW +4gJqyJLOVsqjOCCPO6gi/Y5Gtr5eVwwUHk1STd8s8R2ZBk6IRgQQEQIABgUCUt2k +9QAKCRBfWA7ArIQDD9pwAKCLCcheD+w3jbjmliYU/uRPpt0xiwCglPnOqK9b/a43 +JCFP0g2VnsatpcmJAhwEEAECAAYFAlLdgF8ACgkQW1vaBx1JzDiJ3g//YuDD7naw +NbbgemztItdz4jQf2vV6DZfht3GalpJKGFYJtrL0TvE0S0//aEXtnXvGh/DJYBM6 +VPlZfuFezjt79itVrfRioyFxKtWDpRgs5AZF5R87sVcsKx+akoLRBk53FflccxuW +j9c4/t3m28sAEoYbRLUyBN1pwiudVWfOdV7jk08k6TJHih0osJHpFAUqIvYC8SNc +Xk95RoxS4ulFH1W2HwEhwSfoG1fwLT2skeKRuUJg7/ZNzcJBM17Tvlcvv2CkrDeF +hr8aBwg8x/I7ABvAyu9cqvfQuE32evYE6uEp2VmiyEBS9Ev1CUuS8W85M73jThfT +/vViabmhk00AXH/KVBj79yiy7Lq77BZsLdwomJthfG5XIJ2Rm7sVBSr3c8Kafz4n +okxSaY7GFMAHVTZkyWxfcmPfJmtdaoixZzOdaXXCY1h9TncCtFQ5y4ZP1XZ/hySe +PSdtcAYp8YJkqXUgsCOaiiqPDBJy4vzdL4ZjoBQU6RphMdJvOYSBzfwwFpYnY5H1 +7jc0+x8Pbze+akx+0Q2vdkD+ckLh7YQuEvL6S/IMMne37rMd3cmc/H9yvrDs3fWr +dv4XPL40ebjEGULg+iiEZlDQPgoW0Q23Dq8Ki7Ts3qI0maZqcDWRi59Se0b9LyxG +Ee7yv7BvgzyV4YTNrqTaYG2GqlT7oO1vADyJAhwEEAEIAAYFAlL9Q0UACgkQN/mf +aMr5kut2jBAAk4QxChQpeWVKVoXU2kYUDJgEWSqDt0rAdW/d3IZlh1wvef22zrjU +gPU36cRHdRSoUP82/0hpWdAzEX3OHiTE8i30lTx7ABrXUo4rMDvQR1jKTLC7RASN +KoTIrFnP2+GCs//sqFV5DbjklT/pPUqdbBmtOtriaENf7keHFQ50ns5HieyfGuSd +H3bnkIHtQfDpr3FYm1d2FWwFY6VwdPUNhLOw2sKE5CbDqZIxQygjAkxcq8Y63ENh +Q1uiPM4m1De9l3OQFnPhM2CTHllPKRd5CxLel0OPZERPmuQ6sp3CSf/oq8cbx3VY +rBp34IFGcrsM9Wwh2HtLe9ZgErypmKgpxodSfulxKT4z3xePvIM43QG+CLONaw5G +Cd1uFbPf0/BNQ8s9J96yG7z2Zw/akLLD9OsEaBgoBB+FMYvflcLfKW+naFDzccwN +z1sAooIuXJU2nPmfLloiNORXYUFKQ3DsTwDc7dMD5XB7+Hp15Oyl93biayVT6pwK +5stgOEtul8Tl8nlBTwvJ6gTsEAzQ5ms1XnswCKMv+s+eN21y2TLLfVVwLzf5WZ5X +5aoxKZR/Qlsat6ToALn797I9rluxLyaPrG6lThCa/WH0HRaOMFLWjx7LrgPk+EiN +O4+HkA7CgvebqCsqT5Sf0uzNzd4lMVCp96AuX/dNLV/BLbrqxG1T7qeJAj8EEwEC +ACkFAlFX4hkCGwMFCQWjmoAHCwkIBwMCAQYVCAIJCgsEFgIDAQIeAQIXgAAKCRAP +3Wgtl0ynKltDEACQmlwmtgKWc4euduw5Z4MfADtpXGgQAiU1I0F5Z3aQBaXS/Q3B +aROq7SsQbkqej9X4StB0sHhBNAalu7ahiNkNSZ0sHbsxVe/0rvO2gTRa7KquKIXv +EstipXCBvOSXbJEidrAviX3Yr/TUV+3cZCPhqZfIumH734V06F0nOYwUuIR4Lr8V +ha0auWWiwagvbapzj9EOj39QTpyUVHQ9i7Qpnf3VsxM4Eo+DRKaBIwOvyGH/83is +vEdIA0OL9tON+a4TYkG96xs2RXumsEjCSpbxrp6dGQb3XvdMpVDUpL2CmZeLtWe+ +Dbrc5ZGpWvjsFnRmUiu1zdZWKDskA75mcjkoEqTzYeKISCbqYiHZsOYEMx816SR+ +F4QryMmLPp2FocbSeRvS07CLJLRNQhMj0Ng9+wC5JJLqFoMCPmvEcc+mbebGrs/B +9Z5/R63SqZG2TydaV0nv1wsK9B+WhhbOpT5vmYF2IGRVYF8+JJpIA0CB4liCI0sa +eESBq+SS5yxBCacJBX238wK9dZN1/J02kJoHtWA4R1ZI9uQDYrgW9jOyKf8Cc2r/ +naSqaO2JmtNRrKcmm6q6StoUKLMdEqa7Kbk/0sYCoPKEnxrhwWLMiTLF3GJfbCW+ +R3ft8oNDF3q7sGO4F1zNPUVaDmkfAHkD1bE1Q7PgREg0NJyGWOhHZX+TAokCHAQQ +AQgABgUCVAFqyAAKCRC6nHgGHd2Mm2dkEACZbGOhIarTehZA4DaeT2nP/XcJnigF +2YlnAGJ4mpwZ1IllRb1cn7TedFMCrADNYKD9w7b5B4lpbQro5bczFci+UDzMP987 +YX8GpxlSQ7U5SlFi6obKxxClax58rrhrQmnBjyv5YSgH9kVTYCfekIK2ULHDzFNq +prdAtyaRLilrTQqBpQjbe83DDU2blIFnxHNoDH/IEYbrMwbYCHnUZ2sFG725QmKT +jtY3koBx8fnWyijv1gC7iMuf8IZxCiNupGmcK170L1xzUQJRw8JrYw+QnL8AOwOR +bGEbKQKIBF+lhC+gRt63qa5IyssCjJczKJjTaaMYI9YjBu1ZxAMJbGtZZfuBoDIJ +27rO9XF+HqbcHtqkGyqLpmElF9ssCDwZdCQJ0kVjdgfV2WNlhV1Kw3HUT9Zx8Uyz +AIIPIiXIwKioDjewamQqO8sYkzWkjJDUp8qxkgM/4gX7GEglhLLXhgBIl+dx1WZ7 +eczhkyS8n3CmlFElF5lmxJJBDq2GJiu4L1IH93NGW1VFr4w93YcEzXtUiZMv0Lf8 +BnuTv75PgQElUu2iM7FNg4Tnigiyr9cMHeO9P6SuXxFdKMZkRkEIPdKQgZzZLN1j +z/XLOfB2Tp57BjtVu3O2THmSiFlijCHvjaeh5AHm3onDRAe+VuKADqtIOolQPo++ +lNOkgJy19dttRokCHAQQAQoABgUCWJNr/QAKCRBolOr72F5eOUiWEAC7eJncuK3e +sNpCfVvpF+bDn7ygh6R73WtkQG7ZPPVSnxS9QkicKsMig3ZOVgHFatXzZ++2+n7S +D8CM1Z5B1g48agxV8H0R4i5CDwj5HXvrZAd86mRlBHv6JJXy15orQlWcEwK/dFMu +hASudsatS9WiTTvbIUERYDDkpdVSnMAAdo5YQShycar5EFDez+SUe2WSCHWET+td +BmvmTT28awFxRuLdvZb0cZGR8O6+DlcPlVxY3GVWdn9Nnfxg+J5PR6hqJ1y0tlBI +88Mio4mtQLVOqv1GGkf2SLPAUBrkgGly/HWpKWnQXq1C6CJZwztOVdRNTpY9Xnhe +rP6xlngQJQYeSsYPzLeV33DPmDgWgEDeJtF9/2Vi/llvWfNAA/Hy59zJLL7V3yKo +4jubA7JIXaUVcvgTBesHfH9JAJpEYVbJ73mdJe5CfbXxo10qltBmoVqkhtEONUC1 +kVaAX2KXyP0LGkqnW/F5vP7nI167gIRb8zfD+3luvtv2c964Xmw4JmzKXa8z1oCi +rhON7/JlhnsD0yvbF7mGGXQSmftfdpJSh56jUZbtllpJMaC+5z04/mi72iuaXNcl +2VklfUyEMEd0fyg7djqyXOj2+vON5XrPrxQUwkEE5NOvkpMxknCMfyIx5AKZtcdO +bKUyjnvYQpaZE3yO3M4sVc3yJT25F8pHjIkCPwQTAQIAKQIbAwcLCQgHAwIBBhUI +AgkKCwQWAgMBAh4BAheABQJUAJrNBQkLHN4bAAoJEA/daC2XTKcq0q4P/0yfzPep +j/GLqqWEchJ9uZa3UsJFARF+p627iU0GRTVN82EVs2Dwd2q/PRENfVEcu3d4q3tA +SYZ+fcpyPZ9TDyLvEG6l3vWgb21w3vwKt4GlM+Bx00///x8tBGbYi4rbyD6Z0fmf +jnuEYmleM2kGnyVVmZBYUuNqu69SMUl+PQJqfO3PRdglIZlpZ+Xi8/VDwfqIkpvm +npNZR9OqjY/VosHkTcDMGgI7oU5Y+VTHvaTZlpzSmWx46zRXBXFBe3Uw6mv5NyLE +uLnU4vo4v5W32Px5ZesS/lqEvlRhTLjy6eZsSLlaX2ZZR2Zxe4d5s7mihTu1HpNg +igioEud0YlNDwoNzAUcldjPJg8cOPJAix1l6JZGVGTVUgC8m1PWHNIPk33kNkoHd +mxmytxQesWKsxl4Jc41ZjU1VEzggjLW8L5CZwhJ8vQ79ot+OQX4fsvl1AOZV7dnD +Mk5ebbYPqd0fY6yWRp9qNL6Zp8w1KFbgo4pJ6tWfv5dsN2204ssWeDTbSITwu2af +D7UYjhX3uKPah3PBwGXN4Tzv2c/6Wx28CBQm0xguxnQ8DAYos65kVTHOVnGA4Rtc +ixYkOIFOxsDnCsKae+tkpVNZjK81BZpCFNDYeijflcVJVEm6zPWWpPm31C/KXgKo +kQKl5wVfrsJf9nrkle8jsyBqxIc97e/wo8cTiQIcBBABCAAGBQJYm1zpAAoJEPuF +kLfEylJ5hQEP/i4ScuSRTVg7Tn7SDYfqRCNAQOZvBz5l8Q+yaK/RtJbqtoyRw3hq +mfOaaYxUPTjarVGsriQMvZiKZeoXd3zjKHEBeQrhAPpnB/7kBedGXU6UIYfUBclV +opqP5UiNcCL8oGrDg50OA3wRa7dVIbSAmTi0JqerajtcrSQTWOmn5MeeO/XN9qQq +DDlfuRWW4lSofZ/BgmQH9CBcRdHOpqNaGDATLPHyLJzeKlbRTewrZZMWeFvTlHqU +WieG3jhIztE6aYi24QPBozC2i3fWrMdr3lZ/PklxGaZm4FWlbqEQNYj7ZTYuVPkm +GCI2c/VW+nkUmFx776PooTdMqGwt5N52mSGQjIJOJWIQM76NWO6UQ0xdD419Y632 +Hp/OIqR+7LAq6c9xN28ZSYmgyRC0/Mv0ApBmqLi7a9s07G7GmbWMurtt4F5qJpXK +CVIZ75uCdCNwS3NNgFkxzWVsepfs+2IW/Nf8R8Tpusw581jJ1qhEZKGuwKiSzfr0 +/YHkHFNWQO3zpDkwKN/xeO1zUrBYI0SEhK2TjKQFG4OOGSDoone7wMaxvqGwlmgC +5Mj8DtvnjPDNArEyXgZACgKU9ZO2htLPKaxNKOUza/5CgmXgwvNq9On1KdKUoVTZ +kDkXSaLGYaOE1ziI1x2BTAyrAzQNVeG/mDxOFZdg3C/DVnFJ+GsJXq/miQIcBBAB +CAAGBQJYl3nVAAoJELsf5ofv27PsAnUQAJXWx0SPqRSlfbRQO2TxBiIwNgJrhe9Y +AoN4JzkkHmv3g7+QbbwGMEiDoQs66h9NER0hqonUxeWvk0BHvssLP2GJB/aFnoFp +/F8bsDphTeIm9DU1vYcGNWkDA+7RgiEpI8gtN9nSmZPdWP/vxxCnkFzZe9YdELbr +HR8KjHCyBzFAmIavk78xdaZZWTFAQIBW5kz5cO4R1lndxALL4HC/44YBspzFzWoS +gY5nDewp+mGwT0ssQn8sipYcpjY/HSS3GHs3tv8Yjf20opvaGokuNiPm7ZbGR59w +ci//wQx1J02VNCT+r3f8Q9ExFY+/MUUM4KCNW85J1xZdqQHnzyQf8BxpEqM9Cevr +MmnjyCwOD0s807zZZ74EcM7W7miV14AyvafZlgF/b4KH6Vyq0u9mB4GBlTzgSghx +qZdCasitf2stUAziO/fiVrbqC83FcTZdJ+4Wvde4u0ajkWRqoMhDoDdgX6JDVnG5 +84w+/gFO0Zl+c2K5u7s1DHCI3X3d+TLpUGVhpQJq4nLbh68s25rsR9DIh9hdi2Mn +fLx21r3Uv+wUgK1uAnTLwhvAHZ0ciiH4wf0S24WvmKaOWuedSZcRsPRf0Z0uk6nG +MNaHxNOnUAM7b4CdgZRLMyQBM50uIO2/kgo8f7YaDuirXw5lmdIisJpCHLWmXybv +GM6ApPfwO5o1iQIzBBABCAAdFiEEKV7xtutdyaayHT1OCwgkCpb2ZXEFAlkrANoA +CgkQCwgkCpb2ZXHe/g/+LR8j7vP1dZQ6DWgxgMWLr81LAuYGlIfduXZJBrpxlGTR +C3w6B9qLys7vJ3cBjo2HZIovUdlvODP5PpMIcMUfajC1iavHuAlo3DiKeTqeG6RU +hYccKejXBcM+fd9RJp5qCycVim+ZAHx+SJviuz+cEd+JeI8hxq3cLw+WDl8Qr276 +lzIMznijxbf4Wh0TrLmcIThC+cDJQ0vxsyVKGqRU7I0GnO3U/Yr89YROyAfX8uF1 +Q7ooMTa9Eh4UQtcoQBZnvx6dQY9FqdW+ntdCM7pc9FB+Abk68A0xV7lJqL7B2Tqb +4bJ1uSyhPuGWfrURdwpNgwz8gIxLe89HmHjMoksWYDWQaILSzWSIBPZlBAERcYpL +Fn7XMD2LD84GuBFPQSidMcjEnIhQlYO2rJlJk2xGZ6wIWiGRZc3RKbQFdj8hU26S +8M6AMeTRx8Zdi81e9Pv/kp5xDtLBLZl5P8Rwe08RMw0n1izF9iUdzbrVCCMPqUOA +qUY5u/apet9XlpE768rx4y7L0s70G7sx60GxHA7p3cdqUjbj6LbiYskp+ozwMK3Y +oCLCfuYzJzfSuo1+K5VcHDhpgTMq3CyDHbN3oX79xA/Et4vNEbpFO9HXEJdVRA5T +R7r5ByvskStAye0Bi0rJZCbbfXmT6tOqqm8buODRNxpHl1cTqcDFDGNxJVG5LHKJ +AjMEEAEIAB0WIQQ1sX31dSV3ygxUHOuUv99EhK0ULwUCWSsBFgAKCRCUv99EhK0U +L0/gEACFOlNTpvRmoyHfGpNeqBgMse5vjQpLXip2yZULd9kFihBtiWJy3IviWj9E +IjT5YOB6WMRuV99L/cOinabfgLNxlw7IVcWZqAK6Qj8mq9+84qbx62v1kqOzX+ts +xflFuEGLRjdETMVMUjjb25Jxl+ycS+cYVuupUvaowfTj6/FBZfvUoql0TRxQccuw +0u/gyOYQ+T4L61GwMO5LMMshVMF7go3z5/1fhOCiFH4WqotLm7PPxSdhUCty33IO +9XC4uVKsr93n5F0iLuuzR/qf15H2Rv0VJXnsrJOGFSeKU+pk+ryiaxhTmdLydijX +Q8VVAFMeBopUtF7HpjSpkoFHHIc70u/KGJCjFbLG49Z/j6s84BdrjLgoNpNnnIiC +YmBvP1edKGQhUril/Icxp2YX7CSk9zLiLuF0IF/6jcxSHzwH0B6H0IYyVu0jqVzD +6QgoqaM02MjXM1XzHonUJKxAX0LReClYFre6kdRUFXM+z3sIKabYUGdWH8hnD+tz +X4Y8bcb5Ff8TC5Dyp3NcEFiV79/4mMJmCzLGzOJDdUDqLo7Ebf6DBwQU7t8k3dkX +BAJSNhImUHZ+DEFHBj7bihArVGM+qWIvZqZgK4z+L+kvCXhhtvrsTVKdaTdDGNj2 +z/sHhCjqj0ZTb7eEnHQmWyuQSN2vLcTOnTyBCQeH0LVbEYAeUYh1BBAWCgAdFiEE +ccS3ViC8dXCLS9slTJX6qz6wc+wFAlqV1jMACgkQTJX6qz6wc+zLnQEAg23sZ7Kg +GLy9eWtPZcWb3CS2Ee8ihPspb9JaSpj3kDwA/iikr5BeNGysscMyBybt9tGtB0jd +SwEYoYneuryqvIUBiQIzBBABCAAdFiEEPl//1KPLqt/aWTlfG9n3G1fVkrkFAlqh +8g0ACgkQG9n3G1fVkrlqvA//ainEXzHlv5TYd0UMaH8TULEL/R9GZtw4rafZOdD4 +js5sp+plQxfKAzO63nIVRVaYWwtqV7H8IzefEZ/WjGwLcl7bAR03Hc3q6SKfHORj +J52I6txNIvJlSli7/lgL5olqMRTArcV+kbnruOkdowEEpb68ohZteAt7CuUhM3lN +Z+FUwCelIpmAcWtBZM0tnU8Tpxul1YHJU+V6CIqzjT8Ye0gA30GUEmHYW+4gak8D +F7sZYf110qBkbPUHi2QvqHaPjLLG7Dqf3K3S9JbgjOSNwDOZKTskqFy8de7skg/O +DhMSQTygBC+mRnjVACbnrqg/XvLcHhOxTjsqQ1T9vt46Y2LtR8UkFeJNh7sRlxdZ +cvh1s/Gw5yUzb0q99fJw36T3W71xmp+W1odhzcTqWGdLGExabptsSpeL6jjTroUI +D95Yd7VHWuGQUd+ztFxWFZYHEykN96cHnd4gG01WWq3/YNR5E8IycMvNIPyGmCd7 +72nY/SZtXEI336tZdqkh2hWSehIGYxnp1c3CZozbnCpqAqETuaw47/A6+isc2BvG +ekdTEESeP4PCTViCkOanTpWj6r4L7IWsqThj7KbabGPDWOpQnQRIQIFujJo3T0VH +A8byRx1nZrIdfT9ZVjRioEB/6mqIsxgux/yhy7D3roUqE6/Jr9PK4AXIFXTakuq3 +/oeJATMEEAEKAB0WIQQlGwzc8HsyrQJCG7+/Z0yIiRI9KQUCWqH21wAKCRC/Z0yI +iRI9KR+pCACcMPd2A2OQIADKrgTRbdcQpAKPPvtrolLnCA1tNM6c6AavyVYygd2/ +ZoIMFGvrXsIlRO0VQ0Cp2winKXEakeKCU4DjUF6/uFLrLX9BsBVwWAeZuMcc++ao +9ean7HMmby4lOJ7Rgk4A89HQtV456hQBQFxqHJS9wynT3WKaYdBTazctzbpaq4h2 +Iw39PM2YZotsXwWV3EHCqXWf5w7IVTaDNRM0ZfccmWg9Btnc64qwb4LKo+Y7Dr6S +W2nC572u4F+L6ggtWZUo2ShM5jpC05ZN/CuNTW1AWgLzAUXi6nWRfnZ0VQ1PVbNW +0r2KTqarWQwPgSuHUDI/2cDTbQ6m1gwHiQEzBBABCgAdFiEEJRsM3PB7Mq0CQhu/ +v2dMiIkSPSkFAlqhsbkACgkQv2dMiIkSPSlcwAgAo3jIcv5oo5NtyV/Lps3zKfFx +Vkoxt4pHut8yu7xWwH4pz10K+CgN8hrH8E6iYyGJjvZc4rArY1r7Hau983/O4EKE +EBlO9bHmWJAGtokne48nwwjh8N7DyuykQkQvNB9x/qs/F/tDWf+4EEeKjpy6/9O1 +Q2APFYoPGI8T0XWoCdQ7Sz1cVtPL00IWwONYpELDJDrsuJjGxTCxmSwuM3+UfthM +Z093PKXg5gSoJXfQt8N1q63qpJkROVvvJuCLOLhtmReCyZjgc8Xxou3b60yJ6CN7 +Tf+xXkg4Bxp5RAReQieGSmvBmBH+KlCjHKEhIxpg+v2nopM7QrVR8ITU8AhloLQm +TWF0dCBUdXJuZXIgPG1hdHRzdDg4QGZyZWVkZXNrdG9wLm9yZz6JAj8EEwECACkC +GwMHCwkIBwMCAQYVCAIJCgsEFgIDAQIeAQIXgAUCWJFhUgUJDcxxJAAKCRAP3Wgt +l0ynKpeXD/0TzjBnCqYQije2ZHBR15Bpcw4T9rIoOnOGIHBalIAyxk9iPoO610tI +LY3/9bHgcPDdm9L5fqUuRJuhq5JLdrUx1vdcF2FTIkg79iq3jtmUx3ehiTgYEbL0 +i1HwL0q/04X88cWpmcrkV1gS2T1AHt2Ph1HLDZ/TUQIhdwoTo/YpWfitTD+mFEgg +IaZaNaHPJJUohBh7JQRtVF+Jf454dpPcR464I5J7737YI7J/45hzyV5Pt+CrWM0F +l+xNMldOD5kiKvhi9NCWF6z3m8qS2Npr+t89KB8DkmZgNebhKjsC/dTzb5T/OSpC +ZTOJQGz/FEYKAiHCdog4zXD4mc94+/coGqlcKgj0lLgC9ZuI3KWA0ardBwfK0dir +E3VkynAPhLzDDfGVDREVbfvb/+C3VzZ2aHrdDDeYp5hv4n0f+u9kgq0Hsi0g5UOd +n/fbT0pbkIxxNso7QNX8CyZI0ZlsPXBsGI9ElbcF2lYv7jaJGANYH/6COmWUlfPk +fe9DfNchVdk1tekJYrMmoHkAhCiuy1E1YyQfnEwIhZhLQX/KShdKI9e5nBPuweFO +jll3F6b/Ujtx6+GB4mE6tnk+/iV5zgWZScROhWcMfOB8acc20YLfLgY1z8X/ilHg +JVASLda0i7q/2wUKWJsT9EY0xXJGBH6nxdeJmMcVWG9UFZ3l+YtUdIhGBBARAgAG +BQJS3aT1AAoJEF9YDsCshAMPLEgAoJiabPS0yFqsVfEgfuZ/DAqXEL9QAJ41/2kX +KZe+W1GAaBroL233Czwo/IkCPwQTAQIAKQUCUt2CnQIbAwUJBaOagAcLCQgHAwIB +BhUIAgkKCwQWAgMBAh4BAheAAAoJEA/daC2XTKcqpwgQAJU3k89dFSkAa8viW+L1 +qqEt5GfasOw7CZcMrySMLcBCWhbYKRfmFQjbzLLkKBcRMFtIAwKj6Cl3CxYncznK +bfVyfjPqIiLo9+CwgcHQPwmCB+IzRt3TvYcUQz4Xtyq1l+3EbYgCMJE4EnOCzAkX +Aw8UcwhEjnnBEK/rcXazHDoPXWlkHTGmhvbJyY2CZoF5LbVsClGTNRIAB3Elp+Xj +D3dPqqtIzSKFZG4Xmo6atKGZNEv6uoD6WoHgXcOfTslZbwyTyCn6C79nup4Q8DEQ +ueEfgas24j/ta9pVPACznYXGaLuseEtYIkPve4oLeGlPbgqeHjAsdipOkf6X5Hl/ +EGDCZKUnSxDipT4cXdU+1CnmDZsTNCLCnm4daCUCPWlRn7gWyHCcgnfCFNXhDoIP +Gvugtdwf4Uxx4xLCraAdWBismjiglBd1LMJoXKFh9U9mLuUGRp2dqu6o9R3qIKjx +S5e//K2DqOgs/9p6YKUL4qJjXYhCnBL4MsyRcB2KnSgaiEUCkjW928+WsbSfXCOL +X/9MR937Jtu2ikz0LOK5AHeVqgilxZIfEcUWEo981GYHOVwUybK6Xl9RJp4ihhcu +rEd80d3zvTNmGu73kNA00WBELlx48uYDDBqKvW1xBAo/ARjflWH2JkU9OSIZ8bp7 +qQP4+ZsTx7hvxVhRCApyWDZ0iQIcBBABCAAGBQJUAWrIAAoJELqceAYd3Yybtg4P +/iPYgx61q1XzAwTfNzV10ry/mJ8R6mn9ZdMQPrc5jW1+p34297eip7oLo8AOhZwz +SbR60NTg/bNK2xC8yrQQ9S3x7ulRtv53CX0BAzXykGa0TDrfFh++O+K79EMMhTZL +rUFM47ycWJIMugX4P9+vLAcMOfpeBbrMoCU87mxRRQAa8j2YytGfSl/JJorl+Q8z +2Xenc2v5m4mdZTNY+IZd69+K0o928UaUYWgq/TgdEM4Xdw2cycIHTideuA+B03Tq +J6MhucqcM6/WITVU/SH8RPGuva7m/0/nP5n6ApnlIM4X0dU9ZMVX5VLzFQ/h8Tuh +mKrMtjXdmffjxNVtzmQAOHdg/4aNSxoDXWOwa1y9x5RMvtD0be00nbhfpga/b8IC +7PjG6eVrhYJR1YbftsdyqMqTy2TGZrA9xBb6b/icpqPxgjop++QCyeZszPIzmhBJ +uVWK1bSPJgoDWzvYNA6LPzB74sFsy06hhP6ejTfsm5k5ZrZOh1swzScmxKY7Dge9 +KfLLkssmaEj5KVitWI7BV4eBbg+052GIhglmHd45laG1wzCFPgmMkq40htE5Yg3m +e31kh5ck5rDs7wiYWL7b8yDG2qPIlzRYr0IB5+hB3ipR8l4fhoLj0Mb/e5FBwzN6 +zANuOktjpMDrOMn2Oa8Obl+4dXtyxzsvMe2BBg4UUVEfiQIcBBABCgAGBQJYk2v9 +AAoJEGiU6vvYXl45lR8P/2khos9lU+417/UvFTYm9Y1RqOOtyAe15J6gy+ye9VsW +UEeKhlxqac6KYHgo1q16oKlbeLGwmQAl+Wh02k8/zQJKzaI0sntYQFLaWcbKjK3Q +sn8hYa+erzNIfActLPOEIkEPEsA6H5v2BQOSZz652Lqp9KcIwgGQwK6U7viMrHh+ +V9WbZQ3jf5JVxzM7Z63bcltOlxLDVSkc0WmtoXR9xinS536OdcDdPbojRrCSWCJF +5NurgDdeEsvHJcD4YAvUqKLsKB6JYG+UjwyXuDUqiYKxR/sNCE76IPbYd0bg/jq6 +TG6jGwk11BWXSMIGu5LbUDssEPZsKCSmc5AXAQELlyq3+HfoNPGvnyJWvN+SyhJL +f0ZmvBSI2Wv6bQs/JBzqFk4rfplr6q0QwR6jZSMKQHMWy44hjthg3s6IhRmpgcgQ +lQk4DEHEzXxkqp2kFwdbVbQnAKdXLeijCK1kDHbtiW9sUQ9w4o9tfKLHmh0a1kY7 +Cf6Run1mw2E9nR9N3/80XNF1s+ZzdyKvhJ5JlrW/13IkL8osZfiQz85GzVsp5RkA +aQEEq74taVa2YhuYEq8sQ/iFcol0JmEYGqDSBPEDDiQjfoVg+TLOzTXw56Y59cIB +vYi4hM1MFJXdhBBWO60M1BMgTNDMJtEpE9+d4Ibp+vNkJ45hqWLoIPH5bvHEB7Nx +iQI/BBMBAgApAhsDBwsJCAcDAgEGFQgCCQoLBBYCAwECHgECF4AFAlQAms0FCQsc +3hsACgkQD91oLZdMpypR3xAAmHaXoxVfZh9gGHE5A+5pilbPlAUuO1d/G6M0Fhcr +nxLhSjc8pQaLHNXpLSBkmWpXzP0ICAeT0pXCE2xF3CtvqUSMnjxKnfc2At2+HwYF +uCNPHswN8n4rnyxt/b2CElxQXb+88uf3tD2IVW6iiqrxJWtDxs69ta4iXl5GBmZ4 +8CnauEzN2i4s91jhmMwJzVMCHOUJeCKEBrmM6ohIxyeUBHpZbFerEPtv60pV3G8+ +/wBAN0W2boHot9hx+K46DNFyENNYGG1rmtPs4t39Gb5Jqummtj0tuYs7gav2pJxb +WVcDKosyzmqBSCuVS7GtWSp9FJfVrEjF5aP5PhFZsrmUgL0xuaEDyELHtkwuX6fv +Fbf3HGdGyKWihs9DpOKLrmuuu9Vn0jF9SzwM/gbVM1pB68zH7r5owV+Xk40p2a3S +RjRAYGPaEQ7BNeLttbuwdvxmcyMh2OiZU+CJN3eClhdgaOaXF5P53tZPjWENPunW +6ewT0kfMS035ampOx83HEuh8LK8rhrWALsSLb1iMNAchDq0ugpDpkl2Gm2doXQzk +U85h/BhyW6BVjRRKJ0sFtdSes6rZ2rbFhY8fHCPBlJ/UWf7M3zRzICG/xGalxDNi +gkbxOHLQN/v3/huU/8jN3bqzjLcKlUs7JAv9PiId/9ZUtGS1QG1vEjNYEkicCesM +srOJAhwEEAEIAAYFAlibXPQACgkQ+4WQt8TKUnkJnhAApLQmjMLOjzfVohZyxOtm +95AanLNJp6P8xX40t+zzfGeb6t+Jbiz5dFB6BE/0N5SigzgLzZulM3GuVlNbDol6 +K+CkZApqq2Ae508MeeNIIf9EU8nn37xhJ06DTYqhDHbYkGYYkQzBm47zdRRh2AOC +47I3m/8hfF99mkFX+WIqO4YxEjDi+/bvBE9ViTrxCAPPlzapuUqsN2x3sWYrUyxE +3wTL5wUmBZFmeA124hp8zpi/5Ur1sIoFRt6J8PUnDSGktrpNaBZRBwa/wvLjJJWW +cOqTgRMQyBV4wsyiVz1m7qGf9iLYdzvMaBioPs2xsYF6m+fhjT3V6/WqKI7XnMn/ +WtmAGQfrWkuEQKG5vmP/JXv08WnZzOm/dC6gVSGYcs3HdMRiiXT+B2f0sPhuuXIq +jRM/Tfda+HHin73AQ9cUXoydsv665qp1PHvfRVnsWLPLoq4Mlnpv8eRG7rjw0SEI +cF91QPRkVy0CBHAgcrjip5s30+jKXsOCOGIE7HAWNJ7EnmZzvPVaGhxXbxOmEQww +aD+QVhQmZmlTr9xi2Q/urKFxXWYk7PruxBN/pmeXz1e8FI3vsVShlwyk4DmkTe4V +Cr/gNLSIS5j5i4NcfuWmVsj0ui/iNe3nYn8eB7nq5TdNOZo+HjiGz1gckKP/EyBg +JIt3zYsf1G1FhgzARkC9R1mJAhwEEAEIAAYFAliXedYACgkQux/mh+/bs+yuxA/+ +MsqPRRwcc5MpQht4w+Lsg3+VPuSQoH6cqtSPe/fuviexLLlR0yuerXLmzri4P5Zp +p5P0EqSxwQbY2+V0wGF3fuTo2yzGoe+80eBMLhUaQwZo6vdoPSE+OCHtEjxHjmHM +n3coz55kZF+LjFy9bO+h+O7LGwzA56Zrzr00o5y1VC3ciZZv7VvhkXV4lGIlUMGc +/J9Uj3UVHkv827ZOLacfI0dBHB0KIrLY+kQDNPfdRyTevhnZfLYznLBJKX9z2Gav +OktTPf0rrnOJu6K/hRYH7/UturkvTNXNVrALiza3xmaSPbYRAkTpK+O4iQ1WuAgz +jFZloBWypAT+AL2K9ShM8n0jQJSfKDq1qLfKheS9Xsqp2/xyXNYJS8E4hgd1tqk8 +01DSNR9ne6DUAM6twJ9OtW1dO5Bs/T8Cl2lw55GhJW3RcyhT/s+/SytbB2OQkfKA +oIP21+g0qRpP5SZEpZ4UMceSqpUnXf8gS8h6x85640d7tM7X2bByXIr4D4JbSEL0 +2PI2jGzDbxdRDk9G5+nLM12eDB37pQvE9joGzp+9iKNAuP9BcfBythuJTsNENyhu +mYmruuvs5ZwS4srCvUQAXSy3V6u4cxxKiXu6VUSGrFaSowR4H3FhRy5ZH+A+zSs2 +fWSbv5vg1KGuH+zRA67/zTqniwzi4/wtKNkK36z4DN+JAjMEEAEIAB0WIQQpXvG2 +613JprIdPU4LCCQKlvZlcQUCWSsA2gAKCRALCCQKlvZlcVJ2D/0bXANj3LVlRh68 +vVm/45D/PcjEVvlADY2CXGnKGEnAujFv4vO/XOu4/2lolY1/IZT7/CgW/DtnL055 +Vd8FrZbcJYl86UiyncRifWMHoub4U5NND8f6vRlKpVxPs+fPnwfj+DRcNdlx6mr5 +TtAZzebNoTUBKebDalLD4Ac8DO66Mvhu2Nxtfr1oFBFtr3pUkD6DOuwgc5/3x7CN +jc1+e0DgsxIL0/nDp6ubnp3Q79DOqv5sGUqxaJ1qKVDRvQ7BvWoGtSLyPDTC4MCu +6yRRxS/5Q+fmPn8LG/6XSwA541IAwci9N2Th2DnQ/M51usJxym5Ev1DoFZ+dxg2y +MVY9UmTStb007ym0S1WCBQ51cdpBe/ZQwJlOeRCiNqYv0t3gh38dgkCoIDcY0J0Z +xG6ccix5fMvZJwlqyDwM89KDA7PZOncuEaD3SuFkYTy9o/o4GffCXDgjr92t4Duh +B/V8NKznyFK6CZFTohrOjXthgAWCNYlXWASQ0F/HuwIqg2qwwi+6ztIQ9Us44/Fe +grI7EVnWVPyZhJYJrpbV121T5Su07Bvkw1bCx4E+oU28Sv/8Q+9wmZO/myHLLp5j +iQurd0Gex8O5zBQi6P73pLXdSFLdKW3rMVOhndJQVc++Qk6YVP8MCQbqR8BzcOMO +vPmpid5lCidoWiMHtsg3w7NJayMo9YkCMwQQAQgAHRYhBDWxffV1JXfKDFQc65S/ +30SErRQvBQJZKwEWAAoJEJS/30SErRQvzfQP+gJ/xgCrg1jlS7E7FMYtUfFhFJma +w0ggt8NcmGKFSVJVlNOt57HrQXJU7kKjkLC/emEi2Ftwdt8y4fHHJsLE/H9sraRW +oqtKXxycBonDKs/h+BhmV5baQk2eAB4gmLGhewGuQqwnmrJ7NgVJUxffbSdWmCnN +FjkcecofW/pkEmrTeHP3DPt0XnvjdHQ2MqEVTcP+B4TkzZdJZnd4WYBQMw54JyVg +STdtHT3dX2JPTcI3hpWQux3iL8wYBywoIlcS4BCsN67Im2DctcrWR7O0MDoDz/Hi +3913XV+j2dqeNd0ie0Obx4ggupRw8dcftbEgMDDOGY843vkrcpAqyRN0OAArEzEm +zcc16apRVTkopGcwHUDnbBdml/3DwHNvVkG1VJPbu99Fph2idlKBSc3WpUkn7LaN +Buxn+Tz/qJ20V/dOMLmWzs0Qv2qAbrGcprPuezaRybmRMp8cKn31kX3oppresuP6 +Pw5zhmesFKRCYEI0Siptq8F9jCU6VGY6DC4jfdmPUwxHG1l2T2s5RXOC+ihaZVOl +aXygAOlD/vYwxaTo+rUB2/wqe9UYGTBg4vO8Vbt/ez1DUcCH4fzSl2hL2S0cMu20 +E4MGAeAWnXtEQ+2fBUAhSgkjp84ydwKyKI6+DFaLP1lBa1i4YQ0MSx3qp8x0x3MM +LTF10XowTNmhP25KiHUEEBYKAB0WIQRxxLdWILx1cItL2yVMlfqrPrBz7AUCWpXW +MwAKCRBMlfqrPrBz7CnaAQCDqwvz22DDK5pUNubrkttxfEFMhZ0UFQ4pXIDNWe5q +pgEA7al2Xmya46h84fMMeqBeh4RdoE9QqBnWpCw6qdHZAACJAjMEEAEIAB0WIQQ+ +X//Uo8uq39pZOV8b2fcbV9WSuQUCWqHyDQAKCRAb2fcbV9WSuYDUD/9q7SV3LBtk +im5sZWcVNsoutzY5LODF+3/54q06J1uH8SW5HcRBWqtejR9GJho5+gyP5qGg5/BG +o1vMlIEIasNVOKJjeY3JiB13bqt45av+ObrEKENwfZW3yAsswwVdK8zrAroM3GDv +ID33jGp4IU3ads59yoEqCf0yGLGmlYXHZnVoAB/9NK/x+C70+52YuhviI4+bKdFa +/qYusyVTB2wUqGTV17+T/Y6PIqo3DxfZ/7XnuRmcn0kioOKS6SZ6+NgkykZz2jwE +9oGRmD7gyB7rxKFtbzCBevjVDWxwtt1J2dHT+9z5J4onjhNz6mqHrHa5ERstxSey +g+6ZJVZLf/NPZT0sYxAOuzUH+7z0m4NKFCu7i3MZGvQurtWu2A+JxocZG4vItD12 +ggZcGrBtSLciwGplNGef5CawuQY5ALbc07Q8GADu1+UEKeSrKjnfgnFrlJ2dy5Pt +YM1nrWjI7unRMH9X9E36nLUw/DKnrgwujF4eEPe913+sUmhx8Sh5uQMfyykivCCr +5wMNmYVU6yJhOO3axat8EXDtBCrbNV+YjZW/CDX3PA2Aeo4C6XG4AbWqoiZwXxaw +rYU6c5cJwCfIshmkuYqyotGfwJppPQn7jrM/nxO/H8ecEr2Ynrq90MWupOi1nJPP +GDirqXt83zFoIB3BxfpxoYEnpP+7tX19HIkBMwQQAQoAHRYhBCUbDNzwezKtAkIb +v79nTIiJEj0pBQJaofbXAAoJEL9nTIiJEj0p9/4H/j+d1kg2ROl6kwT/kD4fhBpv +WdI2tydLH9vED22gXMCrmtuRhKe0MxJH6Jnljd3sj7M1gdYHlK4QzXQ0QM4HFAYe +H9IiiCpCwwXG5wLduSoJrLntYsK2O2mT2iRzBOT8n7OIoLj6WTvhMfth68cqj4YS +UVk72CAanJMhiua6ZIrcxHrweIWJZL59TU6horGEQheu73SH5ScupC+sNi0YuxUb +C1aBLI/qubDBCKJKu7U06q16TMOl2LZR4mUnfFBMP0KEBqN1D5Se9gv65ypNse8j +cTdhMjNGxM6Xd1ERG9FzNpi8afB89VKGl+XTgrT2jkcBRSv/jiJ/dvPX78p4vtqJ +ATMEEAEKAB0WIQQlGwzc8HsyrQJCG7+/Z0yIiRI9KQUCWqGxuQAKCRC/Z0yIiRI9 +KVewB/wOvysmVadlKIS0XRuunnWhi/TmhnRzXp7LldiZkbq3FhZmFLuiTacWIUDz +LByXkvfbb+RbgUPUpnL9l9tI+buSRkZ9EbStlduUxigXBq5lGTvRK6a+bNU9UFci +ksSdKqdTwHioTZld+1hCqxHlyC+j0Xxam+7PNXKQtQLStU+dEDB/LjqXKatoTzNk +xodK19Wbok0jA8CTJiRUlU6Bx3+yjq8JfQpil78+rVTS47gafTGLjkbxSCzwaH7T +nJUT0OqmXKTcBOa1VmK+4ZcAGHz/5+YkEFvRDB0pPzLb/g/q5vK0mFJLM0d0mmfH +hYjXxc6rjs/pwOBcH0U8jAFN92HNuQINBE6HVy4BEACr5cHqXqhm5Jijkx3IR2NX +JzveQR55TgW4n5VPmm7yks0eM5v0CDHHJ+xNIRrAL6w0p3bQ9r0rFRxmwgyJJdFj +a6/s/GiD+RazpA8iyDvKwja/gsSreHJe76cUNAj/xK6vzOo3hrwcBX28kHDNTPz+ +sVSQJNQAI9LbN/HNg1Ds9dRUJjA8tGcG/N9pn1zupTM5ypFnQJfUKpdbzuHB+V1p ++OVfe56p7INXyCvLE6L9w69vUYluVSrj7kIE9aSM7zwrDfTn/9RG/J8IB0j/cdgq +lB0rKJgUG72aCSMG3lltnM4stv4ypW7AZxv/XeF9iskvYziIJz1C39DaBJOqoIam +XodRHHHoG6ulXSsM+EyN5XF/aRJ1PZ8gHiAHLxES2zVsFiADHeiXK4if0gZJQVBR +J/aJ+EH+3setyqDsQ44+c3tk2Lsu3ama3CKtKpqLDFfDnGmNW8+3hUHZxU+h4Nav +sjnyqbZ57dACTXYES/+9oTFOWtwqxdbLVzILZS389vIvNflCPcJkQRTbrxX307Uv +DOrEcm226tVhydJwuV0nTn400UYxy6MjaCcnVUTC2nFPEUqXUT+6/sWIw6WlJiJr +s4vmWBf2Jvz7e0YioK47V6o8kuxfXZJhO1bd8Yz5+OZcH5JGLpvtehUEzyITVm5q +pxbN1m+6TejP4HPFW185DwARAQABiQIlBBgBAgAPAhsMBQJYkWFZBQkNzHErAAoJ +EA/daC2XTKcqn+QQALSfr+2wMWeWm4lVaujx/YSfrEI+YnwUZOJGL66K/eeiH6nt +Zfh5RUMd6cQS8hrW38lKTwMP3djcFzCTqAd+gACN/rZuMpK6Unq1eGPPs/0XU7p1 +9JGAXooHY7veyv8x/1dlusaBetORXTlXR+M6HlEluWcROQKp4wiZGIYJ4i/HNU83 +LbhXpzK6yvsn5OctrSlA6hJM+oPGsayrS3miQVWQE4hFa62HbtZgPW4sKFVFe0Vr +/4qzTwtCrwW9rTnx3Cs81hG/ObW2lmKFuVPhR3TuqzfLLobC36JsIdUKYdlDlpkx +MJmQYBq10mhCZsinuZ2I8Nv4QaEG0Np2O82xUtHvZDCvOr1VZKjn9UKSVl9gFCZT +LzcbI3qOURNuVWnHKXSuJV0UfRJm8t1c482D8B/XaTjU73CZmp3/mV4U+o+ITFlJ +UrFVbmmzBPMefE+Z1wQxpOET3thEHdXAqCSZaVXcKqMeD0J7ErqWQg6L/Zb6OEFh +gZx5ZhXI61ZPreC/v82aP/d0Dh8yFReQWRzE/tdFX9+XZiYPuRwM6XvUxjSqAtAu +e+eSx/1se9HNr4ORFwd0oVGgn2WcJ485Aoipr2uSZThVlV1w7ubQMEtqFdBCbnK2 +le89kFt74TUjkPdXPmpmKP2e75EZw8mTy5bKDpXETY6+VOP5WMktACUv0Q2duDME +W1bTOBYJKwYBBAHaRw8BAQdAWdZbhOMXjKG6SWXC57x6luZZ+vWgQa8UDN+koldI +eiSJAxQEGAEIACYWIQQ7tjnlb4YfouhlBWkP3Wgtl0ynKgUCW1bTOAIbAgUJAeEz +gADiCRAP3Wgtl0ynKsAWIAQZFggAfRYhBLOWm08O+X1yHmOOvZyCWmYF1Au+BQJb +VtM4XxSAAAAAAC4AKGlzc3Vlci1mcHJAbm90YXRpb25zLm9wZW5wZ3AuZmlmdGho +b3JzZW1hbi5uZXRCMzk2OUI0RjBFRjk3RDcyMUU2MzhFQkQ5QzgyNUE2NjA1RDQw +QkJFAAoJEJyCWmYF1Au+/F4A/Ro3rYgJbK5T3/dt/svCRMCpawu9pEGGQamcxVv7 +BJ6MAP47H/FLryJ+LH8srz7j5SFalYek/04C/svxSgBtIacrDfmoD/4trvSKy85R +IltN1QwYzYe2MKk9PS8r9lV4Mvk0Sw8lYx/fj6mTNDrVlhOzaQ6qNP4cTFsAgzV5 +PzjPJJ+kZela1DlXxYtlITWKOPeAAV+bS1uwSBpLiuGLE/zpXyLIHYERRLNRaYM3 +npVkQcmVdyJtZyHyYMObLkjdxXCyAVkjIi9FfYne6mvV7rcrVJD+aI2dhYmjiCkh +TGmYapd2jFjjgWv62An24+Ao0WPIHtmLiS3y0Ks/tKXXk1QGnVfwOlUv7JH9SuyE +NTMZKKoosLPqmg47L1RkqaCvElG/J/OuMB415fDP9QTBMnGYuq44ux6duzX/hUc1 +5ygvLDB2/yonbTnZzSoz/0UmxT2JM1kvvlKq1kBTpM7IzwEoDhWESS1gyOeta419 +Q5REuu2tuvkA2b2kc3SRE0tEwbjDD1OUGESLGwMeKso7hBVcZSjwSkqWagJctnmi +RnrQc0Fq8USbW2dJ7UHjPVeN/DqJuHAaPAtT4GwqUaDiOZOycoyvA4XiX3fhPqBk +hA2MyZWaHmSwjF00y4gpaA5rS3f6hizyRHEne8YVV8MX2gANnc6Ly1Lw6Mzde3gE +aZmY4JfF4Kvdu509vdBQMO0blJ39lDBiLXVRW/BqNaa0qa3bIyadyC0sAfCG4rHW +WcqEt1xlkIo8UPNOXuZIGk+pUdo49knvJQ== +=sz2Y +-----END PGP PUBLIC KEY BLOCK----- diff --git a/sources b/sources new file mode 100644 index 0000000..ae44c8e --- /dev/null +++ b/sources @@ -0,0 +1,2 @@ +35b9296b8b2fccd4f46480c0afbd7f4f libXaw3d-1.6.3.tar.bz2 +b410b97faa9571b1e15d3320d2fb8e30 libXaw3d-1.6.3.tar.bz2.sig -- cgit v1.2.3