diff --git a/C/flags.c b/C/flags.c
index 5dd2fc60c..08946397f 100644
--- a/C/flags.c
+++ b/C/flags.c
@@ -51,7 +51,9 @@ static Term indexer(Term inp);
 static Term stream(Term inp);
 static bool getenc(Term inp);
 static bool typein(Term inp);
-static bool dqf(Term t2);
+static bool dqs(Term t2);
+static bool bqs(Term t2);
+static bool sqf(Term t2);
 static bool set_error_stream(Term inp);
 static bool set_input_stream(Term inp);
 static bool set_output_stream(Term inp);
@@ -125,7 +127,7 @@ static bool dqf1(ModEntry *new, Term t2 USES_REGS) {
   }
 }
 
-static bool dqf(Term t2) {
+static bool dqs(Term t2) {
   CACHE_REGS
   ModEntry *new = Yap_GetModuleEntry(CurrentModule);
   return dqf1(new, t2 PASS_REGS);
@@ -159,6 +161,48 @@ static bool bqf1(ModEntry *new, Term t2 USES_REGS) {
   }
 }
 
+static bool bqs(Term t2) {
+  CACHE_REGS
+  ModEntry *new = Yap_GetModuleEntry(CurrentModule);
+  return bqf1(new, t2 PASS_REGS);
+}
+
+
+static bool sqf1(ModEntry *new, Term t2 USES_REGS) {
+  new->flags &= ~(SNGQ_CHARS | SNGQ_CODES | SNGQ_ATOM | SNGQ_STRING);
+  if (IsAtomTerm(t2)) {
+    if (t2 == TermString) {
+      new->flags |= SNGQ_STRING;
+      return true;
+    } else if (t2 == TermAtom) {
+      new->flags |= SNGQ_ATOM;
+      return true;
+    } else if (t2 == TermCodes) {
+      new->flags |= SNGQ_CODES;
+      return true;
+    } else if (t2 == TermChars) {
+      new->flags |= SNGQ_CHARS;
+      return true;
+    }
+    Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, t2, "bad option %s for backquoted "
+                                             "string flag, use one string, "
+                                             "atom, codes or chars",
+              RepAtom(AtomOfTerm(t2))->StrOfAE);
+    return false;
+  } else {
+    Yap_Error(TYPE_ERROR_ATOM, t2, "flag  %s is not module-scoped",
+              RepAtom(AtomOfTerm(t2))->StrOfAE);
+    return false;
+  }
+}
+
+
+static bool sqf(Term t2) {
+  CACHE_REGS
+  ModEntry *new = Yap_GetModuleEntry(CurrentModule);
+  return sqf1(new, t2 PASS_REGS);
+}
+ 
 static Term isaccess(Term inp) {
   if (inp == TermReadWrite || inp == TermReadOnly)
     return inp;
@@ -715,9 +759,11 @@ static bool setYapFlagInModule(Term tflag, Term t2, Term mod) {
               "bad option %s for character_escapes flag, use true or false",
               RepAtom(AtomOfTerm(tflag))->StrOfAE);
     return false;
-  } else if (fv->FlagOfVE == BACKQUOTED_STRING_FLAG) {
+  } else if (fv->FlagOfVE == BACK_QUOTES_FLAG) {
     return bqf1(me, t2 PASS_REGS);
-    ;
+  } else if (fv->FlagOfVE == SINGLE_QUOTES_FLAG) {
+    return sqf1(me, t2 PASS_REGS);
+    
   }
   // bad key?
   return false;
@@ -744,7 +790,7 @@ static Term getYapFlagInModule(Term tflag, Term mod) {
   } else if (fv->FlagOfVE == CHARACTER_ESCAPES_FLAG) {
     if (me->flags & M_CHARESCAPE)
       return TermTrue;
-  } else if (fv->FlagOfVE == BACKQUOTED_STRING_FLAG) {
+  } else if (fv->FlagOfVE == BACK_QUOTES_FLAG) {
     if (me->flags & BCKQ_CHARS)
       return TermChars;
     if (me->flags & BCKQ_CODES)
@@ -752,6 +798,14 @@ static Term getYapFlagInModule(Term tflag, Term mod) {
     if (me->flags & BCKQ_ATOM)
       return TermAtom;
     return TermString;
+  } else if (fv->FlagOfVE == SINGLE_QUOTES_FLAG) {
+    if (me->flags & SNGQ_CHARS)
+      return TermChars;
+    if (me->flags & SNGQ_CODES)
+      return TermCodes;
+    if (me->flags & SNGQ_ATOM)
+      return TermAtom;
+    return TermString;
   } else if (fv->FlagOfVE == DOUBLE_QUOTES_FLAG) {
     if (me->flags & DBLQ_CHARS)
       return TermChars;
@@ -777,7 +831,9 @@ static Int cont_yap_flag(USES_REGS1) {
     Term modt = CurrentModule;
     tflag = Yap_StripModule(tflag, &modt);
     while (i != gmax && i != UNKNOWN_FLAG && i != CHARACTER_ESCAPES_FLAG &&
-           i != BACKQUOTED_STRING_FLAG)
+           i != BACK_QUOTES_FLAG &&
+           i != SINGLE_QUOTES_FLAG &&
+           i != DOUBLE_QUOTES_FLAG)
       i++;
     if (i == gmax)
       cut_fail();
@@ -982,13 +1038,13 @@ void Yap_setModuleFlags(ModEntry *new, ModEntry *cme) {
   Atom at = new->AtomOfME;
   if (at == AtomProlog || CurrentModule == PROLOG_MODULE) {
     new->flags =
-        M_SYSTEM | UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | BCKQ_STRING;
+        M_SYSTEM | UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | BCKQ_STRING |SNGQ_ATOM;
     if (at == AtomUser)
-      new->flags = UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | BCKQ_STRING;
+      new->flags = UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | BCKQ_STRING |SNGQ_ATOM;
   } else if (cme && cme->flags && cme != new) {
     new->flags = cme->flags;
   } else {
-    new->flags = (UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | BCKQ_STRING);
+    new->flags = (UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | BCKQ_STRING  |SNGQ_ATOM);
   }
   // printf("cme=%s new=%s flags=%x\n",cme,at->StrOfAE,new->flags);
 }
@@ -1034,7 +1090,9 @@ bool setYapFlag(Term tflag, Term t2) {
     switch (fv->FlagOfVE) {
     case UNKNOWN_FLAG:
     case CHARACTER_ESCAPES_FLAG:
-    case BACKQUOTED_STRING_FLAG:
+    case BACK_QUOTES_FLAG:
+    case DOUBLE_QUOTES_FLAG:
+    case SINGLE_QUOTES_FLAG:
       return setYapFlagInModule(tflag, t2, CurrentModule);
     default:
       tarr = GLOBAL_Flags;
@@ -1420,7 +1478,9 @@ do_prolog_flag_property(Term tflag,
         if (fv->global) {
           if (fv->FlagOfVE == UNKNOWN_FLAG ||
               fv->FlagOfVE == CHARACTER_ESCAPES_FLAG ||
-              fv->FlagOfVE == BACKQUOTED_STRING_FLAG)
+              fv->FlagOfVE == SINGLE_QUOTES_FLAG ||
+              fv->FlagOfVE == DOUBLE_QUOTES_FLAG ||
+              fv->FlagOfVE == BACK_QUOTES_FLAG)
             Yap_unify(TermModule, args[PROLOG_FLAG_PROPERTY_SCOPE].tvalue);
           rc = rc &&
                Yap_unify(TermGlobal, args[PROLOG_FLAG_PROPERTY_SCOPE].tvalue);
@@ -1453,7 +1513,9 @@ static Int cont_prolog_flag_property(USES_REGS1) { /* current_prolog_flag */
       lab = MkAtomTerm(Yap_LookupAtom(local_flags_setup[i - gmax].name));
     } else {
       if (i == UNKNOWN_FLAG || i == CHARACTER_ESCAPES_FLAG ||
-          i == BACKQUOTED_STRING_FLAG) {
+	  i == SINGLE_QUOTES_FLAG ||
+	  i == DOUBLE_QUOTES_FLAG ||
+	  i == BACK_QUOTES_FLAG) {
         Term labs[2];
         labs[0] = MkVarTerm();
         labs[1] = MkAtomTerm(Yap_LookupAtom(global_flags_setup[i].name));
diff --git a/H/YapFlags.h b/H/YapFlags.h
index b9837678a..aaff6428f 100644
--- a/H/YapFlags.h
+++ b/H/YapFlags.h
@@ -162,19 +162,6 @@ static inline Term list_filler(Term inp) {
   return TermZERO;
 }
 
-static Term bqs(Term inp) {
-  if (inp == TermCodes || inp == TermString || inp == TermSymbolChar)
-    return inp;
-
-  if (IsAtomTerm(inp)) {
-    Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, inp,
-              "set_prolog_flag in {codes,string}");
-    return TermZERO;
-  }
-  Yap_Error(TYPE_ERROR_ATOM, inp, "set_prolog_flag in {codes,string}");
-  return TermZERO;
-}
-
 // INLINE_ONLY inline EXTERN  Term isatom( Term inp );
 
 static inline Term isatom(Term inp) {
@@ -342,17 +329,26 @@ static inline Term getSyntaxErrorsFlag(void) {
   return LOCAL_Flags[SYNTAX_ERRORS_FLAG].at;
 }
 
-static inline bool setBackQuotesFlag(Term val) {
-  if (!bqs(val))
-    return false;
-  if (val == TermSymbolChar)
-    val = TermString;
-  GLOBAL_Flags[BACKQUOTED_STRING_FLAG].at = val;
+// used to overwrite singletons quoteFunc flag
+static inline bool setReadTermBackQuotesFlag(Term val) {
+
+  GLOBAL_Flags[BACK_QUOTES_FLAG].at = val;
   return true;
 }
 
-static inline Term getBackQuotesFlag(void) {
-  return GLOBAL_Flags[BACKQUOTED_STRING_FLAG].at;
+static inline Term getReadTermBackQuotesFlag(void) {
+  Term val;
+  unsigned int flags = Yap_GetModuleEntry(CurrentModule)->flags;
+  if (flags & BCKQ_ATOM) {
+    val = TermAtom;
+  } else if (flags & BCKQ_STRING) {
+    val = TermString;
+  } else if (flags & BCKQ_CHARS) {
+    val = TermChars;
+  } else {
+    val = TermCodes;
+  }
+return GLOBAL_Flags[BACK_QUOTES_FLAG].at = val;
 }
 
 static inline Term indexingMode(void) { return GLOBAL_Flags[INDEX_FLAG].at; }
diff --git a/H/YapGFlagInfo.h b/H/YapGFlagInfo.h
index 60697fba0..9e31a98b8 100644
--- a/H/YapGFlagInfo.h
+++ b/H/YapGFlagInfo.h
@@ -90,9 +90,9 @@ running on an Apple machine.
     YAP_FLAG(ARGV_FLAG, "argv", false, argv, "@boot", NULL),
     YAP_FLAG(ARITHMETIC_EXCEPTIONS_FLAG, "arithmetic_exceptions", true,
              booleanFlag, "true", NULL),
-    YAP_FLAG(BACKQUOTED_STRING_FLAG, "backquoted_string", true, isatom,
-             "string", ), /**>
-If  _Value_ is unbound, tell whether a double quoted list of characters
+    YAP_FLAG(BACK_QUOTES_FLAG, "back_quotes", true, isatom,
+             "string", bqs), /**>
+If  _Value_ is unbound, tell whether a back quoted list of characters
 token is converted to a list of atoms, `chars`, to a list of integers,
 `codes`, or to a single atom, `atom`. If  _Value_ is bound, set to
 the corresponding behavior. The default value is `string`
@@ -174,7 +174,7 @@ If `off` (default)  consider the character `$` a control character, if
 `on` consider `$` a lower case character.
 */
     YAP_FLAG(DOUBLE_QUOTES_FLAG, "double_quotes", true, isatom, "codes",
-             dqf), /**< `double_quotes is iso `
+             dqs), /**< `double_quotes is iso `
 
 If  _Value_ is unbound, tell whether a double quoted list of characters
 token is converted to a list of atoms, `chars`, to a list of integers,
@@ -383,6 +383,9 @@ Name of the environment variable used by the system to search for shared
 objects.
 
 				   */
+    YAP_FLAG(SINGLE_QUOTES_FLAG, "single_quotes", true, isatom, "atom",
+             sqf), /**< `single_quoted text is usuallly interpreted as atoms. This flagTerm allows other inerpretations such as strings_contains_strings */ 
+
   YAP_FLAG(SIGNALS_FLAG, "signals", true, booleanFlag, "true",
 	   NULL), /**< `signals`
 
diff --git a/H/YapText.h b/H/YapText.h
index 3d789ab0e..7d5ac5a83 100644
--- a/H/YapText.h
+++ b/H/YapText.h
@@ -440,8 +440,33 @@ static inline seq_type_t mod_to_type(Term mod USES_REGS) {
 }
 
 // string type depends on current module
-static inline seq_type_t mod_to_bqtype(Term mod USES_REGS) {
+static inline seq_type_t mod_to_atype(Term mod USES_REGS) {
 
+  // see pl-incl.h
+  unsigned int flags = Yap_GetModuleEntry(mod)->flags;
+  if (flags & SNGQ_ATOM) {
+    return YAP_STRING_ATOM | YAP_STRING_OUTPUT_TERM;
+  } else if (flags & SNGQ_STRING) {
+    return YAP_STRING_STRING;
+  } else if (flags & SNGQ_CHARS) {
+    return YAP_STRING_ATOMS;
+  }
+  return YAP_STRING_CODES;
+}
+
+// string type depends on current module
+static inline seq_type_t mod_to_bqtype(Term mod USES_REGS) {
+  Term t2;
+  if ((t2 = GLOBAL_Flags[BACK_QUOTES_FLAG].at)) {
+    if (t2 == TermString) {
+    return YAP_STRING_STRING;
+    } else if (t2 == TermAtom) {
+      return YAP_STRING_ATOM | YAP_STRING_OUTPUT_TERM;
+    } else if (t2 == TermCodes) {
+       return YAP_STRING_CODES;
+    }
+    return YAP_STRING_ATOMS;
+  }    
   // see pl-incl.h
   unsigned int flags = Yap_GetModuleEntry(mod)->flags;
   if (flags & BCKQ_ATOM) {
@@ -906,6 +931,21 @@ static inline char *Yap_AtomToUTF8Text(Atom at USES_REGS) {
   return RepAtom(at)->StrOfAE;
 }
 
+static inline Term Yap_CharsToTAQ(const char *s, Term mod,
+				  encoding_t enc USES_REGS) {
+  seq_tv_t inp, out;
+
+  inp.val.c0 = s;
+  inp.type = YAP_STRING_CHARS;
+  inp.mod = mod;
+  inp.enc = enc;
+  out.type = mod_to_atype(mod PASS_REGS);
+  out.val.uc = NULL;
+  if (!Yap_CVT_Text(&inp, &out PASS_REGS))
+    return 0L;
+  return out.val.t;
+}
+
 static inline Term Yap_CharsToTDQ(const char *s, Term mod,
 				  encoding_t enc USES_REGS) {
   seq_tv_t inp, out;
diff --git a/H/Yatom.h b/H/Yatom.h
index 507e9bfbd..a7b58b730 100755
--- a/H/Yatom.h
+++ b/H/Yatom.h
@@ -279,6 +279,11 @@ INLINE_ONLY inline EXTERN bool IsModProperty(int flags) {
 #define UNKNOWN_MASK                                                           \
   (UNKNOWN_ERROR | UNKNOWN_WARNING | UNKNOWN_FAIL | UNKNOWN_FAST_FAIL |        \
    UNKNOWN_ABORT | UNKNOWN_HALT)
+#define SNGQ_CHARS (0x10000)   /* 'ab' --> [a, b] */
+#define SNGQ_ATOM (0x20000)    /* 'ab' --> ab */
+#define SNGQ_STRING (0x40000)  /* 'ab' --> "ab" */
+#define SNGQ_CODES (0x80000)   /* 'ab' --> [0'a, 0'b] */
+#define SNGQ_MASK (BCKQ_CHARS | BCKQ_ATOM | BCKQ_STRING | BCKQ_CODES)
 
 Term Yap_getUnknownModule(ModEntry *m);
 void Yap_setModuleFlags(ModEntry *n, ModEntry *o);
diff --git a/docs/tut.ipynb b/docs/tut.ipynb
index 738ecde94..d9755329b 100644
--- a/docs/tut.ipynb
+++ b/docs/tut.ipynb
@@ -393,29 +393,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
+     "name": "stderr",
      "output_type": "stream",
      "text": [
-      "ERROR! Session/line number was not unique in database. History logging moved to new session 5605\n",
       " % reconsulting jupyter cell...\n",
-      " % reconsulted ??? in module user, 16 msec 0 bytes\n",
+      "charsio:3:0  warning: singleton variable Np in user:main/0.\n",
       "\n",
-      "No (more) answers\n"
+      " % reconsulted memStream in module user, 2 msec 0 bytes\n",
+      "charsio:1:0 error in prolog:'$handle_error'/3: error:  procedure import/1 could not be found,\n",
+      "          goal was prolog:context(user:import([matplotlib|pyplot]),prolog:'$gated_call'/4)\n",
+      "          exception raised from prolog:'$handle_error':3, /Users/vsc/github/yap-6.3/pl/undefined.yap:0:0: \n",
+      "\n",
+      "\n"
      ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAEWCAYAAAB1xKBvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzsnXd8HNXZ77+PerW6ZFu2JUuWbWwwNjJuYLCBYBNIIAlJICSBlJcQwk1PSN7ckIS0t93kvrmk0V8SwCEECBBKKJaxseWGbXBXsy1XNdtqVlnpuX/MLCyyykra2dldne/nM5/dmTlzzm9nz+4z53lOEVXFYDAYDIahiHJbgMFgMBjCA2MwDAaDweAXxmAYDAaDwS+MwTAYDAaDXxiDYTAYDAa/MAbDYDAYDH5hDIbhXUTkYRH5mds6nEBEbhKRfzqUt6v3TUSWisg+t8ofKWLxkIicFJFNfqRXEZlmv4/YuhrKGIMxBhGRMvtHGh+k8grtH3tMMMrrD1V9VFWvdKt8J1HVtao6w7svIgdE5AonyhKRZSJyOEDZXQx8AJikqgsClKfBQYzBGGOISCGwFFDgw66KMYx1CoADqtrmthCDfxiDMfb4LFAOPAzc3M/5bBF5RURaRGSNiBR4T4jIEhHZLCKn7dclPufe91QrIj8WkT/bu2/Yr6dEpFVEFvctVEQWiMgGETklIsdE5B4RibPPiYj8WkTqRKRZRN4RkXP7+3AicouIVNv6a0TkJp/j63zSqYjcLiIVdtqfikixiKy3y3jCp/xlInJYRP5VRBrsz3rTQDdYRK4Rke32Z1kvInMGSfvfIlJrl7lVRJb2uSdb7HMnRORXA+Tx7lO/iPwJmAI8Z9/r7w5wzXft+3xURL7Yx90TLyL/JSKH7HL/ICKJIpIMvAhMtPNuFZGJ/ursU/4XgPuBxXY+P7GP/4uIVIpIk4g8KyIT/cgrVURWi8hv7LryQRHZbX+vR0Tk20PlYfATVTXbGNqASuB2oBToBvJ8zj0MtACXAPHAfwPr7HOZwEngM0AMcKO9n2WfPwBc4ZPXj4E/2+8LsVo0MYPoKgUW2XkXAnuAr9vnVgBbgXRAgHOACf3kkQw0AzPs/QnAbPv9Ld7PYu8r8HdgHDAb6AReA4qANGA3cLOddhngAX5l35dLgTafch4Gfma/nwfUAQuBaCyjfACIH+BzfxrIsj/3t4DjQIJ9bgPwGft9CrBogDyWAYd99t/3XfSTfqVdzmwgCfizfT+m2ed/DTxrf+epwHPAL/srazg6+9HR9zu5DGgALrDv8/8D3ujznXk1Pgz8zL53m7z33z53DFhqv88ALnD7dxcpm2lhjCFE5GIsN8ATqroVqAI+1SfZP1T1DVXtBH6A9QQ4GbgaqFDVP6mqR1UfB/YCHwqENlXdqqrldt4HgD9i/TGDZdhSgZmAqOoeVT02QFa9wLkikqiqx1R11yDF/oeqNttpdgL/VNVqVT2N9SQ9r0/6H6pqp6quAf4BfKKfPG8F/qiqG1W1R1X/B8sYLRrgc/9ZVRvtz/1/sP4ovfGIbmCaiGSraquqlg/yWYbDJ4CHVHWXqrZjGXfAas3Zn+Ebqtqkqi3AL4AbBskvUDpvAh5U1bfs+vd9rPpXOED6icAa4K+q+r/76JklIuNU9aSqvjVCPYY+GIMxtrgZ60+xwd5/jLPdUrXeN6raCjRh/TAnAgf7pD0I5AdCmIhMF5HnReS4iDRj/Ull2zpeB+4BfgvUici9IjKubx5q+cI/CdwGHBORf4jIzEGKPeHz/kw/+yk++yf1/b72g1j3pC8FwLdsd9QpETkFTB4gLSLybRHZI5ab7xRW6ybbPv0FYDqwVywX4DWDfJbhMBGf77nP+xysVsdWH/0v2ccHIlA631fH7PrXyMB17GogEfhDn+MfAz4IHBTLrXqWC9QwMozBGCOISCLWk+Wl9p/yceAbwPkicr5P0sk+16RguSWO2lsB72cKcMR+34b1R+NlvM97f6ZE/j1Wi6VEVccB/4rlfrIyUP2NqpYCs7D+nL7TXyaq+rKqfgDLHbUXuM+Psv0hw/bhe5mCdU/6Ugv8XFXTfbYku0X2Pux4xXexvpcMVU0HTmN/blWtUNUbgVzg34En+2gYiKHu9zFgks/+ZJ/3DVjGcraP/jRV9RrPs/Iehc6+vK+O2Xlk8V4d68t9WMbsBd/yVHWzql5r63kGeGIEWgz9YAzG2OE6oAfrD3euvZ0DrMUKhHv5oIhcbAd8fwqUq2ot8AIwXUQ+JSIxIvJJO6/n7eu2AzeISKyIzAeu98mzHstVVDSIvlSs+EOr3Sr4sveEiFwoIgtFJBbLMHXY+b0PEckTkWvtP49OoLW/dKPgJyISZ//RXwP8tZ809wG32XpFRJJF5GoRSe0nbSpWbKQeiBGRu7BiKt7P82kRyVHVXuCUfdifz3OCwe/1E8DnROQcEUkCfug9YZd1H/BrEcm1deSLyAqfvLNEJM0fnWJ1ELjFD80Aj9u65orV5fsXwEbbRTkQdwD7sIL8ifb3c5OIpKlqN1adCmQdGNMYgzF2uBnLb31IVY97NyxXz03y3hiJx4AfYbmiSrGCsqhqI9af5Lew3ATfBa7xcW/9ECjGCoT/xM4H+9p24OfAm7aboz9//rex4iktWH9Yf/E5N84+dhLLZdEI/Gc/eUQB38R6Um3CioF8uZ90I+G4Xf5R4FHgNlXd2zeRqm4B/gXrvp7E6mRwywB5voz1hLwf63N18H730Epgl4i0YnVAuEFVz/ih9ZfA/7bv9Vk9hFT1ReA3wGpbnzfm0Gm/3uk9brsHX8WOq9if+XGg2s5/4kA67YeOLJ/8B0VVX8WqR3/DagUVM3jsBFVVrJjLYaxODAlYHTMO2Npvw4qNGAKAWPfbYDAMhIgsw+rxNWmotOGIiJyDFfSPV1VPAPO9GPiK7a4yRACmhWEwjEFE5CNijbfIwIo7PBdIYwGgquuMsYgsjMEwGMYmX8IaL1KFFdsKlOvOEMEYl5TBYDAY/MK0MAwGg8HgF67NHuoE2dnZWlhYOKJr29raSE4eSddxZzG6hk+oajO6hofRNXxGom3r1q0NqjrYwMz3CPZcJE5upaWlOlJWr1494mudxOgaPqGqzegaHkbX8BmJNmCLmrmkDAaDwRBIjMEwGAwGg18Yg2EwGAwGvzAGw2AwGAx+YQyGwWAwGPzCMYMhIpPtZRN3i8guEflaP2nEXlaxUkTeFpELfM7dLNbymRUi0t9SogaDwWAIIk6Ow/AA31LVt+ypnbeKyCuqutsnzVVAib0txFoTYaGIZGLNmDofa/79rSLyrKqedFCvwWAwGAbBMYOh1hKax+z3LSKyB2vlLF+DcS3wiN0XuFxE0kVkAta6wa+oahOAiLyCNYXyWYvQRCLtXR7erGzkYGMbFTXddGQf5+KSbFLiI2qcpcFFWjs9rKto4FBTG1U13XTlWHUsKc7UMcPABGUuKXtN3jeAc1W12ef488C/qeo6e/81rLn4lwEJqvoz+/gPgTOq+l/95H0r1nz45OXlla5atWpEGltbW0lJSRk6oYOc8SjPVHaxptZDR8/7z8VFw8X5MXysJI7kWOk/gyASCvdrIEJVWyjoautWnqroYu0RD1196lhCNFw6KYbrSuJIjDF1bCBCVReMTNvy5cu3qup8f9I6/jhhL/P5N+DrvsYiUKjqvcC9APPnz9dly5aNKJ+ysjJGem0g2HboJN9/9C2ON3u4bm4+H58/idkT0lj35jpypp3P37Ye5sm3DvN2Uw+/uXEuS4qzh87UQdy+X4MRqtrc1rWhqpFvP76Nk+09XH/BZD5WOokZ41NZt24dGUXn8eSWwzy9/Qhvn4rhtzddwAVTMlzTCu7fr4EIVV3gvDZHe0nZS2r+DXhUVZ/qJ8kR3r+e8CT72EDHI5JXd5/gxvvKiY2O4m9fXsKvP2kZhLSkWJJjhQVTM/n36+fw969cREZSLDc/uIlnd/S3nLTB0D/P7TjKzQ9uIj0plr9/5SL+/fo5LJiaSVqiVceWFGfzq0/O5akvLyEuJopP3VfOq7tPuC3bEGI42UtKgAeAPar6qwGSPQt81u4ttQg4bcc+XgauFJEMe4GXK+1jEcf6qga+/OhWZuSl8tTtSwZ9qjs3P40nb1vCvCkZfH3VNl7bY37QhqF5bc8JvrZqG3Mnp/O325Zwbn7agGnnTcngqS8vYcb4cXz50a2sr2oYMK1h7OFkC+MirLV1LxOR7fb2QRG5TURus9O8AFRjrR98H3A7gB3s/imw2d7u9gbAI4nKuha+9KetFGYl88jnF5KdEj/kNWlJsTx0y4XMnpjGHY9tY+eR00FQaghXdh45zR2PbWP2xDQe+tyFpCXFDnlNVko8j3x+AVOzk/nSI1upONESBKWGcMAxg6HW8oyiqnNUda69vaCqf1DVP9hpVFW/oqrFqnqeqm7xuf5BVZ1mbw85pdMtOrp7uOOxbcRFR/Hw5xf49UP2khwfw4O3XEhGUixfeewtWjsDurKmIUJo7fRwx2NvkZ4Uy4O3XEjyMHrZpSXG8vDnFhAfG8Udj22jo7tn6IsMEY8Z6e0Sv3hhD3uPt/Bfnzif/PTEYV+fkxrP/71hHrVN7dz1zE4HFBrCnbue2cmhpnb++4Z55KQO3Xrty8T0RP7r4+ez70QLP//HHgcUGsINYzBcYPOBJh7ZcJDPXzSV5TNyR5zPgqmZ3HFZCU9tO8LqfXUBVGgId1bvq+OpbUe447ISFkzNHHE+y2bk8oWLp/Kn8oNsqok4r7BhmBiDEWS6PL384Ol3yE9P5Nsrpo86v68sL6Y4J5kfPrOTM3071hvGJGe6erjr7zspzknmK8uLR53ft66cTn56Ij94+h26PL0BUGgIV4zBCDL/s/4A+0+08pMPzw7IqNr4mGh+dt15HD55ht+XVQZAoSHc+cOaKmqbzvCz684jPiZ61PklxcVw97Wzqahr5eH1NQFQaAhXjMEIIqfbu7lndSWXTs/hill5Act3cXEWV8+ZwH1ra6hr7ghYvobwo66lg/vWVnP1nAksLs4KWL6Xn5PHshk5/HZ1FafbuwOWryG8MAYjiPyurJLmjm6+d9XMgOf9nStn0N3Ty/99rSLgeRvCh/9+tYIuTy/fuXJGwPO+c+VMmju6+Z1pyY5ZjMEIEnUtHTy8/gAfmZvPORPGBTz/wuxkblo4hb9sruVQY3vA8zeEPrVN7azaXMunFk6hMDs54PmfM2EcH5mXz0PrD5iW7BjFGIwgcf/aGrp7evnq5SWOlXH78mlEi/D7NVWOlWEIXX6/popoEb6yfJpjZXz1shI8Pb3cv87EMsYixmAEgZNtXfy5/CAfOn+iI09+XvLGJfDx+ZN4cmstx06fcawcQ+hx/HQHT245zMfnTyJvXIJj5RRmJ/Oh8yfy5/KDnGzrcqwcQ2hiDEYQeHj9Adq7ehx98vNy26XFqFotGsPY4f611fSoctulo+9GOxRfWT6N9q4eHl5/wPGyDKGFMRgO09Hdw6MbD3L5zFym56U6Xt7kzCSunjOBv2yupaXD9GYZC7R2evjL5lqumTOByZlJjpc3PS+Vy2fm8ujGg2bKkDGGMRgO89yOozS0dvH5i6cGrczPXTSV1k4Pf91yOGhlGtzjr1tqaen08LmLglfHPn/xVBpau8w0+2MMYzAcRFV58M0DzMhLZUkA+8QPxdzJ6ZQWZPDw+gP09Dq/oqLBPXp6lYfXH6C0IIO5k9ODVu6S4ixm5KXy4LoagrFqpyE0MAbDQbbVnmLPsWZuXlKItTxI8PjcRYUcamrnjYr6oJZrCC5vVNRzsLGdm5cUBrVcEeFzFxWy93gLWw+eDGrZBvcwBsNBnthcS2JsNB86f0LQy75y1niyU+J4bOOhoJdtCB6PbzxEVnIcK2ePD3rZHzp/IinxMaaOjSGMwXCItk4Pz+04ytVzJpCa4P9aF4EiLiaK60sn8/reOo6fNoOsIpETzR28treOj8+fTFxM8H/KyfExXDdvIs+/c4xT7aaL7VjAySVaHxSROhHpd7EGEfmOz0p8O0WkR0Qy7XMHROQd+9yW/q4Pdf7xzjHaunr45IWTh07sEDcumExPr/LEllrXNBic44nNtfT0KjcucK+OfWpBAV2eXp5664hrGgzBw8nHkoeBlQOdVNX/9K7EB3wfWNNnGdbl9vn5Dmp0jCc211KUk8z8goHX6HaagqxklhRn8dRbh01gMsJQVZ7adoTFRVkUZDk3GHQoZk0cx5xJaTy1zfTIGws4uUTrG4C/K67cCDzulJZgU1nXypaDJ/nE/MlBD3b35bp5+RxobGd77SlXdRgCy47Dp6lpaOMjF+S7LYXr5uaz80izWft7DCBOPnmKSCHwvKqeO0iaJOAwMM3bwhCRGuAkoMAfVfXeQa6/FbgVIC8vr3TVqlUj0tra2kpKSsqIru3LX/Z18fKBbn61LJH0+NHZ5NHqau9Wvra6nUsmxfCZWcNfptMpXU4SqtoCqetPuzt547CH/16eRFLs6B5KRqvrdKfyjbJ2Pjg1luunx41KSyB1OUWo6oKRaVu+fPlWvz05qurYBhQCO4dI80nguT7H8u3XXGAHcIk/5ZWWlupIWb169Yiv9aXL06OlP31Fv/g/mwOSXyB03f7oVp37k5e1y9MzekE2gbpfThCq2gJZx+bd/U+9/dGtAckvELo++8BGXfLL17Snp3f0gmwi/Xt0gpFoA7aon//podBL6gb6uKNU9Yj9Wgc8DSxwQdeI2FDVSENrJ9eXTnJbyrt8dF4+J9u7eWO/GZMRCaytqKeprYuPzHXfHeXloxfkc+TUGTYfMOt+RzKuGgwRSQMuBf7ucyxZRFK974ErgX57WoUiz799lNT4GC6dnuO2lHe5ZHoOGUmxPL3N9GSJBJ7edpSMpFguCaE69oFZeSTFRfPMdlPHIhknu9U+DmwAZojIYRH5gojcJiK3+ST7CPBPVW3zOZYHrBORHcAm4B+q+pJTOgNJl6eXl3Ye5wOz8kiIHf1ayoEiNjqKD50/kVd2n6DZTEgY1rR0dPPPXce5Zs5EV8ZeDERSXAwrZ4/n+bePmQkJIxgne0ndqKoTVDVWVSep6gOq+gdV/YNPmodV9YY+11Wr6vn2NltVf+6UxkDzZmUDzR0erp4T/JHdQ3HdvHw6bYNmCF9e2nmcTk8v180LHXeUl+vm5dPS4WH13jq3pRgcInQeUSKA594+yriEGJaWhI6rwMu8yekUZCXxnJldNKx5dsdRpmQmccGU4E006C9LirPISY03M9hGMMZgBIiO7h5e2XWCFbPHh5SrwIuIcNW5E9hQ1cjpduOWCkdOt3ezoaqRq84b7/r4nv6IiY5ixew8yvbVc6bLuKUikdD7ZwtT1lY00NIZmu4oLyvPHY+nV3lt7wm3pRhGwGt7T+DpVVcmGvSXlbMncKa7x8ySHKEYgxEgnn/7KOlJsVw0LdttKQMyJz+NCWkJJo4Rpry86zjjxyVw/qTQc0d5WViUSVpiLC/vMnUsEjEGIwB0dPfw6u4TrJw9ntjo0L2lUVHCitnjWbO/nvYuj9tyDMOgvcvDmv31rJidR1RU6LmjvMRGR3HFOXm8uvsE3T29bssxBJjQ/XcLI96sbKCtq4erzgtdd5SXK2fn0enpZc0+4zIIJ97YX09Hdy8rzg1dd5SXFbPzaO7wUF7d6LYUQ4AxBiMAvLrnBCnxMSwqynRbypAsKMwkIymWl4zLIKx4aedxMpJiWVAY+nXskuk5JMZGG9dnBGIMxijp7VVe3VPHpdNziI8JncF6AxETHcUHZuXx+p46ujzGZRAOdHl6eW1PHR+YlUdMCLs8vSTERrN8Zg4v7zph1pSPMEK/9oU4bx85TX1LJ1fMynVbit+sPHc8LZ0e1lc1uC3F4Afrq6weeCvDwB3lZcXs8TS0drLtkFnvO5IwBmOUvLr7BNFRwvIZ4WMwlhRnkxIfY3qyhAkv7zpOSnwMS4pDtwdeXy6bmUtcdJRxS0UYxmCMklf3nODCwgzSkwK3DoDTJMRGc+n0HF7bU2dW4gtxVJXXbJdnKM1PNhSpCbEsKs7iNTNNSERhDMYoqG1qZ+/xFq44J89tKcNm+cxc6lo62XW02W0phkHYdbSZupZOls8Mnxasl8tm5FDT0EZNQ9vQiQ1hgTEYo+DVPdaI6Q/MCj+DsWxGDiKYieJCHO/3s2xG6M1PNhSXzbR+F6aORQ7GYIyCV/ecoCQ3hYKsZLelDJvslHjmTErn9X3mxxzKvL6vjvMnpZGdErjldYPFlKwkinOSWW3qWMRgDMYIae7oZmN1E1eEYevCy/IZOWyvPUVja6fbUgz90NTWxfbaU2HpjvKyfEYuG6ubaOs0MwtEAsZgjJB1FQ14epXLw/jHfNnMXFRhjVm6NSRZs78OVcKqB15fLpuZS1dPL29Wmi7ckYCTK+49KCJ1ItLv8qoiskxETovIdnu7y+fcShHZJyKVIvI9pzSOhjX76hmXEMPcyaE7EdxQnDvRcnW8bnzMIcnre+vJTonnvPw0t6WMmPmFmaTExxi3VITgZAvjYWDlEGnWqupce7sbQESigd8CVwGzgBtFZJaDOoeNqrJmfz1LS3LCYuTtQERFCctm5PDG/no8ZqK4kMLT08uafXUsm5ET0pMNDkVcTBQXT8tm9d5604U7AnByidY3gKYRXLoAqLSXau0CVgHXBlTcKNl/opXjzR1cOj38eq705bKZuTR3eHjr0Cm3pRh82FZ7iuYOT1i7o7xcNjOX480d7DnW4rYUwyiJcbn8xSKyAzgKfFtVdwH5QK1PmsPAwoEyEJFbgVsB8vLyKCsrG5GQ1tZWv699scZasS62sYKysqoRlecvw9E1IrqVaIGH/7mF9hn+Dz50XNcoCFVtw9H1131dRAvIib2Ule0LGV0jIa7Tar0+8GI5HyoO/zoWqrogCNpU1bENKAR2DnBuHJBiv/8gUGG/vx643yfdZ4B7/CmvtLRUR8rq1av9Tvup+zboil+vGXFZw2E4ukbKDX8c/ucJhq6REqrahqNr5f99Qz/xh/XOifEhGPfrmt+s1Y/97s1hXRMJ32OwGYk2YIv6+Z/umgNeVZtVtdV+/wIQKyLZwBFgsk/SSfaxkKCt08PmmpNcEgHuKC9Lp2ez93gLdc0dbksxAHUtHew51hxZdawkm221p2jpMOvJhzOuGQwRGS/2SvYissDW0ghsBkpEZKqIxAE3AM+6pbMv5dWNdPX0RkT8wsslJdZnWWe6PoYE3i6o3u8lElhakkNPr7KhyiyqFM442a32cWADMENEDovIF0TkNhG5zU5yPbDTjmH8BrjBbiF5gDuAl4E9wBNqxTZCgjX760mMjWZ+YYbbUgLGrAnjyEyOY12FMRihwNqKBjKSYpk9cZzbUgLGBQXpJMVFm4eSMMexoLeq3jjE+XuAewY49wLwghO6Rsua/fUsKc4Ki8WS/CUqSrhoWjZvVDSgqtgNP4MLqCprKxq4uCS8u9P2JT4mmkVFWaw1DyVhTfgOInCBAw1tHGxs59IwnAhuKJaWZNPQ2sne46bro5vsO9FCfUsnS0vCZ+0Lf1lakk1NQxu1Te1uSzGMEGMwhsFauzm9NIJ8y168f1BrK8w0IW6ydr+3jkWmwQBMKyOMMQZjGKyvbCA/PZHCrCS3pQScCWmJlOSmmB+zy6ytbGBabgoT0hLdlhJwinNSmJCWwLpK81ASrhiD4Se9vcqG6kaWFGdFrI//4pJsNtU00dHd47aUMUlHdw8bqxsjsnUBICIsLclmXUUDPb1mmpBwxBgMP9l9rJlT7d1cNC0yf8xgdePs9PSy+cBIZnQxjJYtB07S6emNqO60fVlakkNzh4e3D5upaMIRYzD8xNs3fklxlstKnGNhUSax0WLcUi6xtrKe2GhhYVGm21Ic46Jp2YiYOEa4YgyGn6yrbKAkN4XccQluS3GMpLgYSgsyzI/ZJdZVNFBakEFSnNtTvDlHZnIc505MM2N+whRjMPyg09PD5gNNEe2O8nLxtGz2HGumqa3LbSljilPtXew+1sxFxZFfxy6als222pO0d5lV+MINYzD8YNuhU3R090a0O8rLYvszllebKRyCyaaaJlRh0RipY909ypYDJ92WYhgmxmD4wfrKBqIEFhZF/o95ziRrCof1VcZlEEw2VDeSEBvFnEnhu7qev1xYmEFMlLDezCsVdhiD4QdvVjUyZ1I6aYmxbktxnNjoKBZMzTSTxAWZ8uomSgsyImrKmYFIioth3pR0NphWbNhhDMYQtHZ62FF7ioumRX7rwsuS4iyq6ts4YaY7Dwqn2rvYe7yZRVPHTh1bXJzNO4dP0WymOw8rjMEYgk01jXh6dUwEI70sLrI+q2llBIeNdvxi8RiIX3hZXJRFr8KmajPmJ5wY1GCIyCQR+baI/F1ENovIGyLyOxG5WkTGhLFZV9FIfEwUFxREznTmQzFr4jjGJcSYOEaQKH83fpHutpSgMW9KOvExUSaOEWYM2OFbRB7CWl/7eeDfgTogAZgOrAR+ICLfU9U3giHULdZXNTC/MIOE2Mj3LXuJjhIWFWUZH3OQ2FDVyPyCTOJixsQzGAAJ9poypo6FF4PV0P+jqleq6m9Udb2qVqrqTlV9SlX/F7AMODrQxSLyoIjUicjOAc7fJCJvi8g7IrJeRM73OXfAPr5dRLaM9MONFu9030vGkDvKy5LiLGqbzpipqB3mZFsXe4+3sCiCR3cPxJJiM+Yn3BjMYFwlIpMGOqmqXapaOcj1D2O1RAaiBrhUVc8Dfgrc2+f8clWdq6rzB8nDUbzN5bEwYK8vi4tNHCMYbKyxfPiLxkCX7b54P7MZ8xM+DGYwJgIbRGStiNwuIsOaEc12VQ0Y0bJbLd6RO+XAgMbJLdZXNpCaEMN5+ZHfN74v0/NSyEqOM3EMhymvbiQxNnpMxS+8zJmURrIZ8xNWiOrA0wyLNY/3JcANwHXADuBx4ClVHXJpNhEpBJ5X1XOHSPdtYKaqftHerwFOAgr8UVX7tj58r70VuBUgLy+vdNWqVUPJ6pfW1lZSUlLed+w7a9qZlBrF1y5wb/6o/nQFi99t72D/yV5+vSzxrCnKhFR1AAAgAElEQVTd3dQ1FKGqrT9dP3zzDOPi4DsXurf+hZv361dbO6hv7+WXS89eYyacvsdQYSTali9fvtVvT46q+rUB0cAKYBvQ7uc1hcDOIdIsB/YAWT7H8u3XXCwjdYk/5ZWWlupIWb169fv2D59s14I7n9cH1laPOM9A0FdXMHm0/KAW3Pm8Vta1nHXOTV1DEara+upqau3Ugjuf13ter3BHkI2b9+veNVVacOfzevz0mbPOhcv3GEqMRBuwRf20A351yxCR84C7gd8CncD3/bJGQ+c7B7gfuFZV33VkquoR+7UOeBpYEIjyhsNG2686Fn3LXrzjAkzXR2fYWOOtY2Mv4O3FW8dMrCw8GNBgiEiJiPxQRHYBjwJtwJWqukhV/3u0BYvIFOAp4DOqut/neLKIpHrfA1cC/fa0cpLy6kbSEmOZOT412EWHDIVZSUxIS2CD8TE7Qnl1E4mx0ZyXP/biF17OmTCOtMRYE8cIEwabeP8lrHjFJ1V12H/YIvI4VtfbbBE5DPwIiAVQ1T8AdwFZwO9s/7hHLT9aHvC0fSwGeExVXxpu+aNlY00TC6ZmEhUVmcux+oOIsLg4i7J99fT26pi+F05QXt3I/MKMMTX+oi/WmJ9MMx4jTBjQYKhqse++iIzzTa+qg47pV9Ubhzj/ReCL/RyvBs4/+4rgcfTUGQ42tvPZxYVuyggJFhdl8dRbR9h3ooVzJoxzW07E0GSPv/jQ+RPdluI6i4uyeHnXCWqb2pmceXbw2xA6DPloIyJfEpHjwNvAVntzbTBdMDC+5fdYYo9BMXGMwLKpxsTIvHjrmIljhD7+tIW/DZyrqoWqOtXeipwW5iYbq5sYlxDDzPHmiTo/PZEpmUlmcFWA2VDlHX8x9sb49KUk1xrzY+pY6OOPwagCxtT8EOXVjSyYmkW08dkDVktrU00Tvb0Dj9kxDI/y6ibmF2YQGz124xdeRKy5y8qrG73d6g0hij+19fvAehH5o4j8xrs5Lcwtjp0+w4HGduOO8mFRURanz3Sz53iz21IigsbWTvadaDHuKB8WFWVy9HQHtU1n3JZiGITBekl5+SPwOvAO0OusHPfZWD125/YZiPfm/Gli9kTjQhktm8bw/FED4Tuv1JQsE/gOVfwxGLGq+k3HlYQIG2saSU2IMT2CfJiYnkhBlhXH+MLFU92WE/aUVzeSFGfiF75My00hOyWODdWNfOLCyW7LMQyAPy6pF0XkVhGZICKZ3s1xZS5RXt3EwqmZJn7Rh0VTs9hY3UiPiWOMGit+kWniFz6ICAtNHCPk8afG3ogdxyDCu9UeP91BTUObcRX0w6LiTJo7POw5ZuIYo+G9+EXEPnONmEVFWRw73cEhswZLyDKkS0pVx4wPwjv+YuFUYzD64r0n5dWNnDsGp3sPFGN5/YuhWGwb0fLqRgqykl1WY+iPweaSuniwC0VknIgMOm15uFFe3URqfAyzJpr4RV/ei2MMOsDfMATe+MVYXGNlKIpzrDiGqWOhy2AtjI+JyH9gzSm1FajHWtN7GtaU5AXAtxxXGEQ2VjeywMQvBmRxURYvvHPMxDFGgTV/lIlf9Ic3jrGhysQxQpUBa62qfgO4BjgGfBxrGdVvAiVYixpdoqqbg6IyCJzs6KXaxC8GZVFRloljjILmTmX/iVYWmzo2IIuLsjje3MHBRhPHCEUGjWHYEwzeZ28Rzb4ma4jJQhOMHJCFPj7maS5rCUf2nuwBzBxlg+E7HmO8y1oMZ2PaxTZ7T/ZY8Qsz/mJAJqQlUphl5pUaKXubekiOizadBgahOCeZ7JR4U8dCFGMwbPY29XDh1ExijG95UBYVZbGxpole42MeNnubekz8YgiseaUyKa9uMnGMEMTUXKCuuYPjbcrCqcZVMBSLi7No6fBwqDniZ4kJKA2tnRxtVRMj84NFdhyjrt0YjFDDn/UwkuylWu+z90tE5Bp/MheRB0WkTkT6XbFPLH4jIpUi8raIXOBz7mYRqbC3m/39QCPB9I33H+94jL1NxmAMh/fmKDMPJUPhXed7T1OPy0oMffGnhfEQ0AkstvePAD/zM/+HgZWDnL8Kq9dVCXAr8HsAe+qRHwELgQXAj0Qkw88yh015dSMJ0TDbjL8YkvFpCUzNTjY/5mHirWNm/MXQFGUnk5Maz15Tx0IOfwxGsar+B9ANoKrtgF8DFVT1DWCwUTjXAo+oRTmQLiITgBXAK6rapKongVcY3PCMivLqRqZnRpv4hZ8sKspk/8keMx5jGGyobmR6hqlj/uBdH2NvU6+JY4QY/sxW2yUiiYACiEgxVosjEOQDtT77h+1jAx0/CxG5Fat1Ql5eHmVlZcMS0NWj0NXBtMyeYV8bDFpbW0NO17gOD2c88KfnXqcwLdptOWcRavfsdKdSWdfOtYUaUrq8hNr9Asjs7uZUp/KXF1YzPjm0jGwo3i8vTmvzx2D8CGu092QReRS4CLjFMUXDRFXvBe4FmD9/vi5btmzYeVx5OZSVlTGSa50mFHWd09zBH99+je6MqSy7JPRW6w21e/b820eBbZw/PjGkdHkJtfsFMLm+lf/ZvQbNmcayBVPclvM+QvF+eXFa25CmW1VfAT6KZSQeB+aralmAyj8C+E5+P8k+NtBxQwiQNy6B8Uli+sr7SXl1IynxMRSMC60n5VCmKDuZtHhhQ5WpY6GEP72kLsCaN+oYcBSYIiLFIuJP62QongU+a/eWWgScVtVjwMvAlSKSYQe7r7SPGUKEmZnRbKppMnEMPyivbuLCwgwzR9kwEBHOyYwy62OEGP488vwOKMdy+9wHbAD+CuwTkSsHu1BEHrfTzxCRwyLyBRG5TURus5O8AFQDlXbet8O7U5L8FNhsb3fbxwwhwszMaFo6Pew6etptKSFNXUsHlXWtpsv2CJiZGU1dSyc1DW1uSzHY+NNKOAp8QVV3AYjILOBu4LvAU8A/B7pQVW8cLGO1Hh2+MsC5B4EH/dBncIGZmdazRnl1I3MmpbusJnTxXSP+ZFXtEKkNvszMtDpUlFc3UZST4rKa0OWN/fUcamrnxiDEevxpYUz3GgsAVd0NzFTVaudkGUKd9IQoinKSzdoFQ+CNX5gxPsMnL0nITTXzSg3F45sO8fuyqqC4PP0xGLtE5Pcicqm9/Q7YLSLx2GMzDGOTRUVZbK5pwtNjRn0PRHl1IxcWZpjxFyPAOx5jg4ljDIiqsrGmKWizbPtTi2/BijF83d6q7WPdWAspGcYoi4qyaOn0sNusj9EvdS0dVNWbNVZGw+LiLOpbOqk2cYx+qahrpamtK2h1zJ81vc8A/8fe+tIacEWGsGHR1PfWxzBxjLPxxi+8cyMZho/v+hjFJo5xFl53XbAW5fKnW22JiDwpIrtFpNq7BUOcIbTJHZdAUU6y6Ss/ABuqG80aK6OkMCuJvHHxJlY2ABurm5iYlsCkjMSglOfv5IO/BzxYLqhHgD87KcoQPiwuymLzgZMmjtEP5dWNZo2VUeKNY5jxGGdjxS8aWVSUhUhwxvj4U5MTVfU1QFT1oKr+GLjaWVmGcGFRURatnR52HTVxDF/qmjuorm8z05kHgEVFVhyjqt7EMXypqm+lobUrqMtK+2MwOkUkCqgQkTtE5COAcSYagPev8214j3KzxkrA8I1jGN5jQ3Xw65g/BuNrQBLwVaAU+DTwWSdFGcKH3NQEinOSzY+5D+UmfhEwCrOSGD8uwdSxPpRXNzIhLYEpmUlBK9Mfg1Goqq2qelhVP6eqHwNCa/pIg6ssMnGMsyivamSBiV8EBLPO99moKhurm1g4NTNo8Qvwz2B8389jhjHK4mIrjrHTxDEAONHcQXWDGX8RSBYVZdHQauIYXqrq22ho7Qx6HRtwHIaIXAV8EMgXkd/4nBqH1WPKYADeW+e7vLqRuZPNeAyv68QYjMDhvZcbqhuZlmtCqBtr3Kljg7UwjgJbgQ771bs9i7WEqsEAQE5qPNNyU4yP2ebd+IWZPypgFJg4xvsor24ib1w8BVnBi1/AIC0MVd0B7BCRP6uqaVEYBmVRUSZPv3UET0/vmPfbb6hqZGFRpln/IoCICIuLs1hbUY+qBtVvH2qoKhuqGrh4WnbQ78OAv2wReUdE3gbeEpG3+25B1GgIAxYVZdHW1TPm4xhHTp3hQGM7i4uz3ZYScSwqyqShtYuq+rE9I1FFnTX+YokLdWywuaSuCZoKQ9jzro+5amzHMbzTpCwx80cFnPfiGE1My011WY17eOuYG3OUDdjCsEd1H1TVg1hxjPPs7Yx9bEhEZKWI7BORShH5Xj/nfy0i2+1tv4ic8jnX43Pu2eF/NEMwyU6Jp8TEMdhQ1Uhmchwz8sbuH5pTTMlMYkKaiWOsr2pgcmYik4M4/sKLP5MPfgLYBHwc+ASwUUSu9+O6aOC3wFXALOBGe7W+d1HVb6jqXFWdC/w/rBX8vJzxnlPVD/v9iQyusagoiy0Hmugeo+MxvL7lRUWZRJn4RcDxziu1cQzPK9XTq5RXNwVtdtq++BOd/AFwoarerKqfBRYAP/TjugVApapWq2oXsAq4dpD0NwKP+5GvIUR5N45xZGyu832wsZ2jpztM/MJBvHGMyrqxGcfYc6yZ02e6XYlfgH9rekepap3PfiP+GZp8wHcR48PAwv4SikgBMBV43edwgohswRrz8W+q+swA194K3AqQl5dHWVmZH9LOprW1dcTXOkk46erptJ76Hnt1M6eL4lxQZeHWPSurtRagjGmooqys5qzz4fRdhgL96ZJ2q/X6yMvlXD4l1gVV7t6vF2usOqYn9lFWVnHWece1qeqgG/CfwMtYq+zdArwI/Lsf110P3O+z/xngngHS3gn8vz7H8u3XIuAAUDxUmaWlpTpSVq9ePeJrnSTcdH3gV2X62Qc2BldMH9y6Z195dKsu+Pkr2tvb2+/5cPsu3aY/Xb29vbr4F6/q7X/eGnxBNm7er1se3KiX/dfA5Y9EG7BFh/hv9W5DthRU9TvAH4E59navqt7phy06Akz22Z9kH+uPG+jjjlLVI/ZrNVAGzPOjTIPLWPNKjb04hqpSXt3I4iCuTTAWGcvrY3T39LKppsnVFRz9CXp/E9ioqt+0t6f9zHszUCIiU0UkDssonNXbSURmAhnABp9jGSISb7/PBi4CdvtZrsFFFhVl0d7VwztjLI7hZt/4scaioiwa27qoGGNxjLcPn6atq8fVOuZPLCIV+KeIrLXXw8jzJ2O1RoffgeXO2gM8oaq7RORuEfHt9XQDsErf/7hwDrBFRHYAq7FiGMZghAELpo7N9THWVzYAZv3uYDBW18cIhTnKhgx6q+pPgJ+IyBzgk8AaETmsqlf4ce0LwAt9jt3VZ//H/Vy3HmvMhyHMyE6JZ3peCuXVTdy+zG01wWN9VaNrfePHGpMzE8lPT6S8upHPLi50W07QWF/VwDkTxpGZ7F6HkuFM+lMHHMfqJZXrjBxDJLB4jI3HsPrGN7rWN36sISIsHGPrY3R097DlwEnX65g/MYzbRaQMeA3IAv5FVec4LcwQvoy1OMaeY800d3hM/CKILCrKomkMxTG2HTpFp6fX9Sln/GlhTAa+rqqzVfXHJpZgGApvHMM7502ks77KxC+CzWKfucvGAhuqG4kSWFCU6aoOf7rVfl9VtwdDjCEyyEqJZ0Ze6pgJSq6vaqQ4J5m8cQluSxkzTMp4L44xFthQ1cB5k9IZl+DOYEUvY3vhAoNjLCrKZMuBkxEfxwiFvvFjEW8cY2NNE729kR3HaO/ysO3QKdfjF2AMhsEhFhdncaa7hx21p4ZOHMbsqD1Fu8t948cqi+04xr4TLW5LcZRNNU14etX1+AUYg2FwiMVF2UQJrK1ocFuKo6ytaEDErH/hBheXWEZ6XYTXsXUVDcTFRHFhobvxCzAGw+AQaUmxzJmUztqKerelOMrainrmTEonPcm9vvFjlQlpiUzLTeGNiK9jDSwozCQxLtptKcZgGJzjkpJsttee4vSZbrelOMLpM91srz3FJSXGHeUWS0uy2VTTREd3j9tSHOFEcwf7TrSwNETqmDEYBsdYOj2HXo3cro8bqhrpVbh4Wmj8mMcil5Tk0OnpZcuBk25LcQSvu+1iYzAMkc7cyemkxMdErFtqbUU9yXHRzJuS4baUMcvCokxioyWi61h2ShznjB/nthTAGAyDg8RGR7GoKCtiA99rKxpYXJxFXIz5GblFUlwMpQUZvBGBday3V1lX2cDF07JDZslfU9MNjnLJ9GwONbVzsLHNbSkB5WBjG4ea2llakuO2lDHP0pIc9hxrpr6l020pAWXv8RYaWrtCqo4Zg2FwFK9/P9JaGWtDzLc8lvEGhN+sjLQ6ZrnZQqmOGYNhcJSp2cnkpydGnI95bUU9+emJFGUnuy1lzDN7YhoZSbER1712bUUDM/JSQ2rKGUcNhoisFJF9IlIpIt/r5/wtIlIvItvt7Ys+524WkQp7u9lJnQbnEBEumZ7N+qpGPBEyTYinp5f1VY0sLck2y7GGANFRwkXTsllX0RAx0513dPew6UBTyHSn9eKYwRCRaOC3wFXALOBGEZnVT9K/qOpce7vfvjYT+BGwEFgA/EhETFeUMGVpSQ4tHR52HI6MaUJ2HD5FS4cnpFwFY51LSnKoa+mMmGlCNtY00eXpDbk65mQLYwFQqarVqtoFrAKu9fPaFcArqtqkqieBV4CVDuk0OMxF07KJjhJW740Ml8HqvfVERwlLp4VOMHKsc8l067uInDpWR0JslKvLsfbHkEu0joJ8oNZn/zBWi6EvHxORS4D9wDdUtXaAa/P7K0REbgVuBcjLy6OsrGxEYltbW0d8rZNEiq5pacKzW6qZH3/MOVE2Tt+zZ7ecoThN2LbpzWFdFynfZbAYrq4pqVE8vXE/57zvryPwOH2/VJUXtp9hRnoU5W+uHda1jn+XqurIBlwP3O+z/xngnj5psoB4+/2XgNft998G/rdPuh8C3x6qzNLSUh0pq1evHvG1ThIpun63ulIL7nxej50644wgH5y8Z8dOndGCO5/X366uGPa1kfJdBovh6vqPl/Zo0ff/oafaupwRZOP0/aqsa9GCO5/XR9bXDPvakWgDtqif/+tOuqSOYK3W52WSfexdVLVRVb2dp+8HSv291hBeXDbTWga+bF+dy0pGh1e/9/MYQofLZubS06th31tq9V6rji0PwTrmpMHYDJSIyFQRiQNuAJ71TSAiE3x2Pwzssd+/DFwpIhl2sPtK+5ghTJmel0J+eiKv7w1vg/H63jompiUwIy/VbSmGPsydnEFGUuy7f7jhyup9dUzPS2FSRpLbUs7CMYOhqh7gDqw/+j3AE6q6S0TuFpEP28m+KiK7RGQH8FXgFvvaJuCnWEZnM3C3fcwQpogIy2fmsK6ygU5PeM4s2unpYV1lA8tn5prutCFIdJRw6fQcyvbX0xOmq/C1dnrYVNMUkq0LcHgchqq+oKrTVbVYVX9uH7tLVZ+1339fVWer6vmqulxV9/pc+6CqTrO3h5zUaQgOy2fk0t7Vw6aa8LT9m2qaaO/qYfmM0PwxGyw3TlNbV9h24V5XUU93j4ZsHTMjvQ1BY0lxNvExUWHb9XH13nriYqJYMi20ujoa3uPS6TlECZSFqVtq9d56UhOsCRVDEWMwDEEjMS6axcVZrA7TwPfqfXUsLsoiKc7J3uiG0ZCeFMcFUzJ4PQzrmKqyel8dl0zPITY6NP+aQ1OVIWJZPiOXmoY2ahrCa/Zar+blM8xgvVBn+cxcdh5ppq65w20pw2LX0WbqWjpD1h0FxmAYgoy3O+qru0+4rGR4ePVefk6ey0oMQ/FuHdsTXq2MV3afQASWhfBDiTEYhqAyOTOJ2RPH8dKu425LGRYv7TrOrAnjmJwZel0dDe9n5vhUCrKSwq6OvbzrOBcWZpKdEu+2lAExBsMQdFbOHs/WgyfDxmVQ19zB1oMnWXnueLelGPxARFg5ezzrKxs4fabbbTl+UdPQxt7jLaycHdp1zBgMQ9Dx/vG+HCZuKa9OYzDChxXnjsfTq7y+N0zqmN0aWhHidcwYDEPQmZabQlFOMi/vDA+Xwcs7j1OUnUxJborbUgx+MndSOnnj4nkpTOrYSzuPM2dSGvnpiW5LGRRjMAxBx+sy2FDdyKn2LrflDMqp9i7KqxtZce54M7o7jIiKElbMHs+a/fWc6QrtmQWOnT7D9tpTrAhxdxQYg2FwiRWzx9PTqyHfk+W1PXV4ejUsfsyG97Ni9ng6untZsz+0B4r+c5flNguHOmYMhsEV5kxKY0JaQsi7DF7adZwJaQnMyU9zW4phmCyYmkl6Uuy78YFQ5aWdx5mWm8K0MHB5GoNhcAURy2XwRkU9bZ0et+X0S1unhzf217Ni9niioow7KtyIjY7iinPyeHXPCbo8obmefFNbFxtrGkO+d5QXYzAMrrHy3PF0eXpDdsrzsn31dHp6uXK2GawXrqycPZ6WDg9vVjW4LaVfXtl9nF4ND3cUGINhcJELCzPJTY3n79uPui2lX57ZfoTc1HgWTjWTDYYrS6dnMy4hhmdDtY5tO0phVhLn5o9zW4pfGINhcI3oKOHauRMp21dHU1to9ZY62dZF2b46rp07kWjjjgpb4mOiuXrORF7aeTzkXJ9HT52hvKaR6+blh00PPGMwDK7ykXmT8PQq/3jnmNtS3sc/3jlGd49y3bx8t6UYRslH5uVzpruHV0JsoOizO46iaukLFxw1GCKyUkT2iUiliHyvn/PfFJHdIvK2iLwmIgU+53pEZLu9Pdv3WkNkcM6EVGbkpfLMttBasv3pbUeYnpfCrAnh4SowDMz8ggzy0xN5KsTq2DPbjnDBlHQKspLdluI3jhkMEYkGfgtcBcwCbhSRWX2SbQPmq+oc4EngP3zOnVHVufb2YQwRiYhw3bx8th48yaHGdrflAHCosZ2tB0+GlavAMDBRUcJ18yayrqKeupbQmL9sz7Fm9h5vCavWBTjbwlgAVKpqtap2AauAa30TqOpqVfX+S5QDkxzUYwhRrp07EbCCzKGAV8d1c8Prx2wYmI/My6dX4bkdoeH6fGbbEWKihKvnTHRbyrAQVWcWSxeR64GVqvpFe/8zwEJVvWOA9PcAx1X1Z/a+B9gOeIB/U9VnBrjuVuBWgLy8vNJVq1aNSG9rayspKaE3cGas6Pq3TWc41aH8cmniqJ/qR6NNVfn+2jOkJwjfWxDYeX3GyncZKAKt68frz1ivS0b3vY5WV68q3yo7Q8G4KL5emjAqLX0Zibbly5dvVdX5fiVWVUc24Hrgfp/9zwD3DJD201gtjHifY/n2axFwACgeqszS0lIdKatXrx7xtU4yVnSt2nRQC+58XrcdOjnqvEajbfuhk1pw5/O6atPBUevoy1j5LgNFoHXdv7ZaC+58XitONI8qn9HqerOiXgvufF6f23FkVPn0x0i0AVvUz/91J11SR4DJPvuT7GPvQ0SuAH4AfFhVO73HVfWI/VoNlAHzHNRqcJmrzptAfEwUT2ypdVXHX7bUEh8TxcpzJ7iqwxB4Pnz+RGKihCe2HHZVx1+21JKaEMMVYbh6o5MGYzNQIiJTRSQOuAF4X28nEZkH/BHLWNT5HM8QkXj7fTZwEbDbQa0GlxmXEMs1cyby921HXOsv39bp4e/bjnDNnImkJca6osHgHDmp8VxxTh5Pbj1Mp8edGWyb2rp48Z3jfHRePgmx0a5oGA2OGQxV9QB3AC8De4AnVHWXiNwtIt5eT/8JpAB/7dN99hxgi4jsAFZjxTCMwYhwPrVwCm1dPTy7w51Ruc/uOEpbVw+fWjjFlfINzvOphVNoauvi5V3ujMn429bDdPX08qmFBUMnDkFinMxcVV8AXuhz7C6f91cMcN164DwntRlCjwumpDNzfCqPbjzIDRdODmqXVlXlsY2HmDk+lQumpAetXENwuXhaNpMzE3m0/CAfPj+4PZR6e5XHNx2itCCDGeNTg1p2oDAjvQ0hg4hw06ICdh5p5q1DJ4Na9luHTvLOkdPctHCKGXsRwURFCZ9aUMDGmib2HGsOatlrKxuobmjjpjBuwRqDYQgpPnZBPuMSYnhw3YGglvvgugOMS4jhoxeYoUCRzo0LJpMYG81Db9YEtdwH19WQkxrPNWE29sIXYzAMIUVSXAw3LpzCizuPcfhkcEZ+Hz7Zzos7j3HjwikkxzvqpTWEAOlJcXysNJ9nth+lobVz6AsCQGVdC2v21/PZRQXExYTv3274KjdELDcvLkREgtbKeOjNA4gIn11cGJTyDO5zy5KpdHl6eWT9gaCUd//aGuJjosK+Q4UxGIaQY2J6ItfNzeexTQdpdPgJsLG1k0c3HuTauRPJTw/syG5D6DItN4UVs/N4eP0Bmju6HS3ryKkz/O2tw9xw4WSyUuIdLctpjMEwhCS3Ly+m09PLA+uc9TM/sK6GTk8vty+b5mg5htDjjuUlNHd4+NOGg46Wc++aKlTh1kuLHS0nGBiDYQhJinNS+OB5E3hkw0HHFldqauvikQ0H+eC5E5iWG3pzKRmc5bxJaVw6PYcH1tXQ4lAr4/jpDlZtruVjF0yKiBasMRiGkOXrl5fQ3uXhntcrHcn/ntcrae/y8LUrShzJ3xD6fPMD02lq6+K+N6odyf/Xr+xHFe64LDJasMZgGEKWkrxUPl46mT+VH6C2KbA9pmqb2vlT+QGuL53E9LzwHERlGD3nT07n6vMmcN/amoCvlVFxooW/bq3l04sKmJyZFNC83cIYDENI840PTCc6Svj5P/YENN9fvLCHKBG+8YHpAc3XEH58Z8UMunt6+Y+X9gUsT1Xl7ud3kxwXEzGtCzAGwxDijE9L4H9dVsJLu47z+t7AzP/z+t4TvLjzOF+9vIQJaeHvVzaMjsLsZL64tIgntx5mY3VjQPJ87u1jrK1o4FtXTiczOS4geYYCxmAYQp5/WVpESW4KP3xmF62jnMm2tddnBfYAAAxISURBVNPDXX/fRUluCv+ytChACg3hztcuL2FSRiL/+vQ7dHSPbibbU+1d/PT53cyZlMZnImxsjzEYhpAnLiaKf/vYeRw7fYa7ntk5qrzu+vtOjp46wy8/el5Yj7g1BJbEuGh+8ZHzqKpv4xcvjNz9qap898m3OdXexS8+ch7RUZE1L5n5xRjCgtKCTL56eQlPbTvCX0e4yNKTWw/z1FtH+OrlJcwvzAywQkO4c8n0HL548VQe2XCQF98Z2drfj2w4yD93n+DOlTM5Nz8twArdxxgMQ9jwvy4rYUlxFv/69Dusr2oY1rXrqxr4/lNvs7goizuWR04Q0hBYvrtyJnMnp/ONJ7azbZgzJr+25wQ/eW4Xl8/M5fMXTXVIobsYg2EIG6KjhN9/upSp2cl86ZGtbKpp8uu6zQea+NKftlKYlcwfPl1KTLSp9ob+iYuJ4v6b55ObmsDnH97M24dP+XXd2op67nhsG7MnpvGbG+cRFWGuKC+O/nJEZKWI7BORShH5Xj/n40XkL/b5jSJS6HPu+/bxfSKywkmdhvAhLTGWhz+3gJxx8Xz6gY38bethrHXsz0ZVeeqtw9x0/0ZyUuN5+PMLSEsyS68aBic7JZ5HPr+A5PgYbri3nBcGcU+pKo9uPMjnHtpMQVYSD95yYUTPeOyYwRCRaOC3wFXALOBGEZnVJ9kXgJOqOg34NfDv9rWzsNYAnw2sBH5n52cwMDE9kb/dtoS5k9P51l93cPNDm1lX0UBvr2U4elV5s7KBmx/azDef2MHcSen87bYlETE1gyE4FGYn89TtSyjJTeH2R9/ii/+zhfLqxnfrWE+vUravjhvvK+cHT+9kcXEWT9y2mJzU8J5ccCicNIULgEpVrQYQkVXAtYDv2tzXAj+23z8J3CPWcmfXAqtUtROoEZFKO78NDuo1hBEZyXE8/i+L+NOGA/z61Qo+/cBG4mOiyE6Jp675DN29G0lLjOVHH5rFZxcXRlxvFYPz5KYm8OSXl/DAuhp++3olr+45QUJsFMnRSssrL9HV00tmchy//Oh5fHL+5Ih1Q/kiAzXnR52xyPXASlX9or3/GWChqt7hk2anneawvV8FLMQyIuWq+mf7+APAi6r6ZD/l3ArcCpCXl1e6atWqEeltbW0lJSX0JqAzuoamq0fZXtdD9eleTnf2khTlYXp2AvNyo4mLDp0fcSjdM1+MrqHp7FG2nujhYHMPTW3dZKfEUZwWxdzcaGJCyFCM5J4tX758q6rO9ydt2DvbVPVe4F6A+fPn67Jly0aUT1lZGSO91kmMLv+40ud9qGnzYnQNj1DT5Q2khpouX5zW5mTQ+wgw2Wd/kn2s3zQiEgOkAY1+XmswGAyGIOKkwdgMlIjIVBGJwwpiP9snzbPAzfb764HX1fKRPQvcYPeimgqUAJsc1GowGAyGIXDMJaWqHhG5A3gZiAYeVNVdInI3sEVVnwUeAP5kB7WbsIwKdronsALkHuArqjq6CV4MBoPBMCocjWGo6gvAC32O3eXzvgP4+ADX/hz4uZP6DAaDweA/ZsirwWAwGPzCGAyDwWAw+IUxGAaDwWDwC2MwDAaDweAXjo30dgMRqQcOjvDybGB4c2YHB6Nr+ISqNqNreBhdw2ck2gpUNcefhBFlMEaDiGzxd3h8MDG6hk+oajO6hofRNXyc1mZcUgaDwWDwC2MwDAaDweAXxmC8x71uCxgAo2v4hKo2o2t4GF3Dx1FtJoZhMBgMBr8wLQyDwWAw+IUxGAaDwWDwi//f3rnHWFVdcfj71VoIahQkTfGJUA0RFQGflFZtTUAaxUdMMDZKpWmp1bQxNaEhIcbE1oQ/tI0aY0xjTQw+0JriK4VKq2EcDFpgfIEwGFtiiqWKEJtR6/KPva5uTu+dOc7cc+5ksr7kZPbZj7N/d51977777DtrjfgJQ9JcSVskbZO0pEn5KEkPefl6SROzsl95/hZJc4pta9B2g6TXJG2W9BdJx2Zl/5O00Y+i2/iqdS2U9G7W/4+ysqslvenH1cW2Feu6LdO0VdL7WVmV9vq9pF0eQbJZuST9znVvljQjK6vSXgPputL19EjqkjQtK3vL8zdK2lCzrnMl7cnu17KsrN8xULGuGzNNr/iYGudlVdrraElr/bPgVUk/b1KnnjFmZiP2ILlV3w5MAr4GbAJOLNS5Frjb0wuAhzx9otcfBRzn1zmgZm3nAWM8/dOGNj/f10GbLQTuaNJ2HNDrf8d6emxdugr1rye51K/UXn7t7wAzgFdalM8DngYEnAWsr9peJXXNavQHXNDQ5edvAeM7ZK9zgSeGOgbaratQ90JS/J467DUBmOHpQ4CtTd6TtYyxkb7COAPYZma9ZvYR8CAwv1BnPvAHT68EvidJnv+gmfWZ2Q5gm1+vNm1mttbMPvTTblLkwaopY7NWzAFWm9l/zOw9YDUwt0O6rgBWtKnvfjGz50jxXFoxH7jfEt3AYZImUK29BtRlZl3eL9Q3vsrYqxVDGZvt1lXn+HrHzF729F7gdeDIQrVaxthInzCOBP6Rnf+T/zf053XM7BNgD3B4ybZVa8tZRPoG0WC0pA2SuiVd3AFdl/nSd6WkRjjdKm1W+tr+6O444Nksuyp7laGV9qrH2JehOL4M+LOklyT9uAN6zpa0SdLTkqZ63rCwl6QxpA/dR7PsWuyl9Mh8OrC+UFTLGKs0gFLQHiT9ADgNOCfLPtbMdkqaBDwrqcfMttckaRWwwsz6JP2EtEL7bk19l2EBsNL2j9LYSXsNaySdR5owZmfZs91eXwdWS3rDv4HXwcuk+7VP0jzgcVKY5uHChcA6M8tXI5XbS9LBpEnqF2b2QTuvXZaRvsLYCRydnR/leU3rSPoqcCiwu2TbqrUh6XxgKXCRmfU18s1sp//tBf5K+tZRiy4z251puReYWbZtlboyFlB4XFChvcrQSnvVY2xAJJ1CuofzzWx3Iz+z1y7gj7T3cWy/mNkHZrbP008BB0oazzCwl9Pf+KrEXpIOJE0WD5jZY02q1DPGqtikGS4HaQXVS3o80dgkm1qo8zP23/R+2NNT2X/Tu5f2bnqX0TadtMl3fCF/LDDK0+OBN2nT5l9JXROy9CVAt32xwbbD9Y319Li6dHm9KaQNSNVhr6yPibTexP0++29Ivli1vUrqOoa0NzerkH8QcEiW7gLm1qjrG437R/rgfdttV2oMVKXLyw8l7XMcVJe9/LXfD9zeT51axljbDD1cD9KvB7aSPniXet7NpG/sAKOBR/yN8yIwKWu71NttAS7ogLY1wL+AjX78yfNnAT3+hukBFtWs6zfAq97/WmBK1vYat+U24Id16vLzm4BbC+2qttcK4B3gY9Iz4kXAYmCxlwu403X3AKfVZK+BdN0LvJeNrw2eP8lttcnv89KadV2Xja9usgmt2RioS5fXWUj6MUzermp7zSbtkWzO7tW8ToyxcA0SBEEQlGKk72EEQRAEbSImjCAIgqAUMWEEQRAEpYgJIwiCIChFTBhBEARBKWLCCIIWSDpM0rXZ+RGSVlbU18W5V9Ym5SdLuq+KvoOgLPGz2iBogfvtecLMTqqhry7S/5P8u586a4BrzOztqvUEQTNihREErbkVmOwxDpZLmtiIlaAUE+RxSas9FsJ1SvFL/u4ODhtxEiZLesad0j0vaUqxE0knAH2NyULS5R5vYZOk3B/RKpI3giDoCDFhBEFrlgDbzexUM7uxSflJwKXA6cAtwIdmNh14AbjK69wDXG9mM4FfAnc1uc63SA73GiwD5pjZNOCiLH8D8O0hvJ4gGBLhrTYIBs9aS/EJ9kraQ1oBQHLNcIp7F50FPJJCrADJN1mRCcC72fk64D5JDwO5o7ldwBFt1B8EX4qYMIJg8PRl6U+z809J762vAO+b2akDXOe/JKd2AJjZYklnkhzKvSRppiVPsqO9bhB0hHgkFQSt2UsKiTkoLMUs2CHpcvg87vK0JlVfB77ZOJE02czWm9ky0sqj4Z76BKBpvOkgqIOYMIKgBf6tfp1vQC8f5GWuBBZJangybRZS9Dlgur54brVcUo9vsHeRvKBCivH+5CB1BMGQiZ/VBsEwQNJvgVVmtqZF+Sjgb6TIbp/UKi4InFhhBMHw4NfAmH7KjwGWxGQRdJJYYQRBEASliBVGEARBUIqYMIIgCIJSxIQRBEEQlCImjCAIgqAUMWEEQRAEpfgMzNZk44fhkJwAAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x11024d1d0>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -519,29 +513,18 @@
    "metadata": {},
    "outputs": [
     {
-     "ename": "SyntaxError",
-     "evalue": "bracket or operator expected. (<string>, line 8)",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;36m  File \u001b[0;32m\"<string>\"\u001b[0;36m, line \u001b[0;32m8\u001b[0m\n\u001b[0;31m    Plt = bqplot.pyplot,\n    Np = numpy,\n := Plt.figure(1, title=`Lin\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m bracket or operator expected.\n"
-     ]
-    },
-    {
-     "ename": "SyntaxError",
-     "evalue": "bracket or operator expected. (<string>, line 8)",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;36m  File \u001b[0;32m\"<string>\"\u001b[0;36m, line \u001b[0;32m8\u001b[0m\n\u001b[0;31m    lt = bqplot.pyplot,\n    Np = numpy,\n := Plt.figure(1, title=`Line\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m bracket or operator expected.\n"
-     ]
-    },
-    {
-     "name": "stdout",
+     "name": "stderr",
      "output_type": "stream",
      "text": [
       " % reconsulting jupyter cell...\n",
-      ":- user:python_import(numoy) failed.\n",
-      " % reconsulted ??? in module user, 262 msec 0 bytes\n",
-      "No (more) answers\n"
+      ":- user:python:python_import(numoy) failed.\n",
+      "none:6:0  warning: syntax error bracket or operator expected.\n",
+      "- Plt = bqplot.pyplot,\n",
+      "    Np = numpy,\n",
+      " := Plt.figure(1, title= <<<< at line 6 \n",
+      "\n",
+      "\n",
+      " % reconsulted memStream in module user, 145 msec 0 bytes\n"
      ]
     }
    ],
diff --git a/library/lammpi/CMakeLists.txt b/library/lammpi/CMakeLists.txt
index 88b59f7a5..1348e1ea3 100644
--- a/library/lammpi/CMakeLists.txt
+++ b/library/lammpi/CMakeLists.txt
@@ -68,8 +68,7 @@ set (MPI_YAP_SOURCES
   # pass to the MPI program.
   #
 
-  add_executable (yap_mpi ${MPI_YAP_SOURCES} Yaplib ../../console/yap.c)
-
+  add_executable (yap_mpi ${MPI_YAP_SOURCES}  ../../console/yap.c)
   target_link_libraries(yap_mpi libYap ${MPI_C_LIBRARIES})
 
   set_target_properties (yap_mpi PROPERTIES PREFIX "")
@@ -77,10 +76,11 @@ set (MPI_YAP_SOURCES
   include_directories (${MPI_C_INCLUDE_PATH})
 
   add_definitions (-DHAVE_MPI_H=1)
-    target_compile_definitions(yap_mpi  ${MPI_C_COMPILE_FLAGS})
+    target_compile_definitions(yap_mpi
+    PRIVATE ${MPI_C_COMPILE_FLAGS})
 
   install(TARGETS  yap_mpi
-    RUNTIME DESTINATION ${YAP_INSTALL_BDIR}
+    RUNTIME DESTINATION ${bindir}
     )
 
   endif (MPI_C_FOUND)
diff --git a/os/readterm.c b/os/readterm.c
index 476ae73b5..f7f8212a8 100644
--- a/os/readterm.c
+++ b/os/readterm.c
@@ -466,7 +466,7 @@ static xarg *setReadEnv(Term opts, FEnv *fe, struct renv *re, int inp_stream) {
     return NULL;
   }
 
-  re->bq = getBackQuotesFlag();
+  re->bq = getReadTermBackQuotesFlag();
   if (args[READ_OUTPUT].used) {
     fe->t0 = args[READ_OUTPUT].tvalue;
   } else {
@@ -480,7 +480,7 @@ static xarg *setReadEnv(Term opts, FEnv *fe, struct renv *re, int inp_stream) {
       fe->cmod = PROLOG_MODULE;
   }
   if (args[READ_BACKQUOTED_STRING].used) {
-    if (!setBackQuotesFlag(args[READ_BACKQUOTED_STRING].tvalue)) {
+    if (!setReadTermBackQuotesFlag(args[READ_BACKQUOTED_STRING].tvalue)) {
       return false;
     }
   }
@@ -1109,7 +1109,7 @@ static xarg *setClauseReadEnv(Term opts, FEnv *fe, struct renv *re, int sno) {
     if (fe->cmod == TermProlog)
       fe->cmod = PROLOG_MODULE;
   }
-  re->bq = getBackQuotesFlag();
+  re->bq = getReadTermBackQuotesFlag();
   fe->enc = GLOBAL_Stream[sno].encoding;
   fe->sp = 0;
   fe->qq = 0;
diff --git a/pl/boot.yap b/pl/boot.yap
index d386872e3..5f65dce47 100644
--- a/pl/boot.yap
+++ b/pl/boot.yap
@@ -251,12 +251,8 @@ initialize_prolog :-
 :- c_compile( 'modules.yap' ).
 :- c_compile( 'grammar.yap' ).
 
-:- start_low_level_trace.
-
 :- ['absf.yap'].
 
-:- stop_low_level_trace.
-
 :- use_module('error.yap').
 
 :- [